xref: /openbmc/linux/drivers/usb/usbip/stub_dev.c (revision 6774def6)
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  */
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  */
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 
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 
116 err:
117 	spin_unlock_irq(&sdev->ud.lock);
118 	return -EINVAL;
119 }
120 static DEVICE_ATTR(usbip_sockfd, S_IWUSR, NULL, store_sockfd);
121 
122 static 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 
140 err_debug:
141 	device_remove_file(dev, &dev_attr_usbip_sockfd);
142 err_sockfd:
143 	device_remove_file(dev, &dev_attr_usbip_status);
144 err_status:
145 	return err;
146 }
147 
148 static 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 
155 static 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 
214 static 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 
246 static 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  */
259 static 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 
305 static void stub_device_free(struct stub_device *sdev)
306 {
307 	kfree(sdev);
308 }
309 
310 static 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 
394 static 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  */
409 static 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 
473 static 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 
480 static 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 
489 struct 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