2008-07-09 14:56:51 -06:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2003-2008 Takahiro Hirofuchi
|
|
|
|
*
|
|
|
|
* This is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
|
|
|
* USA.
|
|
|
|
*/
|
|
|
|
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
|
|
|
|
2008-07-09 14:56:51 -06:00
|
|
|
#include "usbip_common.h"
|
|
|
|
#include "stub.h"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int stub_probe(struct usb_interface *interface,
|
|
|
|
const struct usb_device_id *id);
|
|
|
|
static void stub_disconnect(struct usb_interface *interface);
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Define device IDs here if you want to explicitly limit exportable devices.
|
|
|
|
* In the most cases, wild card matching will be ok because driver binding can
|
|
|
|
* be changed dynamically by a userland program.
|
|
|
|
*/
|
|
|
|
static struct usb_device_id stub_table[] = {
|
|
|
|
#if 0
|
|
|
|
/* just an example */
|
|
|
|
{ USB_DEVICE(0x05ac, 0x0301) }, /* Mac 1 button mouse */
|
|
|
|
{ USB_DEVICE(0x0430, 0x0009) }, /* Plat Home Keyboard */
|
|
|
|
{ USB_DEVICE(0x059b, 0x0001) }, /* Iomega USB Zip 100 */
|
|
|
|
{ USB_DEVICE(0x04b3, 0x4427) }, /* IBM USB CD-ROM */
|
|
|
|
{ USB_DEVICE(0x05a9, 0xa511) }, /* LifeView USB cam */
|
|
|
|
{ USB_DEVICE(0x55aa, 0x0201) }, /* Imation card reader */
|
|
|
|
{ USB_DEVICE(0x046d, 0x0870) }, /* Qcam Express(QV-30) */
|
|
|
|
{ USB_DEVICE(0x04bb, 0x0101) }, /* IO-DATA HD 120GB */
|
|
|
|
{ USB_DEVICE(0x04bb, 0x0904) }, /* IO-DATA USB-ET/TX */
|
|
|
|
{ USB_DEVICE(0x04bb, 0x0201) }, /* IO-DATA USB-ET/TX */
|
|
|
|
{ USB_DEVICE(0x08bb, 0x2702) }, /* ONKYO USB Speaker */
|
|
|
|
{ USB_DEVICE(0x046d, 0x08b2) }, /* Logicool Qcam 4000 Pro */
|
|
|
|
#endif
|
|
|
|
/* magic for wild card */
|
|
|
|
{ .driver_info = 1 },
|
|
|
|
{ 0, } /* Terminating entry */
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(usb, stub_table);
|
|
|
|
|
|
|
|
struct usb_driver stub_driver = {
|
|
|
|
.name = "usbip",
|
|
|
|
.probe = stub_probe,
|
|
|
|
.disconnect = stub_disconnect,
|
|
|
|
.id_table = stub_table,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/* Define sysfs entries for a usbip-bound device */
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* usbip_status shows status of usbip as long as this driver is bound to the
|
|
|
|
* target device.
|
|
|
|
*/
|
|
|
|
static ssize_t show_status(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct stub_device *sdev = dev_get_drvdata(dev);
|
|
|
|
int status;
|
|
|
|
|
|
|
|
if (!sdev) {
|
|
|
|
dev_err(dev, "sdev is null\n");
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock(&sdev->ud.lock);
|
|
|
|
status = sdev->ud.status;
|
|
|
|
spin_unlock(&sdev->ud.lock);
|
|
|
|
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", status);
|
|
|
|
}
|
|
|
|
static DEVICE_ATTR(usbip_status, S_IRUGO, show_status, NULL);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* usbip_sockfd gets a socket descriptor of an established TCP connection that
|
|
|
|
* is used to transfer usbip requests by kernel threads. -1 is a magic number
|
|
|
|
* by which usbip connection is finished.
|
|
|
|
*/
|
|
|
|
static ssize_t store_sockfd(struct device *dev, struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
|
|
|
struct stub_device *sdev = dev_get_drvdata(dev);
|
|
|
|
int sockfd = 0;
|
|
|
|
struct socket *socket;
|
|
|
|
|
|
|
|
if (!sdev) {
|
|
|
|
dev_err(dev, "sdev is null\n");
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
sscanf(buf, "%d", &sockfd);
|
|
|
|
|
|
|
|
if (sockfd != -1) {
|
|
|
|
dev_info(dev, "stub up\n");
|
|
|
|
|
|
|
|
spin_lock(&sdev->ud.lock);
|
|
|
|
|
|
|
|
if (sdev->ud.status != SDEV_ST_AVAILABLE) {
|
|
|
|
dev_err(dev, "not ready\n");
|
|
|
|
spin_unlock(&sdev->ud.lock);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
socket = sockfd_to_socket(sockfd);
|
|
|
|
if (!socket) {
|
|
|
|
spin_unlock(&sdev->ud.lock);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
setnodelay(socket);
|
|
|
|
setkeepalive(socket);
|
|
|
|
setreuse(socket);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
sdev->ud.tcp_socket = socket;
|
|
|
|
|
|
|
|
spin_unlock(&sdev->ud.lock);
|
|
|
|
|
|
|
|
usbip_start_threads(&sdev->ud);
|
|
|
|
|
|
|
|
spin_lock(&sdev->ud.lock);
|
|
|
|
sdev->ud.status = SDEV_ST_USED;
|
|
|
|
spin_unlock(&sdev->ud.lock);
|
|
|
|
|
|
|
|
} else {
|
|
|
|
dev_info(dev, "stub down\n");
|
|
|
|
|
|
|
|
spin_lock(&sdev->ud.lock);
|
|
|
|
if (sdev->ud.status != SDEV_ST_USED) {
|
|
|
|
spin_unlock(&sdev->ud.lock);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
spin_unlock(&sdev->ud.lock);
|
|
|
|
|
|
|
|
usbip_event_add(&sdev->ud, SDEV_EVENT_DOWN);
|
|
|
|
}
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
static DEVICE_ATTR(usbip_sockfd, S_IWUSR, NULL, store_sockfd);
|
|
|
|
|
|
|
|
static int stub_add_files(struct device *dev)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
err = device_create_file(dev, &dev_attr_usbip_status);
|
|
|
|
if (err)
|
|
|
|
goto err_status;
|
|
|
|
|
|
|
|
err = device_create_file(dev, &dev_attr_usbip_sockfd);
|
|
|
|
if (err)
|
|
|
|
goto err_sockfd;
|
|
|
|
|
|
|
|
err = device_create_file(dev, &dev_attr_usbip_debug);
|
|
|
|
if (err)
|
|
|
|
goto err_debug;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_debug:
|
|
|
|
device_remove_file(dev, &dev_attr_usbip_sockfd);
|
|
|
|
|
|
|
|
err_sockfd:
|
|
|
|
device_remove_file(dev, &dev_attr_usbip_status);
|
|
|
|
|
|
|
|
err_status:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void stub_remove_files(struct device *dev)
|
|
|
|
{
|
|
|
|
device_remove_file(dev, &dev_attr_usbip_status);
|
|
|
|
device_remove_file(dev, &dev_attr_usbip_sockfd);
|
|
|
|
device_remove_file(dev, &dev_attr_usbip_debug);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/* Event handler functions called by an event handler thread */
|
|
|
|
|
|
|
|
static void stub_shutdown_connection(struct usbip_device *ud)
|
|
|
|
{
|
|
|
|
struct stub_device *sdev = container_of(ud, struct stub_device, ud);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* When removing an exported device, kernel panic sometimes occurred
|
|
|
|
* and then EIP was sk_wait_data of stub_rx thread. Is this because
|
|
|
|
* sk_wait_data returned though stub_rx thread was already finished by
|
|
|
|
* step 1?
|
|
|
|
*/
|
|
|
|
if (ud->tcp_socket) {
|
2009-07-21 00:46:13 -06:00
|
|
|
usbip_udbg("shutdown tcp_socket %p\n", ud->tcp_socket);
|
2008-07-09 14:56:51 -06:00
|
|
|
kernel_sock_shutdown(ud->tcp_socket, SHUT_RDWR);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 1. stop threads */
|
|
|
|
usbip_stop_threads(ud);
|
|
|
|
|
|
|
|
/* 2. close the socket */
|
|
|
|
/*
|
|
|
|
* tcp_socket is freed after threads are killed.
|
|
|
|
* So usbip_xmit do not touch NULL socket.
|
|
|
|
*/
|
|
|
|
if (ud->tcp_socket) {
|
|
|
|
sock_release(ud->tcp_socket);
|
|
|
|
ud->tcp_socket = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 3. free used data */
|
|
|
|
stub_device_cleanup_urbs(sdev);
|
|
|
|
|
|
|
|
/* 4. free stub_unlink */
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
struct stub_unlink *unlink, *tmp;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&sdev->priv_lock, flags);
|
|
|
|
|
|
|
|
list_for_each_entry_safe(unlink, tmp, &sdev->unlink_tx, list) {
|
|
|
|
list_del(&unlink->list);
|
|
|
|
kfree(unlink);
|
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry_safe(unlink, tmp,
|
|
|
|
&sdev->unlink_free, list) {
|
|
|
|
list_del(&unlink->list);
|
|
|
|
kfree(unlink);
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&sdev->priv_lock, flags);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void stub_device_reset(struct usbip_device *ud)
|
|
|
|
{
|
|
|
|
struct stub_device *sdev = container_of(ud, struct stub_device, ud);
|
|
|
|
struct usb_device *udev = interface_to_usbdev(sdev->interface);
|
|
|
|
int ret;
|
|
|
|
|
2009-07-21 00:46:13 -06:00
|
|
|
usbip_udbg("device reset");
|
2008-07-09 14:56:51 -06:00
|
|
|
ret = usb_lock_device_for_reset(udev, sdev->interface);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(&udev->dev, "lock for reset\n");
|
|
|
|
|
|
|
|
spin_lock(&ud->lock);
|
|
|
|
ud->status = SDEV_ST_ERROR;
|
|
|
|
spin_unlock(&ud->lock);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* try to reset the device */
|
|
|
|
ret = usb_reset_device(udev);
|
|
|
|
|
|
|
|
usb_unlock_device(udev);
|
|
|
|
|
|
|
|
spin_lock(&ud->lock);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(&udev->dev, "device reset\n");
|
|
|
|
ud->status = SDEV_ST_ERROR;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
dev_info(&udev->dev, "device reset\n");
|
|
|
|
ud->status = SDEV_ST_AVAILABLE;
|
|
|
|
|
|
|
|
}
|
|
|
|
spin_unlock(&ud->lock);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void stub_device_unusable(struct usbip_device *ud)
|
|
|
|
{
|
|
|
|
spin_lock(&ud->lock);
|
|
|
|
ud->status = SDEV_ST_ERROR;
|
|
|
|
spin_unlock(&ud->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* stub_device_alloc - allocate a new stub_device struct
|
|
|
|
* @interface: usb_interface of a new device
|
|
|
|
*
|
|
|
|
* Allocates and initializes a new stub_device struct.
|
|
|
|
*/
|
|
|
|
static struct stub_device *stub_device_alloc(struct usb_interface *interface)
|
|
|
|
{
|
|
|
|
struct stub_device *sdev;
|
|
|
|
int busnum = interface_to_busnum(interface);
|
|
|
|
int devnum = interface_to_devnum(interface);
|
|
|
|
|
|
|
|
dev_dbg(&interface->dev, "allocating stub device");
|
|
|
|
|
|
|
|
/* yes, it's a new device */
|
|
|
|
sdev = kzalloc(sizeof(struct stub_device), GFP_KERNEL);
|
|
|
|
if (!sdev) {
|
|
|
|
dev_err(&interface->dev, "no memory for stub_device\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
sdev->interface = interface;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* devid is defined with devnum when this driver is first allocated.
|
|
|
|
* devnum may change later if a device is reset. However, devid never
|
|
|
|
* changes during a usbip connection.
|
|
|
|
*/
|
|
|
|
sdev->devid = (busnum << 16) | devnum;
|
|
|
|
|
|
|
|
usbip_task_init(&sdev->ud.tcp_rx, "stub_rx", stub_rx_loop);
|
|
|
|
usbip_task_init(&sdev->ud.tcp_tx, "stub_tx", stub_tx_loop);
|
|
|
|
|
|
|
|
sdev->ud.side = USBIP_STUB;
|
|
|
|
sdev->ud.status = SDEV_ST_AVAILABLE;
|
|
|
|
/* sdev->ud.lock = SPIN_LOCK_UNLOCKED; */
|
|
|
|
spin_lock_init(&sdev->ud.lock);
|
|
|
|
sdev->ud.tcp_socket = NULL;
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&sdev->priv_init);
|
|
|
|
INIT_LIST_HEAD(&sdev->priv_tx);
|
|
|
|
INIT_LIST_HEAD(&sdev->priv_free);
|
|
|
|
INIT_LIST_HEAD(&sdev->unlink_free);
|
|
|
|
INIT_LIST_HEAD(&sdev->unlink_tx);
|
|
|
|
/* sdev->priv_lock = SPIN_LOCK_UNLOCKED; */
|
|
|
|
spin_lock_init(&sdev->priv_lock);
|
|
|
|
|
|
|
|
init_waitqueue_head(&sdev->tx_waitq);
|
|
|
|
|
|
|
|
sdev->ud.eh_ops.shutdown = stub_shutdown_connection;
|
|
|
|
sdev->ud.eh_ops.reset = stub_device_reset;
|
|
|
|
sdev->ud.eh_ops.unusable = stub_device_unusable;
|
|
|
|
|
|
|
|
usbip_start_eh(&sdev->ud);
|
|
|
|
|
2009-07-21 00:46:13 -06:00
|
|
|
usbip_udbg("register new interface\n");
|
2008-07-09 14:56:51 -06:00
|
|
|
return sdev;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int stub_device_free(struct stub_device *sdev)
|
|
|
|
{
|
|
|
|
if (!sdev)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
kfree(sdev);
|
2009-07-21 00:46:13 -06:00
|
|
|
usbip_udbg("kfree udev ok\n");
|
2008-07-09 14:56:51 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If a usb device has multiple active interfaces, this driver is bound to all
|
|
|
|
* the active interfaces. However, usbip exports *a* usb device (i.e., not *an*
|
|
|
|
* active interface). Currently, a userland program must ensure that it
|
|
|
|
* looks at the usbip's sysfs entries of only the first active interface.
|
|
|
|
*
|
|
|
|
* TODO: use "struct usb_device_driver" to bind a usb device.
|
|
|
|
* However, it seems it is not fully supported in mainline kernel yet
|
|
|
|
* (2.6.19.2).
|
|
|
|
*/
|
|
|
|
static int stub_probe(struct usb_interface *interface,
|
|
|
|
const struct usb_device_id *id)
|
|
|
|
{
|
|
|
|
struct usb_device *udev = interface_to_usbdev(interface);
|
|
|
|
struct stub_device *sdev = NULL;
|
2008-10-29 18:59:32 -06:00
|
|
|
const char *udev_busid = dev_name(interface->dev.parent);
|
2008-07-09 14:56:51 -06:00
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
dev_dbg(&interface->dev, "Enter\n");
|
|
|
|
|
|
|
|
/* check we should claim or not by busid_table */
|
|
|
|
if (match_busid(udev_busid)) {
|
|
|
|
dev_info(&interface->dev,
|
|
|
|
"this device %s is not in match_busid table. skip!\n",
|
|
|
|
udev_busid);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return value should be ENODEV or ENOXIO to continue trying
|
|
|
|
* other matched drivers by the driver core.
|
|
|
|
* See driver_probe_device() in driver/base/dd.c
|
|
|
|
*/
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (udev->descriptor.bDeviceClass == USB_CLASS_HUB) {
|
2009-07-21 00:46:13 -06:00
|
|
|
usbip_udbg("this device %s is a usb hub device. skip!\n",
|
2008-07-09 14:56:51 -06:00
|
|
|
udev_busid);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp(udev->bus->bus_name, "vhci_hcd")) {
|
2009-07-21 00:46:13 -06:00
|
|
|
usbip_udbg("this device %s is attached on vhci_hcd. skip!\n",
|
2008-07-09 14:56:51 -06:00
|
|
|
udev_busid);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ok. this is my device. */
|
|
|
|
sdev = stub_device_alloc(interface);
|
|
|
|
if (!sdev)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
dev_info(&interface->dev, "USB/IP Stub: register a new interface "
|
|
|
|
"(bus %u dev %u ifn %u)\n", udev->bus->busnum, udev->devnum,
|
|
|
|
interface->cur_altsetting->desc.bInterfaceNumber);
|
|
|
|
|
|
|
|
/* set private data to usb_interface */
|
|
|
|
usb_set_intfdata(interface, sdev);
|
|
|
|
|
|
|
|
err = stub_add_files(&interface->dev);
|
|
|
|
if (err) {
|
|
|
|
dev_err(&interface->dev, "create sysfs files for %s\n",
|
|
|
|
udev_busid);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* called in usb_disconnect() or usb_deregister()
|
|
|
|
* but only if actconfig(active configuration) exists
|
|
|
|
*/
|
|
|
|
static void stub_disconnect(struct usb_interface *interface)
|
|
|
|
{
|
|
|
|
struct stub_device *sdev = usb_get_intfdata(interface);
|
|
|
|
|
2009-07-21 00:46:13 -06:00
|
|
|
usbip_udbg("Enter\n");
|
2008-07-09 14:56:51 -06:00
|
|
|
|
|
|
|
/* get stub_device */
|
|
|
|
if (!sdev) {
|
|
|
|
err(" could not get device from inteface data");
|
|
|
|
/* BUG(); */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
usb_set_intfdata(interface, NULL);
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* NOTE:
|
|
|
|
* rx/tx threads are invoked for each usb_device.
|
|
|
|
*/
|
|
|
|
stub_remove_files(&interface->dev);
|
|
|
|
|
|
|
|
/* 1. shutdown the current connection */
|
|
|
|
usbip_event_add(&sdev->ud, SDEV_EVENT_REMOVED);
|
|
|
|
|
|
|
|
/* 2. wait for the stop of the event handler */
|
|
|
|
usbip_stop_eh(&sdev->ud);
|
|
|
|
|
|
|
|
/* 3. free sdev */
|
|
|
|
stub_device_free(sdev);
|
|
|
|
|
|
|
|
|
2009-07-21 00:46:13 -06:00
|
|
|
usbip_udbg("bye\n");
|
2008-07-09 14:56:51 -06:00
|
|
|
}
|