drop from segments physcopy/vircopy invocations

	. sys_vircopy always uses D for both src and dst
	. sys_physcopy uses PHYS_SEG if and only if corresponding
	  endpoint is NONE, so we can derive the mode (PHYS_SEG or D)
	  from the endpoint arg in the kernel, dropping the seg args
	. fields in msg still filled in for backwards compatability,
	  using same NONE-logic in the library

diff --git a/include/minix/com.h b/include/minix/com.h
index 160728fef91b6f3076f7a5eb4446e23082177661..46242b16e3b734cdcf326d56082dad93e45b9858 100644 (file)
--- a/include/minix/com.h
+++ b/include/minix/com.h
@@ -432,14 +432,18 @@
 #define IOP_ENDPT      m2_l1   /* target endpoint */
 
 /* Field names for _UMAP, _VIRCOPY, _PHYSCOPY. */
-#define CP_SRC_SPACE   m5_s1   /* T or D space (stack is also D) */
 #define CP_SRC_ENDPT   m5_i1   /* process to copy from */
 #define CP_SRC_ADDR    m5_l1   /* address where data come from */
-#define CP_DST_SPACE   m5_s2   /* T or D space (stack is also D) */
 #define CP_DST_ENDPT   m5_i2   /* process to copy to */
 #define CP_DST_ADDR    m5_l2   /* address where data go to */
 #define CP_NR_BYTES    m5_l3   /* number of bytes to copy */
 
+#define UMAP_SEG       m5_s1
+
+/* only used for backwards compatability */
+#define CP_SRC_SPACE_OBSOLETE  m5_s1   /* T or D space (stack is also D) */
+#define CP_DST_SPACE_OBSOLETE  m5_s2   /* T or D space (stack is also D) */
+
 /* Field names for SYS_VUMAP. */
 #define VUMAP_ENDPT    m10_i1  /* grant owner, or SELF for local addresses */
 #define VUMAP_VADDR    m10_l1  /* address of virtual (input) vector */

diff --git a/include/minix/syslib.h b/include/minix/syslib.h
index 7bd68af2da7d3cf9ed5d91db4164bd0374adbb7a..90b172934e914bc336090012380e43409f978f2b 100644 (file)
--- a/include/minix/syslib.h
+++ b/include/minix/syslib.h
@@ -131,19 +131,14 @@ int sys_vtimer(endpoint_t proc_nr, int which, clock_t *newval, clock_t
 int sys_irqctl(int request, int irq_vec, int policy, int *irq_hook_id);
 
 /* Shorthands for sys_vircopy() and sys_physcopy() system calls. */
-#define sys_datacopy(src_proc, src_vir, dst_proc, dst_vir, bytes) \
-       sys_vircopy(src_proc, D, src_vir, dst_proc, D, dst_vir, bytes)
-#define sys_textcopy(src_proc, src_vir, dst_proc, dst_vir, bytes) \
-       sys_vircopy(src_proc, T, src_vir, dst_proc, T, dst_vir, bytes)
-#define sys_stackcopy(src_proc, src_vir, dst_proc, dst_vir, bytes) \
-       sys_vircopy(src_proc, S, src_vir, dst_proc, S, dst_vir, bytes)
-int sys_vircopy(endpoint_t src_proc, int src_s, vir_bytes src_v,
-       endpoint_t dst_proc, int dst_seg, vir_bytes dst_vir, phys_bytes bytes);
+#define sys_datacopy sys_vircopy
+int sys_vircopy(endpoint_t src_proc, vir_bytes src_v,
+       endpoint_t dst_proc, vir_bytes dst_vir, phys_bytes bytes);
 
 #define sys_abscopy(src_phys, dst_phys, bytes) \
-       sys_physcopy(NONE, PHYS_SEG, src_phys, NONE, PHYS_SEG, dst_phys, bytes)
-int sys_physcopy(endpoint_t src_proc, int src_seg, vir_bytes src_vir,
-       endpoint_t dst_proc, int dst_seg, vir_bytes dst_vir, phys_bytes bytes);
+       sys_physcopy(NONE, src_phys, NONE, dst_phys, bytes)
+int sys_physcopy(endpoint_t src_proc, vir_bytes src_vir,
+       endpoint_t dst_proc, vir_bytes dst_vir, phys_bytes bytes);
 
 
 /* Grant-based copy functions. */

diff --git a/kernel/system/do_copy.c b/kernel/system/do_copy.c
index 33b7e0c82342d8a3176fb6923a9f2d5d6423a0ae..2e80c8351d2e3fb9f74e02c072d889ddda52c348 100644 (file)
--- a/kernel/system/do_copy.c
+++ b/kernel/system/do_copy.c
@@ -2,10 +2,8 @@
  *   m_type:   SYS_VIRCOPY, SYS_PHYSCOPY
  *
  * The parameters for this kernel call are:
- *    m5_s1:   CP_SRC_SPACE            source virtual segment
  *    m5_l1:   CP_SRC_ADDR             source offset within segment
  *    m5_i1:   CP_SRC_ENDPT            source process number
- *    m5_s2:   CP_DST_SPACE            destination virtual segment
  *    m5_l2:   CP_DST_ADDR             destination offset within segment
  *    m5_i2:   CP_DST_ENDPT            destination process number
  *    m5_l3:   CP_NR_BYTES             number of bytes to copy
@@ -28,6 +26,7 @@ int do_copy(struct proc * caller, message * m_ptr)
   struct vir_addr vir_addr[2]; /* virtual source and destination address */
   phys_bytes bytes;            /* number of bytes to copy */
   int i;
+  endpoint_t pe;
 
 #if 0
   if (caller->p_endpoint != PM_PROC_NR && caller->p_endpoint != VFS_PROC_NR &&
@@ -39,22 +38,20 @@ int do_copy(struct proc * caller, message * m_ptr)
        {
                first= 0;
                printf(
-"do_copy: got request from %d (source %d, seg %d, destination %d, seg %d)\n",
+"do_copy: got request from %d (source %d, destination %d)\n",
                        caller->p_endpoint,
                        m_ptr->CP_SRC_ENDPT,
-                       m_ptr->CP_SRC_SPACE,
-                       m_ptr->CP_DST_ENDPT,
-                       m_ptr->CP_DST_SPACE);
+                       m_ptr->CP_DST_ENDPT);
        }
   }
 #endif
 
   /* Dismember the command message. */
-  vir_addr[_SRC_].proc_nr_e = m_ptr->CP_SRC_ENDPT;
-  vir_addr[_SRC_].segment = m_ptr->CP_SRC_SPACE;
+  pe = vir_addr[_SRC_].proc_nr_e = m_ptr->CP_SRC_ENDPT;
+  vir_addr[_SRC_].segment = (pe == NONE ? PHYS_SEG : D);
   vir_addr[_SRC_].offset = (vir_bytes) m_ptr->CP_SRC_ADDR;
-  vir_addr[_DST_].proc_nr_e = m_ptr->CP_DST_ENDPT;
-  vir_addr[_DST_].segment = m_ptr->CP_DST_SPACE;
+  pe = vir_addr[_DST_].proc_nr_e = m_ptr->CP_DST_ENDPT;
+  vir_addr[_DST_].segment = (pe == NONE ? PHYS_SEG : D);
   vir_addr[_DST_].offset = (vir_bytes) m_ptr->CP_DST_ADDR;
   bytes = (phys_bytes) m_ptr->CP_NR_BYTES;
 

diff --git a/kernel/system/do_umap.c b/kernel/system/do_umap.c
index 89378158c9dd35aafbff1408c4bd6ca4ba45b37b..32c1ff3a8b6fb1e30fa3adffc2fc6a8ae0896ba9 100755 (executable)
--- a/kernel/system/do_umap.c
+++ b/kernel/system/do_umap.c
@@ -3,7 +3,7 @@
  *
  * The parameters for this kernel call are:
  *    m5_i1:   CP_SRC_PROC_NR  (process number)
- *    m5_s1:   CP_SRC_SPACE    (segment where address is: T, D, or S)
+ *    m5_s1:   UMAP_SEG        (segment where address is: T, D, or S)
  *    m5_l1:   CP_SRC_ADDR     (virtual address)
  *    m5_l2:   CP_DST_ADDR     (returns physical address)
  *    m5_l3:   CP_NR_BYTES     (size of datastructure)
@@ -24,7 +24,7 @@
  *==========================================================================*/
 int do_umap(struct proc * caller, message * m_ptr)
 {
-  int seg_index = m_ptr->CP_SRC_SPACE & SEGMENT_INDEX;
+  int seg_index = m_ptr->UMAP_SEG & SEGMENT_INDEX;
   int endpt = (int) m_ptr->CP_SRC_ENDPT;
 
   /* This call is a subset of umap_remote, it allows mapping virtual addresses

diff --git a/kernel/system/do_umap_remote.c b/kernel/system/do_umap_remote.c
index 5a62d2102ca071497ecb73e3556794019456bc34..a4ecc64f9eac1f492c087328d005c43bd92da416 100644 (file)
--- a/kernel/system/do_umap_remote.c
+++ b/kernel/system/do_umap_remote.c
@@ -3,7 +3,7 @@
  *
  * The parameters for this kernel call are:
  *    m5_i1:   CP_SRC_PROC_NR  (process number)
- *    m5_s1:   CP_SRC_SPACE    (segment where address is: T, D, or S)
+ *    m5_s1:   UMAP_SEG        (segment where address is: T, D, or S)
  *    m5_l1:   CP_SRC_ADDR     (virtual address)
  *    m5_i2:   CP_DST_ENDPT    (process number of grantee to check access for)
  *    m5_l2:   CP_DST_ADDR     (returns physical address)
@@ -26,8 +26,8 @@
 int do_umap_remote(struct proc * caller, message * m_ptr)
 {
 /* Map virtual address to physical, for non-kernel processes. */
-  int seg_type = m_ptr->CP_SRC_SPACE & SEGMENT_TYPE;
-  int seg_index = m_ptr->CP_SRC_SPACE & SEGMENT_INDEX;
+  int seg_type = m_ptr->UMAP_SEG & SEGMENT_TYPE;
+  int seg_index = m_ptr->UMAP_SEG & SEGMENT_INDEX;
   vir_bytes offset = m_ptr->CP_SRC_ADDR;
   int count = m_ptr->CP_NR_BYTES;
   int endpt = (int) m_ptr->CP_SRC_ENDPT;

diff --git a/lib/libsys/sys_physcopy.c b/lib/libsys/sys_physcopy.c
index c678b67dea2c10e50faf748f0ddd0e9a96972255..9c1dab179daa38c49970f45aedb2a0fd8832501b 100644 (file)
--- a/lib/libsys/sys_physcopy.c
+++ b/lib/libsys/sys_physcopy.c
@@ -1,12 +1,9 @@
 #include "syslib.h"
 
-int sys_physcopy(src_proc, src_seg, src_vir, 
-       dst_proc, dst_seg, dst_vir, bytes)
+int sys_physcopy(src_proc, src_vir, dst_proc, dst_vir, bytes)
 endpoint_t src_proc;           /* source process */
-int src_seg;                   /* source memory segment */
 vir_bytes src_vir;             /* source virtual address */
 endpoint_t dst_proc;           /* destination process */
-int dst_seg;                   /* destination memory segment */
 vir_bytes dst_vir;             /* destination virtual address */
 phys_bytes bytes;              /* how many bytes */
 {
@@ -20,11 +17,16 @@ phys_bytes bytes;           /* how many bytes */
 
   if (bytes == 0L) return(OK);
   copy_mess.CP_SRC_ENDPT = src_proc;
-  copy_mess.CP_SRC_SPACE = src_seg;
   copy_mess.CP_SRC_ADDR = (long) src_vir;
   copy_mess.CP_DST_ENDPT = dst_proc;
-  copy_mess.CP_DST_SPACE = dst_seg;
   copy_mess.CP_DST_ADDR = (long) dst_vir;
   copy_mess.CP_NR_BYTES = (long) bytes;
+
+  /* provide backwards compatability arguments to old
+   * kernels based on process id's; NONE <=> physical
+   */
+  copy_mess.CP_DST_SPACE_OBSOLETE = (dst_proc == NONE ? PHYS_SEG : D);
+  copy_mess.CP_SRC_SPACE_OBSOLETE = (src_proc == NONE ? PHYS_SEG : D);
+
   return(_kernel_call(SYS_PHYSCOPY, &copy_mess));
 }

diff --git a/lib/libsys/sys_umap.c b/lib/libsys/sys_umap.c
index 66b9c9a59b057a516edee040f37473b3c64ceadb..e2e3ce467c7598de2818a9e429cf6db4a9b11032 100644 (file)
--- a/lib/libsys/sys_umap.c
+++ b/lib/libsys/sys_umap.c
@@ -14,7 +14,7 @@ phys_bytes *phys_addr;                        /* placeholder for result */
     int result;
 
     m.CP_SRC_ENDPT = proc_ep;
-    m.CP_SRC_SPACE = seg;
+    m.UMAP_SEG = seg;
     m.CP_SRC_ADDR = vir_addr;
     m.CP_NR_BYTES = bytes;
 

diff --git a/lib/libsys/sys_umap_remote.c b/lib/libsys/sys_umap_remote.c
index dd03c045a2db20704818d44339ed4298edb70009..2adda8ec4cb19ddb2d8a882f598116307987c2aa 100755 (executable)
--- a/lib/libsys/sys_umap_remote.c
+++ b/lib/libsys/sys_umap_remote.c
@@ -24,7 +24,7 @@ phys_bytes *phys_addr;                        /* placeholder for result */
 
     m.CP_SRC_ENDPT = proc_ep;
     m.CP_DST_ENDPT = grantee;
-    m.CP_SRC_SPACE = seg;
+    m.UMAP_SEG = seg;
     m.CP_SRC_ADDR = vir_addr;
     m.CP_NR_BYTES = bytes;
 

diff --git a/lib/libsys/sys_vircopy.c b/lib/libsys/sys_vircopy.c
index cb9cbb36dd9598f75973d937988eefe21704f8de..a9e57abb81fdfe23f95411d63195f899a503a8f2 100644 (file)
--- a/lib/libsys/sys_vircopy.c
+++ b/lib/libsys/sys_vircopy.c
@@ -1,12 +1,10 @@
 #include "syslib.h"
 
-int sys_vircopy(src_proc, src_seg, src_vir, 
-       dst_proc, dst_seg, dst_vir, bytes)
+int sys_vircopy(src_proc, src_vir, 
+       dst_proc, dst_vir, bytes)
 endpoint_t src_proc;           /* source process */
-int src_seg;                   /* source memory segment */
 vir_bytes src_vir;             /* source virtual address */
 endpoint_t dst_proc;           /* destination process */
-int dst_seg;                   /* destination memory segment */
 vir_bytes dst_vir;             /* destination virtual address */
 phys_bytes bytes;              /* how many bytes */
 {
@@ -19,11 +17,14 @@ phys_bytes bytes;           /* how many bytes */
 
   if (bytes == 0L) return(OK);
   copy_mess.CP_SRC_ENDPT = src_proc;
-  copy_mess.CP_SRC_SPACE = src_seg;
   copy_mess.CP_SRC_ADDR = (long) src_vir;
   copy_mess.CP_DST_ENDPT = dst_proc;
-  copy_mess.CP_DST_SPACE = dst_seg;
   copy_mess.CP_DST_ADDR = (long) dst_vir;
   copy_mess.CP_NR_BYTES = (long) bytes;
+
+  /* backwards compatability D segs */
+  copy_mess.CP_DST_SPACE_OBSOLETE = D;
+  copy_mess.CP_SRC_SPACE_OBSOLETE = D;
+
   return(_kernel_call(SYS_VIRCOPY, &copy_mess));
 }

diff --git a/servers/pm/misc.c b/servers/pm/misc.c
index c6beef105deb807f4536e5100cc88715faa54e0e..705c1088d070b6911c63f11b083d4d9c3dfb9c50 100644 (file)
--- a/servers/pm/misc.c
+++ b/servers/pm/misc.c
@@ -94,8 +94,8 @@ int do_sysuname()
        /* Copy an uname string to the user. */
        n = strlen(string) + 1;
        if (n > m_in.sysuname_len) n = m_in.sysuname_len;
-       r = sys_vircopy(SELF, D, (phys_bytes) string, 
-               mp->mp_endpoint, D, (phys_bytes) m_in.sysuname_value,
+       r = sys_vircopy(SELF, (phys_bytes) string, 
+               mp->mp_endpoint, (phys_bytes) m_in.sysuname_value,
                (phys_bytes) n);
        if (r < 0) return(r);
        break;
@@ -107,8 +107,8 @@ int do_sysuname()
        if (mp->mp_effuid != 0 || len == 0) return(EPERM);
        n = len < m_in.sysuname_len ? len : m_in.sysuname_len;
        if (n <= 0) return(EINVAL);
-       r = sys_vircopy(mp->mp_endpoint, D, (phys_bytes) m_in.sysuname_value,
-               SELF, D, (phys_bytes) tmp, (phys_bytes) n);
+       r = sys_vircopy(mp->mp_endpoint, (phys_bytes) m_in.sysuname_value,
+               SELF, (phys_bytes) tmp, (phys_bytes) n);
        if (r < 0) return(r);
        tmp[n-1] = 0;
        strcpy(string, tmp);

diff --git a/servers/pm/trace.c b/servers/pm/trace.c
index 5d19feedd8762155c7264437a3b419f7d7ae5e28..522a401f0f003c622dd34dded1fa479427962685 100644 (file)
--- a/servers/pm/trace.c
+++ b/servers/pm/trace.c
@@ -41,7 +41,7 @@ int do_trace()
 {
   register struct mproc *child;
   struct ptrace_range pr;
-  int i, r, seg, req;
+  int i, r, req;
   message m;
 
   req = m_in.request;
@@ -190,14 +190,13 @@ int do_trace()
        if (pr.pr_space != TS_INS && pr.pr_space != TS_DATA) return(EINVAL);
        if (pr.pr_size == 0 || pr.pr_size > LONG_MAX) return(EINVAL);
 
-       seg = (pr.pr_space == TS_INS) ? T : D;
        if (req == T_GETRANGE)
-               r = sys_vircopy(child->mp_endpoint, seg, (vir_bytes) pr.pr_addr,
-                       who_e, D, (vir_bytes) pr.pr_ptr,
+               r = sys_vircopy(child->mp_endpoint, (vir_bytes) pr.pr_addr,
+                       who_e, (vir_bytes) pr.pr_ptr,
                        (phys_bytes) pr.pr_size);
        else
-               r = sys_vircopy(who_e, D, (vir_bytes) pr.pr_ptr,
-                       child->mp_endpoint, seg, (vir_bytes) pr.pr_addr,
+               r = sys_vircopy(who_e, (vir_bytes) pr.pr_ptr,
+                       child->mp_endpoint, (vir_bytes) pr.pr_addr,
                        (phys_bytes) pr.pr_size);
 
        if (r != OK) return(r);

diff --git a/servers/rs/exec.c b/servers/rs/exec.c
index 1a9cbadfa990032cd647e6469a97ee18e6eefa05..1c3117c9266c20cb619f21a3549e9b3b9fe732e6 100644 (file)
--- a/servers/rs/exec.c
+++ b/servers/rs/exec.c
@@ -202,8 +202,8 @@ size_t seg_bytes           /* how much is to be transferred? */
   int r;
 
   if (off+seg_bytes > execi->hdr_len) return ENOEXEC;
-  if((r= sys_vircopy(SELF, D, ((vir_bytes)execi->hdr)+off,
-       execi->proc_e, D, seg_addr, seg_bytes)) != OK) {
+  if((r= sys_vircopy(SELF, ((vir_bytes)execi->hdr)+off,
+       execi->proc_e, seg_addr, seg_bytes)) != OK) {
        printf("RS: exec read_seg: copy 0x%x bytes into %d at 0x%lx failed: %d\n",
                seg_bytes, execi->proc_e, seg_addr, r);
   }

diff --git a/servers/rs/request.c b/servers/rs/request.c
index 54628eac7513c1dbd0399d3c6d9afb7a902562e6..3a56e2575e9119f56e62f834a68ccf346481f958 100755 (executable)
--- a/servers/rs/request.c
+++ b/servers/rs/request.c
@@ -918,8 +918,8 @@ message *m_ptr;
                return EINVAL;
        }
 
-       if((r=sys_vircopy(m_ptr->m_source, D, (vir_bytes) m_ptr->RS_NAME,
-               SELF, D, (vir_bytes) namebuf, len)) != OK) {
+       if((r=sys_vircopy(m_ptr->m_source, (vir_bytes) m_ptr->RS_NAME,
+               SELF, (vir_bytes) namebuf, len)) != OK) {
                printf("RS: name copy failed\n");
                return r;
 

diff --git a/servers/vfs/coredump.c b/servers/vfs/coredump.c
index 37e24d024ec90f3aa9c932ee3e3b7af3e2bc1f90..6d484d83d660584df345af761f2a038f08834467 100644 (file)
--- a/servers/vfs/coredump.c
+++ b/servers/vfs/coredump.c
@@ -304,9 +304,9 @@ static void dump_segments(struct filp *f, Elf_Phdr phdrs[], int phnum)
        }
 
        for (off = 0; off < (off_t) len; off += CLICK_SIZE) {
-               r = sys_vircopy(fp->fp_endpoint, D,
+               r = sys_vircopy(fp->fp_endpoint,
                        (vir_bytes) (seg_off + off),
-                       SELF, D, (vir_bytes) buf,
+                       SELF, (vir_bytes) buf,
                        (phys_bytes) CLICK_SIZE);
 
                write_buf(f, (char *) buf, (off + CLICK_SIZE <= (off_t) len) ?

diff --git a/servers/vfs/dmap.c b/servers/vfs/dmap.c
index ed83553e20f19b244df7e33d31621871784eff8a..347b14de447944858695983ded0800a8f7ee37ee 100644 (file)
--- a/servers/vfs/dmap.c
+++ b/servers/vfs/dmap.c
@@ -55,7 +55,7 @@ int do_mapdriver()
        printf("VFS: do_mapdriver: label too long\n");
        return(EINVAL);
   }
-  r = sys_vircopy(who_e, D, label_vir, SELF, D, (vir_bytes) label, label_len);
+  r = sys_vircopy(who_e, label_vir, SELF, (vir_bytes) label, label_len);
   if (r != OK) {
        printf("VFS: do_mapdriver: sys_vircopy failed: %d\n", r);
        return(EINVAL);

diff --git a/servers/vfs/request.c b/servers/vfs/request.c
index c28a75cf843b0c30026f3edc5563eacdf241b5e6..e39979dea5290998f1283ea711ffce26ba87f234 100644 (file)
--- a/servers/vfs/request.c
+++ b/servers/vfs/request.c
@@ -985,7 +985,7 @@ int req_stat(endpoint_t fs_e, ino_t inode_nr, endpoint_t proc_e, vir_bytes buf,
   old_sb.st_ctime = sb.st_ctime;
 #endif
 
-  r = sys_vircopy(SELF, D, (vir_bytes) &old_sb, proc_e, D, buf,
+  r = sys_vircopy(SELF, (vir_bytes) &old_sb, proc_e, buf,
                  sizeof(struct minix_prev_stat));
 
   return(r);

diff --git a/servers/vfs/select.c b/servers/vfs/select.c
index c1290fbfca572751af7495651d94cddf005df0bb..01d4305235e8e5516cf421e601ee755828db2d2b 100644 (file)
--- a/servers/vfs/select.c
+++ b/servers/vfs/select.c
@@ -123,7 +123,7 @@ int do_select(void)
   /* Did the process set a timeout value? If so, retrieve it. */
   if (vtimeout != 0) {
        do_timeout = 1;
-       r = sys_vircopy(who_e, D, (vir_bytes) vtimeout, SELF, D,
+       r = sys_vircopy(who_e, (vir_bytes) vtimeout, SELF, 
                        (vir_bytes) &timeout, sizeof(timeout));
        if (r != OK) return(r);
   }
@@ -546,7 +546,7 @@ static int copy_fdsets(struct selectentry *se, int nfds, int direction)
   src_fds = (direction == FROM_PROC) ? se->vir_readfds : &se->ready_readfds;
   dst_fds = (direction == FROM_PROC) ? &se->readfds : se->vir_readfds;
   if (se->vir_readfds) {
-       r = sys_vircopy(src_e, D, (vir_bytes) src_fds, dst_e, D,
+       r = sys_vircopy(src_e, (vir_bytes) src_fds, dst_e, 
                        (vir_bytes) dst_fds, fd_setsize);
        if (r != OK) return(r);
   }
@@ -555,7 +555,7 @@ static int copy_fdsets(struct selectentry *se, int nfds, int direction)
   src_fds = (direction == FROM_PROC) ? se->vir_writefds : &se->ready_writefds;
   dst_fds = (direction == FROM_PROC) ? &se->writefds : se->vir_writefds;
   if (se->vir_writefds) {
-       r = sys_vircopy(src_e, D, (vir_bytes) src_fds, dst_e, D,
+       r = sys_vircopy(src_e, (vir_bytes) src_fds, dst_e, 
                        (vir_bytes) dst_fds, fd_setsize);
        if (r != OK) return(r);
   }
@@ -564,7 +564,7 @@ static int copy_fdsets(struct selectentry *se, int nfds, int direction)
   src_fds = (direction == FROM_PROC) ? se->vir_errorfds : &se->ready_errorfds;
   dst_fds = (direction == FROM_PROC) ? &se->errorfds : se->vir_errorfds;
   if (se->vir_errorfds) {
-       r = sys_vircopy(src_e, D, (vir_bytes) src_fds, dst_e, D,
+       r = sys_vircopy(src_e, (vir_bytes) src_fds, dst_e, 
                        (vir_bytes) dst_fds, fd_setsize);
        if (r != OK) return(r);
   }