开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
inode.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：20k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

inode.c：源码内容
  1. /*****************************************************************************/
  3. /*
  4.  * inode.c  --  Inode/Dentry functions for the USB device file system.
  5.  *
  6.  * Copyright (C) 2000
  7.  *          Thomas Sailer (sailer@ife.ee.ethz.ch)
  8.  *
  9.  * This program is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2 of the License, or
  12.  * (at your option) any later version.
  13.  *
  14.  * This program is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this program; if not, write to the Free Software
  21.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22.  *
  23.  *  $Id: inode.c,v 1.3 2000/01/11 13:58:25 tom Exp $
  24.  *
  25.  *  History:
  26.  *   0.1  04.01.2000  Created
  27.  */
  29. /*****************************************************************************/
  31. #define __NO_VERSION__
  32. #include <linux/config.h>
  33. #include <linux/module.h>
  34. #include <linux/fs.h>
  35. #include <linux/sched.h>
  36. #include <linux/smp_lock.h>
  37. #include <linux/locks.h>
  38. #include <linux/init.h>
  39. #include <linux/proc_fs.h>
  40. #include <linux/usb.h>
  41. #include <linux/usbdevice_fs.h>
  42. #include <asm/uaccess.h>
  44. /* --------------------------------------------------------------------- */
  46. /*
  47.  * This list of superblocks is still used,
  48.  * but since usbdevfs became FS_SINGLE
  49.  * there is only one super_block.
  50.  */
  51. static LIST_HEAD(superlist);
  53. struct special {
  54. const char *name;
  55. struct file_operations *fops;
  56. struct inode *inode;
  57. struct list_head inodes;
  58. };
  60. static struct special special[] = { 
  61. { "devices", &usbdevfs_devices_fops,  },
  62. { "drivers", &usbdevfs_drivers_fops,  }
  63. };
  65. #define NRSPECIAL (sizeof(special)/sizeof(special[0]))
  67. /* --------------------------------------------------------------------- */
  69. static int dnumber(struct dentry *dentry)
  70. {
  71. const char *name;
  72. unsigned int s;
  74. if (dentry->d_name.len != 3)
  75. return -1;
  76. name = dentry->d_name.name;
  77. if (name[0] < '0' || name[0] > '9' ||
  78.     name[1] < '0' || name[1] > '9' ||
  79.     name[2] < '0' || name[2] > '9')
  80. return -1;
  81. s = name[0] - '0';
  82. s = s * 10 + name[1] - '0';
  83. s = s * 10 + name[2] - '0';
  84. return s;
  85. }
  87. /*
  88.  * utility functions; should be called with the kernel lock held
  89.  * to protect against busses/devices appearing/disappearing
  90.  */
  92. static void new_dev_inode(struct usb_device *dev, struct super_block *sb)
  93. {
  94. struct inode *inode;
  95. unsigned int devnum = dev->devnum;
  96. unsigned int busnum = dev->bus->busnum;
  98. if (devnum < 1 || devnum > 127 || busnum > 255)
  99. return;
  100. inode = iget(sb, IDEVICE | (busnum << 8) | devnum);
  101. if (!inode) {
  102. printk(KERN_ERR "usbdevfs: cannot create inode for bus %u device %un", busnum, devnum);
  103. return;
  104. }
  105. inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
  106. inode->i_uid = sb->u.usbdevfs_sb.devuid;
  107. inode->i_gid = sb->u.usbdevfs_sb.devgid;
  108. inode->i_mode = sb->u.usbdevfs_sb.devmode | S_IFREG;
  109. inode->i_fop = &usbdevfs_device_file_operations;
  110. inode->i_size = sizeof(struct usb_device_descriptor);
  111. inode->u.usbdev_i.p.dev = dev;
  112. list_add_tail(&inode->u.usbdev_i.slist, &sb->u.usbdevfs_sb.ilist);
  113. list_add_tail(&inode->u.usbdev_i.dlist, &dev->inodes);
  114. }
  116. static void recurse_new_dev_inode(struct usb_device *dev, struct super_block *sb)
  117. {
  118. unsigned int i;
  120. if (!dev)
  121. return;
  122. new_dev_inode(dev, sb);
  123. for (i = 0; i < dev->maxchild; i++) {
  124.                 if (!dev->children[i])
  125.                         continue;
  126. recurse_new_dev_inode(dev->children[i], sb);
  127. }
  128. }
  130. static void new_bus_inode(struct usb_bus *bus, struct super_block *sb)
  131. {
  132. struct inode *inode;
  133. unsigned int busnum = bus->busnum;
  135. if (busnum > 255)
  136. return;
  137. inode = iget(sb, IBUS | (busnum << 8));
  138. if (!inode) {
  139. printk(KERN_ERR "usbdevfs: cannot create inode for bus %un", busnum);
  140. return;
  141. }
  142. inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
  143. inode->i_uid = sb->u.usbdevfs_sb.busuid;
  144. inode->i_gid = sb->u.usbdevfs_sb.busgid;
  145. inode->i_mode = sb->u.usbdevfs_sb.busmode | S_IFDIR;
  146. inode->i_op = &usbdevfs_bus_inode_operations;
  147. inode->i_fop = &usbdevfs_bus_file_operations;
  148. inode->u.usbdev_i.p.bus = bus;
  149. list_add_tail(&inode->u.usbdev_i.slist, &sb->u.usbdevfs_sb.ilist);
  150. list_add_tail(&inode->u.usbdev_i.dlist, &bus->inodes);
  151. }
  153. static void free_inode(struct inode *inode)
  154. {
  155. inode->u.usbdev_i.p.bus = NULL;
  156. inode->u.usbdev_i.p.dev = NULL;
  157. inode->i_mode &= ~S_IRWXUGO;
  158. inode->i_uid = inode->i_gid = 0;
  159. inode->i_size = 0;
  160. list_del(&inode->u.usbdev_i.slist);
  161. INIT_LIST_HEAD(&inode->u.usbdev_i.slist);
  162. list_del(&inode->u.usbdev_i.dlist);
  163. INIT_LIST_HEAD(&inode->u.usbdev_i.dlist);
  164. iput(inode);
  165. }
  167. static int parse_options(struct super_block *s, char *data)
  168. {
  169. uid_t devuid = 0, busuid = 0, listuid = 0;
  170. gid_t devgid = 0, busgid = 0, listgid = 0;
  171. umode_t devmode = S_IWUSR | S_IRUGO, busmode = S_IXUGO | S_IRUGO, listmode = S_IRUGO;
  172. char *curopt = NULL, *value;
  174. /* parse options */
  175. if (data)
  176. curopt = strtok(data, ",");
  177. for (; curopt; curopt = strtok(NULL, ",")) {
  178. if ((value = strchr(curopt, '=')) != NULL)
  179. *value++ = 0;
  180. if (!strcmp(curopt, "devuid")) {
  181. if (!value || !value[0])
  182. return -EINVAL;
  183. devuid = simple_strtoul(value, &value, 0);
  184. if (*value)
  185. return -EINVAL;
  186. }
  187. if (!strcmp(curopt, "devgid")) {
  188. if (!value || !value[0])
  189. return -EINVAL;
  190. devgid = simple_strtoul(value, &value, 0);
  191. if (*value)
  192. return -EINVAL;
  193. }
  194. if (!strcmp(curopt, "devmode")) {
  195. if (!value || !value[0])
  196. return -EINVAL;
  197. devmode = simple_strtoul(value, &value, 0) & S_IRWXUGO;
  198. if (*value)
  199. return -EINVAL;
  200. }
  201. if (!strcmp(curopt, "busuid")) {
  202. if (!value || !value[0])
  203. return -EINVAL;
  204. busuid = simple_strtoul(value, &value, 0);
  205. if (*value)
  206. return -EINVAL;
  207. }
  208. if (!strcmp(curopt, "busgid")) {
  209. if (!value || !value[0])
  210. return -EINVAL;
  211. busgid = simple_strtoul(value, &value, 0);
  212. if (*value)
  213. return -EINVAL;
  214. }
  215. if (!strcmp(curopt, "busmode")) {
  216. if (!value || !value[0])
  217. return -EINVAL;
  218. busmode = simple_strtoul(value, &value, 0) & S_IRWXUGO;
  219. if (*value)
  220. return -EINVAL;
  221. }
  222. if (!strcmp(curopt, "listuid")) {
  223. if (!value || !value[0])
  224. return -EINVAL;
  225. listuid = simple_strtoul(value, &value, 0);
  226. if (*value)
  227. return -EINVAL;
  228. }
  229. if (!strcmp(curopt, "listgid")) {
  230. if (!value || !value[0])
  231. return -EINVAL;
  232. listgid = simple_strtoul(value, &value, 0);
  233. if (*value)
  234. return -EINVAL;
  235. }
  236. if (!strcmp(curopt, "listmode")) {
  237. if (!value || !value[0])
  238. return -EINVAL;
  239. listmode = simple_strtoul(value, &value, 0) & S_IRWXUGO;
  240. if (*value)
  241. return -EINVAL;
  242. }
  243. }
  245. s->u.usbdevfs_sb.devuid = devuid;
  246. s->u.usbdevfs_sb.devgid = devgid;
  247. s->u.usbdevfs_sb.devmode = devmode;
  248. s->u.usbdevfs_sb.busuid = busuid;
  249. s->u.usbdevfs_sb.busgid = busgid;
  250. s->u.usbdevfs_sb.busmode = busmode;
  251. s->u.usbdevfs_sb.listuid = listuid;
  252. s->u.usbdevfs_sb.listgid = listgid;
  253. s->u.usbdevfs_sb.listmode = listmode;
  255. return 0;
  256. }
  258. static struct usb_bus *usbdevfs_findbus(int busnr)
  259. {
  260.         struct list_head *list;
  261.         struct usb_bus *bus;
  263. down (&usb_bus_list_lock);
  264.         for (list = usb_bus_list.next; list != &usb_bus_list; list = list->next) {
  265.                 bus = list_entry(list, struct usb_bus, bus_list);
  266.                 if (bus->busnum == busnr) {
  267. up (&usb_bus_list_lock);
  268.                         return bus;
  269. }
  270.         }
  271. up (&usb_bus_list_lock);
  272.         return NULL;
  273. }
  275. #if 0
  276. static struct usb_device *finddev(struct usb_device *dev, int devnr)
  277. {
  278.         unsigned int i;
  279.         struct usb_device *d2;
  281.         if (!dev)
  282.                 return NULL;
  283.         if (dev->devnum == devnr)
  284.                 return dev;
  285.         for (i = 0; i < dev->maxchild; i++) {
  286.                 if (!dev->children[i])
  287.                         continue;
  288.                 if ((d2 = finddev(dev->children[i], devnr)))
  289.                         return d2;
  290.         }
  291.         return NULL;
  292. }
  294. static struct usb_device *usbdevfs_finddevice(struct usb_bus *bus, int devnr)
  295. {
  296.         return finddev(bus->root_hub, devnr);
  297. }
  298. #endif
  300. /* --------------------------------------------------------------------- */
  302. static int usbdevfs_revalidate(struct dentry *dentry, int flags)
  303. {
  304. struct inode *inode = dentry->d_inode;
  306.         if (!inode)
  307.                 return 0;
  308. if (ITYPE(inode->i_ino) == IBUS && !inode->u.usbdev_i.p.bus)
  309. return 0;
  310. if (ITYPE(inode->i_ino) == IDEVICE && !inode->u.usbdev_i.p.dev)
  311. return 0;
  312. return 1;
  313. }
  315. static struct dentry_operations usbdevfs_dentry_operations = {
  316. d_revalidate: usbdevfs_revalidate,
  317. };
  319. static struct dentry *usbdevfs_root_lookup(struct inode *dir, struct dentry *dentry)
  320. {
  321. int busnr;
  322. unsigned long ino = 0;
  323. unsigned int i;
  324. struct inode *inode;
  326. /* sanity check */
  327. if (dir->i_ino != IROOT)
  328. return ERR_PTR(-EINVAL);
  329. dentry->d_op = &usbdevfs_dentry_operations;
  330. busnr = dnumber(dentry);
  331. if (busnr >= 0 && busnr <= 255)
  332. ino = IBUS | (busnr << 8);
  333. if (!ino) {
  334. for (i = 0; i < NRSPECIAL; i++) {
  335. if (strlen(special[i].name) == dentry->d_name.len && 
  336.     !strncmp(special[i].name, dentry->d_name.name, dentry->d_name.len)) {
  337. ino = ISPECIAL | (i + IROOT + 1);
  338. break;
  339. }
  340. }
  341. }
  342. if (!ino)
  343. return ERR_PTR(-ENOENT);
  344. inode = iget(dir->i_sb, ino);
  345. if (!inode)
  346. return ERR_PTR(-EINVAL);
  347. if (inode && ITYPE(ino) == IBUS && inode->u.usbdev_i.p.bus == NULL) {
  348. iput(inode);
  349. inode = NULL;
  350. }
  351. d_add(dentry, inode);
  352. return NULL;
  353. }
  355. static struct dentry *usbdevfs_bus_lookup(struct inode *dir, struct dentry *dentry)
  356. {
  357. struct inode *inode;
  358. int devnr;
  360. /* sanity check */
  361. if (ITYPE(dir->i_ino) != IBUS)
  362. return ERR_PTR(-EINVAL);
  363. dentry->d_op = &usbdevfs_dentry_operations;
  364. devnr = dnumber(dentry);
  365. if (devnr < 1 || devnr > 127)
  366. return ERR_PTR(-ENOENT);
  367. inode = iget(dir->i_sb, IDEVICE | (dir->i_ino & (0xff << 8)) | devnr);
  368. if (!inode)
  369. return ERR_PTR(-EINVAL);
  370. if (inode && inode->u.usbdev_i.p.dev == NULL) {
  371. iput(inode);
  372. inode = NULL;
  373. }
  374. d_add(dentry, inode);
  375. return NULL;
  376. }
  378. static int usbdevfs_root_readdir(struct file *filp, void *dirent, filldir_t filldir)
  379. {
  380. struct inode *inode = filp->f_dentry->d_inode;
  381. unsigned long ino = inode->i_ino;
  382. struct special *spec;
  383. struct list_head *list;
  384. struct usb_bus *bus;
  385. char numbuf[8];
  386. unsigned int i;
  388. /* sanity check */
  389. if (ino != IROOT)
  390. return -EINVAL;
  391. i = filp->f_pos;
  392. switch (i) {
  393. case 0:
  394. if (filldir(dirent, ".", 1, i, IROOT, DT_DIR) < 0)
  395. return 0;
  396. filp->f_pos++;
  397. i++;
  398. /* fall through */
  400. case 1:
  401. if (filldir(dirent, "..", 2, i, IROOT, DT_DIR) < 0)
  402. return 0;
  403. filp->f_pos++;
  404. i++;
  405. /* fall through */
  407. default:
  409. while (i >= 2 && i < 2+NRSPECIAL) {
  410. spec = &special[filp->f_pos-2];
  411. if (filldir(dirent, spec->name, strlen(spec->name), i, ISPECIAL | (filp->f_pos-2+IROOT), DT_UNKNOWN) < 0)
  412. return 0;
  413. filp->f_pos++;
  414. i++;
  415. }
  416. if (i < 2+NRSPECIAL)
  417. return 0;
  418. i -= 2+NRSPECIAL;
  419. down (&usb_bus_list_lock);
  420. for (list = usb_bus_list.next; list != &usb_bus_list; list = list->next) {
  421. if (i > 0) {
  422. i--;
  423. continue;
  424. }
  425. bus = list_entry(list, struct usb_bus, bus_list);
  426. sprintf(numbuf, "%03d", bus->busnum);
  427. if (filldir(dirent, numbuf, 3, filp->f_pos, IBUS | ((bus->busnum & 0xff) << 8), DT_UNKNOWN) < 0)
  428. break;
  429. filp->f_pos++;
  430. }
  431. up (&usb_bus_list_lock);
  432. return 0;
  433. }
  434. }
  436. static int bus_readdir(struct usb_device *dev, unsigned long ino, int pos, struct file *filp, void *dirent, filldir_t filldir)
  437. {
  438. char numbuf[8];
  439. unsigned int i;
  441. if (!dev)
  442. return pos;
  443. sprintf(numbuf, "%03d", dev->devnum);
  444. if (pos > 0)
  445. pos--;
  446. else {
  447. if (filldir(dirent, numbuf, 3, filp->f_pos, ino | (dev->devnum & 0xff), DT_UNKNOWN) < 0)
  448. return -1;
  449. filp->f_pos++;
  450. }
  451. for (i = 0; i < dev->maxchild; i++) {
  452. if (!dev->children[i])
  453. continue;
  454. pos = bus_readdir(dev->children[i], ino, pos, filp, dirent, filldir);
  455. if (pos < 0)
  456. return -1;
  457. }
  458. return pos;
  459. }
  461. static int usbdevfs_bus_readdir(struct file *filp, void *dirent, filldir_t filldir)
  462. {
  463. struct inode *inode = filp->f_dentry->d_inode;
  464. unsigned long ino = inode->i_ino;
  465. struct usb_bus *bus;
  467. /* sanity check */
  468. if (ITYPE(ino) != IBUS)
  469. return -EINVAL;
  470. switch ((unsigned int)filp->f_pos) {
  471. case 0:
  472. if (filldir(dirent, ".", 1, filp->f_pos, ino, DT_DIR) < 0)
  473. return 0;
  474. filp->f_pos++;
  475. /* fall through */
  477. case 1:
  478. if (filldir(dirent, "..", 2, filp->f_pos, IROOT, DT_DIR) < 0)
  479. return 0;
  480. filp->f_pos++;
  481. /* fall through */
  483. default:
  484. lock_kernel();
  485. bus = usbdevfs_findbus(IBUSNR(ino));
  486. bus_readdir(bus->root_hub, IDEVICE | ((bus->busnum & 0xff) << 8), filp->f_pos-2, filp, dirent, filldir);
  487. unlock_kernel();
  488. return 0;
  489. }
  490. }
  492. static struct file_operations usbdevfs_root_file_operations = {
  493. readdir: usbdevfs_root_readdir,
  494. };
  496. static struct inode_operations usbdevfs_root_inode_operations = {
  497. lookup: usbdevfs_root_lookup,
  498. };
  500. static struct file_operations usbdevfs_bus_file_operations = {
  501. readdir: usbdevfs_bus_readdir,
  502. };
  504. static struct inode_operations usbdevfs_bus_inode_operations = {
  505. lookup: usbdevfs_bus_lookup,
  506. };
  508. static void usbdevfs_read_inode(struct inode *inode)
  509. {
  510. struct special *spec;
  512. inode->i_ctime = inode->i_mtime = inode->i_atime = CURRENT_TIME;
  513. inode->i_mode = S_IFREG;
  514. inode->i_gid = inode->i_uid = 0;
  515. INIT_LIST_HEAD(&inode->u.usbdev_i.dlist);
  516. INIT_LIST_HEAD(&inode->u.usbdev_i.slist);
  517. inode->u.usbdev_i.p.dev = NULL;
  518. inode->u.usbdev_i.p.bus = NULL;
  519. switch (ITYPE(inode->i_ino)) {
  520. case ISPECIAL:
  521. if (inode->i_ino == IROOT) {
  522. inode->i_op = &usbdevfs_root_inode_operations;
  523. inode->i_fop = &usbdevfs_root_file_operations;
  524. inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO;
  525. return;
  526. }
  527. if (inode->i_ino <= IROOT || inode->i_ino > IROOT+NRSPECIAL)
  528. return;
  529. spec = &special[inode->i_ino-(IROOT+1)];
  530. inode->i_fop = spec->fops;
  531. return;
  533. case IDEVICE:
  534. return;
  536. case IBUS:
  537. return;
  539. default:
  540. return;
  541.         }
  542. }
  544. static void usbdevfs_put_super(struct super_block *sb)
  545. {
  546. list_del(&sb->u.usbdevfs_sb.slist);
  547. INIT_LIST_HEAD(&sb->u.usbdevfs_sb.slist);
  548. while (!list_empty(&sb->u.usbdevfs_sb.ilist))
  549. free_inode(list_entry(sb->u.usbdevfs_sb.ilist.next, struct inode, u.usbdev_i.slist));
  550. }
  552. static int usbdevfs_statfs(struct super_block *sb, struct statfs *buf)
  553. {
  554.         buf->f_type = USBDEVICE_SUPER_MAGIC;
  555.         buf->f_bsize = PAGE_SIZE/sizeof(long);   /* ??? */
  556.         buf->f_bfree = 0;
  557.         buf->f_bavail = 0;
  558.         buf->f_ffree = 0;
  559.         buf->f_namelen = NAME_MAX;
  560.         return 0;
  561. }
  563. static int usbdevfs_remount(struct super_block *s, int *flags, char *data)
  564. {
  565. struct list_head *ilist = s->u.usbdevfs_sb.ilist.next;
  566. struct inode *inode;
  567. int ret;
  569. if ((ret = parse_options(s, data))) {
  570. printk(KERN_WARNING "usbdevfs: remount parameter errorn");
  571. return ret;
  572. }
  574. for (; ilist != &s->u.usbdevfs_sb.ilist; ilist = ilist->next) {
  575. inode = list_entry(ilist, struct inode, u.usbdev_i.slist);
  577. switch (ITYPE(inode->i_ino)) {
  578. case ISPECIAL :
  579. inode->i_uid = s->u.usbdevfs_sb.listuid;
  580. inode->i_gid = s->u.usbdevfs_sb.listgid;
  581. inode->i_mode = s->u.usbdevfs_sb.listmode | S_IFREG;
  582. break;
  583. case IBUS :
  584. inode->i_uid = s->u.usbdevfs_sb.busuid;
  585. inode->i_gid = s->u.usbdevfs_sb.busgid;
  586. inode->i_mode = s->u.usbdevfs_sb.busmode | S_IFDIR;
  587. break;
  588. case IDEVICE :
  589. inode->i_uid = s->u.usbdevfs_sb.devuid;
  590. inode->i_gid = s->u.usbdevfs_sb.devgid;
  591. inode->i_mode = s->u.usbdevfs_sb.devmode | S_IFREG;
  592. break;
  593. }
  594. }
  596. return 0;
  597. }
  599. static struct super_operations usbdevfs_sops = { 
  600. read_inode: usbdevfs_read_inode,
  601. put_super: usbdevfs_put_super,
  602. statfs: usbdevfs_statfs,
  603. remount_fs: usbdevfs_remount,
  604. };
  606. struct super_block *usbdevfs_read_super(struct super_block *s, void *data, int silent)
  607. {
  608.         struct inode *root_inode, *inode;
  609. struct list_head *blist;
  610. struct usb_bus *bus;
  611. unsigned int i;
  613. if (parse_options(s, data)) {
  614. printk(KERN_WARNING "usbdevfs: mount parameter errorn");
  615. return NULL;
  616. }
  618. /* fill superblock */
  619.         s->s_blocksize = 1024;
  620.         s->s_blocksize_bits = 10;
  621.         s->s_magic = USBDEVICE_SUPER_MAGIC;
  622.         s->s_op = &usbdevfs_sops;
  623. INIT_LIST_HEAD(&s->u.usbdevfs_sb.slist);
  624. INIT_LIST_HEAD(&s->u.usbdevfs_sb.ilist);
  625. root_inode = iget(s, IROOT);
  626.         if (!root_inode)
  627.                 goto out_no_root;
  628.         s->s_root = d_alloc_root(root_inode);
  629.         if (!s->s_root)
  630.                 goto out_no_root;
  631. list_add_tail(&s->u.usbdevfs_sb.slist, &superlist);
  632. for (i = 0; i < NRSPECIAL; i++) {
  633. if (!(inode = iget(s, IROOT+1+i)))
  634. continue;
  635. inode->i_uid = s->u.usbdevfs_sb.listuid;
  636. inode->i_gid = s->u.usbdevfs_sb.listgid;
  637. inode->i_mode = s->u.usbdevfs_sb.listmode | S_IFREG;
  638. special[i].inode = inode;
  639. list_add_tail(&inode->u.usbdev_i.slist, &s->u.usbdevfs_sb.ilist);
  640. list_add_tail(&inode->u.usbdev_i.dlist, &special[i].inodes);
  641. }
  642. down (&usb_bus_list_lock);
  643. for (blist = usb_bus_list.next; blist != &usb_bus_list; blist = blist->next) {
  644. bus = list_entry(blist, struct usb_bus, bus_list);
  645. new_bus_inode(bus, s);
  646. recurse_new_dev_inode(bus->root_hub, s);
  647. }
  648. up (&usb_bus_list_lock);
  649.         return s;
  651.  out_no_root:
  652.         printk("usbdevfs_read_super: get root inode failedn");
  653.         iput(root_inode);
  654.         return NULL;
  655. }
  657. static DECLARE_FSTYPE(usbdevice_fs_type, "usbdevfs", usbdevfs_read_super, FS_SINGLE);
  659. /* --------------------------------------------------------------------- */
  661. static void update_special_inodes (void)
  662. {
  663. int i;
  664. for (i = 0; i < NRSPECIAL; i++) {
  665. struct inode *inode = special[i].inode;
  666. if (inode)
  667. inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
  668. }
  669. }
  672. void usbdevfs_add_bus(struct usb_bus *bus)
  673. {
  674. struct list_head *slist;
  676. lock_kernel();
  677. for (slist = superlist.next; slist != &superlist; slist = slist->next)
  678. new_bus_inode(bus, list_entry(slist, struct super_block, u.usbdevfs_sb.slist));
  679. update_special_inodes();
  680. unlock_kernel();
  681. usbdevfs_conn_disc_event();
  682. }
  684. void usbdevfs_remove_bus(struct usb_bus *bus)
  685. {
  686. lock_kernel();
  687. while (!list_empty(&bus->inodes))
  688. free_inode(list_entry(bus->inodes.next, struct inode, u.usbdev_i.dlist));
  689. update_special_inodes();
  690. unlock_kernel();
  691. usbdevfs_conn_disc_event();
  692. }
  694. void usbdevfs_add_device(struct usb_device *dev)
  695. {
  696. struct list_head *slist;
  698. lock_kernel();
  699. for (slist = superlist.next; slist != &superlist; slist = slist->next)
  700. new_dev_inode(dev, list_entry(slist, struct super_block, u.usbdevfs_sb.slist));
  701. update_special_inodes();
  702. unlock_kernel();
  703. usbdevfs_conn_disc_event();
  704. }
  706. void usbdevfs_remove_device(struct usb_device *dev)
  707. {
  708. struct dev_state *ds;
  709. struct siginfo sinfo;
  711. lock_kernel();
  712. while (!list_empty(&dev->inodes))
  713. free_inode(list_entry(dev->inodes.next, struct inode, u.usbdev_i.dlist));
  714. while (!list_empty(&dev->filelist)) {
  715. ds = list_entry(dev->filelist.next, struct dev_state, list);
  716. list_del(&ds->list);
  717. INIT_LIST_HEAD(&ds->list);
  718. down_write(&ds->devsem);
  719. ds->dev = NULL;
  720. up_write(&ds->devsem);
  721. if (ds->discsignr) {
  722. sinfo.si_signo = SIGPIPE;
  723. sinfo.si_errno = EPIPE;
  724. sinfo.si_code = SI_ASYNCIO;
  725. sinfo.si_addr = ds->disccontext;
  726. send_sig_info(ds->discsignr, &sinfo, ds->disctask);
  727. }
  728. }
  730. update_special_inodes();
  731. unlock_kernel();
  732. usbdevfs_conn_disc_event();
  733. }
  735. /* --------------------------------------------------------------------- */
  737. #ifdef CONFIG_PROC_FS
  738. static struct proc_dir_entry *usbdir = NULL;
  739. #endif
  741. int __init usbdevfs_init(void)
  742. {
  743. int ret;
  745. for (ret = 0; ret < NRSPECIAL; ret++) {
  746. INIT_LIST_HEAD(&special[ret].inodes);
  747. }
  748. if ((ret = usb_register(&usbdevfs_driver)))
  749. return ret;
  750. if ((ret = register_filesystem(&usbdevice_fs_type))) {
  751. usb_deregister(&usbdevfs_driver);
  752. return ret;
  753. }
  754. #ifdef CONFIG_PROC_FS
  755. /* create mount point for usbdevfs */
  756. usbdir = proc_mkdir("usb", proc_bus);
  757. #endif
  758. return ret;
  759. }
  761. void __exit usbdevfs_cleanup(void)
  762. {
  763. usb_deregister(&usbdevfs_driver);
  764. unregister_filesystem(&usbdevice_fs_type);
  765. #ifdef CONFIG_PROC_FS
  766.         if (usbdir)
  767.                 remove_proc_entry("usb", proc_bus);
  768. #endif
  769. }
  771. #if 0
  772. module_init(usbdevfs_init);
  773. module_exit(usbdevfs_cleanup);
  774. #endif