minix/fs/pfs/read.c

   1 #include "fs.h"
   2 #include "buf.h"
   3 #include "inode.h"
   4 #include <minix/com.h>
   5 #include <string.h>
   6
   7
   8 /*===========================================================================*
   9  *                              fs_readwrite                                 *
  10  *===========================================================================*/
  11 int fs_readwrite(message *fs_m_in, message *fs_m_out)
  12 {
  13   int r, rw_flag;
  14   struct buf *bp;
  15   cp_grant_id_t gid;
  16   off_t position, f_size;
  17   size_t nrbytes, cum_io;
  18   mode_t mode_word;
  19   struct inode *rip;
  20   ino_t inumb;
  21
  22   r = OK;
  23   cum_io = 0;
  24   inumb = fs_m_in->m_vfs_fs_readwrite.inode;
  25
  26   /* Find the inode referred */
  27   if ((rip = find_inode(inumb)) == NULL) return(EINVAL);
  28
  29   mode_word = rip->i_mode & I_TYPE;
  30   if (mode_word != I_NAMED_PIPE) return(EIO);
  31   f_size = rip->i_size;
  32
  33   /* Get the values from the request message */
  34   rw_flag = (fs_m_in->m_type == REQ_READ ? READING : WRITING);
  35   gid = fs_m_in->m_vfs_fs_readwrite.grant;
  36   nrbytes = fs_m_in->m_vfs_fs_readwrite.nbytes;
  37
  38   /* We can't read beyond the max file position */
  39   if (nrbytes > PIPE_BUF) return(EFBIG);
  40
  41   /* Mark inode in use */
  42   if ((get_inode(rip->i_dev, rip->i_num)) == NULL) return(err_code);
  43   if ((bp = get_block(rip->i_dev, rip->i_num)) == NULL) return(err_code);
  44
  45   if (rw_flag == WRITING) {
  46         /* Check in advance to see if file will grow too big. */
  47         /* Casting nrbytes to signed is safe, because it's guaranteed not to
  48          * be beyond max signed value (i.e., MAX_FILE_POS).
  49          */
  50         position = rip->i_size;
  51         if ((unsigned) position + nrbytes > PIPE_BUF) {
  52                 put_inode(rip);
  53                 put_block(rip->i_dev, rip->i_num);
  54                 return(EFBIG);
  55         }
  56   } else {
  57         position = 0;
  58         if (nrbytes > rip->i_size) {
  59                 /* There aren't that many bytes to read */
  60                 nrbytes = rip->i_size;
  61         }
  62   }
  63
  64   if (rw_flag == READING) {
  65         /* Copy a chunk from the block buffer to user space. */
  66         r = sys_safecopyto(fs_m_in->m_source, gid, (vir_bytes) 0,
  67                 (vir_bytes) (bp->b_data+position), (size_t) nrbytes);
  68   } else {
  69         /* Copy a chunk from user space to the block buffer. */
  70         r = sys_safecopyfrom(fs_m_in->m_source, gid, (vir_bytes) 0,
  71                 (vir_bytes) (bp->b_data+position), (size_t) nrbytes);
  72   }
  73
  74   if (r == OK) {
  75         position += (signed) nrbytes; /* Update position */
  76         cum_io += nrbytes;
  77
  78         /* On write, update file size and access time. */
  79         if (rw_flag == WRITING) {
  80                 rip->i_size = position;
  81         } else {
  82                 memmove(bp->b_data, bp->b_data+nrbytes, rip->i_size - nrbytes);
  83                 rip->i_size -= nrbytes;
  84         }
  85
  86         if (rw_flag == READING) rip->i_update |= ATIME;
  87         if (rw_flag == WRITING) rip->i_update |= CTIME | MTIME;
  88   }
  89
  90   fs_m_out->m_fs_vfs_readwrite.nbytes = cum_io;
  91   fs_m_out->m_fs_vfs_readwrite.seek_pos = rip->i_size;
  92
  93   put_inode(rip);
  94   put_block(rip->i_dev, rip->i_num);
  95
  96   return(r);
  97 }