Message types for VFS read, write & peek

All of these requests share the same message type as at least one server
manages those requests in the same handler, just by checking the actual
type of the request, and then acting upon it.

Change-Id: I17337b4c67ae209523574c22ccc108cf5f1e65e9

diff --git a/include/minix/ipc.h b/include/minix/ipc.h
index 7c0a1ae3b5f1961047e60a5a30e6b621c7ca43f0..552e2b19a82f21102a2820081ca5a6b956744062 100644 (file)
--- a/include/minix/ipc.h
+++ b/include/minix/ipc.h
@@ -431,6 +431,26 @@ typedef struct {
 } mess_fs_vfs_readsuper;
 _ASSERT_MSG_SIZE(mess_fs_vfs_readsuper);
 
+typedef struct {
+       ino_t inode;
+       off_t seek_pos;
+
+       cp_grant_id_t grant;
+       size_t nbytes;
+
+       uint8_t data[32];
+} mess_vfs_fs_readwrite;
+_ASSERT_MSG_SIZE(mess_vfs_fs_readwrite);
+
+typedef struct {
+       off_t seek_pos;
+
+       size_t nbytes;
+
+       uint8_t data[44];
+} mess_fs_vfs_readwrite;
+_ASSERT_MSG_SIZE(mess_fs_vfs_readwrite);
+
 typedef struct {
        ino_t dir_old;
        ino_t dir_new;
@@ -593,6 +613,8 @@ typedef struct {
        mess_vfs_fs_readsuper m_vfs_fs_readsuper;
        mess_fs_vfs_readsuper m_fs_vfs_readsuper;
        mess_vfs_fs_rename m_vfs_fs_rename;
+       mess_vfs_fs_readwrite m_vfs_fs_readwrite;
+       mess_fs_vfs_readwrite m_fs_vfs_readwrite;
        mess_vfs_fs_slink m_vfs_fs_slink;
        mess_vfs_fs_stat m_vfs_fs_stat;
        mess_vfs_fs_statvfs m_vfs_fs_statvfs;

diff --git a/lib/libpuffs/read.c b/lib/libpuffs/read.c
index 9023e126b576dbc9991a31a7d23bca15ad4631dd..84ee644b64dbb33ff5255a3aca5efb2f1e8dc68f 100644 (file)
--- a/lib/libpuffs/read.c
+++ b/lib/libpuffs/read.c
@@ -37,16 +37,16 @@ int fs_readwrite(void)
   struct vattr va;
   PUFFS_MAKECRED(pcr, &global_kcred);
 
-  if ((pn = puffs_pn_nodewalk(global_pu, 0, &fs_m_in.REQ_INODE_NR)) == NULL) {
+  if ((pn = puffs_pn_nodewalk(global_pu, 0, &fs_m_in.m_vfs_fs_readwrite.inode)) == NULL) {
        lpuffs_debug("walk failed...\n");
         return(EINVAL);
   }
 
   /* Get the values from the request message */
   rw_flag = (fs_m_in.m_type == REQ_READ ? READING : WRITING);
-  gid = (cp_grant_id_t) fs_m_in.REQ_GRANT;
-  pos = (off_t) fs_m_in.REQ_SEEK_POS;
-  nrbytes = bytes_left = (size_t) fs_m_in.REQ_NBYTES;
+  gid = fs_m_in.m_vfs_fs_readwrite.grant;
+  pos = fs_m_in.m_vfs_fs_readwrite.seek_pos;
+  nrbytes = bytes_left = fs_m_in.m_vfs_fs_readwrite.nbytes;
 
   if (nrbytes > RW_BUFSIZ)
        nrbytes = bytes_left = RW_BUFSIZ;
@@ -98,8 +98,8 @@ int fs_readwrite(void)
 
   if (r != OK) return(EINVAL);
 
-  fs_m_out.RES_SEEK_POS = pos + bytes_done;
-  fs_m_out.RES_NBYTES = bytes_done;
+  fs_m_out.m_fs_vfs_readwrite.seek_pos = pos + bytes_done;
+  fs_m_out.m_fs_vfs_readwrite.nbytes = bytes_done;
 
   return(r);
 }

diff --git a/lib/libsffs/read.c b/lib/libsffs/read.c
index 9237f9806d2a574837c9e8053f6410eafb05aec9..a4bb9b5285dcbc0f10e41f08bf7559be0aa6f587 100644 (file)
--- a/lib/libsffs/read.c
+++ b/lib/libsffs/read.c
@@ -22,13 +22,13 @@ int do_read(void)
 /* Read data from a file.
  */
   struct inode *ino;
-  u64_t pos;
+  off_t pos;
   size_t count, size;
   vir_bytes off;
   char *ptr;
   int r, chunk;
 
-  if ((ino = find_inode(m_in.REQ_INODE_NR)) == NULL)
+  if ((ino = find_inode(m_in.m_vfs_fs_readwrite.inode)) == NULL)
        return EINVAL;
 
   if (IS_DIR(ino)) return EISDIR;
@@ -36,8 +36,8 @@ int do_read(void)
   if ((r = get_handle(ino)) != OK)
        return r;
 
-  pos = m_in.REQ_SEEK_POS;
-  count = m_in.REQ_NBYTES;
+  pos = m_in.m_vfs_fs_readwrite.seek_pos;
+  count = m_in.m_vfs_fs_readwrite.nbytes;
 
   assert(count > 0);
 
@@ -53,7 +53,7 @@ int do_read(void)
 
        chunk = r;
 
-       r = sys_safecopyto(m_in.m_source, m_in.REQ_GRANT, off,
+       r = sys_safecopyto(m_in.m_source, m_in.m_vfs_fs_readwrite.grant, off,
                (vir_bytes) ptr, chunk);
 
        if (r != OK)
@@ -67,8 +67,8 @@ int do_read(void)
   if (r < 0)
        return r;
 
-  m_out.RES_SEEK_POS = pos;
-  m_out.RES_NBYTES = off;
+  m_out.m_fs_vfs_readwrite.seek_pos = pos;
+  m_out.m_fs_vfs_readwrite.nbytes = off;
 
   return OK;
 }

diff --git a/lib/libsffs/write.c b/lib/libsffs/write.c
index 22cbfa7d2743901ce7e10c02cff2ff7deb157b55..7059a1aa728e9f0a1b39183316219ef9b0596d8d 100644 (file)
--- a/lib/libsffs/write.c
+++ b/lib/libsffs/write.c
@@ -81,7 +81,7 @@ int do_write(void)
 /* Write data to a file.
  */
   struct inode *ino;
-  u64_t pos;
+  off_t pos;
   size_t count;
   cp_grant_id_t grant;
   int r;
@@ -89,22 +89,22 @@ int do_write(void)
   if (state.s_read_only)
        return EROFS;
 
-  if ((ino = find_inode(m_in.REQ_INODE_NR)) == NULL)
+  if ((ino = find_inode(m_in.m_vfs_fs_readwrite.inode)) == NULL)
        return EINVAL;
 
   if (IS_DIR(ino)) return EISDIR;
 
-  pos = m_in.REQ_SEEK_POS;
-  count = m_in.REQ_NBYTES;
-  grant = m_in.REQ_GRANT;
+  pos = m_in.m_vfs_fs_readwrite.seek_pos;
+  count = m_in.m_vfs_fs_readwrite.nbytes;
+  grant = m_in.m_vfs_fs_readwrite.grant;
 
   if (count == 0) return EINVAL;
 
   if ((r = write_file(ino, &pos, &count, &grant)) != OK)
        return r;
 
-  m_out.RES_SEEK_POS = pos;
-  m_out.RES_NBYTES = count;
+  m_out.m_fs_vfs_readwrite.seek_pos = pos;
+  m_out.m_fs_vfs_readwrite.nbytes = count;
 
   return OK;
 }

diff --git a/lib/libvtreefs/read.c b/lib/libvtreefs/read.c
index 358a114f959f46d768c9ec113adde280c35d29e6..ad3d6c20228ffae9fef285e10b7bfd982359ca16 100644 (file)
--- a/lib/libvtreefs/read.c
+++ b/lib/libvtreefs/read.c
@@ -22,7 +22,7 @@ int fs_read(void)
        int r;
 
        /* Try to get inode by to its inode number. */
-       if ((node = find_inode(fs_m_in.REQ_INODE_NR)) == NULL)
+       if ((node = find_inode(fs_m_in.m_vfs_fs_readwrite.inode)) == NULL)
                return EINVAL;
 
        /* Check whether the node is a regular file. */
@@ -30,12 +30,12 @@ int fs_read(void)
                return EINVAL;
 
        /* Get the values from the request message. */
-       gid = fs_m_in.REQ_GRANT;
-       pos = fs_m_in.REQ_SEEK_POS;
+       gid = fs_m_in.m_vfs_fs_readwrite.grant;
+       pos = fs_m_in.m_vfs_fs_readwrite.seek_pos;
 
        /* Call the read hook, if any. */
        if (!is_inode_deleted(node) && vtreefs_hooks->read_hook != NULL) {
-               len = fs_m_in.REQ_NBYTES;
+               len = fs_m_in.m_vfs_fs_readwrite.nbytes;
 
                /* On success, the read hook provides us with a pointer to the
                 * resulting data. This avoids copying overhead.
@@ -43,11 +43,11 @@ int fs_read(void)
                r = vtreefs_hooks->read_hook(node, pos, &ptr, &len,
                        get_inode_cbdata(node));
 
-               assert(len <= fs_m_in.REQ_NBYTES);
+               assert(len <= fs_m_in.m_vfs_fs_readwrite.nbytes);
 
                /* Copy the resulting data to user space. */
                if (r == OK && len > 0) {
-                       r = sys_safecopyto(fs_m_in.m_source, fs_m_in.REQ_GRANT,
+                       r = sys_safecopyto(fs_m_in.m_source, fs_m_in.m_vfs_fs_readwrite.grant,
                                0, (vir_bytes) ptr, len);
                }
        } else {
@@ -57,8 +57,8 @@ int fs_read(void)
        }
 
        if (r == OK) {
-               fs_m_out.RES_SEEK_POS = pos + len;
-               fs_m_out.RES_NBYTES = len;
+               fs_m_out.m_fs_vfs_readwrite.seek_pos = pos + len;
+               fs_m_out.m_fs_vfs_readwrite.nbytes = len;
        }
 
        return r;

diff --git a/servers/ext2/read.c b/servers/ext2/read.c
index 130a82710a1e48c93dc9203b06784b3c82d57d98..09cb3ee50d1f0b056775bb8681a6eb37b183f64c 100644 (file)
--- a/servers/ext2/read.c
+++ b/servers/ext2/read.c
@@ -37,7 +37,7 @@ int fs_readwrite(void)
   cp_grant_id_t gid;
   off_t position, f_size, bytes_left;
   unsigned int off, cum_io, block_size, chunk;
-  pmode_t mode_word;
+  mode_t mode_word;
   int completed;
   struct inode *rip;
   size_t nrbytes;
@@ -45,7 +45,7 @@ int fs_readwrite(void)
   r = OK;
 
   /* Find the inode referred */
-  if ((rip = find_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+  if ((rip = find_inode(fs_dev, fs_m_in.m_vfs_fs_readwrite.inode)) == NULL)
        return(EINVAL);
 
   mode_word = rip->i_mode & I_TYPE;
@@ -69,9 +69,9 @@ int fs_readwrite(void)
        case REQ_PEEK: rw_flag = PEEKING; break;
        default: panic("odd request");
   }
-  gid = (cp_grant_id_t) fs_m_in.REQ_GRANT;
-  position = (off_t) fs_m_in.REQ_SEEK_POS;
-  nrbytes = (size_t) fs_m_in.REQ_NBYTES;
+  gid = fs_m_in.m_vfs_fs_readwrite.grant;
+  position = fs_m_in.m_vfs_fs_readwrite.seek_pos;
+  nrbytes = fs_m_in.m_vfs_fs_readwrite.nbytes;
 
   rdwt_err = OK;                /* set to EIO if disk error occurs */
 
@@ -106,8 +106,9 @@ int fs_readwrite(void)
        position += (off_t) chunk;    /* position within the file */
   }
 
-  fs_m_out.RES_SEEK_POS = position; /* It might change later and the VFS
-                                           has to know this value */
+  fs_m_out.m_fs_vfs_readwrite.seek_pos = position; /* It might change later
+                                                     and the VFS has to know
+                                                     this value */
 
   /* On write, update file size and access time. */
   if (rw_flag == WRITING) {
@@ -135,7 +136,7 @@ int fs_readwrite(void)
        rip->i_dirt = IN_DIRTY;          /* inode is thus now dirty */
   }
 
-  fs_m_out.RES_NBYTES = cum_io;
+  fs_m_out.m_fs_vfs_readwrite.nbytes = cum_io;
 
   return(r);
 }

diff --git a/servers/iso9660fs/read.c b/servers/iso9660fs/read.c
index c5717d90b72015fbad961d297e6d56c45786160e..75c2ac21d5b02a947d4bd3779265c23183d6bb77 100644 (file)
--- a/servers/iso9660fs/read.c
+++ b/servers/iso9660fs/read.c
@@ -14,7 +14,7 @@ static char getdents_buf[GETDENTS_BUFSIZ];
  *===========================================================================*/
 int fs_read(void) {
   int r, chunk, block_size;
-  int nrbytes;
+  size_t nrbytes;
   cp_grant_id_t gid;
   off_t position, f_size, bytes_left;
   unsigned int off, cum_io;
@@ -31,13 +31,13 @@ int fs_read(void) {
   r = OK;
   
   /* Try to get inode according to its index */
-  dir = get_dir_record(fs_m_in.REQ_INODE_NR);
+  dir = get_dir_record(fs_m_in.m_vfs_fs_readwrite.inode);
   if (dir == NULL) return(EINVAL); /* no inode found */
 
-  position = fs_m_in.REQ_SEEK_POS; 
-  nrbytes = (unsigned) fs_m_in.REQ_NBYTES; /* number of bytes to read */
+  position = fs_m_in.m_vfs_fs_readwrite.seek_pos;
+  nrbytes = fs_m_in.m_vfs_fs_readwrite.nbytes; /* number of bytes to read */
   block_size = v_pri.logical_block_size_l;
-  gid = fs_m_in.REQ_GRANT;
+  gid = fs_m_in.m_vfs_fs_readwrite.grant;
   f_size = dir->d_file_size;
 
   rdwt_err = OK;               /* set to EIO if disk error occurs */
@@ -45,18 +45,19 @@ int fs_read(void) {
   cum_io = 0;
   /* Split the transfer into chunks that don't span two blocks. */
   while (nrbytes != 0) {
-       off = (unsigned int) (position % block_size);
+       off = position % block_size;
           
        chunk = MIN(nrbytes, 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;
+       if (chunk > bytes_left) chunk = (int32_t) bytes_left;
       
        /* Read or write 'chunk' bytes. */
-       r = read_chunk(dir, ((u64_t)(position)), off, chunk, (unsigned) nrbytes, 
-                      gid, cum_io, block_size, &completed, rw);
+       r = read_chunk(dir, position, off, chunk,
+                       (uint32_t) nrbytes, gid, cum_io, block_size,
+                       &completed, rw);
 
        if (r != OK) break;     /* EOF reached */
        if (rdwt_err < 0) break;
@@ -67,12 +68,12 @@ int fs_read(void) {
        position += chunk;      /* position within the file */
   }
 
-  fs_m_out.RES_SEEK_POS = position; 
+  fs_m_out.m_fs_vfs_readwrite.seek_pos = position;
   
   if (rdwt_err != OK) r = rdwt_err;    /* check for disk error */
   if (rdwt_err == END_OF_FILE) r = OK;
   
-  fs_m_out.RES_NBYTES = cum_io; /*dir->d_file_size;*/
+  fs_m_out.m_fs_vfs_readwrite.nbytes = cum_io; /*dir->d_file_size;*/
   release_dir_record(dir);
 
   return(r);

diff --git a/servers/mfs/read.c b/servers/mfs/read.c
index f947cf57d7386c9f6da8502307b45ae9981b7beb..0d928efba5cfc19a04b2ec4f4db7aec6d6ef5461 100644 (file)
--- a/servers/mfs/read.c
+++ b/servers/mfs/read.c
@@ -30,7 +30,7 @@ int fs_readwrite(void)
   cp_grant_id_t gid;
   off_t position, f_size, bytes_left;
   unsigned int off, cum_io, block_size, chunk;
-  pmode_t mode_word;
+  mode_t mode_word;
   int completed;
   struct inode *rip;
   size_t nrbytes;
@@ -38,7 +38,7 @@ int fs_readwrite(void)
   r = OK;
   
   /* Find the inode referred */
-  if ((rip = find_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+  if ((rip = find_inode(fs_dev, (pino_t) fs_m_in.m_vfs_fs_readwrite.inode)) == NULL)
        return(EINVAL);
 
   mode_word = rip->i_mode & I_TYPE;
@@ -61,9 +61,9 @@ int fs_readwrite(void)
        case REQ_PEEK: rw_flag = PEEKING; break;
        default: panic("odd request");
   }
-  gid = (cp_grant_id_t) fs_m_in.REQ_GRANT;
-  position = (off_t) fs_m_in.REQ_SEEK_POS;
-  nrbytes = (size_t) fs_m_in.REQ_NBYTES;
+  gid = fs_m_in.m_vfs_fs_readwrite.grant;
+  position = fs_m_in.m_vfs_fs_readwrite.seek_pos;
+  nrbytes = fs_m_in.m_vfs_fs_readwrite.nbytes;
 
   lmfs_reset_rdwt_err();
 
@@ -113,8 +113,9 @@ int fs_readwrite(void)
          position += (off_t) chunk;    /* position within the file */
   }
 
-  fs_m_out.RES_SEEK_POS = position; /* It might change later and the VFS
-                                          has to know this value */
+  fs_m_out.m_fs_vfs_readwrite.seek_pos = position; /* It might change later and
+                                                   the VFS has to know this
+                                                   value */
   
   /* On write, update file size and access time. */
   if (rw_flag == WRITING) {
@@ -137,7 +138,7 @@ int fs_readwrite(void)
          IN_MARKDIRTY(rip);            /* inode is thus now dirty */
   }
   
-  fs_m_out.RES_NBYTES = cum_io;
+  fs_m_out.m_fs_vfs_readwrite.nbytes = cum_io;
   
   return(r);
 }

diff --git a/servers/pfs/read.c b/servers/pfs/read.c
index 342d0baf8dcebf9f121cf3d6cf098211e4f9d818..7a5100fb3b58a36c2d5ed82745e55720fc65abd2 100644 (file)
--- a/servers/pfs/read.c
+++ b/servers/pfs/read.c
@@ -15,13 +15,13 @@ int fs_readwrite(message *fs_m_in, message *fs_m_out)
   cp_grant_id_t gid;
   off_t position, f_size;
   unsigned int nrbytes, cum_io;
-  pmode_t mode_word;
+  mode_t mode_word;
   struct inode *rip;
-  pino_t inumb;
+  ino_t inumb;
 
   r = OK;
   cum_io = 0;
-  inumb = (pino_t) fs_m_in->REQ_INODE_NR;
+  inumb = fs_m_in->m_vfs_fs_readwrite.inode;
 
   /* Find the inode referred */
   if ((rip = find_inode(inumb)) == NULL) return(EINVAL);
@@ -32,8 +32,8 @@ int fs_readwrite(message *fs_m_in, message *fs_m_out)
 
   /* Get the values from the request message */
   rw_flag = (fs_m_in->m_type == REQ_READ ? READING : WRITING);
-  gid = (cp_grant_id_t) fs_m_in->REQ_GRANT;
-  nrbytes = (unsigned) fs_m_in->REQ_NBYTES;
+  gid = fs_m_in->m_vfs_fs_readwrite.grant;
+  nrbytes = (unsigned) fs_m_in->m_vfs_fs_readwrite.nbytes;
 
   /* We can't read beyond the max file position */
   if (nrbytes > PIPE_BUF) return(EFBIG);
@@ -87,8 +87,8 @@ int fs_readwrite(message *fs_m_in, message *fs_m_out)
        if (rw_flag == WRITING) rip->i_update |= CTIME | MTIME;
   }
 
-  fs_m_out->RES_NBYTES = (size_t) cum_io;
-  fs_m_out->RES_SEEK_POS = rip->i_size;
+  fs_m_out->m_fs_vfs_readwrite.nbytes = (size_t) cum_io;
+  fs_m_out->m_fs_vfs_readwrite.seek_pos = rip->i_size;
 
   put_inode(rip);
   put_block(rip->i_dev, rip->i_num);

diff --git a/servers/vfs/request.c b/servers/vfs/request.c
index d3bf60f13128ccea33733dbb894e94c30114e62f..64b6fb8ad91037aa90dafcf403437fcbf01e3155 100644 (file)
--- a/servers/vfs/request.c
+++ b/servers/vfs/request.c
@@ -845,13 +845,13 @@ static int req_readwrite_actual(endpoint_t fs_e, ino_t inode_nr, off_t pos,
 
   /* Fill in request message */
   m.m_type = rw_flag == READING ? REQ_READ : REQ_WRITE;
-  m.REQ_INODE_NR = (pino_t) inode_nr;
-  m.REQ_GRANT = grant_id;
-  m.REQ_SEEK_POS = pos;
+  m.m_vfs_fs_readwrite.inode = inode_nr;
+  m.m_vfs_fs_readwrite.grant = grant_id;
+  m.m_vfs_fs_readwrite.seek_pos = pos;
   if ((!(vmp->m_fs_flags & RES_64BIT)) && (pos > INT_MAX)) {
        return EINVAL;
   }
-  m.REQ_NBYTES = num_of_bytes;
+  m.m_vfs_fs_readwrite.nbytes = num_of_bytes;
 
   /* Send/rec request */
   r = fs_sendrec(fs_e, &m);
@@ -859,8 +859,8 @@ static int req_readwrite_actual(endpoint_t fs_e, ino_t inode_nr, off_t pos,
 
   if (r == OK) {
        /* Fill in response structure */
-       *new_posp = m.RES_SEEK_POS;
-       *cum_iop = m.RES_NBYTES;
+       *new_posp = m.m_fs_vfs_readwrite.seek_pos;
+       *cum_iop = m.m_fs_vfs_readwrite.nbytes;
   }
 
   return(r);
@@ -905,10 +905,10 @@ int req_peek(endpoint_t fs_e, ino_t inode_nr, off_t pos, unsigned int bytes)
 
   /* Fill in request message */
   m.m_type = REQ_PEEK;
-  m.REQ_INODE_NR = inode_nr;
-  m.REQ_GRANT = -1;
-  m.REQ_SEEK_POS = pos;
-  m.REQ_NBYTES = bytes;
+  m.m_vfs_fs_readwrite.inode = inode_nr;
+  m.m_vfs_fs_readwrite.grant = -1;
+  m.m_vfs_fs_readwrite.seek_pos = pos;
+  m.m_vfs_fs_readwrite.nbytes = bytes;
 
   /* Send/rec request */
   return fs_sendrec(fs_e, &m);