1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright (C) 2003-2008 Takahiro Hirofuchi 4 */ 5 6 #include <linux/string.h> 7 #include <linux/module.h> 8 #include <linux/device.h> 9 #include <linux/scatterlist.h> 10 11 #include "usbip_common.h" 12 #include "stub.h" 13 14 #define DRIVER_AUTHOR "Takahiro Hirofuchi" 15 #define DRIVER_DESC "USB/IP Host Driver" 16 17 struct kmem_cache *stub_priv_cache; 18 19 /* 20 * busid_tables defines matching busids that usbip can grab. A user can change 21 * dynamically what device is locally used and what device is exported to a 22 * remote host. 23 */ 24 #define MAX_BUSID 16 25 static struct bus_id_priv busid_table[MAX_BUSID]; 26 static DEFINE_SPINLOCK(busid_table_lock); 27 28 static void init_busid_table(void) 29 { 30 int i; 31 32 /* 33 * This also sets the bus_table[i].status to 34 * STUB_BUSID_OTHER, which is 0. 35 */ 36 memset(busid_table, 0, sizeof(busid_table)); 37 38 for (i = 0; i < MAX_BUSID; i++) 39 spin_lock_init(&busid_table[i].busid_lock); 40 } 41 42 /* 43 * Find the index of the busid by name. 44 * Must be called with busid_table_lock held. 45 */ 46 static int get_busid_idx(const char *busid) 47 { 48 int i; 49 int idx = -1; 50 51 for (i = 0; i < MAX_BUSID; i++) { 52 spin_lock(&busid_table[i].busid_lock); 53 if (busid_table[i].name[0]) 54 if (!strncmp(busid_table[i].name, busid, BUSID_SIZE)) { 55 idx = i; 56 spin_unlock(&busid_table[i].busid_lock); 57 break; 58 } 59 spin_unlock(&busid_table[i].busid_lock); 60 } 61 return idx; 62 } 63 64 /* Returns holding busid_lock. Should call put_busid_priv() to unlock */ 65 struct bus_id_priv *get_busid_priv(const char *busid) 66 { 67 int idx; 68 struct bus_id_priv *bid = NULL; 69 70 spin_lock(&busid_table_lock); 71 idx = get_busid_idx(busid); 72 if (idx >= 0) { 73 bid = &(busid_table[idx]); 74 /* get busid_lock before returning */ 75 spin_lock(&bid->busid_lock); 76 } 77 spin_unlock(&busid_table_lock); 78 79 return bid; 80 } 81 82 void put_busid_priv(struct bus_id_priv *bid) 83 { 84 if (bid) 85 spin_unlock(&bid->busid_lock); 86 } 87 88 static int add_match_busid(char *busid) 89 { 90 int i; 91 int ret = -1; 92 93 spin_lock(&busid_table_lock); 94 /* already registered? */ 95 if (get_busid_idx(busid) >= 0) { 96 ret = 0; 97 goto out; 98 } 99 100 for (i = 0; i < MAX_BUSID; i++) { 101 spin_lock(&busid_table[i].busid_lock); 102 if (!busid_table[i].name[0]) { 103 strlcpy(busid_table[i].name, busid, BUSID_SIZE); 104 if ((busid_table[i].status != STUB_BUSID_ALLOC) && 105 (busid_table[i].status != STUB_BUSID_REMOV)) 106 busid_table[i].status = STUB_BUSID_ADDED; 107 ret = 0; 108 spin_unlock(&busid_table[i].busid_lock); 109 break; 110 } 111 spin_unlock(&busid_table[i].busid_lock); 112 } 113 114 out: 115 spin_unlock(&busid_table_lock); 116 117 return ret; 118 } 119 120 int del_match_busid(char *busid) 121 { 122 int idx; 123 int ret = -1; 124 125 spin_lock(&busid_table_lock); 126 idx = get_busid_idx(busid); 127 if (idx < 0) 128 goto out; 129 130 /* found */ 131 ret = 0; 132 133 spin_lock(&busid_table[idx].busid_lock); 134 135 if (busid_table[idx].status == STUB_BUSID_OTHER) 136 memset(busid_table[idx].name, 0, BUSID_SIZE); 137 138 if ((busid_table[idx].status != STUB_BUSID_OTHER) && 139 (busid_table[idx].status != STUB_BUSID_ADDED)) 140 busid_table[idx].status = STUB_BUSID_REMOV; 141 142 spin_unlock(&busid_table[idx].busid_lock); 143 out: 144 spin_unlock(&busid_table_lock); 145 146 return ret; 147 } 148 149 static ssize_t match_busid_show(struct device_driver *drv, char *buf) 150 { 151 int i; 152 char *out = buf; 153 154 spin_lock(&busid_table_lock); 155 for (i = 0; i < MAX_BUSID; i++) { 156 spin_lock(&busid_table[i].busid_lock); 157 if (busid_table[i].name[0]) 158 out += sprintf(out, "%s ", busid_table[i].name); 159 spin_unlock(&busid_table[i].busid_lock); 160 } 161 spin_unlock(&busid_table_lock); 162 out += sprintf(out, "\n"); 163 164 return out - buf; 165 } 166 167 static ssize_t match_busid_store(struct device_driver *dev, const char *buf, 168 size_t count) 169 { 170 int len; 171 char busid[BUSID_SIZE]; 172 173 if (count < 5) 174 return -EINVAL; 175 176 /* busid needs to include \0 termination */ 177 len = strlcpy(busid, buf + 4, BUSID_SIZE); 178 if (sizeof(busid) <= len) 179 return -EINVAL; 180 181 if (!strncmp(buf, "add ", 4)) { 182 if (add_match_busid(busid) < 0) 183 return -ENOMEM; 184 185 pr_debug("add busid %s\n", busid); 186 return count; 187 } 188 189 if (!strncmp(buf, "del ", 4)) { 190 if (del_match_busid(busid) < 0) 191 return -ENODEV; 192 193 pr_debug("del busid %s\n", busid); 194 return count; 195 } 196 197 return -EINVAL; 198 } 199 static DRIVER_ATTR_RW(match_busid); 200 201 static int do_rebind(char *busid, struct bus_id_priv *busid_priv) 202 { 203 int ret = 0; 204 205 /* device_attach() callers should hold parent lock for USB */ 206 if (busid_priv->udev->dev.parent) 207 device_lock(busid_priv->udev->dev.parent); 208 ret = device_attach(&busid_priv->udev->dev); 209 if (busid_priv->udev->dev.parent) 210 device_unlock(busid_priv->udev->dev.parent); 211 if (ret < 0) 212 dev_err(&busid_priv->udev->dev, "rebind failed\n"); 213 return ret; 214 } 215 216 static void stub_device_rebind(void) 217 { 218 #if IS_MODULE(CONFIG_USBIP_HOST) 219 struct bus_id_priv *busid_priv; 220 int i; 221 222 /* update status to STUB_BUSID_OTHER so probe ignores the device */ 223 spin_lock(&busid_table_lock); 224 for (i = 0; i < MAX_BUSID; i++) { 225 if (busid_table[i].name[0] && 226 busid_table[i].shutdown_busid) { 227 busid_priv = &(busid_table[i]); 228 busid_priv->status = STUB_BUSID_OTHER; 229 } 230 } 231 spin_unlock(&busid_table_lock); 232 233 /* now run rebind - no need to hold locks. driver files are removed */ 234 for (i = 0; i < MAX_BUSID; i++) { 235 if (busid_table[i].name[0] && 236 busid_table[i].shutdown_busid) { 237 busid_priv = &(busid_table[i]); 238 do_rebind(busid_table[i].name, busid_priv); 239 } 240 } 241 #endif 242 } 243 244 static ssize_t rebind_store(struct device_driver *dev, const char *buf, 245 size_t count) 246 { 247 int ret; 248 int len; 249 struct bus_id_priv *bid; 250 251 /* buf length should be less that BUSID_SIZE */ 252 len = strnlen(buf, BUSID_SIZE); 253 254 if (!(len < BUSID_SIZE)) 255 return -EINVAL; 256 257 bid = get_busid_priv(buf); 258 if (!bid) 259 return -ENODEV; 260 261 /* mark the device for deletion so probe ignores it during rescan */ 262 bid->status = STUB_BUSID_OTHER; 263 /* release the busid lock */ 264 put_busid_priv(bid); 265 266 ret = do_rebind((char *) buf, bid); 267 if (ret < 0) 268 return ret; 269 270 /* delete device from busid_table */ 271 del_match_busid((char *) buf); 272 273 return count; 274 } 275 276 static DRIVER_ATTR_WO(rebind); 277 278 static struct stub_priv *stub_priv_pop_from_listhead(struct list_head *listhead) 279 { 280 struct stub_priv *priv, *tmp; 281 282 list_for_each_entry_safe(priv, tmp, listhead, list) { 283 list_del_init(&priv->list); 284 return priv; 285 } 286 287 return NULL; 288 } 289 290 void stub_free_priv_and_urb(struct stub_priv *priv) 291 { 292 struct urb *urb; 293 int i; 294 295 for (i = 0; i < priv->num_urbs; i++) { 296 urb = priv->urbs[i]; 297 298 if (!urb) 299 return; 300 301 kfree(urb->setup_packet); 302 urb->setup_packet = NULL; 303 304 305 if (urb->transfer_buffer && !priv->sgl) { 306 kfree(urb->transfer_buffer); 307 urb->transfer_buffer = NULL; 308 } 309 310 if (urb->num_sgs) { 311 sgl_free(urb->sg); 312 urb->sg = NULL; 313 urb->num_sgs = 0; 314 } 315 316 usb_free_urb(urb); 317 } 318 if (!list_empty(&priv->list)) 319 list_del(&priv->list); 320 if (priv->sgl) 321 sgl_free(priv->sgl); 322 kfree(priv->urbs); 323 kmem_cache_free(stub_priv_cache, priv); 324 } 325 326 static struct stub_priv *stub_priv_pop(struct stub_device *sdev) 327 { 328 unsigned long flags; 329 struct stub_priv *priv; 330 331 spin_lock_irqsave(&sdev->priv_lock, flags); 332 333 priv = stub_priv_pop_from_listhead(&sdev->priv_init); 334 if (priv) 335 goto done; 336 337 priv = stub_priv_pop_from_listhead(&sdev->priv_tx); 338 if (priv) 339 goto done; 340 341 priv = stub_priv_pop_from_listhead(&sdev->priv_free); 342 343 done: 344 spin_unlock_irqrestore(&sdev->priv_lock, flags); 345 346 return priv; 347 } 348 349 void stub_device_cleanup_urbs(struct stub_device *sdev) 350 { 351 struct stub_priv *priv; 352 int i; 353 354 dev_dbg(&sdev->udev->dev, "Stub device cleaning up urbs\n"); 355 356 while ((priv = stub_priv_pop(sdev))) { 357 for (i = 0; i < priv->num_urbs; i++) 358 usb_kill_urb(priv->urbs[i]); 359 360 stub_free_priv_and_urb(priv); 361 } 362 } 363 364 static int __init usbip_host_init(void) 365 { 366 int ret; 367 368 init_busid_table(); 369 370 stub_priv_cache = KMEM_CACHE(stub_priv, SLAB_HWCACHE_ALIGN); 371 if (!stub_priv_cache) { 372 pr_err("kmem_cache_create failed\n"); 373 return -ENOMEM; 374 } 375 376 ret = usb_register_device_driver(&stub_driver, THIS_MODULE); 377 if (ret) { 378 pr_err("usb_register failed %d\n", ret); 379 goto err_usb_register; 380 } 381 382 ret = driver_create_file(&stub_driver.drvwrap.driver, 383 &driver_attr_match_busid); 384 if (ret) { 385 pr_err("driver_create_file failed\n"); 386 goto err_create_file; 387 } 388 389 ret = driver_create_file(&stub_driver.drvwrap.driver, 390 &driver_attr_rebind); 391 if (ret) { 392 pr_err("driver_create_file failed\n"); 393 goto err_create_file; 394 } 395 396 return ret; 397 398 err_create_file: 399 usb_deregister_device_driver(&stub_driver); 400 err_usb_register: 401 kmem_cache_destroy(stub_priv_cache); 402 return ret; 403 } 404 405 static void __exit usbip_host_exit(void) 406 { 407 driver_remove_file(&stub_driver.drvwrap.driver, 408 &driver_attr_match_busid); 409 410 driver_remove_file(&stub_driver.drvwrap.driver, 411 &driver_attr_rebind); 412 413 /* 414 * deregister() calls stub_disconnect() for all devices. Device 415 * specific data is cleared in stub_disconnect(). 416 */ 417 usb_deregister_device_driver(&stub_driver); 418 419 /* initiate scan to attach devices */ 420 stub_device_rebind(); 421 422 kmem_cache_destroy(stub_priv_cache); 423 } 424 425 module_init(usbip_host_init); 426 module_exit(usbip_host_exit); 427 428 MODULE_AUTHOR(DRIVER_AUTHOR); 429 MODULE_DESCRIPTION(DRIVER_DESC); 430 MODULE_LICENSE("GPL"); 431