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

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

嵌入式Linux

开发平台：

Unix_Linux

base.c：源码内容
  1. /*
  2.  *  linux/fs/proc/base.c
  3.  *
  4.  *  Copyright (C) 1991, 1992 Linus Torvalds
  5.  *
  6.  *  proc base directory handling functions
  7.  *
  8.  *  1999, Al Viro. Rewritten. Now it covers the whole per-process part.
  9.  *  Instead of using magical inumbers to determine the kind of object
  10.  *  we allocate and fill in-core inodes upon lookup. They don't even
  11.  *  go into icache. We cache the reference to task_struct upon lookup too.
  12.  *  Eventually it should become a filesystem in its own. We don't use the
  13.  *  rest of procfs anymore.
  14.  */
  16. #include <asm/uaccess.h>
  18. #include <linux/config.h>
  19. #include <linux/errno.h>
  20. #include <linux/sched.h>
  21. #include <linux/proc_fs.h>
  22. #include <linux/stat.h>
  23. #include <linux/init.h>
  24. #include <linux/file.h>
  25. #include <linux/string.h>
  27. /*
  28.  * For hysterical raisins we keep the same inumbers as in the old procfs.
  29.  * Feel free to change the macro below - just keep the range distinct from
  30.  * inumbers of the rest of procfs (currently those are in 0x0000--0xffff).
  31.  * As soon as we'll get a separate superblock we will be able to forget
  32.  * about magical ranges too.
  33.  */
  35. #define fake_ino(pid,ino) (((pid)<<16)|(ino))
  37. ssize_t proc_pid_read_maps(struct task_struct*,struct file*,char*,size_t,loff_t*);
  38. int proc_pid_stat(struct task_struct*,char*);
  39. int proc_pid_status(struct task_struct*,char*);
  40. int proc_pid_statm(struct task_struct*,char*);
  41. int proc_pid_cpu(struct task_struct*,char*);
  43. static int proc_fd_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt)
  44. {
  45. if (inode->u.proc_i.file) {
  46. *mnt = mntget(inode->u.proc_i.file->f_vfsmnt);
  47. *dentry = dget(inode->u.proc_i.file->f_dentry);
  48. return 0;
  49. }
  50. return -ENOENT;
  51. }
  53. static int proc_exe_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt)
  54. {
  55. struct mm_struct * mm;
  56. struct vm_area_struct * vma;
  57. int result = -ENOENT;
  58. struct task_struct *task = inode->u.proc_i.task;
  60. task_lock(task);
  61. mm = task->mm;
  62. if (mm)
  63. atomic_inc(&mm->mm_users);
  64. task_unlock(task);
  65. if (!mm)
  66. goto out;
  67. down_read(&mm->mmap_sem);
  68. vma = mm->mmap;
  69. while (vma) {
  70. if ((vma->vm_flags & VM_EXECUTABLE) && 
  71.     vma->vm_file) {
  72. *mnt = mntget(vma->vm_file->f_vfsmnt);
  73. *dentry = dget(vma->vm_file->f_dentry);
  74. result = 0;
  75. break;
  76. }
  77. vma = vma->vm_next;
  78. }
  79. up_read(&mm->mmap_sem);
  80. mmput(mm);
  81. out:
  82. return result;
  83. }
  85. static int proc_cwd_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt)
  86. {
  87. struct fs_struct *fs;
  88. int result = -ENOENT;
  89. task_lock(inode->u.proc_i.task);
  90. fs = inode->u.proc_i.task->fs;
  91. if(fs)
  92. atomic_inc(&fs->count);
  93. task_unlock(inode->u.proc_i.task);
  94. if (fs) {
  95. read_lock(&fs->lock);
  96. *mnt = mntget(fs->pwdmnt);
  97. *dentry = dget(fs->pwd);
  98. read_unlock(&fs->lock);
  99. result = 0;
  100. put_fs_struct(fs);
  101. }
  102. return result;
  103. }
  105. static int proc_root_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt)
  106. {
  107. struct fs_struct *fs;
  108. int result = -ENOENT;
  109. task_lock(inode->u.proc_i.task);
  110. fs = inode->u.proc_i.task->fs;
  111. if(fs)
  112. atomic_inc(&fs->count);
  113. task_unlock(inode->u.proc_i.task);
  114. if (fs) {
  115. read_lock(&fs->lock);
  116. *mnt = mntget(fs->rootmnt);
  117. *dentry = dget(fs->root);
  118. read_unlock(&fs->lock);
  119. result = 0;
  120. put_fs_struct(fs);
  121. }
  122. return result;
  123. }
  125. static int proc_pid_environ(struct task_struct *task, char * buffer)
  126. {
  127. struct mm_struct *mm;
  128. int res = 0;
  129. task_lock(task);
  130. mm = task->mm;
  131. if (mm)
  132. atomic_inc(&mm->mm_users);
  133. task_unlock(task);
  134. if (mm) {
  135. int len = mm->env_end - mm->env_start;
  136. if (len > PAGE_SIZE)
  137. len = PAGE_SIZE;
  138. res = access_process_vm(task, mm->env_start, buffer, len, 0);
  139. mmput(mm);
  140. }
  141. return res;
  142. }
  144. static int proc_pid_cmdline(struct task_struct *task, char * buffer)
  145. {
  146. struct mm_struct *mm;
  147. int res = 0;
  148. task_lock(task);
  149. mm = task->mm;
  150. if (mm)
  151. atomic_inc(&mm->mm_users);
  152. task_unlock(task);
  153. if (mm) {
  154. int len = mm->arg_end - mm->arg_start;
  155. if (len > PAGE_SIZE)
  156. len = PAGE_SIZE;
  157. res = access_process_vm(task, mm->arg_start, buffer, len, 0);
  158. // If the nul at the end of args has been overwritten, then
  159. // assume application is using setproctitle(3).
  160. if ( res > 0 && buffer[res-1] != '' )
  161. {
  162. len = strnlen( buffer, res );
  163. if ( len < res )
  164. {
  165.     res = len;
  166. }
  167. else
  168. {
  169. len = mm->env_end - mm->env_start;
  170. if (len > PAGE_SIZE - res)
  171. len = PAGE_SIZE - res;
  172. res += access_process_vm(task, mm->env_start, buffer+res, len, 0);
  173. res = strnlen( buffer, res );
  174. }
  175. }
  176. mmput(mm);
  177. }
  178. return res;
  179. }
  181. /************************************************************************/
  182. /*                       Here the fs part begins                        */
  183. /************************************************************************/
  185. /* permission checks */
  187. static int proc_check_root(struct inode *inode)
  188. {
  189. struct dentry *de, *base, *root;
  190. struct vfsmount *our_vfsmnt, *vfsmnt, *mnt;
  191. int res = 0;
  193. if (proc_root_link(inode, &root, &vfsmnt)) /* Ewww... */
  194. return -ENOENT;
  195. read_lock(&current->fs->lock);
  196. our_vfsmnt = mntget(current->fs->rootmnt);
  197. base = dget(current->fs->root);
  198. read_unlock(&current->fs->lock);
  200. spin_lock(&dcache_lock);
  201. de = root;
  202. mnt = vfsmnt;
  204. while (vfsmnt != our_vfsmnt) {
  205. if (vfsmnt == vfsmnt->mnt_parent)
  206. goto out;
  207. de = vfsmnt->mnt_mountpoint;
  208. vfsmnt = vfsmnt->mnt_parent;
  209. }
  211. if (!is_subdir(de, base))
  212. goto out;
  213. spin_unlock(&dcache_lock);
  215. exit:
  216. dput(base);
  217. mntput(our_vfsmnt);
  218. dput(root);
  219. mntput(mnt);
  220. return res;
  221. out:
  222. spin_unlock(&dcache_lock);
  223. res = -EACCES;
  224. goto exit;
  225. }
  227. static int proc_permission(struct inode *inode, int mask)
  228. {
  229. if (vfs_permission(inode, mask) != 0)
  230. return -EACCES;
  231. return proc_check_root(inode);
  232. }
  234. static ssize_t pid_maps_read(struct file * file, char * buf,
  235.       size_t count, loff_t *ppos)
  236. {
  237. struct inode * inode = file->f_dentry->d_inode;
  238. struct task_struct *task = inode->u.proc_i.task;
  239. ssize_t res;
  241. res = proc_pid_read_maps(task, file, buf, count, ppos);
  242. return res;
  243. }
  245. static struct file_operations proc_maps_operations = {
  246. read: pid_maps_read,
  247. };
  249. #define PROC_BLOCK_SIZE (3*1024) /* 4K page size but our output routines use some slack for overruns */
  251. static ssize_t proc_info_read(struct file * file, char * buf,
  252.   size_t count, loff_t *ppos)
  253. {
  254. struct inode * inode = file->f_dentry->d_inode;
  255. unsigned long page;
  256. ssize_t length;
  257. ssize_t end;
  258. struct task_struct *task = inode->u.proc_i.task;
  260. if (count > PROC_BLOCK_SIZE)
  261. count = PROC_BLOCK_SIZE;
  262. if (!(page = __get_free_page(GFP_KERNEL)))
  263. return -ENOMEM;
  265. length = inode->u.proc_i.op.proc_read(task, (char*)page);
  267. if (length < 0) {
  268. free_page(page);
  269. return length;
  270. }
  271. /* Static 4kB (or whatever) block capacity */
  272. if (*ppos >= length) {
  273. free_page(page);
  274. return 0;
  275. }
  276. if (count + *ppos > length)
  277. count = length - *ppos;
  278. end = count + *ppos;
  279. copy_to_user(buf, (char *) page + *ppos, count);
  280. *ppos = end;
  281. free_page(page);
  282. return count;
  283. }
  285. static struct file_operations proc_info_file_operations = {
  286. read: proc_info_read,
  287. };
  289. #define MAY_PTRACE(p) 
  290. (p==current||(p->p_pptr==current&&(p->ptrace & PT_PTRACED)&&p->state==TASK_STOPPED))
  293. static int mem_open(struct inode* inode, struct file* file)
  294. {
  295. file->private_data = (void*)((long)current->self_exec_id);
  296. return 0;
  297. }
  299. static ssize_t mem_read(struct file * file, char * buf,
  300. size_t count, loff_t *ppos)
  301. {
  302. struct task_struct *task = file->f_dentry->d_inode->u.proc_i.task;
  303. char *page;
  304. unsigned long src = *ppos;
  305. int copied = 0;
  306. struct mm_struct *mm;
  309. if (!MAY_PTRACE(task))
  310. return -ESRCH;
  312. page = (char *)__get_free_page(GFP_USER);
  313. if (!page)
  314. return -ENOMEM;
  316. task_lock(task);
  317. mm = task->mm;
  318. if (mm)
  319. atomic_inc(&mm->mm_users);
  320. task_unlock(task);
  321. if (!mm)
  322. return 0;
  324. if (file->private_data != (void*)((long)current->self_exec_id) ) {
  325. mmput(mm);
  326. return -EIO;
  327. }
  330. while (count > 0) {
  331. int this_len, retval;
  333. this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
  334. retval = access_process_vm(task, src, page, this_len, 0);
  335. if (!retval) {
  336. if (!copied)
  337. copied = -EIO;
  338. break;
  339. }
  340. if (copy_to_user(buf, page, retval)) {
  341. copied = -EFAULT;
  342. break;
  343. }
  344. copied += retval;
  345. src += retval;
  346. buf += retval;
  347. count -= retval;
  348. }
  349. *ppos = src;
  350. mmput(mm);
  351. free_page((unsigned long) page);
  352. return copied;
  353. }
  355. #define mem_write NULL
  357. #ifndef mem_write
  358. /* This is a security hazard */
  359. static ssize_t mem_write(struct file * file, const char * buf,
  360.  size_t count, loff_t *ppos)
  361. {
  362. int copied = 0;
  363. char *page;
  364. struct task_struct *task = file->f_dentry->d_inode->u.proc_i.task;
  365. unsigned long dst = *ppos;
  367. if (!MAY_PTRACE(task))
  368. return -ESRCH;
  370. page = (char *)__get_free_page(GFP_USER);
  371. if (!page)
  372. return -ENOMEM;
  374. while (count > 0) {
  375. int this_len, retval;
  377. this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
  378. if (copy_from_user(page, buf, this_len)) {
  379. copied = -EFAULT;
  380. break;
  381. }
  382. retval = access_process_vm(task, dst, page, this_len, 1);
  383. if (!retval) {
  384. if (!copied)
  385. copied = -EIO;
  386. break;
  387. }
  388. copied += retval;
  389. buf += retval;
  390. dst += retval;
  391. count -= retval;
  392. }
  393. *ppos = dst;
  394. free_page((unsigned long) page);
  395. return copied;
  396. }
  397. #endif
  399. static struct file_operations proc_mem_operations = {
  400. read: mem_read,
  401. write: mem_write,
  402. open: mem_open,
  403. };
  405. static struct inode_operations proc_mem_inode_operations = {
  406. permission: proc_permission,
  407. };
  409. static int proc_pid_follow_link(struct dentry *dentry, struct nameidata *nd)
  410. {
  411. struct inode *inode = dentry->d_inode;
  412. int error = -EACCES;
  414. /* We don't need a base pointer in the /proc filesystem */
  415. path_release(nd);
  417. if (current->fsuid != inode->i_uid && !capable(CAP_DAC_OVERRIDE))
  418. goto out;
  419. error = proc_check_root(inode);
  420. if (error)
  421. goto out;
  423. error = inode->u.proc_i.op.proc_get_link(inode, &nd->dentry, &nd->mnt);
  424. nd->last_type = LAST_BIND;
  425. out:
  426. return error;
  427. }
  429. static int do_proc_readlink(struct dentry *dentry, struct vfsmount *mnt,
  430.     char * buffer, int buflen)
  431. {
  432. struct inode * inode;
  433. char * tmp = (char*)__get_free_page(GFP_KERNEL), *path;
  434. int len;
  436. if (!tmp)
  437. return -ENOMEM;
  439. inode = dentry->d_inode;
  440. path = d_path(dentry, mnt, tmp, PAGE_SIZE);
  441. len = tmp + PAGE_SIZE - 1 - path;
  443. if (len < buflen)
  444. buflen = len;
  445. copy_to_user(buffer, path, buflen);
  446. free_page((unsigned long)tmp);
  447. return buflen;
  448. }
  450. static int proc_pid_readlink(struct dentry * dentry, char * buffer, int buflen)
  451. {
  452. int error = -EACCES;
  453. struct inode *inode = dentry->d_inode;
  454. struct dentry *de;
  455. struct vfsmount *mnt = NULL;
  457. if (current->fsuid != inode->i_uid && !capable(CAP_DAC_OVERRIDE))
  458. goto out;
  459. error = proc_check_root(inode);
  460. if (error)
  461. goto out;
  463. error = inode->u.proc_i.op.proc_get_link(inode, &de, &mnt);
  464. if (error)
  465. goto out;
  467. error = do_proc_readlink(de, mnt, buffer, buflen);
  468. dput(de);
  469. mntput(mnt);
  470. out:
  471. return error;
  472. }
  474. static struct inode_operations proc_pid_link_inode_operations = {
  475. readlink: proc_pid_readlink,
  476. follow_link: proc_pid_follow_link
  477. };
  479. struct pid_entry {
  480. int type;
  481. int len;
  482. char *name;
  483. mode_t mode;
  484. };
  486. enum pid_directory_inos {
  487. PROC_PID_INO = 2,
  488. PROC_PID_STATUS,
  489. PROC_PID_MEM,
  490. PROC_PID_CWD,
  491. PROC_PID_ROOT,
  492. PROC_PID_EXE,
  493. PROC_PID_FD,
  494. PROC_PID_ENVIRON,
  495. PROC_PID_CMDLINE,
  496. PROC_PID_STAT,
  497. PROC_PID_STATM,
  498. PROC_PID_MAPS,
  499. PROC_PID_CPU,
  500. PROC_PID_FD_DIR = 0x8000, /* 0x8000-0xffff */
  501. };
  503. #define E(type,name,mode) {(type),sizeof(name)-1,(name),(mode)}
  504. static struct pid_entry base_stuff[] = {
  505.   E(PROC_PID_FD, "fd", S_IFDIR|S_IRUSR|S_IXUSR),
  506.   E(PROC_PID_ENVIRON, "environ", S_IFREG|S_IRUSR),
  507.   E(PROC_PID_STATUS, "status", S_IFREG|S_IRUGO),
  508.   E(PROC_PID_CMDLINE, "cmdline", S_IFREG|S_IRUGO),
  509.   E(PROC_PID_STAT, "stat", S_IFREG|S_IRUGO),
  510.   E(PROC_PID_STATM, "statm", S_IFREG|S_IRUGO),
  511. #ifdef CONFIG_SMP
  512.   E(PROC_PID_CPU, "cpu", S_IFREG|S_IRUGO),
  513. #endif
  514.   E(PROC_PID_MAPS, "maps", S_IFREG|S_IRUGO),
  515.   E(PROC_PID_MEM, "mem", S_IFREG|S_IRUSR|S_IWUSR),
  516.   E(PROC_PID_CWD, "cwd", S_IFLNK|S_IRWXUGO),
  517.   E(PROC_PID_ROOT, "root", S_IFLNK|S_IRWXUGO),
  518.   E(PROC_PID_EXE, "exe", S_IFLNK|S_IRWXUGO),
  519.   {0,0,NULL,0}
  520. };
  521. #undef E
  523. #define NUMBUF 10
  525. static int proc_readfd(struct file * filp, void * dirent, filldir_t filldir)
  526. {
  527. struct inode *inode = filp->f_dentry->d_inode;
  528. struct task_struct *p = inode->u.proc_i.task;
  529. unsigned int fd, pid, ino;
  530. int retval;
  531. char buf[NUMBUF];
  532. struct files_struct * files;
  534. retval = 0;
  535. pid = p->pid;
  537. fd = filp->f_pos;
  538. switch (fd) {
  539. case 0:
  540. if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR) < 0)
  541. goto out;
  542. filp->f_pos++;
  543. case 1:
  544. ino = fake_ino(pid, PROC_PID_INO);
  545. if (filldir(dirent, "..", 2, 1, ino, DT_DIR) < 0)
  546. goto out;
  547. filp->f_pos++;
  548. default:
  549. task_lock(p);
  550. files = p->files;
  551. if (files)
  552. atomic_inc(&files->count);
  553. task_unlock(p);
  554. if (!files)
  555. goto out;
  556. read_lock(&files->file_lock);
  557. for (fd = filp->f_pos-2;
  558.      fd < files->max_fds;
  559.      fd++, filp->f_pos++) {
  560. unsigned int i,j;
  562. if (!fcheck_files(files, fd))
  563. continue;
  564. read_unlock(&files->file_lock);
  566. j = NUMBUF;
  567. i = fd;
  568. do {
  569. j--;
  570. buf[j] = '0' + (i % 10);
  571. i /= 10;
  572. } while (i);
  574. ino = fake_ino(pid, PROC_PID_FD_DIR + fd);
  575. if (filldir(dirent, buf+j, NUMBUF-j, fd+2, ino, DT_LNK) < 0) {
  576. read_lock(&files->file_lock);
  577. break;
  578. }
  579. read_lock(&files->file_lock);
  580. }
  581. read_unlock(&files->file_lock);
  582. put_files_struct(files);
  583. }
  584. out:
  585. return retval;
  586. }
  588. static int proc_base_readdir(struct file * filp,
  589. void * dirent, filldir_t filldir)
  590. {
  591. int i;
  592. int pid;
  593. struct inode *inode = filp->f_dentry->d_inode;
  594. struct pid_entry *p;
  596. pid = inode->u.proc_i.task->pid;
  597. if (!pid)
  598. return -ENOENT;
  599. i = filp->f_pos;
  600. switch (i) {
  601. case 0:
  602. if (filldir(dirent, ".", 1, i, inode->i_ino, DT_DIR) < 0)
  603. return 0;
  604. i++;
  605. filp->f_pos++;
  606. /* fall through */
  607. case 1:
  608. if (filldir(dirent, "..", 2, i, PROC_ROOT_INO, DT_DIR) < 0)
  609. return 0;
  610. i++;
  611. filp->f_pos++;
  612. /* fall through */
  613. default:
  614. i -= 2;
  615. if (i>=sizeof(base_stuff)/sizeof(base_stuff[0]))
  616. return 1;
  617. p = base_stuff + i;
  618. while (p->name) {
  619. if (filldir(dirent, p->name, p->len, filp->f_pos,
  620.     fake_ino(pid, p->type), p->mode >> 12) < 0)
  621. return 0;
  622. filp->f_pos++;
  623. p++;
  624. }
  625. }
  626. return 1;
  627. }
  629. /* building an inode */
  631. static int task_dumpable(struct task_struct *task)
  632. {
  633. int dumpable = 0;
  634. struct mm_struct *mm;
  636. task_lock(task);
  637. mm = task->mm;
  638. if (mm)
  639. dumpable = mm->dumpable;
  640. task_unlock(task);
  641. return dumpable;
  642. }
  645. static struct inode *proc_pid_make_inode(struct super_block * sb, struct task_struct *task, int ino)
  646. {
  647. struct inode * inode;
  649. /* We need a new inode */
  651. inode = new_inode(sb);
  652. if (!inode)
  653. goto out;
  655. /* Common stuff */
  657. inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
  658. inode->i_ino = fake_ino(task->pid, ino);
  660. if (!task->pid)
  661. goto out_unlock;
  663. /*
  664.  * grab the reference to task.
  665.  */
  666. get_task_struct(task);
  667. inode->u.proc_i.task = task;
  668. inode->i_uid = 0;
  669. inode->i_gid = 0;
  670. if (ino == PROC_PID_INO || task_dumpable(task)) {
  671. inode->i_uid = task->euid;
  672. inode->i_gid = task->egid;
  673. }
  675. out:
  676. return inode;
  678. out_unlock:
  679. iput(inode);
  680. return NULL;
  681. }
  683. /* dentry stuff */
  685. static int pid_fd_revalidate(struct dentry * dentry, int flags)
  686. {
  687. return 0;
  688. }
  690. /*
  691.  * Exceptional case: normally we are not allowed to unhash a busy
  692.  * directory. In this case, however, we can do it - no aliasing problems
  693.  * due to the way we treat inodes.
  694.  */
  695. static int pid_base_revalidate(struct dentry * dentry, int flags)
  696. {
  697. if (dentry->d_inode->u.proc_i.task->pid)
  698. return 1;
  699. d_drop(dentry);
  700. return 0;
  701. }
  703. static int pid_delete_dentry(struct dentry * dentry)
  704. {
  705. return 1;
  706. }
  708. static struct dentry_operations pid_fd_dentry_operations =
  709. {
  710. d_revalidate: pid_fd_revalidate,
  711. d_delete: pid_delete_dentry,
  712. };
  714. static struct dentry_operations pid_dentry_operations =
  715. {
  716. d_delete: pid_delete_dentry,
  717. };
  719. static struct dentry_operations pid_base_dentry_operations =
  720. {
  721. d_revalidate: pid_base_revalidate,
  722. d_delete: pid_delete_dentry,
  723. };
  725. /* Lookups */
  726. #define MAX_MULBY10 ((~0U-9)/10)
  728. static struct dentry *proc_lookupfd(struct inode * dir, struct dentry * dentry)
  729. {
  730. unsigned int fd, c;
  731. struct task_struct *task = dir->u.proc_i.task;
  732. struct file * file;
  733. struct files_struct * files;
  734. struct inode *inode;
  735. const char *name;
  736. int len;
  738. fd = 0;
  739. len = dentry->d_name.len;
  740. name = dentry->d_name.name;
  741. if (len > 1 && *name == '0') goto out;
  742. while (len-- > 0) {
  743. c = *name - '0';
  744. name++;
  745. if (c > 9)
  746. goto out;
  747. if (fd >= MAX_MULBY10)
  748. goto out;
  749. fd *= 10;
  750. fd += c;
  751. }
  753. inode = proc_pid_make_inode(dir->i_sb, task, PROC_PID_FD_DIR+fd);
  754. if (!inode)
  755. goto out;
  756. task_lock(task);
  757. files = task->files;
  758. if (files)
  759. atomic_inc(&files->count);
  760. task_unlock(task);
  761. if (!files)
  762. goto out_unlock;
  763. read_lock(&files->file_lock);
  764. file = inode->u.proc_i.file = fcheck_files(files, fd);
  765. if (!file)
  766. goto out_unlock2;
  767. get_file(file);
  768. read_unlock(&files->file_lock);
  769. put_files_struct(files);
  770. inode->i_op = &proc_pid_link_inode_operations;
  771. inode->i_size = 64;
  772. inode->i_mode = S_IFLNK;
  773. inode->u.proc_i.op.proc_get_link = proc_fd_link;
  774. if (file->f_mode & 1)
  775. inode->i_mode |= S_IRUSR | S_IXUSR;
  776. if (file->f_mode & 2)
  777. inode->i_mode |= S_IWUSR | S_IXUSR;
  778. dentry->d_op = &pid_fd_dentry_operations;
  779. d_add(dentry, inode);
  780. return NULL;
  782. out_unlock2:
  783. put_files_struct(files);
  784. read_unlock(&files->file_lock);
  785. out_unlock:
  786. iput(inode);
  787. out:
  788. return ERR_PTR(-ENOENT);
  789. }
  791. static struct file_operations proc_fd_operations = {
  792. read: generic_read_dir,
  793. readdir: proc_readfd,
  794. };
  796. /*
  797.  * proc directories can do almost nothing..
  798.  */
  799. static struct inode_operations proc_fd_inode_operations = {
  800. lookup: proc_lookupfd,
  801. permission: proc_permission,
  802. };
  804. static struct dentry *proc_base_lookup(struct inode *dir, struct dentry *dentry)
  805. {
  806. struct inode *inode;
  807. int error;
  808. struct task_struct *task = dir->u.proc_i.task;
  809. struct pid_entry *p;
  811. error = -ENOENT;
  812. inode = NULL;
  814. for (p = base_stuff; p->name; p++) {
  815. if (p->len != dentry->d_name.len)
  816. continue;
  817. if (!memcmp(dentry->d_name.name, p->name, p->len))
  818. break;
  819. }
  820. if (!p->name)
  821. goto out;
  823. error = -EINVAL;
  824. inode = proc_pid_make_inode(dir->i_sb, task, p->type);
  825. if (!inode)
  826. goto out;
  828. inode->i_mode = p->mode;
  829. /*
  830.  * Yes, it does not scale. And it should not. Don't add
  831.  * new entries into /proc/<pid>/ without very good reasons.
  832.  */
  833. switch(p->type) {
  834. case PROC_PID_FD:
  835. inode->i_nlink = 2;
  836. inode->i_op = &proc_fd_inode_operations;
  837. inode->i_fop = &proc_fd_operations;
  838. break;
  839. case PROC_PID_EXE:
  840. inode->i_op = &proc_pid_link_inode_operations;
  841. inode->u.proc_i.op.proc_get_link = proc_exe_link;
  842. break;
  843. case PROC_PID_CWD:
  844. inode->i_op = &proc_pid_link_inode_operations;
  845. inode->u.proc_i.op.proc_get_link = proc_cwd_link;
  846. break;
  847. case PROC_PID_ROOT:
  848. inode->i_op = &proc_pid_link_inode_operations;
  849. inode->u.proc_i.op.proc_get_link = proc_root_link;
  850. break;
  851. case PROC_PID_ENVIRON:
  852. inode->i_fop = &proc_info_file_operations;
  853. inode->u.proc_i.op.proc_read = proc_pid_environ;
  854. break;
  855. case PROC_PID_STATUS:
  856. inode->i_fop = &proc_info_file_operations;
  857. inode->u.proc_i.op.proc_read = proc_pid_status;
  858. break;
  859. case PROC_PID_STAT:
  860. inode->i_fop = &proc_info_file_operations;
  861. inode->u.proc_i.op.proc_read = proc_pid_stat;
  862. break;
  863. case PROC_PID_CMDLINE:
  864. inode->i_fop = &proc_info_file_operations;
  865. inode->u.proc_i.op.proc_read = proc_pid_cmdline;
  866. break;
  867. case PROC_PID_STATM:
  868. inode->i_fop = &proc_info_file_operations;
  869. inode->u.proc_i.op.proc_read = proc_pid_statm;
  870. break;
  871. case PROC_PID_MAPS:
  872. inode->i_fop = &proc_maps_operations;
  873. break;
  874. #ifdef CONFIG_SMP
  875. case PROC_PID_CPU:
  876. inode->i_fop = &proc_info_file_operations;
  877. inode->u.proc_i.op.proc_read = proc_pid_cpu;
  878. break;
  879. #endif
  880. case PROC_PID_MEM:
  881. inode->i_op = &proc_mem_inode_operations;
  882. inode->i_fop = &proc_mem_operations;
  883. break;
  884. default:
  885. printk("procfs: impossible type (%d)",p->type);
  886. iput(inode);
  887. return ERR_PTR(-EINVAL);
  888. }
  889. dentry->d_op = &pid_dentry_operations;
  890. d_add(dentry, inode);
  891. return NULL;
  893. out:
  894. return ERR_PTR(error);
  895. }
  897. static struct file_operations proc_base_operations = {
  898. read: generic_read_dir,
  899. readdir: proc_base_readdir,
  900. };
  902. static struct inode_operations proc_base_inode_operations = {
  903. lookup: proc_base_lookup,
  904. };
  906. /*
  907.  * /proc/self:
  908.  */
  909. static int proc_self_readlink(struct dentry *dentry, char *buffer, int buflen)
  910. {
  911. char tmp[30];
  912. sprintf(tmp, "%d", current->pid);
  913. return vfs_readlink(dentry,buffer,buflen,tmp);
  914. }
  916. static int proc_self_follow_link(struct dentry *dentry, struct nameidata *nd)
  917. {
  918. char tmp[30];
  919. sprintf(tmp, "%d", current->pid);
  920. return vfs_follow_link(nd,tmp);
  921. }
  923. static struct inode_operations proc_self_inode_operations = {
  924. readlink: proc_self_readlink,
  925. follow_link: proc_self_follow_link,
  926. };
  928. struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry)
  929. {
  930. unsigned int pid, c;
  931. struct task_struct *task;
  932. const char *name;
  933. struct inode *inode;
  934. int len;
  936. pid = 0;
  937. name = dentry->d_name.name;
  938. len = dentry->d_name.len;
  939. if (len == 4 && !memcmp(name, "self", 4)) {
  940. inode = new_inode(dir->i_sb);
  941. if (!inode)
  942. return ERR_PTR(-ENOMEM);
  943. inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
  944. inode->i_ino = fake_ino(0, PROC_PID_INO);
  945. inode->u.proc_i.file = NULL;
  946. inode->u.proc_i.task = NULL;
  947. inode->i_mode = S_IFLNK|S_IRWXUGO;
  948. inode->i_uid = inode->i_gid = 0;
  949. inode->i_size = 64;
  950. inode->i_op = &proc_self_inode_operations;
  951. d_add(dentry, inode);
  952. return NULL;
  953. }
  954. while (len-- > 0) {
  955. c = *name - '0';
  956. name++;
  957. if (c > 9)
  958. goto out;
  959. if (pid >= MAX_MULBY10)
  960. goto out;
  961. pid *= 10;
  962. pid += c;
  963. if (!pid)
  964. goto out;
  965. }
  967. read_lock(&tasklist_lock);
  968. task = find_task_by_pid(pid);
  969. if (task)
  970. get_task_struct(task);
  971. read_unlock(&tasklist_lock);
  972. if (!task)
  973. goto out;
  975. inode = proc_pid_make_inode(dir->i_sb, task, PROC_PID_INO);
  977. free_task_struct(task);
  979. if (!inode)
  980. goto out;
  981. inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO;
  982. inode->i_op = &proc_base_inode_operations;
  983. inode->i_fop = &proc_base_operations;
  984. inode->i_nlink = 3;
  985. inode->i_flags|=S_IMMUTABLE;
  987. dentry->d_op = &pid_base_dentry_operations;
  988. d_add(dentry, inode);
  989. return NULL;
  990. out:
  991. return ERR_PTR(-ENOENT);
  992. }
  994. void proc_pid_delete_inode(struct inode *inode)
  995. {
  996. if (inode->u.proc_i.file)
  997. fput(inode->u.proc_i.file);
  998. if (inode->u.proc_i.task)
  999. free_task_struct(inode->u.proc_i.task);
  1000. }
  1002. #define PROC_NUMBUF 10
  1003. #define PROC_MAXPIDS 20
  1005. /*
  1006.  * Get a few pid's to return for filldir - we need to hold the
  1007.  * tasklist lock while doing this, and we must release it before
  1008.  * we actually do the filldir itself, so we use a temp buffer..
  1009.  */
  1010. static int get_pid_list(int index, unsigned int *pids)
  1011. {
  1012. struct task_struct *p;
  1013. int nr_pids = 0;
  1015. index--;
  1016. read_lock(&tasklist_lock);
  1017. for_each_task(p) {
  1018. int pid = p->pid;
  1019. if (!pid)
  1020. continue;
  1021. if (--index >= 0)
  1022. continue;
  1023. pids[nr_pids] = pid;
  1024. nr_pids++;
  1025. if (nr_pids >= PROC_MAXPIDS)
  1026. break;
  1027. }
  1028. read_unlock(&tasklist_lock);
  1029. return nr_pids;
  1030. }
  1032. int proc_pid_readdir(struct file * filp, void * dirent, filldir_t filldir)
  1033. {
  1034. unsigned int pid_array[PROC_MAXPIDS];
  1035. char buf[PROC_NUMBUF];
  1036. unsigned int nr = filp->f_pos - FIRST_PROCESS_ENTRY;
  1037. unsigned int nr_pids, i;
  1039. if (!nr) {
  1040. ino_t ino = fake_ino(0,PROC_PID_INO);
  1041. if (filldir(dirent, "self", 4, filp->f_pos, ino, DT_LNK) < 0)
  1042. return 0;
  1043. filp->f_pos++;
  1044. nr++;
  1045. }
  1047. nr_pids = get_pid_list(nr, pid_array);
  1049. for (i = 0; i < nr_pids; i++) {
  1050. int pid = pid_array[i];
  1051. ino_t ino = fake_ino(pid,PROC_PID_INO);
  1052. unsigned long j = PROC_NUMBUF;
  1054. do buf[--j] = '0' + (pid % 10); while (pid/=10);
  1056. if (filldir(dirent, buf+j, PROC_NUMBUF-j, filp->f_pos, ino, DT_DIR) < 0)
  1057. break;
  1058. filp->f_pos++;
  1059. }
  1060. return 0;
  1061. }