URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [rc203soc/] [sw/] [uClinux/] [fs/] [proc/] [root.c] - Blame information for rev 1777

Go to most recent revision | Details | Compare with Previous | View Log


/*
 *  linux/fs/proc/root.c
 *
 *  Copyright (C) 1991, 1992 Linus Torvalds
 *
 *  proc root directory handling functions
 */
 
#include <asm/segment.h>
 
#include <linux/errno.h>
#include <linux/sched.h>
#include <linux/proc_fs.h>
#include <linux/stat.h>
#include <linux/config.h>
#include <asm/bitops.h>
 
/*
 * Offset of the first process in the /proc root directory..
 */
#define FIRST_PROCESS_ENTRY 256
 
static int proc_root_readdir(struct inode *, struct file *, void *, filldir_t);
static int proc_root_lookup(struct inode *,const char *,int,struct inode **);
 
static unsigned char proc_alloc_map[PROC_NDYNAMIC / 8] = {0};
 
/*
 * These are the generic /proc directory operations. They
 * use the in-memory "struct proc_dir_entry" tree to parse
 * the /proc directory.
 *
 * NOTE! The /proc/scsi directory currently does not correctly
 * build up the proc_dir_entry tree, and will show up empty.
 */
static struct file_operations proc_dir_operations = {
        NULL,                   /* lseek - default */
        NULL,                   /* read - bad */
        NULL,                   /* write - bad */
        proc_readdir,           /* readdir */
        NULL,                   /* select - default */
        NULL,                   /* ioctl - default */
        NULL,                   /* mmap */
        NULL,                   /* no special open code */
        NULL,                   /* no special release code */
        NULL                    /* can't fsync */
};
 
/*
 * proc directories can do almost nothing..
 */
struct inode_operations proc_dir_inode_operations = {
        &proc_dir_operations,   /* default net directory file-ops */
        NULL,                   /* create */
        proc_lookup,            /* lookup */
        NULL,                   /* link */
        NULL,                   /* unlink */
        NULL,                   /* symlink */
        NULL,                   /* mkdir */
        NULL,                   /* rmdir */
        NULL,                   /* mknod */
        NULL,                   /* rename */
        NULL,                   /* readlink */
        NULL,                   /* follow_link */
        NULL,                   /* readpage */
        NULL,                   /* writepage */
        NULL,                   /* bmap */
        NULL,                   /* truncate */
        NULL                    /* permission */
};
 
/*
 * The root /proc directory is special, as it has the
 * <pid> directories. Thus we don't use the generic
 * directory handling functions for that..
 */
static struct file_operations proc_root_operations = {
        NULL,                   /* lseek - default */
        NULL,                   /* read - bad */
        NULL,                   /* write - bad */
        proc_root_readdir,      /* readdir */
        NULL,                   /* select - default */
        NULL,                   /* ioctl - default */
        NULL,                   /* mmap */
        NULL,                   /* no special open code */
        NULL,                   /* no special release code */
        NULL                    /* no fsync */
};
 
/*
 * proc root can do almost nothing..
 */
static struct inode_operations proc_root_inode_operations = {
        &proc_root_operations,  /* default base directory file-ops */
        NULL,                   /* create */
        proc_root_lookup,       /* lookup */
        NULL,                   /* link */
        NULL,                   /* unlink */
        NULL,                   /* symlink */
        NULL,                   /* mkdir */
        NULL,                   /* rmdir */
        NULL,                   /* mknod */
        NULL,                   /* rename */
        NULL,                   /* readlink */
        NULL,                   /* follow_link */
        NULL,                   /* readpage */
        NULL,                   /* writepage */
        NULL,                   /* bmap */
        NULL,                   /* truncate */
        NULL                    /* permission */
};
 
/*
 * This is the root "inode" in the /proc tree..
 */
struct proc_dir_entry proc_root = {
        PROC_ROOT_INO, 5, "/proc",
        S_IFDIR | S_IRUGO | S_IXUGO, 2, 0, 0,
        0, &proc_root_inode_operations,
        NULL, NULL,
        NULL,
        &proc_root, NULL
};
 
struct proc_dir_entry proc_net = {
        PROC_NET, 3, "net",
        S_IFDIR | S_IRUGO | S_IXUGO, 2, 0, 0,
        0, &proc_dir_inode_operations,
        NULL, NULL,
        NULL,
        NULL, NULL
};
 
struct proc_dir_entry proc_scsi = {
        PROC_SCSI, 4, "scsi",
        S_IFDIR | S_IRUGO | S_IXUGO, 2, 0, 0,
        0, &proc_dir_inode_operations,
        NULL, NULL,
        NULL, &proc_root, NULL
};
 
struct proc_dir_entry proc_sys_root = {
        PROC_SYS, 3, "sys",                     /* inode, name */
        S_IFDIR | S_IRUGO | S_IXUGO, 2, 0, 0,     /* mode, nlink, uid, gid */
        0, &proc_dir_inode_operations,           /* size, ops */
        NULL, NULL,                             /* get_info, fill_inode */
        NULL,                                   /* next */
        NULL, NULL                              /* parent, subdir */
};
 
int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp)
{
        dp->next = dir->subdir;
        dp->parent = dir;
        dir->subdir = dp;
        if (S_ISDIR(dp->mode))
                dir->nlink++;
        return 0;
}
 
int proc_unregister(struct proc_dir_entry * dir, int ino)
{
        struct proc_dir_entry **p = &dir->subdir, *dp;
 
        while ((dp = *p) != NULL) {
                if (dp->low_ino == ino) {
                        *p = dp->next;
                        dp->next = NULL;
                        if (S_ISDIR(dp->mode))
                                dir->nlink--;
                        if (ino >= PROC_DYNAMIC_FIRST &&
                            ino < PROC_DYNAMIC_FIRST+PROC_NDYNAMIC)
                                clear_bit(ino-PROC_DYNAMIC_FIRST,
                                          (void *) proc_alloc_map);
                        return 0;
                }
                p = &dp->next;
        }
        return -EINVAL;
}
 
static int make_inode_number(void)
{
        int i = find_first_zero_bit((void *) proc_alloc_map, PROC_NDYNAMIC);
        if (i<0 || i>=PROC_NDYNAMIC)
                return -1;
        set_bit(i, (void *) proc_alloc_map);
        return PROC_DYNAMIC_FIRST + i;
}
 
int proc_register_dynamic(struct proc_dir_entry * dir,
                          struct proc_dir_entry * dp)
{
        int i = make_inode_number();
        if (i < 0)
                return -EAGAIN;
        dp->low_ino = i;
        dp->next = dir->subdir;
        dp->parent = dir;
        dir->subdir = dp;
        if (S_ISDIR(dp->mode))
                dir->nlink++;
        return 0;
}
 
/*
 * /proc/self:
 */
static int proc_self_followlink(struct inode * dir, struct inode * inode,
                        int flag, int mode, struct inode ** res_inode)
{
        iput(dir);
        *res_inode = proc_get_inode(inode->i_sb, (current->pid << 16) + PROC_PID_INO, &proc_pid);
        iput(inode);
        if (!*res_inode)
                return -ENOENT;
        return 0;
}
 
static int proc_self_readlink(struct inode * inode, char * buffer, int buflen)
{
        int len;
        char tmp[30];
 
        iput(inode);
        len = 1 + sprintf(tmp, "%d", current->pid);
        if (buflen < len)
                len = buflen;
        memcpy_tofs(buffer, tmp, len);
        return len;
}
 
static struct inode_operations proc_self_inode_operations = {
        NULL,                   /* no file-ops */
        NULL,                   /* create */
        NULL,                   /* lookup */
        NULL,                   /* link */
        NULL,                   /* unlink */
        NULL,                   /* symlink */
        NULL,                   /* mkdir */
        NULL,                   /* rmdir */
        NULL,                   /* mknod */
        NULL,                   /* rename */
        proc_self_readlink,     /* readlink */
        proc_self_followlink,   /* follow_link */
        NULL,                   /* readpage */
        NULL,                   /* writepage */
        NULL,                   /* bmap */
        NULL,                   /* truncate */
        NULL                    /* permission */
};
 
struct proc_dir_entry pde_loadavg = {
                PROC_LOADAVG, 7, "loadavg",
                S_IFREG | S_IRUGO, 1, 0, 0,
};
struct proc_dir_entry pde_uptime = {
                PROC_UPTIME, 6, "uptime",
                S_IFREG | S_IRUGO, 1, 0, 0,
};
struct proc_dir_entry pde_meminfo = {
                PROC_MEMINFO, 7, "meminfo",
                S_IFREG | S_IRUGO, 1, 0, 0,
};
struct proc_dir_entry pde_serial = {
                PROC_SERIAL, 6, "serial",
                S_IFREG | S_IRUGO, 1, 0, 0,
};
struct proc_dir_entry pde_kmsg = {
                PROC_KMSG, 4, "kmsg",
                S_IFREG | S_IRUSR, 1, 0, 0,
};
struct proc_dir_entry pde_version = {
                PROC_VERSION, 7, "version",
                S_IFREG | S_IRUGO, 1, 0, 0,
};
#ifdef CONFIG_PCI
struct proc_dir_entry pde_pci = {
                PROC_PCI, 3, "pci",
                S_IFREG | S_IRUGO, 1, 0, 0,
};
#endif
struct proc_dir_entry pde_cpuinfo = {
                PROC_CPUINFO, 7, "cpuinfo",
                S_IFREG | S_IRUGO, 1, 0, 0,
};
struct proc_dir_entry pde_self = {
                PROC_SELF, 4, "self",
                S_IFLNK | S_IRUGO | S_IWUGO | S_IXUGO, 1, 0, 0,
                64, &proc_self_inode_operations,
};
 
#ifdef CONFIG_DEBUG_MALLOC
struct proc_dir_entry pde_malloc = {
                PROC_MALLOC, 6, "malloc",
                S_IFREG | S_IRUGO, 1, 0, 0,
};
#endif
struct proc_dir_entry pde_kcore = {
                PROC_KCORE, 5, "kcore",
                S_IFREG | S_IRUSR, 1, 0, 0,
};
 
#ifdef CONFIG_MODULES
struct proc_dir_entry pde_modules = {
                PROC_MODULES, 7, "modules",
                S_IFREG | S_IRUGO, 1, 0, 0,
};
struct proc_dir_entry pde_ksyms = {
                PROC_KSYMS, 5, "ksyms",
                S_IFREG | S_IRUGO, 1, 0, 0,
};
#endif
struct proc_dir_entry pde_stat = {
                PROC_STAT, 4, "stat",
                S_IFREG | S_IRUGO, 1, 0, 0,
};
struct proc_dir_entry pde_devices =  {
                PROC_DEVICES, 7, "devices",
                S_IFREG | S_IRUGO, 1, 0, 0,
};
struct proc_dir_entry pde_interrupts =  {
                PROC_INTERRUPTS, 10,"interrupts",
                S_IFREG | S_IRUGO, 1, 0, 0,
};
#ifdef __SMP_PROF__
struct proc_dir_entry pde_smp =  {
                PROC_SMP_PROF, 3,"smp",
                S_IFREG | S_IRUGO, 1, 0, 0,
};
#endif 
struct proc_dir_entry pde_filesystems =  {
                PROC_FILESYSTEMS, 11,"filesystems",
                S_IFREG | S_IRUGO, 1, 0, 0,
};
struct proc_dir_entry pde_dma =  {
                PROC_DMA, 3, "dma",
                S_IFREG | S_IRUGO, 1, 0, 0,
};
struct proc_dir_entry pde_ioports =  {
                PROC_IOPORTS, 7, "ioports",
                S_IFREG | S_IRUGO, 1, 0, 0,
};
struct proc_dir_entry pde_cmdline =  {
                PROC_CMDLINE, 7, "cmdline",
                S_IFREG | S_IRUGO, 1, 0, 0,
};
#ifdef CONFIG_RTC
struct proc_dir_entry pde_rtc =  {
                PROC_RTC, 3, "rtc",
                S_IFREG | S_IRUGO, 1, 0, 0,
};
#endif
struct proc_dir_entry pde_locks =  {
                PROC_LOCKS, 5, "locks",
                S_IFREG | S_IRUGO, 1, 0, 0,
};
 
struct proc_dir_entry pde_mounts =
           { PROC_MTAB, 6, "mounts", S_IFREG | S_IRUGO, 1, 0, 0, };
 
struct proc_dir_entry pde_profile = {
                        PROC_PROFILE, 7, "profile",
                        S_IFREG | S_IRUGO | S_IWUSR, 1, 0, 0,
};
 
void proc_root_init(void)
{
        static int done = 0;
 
        if (done)
                return;
        done = 1;
        proc_base_init();
 
        proc_register(&proc_root, &pde_loadavg);
        proc_register(&proc_root, &pde_uptime);
        proc_register(&proc_root, &pde_meminfo);
        proc_register(&proc_root, &pde_kmsg);
        proc_register(&proc_root, &pde_version);
#ifdef CONFIG_PCI
        proc_register(&proc_root, &pde_pci);
#endif
        proc_register(&proc_root, &pde_cpuinfo);
        proc_register(&proc_root, &pde_self);
        proc_register(&proc_root, &proc_net);
        proc_register(&proc_root, &proc_scsi);
        proc_register(&proc_root, &proc_sys_root);
        proc_register(&proc_root, &pde_serial);
 
#ifdef CONFIG_DEBUG_MALLOC
        proc_register(&proc_root, &pde_malloc);
#endif
        proc_register(&proc_root, &pde_kcore);
 
#ifdef CONFIG_MODULES
        proc_register(&proc_root, &pde_modules);
        proc_register(&proc_root, &pde_ksyms);
#endif
        proc_register(&proc_root, &pde_stat);
        proc_register(&proc_root, &pde_devices);
        proc_register(&proc_root, &pde_interrupts);
#ifdef __SMP_PROF__
        proc_register(&proc_root, &pde_smp);
#endif 
        proc_register(&proc_root, &pde_filesystems);
        proc_register(&proc_root, &pde_dma);
        proc_register(&proc_root, &pde_ioports);
        proc_register(&proc_root, &pde_cmdline);
#ifdef CONFIG_RTC
        proc_register(&proc_root, &pde_rtc);
#endif
        proc_register(&proc_root, &pde_locks);
 
        proc_register( &proc_root, &pde_mounts);
 
        if (prof_shift) {
                proc_register(&proc_root, &pde_profile);
        }
}
 
 
int proc_match(int len,const char * name,struct proc_dir_entry * de)
{
        if (!de || !de->low_ino)
                return 0;
        /* "" means "." ---> so paths like "/usr/lib//libc.a" work */
        if (!len && (de->name[0]=='.') && (de->name[1]=='\0'))
                return 1;
        if (de->namelen != len)
                return 0;
        return !memcmp(name, de->name, len);
}
 
int proc_lookup(struct inode * dir,const char * name, int len,
        struct inode ** result)
{
        struct proc_dir_entry * de;
        int ino;
 
        *result = NULL;
        if (!dir || !S_ISDIR(dir->i_mode)) {
                iput(dir);
                return -ENOTDIR;
        }
 
        de = (struct proc_dir_entry *) dir->u.generic_ip;
        if (!de) {
                iput(dir);
                return -EINVAL;
        }
 
        /* Special case "." and "..": they aren't on the directory list */
        *result = dir;
        if (!len)
                return 0;
        if (name[0] == '.') {
                if (len == 1)
                        return 0;
                if (name[1] == '.' && len == 2) {
                        struct inode * inode;
                        inode = proc_get_inode(dir->i_sb, de->parent->low_ino, de->parent);
                        iput(dir);
                        if (!inode)
                                return -EINVAL;
                        *result = inode;
                        return 0;
                }
        }
 
        *result = NULL;
        for (de = de->subdir; de ; de = de->next) {
                if (proc_match(len, name, de))
                        break;
        }
        if (!de) {
                iput(dir);
                return -ENOENT;
        }
 
        ino = de->low_ino | (dir->i_ino & ~(0xffff));
 
        if (!(*result = proc_get_inode(dir->i_sb, ino, de))) {
                iput(dir);
                return -EINVAL;
        }
        iput(dir);
        return 0;
}
 
static int proc_root_lookup(struct inode * dir,const char * name, int len,
        struct inode ** result)
{
        unsigned int pid, c;
        int i, ino, retval;
 
        dir->i_count++;
        retval = proc_lookup(dir, name, len, result);
        if (retval != -ENOENT) {
                iput(dir);
                return retval;
        }
 
        pid = 0;
        while (len-- > 0) {
                c = *name - '0';
                name++;
                if (c > 9) {
                        pid = 0;
                        break;
                }
                pid *= 10;
                pid += c;
                if (pid & 0xffff0000) {
                        pid = 0;
                        break;
                }
        }
        for (i = 0 ; i < NR_TASKS ; i++)
                if (task[i] && task[i]->pid == pid)
                        break;
        if (!pid || i >= NR_TASKS) {
                iput(dir);
                return -ENOENT;
        }
        ino = (pid << 16) + PROC_PID_INO;
        if (!(*result = proc_get_inode(dir->i_sb, ino, &proc_pid))) {
                iput(dir);
                return -EINVAL;
        }
        iput(dir);
        return 0;
}
 
/*
 * This returns non-zero if at EOF, so that the /proc
 * root directory can use this and check if it should
 * continue with the <pid> entries..
 *
 * Note that the VFS-layer doesn't care about the return
 * value of the readdir() call, as long as it's non-negative
 * for success..
 */
int proc_readdir(struct inode * inode, struct file * filp,
        void * dirent, filldir_t filldir)
{
        struct proc_dir_entry * de;
        unsigned int ino;
        int i;
 
        if (!inode || !S_ISDIR(inode->i_mode))
                return -ENOTDIR;
        ino = inode->i_ino;
        de = (struct proc_dir_entry *) inode->u.generic_ip;
        if (!de)
                return -EINVAL;
        i = filp->f_pos;
        switch (i) {
                case 0:
                        if (filldir(dirent, ".", 1, i, ino) < 0)
                                return 0;
                        i++;
                        filp->f_pos++;
                        /* fall through */
                case 1:
                        if (filldir(dirent, "..", 2, i, de->parent->low_ino) < 0)
                                return 0;
                        i++;
                        filp->f_pos++;
                        /* fall through */
                default:
                        ino &= ~0xffff;
                        de = de->subdir;
                        i -= 2;
                        for (;;) {
                                if (!de)
                                        return 1;
                                if (!i)
                                        break;
                                de = de->next;
                                i--;
                        }
 
                        do {
                                if (filldir(dirent, de->name, de->namelen, filp->f_pos, ino | de->low_ino) < 0)
                                        return 0;
                                filp->f_pos++;
                                de = de->next;
                        } while (de);
        }
        return 1;
}
 
#define NUMBUF 10
 
static int proc_root_readdir(struct inode * inode, struct file * filp,
        void * dirent, filldir_t filldir)
{
        char buf[NUMBUF];
        unsigned int nr,pid;
        unsigned long i,j;
 
        nr = filp->f_pos;
        if (nr < FIRST_PROCESS_ENTRY) {
                int error = proc_readdir(inode, filp, dirent, filldir);
                if (error <= 0)
                        return error;
                filp->f_pos = nr = FIRST_PROCESS_ENTRY;
        }
 
        for (nr -= FIRST_PROCESS_ENTRY; nr < NR_TASKS; nr++, filp->f_pos++) {
                struct task_struct * p = task[nr];
 
                if (!p || !(pid = p->pid))
                        continue;
 
                j = NUMBUF;
                i = pid;
                do {
                        j--;
                        buf[j] = '0' + (i % 10);
                        i /= 10;
                } while (i);
 
                if (filldir(dirent, buf+j, NUMBUF-j, filp->f_pos, (pid << 16) + PROC_PID_INO) < 0)
                        break;
        }
        return 0;
}

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [rc203soc/] [sw/] [uClinux/] [fs/] [proc/] [root.c] - Blame information for rev 1777

Line No.	Rev	Author	Line
1	1628	jcastillo	`/*`
2			`* linux/fs/proc/root.c`
3			`*`
4			`* Copyright (C) 1991, 1992 Linus Torvalds`
5			`*`
6			`* proc root directory handling functions`
7			`*/`
8
9			`#include <asm/segment.h>`
10
11			`#include <linux/errno.h>`
12			`#include <linux/sched.h>`
13			`#include <linux/proc_fs.h>`
14			`#include <linux/stat.h>`
15			`#include <linux/config.h>`
16			`#include <asm/bitops.h>`
17
18			`/*`
19			`* Offset of the first process in the /proc root directory..`
20			`*/`
21			`#define FIRST_PROCESS_ENTRY 256`
22
23			`static int proc_root_readdir(struct inode , struct file , void *, filldir_t);`
24			`static int proc_root_lookup(struct inode ,const char ,int,struct inode **);`
25
26			`static unsigned char proc_alloc_map[PROC_NDYNAMIC / 8] = {0};`
27
28			`/*`
29			`* These are the generic /proc directory operations. They`
30			`* use the in-memory "struct proc_dir_entry" tree to parse`
31			`* the /proc directory.`
32			`*`
33			`* NOTE! The /proc/scsi directory currently does not correctly`
34			`* build up the proc_dir_entry tree, and will show up empty.`
35			`*/`
36			`static struct file_operations proc_dir_operations = {`
37			`NULL, /* lseek - default */`
38			`NULL, /* read - bad */`
39			`NULL, /* write - bad */`
40			`proc_readdir, /* readdir */`
41			`NULL, /* select - default */`
42			`NULL, /* ioctl - default */`
43			`NULL, /* mmap */`
44			`NULL, /* no special open code */`
45			`NULL, /* no special release code */`
46			`NULL /* can't fsync */`
47			`};`
48
49			`/*`
50			`* proc directories can do almost nothing..`
51			`*/`
52			`struct inode_operations proc_dir_inode_operations = {`
53			`&proc_dir_operations, /* default net directory file-ops */`
54			`NULL, /* create */`
55			`proc_lookup, /* lookup */`
56			`NULL, /* link */`
57			`NULL, /* unlink */`
58			`NULL, /* symlink */`
59			`NULL, /* mkdir */`
60			`NULL, /* rmdir */`
61			`NULL, /* mknod */`
62			`NULL, /* rename */`
63			`NULL, /* readlink */`
64			`NULL, /* follow_link */`
65			`NULL, /* readpage */`
66			`NULL, /* writepage */`
67			`NULL, /* bmap */`
68			`NULL, /* truncate */`
69			`NULL /* permission */`
70			`};`
71
72			`/*`
73			`* The root /proc directory is special, as it has the`
74			`* <pid> directories. Thus we don't use the generic`
75			`* directory handling functions for that..`
76			`*/`
77			`static struct file_operations proc_root_operations = {`
78			`NULL, /* lseek - default */`
79			`NULL, /* read - bad */`
80			`NULL, /* write - bad */`
81			`proc_root_readdir, /* readdir */`
82			`NULL, /* select - default */`
83			`NULL, /* ioctl - default */`
84			`NULL, /* mmap */`
85			`NULL, /* no special open code */`
86			`NULL, /* no special release code */`
87			`NULL /* no fsync */`
88			`};`
89
90			`/*`
91			`* proc root can do almost nothing..`
92			`*/`
93			`static struct inode_operations proc_root_inode_operations = {`
94			`&proc_root_operations, /* default base directory file-ops */`
95			`NULL, /* create */`
96			`proc_root_lookup, /* lookup */`
97			`NULL, /* link */`
98			`NULL, /* unlink */`
99			`NULL, /* symlink */`
100			`NULL, /* mkdir */`
101			`NULL, /* rmdir */`
102			`NULL, /* mknod */`
103			`NULL, /* rename */`
104			`NULL, /* readlink */`
105			`NULL, /* follow_link */`
106			`NULL, /* readpage */`
107			`NULL, /* writepage */`
108			`NULL, /* bmap */`
109			`NULL, /* truncate */`
110			`NULL /* permission */`
111			`};`
112
113			`/*`
114			`* This is the root "inode" in the /proc tree..`
115			`*/`
116			`struct proc_dir_entry proc_root = {`
117			`PROC_ROOT_INO, 5, "/proc",`
118			`S_IFDIR \| S_IRUGO \| S_IXUGO, 2, 0, 0,`
119			`0, &proc_root_inode_operations,`
120			`NULL, NULL,`
121			`NULL,`
122			`&proc_root, NULL`
123			`};`
124
125			`struct proc_dir_entry proc_net = {`
126			`PROC_NET, 3, "net",`
127			`S_IFDIR \| S_IRUGO \| S_IXUGO, 2, 0, 0,`
128			`0, &proc_dir_inode_operations,`
129			`NULL, NULL,`
130			`NULL,`
131			`NULL, NULL`
132			`};`
133
134			`struct proc_dir_entry proc_scsi = {`
135			`PROC_SCSI, 4, "scsi",`
136			`S_IFDIR \| S_IRUGO \| S_IXUGO, 2, 0, 0,`
137			`0, &proc_dir_inode_operations,`
138			`NULL, NULL,`
139			`NULL, &proc_root, NULL`
140			`};`
141
142			`struct proc_dir_entry proc_sys_root = {`
143			`PROC_SYS, 3, "sys", /* inode, name */`
144			`S_IFDIR \| S_IRUGO \| S_IXUGO, 2, 0, 0, /* mode, nlink, uid, gid */`
145			`0, &proc_dir_inode_operations, /* size, ops */`
146			`NULL, NULL, /* get_info, fill_inode */`
147			`NULL, /* next */`
148			`NULL, NULL /* parent, subdir */`
149			`};`
150
151			`int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp)`
152			`{`
153			`dp->next = dir->subdir;`
154			`dp->parent = dir;`
155			`dir->subdir = dp;`
156			`if (S_ISDIR(dp->mode))`
157			`dir->nlink++;`
158			`return 0;`
159			`}`
160
161			`int proc_unregister(struct proc_dir_entry * dir, int ino)`
162			`{`
163			`struct proc_dir_entry *p = &dir->subdir, dp;`
164
165			`while ((dp = *p) != NULL) {`
166			`if (dp->low_ino == ino) {`
167			`*p = dp->next;`
168			`dp->next = NULL;`
169			`if (S_ISDIR(dp->mode))`
170			`dir->nlink--;`
171			`if (ino >= PROC_DYNAMIC_FIRST &&`
172			`ino < PROC_DYNAMIC_FIRST+PROC_NDYNAMIC)`
173			`clear_bit(ino-PROC_DYNAMIC_FIRST,`
174			`(void *) proc_alloc_map);`
175			`return 0;`
176			`}`
177			`p = &dp->next;`
178			`}`
179			`return -EINVAL;`
180			`}`
181
182			`static int make_inode_number(void)`
183			`{`
184			`int i = find_first_zero_bit((void *) proc_alloc_map, PROC_NDYNAMIC);`
185			`if (i<0 \|\| i>=PROC_NDYNAMIC)`
186			`return -1;`
187			`set_bit(i, (void *) proc_alloc_map);`
188			`return PROC_DYNAMIC_FIRST + i;`
189			`}`
190
191			`int proc_register_dynamic(struct proc_dir_entry * dir,`
192			`struct proc_dir_entry * dp)`
193			`{`
194			`int i = make_inode_number();`
195			`if (i < 0)`
196			`return -EAGAIN;`
197			`dp->low_ino = i;`
198			`dp->next = dir->subdir;`
199			`dp->parent = dir;`
200			`dir->subdir = dp;`
201			`if (S_ISDIR(dp->mode))`
202			`dir->nlink++;`
203			`return 0;`
204			`}`
205
206			`/*`
207			`* /proc/self:`
208			`*/`
209			`static int proc_self_followlink(struct inode * dir, struct inode * inode,`
210			`int flag, int mode, struct inode ** res_inode)`
211			`{`
212			`iput(dir);`
213			`*res_inode = proc_get_inode(inode->i_sb, (current->pid << 16) + PROC_PID_INO, &proc_pid);`
214			`iput(inode);`
215			`if (!*res_inode)`
216			`return -ENOENT;`
217			`return 0;`
218			`}`
219
220			`static int proc_self_readlink(struct inode * inode, char * buffer, int buflen)`
221			`{`
222			`int len;`
223			`char tmp[30];`
224
225			`iput(inode);`
226			`len = 1 + sprintf(tmp, "%d", current->pid);`
227			`if (buflen < len)`
228			`len = buflen;`
229			`memcpy_tofs(buffer, tmp, len);`
230			`return len;`
231			`}`
232
233			`static struct inode_operations proc_self_inode_operations = {`
234			`NULL, /* no file-ops */`
235			`NULL, /* create */`
236			`NULL, /* lookup */`
237			`NULL, /* link */`
238			`NULL, /* unlink */`
239			`NULL, /* symlink */`
240			`NULL, /* mkdir */`
241			`NULL, /* rmdir */`
242			`NULL, /* mknod */`
243			`NULL, /* rename */`
244			`proc_self_readlink, /* readlink */`
245			`proc_self_followlink, /* follow_link */`
246			`NULL, /* readpage */`
247			`NULL, /* writepage */`
248			`NULL, /* bmap */`
249			`NULL, /* truncate */`
250			`NULL /* permission */`
251			`};`
252
253			`struct proc_dir_entry pde_loadavg = {`
254			`PROC_LOADAVG, 7, "loadavg",`
255			`S_IFREG \| S_IRUGO, 1, 0, 0,`
256			`};`
257			`struct proc_dir_entry pde_uptime = {`
258			`PROC_UPTIME, 6, "uptime",`
259			`S_IFREG \| S_IRUGO, 1, 0, 0,`
260			`};`
261			`struct proc_dir_entry pde_meminfo = {`
262			`PROC_MEMINFO, 7, "meminfo",`
263			`S_IFREG \| S_IRUGO, 1, 0, 0,`
264			`};`
265			`struct proc_dir_entry pde_serial = {`
266			`PROC_SERIAL, 6, "serial",`
267			`S_IFREG \| S_IRUGO, 1, 0, 0,`
268			`};`
269			`struct proc_dir_entry pde_kmsg = {`
270			`PROC_KMSG, 4, "kmsg",`
271			`S_IFREG \| S_IRUSR, 1, 0, 0,`
272			`};`
273			`struct proc_dir_entry pde_version = {`
274			`PROC_VERSION, 7, "version",`
275			`S_IFREG \| S_IRUGO, 1, 0, 0,`
276			`};`
277			`#ifdef CONFIG_PCI`
278			`struct proc_dir_entry pde_pci = {`
279			`PROC_PCI, 3, "pci",`
280			`S_IFREG \| S_IRUGO, 1, 0, 0,`
281			`};`
282			`#endif`
283			`struct proc_dir_entry pde_cpuinfo = {`
284			`PROC_CPUINFO, 7, "cpuinfo",`
285			`S_IFREG \| S_IRUGO, 1, 0, 0,`
286			`};`
287			`struct proc_dir_entry pde_self = {`
288			`PROC_SELF, 4, "self",`
289			`S_IFLNK \| S_IRUGO \| S_IWUGO \| S_IXUGO, 1, 0, 0,`
290			`64, &proc_self_inode_operations,`
291			`};`
292
293			`#ifdef CONFIG_DEBUG_MALLOC`
294			`struct proc_dir_entry pde_malloc = {`
295			`PROC_MALLOC, 6, "malloc",`
296			`S_IFREG \| S_IRUGO, 1, 0, 0,`
297			`};`
298			`#endif`
299			`struct proc_dir_entry pde_kcore = {`
300			`PROC_KCORE, 5, "kcore",`
301			`S_IFREG \| S_IRUSR, 1, 0, 0,`
302			`};`
303
304			`#ifdef CONFIG_MODULES`
305			`struct proc_dir_entry pde_modules = {`
306			`PROC_MODULES, 7, "modules",`
307			`S_IFREG \| S_IRUGO, 1, 0, 0,`
308			`};`
309			`struct proc_dir_entry pde_ksyms = {`
310			`PROC_KSYMS, 5, "ksyms",`
311			`S_IFREG \| S_IRUGO, 1, 0, 0,`
312			`};`
313			`#endif`
314			`struct proc_dir_entry pde_stat = {`
315			`PROC_STAT, 4, "stat",`
316			`S_IFREG \| S_IRUGO, 1, 0, 0,`
317			`};`
318			`struct proc_dir_entry pde_devices = {`
319			`PROC_DEVICES, 7, "devices",`
320			`S_IFREG \| S_IRUGO, 1, 0, 0,`
321			`};`
322			`struct proc_dir_entry pde_interrupts = {`
323			`PROC_INTERRUPTS, 10,"interrupts",`
324			`S_IFREG \| S_IRUGO, 1, 0, 0,`
325			`};`
326			`#ifdef __SMP_PROF__`
327			`struct proc_dir_entry pde_smp = {`
328			`PROC_SMP_PROF, 3,"smp",`
329			`S_IFREG \| S_IRUGO, 1, 0, 0,`
330			`};`
331			`#endif`
332			`struct proc_dir_entry pde_filesystems = {`
333			`PROC_FILESYSTEMS, 11,"filesystems",`
334			`S_IFREG \| S_IRUGO, 1, 0, 0,`
335			`};`
336			`struct proc_dir_entry pde_dma = {`
337			`PROC_DMA, 3, "dma",`
338			`S_IFREG \| S_IRUGO, 1, 0, 0,`
339			`};`
340			`struct proc_dir_entry pde_ioports = {`
341			`PROC_IOPORTS, 7, "ioports",`
342			`S_IFREG \| S_IRUGO, 1, 0, 0,`
343			`};`
344			`struct proc_dir_entry pde_cmdline = {`
345			`PROC_CMDLINE, 7, "cmdline",`
346			`S_IFREG \| S_IRUGO, 1, 0, 0,`
347			`};`
348			`#ifdef CONFIG_RTC`
349			`struct proc_dir_entry pde_rtc = {`
350			`PROC_RTC, 3, "rtc",`
351			`S_IFREG \| S_IRUGO, 1, 0, 0,`
352			`};`
353			`#endif`
354			`struct proc_dir_entry pde_locks = {`
355			`PROC_LOCKS, 5, "locks",`
356			`S_IFREG \| S_IRUGO, 1, 0, 0,`
357			`};`
358
359			`struct proc_dir_entry pde_mounts =`
360			`{ PROC_MTAB, 6, "mounts", S_IFREG \| S_IRUGO, 1, 0, 0, };`
361
362			`struct proc_dir_entry pde_profile = {`
363			`PROC_PROFILE, 7, "profile",`
364			`S_IFREG \| S_IRUGO \| S_IWUSR, 1, 0, 0,`
365			`};`
366
367			`void proc_root_init(void)`
368			`{`
369			`static int done = 0;`
370
371			`if (done)`
372			`return;`
373			`done = 1;`
374			`proc_base_init();`
375
376			`proc_register(&proc_root, &pde_loadavg);`
377			`proc_register(&proc_root, &pde_uptime);`
378			`proc_register(&proc_root, &pde_meminfo);`
379			`proc_register(&proc_root, &pde_kmsg);`
380			`proc_register(&proc_root, &pde_version);`
381			`#ifdef CONFIG_PCI`
382			`proc_register(&proc_root, &pde_pci);`
383			`#endif`
384			`proc_register(&proc_root, &pde_cpuinfo);`
385			`proc_register(&proc_root, &pde_self);`
386			`proc_register(&proc_root, &proc_net);`
387			`proc_register(&proc_root, &proc_scsi);`
388			`proc_register(&proc_root, &proc_sys_root);`
389			`proc_register(&proc_root, &pde_serial);`
390
391			`#ifdef CONFIG_DEBUG_MALLOC`
392			`proc_register(&proc_root, &pde_malloc);`
393			`#endif`
394			`proc_register(&proc_root, &pde_kcore);`
395
396			`#ifdef CONFIG_MODULES`
397			`proc_register(&proc_root, &pde_modules);`
398			`proc_register(&proc_root, &pde_ksyms);`
399			`#endif`
400			`proc_register(&proc_root, &pde_stat);`
401			`proc_register(&proc_root, &pde_devices);`
402			`proc_register(&proc_root, &pde_interrupts);`
403			`#ifdef __SMP_PROF__`
404			`proc_register(&proc_root, &pde_smp);`
405			`#endif`
406			`proc_register(&proc_root, &pde_filesystems);`
407			`proc_register(&proc_root, &pde_dma);`
408			`proc_register(&proc_root, &pde_ioports);`
409			`proc_register(&proc_root, &pde_cmdline);`
410			`#ifdef CONFIG_RTC`
411			`proc_register(&proc_root, &pde_rtc);`
412			`#endif`
413			`proc_register(&proc_root, &pde_locks);`
414
415			`proc_register( &proc_root, &pde_mounts);`
416
417			`if (prof_shift) {`
418			`proc_register(&proc_root, &pde_profile);`
419			`}`
420			`}`
421
422
423			`int proc_match(int len,const char * name,struct proc_dir_entry * de)`
424			`{`
425			`if (!de \|\| !de->low_ino)`
426			`return 0;`
427			`/* "" means "." ---> so paths like "/usr/lib//libc.a" work */`
428			`if (!len && (de->name[0]=='.') && (de->name[1]=='\0'))`
429			`return 1;`
430			`if (de->namelen != len)`
431			`return 0;`
432			`return !memcmp(name, de->name, len);`
433			`}`
434
435			`int proc_lookup(struct inode * dir,const char * name, int len,`
436			`struct inode ** result)`
437			`{`
438			`struct proc_dir_entry * de;`
439			`int ino;`
440
441			`*result = NULL;`
442			`if (!dir \|\| !S_ISDIR(dir->i_mode)) {`
443			`iput(dir);`
444			`return -ENOTDIR;`
445			`}`
446
447			`de = (struct proc_dir_entry *) dir->u.generic_ip;`
448			`if (!de) {`
449			`iput(dir);`
450			`return -EINVAL;`
451			`}`
452
453			`/* Special case "." and "..": they aren't on the directory list */`
454			`*result = dir;`
455			`if (!len)`
456			`return 0;`
457			`if (name[0] == '.') {`
458			`if (len == 1)`
459			`return 0;`
460			`if (name[1] == '.' && len == 2) {`
461			`struct inode * inode;`
462			`inode = proc_get_inode(dir->i_sb, de->parent->low_ino, de->parent);`
463			`iput(dir);`
464			`if (!inode)`
465			`return -EINVAL;`
466			`*result = inode;`
467			`return 0;`
468			`}`
469			`}`
470
471			`*result = NULL;`
472			`for (de = de->subdir; de ; de = de->next) {`
473			`if (proc_match(len, name, de))`
474			`break;`
475			`}`
476			`if (!de) {`
477			`iput(dir);`
478			`return -ENOENT;`
479			`}`
480
481			`ino = de->low_ino \| (dir->i_ino & ~(0xffff));`
482
483			`if (!(*result = proc_get_inode(dir->i_sb, ino, de))) {`
484			`iput(dir);`
485			`return -EINVAL;`
486			`}`
487			`iput(dir);`
488			`return 0;`
489			`}`
490
491			`static int proc_root_lookup(struct inode * dir,const char * name, int len,`
492			`struct inode ** result)`
493			`{`
494			`unsigned int pid, c;`
495			`int i, ino, retval;`
496
497			`dir->i_count++;`
498			`retval = proc_lookup(dir, name, len, result);`
499			`if (retval != -ENOENT) {`
500			`iput(dir);`
501			`return retval;`
502			`}`
503
504			`pid = 0;`
505			`while (len-- > 0) {`
506			`c = *name - '0';`
507			`name++;`
508			`if (c > 9) {`
509			`pid = 0;`
510			`break;`
511			`}`
512			`pid *= 10;`
513			`pid += c;`
514			`if (pid & 0xffff0000) {`
515			`pid = 0;`
516			`break;`
517			`}`
518			`}`
519			`for (i = 0 ; i < NR_TASKS ; i++)`
520			`if (task[i] && task[i]->pid == pid)`
521			`break;`
522			`if (!pid \|\| i >= NR_TASKS) {`
523			`iput(dir);`
524			`return -ENOENT;`
525			`}`
526			`ino = (pid << 16) + PROC_PID_INO;`
527			`if (!(*result = proc_get_inode(dir->i_sb, ino, &proc_pid))) {`
528			`iput(dir);`
529			`return -EINVAL;`
530			`}`
531			`iput(dir);`
532			`return 0;`
533			`}`
534
535			`/*`
536			`* This returns non-zero if at EOF, so that the /proc`
537			`* root directory can use this and check if it should`
538			`* continue with the <pid> entries..`
539			`*`
540			`* Note that the VFS-layer doesn't care about the return`
541			`* value of the readdir() call, as long as it's non-negative`
542			`* for success..`
543			`*/`
544			`int proc_readdir(struct inode * inode, struct file * filp,`
545			`void * dirent, filldir_t filldir)`
546			`{`
547			`struct proc_dir_entry * de;`
548			`unsigned int ino;`
549			`int i;`
550
551			`if (!inode \|\| !S_ISDIR(inode->i_mode))`
552			`return -ENOTDIR;`
553			`ino = inode->i_ino;`
554			`de = (struct proc_dir_entry *) inode->u.generic_ip;`
555			`if (!de)`
556			`return -EINVAL;`
557			`i = filp->f_pos;`
558			`switch (i) {`
559			`case 0:`
560			`if (filldir(dirent, ".", 1, i, ino) < 0)`
561			`return 0;`
562			`i++;`
563			`filp->f_pos++;`
564			`/* fall through */`
565			`case 1:`
566			`if (filldir(dirent, "..", 2, i, de->parent->low_ino) < 0)`
567			`return 0;`
568			`i++;`
569			`filp->f_pos++;`
570			`/* fall through */`
571			`default:`
572			`ino &= ~0xffff;`
573			`de = de->subdir;`
574			`i -= 2;`
575			`for (;;) {`
576			`if (!de)`
577			`return 1;`
578			`if (!i)`
579			`break;`
580			`de = de->next;`
581			`i--;`
582			`}`
583
584			`do {`
585			`if (filldir(dirent, de->name, de->namelen, filp->f_pos, ino \| de->low_ino) < 0)`
586			`return 0;`
587			`filp->f_pos++;`
588			`de = de->next;`
589			`} while (de);`
590			`}`
591			`return 1;`
592			`}`
593
594			`#define NUMBUF 10`
595
596			`static int proc_root_readdir(struct inode * inode, struct file * filp,`
597			`void * dirent, filldir_t filldir)`
598			`{`
599			`char buf[NUMBUF];`
600			`unsigned int nr,pid;`
601			`unsigned long i,j;`
602
603			`nr = filp->f_pos;`
604			`if (nr < FIRST_PROCESS_ENTRY) {`
605			`int error = proc_readdir(inode, filp, dirent, filldir);`
606			`if (error <= 0)`
607			`return error;`
608			`filp->f_pos = nr = FIRST_PROCESS_ENTRY;`
609			`}`
610
611			`for (nr -= FIRST_PROCESS_ENTRY; nr < NR_TASKS; nr++, filp->f_pos++) {`
612			`struct task_struct * p = task[nr];`
613
614			`if (!p \|\| !(pid = p->pid))`
615			`continue;`
616
617			`j = NUMBUF;`
618			`i = pid;`
619			`do {`
620			`j--;`
621			`buf[j] = '0' + (i % 10);`
622			`i /= 10;`
623			`} while (i);`
624
625			`if (filldir(dirent, buf+j, NUMBUF-j, filp->f_pos, (pid << 16) + PROC_PID_INO) < 0)`
626			`break;`
627			`}`
628			`return 0;`
629			`}`