Return to file_dev.c CVS log

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

Annotation of linux/fs/minix/file_dev.c, revision 1.1.1.2

1.1       root        1: /*
                      2:  *  linux/fs/file_dev.c
                      3:  *
                      4:  *  (C) 1991  Linus Torvalds
                      5:  */
                      6: 
                      7: #include <errno.h>
                      8: #include <fcntl.h>
                      9: 
                     10: #include <linux/sched.h>
                     11: #include <linux/minix_fs.h>
                     12: #include <linux/kernel.h>
                     13: #include <asm/segment.h>
                     14: 
                     15: #define MIN(a,b) (((a)<(b))?(a):(b))
                     16: #define MAX(a,b) (((a)>(b))?(a):(b))
                     17: 
                     18: int minix_file_read(struct inode * inode, struct file * filp, char * buf, int count)
                     19: {
                     20:        int read,left,chars,nr;
                     21:        struct buffer_head * bh;
                     22: 
                     23:        if (filp->f_pos > inode->i_size)
                     24:                left = 0;
                     25:        else
                     26:                left = inode->i_size - filp->f_pos;
                     27:        if (left > count)
                     28:                left = count;
                     29:        read = 0;
                     30:        while (left > 0) {
                     31:                if (nr = bmap(inode,(filp->f_pos)>>BLOCK_SIZE_BITS)) {
                     32:                        if (!(bh=bread(inode->i_dev,nr)))
                     33:                                return read?read:-EIO;
                     34:                } else
                     35:                        bh = NULL;
                     36:                nr = filp->f_pos & (BLOCK_SIZE-1);
                     37:                chars = MIN( BLOCK_SIZE-nr , left );
                     38:                filp->f_pos += chars;
                     39:                left -= chars;
                     40:                read += chars;
                     41:                if (bh) {
1.1.1.2 ! root       42:                        memcpy_tofs(buf,nr+bh->b_data,chars);
        !            43:                        buf += chars;
1.1       root       44:                        brelse(bh);
                     45:                } else {
                     46:                        while (chars-->0)
                     47:                                put_fs_byte(0,buf++);
                     48:                }
                     49:        }
                     50:        inode->i_atime = CURRENT_TIME;
                     51:        return read;
                     52: }
                     53: 
                     54: int minix_file_write(struct inode * inode, struct file * filp, char * buf, int count)
                     55: {
                     56:        off_t pos;
                     57:        int written,block,c;
                     58:        struct buffer_head * bh;
                     59:        char * p;
                     60: 
                     61: /*
                     62:  * ok, append may not work when many processes are writing at the same time
                     63:  * but so what. That way leads to madness anyway.
                     64:  */
                     65:        if (filp->f_flags & O_APPEND)
                     66:                pos = inode->i_size;
                     67:        else
                     68:                pos = filp->f_pos;
                     69:        written = 0;
                     70:        while (written<count) {
                     71:                if (!(block = minix_create_block(inode,pos/BLOCK_SIZE))) {
                     72:                        if (!written)
                     73:                                written = -ENOSPC;
                     74:                        break;
                     75:                }
                     76:                if (!(bh=bread(inode->i_dev,block))) {
                     77:                        if (!written)
                     78:                                written = -EIO;
                     79:                        break;
                     80:                }
                     81:                c = pos % BLOCK_SIZE;
                     82:                p = c + bh->b_data;
                     83:                c = BLOCK_SIZE-c;
                     84:                if (c > count-written)
                     85:                        c = count-written;
                     86:                pos += c;
                     87:                if (pos > inode->i_size) {
                     88:                        inode->i_size = pos;
                     89:                        inode->i_dirt = 1;
                     90:                }
                     91:                written += c;
1.1.1.2 ! root       92:                memcpy_fromfs(p,buf,c);
        !            93:                buf += c;
        !            94:                bh->b_dirt = 1;
1.1       root       95:                brelse(bh);
                     96:        }
                     97:        inode->i_mtime = CURRENT_TIME;
                     98:        if (!(filp->f_flags & O_APPEND)) {
                     99:                filp->f_pos = pos;
                    100:                inode->i_ctime = CURRENT_TIME;
                    101:                inode->i_dirt = 1;
                    102:        }
                    103:        return written;
                    104: }

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