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

Make PFS backcalls regular VFS calls

Browse source 
- prefix them with VFS_ as they are going to VFS;
- give these calls normal call numbers;
- give them their own set of message field aliases;
- also make do_mapdriver a regular call.

Change-Id: I2140439f288b06d699a1f65438bd8306509b259e
This commit is contained in:
David van Moolenbroek 2013-09-09 00:04:12 +02:00 committed by Lionel Sambuc
parent 3af30c2c60
commit f6915d3dee
11 changed files with 85 additions and 75 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
include/minix/callnr.h
View file

@ -1,4 +1,4 @@
#define NCALLS 124 /* number of system calls allowed */
#define NCALLS 130 /* number of system calls allowed */
/* In case it isn't obvious enough: this list is sorted numerically. */
#define EXIT 1
@ -110,3 +110,10 @@
#define MAPDRIVER 122 /* to VFS, map a device */
#define GETRUSAGE 123 /* to PM, VFS */
#define VFS_PFS_CHECK_PERMS 124 /* to VFS */
#define VFS_PFS_VERIFY_FD 125 /* to VFS */
#define VFS_PFS_SET_FILP 126 /* to VFS */
#define VFS_PFS_COPY_FILP 127 /* to VFS */
#define VFS_PFS_PUT_FILP 128 /* to VFS */
#define VFS_PFS_CANCEL_FD 129 /* to VFS */

7
include/minix/com.h
View file

@ -934,6 +934,13 @@
#define VFS_IOCTL_REQ m2_i3
#define VFS_IOCTL_ARG m2_p1
/* Field names for the PFS backcalls to VFS. */
#define VFS_PFS_ENDPT m2_i1
#define VFS_PFS_GRANT m2_i2
#define VFS_PFS_COUNT m2_i3
#define VFS_PFS_FD m2_i3
#define VFS_PFS_FILP m2_p1
/*===========================================================================*
* Messages for VM server *
*===========================================================================*/

14
include/minix/vfsif.h
View file

@ -137,19 +137,5 @@ typedef u32_t pino_t; /* Protocol version of ino_t */
#define TRNS_ADD_ID(t,id) (((t) << 16) | ((id) & 0xFFFF))
#define TRNS_DEL_ID(t) ((short)((t) >> 16))
#define PFS_BASE (VFS_BASE + 100)
#define PFS_REQ_CHECK_PERMS (PFS_BASE + 1)
#define PFS_REQ_VERIFY_FD (PFS_BASE + 2)
#define PFS_REQ_SET_FILP (PFS_BASE + 3)
#define PFS_REQ_COPY_FILP (PFS_BASE + 4)
#define PFS_REQ_PUT_FILP (PFS_BASE + 5)
#define PFS_REQ_CANCEL_FD (PFS_BASE + 6)
#define PFS_NREQS 7
#define IS_PFS_VFS_RQ(type) (type >= PFS_BASE && \
type < (PFS_BASE + PFS_NREQS))
#endif

36
servers/pfs/uds.c
View file

@ -47,10 +47,10 @@ static int check_perms(devminor_t minor, struct sockaddr_un *addr)
/* ask the VFS to verify the permissions */
memset(&vfs_m, '\0', sizeof(message));
vfs_m.m_type = PFS_REQ_CHECK_PERMS;
vfs_m.USER_ENDPT = uds_fd_table[minor].owner;
vfs_m.IO_GRANT = (char *) grant_id;
vfs_m.COUNT = UNIX_PATH_MAX;
vfs_m.m_type = VFS_PFS_CHECK_PERMS;
vfs_m.VFS_PFS_ENDPT = uds_fd_table[minor].owner;
vfs_m.VFS_PFS_GRANT = grant_id;
vfs_m.VFS_PFS_COUNT = UNIX_PATH_MAX;
rc = sendrec(VFS_PROC_NR, &vfs_m);
cpf_revoke(grant_id);
@ -82,9 +82,9 @@ static filp_id_t verify_fd(endpoint_t ep, int fd)
memset(&vfs_m, '\0', sizeof(message));
vfs_m.m_type = PFS_REQ_VERIFY_FD;
vfs_m.USER_ENDPT = ep;
vfs_m.COUNT = fd;
vfs_m.m_type = VFS_PFS_VERIFY_FD;
vfs_m.VFS_PFS_ENDPT = ep;
vfs_m.VFS_PFS_FD = fd;
rc = sendrec(VFS_PROC_NR, &vfs_m);
if (OK != rc) {
@ -97,7 +97,7 @@ static filp_id_t verify_fd(endpoint_t ep, int fd)
printf("(uds) VFS reply => %d\n", vfs_m.m_type);
#endif
return vfs_m.ADDRESS;
return vfs_m.VFS_PFS_FILP;
}
static int set_filp(filp_id_t sfilp)
@ -112,8 +112,8 @@ static int set_filp(filp_id_t sfilp)
memset(&vfs_m, '\0', sizeof(message));
vfs_m.m_type = PFS_REQ_SET_FILP;
vfs_m.ADDRESS = sfilp;
vfs_m.m_type = VFS_PFS_SET_FILP;
vfs_m.VFS_PFS_FILP = sfilp;
rc = sendrec(VFS_PROC_NR, &vfs_m);
if (OK != rc) {
@ -141,9 +141,9 @@ static int copy_filp(endpoint_t to_ep, filp_id_t cfilp)
memset(&vfs_m, '\0', sizeof(message));
vfs_m.m_type = PFS_REQ_COPY_FILP;
vfs_m.USER_ENDPT = to_ep;
vfs_m.ADDRESS = cfilp;
vfs_m.m_type = VFS_PFS_COPY_FILP;
vfs_m.VFS_PFS_ENDPT = to_ep;
vfs_m.VFS_PFS_FILP = cfilp;
rc = sendrec(VFS_PROC_NR, &vfs_m);
if (OK != rc) {
@ -170,8 +170,8 @@ static int put_filp(filp_id_t pfilp)
memset(&vfs_m, '\0', sizeof(message));
vfs_m.m_type = PFS_REQ_PUT_FILP;
vfs_m.ADDRESS = pfilp;
vfs_m.m_type = VFS_PFS_PUT_FILP;
vfs_m.VFS_PFS_FILP = pfilp;
rc = sendrec(VFS_PROC_NR, &vfs_m);
if (OK != rc) {
@ -198,9 +198,9 @@ static int cancel_fd(endpoint_t ep, int fd)
memset(&vfs_m, '\0', sizeof(message));
vfs_m.m_type = PFS_REQ_CANCEL_FD;
vfs_m.USER_ENDPT = ep;
vfs_m.COUNT = fd;
vfs_m.m_type = VFS_PFS_CANCEL_FD;
vfs_m.VFS_PFS_ENDPT = ep;
vfs_m.VFS_PFS_FD = fd;
rc = sendrec(VFS_PROC_NR, &vfs_m);
if (OK != rc) {

6
servers/pm/table.c
View file

@ -135,6 +135,12 @@ int (*call_vec[])(void) = {
no_sys, /* 121 = (task reply) */
no_sys, /* 122 = (map driver ) */
do_getrusage, /* 123 = getrusage */
no_sys, /* 124 = (check_perms) */
no_sys, /* 125 = (verify_fd) */
no_sys, /* 126 = (set_filp) */
no_sys, /* 127 = (copy_filp) */
no_sys, /* 128 = (put_filp) */
no_sys, /* 129 = (cancel_fd) */
};
/* This should not fail with "array size is negative": */
extern int dummy[sizeof(call_vec) == NCALLS * sizeof(call_vec[0]) ? 1 : -1];

2
servers/vfs/dmap.c
View file

@ -59,7 +59,7 @@ void unlock_dmap(struct dmap *dp)
/*===========================================================================*
* do_mapdriver *
*===========================================================================*/
int do_mapdriver()
int do_mapdriver(message *UNUSED(m_out))
{
/* Create a device->driver mapping. RS will tell us which major is driven by
* this driver, what type of device it is (regular, TTY, asynchronous, clone,

35
servers/vfs/filedes.c
View file

@ -450,11 +450,14 @@ int do_verify_fd(message *m_out)
endpoint_t proc_e;
int fd;
proc_e = job_m_in.USER_ENDPT;
fd = job_m_in.COUNT;
/* This should be replaced with an ACL check. */
if (who_e != PFS_PROC_NR) return EPERM;
proc_e = job_m_in.VFS_PFS_ENDPT;
fd = job_m_in.VFS_PFS_FD;
rfilp = (struct filp *) verify_fd(proc_e, fd);
m_out->ADDRESS = (void *) rfilp;
m_out->VFS_PFS_FILP = (void *) rfilp;
if (rfilp != NULL) unlock_filp(rfilp);
return (rfilp != NULL) ? OK : EINVAL;
}
@ -480,7 +483,11 @@ filp_id_t sfilp;
int do_set_filp(message *UNUSED(m_out))
{
filp_id_t f;
f = (filp_id_t) job_m_in.ADDRESS;
/* This should be replaced with an ACL check. */
if (who_e != PFS_PROC_NR) return EPERM;
f = (filp_id_t) job_m_in.VFS_PFS_FILP;
return set_filp(f);
}
@ -523,8 +530,11 @@ int do_copy_filp(message *UNUSED(m_out))
endpoint_t proc_e;
filp_id_t f;
proc_e = job_m_in.USER_ENDPT;
f = (filp_id_t) job_m_in.ADDRESS;
/* This should be replaced with an ACL check. */
if (who_e != PFS_PROC_NR) return EPERM;
proc_e = job_m_in.VFS_PFS_ENDPT;
f = (filp_id_t) job_m_in.VFS_PFS_FILP;
return copy_filp(proc_e, f);
}
@ -550,7 +560,11 @@ filp_id_t pfilp;
int do_put_filp(message *UNUSED(m_out))
{
filp_id_t f;
f = (filp_id_t) job_m_in.ADDRESS;
/* This should be replaced with an ACL check. */
if (who_e != PFS_PROC_NR) return EPERM;
f = (filp_id_t) job_m_in.VFS_PFS_FILP;
return put_filp(f);
}
@ -597,8 +611,11 @@ int do_cancel_fd(message *UNUSED(m_out))
endpoint_t proc_e;
int fd;
proc_e = job_m_in.USER_ENDPT;
fd = job_m_in.COUNT;
/* This should be replaced with an ACL check. */
if (who_e != PFS_PROC_NR) return EPERM;
proc_e = job_m_in.VFS_PFS_ENDPT;
fd = job_m_in.VFS_PFS_FD;
return cancel_fd(proc_e, fd);
}

22
servers/vfs/main.c
View file

@ -256,24 +256,14 @@ static void do_work(void)
memset(&m_out, 0, sizeof(m_out));
if (job_call_nr == MAPDRIVER) {
error = do_mapdriver();
} else if (job_call_nr == COMMON_GETSYSINFO) {
if (job_call_nr == COMMON_GETSYSINFO) {
error = do_getsysinfo();
} else if (IS_PFS_VFS_RQ(job_call_nr)) {
if (who_e != PFS_PROC_NR) {
printf("VFS: only PFS is allowed to make nested VFS calls\n");
error = ENOSYS;
} else if (job_call_nr <= PFS_BASE ||
job_call_nr >= PFS_BASE + PFS_NREQS) {
error = ENOSYS;
} else {
job_call_nr -= PFS_BASE;
error = (*pfs_call_vec[job_call_nr])(&m_out);
}
} else {
/* We're dealing with a POSIX system call from a normal
* process. Call the internal function that does the work.
/* At this point we assume that we're dealing with a call that has been
* made specifically to VFS. Typically it will be a POSIX call from a
* normal process, but we also handle a few calls made by system
* processes (such as PFS) through here. Call the internal function
* that does the work.
*/
if (job_call_nr < 0 || job_call_nr >= NCALLS) {
error = ENOSYS;

7
servers/vfs/path.c
View file

@ -870,6 +870,9 @@ size_t pathlen;
*===========================================================================*/
int do_check_perms(message *UNUSED(m_out))
{
return check_perms(job_m_in.USER_ENDPT, (cp_grant_id_t) job_m_in.IO_GRANT,
(size_t) job_m_in.COUNT);
/* This should be replaced by an ACL check. */
if (who_e != PFS_PROC_NR) return EPERM;
return check_perms(job_m_in.VFS_PFS_ENDPT, job_m_in.VFS_PFS_GRANT,
(size_t) job_m_in.VFS_PFS_COUNT);
}

3
servers/vfs/proto.h
View file

@ -56,7 +56,7 @@ void cdev_up(int major);
/* dmap.c */
void lock_dmap(struct dmap *dp);
void unlock_dmap(struct dmap *dp);
int do_mapdriver(void);
int do_mapdriver(message *m_out);
void init_dmap(void);
void init_dmap_locks(void);
int dmap_driver_match(endpoint_t proc, int major);
@ -64,7 +64,6 @@ void dmap_endpt_up(endpoint_t proc_nr, int is_blk);
void dmap_unmap_by_endpt(endpoint_t proc_nr);
struct dmap *get_dmap(endpoint_t proc_e);
struct dmap *get_dmap_by_major(int major);
int do_mapdriver(void);
int map_service(struct rprocpub *rpub);
void dmap_unmap_by_endpt(endpoint_t proc_nr);
int map_driver(const char *label, int major, endpoint_t proc_nr, int

19
servers/vfs/table.c
View file

@ -136,19 +136,14 @@ int (*call_vec[])(message *m_out) = {
no_sys, /* 119 = unsused */
no_sys, /* 120 = unsused */
no_sys, /* 121 = (task reply) */
no_sys, /* 122 = (map driver ) */
do_mapdriver, /* 122 = mapdriver */
do_getrusage, /* 123 = getrusage */
do_check_perms, /* 124 = from PFS: check_perms */
do_verify_fd, /* 125 = from PFS: verify_fd */
do_set_filp, /* 126 = from PFS: set_filp */
do_copy_filp, /* 127 = from PFS: copy_filp */
do_put_filp, /* 128 = from PFS: put_filp */
do_cancel_fd, /* 129 = from PFS: cancel_fd */
};
/* This should not fail with "array size is negative": */
extern int dummy[sizeof(call_vec) == NCALLS * sizeof(call_vec[0]) ? 1 : -1];
int (*pfs_call_vec[])(message *m_out) = {
no_sys, /* 0 */
do_check_perms, /* 1 */
do_verify_fd, /* 2 */
do_set_filp, /* 3 */
do_copy_filp, /* 4 */
do_put_filp, /* 5 */
do_cancel_fd /* 6 */
};