/*
* linux/fs/proc/base.c
*
* Copyright (C) 1991, 1992 Linus Torvalds
*
* proc base directory handling functions
*
* 1999, Al Viro. Rewritten. Now it covers the whole per-process part.
* Instead of using magical inumbers to determine the kind of object
* we allocate and fill in-core inodes upon lookup. They don't even
* go into icache. We cache the reference to task_struct upon lookup too.
* Eventually it should become a filesystem in its own. We don't use the
* rest of procfs anymore.
*/
#include <asm/uaccess.h>
#include <linux/config.h>
#include <linux/errno.h>
#include <linux/sched.h>
#include <linux/proc_fs.h>
#include <linux/stat.h>
#include <linux/init.h>
#include <linux/file.h>
#include <linux/string.h>
/*
* For hysterical raisins we keep the same inumbers as in the old procfs.
* Feel free to change the macro below - just keep the range distinct from
* inumbers of the rest of procfs (currently those are in 0x0000--0xffff).
* As soon as we'll get a separate superblock we will be able to forget
* about magical ranges too.
*/
#define fake_ino(pid,ino) (((pid)<<16)|(ino))
ssize_t proc_pid_read_maps(struct task_struct*,struct file*,char*,size_t,loff_t*);
int proc_pid_stat(struct task_struct*,char*);
int proc_pid_status(struct task_struct*,char*);
int proc_pid_statm(struct task_struct*,char*);
int proc_pid_cpu(struct task_struct*,char*);
43 static int proc_fd_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt)
{
45 if (inode->u.proc_i.file) {
*mnt = mntget(inode->u.proc_i.file->f_vfsmnt);
*dentry = dget(inode->u.proc_i.file->f_dentry);
48 return 0;
}
50 return -ENOENT;
}
53 static int proc_exe_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt)
{
struct mm_struct * mm;
struct vm_area_struct * vma;
int result = -ENOENT;
struct task_struct *task = inode->u.proc_i.task;
task_lock(task);
mm = task->mm;
62 if (mm)
atomic_inc(&mm->mm_users);
task_unlock(task);
65 if (!mm)
66 goto out;
down(&mm->mmap_sem);
vma = mm->mmap;
69 while (vma) {
if ((vma->vm_flags & VM_EXECUTABLE) &&
71 vma->vm_file) {
*mnt = mntget(vma->vm_file->f_vfsmnt);
*dentry = dget(vma->vm_file->f_dentry);
result = 0;
75 break;
}
vma = vma->vm_next;
}
up(&mm->mmap_sem);
mmput(mm);
out:
82 return result;
}
85 static int proc_cwd_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt)
{
struct fs_struct *fs;
int result = -ENOENT;
task_lock(inode->u.proc_i.task);
fs = inode->u.proc_i.task->fs;
91 if(fs)
atomic_inc(&fs->count);
task_unlock(inode->u.proc_i.task);
94 if (fs) {
read_lock(&fs->lock);
*mnt = mntget(fs->pwdmnt);
*dentry = dget(fs->pwd);
98 read_unlock(&fs->lock);
result = 0;
put_fs_struct(fs);
}
102 return result;
}
105 static int proc_root_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt)
{
struct fs_struct *fs;
int result = -ENOENT;
task_lock(inode->u.proc_i.task);
fs = inode->u.proc_i.task->fs;
111 if(fs)
atomic_inc(&fs->count);
task_unlock(inode->u.proc_i.task);
114 if (fs) {
read_lock(&fs->lock);
*mnt = mntget(fs->rootmnt);
*dentry = dget(fs->root);
118 read_unlock(&fs->lock);
result = 0;
put_fs_struct(fs);
}
122 return result;
}
125 static int proc_pid_environ(struct task_struct *task, char * buffer)
{
struct mm_struct *mm;
int res = 0;
task_lock(task);
mm = task->mm;
131 if (mm)
atomic_inc(&mm->mm_users);
task_unlock(task);
134 if (mm) {
int len = mm->env_end - mm->env_start;
136 if (len > PAGE_SIZE)
len = PAGE_SIZE;
res = access_process_vm(task, mm->env_start, buffer, len, 0);
mmput(mm);
}
141 return res;
}
144 static int proc_pid_cmdline(struct task_struct *task, char * buffer)
{
struct mm_struct *mm;
int res = 0;
task_lock(task);
mm = task->mm;
150 if (mm)
atomic_inc(&mm->mm_users);
task_unlock(task);
153 if (mm) {
int len = mm->arg_end - mm->arg_start;
155 if (len > PAGE_SIZE)
len = PAGE_SIZE;
res = access_process_vm(task, mm->arg_start, buffer, len, 0);
// If the nul at the end of args has been overwritten, then
// assume application is using setproctitle(3).
160 if ( res > 0 && buffer[res-1] != '\0' )
{
len = strnlen( buffer, res );
163 if ( len < res )
{
res = len;
}
167 else
{
len = mm->env_end - mm->env_start;
170 if (len > PAGE_SIZE - res)
len = PAGE_SIZE - res;
res += access_process_vm(task, mm->env_start, buffer+res, len, 0);
res = strnlen( buffer, res );
}
}
mmput(mm);
}
178 return res;
}
/************************************************************************/
/* Here the fs part begins */
/************************************************************************/
/* permission checks */
187 static int standard_permission(struct inode *inode, int mask)
{
int mode = inode->i_mode;
if ((mask & S_IWOTH) && IS_RDONLY(inode) &&
192 (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
193 return -EROFS; /* Nobody gets write access to a read-only fs */
194 else if ((mask & S_IWOTH) && IS_IMMUTABLE(inode))
195 return -EACCES; /* Nobody gets write access to an immutable file */
196 else if (current->fsuid == inode->i_uid)
mode >>= 6;
198 else if (in_group_p(inode->i_gid))
mode >>= 3;
200 if (((mode & mask & S_IRWXO) == mask) || capable(CAP_DAC_OVERRIDE))
201 return 0;
/* read and search access */
if ((mask == S_IROTH) ||
204 (S_ISDIR(mode) && !(mask & ~(S_IROTH | S_IXOTH))))
205 if (capable(CAP_DAC_READ_SEARCH))
206 return 0;
207 return -EACCES;
}
210 static int proc_check_root(struct inode *inode)
{
struct dentry *de, *base, *root;
struct vfsmount *our_vfsmnt, *vfsmnt, *mnt;
int res = 0;
216 if (proc_root_link(inode, &root, &vfsmnt)) /* Ewww... */
217 return -ENOENT;
read_lock(¤t->fs->lock);
our_vfsmnt = mntget(current->fs->rootmnt);
base = dget(current->fs->root);
221 read_unlock(¤t->fs->lock);
spin_lock(&dcache_lock);
de = root;
mnt = vfsmnt;
227 while (vfsmnt != our_vfsmnt) {
228 if (vfsmnt == vfsmnt->mnt_parent)
229 goto out;
de = vfsmnt->mnt_mountpoint;
vfsmnt = vfsmnt->mnt_parent;
}
234 if (!is_subdir(de, base))
235 goto out;
236 spin_unlock(&dcache_lock);
exit:
dput(base);
mntput(our_vfsmnt);
dput(root);
mntput(mnt);
243 return res;
out:
245 spin_unlock(&dcache_lock);
res = -EACCES;
247 goto exit;
}
250 static int proc_permission(struct inode *inode, int mask)
{
252 if (standard_permission(inode, mask) != 0)
253 return -EACCES;
254 return proc_check_root(inode);
}
257 static ssize_t pid_maps_read(struct file * file, char * buf,
size_t count, loff_t *ppos)
{
struct inode * inode = file->f_dentry->d_inode;
struct task_struct *task = inode->u.proc_i.task;
ssize_t res;
res = proc_pid_read_maps(task, file, buf, count, ppos);
265 return res;
}
static struct file_operations proc_maps_operations = {
read: pid_maps_read,
};
#define PROC_BLOCK_SIZE (3*1024) /* 4K page size but our output routines use some slack for overruns */
274 static ssize_t proc_info_read(struct file * file, char * buf,
size_t count, loff_t *ppos)
{
struct inode * inode = file->f_dentry->d_inode;
unsigned long page;
ssize_t length;
ssize_t end;
struct task_struct *task = inode->u.proc_i.task;
283 if (count > PROC_BLOCK_SIZE)
count = PROC_BLOCK_SIZE;
285 if (!(page = __get_free_page(GFP_KERNEL)))
286 return -ENOMEM;
length = inode->u.proc_i.op.proc_read(task, (char*)page);
290 if (length < 0) {
free_page(page);
292 return length;
}
/* Static 4kB (or whatever) block capacity */
295 if (*ppos >= length) {
free_page(page);
297 return 0;
}
299 if (count + *ppos > length)
count = length - *ppos;
end = count + *ppos;
copy_to_user(buf, (char *) page + *ppos, count);
*ppos = end;
free_page(page);
305 return count;
}
static struct file_operations proc_info_file_operations = {
read: proc_info_read,
};
#define MAY_PTRACE(p) \
(p==current||(p->p_pptr==current&&(p->ptrace & PT_PTRACED)&&p->state==TASK_STOPPED))
315 static ssize_t mem_read(struct file * file, char * buf,
size_t count, loff_t *ppos)
{
struct task_struct *task = file->f_dentry->d_inode->u.proc_i.task;
char *page;
unsigned long src = *ppos;
int copied = 0;
323 if (!MAY_PTRACE(task))
324 return -ESRCH;
page = (char *)__get_free_page(GFP_USER);
327 if (!page)
328 return -ENOMEM;
330 while (count > 0) {
int this_len, retval;
this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
retval = access_process_vm(task, src, page, this_len, 0);
335 if (!retval) {
336 if (!copied)
copied = -EIO;
338 break;
}
340 if (copy_to_user(buf, page, retval)) {
copied = -EFAULT;
342 break;
}
copied += retval;
src += retval;
buf += retval;
count -= retval;
}
*ppos = src;
free_page((unsigned long) page);
351 return copied;
}
#define mem_write NULL
#ifndef mem_write
/* This is a security hazard */
static ssize_t mem_write(struct file * file, const char * buf,
size_t count, loff_t *ppos)
{
int copied = 0;
char *page;
struct task_struct *task = file->f_dentry->d_inode->u.proc_i.task;
unsigned long dst = *ppos;
if (!MAY_PTRACE(task))
return -ESRCH;
page = (char *)__get_free_page(GFP_USER);
if (!page)
return -ENOMEM;
while (count > 0) {
int this_len, retval;
this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
if (copy_from_user(page, buf, this_len)) {
copied = -EFAULT;
break;
}
retval = access_process_vm(task, dst, page, this_len, 1);
if (!retval) {
if (!copied)
copied = -EIO;
break;
}
copied += retval;
buf += retval;
dst += retval;
count -= retval;
}
*ppos = dst;
free_page((unsigned long) page);
return copied;
}
#endif
static struct file_operations proc_mem_operations = {
read: mem_read,
write: mem_write,
};
static struct inode_operations proc_mem_inode_operations = {
permission: proc_permission,
};
407 static int proc_pid_follow_link(struct dentry *dentry, struct nameidata *nd)
{
struct inode *inode = dentry->d_inode;
int error = -EACCES;
/* We don't need a base pointer in the /proc filesystem */
path_release(nd);
415 if (current->fsuid != inode->i_uid && !capable(CAP_DAC_OVERRIDE))
416 goto out;
error = proc_check_root(inode);
418 if (error)
419 goto out;
error = inode->u.proc_i.op.proc_get_link(inode, &nd->dentry, &nd->mnt);
nd->last_type = LAST_BIND;
out:
424 return error;
}
427 static int do_proc_readlink(struct dentry *dentry, struct vfsmount *mnt,
char * buffer, int buflen)
{
struct inode * inode;
char * tmp = (char*)__get_free_page(GFP_KERNEL), *path;
int len;
434 if (!tmp)
435 return -ENOMEM;
inode = dentry->d_inode;
path = d_path(dentry, mnt, tmp, PAGE_SIZE);
len = tmp + PAGE_SIZE - 1 - path;
441 if (len < buflen)
buflen = len;
copy_to_user(buffer, path, buflen);
free_page((unsigned long)tmp);
445 return buflen;
}
448 static int proc_pid_readlink(struct dentry * dentry, char * buffer, int buflen)
{
int error = -EACCES;
struct inode *inode = dentry->d_inode;
struct dentry *de;
struct vfsmount *mnt = NULL;
455 if (current->fsuid != inode->i_uid && !capable(CAP_DAC_OVERRIDE))
456 goto out;
error = proc_check_root(inode);
458 if (error)
459 goto out;
error = inode->u.proc_i.op.proc_get_link(inode, &de, &mnt);
462 if (error)
463 goto out;
error = do_proc_readlink(de, mnt, buffer, buflen);
dput(de);
mntput(mnt);
out:
469 return error;
}
static struct inode_operations proc_pid_link_inode_operations = {
readlink: proc_pid_readlink,
follow_link: proc_pid_follow_link
};
struct pid_entry {
int type;
int len;
char *name;
mode_t mode;
};
enum pid_directory_inos {
PROC_PID_INO = 2,
PROC_PID_STATUS,
PROC_PID_MEM,
PROC_PID_CWD,
PROC_PID_ROOT,
PROC_PID_EXE,
PROC_PID_FD,
PROC_PID_ENVIRON,
PROC_PID_CMDLINE,
PROC_PID_STAT,
PROC_PID_STATM,
PROC_PID_MAPS,
PROC_PID_CPU,
PROC_PID_FD_DIR = 0x8000, /* 0x8000-0xffff */
};
#define E(type,name,mode) {(type),sizeof(name)-1,(name),(mode)}
static struct pid_entry base_stuff[] = {
E(PROC_PID_FD, "fd", S_IFDIR|S_IRUSR|S_IXUSR),
E(PROC_PID_ENVIRON, "environ", S_IFREG|S_IRUSR),
E(PROC_PID_STATUS, "status", S_IFREG|S_IRUGO),
E(PROC_PID_CMDLINE, "cmdline", S_IFREG|S_IRUGO),
E(PROC_PID_STAT, "stat", S_IFREG|S_IRUGO),
E(PROC_PID_STATM, "statm", S_IFREG|S_IRUGO),
#ifdef CONFIG_SMP
E(PROC_PID_CPU, "cpu", S_IFREG|S_IRUGO),
#endif
E(PROC_PID_MAPS, "maps", S_IFREG|S_IRUGO),
E(PROC_PID_MEM, "mem", S_IFREG|S_IRUSR|S_IWUSR),
E(PROC_PID_CWD, "cwd", S_IFLNK|S_IRWXUGO),
E(PROC_PID_ROOT, "root", S_IFLNK|S_IRWXUGO),
E(PROC_PID_EXE, "exe", S_IFLNK|S_IRWXUGO),
{0,0,NULL,0}
};
#undef E
#define NUMBUF 10
523 static int proc_readfd(struct file * filp, void * dirent, filldir_t filldir)
{
struct inode *inode = filp->f_dentry->d_inode;
struct task_struct *p = inode->u.proc_i.task;
unsigned int fd, pid, ino;
int retval;
char buf[NUMBUF];
struct files_struct * files;
retval = 0;
pid = p->pid;
fd = filp->f_pos;
536 switch (fd) {
537 case 0:
538 if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR) < 0)
539 goto out;
filp->f_pos++;
541 case 1:
ino = fake_ino(pid, PROC_PID_INO);
543 if (filldir(dirent, "..", 2, 1, ino, DT_DIR) < 0)
544 goto out;
filp->f_pos++;
546 default:
task_lock(p);
files = p->files;
549 if (files)
atomic_inc(&files->count);
task_unlock(p);
552 if (!files)
553 goto out;
for (fd = filp->f_pos-2;
555 fd < files->max_fds;
fd++, filp->f_pos++) {
unsigned int i,j;
559 if (!fcheck_files(files, fd))
560 continue;
j = NUMBUF;
i = fd;
564 do {
j--;
buf[j] = '0' + (i % 10);
i /= 10;
568 } while (i);
ino = fake_ino(pid, PROC_PID_FD_DIR + fd);
571 if (filldir(dirent, buf+j, NUMBUF-j, fd+2, ino, DT_LNK) < 0)
572 break;
}
put_files_struct(files);
}
out:
577 return retval;
}
580 static int proc_base_readdir(struct file * filp,
void * dirent, filldir_t filldir)
{
int i;
int pid;
struct inode *inode = filp->f_dentry->d_inode;
struct pid_entry *p;
pid = inode->u.proc_i.task->pid;
589 if (!inode->u.proc_i.task->p_pptr)
590 return -ENOENT;
i = filp->f_pos;
592 switch (i) {
593 case 0:
594 if (filldir(dirent, ".", 1, i, inode->i_ino, DT_DIR) < 0)
595 return 0;
i++;
filp->f_pos++;
/* fall through */
599 case 1:
600 if (filldir(dirent, "..", 2, i, PROC_ROOT_INO, DT_DIR) < 0)
601 return 0;
i++;
filp->f_pos++;
/* fall through */
605 default:
i -= 2;
607 if (i>=sizeof(base_stuff)/sizeof(base_stuff[0]))
608 return 1;
p = base_stuff + i;
610 while (p->name) {
if (filldir(dirent, p->name, p->len, filp->f_pos,
612 fake_ino(pid, p->type), p->mode >> 12) < 0)
613 return 0;
filp->f_pos++;
p++;
}
}
618 return 1;
}
/* building an inode */
623 static struct inode *proc_pid_make_inode(struct super_block * sb, struct task_struct *task, int ino)
{
struct inode * inode;
/* We need a new inode */
inode = new_inode(sb);
630 if (!inode)
631 goto out;
/* Common stuff */
inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
inode->i_ino = fake_ino(task->pid, ino);
inode->u.proc_i.file = NULL;
/*
* grab the reference to task.
*/
inode->u.proc_i.task = task;
get_task_struct(task);
644 if (!task->p_pptr)
645 goto out_unlock;
inode->i_uid = 0;
inode->i_gid = 0;
649 if (ino == PROC_PID_INO || task->dumpable) {
inode->i_uid = task->euid;
inode->i_gid = task->egid;
}
out:
655 return inode;
out_unlock:
iput(inode);
659 return NULL;
}
/* dentry stuff */
664 static int pid_fd_revalidate(struct dentry * dentry, int flags)
{
666 return 0;
}
/*
* Exceptional case: normally we are not allowed to unhash a busy
* directory. In this case, however, we can do it - no aliasing problems
* due to the way we treat inodes.
*/
674 static int pid_base_revalidate(struct dentry * dentry, int flags)
{
676 if (dentry->d_inode->u.proc_i.task->p_pptr)
677 return 1;
d_drop(dentry);
679 return 0;
}
682 static int pid_delete_dentry(struct dentry * dentry)
{
684 return 1;
}
static struct dentry_operations pid_fd_dentry_operations =
{
d_revalidate: pid_fd_revalidate,
d_delete: pid_delete_dentry,
};
static struct dentry_operations pid_dentry_operations =
{
d_delete: pid_delete_dentry,
};
static struct dentry_operations pid_base_dentry_operations =
{
d_revalidate: pid_base_revalidate,
d_delete: pid_delete_dentry,
};
/* Lookups */
#define MAX_MULBY10 ((~0U-9)/10)
707 static struct dentry *proc_lookupfd(struct inode * dir, struct dentry * dentry)
{
unsigned int fd, c;
struct task_struct *task = dir->u.proc_i.task;
struct file * file;
struct files_struct * files;
struct inode *inode;
const char *name;
int len;
fd = 0;
len = dentry->d_name.len;
name = dentry->d_name.name;
720 if (len > 1 && *name == '0') goto out;
721 while (len-- > 0) {
c = *name - '0';
name++;
724 if (c > 9)
725 goto out;
726 if (fd >= MAX_MULBY10)
727 goto out;
fd *= 10;
fd += c;
}
inode = proc_pid_make_inode(dir->i_sb, task, PROC_PID_FD_DIR+fd);
733 if (!inode)
734 goto out;
task_lock(task);
files = task->files;
737 if (files)
atomic_inc(&files->count);
task_unlock(task);
740 if (!files)
741 goto out_unlock;
read_lock(&files->file_lock);
file = inode->u.proc_i.file = fcheck_files(files, fd);
744 if (!file)
745 goto out_unlock2;
get_file(file);
747 read_unlock(&files->file_lock);
put_files_struct(files);
inode->i_op = &proc_pid_link_inode_operations;
inode->i_size = 64;
inode->i_mode = S_IFLNK;
inode->u.proc_i.op.proc_get_link = proc_fd_link;
753 if (file->f_mode & 1)
inode->i_mode |= S_IRUSR | S_IXUSR;
755 if (file->f_mode & 2)
inode->i_mode |= S_IWUSR | S_IXUSR;
dentry->d_op = &pid_fd_dentry_operations;
d_add(dentry, inode);
759 return NULL;
out_unlock2:
put_files_struct(files);
763 read_unlock(&files->file_lock);
out_unlock:
iput(inode);
out:
767 return ERR_PTR(-ENOENT);
}
static struct file_operations proc_fd_operations = {
read: generic_read_dir,
readdir: proc_readfd,
};
/*
* proc directories can do almost nothing..
*/
static struct inode_operations proc_fd_inode_operations = {
lookup: proc_lookupfd,
permission: proc_permission,
};
783 static struct dentry *proc_base_lookup(struct inode *dir, struct dentry *dentry)
{
struct inode *inode;
int error;
struct task_struct *task = dir->u.proc_i.task;
struct pid_entry *p;
error = -ENOENT;
inode = NULL;
793 for (p = base_stuff; p->name; p++) {
794 if (p->len != dentry->d_name.len)
795 continue;
796 if (!memcmp(dentry->d_name.name, p->name, p->len))
797 break;
}
799 if (!p->name)
800 goto out;
error = -EINVAL;
inode = proc_pid_make_inode(dir->i_sb, task, p->type);
804 if (!inode)
805 goto out;
inode->i_mode = p->mode;
/*
* Yes, it does not scale. And it should not. Don't add
* new entries into /proc/<pid>/ without very good reasons.
*/
812 switch(p->type) {
813 case PROC_PID_FD:
inode->i_nlink = 2;
inode->i_op = &proc_fd_inode_operations;
inode->i_fop = &proc_fd_operations;
817 break;
818 case PROC_PID_EXE:
inode->i_op = &proc_pid_link_inode_operations;
inode->u.proc_i.op.proc_get_link = proc_exe_link;
821 break;
822 case PROC_PID_CWD:
inode->i_op = &proc_pid_link_inode_operations;
inode->u.proc_i.op.proc_get_link = proc_cwd_link;
825 break;
826 case PROC_PID_ROOT:
inode->i_op = &proc_pid_link_inode_operations;
inode->u.proc_i.op.proc_get_link = proc_root_link;
829 break;
830 case PROC_PID_ENVIRON:
inode->i_fop = &proc_info_file_operations;
inode->u.proc_i.op.proc_read = proc_pid_environ;
833 break;
834 case PROC_PID_STATUS:
inode->i_fop = &proc_info_file_operations;
inode->u.proc_i.op.proc_read = proc_pid_status;
837 break;
838 case PROC_PID_STAT:
inode->i_fop = &proc_info_file_operations;
inode->u.proc_i.op.proc_read = proc_pid_stat;
841 break;
842 case PROC_PID_CMDLINE:
inode->i_fop = &proc_info_file_operations;
inode->u.proc_i.op.proc_read = proc_pid_cmdline;
845 break;
846 case PROC_PID_STATM:
inode->i_fop = &proc_info_file_operations;
inode->u.proc_i.op.proc_read = proc_pid_statm;
849 break;
850 case PROC_PID_MAPS:
inode->i_fop = &proc_maps_operations;
852 break;
#ifdef CONFIG_SMP
case PROC_PID_CPU:
inode->i_fop = &proc_info_file_operations;
inode->u.proc_i.op.proc_read = proc_pid_cpu;
break;
#endif
859 case PROC_PID_MEM:
inode->i_op = &proc_mem_inode_operations;
inode->i_fop = &proc_mem_operations;
862 break;
863 default:
printk("procfs: impossible type (%d)",p->type);
iput(inode);
866 return ERR_PTR(-EINVAL);
}
dentry->d_op = &pid_dentry_operations;
d_add(dentry, inode);
870 return NULL;
out:
873 return ERR_PTR(error);
}
static struct file_operations proc_base_operations = {
read: generic_read_dir,
readdir: proc_base_readdir,
};
static struct inode_operations proc_base_inode_operations = {
lookup: proc_base_lookup,
};
/*
* /proc/self:
*/
888 static int proc_self_readlink(struct dentry *dentry, char *buffer, int buflen)
{
char tmp[30];
sprintf(tmp, "%d", current->pid);
892 return vfs_readlink(dentry,buffer,buflen,tmp);
}
895 static int proc_self_follow_link(struct dentry *dentry, struct nameidata *nd)
{
char tmp[30];
sprintf(tmp, "%d", current->pid);
899 return vfs_follow_link(nd,tmp);
}
static struct inode_operations proc_self_inode_operations = {
readlink: proc_self_readlink,
follow_link: proc_self_follow_link,
};
907 struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry)
{
unsigned int pid, c;
struct task_struct *task;
const char *name;
struct inode *inode;
int len;
pid = 0;
name = dentry->d_name.name;
len = dentry->d_name.len;
918 if (len == 4 && !memcmp(name, "self", 4)) {
inode = new_inode(dir->i_sb);
920 if (!inode)
921 return ERR_PTR(-ENOMEM);
inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
inode->i_ino = fake_ino(0, PROC_PID_INO);
inode->u.proc_i.file = NULL;
inode->u.proc_i.task = NULL;
inode->i_mode = S_IFLNK|S_IRWXUGO;
inode->i_uid = inode->i_gid = 0;
inode->i_size = 64;
inode->i_op = &proc_self_inode_operations;
d_add(dentry, inode);
931 return NULL;
}
933 while (len-- > 0) {
c = *name - '0';
name++;
936 if (c > 9)
937 goto out;
938 if (pid >= MAX_MULBY10)
939 goto out;
pid *= 10;
pid += c;
942 if (!pid)
943 goto out;
}
read_lock(&tasklist_lock);
task = find_task_by_pid(pid);
948 if (task)
get_task_struct(task);
950 read_unlock(&tasklist_lock);
951 if (!task)
952 goto out;
inode = proc_pid_make_inode(dir->i_sb, task, PROC_PID_INO);
free_task_struct(task);
958 if (!inode)
959 goto out;
inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO;
inode->i_op = &proc_base_inode_operations;
inode->i_fop = &proc_base_operations;
inode->i_nlink = 3;
inode->i_flags|=S_IMMUTABLE;
dentry->d_op = &pid_base_dentry_operations;
d_add(dentry, inode);
968 return NULL;
out:
970 return ERR_PTR(-ENOENT);
}
973 void proc_pid_delete_inode(struct inode *inode)
{
975 if (inode->u.proc_i.file)
fput(inode->u.proc_i.file);
977 if (inode->u.proc_i.task)
free_task_struct(inode->u.proc_i.task);
}
#define PROC_NUMBUF 10
#define PROC_MAXPIDS 20
/*
* Get a few pid's to return for filldir - we need to hold the
* tasklist lock while doing this, and we must release it before
* we actually do the filldir itself, so we use a temp buffer..
*/
989 static int get_pid_list(int index, unsigned int *pids)
{
struct task_struct *p;
int nr_pids = 0;
index--;
read_lock(&tasklist_lock);
996 for_each_task(p) {
int pid = p->pid;
998 if (!pid)
999 continue;
1000 if (--index >= 0)
1001 continue;
pids[nr_pids] = pid;
nr_pids++;
1004 if (nr_pids >= PROC_MAXPIDS)
1005 break;
}
1007 read_unlock(&tasklist_lock);
1008 return nr_pids;
}
1011 int proc_pid_readdir(struct file * filp, void * dirent, filldir_t filldir)
{
unsigned int pid_array[PROC_MAXPIDS];
char buf[PROC_NUMBUF];
unsigned int nr = filp->f_pos - FIRST_PROCESS_ENTRY;
unsigned int nr_pids, i;
1018 if (!nr) {
ino_t ino = fake_ino(0,PROC_PID_INO);
1020 if (filldir(dirent, "self", 4, filp->f_pos, ino, DT_LNK) < 0)
1021 return 0;
filp->f_pos++;
nr++;
}
nr_pids = get_pid_list(nr, pid_array);
1028 for (i = 0; i < nr_pids; i++) {
int pid = pid_array[i];
ino_t ino = fake_ino(pid,PROC_PID_INO);
unsigned long j = PROC_NUMBUF;
1033 do buf[--j] = '0' + (pid % 10); while (pid/=10);
1035 if (filldir(dirent, buf+j, PROC_NUMBUF-j, filp->f_pos, ino, DT_DIR) < 0)
1036 break;
filp->f_pos++;
}
1039 return 0;
}