1/* 2 * Copyright (C) 2003-2008 Takahiro Hirofuchi 3 * 4 * This is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License as published by 6 * the Free Software Foundation; either version 2 of the License, or 7 * (at your option) any later version. 8 * 9 * This is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write to the Free Software 16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 17 * USA. 18 */ 19 20#include <linux/device.h> 21#include <linux/file.h> 22#include <linux/kthread.h> 23#include <linux/module.h> 24 25#include "usbip_common.h" 26#include "stub.h" 27 28/* 29 * usbip_status shows the status of usbip-host as long as this driver is bound 30 * to the target device. 31 */ 32static ssize_t usbip_status_show(struct device *dev, 33 struct device_attribute *attr, char *buf) 34{ 35 struct stub_device *sdev = dev_get_drvdata(dev); 36 int status; 37 38 if (!sdev) { 39 dev_err(dev, "sdev is null\n"); 40 return -ENODEV; 41 } 42 43 spin_lock_irq(&sdev->ud.lock); 44 status = sdev->ud.status; 45 spin_unlock_irq(&sdev->ud.lock); 46 47 return snprintf(buf, PAGE_SIZE, "%d\n", status); 48} 49static DEVICE_ATTR_RO(usbip_status); 50 51/* 52 * usbip_sockfd gets a socket descriptor of an established TCP connection that 53 * is used to transfer usbip requests by kernel threads. -1 is a magic number 54 * by which usbip connection is finished. 55 */ 56static ssize_t store_sockfd(struct device *dev, struct device_attribute *attr, 57 const char *buf, size_t count) 58{ 59 struct stub_device *sdev = dev_get_drvdata(dev); 60 int sockfd = 0; 61 struct socket *socket; 62 int rv; 63 64 if (!sdev) { 65 dev_err(dev, "sdev is null\n"); 66 return -ENODEV; 67 } 68 69 rv = sscanf(buf, "%d", &sockfd); 70 if (rv != 1) 71 return -EINVAL; 72 73 if (sockfd != -1) { 74 int err; 75 76 dev_info(dev, "stub up\n"); 77 78 spin_lock_irq(&sdev->ud.lock); 79 80 if (sdev->ud.status != SDEV_ST_AVAILABLE) { 81 dev_err(dev, "not ready\n"); 82 goto err; 83 } 84 85 socket = sockfd_lookup(sockfd, &err); 86 if (!socket) 87 goto err; 88 89 sdev->ud.tcp_socket = socket; 90 91 spin_unlock_irq(&sdev->ud.lock); 92 93 sdev->ud.tcp_rx = kthread_get_run(stub_rx_loop, &sdev->ud, 94 "stub_rx"); 95 sdev->ud.tcp_tx = kthread_get_run(stub_tx_loop, &sdev->ud, 96 "stub_tx"); 97 98 spin_lock_irq(&sdev->ud.lock); 99 sdev->ud.status = SDEV_ST_USED; 100 spin_unlock_irq(&sdev->ud.lock); 101 102 } else { 103 dev_info(dev, "stub down\n"); 104 105 spin_lock_irq(&sdev->ud.lock); 106 if (sdev->ud.status != SDEV_ST_USED) 107 goto err; 108 109 spin_unlock_irq(&sdev->ud.lock); 110 111 usbip_event_add(&sdev->ud, SDEV_EVENT_DOWN); 112 } 113 114 return count; 115 116err: 117 spin_unlock_irq(&sdev->ud.lock); 118 return -EINVAL; 119} 120static DEVICE_ATTR(usbip_sockfd, S_IWUSR, NULL, store_sockfd); 121 122static int stub_add_files(struct device *dev) 123{ 124 int err = 0; 125 126 err = device_create_file(dev, &dev_attr_usbip_status); 127 if (err) 128 goto err_status; 129 130 err = device_create_file(dev, &dev_attr_usbip_sockfd); 131 if (err) 132 goto err_sockfd; 133 134 err = device_create_file(dev, &dev_attr_usbip_debug); 135 if (err) 136 goto err_debug; 137 138 return 0; 139 140err_debug: 141 device_remove_file(dev, &dev_attr_usbip_sockfd); 142err_sockfd: 143 device_remove_file(dev, &dev_attr_usbip_status); 144err_status: 145 return err; 146} 147 148static void stub_remove_files(struct device *dev) 149{ 150 device_remove_file(dev, &dev_attr_usbip_status); 151 device_remove_file(dev, &dev_attr_usbip_sockfd); 152 device_remove_file(dev, &dev_attr_usbip_debug); 153} 154 155static void stub_shutdown_connection(struct usbip_device *ud) 156{ 157 struct stub_device *sdev = container_of(ud, struct stub_device, ud); 158 159 /* 160 * When removing an exported device, kernel panic sometimes occurred 161 * and then EIP was sk_wait_data of stub_rx thread. Is this because 162 * sk_wait_data returned though stub_rx thread was already finished by 163 * step 1? 164 */ 165 if (ud->tcp_socket) { 166 dev_dbg(&sdev->udev->dev, "shutdown tcp_socket %p\n", 167 ud->tcp_socket); 168 kernel_sock_shutdown(ud->tcp_socket, SHUT_RDWR); 169 } 170 171 /* 1. stop threads */ 172 if (ud->tcp_rx) { 173 kthread_stop_put(ud->tcp_rx); 174 ud->tcp_rx = NULL; 175 } 176 if (ud->tcp_tx) { 177 kthread_stop_put(ud->tcp_tx); 178 ud->tcp_tx = NULL; 179 } 180 181 /* 182 * 2. close the socket 183 * 184 * tcp_socket is freed after threads are killed so that usbip_xmit does 185 * not touch NULL socket. 186 */ 187 if (ud->tcp_socket) { 188 sockfd_put(ud->tcp_socket); 189 ud->tcp_socket = NULL; 190 } 191 192 /* 3. free used data */ 193 stub_device_cleanup_urbs(sdev); 194 195 /* 4. free stub_unlink */ 196 { 197 unsigned long flags; 198 struct stub_unlink *unlink, *tmp; 199 200 spin_lock_irqsave(&sdev->priv_lock, flags); 201 list_for_each_entry_safe(unlink, tmp, &sdev->unlink_tx, list) { 202 list_del(&unlink->list); 203 kfree(unlink); 204 } 205 list_for_each_entry_safe(unlink, tmp, &sdev->unlink_free, 206 list) { 207 list_del(&unlink->list); 208 kfree(unlink); 209 } 210 spin_unlock_irqrestore(&sdev->priv_lock, flags); 211 } 212} 213 214static void stub_device_reset(struct usbip_device *ud) 215{ 216 struct stub_device *sdev = container_of(ud, struct stub_device, ud); 217 struct usb_device *udev = sdev->udev; 218 int ret; 219 220 dev_dbg(&udev->dev, "device reset"); 221 222 ret = usb_lock_device_for_reset(udev, sdev->interface); 223 if (ret < 0) { 224 dev_err(&udev->dev, "lock for reset\n"); 225 spin_lock_irq(&ud->lock); 226 ud->status = SDEV_ST_ERROR; 227 spin_unlock_irq(&ud->lock); 228 return; 229 } 230 231 /* try to reset the device */ 232 ret = usb_reset_device(udev); 233 usb_unlock_device(udev); 234 235 spin_lock_irq(&ud->lock); 236 if (ret) { 237 dev_err(&udev->dev, "device reset\n"); 238 ud->status = SDEV_ST_ERROR; 239 } else { 240 dev_info(&udev->dev, "device reset\n"); 241 ud->status = SDEV_ST_AVAILABLE; 242 } 243 spin_unlock_irq(&ud->lock); 244} 245 246static void stub_device_unusable(struct usbip_device *ud) 247{ 248 spin_lock_irq(&ud->lock); 249 ud->status = SDEV_ST_ERROR; 250 spin_unlock_irq(&ud->lock); 251} 252 253/** 254 * stub_device_alloc - allocate a new stub_device struct 255 * @interface: usb_interface of a new device 256 * 257 * Allocates and initializes a new stub_device struct. 258 */ 259static struct stub_device *stub_device_alloc(struct usb_device *udev) 260{ 261 struct stub_device *sdev; 262 int busnum = udev->bus->busnum; 263 int devnum = udev->devnum; 264 265 dev_dbg(&udev->dev, "allocating stub device"); 266 267 /* yes, it's a new device */ 268 sdev = kzalloc(sizeof(struct stub_device), GFP_KERNEL); 269 if (!sdev) 270 return NULL; 271 272 sdev->udev = usb_get_dev(udev); 273 274 /* 275 * devid is defined with devnum when this driver is first allocated. 276 * devnum may change later if a device is reset. However, devid never 277 * changes during a usbip connection. 278 */ 279 sdev->devid = (busnum << 16) | devnum; 280 sdev->ud.side = USBIP_STUB; 281 sdev->ud.status = SDEV_ST_AVAILABLE; 282 spin_lock_init(&sdev->ud.lock); 283 sdev->ud.tcp_socket = NULL; 284 285 INIT_LIST_HEAD(&sdev->priv_init); 286 INIT_LIST_HEAD(&sdev->priv_tx); 287 INIT_LIST_HEAD(&sdev->priv_free); 288 INIT_LIST_HEAD(&sdev->unlink_free); 289 INIT_LIST_HEAD(&sdev->unlink_tx); 290 spin_lock_init(&sdev->priv_lock); 291 292 init_waitqueue_head(&sdev->tx_waitq); 293 294 sdev->ud.eh_ops.shutdown = stub_shutdown_connection; 295 sdev->ud.eh_ops.reset = stub_device_reset; 296 sdev->ud.eh_ops.unusable = stub_device_unusable; 297 298 usbip_start_eh(&sdev->ud); 299 300 dev_dbg(&udev->dev, "register new device\n"); 301 302 return sdev; 303} 304 305static void stub_device_free(struct stub_device *sdev) 306{ 307 kfree(sdev); 308} 309 310static int stub_probe(struct usb_device *udev) 311{ 312 struct stub_device *sdev = NULL; 313 const char *udev_busid = dev_name(&udev->dev); 314 int err = 0; 315 struct bus_id_priv *busid_priv; 316 int rc; 317 318 dev_dbg(&udev->dev, "Enter\n"); 319 320 /* check we should claim or not by busid_table */ 321 busid_priv = get_busid_priv(udev_busid); 322 if (!busid_priv || (busid_priv->status == STUB_BUSID_REMOV) || 323 (busid_priv->status == STUB_BUSID_OTHER)) { 324 dev_info(&udev->dev, 325 "%s is not in match_busid table... skip!\n", 326 udev_busid); 327 328 /* 329 * Return value should be ENODEV or ENOXIO to continue trying 330 * other matched drivers by the driver core. 331 * See driver_probe_device() in driver/base/dd.c 332 */ 333 return -ENODEV; 334 } 335 336 if (udev->descriptor.bDeviceClass == USB_CLASS_HUB) { 337 dev_dbg(&udev->dev, "%s is a usb hub device... skip!\n", 338 udev_busid); 339 return -ENODEV; 340 } 341 342 if (!strcmp(udev->bus->bus_name, "vhci_hcd")) { 343 dev_dbg(&udev->dev, 344 "%s is attached on vhci_hcd... skip!\n", 345 udev_busid); 346 347 return -ENODEV; 348 } 349 350 /* ok, this is my device */ 351 sdev = stub_device_alloc(udev); 352 if (!sdev) 353 return -ENOMEM; 354 355 dev_info(&udev->dev, 356 "usbip-host: register new device (bus %u dev %u)\n", 357 udev->bus->busnum, udev->devnum); 358 359 busid_priv->shutdown_busid = 0; 360 361 /* set private data to usb_device */ 362 dev_set_drvdata(&udev->dev, sdev); 363 busid_priv->sdev = sdev; 364 busid_priv->udev = udev; 365 366 /* 367 * Claim this hub port. 368 * It doesn't matter what value we pass as owner 369 * (struct dev_state) as long as it is unique. 370 */ 371 rc = usb_hub_claim_port(udev->parent, udev->portnum, 372 (struct usb_dev_state *) udev); 373 if (rc) { 374 dev_dbg(&udev->dev, "unable to claim port\n"); 375 return rc; 376 } 377 378 err = stub_add_files(&udev->dev); 379 if (err) { 380 dev_err(&udev->dev, "stub_add_files for %s\n", udev_busid); 381 dev_set_drvdata(&udev->dev, NULL); 382 usb_put_dev(udev); 383 kthread_stop_put(sdev->ud.eh); 384 385 busid_priv->sdev = NULL; 386 stub_device_free(sdev); 387 return err; 388 } 389 busid_priv->status = STUB_BUSID_ALLOC; 390 391 return 0; 392} 393 394static void shutdown_busid(struct bus_id_priv *busid_priv) 395{ 396 if (busid_priv->sdev && !busid_priv->shutdown_busid) { 397 busid_priv->shutdown_busid = 1; 398 usbip_event_add(&busid_priv->sdev->ud, SDEV_EVENT_REMOVED); 399 400 /* wait for the stop of the event handler */ 401 usbip_stop_eh(&busid_priv->sdev->ud); 402 } 403} 404 405/* 406 * called in usb_disconnect() or usb_deregister() 407 * but only if actconfig(active configuration) exists 408 */ 409static void stub_disconnect(struct usb_device *udev) 410{ 411 struct stub_device *sdev; 412 const char *udev_busid = dev_name(&udev->dev); 413 struct bus_id_priv *busid_priv; 414 int rc; 415 416 dev_dbg(&udev->dev, "Enter\n"); 417 418 busid_priv = get_busid_priv(udev_busid); 419 if (!busid_priv) { 420 BUG(); 421 return; 422 } 423 424 sdev = dev_get_drvdata(&udev->dev); 425 426 /* get stub_device */ 427 if (!sdev) { 428 dev_err(&udev->dev, "could not get device"); 429 return; 430 } 431 432 dev_set_drvdata(&udev->dev, NULL); 433 434 /* 435 * NOTE: rx/tx threads are invoked for each usb_device. 436 */ 437 stub_remove_files(&udev->dev); 438 439 /* release port */ 440 rc = usb_hub_release_port(udev->parent, udev->portnum, 441 (struct usb_dev_state *) udev); 442 if (rc) { 443 dev_dbg(&udev->dev, "unable to release port\n"); 444 return; 445 } 446 447 /* If usb reset is called from event handler */ 448 if (busid_priv->sdev->ud.eh == current) 449 return; 450 451 /* shutdown the current connection */ 452 shutdown_busid(busid_priv); 453 454 usb_put_dev(sdev->udev); 455 456 /* free sdev */ 457 busid_priv->sdev = NULL; 458 stub_device_free(sdev); 459 460 if (busid_priv->status == STUB_BUSID_ALLOC) { 461 busid_priv->status = STUB_BUSID_ADDED; 462 } else { 463 busid_priv->status = STUB_BUSID_OTHER; 464 del_match_busid((char *)udev_busid); 465 } 466} 467 468#ifdef CONFIG_PM 469 470/* These functions need usb_port_suspend and usb_port_resume, 471 * which reside in drivers/usb/core/usb.h. Skip for now. */ 472 473static int stub_suspend(struct usb_device *udev, pm_message_t message) 474{ 475 dev_dbg(&udev->dev, "stub_suspend\n"); 476 477 return 0; 478} 479 480static int stub_resume(struct usb_device *udev, pm_message_t message) 481{ 482 dev_dbg(&udev->dev, "stub_resume\n"); 483 484 return 0; 485} 486 487#endif /* CONFIG_PM */ 488 489struct usb_device_driver stub_driver = { 490 .name = "usbip-host", 491 .probe = stub_probe, 492 .disconnect = stub_disconnect, 493#ifdef CONFIG_PM 494 .suspend = stub_suspend, 495 .resume = stub_resume, 496#endif 497 .supports_autosuspend = 0, 498}; 499