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;
 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         return 0;
 218 }
 219
 220 static void stub_device_rebind(void)
 221 {
 222 #if IS_MODULE(CONFIG_USBIP_HOST)
 223         struct bus_id_priv *busid_priv;
 224         int i;
 225
 226         /* update status to STUB_BUSID_OTHER so probe ignores the device */
 227         spin_lock(&busid_table_lock);
 228         for (i = 0; i < MAX_BUSID; i++) {
 229                 if (busid_table[i].name[0] &&
 230                     busid_table[i].shutdown_busid) {
 231                         busid_priv = &(busid_table[i]);
 232                         busid_priv->status = STUB_BUSID_OTHER;
 233                 }
 234         }
 235         spin_unlock(&busid_table_lock);
 236
 237         /* now run rebind - no need to hold locks. driver files are removed */
 238         for (i = 0; i < MAX_BUSID; i++) {
 239                 if (busid_table[i].name[0] &&
 240                     busid_table[i].shutdown_busid) {
 241                         busid_priv = &(busid_table[i]);
 242                         do_rebind(busid_table[i].name, busid_priv);
 243                 }
 244         }
 245 #endif
 246 }
 247
 248 static ssize_t rebind_store(struct device_driver *dev, const char *buf,
 249                                  size_t count)
 250 {
 251         int ret;
 252         int len;
 253         struct bus_id_priv *bid;
 254
 255         /* buf length should be less that BUSID_SIZE */
 256         len = strnlen(buf, BUSID_SIZE);
 257
 258         if (!(len < BUSID_SIZE))
 259                 return -EINVAL;
 260
 261         bid = get_busid_priv(buf);
 262         if (!bid)
 263                 return -ENODEV;
 264
 265         /* mark the device for deletion so probe ignores it during rescan */
 266         bid->status = STUB_BUSID_OTHER;
 267         /* release the busid lock */
 268         put_busid_priv(bid);
 269
 270         ret = do_rebind((char *) buf, bid);
 271         if (ret < 0)
 272                 return ret;
 273
 274         /* delete device from busid_table */
 275         del_match_busid((char *) buf);
 276
 277         return count;
 278 }
 279
 280 static DRIVER_ATTR_WO(rebind);
 281
 282 static struct stub_priv *stub_priv_pop_from_listhead(struct list_head *listhead)
 283 {
 284         struct stub_priv *priv, *tmp;
 285
 286         list_for_each_entry_safe(priv, tmp, listhead, list) {
 287                 list_del_init(&priv->list);
 288                 return priv;
 289         }
 290
 291         return NULL;
 292 }
 293
 294 void stub_free_priv_and_urb(struct stub_priv *priv)
 295 {
 296         struct urb *urb;
 297         int i;
 298
 299         for (i = 0; i < priv->num_urbs; i++) {
 300                 urb = priv->urbs[i];
 301
 302                 if (!urb)
 303                         return;
 304
 305                 kfree(urb->setup_packet);
 306                 urb->setup_packet = NULL;
 307
 308
 309                 if (urb->transfer_buffer && !priv->sgl) {
 310                         kfree(urb->transfer_buffer);
 311                         urb->transfer_buffer = NULL;
 312                 }
 313
 314                 if (urb->num_sgs) {
 315                         sgl_free(urb->sg);
 316                         urb->sg = NULL;
 317                         urb->num_sgs = 0;
 318                 }
 319
 320                 usb_free_urb(urb);
 321         }
 322         if (!list_empty(&priv->list))
 323                 list_del(&priv->list);
 324         if (priv->sgl)
 325                 sgl_free(priv->sgl);
 326         kfree(priv->urbs);
 327         kmem_cache_free(stub_priv_cache, priv);
 328 }
 329
 330 static struct stub_priv *stub_priv_pop(struct stub_device *sdev)
 331 {
 332         unsigned long flags;
 333         struct stub_priv *priv;
 334
 335         spin_lock_irqsave(&sdev->priv_lock, flags);
 336
 337         priv = stub_priv_pop_from_listhead(&sdev->priv_init);
 338         if (priv)
 339                 goto done;
 340
 341         priv = stub_priv_pop_from_listhead(&sdev->priv_tx);
 342         if (priv)
 343                 goto done;
 344
 345         priv = stub_priv_pop_from_listhead(&sdev->priv_free);
 346
 347 done:
 348         spin_unlock_irqrestore(&sdev->priv_lock, flags);
 349
 350         return priv;
 351 }
 352
 353 void stub_device_cleanup_urbs(struct stub_device *sdev)
 354 {
 355         struct stub_priv *priv;
 356         int i;
 357
 358         dev_dbg(&sdev->udev->dev, "Stub device cleaning up urbs\n");
 359
 360         while ((priv = stub_priv_pop(sdev))) {
 361                 for (i = 0; i < priv->num_urbs; i++)
 362                         usb_kill_urb(priv->urbs[i]);
 363
 364                 stub_free_priv_and_urb(priv);
 365         }
 366 }
 367
 368 static int __init usbip_host_init(void)
 369 {
 370         int ret;
 371
 372         init_busid_table();
 373
 374         stub_priv_cache = KMEM_CACHE(stub_priv, SLAB_HWCACHE_ALIGN);
 375         if (!stub_priv_cache) {
 376                 pr_err("kmem_cache_create failed\n");
 377                 return -ENOMEM;
 378         }
 379
 380         ret = usb_register_device_driver(&stub_driver, THIS_MODULE);
 381         if (ret) {
 382                 pr_err("usb_register failed %d\n", ret);
 383                 goto err_usb_register;
 384         }
 385
 386         ret = driver_create_file(&stub_driver.drvwrap.driver,
 387                                  &driver_attr_match_busid);
 388         if (ret) {
 389                 pr_err("driver_create_file failed\n");
 390                 goto err_create_file;
 391         }
 392
 393         ret = driver_create_file(&stub_driver.drvwrap.driver,
 394                                  &driver_attr_rebind);
 395         if (ret) {
 396                 pr_err("driver_create_file failed\n");
 397                 goto err_create_file;
 398         }
 399
 400         return ret;
 401
 402 err_create_file:
 403         usb_deregister_device_driver(&stub_driver);
 404 err_usb_register:
 405         kmem_cache_destroy(stub_priv_cache);
 406         return ret;
 407 }
 408
 409 static void __exit usbip_host_exit(void)
 410 {
 411         driver_remove_file(&stub_driver.drvwrap.driver,
 412                            &driver_attr_match_busid);
 413
 414         driver_remove_file(&stub_driver.drvwrap.driver,
 415                            &driver_attr_rebind);
 416
 417         /*
 418          * deregister() calls stub_disconnect() for all devices. Device
 419          * specific data is cleared in stub_disconnect().
 420          */
 421         usb_deregister_device_driver(&stub_driver);
 422
 423         /* initiate scan to attach devices */
 424         stub_device_rebind();
 425
 426         kmem_cache_destroy(stub_priv_cache);
 427 }
 428
 429 module_init(usbip_host_init);
 430 module_exit(usbip_host_exit);
 431
 432 MODULE_AUTHOR(DRIVER_AUTHOR);
 433 MODULE_DESCRIPTION(DRIVER_DESC);
 434 MODULE_LICENSE("GPL");