Subversion Repositories HelenOS

/* This file contains the heart of the mechanism used to read files.

 * Read requests are split up into chunks that do not cross block

 * boundaries. Each chunk is then processed in turn.

 */

/* Methods:

 * do_read:    perform the READ system call

 * read_map:   given an inode and file position, look up its zone number

 * rd_indir:   read an entry in an indirect block

 */

#include <stdio.h>

#include "fs.h"

#include "block.h"

#include "file.h"

#include "fproc.h"

#include "inode.h"

#include "super.h"

#include "param.h"

static int read_chunk(inode_t *rip, offset_t position,

        unsigned off, int chunk, char *buff);

int do_read()

{

    /* Perform read(fd, buffer, nbytes) call. */

    register inode_t *rip;

    register filp_t *f;

    offset_t bytes_left, f_size, position;

    unsigned int off, cum_io;

    int oflags, r, chunk;

    int regular;

    mode_t mode_word;

    void *old_addr;

    /* If the file descriptor is valid, get the inode, size and mode. */

    if (nbytes < 0)

        return FS_EINVAL;

    if ((f = get_filp(fd)) == NIL_FILP)

        return err_code;

    if (f->filp_mode == FILP_CLOSED)

        return FS_EIO;

    if (nbytes == 0)

        return 0;    

    position = f->filp_pos;

    if (position > MAX_FILE_POS)

        return FS_EINVAL;

    if (position + nbytes < position)

        return FS_EINVAL;   /* unsigned overflow */

    oflags = f->filp_flags;

    rip = f->filp_ino;

    f_size = rip->i_size;

    r = OK;  

    cum_io = 0;

    mode_word = rip->i_mode & I_TYPE;

    regular = (mode_word == I_REGULAR);

    status = OK;                /* set to EIO if disk error occurs */

    old_addr = fp->buffer; 

    /* Split the transfer into chunks that don't span two blocks. */

    while (nbytes != 0) {

        off = (unsigned int)(position % BLOCK_SIZE); /* offset in blk*/

        chunk = MIN(nbytes, BLOCK_SIZE - off);

        if (chunk < 0) {

            chunk = BLOCK_SIZE - off;

        }

        bytes_left = f_size - position;

        if (position >= f_size) {

            break;          /* we are beyond EOF */

        }

        if (chunk > bytes_left)

            chunk = (int)bytes_left;

        /* Read 'chunk' bytes. */

        r = read_chunk(rip, position, off, chunk, fp->buffer);

        if (status < 0)

            break;

        /* Update counters and pointers. */

        fp->buffer += chunk * sizeof(char);         /* user buffer address */

        nbytes -= chunk;        /* bytes yet to be read */

        cum_io += chunk;        /* bytes read so far */

            position += chunk;      /* position within the file */

    }

    if (bytes_left <= 0 || nbytes == 0)

        status = END_OF_FILE;

    fp->buffer = old_addr;

    f->filp_pos = position;

    rip->i_seek = NO_SEEK;

    if (status != OK) {

        r = status;     /* check for disk error */

    }

    if (status == END_OF_FILE) {

        r = OK;

    }

    if (r == OK) {

        fp->fp_cum_io_partial = 0;

        print_console("File was successfully read into buffer\n");

            return cum_io;

    }

    else {

        print_console("Some error occured during reading the file\n");

        return r;

    }

}

static int read_chunk(register inode_t *rip, offset_t position, unsigned off,

    int chunk, char *buff)

{

    /*

     * rip: pointer to inode for file to be read

     * position:    position within file to read or write

     * off:     off within the current block

     * chunk:   number of bytes to read or write

     * buff:    virtual address of the user buffer

     */

    /* Read (part of) a block. */

    register block_t *bp;

    block_num_t b;

    b = read_map(rip, position);

    /* Reading from a nonexistent block.  Must read as all zeros.*/

    if (b == NO_BLOCK) {

         bp = get_zero_block();    /* get a zero block */  

    }

    else {

        bp = get_block(b);

    }

    /* Copy a chunk from the block buffer to user space. */

    memcpy((void *)buff, (void *)(bp->b.b__data+off), chunk);

    return OK;

}

block_num_t read_map(register inode_t *rip, offset_t position)

{

    /* Given an inode and a position within the corresponding file, locate the

     * block (not zone) number in which that position is to be found and return it.

     */

    register block_t *bp;

    register zone_t z;

    int scale, boff, dzones, nr_indirects, index, zind, ex;

    block_num_t b;

    long excess, zone, block_pos;

    scale = rip->i_sp->s_log_zone_size;   /* for block-zone conversion */

    block_pos = position/BLOCK_SIZE;      /* relative blk # in file */

    zone = block_pos >> scale;    /* position's zone */

    boff = (int) (block_pos - (zone << scale) ); /* relative blk # within zone */

    dzones = rip->i_ndzones;

    nr_indirects = rip->i_nindirs;

    /* Is 'position' to be found in the inode itself? */

    if (zone < dzones) {

        zind = (int)zone;      /* index should be an int */

        z = rip->i_zone[zind];

        if (z == NO_ZONE)

           return NO_BLOCK;

        b = ((block_num_t) z << scale) + boff;

        return b;

    }

    /* It is not in the inode, so it must be single or double indirect. */

    excess = zone - dzones;       /* first Vx_NR_DZONES don't count */

    if (excess < nr_indirects) {

    /* 'position' can be located via the single indirect block. */

    z = rip->i_zone[dzones];

    }

    else {

    /* 'position' can be located via the double indirect block. */

        if ( (z = rip->i_zone[dzones+1]) == NO_ZONE)

            return NO_BLOCK;

        excess -= nr_indirects;         /* single indir doesn't count*/

        b = (block_num_t) z << scale;

        bp = get_block(b);              /* get double indirect block */

        index = (int) (excess/nr_indirects);

        z = rd_indir(bp, index);        /* z= zone for single*/

        excess = excess % nr_indirects;     /* index into single ind blk */

    }

    /* 'z' is zone num for single indirect block; 'excess' is index into it. */

    if (z == NO_ZONE)

        return NO_BLOCK;

    b = (block_num_t) z << scale;       /* b is blk # for single ind */

    bp = get_block(b);              /* get single indirect block */

    ex = (int) excess;          /* need an integer */

    z = rd_indir(bp, ex);           /* get block pointed to */

    if (z == NO_ZONE)

        return NO_BLOCK;

    b = ((block_num_t) z << scale) + boff;

    return b;

}

zone_t rd_indir(block_t *bp, int index)

{

    super_block_t *sp;

    zone_t zone;   

    sp = get_super();   /* need super block to find file sys type */

    /* read a zone from an indirect block */

    if (sp->s_version == V1) {

        zone = (zone_t)bp->b.b__v1_ind[index];

    }

    else {

        zone = (zone_t)bp->b.b__v2_ind[index];

    }

    if (zone != NO_ZONE && (zone < (zone_t)sp->s_firstdatazone || zone >= sp->s_zones)) {

        print_console_int("Illegal zone number %d ", zone);

        print_console_int("in indirect block, index %d\n", index);

    }

    return zone;

}