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 */
usbip_status_show(struct device * dev,struct device_attribute * attr,char * buf)32 static 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 }
49 static 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 */
store_sockfd(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)56 static 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 sdev->ud.sockfd = sockfd;
91
92 spin_unlock_irq(&sdev->ud.lock);
93
94 sdev->ud.tcp_rx = kthread_get_run(stub_rx_loop, &sdev->ud,
95 "stub_rx");
96 sdev->ud.tcp_tx = kthread_get_run(stub_tx_loop, &sdev->ud,
97 "stub_tx");
98
99 spin_lock_irq(&sdev->ud.lock);
100 sdev->ud.status = SDEV_ST_USED;
101 spin_unlock_irq(&sdev->ud.lock);
102
103 } else {
104 dev_info(dev, "stub down\n");
105
106 spin_lock_irq(&sdev->ud.lock);
107 if (sdev->ud.status != SDEV_ST_USED)
108 goto err;
109
110 spin_unlock_irq(&sdev->ud.lock);
111
112 usbip_event_add(&sdev->ud, SDEV_EVENT_DOWN);
113 }
114
115 return count;
116
117 err:
118 spin_unlock_irq(&sdev->ud.lock);
119 return -EINVAL;
120 }
121 static DEVICE_ATTR(usbip_sockfd, S_IWUSR, NULL, store_sockfd);
122
stub_add_files(struct device * dev)123 static int stub_add_files(struct device *dev)
124 {
125 int err = 0;
126
127 err = device_create_file(dev, &dev_attr_usbip_status);
128 if (err)
129 goto err_status;
130
131 err = device_create_file(dev, &dev_attr_usbip_sockfd);
132 if (err)
133 goto err_sockfd;
134
135 err = device_create_file(dev, &dev_attr_usbip_debug);
136 if (err)
137 goto err_debug;
138
139 return 0;
140
141 err_debug:
142 device_remove_file(dev, &dev_attr_usbip_sockfd);
143 err_sockfd:
144 device_remove_file(dev, &dev_attr_usbip_status);
145 err_status:
146 return err;
147 }
148
stub_remove_files(struct device * dev)149 static void stub_remove_files(struct device *dev)
150 {
151 device_remove_file(dev, &dev_attr_usbip_status);
152 device_remove_file(dev, &dev_attr_usbip_sockfd);
153 device_remove_file(dev, &dev_attr_usbip_debug);
154 }
155
stub_shutdown_connection(struct usbip_device * ud)156 static void stub_shutdown_connection(struct usbip_device *ud)
157 {
158 struct stub_device *sdev = container_of(ud, struct stub_device, ud);
159
160 /*
161 * When removing an exported device, kernel panic sometimes occurred
162 * and then EIP was sk_wait_data of stub_rx thread. Is this because
163 * sk_wait_data returned though stub_rx thread was already finished by
164 * step 1?
165 */
166 if (ud->tcp_socket) {
167 dev_dbg(&sdev->udev->dev, "shutdown sockfd %d\n", ud->sockfd);
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 ud->sockfd = -1;
191 }
192
193 /* 3. free used data */
194 stub_device_cleanup_urbs(sdev);
195
196 /* 4. free stub_unlink */
197 {
198 unsigned long flags;
199 struct stub_unlink *unlink, *tmp;
200
201 spin_lock_irqsave(&sdev->priv_lock, flags);
202 list_for_each_entry_safe(unlink, tmp, &sdev->unlink_tx, list) {
203 list_del(&unlink->list);
204 kfree(unlink);
205 }
206 list_for_each_entry_safe(unlink, tmp, &sdev->unlink_free,
207 list) {
208 list_del(&unlink->list);
209 kfree(unlink);
210 }
211 spin_unlock_irqrestore(&sdev->priv_lock, flags);
212 }
213 }
214
stub_device_reset(struct usbip_device * ud)215 static void stub_device_reset(struct usbip_device *ud)
216 {
217 struct stub_device *sdev = container_of(ud, struct stub_device, ud);
218 struct usb_device *udev = sdev->udev;
219 int ret;
220
221 dev_dbg(&udev->dev, "device reset");
222
223 ret = usb_lock_device_for_reset(udev, NULL);
224 if (ret < 0) {
225 dev_err(&udev->dev, "lock for reset\n");
226 spin_lock_irq(&ud->lock);
227 ud->status = SDEV_ST_ERROR;
228 spin_unlock_irq(&ud->lock);
229 return;
230 }
231
232 /* try to reset the device */
233 ret = usb_reset_device(udev);
234 usb_unlock_device(udev);
235
236 spin_lock_irq(&ud->lock);
237 if (ret) {
238 dev_err(&udev->dev, "device reset\n");
239 ud->status = SDEV_ST_ERROR;
240 } else {
241 dev_info(&udev->dev, "device reset\n");
242 ud->status = SDEV_ST_AVAILABLE;
243 }
244 spin_unlock_irq(&ud->lock);
245 }
246
stub_device_unusable(struct usbip_device * ud)247 static void stub_device_unusable(struct usbip_device *ud)
248 {
249 spin_lock_irq(&ud->lock);
250 ud->status = SDEV_ST_ERROR;
251 spin_unlock_irq(&ud->lock);
252 }
253
254 /**
255 * stub_device_alloc - allocate a new stub_device struct
256 * @udev: usb_device of a new device
257 *
258 * Allocates and initializes a new stub_device struct.
259 */
stub_device_alloc(struct usb_device * udev)260 static struct stub_device *stub_device_alloc(struct usb_device *udev)
261 {
262 struct stub_device *sdev;
263 int busnum = udev->bus->busnum;
264 int devnum = udev->devnum;
265
266 dev_dbg(&udev->dev, "allocating stub device");
267
268 /* yes, it's a new device */
269 sdev = kzalloc(sizeof(struct stub_device), GFP_KERNEL);
270 if (!sdev)
271 return NULL;
272
273 sdev->udev = usb_get_dev(udev);
274
275 /*
276 * devid is defined with devnum when this driver is first allocated.
277 * devnum may change later if a device is reset. However, devid never
278 * changes during a usbip connection.
279 */
280 sdev->devid = (busnum << 16) | devnum;
281 sdev->ud.side = USBIP_STUB;
282 sdev->ud.status = SDEV_ST_AVAILABLE;
283 spin_lock_init(&sdev->ud.lock);
284 sdev->ud.tcp_socket = NULL;
285 sdev->ud.sockfd = -1;
286
287 INIT_LIST_HEAD(&sdev->priv_init);
288 INIT_LIST_HEAD(&sdev->priv_tx);
289 INIT_LIST_HEAD(&sdev->priv_free);
290 INIT_LIST_HEAD(&sdev->unlink_free);
291 INIT_LIST_HEAD(&sdev->unlink_tx);
292 spin_lock_init(&sdev->priv_lock);
293
294 init_waitqueue_head(&sdev->tx_waitq);
295
296 sdev->ud.eh_ops.shutdown = stub_shutdown_connection;
297 sdev->ud.eh_ops.reset = stub_device_reset;
298 sdev->ud.eh_ops.unusable = stub_device_unusable;
299
300 usbip_start_eh(&sdev->ud);
301
302 dev_dbg(&udev->dev, "register new device\n");
303
304 return sdev;
305 }
306
stub_device_free(struct stub_device * sdev)307 static void stub_device_free(struct stub_device *sdev)
308 {
309 kfree(sdev);
310 }
311
stub_probe(struct usb_device * udev)312 static int stub_probe(struct usb_device *udev)
313 {
314 struct stub_device *sdev = NULL;
315 const char *udev_busid = dev_name(&udev->dev);
316 struct bus_id_priv *busid_priv;
317 int rc = 0;
318 char save_status;
319
320 dev_dbg(&udev->dev, "Enter probe\n");
321
322 /* Not sure if this is our device. Allocate here to avoid
323 * calling alloc while holding busid_table lock.
324 */
325 sdev = stub_device_alloc(udev);
326 if (!sdev)
327 return -ENOMEM;
328
329 /* check we should claim or not by busid_table */
330 busid_priv = get_busid_priv(udev_busid);
331 if (!busid_priv || (busid_priv->status == STUB_BUSID_REMOV) ||
332 (busid_priv->status == STUB_BUSID_OTHER)) {
333 dev_info(&udev->dev,
334 "%s is not in match_busid table... skip!\n",
335 udev_busid);
336
337 /*
338 * Return value should be ENODEV or ENOXIO to continue trying
339 * other matched drivers by the driver core.
340 * See driver_probe_device() in driver/base/dd.c
341 */
342 rc = -ENODEV;
343 if (!busid_priv)
344 goto sdev_free;
345
346 goto call_put_busid_priv;
347 }
348
349 if (udev->descriptor.bDeviceClass == USB_CLASS_HUB) {
350 dev_dbg(&udev->dev, "%s is a usb hub device... skip!\n",
351 udev_busid);
352 rc = -ENODEV;
353 goto call_put_busid_priv;
354 }
355
356 if (!strcmp(udev->bus->bus_name, "vhci_hcd")) {
357 dev_dbg(&udev->dev,
358 "%s is attached on vhci_hcd... skip!\n",
359 udev_busid);
360
361 rc = -ENODEV;
362 goto call_put_busid_priv;
363 }
364
365
366 dev_info(&udev->dev,
367 "usbip-host: register new device (bus %u dev %u)\n",
368 udev->bus->busnum, udev->devnum);
369
370 busid_priv->shutdown_busid = 0;
371
372 /* set private data to usb_device */
373 dev_set_drvdata(&udev->dev, sdev);
374
375 busid_priv->sdev = sdev;
376 busid_priv->udev = udev;
377
378 save_status = busid_priv->status;
379 busid_priv->status = STUB_BUSID_ALLOC;
380
381 /* release the busid_lock */
382 put_busid_priv(busid_priv);
383
384 /*
385 * Claim this hub port.
386 * It doesn't matter what value we pass as owner
387 * (struct dev_state) as long as it is unique.
388 */
389 rc = usb_hub_claim_port(udev->parent, udev->portnum,
390 (struct usb_dev_state *) udev);
391 if (rc) {
392 dev_dbg(&udev->dev, "unable to claim port\n");
393 goto err_port;
394 }
395
396 rc = stub_add_files(&udev->dev);
397 if (rc) {
398 dev_err(&udev->dev, "stub_add_files for %s\n", udev_busid);
399 goto err_files;
400 }
401
402 return 0;
403
404 err_files:
405 usb_hub_release_port(udev->parent, udev->portnum,
406 (struct usb_dev_state *) udev);
407 err_port:
408 dev_set_drvdata(&udev->dev, NULL);
409 usb_put_dev(udev);
410
411 /* we already have busid_priv, just lock busid_lock */
412 spin_lock(&busid_priv->busid_lock);
413 busid_priv->sdev = NULL;
414 busid_priv->status = save_status;
415 spin_unlock(&busid_priv->busid_lock);
416 /* lock is released - go to free */
417 goto sdev_free;
418
419 call_put_busid_priv:
420 /* release the busid_lock */
421 put_busid_priv(busid_priv);
422
423 sdev_free:
424 stub_device_free(sdev);
425
426 return rc;
427 }
428
shutdown_busid(struct bus_id_priv * busid_priv)429 static void shutdown_busid(struct bus_id_priv *busid_priv)
430 {
431 usbip_event_add(&busid_priv->sdev->ud, SDEV_EVENT_REMOVED);
432
433 /* wait for the stop of the event handler */
434 usbip_stop_eh(&busid_priv->sdev->ud);
435 }
436
437 /*
438 * called in usb_disconnect() or usb_deregister()
439 * but only if actconfig(active configuration) exists
440 */
stub_disconnect(struct usb_device * udev)441 static void stub_disconnect(struct usb_device *udev)
442 {
443 struct stub_device *sdev;
444 const char *udev_busid = dev_name(&udev->dev);
445 struct bus_id_priv *busid_priv;
446 int rc;
447
448 dev_dbg(&udev->dev, "Enter disconnect\n");
449
450 busid_priv = get_busid_priv(udev_busid);
451 if (!busid_priv) {
452 BUG();
453 return;
454 }
455
456 sdev = dev_get_drvdata(&udev->dev);
457
458 /* get stub_device */
459 if (!sdev) {
460 dev_err(&udev->dev, "could not get device");
461 /* release busid_lock */
462 put_busid_priv(busid_priv);
463 return;
464 }
465
466 dev_set_drvdata(&udev->dev, NULL);
467
468 /* release busid_lock before call to remove device files */
469 put_busid_priv(busid_priv);
470
471 /*
472 * NOTE: rx/tx threads are invoked for each usb_device.
473 */
474 stub_remove_files(&udev->dev);
475
476 /* release port */
477 rc = usb_hub_release_port(udev->parent, udev->portnum,
478 (struct usb_dev_state *) udev);
479 if (rc) {
480 dev_dbg(&udev->dev, "unable to release port\n");
481 return;
482 }
483
484 /* If usb reset is called from event handler */
485 if (usbip_in_eh(current))
486 return;
487
488 /* we already have busid_priv, just lock busid_lock */
489 spin_lock(&busid_priv->busid_lock);
490 if (!busid_priv->shutdown_busid)
491 busid_priv->shutdown_busid = 1;
492 /* release busid_lock */
493 spin_unlock(&busid_priv->busid_lock);
494
495 /* shutdown the current connection */
496 shutdown_busid(busid_priv);
497
498 usb_put_dev(sdev->udev);
499
500 /* we already have busid_priv, just lock busid_lock */
501 spin_lock(&busid_priv->busid_lock);
502 /* free sdev */
503 busid_priv->sdev = NULL;
504 stub_device_free(sdev);
505
506 if (busid_priv->status == STUB_BUSID_ALLOC)
507 busid_priv->status = STUB_BUSID_ADDED;
508 /* release busid_lock */
509 spin_unlock(&busid_priv->busid_lock);
510 return;
511 }
512
513 #ifdef CONFIG_PM
514
515 /* These functions need usb_port_suspend and usb_port_resume,
516 * which reside in drivers/usb/core/usb.h. Skip for now. */
517
stub_suspend(struct usb_device * udev,pm_message_t message)518 static int stub_suspend(struct usb_device *udev, pm_message_t message)
519 {
520 dev_dbg(&udev->dev, "stub_suspend\n");
521
522 return 0;
523 }
524
stub_resume(struct usb_device * udev,pm_message_t message)525 static int stub_resume(struct usb_device *udev, pm_message_t message)
526 {
527 dev_dbg(&udev->dev, "stub_resume\n");
528
529 return 0;
530 }
531
532 #endif /* CONFIG_PM */
533
534 struct usb_device_driver stub_driver = {
535 .name = "usbip-host",
536 .probe = stub_probe,
537 .disconnect = stub_disconnect,
538 #ifdef CONFIG_PM
539 .suspend = stub_suspend,
540 .resume = stub_resume,
541 #endif
542 .supports_autosuspend = 0,
543 };
544