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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
capifs.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：11k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

capifs.c：源码内容
  1. /* $Id: capifs.c,v 1.1.4.1 2001/11/20 14:19:34 kai Exp $
  2.  * 
  3.  * Copyright 2000 by Carsten Paeth <calle@calle.de>
  4.  *
  5.  * Heavily based on devpts filesystem from H. Peter Anvin
  6.  * 
  7.  * This software may be used and distributed according to the terms
  8.  * of the GNU General Public License, incorporated herein by reference.
  9.  *
  10.  */
  12. #include <linux/version.h>
  13. #include <linux/fs.h>
  14. #include <linux/tty.h>
  15. #include <linux/types.h>
  16. #include <linux/errno.h>
  17. #include <linux/stat.h>
  18. #include <linux/param.h>
  19. #include <linux/module.h>
  20. #include <linux/string.h>
  21. #include <linux/init.h>
  22. #include <linux/kdev_t.h>
  23. #include <linux/kernel.h>
  24. #include <linux/locks.h>
  25. #include <linux/major.h>
  26. #include <linux/slab.h>
  27. #include <linux/ctype.h>
  28. #include <asm/bitops.h>
  29. #include <asm/uaccess.h>
  31. MODULE_DESCRIPTION("CAPI4Linux: /dev/capi/ filesystem");
  32. MODULE_AUTHOR("Carsten Paeth");
  33. MODULE_LICENSE("GPL");
  35. static char *revision = "$Revision: 1.1.4.1 $";
  37. struct capifs_ncci {
  38. struct inode *inode;
  39. char used;
  40. char type;
  41. unsigned int num;
  42. kdev_t kdev;
  43. };
  45. struct capifs_sb_info {
  46. u32 magic;
  47. struct super_block *next;
  48. struct super_block **back;
  49. int setuid;
  50. int setgid;
  51. uid_t   uid;
  52. gid_t   gid;
  53. umode_t mode;
  55. unsigned int max_ncci;
  56. struct capifs_ncci *nccis;
  57. };
  59. #define CAPIFS_SUPER_MAGIC (('C'<<8)|'N')
  60. #define CAPIFS_SBI_MAGIC   (('C'<<24)|('A'<<16)|('P'<<8)|'I')
  62. static inline struct capifs_sb_info *SBI(struct super_block *sb)
  63. {
  64. return (struct capifs_sb_info *)(sb->u.generic_sbp);
  65. }
  67. /* ------------------------------------------------------------------ */
  69. static int capifs_root_readdir(struct file *,void *,filldir_t);
  70. static struct dentry *capifs_root_lookup(struct inode *,struct dentry *);
  71. static int capifs_revalidate(struct dentry *, int);
  72. static struct inode *capifs_new_inode(struct super_block *sb);
  74. static struct file_operations capifs_root_operations = {
  75. read: generic_read_dir,
  76. readdir: capifs_root_readdir,
  77. };
  79. struct inode_operations capifs_root_inode_operations = {
  80. lookup: capifs_root_lookup,
  81. };
  83. static struct dentry_operations capifs_dentry_operations = {
  84. d_revalidate: capifs_revalidate,
  85. };
  87. /*
  88.  * /dev/capi/%d
  89.  * /dev/capi/r%d
  90.  */
  92. static int capifs_root_readdir(struct file *filp, void *dirent, filldir_t filldir)
  93. {
  94. struct inode * inode = filp->f_dentry->d_inode;
  95. struct capifs_sb_info * sbi = SBI(filp->f_dentry->d_inode->i_sb);
  96. off_t nr;
  97. char numbuf[32];
  99. nr = filp->f_pos;
  101. switch(nr)
  102. {
  103. case 0:
  104. if (filldir(dirent, ".", 1, nr, inode->i_ino, DT_DIR) < 0)
  105. return 0;
  106. filp->f_pos = ++nr;
  107. /* fall through */
  108. case 1:
  109. if (filldir(dirent, "..", 2, nr, inode->i_ino, DT_DIR) < 0)
  110. return 0;
  111. filp->f_pos = ++nr;
  112. /* fall through */
  113. default:
  114. while (nr < sbi->max_ncci) {
  115. int n = nr - 2;
  116. struct capifs_ncci *np = &sbi->nccis[n];
  117. if (np->inode && np->used) {
  118. char *p = numbuf;
  119. if (np->type) *p++ = np->type;
  120. sprintf(p, "%u", np->num);
  121. if ( filldir(dirent, numbuf, strlen(numbuf), nr, nr, DT_UNKNOWN) < 0 )
  122. return 0;
  123. }
  124. filp->f_pos = ++nr;
  125. }
  126. break;
  127. }
  129. return 0;
  130. }
  132. /*
  133.  * Revalidate is called on every cache lookup.  We use it to check that
  134.  * the ncci really does still exist.  Never revalidate negative dentries;
  135.  * for simplicity (fix later?)
  136.  */
  137. static int capifs_revalidate(struct dentry * dentry, int flags)
  138. {
  139. struct capifs_sb_info *sbi;
  141. if ( !dentry->d_inode )
  142. return 0;
  144. sbi = SBI(dentry->d_inode->i_sb);
  146. return ( sbi->nccis[dentry->d_inode->i_ino - 2].inode == dentry->d_inode );
  147. }
  149. static struct dentry *capifs_root_lookup(struct inode * dir, struct dentry * dentry)
  150. {
  151. struct capifs_sb_info *sbi = SBI(dir->i_sb);
  152. struct capifs_ncci *np;
  153. unsigned int i;
  154. char numbuf[32];
  155. char *p, *tmp;
  156. unsigned int num;
  157. char type = 0;
  159. dentry->d_inode = NULL; /* Assume failure */
  160. dentry->d_op    = &capifs_dentry_operations;
  162. if (dentry->d_name.len >= sizeof(numbuf) )
  163. return NULL;
  164. strncpy(numbuf, dentry->d_name.name, dentry->d_name.len);
  165. numbuf[dentry->d_name.len] = 0;
  166.         p = numbuf;
  167. if (!isdigit(*p)) type = *p++;
  168. tmp = p;
  169. num = (unsigned int)simple_strtoul(p, &tmp, 10);
  170. if (tmp == p || *tmp)
  171. return NULL;
  173. for (i = 0, np = sbi->nccis ; i < sbi->max_ncci; i++, np++) {
  174. if (np->used && np->num == num && np->type == type)
  175. break;
  176. }
  178. if ( i >= sbi->max_ncci )
  179. return NULL;
  181. dentry->d_inode = np->inode;
  182. if ( dentry->d_inode )
  183. atomic_inc(&dentry->d_inode->i_count);
  185. d_add(dentry, dentry->d_inode);
  187. return NULL;
  188. }
  190. /* ------------------------------------------------------------------ */
  192. static struct super_block *mounts = NULL;
  194. static void capifs_put_super(struct super_block *sb)
  195. {
  196. struct capifs_sb_info *sbi = SBI(sb);
  197. struct inode *inode;
  198. int i;
  200. for ( i = 0 ; i < sbi->max_ncci ; i++ ) {
  201. if ( (inode = sbi->nccis[i].inode) ) {
  202. if (atomic_read(&inode->i_count) != 1 )
  203. printk("capifs_put_super: badness: entry %d count %dn",
  204.        i, (unsigned)atomic_read(&inode->i_count));
  205. inode->i_nlink--;
  206. iput(inode);
  207. }
  208. }
  210. *sbi->back = sbi->next;
  211. if ( sbi->next )
  212. SBI(sbi->next)->back = sbi->back;
  214. kfree(sbi->nccis);
  215. kfree(sbi);
  216. }
  218. static int capifs_statfs(struct super_block *sb, struct statfs *buf);
  220. static struct super_operations capifs_sops = {
  221. put_super: capifs_put_super,
  222. statfs: capifs_statfs,
  223. };
  225. static int capifs_parse_options(char *options, struct capifs_sb_info *sbi)
  226. {
  227. int setuid = 0;
  228. int setgid = 0;
  229. uid_t uid = 0;
  230. gid_t gid = 0;
  231. umode_t mode = 0600;
  232. unsigned int maxncci = 512;
  233. char *this_char, *value;
  235. this_char = NULL;
  236. if ( options )
  237. this_char = strtok(options,",");
  238. for ( ; this_char; this_char = strtok(NULL,",")) {
  239. if ((value = strchr(this_char,'=')) != NULL)
  240. *value++ = 0;
  241. if (!strcmp(this_char,"uid")) {
  242. if (!value || !*value)
  243. return 1;
  244. uid = simple_strtoul(value,&value,0);
  245. if (*value)
  246. return 1;
  247. setuid = 1;
  248. }
  249. else if (!strcmp(this_char,"gid")) {
  250. if (!value || !*value)
  251. return 1;
  252. gid = simple_strtoul(value,&value,0);
  253. if (*value)
  254. return 1;
  255. setgid = 1;
  256. }
  257. else if (!strcmp(this_char,"mode")) {
  258. if (!value || !*value)
  259. return 1;
  260. mode = simple_strtoul(value,&value,8);
  261. if (*value)
  262. return 1;
  263. }
  264. else if (!strcmp(this_char,"maxncci")) {
  265. if (!value || !*value)
  266. return 1;
  267. maxncci = simple_strtoul(value,&value,8);
  268. if (*value)
  269. return 1;
  270. }
  271. else
  272. return 1;
  273. }
  274. sbi->setuid   = setuid;
  275. sbi->setgid   = setgid;
  276. sbi->uid      = uid;
  277. sbi->gid      = gid;
  278. sbi->mode     = mode & ~S_IFMT;
  279. sbi->max_ncci = maxncci;
  281. return 0;
  282. }
  284. struct super_block *capifs_read_super(struct super_block *s, void *data,
  285.       int silent)
  286. {
  287. struct inode * root_inode;
  288. struct dentry * root;
  289. struct capifs_sb_info *sbi;
  291. /* Super block already completed? */
  292. if (s->s_root)
  293. goto out;
  295. sbi = (struct capifs_sb_info *) kmalloc(sizeof(struct capifs_sb_info), GFP_KERNEL);
  296. if ( !sbi )
  297. goto fail;
  299. memset(sbi, 0, sizeof(struct capifs_sb_info));
  300. sbi->magic  = CAPIFS_SBI_MAGIC;
  302. if ( capifs_parse_options(data,sbi) ) {
  303. kfree(sbi);
  304. printk("capifs: called with bogus optionsn");
  305. goto fail;
  306. }
  308. sbi->nccis = kmalloc(sizeof(struct capifs_ncci) * sbi->max_ncci, GFP_KERNEL);
  309. if ( !sbi->nccis ) {
  310. kfree(sbi);
  311. goto fail;
  312. }
  313. memset(sbi->nccis, 0, sizeof(struct capifs_ncci) * sbi->max_ncci);
  315. s->u.generic_sbp = (void *) sbi;
  316. s->s_blocksize = 1024;
  317. s->s_blocksize_bits = 10;
  318. s->s_magic = CAPIFS_SUPER_MAGIC;
  319. s->s_op = &capifs_sops;
  320. s->s_root = NULL;
  322. /*
  323.  * Get the root inode and dentry, but defer checking for errors.
  324.  */
  325. root_inode = capifs_new_inode(s);
  326. if (root_inode) {
  327. root_inode->i_ino = 1;
  328. root_inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO | S_IWUSR;
  329. root_inode->i_op = &capifs_root_inode_operations;
  330. root_inode->i_fop = &capifs_root_operations;
  331. root_inode->i_nlink = 2;
  332. } 
  333. root = d_alloc_root(root_inode);
  335. /*
  336.  * Check whether somebody else completed the super block.
  337.  */
  338. if (s->s_root) {
  339. if (root) dput(root);
  340. else iput(root_inode);
  341. goto out;
  342. }
  344. if (!root) {
  345. printk("capifs: get root dentry failedn");
  346. /*
  347.   * iput() can block, so we clear the super block first.
  348.   */
  349. iput(root_inode);
  350. kfree(sbi->nccis);
  351. kfree(sbi);
  352. goto fail;
  353. }
  355. /*
  356.  * Check whether somebody else completed the super block.
  357.  */
  358. if (s->s_root)
  359. goto out;
  361. /*
  362.  * Success! Install the root dentry now to indicate completion.
  363.  */
  364. s->s_root = root;
  366. sbi->next = mounts;
  367. if ( sbi->next )
  368. SBI(sbi->next)->back = &(sbi->next);
  369. sbi->back = &mounts;
  370. mounts = s;
  372. out: /* Success ... somebody else completed the super block for us. */ 
  373. return s;
  374. fail:
  375. return NULL;
  376. }
  378. static int capifs_statfs(struct super_block *sb, struct statfs *buf)
  379. {
  380. buf->f_type = CAPIFS_SUPER_MAGIC;
  381. buf->f_bsize = 1024;
  382. buf->f_blocks = 0;
  383. buf->f_bfree = 0;
  384. buf->f_bavail = 0;
  385. buf->f_files = 0;
  386. buf->f_ffree = 0;
  387. buf->f_namelen = NAME_MAX;
  388. return 0;
  389. }
  391. static struct inode *capifs_new_inode(struct super_block *sb)
  392. {
  393. struct inode *inode = new_inode(sb);
  394. if (inode) {
  395. inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
  396. inode->i_blocks = 0;
  397. inode->i_blksize = 1024;
  398. inode->i_uid = inode->i_gid = 0;
  399. }
  400. return inode;
  401. }
  403. static DECLARE_FSTYPE(capifs_fs_type, "capifs", capifs_read_super, 0);
  405. void capifs_new_ncci(char type, unsigned int num, kdev_t device)
  406. {
  407. struct super_block *sb;
  408. struct capifs_sb_info *sbi;
  409. struct capifs_ncci *np;
  410. ino_t ino;
  412. for ( sb = mounts ; sb ; sb = sbi->next ) {
  413. sbi = SBI(sb);
  415. for (ino = 0, np = sbi->nccis ; ino < sbi->max_ncci; ino++, np++) {
  416. if (np->used == 0) {
  417. np->used = 1;
  418. np->type = type;
  419. np->num = num;
  420. np->kdev = device;
  421. break;
  422. }
  423. }
  424. if ( ino >= sbi->max_ncci )
  425. continue;
  427. if ((np->inode = capifs_new_inode(sb)) != NULL) {
  428. struct inode *inode = np->inode;
  429. inode->i_uid = sbi->setuid ? sbi->uid : current->fsuid;
  430. inode->i_gid = sbi->setgid ? sbi->gid : current->fsgid;
  431. inode->i_nlink = 1;
  432. inode->i_ino = ino + 2;
  433. init_special_inode(inode, sbi->mode|S_IFCHR, np->kdev);
  434. }
  435. }
  436. }
  438. void capifs_free_ncci(char type, unsigned int num)
  439. {
  440. struct super_block *sb;
  441. struct capifs_sb_info *sbi;
  442. struct inode *inode;
  443. struct capifs_ncci *np;
  444. ino_t ino;
  446. for ( sb = mounts ; sb ; sb = sbi->next ) {
  447. sbi = SBI(sb);
  449. for (ino = 0, np = sbi->nccis ; ino < sbi->max_ncci; ino++, np++) {
  450. if (!np->used || np->type != type || np->num != num)
  451. continue;
  452. if (np->inode) {
  453. inode = np->inode;
  454. np->inode = 0;
  455. np->used = 0;
  456. inode->i_nlink--;
  457. iput(inode);
  458. break;
  459. }
  460. }
  461. }
  462. }
  464. static int __init capifs_init(void)
  465. {
  466. char rev[32];
  467. char *p;
  468. int err;
  470. MOD_INC_USE_COUNT;
  472. if ((p = strchr(revision, ':')) != 0 && p[1]) {
  473. strncpy(rev, p + 2, sizeof(rev));
  474. rev[sizeof(rev)-1] = 0;
  475. if ((p = strchr(rev, '$')) != 0 && p > rev)
  476.    *(p-1) = 0;
  477. } else
  478. strcpy(rev, "1.0");
  480. err = register_filesystem(&capifs_fs_type);
  481. if (err) {
  482. MOD_DEC_USE_COUNT;
  483. return err;
  484. }
  485.         printk(KERN_NOTICE "capifs: Rev %sn", rev);
  486. MOD_DEC_USE_COUNT;
  487. return 0;
  488. }
  490. static void __exit capifs_exit(void)
  491. {
  492. unregister_filesystem(&capifs_fs_type);
  493. }
  495. EXPORT_SYMBOL(capifs_new_ncci);
  496. EXPORT_SYMBOL(capifs_free_ncci);
  498. module_init(capifs_init);
  499. module_exit(capifs_exit);