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

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

Linux/Unix编程

开发平台：

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>
  26. #include <linux/seq_file.h>
  27. #include <linux/namespace.h>
  29. /*
  30.  * For hysterical raisins we keep the same inumbers as in the old procfs.
  31.  * Feel free to change the macro below - just keep the range distinct from
  32.  * inumbers of the rest of procfs (currently those are in 0x0000--0xffff).
  33.  * As soon as we'll get a separate superblock we will be able to forget
  34.  * about magical ranges too.
  35.  */
  37. #define fake_ino(pid,ino) (((pid)<<16)|(ino))
  39. ssize_t proc_pid_read_maps(struct task_struct*,struct file*,char*,size_t,loff_t*);
  40. int proc_pid_stat(struct task_struct*,char*);
  41. int proc_pid_status(struct task_struct*,char*);
  42. int proc_pid_statm(struct task_struct*,char*);
  43. int proc_pid_cpu(struct task_struct*,char*);
  45. static int proc_fd_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt)
  46. {
  47. if (inode->u.proc_i.file) {
  48. *mnt = mntget(inode->u.proc_i.file->f_vfsmnt);
  49. *dentry = dget(inode->u.proc_i.file->f_dentry);
  50. return 0;
  51. }
  52. return -ENOENT;
  53. }
  55. static int proc_exe_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt)
  56. {
  57. struct mm_struct * mm;
  58. struct vm_area_struct * vma;
  59. int result = -ENOENT;
  60. struct task_struct *task = inode->u.proc_i.task;
  62. task_lock(task);
  63. mm = task->mm;
  64. if (mm)
  65. atomic_inc(&mm->mm_users);
  66. task_unlock(task);
  67. if (!mm)
  68. goto out;
  69. down_read(&mm->mmap_sem);
  70. vma = mm->mmap;
  71. while (vma) {
  72. if ((vma->vm_flags & VM_EXECUTABLE) && 
  73.     vma->vm_file) {
  74. *mnt = mntget(vma->vm_file->f_vfsmnt);
  75. *dentry = dget(vma->vm_file->f_dentry);
  76. result = 0;
  77. break;
  78. }
  79. vma = vma->vm_next;
  80. }
  81. up_read(&mm->mmap_sem);
  82. mmput(mm);
  83. out:
  84. return result;
  85. }
  87. static int proc_cwd_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt)
  88. {
  89. struct fs_struct *fs;
  90. int result = -ENOENT;
  91. task_lock(inode->u.proc_i.task);
  92. fs = inode->u.proc_i.task->fs;
  93. if(fs)
  94. atomic_inc(&fs->count);
  95. task_unlock(inode->u.proc_i.task);
  96. if (fs) {
  97. read_lock(&fs->lock);
  98. *mnt = mntget(fs->pwdmnt);
  99. *dentry = dget(fs->pwd);
  100. read_unlock(&fs->lock);
  101. result = 0;
  102. put_fs_struct(fs);
  103. }
  104. return result;
  105. }
  107. static int proc_root_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt)
  108. {
  109. struct fs_struct *fs;
  110. int result = -ENOENT;
  111. task_lock(inode->u.proc_i.task);
  112. fs = inode->u.proc_i.task->fs;
  113. if(fs)
  114. atomic_inc(&fs->count);
  115. task_unlock(inode->u.proc_i.task);
  116. if (fs) {
  117. read_lock(&fs->lock);
  118. *mnt = mntget(fs->rootmnt);
  119. *dentry = dget(fs->root);
  120. read_unlock(&fs->lock);
  121. result = 0;
  122. put_fs_struct(fs);
  123. }
  124. return result;
  125. }
  127. static int proc_pid_environ(struct task_struct *task, char * buffer)
  128. {
  129. struct mm_struct *mm;
  130. int res = 0;
  131. task_lock(task);
  132. mm = task->mm;
  133. if (mm)
  134. atomic_inc(&mm->mm_users);
  135. task_unlock(task);
  136. if (mm) {
  137. int len = mm->env_end - mm->env_start;
  138. if (len > PAGE_SIZE)
  139. len = PAGE_SIZE;
  140. res = access_process_vm(task, mm->env_start, buffer, len, 0);
  141. mmput(mm);
  142. }
  143. return res;
  144. }
  146. static int proc_pid_cmdline(struct task_struct *task, char * buffer)
  147. {
  148. struct mm_struct *mm;
  149. int res = 0;
  150. task_lock(task);
  151. mm = task->mm;
  152. if (mm)
  153. atomic_inc(&mm->mm_users);
  154. task_unlock(task);
  155. if (mm) {
  156. int len = mm->arg_end - mm->arg_start;
  157. if (len > PAGE_SIZE)
  158. len = PAGE_SIZE;
  159. res = access_process_vm(task, mm->arg_start, buffer, len, 0);
  160. // If the nul at the end of args has been overwritten, then
  161. // assume application is using setproctitle(3).
  162. if ( res > 0 && buffer[res-1] != '' )
  163. {
  164. len = strnlen( buffer, res );
  165. if ( len < res )
  166. {
  167.     res = len;
  168. }
  169. else
  170. {
  171. len = mm->env_end - mm->env_start;
  172. if (len > PAGE_SIZE - res)
  173. len = PAGE_SIZE - res;
  174. res += access_process_vm(task, mm->env_start, buffer+res, len, 0);
  175. res = strnlen( buffer, res );
  176. }
  177. }
  178. mmput(mm);
  179. }
  180. return res;
  181. }
  183. /************************************************************************/
  184. /*                       Here the fs part begins                        */
  185. /************************************************************************/
  187. /* permission checks */
  189. static int proc_check_root(struct inode *inode)
  190. {
  191. struct dentry *de, *base, *root;
  192. struct vfsmount *our_vfsmnt, *vfsmnt, *mnt;
  193. int res = 0;
  195. if (proc_root_link(inode, &root, &vfsmnt)) /* Ewww... */
  196. return -ENOENT;
  197. read_lock(&current->fs->lock);
  198. our_vfsmnt = mntget(current->fs->rootmnt);
  199. base = dget(current->fs->root);
  200. read_unlock(&current->fs->lock);
  202. spin_lock(&dcache_lock);
  203. de = root;
  204. mnt = vfsmnt;
  206. while (vfsmnt != our_vfsmnt) {
  207. if (vfsmnt == vfsmnt->mnt_parent)
  208. goto out;
  209. de = vfsmnt->mnt_mountpoint;
  210. vfsmnt = vfsmnt->mnt_parent;
  211. }
  213. if (!is_subdir(de, base))
  214. goto out;
  215. spin_unlock(&dcache_lock);
  217. exit:
  218. dput(base);
  219. mntput(our_vfsmnt);
  220. dput(root);
  221. mntput(mnt);
  222. return res;
  223. out:
  224. spin_unlock(&dcache_lock);
  225. res = -EACCES;
  226. goto exit;
  227. }
  229. static int proc_permission(struct inode *inode, int mask)
  230. {
  231. if (vfs_permission(inode, mask) != 0)
  232. return -EACCES;
  233. return proc_check_root(inode);
  234. }
  236. static ssize_t pid_maps_read(struct file * file, char * buf,
  237.       size_t count, loff_t *ppos)
  238. {
  239. struct inode * inode = file->f_dentry->d_inode;
  240. struct task_struct *task = inode->u.proc_i.task;
  241. ssize_t res;
  243. res = proc_pid_read_maps(task, file, buf, count, ppos);
  244. return res;
  245. }
  247. static struct file_operations proc_maps_operations = {
  248. read: pid_maps_read,
  249. };
  251. extern struct seq_operations mounts_op;
  252. static int mounts_open(struct inode *inode, struct file *file)
  253. {
  254. struct task_struct *task = inode->u.proc_i.task;
  255. int ret = seq_open(file, &mounts_op);
  257. if (!ret) {
  258. struct seq_file *m = file->private_data;
  259. struct namespace *namespace;
  260. task_lock(task);
  261. namespace = task->namespace;
  262. if (namespace)
  263. get_namespace(namespace);
  264. task_unlock(task);
  266. if (namespace)
  267. m->private = namespace;
  268. else {
  269. seq_release(inode, file);
  270. ret = -EINVAL;
  271. }
  272. }
  273. return ret;
  274. }
  276. static int mounts_release(struct inode *inode, struct file *file)
  277. {
  278. struct seq_file *m = file->private_data;
  279. struct namespace *namespace = m->private;
  280. put_namespace(namespace);
  281. return seq_release(inode, file);
  282. }
  284. static struct file_operations proc_mounts_operations = {
  285. open: mounts_open,
  286. read: seq_read,
  287. llseek: seq_lseek,
  288. release: mounts_release,
  289. };
  291. #define PROC_BLOCK_SIZE (3*1024) /* 4K page size but our output routines use some slack for overruns */
  293. static ssize_t proc_info_read(struct file * file, char * buf,
  294.   size_t count, loff_t *ppos)
  295. {
  296. struct inode * inode = file->f_dentry->d_inode;
  297. unsigned long page;
  298. ssize_t length;
  299. ssize_t end;
  300. struct task_struct *task = inode->u.proc_i.task;
  302. if (count > PROC_BLOCK_SIZE)
  303. count = PROC_BLOCK_SIZE;
  304. if (!(page = __get_free_page(GFP_KERNEL)))
  305. return -ENOMEM;
  307. length = inode->u.proc_i.op.proc_read(task, (char*)page);
  309. if (length < 0) {
  310. free_page(page);
  311. return length;
  312. }
  313. /* Static 4kB (or whatever) block capacity */
  314. if (*ppos >= length) {
  315. free_page(page);
  316. return 0;
  317. }
  318. if (count + *ppos > length)
  319. count = length - *ppos;
  320. end = count + *ppos;
  321. copy_to_user(buf, (char *) page + *ppos, count);
  322. *ppos = end;
  323. free_page(page);
  324. return count;
  325. }
  327. static struct file_operations proc_info_file_operations = {
  328. read: proc_info_read,
  329. };
  331. #define MAY_PTRACE(p) 
  332. (p==current||(p->p_pptr==current&&(p->ptrace & PT_PTRACED)&&p->state==TASK_STOPPED))
  335. static int mem_open(struct inode* inode, struct file* file)
  336. {
  337. file->private_data = (void*)((long)current->self_exec_id);
  338. return 0;
  339. }
  341. static ssize_t mem_read(struct file * file, char * buf,
  342. size_t count, loff_t *ppos)
  343. {
  344. struct task_struct *task = file->f_dentry->d_inode->u.proc_i.task;
  345. char *page;
  346. unsigned long src = *ppos;
  347. int copied = 0;
  348. struct mm_struct *mm;
  351. if (!MAY_PTRACE(task))
  352. return -ESRCH;
  354. page = (char *)__get_free_page(GFP_USER);
  355. if (!page)
  356. return -ENOMEM;
  358. task_lock(task);
  359. mm = task->mm;
  360. if (mm)
  361. atomic_inc(&mm->mm_users);
  362. task_unlock(task);
  363. if (!mm)
  364. return 0;
  366. if (file->private_data != (void*)((long)current->self_exec_id) ) {
  367. mmput(mm);
  368. return -EIO;
  369. }
  372. while (count > 0) {
  373. int this_len, retval;
  375. this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
  376. retval = access_process_vm(task, src, page, this_len, 0);
  377. if (!retval) {
  378. if (!copied)
  379. copied = -EIO;
  380. break;
  381. }
  382. if (copy_to_user(buf, page, retval)) {
  383. copied = -EFAULT;
  384. break;
  385. }
  386. copied += retval;
  387. src += retval;
  388. buf += retval;
  389. count -= retval;
  390. }
  391. *ppos = src;
  392. mmput(mm);
  393. free_page((unsigned long) page);
  394. return copied;
  395. }
  397. #define mem_write NULL
  399. #ifndef mem_write
  400. /* This is a security hazard */
  401. static ssize_t mem_write(struct file * file, const char * buf,
  402.  size_t count, loff_t *ppos)
  403. {
  404. int copied = 0;
  405. char *page;
  406. struct task_struct *task = file->f_dentry->d_inode->u.proc_i.task;
  407. unsigned long dst = *ppos;
  409. if (!MAY_PTRACE(task))
  410. return -ESRCH;
  412. page = (char *)__get_free_page(GFP_USER);
  413. if (!page)
  414. return -ENOMEM;
  416. while (count > 0) {
  417. int this_len, retval;
  419. this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
  420. if (copy_from_user(page, buf, this_len)) {
  421. copied = -EFAULT;
  422. break;
  423. }
  424. retval = access_process_vm(task, dst, page, this_len, 1);
  425. if (!retval) {
  426. if (!copied)
  427. copied = -EIO;
  428. break;
  429. }
  430. copied += retval;
  431. buf += retval;
  432. dst += retval;
  433. count -= retval;
  434. }
  435. *ppos = dst;
  436. free_page((unsigned long) page);
  437. return copied;
  438. }
  439. #endif
  441. static struct file_operations proc_mem_operations = {
  442. read: mem_read,
  443. write: mem_write,
  444. open: mem_open,
  445. };
  447. static struct inode_operations proc_mem_inode_operations = {
  448. permission: proc_permission,
  449. };
  451. static int proc_pid_follow_link(struct dentry *dentry, struct nameidata *nd)
  452. {
  453. struct inode *inode = dentry->d_inode;
  454. int error = -EACCES;
  456. /* We don't need a base pointer in the /proc filesystem */
  457. path_release(nd);
  459. if (current->fsuid != inode->i_uid && !capable(CAP_DAC_OVERRIDE))
  460. goto out;
  461. error = proc_check_root(inode);
  462. if (error)
  463. goto out;
  465. error = inode->u.proc_i.op.proc_get_link(inode, &nd->dentry, &nd->mnt);
  466. nd->last_type = LAST_BIND;
  467. out:
  468. return error;
  469. }
  471. static int do_proc_readlink(struct dentry *dentry, struct vfsmount *mnt,
  472.     char * buffer, int buflen)
  473. {
  474. struct inode * inode;
  475. char * tmp = (char*)__get_free_page(GFP_KERNEL), *path;
  476. int len;
  478. if (!tmp)
  479. return -ENOMEM;
  481. inode = dentry->d_inode;
  482. path = d_path(dentry, mnt, tmp, PAGE_SIZE);
  483. len = tmp + PAGE_SIZE - 1 - path;
  485. if (len < buflen)
  486. buflen = len;
  487. copy_to_user(buffer, path, buflen);
  488. free_page((unsigned long)tmp);
  489. return buflen;
  490. }
  492. static int proc_pid_readlink(struct dentry * dentry, char * buffer, int buflen)
  493. {
  494. int error = -EACCES;
  495. struct inode *inode = dentry->d_inode;
  496. struct dentry *de;
  497. struct vfsmount *mnt = NULL;
  499. if (current->fsuid != inode->i_uid && !capable(CAP_DAC_OVERRIDE))
  500. goto out;
  501. error = proc_check_root(inode);
  502. if (error)
  503. goto out;
  505. error = inode->u.proc_i.op.proc_get_link(inode, &de, &mnt);
  506. if (error)
  507. goto out;
  509. error = do_proc_readlink(de, mnt, buffer, buflen);
  510. dput(de);
  511. mntput(mnt);
  512. out:
  513. return error;
  514. }
  516. static struct inode_operations proc_pid_link_inode_operations = {
  517. readlink: proc_pid_readlink,
  518. follow_link: proc_pid_follow_link
  519. };
  521. struct pid_entry {
  522. int type;
  523. int len;
  524. char *name;
  525. mode_t mode;
  526. };
  528. enum pid_directory_inos {
  529. PROC_PID_INO = 2,
  530. PROC_PID_STATUS,
  531. PROC_PID_MEM,
  532. PROC_PID_CWD,
  533. PROC_PID_ROOT,
  534. PROC_PID_EXE,
  535. PROC_PID_FD,
  536. PROC_PID_ENVIRON,
  537. PROC_PID_CMDLINE,
  538. PROC_PID_STAT,
  539. PROC_PID_STATM,
  540. PROC_PID_MAPS,
  541. PROC_PID_CPU,
  542. PROC_PID_MOUNTS,
  543. PROC_PID_FD_DIR = 0x8000, /* 0x8000-0xffff */
  544. };
  546. #define E(type,name,mode) {(type),sizeof(name)-1,(name),(mode)}
  547. static struct pid_entry base_stuff[] = {
  548.   E(PROC_PID_FD, "fd", S_IFDIR|S_IRUSR|S_IXUSR),
  549.   E(PROC_PID_ENVIRON, "environ", S_IFREG|S_IRUSR),
  550.   E(PROC_PID_STATUS, "status", S_IFREG|S_IRUGO),
  551.   E(PROC_PID_CMDLINE, "cmdline", S_IFREG|S_IRUGO),
  552.   E(PROC_PID_STAT, "stat", S_IFREG|S_IRUGO),
  553.   E(PROC_PID_STATM, "statm", S_IFREG|S_IRUGO),
  554. #ifdef CONFIG_SMP
  555.   E(PROC_PID_CPU, "cpu", S_IFREG|S_IRUGO),
  556. #endif
  557.   E(PROC_PID_MAPS, "maps", S_IFREG|S_IRUGO),
  558.   E(PROC_PID_MEM, "mem", S_IFREG|S_IRUSR|S_IWUSR),
  559.   E(PROC_PID_CWD, "cwd", S_IFLNK|S_IRWXUGO),
  560.   E(PROC_PID_ROOT, "root", S_IFLNK|S_IRWXUGO),
  561.   E(PROC_PID_EXE, "exe", S_IFLNK|S_IRWXUGO),
  562.   E(PROC_PID_MOUNTS, "mounts", S_IFREG|S_IRUGO),
  563.   {0,0,NULL,0}
  564. };
  565. #undef E
  567. #define NUMBUF 10
  569. static int proc_readfd(struct file * filp, void * dirent, filldir_t filldir)
  570. {
  571. struct inode *inode = filp->f_dentry->d_inode;
  572. struct task_struct *p = inode->u.proc_i.task;
  573. unsigned int fd, pid, ino;
  574. int retval;
  575. char buf[NUMBUF];
  576. struct files_struct * files;
  578. retval = 0;
  579. pid = p->pid;
  581. fd = filp->f_pos;
  582. switch (fd) {
  583. case 0:
  584. if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR) < 0)
  585. goto out;
  586. filp->f_pos++;
  587. case 1:
  588. ino = fake_ino(pid, PROC_PID_INO);
  589. if (filldir(dirent, "..", 2, 1, ino, DT_DIR) < 0)
  590. goto out;
  591. filp->f_pos++;
  592. default:
  593. task_lock(p);
  594. files = p->files;
  595. if (files)
  596. atomic_inc(&files->count);
  597. task_unlock(p);
  598. if (!files)
  599. goto out;
  600. read_lock(&files->file_lock);
  601. for (fd = filp->f_pos-2;
  602.      fd < files->max_fds;
  603.      fd++, filp->f_pos++) {
  604. unsigned int i,j;
  606. if (!fcheck_files(files, fd))
  607. continue;
  608. read_unlock(&files->file_lock);
  610. j = NUMBUF;
  611. i = fd;
  612. do {
  613. j--;
  614. buf[j] = '0' + (i % 10);
  615. i /= 10;
  616. } while (i);
  618. ino = fake_ino(pid, PROC_PID_FD_DIR + fd);
  619. if (filldir(dirent, buf+j, NUMBUF-j, fd+2, ino, DT_LNK) < 0) {
  620. read_lock(&files->file_lock);
  621. break;
  622. }
  623. read_lock(&files->file_lock);
  624. }
  625. read_unlock(&files->file_lock);
  626. put_files_struct(files);
  627. }
  628. out:
  629. return retval;
  630. }
  632. static int proc_base_readdir(struct file * filp,
  633. void * dirent, filldir_t filldir)
  634. {
  635. int i;
  636. int pid;
  637. struct inode *inode = filp->f_dentry->d_inode;
  638. struct pid_entry *p;
  640. pid = inode->u.proc_i.task->pid;
  641. if (!pid)
  642. return -ENOENT;
  643. i = filp->f_pos;
  644. switch (i) {
  645. case 0:
  646. if (filldir(dirent, ".", 1, i, inode->i_ino, DT_DIR) < 0)
  647. return 0;
  648. i++;
  649. filp->f_pos++;
  650. /* fall through */
  651. case 1:
  652. if (filldir(dirent, "..", 2, i, PROC_ROOT_INO, DT_DIR) < 0)
  653. return 0;
  654. i++;
  655. filp->f_pos++;
  656. /* fall through */
  657. default:
  658. i -= 2;
  659. if (i>=sizeof(base_stuff)/sizeof(base_stuff[0]))
  660. return 1;
  661. p = base_stuff + i;
  662. while (p->name) {
  663. if (filldir(dirent, p->name, p->len, filp->f_pos,
  664.     fake_ino(pid, p->type), p->mode >> 12) < 0)
  665. return 0;
  666. filp->f_pos++;
  667. p++;
  668. }
  669. }
  670. return 1;
  671. }
  673. /* building an inode */
  675. static int task_dumpable(struct task_struct *task)
  676. {
  677. int dumpable = 0;
  678. struct mm_struct *mm;
  680. task_lock(task);
  681. mm = task->mm;
  682. if (mm)
  683. dumpable = mm->dumpable;
  684. task_unlock(task);
  685. return dumpable;
  686. }
  689. static struct inode *proc_pid_make_inode(struct super_block * sb, struct task_struct *task, int ino)
  690. {
  691. struct inode * inode;
  693. /* We need a new inode */
  695. inode = new_inode(sb);
  696. if (!inode)
  697. goto out;
  699. /* Common stuff */
  701. inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
  702. inode->i_ino = fake_ino(task->pid, ino);
  704. if (!task->pid)
  705. goto out_unlock;
  707. /*
  708.  * grab the reference to task.
  709.  */
  710. get_task_struct(task);
  711. inode->u.proc_i.task = task;
  712. inode->i_uid = 0;
  713. inode->i_gid = 0;
  714. if (ino == PROC_PID_INO || task_dumpable(task)) {
  715. inode->i_uid = task->euid;
  716. inode->i_gid = task->egid;
  717. }
  719. out:
  720. return inode;
  722. out_unlock:
  723. iput(inode);
  724. return NULL;
  725. }
  727. /* dentry stuff */
  729. static int pid_fd_revalidate(struct dentry * dentry, int flags)
  730. {
  731. return 0;
  732. }
  734. /*
  735.  * Exceptional case: normally we are not allowed to unhash a busy
  736.  * directory. In this case, however, we can do it - no aliasing problems
  737.  * due to the way we treat inodes.
  738.  */
  739. static int pid_base_revalidate(struct dentry * dentry, int flags)
  740. {
  741. if (dentry->d_inode->u.proc_i.task->pid)
  742. return 1;
  743. d_drop(dentry);
  744. return 0;
  745. }
  747. static int pid_delete_dentry(struct dentry * dentry)
  748. {
  749. return 1;
  750. }
  752. static struct dentry_operations pid_fd_dentry_operations =
  753. {
  754. d_revalidate: pid_fd_revalidate,
  755. d_delete: pid_delete_dentry,
  756. };
  758. static struct dentry_operations pid_dentry_operations =
  759. {
  760. d_delete: pid_delete_dentry,
  761. };
  763. static struct dentry_operations pid_base_dentry_operations =
  764. {
  765. d_revalidate: pid_base_revalidate,
  766. d_delete: pid_delete_dentry,
  767. };
  769. /* Lookups */
  770. #define MAX_MULBY10 ((~0U-9)/10)
  772. static struct dentry *proc_lookupfd(struct inode * dir, struct dentry * dentry)
  773. {
  774. unsigned int fd, c;
  775. struct task_struct *task = dir->u.proc_i.task;
  776. struct file * file;
  777. struct files_struct * files;
  778. struct inode *inode;
  779. const char *name;
  780. int len;
  782. fd = 0;
  783. len = dentry->d_name.len;
  784. name = dentry->d_name.name;
  785. if (len > 1 && *name == '0') goto out;
  786. while (len-- > 0) {
  787. c = *name - '0';
  788. name++;
  789. if (c > 9)
  790. goto out;
  791. if (fd >= MAX_MULBY10)
  792. goto out;
  793. fd *= 10;
  794. fd += c;
  795. }
  797. inode = proc_pid_make_inode(dir->i_sb, task, PROC_PID_FD_DIR+fd);
  798. if (!inode)
  799. goto out;
  800. task_lock(task);
  801. files = task->files;
  802. if (files)
  803. atomic_inc(&files->count);
  804. task_unlock(task);
  805. if (!files)
  806. goto out_unlock;
  807. read_lock(&files->file_lock);
  808. file = inode->u.proc_i.file = fcheck_files(files, fd);
  809. if (!file)
  810. goto out_unlock2;
  811. get_file(file);
  812. read_unlock(&files->file_lock);
  813. put_files_struct(files);
  814. inode->i_op = &proc_pid_link_inode_operations;
  815. inode->i_size = 64;
  816. inode->i_mode = S_IFLNK;
  817. inode->u.proc_i.op.proc_get_link = proc_fd_link;
  818. if (file->f_mode & 1)
  819. inode->i_mode |= S_IRUSR | S_IXUSR;
  820. if (file->f_mode & 2)
  821. inode->i_mode |= S_IWUSR | S_IXUSR;
  822. dentry->d_op = &pid_fd_dentry_operations;
  823. d_add(dentry, inode);
  824. return NULL;
  826. out_unlock2:
  827. put_files_struct(files);
  828. read_unlock(&files->file_lock);
  829. out_unlock:
  830. iput(inode);
  831. out:
  832. return ERR_PTR(-ENOENT);
  833. }
  835. static struct file_operations proc_fd_operations = {
  836. read: generic_read_dir,
  837. readdir: proc_readfd,
  838. };
  840. /*
  841.  * proc directories can do almost nothing..
  842.  */
  843. static struct inode_operations proc_fd_inode_operations = {
  844. lookup: proc_lookupfd,
  845. permission: proc_permission,
  846. };
  848. static struct dentry *proc_base_lookup(struct inode *dir, struct dentry *dentry)
  849. {
  850. struct inode *inode;
  851. int error;
  852. struct task_struct *task = dir->u.proc_i.task;
  853. struct pid_entry *p;
  855. error = -ENOENT;
  856. inode = NULL;
  858. for (p = base_stuff; p->name; p++) {
  859. if (p->len != dentry->d_name.len)
  860. continue;
  861. if (!memcmp(dentry->d_name.name, p->name, p->len))
  862. break;
  863. }
  864. if (!p->name)
  865. goto out;
  867. error = -EINVAL;
  868. inode = proc_pid_make_inode(dir->i_sb, task, p->type);
  869. if (!inode)
  870. goto out;
  872. inode->i_mode = p->mode;
  873. /*
  874.  * Yes, it does not scale. And it should not. Don't add
  875.  * new entries into /proc/<pid>/ without very good reasons.
  876.  */
  877. switch(p->type) {
  878. case PROC_PID_FD:
  879. inode->i_nlink = 2;
  880. inode->i_op = &proc_fd_inode_operations;
  881. inode->i_fop = &proc_fd_operations;
  882. break;
  883. case PROC_PID_EXE:
  884. inode->i_op = &proc_pid_link_inode_operations;
  885. inode->u.proc_i.op.proc_get_link = proc_exe_link;
  886. break;
  887. case PROC_PID_CWD:
  888. inode->i_op = &proc_pid_link_inode_operations;
  889. inode->u.proc_i.op.proc_get_link = proc_cwd_link;
  890. break;
  891. case PROC_PID_ROOT:
  892. inode->i_op = &proc_pid_link_inode_operations;
  893. inode->u.proc_i.op.proc_get_link = proc_root_link;
  894. break;
  895. case PROC_PID_ENVIRON:
  896. inode->i_fop = &proc_info_file_operations;
  897. inode->u.proc_i.op.proc_read = proc_pid_environ;
  898. break;
  899. case PROC_PID_STATUS:
  900. inode->i_fop = &proc_info_file_operations;
  901. inode->u.proc_i.op.proc_read = proc_pid_status;
  902. break;
  903. case PROC_PID_STAT:
  904. inode->i_fop = &proc_info_file_operations;
  905. inode->u.proc_i.op.proc_read = proc_pid_stat;
  906. break;
  907. case PROC_PID_CMDLINE:
  908. inode->i_fop = &proc_info_file_operations;
  909. inode->u.proc_i.op.proc_read = proc_pid_cmdline;
  910. break;
  911. case PROC_PID_STATM:
  912. inode->i_fop = &proc_info_file_operations;
  913. inode->u.proc_i.op.proc_read = proc_pid_statm;
  914. break;
  915. case PROC_PID_MAPS:
  916. inode->i_fop = &proc_maps_operations;
  917. break;
  918. #ifdef CONFIG_SMP
  919. case PROC_PID_CPU:
  920. inode->i_fop = &proc_info_file_operations;
  921. inode->u.proc_i.op.proc_read = proc_pid_cpu;
  922. break;
  923. #endif
  924. case PROC_PID_MEM:
  925. inode->i_op = &proc_mem_inode_operations;
  926. inode->i_fop = &proc_mem_operations;
  927. break;
  928. case PROC_PID_MOUNTS:
  929. inode->i_fop = &proc_mounts_operations;
  930. break;
  931. default:
  932. printk("procfs: impossible type (%d)",p->type);
  933. iput(inode);
  934. return ERR_PTR(-EINVAL);
  935. }
  936. dentry->d_op = &pid_dentry_operations;
  937. d_add(dentry, inode);
  938. return NULL;
  940. out:
  941. return ERR_PTR(error);
  942. }
  944. static struct file_operations proc_base_operations = {
  945. read: generic_read_dir,
  946. readdir: proc_base_readdir,
  947. };
  949. static struct inode_operations proc_base_inode_operations = {
  950. lookup: proc_base_lookup,
  951. };
  953. /*
  954.  * /proc/self:
  955.  */
  956. static int proc_self_readlink(struct dentry *dentry, char *buffer, int buflen)
  957. {
  958. char tmp[30];
  959. sprintf(tmp, "%d", current->pid);
  960. return vfs_readlink(dentry,buffer,buflen,tmp);
  961. }
  963. static int proc_self_follow_link(struct dentry *dentry, struct nameidata *nd)
  964. {
  965. char tmp[30];
  966. sprintf(tmp, "%d", current->pid);
  967. return vfs_follow_link(nd,tmp);
  968. }
  970. static struct inode_operations proc_self_inode_operations = {
  971. readlink: proc_self_readlink,
  972. follow_link: proc_self_follow_link,
  973. };
  975. struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry)
  976. {
  977. unsigned int pid, c;
  978. struct task_struct *task;
  979. const char *name;
  980. struct inode *inode;
  981. int len;
  983. pid = 0;
  984. name = dentry->d_name.name;
  985. len = dentry->d_name.len;
  986. if (len == 4 && !memcmp(name, "self", 4)) {
  987. inode = new_inode(dir->i_sb);
  988. if (!inode)
  989. return ERR_PTR(-ENOMEM);
  990. inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
  991. inode->i_ino = fake_ino(0, PROC_PID_INO);
  992. inode->u.proc_i.file = NULL;
  993. inode->u.proc_i.task = NULL;
  994. inode->i_mode = S_IFLNK|S_IRWXUGO;
  995. inode->i_uid = inode->i_gid = 0;
  996. inode->i_size = 64;
  997. inode->i_op = &proc_self_inode_operations;
  998. d_add(dentry, inode);
  999. return NULL;
  1000. }
  1001. while (len-- > 0) {
  1002. c = *name - '0';
  1003. name++;
  1004. if (c > 9)
  1005. goto out;
  1006. if (pid >= MAX_MULBY10)
  1007. goto out;
  1008. pid *= 10;
  1009. pid += c;
  1010. if (!pid)
  1011. goto out;
  1012. }
  1014. read_lock(&tasklist_lock);
  1015. task = find_task_by_pid(pid);
  1016. if (task)
  1017. get_task_struct(task);
  1018. read_unlock(&tasklist_lock);
  1019. if (!task)
  1020. goto out;
  1022. inode = proc_pid_make_inode(dir->i_sb, task, PROC_PID_INO);
  1024. free_task_struct(task);
  1026. if (!inode)
  1027. goto out;
  1028. inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO;
  1029. inode->i_op = &proc_base_inode_operations;
  1030. inode->i_fop = &proc_base_operations;
  1031. inode->i_nlink = 3;
  1032. inode->i_flags|=S_IMMUTABLE;
  1034. dentry->d_op = &pid_base_dentry_operations;
  1035. d_add(dentry, inode);
  1036. return NULL;
  1037. out:
  1038. return ERR_PTR(-ENOENT);
  1039. }
  1041. void proc_pid_delete_inode(struct inode *inode)
  1042. {
  1043. if (inode->u.proc_i.file)
  1044. fput(inode->u.proc_i.file);
  1045. if (inode->u.proc_i.task)
  1046. free_task_struct(inode->u.proc_i.task);
  1047. }
  1049. #define PROC_NUMBUF 10
  1050. #define PROC_MAXPIDS 20
  1052. /*
  1053.  * Get a few pid's to return for filldir - we need to hold the
  1054.  * tasklist lock while doing this, and we must release it before
  1055.  * we actually do the filldir itself, so we use a temp buffer..
  1056.  */
  1057. static int get_pid_list(int index, unsigned int *pids)
  1058. {
  1059. struct task_struct *p;
  1060. int nr_pids = 0;
  1062. index--;
  1063. read_lock(&tasklist_lock);
  1064. for_each_task(p) {
  1065. int pid = p->pid;
  1066. if (!pid)
  1067. continue;
  1068. if (--index >= 0)
  1069. continue;
  1070. pids[nr_pids] = pid;
  1071. nr_pids++;
  1072. if (nr_pids >= PROC_MAXPIDS)
  1073. break;
  1074. }
  1075. read_unlock(&tasklist_lock);
  1076. return nr_pids;
  1077. }
  1079. int proc_pid_readdir(struct file * filp, void * dirent, filldir_t filldir)
  1080. {
  1081. unsigned int pid_array[PROC_MAXPIDS];
  1082. char buf[PROC_NUMBUF];
  1083. unsigned int nr = filp->f_pos - FIRST_PROCESS_ENTRY;
  1084. unsigned int nr_pids, i;
  1086. if (!nr) {
  1087. ino_t ino = fake_ino(0,PROC_PID_INO);
  1088. if (filldir(dirent, "self", 4, filp->f_pos, ino, DT_LNK) < 0)
  1089. return 0;
  1090. filp->f_pos++;
  1091. nr++;
  1092. }
  1094. nr_pids = get_pid_list(nr, pid_array);
  1096. for (i = 0; i < nr_pids; i++) {
  1097. int pid = pid_array[i];
  1098. ino_t ino = fake_ino(pid,PROC_PID_INO);
  1099. unsigned long j = PROC_NUMBUF;
  1101. do buf[--j] = '0' + (pid % 10); while (pid/=10);
  1103. if (filldir(dirent, buf+j, PROC_NUMBUF-j, filp->f_pos, ino, DT_DIR) < 0)
  1104. break;
  1105. filp->f_pos++;
  1106. }
  1107. return 0;
  1108. }