servers/vfs/read.c

   1 /* This file contains the heart of the mechanism used to read (and write)
   2  * files.  Read and write requests are split up into chunks that do not cross
   3  * block boundaries.  Each chunk is then processed in turn.  Reads on special
   4  * files are also detected and handled.
   5  *
   6  * The entry points into this file are
   7  *   do_read:    perform the READ system call by calling read_write
   8  *   do_getdents: read entries from a directory (GETDENTS)
   9  *   read_write: actually do the work of READ and WRITE
  10  *
  11  */
  12
  13 #include "fs.h"
  14 #include <fcntl.h>
  15 #include <unistd.h>
  16 #include <minix/com.h>
  17 #include <minix/u64.h>
  18 #include "file.h"
  19 #include "fproc.h"
  20 #include "scratchpad.h"
  21 #include "param.h"
  22 #include <dirent.h>
  23 #include <assert.h>
  24 #include <minix/vfsif.h>
  25 #include "vnode.h"
  26 #include "vmnt.h"
  27
  28
  29 /*===========================================================================*
  30  *                              do_read                                      *
  31  *===========================================================================*/
  32 int do_read()
  33 {
  34   return(do_read_write(READING));
  35 }
  36
  37
  38 /*===========================================================================*
  39  *                              lock_bsf                                     *
  40  *===========================================================================*/
  41 void lock_bsf(void)
  42 {
  43   struct fproc *org_fp;
  44   struct worker_thread *org_self;
  45
  46   if (mutex_trylock(&bsf_lock) == 0)
  47         return;
  48
  49   org_fp = fp;
  50   org_self = self;
  51
  52   if (mutex_lock(&bsf_lock) != 0)
  53         panic("unable to lock block special file lock");
  54
  55   fp = org_fp;
  56   self = org_self;
  57 }
  58
  59 /*===========================================================================*
  60  *                              unlock_bsf                                   *
  61  *===========================================================================*/
  62 void unlock_bsf(void)
  63 {
  64   if (mutex_unlock(&bsf_lock) != 0)
  65         panic("failed to unlock block special file lock");
  66 }
  67
  68 /*===========================================================================*
  69  *                              do_read_write                                *
  70  *===========================================================================*/
  71 int do_read_write(rw_flag)
  72 int rw_flag;                    /* READING or WRITING */
  73 {
  74 /* Perform read(fd, buffer, nbytes) or write(fd, buffer, nbytes) call. */
  75   struct filp *f;
  76   tll_access_t locktype;
  77   int r;
  78
  79   scratch(fp).file.fd_nr = job_m_in.fd;
  80   scratch(fp).io.io_buffer = job_m_in.buffer;
  81   scratch(fp).io.io_nbytes = (size_t) job_m_in.nbytes;
  82
  83   locktype = (rw_flag == READING) ? VNODE_READ : VNODE_WRITE;
  84   if ((f = get_filp(scratch(fp).file.fd_nr, locktype)) == NULL)
  85         return(err_code);
  86   if (((f->filp_mode) & (rw_flag == READING ? R_BIT : W_BIT)) == 0) {
  87         unlock_filp(f);
  88         return(f->filp_mode == FILP_CLOSED ? EIO : EBADF);
  89   }
  90   if (scratch(fp).io.io_nbytes == 0) {
  91         unlock_filp(f);
  92         return(0);      /* so char special files need not check for 0*/
  93   }
  94
  95   r = read_write(rw_flag, f, scratch(fp).io.io_buffer, scratch(fp).io.io_nbytes,
  96                  who_e);
  97
  98   unlock_filp(f);
  99   return(r);
 100 }
 101
 102 /*===========================================================================*
 103  *                              read_write                                   *
 104  *===========================================================================*/
 105 int read_write(int rw_flag, struct filp *f, char *buf, size_t size,
 106                       endpoint_t for_e)
 107 {
 108   register struct vnode *vp;
 109   u64_t position, res_pos, new_pos;
 110   unsigned int cum_io, cum_io_incr, res_cum_io;
 111   int op, oflags, r;
 112
 113   position = f->filp_pos;
 114   oflags = f->filp_flags;
 115   vp = f->filp_vno;
 116   r = OK;
 117   cum_io = 0;
 118
 119   if (size > SSIZE_MAX) return(EINVAL);
 120
 121   if (S_ISFIFO(vp->v_mode)) {
 122         if (fp->fp_cum_io_partial != 0) {
 123                 panic("VFS: read_write: fp_cum_io_partial not clear");
 124         }
 125         r = rw_pipe(rw_flag, for_e, f, buf, size);
 126         return(r);
 127   }
 128
 129   op = (rw_flag == READING ? VFS_DEV_READ : VFS_DEV_WRITE);
 130
 131   if (S_ISCHR(vp->v_mode)) {    /* Character special files. */
 132         dev_t dev;
 133         int suspend_reopen;
 134
 135         if (vp->v_sdev == NO_DEV)
 136                 panic("VFS: read_write tries to access char dev NO_DEV");
 137
 138         suspend_reopen = (f->filp_state & FS_NEEDS_REOPEN);
 139         dev = (dev_t) vp->v_sdev;
 140
 141         r = dev_io(op, dev, for_e, buf, position, size, oflags,
 142                    suspend_reopen);
 143         if (r >= 0) {
 144                 cum_io = r;
 145                 position = add64ul(position, r);
 146                 r = OK;
 147         }
 148   } else if (S_ISBLK(vp->v_mode)) {     /* Block special files. */
 149         if (vp->v_sdev == NO_DEV)
 150                 panic("VFS: read_write tries to access block dev NO_DEV");
 151
 152         lock_bsf();
 153
 154         r = req_breadwrite(vp->v_bfs_e, for_e, vp->v_sdev, position, size,
 155                            buf, rw_flag, &res_pos, &res_cum_io);
 156         if (r == OK) {
 157                 position = res_pos;
 158                 cum_io += res_cum_io;
 159         }
 160
 161         unlock_bsf();
 162   } else {                              /* Regular files */
 163         if (rw_flag == WRITING) {
 164                 /* Check for O_APPEND flag. */
 165                 if (oflags & O_APPEND) position = cvul64(vp->v_size);
 166         }
 167
 168         /* Issue request */
 169         r = req_readwrite(vp->v_fs_e, vp->v_inode_nr, position, rw_flag, for_e,
 170                           buf, size, &new_pos, &cum_io_incr);
 171
 172         if (r >= 0) {
 173                 if (ex64hi(new_pos))
 174                         panic("read_write: bad new pos");
 175
 176                 position = new_pos;
 177                 cum_io += cum_io_incr;
 178         }
 179   }
 180
 181   /* On write, update file size and access time. */
 182   if (rw_flag == WRITING) {
 183         if (S_ISREG(vp->v_mode) || S_ISDIR(vp->v_mode)) {
 184                 if (cmp64ul(position, vp->v_size) > 0) {
 185                         if (ex64hi(position) != 0) {
 186                                 panic("read_write: file size too big ");
 187                         }
 188                         vp->v_size = ex64lo(position);
 189                 }
 190         }
 191   }
 192
 193   f->filp_pos = position;
 194
 195   if (r == OK) return(cum_io);
 196   return(r);
 197 }
 198
 199 /*===========================================================================*
 200  *                              do_getdents                                  *
 201  *===========================================================================*/
 202 int do_getdents()
 203 {
 204 /* Perform the getdents(fd, buf, size) system call. */
 205   int r = OK;
 206   u64_t new_pos;
 207   register struct filp *rfilp;
 208
 209   scratch(fp).file.fd_nr = job_m_in.fd;
 210   scratch(fp).io.io_buffer = job_m_in.buffer;
 211   scratch(fp).io.io_nbytes = (size_t) job_m_in.nbytes;
 212
 213   /* Is the file descriptor valid? */
 214   if ( (rfilp = get_filp(scratch(fp).file.fd_nr, VNODE_READ)) == NULL)
 215         return(err_code);
 216
 217   if (!(rfilp->filp_mode & R_BIT))
 218         r = EBADF;
 219   else if (!S_ISDIR(rfilp->filp_vno->v_mode))
 220         r = EBADF;
 221
 222   if (r == OK) {
 223         if (ex64hi(rfilp->filp_pos) != 0)
 224                 panic("do_getdents: can't handle large offsets");
 225
 226         r = req_getdents(rfilp->filp_vno->v_fs_e, rfilp->filp_vno->v_inode_nr,
 227                          rfilp->filp_pos, scratch(fp).io.io_buffer,
 228                          scratch(fp).io.io_nbytes, &new_pos,0);
 229
 230         if (r > 0) rfilp->filp_pos = new_pos;
 231   }
 232
 233   unlock_filp(rfilp);
 234   return(r);
 235 }
 236
 237
 238 /*===========================================================================*
 239  *                              rw_pipe                                      *
 240  *===========================================================================*/
 241 int rw_pipe(rw_flag, usr_e, f, buf, req_size)
 242 int rw_flag;                    /* READING or WRITING */
 243 endpoint_t usr_e;
 244 struct filp *f;
 245 char *buf;
 246 size_t req_size;
 247 {
 248   int r, oflags, partial_pipe = 0;
 249   size_t size, cum_io, cum_io_incr;
 250   struct vnode *vp;
 251   u64_t position, new_pos;
 252
 253   /* Must make sure we're operating on locked filp and vnode */
 254   assert(tll_islocked(&f->filp_vno->v_lock));
 255   assert(mutex_trylock(&f->filp_lock) == -EDEADLK);
 256
 257   oflags = f->filp_flags;
 258   vp = f->filp_vno;
 259   position = cvu64((rw_flag == READING) ? vp->v_pipe_rd_pos :
 260                                                         vp->v_pipe_wr_pos);
 261   /* fp->fp_cum_io_partial is only nonzero when doing partial writes */
 262   cum_io = fp->fp_cum_io_partial;
 263
 264   r = pipe_check(vp, rw_flag, oflags, req_size, position, 0);
 265   if (r <= 0) {
 266         if (r == SUSPEND) pipe_suspend(f, buf, req_size);
 267         return(r);
 268   }
 269
 270   size = r;
 271   if (size < req_size) partial_pipe = 1;
 272
 273   /* Truncate read request at size. */
 274   if((rw_flag == READING) &&
 275         cmp64ul(add64ul(position, size), vp->v_size) > 0) {
 276         /* Position always should fit in an off_t (LONG_MAX). */
 277         off_t pos32;
 278
 279         assert(cmp64ul(position, LONG_MAX) <= 0);
 280         pos32 = cv64ul(position);
 281         assert(pos32 >= 0);
 282         assert(pos32 <= LONG_MAX);
 283         size = vp->v_size - pos32;
 284   }
 285
 286   if (vp->v_mapfs_e == 0)
 287         panic("unmapped pipe");
 288
 289   r = req_readwrite(vp->v_mapfs_e, vp->v_mapinode_nr, position, rw_flag, usr_e,
 290                     buf, size, &new_pos, &cum_io_incr);
 291
 292   if (r >= 0) {
 293         if (ex64hi(new_pos))
 294                 panic("rw_pipe: bad new pos");
 295
 296         position = new_pos;
 297         cum_io += cum_io_incr;
 298         buf += cum_io_incr;
 299         req_size -= cum_io_incr;
 300   }
 301
 302   /* On write, update file size and access time. */
 303   if (rw_flag == WRITING) {
 304         if (cmp64ul(position, vp->v_size) > 0) {
 305                 if (ex64hi(position) != 0) {
 306                         panic("read_write: file size too big for v_size");
 307                 }
 308                 vp->v_size = ex64lo(position);
 309         }
 310   } else {
 311         if (cmp64ul(position, vp->v_size) >= 0) {
 312                 /* Reset pipe pointers */
 313                 vp->v_size = 0;
 314                 vp->v_pipe_rd_pos= 0;
 315                 vp->v_pipe_wr_pos= 0;
 316                 position = cvu64(0);
 317         }
 318   }
 319
 320   if (rw_flag == READING)
 321         vp->v_pipe_rd_pos= cv64ul(position);
 322   else
 323         vp->v_pipe_wr_pos= cv64ul(position);
 324
 325   if (r == OK) {
 326         if (partial_pipe) {
 327                 /* partial write on pipe with */
 328                 /* O_NONBLOCK, return write count */
 329                 if (!(oflags & O_NONBLOCK)) {
 330                         /* partial write on pipe with req_size > PIPE_SIZE,
 331                          * non-atomic
 332                          */
 333                         fp->fp_cum_io_partial = cum_io;
 334                         pipe_suspend(f, buf, req_size);
 335                         return(SUSPEND);
 336                 }
 337         }
 338         fp->fp_cum_io_partial = 0;
 339         return(cum_io);
 340   }
 341
 342   return(r);
 343 }