stub_main.c 8.9 KB

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