tacit/minix
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

VFS: use 64-bit file offsets in all requests

Browse Source 
Change-Id: I07189d410094b193cb7bbd3f2507537bb1e7f96c
This commit is contained in:
Thomas Veerman 2013-03-25 16:08:04 +00:00
parent c13b6a1fd2
commit 03b6be1bf9
15 changed files with 160 additions and 182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
include/minix/vfsif.h
View File

@ -56,12 +56,13 @@
#define RES_PROTO m9_s3
/* RES_PROTO is defined as follows:
* |----------------|
* 7V 4CR 0
* |--------------------------------|
* 8O7 V 4 CR 0
* 15 0
* mentioned bits are inclusive
* CR: bits 4-0 encode no. concurrent requests are supported by FS
* V: bits 7-5 encode version of protocol
* O: bit 8 encodes support for 64-bit file offsets
*/
#define RES_PROTO_CR_SHIFT 0
#define RES_PROTO_CR_MASK 0x1F
@ -74,6 +75,8 @@
#define VFS_FS_PROTO_PUT_VERSION(b,v) \
((b) |= (((v) << RES_PROTO_V_SHIFT) & RES_PROTO_V_MASK))
#define VFS_FS_CURRENT_VERSION 1 /* Current version */
#define RES_PROTO_BIGOFFT_SHIFT 8
#define VFS_FS_PROTO_BIGOFFT(b) (b & RES_PROTO_BIGOFFT_SHIFT)
/* VFS/FS flags */
#define REQ_RDONLY 001

4
servers/vfs/device.c
View File

@ -395,7 +395,7 @@ int dev_io(
dev_t dev, /* major-minor device number */
int proc_e, /* in whose address space is buf? */
void *buf, /* virtual address of the buffer */
u64_t pos, /* byte position */
off_t pos, /* byte position */
size_t bytes, /* how many bytes to transfer */
int flags, /* special flags, like O_NONBLOCK */
int suspend_reopen /* Just suspend the process */
@ -680,7 +680,7 @@ int do_ioctl()
if (S_ISBLK(vp->v_mode))
r = bdev_ioctl(dev, who_e, ioctlrequest, argx);
else
r = dev_io(VFS_DEV_IOCTL, dev, who_e, argx, cvu64(0),
r = dev_io(VFS_DEV_IOCTL, dev, who_e, argx, 0,
ioctlrequest, f->filp_flags, suspend_reopen);
}

14
servers/vfs/exec.c
View File

@ -487,9 +487,8 @@ char path[PATH_MAX]; /* path to script file */
*/
enum { INSERT=FALSE, REPLACE=TRUE };
int n, r;
off_t pos;
off_t pos, new_pos;
char *sp, *interp = NULL;
u64_t new_pos;
unsigned int cum_io;
char buf[_MAX_BLOCK_SIZE];
@ -499,7 +498,7 @@ char path[PATH_MAX]; /* path to script file */
pos = 0; /* Read from the start of the file */
/* Issue request */
r = req_readwrite(vp->v_fs_e, vp->v_inode_nr, cvul64(pos), READING,
r = req_readwrite(vp->v_fs_e, vp->v_inode_nr, pos, READING,
VFS_PROC_NR, buf, _MAX_BLOCK_SIZE, &new_pos, &cum_io);
if (r != OK) return(r);
@ -616,7 +615,7 @@ static int read_seg(struct exec_info *execi, off_t off, off_t seg_addr, size_t s
* partially initialized.
*/
int r;
u64_t new_pos;
off_t new_pos;
unsigned int cum_io;
struct vnode *vp = ((struct vfs_exec_info *) execi->opaque)->vp;
@ -624,7 +623,7 @@ static int read_seg(struct exec_info *execi, off_t off, off_t seg_addr, size_t s
if (off + seg_bytes > LONG_MAX) return(EIO);
if ((unsigned long) vp->v_size < off+seg_bytes) return(EIO);
if ((r = req_readwrite(vp->v_fs_e, vp->v_inode_nr, cvul64(off), READING,
if ((r = req_readwrite(vp->v_fs_e, vp->v_inode_nr, off, READING,
execi->proc_e, (char*)seg_addr, seg_bytes,
&new_pos, &cum_io)) != OK) {
printf("VFS: read_seg: req_readwrite failed (data)\n");
@ -659,9 +658,8 @@ static void clo_exec(struct fproc *rfp)
static int map_header(struct vfs_exec_info *execi)
{
int r;
u64_t new_pos;
unsigned int cum_io;
off_t pos;
off_t pos, new_pos;
static char hdr[PAGE_SIZE]; /* Assume that header is not larger than a page */
pos = 0; /* Read from the start of the file */
@ -671,7 +669,7 @@ static int map_header(struct vfs_exec_info *execi)
execi->args.hdr = hdr;
r = req_readwrite(execi->vp->v_fs_e, execi->vp->v_inode_nr,
cvul64(pos), READING, VFS_PROC_NR, hdr,
pos, READING, VFS_PROC_NR, hdr,
execi->args.hdr_len, &new_pos, &cum_io);
if (r != OK) {
printf("VFS: exec: map_header: req_readwrite failed\n");

2
servers/vfs/file.h
View File

@ -11,7 +11,7 @@ EXTERN struct filp {
int filp_state; /* state for crash recovery */
int filp_count; /* how many file descriptors share this slot?*/
struct vnode *filp_vno; /* vnode belonging to this file */
u64_t filp_pos; /* file position */
off_t filp_pos; /* file position */
mutex_t filp_lock; /* lock to gain exclusive access */
struct fproc *filp_softlock; /* if not NULL; this filp didn't lock the
* vnode. Another filp already holds a lock

2
servers/vfs/filedes.c
View File

@ -177,7 +177,7 @@ int get_fd(int start, mode_t bits, int *k, struct filp **fpt)
assert(f->filp_count >= 0);
if (f->filp_count == 0 && mutex_trylock(&f->filp_lock) == 0) {
f->filp_mode = bits;
f->filp_pos = cvu64(0);
f->filp_pos = 0;
f->filp_selectors = 0;
f->filp_select_ops = 0;
f->filp_pipe_select_ops = 0;

6
servers/vfs/lock.c
View File

@ -66,11 +66,7 @@ int req; /* either F_SETLK or F_SETLKW */
/* Compute the first and last bytes in the lock region. */
switch (flock.l_whence) {
case SEEK_SET: first = 0; break;
case SEEK_CUR:
if (ex64hi(f->filp_pos) != 0)
panic("lock_op: position in file too high");
first = ex64lo(f->filp_pos);
break;
case SEEK_CUR: first = f->filp_pos; break;
case SEEK_END: first = f->filp_vno->v_size; break;
default: return(EINVAL);
}

6
servers/vfs/misc.c
View File

@ -212,11 +212,7 @@ int do_fcntl()
/* Figure out starting position base. */
switch(flock_arg.l_whence) {
case SEEK_SET: start = 0; break;
case SEEK_CUR:
if (ex64hi(f->filp_pos) != 0)
panic("do_fcntl: position in file too high");
start = ex64lo(f->filp_pos);
break;
case SEEK_CUR: start = f->filp_pos; break;
case SEEK_END: start = f->filp_vno->v_size; break;
default: r = EINVAL;
}

91
servers/vfs/open.c
View File

@ -596,7 +596,7 @@ int do_lseek_321()
register struct filp *rfilp;
int r = OK, seekfd, seekwhence;
i32_t offset;
u64_t pos, newpos;
off_t pos, newpos;
seekfd = job_m_in.ls_fd;
seekwhence = job_m_in.whence;
@ -613,27 +613,24 @@ int do_lseek_321()
/* The value of 'whence' determines the start position to use. */
switch(seekwhence) {
case SEEK_SET: pos = cvu64(0); break;
case SEEK_SET: pos = 0; break;
case SEEK_CUR: pos = rfilp->filp_pos; break;
case SEEK_END: pos = cvul64(rfilp->filp_vno->v_size); break;
case SEEK_END: pos = rfilp->filp_vno->v_size; break;
default: unlock_filp(rfilp); return(EINVAL);
}
if (offset >= 0)
newpos = add64ul(pos, offset);
else
newpos = sub64ul(pos, -offset);
newpos = pos + offset;
/* Check for overflow. */
if (ex64hi(newpos) != 0) {
if (newpos > INT_MAX) { /* This is for backwards compatibility */
r = EOVERFLOW;
} else if ((i32_t) ex64lo(newpos) < 0) { /* no negative file size */
} else if (newpos < 0) { /* no negative file size */
r = EOVERFLOW;
} else {
/* insert the new position into the output message */
m_out.reply_l1 = ex64lo(newpos);
m_out.reply_l1 = (long) newpos;
if (cmp64(newpos, rfilp->filp_pos) != 0) {
if (newpos != rfilp->filp_pos) {
rfilp->filp_pos = newpos;
/* Inhibit read ahead request */
@ -655,7 +652,7 @@ int do_lseek()
register struct filp *rfilp;
int r = OK, seekfd, seekwhence;
off_t offset;
u64_t pos, newpos;
off_t pos, newpos;
seekfd = job_m_in.ls_fd;
seekwhence = job_m_in.whence;
@ -672,22 +669,23 @@ int do_lseek()
/* The value of 'whence' determines the start position to use. */
switch(seekwhence) {
case SEEK_SET: pos = cvu64(0); break;
case SEEK_SET: pos = 0; break;
case SEEK_CUR: pos = rfilp->filp_pos; break;
case SEEK_END: pos = cvul64(rfilp->filp_vno->v_size); break;
case SEEK_END: pos = rfilp->filp_vno->v_size; break;
default: unlock_filp(rfilp); return(EINVAL);
}
if (offset < 0 && -offset > pos) { /* no negative file size */
r = EOVERFLOW;
} else {
newpos = pos + offset;
if (newpos < 0) { /* no negative file size */
r = EOVERFLOW;
} else {
/* insert the new position into the output message */
m_out.reply_l1 = ex64lo(newpos);
m_out.reply_l2 = ex64hi(newpos);
if (cmp64(newpos, rfilp->filp_pos) != 0) {
if (newpos != rfilp->filp_pos) {
rfilp->filp_pos = newpos;
/* Inhibit read ahead request */
@ -700,63 +698,6 @@ int do_lseek()
return(r);
}
/*===========================================================================*
* do_llseek *
*===========================================================================*/
int do_llseek()
{
/* Perform the llseek(ls_fd, offset, whence) system call. */
register struct filp *rfilp;
u64_t pos, newpos;
int r = OK, seekfd, seekwhence;
long off_hi, off_lo;
seekfd = job_m_in.ls_fd;
seekwhence = job_m_in.whence;
off_hi = job_m_in.offset_high;
off_lo = job_m_in.offset_lo;
/* Check to see if the file descriptor is valid. */
if ( (rfilp = get_filp(seekfd, VNODE_READ)) == NULL) return(err_code);
/* No lseek on pipes. */
if (S_ISFIFO(rfilp->filp_vno->v_mode)) {
unlock_filp(rfilp);
return(ESPIPE);
}
/* The value of 'whence' determines the start position to use. */
switch(seekwhence) {
case SEEK_SET: pos = cvu64(0); break;
case SEEK_CUR: pos = rfilp->filp_pos; break;
case SEEK_END: pos = cvul64(rfilp->filp_vno->v_size); break;
default: unlock_filp(rfilp); return(EINVAL);
}
newpos = add64(pos, make64(off_lo, off_hi));
/* Check for overflow. */
if ((off_hi > 0) && cmp64(newpos, pos) < 0)
r = EINVAL;
else if ((off_hi < 0) && cmp64(newpos, pos) > 0)
r = EINVAL;
else {
/* insert the new position into the output message */
m_out.reply_l1 = ex64lo(newpos);
m_out.reply_l2 = ex64hi(newpos);
if (cmp64(newpos, rfilp->filp_pos) != 0) {
rfilp->filp_pos = newpos;
/* Inhibit read ahead request */
r = req_inhibread(rfilp->filp_vno->v_fs_e,
rfilp->filp_vno->v_inode_nr);
}
}
unlock_filp(rfilp);
return(r);
}
/*===========================================================================*
* do_close *

4
servers/vfs/path.c
View File

@ -615,12 +615,12 @@ char ename[NAME_MAX + 1];
{
#define DIR_ENTRIES 8
#define DIR_ENTRY_SIZE (sizeof(struct dirent) + NAME_MAX)
u64_t pos, new_pos;
off_t pos, new_pos;
int r, consumed, totalbytes, name_len;
char buf[DIR_ENTRY_SIZE * DIR_ENTRIES];
struct dirent *cur;
pos = make64(0, 0);
pos = 0;
if (!S_ISDIR(dirp->v_mode)) return(EBADF);

14
servers/vfs/proto.h
View File

@ -34,7 +34,7 @@ void dev_reply(struct dmap *dp);
int dev_close(dev_t dev, int filp_no);
int bdev_open(dev_t dev, int access);
int bdev_close(dev_t dev);
int dev_io(int op, dev_t dev, endpoint_t proc_e, void *buf, u64_t pos,
int dev_io(int op, dev_t dev, endpoint_t proc_e, void *buf, off_t pos,
size_t bytes, int flags, int suspend_reopen);
int gen_opcl(int op, dev_t dev, endpoint_t task_nr, int flags);
int gen_io(endpoint_t driver_e, message *mess_ptr);
@ -218,9 +218,9 @@ int rw_pipe(int rw_flag, endpoint_t usr, struct filp *f, char *buf,
size_t req_size);
/* request.c */
int req_breadwrite(endpoint_t fs_e, endpoint_t user_e, dev_t dev, u64_t pos,
int req_breadwrite(endpoint_t fs_e, endpoint_t user_e, dev_t dev, off_t pos,
unsigned int num_of_bytes, char *user_addr, int rw_flag,
u64_t *new_posp, unsigned int *cum_iop);
off_t *new_posp, unsigned int *cum_iop);
int req_chmod(endpoint_t fs_e, ino_t inode_nr, mode_t rmode,
mode_t *new_modep);
int req_chown(endpoint_t fs_e, ino_t inode_nr, uid_t newuid, gid_t newgid,
@ -231,8 +231,8 @@ int req_flush(endpoint_t fs_e, dev_t dev);
int req_fstatfs(endpoint_t fs_e, endpoint_t proc_e, vir_bytes buf);
int req_statvfs(endpoint_t fs_e, endpoint_t proc_e, vir_bytes buf);
int req_ftrunc(endpoint_t fs_e, ino_t inode_nr, off_t start, off_t end);
int req_getdents(endpoint_t fs_e, ino_t inode_nr, u64_t pos, char *buf,
size_t size, u64_t *new_pos, int direct, int getdents_321);
int req_getdents(endpoint_t fs_e, ino_t inode_nr, off_t pos, char *buf,
size_t size, off_t *new_pos, int direct, int getdents_321);
int req_inhibread(endpoint_t fs_e, ino_t inode_nr);
int req_link(endpoint_t fs_e, ino_t link_parent, char *lastc,
ino_t linked_file);
@ -251,9 +251,9 @@ int req_rdlink(endpoint_t fs_e, ino_t inode_nr, endpoint_t proc_e,
vir_bytes buf, size_t len, int direct);
int req_readsuper(struct vmnt *vmp, char *driver_name, dev_t dev, int readonly,
int isroot, struct node_details *res_nodep);
int req_readwrite(endpoint_t fs_e, ino_t inode_nr, u64_t pos, int rw_flag,
int req_readwrite(endpoint_t fs_e, ino_t inode_nr, off_t pos, int rw_flag,
endpoint_t user_e, char *user_addr, unsigned int num_of_bytes,
u64_t *new_posp, unsigned int *cum_iop);
off_t *new_posp, unsigned int *cum_iop);
int req_rename(endpoint_t fs_e, ino_t old_dir, char *old_name, ino_t new_dir,
char *new_name);
int req_rmdir(endpoint_t fs_e, ino_t inode_nr, char *lastc);

30
servers/vfs/read.c
View File

@ -126,7 +126,7 @@ int read_write(int rw_flag, struct filp *f, char *buf, size_t size,
endpoint_t for_e)
{
register struct vnode *vp;
u64_t position, res_pos, new_pos;
off_t position, res_pos, new_pos;
unsigned int cum_io, cum_io_incr, res_cum_io;
int op, r;
@ -164,7 +164,7 @@ int read_write(int rw_flag, struct filp *f, char *buf, size_t size,
suspend_reopen);
if (r >= 0) {
cum_io = r;
position = add64ul(position, r);
position += cum_io;
r = OK;
}
} else if (S_ISBLK(vp->v_mode)) { /* Block special files. */
@ -186,7 +186,7 @@ int read_write(int rw_flag, struct filp *f, char *buf, size_t size,
} else { /* Regular files */
if (rw_flag == WRITING) {
/* Check for O_APPEND flag. */
if (f->filp_flags & O_APPEND) position = cvul64(vp->v_size);
if (f->filp_flags & O_APPEND) position = vp->v_size;
}
/* Issue request */
@ -194,9 +194,6 @@ int read_write(int rw_flag, struct filp *f, char *buf, size_t size,
buf, size, &new_pos, &cum_io_incr);
if (r >= 0) {
if (ex64hi(new_pos))
panic("read_write: bad new pos");
position = new_pos;
cum_io += cum_io_incr;
}
@ -205,11 +202,8 @@ int read_write(int rw_flag, struct filp *f, char *buf, size_t size,
/* On write, update file size and access time. */
if (rw_flag == WRITING) {
if (S_ISREG(vp->v_mode) || S_ISDIR(vp->v_mode)) {
if (cmp64ul(position, vp->v_size) > 0) {
if (ex64hi(position) != 0) {
panic("read_write: file size too big ");
}
vp->v_size = ex64lo(position);
if (position > vp->v_size) {
vp->v_size = position;
}
}
}
@ -238,7 +232,7 @@ int do_getdents()
{
/* Perform the getdents(fd, buf, size) system call. */
int r = OK, getdents_321 = 0;
u64_t new_pos;
off_t new_pos;
register struct filp *rfilp;
if (job_call_nr == GETDENTS_321) getdents_321 = 1;
@ -256,9 +250,6 @@ int do_getdents()
r = EBADF;
if (r == OK) {
if (ex64hi(rfilp->filp_pos) != 0)
panic("do_getdents: can't handle large offsets");
r = req_getdents(rfilp->filp_vno->v_fs_e, rfilp->filp_vno->v_inode_nr,
rfilp->filp_pos, scratch(fp).io.io_buffer,
scratch(fp).io.io_nbytes, &new_pos, 0, getdents_321);
@ -284,7 +275,7 @@ size_t req_size;
int r, oflags, partial_pipe = 0;
size_t size, cum_io, cum_io_incr;
struct vnode *vp;
u64_t position, new_pos;
off_t position, new_pos;
/* Must make sure we're operating on locked filp and vnode */
assert(tll_locked_by_me(&f->filp_vno->v_lock));
@ -292,7 +283,7 @@ size_t req_size;
oflags = f->filp_flags;
vp = f->filp_vno;
position = cvu64(0); /* Not actually used */
position = 0; /* Not actually used */
/* fp->fp_cum_io_partial is only nonzero when doing partial writes */
cum_io = fp->fp_cum_io_partial;
@ -321,14 +312,11 @@ size_t req_size;
return(r);
}
if (ex64hi(new_pos))
panic("rw_pipe: bad new pos");
cum_io += cum_io_incr;
buf += cum_io_incr;
req_size -= cum_io_incr;
vp->v_size = ex64lo(new_pos);
vp->v_size = new_pos;
if (partial_pipe) {
/* partial write on pipe with */

141
servers/vfs/request.c
View File

@ -35,11 +35,11 @@ int req_breadwrite(
endpoint_t fs_e,
endpoint_t user_e,
dev_t dev,
u64_t pos,
off_t pos,
unsigned int num_of_bytes,
char *user_addr,
int rw_flag,
u64_t *new_posp,
off_t *new_pos,
unsigned int *cum_iop
)
{
@ -66,7 +66,7 @@ int req_breadwrite(
if (r != OK) return(r);
/* Fill in response structure */
*new_posp = make64(m.RES_SEEK_POS_LO, m.RES_SEEK_POS_HI);
*new_pos = make64(m.RES_SEEK_POS_LO, m.RES_SEEK_POS_HI);
*cum_iop = m.RES_NBYTES;
return(OK);
@ -148,9 +148,9 @@ int req_create(
cp_grant_id_t grant_id;
size_t len;
message m;
struct vmnt *vmp;
if (path[0] == '/')
panic("req_create: filename starts with '/'");
vmp = find_vmnt(fs_e);
len = strlen(path) + 1;
grant_id = cpf_grant_direct(fs_e, (vir_bytes) path, len, CPF_READ);
@ -175,7 +175,11 @@ int req_create(
res->fs_e = m.m_source;
res->inode_nr = (ino_t) m.RES_INODE_NR;
res->fmode = (mode_t) m.RES_MODE;
if (VFS_FS_PROTO_BIGOFFT(vmp->m_proto)) {
res->fsize = make64(m.RES_FILE_SIZE_LO, m.RES_FILE_SIZE_HI);
} else {
res->fsize = m.RES_FILE_SIZE_LO;
}
res->uid = (uid_t) m.RES_UID;
res->gid = (gid_t) m.RES_GID;
res->dev = NO_DEV;
@ -258,14 +262,33 @@ int req_statvfs(endpoint_t fs_e, endpoint_t proc_e, vir_bytes buf)
int req_ftrunc(endpoint_t fs_e, ino_t inode_nr, off_t start, off_t end)
{
message m;
struct vmnt *vmp;
vmp = find_vmnt(fs_e);
/* Fill in request message */
m.m_type = REQ_FTRUNC;
m.REQ_INODE_NR = (pino_t) inode_nr;
m.REQ_TRC_START_LO = start;
m.REQ_TRC_START_HI = 0; /* Not used for now, so clear it. */
m.REQ_TRC_END_LO = end;
m.REQ_TRC_END_HI = 0; /* Not used for now, so clear it. */
m.REQ_TRC_START_LO = ex64lo(start);
if (VFS_FS_PROTO_BIGOFFT(vmp->m_proto)) {
m.REQ_TRC_START_HI = ex64hi(start);
} else if (start > INT_MAX) {
/* FS does not support 64-bit off_t and 32 bits is not enough */
return EINVAL;
} else {
m.REQ_TRC_START_HI = 0;
}
m.REQ_TRC_END_LO = ex64lo(end);
if (VFS_FS_PROTO_BIGOFFT(vmp->m_proto)) {
m.REQ_TRC_END_HI = ex64hi(end);
} else if (end > INT_MAX) {
/* FS does not support 64-bit off_t and 32 bits is not enough */
return EINVAL;
} else {
m.REQ_TRC_END_HI = 0;
}
/* Send/rec request */
return fs_sendrec(fs_e, &m);
@ -278,10 +301,10 @@ int req_ftrunc(endpoint_t fs_e, ino_t inode_nr, off_t start, off_t end)
int req_getdents(
endpoint_t fs_e,
ino_t inode_nr,
u64_t pos,
off_t pos,
char *buf,
size_t size,
u64_t *new_pos,
off_t *new_pos,
int direct,
int getdents_321 /* Set to 1 if user land expects old format */
)
@ -352,7 +375,16 @@ int req_getdents(
m.REQ_GRANT = grant_id;
m.REQ_MEM_SIZE = size;
m.REQ_SEEK_POS_LO = ex64lo(pos);
m.REQ_SEEK_POS_HI = 0; /* Not used for now, so clear it. */
if (VFS_FS_PROTO_BIGOFFT(vmp->m_proto)) {
m.REQ_SEEK_POS_HI = ex64hi(pos);
} else if (pos > INT_MAX) {
/* FS does not support 64-bit off_t and 32 bits is not enough */
if (indir_buf_src != NULL) free(indir_buf_src);
if (indir_buf_dst != NULL) free(indir_buf_dst);
return EINVAL;
} else {
m.REQ_SEEK_POS_HI = 0;
}
r = fs_sendrec(fs_e, &m);
cpf_revoke(grant_id);
@ -373,7 +405,11 @@ int req_getdents(
}
if (r == OK) {
*new_pos = cvul64(m.RES_SEEK_POS_LO);
if (VFS_FS_PROTO_BIGOFFT(vmp->m_proto)) {
*new_pos = make64(m.RES_SEEK_POS_LO, m.RES_SEEK_POS_HI);
} else {
*new_pos = m.RES_SEEK_POS_LO;
}
r = m.RES_NBYTES;
}
@ -499,12 +535,14 @@ int req_lookup(
struct fproc *rfp
)
{
int r;
size_t len;
cp_grant_id_t grant_id=0, grant_id2=0;
message m;
vfs_ucred_t credentials;
int flags;
int r, flags;
size_t len;
struct vmnt *vmp;
cp_grant_id_t grant_id=0, grant_id2=0;
vmp = find_vmnt(fs_e);
grant_id = cpf_grant_direct(fs_e, (vir_bytes) resolve->l_path, PATH_MAX,
CPF_READ | CPF_WRITE);
@ -561,7 +599,11 @@ int req_lookup(
case OK:
res->inode_nr = (ino_t) m.RES_INODE_NR;
res->fmode = (mode_t) m.RES_MODE;
if (VFS_FS_PROTO_BIGOFFT(vmp->m_proto)) {
res->fsize = make64(m.RES_FILE_SIZE_LO, m.RES_FILE_SIZE_HI);
} else {
res->fsize = m.RES_FILE_SIZE_LO;
}
res->dev = m.RES_DEV;
res->uid = (uid_t) m.RES_UID;
res->gid = (gid_t) m.RES_GID;
@ -695,9 +737,12 @@ int req_newnode(
struct node_details *res
)
{
struct vmnt *vmp;
int r;
message m;
vmp = find_vmnt(fs_e);
/* Fill in request message */
m.m_type = REQ_NEWNODE;
m.REQ_MODE = (pmode_t) dmode;
@ -711,7 +756,11 @@ int req_newnode(
res->fs_e = m.m_source;
res->inode_nr = (ino_t) m.RES_INODE_NR;
res->fmode = (mode_t) m.RES_MODE;
if (VFS_FS_PROTO_BIGOFFT(vmp->m_proto)) {
res->fsize = make64(m.RES_FILE_SIZE_LO, m.RES_FILE_SIZE_HI);
} else {
res->fsize = m.RES_FILE_SIZE_LO;
}
res->dev = m.RES_DEV;
res->uid = (uid_t) m.RES_UID;
res->gid = (gid_t) m.RES_GID;
@ -823,7 +872,7 @@ int req_readsuper(
dev_t dev,
int readonly,
int isroot,
struct node_details *res_nodep
struct node_details *res
)
{
int r;
@ -857,13 +906,17 @@ int req_readsuper(
if(r == OK) {
/* Fill in response structure */
res_nodep->fs_e = m.m_source;
res_nodep->inode_nr = (ino_t) m.RES_INODE_NR;
res->fs_e = m.m_source;
res->inode_nr = (ino_t) m.RES_INODE_NR;
vmp->m_proto = m.RES_PROTO;
res_nodep->fmode = (mode_t) m.RES_MODE;
res_nodep->fsize = m.RES_FILE_SIZE_LO;
res_nodep->uid = (uid_t) m.RES_UID;
res_nodep->gid = (gid_t) m.RES_GID;
res->fmode = (mode_t) m.RES_MODE;
if (VFS_FS_PROTO_BIGOFFT(vmp->m_proto)) {
res->fsize = make64(m.RES_FILE_SIZE_LO, m.RES_FILE_SIZE_HI);
} else {
res->fsize = m.RES_FILE_SIZE_LO;
}
res->uid = (uid_t) m.RES_UID;
res->gid = (gid_t) m.RES_GID;
}
return(r);
@ -873,18 +926,18 @@ int req_readsuper(
/*===========================================================================*
* req_readwrite *
*===========================================================================*/
int req_readwrite(fs_e, inode_nr, pos, rw_flag, user_e,
user_addr, num_of_bytes, new_posp, cum_iop)
endpoint_t fs_e;
ino_t inode_nr;
u64_t pos;
int rw_flag;
endpoint_t user_e;
char *user_addr;
unsigned int num_of_bytes;
u64_t *new_posp;
unsigned int *cum_iop;
int req_readwrite(
endpoint_t fs_e,
ino_t inode_nr,
off_t pos,
int rw_flag,
endpoint_t user_e,
char *user_addr,
unsigned int num_of_bytes,
off_t *new_posp,
unsigned int *cum_iop)
{
struct vmnt *vmp;
int r;
cp_grant_id_t grant_id = -1;
message m;
@ -897,9 +950,7 @@ unsigned int *cum_iop;
* PEEKING: do i/o in FS, just get the blocks into the cache, no copy
*/
if (ex64hi(pos) != 0)
panic("req_readwrite: pos too large");
vmp = find_vmnt(fs_e);
assert(rw_flag == READING || rw_flag == WRITING || rw_flag == PEEKING);
switch(rw_flag) {
@ -926,7 +977,13 @@ unsigned int *cum_iop;
m.REQ_INODE_NR = (pino_t) inode_nr;
m.REQ_GRANT = grant_id;
m.REQ_SEEK_POS_LO = ex64lo(pos);
m.REQ_SEEK_POS_HI = 0; /* Not used for now, so clear it. */
if (VFS_FS_PROTO_BIGOFFT(vmp->m_proto)) {
m.REQ_SEEK_POS_HI = ex64hi(pos);
} else if (pos > INT_MAX) {
return EINVAL;
} else {
m.REQ_SEEK_POS_HI = 0;
}
m.REQ_NBYTES = num_of_bytes;
/* Send/rec request */
@ -935,7 +992,11 @@ unsigned int *cum_iop;
if (r == OK) {
/* Fill in response structure */
*new_posp = cvul64(m.RES_SEEK_POS_LO);
if (VFS_FS_PROTO_BIGOFFT(vmp->m_proto)) {
*new_posp = make64(m.RES_SEEK_POS_LO, m.RES_SEEK_POS_HI);
} else {
*new_posp = m.RES_SEEK_POS_LO;
}
*cum_iop = m.RES_NBYTES;
}

6
servers/vfs/select.c
View File

@ -382,8 +382,7 @@ static int select_request_async(struct filp *f, int *ops, int block)
return(SUSPEND);
f->filp_select_flags &= ~FSF_UPDATE;
r = dev_io(VFS_DEV_SELECT, f->filp_vno->v_sdev, rops, NULL,
cvu64(0), 0, 0, FALSE);
r = dev_io(VFS_DEV_SELECT, f->filp_vno->v_sdev, rops, NULL, 0, 0, 0, FALSE);
if (r < 0 && r != SUSPEND)
return(r);
@ -434,8 +433,7 @@ static int select_request_sync(struct filp *f, int *ops, int block)
rops = *ops;
if (block) rops |= SEL_NOTIFY;
*ops = dev_io(VFS_DEV_SELECT, f->filp_vno->v_sdev, rops, NULL,
cvu64(0), 0, 0, FALSE);
*ops = dev_io(VFS_DEV_SELECT, f->filp_vno->v_sdev, rops, NULL, 0, 0, 0,FALSE);
if (*ops < 0)
return(*ops);

2
servers/vfs/table.c
View File

@ -96,7 +96,7 @@ int (*call_vec[])(void) = {
no_sys, /* 78 = (sysuname) */
no_sys, /* 79 = unused */
do_getdents, /* 80 = getdents_321 (to be phased out) */
do_llseek, /* 81 = llseek */
do_lseek, /* 81 = llseek */
do_fstatfs, /* 82 = fstatfs */
do_statvfs, /* 83 = fstatvfs */
do_fstatvfs, /* 84 = statvfs */

3
servers/vfs/vnode.h
View File

@ -13,9 +13,6 @@ EXTERN struct vnode {
int v_ref_count; /* # times vnode used; 0 means slot is free */
int v_fs_count; /* # reference at the underlying FS */
int v_mapfs_count; /* # reference at the underlying mapped FS */
#if 0
int v_ref_check; /* for consistency checks */
#endif
endpoint_t v_bfs_e; /* endpoint number for the FS proces in case
of a block special file */
dev_t v_dev; /* device number on which the corresponding