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

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

嵌入式Linux

开发平台：

Unix_Linux

generic.c：源码内容
  1. /*
  2.  * proc/fs/generic.c --- generic routines for the proc-fs
  3.  *
  4.  * This file contains generic proc-fs routines for handling
  5.  * directories and files.
  6.  * 
  7.  * Copyright (C) 1991, 1992 Linus Torvalds.
  8.  * Copyright (C) 1997 Theodore Ts'o
  9.  */
  11. #include <asm/uaccess.h>
  13. #include <linux/errno.h>
  14. #include <linux/sched.h>
  15. #include <linux/proc_fs.h>
  16. #include <linux/stat.h>
  17. #define __NO_VERSION__
  18. #include <linux/module.h>
  19. #include <asm/bitops.h>
  21. static ssize_t proc_file_read(struct file * file, char * buf,
  22.       size_t nbytes, loff_t *ppos);
  23. static ssize_t proc_file_write(struct file * file, const char * buffer,
  24.        size_t count, loff_t *ppos);
  25. static loff_t proc_file_lseek(struct file *, loff_t, int);
  27. int proc_match(int len, const char *name,struct proc_dir_entry * de)
  28. {
  29. if (!de || !de->low_ino)
  30. return 0;
  31. if (de->namelen != len)
  32. return 0;
  33. return !memcmp(name, de->name, len);
  34. }
  36. static struct file_operations proc_file_operations = {
  37. llseek: proc_file_lseek,
  38. read: proc_file_read,
  39. write: proc_file_write,
  40. };
  42. #ifndef MIN
  43. #define MIN(a,b) (((a) < (b)) ? (a) : (b))
  44. #endif
  46. /* buffer size is one page but our output routines use some slack for overruns */
  47. #define PROC_BLOCK_SIZE (PAGE_SIZE - 1024)
  49. static ssize_t
  50. proc_file_read(struct file * file, char * buf, size_t nbytes, loff_t *ppos)
  51. {
  52. struct inode * inode = file->f_dentry->d_inode;
  53. char  *page;
  54. ssize_t retval=0;
  55. int eof=0;
  56. ssize_t n, count;
  57. char *start;
  58. struct proc_dir_entry * dp;
  60. dp = (struct proc_dir_entry *) inode->u.generic_ip;
  61. if (!(page = (char*) __get_free_page(GFP_KERNEL)))
  62. return -ENOMEM;
  64. while ((nbytes > 0) && !eof)
  65. {
  66. count = MIN(PROC_BLOCK_SIZE, nbytes);
  68. start = NULL;
  69. if (dp->get_info) {
  70. /*
  71.  * Handle backwards compatibility with the old net
  72.  * routines.
  73.  */
  74. n = dp->get_info(page, &start, *ppos, count);
  75. if (n < count)
  76. eof = 1;
  77. } else if (dp->read_proc) {
  78. n = dp->read_proc(page, &start, *ppos,
  79.   count, &eof, dp->data);
  80. } else
  81. break;
  83. if (!start) {
  84. /*
  85.  * For proc files that are less than 4k
  86.  */
  87. start = page + *ppos;
  88. n -= *ppos;
  89. if (n <= 0)
  90. break;
  91. if (n > count)
  92. n = count;
  93. }
  94. if (n == 0)
  95. break; /* End of file */
  96. if (n < 0) {
  97. if (retval == 0)
  98. retval = n;
  99. break;
  100. }
  102. /* This is a hack to allow mangling of file pos independent
  103.    * of actual bytes read.  Simply place the data at page,
  104.    * return the bytes, and set `start' to the desired offset
  105.    * as an unsigned int. - Paul.Russell@rustcorp.com.au
  106.  */
  107.   n -= copy_to_user(buf, start < page ? page : start, n);
  108. if (n == 0) {
  109. if (retval == 0)
  110. retval = -EFAULT;
  111. break;
  112. }
  114. *ppos += start < page ? (long)start : n; /* Move down the file */
  115. nbytes -= n;
  116. buf += n;
  117. retval += n;
  118. }
  119. free_page((unsigned long) page);
  120. return retval;
  121. }
  123. static ssize_t
  124. proc_file_write(struct file * file, const char * buffer,
  125. size_t count, loff_t *ppos)
  126. {
  127. struct inode *inode = file->f_dentry->d_inode;
  128. struct proc_dir_entry * dp;
  130. dp = (struct proc_dir_entry *) inode->u.generic_ip;
  132. if (!dp->write_proc)
  133. return -EIO;
  135. /* FIXME: does this routine need ppos?  probably... */
  136. return dp->write_proc(file, buffer, count, dp->data);
  137. }
  140. static loff_t
  141. proc_file_lseek(struct file * file, loff_t offset, int orig)
  142. {
  143.     switch (orig) {
  144.     case 0:
  145. if (offset < 0)
  146.     return -EINVAL;    
  147. file->f_pos = offset;
  148. return(file->f_pos);
  149.     case 1:
  150. if (offset + file->f_pos < 0)
  151.     return -EINVAL;    
  152. file->f_pos += offset;
  153. return(file->f_pos);
  154.     case 2:
  155. return(-EINVAL);
  156.     default:
  157. return(-EINVAL);
  158.     }
  159. }
  161. /*
  162.  * This function parses a name such as "tty/driver/serial", and
  163.  * returns the struct proc_dir_entry for "/proc/tty/driver", and
  164.  * returns "serial" in residual.
  165.  */
  166. static int xlate_proc_name(const char *name,
  167.    struct proc_dir_entry **ret, const char **residual)
  168. {
  169. const char      *cp = name, *next;
  170. struct proc_dir_entry *de;
  171. int len;
  173. de = &proc_root;
  174. while (1) {
  175. next = strchr(cp, '/');
  176. if (!next)
  177. break;
  179. len = next - cp;
  180. for (de = de->subdir; de ; de = de->next) {
  181. if (proc_match(len, cp, de))
  182. break;
  183. }
  184. if (!de)
  185. return -ENOENT;
  186. cp += len + 1;
  187. }
  188. *residual = cp;
  189. *ret = de;
  190. return 0;
  191. }
  193. static unsigned long proc_alloc_map[(PROC_NDYNAMIC + BITS_PER_LONG - 1) / BITS_PER_LONG];
  195. spinlock_t proc_alloc_map_lock = SPIN_LOCK_UNLOCKED;
  197. static int make_inode_number(void)
  198. {
  199. int i;
  200. spin_lock(&proc_alloc_map_lock);
  201. i = find_first_zero_bit(proc_alloc_map, PROC_NDYNAMIC);
  202. if (i < 0 || i >= PROC_NDYNAMIC) {
  203. i = -1;
  204. goto out;
  205. }
  206. set_bit(i, proc_alloc_map);
  207. i += PROC_DYNAMIC_FIRST;
  208. out:
  209. spin_unlock(&proc_alloc_map_lock);
  210. return i;
  211. }
  213. static int proc_readlink(struct dentry *dentry, char *buffer, int buflen)
  214. {
  215. char *s=((struct proc_dir_entry *)dentry->d_inode->u.generic_ip)->data;
  216. return vfs_readlink(dentry, buffer, buflen, s);
  217. }
  219. static int proc_follow_link(struct dentry *dentry, struct nameidata *nd)
  220. {
  221. char *s=((struct proc_dir_entry *)dentry->d_inode->u.generic_ip)->data;
  222. return vfs_follow_link(nd, s);
  223. }
  225. static struct inode_operations proc_link_inode_operations = {
  226. readlink: proc_readlink,
  227. follow_link: proc_follow_link,
  228. };
  230. /*
  231.  * As some entries in /proc are volatile, we want to 
  232.  * get rid of unused dentries.  This could be made 
  233.  * smarter: we could keep a "volatile" flag in the 
  234.  * inode to indicate which ones to keep.
  235.  */
  236. static int proc_delete_dentry(struct dentry * dentry)
  237. {
  238. return 1;
  239. }
  241. static struct dentry_operations proc_dentry_operations =
  242. {
  243. d_delete: proc_delete_dentry,
  244. };
  246. /*
  247.  * Don't create negative dentries here, return -ENOENT by hand
  248.  * instead.
  249.  */
  250. struct dentry *proc_lookup(struct inode * dir, struct dentry *dentry)
  251. {
  252. struct inode *inode;
  253. struct proc_dir_entry * de;
  254. int error;
  256. error = -ENOENT;
  257. inode = NULL;
  258. de = (struct proc_dir_entry *) dir->u.generic_ip;
  259. if (de) {
  260. for (de = de->subdir; de ; de = de->next) {
  261. if (!de || !de->low_ino)
  262. continue;
  263. if (de->namelen != dentry->d_name.len)
  264. continue;
  265. if (!memcmp(dentry->d_name.name, de->name, de->namelen)) {
  266. int ino = de->low_ino;
  267. error = -EINVAL;
  268. inode = proc_get_inode(dir->i_sb, ino, de);
  269. break;
  270. }
  271. }
  272. }
  274. if (inode) {
  275. dentry->d_op = &proc_dentry_operations;
  276. d_add(dentry, inode);
  277. return NULL;
  278. }
  279. return ERR_PTR(error);
  280. }
  282. /*
  283.  * This returns non-zero if at EOF, so that the /proc
  284.  * root directory can use this and check if it should
  285.  * continue with the <pid> entries..
  286.  *
  287.  * Note that the VFS-layer doesn't care about the return
  288.  * value of the readdir() call, as long as it's non-negative
  289.  * for success..
  290.  */
  291. int proc_readdir(struct file * filp,
  292. void * dirent, filldir_t filldir)
  293. {
  294. struct proc_dir_entry * de;
  295. unsigned int ino;
  296. int i;
  297. struct inode *inode = filp->f_dentry->d_inode;
  299. ino = inode->i_ino;
  300. de = (struct proc_dir_entry *) inode->u.generic_ip;
  301. if (!de)
  302. return -EINVAL;
  303. i = filp->f_pos;
  304. switch (i) {
  305. case 0:
  306. if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
  307. return 0;
  308. i++;
  309. filp->f_pos++;
  310. /* fall through */
  311. case 1:
  312. if (filldir(dirent, "..", 2, i,
  313.     filp->f_dentry->d_parent->d_inode->i_ino,
  314.     DT_DIR) < 0)
  315. return 0;
  316. i++;
  317. filp->f_pos++;
  318. /* fall through */
  319. default:
  320. de = de->subdir;
  321. i -= 2;
  322. for (;;) {
  323. if (!de)
  324. return 1;
  325. if (!i)
  326. break;
  327. de = de->next;
  328. i--;
  329. }
  331. do {
  332. if (filldir(dirent, de->name, de->namelen, filp->f_pos,
  333.     de->low_ino, de->mode >> 12) < 0)
  334. return 0;
  335. filp->f_pos++;
  336. de = de->next;
  337. } while (de);
  338. }
  339. return 1;
  340. }
  342. /*
  343.  * These are the generic /proc directory operations. They
  344.  * use the in-memory "struct proc_dir_entry" tree to parse
  345.  * the /proc directory.
  346.  */
  347. static struct file_operations proc_dir_operations = {
  348. read: generic_read_dir,
  349. readdir: proc_readdir,
  350. };
  352. /*
  353.  * proc directories can do almost nothing..
  354.  */
  355. static struct inode_operations proc_dir_inode_operations = {
  356. lookup: proc_lookup,
  357. };
  359. static int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp)
  360. {
  361. int i;
  363. i = make_inode_number();
  364. if (i < 0)
  365. return -EAGAIN;
  366. dp->low_ino = i;
  367. dp->next = dir->subdir;
  368. dp->parent = dir;
  369. dir->subdir = dp;
  370. if (S_ISDIR(dp->mode)) {
  371. if (dp->proc_iops == NULL) {
  372. dp->proc_fops = &proc_dir_operations;
  373. dp->proc_iops = &proc_dir_inode_operations;
  374. }
  375. dir->nlink++;
  376. } else if (S_ISLNK(dp->mode)) {
  377. if (dp->proc_iops == NULL)
  378. dp->proc_iops = &proc_link_inode_operations;
  379. } else if (S_ISREG(dp->mode)) {
  380. if (dp->proc_fops == NULL)
  381. dp->proc_fops = &proc_file_operations;
  382. }
  383. return 0;
  384. }
  386. /*
  387.  * Kill an inode that got unregistered..
  388.  */
  389. static void proc_kill_inodes(struct proc_dir_entry *de)
  390. {
  391. struct list_head *p;
  392. struct super_block *sb = proc_mnt->mnt_sb;
  394. /*
  395.  * Actually it's a partial revoke().
  396.  */
  397. file_list_lock();
  398. for (p = sb->s_files.next; p != &sb->s_files; p = p->next) {
  399. struct file * filp = list_entry(p, struct file, f_list);
  400. struct dentry * dentry = filp->f_dentry;
  401. struct inode * inode;
  402. struct file_operations *fops;
  404. if (dentry->d_op != &proc_dentry_operations)
  405. continue;
  406. inode = dentry->d_inode;
  407. if (inode->u.generic_ip != de)
  408. continue;
  409. fops = filp->f_op;
  410. filp->f_op = NULL;
  411. fops_put(fops);
  412. }
  413. file_list_unlock();
  414. }
  416. static struct proc_dir_entry *proc_create(struct proc_dir_entry **parent,
  417.   const char *name,
  418.   mode_t mode,
  419.   nlink_t nlink)
  420. {
  421. struct proc_dir_entry *ent = NULL;
  422. const char *fn = name;
  423. int len;
  425. /* make sure name is valid */
  426. if (!name || !strlen(name)) goto out;
  428. if (!(*parent) && xlate_proc_name(name, parent, &fn) != 0)
  429. goto out;
  430. len = strlen(fn);
  432. ent = kmalloc(sizeof(struct proc_dir_entry) + len + 1, GFP_KERNEL);
  433. if (!ent) goto out;
  435. memset(ent, 0, sizeof(struct proc_dir_entry));
  436. memcpy(((char *) ent) + sizeof(struct proc_dir_entry), fn, len + 1);
  437. ent->name = ((char *) ent) + sizeof(*ent);
  438. ent->namelen = len;
  439. ent->mode = mode;
  440. ent->nlink = nlink;
  441.  out:
  442. return ent;
  443. }
  445. struct proc_dir_entry *proc_symlink(const char *name,
  446. struct proc_dir_entry *parent, const char *dest)
  447. {
  448. struct proc_dir_entry *ent;
  450. ent = proc_create(&parent,name,
  451.   (S_IFLNK | S_IRUGO | S_IWUGO | S_IXUGO),1);
  453. if (ent) {
  454. ent->data = kmalloc((ent->size=strlen(dest))+1, GFP_KERNEL);
  455. if (ent->data) {
  456. strcpy((char*)ent->data,dest);
  457. proc_register(parent, ent);
  458. } else {
  459. kfree(ent);
  460. ent = NULL;
  461. }
  462. }
  463. return ent;
  464. }
  466. struct proc_dir_entry *proc_mknod(const char *name, mode_t mode,
  467. struct proc_dir_entry *parent, kdev_t rdev)
  468. {
  469. struct proc_dir_entry *ent;
  471. ent = proc_create(&parent,name,mode,1);
  472. if (ent) {
  473. ent->rdev = rdev;
  474. proc_register(parent, ent);
  475. }
  476. return ent;
  477. }
  479. struct proc_dir_entry *proc_mkdir(const char *name, struct proc_dir_entry *parent)
  480. {
  481. struct proc_dir_entry *ent;
  483. ent = proc_create(&parent,name,
  484.   (S_IFDIR | S_IRUGO | S_IXUGO),2);
  485. if (ent) {
  486. ent->proc_fops = &proc_dir_operations;
  487. ent->proc_iops = &proc_dir_inode_operations;
  489. proc_register(parent, ent);
  490. }
  491. return ent;
  492. }
  494. struct proc_dir_entry *create_proc_entry(const char *name, mode_t mode,
  495.  struct proc_dir_entry *parent)
  496. {
  497. struct proc_dir_entry *ent;
  498. nlink_t nlink;
  500. if (S_ISDIR(mode)) {
  501. if ((mode & S_IALLUGO) == 0)
  502. mode |= S_IRUGO | S_IXUGO;
  503. nlink = 2;
  504. } else {
  505. if ((mode & S_IFMT) == 0)
  506. mode |= S_IFREG;
  507. if ((mode & S_IALLUGO) == 0)
  508. mode |= S_IRUGO;
  509. nlink = 1;
  510. }
  512. ent = proc_create(&parent,name,mode,nlink);
  513. if (ent) {
  514. if (S_ISDIR(mode)) {
  515. ent->proc_fops = &proc_dir_operations;
  516. ent->proc_iops = &proc_dir_inode_operations;
  517. }
  518. proc_register(parent, ent);
  519. }
  520. return ent;
  521. }
  523. void free_proc_entry(struct proc_dir_entry *de)
  524. {
  525. int ino = de->low_ino;
  527. if (ino < PROC_DYNAMIC_FIRST ||
  528.     ino >= PROC_DYNAMIC_FIRST+PROC_NDYNAMIC)
  529. return;
  530. if (S_ISLNK(de->mode) && de->data)
  531. kfree(de->data);
  532. kfree(de);
  533. }
  535. /*
  536.  * Remove a /proc entry and free it if it's not currently in use.
  537.  * If it is in use, we set the 'deleted' flag.
  538.  */
  539. void remove_proc_entry(const char *name, struct proc_dir_entry *parent)
  540. {
  541. struct proc_dir_entry **p;
  542. struct proc_dir_entry *de;
  543. const char *fn = name;
  544. int len;
  546. if (!parent && xlate_proc_name(name, &parent, &fn) != 0)
  547. goto out;
  548. len = strlen(fn);
  549. for (p = &parent->subdir; *p; p=&(*p)->next ) {
  550. if (!proc_match(len, fn, *p))
  551. continue;
  552. de = *p;
  553. *p = de->next;
  554. de->next = NULL;
  555. if (S_ISDIR(de->mode))
  556. parent->nlink--;
  557. clear_bit(de->low_ino - PROC_DYNAMIC_FIRST,
  558.   proc_alloc_map);
  559. proc_kill_inodes(de);
  560. de->nlink = 0;
  561. if (!atomic_read(&de->count))
  562. free_proc_entry(de);
  563. else {
  564. de->deleted = 1;
  565. printk("remove_proc_entry: %s/%s busy, count=%dn",
  566. parent->name, de->name, atomic_read(&de->count));
  567. }
  568. break;
  569. }
  570. out:
  571. return;
  572. }