Return to read_write.c CVS log

Up to [Early Linux] / linux / fs

Annotation of linux/fs/read_write.c, revision 1.1.1.1

1.1       root        1: #include <sys/stat.h>
                      2: #include <errno.h>
                      3: #include <sys/types.h>
                      4: 
                      5: #include <linux/kernel.h>
                      6: #include <linux/sched.h>
                      7: #include <asm/segment.h>
                      8: 
                      9: extern int rw_char(int rw,int dev, char * buf, int count);
                     10: extern int read_pipe(struct m_inode * inode, char * buf, int count);
                     11: extern int write_pipe(struct m_inode * inode, char * buf, int count);
                     12: extern int block_read(int dev, off_t * pos, char * buf, int count);
                     13: extern int block_write(int dev, off_t * pos, char * buf, int count);
                     14: extern int file_read(struct m_inode * inode, struct file * filp,
                     15:                char * buf, int count);
                     16: extern int file_write(struct m_inode * inode, struct file * filp,
                     17:                char * buf, int count);
                     18: 
                     19: int sys_lseek(unsigned int fd,off_t offset, int origin)
                     20: {
                     21:        struct file * file;
                     22:        int tmp;
                     23: 
                     24:        if (fd >= NR_OPEN || !(file=current->filp[fd]) || !(file->f_inode)
                     25:           || !IS_BLOCKDEV(MAJOR(file->f_inode->i_dev)))
                     26:                return -EBADF;
                     27:        if (file->f_inode->i_pipe)
                     28:                return -ESPIPE;
                     29:        switch (origin) {
                     30:                case 0:
                     31:                        if (offset<0) return -EINVAL;
                     32:                        file->f_pos=offset;
                     33:                        break;
                     34:                case 1:
                     35:                        if (file->f_pos+offset<0) return -EINVAL;
                     36:                        file->f_pos += offset;
                     37:                        break;
                     38:                case 2:
                     39:                        if ((tmp=file->f_inode->i_size+offset) < 0)
                     40:                                return -EINVAL;
                     41:                        file->f_pos = tmp;
                     42:                        break;
                     43:                default:
                     44:                        return -EINVAL;
                     45:        }
                     46:        return file->f_pos;
                     47: }
                     48: 
                     49: int sys_read(unsigned int fd,char * buf,int count)
                     50: {
                     51:        struct file * file;
                     52:        struct m_inode * inode;
                     53: 
                     54:        if (fd>=NR_OPEN || count<0 || !(file=current->filp[fd]))
                     55:                return -EINVAL;
                     56:        if (!count)
                     57:                return 0;
                     58:        verify_area(buf,count);
                     59:        inode = file->f_inode;
                     60:        if (inode->i_pipe)
                     61:                return (file->f_mode&1)?read_pipe(inode,buf,count):-1;
                     62:        if (S_ISCHR(inode->i_mode))
                     63:                return rw_char(READ,inode->i_zone[0],buf,count);
                     64:        if (S_ISBLK(inode->i_mode))
                     65:                return block_read(inode->i_zone[0],&file->f_pos,buf,count);
                     66:        if (S_ISDIR(inode->i_mode) || S_ISREG(inode->i_mode)) {
                     67:                if (count+file->f_pos > inode->i_size)
                     68:                        count = inode->i_size - file->f_pos;
                     69:                if (count<=0)
                     70:                        return 0;
                     71:                return file_read(inode,file,buf,count);
                     72:        }
                     73:        printk("(Read)inode->i_mode=%06o\n\r",inode->i_mode);
                     74:        return -EINVAL;
                     75: }
                     76: 
                     77: int sys_write(unsigned int fd,char * buf,int count)
                     78: {
                     79:        struct file * file;
                     80:        struct m_inode * inode;
                     81:        
                     82:        if (fd>=NR_OPEN || count <0 || !(file=current->filp[fd]))
                     83:                return -EINVAL;
                     84:        if (!count)
                     85:                return 0;
                     86:        inode=file->f_inode;
                     87:        if (inode->i_pipe)
                     88:                return (file->f_mode&2)?write_pipe(inode,buf,count):-1;
                     89:        if (S_ISCHR(inode->i_mode))
                     90:                return rw_char(WRITE,inode->i_zone[0],buf,count);
                     91:        if (S_ISBLK(inode->i_mode))
                     92:                return block_write(inode->i_zone[0],&file->f_pos,buf,count);
                     93:        if (S_ISREG(inode->i_mode))
                     94:                return file_write(inode,file,buf,count);
                     95:        printk("(Write)inode->i_mode=%06o\n\r",inode->i_mode);
                     96:        return -EINVAL;
                     97: }

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