sanchayanmaity/minix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Message types for VFS read, write & peek

Browse source 
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
This commit is contained in:
Lionel Sambuc 2014-04-28 20:19:19 +02:00
parent 27baf1f58a
commit 56350a991b
10 changed files with 97 additions and 72 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
include/minix/ipc.h
View file

@ -431,6 +431,26 @@ typedef struct {
} mess_fs_vfs_readsuper; } mess_fs_vfs_readsuper;
_ASSERT_MSG_SIZE(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 { typedef struct {
ino_t dir_old; ino_t dir_old;
ino_t dir_new; ino_t dir_new;
@ -593,6 +613,8 @@ typedef struct {
mess_vfs_fs_readsuper m_vfs_fs_readsuper; mess_vfs_fs_readsuper m_vfs_fs_readsuper;
mess_fs_vfs_readsuper m_fs_vfs_readsuper; mess_fs_vfs_readsuper m_fs_vfs_readsuper;
mess_vfs_fs_rename m_vfs_fs_rename; 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_slink m_vfs_fs_slink;
mess_vfs_fs_stat m_vfs_fs_stat; mess_vfs_fs_stat m_vfs_fs_stat;
mess_vfs_fs_statvfs m_vfs_fs_statvfs; mess_vfs_fs_statvfs m_vfs_fs_statvfs;

12
lib/libpuffs/read.c
View file

@ -37,16 +37,16 @@ int fs_readwrite(void)
struct vattr va; struct vattr va;
PUFFS_MAKECRED(pcr, &global_kcred); 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"); lpuffs_debug("walk failed...\n");
return(EINVAL); return(EINVAL);
} }
/* Get the values from the request message */ /* Get the values from the request message */
rw_flag = (fs_m_in.m_type == REQ_READ ? READING : WRITING); rw_flag = (fs_m_in.m_type == REQ_READ ? READING : WRITING);
gid = (cp_grant_id_t) fs_m_in.REQ_GRANT; gid = fs_m_in.m_vfs_fs_readwrite.grant;
pos = (off_t) fs_m_in.REQ_SEEK_POS; pos = fs_m_in.m_vfs_fs_readwrite.seek_pos;
nrbytes = bytes_left = (size_t) fs_m_in.REQ_NBYTES; nrbytes = bytes_left = fs_m_in.m_vfs_fs_readwrite.nbytes;
if (nrbytes > RW_BUFSIZ) if (nrbytes > RW_BUFSIZ)
nrbytes = bytes_left = RW_BUFSIZ; nrbytes = bytes_left = RW_BUFSIZ;
@ -98,8 +98,8 @@ int fs_readwrite(void)
if (r != OK) return(EINVAL); if (r != OK) return(EINVAL);
fs_m_out.RES_SEEK_POS = pos + bytes_done; fs_m_out.m_fs_vfs_readwrite.seek_pos = pos + bytes_done;
fs_m_out.RES_NBYTES = bytes_done; fs_m_out.m_fs_vfs_readwrite.nbytes = bytes_done;
return(r); return(r);
} }

14
lib/libsffs/read.c
View file

@ -22,13 +22,13 @@ int do_read(void)
/* Read data from a file. /* Read data from a file.
*/ */
struct inode *ino; struct inode *ino;
u64_t pos; off_t pos;
size_t count, size; size_t count, size;
vir_bytes off; vir_bytes off;
char *ptr; char *ptr;
int r, chunk; 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; return EINVAL;
if (IS_DIR(ino)) return EISDIR; if (IS_DIR(ino)) return EISDIR;
@ -36,8 +36,8 @@ int do_read(void)
if ((r = get_handle(ino)) != OK) if ((r = get_handle(ino)) != OK)
return r; return r;
pos = m_in.REQ_SEEK_POS; pos = m_in.m_vfs_fs_readwrite.seek_pos;
count = m_in.REQ_NBYTES; count = m_in.m_vfs_fs_readwrite.nbytes;
assert(count > 0); assert(count > 0);
@ -53,7 +53,7 @@ int do_read(void)
chunk = r; 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); (vir_bytes) ptr, chunk);
if (r != OK) if (r != OK)
@ -67,8 +67,8 @@ int do_read(void)
if (r < 0) if (r < 0)
return r; return r;
m_out.RES_SEEK_POS = pos; m_out.m_fs_vfs_readwrite.seek_pos = pos;
m_out.RES_NBYTES = off; m_out.m_fs_vfs_readwrite.nbytes = off;
return OK; return OK;
} }

14
lib/libsffs/write.c
View file

@ -81,7 +81,7 @@ int do_write(void)
/* Write data to a file. /* Write data to a file.
*/ */
struct inode *ino; struct inode *ino;
u64_t pos; off_t pos;
size_t count; size_t count;
cp_grant_id_t grant; cp_grant_id_t grant;
int r; int r;
@ -89,22 +89,22 @@ int do_write(void)
if (state.s_read_only) if (state.s_read_only)
return EROFS; 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; return EINVAL;
if (IS_DIR(ino)) return EISDIR; if (IS_DIR(ino)) return EISDIR;
pos = m_in.REQ_SEEK_POS; pos = m_in.m_vfs_fs_readwrite.seek_pos;
count = m_in.REQ_NBYTES; count = m_in.m_vfs_fs_readwrite.nbytes;
grant = m_in.REQ_GRANT; grant = m_in.m_vfs_fs_readwrite.grant;
if (count == 0) return EINVAL; if (count == 0) return EINVAL;
if ((r = write_file(ino, &pos, &count, &grant)) != OK) if ((r = write_file(ino, &pos, &count, &grant)) != OK)
return r; return r;
m_out.RES_SEEK_POS = pos; m_out.m_fs_vfs_readwrite.seek_pos = pos;
m_out.RES_NBYTES = count; m_out.m_fs_vfs_readwrite.nbytes = count;
return OK; return OK;
} }

16
lib/libvtreefs/read.c
View file

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

17
servers/ext2/read.c
View file

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

23
servers/iso9660fs/read.c
View file

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

17
servers/mfs/read.c
View file

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

14
servers/pfs/read.c
View file

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

20
servers/vfs/request.c
View file

@ -845,13 +845,13 @@ static int req_readwrite_actual(endpoint_t fs_e, ino_t inode_nr, off_t pos,
/* Fill in request message */ /* Fill in request message */
m.m_type = rw_flag == READING ? REQ_READ : REQ_WRITE; m.m_type = rw_flag == READING ? REQ_READ : REQ_WRITE;
m.REQ_INODE_NR = (pino_t) inode_nr; m.m_vfs_fs_readwrite.inode = inode_nr;
m.REQ_GRANT = grant_id; m.m_vfs_fs_readwrite.grant = grant_id;
m.REQ_SEEK_POS = pos; m.m_vfs_fs_readwrite.seek_pos = pos;
if ((!(vmp->m_fs_flags & RES_64BIT)) && (pos > INT_MAX)) { if ((!(vmp->m_fs_flags & RES_64BIT)) && (pos > INT_MAX)) {
return EINVAL; return EINVAL;
} }
m.REQ_NBYTES = num_of_bytes; m.m_vfs_fs_readwrite.nbytes = num_of_bytes;
/* Send/rec request */ /* Send/rec request */
r = fs_sendrec(fs_e, &m); 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) { if (r == OK) {
/* Fill in response structure */ /* Fill in response structure */
*new_posp = m.RES_SEEK_POS; *new_posp = m.m_fs_vfs_readwrite.seek_pos;
*cum_iop = m.RES_NBYTES; *cum_iop = m.m_fs_vfs_readwrite.nbytes;
} }
return(r); 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 */ /* Fill in request message */
m.m_type = REQ_PEEK; m.m_type = REQ_PEEK;
m.REQ_INODE_NR = inode_nr; m.m_vfs_fs_readwrite.inode = inode_nr;
m.REQ_GRANT = -1; m.m_vfs_fs_readwrite.grant = -1;
m.REQ_SEEK_POS = pos; m.m_vfs_fs_readwrite.seek_pos = pos;
m.REQ_NBYTES = bytes; m.m_vfs_fs_readwrite.nbytes = bytes;
/* Send/rec request */ /* Send/rec request */
return fs_sendrec(fs_e, &m); return fs_sendrec(fs_e, &m);