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