Return to inode.c CVS log

Up to [Early Linux] / linux / fs / proc

Annotation of linux/fs/proc/inode.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  *  linux/fs/proc/inode.c
                      3:  *
                      4:  *  Copyright (C) 1991, 1992  Linus Torvalds
                      5:  */
                      6: 
                      7: #include <linux/sched.h>
                      8: #include <linux/proc_fs.h>
                      9: #include <linux/kernel.h>
                     10: #include <linux/mm.h>
                     11: #include <linux/string.h>
                     12: #include <linux/stat.h>
                     13: 
                     14: #include <asm/system.h>
                     15: #include <asm/segment.h>
                     16: 
                     17: void proc_put_inode(struct inode *inode)
                     18: {
                     19:        inode->i_size = 0;
                     20: }
                     21: 
                     22: void proc_put_super(struct super_block *sb)
                     23: {
                     24:        lock_super(sb);
                     25:        sb->s_dev = 0;
                     26:        free_super(sb);
                     27: }
                     28: 
                     29: static struct super_operations proc_sops = { 
                     30:        proc_read_inode,
                     31:        proc_write_inode,
                     32:        proc_put_inode,
                     33:        proc_put_super,
                     34:        NULL,
                     35:        proc_statfs
                     36: };
                     37: 
                     38: struct super_block *proc_read_super(struct super_block *s,void *data)
                     39: {
                     40:        int dev=s->s_dev;
                     41: 
                     42:        lock_super(s);
                     43:        s->s_blocksize = 1024;
                     44:        s->s_magic = PROC_SUPER_MAGIC;
                     45:        s->s_dev = dev;
                     46:        s->s_op = &proc_sops;
                     47:        free_super(s);
                     48:        if (!(s->s_mounted = iget(dev,PROC_ROOT_INO))) {
                     49:                s->s_dev=0;
                     50:                printk("get root inode failed\n");
                     51:                return NULL;
                     52:        }
                     53:        return s;
                     54: }
                     55: 
                     56: void proc_statfs(struct super_block *sb, struct statfs *buf)
                     57: {
                     58:        put_fs_long(PROC_SUPER_MAGIC, &buf->f_type);
                     59:        put_fs_long(1024, &buf->f_bsize);
                     60:        put_fs_long(0, &buf->f_blocks);
                     61:        put_fs_long(0, &buf->f_bfree);
                     62:        put_fs_long(0, &buf->f_bavail);
                     63:        put_fs_long(0, &buf->f_files);
                     64:        put_fs_long(0, &buf->f_ffree);
                     65:        /* Don't know what value to put in buf->f_fsid */
                     66: }
                     67: 
                     68: int proc_bmap(struct inode * inode,int block)
                     69: {
                     70:        return 0;
                     71: }
                     72: 
                     73: int proc_create_block(struct inode * inode, int block)
                     74: {
                     75:        return 0;
                     76: }
                     77: 
                     78: void proc_read_inode(struct inode * inode)
                     79: {
                     80:        unsigned long ino, pid;
                     81:        struct task_struct * p;
                     82:        int i;
                     83:        
                     84:        inode->i_op = NULL;
                     85:        inode->i_mode = 0;
                     86:        inode->i_uid = 0;
                     87:        inode->i_gid = 0;
                     88:        inode->i_nlink = 1;
                     89:        inode->i_size = 0;
                     90:        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
                     91:        inode->i_blocks = inode->i_blksize = 0;
                     92:        ino = inode->i_ino;
                     93:        pid = ino >> 16;
                     94:        p = task[0];
                     95:        for (i = 0; i < NR_TASKS ; i++)
                     96:                if ((p = task[i]) && (p->pid == pid))
                     97:                        break;
                     98:        if (!p || i >= NR_TASKS)
                     99:                return;
                    100:        if (ino == PROC_ROOT_INO) {
                    101:                inode->i_mode = S_IFDIR | 0555;
                    102:                inode->i_op = &proc_root_inode_operations;
                    103:                return;
                    104:        }
                    105:        if (!pid)
                    106:                return;
                    107:        ino &= 0x0000ffff;
                    108:        inode->i_uid = p->euid;
                    109:        inode->i_gid = p->egid;
                    110:        switch (ino) {
                    111:                case 2:
                    112:                        inode->i_nlink = 2;
                    113:                        for (i = 1 ; i < NR_TASKS ; i++)
                    114:                                if (task[i])
                    115:                                        inode->i_nlink++;
                    116:                        inode->i_mode = S_IFDIR | 0500;
                    117:                        inode->i_op = &proc_base_inode_operations;
                    118:                        return;
                    119:                case 3:
                    120:                        inode->i_op = &proc_mem_inode_operations;
                    121:                        inode->i_mode = S_IFCHR | 0600;
                    122:                        inode->i_rdev = 0x0101;
                    123:                        return;
                    124:                case 4:
                    125:                case 5:
                    126:                case 6:
                    127:                        inode->i_op = &proc_link_inode_operations;
                    128:                        inode->i_size = 3;
                    129:                        inode->i_mode = S_IFLNK | 0700;
                    130:                        return;
                    131:                case 7:
                    132:                case 8:
                    133:                        inode->i_mode = S_IFDIR | 0500;
                    134:                        inode->i_op = &proc_fd_inode_operations;
                    135:                        inode->i_nlink = 2;
                    136:                        return;
                    137:        }
                    138:        switch (ino >> 8) {
                    139:                case 1:
                    140:                        ino &= 0xff;
                    141:                        if (ino >= NR_OPEN || !p->filp[ino])
                    142:                                return;
                    143:                        inode->i_op = &proc_link_inode_operations;
                    144:                        inode->i_size = 3;
                    145:                        inode->i_mode = S_IFLNK | 0700;
                    146:                        return;
                    147:                case 2:
                    148:                        ino &= 0xff;
                    149:                        if (ino >= p->numlibraries)
                    150:                                return;
                    151:                        inode->i_op = &proc_link_inode_operations;
                    152:                        inode->i_size = 3;
                    153:                        inode->i_mode = S_IFLNK | 0700;
                    154:                        return;
                    155:        }
                    156:        return;
                    157: }
                    158: 
                    159: void proc_write_inode(struct inode * inode)
                    160: {
                    161:        inode->i_dirt=0;
                    162: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.