Greg Kroah-Hartman | 5fd54ac | 2017-11-03 11:28:30 +0100 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 2 | /* |
| 3 | * Copyright (C) 2003-2008 Takahiro Hirofuchi |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 4 | */ |
| 5 | |
matt mooney | 7aaacb4 | 2011-05-11 22:33:43 -0700 | [diff] [blame] | 6 | #include <linux/device.h> |
Bernard Blackham | 3d0a2a2 | 2012-10-22 06:45:00 +1100 | [diff] [blame] | 7 | #include <linux/file.h> |
Arnd Bergmann | 9720b4b | 2011-03-02 00:13:05 +0100 | [diff] [blame] | 8 | #include <linux/kthread.h> |
Paul Gortmaker | 99c9785 | 2011-07-03 15:49:50 -0400 | [diff] [blame] | 9 | #include <linux/module.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 10 | |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 11 | #include "usbip_common.h" |
| 12 | #include "stub.h" |
| 13 | |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 14 | /* |
matt mooney | d012c2a5 | 2011-05-19 21:37:03 -0700 | [diff] [blame] | 15 | * usbip_status shows the status of usbip-host as long as this driver is bound |
| 16 | * to the target device. |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 17 | */ |
Greg Kroah-Hartman | b1f56ac | 2013-08-26 12:02:54 -0700 | [diff] [blame] | 18 | static ssize_t usbip_status_show(struct device *dev, |
| 19 | struct device_attribute *attr, char *buf) |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 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 | |
Harvey Yang | dcf14779 | 2013-01-22 13:31:30 +0800 | [diff] [blame] | 29 | spin_lock_irq(&sdev->ud.lock); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 30 | status = sdev->ud.status; |
Harvey Yang | dcf14779 | 2013-01-22 13:31:30 +0800 | [diff] [blame] | 31 | spin_unlock_irq(&sdev->ud.lock); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 32 | |
| 33 | return snprintf(buf, PAGE_SIZE, "%d\n", status); |
| 34 | } |
Greg Kroah-Hartman | b1f56ac | 2013-08-26 12:02:54 -0700 | [diff] [blame] | 35 | static DEVICE_ATTR_RO(usbip_status); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 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 | */ |
Greg Kroah-Hartman | ca35910 | 2018-01-23 11:24:07 +0100 | [diff] [blame] | 42 | static ssize_t usbip_sockfd_store(struct device *dev, struct device_attribute *attr, |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 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; |
Elena Oat | f8cfc02 | 2014-02-27 12:26:52 +0200 | [diff] [blame] | 48 | int rv; |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 49 | |
| 50 | if (!sdev) { |
| 51 | dev_err(dev, "sdev is null\n"); |
| 52 | return -ENODEV; |
| 53 | } |
| 54 | |
Elena Oat | f8cfc02 | 2014-02-27 12:26:52 +0200 | [diff] [blame] | 55 | rv = sscanf(buf, "%d", &sockfd); |
| 56 | if (rv != 1) |
| 57 | return -EINVAL; |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 58 | |
| 59 | if (sockfd != -1) { |
Al Viro | 964ea96 | 2014-03-05 20:33:08 -0500 | [diff] [blame] | 60 | int err; |
Pawel Lebioda | 3eed8c0 | 2014-05-14 19:20:27 +0200 | [diff] [blame] | 61 | |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 62 | dev_info(dev, "stub up\n"); |
| 63 | |
Harvey Yang | dcf14779 | 2013-01-22 13:31:30 +0800 | [diff] [blame] | 64 | spin_lock_irq(&sdev->ud.lock); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 65 | |
| 66 | if (sdev->ud.status != SDEV_ST_AVAILABLE) { |
| 67 | dev_err(dev, "not ready\n"); |
Kurt Kanzenbach | 31398f6 | 2013-04-04 16:03:08 +0200 | [diff] [blame] | 68 | goto err; |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 69 | } |
| 70 | |
Al Viro | 964ea96 | 2014-03-05 20:33:08 -0500 | [diff] [blame] | 71 | socket = sockfd_lookup(sockfd, &err); |
Kurt Kanzenbach | 31398f6 | 2013-04-04 16:03:08 +0200 | [diff] [blame] | 72 | if (!socket) |
| 73 | goto err; |
| 74 | |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 75 | sdev->ud.tcp_socket = socket; |
Shuah Khan | 009f41a | 2018-01-26 11:56:50 -0700 | [diff] [blame] | 76 | sdev->ud.sockfd = sockfd; |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 77 | |
Harvey Yang | dcf14779 | 2013-01-22 13:31:30 +0800 | [diff] [blame] | 78 | spin_unlock_irq(&sdev->ud.lock); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 79 | |
Kurt Kanzenbach | 8c4e583 | 2013-02-22 12:13:34 +0100 | [diff] [blame] | 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"); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 84 | |
Harvey Yang | dcf14779 | 2013-01-22 13:31:30 +0800 | [diff] [blame] | 85 | spin_lock_irq(&sdev->ud.lock); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 86 | sdev->ud.status = SDEV_ST_USED; |
Harvey Yang | dcf14779 | 2013-01-22 13:31:30 +0800 | [diff] [blame] | 87 | spin_unlock_irq(&sdev->ud.lock); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 88 | |
| 89 | } else { |
| 90 | dev_info(dev, "stub down\n"); |
| 91 | |
Harvey Yang | dcf14779 | 2013-01-22 13:31:30 +0800 | [diff] [blame] | 92 | spin_lock_irq(&sdev->ud.lock); |
Kurt Kanzenbach | 31398f6 | 2013-04-04 16:03:08 +0200 | [diff] [blame] | 93 | if (sdev->ud.status != SDEV_ST_USED) |
| 94 | goto err; |
| 95 | |
Harvey Yang | dcf14779 | 2013-01-22 13:31:30 +0800 | [diff] [blame] | 96 | spin_unlock_irq(&sdev->ud.lock); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 97 | |
| 98 | usbip_event_add(&sdev->ud, SDEV_EVENT_DOWN); |
| 99 | } |
| 100 | |
| 101 | return count; |
Kurt Kanzenbach | 31398f6 | 2013-04-04 16:03:08 +0200 | [diff] [blame] | 102 | |
| 103 | err: |
| 104 | spin_unlock_irq(&sdev->ud.lock); |
Al Viro | 964ea96 | 2014-03-05 20:33:08 -0500 | [diff] [blame] | 105 | return -EINVAL; |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 106 | } |
Greg Kroah-Hartman | ca35910 | 2018-01-23 11:24:07 +0100 | [diff] [blame] | 107 | static DEVICE_ATTR_WO(usbip_sockfd); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 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); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 129 | err_sockfd: |
| 130 | device_remove_file(dev, &dev_attr_usbip_status); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 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 | |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 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) { |
Shuah Khan | 90120d1 | 2017-12-15 10:50:09 -0700 | [diff] [blame] | 153 | dev_dbg(&sdev->udev->dev, "shutdown sockfd %d\n", ud->sockfd); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 154 | kernel_sock_shutdown(ud->tcp_socket, SHUT_RDWR); |
| 155 | } |
| 156 | |
| 157 | /* 1. stop threads */ |
navin | b7caecb | 2012-09-19 17:07:27 +0530 | [diff] [blame] | 158 | if (ud->tcp_rx) { |
Oleg Nesterov | ba46ce3 | 2012-03-13 19:07:18 +0100 | [diff] [blame] | 159 | kthread_stop_put(ud->tcp_rx); |
navin | b7caecb | 2012-09-19 17:07:27 +0530 | [diff] [blame] | 160 | ud->tcp_rx = NULL; |
| 161 | } |
| 162 | if (ud->tcp_tx) { |
Oleg Nesterov | ba46ce3 | 2012-03-13 19:07:18 +0100 | [diff] [blame] | 163 | kthread_stop_put(ud->tcp_tx); |
navin | b7caecb | 2012-09-19 17:07:27 +0530 | [diff] [blame] | 164 | ud->tcp_tx = NULL; |
| 165 | } |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 166 | |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 167 | /* |
matt mooney | 8735276 | 2011-05-19 21:36:56 -0700 | [diff] [blame] | 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. |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 172 | */ |
| 173 | if (ud->tcp_socket) { |
Al Viro | 964ea96 | 2014-03-05 20:33:08 -0500 | [diff] [blame] | 174 | sockfd_put(ud->tcp_socket); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 175 | ud->tcp_socket = NULL; |
Shuah Khan | 009f41a | 2018-01-26 11:56:50 -0700 | [diff] [blame] | 176 | ud->sockfd = -1; |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 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); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 188 | list_for_each_entry_safe(unlink, tmp, &sdev->unlink_tx, list) { |
| 189 | list_del(&unlink->list); |
| 190 | kfree(unlink); |
| 191 | } |
matt mooney | 8735276 | 2011-05-19 21:36:56 -0700 | [diff] [blame] | 192 | list_for_each_entry_safe(unlink, tmp, &sdev->unlink_free, |
| 193 | list) { |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 194 | list_del(&unlink->list); |
| 195 | kfree(unlink); |
| 196 | } |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 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); |
Max Vozeler | 2d8f459 | 2011-01-12 15:01:59 +0200 | [diff] [blame] | 204 | struct usb_device *udev = sdev->udev; |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 205 | int ret; |
| 206 | |
matt mooney | 1a4b6f6 | 2011-05-19 16:47:32 -0700 | [diff] [blame] | 207 | dev_dbg(&udev->dev, "device reset"); |
Max Vozeler | 2d8f459 | 2011-01-12 15:01:59 +0200 | [diff] [blame] | 208 | |
Alexander Popov | 8c7003a3 | 2016-04-28 13:07:22 +0300 | [diff] [blame] | 209 | ret = usb_lock_device_for_reset(udev, NULL); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 210 | if (ret < 0) { |
| 211 | dev_err(&udev->dev, "lock for reset\n"); |
Harvey Yang | dcf14779 | 2013-01-22 13:31:30 +0800 | [diff] [blame] | 212 | spin_lock_irq(&ud->lock); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 213 | ud->status = SDEV_ST_ERROR; |
Harvey Yang | dcf14779 | 2013-01-22 13:31:30 +0800 | [diff] [blame] | 214 | spin_unlock_irq(&ud->lock); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 215 | return; |
| 216 | } |
| 217 | |
| 218 | /* try to reset the device */ |
| 219 | ret = usb_reset_device(udev); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 220 | usb_unlock_device(udev); |
| 221 | |
Harvey Yang | dcf14779 | 2013-01-22 13:31:30 +0800 | [diff] [blame] | 222 | spin_lock_irq(&ud->lock); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 223 | if (ret) { |
| 224 | dev_err(&udev->dev, "device reset\n"); |
| 225 | ud->status = SDEV_ST_ERROR; |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 226 | } else { |
| 227 | dev_info(&udev->dev, "device reset\n"); |
| 228 | ud->status = SDEV_ST_AVAILABLE; |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 229 | } |
Harvey Yang | dcf14779 | 2013-01-22 13:31:30 +0800 | [diff] [blame] | 230 | spin_unlock_irq(&ud->lock); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 231 | } |
| 232 | |
| 233 | static void stub_device_unusable(struct usbip_device *ud) |
| 234 | { |
Harvey Yang | dcf14779 | 2013-01-22 13:31:30 +0800 | [diff] [blame] | 235 | spin_lock_irq(&ud->lock); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 236 | ud->status = SDEV_ST_ERROR; |
Harvey Yang | dcf14779 | 2013-01-22 13:31:30 +0800 | [diff] [blame] | 237 | spin_unlock_irq(&ud->lock); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 238 | } |
| 239 | |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 240 | /** |
| 241 | * stub_device_alloc - allocate a new stub_device struct |
Alexander Popov | 8c7003a3 | 2016-04-28 13:07:22 +0300 | [diff] [blame] | 242 | * @udev: usb_device of a new device |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 243 | * |
| 244 | * Allocates and initializes a new stub_device struct. |
| 245 | */ |
Valentina Manea | b7945b7 | 2014-01-23 23:12:29 +0200 | [diff] [blame] | 246 | static struct stub_device *stub_device_alloc(struct usb_device *udev) |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 247 | { |
| 248 | struct stub_device *sdev; |
Valentina Manea | b7945b7 | 2014-01-23 23:12:29 +0200 | [diff] [blame] | 249 | int busnum = udev->bus->busnum; |
| 250 | int devnum = udev->devnum; |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 251 | |
Valentina Manea | b7945b7 | 2014-01-23 23:12:29 +0200 | [diff] [blame] | 252 | dev_dbg(&udev->dev, "allocating stub device"); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 253 | |
| 254 | /* yes, it's a new device */ |
| 255 | sdev = kzalloc(sizeof(struct stub_device), GFP_KERNEL); |
Joe Perches | 78110bb | 2013-02-11 09:41:29 -0800 | [diff] [blame] | 256 | if (!sdev) |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 257 | return NULL; |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 258 | |
Max Vozeler | 2d8f459 | 2011-01-12 15:01:59 +0200 | [diff] [blame] | 259 | sdev->udev = usb_get_dev(udev); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 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 | */ |
matt mooney | b744a45 | 2011-05-06 03:47:41 -0700 | [diff] [blame] | 266 | sdev->devid = (busnum << 16) | devnum; |
| 267 | sdev->ud.side = USBIP_STUB; |
| 268 | sdev->ud.status = SDEV_ST_AVAILABLE; |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 269 | spin_lock_init(&sdev->ud.lock); |
matt mooney | b744a45 | 2011-05-06 03:47:41 -0700 | [diff] [blame] | 270 | sdev->ud.tcp_socket = NULL; |
Shuah Khan | 009f41a | 2018-01-26 11:56:50 -0700 | [diff] [blame] | 271 | sdev->ud.sockfd = -1; |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 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); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 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 | |
Valentina Manea | b7945b7 | 2014-01-23 23:12:29 +0200 | [diff] [blame] | 288 | dev_dbg(&udev->dev, "register new device\n"); |
matt mooney | 1a4b6f6 | 2011-05-19 16:47:32 -0700 | [diff] [blame] | 289 | |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 290 | return sdev; |
| 291 | } |
| 292 | |
Kurt Kanzenbach | b94b3a6 | 2013-04-04 16:03:11 +0200 | [diff] [blame] | 293 | static void stub_device_free(struct stub_device *sdev) |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 294 | { |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 295 | kfree(sdev); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 296 | } |
| 297 | |
Valentina Manea | b7945b7 | 2014-01-23 23:12:29 +0200 | [diff] [blame] | 298 | static int stub_probe(struct usb_device *udev) |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 299 | { |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 300 | struct stub_device *sdev = NULL; |
Valentina Manea | b7945b7 | 2014-01-23 23:12:29 +0200 | [diff] [blame] | 301 | const char *udev_busid = dev_name(&udev->dev); |
Endre Kollar | aa5873e | 2010-07-27 12:39:30 +0200 | [diff] [blame] | 302 | struct bus_id_priv *busid_priv; |
Shuah Khan (Samsung OSG) | 22076557 | 2018-05-14 20:49:58 -0600 | [diff] [blame^] | 303 | int rc = 0; |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 304 | |
Shuah Khan | 28b68ac | 2018-04-11 18:13:30 -0600 | [diff] [blame] | 305 | dev_dbg(&udev->dev, "Enter probe\n"); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 306 | |
| 307 | /* check we should claim or not by busid_table */ |
Endre Kollar | aa5873e | 2010-07-27 12:39:30 +0200 | [diff] [blame] | 308 | busid_priv = get_busid_priv(udev_busid); |
matt mooney | 8735276 | 2011-05-19 21:36:56 -0700 | [diff] [blame] | 309 | if (!busid_priv || (busid_priv->status == STUB_BUSID_REMOV) || |
matt mooney | b744a45 | 2011-05-06 03:47:41 -0700 | [diff] [blame] | 310 | (busid_priv->status == STUB_BUSID_OTHER)) { |
Valentina Manea | b7945b7 | 2014-01-23 23:12:29 +0200 | [diff] [blame] | 311 | dev_info(&udev->dev, |
Elad Wexler | 6165cc5 | 2013-09-05 12:07:10 +0300 | [diff] [blame] | 312 | "%s is not in match_busid table... skip!\n", |
| 313 | udev_busid); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 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 | */ |
Shuah Khan (Samsung OSG) | 22076557 | 2018-05-14 20:49:58 -0600 | [diff] [blame^] | 320 | rc = -ENODEV; |
| 321 | goto call_put_busid_priv; |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 322 | } |
| 323 | |
matt mooney | 1a4b6f6 | 2011-05-19 16:47:32 -0700 | [diff] [blame] | 324 | if (udev->descriptor.bDeviceClass == USB_CLASS_HUB) { |
| 325 | dev_dbg(&udev->dev, "%s is a usb hub device... skip!\n", |
| 326 | udev_busid); |
Shuah Khan (Samsung OSG) | 22076557 | 2018-05-14 20:49:58 -0600 | [diff] [blame^] | 327 | rc = -ENODEV; |
| 328 | goto call_put_busid_priv; |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 329 | } |
| 330 | |
| 331 | if (!strcmp(udev->bus->bus_name, "vhci_hcd")) { |
Elad Wexler | 6165cc5 | 2013-09-05 12:07:10 +0300 | [diff] [blame] | 332 | dev_dbg(&udev->dev, |
| 333 | "%s is attached on vhci_hcd... skip!\n", |
| 334 | udev_busid); |
| 335 | |
Shuah Khan (Samsung OSG) | 22076557 | 2018-05-14 20:49:58 -0600 | [diff] [blame^] | 336 | rc = -ENODEV; |
| 337 | goto call_put_busid_priv; |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 338 | } |
| 339 | |
matt mooney | d012c2a5 | 2011-05-19 21:37:03 -0700 | [diff] [blame] | 340 | /* ok, this is my device */ |
Valentina Manea | b7945b7 | 2014-01-23 23:12:29 +0200 | [diff] [blame] | 341 | sdev = stub_device_alloc(udev); |
Shuah Khan (Samsung OSG) | 22076557 | 2018-05-14 20:49:58 -0600 | [diff] [blame^] | 342 | if (!sdev) { |
| 343 | rc = -ENOMEM; |
| 344 | goto call_put_busid_priv; |
| 345 | } |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 346 | |
Valentina Manea | b7945b7 | 2014-01-23 23:12:29 +0200 | [diff] [blame] | 347 | dev_info(&udev->dev, |
| 348 | "usbip-host: register new device (bus %u dev %u)\n", |
| 349 | udev->bus->busnum, udev->devnum); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 350 | |
Endre Kollar | aa5873e | 2010-07-27 12:39:30 +0200 | [diff] [blame] | 351 | busid_priv->shutdown_busid = 0; |
| 352 | |
Valentina Manea | b7945b7 | 2014-01-23 23:12:29 +0200 | [diff] [blame] | 353 | /* set private data to usb_device */ |
| 354 | dev_set_drvdata(&udev->dev, sdev); |
Endre Kollar | aa5873e | 2010-07-27 12:39:30 +0200 | [diff] [blame] | 355 | busid_priv->sdev = sdev; |
Valentina Manea | a46034c | 2014-03-08 14:53:33 +0200 | [diff] [blame] | 356 | busid_priv->udev = udev; |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 357 | |
Valentina Manea | 6080cd0 | 2014-03-08 14:53:34 +0200 | [diff] [blame] | 358 | /* |
| 359 | * Claim this hub port. |
| 360 | * It doesn't matter what value we pass as owner |
| 361 | * (struct dev_state) as long as it is unique. |
| 362 | */ |
| 363 | rc = usb_hub_claim_port(udev->parent, udev->portnum, |
Valentina Manea | 9b6f0c4 | 2014-03-10 10:36:40 +0200 | [diff] [blame] | 364 | (struct usb_dev_state *) udev); |
Valentina Manea | 6080cd0 | 2014-03-08 14:53:34 +0200 | [diff] [blame] | 365 | if (rc) { |
| 366 | dev_dbg(&udev->dev, "unable to claim port\n"); |
Alexey Khoroshilov | 3ff6744 | 2014-11-29 01:29:10 +0300 | [diff] [blame] | 367 | goto err_port; |
Valentina Manea | 6080cd0 | 2014-03-08 14:53:34 +0200 | [diff] [blame] | 368 | } |
| 369 | |
Alexey Khoroshilov | 3ff6744 | 2014-11-29 01:29:10 +0300 | [diff] [blame] | 370 | rc = stub_add_files(&udev->dev); |
| 371 | if (rc) { |
Valentina Manea | b7945b7 | 2014-01-23 23:12:29 +0200 | [diff] [blame] | 372 | dev_err(&udev->dev, "stub_add_files for %s\n", udev_busid); |
Alexey Khoroshilov | 3ff6744 | 2014-11-29 01:29:10 +0300 | [diff] [blame] | 373 | goto err_files; |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 374 | } |
Endre Kollar | aa5873e | 2010-07-27 12:39:30 +0200 | [diff] [blame] | 375 | busid_priv->status = STUB_BUSID_ALLOC; |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 376 | |
Shuah Khan (Samsung OSG) | 22076557 | 2018-05-14 20:49:58 -0600 | [diff] [blame^] | 377 | rc = 0; |
| 378 | goto call_put_busid_priv; |
| 379 | |
Alexey Khoroshilov | 3ff6744 | 2014-11-29 01:29:10 +0300 | [diff] [blame] | 380 | err_files: |
| 381 | usb_hub_release_port(udev->parent, udev->portnum, |
| 382 | (struct usb_dev_state *) udev); |
| 383 | err_port: |
| 384 | dev_set_drvdata(&udev->dev, NULL); |
| 385 | usb_put_dev(udev); |
Alexey Khoroshilov | 3ff6744 | 2014-11-29 01:29:10 +0300 | [diff] [blame] | 386 | |
| 387 | busid_priv->sdev = NULL; |
| 388 | stub_device_free(sdev); |
Shuah Khan (Samsung OSG) | 22076557 | 2018-05-14 20:49:58 -0600 | [diff] [blame^] | 389 | |
| 390 | call_put_busid_priv: |
| 391 | put_busid_priv(busid_priv); |
Alexey Khoroshilov | 3ff6744 | 2014-11-29 01:29:10 +0300 | [diff] [blame] | 392 | return rc; |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 393 | } |
| 394 | |
Endre Kollar | aa5873e | 2010-07-27 12:39:30 +0200 | [diff] [blame] | 395 | static void shutdown_busid(struct bus_id_priv *busid_priv) |
| 396 | { |
| 397 | if (busid_priv->sdev && !busid_priv->shutdown_busid) { |
| 398 | busid_priv->shutdown_busid = 1; |
| 399 | usbip_event_add(&busid_priv->sdev->ud, SDEV_EVENT_REMOVED); |
| 400 | |
Kurt Kanzenbach | 771788074 | 2013-04-04 16:03:05 +0200 | [diff] [blame] | 401 | /* wait for the stop of the event handler */ |
Endre Kollar | aa5873e | 2010-07-27 12:39:30 +0200 | [diff] [blame] | 402 | usbip_stop_eh(&busid_priv->sdev->ud); |
| 403 | } |
Endre Kollar | aa5873e | 2010-07-27 12:39:30 +0200 | [diff] [blame] | 404 | } |
| 405 | |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 406 | /* |
| 407 | * called in usb_disconnect() or usb_deregister() |
| 408 | * but only if actconfig(active configuration) exists |
| 409 | */ |
Valentina Manea | b7945b7 | 2014-01-23 23:12:29 +0200 | [diff] [blame] | 410 | static void stub_disconnect(struct usb_device *udev) |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 411 | { |
Endre Kollar | aa5873e | 2010-07-27 12:39:30 +0200 | [diff] [blame] | 412 | struct stub_device *sdev; |
Valentina Manea | b7945b7 | 2014-01-23 23:12:29 +0200 | [diff] [blame] | 413 | const char *udev_busid = dev_name(&udev->dev); |
Endre Kollar | aa5873e | 2010-07-27 12:39:30 +0200 | [diff] [blame] | 414 | struct bus_id_priv *busid_priv; |
Valentina Manea | 6080cd0 | 2014-03-08 14:53:34 +0200 | [diff] [blame] | 415 | int rc; |
Endre Kollar | aa5873e | 2010-07-27 12:39:30 +0200 | [diff] [blame] | 416 | |
Shuah Khan | 28b68ac | 2018-04-11 18:13:30 -0600 | [diff] [blame] | 417 | dev_dbg(&udev->dev, "Enter disconnect\n"); |
matt mooney | 1a4b6f6 | 2011-05-19 16:47:32 -0700 | [diff] [blame] | 418 | |
Endre Kollar | aa5873e | 2010-07-27 12:39:30 +0200 | [diff] [blame] | 419 | busid_priv = get_busid_priv(udev_busid); |
Endre Kollar | aa5873e | 2010-07-27 12:39:30 +0200 | [diff] [blame] | 420 | if (!busid_priv) { |
| 421 | BUG(); |
| 422 | return; |
| 423 | } |
| 424 | |
Valentina Manea | b7945b7 | 2014-01-23 23:12:29 +0200 | [diff] [blame] | 425 | sdev = dev_get_drvdata(&udev->dev); |
Endre Kollar | aa5873e | 2010-07-27 12:39:30 +0200 | [diff] [blame] | 426 | |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 427 | /* get stub_device */ |
| 428 | if (!sdev) { |
Valentina Manea | b7945b7 | 2014-01-23 23:12:29 +0200 | [diff] [blame] | 429 | dev_err(&udev->dev, "could not get device"); |
Shuah Khan (Samsung OSG) | 22076557 | 2018-05-14 20:49:58 -0600 | [diff] [blame^] | 430 | goto call_put_busid_priv; |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 431 | } |
| 432 | |
Valentina Manea | b7945b7 | 2014-01-23 23:12:29 +0200 | [diff] [blame] | 433 | dev_set_drvdata(&udev->dev, NULL); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 434 | |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 435 | /* |
Bart Westgeest | c7f0089 | 2012-10-10 13:34:27 -0400 | [diff] [blame] | 436 | * NOTE: rx/tx threads are invoked for each usb_device. |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 437 | */ |
Valentina Manea | b7945b7 | 2014-01-23 23:12:29 +0200 | [diff] [blame] | 438 | stub_remove_files(&udev->dev); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 439 | |
Valentina Manea | 6080cd0 | 2014-03-08 14:53:34 +0200 | [diff] [blame] | 440 | /* release port */ |
| 441 | rc = usb_hub_release_port(udev->parent, udev->portnum, |
Valentina Manea | 9b6f0c4 | 2014-03-10 10:36:40 +0200 | [diff] [blame] | 442 | (struct usb_dev_state *) udev); |
Valentina Manea | 6080cd0 | 2014-03-08 14:53:34 +0200 | [diff] [blame] | 443 | if (rc) { |
| 444 | dev_dbg(&udev->dev, "unable to release port\n"); |
Shuah Khan (Samsung OSG) | 22076557 | 2018-05-14 20:49:58 -0600 | [diff] [blame^] | 445 | goto call_put_busid_priv; |
Valentina Manea | 6080cd0 | 2014-03-08 14:53:34 +0200 | [diff] [blame] | 446 | } |
| 447 | |
Bart Westgeest | c7f0089 | 2012-10-10 13:34:27 -0400 | [diff] [blame] | 448 | /* If usb reset is called from event handler */ |
Nobuo Iwata | bb7871a | 2016-03-24 10:50:59 +0900 | [diff] [blame] | 449 | if (usbip_in_eh(current)) |
Shuah Khan (Samsung OSG) | 22076557 | 2018-05-14 20:49:58 -0600 | [diff] [blame^] | 450 | goto call_put_busid_priv; |
Endre Kollar | aa5873e | 2010-07-27 12:39:30 +0200 | [diff] [blame] | 451 | |
Bart Westgeest | c7f0089 | 2012-10-10 13:34:27 -0400 | [diff] [blame] | 452 | /* shutdown the current connection */ |
Endre Kollar | aa5873e | 2010-07-27 12:39:30 +0200 | [diff] [blame] | 453 | shutdown_busid(busid_priv); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 454 | |
Max Vozeler | 2d8f459 | 2011-01-12 15:01:59 +0200 | [diff] [blame] | 455 | usb_put_dev(sdev->udev); |
Max Vozeler | 2d8f459 | 2011-01-12 15:01:59 +0200 | [diff] [blame] | 456 | |
Bart Westgeest | c7f0089 | 2012-10-10 13:34:27 -0400 | [diff] [blame] | 457 | /* free sdev */ |
Endre Kollar | aa5873e | 2010-07-27 12:39:30 +0200 | [diff] [blame] | 458 | busid_priv->sdev = NULL; |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 459 | stub_device_free(sdev); |
| 460 | |
Shuah Khan (Samsung OSG) | 7510df3 | 2018-04-30 16:17:20 -0600 | [diff] [blame] | 461 | if (busid_priv->status == STUB_BUSID_ALLOC) |
Endre Kollar | aa5873e | 2010-07-27 12:39:30 +0200 | [diff] [blame] | 462 | busid_priv->status = STUB_BUSID_ADDED; |
Shuah Khan (Samsung OSG) | 22076557 | 2018-05-14 20:49:58 -0600 | [diff] [blame^] | 463 | |
| 464 | call_put_busid_priv: |
| 465 | put_busid_priv(busid_priv); |
Takahiro Hirofuchi | 4d7b5c7 | 2008-07-09 14:56:51 -0600 | [diff] [blame] | 466 | } |
matt mooney | d012c2a5 | 2011-05-19 21:37:03 -0700 | [diff] [blame] | 467 | |
Valentina Manea | b7945b7 | 2014-01-23 23:12:29 +0200 | [diff] [blame] | 468 | #ifdef CONFIG_PM |
Akshay Joshi | 553a1a5 | 2011-08-17 15:58:31 -0400 | [diff] [blame] | 469 | |
Valentina Manea | b7945b7 | 2014-01-23 23:12:29 +0200 | [diff] [blame] | 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) |
Arjan Mels | 1aee199 | 2011-06-30 22:18:18 +0200 | [diff] [blame] | 474 | { |
Valentina Manea | b7945b7 | 2014-01-23 23:12:29 +0200 | [diff] [blame] | 475 | dev_dbg(&udev->dev, "stub_suspend\n"); |
| 476 | |
Arjan Mels | 1aee199 | 2011-06-30 22:18:18 +0200 | [diff] [blame] | 477 | return 0; |
| 478 | } |
| 479 | |
Valentina Manea | b7945b7 | 2014-01-23 23:12:29 +0200 | [diff] [blame] | 480 | static int stub_resume(struct usb_device *udev, pm_message_t message) |
Arjan Mels | 1aee199 | 2011-06-30 22:18:18 +0200 | [diff] [blame] | 481 | { |
Valentina Manea | b7945b7 | 2014-01-23 23:12:29 +0200 | [diff] [blame] | 482 | dev_dbg(&udev->dev, "stub_resume\n"); |
| 483 | |
Arjan Mels | 1aee199 | 2011-06-30 22:18:18 +0200 | [diff] [blame] | 484 | return 0; |
| 485 | } |
| 486 | |
Valentina Manea | b7945b7 | 2014-01-23 23:12:29 +0200 | [diff] [blame] | 487 | #endif /* CONFIG_PM */ |
| 488 | |
| 489 | struct usb_device_driver stub_driver = { |
matt mooney | d012c2a5 | 2011-05-19 21:37:03 -0700 | [diff] [blame] | 490 | .name = "usbip-host", |
| 491 | .probe = stub_probe, |
| 492 | .disconnect = stub_disconnect, |
Valentina Manea | b7945b7 | 2014-01-23 23:12:29 +0200 | [diff] [blame] | 493 | #ifdef CONFIG_PM |
| 494 | .suspend = stub_suspend, |
| 495 | .resume = stub_resume, |
| 496 | #endif |
| 497 | .supports_autosuspend = 0, |
Akshay Joshi | 97c451c | 2011-08-17 15:58:32 -0400 | [diff] [blame] | 498 | }; |