drivers/usb/usbip/stub_main.c

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