Index: alpha/alpha/sys_machdep.c
===================================================================
RCS file: /home/ncvs/src/sys/alpha/alpha/sys_machdep.c,v
retrieving revision 1.18
diff -u -r1.18 sys_machdep.c
--- alpha/alpha/sys_machdep.c	31 Jul 2002 19:37:02 -0000	1.18
+++ alpha/alpha/sys_machdep.c	12 Dec 2002 03:14:38 -0000
@@ -76,7 +76,7 @@
 {
 	int error = 0;
 
-	switch(SCARG(uap,op)) {
+	switch(uap->op) {
 	case ALPHA_SETHAE:
 		error = alpha_sethae(td, uap->parms);
 		break;
Index: alpha/osf1/osf1_misc.c
===================================================================
RCS file: /home/ncvs/src/sys/alpha/osf1/osf1_misc.c,v
retrieving revision 1.33
diff -u -r1.33 osf1_misc.c
--- alpha/osf1/osf1_misc.c	30 Aug 2002 04:04:34 -0000	1.33
+++ alpha/osf1/osf1_misc.c	12 Dec 2002 03:14:38 -0000
@@ -249,9 +249,9 @@
 	sg = stackgap_init();
 	CHECKALTEXIST(td, &sg, uap->path);
 
-	SCARG(&a, path) = SCARG(uap, path);
-	SCARG(&a, flags) = SCARG(uap, flags);		/* XXX translate */
-	SCARG(&a, mode) = SCARG(uap, mode);
+	a.path = uap->path;
+	a.flags = uap->flags;		/* XXX translate */
+	a.mode = uap->mode;
 
 	return open(td, &a);
 }
@@ -396,16 +396,16 @@
 		syscallarg(struct rlimit *) rlp;
 	} */ a;
 
-	if (SCARG(uap, which) >= OSF1_RLIMIT_NLIMITS)
+	if (uap->which >= OSF1_RLIMIT_NLIMITS)
 		return (EINVAL);
 
-	if (SCARG(uap, which) <= OSF1_RLIMIT_LASTCOMMON)
-		SCARG(&a, which) = SCARG(uap, which);
-	else if (SCARG(uap, which) == OSF1_RLIMIT_NOFILE)
-		SCARG(&a, which) = RLIMIT_NOFILE;
+	if (uap->which <= OSF1_RLIMIT_LASTCOMMON)
+		a.which = uap->which;
+	else if (uap->which == OSF1_RLIMIT_NOFILE)
+		a.which = RLIMIT_NOFILE;
 	else
 		return (0);
-	SCARG(&a, rlp) = (struct rlimit *)SCARG(uap, rlp);
+	a.rlp = (struct rlimit *)uap->rlp;
 
 	return getrlimit(td, &a);
 }
@@ -421,16 +421,16 @@
 		syscallarg(struct rlimit *) rlp;
 	} */ a;
 
-	if (SCARG(uap, which) >= OSF1_RLIMIT_NLIMITS)
+	if (uap->which >= OSF1_RLIMIT_NLIMITS)
 		return (EINVAL);
 
-	if (SCARG(uap, which) <= OSF1_RLIMIT_LASTCOMMON)
-		SCARG(&a, which) = SCARG(uap, which);
-	else if (SCARG(uap, which) == OSF1_RLIMIT_NOFILE)
-		SCARG(&a, which) = RLIMIT_NOFILE;
+	if (uap->which <= OSF1_RLIMIT_LASTCOMMON)
+		a.which = uap->which;
+	else if (uap->which == OSF1_RLIMIT_NOFILE)
+		a.which = RLIMIT_NOFILE;
 	else
 		return (0);
-	SCARG(&a, rlp) = (struct rlimit *)SCARG(uap, rlp);
+	a.rlp = (struct rlimit *)uap->rlp;
 
 	return setrlimit(td, &a);
 }
@@ -476,14 +476,14 @@
 
 	GIANT_REQUIRED;
 
-	SCARG(&a, addr) = SCARG(uap, addr);
-	SCARG(&a, len) = SCARG(uap, len);
-	SCARG(&a, prot) = SCARG(uap, prot);
-	SCARG(&a, fd) = SCARG(uap, fd);
-	SCARG(&a, pad) = 0;
-	SCARG(&a, pos) = SCARG(uap, pos);
+	a.addr = uap->addr;
+	a.len = uap->len;
+	a.prot = uap->prot;
+	a.fd = uap->fd;
+	a.pad = 0;
+	a.pos = uap->pos;
 
-	SCARG(&a, flags) = 0;
+	a.flags = 0;
 
 	/*
 	 *  OSF/1's mmap, unlike FreeBSD's, does its best to map memory at the
@@ -493,8 +493,8 @@
 	 *  close to where they've requested as possible.
 	 */
 
-	if (SCARG(uap, addr) != NULL)
-		addr = round_page((vm_offset_t)SCARG(&a,addr));
+	if (uap->addr != NULL)
+		addr = round_page((vm_offset_t)a.addr);
 	else
 	/*
 	 *  Try to use the apparent OSF/1 default placement of 0x10000 for
@@ -502,55 +502,55 @@
 	 *  SEGV'ing.
 	 */
 		addr = round_page((vm_offset_t)0x10000UL);
-	len = (vm_offset_t)SCARG(&a, len);
+	len = (vm_offset_t)a.len;
 	map = &td->td_proc->p_vmspace->vm_map;
 	if (!vm_map_findspace(map, addr, len, &newaddr)) {
-		SCARG(&a,addr) = (caddr_t) newaddr;
-		SCARG(&a, flags) |= (MAP_FIXED);
+		a.addr = (caddr_t) newaddr;
+		a.flags |= (MAP_FIXED);
 	}
 #ifdef DEBUG
 	else
 		uprintf("osf1_mmap:vm_map_findspace failed for: %p 0x%lx\n",
 		    (caddr_t)addr, len);
 #endif
-	if (SCARG(uap, flags) & OSF1_MAP_SHARED)
-		SCARG(&a, flags) |= MAP_SHARED;
-	if (SCARG(uap, flags) & OSF1_MAP_PRIVATE)
-		SCARG(&a, flags) |= MAP_PRIVATE;
+	if (uap->flags & OSF1_MAP_SHARED)
+		a.flags |= MAP_SHARED;
+	if (uap->flags & OSF1_MAP_PRIVATE)
+		a.flags |= MAP_PRIVATE;
 
-	switch (SCARG(uap, flags) & OSF1_MAP_TYPE) {
+	switch (uap->flags & OSF1_MAP_TYPE) {
 	case OSF1_MAP_ANONYMOUS:
-		SCARG(&a, flags) |= MAP_ANON;
+		a.flags |= MAP_ANON;
 		break;
 	case OSF1_MAP_FILE:
-		SCARG(&a, flags) |= MAP_FILE;
+		a.flags |= MAP_FILE;
 		break;
 	default:
 		return (EINVAL);
 	}
-	if (SCARG(uap, flags) & OSF1_MAP_FIXED)
-		SCARG(&a, flags) |= MAP_FIXED;
-	if (SCARG(uap, flags) & OSF1_MAP_HASSEMAPHORE)
-		SCARG(&a, flags) |= MAP_HASSEMAPHORE;
-	if (SCARG(uap, flags) & OSF1_MAP_INHERIT)
+	if (uap->flags & OSF1_MAP_FIXED)
+		a.flags |= MAP_FIXED;
+	if (uap->flags & OSF1_MAP_HASSEMAPHORE)
+		a.flags |= MAP_HASSEMAPHORE;
+	if (uap->flags & OSF1_MAP_INHERIT)
 		return (EINVAL);
-	if (SCARG(uap, flags) & OSF1_MAP_UNALIGNED)
+	if (uap->flags & OSF1_MAP_UNALIGNED)
 		return (EINVAL);
 	/*
 	 *  Emulate an osf/1 bug:  Apparently, mmap'ed segments are always
 	 *  readable even if the user doesn't or in PROT_READ.  This causes
 	 *  some buggy programs to segv.
 	 */
-	SCARG(&a, prot) |= PROT_READ;
+	a.prot |= PROT_READ;
 
 
 	retval = mmap(td, &a);
 #ifdef DEBUG
 	uprintf(
 	    "\nosf1_mmap: addr=%p (%p), len = 0x%lx, prot=0x%x, fd=%d, pad=0, pos=0x%lx",
-	    SCARG(uap, addr), SCARG(&a, addr),SCARG(uap, len), SCARG(uap, prot),
-	    SCARG(uap, fd), SCARG(uap, pos));
-	printf(" flags = 0x%x\n",SCARG(uap, flags));
+	    uap->addr, a.addr,uap->len, uap->prot,
+	    uap->fd, uap->pos);
+	printf(" flags = 0x%x\n",uap->flags);
 #endif
 	return (retval);
 }
@@ -562,15 +562,15 @@
 {
 	struct msync_args a;
 
-	a.addr = SCARG(uap, addr);
-	a.len  = SCARG(uap, len);
+	a.addr = uap->addr;
+	a.len  = uap->len;
 	a.flags = 0;
-	if(SCARG(uap, flags) & OSF1_MS_ASYNC)
-		SCARG(&a, flags) |= MS_ASYNC;
-	if(SCARG(uap, flags) & OSF1_MS_SYNC)
-		SCARG(&a, flags) |= MS_SYNC;
-	if(SCARG(uap, flags) & OSF1_MS_INVALIDATE)
-		SCARG(&a, flags) |= MS_INVALIDATE;
+	if(uap->flags & OSF1_MS_ASYNC)
+		a.flags |= MS_ASYNC;
+	if(uap->flags & OSF1_MS_SYNC)
+		a.flags |= MS_SYNC;
+	if(uap->flags & OSF1_MS_INVALIDATE)
+		a.flags |= MS_INVALIDATE;
 	return(msync(td, &a));
 }
 
@@ -615,7 +615,7 @@
 	CHECKALTEXIST(td, &sg, uap->path);
 
 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
-	    SCARG(uap, path), td);
+	    uap->path, td);
 	if ((error = namei(&nd)))
 		return (error);
 	error = vn_stat(nd.ni_vp, &sb, td->td_ucred, NOCRED, td);
@@ -623,7 +623,7 @@
 	if (error)
 		return (error);
 	cvtstat2osf1(&sb, &osb);
-	error = copyout((caddr_t)&osb, (caddr_t)SCARG(uap, ub), sizeof (osb));
+	error = copyout((caddr_t)&osb, (caddr_t)uap->ub, sizeof (osb));
 	return (error);
 }
 
@@ -646,7 +646,7 @@
 	CHECKALTEXIST(td, &sg, uap->path);
 
 	NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF, UIO_USERSPACE,
-	    SCARG(uap, path), td);
+	    uap->path, td);
 	if ((error = namei(&nd)))
 		return (error);
 	error = vn_stat(nd.ni_vp, &sb, td->td_ucred, NOCRED, td);
@@ -654,7 +654,7 @@
 	if (error)
 		return (error);
 	cvtstat2osf1(&sb, &osb);
-	error = copyout((caddr_t)&osb, (caddr_t)SCARG(uap, ub), sizeof (osb));
+	error = copyout((caddr_t)&osb, (caddr_t)uap->ub, sizeof (osb));
 	return (error);
 }
 
@@ -678,7 +678,7 @@
 	fdrop(fp, td);
 	cvtstat2osf1(&ub, &oub);
 	if (error == 0)
-		error = copyout((caddr_t)&oub, (caddr_t)SCARG(uap, sb),
+		error = copyout((caddr_t)&oub, (caddr_t)uap->sb,
 		    sizeof (oub));
 	return (error);
 }
@@ -736,9 +736,9 @@
 	sg = stackgap_init();
         CHECKALTEXIST(td, &sg, uap->path);
 
-	SCARG(&a, path) = SCARG(uap, path);
-	SCARG(&a, mode) = SCARG(uap, mode);
-	SCARG(&a, dev) = osf2bsd_dev(SCARG(uap, dev));
+	a.path = uap->path;
+	a.mode = uap->mode;
+	a.dev = osf2bsd_dev(uap->dev);
 
 	return mknod(td, &a);
 #endif
@@ -784,32 +784,32 @@
 
 	error = 0;
 
-	switch (SCARG(uap, cmd)) {
+	switch (uap->cmd) {
 
 	case F_SETFL:
-		SCARG(&a, fd) = SCARG(uap, fd);
-		SCARG(&a, cmd) = F_SETFL;
+		a.fd = uap->fd;
+		a.cmd = F_SETFL;
 		/* need to translate flags here */
 		tmp = 0;
-		if ((long)SCARG(uap, arg) & OSF1_FNONBLOCK)
+		if ((long)uap->arg & OSF1_FNONBLOCK)
 			tmp |= FNONBLOCK;
-		if ((long)SCARG(uap, arg) & OSF1_FAPPEND)
+		if ((long)uap->arg & OSF1_FAPPEND)
 			tmp |= FAPPEND;
-		if ((long)SCARG(uap, arg) & OSF1_FDEFER)
+		if ((long)uap->arg & OSF1_FDEFER)
 			tmp |= FDEFER;
-		if ((long)SCARG(uap, arg) & OSF1_FASYNC)
+		if ((long)uap->arg & OSF1_FASYNC)
 			tmp |= FASYNC;
-		if ((long)SCARG(uap, arg) & OSF1_FCREAT)
+		if ((long)uap->arg & OSF1_FCREAT)
 			tmp |= O_CREAT;
-		if ((long)SCARG(uap, arg) & OSF1_FTRUNC)
+		if ((long)uap->arg & OSF1_FTRUNC)
 			tmp |= O_TRUNC;
-		if ((long)SCARG(uap, arg) & OSF1_FEXCL)
+		if ((long)uap->arg & OSF1_FEXCL)
 			tmp |= O_EXCL;
-		if ((long)SCARG(uap, arg) & OSF1_FNDELAY)
+		if ((long)uap->arg & OSF1_FNDELAY)
 			tmp |= FNDELAY;
-		if ((long)SCARG(uap, arg) & OSF1_FSYNC)
+		if ((long)uap->arg & OSF1_FSYNC)
 			tmp |= FFSYNC;
-		SCARG(&a, arg) = tmp;
+		a.arg = tmp;
 		error = fcntl(td, &a);
 		break;
 
@@ -892,42 +892,42 @@
 	long tmp;
 	int error;
 
-	SCARG(&a, fd) = SCARG(uap, fd);
+	a.fd = uap->fd;
 
-	switch (SCARG(uap, cmd)) {
+	switch (uap->cmd) {
 
 	case OSF1_F_DUPFD:
-		SCARG(&a, cmd) = F_DUPFD;
-		SCARG(&a, arg) = (long)SCARG(uap, arg);
+		a.cmd = F_DUPFD;
+		a.arg = (long)uap->arg;
 		break;
 
 	case OSF1_F_GETFD:
-		SCARG(&a, cmd) = F_GETFD;
-		SCARG(&a, arg) = (long)SCARG(uap, arg);
+		a.cmd = F_GETFD;
+		a.arg = (long)uap->arg;
 		break;
 
 	case OSF1_F_SETFD:
-		SCARG(&a, cmd) = F_SETFD;
-		SCARG(&a, arg) = (long)SCARG(uap, arg);
+		a.cmd = F_SETFD;
+		a.arg = (long)uap->arg;
 		break;
 
 	case OSF1_F_GETFL:
-		SCARG(&a, cmd) = F_GETFL;
-		SCARG(&a, arg) = (long)SCARG(uap, arg);		/* ignored */
+		a.cmd = F_GETFL;
+		a.arg = (long)uap->arg;		/* ignored */
 		break;
 
 	case OSF1_F_SETFL:
-		SCARG(&a, cmd) = F_SETFL;
+		a.cmd = F_SETFL;
 		tmp = 0;
-		if ((long)SCARG(uap, arg) & OSF1_FAPPEND)
+		if ((long)uap->arg & OSF1_FAPPEND)
 			tmp |= FAPPEND;
-		if ((long)SCARG(uap, arg) & OSF1_FNONBLOCK)
+		if ((long)uap->arg & OSF1_FNONBLOCK)
 			tmp |= FNONBLOCK;
-		if ((long)SCARG(uap, arg) & OSF1_FASYNC)
+		if ((long)uap->arg & OSF1_FASYNC)
 			tmp |= FASYNC;
-		if ((long)SCARG(uap, arg) & OSF1_FSYNC)
+		if ((long)uap->arg & OSF1_FSYNC)
 			tmp |= FFSYNC;
-		SCARG(&a, arg) = tmp;
+		a.arg = tmp;
 		break;
 
 	default:					/* XXX other cases */
@@ -939,7 +939,7 @@
 	if (error)
 		return error;
 
-	switch (SCARG(uap, cmd)) {
+	switch (uap->cmd) {
 	case OSF1_F_GETFL:
 		/* XXX */
 		break;
@@ -956,12 +956,12 @@
 {
 	struct socket_args a;
 
-	if (SCARG(uap, type) > AF_LINK)
+	if (uap->type > AF_LINK)
 		return (EINVAL);	/* XXX After AF_LINK, divergence. */
 
-	SCARG(&a, domain) = SCARG(uap, domain);
-	SCARG(&a, type) = SCARG(uap, type);
-	SCARG(&a, protocol) = SCARG(uap, protocol);
+	a.domain = uap->domain;
+	a.type = uap->type;
+	a.protocol = uap->protocol;
 
 	return socket(td, &a);
 }
@@ -974,15 +974,15 @@
 {
 	struct sendto_args a;
 
-	if (SCARG(uap, flags) & ~0x7f)		/* unsupported flags */
+	if (uap->flags & ~0x7f)		/* unsupported flags */
 		return (EINVAL);
 
-	SCARG(&a, s) = SCARG(uap, s);
-	SCARG(&a, buf) = SCARG(uap, buf);
-	SCARG(&a, len) = SCARG(uap, len);
-	SCARG(&a, flags) = SCARG(uap, flags);
-	SCARG(&a, to) = (caddr_t)SCARG(uap, to);
-	SCARG(&a, tolen) = SCARG(uap, tolen);
+	a.s = uap->s;
+	a.buf = uap->buf;
+	a.len = uap->len;
+	a.flags = uap->flags;
+	a.to = (caddr_t)uap->to;
+	a.tolen = uap->tolen;
 
 	return sendto(td, &a);
 }
@@ -995,24 +995,24 @@
 {
 	struct reboot_args a;
 
-	if (SCARG(uap, opt) & ~OSF1_RB_ALLFLAGS &&
-	    SCARG(uap, opt) & (OSF1_RB_ALTBOOT|OSF1_RB_UNIPROC))
+	if (uap->opt & ~OSF1_RB_ALLFLAGS &&
+	    uap->opt & (OSF1_RB_ALTBOOT|OSF1_RB_UNIPROC))
 		return (EINVAL);
 
-	SCARG(&a, opt) = 0;
+	a.opt = 0;
 
-	if (SCARG(uap, opt) & OSF1_RB_ASKNAME)
-		SCARG(&a, opt) |= RB_ASKNAME;
-	if (SCARG(uap, opt) & OSF1_RB_SINGLE)
-		SCARG(&a, opt) |= RB_SINGLE;
-	if (SCARG(uap, opt) & OSF1_RB_NOSYNC)
-		SCARG(&a, opt) |= RB_NOSYNC;
-	if (SCARG(uap, opt) & OSF1_RB_HALT)
-		SCARG(&a, opt) |= RB_HALT;
-	if (SCARG(uap, opt) & OSF1_RB_INITNAME)
-		SCARG(&a, opt) |= RB_INITNAME;
-	if (SCARG(uap, opt) & OSF1_RB_DFLTROOT)
-		SCARG(&a, opt) |= RB_DFLTROOT;
+	if (uap->opt & OSF1_RB_ASKNAME)
+		a.opt |= RB_ASKNAME;
+	if (uap->opt & OSF1_RB_SINGLE)
+		a.opt |= RB_SINGLE;
+	if (uap->opt & OSF1_RB_NOSYNC)
+		a.opt |= RB_NOSYNC;
+	if (uap->opt & OSF1_RB_HALT)
+		a.opt |= RB_HALT;
+	if (uap->opt & OSF1_RB_INITNAME)
+		a.opt |= RB_INITNAME;
+	if (uap->opt & OSF1_RB_DFLTROOT)
+		a.opt |= RB_DFLTROOT;
 
 	return reboot(td, &a);
 }
@@ -1025,10 +1025,10 @@
 {
 	struct lseek_args a;
 
-	SCARG(&a, fd) = SCARG(uap, fd);
-	SCARG(&a, pad) = 0;
-	SCARG(&a, offset) = SCARG(uap, offset);
-	SCARG(&a, whence) = SCARG(uap, whence);
+	a.fd = uap->fd;
+	a.pad = 0;
+	a.offset = uap->offset;
+	a.whence = uap->whence;
 
 	return lseek(td, &a);
 }
@@ -1060,7 +1060,7 @@
 	struct ucred *newcred, *oldcred;
 
 	p = td->td_proc;
-	uid = SCARG(uap, uid);
+	uid = uap->uid;
 	newcred = crget();
 	uip = uifind(uid);
 	PROC_LOCK(p);
@@ -1115,7 +1115,7 @@
 	struct ucred *newcred, *oldcred;
 
 	p = td->td_proc;
-	gid = SCARG(uap, gid);
+	gid = uap->gid;
 	newcred = crget();
 	PROC_LOCK(p);
 	oldcred = p->p_ucred;
@@ -1175,28 +1175,28 @@
 
 	sg = stackgap_init();
 
-	if (SCARG(uap, iovcnt) > (STACKGAPLEN / sizeof (struct iovec)))
+	if (uap->iovcnt > (STACKGAPLEN / sizeof (struct iovec)))
 		return (EINVAL);
 
-	osize = SCARG(uap, iovcnt) * sizeof (struct osf1_iovec);
-	nsize = SCARG(uap, iovcnt) * sizeof (struct iovec);
+	osize = uap->iovcnt * sizeof (struct osf1_iovec);
+	nsize = uap->iovcnt * sizeof (struct iovec);
 
 	oio = malloc(osize, M_TEMP, M_WAITOK);
 	nio = malloc(nsize, M_TEMP, M_WAITOK);
 
 	error = 0;
-	if ((error = copyin(SCARG(uap, iovp), oio, osize)))
+	if ((error = copyin(uap->iovp, oio, osize)))
 		goto punt;
-	for (i = 0; i < SCARG(uap, iovcnt); i++) {
+	for (i = 0; i < uap->iovcnt; i++) {
 		nio[i].iov_base = oio[i].iov_base;
 		nio[i].iov_len = oio[i].iov_len;
 	}
 
-	SCARG(&a, fd) = SCARG(uap, fd);
-	SCARG(&a, iovp) = stackgap_alloc(&sg, nsize);
-	SCARG(&a, iovcnt) = SCARG(uap, iovcnt);
+	a.fd = uap->fd;
+	a.iovp = stackgap_alloc(&sg, nsize);
+	a.iovcnt = uap->iovcnt;
 
-	if ((error = copyout(nio, (caddr_t)SCARG(&a, iovp), nsize)))
+	if ((error = copyout(nio, (caddr_t)a.iovp, nsize)))
 		goto punt;
 	error = readv(td, &a);
 
@@ -1224,28 +1224,28 @@
 
 	sg = stackgap_init();
 
-	if (SCARG(uap, iovcnt) > (STACKGAPLEN / sizeof (struct iovec)))
+	if (uap->iovcnt > (STACKGAPLEN / sizeof (struct iovec)))
 		return (EINVAL);
 
-	osize = SCARG(uap, iovcnt) * sizeof (struct osf1_iovec);
-	nsize = SCARG(uap, iovcnt) * sizeof (struct iovec);
+	osize = uap->iovcnt * sizeof (struct osf1_iovec);
+	nsize = uap->iovcnt * sizeof (struct iovec);
 
 	oio = malloc(osize, M_TEMP, M_WAITOK);
 	nio = malloc(nsize, M_TEMP, M_WAITOK);
 
 	error = 0;
-	if ((error = copyin(SCARG(uap, iovp), oio, osize)))
+	if ((error = copyin(uap->iovp, oio, osize)))
 		goto punt;
-	for (i = 0; i < SCARG(uap, iovcnt); i++) {
+	for (i = 0; i < uap->iovcnt; i++) {
 		nio[i].iov_base = oio[i].iov_base;
 		nio[i].iov_len = oio[i].iov_len;
 	}
 
-	SCARG(&a, fd) = SCARG(uap, fd);
-	SCARG(&a, iovp) = stackgap_alloc(&sg, nsize);
-	SCARG(&a, iovcnt) = SCARG(uap, iovcnt);
+	a.fd = uap->fd;
+	a.iovp = stackgap_alloc(&sg, nsize);
+	a.iovcnt = uap->iovcnt;
 
-	if ((error = copyout(nio, (caddr_t)SCARG(&a, iovp), nsize)))
+	if ((error = copyout(nio, (caddr_t)a.iovp, nsize)))
 		goto punt;
 	error = writev(td, &a);
 
@@ -1270,9 +1270,9 @@
 	sg = stackgap_init();
         CHECKALTEXIST(td, &sg, uap->path);
 
-	SCARG(&a, path) = SCARG(uap, path);
-	SCARG(&a, pad) = 0;
-	SCARG(&a, length) = SCARG(uap, length);
+	a.path = uap->path;
+	a.pad = 0;
+	a.length = uap->length;
 
 	return truncate(td, &a);
 }
@@ -1285,9 +1285,9 @@
 {
 	struct ftruncate_args a;
 
-	SCARG(&a, fd) = SCARG(uap, fd);
-	SCARG(&a, pad) = 0;
-	SCARG(&a, length) = SCARG(uap, length);
+	a.fd = uap->fd;
+	a.pad = 0;
+	a.length = uap->length;
 
 	return ftruncate(td, &a);
 }
@@ -1400,11 +1400,11 @@
 	struct osf1_rusage *orusage, oru;
 	struct rusage *rusage = NULL, ru;
 
-	orusage = SCARG(uap, rusage);
+	orusage = uap->rusage;
 	if (orusage) {
 		sg = stackgap_init();
 		rusage = stackgap_alloc(&sg, sizeof(struct rusage));
-		SCARG(uap, rusage) = (struct osf1_rusage *)rusage;
+		uap->rusage = (struct osf1_rusage *)rusage;
 	}
 	if ((error = wait4(td, (struct wait_args *)uap)))
 		return error;
@@ -1439,11 +1439,11 @@
 	struct execve_args ap;
 
 	sg = stackgap_init();
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	CHECKALTEXIST(td, &sg, uap->path);
 
-	SCARG(&ap, fname) = SCARG(uap, path);
-	SCARG(&ap, argv) = SCARG(uap, argp);
-	SCARG(&ap, envv) = SCARG(uap, envp);
+	ap.fname = uap->path;
+	ap.argv = uap->argp;
+	ap.envv = uap->envp;
 
 	return execve(td, &ap);
 }
@@ -1458,7 +1458,7 @@
 	struct osf1_timeval time;
 	struct timeval difftv, endtv, sleeptv, tv;
 
-	if ((error = copyin(SCARG(uap, sleep), &time, sizeof time)))
+	if ((error = copyin(uap->sleep, &time, sizeof time)))
 		return (error);
 
 	sleeptv.tv_sec =  (u_long)time.tv_sec;
@@ -1478,7 +1478,7 @@
 
 	tsleep(td, PUSER|PCATCH, "OSF/1", timo);
 
-	if (SCARG(uap, slept) != NULL) {
+	if (uap->slept != NULL) {
 		s = splclock();
 		microtime(&endtv);
 		timersub(&time, &endtv, &difftv);
@@ -1486,7 +1486,7 @@
 		if (tv.tv_sec < 0 || tv.tv_usec < 0)
 			tv.tv_sec = tv.tv_usec = 0;
 		TV_CP(difftv, time)
-		error = copyout(&time, SCARG(uap, slept), sizeof time);
+		error = copyout(&time, uap->slept, sizeof time);
 	}
 	return (error);
 }
Index: alpha/osf1/osf1_mount.c
===================================================================
RCS file: /home/ncvs/src/sys/alpha/osf1/osf1_mount.c,v
retrieving revision 1.8
diff -u -r1.8 osf1_mount.c
--- alpha/osf1/osf1_mount.c	12 Aug 2002 01:16:55 -0000	1.8
+++ alpha/osf1/osf1_mount.c	12 Dec 2002 03:14:38 -0000
@@ -127,7 +127,7 @@
 	struct osf1_statfs osfs;
 	struct nameidata nd;
 
-	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td);
+	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, td);
 	if ((error = namei(&nd)))
 		return (error);
 	mp = nd.ni_vp->v_mount;
@@ -142,8 +142,8 @@
 		return (error);
 	sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
 	bsd2osf_statfs(sp, &osfs);
-	return copyout(&osfs, SCARG(uap, buf), min(sizeof osfs,
-	    SCARG(uap, len)));
+	return copyout(&osfs, uap->buf, min(sizeof osfs,
+	    uap->len));
 }
 
 int
@@ -157,7 +157,7 @@
 	struct statfs *sp;
 	struct osf1_statfs osfs;
 
-	if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)))
+	if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)))
 		return (error);
 	mp = ((struct vnode *)fp->f_data)->v_mount;
 #ifdef MAC
@@ -174,8 +174,8 @@
 		return (error);
 	sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
 	bsd2osf_statfs(sp, &osfs);
-	return copyout(&osfs, SCARG(uap, buf), min(sizeof osfs,
-	    SCARG(uap, len)));
+	return copyout(&osfs, uap->buf, min(sizeof osfs,
+	    uap->len));
 }
 
 int
@@ -189,11 +189,11 @@
 	struct statfs *sp;
 	struct osf1_statfs osfs;
 
-	if (SCARG(uap, flags) & ~OSF1_GETFSSTAT_FLAGS)
+	if (uap->flags & ~OSF1_GETFSSTAT_FLAGS)
 		return (EINVAL);
 
-	maxcount = SCARG(uap, bufsize) / sizeof(struct osf1_statfs);
-	osf_sfsp = (caddr_t)SCARG(uap, buf);
+	maxcount = uap->bufsize / sizeof(struct osf1_statfs);
+	osf_sfsp = (caddr_t)uap->buf;
 	for (count = 0, mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) {
 		nmp = TAILQ_NEXT(mp, mnt_list);
 		if (osf_sfsp && count < maxcount) {
@@ -208,8 +208,8 @@
 			 * fsstat cache.  OSF1_MNT_WAIT overrides
 			 * OSF1_MNT_NOWAIT.
 			 */
-			if (((SCARG(uap, flags) & OSF1_MNT_NOWAIT) == 0 ||
-			    (SCARG(uap, flags) & OSF1_MNT_WAIT)) &&
+			if (((uap->flags & OSF1_MNT_NOWAIT) == 0 ||
+			    (uap->flags & OSF1_MNT_WAIT)) &&
 			    (error = VFS_STATFS(mp, sp, td)))
 				continue;
 			sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
@@ -236,14 +236,14 @@
 {
 	struct unmount_args a;
 
-	SCARG(&a, path) = SCARG(uap, path);
+	a.path = uap->path;
 
-	if (SCARG(uap, flags) & ~OSF1_UNMOUNT_FLAGS)
+	if (uap->flags & ~OSF1_UNMOUNT_FLAGS)
 		return (EINVAL);
-	SCARG(&a, flags) = 0;
-	if ((SCARG(uap, flags) & OSF1_MNT_FORCE) &&
-	    (SCARG(uap, flags) & OSF1_MNT_NOFORCE) == 0)
-		SCARG(&a, flags) |= MNT_FORCE;
+	a.flags = 0;
+	if ((uap->flags & OSF1_MNT_FORCE) &&
+	    (uap->flags & OSF1_MNT_NOFORCE) == 0)
+		a.flags |= MNT_FORCE;
 
 	return unmount(td, &a);
 }
@@ -256,13 +256,13 @@
 	int error;
 	struct mount_args a;
 
-	SCARG(&a, path) = SCARG(uap, path);
+	a.path = uap->path;
 
-	if (SCARG(uap, flags) & ~OSF1_MOUNT_FLAGS)
+	if (uap->flags & ~OSF1_MOUNT_FLAGS)
 		return (EINVAL);
-	SCARG(&a, flags) = SCARG(uap, flags);		/* XXX - xlate */
+	a.flags = uap->flags;		/* XXX - xlate */
 
-	switch (SCARG(uap, type)) {
+	switch (uap->type) {
 	case OSF1_MOUNT_UFS:				/* XXX */
 		return (EINVAL);
 		break;
@@ -319,7 +319,7 @@
 
 	sg = stackgap_init();
 
-	if ((error = copyin(SCARG(osf_argp, data), &osf_ma, sizeof osf_ma)))
+	if ((error = copyin(osf_argp->data, &osf_ma, sizeof osf_ma)))
 		return error;
 
 	bzero(&bsd_ma, sizeof bsd_ma);
@@ -328,13 +328,13 @@
 	bsd_ma.base = osf_ma.base;
 	bsd_ma.size = osf_ma.size;
 
-	SCARG(bsd_argp, data) = stackgap_alloc(&sg, sizeof bsd_ma);
-	if ((error = copyout(&bsd_ma, SCARG(bsd_argp, data), sizeof bsd_ma)))
+	bsd_argp->data = stackgap_alloc(&sg, sizeof bsd_ma);
+	if ((error = copyout(&bsd_ma, bsd_argp->data, sizeof bsd_ma)))
 		return error;
 
 	len = strlen(mfs_name) + 1;
-	SCARG(bsd_argp, type) = stackgap_alloc(&sg, len);
-	if ((error = copyout(mfs_name, (void *)SCARG(bsd_argp, type), len)))
+	bsd_argp->type = stackgap_alloc(&sg, len);
+	if ((error = copyout(mfs_name, (void *)bsd_argp->type, len)))
 		return error;
 #endif
 	return 0;
@@ -354,7 +354,7 @@
 
 	sg = stackgap_init();
 
-	if ((error = copyin(SCARG(osf_argp, data), &osf_na, sizeof osf_na)))
+	if ((error = copyin(osf_argp->data, &osf_na, sizeof osf_na)))
 		return error;
 
 	bzero(&bsd_na, sizeof bsd_na);
@@ -391,13 +391,13 @@
 	if (osf_na.flags & OSF1_NFSMNT_NOCONN)
 		bsd_na.flags |= NFSMNT_NOCONN;
 
-	SCARG(bsd_argp, data) = stackgap_alloc(&sg, sizeof bsd_na);
-	if ((error = copyout(&bsd_na, SCARG(bsd_argp, data), sizeof bsd_na)))
+	bsd_argp->data = stackgap_alloc(&sg, sizeof bsd_na);
+	if ((error = copyout(&bsd_na, bsd_argp->data, sizeof bsd_na)))
 		return error;
 
 	len = strlen(nfs_name) + 1;
-	SCARG(bsd_argp, type) = stackgap_alloc(&sg, len);
-	if ((error = copyout(nfs_name, (void *)SCARG(bsd_argp, type), len)))
+	bsd_argp->type = stackgap_alloc(&sg, len);
+	if ((error = copyout(nfs_name, (void *)bsd_argp->type, len)))
 		return error;
 
 	return 0;
Index: alpha/osf1/osf1_signal.c
===================================================================
RCS file: /home/ncvs/src/sys/alpha/osf1/osf1_signal.c,v
retrieving revision 1.23
diff -u -r1.23 osf1_signal.c
--- alpha/osf1/osf1_signal.c	25 Oct 2002 19:10:55 -0000	1.23
+++ alpha/osf1/osf1_signal.c	12 Dec 2002 03:14:38 -0000
@@ -224,8 +224,8 @@
 	struct sigaction_args sa;
 
 	sg = stackgap_init();
-	nosa = SCARG(uap, nsa);
-	oosa = SCARG(uap, osa);
+	nosa = uap->nsa;
+	oosa = uap->osa;
 	if (osf1_sigdbg && uap->sigtramp)
 		uprintf("osf1_sigaction: trampoline handler at %p\n",
 		    uap->sigtramp);
@@ -244,9 +244,9 @@
 	} else
 		nbsa = NULL;
 
-	SCARG(&sa, sig) = SCARG(uap, signum);
-	SCARG(&sa, act) = nbsa;
-	SCARG(&sa, oact) = obsa;
+	sa.sig = uap->signum;
+	sa.act = nbsa;
+	sa.oact = obsa;
 
 	if ((error = sigaction(td, &sa)) != 0)
 		return error;
@@ -274,8 +274,8 @@
 	struct sigaltstack_args sa;
 
 	sg = stackgap_init();
-	noss = SCARG(uap, nss);
-	ooss = SCARG(uap, oss);
+	noss = uap->nss;
+	ooss = uap->oss;
 
 	if (ooss != NULL)
 		obss = stackgap_alloc(&sg, sizeof(struct sigaltstack));
@@ -292,8 +292,8 @@
 	} else
 		nbss = NULL;
 
-	SCARG(&sa, ss) = nbss;
-	SCARG(&sa, oss) = obss;
+	sa.ss = nbss;
+	sa.oss = obss;
 
 	if ((error = sigaltstack(td, &sa)) != 0)
 		return error;
@@ -321,22 +321,22 @@
 	p = td->td_proc;
 	sg = stackgap_init();
 
-	signum = OSF1_SIGNO(SCARG(uap, signum));
+	signum = OSF1_SIGNO(uap->signum);
 	if (signum <= 0 || signum > OSF1_NSIG) {
-		if (OSF1_SIGCALL(SCARG(uap, signum)) == OSF1_SIGNAL_MASK ||
-		    OSF1_SIGCALL(SCARG(uap, signum)) == OSF1_SIGDEFER_MASK)
+		if (OSF1_SIGCALL(uap->signum) == OSF1_SIGNAL_MASK ||
+		    OSF1_SIGCALL(uap->signum) == OSF1_SIGDEFER_MASK)
 			td->td_retval[0] = -1;
 		return EINVAL;
 	}
 
-	switch (OSF1_SIGCALL(SCARG(uap, signum))) {
+	switch (OSF1_SIGCALL(uap->signum)) {
 	case OSF1_SIGDEFER_MASK:
 		/*
 		 * sigset is identical to signal() except
 		 * that SIG_HOLD is allowed as
 		 * an action.
 		 */
-		if ((u_long)SCARG(uap, handler) ==  OSF1_SIG_HOLD) {
+		if ((u_long)uap->handler ==  OSF1_SIG_HOLD) {
 			sigset_t mask;
 			sigset_t *bmask;
 			struct sigprocmask_args sa;
@@ -344,9 +344,9 @@
 			bmask = stackgap_alloc(&sg, sizeof(sigset_t));
 			SIGEMPTYSET(mask);
 			SIGADDSET(mask, signum);
-			SCARG(&sa, how) = SIG_BLOCK;
-			SCARG(&sa, set) = bmask;
-			SCARG(&sa, oset) = NULL;
+			sa.how = SIG_BLOCK;
+			sa.set = bmask;
+			sa.oset = NULL;
 			if ((error = copyout(&mask, bmask, sizeof(mask))) != 0)
 				return (error);
 			return sigprocmask(td, &sa);
@@ -360,11 +360,11 @@
 
 			nbsa = stackgap_alloc(&sg, sizeof(struct sigaction));
 			obsa = stackgap_alloc(&sg, sizeof(struct sigaction));
-			SCARG(&sa_args, sig) = signum;
-			SCARG(&sa_args, act) = nbsa;
-			SCARG(&sa_args, oact) = obsa;
+			sa_args.sig = signum;
+			sa_args.act = nbsa;
+			sa_args.oact = obsa;
 
-			sa.sa_handler = SCARG(uap, handler);
+			sa.sa_handler = uap->handler;
 			SIGEMPTYSET(sa.sa_mask);
 			sa.sa_flags = 0;
 #if 0
@@ -394,9 +394,9 @@
 			bset = stackgap_alloc(&sg, sizeof(sigset_t));
 			SIGEMPTYSET(set);
 			SIGADDSET(set, signum);
-			SCARG(&sa, how) = SIG_BLOCK;
-			SCARG(&sa, set) = bset;
-			SCARG(&sa, oset) = NULL;
+			sa.how = SIG_BLOCK;
+			sa.set = bset;
+			sa.oset = NULL;
 			if ((error = copyout(&set, bset, sizeof(set))) != 0)
 				return (error);
 			return sigprocmask(td, &sa);
@@ -411,9 +411,9 @@
 			bset = stackgap_alloc(&sg, sizeof(sigset_t));
 			SIGEMPTYSET(set);
 			SIGADDSET(set, signum);
-			SCARG(&sa, how) = SIG_UNBLOCK;
-			SCARG(&sa, set) = bset;
-			SCARG(&sa, oset) = NULL;
+			sa.how = SIG_UNBLOCK;
+			sa.set = bset;
+			sa.oset = NULL;
 			if ((error = copyout(&set, bset, sizeof(set))) != 0)
 				return (error);
 			return sigprocmask(td, &sa);
@@ -426,9 +426,9 @@
 			struct sigaction *bsa, sa;
 
 			bsa = stackgap_alloc(&sg, sizeof(struct sigaction));
-			SCARG(&sa_args, sig) = signum;
-			SCARG(&sa_args, act) = bsa;
-			SCARG(&sa_args, oact) = NULL;
+			sa_args.sig = signum;
+			sa_args.act = bsa;
+			sa_args.oact = NULL;
 
 			sa.sa_handler = SIG_IGN;
 			SIGEMPTYSET(sa.sa_mask);
@@ -453,7 +453,7 @@
 			set = p->p_sigmask;
 			PROC_UNLOCK(p);
 			SIGDELSET(set, signum);
-			SCARG(&sa, sigmask) = bmask;
+			sa.sigmask = bmask;
 			if ((error = copyout(&set, bmask, sizeof(set))) != 0)
 				return (error);
 			return sigsuspend(td, &sa);
@@ -487,7 +487,7 @@
 
 	PROC_LOCK(p);
 
-	switch (SCARG(uap, how)) {
+	switch (uap->how) {
 	case OSF1_SIG_BLOCK:
 		SIGSETOR(p->p_sigmask, bss);
 		SIG_CANTMASK(p->p_sigmask);
@@ -532,7 +532,7 @@
 	PROC_UNLOCK(p);
 	bsd_to_osf1_sigset(&bss, &oss);
 
-	return copyout(&oss, SCARG(uap, mask), sizeof(oss));
+	return copyout(&oss, uap->mask, sizeof(oss));
 }
 
 int
@@ -552,9 +552,9 @@
 	sg = stackgap_init();
 
 	bmask = stackgap_alloc(&sg, sizeof(sigset_t));
-	oss = SCARG(uap, ss);
+	oss = uap->ss;
 	osf1_to_bsd_sigset(&oss, &bss);
-	SCARG(&sa, sigmask) = bmask;
+	sa.sigmask = bmask;
 	if ((error = copyout(&bss, bmask, sizeof(bss))) != 0)
 		return (error);
 	return sigsuspend(td, &sa);
@@ -570,8 +570,8 @@
 {
 	struct kill_args ka;
 
-	SCARG(&ka, pid) = SCARG(uap, pid);
-	SCARG(&ka, signum) = SCARG(uap, signum);
+	ka.pid = uap->pid;
+	ka.signum = uap->signum;
 	return kill(td, &ka);
 }
 
Index: alpha/osf1/osf1_util.h
===================================================================
RCS file: /home/ncvs/src/sys/alpha/osf1/osf1_util.h,v
retrieving revision 1.4
diff -u -r1.4 osf1_util.h
--- alpha/osf1/osf1_util.h	2 Jun 2002 20:05:41 -0000	1.4
+++ alpha/osf1/osf1_util.h	12 Dec 2002 03:14:38 -0000
@@ -37,11 +37,6 @@
 #include <sys/sysent.h>
 #include <sys/cdefs.h>
 
-
-#ifndef	SCARG
-#define	SCARG(p, x)  (p)->x
-#endif
-
 static __inline caddr_t stackgap_init(void);
 static __inline void *stackgap_alloc(caddr_t *, size_t);
 
Index: compat/svr4/svr4_fcntl.c
===================================================================
RCS file: /home/ncvs/src/sys/compat/svr4/svr4_fcntl.c,v
retrieving revision 1.25
diff -u -r1.25 svr4_fcntl.c
--- compat/svr4/svr4_fcntl.c	17 Aug 2002 02:36:15 -0000	1.25
+++ compat/svr4/svr4_fcntl.c	12 Dec 2002 03:14:38 -0000
@@ -349,8 +349,8 @@
 		return EINVAL;
 	}
 
-	SCARG(&ft, fd) = fd;
-	SCARG(&ft, length) = start;
+	ft.fd = fd;
+	ft.length = start;
 
 	error = ftruncate(td, &ft);
 
@@ -368,7 +368,7 @@
 	struct open_args	cup;
 
 	caddr_t sg = stackgap_init();
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	CHECKALTEXIST(td, &sg, uap->path);
 
 	(&cup)->path = uap->path;
 	(&cup)->flags = svr4_to_bsd_flags(uap->flags);
@@ -384,7 +384,7 @@
 	retval = td->td_retval[0];
 
 	PROC_LOCK(p);
-	if (!(SCARG(&cup, flags) & O_NOCTTY) && SESS_LEADER(p) &&
+	if (!(cup.flags & O_NOCTTY) && SESS_LEADER(p) &&
 	    !(td->td_proc->p_flag & P_CONTROLT)) {
 #if defined(NOTYET)
 		struct file	*fp;
@@ -428,11 +428,11 @@
 	struct open_args cup;
 
 	caddr_t sg = stackgap_init();
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	CHECKALTEXIST(td, &sg, uap->path);
 
-	SCARG(&cup, path) = SCARG(uap, path);
-	SCARG(&cup, mode) = SCARG(uap, mode);
-	SCARG(&cup, flags) = O_WRONLY | O_CREAT | O_TRUNC;
+	cup.path = uap->path;
+	cup.mode = uap->mode;
+	cup.flags = O_WRONLY | O_CREAT | O_TRUNC;
 
 	return open(td, &cup);
 }
@@ -452,16 +452,16 @@
 {
 	struct lseek_args ap;
 
-	SCARG(&ap, fd) = SCARG(uap, fd);
+	ap.fd = uap->fd;
 
 #if BYTE_ORDER == BIG_ENDIAN
-	SCARG(&ap, offset) = (((u_int64_t) SCARG(uap, offset1)) << 32) | 
-		SCARG(uap, offset2);
+	ap.offset = (((u_int64_t) uap->offset1) << 32) | 
+		uap->offset2;
 #else
-	SCARG(&ap, offset) = (((u_int64_t) SCARG(uap, offset2)) << 32) | 
-		SCARG(uap, offset1);
+	ap.offset = (((u_int64_t) uap->offset2) << 32) | 
+		uap->offset1;
 #endif
-	SCARG(&ap, whence) = SCARG(uap, whence);
+	ap.whence = uap->whence;
 
 	return lseek(td, &ap);
 }
@@ -475,12 +475,12 @@
 	int *retval;
 
 	caddr_t sg = stackgap_init();
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	CHECKALTEXIST(td, &sg, uap->path);
 
 	retval = td->td_retval;
 
-	SCARG(&cup, path) = SCARG(uap, path);
-	SCARG(&cup, flags) = SCARG(uap, flags);
+	cup.path = uap->path;
+	cup.flags = uap->flags;
 
 	return access(td, &cup);
 }
@@ -497,10 +497,10 @@
 	 * Just translate the args structure and call the NetBSD
 	 * pread(2) system call (offset type is 64-bit in NetBSD).
 	 */
-	SCARG(&pra, fd) = SCARG(uap, fd);
-	SCARG(&pra, buf) = SCARG(uap, buf);
-	SCARG(&pra, nbyte) = SCARG(uap, nbyte);
-	SCARG(&pra, offset) = SCARG(uap, off);
+	pra.fd = uap->fd;
+	pra.buf = uap->buf;
+	pra.nbyte = uap->nbyte;
+	pra.offset = uap->off;
 
 	return pread(td, &pra);
 }
@@ -521,10 +521,10 @@
 	 * Just translate the args structure and call the NetBSD
 	 * pread(2) system call (offset type is 64-bit in NetBSD).
 	 */
-	SCARG(&pra, fd) = SCARG(uap, fd);
-	SCARG(&pra, buf) = SCARG(uap, buf);
-	SCARG(&pra, nbyte) = SCARG(uap, nbyte);
-	SCARG(&pra, offset) = SCARG(uap, off);
+	pra.fd = uap->fd;
+	pra.buf = uap->buf;
+	pra.nbyte = uap->nbyte;
+	pra.offset = uap->off;
 
 	return (sys_pread(td, &pra, retval));
 }
@@ -542,10 +542,10 @@
 	 * Just translate the args structure and call the NetBSD
 	 * pwrite(2) system call (offset type is 64-bit in NetBSD).
 	 */
-	SCARG(&pwa, fd) = SCARG(uap, fd);
-	SCARG(&pwa, buf) = SCARG(uap, buf);
-	SCARG(&pwa, nbyte) = SCARG(uap, nbyte);
-	SCARG(&pwa, offset) = SCARG(uap, off);
+	pwa.fd = uap->fd;
+	pwa.buf = uap->buf;
+	pwa.nbyte = uap->nbyte;
+	pwa.offset = uap->off;
 
 	return pwrite(td, &pwa);
 }
@@ -565,10 +565,10 @@
 	 * Just translate the args structure and call the NetBSD
 	 * pwrite(2) system call (offset type is 64-bit in NetBSD).
 	 */
-	SCARG(&pwa, fd) = SCARG(uap, fd);
-	SCARG(&pwa, buf) = SCARG(uap, buf);
-	SCARG(&pwa, nbyte) = SCARG(uap, nbyte);
-	SCARG(&pwa, offset) = SCARG(uap, off);
+	pwa.fd = uap->fd;
+	pwa.buf = uap->buf;
+	pwa.nbyte = uap->nbyte;
+	pwa.offset = uap->off;
 
 	return (sys_pwrite(td, &pwa, retval));
 }
@@ -585,18 +585,18 @@
 
 	retval = td->td_retval;
 
-	SCARG(&fa, fd) = SCARG(uap, fd);
-	SCARG(&fa, cmd) = svr4_to_bsd_cmd(SCARG(uap, cmd));
+	fa.fd = uap->fd;
+	fa.cmd = svr4_to_bsd_cmd(uap->cmd);
 
-	switch (SCARG(&fa, cmd)) {
+	switch (fa.cmd) {
 	case F_DUPFD:
 	case F_GETFD:
 	case F_SETFD:
-		SCARG(&fa, arg) = (long) SCARG(uap, arg);
+		fa.arg = (long) uap->arg;
 		return fcntl(td, &fa);
 
 	case F_GETFL:
-		SCARG(&fa, arg) = (long) SCARG(uap, arg);
+		fa.arg = (long) uap->arg;
 		error = fcntl(td, &fa);
 		if (error)
 			return error;
@@ -612,17 +612,17 @@
 			long cmd;
 			int flags;
 
-			DPRINTF(("Setting flags %p\n", SCARG(uap, arg)));
-			cmd = SCARG(&fa, cmd); /* save it for a while */
+			DPRINTF(("Setting flags %p\n", uap->arg));
+			cmd = fa.cmd; /* save it for a while */
 
-			SCARG(&fa, cmd) = F_GETFL;
+			fa.cmd = F_GETFL;
 			if ((error = fcntl(td, &fa)) != 0)
 				return error;
 			flags = *retval;
 			flags &= O_ASYNC;
-			flags |= svr4_to_bsd_flags((u_long) SCARG(uap, arg));
-			SCARG(&fa, cmd) = cmd;
-			SCARG(&fa, arg) = (long) flags;
+			flags |= svr4_to_bsd_flags((u_long) uap->arg);
+			fa.cmd = cmd;
+			fa.arg = (long) flags;
 			return fcntl(td, &fa);
 		}
 
@@ -635,9 +635,9 @@
 			caddr_t sg = stackgap_init();
 
 			flp = stackgap_alloc(&sg, sizeof(struct flock));
-			SCARG(&fa, arg) = (long) flp;
+			fa.arg = (long) flp;
 
-			error = copyin(SCARG(uap, arg), &ifl, sizeof ifl);
+			error = copyin(uap->arg, &ifl, sizeof ifl);
 			if (error)
 				return error;
 
@@ -648,7 +648,7 @@
 				return error;
 
 			error = fcntl(td, &fa);
-			if (error || SCARG(&fa, cmd) != F_GETLK)
+			if (error || fa.cmd != F_GETLK)
 				return error;
 
 			error = copyin(flp, &fl, sizeof fl);
@@ -657,20 +657,20 @@
 
 			bsd_to_svr4_flock(&fl, &ifl);
 
-			return copyout(&ifl, SCARG(uap, arg), sizeof ifl);
+			return copyout(&ifl, uap->arg, sizeof ifl);
 		}
 	case -1:
-		switch (SCARG(uap, cmd)) {
+		switch (uap->cmd) {
 		case SVR4_F_DUP2FD:
 			{
 				struct dup2_args du;
 
-				SCARG(&du, from) = SCARG(uap, fd);
-				SCARG(&du, to) = (int)SCARG(uap, arg);
+				du.from = uap->fd;
+				du.to = (int)uap->arg;
 				error = dup2(td, &du);
 				if (error)
 					return error;
-				*retval = SCARG(&du, to);
+				*retval = du.to;
 				return 0;
 			}
 
@@ -679,12 +679,12 @@
 				struct svr4_flock	 ifl;
 				struct flock		 fl;
 
-				error = copyin(SCARG(uap, arg), &ifl,
+				error = copyin(uap->arg, &ifl,
 				    sizeof ifl);
 				if (error)
 					return error;
 				svr4_to_bsd_flock(&ifl, &fl);
-				return fd_truncate(td, SCARG(uap, fd), &fl);
+				return fd_truncate(td, uap->fd, &fl);
 			}
 
 		case SVR4_F_GETLK64:
@@ -696,9 +696,9 @@
 				caddr_t sg = stackgap_init();
 
 				flp = stackgap_alloc(&sg, sizeof(struct flock));
-				SCARG(&fa, arg) = (long) flp;
+				fa.arg = (long) flp;
 
-				error = copyin(SCARG(uap, arg), &ifl,
+				error = copyin(uap->arg, &ifl,
 				    sizeof ifl);
 				if (error)
 					return error;
@@ -710,7 +710,7 @@
 					return error;
 
 				error = fcntl(td, &fa);
-				if (error || SCARG(&fa, cmd) != F_GETLK)
+				if (error || fa.cmd != F_GETLK)
 					return error;
 
 				error = copyin(flp, &fl, sizeof fl);
@@ -719,7 +719,7 @@
 
 				bsd_to_svr4_flock64(&fl, &ifl);
 
-				return copyout(&ifl, SCARG(uap, arg),
+				return copyout(&ifl, uap->arg,
 				    sizeof ifl);
 			}
 
@@ -728,16 +728,16 @@
 				struct svr4_flock64	 ifl;
 				struct flock		 fl;
 
-				error = copyin(SCARG(uap, arg), &ifl,
+				error = copyin(uap->arg, &ifl,
 				    sizeof ifl);
 				if (error)
 					return error;
 				svr4_to_bsd_flock64(&ifl, &fl);
-				return fd_truncate(td, SCARG(uap, fd), &fl);
+				return fd_truncate(td, uap->fd, &fl);
 			}
 
 		case SVR4_F_REVOKE:
-			return fd_revoke(td, SCARG(uap, fd));
+			return fd_revoke(td, uap->fd);
 
 		default:
 			return ENOSYS;
Index: compat/svr4/svr4_filio.c
===================================================================
RCS file: /home/ncvs/src/sys/compat/svr4/svr4_filio.c,v
retrieving revision 1.19
diff -u -r1.19 svr4_filio.c
--- compat/svr4/svr4_filio.c	1 Oct 2002 17:15:50 -0000	1.19
+++ compat/svr4/svr4_filio.c	12 Dec 2002 03:14:38 -0000
@@ -63,26 +63,26 @@
      int idx = 0, cerr;
      u_long siz;
 
-     SCARG(&pa, fds) = SCARG(uap, fds);
-     SCARG(&pa, nfds) = SCARG(uap, nfds);
-     SCARG(&pa, timeout) = SCARG(uap, timeout);
+     pa.fds = uap->fds;
+     pa.nfds = uap->nfds;
+     pa.timeout = uap->timeout;
 
-     siz = SCARG(uap, nfds) * sizeof(struct pollfd);
+     siz = uap->nfds * sizeof(struct pollfd);
      pfd = (struct pollfd *)malloc(siz, M_TEMP, M_WAITOK);
 
      error = poll(td, (struct poll_args *)uap);
 
-     if ((cerr = copyin(SCARG(uap, fds), pfd, siz)) != 0) {
+     if ((cerr = copyin(uap->fds, pfd, siz)) != 0) {
        error = cerr;
        goto done;
      }
 
-     for (idx = 0; idx < SCARG(uap, nfds); idx++) {
+     for (idx = 0; idx < uap->nfds; idx++) {
        /* POLLWRNORM already equals POLLOUT, so we don't worry about that */
        if (pfd[idx].revents & (POLLOUT | POLLWRNORM | POLLWRBAND))
 	    pfd[idx].revents |= (POLLOUT | POLLWRNORM | POLLWRBAND);
      }
-     if ((cerr = copyout(pfd, SCARG(uap, fds), siz)) != 0) {
+     if ((cerr = copyout(pfd, uap->fds, siz)) != 0) {
        error = cerr;
        goto done;   /* yeah, I know it's the next line, but this way I won't
 		       forget to update it if I add more code */
@@ -105,9 +105,9 @@
      sigset_t sigmask;
      int rv;
 
-     SCARG(&ra, fd) = SCARG(uap, fd);
-     SCARG(&ra, buf) = SCARG(uap, buf);
-     SCARG(&ra, nbyte) = SCARG(uap, nbyte);
+     ra.fd = uap->fd;
+     ra.buf = uap->buf;
+     ra.nbyte = uap->nbyte;
 
      if (fget(td, uap->fd, &fp) != 0) {
        DPRINTF(("Something fishy with the user-supplied file descriptor...\n"));
@@ -116,9 +116,9 @@
 
      if (fp->f_type == DTYPE_SOCKET) {
        so = (struct socket *)fp->f_data;
-       DPRINTF(("fd %d is a socket\n", SCARG(uap, fd)));
+       DPRINTF(("fd %d is a socket\n", uap->fd));
        if (so->so_state & SS_ASYNC) {
-	 DPRINTF(("fd %d is an ASYNC socket!\n", SCARG(uap, fd)));
+	 DPRINTF(("fd %d is an ASYNC socket!\n", uap->fd));
        }
        DPRINTF(("Here are its flags: 0x%x\n", so->so_state));
 #if defined(GROTTY_READ_HACK)
@@ -130,7 +130,7 @@
      rv = read(td, &ra);
 
      DPRINTF(("svr4_read(%d, 0x%0x, %d) = %d\n", 
-	     SCARG(uap, fd), SCARG(uap, buf), SCARG(uap, nbyte), rv));
+	     uap->fd, uap->buf, uap->nbyte, rv));
      if (rv == EAGAIN) {
        DPRINTF(("sigmask = 0x%x\n", td->td_proc->p_sigmask));
        DPRINTF(("sigignore = 0x%x\n", td->td_proc->p_sigignore));
@@ -159,14 +159,14 @@
      struct file *fp;
      int rv;
 
-     SCARG(&wa, fd) = SCARG(uap, fd);
-     SCARG(&wa, buf) = SCARG(uap, buf);
-     SCARG(&wa, nbyte) = SCARG(uap, nbyte);
+     wa.fd = uap->fd;
+     wa.buf = uap->buf;
+     wa.nbyte = uap->nbyte;
 
      rv = write(td, &wa);
 
      DPRINTF(("svr4_write(%d, 0x%0x, %d) = %d\n", 
-	     SCARG(uap, fd), SCARG(uap, buf), SCARG(uap, nbyte), rv));
+	     uap->fd, uap->buf, uap->nbyte, rv));
 
      return(rv);
 }
Index: compat/svr4/svr4_ioctl.c
===================================================================
RCS file: /home/ncvs/src/sys/compat/svr4/svr4_ioctl.c,v
retrieving revision 1.14
diff -u -r1.14 svr4_ioctl.c
--- compat/svr4/svr4_ioctl.c	31 May 2002 11:52:29 -0000	1.14
+++ compat/svr4/svr4_ioctl.c	12 Dec 2002 03:14:38 -0000
@@ -94,13 +94,13 @@
 	int		 num;
 	int		 argsiz;
 
-	svr4_decode_cmd(SCARG(uap, com), dir, &c, &num, &argsiz);
+	svr4_decode_cmd(uap->com, dir, &c, &num, &argsiz);
 
-	DPRINTF(("svr4_ioctl[%lx](%d, _IO%s(%c, %d, %d), %p);\n", SCARG(uap, com), SCARG(uap, fd),
-	    dir, c, num, argsiz, SCARG(uap, data)));
+	DPRINTF(("svr4_ioctl[%lx](%d, _IO%s(%c, %d, %d), %p);\n", uap->com, uap->fd,
+	    dir, c, num, argsiz, uap->data));
 #endif
 	retval = td->td_retval;
-	cmd = SCARG(uap, com);
+	cmd = uap->com;
 
 	if ((error = fget(td, uap->fd, &fp)) != 0)
 		return (error);
@@ -161,7 +161,7 @@
 		DPRINTF((">>> OUT: so_state = 0x%x\n", so->so_state));
 	}
 #endif
-	error = (*fun)(fp, td, retval, SCARG(uap, fd), cmd, SCARG(uap, data));
+	error = (*fun)(fp, td, retval, uap->fd, cmd, uap->data);
 	fdrop(fp, td);
 	return (error);
 }
Index: compat/svr4/svr4_ipc.c
===================================================================
RCS file: /home/ncvs/src/sys/compat/svr4/svr4_ipc.c,v
retrieving revision 1.9
diff -u -r1.9 svr4_ipc.c
--- compat/svr4/svr4_ipc.c	20 Mar 2002 05:41:37 -0000	1.9
+++ compat/svr4/svr4_ipc.c	12 Dec 2002 03:14:38 -0000
@@ -221,55 +221,55 @@
 	struct semid_ds bs, *bsp;
 	caddr_t sg = stackgap_init();
 
-	SCARG(&ap, semid) = SCARG(uap, semid);
-	SCARG(&ap, semnum) = SCARG(uap, semnum);
+	ap.semid = uap->semid;
+	ap.semnum = uap->semnum;
 
-	switch (SCARG(uap, cmd)) {
+	switch (uap->cmd) {
 	case SVR4_SEM_GETZCNT:
 	case SVR4_SEM_GETNCNT:
 	case SVR4_SEM_GETPID:
 	case SVR4_SEM_GETVAL:
-		switch (SCARG(uap, cmd)) {
+		switch (uap->cmd) {
 		case SVR4_SEM_GETZCNT:
-			SCARG(&ap, cmd) = GETZCNT;
+			ap.cmd = GETZCNT;
 			break;
 		case SVR4_SEM_GETNCNT:
-			SCARG(&ap, cmd) = GETNCNT;
+			ap.cmd = GETNCNT;
 			break;
 		case SVR4_SEM_GETPID:
-			SCARG(&ap, cmd) = GETPID;
+			ap.cmd = GETPID;
 			break;
 		case SVR4_SEM_GETVAL:
-			SCARG(&ap, cmd) = GETVAL;
+			ap.cmd = GETVAL;
 			break;
 		}
 		return sys___semctl(p, &ap, retval);
 
 	case SVR4_SEM_SETVAL:
-		error = svr4_setsemun(&sg, &SCARG(&ap, arg), &SCARG(uap, arg));
+		error = svr4_setsemun(&sg, &ap.arg, &uap->arg);
 		if (error)
 			return error;
-		SCARG(&ap, cmd) = SETVAL;
+		ap.cmd = SETVAL;
 		return sys___semctl(p, &ap, retval);
 
 	case SVR4_SEM_GETALL:
-		error = svr4_setsemun(&sg, &SCARG(&ap, arg), &SCARG(uap, arg));
+		error = svr4_setsemun(&sg, &ap.arg, &uap->arg);
 		if (error)
 			return error;
-		SCARG(&ap, cmd) = GETVAL;
+		ap.cmd = GETVAL;
 		return sys___semctl(p, &ap, retval);
 
 	case SVR4_SEM_SETALL:
-		error = svr4_setsemun(&sg, &SCARG(&ap, arg), &SCARG(uap, arg));
+		error = svr4_setsemun(&sg, &ap.arg, &uap->arg);
 		if (error)
 			return error;
-		SCARG(&ap, cmd) = SETVAL;
+		ap.cmd = SETVAL;
 		return sys___semctl(p, &ap, retval);
 
 	case SVR4_IPC_STAT:
-                SCARG(&ap, cmd) = IPC_STAT;
+                ap.cmd = IPC_STAT;
 		bsp = stackgap_alloc(&sg, sizeof(bs));
-		error = svr4_setsemun(&sg, &SCARG(&ap, arg),
+		error = svr4_setsemun(&sg, &ap.arg,
 				      (union semun *)&bsp);
 		if (error)
 			return error;
@@ -279,16 +279,16 @@
                 if (error)
                         return error;
                 bsd_to_svr4_semid_ds(&bs, &ss);
-		return copyout(&ss, SCARG(uap, arg).buf, sizeof(ss));
+		return copyout(&ss, uap->arg.buf, sizeof(ss));
 
 	case SVR4_IPC_SET:
-		SCARG(&ap, cmd) = IPC_SET;
+		ap.cmd = IPC_SET;
 		bsp = stackgap_alloc(&sg, sizeof(bs));
-		error = svr4_setsemun(&sg, &SCARG(&ap, arg),
+		error = svr4_setsemun(&sg, &ap.arg,
 				      (union semun *)&bsp);
 		if (error)
 			return error;
-		error = copyin(SCARG(uap, arg).buf, (caddr_t) &ss, sizeof ss);
+		error = copyin(uap->arg.buf, (caddr_t) &ss, sizeof ss);
                 if (error)
                         return error;
                 svr4_to_bsd_semid_ds(&ss, &bs);
@@ -298,13 +298,13 @@
 		return sys___semctl(p, &ap, retval);
 
 	case SVR4_IPC_RMID:
-		SCARG(&ap, cmd) = IPC_RMID;
+		ap.cmd = IPC_RMID;
 		bsp = stackgap_alloc(&sg, sizeof(bs));
-		error = svr4_setsemun(&sg, &SCARG(&ap, arg),
+		error = svr4_setsemun(&sg, &ap.arg,
 				      (union semun *)&bsp);
 		if (error)
 			return error;
-		error = copyin(SCARG(uap, arg).buf, &ss, sizeof ss);
+		error = copyin(uap->arg.buf, &ss, sizeof ss);
                 if (error)
                         return error;
                 svr4_to_bsd_semid_ds(&ss, &bs);
@@ -334,9 +334,9 @@
 	struct svr4_sys_semget_args *uap = v;
 	struct sys_semget_args ap;
 
-	SCARG(&ap, key) = SCARG(uap, key);
-	SCARG(&ap, nsems) = SCARG(uap, nsems);
-	SCARG(&ap, semflg) = SCARG(uap, semflg);
+	ap.key = uap->key;
+	ap.nsems = uap->nsems;
+	ap.semflg = uap->semflg;
 
 	return sys_semget(p, &ap, retval);
 }
@@ -357,10 +357,10 @@
 	struct svr4_sys_semop_args *uap = v;
 	struct sys_semop_args ap;
 
-	SCARG(&ap, semid) = SCARG(uap, semid);
+	ap.semid = uap->semid;
 	/* These are the same */
-	SCARG(&ap, sops) = (struct sembuf *) SCARG(uap, sops);
-	SCARG(&ap, nsops) = SCARG(uap, nsops);
+	ap.sops = (struct sembuf *) uap->sops;
+	ap.nsops = uap->nsops;
 
 	return sys_semop(p, &ap, retval);
 }
@@ -373,9 +373,9 @@
 {
 	struct svr4_sys_semsys_args *uap = v;
 
-	DPRINTF(("svr4_semsys(%d)\n", SCARG(uap, what)));
+	DPRINTF(("svr4_semsys(%d)\n", uap->what));
 
-	switch (SCARG(uap, what)) {
+	switch (uap->what) {
 	case SVR4_semctl:
 		return svr4_semctl(p, v, retval);
 	case SVR4_semget:
@@ -462,10 +462,10 @@
 	struct svr4_sys_msgsnd_args *uap = v;
 	struct sys_msgsnd_args ap;
 
-	SCARG(&ap, msqid) = SCARG(uap, msqid);
-	SCARG(&ap, msgp) = SCARG(uap, msgp);
-	SCARG(&ap, msgsz) = SCARG(uap, msgsz);
-	SCARG(&ap, msgflg) = SCARG(uap, msgflg);
+	ap.msqid = uap->msqid;
+	ap.msgp = uap->msgp;
+	ap.msgsz = uap->msgsz;
+	ap.msgflg = uap->msgflg;
 
 	return sys_msgsnd(p, &ap, retval);
 }
@@ -488,11 +488,11 @@
 	struct svr4_sys_msgrcv_args *uap = v;
 	struct sys_msgrcv_args ap;
 
-	SCARG(&ap, msqid) = SCARG(uap, msqid);
-	SCARG(&ap, msgp) = SCARG(uap, msgp);
-	SCARG(&ap, msgsz) = SCARG(uap, msgsz);
-	SCARG(&ap, msgtyp) = SCARG(uap, msgtyp);
-	SCARG(&ap, msgflg) = SCARG(uap, msgflg);
+	ap.msqid = uap->msqid;
+	ap.msgp = uap->msgp;
+	ap.msgsz = uap->msgsz;
+	ap.msgtyp = uap->msgtyp;
+	ap.msgflg = uap->msgflg;
 
 	return sys_msgrcv(p, &ap, retval);
 }
@@ -512,8 +512,8 @@
 	struct svr4_sys_msgget_args *uap = v;
 	struct sys_msgget_args ap;
 
-	SCARG(&ap, key) = SCARG(uap, key);
-	SCARG(&ap, msgflg) = SCARG(uap, msgflg);
+	ap.key = uap->key;
+	ap.msgflg = uap->msgflg;
 
 	return sys_msgget(p, &ap, retval);
 }
@@ -538,39 +538,39 @@
 	struct msqid_ds bs;
 	caddr_t sg = stackgap_init();
 
-	SCARG(&ap, msqid) = SCARG(uap, msqid);
-	SCARG(&ap, cmd) = SCARG(uap, cmd);
-	SCARG(&ap, buf) = stackgap_alloc(&sg, sizeof(bs));
+	ap.msqid = uap->msqid;
+	ap.cmd = uap->cmd;
+	ap.buf = stackgap_alloc(&sg, sizeof(bs));
 
-	switch (SCARG(uap, cmd)) {
+	switch (uap->cmd) {
 	case SVR4_IPC_STAT:
-		SCARG(&ap, cmd) = IPC_STAT;
+		ap.cmd = IPC_STAT;
 		if ((error = sys_msgctl(p, &ap, retval)) != 0)
 			return error;
-		error = copyin(&bs, SCARG(&ap, buf), sizeof bs);
+		error = copyin(&bs, ap.buf, sizeof bs);
 		if (error)
 			return error;
 		bsd_to_svr4_msqid_ds(&bs, &ss);
-		return copyout(&ss, SCARG(uap, buf), sizeof ss);
+		return copyout(&ss, uap->buf, sizeof ss);
 
 	case SVR4_IPC_SET:
-		SCARG(&ap, cmd) = IPC_SET;
-		error = copyin(SCARG(uap, buf), &ss, sizeof ss);
+		ap.cmd = IPC_SET;
+		error = copyin(uap->buf, &ss, sizeof ss);
 		if (error)
 			return error;
 		svr4_to_bsd_msqid_ds(&ss, &bs);
-		error = copyout(&bs, SCARG(&ap, buf), sizeof bs);
+		error = copyout(&bs, ap.buf, sizeof bs);
 		if (error)
 			return error;
 		return sys_msgctl(p, &ap, retval);
 
 	case SVR4_IPC_RMID:
-		SCARG(&ap, cmd) = IPC_RMID;
-		error = copyin(SCARG(uap, buf), &ss, sizeof ss);
+		ap.cmd = IPC_RMID;
+		error = copyin(uap->buf, &ss, sizeof ss);
 		if (error)
 			return error;
 		svr4_to_bsd_msqid_ds(&ss, &bs);
-		error = copyout(&bs, SCARG(&ap, buf), sizeof bs);
+		error = copyout(&bs, ap.buf, sizeof bs);
 		if (error)
 			return error;
 		return sys_msgctl(p, &ap, retval);
@@ -588,9 +588,9 @@
 {
 	struct svr4_sys_msgsys_args *uap = v;
 
-	DPRINTF(("svr4_msgsys(%d)\n", SCARG(uap, what)));
+	DPRINTF(("svr4_msgsys(%d)\n", uap->what));
 
-	switch (SCARG(uap, what)) {
+	switch (uap->what) {
 	case SVR4_msgsnd:
 		return svr4_msgsnd(p, v, retval);
 	case SVR4_msgrcv:
@@ -660,9 +660,9 @@
 	struct svr4_sys_shmat_args *uap = v;
 	struct sys_shmat_args ap;
 
-	SCARG(&ap, shmid) = SCARG(uap, shmid);
-	SCARG(&ap, shmaddr) = SCARG(uap, shmaddr);
-	SCARG(&ap, shmflg) = SCARG(uap, shmflg);
+	ap.shmid = uap->shmid;
+	ap.shmaddr = uap->shmaddr;
+	ap.shmflg = uap->shmflg;
 
 	return sys_shmat(p, &ap, retval);
 }
@@ -681,7 +681,7 @@
 	struct svr4_sys_shmdt_args *uap = v;
 	struct sys_shmdt_args ap;
 
-	SCARG(&ap, shmaddr) = SCARG(uap, shmaddr);
+	ap.shmaddr = uap->shmaddr;
 
 	return sys_shmdt(p, &ap, retval);
 }
@@ -702,9 +702,9 @@
 	struct svr4_sys_shmget_args *uap = v;
 	struct sys_shmget_args ap;
 
-	SCARG(&ap, key) = SCARG(uap, key);
-	SCARG(&ap, size) = SCARG(uap, size);
-	SCARG(&ap, shmflg) = SCARG(uap, shmflg);
+	ap.key = uap->key;
+	ap.size = uap->size;
+	ap.shmflg = uap->shmflg;
 
 	return sys_shmget(p, &ap, retval);
 }
@@ -729,21 +729,21 @@
 	struct shmid_ds bs;
 	struct svr4_shmid_ds ss;
 
-	SCARG(&ap, shmid) = SCARG(uap, shmid);
+	ap.shmid = uap->shmid;
 
-	if (SCARG(uap, buf) != NULL) {
-		SCARG(&ap, buf) = stackgap_alloc(&sg, sizeof (struct shmid_ds));
-		switch (SCARG(uap, cmd)) {
+	if (uap->buf != NULL) {
+		ap.buf = stackgap_alloc(&sg, sizeof (struct shmid_ds));
+		switch (uap->cmd) {
 		case SVR4_IPC_SET:
 		case SVR4_IPC_RMID:
 		case SVR4_SHM_LOCK:
 		case SVR4_SHM_UNLOCK:
-			error = copyin(SCARG(uap, buf), (caddr_t) &ss,
+			error = copyin(uap->buf, (caddr_t) &ss,
 			    sizeof ss);
 			if (error)
 				return error;
 			svr4_to_bsd_shmid_ds(&ss, &bs);
-			error = copyout(&bs, SCARG(&ap, buf), sizeof bs);
+			error = copyout(&bs, ap.buf, sizeof bs);
 			if (error)
 				return error;
 			break;
@@ -752,38 +752,38 @@
 		}
 	}
 	else
-		SCARG(&ap, buf) = NULL;
+		ap.buf = NULL;
 
 
-	switch (SCARG(uap, cmd)) {
+	switch (uap->cmd) {
 	case SVR4_IPC_STAT:
-		SCARG(&ap, cmd) = IPC_STAT;
+		ap.cmd = IPC_STAT;
 		if ((error = sys_shmctl(p, &ap, retval)) != 0)
 			return error;
-		if (SCARG(uap, buf) == NULL)
+		if (uap->buf == NULL)
 			return 0;
-		error = copyin(&bs, SCARG(&ap, buf), sizeof bs);
+		error = copyin(&bs, ap.buf, sizeof bs);
 		if (error)
 			return error;
 		bsd_to_svr4_shmid_ds(&bs, &ss);
-		return copyout(&ss, SCARG(uap, buf), sizeof ss);
+		return copyout(&ss, uap->buf, sizeof ss);
 
 	case SVR4_IPC_SET:
-		SCARG(&ap, cmd) = IPC_SET;
+		ap.cmd = IPC_SET;
 		return sys_shmctl(p, &ap, retval);
 
 	case SVR4_IPC_RMID:
 	case SVR4_SHM_LOCK:
 	case SVR4_SHM_UNLOCK:
-		switch (SCARG(uap, cmd)) {
+		switch (uap->cmd) {
 		case SVR4_IPC_RMID:
-			SCARG(&ap, cmd) = IPC_RMID;
+			ap.cmd = IPC_RMID;
 			break;
 		case SVR4_SHM_LOCK:
-			SCARG(&ap, cmd) = SHM_LOCK;
+			ap.cmd = SHM_LOCK;
 			break;
 		case SVR4_SHM_UNLOCK:
-			SCARG(&ap, cmd) = SHM_UNLOCK;
+			ap.cmd = SHM_UNLOCK;
 			break;
 		default:
 			return EINVAL;
@@ -803,9 +803,9 @@
 {
 	struct svr4_sys_shmsys_args *uap = v;
 
-	DPRINTF(("svr4_shmsys(%d)\n", SCARG(uap, what)));
+	DPRINTF(("svr4_shmsys(%d)\n", uap->what));
 
-	switch (SCARG(uap, what)) {
+	switch (uap->what) {
 	case SVR4_shmat:
 		return svr4_shmat(p, v, retval);
 	case SVR4_shmdt:
Index: compat/svr4/svr4_misc.c
===================================================================
RCS file: /home/ncvs/src/sys/compat/svr4/svr4_misc.c,v
retrieving revision 1.51
diff -u -r1.51 svr4_misc.c
--- compat/svr4/svr4_misc.c	31 Aug 2002 19:33:59 -0000	1.51
+++ compat/svr4/svr4_misc.c	12 Dec 2002 03:14:38 -0000
@@ -132,25 +132,25 @@
 {
 	struct wait_args w4;
 	int error, *retval = td->td_retval, st, sig;
-	size_t sz = sizeof(*SCARG(&w4, status));
+	size_t sz = sizeof(*w4.status);
 
-	SCARG(&w4, rusage) = NULL;
-	SCARG(&w4, options) = 0;
+	w4.rusage = NULL;
+	w4.options = 0;
 
-	if (SCARG(uap, status) == NULL) {
+	if (uap->status == NULL) {
 		caddr_t sg = stackgap_init();
 
-		SCARG(&w4, status) = stackgap_alloc(&sg, sz);
+		w4.status = stackgap_alloc(&sg, sz);
 	}
 	else
-		SCARG(&w4, status) = SCARG(uap, status);
+		w4.status = uap->status;
 
-	SCARG(&w4, pid) = WAIT_ANY;
+	w4.pid = WAIT_ANY;
 
 	if ((error = wait4(td, &w4)) != 0)
 		return error;
       
-	if ((error = copyin(SCARG(&w4, status), &st, sizeof(st))) != 0)
+	if ((error = copyin(w4.status, &st, sizeof(st))) != 0)
 		return error;
 
 	if (WIFSIGNALED(st)) {
@@ -169,8 +169,8 @@
 	 */
 	retval[1] = st;
 
-	if (SCARG(uap, status))
-		if ((error = copyout(&st, SCARG(uap, status), sizeof(st))) != 0)
+	if (uap->status)
+		if ((error = copyout(&st, uap->status, sizeof(st))) != 0)
 			return error;
 
 	return 0;
@@ -185,11 +185,11 @@
 	caddr_t sg;
 
 	sg = stackgap_init();
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	CHECKALTEXIST(td, &sg, uap->path);
 
-	SCARG(&ap, fname) = SCARG(uap, path);
-	SCARG(&ap, argv) = SCARG(uap, argp);
-	SCARG(&ap, envv) = NULL;
+	ap.fname = uap->path;
+	ap.argv = uap->argp;
+	ap.envv = NULL;
 
 	return execve(td, &ap);
 }
@@ -205,9 +205,9 @@
 	sg = stackgap_init();
 	CHECKALTEXIST(td, &sg, uap->path);
 
-	SCARG(&ap, fname) = SCARG(uap, path);
-	SCARG(&ap, argv) = SCARG(uap, argp);
-	SCARG(&ap, envv) = SCARG(uap, envp);
+	ap.fname = uap->path;
+	ap.argv = uap->argp;
+	ap.envv = uap->envp;
 
 	return execve(td, &ap);
 }
@@ -222,9 +222,9 @@
 	struct timeval tv;
 
 	microtime(&tv);
-	if (SCARG(uap, t))
-		error = copyout(&tv.tv_sec, SCARG(uap, t),
-				sizeof(*(SCARG(uap, t))));
+	if (uap->t)
+		error = copyout(&tv.tv_sec, uap->t,
+				sizeof(*(uap->t)));
 	td->td_retval[0] = (int) tv.tv_sec;
 
 	return error;
@@ -261,8 +261,8 @@
 	int ncookies;
 
 	DPRINTF(("svr4_sys_getdents64(%d, *, %d)\n",
-		SCARG(uap, fd), SCARG(uap, nbytes)));
-	if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) {
+		uap->fd, uap->nbytes));
+	if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0) {
 		return (error);
 	}
 
@@ -283,7 +283,7 @@
 		return error;
 	}
 
-	nbytes = SCARG(uap, nbytes);
+	nbytes = uap->nbytes;
 	if (nbytes == 1) {
 		nbytes = sizeof (struct svr4_dirent64);
 		justone = 1;
@@ -326,7 +326,7 @@
 	}
 
 	inp = buf;
-	outp = (caddr_t) SCARG(uap, dp);
+	outp = (caddr_t) uap->dp;
 	resid = nbytes;
 	if ((len = buflen - auio.uio_resid) <= 0) {
 		goto eof;
@@ -404,7 +404,7 @@
 			break;
     	}
 
-	if (outp == (caddr_t) SCARG(uap, dp))
+	if (outp == (caddr_t) uap->dp)
 		goto again;
 	fp->f_offset = off;
 
@@ -443,7 +443,7 @@
 	u_long *cookiebuf = NULL, *cookie;
 	int ncookies = 0, *retval = td->td_retval;
 
-	if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0)
+	if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
 		return (error);
 
 	if ((fp->f_flag & FREAD) == 0) {
@@ -457,7 +457,7 @@
 		return (EINVAL);
 	}
 
-	buflen = min(MAXBSIZE, SCARG(uap, nbytes));
+	buflen = min(MAXBSIZE, uap->nbytes);
 	buf = malloc(buflen, M_TEMP, M_WAITOK);
 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
 	off = fp->f_offset;
@@ -489,8 +489,8 @@
 	}
 
 	inp = buf;
-	outp = SCARG(uap, buf);
-	resid = SCARG(uap, nbytes);
+	outp = uap->buf;
+	resid = uap->nbytes;
 	if ((len = buflen - auio.uio_resid) == 0)
 		goto eof;
 
@@ -534,12 +534,12 @@
 	}
 
 	/* if we squished out the whole block, try again */
-	if (outp == SCARG(uap, buf))
+	if (outp == uap->buf)
 		goto again;
 	fp->f_offset = off;	/* update the vnode offset */
 
 eof:
-	*retval = SCARG(uap, nbytes) - resid;
+	*retval = uap->nbytes - resid;
 out:
 	VOP_UNLOCK(vp, 0, td);
 	fdrop(fp, td);
@@ -563,18 +563,18 @@
 	/*
          * Verify the arguments.
          */
-	if (SCARG(uap, prot) & ~(PROT_READ | PROT_WRITE | PROT_EXEC))
+	if (uap->prot & ~(PROT_READ | PROT_WRITE | PROT_EXEC))
 		return EINVAL;	/* XXX still needed? */
 
-	if (SCARG(uap, len) == 0)
+	if (uap->len == 0)
 		return EINVAL;
 
-	SCARG(&mm, prot) = SCARG(uap, prot);
-	SCARG(&mm, len) = SCARG(uap, len);
-	SCARG(&mm, flags) = SCARG(uap, flags) & ~_MAP_NEW;
-	SCARG(&mm, fd) = SCARG(uap, fd);
-	SCARG(&mm, addr) = SCARG(uap, addr);
-	SCARG(&mm, pos) = SCARG(uap, pos);
+	mm.prot = uap->prot;
+	mm.len = uap->len;
+	mm.flags = uap->flags & ~_MAP_NEW;
+	mm.fd = uap->fd;
+	mm.addr = uap->addr;
+	mm.pos = uap->pos;
 
 	return mmap(td, &mm);
 }
@@ -591,23 +591,23 @@
 	/*
          * Verify the arguments.
          */
-	if (SCARG(uap, prot) & ~(PROT_READ | PROT_WRITE | PROT_EXEC))
+	if (uap->prot & ~(PROT_READ | PROT_WRITE | PROT_EXEC))
 		return EINVAL;	/* XXX still needed? */
 
-	if (SCARG(uap, len) == 0)
+	if (uap->len == 0)
 		return EINVAL;
 
-	SCARG(&mm, prot) = SCARG(uap, prot);
-	SCARG(&mm, len) = SCARG(uap, len);
-	SCARG(&mm, flags) = SCARG(uap, flags) & ~_MAP_NEW;
-	SCARG(&mm, fd) = SCARG(uap, fd);
-	SCARG(&mm, addr) = SCARG(uap, addr);
-	SCARG(&mm, pos) = SCARG(uap, pos);
+	mm.prot = uap->prot;
+	mm.len = uap->len;
+	mm.flags = uap->flags & ~_MAP_NEW;
+	mm.fd = uap->fd;
+	mm.addr = uap->addr;
+	mm.pos = uap->pos;
 
 	rp = (void *) round_page((vm_offset_t)(td->td_proc->p_vmspace->vm_daddr + maxdsiz));
-	if ((SCARG(&mm, flags) & MAP_FIXED) == 0 &&
-	    SCARG(&mm, addr) != 0 && (void *)SCARG(&mm, addr) < rp)
-		SCARG(&mm, addr) = rp;
+	if ((mm.flags & MAP_FIXED) == 0 &&
+	    mm.addr != 0 && (void *)mm.addr < rp)
+		mm.addr = rp;
 
 	return mmap(td, &mm);
 }
@@ -625,7 +625,7 @@
 
 	if ((error = suser(td)) != 0)
 		return error;
-	if ((error = getvnode(fdp, SCARG(uap, fd), &fp)) != 0)
+	if ((error = getvnode(fdp, uap->fd, &fp)) != 0)
 		return error;
 	vp = (struct vnode *) fp->f_data;
 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
@@ -664,14 +664,14 @@
 
 	if (S_ISFIFO(mode)) {
 		struct mkfifo_args ap;
-		SCARG(&ap, path) = path;
-		SCARG(&ap, mode) = mode;
+		ap.path = path;
+		ap.mode = mode;
 		return mkfifo(td, &ap);
 	} else {
 		struct mknod_args ap;
-		SCARG(&ap, path) = path;
-		SCARG(&ap, mode) = mode;
-		SCARG(&ap, dev) = dev;
+		ap.path = path;
+		ap.mode = mode;
+		ap.dev = dev;
 		return mknod(td, &ap);
 	}
 }
@@ -684,8 +684,8 @@
 {
         int *retval = td->td_retval;
 	return svr4_mknod(td, retval,
-			  SCARG(uap, path), SCARG(uap, mode),
-			  (svr4_dev_t)svr4_to_bsd_odev_t(SCARG(uap, dev)));
+			  uap->path, uap->mode,
+			  (svr4_dev_t)svr4_to_bsd_odev_t(uap->dev));
 }
 
 
@@ -696,8 +696,8 @@
 {
         int *retval = td->td_retval;
 	return svr4_mknod(td, retval,
-			  SCARG(uap, path), SCARG(uap, mode),
-			  (svr4_dev_t)svr4_to_bsd_dev_t(SCARG(uap, dev)));
+			  uap->path, uap->mode,
+			  (svr4_dev_t)svr4_to_bsd_dev_t(uap->dev));
 }
 
 
@@ -719,7 +719,7 @@
 
 	retval = &(td->td_retval[0]);
 
-	switch (SCARG(uap, name)) {
+	switch (uap->name) {
 	case SVR4_CONFIG_UNUSED:
 		*retval = 0;
 		break;
@@ -823,7 +823,7 @@
 	int rv;
 
 	base = round_page((vm_offset_t) vm->vm_daddr);
-	ns = (vm_offset_t)SCARG(uap, nsize);
+	ns = (vm_offset_t)uap->nsize;
 	new = round_page(ns);
 	/* For p_rlimit. */
 	mtx_assert(&Giant, MA_OWNED);
@@ -890,8 +890,8 @@
 	caddr_t sg = stackgap_init();
 	ru = stackgap_alloc(&sg, sizeof(struct rusage));
 
-	SCARG(&ga, who) = RUSAGE_SELF;
-	SCARG(&ga, rusage) = ru;
+	ga.who = RUSAGE_SELF;
+	ga.rusage = ru;
 
 	error = getrusage(td, &ga);
 	if (error)
@@ -903,7 +903,7 @@
 	tms.tms_utime = timeval_to_clock_t(&r.ru_utime);
 	tms.tms_stime = timeval_to_clock_t(&r.ru_stime);
 
-	SCARG(&ga, who) = RUSAGE_CHILDREN;
+	ga.who = RUSAGE_CHILDREN;
 	error = getrusage(td, &ga);
 	if (error)
 		return error;
@@ -917,7 +917,7 @@
 	microtime(&t);
 	*retval = timeval_to_clock_t(&t);
 
-	return copyout(&tms, SCARG(uap, tp), sizeof(tms));
+	return copyout(&tms, uap->tp, sizeof(tms));
 }
 
 
@@ -928,7 +928,7 @@
 {
         int *retval = td->td_retval;
 
-	switch (SCARG(uap, cmd)) {
+	switch (uap->cmd) {
 	case SVR4_GFILLIM:
 		/* For p_rlimit below. */
 		mtx_assert(&Giant, MA_OWNED);
@@ -946,7 +946,7 @@
 			struct rlimit *url = (struct rlimit *) 
 				stackgap_alloc(&sg, sizeof *url);
 
-			krl.rlim_cur = SCARG(uap, newlimit) * 512;
+			krl.rlim_cur = uap->newlimit * 512;
 			mtx_assert(&Giant, MA_OWNED);
 			krl.rlim_max = td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_max;
 
@@ -954,8 +954,8 @@
 			if (error)
 				return error;
 
-			SCARG(&srl, which) = RLIMIT_FSIZE;
-			SCARG(&srl, rlp) = url;
+			srl.which = RLIMIT_FSIZE;
+			srl.rlp = url;
 
 			error = setrlimit(td, &srl);
 			if (error)
@@ -1020,7 +1020,7 @@
         int *retval = td->td_retval;
 	struct proc *p = td->td_proc;
 
-	switch (SCARG(uap, cmd)) {
+	switch (uap->cmd) {
 	case 1:			/* setpgrp() */
 		/*
 		 * SVR4 setpgrp() (which takes no arguments) has the
@@ -1039,9 +1039,9 @@
 		return 0;
 
 	case 2:			/* getsid(pid) */
-		if (SCARG(uap, pid) == 0)
+		if (uap->pid == 0)
 			PROC_LOCK(p);
-		else if ((p = svr4_pfind(SCARG(uap, pid))) == NULL)
+		else if ((p = svr4_pfind(uap->pid)) == NULL)
 			return ESRCH;
 		/*
 		 * This has already been initialized to the pid of
@@ -1056,9 +1056,9 @@
 
 	case 4:			/* getpgid(pid) */
 
-		if (SCARG(uap, pid) == 0)
+		if (uap->pid == 0)
 			PROC_LOCK(p);
-		else if ((p = svr4_pfind(SCARG(uap, pid))) == NULL)
+		else if ((p = svr4_pfind(uap->pid)) == NULL)
 			return ESRCH;
 
 		*retval = (int) p->p_pgrp->pg_id;
@@ -1069,8 +1069,8 @@
 		{
 			struct setpgid_args sa;
 
-			SCARG(&sa, pid) = SCARG(uap, pid);
-			SCARG(&sa, pgid) = SCARG(uap, pgid);
+			sa.pid = uap->pid;
+			sa.pgid = uap->pgid;
 			return setpgid(td, &sa);
 		}
 
@@ -1096,7 +1096,7 @@
 	struct svr4_hrtcntl_args *uap;
 	register_t *retval;
 {
-	switch (SCARG(uap, fun)) {
+	switch (uap->fun) {
 	case SVR4_HRT_CNTL_RES:
 		DPRINTF(("htrcntl(RES)\n"));
 		*retval = SVR4_HRT_USEC;
@@ -1107,11 +1107,11 @@
 		{
 			struct timeval tv;
 			svr4_hrt_time_t t;
-			if (SCARG(uap, clk) != SVR4_HRT_CLK_STD) {
-				DPRINTF(("clk == %d\n", SCARG(uap, clk)));
+			if (uap->clk != SVR4_HRT_CLK_STD) {
+				DPRINTF(("clk == %d\n", uap->clk));
 				return EINVAL;
 			}
-			if (SCARG(uap, ti) == NULL) {
+			if (uap->ti == NULL) {
 				DPRINTF(("ti NULL\n"));
 				return EINVAL;
 			}
@@ -1119,7 +1119,7 @@
 			t.h_sec = tv.tv_sec;
 			t.h_rem = tv.tv_usec;
 			t.h_res = SVR4_HRT_USEC;
-			return copyout(&t, SCARG(uap, ti), sizeof(t));
+			return copyout(&t, uap->ti, sizeof(t));
 		}
 
 	case SVR4_HRT_CNTL_START:
@@ -1130,7 +1130,7 @@
 		DPRINTF(("htrcntl(GET)\n"));
 		return ENOSYS;
 	default:
-		DPRINTF(("Bad htrcntl command %d\n", SCARG(uap, fun)));
+		DPRINTF(("Bad htrcntl command %d\n", uap->fun));
 		return ENOSYS;
 	}
 }
@@ -1143,7 +1143,7 @@
 {
         int *retval = td->td_retval;
 
-	switch (SCARG(uap, cmd)) {
+	switch (uap->cmd) {
 	case SVR4_HRT_CNTL:
 		return svr4_hrtcntl(td, (struct svr4_hrtcntl_args *) uap,
 				    retval);
@@ -1161,7 +1161,7 @@
 		return ENOSYS;
 
 	default:
-		DPRINTF(("Bad hrtsys command %d\n", SCARG(uap, cmd)));
+		DPRINTF(("Bad hrtsys command %d\n", uap->cmd));
 		return EINVAL;
 	}
 }
@@ -1235,18 +1235,18 @@
 	struct proc *q, *t;
 
 
-	switch (SCARG(uap, grp)) {
+	switch (uap->grp) {
 	case SVR4_P_PID:	
 		break;
 
 	case SVR4_P_PGID:
 		PROC_LOCK(td->td_proc);
-		SCARG(uap, id) = -td->td_proc->p_pgid;
+		uap->id = -td->td_proc->p_pgid;
 		PROC_UNLOCK(td->td_proc);
 		break;
 
 	case SVR4_P_ALL:
-		SCARG(uap, id) = WAIT_ANY;
+		uap->id = WAIT_ANY;
 		break;
 
 	default:
@@ -1254,37 +1254,37 @@
 	}
 
 	DPRINTF(("waitsys(%d, %d, %p, %x)\n", 
-	         SCARG(uap, grp), SCARG(uap, id),
-		 SCARG(uap, info), SCARG(uap, options)));
+	         uap->grp, uap->id,
+		 uap->info, uap->options));
 
 loop:
 	nfound = 0;
 	sx_slock(&proctree_lock);
 	LIST_FOREACH(q, &td->td_proc->p_children, p_sibling) {
 		PROC_LOCK(q);
-		if (SCARG(uap, id) != WAIT_ANY &&
-		    q->p_pid != SCARG(uap, id) &&
-		    q->p_pgid != -SCARG(uap, id)) {
+		if (uap->id != WAIT_ANY &&
+		    q->p_pid != uap->id &&
+		    q->p_pgid != -uap->id) {
 			PROC_UNLOCK(q);
 			DPRINTF(("pid %d pgid %d != %d\n", q->p_pid,
-				 q->p_pgid, SCARG(uap, id)));
+				 q->p_pgid, uap->id));
 			continue;
 		}
 		nfound++;
 		mtx_lock_spin(&sched_lock);
 		if ((q->p_state == PRS_ZOMBIE) && 
-		    ((SCARG(uap, options) & (SVR4_WEXITED|SVR4_WTRAPPED)))) {
+		    ((uap->options & (SVR4_WEXITED|SVR4_WTRAPPED)))) {
 			mtx_unlock_spin(&sched_lock);
 			PROC_UNLOCK(q);
 			sx_sunlock(&proctree_lock);
 			*retval = 0;
 			DPRINTF(("found %d\n", q->p_pid));
-			error = svr4_setinfo(q, q->p_xstat, SCARG(uap, info));
+			error = svr4_setinfo(q, q->p_xstat, uap->info);
 			if (error != 0)
 				return error;
 
 
-		        if ((SCARG(uap, options) & SVR4_WNOWAIT)) {
+		        if ((uap->options & SVR4_WNOWAIT)) {
 				DPRINTF(("Don't wait\n"));
 				return 0;
 			}
@@ -1391,15 +1391,15 @@
 		/* XXXKSE this needs clarification */
 		if (P_SHOULDSTOP(q) && ((q->p_flag & P_WAITED) == 0) &&
 		    (q->p_flag & P_TRACED ||
-		     (SCARG(uap, options) & (SVR4_WSTOPPED|SVR4_WCONTINUED)))) {
+		     (uap->options & (SVR4_WSTOPPED|SVR4_WCONTINUED)))) {
 			mtx_unlock_spin(&sched_lock);
 			DPRINTF(("jobcontrol %d\n", q->p_pid));
-		        if (((SCARG(uap, options) & SVR4_WNOWAIT)) == 0)
+		        if (((uap->options & SVR4_WNOWAIT)) == 0)
 				q->p_flag |= P_WAITED;
 			PROC_UNLOCK(q);
 			*retval = 0;
 			return svr4_setinfo(q, W_STOPCODE(q->p_xstat),
-					    SCARG(uap, info));
+					    uap->info);
 		}
 		mtx_unlock_spin(&sched_lock);
 		PROC_UNLOCK(q);
@@ -1408,9 +1408,9 @@
 	if (nfound == 0)
 		return ECHILD;
 
-	if (SCARG(uap, options) & SVR4_WNOHANG) {
+	if (uap->options & SVR4_WNOHANG) {
 		*retval = 0;
-		if ((error = svr4_setinfo(NULL, 0, SCARG(uap, info))) != 0)
+		if ((error = svr4_setinfo(NULL, 0, uap->info)) != 0)
 			return error;
 		return 0;
 	}
@@ -1485,9 +1485,9 @@
 	struct svr4_statvfs sfs;
 	int error;
 
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
-	SCARG(&fs_args, path) = SCARG(uap, path);
-	SCARG(&fs_args, buf) = fs;
+	CHECKALTEXIST(td, &sg, uap->path);
+	fs_args.path = uap->path;
+	fs_args.buf = fs;
 
 	if ((error = statfs(td, &fs_args)) != 0)
 		return error;
@@ -1497,7 +1497,7 @@
 
 	bsd_statfs_to_svr4_statvfs(&bfs, &sfs);
 
-	return copyout(&sfs, SCARG(uap, fs), sizeof(sfs));
+	return copyout(&sfs, uap->fs, sizeof(sfs));
 }
 
 
@@ -1513,8 +1513,8 @@
 	struct svr4_statvfs sfs;
 	int error;
 
-	SCARG(&fs_args, fd) = SCARG(uap, fd);
-	SCARG(&fs_args, buf) = fs;
+	fs_args.fd = uap->fd;
+	fs_args.buf = fs;
 
 	if ((error = fstatfs(td, &fs_args)) != 0)
 		return error;
@@ -1524,7 +1524,7 @@
 
 	bsd_statfs_to_svr4_statvfs(&bfs, &sfs);
 
-	return copyout(&sfs, SCARG(uap, fs), sizeof(sfs));
+	return copyout(&sfs, uap->fs, sizeof(sfs));
 }
 
 
@@ -1540,9 +1540,9 @@
 	struct svr4_statvfs64 sfs;
 	int error;
 
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
-	SCARG(&fs_args, path) = SCARG(uap, path);
-	SCARG(&fs_args, buf) = fs;
+	CHECKALTEXIST(td, &sg, uap->path);
+	fs_args.path = uap->path;
+	fs_args.buf = fs;
 
 	if ((error = statfs(td, &fs_args)) != 0)
 		return error;
@@ -1552,7 +1552,7 @@
 
 	bsd_statfs_to_svr4_statvfs64(&bfs, &sfs);
 
-	return copyout(&sfs, SCARG(uap, fs), sizeof(sfs));
+	return copyout(&sfs, uap->fs, sizeof(sfs));
 }
 
 
@@ -1568,8 +1568,8 @@
 	struct svr4_statvfs64 sfs;
 	int error;
 
-	SCARG(&fs_args, fd) = SCARG(uap, fd);
-	SCARG(&fs_args, buf) = fs;
+	fs_args.fd = uap->fd;
+	fs_args.buf = fs;
 
 	if ((error = fstatfs(td, &fs_args)) != 0)
 		return error;
@@ -1579,7 +1579,7 @@
 
 	bsd_statfs_to_svr4_statvfs64(&bfs, &sfs);
 
-	return copyout(&sfs, SCARG(uap, fs), sizeof(sfs));
+	return copyout(&sfs, uap->fs, sizeof(sfs));
 }
 
 int
@@ -1595,12 +1595,12 @@
         itp = stackgap_alloc(&sg, sizeof(*itp));
 	oitp = stackgap_alloc(&sg, sizeof(*oitp));
         timevalclear(&itp->it_interval);
-        itp->it_value.tv_sec = SCARG(uap, sec);
+        itp->it_value.tv_sec = uap->sec;
         itp->it_value.tv_usec = 0;
 
-	SCARG(&sa, which) = ITIMER_REAL;
-	SCARG(&sa, itv) = itp;
-	SCARG(&sa, oitv) = oitp;
+	sa.which = ITIMER_REAL;
+	sa.itv = itp;
+	sa.oitv = oitp;
         error = setitimer(td, &sa);
 	if (error)
 		return error;
@@ -1616,11 +1616,11 @@
 	struct thread *td;
 	struct svr4_sys_gettimeofday_args *uap;
 {
-	if (SCARG(uap, tp)) {
+	if (uap->tp) {
 		struct timeval atv;
 
 		microtime(&atv);
-		return copyout(&atv, SCARG(uap, tp), sizeof (atv));
+		return copyout(&atv, uap->tp, sizeof (atv));
 	}
 
 	return 0;
@@ -1636,14 +1636,14 @@
 	retval = td->td_retval;
 	*retval = 0;
 
-	switch (SCARG(uap, cmd)) {
+	switch (uap->cmd) {
 	case SVR4_SYS_SETACL:
 		/* We don't support acls on any filesystem */
 		return ENOSYS;
 
 	case SVR4_SYS_GETACL:
-		return copyout(retval, &SCARG(uap, num),
-		    sizeof(SCARG(uap, num)));
+		return copyout(retval, &uap->num,
+		    sizeof(uap->num));
 
 	case SVR4_SYS_GETACLCNT:
 		return 0;
@@ -1679,14 +1679,14 @@
 	struct thread *td;
 	struct svr4_sys_memcntl_args *uap;
 {
-	switch (SCARG(uap, cmd)) {
+	switch (uap->cmd) {
 	case SVR4_MC_SYNC:
 		{
 			struct msync_args msa;
 
-			SCARG(&msa, addr) = SCARG(uap, addr);
-			SCARG(&msa, len) = SCARG(uap, len);
-			SCARG(&msa, flags) = (int)SCARG(uap, arg);
+			msa.addr = uap->addr;
+			msa.len = uap->len;
+			msa.flags = (int)uap->arg;
 
 			return msync(td, &msa);
 		}
@@ -1694,9 +1694,9 @@
 		{
 			struct madvise_args maa;
 
-			SCARG(&maa, addr) = SCARG(uap, addr);
-			SCARG(&maa, len) = SCARG(uap, len);
-			SCARG(&maa, behav) = (int)SCARG(uap, arg);
+			maa.addr = uap->addr;
+			maa.len = uap->len;
+			maa.behav = (int)uap->arg;
 
 			return madvise(td, &maa);
 		}
@@ -1719,9 +1719,9 @@
 	struct setpriority_args ap;
 	int error;
 
-	SCARG(&ap, which) = PRIO_PROCESS;
-	SCARG(&ap, who) = 0;
-	SCARG(&ap, prio) = SCARG(uap, prio);
+	ap.which = PRIO_PROCESS;
+	ap.who = 0;
+	ap.prio = uap->prio;
 
 	if ((error = setpriority(td, &ap)) != 0)
 		return error;
@@ -1742,17 +1742,17 @@
 	int error, *retval = td->td_retval;
 
 	NDINIT(&nd, LOOKUP, NOFOLLOW | SAVENAME, UIO_USERSPACE,
-	    SCARG(uap, path), td);
+	    uap->path, td);
 
 	if ((error = namei(&nd)) != 0)
 		return error;
 
-	if ((error = copyout(nd.ni_cnd.cn_pnbuf, SCARG(uap, buf),
-	    SCARG(uap, bufsiz))) != 0)
+	if ((error = copyout(nd.ni_cnd.cn_pnbuf, uap->buf,
+	    uap->bufsiz)) != 0)
 		goto bad;
 
-	*retval = strlen(nd.ni_cnd.cn_pnbuf) < SCARG(uap, bufsiz) ? 
-	  strlen(nd.ni_cnd.cn_pnbuf) + 1 : SCARG(uap, bufsiz);
+	*retval = strlen(nd.ni_cnd.cn_pnbuf) < uap->bufsiz ? 
+	  strlen(nd.ni_cnd.cn_pnbuf) + 1 : uap->bufsiz;
 bad:
 	NDFREE(&nd, NDF_ONLY_PNBUF);
 	vput(nd.ni_vp);
Index: compat/svr4/svr4_resource.c
===================================================================
RCS file: /home/ncvs/src/sys/compat/svr4/svr4_resource.c,v
retrieving revision 1.11
diff -u -r1.11 svr4_resource.c
--- compat/svr4/svr4_resource.c	30 Aug 2002 18:09:46 -0000	1.11
+++ compat/svr4/svr4_resource.c	12 Dec 2002 03:14:38 -0000
@@ -133,7 +133,7 @@
 	register struct thread *td;
 	struct svr4_sys_getrlimit_args *uap;
 {
-	int rl = svr4_to_native_rl(SCARG(uap, which));
+	int rl = svr4_to_native_rl(uap->which);
 	struct rlimit blim;
 	struct svr4_rlimit slim;
 
@@ -171,7 +171,7 @@
 	else
 		slim.rlim_cur = SVR4_RLIM_SAVED_CUR;
 
-	return copyout(&slim, SCARG(uap, rlp), sizeof(*SCARG(uap, rlp)));
+	return copyout(&slim, uap->rlp, sizeof(*uap->rlp));
 }
 
 
@@ -180,7 +180,7 @@
 	register struct thread *td;
 	struct svr4_sys_setrlimit_args *uap;
 {
-	int rl = svr4_to_native_rl(SCARG(uap, which));
+	int rl = svr4_to_native_rl(uap->which);
 	struct rlimit blim, *limp;
 	struct svr4_rlimit slim;
 	int error;
@@ -192,7 +192,7 @@
 	mtx_assert(&Giant, MA_OWNED);
 	limp = &td->td_proc->p_rlimit[rl];
 
-	if ((error = copyin(SCARG(uap, rlp), &slim, sizeof(slim))) != 0)
+	if ((error = copyin(uap->rlp, &slim, sizeof(slim))) != 0)
 		return error;
 
 	/*
@@ -231,7 +231,7 @@
 	register struct thread *td;
 	struct svr4_sys_getrlimit64_args *uap;
 {
-	int rl = svr4_to_native_rl(SCARG(uap, which));
+	int rl = svr4_to_native_rl(uap->which);
 	struct rlimit blim;
 	struct svr4_rlimit64 slim;
 
@@ -269,7 +269,7 @@
 	else
 		slim.rlim_cur = SVR4_RLIM64_SAVED_CUR;
 
-	return copyout(&slim, SCARG(uap, rlp), sizeof(*SCARG(uap, rlp)));
+	return copyout(&slim, uap->rlp, sizeof(*uap->rlp));
 }
 
 
@@ -278,7 +278,7 @@
 	register struct thread *td;
 	struct svr4_sys_setrlimit64_args *uap;
 {
-	int rl = svr4_to_native_rl(SCARG(uap, which));
+	int rl = svr4_to_native_rl(uap->which);
 	struct rlimit blim, *limp;
 	struct svr4_rlimit64 slim;
 	int error;
@@ -290,7 +290,7 @@
 	mtx_assert(&Giant, MA_OWNED);
 	limp = &td->td_proc->p_rlimit[rl];
 
-	if ((error = copyin(SCARG(uap, rlp), &slim, sizeof(slim))) != 0)
+	if ((error = copyin(uap->rlp, &slim, sizeof(slim))) != 0)
 		return error;
 
 	/*
Index: compat/svr4/svr4_signal.c
===================================================================
RCS file: /home/ncvs/src/sys/compat/svr4/svr4_signal.c,v
retrieving revision 1.21
diff -u -r1.21 svr4_signal.c
--- compat/svr4/svr4_signal.c	1 Oct 2002 17:15:50 -0000	1.21
+++ compat/svr4/svr4_signal.c	12 Dec 2002 03:14:38 -0000
@@ -269,12 +269,12 @@
 	int error;
 
 	DPRINTF(("@@@ svr4_sys_sigaction(%d, %d, %d)\n", td->td_proc->p_pid,
-			SCARG(uap, signum),
-			SVR4_SVR42BSD_SIG(SCARG(uap, signum))));
+			uap->signum,
+			SVR4_SVR42BSD_SIG(uap->signum)));
 	
 	sg = stackgap_init();
-	nisa = SCARG(uap, nsa);
-	oisa = SCARG(uap, osa);
+	nisa = uap->nsa;
+	oisa = uap->osa;
 
 	if (oisa != NULL)
 		obsa = stackgap_alloc(&sg, sizeof(struct sigaction));
@@ -301,9 +301,9 @@
 	}
 #endif
 
-	SCARG(&sa, sig) = SVR4_SVR42BSD_SIG(SCARG(uap, signum));
-	SCARG(&sa, act) = nbsa;
-	SCARG(&sa, oact) = obsa;
+	sa.sig = SVR4_SVR42BSD_SIG(uap->signum);
+	sa.act = nbsa;
+	sa.oact = obsa;
 
 	if ((error = sigaction(td, &sa)) != 0)
 		return error;
@@ -332,8 +332,8 @@
 
 	retval = td->td_retval;
 	sg = stackgap_init();
-	nsss = SCARG(uap, nss);
-	osss = SCARG(uap, oss);
+	nsss = uap->nss;
+	osss = uap->oss;
 
 	if (osss != NULL)
 		obss = stackgap_alloc(&sg, sizeof(struct sigaltstack));
@@ -350,8 +350,8 @@
 	} else
 		nbss = NULL;
 
-	SCARG(&sa, ss) = nbss;
-	SCARG(&sa, oss) = obss;
+	sa.ss = nbss;
+	sa.oss = obss;
 
 	if ((error = sigaltstack(td, &sa)) != 0)
 		return error;
@@ -381,13 +381,13 @@
 
 	DPRINTF(("@@@ svr4_sys_signal(%d)\n", td->td_proc->p_pid));
 
-	signum = SVR4_SVR42BSD_SIG(SVR4_SIGNO(SCARG(uap, signum)));
+	signum = SVR4_SVR42BSD_SIG(SVR4_SIGNO(uap->signum));
 	if (signum <= 0 || signum > SVR4_NSIG)
 		return (EINVAL);
 
-	switch (SVR4_SIGCALL(SCARG(uap, signum))) {
+	switch (SVR4_SIGCALL(uap->signum)) {
 	case SVR4_SIGDEFER_MASK:
-		if (SCARG(uap, handler) == SVR4_SIG_HOLD)
+		if (uap->handler == SVR4_SIG_HOLD)
 			goto sighold;
 		/* FALLTHROUGH */
 
@@ -398,11 +398,11 @@
 
 			nbsa = stackgap_alloc(&sg, sizeof(struct sigaction));
 			obsa = stackgap_alloc(&sg, sizeof(struct sigaction));
-			SCARG(&sa_args, sig) = signum;
-			SCARG(&sa_args, act) = nbsa;
-			SCARG(&sa_args, oact) = obsa;
+			sa_args.sig = signum;
+			sa_args.act = nbsa;
+			sa_args.oact = obsa;
 
-			sa.sa_handler = (sig_t) SCARG(uap, handler);
+			sa.sa_handler = (sig_t) uap->handler;
 			SIGEMPTYSET(sa.sa_mask);
 			sa.sa_flags = 0;
 
@@ -432,9 +432,9 @@
 			set = stackgap_alloc(&sg, sizeof(sigset_t));
 			SIGEMPTYSET(*set);
 			SIGADDSET(*set, signum);
-			SCARG(&sa, how) = SIG_BLOCK;
-			SCARG(&sa, set) = set;
-			SCARG(&sa, oset) = NULL;
+			sa.how = SIG_BLOCK;
+			sa.set = set;
+			sa.oset = NULL;
 			return sigprocmask(td, &sa);
 		}
 
@@ -446,9 +446,9 @@
 			set = stackgap_alloc(&sg, sizeof(sigset_t));
 			SIGEMPTYSET(*set);
 			SIGADDSET(*set, signum);
-			SCARG(&sa, how) = SIG_UNBLOCK;
-			SCARG(&sa, set) = set;
-			SCARG(&sa, oset) = NULL;
+			sa.how = SIG_UNBLOCK;
+			sa.set = set;
+			sa.oset = NULL;
 			return sigprocmask(td, &sa);
 		}
 
@@ -458,9 +458,9 @@
 			struct sigaction *bsa, sa;
 
 			bsa = stackgap_alloc(&sg, sizeof(struct sigaction));
-			SCARG(&sa_args, sig) = signum;
-			SCARG(&sa_args, act) = bsa;
-			SCARG(&sa_args, oact) = NULL;
+			sa_args.sig = signum;
+			sa_args.act = bsa;
+			sa_args.oact = NULL;
 
 			sa.sa_handler = SIG_IGN;
 			SIGEMPTYSET(sa.sa_mask);
@@ -484,7 +484,7 @@
 			*set = td->td_proc->p_sigmask;
 			PROC_UNLOCK(td->td_proc);
 			SIGDELSET(*set, signum);
-			SCARG(&sa, sigmask) = set;
+			sa.sigmask = set;
 			return sigsuspend(td, &sa);
 		}
 
@@ -504,26 +504,26 @@
 	int error = 0, *retval;
 
 	retval = td->td_retval;
-	if (SCARG(uap, oset) != NULL) {
+	if (uap->oset != NULL) {
 		/* Fix the return value first if needed */
 		PROC_LOCK(td->td_proc);
 		bsd_to_svr4_sigset(&td->td_proc->p_sigmask, &sss);
 		PROC_UNLOCK(td->td_proc);
-		if ((error = copyout(&sss, SCARG(uap, oset), sizeof(sss))) != 0)
+		if ((error = copyout(&sss, uap->oset, sizeof(sss))) != 0)
 			return error;
 	}
 
-	if (SCARG(uap, set) == NULL)
+	if (uap->set == NULL)
 		/* Just examine */
 		return 0;
 
-	if ((error = copyin(SCARG(uap, set), &sss, sizeof(sss))) != 0)
+	if ((error = copyin(uap->set, &sss, sizeof(sss))) != 0)
 		return error;
 
 	svr4_to_bsd_sigset(&sss, &bss);
 
 	PROC_LOCK(td->td_proc);
-	switch (SCARG(uap, how)) {
+	switch (uap->how) {
 	case SVR4_SIG_BLOCK:
 		SIGSETOR(td->td_proc->p_sigmask, bss);
 		SIG_CANTMASK(td->td_proc->p_sigmask);
@@ -560,9 +560,9 @@
 
 	DPRINTF(("@@@ svr4_sys_sigpending(%d)\n", td->td_proc->p_pid));
 	retval = td->td_retval;
-	switch (SCARG(uap, what)) {
+	switch (uap->what) {
 	case 1:	/* sigpending */
-		if (SCARG(uap, mask) == NULL)
+		if (uap->mask == NULL)
 			return 0;
 		PROC_LOCK(td->td_proc);
 		bss = td->td_proc->p_siglist;
@@ -586,7 +586,7 @@
 		return EINVAL;
 	}
 		
-	return copyout(&sss, SCARG(uap, mask), sizeof(sss));
+	return copyout(&sss, uap->mask, sizeof(sss));
 }
 
 int
@@ -600,13 +600,13 @@
 	int error;
 	caddr_t sg = stackgap_init();
 
-	if ((error = copyin(SCARG(uap, ss), &sss, sizeof(sss))) != 0)
+	if ((error = copyin(uap->ss, &sss, sizeof(sss))) != 0)
 		return error;
 
 	bss = stackgap_alloc(&sg, sizeof(sigset_t));
 	svr4_to_bsd_sigset(&sss, bss);
 
-	SCARG(&sa, sigmask) = bss;
+	sa.sigmask = bss;
 	return sigsuspend(td, &sa);
 }
 
@@ -618,8 +618,8 @@
 {
 	struct kill_args ka;
 
-	SCARG(&ka, pid) = SCARG(uap, pid);
-	SCARG(&ka, signum) = SVR4_SVR42BSD_SIG(SCARG(uap, signum));
+	ka.pid = uap->pid;
+	ka.signum = SVR4_SVR42BSD_SIG(uap->signum);
 	return kill(td, &ka);
 }
 
@@ -671,6 +671,6 @@
 {
 	struct sigsuspend_args bsa;
 
-	SCARG(&bsa, sigmask) = &td->td_proc->p_sigmask;
+	bsa.sigmask = &td->td_proc->p_sigmask;
 	return sigsuspend(td, &bsa);
 }
Index: compat/svr4/svr4_socket.c
===================================================================
RCS file: /home/ncvs/src/sys/compat/svr4/svr4_socket.c,v
retrieving revision 1.13
diff -u -r1.13 svr4_socket.c
--- compat/svr4/svr4_socket.c	12 Sep 2001 08:36:58 -0000	1.13
+++ compat/svr4/svr4_socket.c	12 Dec 2002 03:14:38 -0000
@@ -166,25 +166,25 @@
 	struct thread *td;
 	struct svr4_sys_socket_args *uap;
 {
-	switch (SCARG(uap, type)) {
+	switch (uap->type) {
 	case SVR4_SOCK_DGRAM:
-		SCARG(uap, type) = SOCK_DGRAM;
+		uap->type = SOCK_DGRAM;
 		break;
 
 	case SVR4_SOCK_STREAM:
-		SCARG(uap, type) = SOCK_STREAM;
+		uap->type = SOCK_STREAM;
 		break;
 
 	case SVR4_SOCK_RAW:
-		SCARG(uap, type) = SOCK_RAW;
+		uap->type = SOCK_RAW;
 		break;
 
 	case SVR4_SOCK_RDM:
-		SCARG(uap, type) = SOCK_RDM;
+		uap->type = SOCK_RDM;
 		break;
 
 	case SVR4_SOCK_SEQPACKET:
-		SCARG(uap, type) = SOCK_SEQPACKET;
+		uap->type = SOCK_SEQPACKET;
 		break;
 	default:
 		return EINVAL;
Index: compat/svr4/svr4_stat.c
===================================================================
RCS file: /home/ncvs/src/sys/compat/svr4/svr4_stat.c,v
retrieving revision 1.13
diff -u -r1.13 svr4_stat.c
--- compat/svr4/svr4_stat.c	17 Oct 2002 22:27:21 -0000	1.13
+++ compat/svr4/svr4_stat.c	12 Dec 2002 03:14:38 -0000
@@ -164,24 +164,24 @@
 	int			error;
 	caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	CHECKALTEXIST(td, &sg, uap->path);
 
-	SCARG(&cup, path) = SCARG(uap, path);
-	SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(struct stat));
+	cup.path = uap->path;
+	cup.ub = stackgap_alloc(&sg, sizeof(struct stat));
 
 
 	if ((error = stat(td, &cup)) != 0)
 		return error;
 
-	if ((error = copyin(SCARG(&cup, ub), &st, sizeof st)) != 0)
+	if ((error = copyin(cup.ub, &st, sizeof st)) != 0)
 		return error;
 
 	bsd_to_svr4_stat(&st, &svr4_st);
 
 	if (S_ISSOCK(st.st_mode))
-		(void) svr4_add_socket(td, SCARG(uap, path), &st);
+		(void) svr4_add_socket(td, uap->path, &st);
 
-	if ((error = copyout(&svr4_st, SCARG(uap, ub), sizeof svr4_st)) != 0)
+	if ((error = copyout(&svr4_st, uap->ub, sizeof svr4_st)) != 0)
 		return error;
 
 	return 0;
@@ -199,23 +199,23 @@
 	int			error;
 	caddr_t			sg = stackgap_init();
 
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	CHECKALTEXIST(td, &sg, uap->path);
 
-	SCARG(&cup, path) = SCARG(uap, path);
-	SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(struct stat));
+	cup.path = uap->path;
+	cup.ub = stackgap_alloc(&sg, sizeof(struct stat));
 
 	if ((error = lstat(td, &cup)) != 0)
 		return error;
 
-	if ((error = copyin(SCARG(&cup, ub), &st, sizeof st)) != 0)
+	if ((error = copyin(cup.ub, &st, sizeof st)) != 0)
 		return error;
 
 	bsd_to_svr4_stat(&st, &svr4_st);
 
 	if (S_ISSOCK(st.st_mode))
-		(void) svr4_add_socket(td, SCARG(uap, path), &st);
+		(void) svr4_add_socket(td, uap->path, &st);
 
-	if ((error = copyout(&svr4_st, SCARG(uap, ub), sizeof svr4_st)) != 0)
+	if ((error = copyout(&svr4_st, uap->ub, sizeof svr4_st)) != 0)
 		return error;
 
 	return 0;
@@ -233,18 +233,18 @@
 	int			error;
 	caddr_t			sg = stackgap_init();
 
-	SCARG(&cup, fd) = SCARG(uap, fd);
-	SCARG(&cup, sb) = stackgap_alloc(&sg, sizeof(struct stat));
+	cup.fd = uap->fd;
+	cup.sb = stackgap_alloc(&sg, sizeof(struct stat));
 
 	if ((error = fstat(td, &cup)) != 0)
 		return error;
 
-	if ((error = copyin(SCARG(&cup, sb), &st, sizeof st)) != 0)
+	if ((error = copyin(cup.sb, &st, sizeof st)) != 0)
 		return error;
 
 	bsd_to_svr4_stat(&st, &svr4_st);
 
-	if ((error = copyout(&svr4_st, SCARG(uap, sb), sizeof svr4_st)) != 0)
+	if ((error = copyout(&svr4_st, uap->sb, sizeof svr4_st)) != 0)
 		return error;
 
 	return 0;
@@ -262,25 +262,25 @@
 	int			error;
 
 	caddr_t sg = stackgap_init();
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	CHECKALTEXIST(td, &sg, uap->path);
 
-	SCARG(&cup, path) = SCARG(uap, path);
-	SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(struct stat));
+	cup.path = uap->path;
+	cup.ub = stackgap_alloc(&sg, sizeof(struct stat));
 
 	if ((error = stat(td, &cup)) != 0)
 		return error;
 
-	if ((error = copyin(SCARG(&cup, ub), &st, sizeof st)) != 0)
+	if ((error = copyin(cup.ub, &st, sizeof st)) != 0)
 		return error;
 
 	bsd_to_svr4_xstat(&st, &svr4_st);
 
 #if defined(SOCKET_NOTYET)
 	if (S_ISSOCK(st.st_mode))
-		(void) svr4_add_socket(td, SCARG(uap, path), &st);
+		(void) svr4_add_socket(td, uap->path, &st);
 #endif
 
-	if ((error = copyout(&svr4_st, SCARG(uap, ub), sizeof svr4_st)) != 0)
+	if ((error = copyout(&svr4_st, uap->ub, sizeof svr4_st)) != 0)
 		return error;
 
 	return 0;
@@ -296,24 +296,24 @@
 	struct lstat_args	cup;
 	int			error;
 	caddr_t sg = stackgap_init();
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	CHECKALTEXIST(td, &sg, uap->path);
 
-	SCARG(&cup, path) = SCARG(uap, path);
-	SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(struct stat));
+	cup.path = uap->path;
+	cup.ub = stackgap_alloc(&sg, sizeof(struct stat));
 
 	if ((error = lstat(td, &cup)) != 0)
 		return error;
 
-	if ((error = copyin(SCARG(&cup, ub), &st, sizeof st)) != 0)
+	if ((error = copyin(cup.ub, &st, sizeof st)) != 0)
 		return error;
 
 	bsd_to_svr4_xstat(&st, &svr4_st);
 
 #if defined(SOCKET_NOTYET)
 	if (S_ISSOCK(st.st_mode))
-		(void) svr4_add_socket(td, SCARG(uap, path), &st);
+		(void) svr4_add_socket(td, uap->path, &st);
 #endif
-	if ((error = copyout(&svr4_st, SCARG(uap, ub), sizeof svr4_st)) != 0)
+	if ((error = copyout(&svr4_st, uap->ub, sizeof svr4_st)) != 0)
 		return error;
 
 	return 0;
@@ -332,18 +332,18 @@
 
 	caddr_t sg = stackgap_init();
 
-	SCARG(&cup, fd) = SCARG(uap, fd);
-	SCARG(&cup, sb) = stackgap_alloc(&sg, sizeof(struct stat));
+	cup.fd = uap->fd;
+	cup.sb = stackgap_alloc(&sg, sizeof(struct stat));
 
 	if ((error = fstat(td, &cup)) != 0)
 		return error;
 
-	if ((error = copyin(SCARG(&cup, sb), &st, sizeof st)) != 0)
+	if ((error = copyin(cup.sb, &st, sizeof st)) != 0)
 		return error;
 
 	bsd_to_svr4_xstat(&st, &svr4_st);
 
-	if ((error = copyout(&svr4_st, SCARG(uap, sb), sizeof svr4_st)) != 0)
+	if ((error = copyout(&svr4_st, uap->sb, sizeof svr4_st)) != 0)
 		return error;
 
 	return 0;
@@ -360,23 +360,23 @@
 	int			error;
 	caddr_t			sg = stackgap_init();
 
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	CHECKALTEXIST(td, &sg, uap->path);
 
-	SCARG(&cup, path) = SCARG(uap, path);
-	SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(struct stat));
+	cup.path = uap->path;
+	cup.ub = stackgap_alloc(&sg, sizeof(struct stat));
 
 	if ((error = stat(td, &cup)) != 0)
 		return error;
 
-	if ((error = copyin(SCARG(&cup, ub), &st, sizeof st)) != 0)
+	if ((error = copyin(cup.ub, &st, sizeof st)) != 0)
 		return error;
 
 	bsd_to_svr4_stat64(&st, &svr4_st);
 
 	if (S_ISSOCK(st.st_mode))
-		(void) svr4_add_socket(td, SCARG(uap, path), &st);
+		(void) svr4_add_socket(td, uap->path, &st);
 
-	if ((error = copyout(&svr4_st, SCARG(uap, sb), sizeof svr4_st)) != 0)
+	if ((error = copyout(&svr4_st, uap->sb, sizeof svr4_st)) != 0)
 		return error;
 
 	return 0;
@@ -394,23 +394,23 @@
 	int			error;
 	caddr_t			sg = stackgap_init();
 
-	CHECKALTEXIST(td, &sg, (char *) SCARG(uap, path));
+	CHECKALTEXIST(td, &sg, (char *) uap->path);
 
-	SCARG(&cup, path) = SCARG(uap, path);
-	SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(struct stat));
+	cup.path = uap->path;
+	cup.ub = stackgap_alloc(&sg, sizeof(struct stat));
 
 	if ((error = lstat(td, (struct lstat_args *)&cup)) != 0)
 		return error;
 
-	if ((error = copyin(SCARG(&cup, ub), &st, sizeof st)) != 0)
+	if ((error = copyin(cup.ub, &st, sizeof st)) != 0)
 		return error;
 
 	bsd_to_svr4_stat64(&st, &svr4_st);
 
 	if (S_ISSOCK(st.st_mode))
-		(void) svr4_add_socket(td, SCARG(uap, path), &st);
+		(void) svr4_add_socket(td, uap->path, &st);
 
-	if ((error = copyout(&svr4_st, SCARG(uap, sb), sizeof svr4_st)) != 0)
+	if ((error = copyout(&svr4_st, uap->sb, sizeof svr4_st)) != 0)
 		return error;
 
 	return 0;
@@ -428,18 +428,18 @@
 	int			error;
 	caddr_t sg = stackgap_init();
 
-	SCARG(&cup, fd) = SCARG(uap, fd);
-	SCARG(&cup, sb) = stackgap_alloc(&sg, sizeof(struct stat));
+	cup.fd = uap->fd;
+	cup.sb = stackgap_alloc(&sg, sizeof(struct stat));
 
 	if ((error = fstat(td, &cup)) != 0)
 		return error;
 
-	if ((error = copyin(SCARG(&cup, sb), &st, sizeof st)) != 0)
+	if ((error = copyin(cup.sb, &st, sizeof st)) != 0)
 		return error;
 
 	bsd_to_svr4_stat64(&st, &svr4_st);
 
-	if ((error = copyout(&svr4_st, SCARG(uap, sb), sizeof svr4_st)) != 0)
+	if ((error = copyout(&svr4_st, uap->sb, sizeof svr4_st)) != 0)
 		return error;
 
 	return 0;
@@ -460,7 +460,7 @@
          * XXX: should set f_tfree and f_tinode at least
          * How do we translate dev -> fstat? (and then to svr4_ustat)
          */
-	if ((error = copyout(&us, SCARG(uap, name), sizeof us)) != 0)
+	if ((error = copyout(&us, uap->name, sizeof us)) != 0)
 		return (error);
 
 	return 0;
@@ -483,7 +483,7 @@
 	strlcpy(sut.version, version, sizeof(sut.version));
 	strlcpy(sut.machine, machine, sizeof(sut.machine));
 
-	return copyout((caddr_t) &sut, (caddr_t) SCARG(uap, name),
+	return copyout((caddr_t) &sut, (caddr_t) uap->name,
 		       sizeof(struct svr4_utsname));
 }
 
@@ -499,9 +499,9 @@
 	char		buf[1];   /* XXX NetBSD uses 256, but that seems
 				     like awfully excessive kstack usage
 				     for an empty string... */
-	u_int		rlen = SCARG(uap, len);
+	u_int		rlen = uap->len;
 
-	switch (SCARG(uap, what)) {
+	switch (uap->what) {
 	case SVR4_SI_SYSNAME:
 		str = ostype;
 		break;
@@ -554,13 +554,13 @@
 		if ((error = suser(td)) != 0)
 			return error;
 		name = KERN_HOSTNAME;
-		return kern_sysctl(&name, 1, 0, 0, SCARG(uap, buf), rlen, td);
+		return kern_sysctl(&name, 1, 0, 0, uap->buf, rlen, td);
 
 	case SVR4_SI_SET_SRPC_DOMAIN:
 		if ((error = suser(td)) != 0)
 			return error;
 		name = KERN_NISDOMAINNAME;
-		return kern_sysctl(&name, 1, 0, 0, SCARG(uap, buf), rlen, td);
+		return kern_sysctl(&name, 1, 0, 0, uap->buf, rlen, td);
 #else
 	case SVR4_SI_SET_HOSTNAME:
         case SVR4_SI_SET_SRPC_DOMAIN:
@@ -570,7 +570,7 @@
 		return 0;
 
 	default:
-		DPRINTF(("Bad systeminfo command %d\n", SCARG(uap, what)));
+		DPRINTF(("Bad systeminfo command %d\n", uap->what));
 		return ENOSYS;
 	}
 
@@ -579,13 +579,13 @@
 		if (len > rlen)
 			len = rlen;
 
-		if (SCARG(uap, buf)) {
-			error = copyout(str, SCARG(uap, buf), len);
+		if (uap->buf) {
+			error = copyout(str, uap->buf, len);
 			if (error)
 				return error;
 			/* make sure we are NULL terminated */
 			buf[0] = '\0';
-			error = copyout(buf, &(SCARG(uap, buf)[len - 1]), 1);
+			error = copyout(buf, &(uap->buf[len - 1]), 1);
 		}
 		else
 			error = 0;
@@ -602,19 +602,19 @@
 	register struct thread *td;
 	struct svr4_sys_utssys_args *uap;
 {
-	switch (SCARG(uap, sel)) {
+	switch (uap->sel) {
 	case 0:		/* uname(2)  */
 		{
 			struct svr4_sys_uname_args ua;
-			SCARG(&ua, name) = SCARG(uap, a1);
+			ua.name = uap->a1;
 			return svr4_sys_uname(td, &ua);
 		}
 
 	case 2:		/* ustat(2)  */
 		{
 			struct svr4_ustat_args ua;
-			SCARG(&ua, dev) = (svr4_dev_t) SCARG(uap, a2);
-			SCARG(&ua, name) = SCARG(uap, a1);
+			ua.dev = (svr4_dev_t) uap->a2;
+			ua.name = uap->a1;
 			return svr4_ustat(td, &ua);
 		}
 
@@ -640,10 +640,10 @@
 	caddr_t sg = stackgap_init();
 	void *ttp;
 
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
-	SCARG(&ap, path) = SCARG(uap, path);
-	if (SCARG(uap, ubuf) != NULL) {
-		if ((error = copyin(SCARG(uap, ubuf), &ub, sizeof(ub))) != 0)
+	CHECKALTEXIST(td, &sg, uap->path);
+	ap.path = uap->path;
+	if (uap->ubuf != NULL) {
+		if ((error = copyin(uap->ubuf, &ub, sizeof(ub))) != 0)
 			return error;
 		tbuf[0].tv_sec = ub.actime;
 		tbuf[0].tv_usec = 0;
@@ -653,10 +653,10 @@
 		error = copyout(tbuf, ttp, sizeof(tbuf));
 		if (error)
 			return error;
-		SCARG(&ap, tptr) = ttp;
+		ap.tptr = ttp;
 	}
 	else
-		SCARG(&ap, tptr) = NULL;
+		ap.tptr = NULL;
 	return utimes(td, &ap);
 }
 
@@ -667,7 +667,7 @@
 	struct svr4_sys_utimes_args *uap;
 {
 	caddr_t sg = stackgap_init();
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	CHECKALTEXIST(td, &sg, uap->path);
 	return utimes(td, (struct utimes_args *)uap);
 }
 
@@ -728,11 +728,11 @@
 	caddr_t		sg = stackgap_init();
 	register_t	*retval = td->td_retval;
 
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	CHECKALTEXIST(td, &sg, uap->path);
 
-	SCARG(uap, name) = svr4_to_bsd_pathconf(SCARG(uap, name));
+	uap->name = svr4_to_bsd_pathconf(uap->name);
 
-	switch (SCARG(uap, name)) {
+	switch (uap->name) {
 	case -1:
 		*retval = -1;
 		return EINVAL;
@@ -752,9 +752,9 @@
 {
         register_t	*retval = td->td_retval;
 
-	SCARG(uap, name) = svr4_to_bsd_pathconf(SCARG(uap, name));
+	uap->name = svr4_to_bsd_pathconf(uap->name);
 
-	switch (SCARG(uap, name)) {
+	switch (uap->name) {
 	case -1:
 		*retval = -1;
 		return EINVAL;
Index: compat/svr4/svr4_stream.c
===================================================================
RCS file: /home/ncvs/src/sys/compat/svr4/svr4_stream.c,v
retrieving revision 1.36
diff -u -r1.36 svr4_stream.c
--- compat/svr4/svr4_stream.c	6 Oct 2002 14:39:14 -0000	1.36
+++ compat/svr4/svr4_stream.c	12 Dec 2002 03:14:38 -0000
@@ -524,17 +524,17 @@
 	void *tpath;
 
 	tpath = stackgap_alloc(&sg, l);
-	SCARG(&la, ub) = stackgap_alloc(&sg, sizeof(struct stat));
+	la.ub = stackgap_alloc(&sg, sizeof(struct stat));
 
 	if ((error = copyout(path, tpath, l)) != 0)
 		return error;
 
-	SCARG(&la, path) = tpath;
+	la.path = tpath;
 
 	if ((error = lstat(td, &la)) != 0)
 		return 0;
 
-	if ((error = copyin(SCARG(&la, ub), &st, sizeof(st))) != 0)
+	if ((error = copyin(la.ub, &st, sizeof(st))) != 0)
 		return 0;
 
 	/*
@@ -546,7 +546,7 @@
 	if ((st.st_mode & ALLPERMS) != 0)
 		return 0;
 
-	SCARG(&ua, path) = SCARG(&la, path);
+	ua.path = la.path;
 
 	if ((error = unlink(td, &ua)) != 0) {
 		DPRINTF(("clean_pipe: unlink failed %d\n", error));
@@ -773,9 +773,9 @@
 	/*
 	 * We are making assumptions again...
 	 */
-	SCARG(&la, s) = fd;
+	la.s = fd;
 	DPRINTF(("SI_LISTEN: fileno %d backlog = %d\n", fd, 5));
-	SCARG(&la, backlog) = 5;
+	la.backlog = 5;
 
 	if ((error = listen(td, &la)) != 0) {
 		DPRINTF(("SI_LISTEN: listen failed %d\n", error));
@@ -880,16 +880,16 @@
 	int error;
 	struct shutdown_args ap;
 
-	if (ioc->len != sizeof(SCARG(&ap, how))) {
+	if (ioc->len != sizeof(ap.how)) {
 		DPRINTF(("SI_SHUTDOWN: Wrong size %d != %d\n",
-			 sizeof(SCARG(&ap, how)), ioc->len));
+			 sizeof(ap.how), ioc->len));
 		return EINVAL;
 	}
 
-	if ((error = copyin(ioc->buf, &SCARG(&ap, how), ioc->len)) != 0)
+	if ((error = copyin(ioc->buf, &ap.how, ioc->len)) != 0)
 		return error;
 
-	SCARG(&ap, s) = fd;
+	ap.s = fd;
 
 	return shutdown(td, &ap);
 }
@@ -1066,10 +1066,10 @@
 	if ((error = copyout(skp, sup, sasize)) != 0)
 		return error;
 
-	SCARG(&ba, s) = fd;
+	ba.s = fd;
 	DPRINTF(("TI_BIND: fileno %d\n", fd));
-	SCARG(&ba, name) = (void *) sup;
-	SCARG(&ba, namelen) = sasize;
+	ba.name = (void *) sup;
+	ba.namelen = sasize;
 
 	if ((error = bind(td, &ba)) != 0) {
 		DPRINTF(("TI_BIND: bind failed %d\n", error));
@@ -1186,9 +1186,9 @@
 		DPRINTF(("TI_GETMYNAME\n"));
 		{
 			struct getsockname_args ap;
-			SCARG(&ap, fdes) = fd;
-			SCARG(&ap, asa) = sup;
-			SCARG(&ap, alen) = lenp;
+			ap.fdes = fd;
+			ap.asa = sup;
+			ap.alen = lenp;
 			if ((error = getsockname(td, &ap)) != 0) {
 				DPRINTF(("ti_ioctl: getsockname error\n"));
 				return error;
@@ -1200,9 +1200,9 @@
 		DPRINTF(("TI_GETPEERNAME\n"));
 		{
 			struct getpeername_args ap;
-			SCARG(&ap, fdes) = fd;
-			SCARG(&ap, asa) = sup;
-			SCARG(&ap, alen) = lenp;
+			ap.fdes = fd;
+			ap.asa = sup;
+			ap.alen = lenp;
 			if ((error = getpeername(td, &ap)) != 0) {
 				DPRINTF(("ti_ioctl: getpeername error\n"));
 				return error;
@@ -1334,8 +1334,8 @@
 		return error;
 	}
 
-	SCARG(&d2p, from) = st->s_afd;
-	SCARG(&d2p, to) = fdi.fd;
+	d2p.from = st->s_afd;
+	d2p.to = fdi.fd;
 
 	if ((error = dup2(td, &d2p)) != 0) {
 		DPRINTF(("fdinsert: dup2(%d, %d) failed %d\n", 
@@ -1343,7 +1343,7 @@
 		return error;
 	}
 
-	SCARG(&clp, fd) = st->s_afd;
+	clp.fd = st->s_afd;
 
 	if ((error = close(td, &clp)) != 0) {
 		DPRINTF(("fdinsert: close(%d) failed %d\n", 
@@ -1376,8 +1376,8 @@
 	 * ``reserve'' it. I don't know how this get reserved inside
 	 * the kernel, but we are going to create it nevertheless.
 	 */
-	SCARG(&ap, path) = dat;
-	SCARG(&ap, mode) = S_IFIFO;
+	ap.path = dat;
+	ap.mode = S_IFIFO;
 
 	return mkfifo(td, &ap);
 }
@@ -1397,7 +1397,7 @@
 	 * This is a supposed to be a kernel and library only ioctl.
 	 * I guess it is supposed to release the socket.
 	 */
-	SCARG(&ap, path) = dat;
+	ap.path = dat;
 
 	return unlink(td, &ap);
 }
@@ -1473,8 +1473,8 @@
 		return EINVAL;
 	}
 	/* get old status flags */
-	SCARG(&fa, fd) = fd;
-	SCARG(&fa, cmd) = F_GETFL;
+	fa.fd = fd;
+	fa.cmd = F_GETFL;
 	if ((error = fcntl(td, &fa)) != 0)
 		return error;
 
@@ -1502,8 +1502,8 @@
 
 	/* set the new flags, if changed */
 	if (flags != oflags) {
-		SCARG(&fa, cmd) = F_SETFL;
-		SCARG(&fa, arg) = (long) flags;
+		fa.cmd = F_SETFL;
+		fa.arg = (long) flags;
 		if ((error = fcntl(td, &fa)) != 0)
 			  return error;
 		flags = td->td_retval[0];
@@ -1511,8 +1511,8 @@
 
 	/* set up SIGIO receiver if needed */
 	if (dat != NULL) {
-		SCARG(&fa, cmd) = F_SETOWN;
-		SCARG(&fa, arg) = (long) td->td_proc->p_pid;
+		fa.cmd = F_SETOWN;
+		fa.arg = (long) td->td_proc->p_pid;
 		return fcntl(td, &fa);
 	}
 	return 0;
@@ -1760,14 +1760,14 @@
 	retval = td->td_retval;
 
 #ifdef DEBUG_SVR4
-	show_msg(">putmsg", SCARG(uap, fd), SCARG(uap, ctl),
-		 SCARG(uap, dat), SCARG(uap, flags));
+	show_msg(">putmsg", uap->fd, uap->ctl,
+		 uap->dat, uap->flags);
 #endif /* DEBUG_SVR4 */
 
 	FILE_LOCK_ASSERT(fp, MA_NOTOWNED);
 
-	if (SCARG(uap, ctl) != NULL) {
-	  if ((error = copyin(SCARG(uap, ctl), &ctl, sizeof(ctl))) != 0) {
+	if (uap->ctl != NULL) {
+	  if ((error = copyin(uap->ctl, &ctl, sizeof(ctl))) != 0) {
 #ifdef DEBUG_SVR4
 	    uprintf("putmsg: copyin(): %d\n", error);
 #endif
@@ -1777,8 +1777,8 @@
 	else
 		ctl.len = -1;
 
-	if (SCARG(uap, dat) != NULL) {
-	  if ((error = copyin(SCARG(uap, dat), &dat, sizeof(dat))) != 0) {
+	if (uap->dat != NULL) {
+	  if ((error = copyin(uap->dat, &dat, sizeof(dat))) != 0) {
 #ifdef DEBUG_SVR4
 	    uprintf("putmsg: copyin(): %d (2)\n", error);
 #endif
@@ -1820,9 +1820,9 @@
 				 * is how it works. newton@atdot.dotat.org XXX
 				 */
 				DPRINTF(("sending expedited data ??\n"));
-				SCARG(&wa, fd) = SCARG(uap, fd);
-				SCARG(&wa, buf) = dat.buf;
-				SCARG(&wa, nbyte) = dat.len;
+				wa.fd = uap->fd;
+				wa.buf = dat.buf;
+				wa.nbyte = dat.len;
 				return write(td, &wa);
 			}
 	                DPRINTF(("putmsg: Invalid inet length %ld\n", sc.len));
@@ -1872,9 +1872,9 @@
 		{
 			struct connect_args co;
 
-			SCARG(&co, s) = SCARG(uap, fd);
-			SCARG(&co, name) = (void *) sup;
-			SCARG(&co, namelen) = (int) sasize;
+			co.s = uap->fd;
+			co.name = (void *) sup;
+			co.namelen = (int) sasize;
 			
 			return connect(td, &co);
 		}
@@ -1896,8 +1896,8 @@
 			error = so->so_proto->pr_usrreqs->pru_sosend(so, 0, 
 					      uio, 0, 0, 0, uio->uio_td);
 #endif
-			error = svr4_sendit(td, SCARG(uap, fd), &msg,
-				       SCARG(uap, flags));
+			error = svr4_sendit(td, uap->fd, &msg,
+				       uap->flags);
 			DPRINTF(("sendto_request error: %d\n", error));
 			*retval = 0;
 			return error;
@@ -1957,12 +1957,12 @@
 	memset(&sc, 0, sizeof(sc));
 
 #ifdef DEBUG_SVR4
-	show_msg(">getmsg", SCARG(uap, fd), SCARG(uap, ctl),
-		 SCARG(uap, dat), 0);
+	show_msg(">getmsg", uap->fd, uap->ctl,
+		 uap->dat, 0);
 #endif /* DEBUG_SVR4 */
 
-	if (SCARG(uap, ctl) != NULL) {
-		if ((error = copyin(SCARG(uap, ctl), &ctl, sizeof(ctl))) != 0)
+	if (uap->ctl != NULL) {
+		if ((error = copyin(uap->ctl, &ctl, sizeof(ctl))) != 0)
 			return error;
 	}
 	else {
@@ -1970,8 +1970,8 @@
 		ctl.maxlen = 0;
 	}
 
-	if (SCARG(uap, dat) != NULL) {
-	    	if ((error = copyin(SCARG(uap, dat), &dat, sizeof(dat))) != 0)
+	if (uap->dat != NULL) {
+	    	if ((error = copyin(uap->dat, &dat, sizeof(dat))) != 0)
 			return error;
 	}
 	else {
@@ -2040,9 +2040,9 @@
 		 * a connect verification.
 		 */
 
-		SCARG(&ga, fdes) = SCARG(uap, fd);
-		SCARG(&ga, asa) = (void *) sup;
-		SCARG(&ga, alen) = flen;
+		ga.fdes = uap->fd;
+		ga.asa = (void *) sup;
+		ga.alen = flen;
 		
 		if ((error = getpeername(td, &ga)) != 0) {
 			DPRINTF(("getmsg: getpeername failed %d\n", error));
@@ -2099,9 +2099,9 @@
 		/*
 		 * We are after a listen, so we try to accept...
 		 */
-		SCARG(&aa, s) = SCARG(uap, fd);
-		SCARG(&aa, name) = (void *) sup;
-		SCARG(&aa, anamelen) = flen;
+		aa.s = uap->fd;
+		aa.name = (void *) sup;
+		aa.anamelen = flen;
 		
 		if ((error = accept(td, &aa)) != 0) {
 			DPRINTF(("getmsg: accept failed %d\n", error));
@@ -2174,7 +2174,7 @@
 		aiov.iov_len = dat.maxlen;
 		msg.msg_flags = 0;
 
-		error = svr4_recvit(td, SCARG(uap, fd), &msg, (caddr_t) flen);
+		error = svr4_recvit(td, uap->fd, &msg, (caddr_t) flen);
 
 		if (error) {
 			DPRINTF(("getmsg: recvit failed %d\n", error));
@@ -2222,9 +2222,9 @@
 			 * appropriately (or inappropriately :-)
 			 *   -- newton@atdot.dotat.org        XXX
 			 */
-			SCARG(&ra, fd) = SCARG(uap, fd);
-			SCARG(&ra, buf) = dat.buf;
-			SCARG(&ra, nbyte) = dat.maxlen;
+			ra.fd = uap->fd;
+			ra.buf = dat.buf;
+			ra.nbyte = dat.maxlen;
 			if ((error = read(td, &ra)) != 0) {
 			        return error;
 			}
@@ -2237,30 +2237,30 @@
 		return EINVAL;
 	}
 
-	if (SCARG(uap, ctl)) {
+	if (uap->ctl) {
 		if (ctl.len != -1)
 			if ((error = copyout(&sc, ctl.buf, ctl.len)) != 0)
 				return error;
 
-		if ((error = copyout(&ctl, SCARG(uap, ctl), sizeof(ctl))) != 0)
+		if ((error = copyout(&ctl, uap->ctl, sizeof(ctl))) != 0)
 			return error;
 	}
 
-	if (SCARG(uap, dat)) {
-		if ((error = copyout(&dat, SCARG(uap, dat), sizeof(dat))) != 0)
+	if (uap->dat) {
+		if ((error = copyout(&dat, uap->dat, sizeof(dat))) != 0)
 			return error;
 	}
 
-	if (SCARG(uap, flags)) { /* XXX: Need translation */
-		if ((error = copyout(&fl, SCARG(uap, flags), sizeof(fl))) != 0)
+	if (uap->flags) { /* XXX: Need translation */
+		if ((error = copyout(&fl, uap->flags, sizeof(fl))) != 0)
 			return error;
 	}
 
 	*retval = 0;
 
 #ifdef DEBUG_SVR4
-	show_msg("<getmsg", SCARG(uap, fd), SCARG(uap, ctl),
-		 SCARG(uap, dat), fl);
+	show_msg("<getmsg", uap->fd, uap->ctl,
+		 uap->dat, fl);
 #endif /* DEBUG_SVR4 */
 	return error;
 }
@@ -2270,10 +2270,10 @@
 	struct svr4_sys_send_args *uap;
 {
 	struct osend_args osa;
-	SCARG(&osa, s) = SCARG(uap, s);
-	SCARG(&osa, buf) = SCARG(uap, buf);
-	SCARG(&osa, len) = SCARG(uap, len);
-	SCARG(&osa, flags) = SCARG(uap, flags);
+	osa.s = uap->s;
+	osa.buf = uap->buf;
+	osa.len = uap->len;
+	osa.flags = uap->flags;
 	return osend(td, &osa);
 }
 
@@ -2282,10 +2282,10 @@
 	struct svr4_sys_recv_args *uap;
 {
 	struct orecv_args ora;
-	SCARG(&ora, s) = SCARG(uap, s);
-	SCARG(&ora, buf) = SCARG(uap, buf);
-	SCARG(&ora, len) = SCARG(uap, len);
-	SCARG(&ora, flags) = SCARG(uap, flags);
+	ora.s = uap->s;
+	ora.buf = uap->buf;
+	ora.len = uap->len;
+	ora.flags = uap->flags;
 	return orecv(td, &ora);
 }
 
@@ -2300,12 +2300,12 @@
 {
         struct sendto_args sa;
 
-	SCARG(&sa, s) = SCARG(uap, s);
-	SCARG(&sa, buf) = SCARG(uap, buf);
-	SCARG(&sa, len) = SCARG(uap, len);
-	SCARG(&sa, flags) = SCARG(uap, flags);
-	SCARG(&sa, to) = (caddr_t)SCARG(uap, to);
-	SCARG(&sa, tolen) = SCARG(uap, tolen);
+	sa.s = uap->s;
+	sa.buf = uap->buf;
+	sa.len = uap->len;
+	sa.flags = uap->flags;
+	sa.to = (caddr_t)uap->to;
+	sa.tolen = uap->tolen;
 
 	DPRINTF(("calling sendto()\n"));
 	return sendto(td, &sa);
Index: dev/streams/streams.c
===================================================================
RCS file: /home/ncvs/src/sys/dev/streams/streams.c,v
retrieving revision 1.30
diff -u -r1.30 streams.c
--- dev/streams/streams.c	20 Mar 2002 02:07:43 -0000	1.30
+++ dev/streams/streams.c	12 Dec 2002 03:14:38 -0000
@@ -315,9 +315,9 @@
 	register_t fd = -1;
 	int error;
 
-	SCARG(&oa, path) = path;
-	SCARG(&oa, flags) = O_RDWR;
-	SCARG(&oa, mode) = 0;
+	oa.path = path;
+	oa.flags = O_RDWR;
+	oa.mode = 0;
 
 	while (fd == -1) {
 		ptyname[8] = ttyletters[l];
Index: i386/ibcs2/ibcs2_fcntl.c
===================================================================
RCS file: /home/ncvs/src/sys/i386/ibcs2/ibcs2_fcntl.c,v
retrieving revision 1.21
diff -u -r1.21 ibcs2_fcntl.c
--- i386/ibcs2/ibcs2_fcntl.c	17 Aug 2002 02:36:16 -0000	1.21
+++ i386/ibcs2/ibcs2_fcntl.c	12 Dec 2002 03:14:38 -0000
@@ -174,20 +174,20 @@
 	struct ibcs2_open_args *uap;
 {
 	struct proc *p = td->td_proc;
-	int noctty = SCARG(uap, flags) & IBCS2_O_NOCTTY;
+	int noctty = uap->flags & IBCS2_O_NOCTTY;
 	int ret;
 	caddr_t sg = stackgap_init();
 
-	SCARG(uap, flags) = cvt_o_flags(SCARG(uap, flags));
-	if (SCARG(uap, flags) & O_CREAT)
-		CHECKALTCREAT(td, &sg, SCARG(uap, path));
+	uap->flags = cvt_o_flags(uap->flags);
+	if (uap->flags & O_CREAT)
+		CHECKALTCREAT(td, &sg, uap->path);
 	else
-		CHECKALTEXIST(td, &sg, SCARG(uap, path));
+		CHECKALTEXIST(td, &sg, uap->path);
 	ret = open(td, (struct open_args *)uap);
 
 #ifdef SPX_HACK
 	if (ret == ENXIO) {
-		if (!strcmp(SCARG(uap, path), "/compat/ibcs2/dev/spx"))
+		if (!strcmp(uap->path, "/compat/ibcs2/dev/spx"))
 			ret = spx_open(td, uap);
 	} else
 #endif /* SPX_HACK */
@@ -219,10 +219,10 @@
 	struct open_args cup;   
 	caddr_t sg = stackgap_init();
 
-	CHECKALTCREAT(td, &sg, SCARG(uap, path));
-	SCARG(&cup, path) = SCARG(uap, path);
-	SCARG(&cup, mode) = SCARG(uap, mode);
-	SCARG(&cup, flags) = O_WRONLY | O_CREAT | O_TRUNC;
+	CHECKALTCREAT(td, &sg, uap->path);
+	cup.path = uap->path;
+	cup.mode = uap->mode;
+	cup.flags = O_WRONLY | O_CREAT | O_TRUNC;
 	return open(td, &cup);
 }       
 
@@ -234,9 +234,9 @@
         struct access_args cup;
         caddr_t sg = stackgap_init();
 
-        CHECKALTEXIST(td, &sg, SCARG(uap, path));
-        SCARG(&cup, path) = SCARG(uap, path);
-        SCARG(&cup, flags) = SCARG(uap, flags);
+        CHECKALTEXIST(td, &sg, uap->path);
+        cup.path = uap->path;
+        cup.flags = uap->flags;
         return access(td, &cup);
 }
 
@@ -250,55 +250,55 @@
 	struct flock *flp;
 	struct ibcs2_flock ifl;
 	
-	switch(SCARG(uap, cmd)) {
+	switch(uap->cmd) {
 	case IBCS2_F_DUPFD:
-		SCARG(&fa, fd) = SCARG(uap, fd);
-		SCARG(&fa, cmd) = F_DUPFD;
-		SCARG(&fa, arg) = (/* XXX */ int)SCARG(uap, arg);
+		fa.fd = uap->fd;
+		fa.cmd = F_DUPFD;
+		fa.arg = (/* XXX */ int)uap->arg;
 		return fcntl(td, &fa);
 	case IBCS2_F_GETFD:
-		SCARG(&fa, fd) = SCARG(uap, fd);
-		SCARG(&fa, cmd) = F_GETFD;
-		SCARG(&fa, arg) = (/* XXX */ int)SCARG(uap, arg);
+		fa.fd = uap->fd;
+		fa.cmd = F_GETFD;
+		fa.arg = (/* XXX */ int)uap->arg;
 		return fcntl(td, &fa);
 	case IBCS2_F_SETFD:
-		SCARG(&fa, fd) = SCARG(uap, fd);
-		SCARG(&fa, cmd) = F_SETFD;
-		SCARG(&fa, arg) = (/* XXX */ int)SCARG(uap, arg);
+		fa.fd = uap->fd;
+		fa.cmd = F_SETFD;
+		fa.arg = (/* XXX */ int)uap->arg;
 		return fcntl(td, &fa);
 	case IBCS2_F_GETFL:
-		SCARG(&fa, fd) = SCARG(uap, fd);
-		SCARG(&fa, cmd) = F_GETFL;
-		SCARG(&fa, arg) = (/* XXX */ int)SCARG(uap, arg);
+		fa.fd = uap->fd;
+		fa.cmd = F_GETFL;
+		fa.arg = (/* XXX */ int)uap->arg;
 		error = fcntl(td, &fa);
 		if (error)
 			return error;
 		td->td_retval[0] = oflags2ioflags(td->td_retval[0]);
 		return error;
 	case IBCS2_F_SETFL:
-		SCARG(&fa, fd) = SCARG(uap, fd);
-		SCARG(&fa, cmd) = F_SETFL;
-		SCARG(&fa, arg) = (/* XXX */ int)
-				  ioflags2oflags((int)SCARG(uap, arg));
+		fa.fd = uap->fd;
+		fa.cmd = F_SETFL;
+		fa.arg = (/* XXX */ int)
+				  ioflags2oflags((int)uap->arg);
 		return fcntl(td, &fa);
 
 	case IBCS2_F_GETLK:
 	    {
 		caddr_t sg = stackgap_init();
 		flp = stackgap_alloc(&sg, sizeof(*flp));
-		error = copyin((caddr_t)SCARG(uap, arg), (caddr_t)&ifl,
+		error = copyin((caddr_t)uap->arg, (caddr_t)&ifl,
 			       ibcs2_flock_len);
 		if (error)
 			return error;
 		cvt_iflock2flock(&ifl, flp);
-		SCARG(&fa, fd) = SCARG(uap, fd);
-		SCARG(&fa, cmd) = F_GETLK;
-		SCARG(&fa, arg) = (/* XXX */ int)flp;
+		fa.fd = uap->fd;
+		fa.cmd = F_GETLK;
+		fa.arg = (/* XXX */ int)flp;
 		error = fcntl(td, &fa);
 		if (error)
 			return error;
 		cvt_flock2iflock(flp, &ifl);
-		return copyout((caddr_t)&ifl, (caddr_t)SCARG(uap, arg),
+		return copyout((caddr_t)&ifl, (caddr_t)uap->arg,
 			       ibcs2_flock_len);
 	    }
 
@@ -306,14 +306,14 @@
 	    {
 		caddr_t sg = stackgap_init();
 		flp = stackgap_alloc(&sg, sizeof(*flp));
-		error = copyin((caddr_t)SCARG(uap, arg), (caddr_t)&ifl,
+		error = copyin((caddr_t)uap->arg, (caddr_t)&ifl,
 			       ibcs2_flock_len);
 		if (error)
 			return error;
 		cvt_iflock2flock(&ifl, flp);
-		SCARG(&fa, fd) = SCARG(uap, fd);
-		SCARG(&fa, cmd) = F_SETLK;
-		SCARG(&fa, arg) = (/* XXX */ int)flp;
+		fa.fd = uap->fd;
+		fa.cmd = F_SETLK;
+		fa.arg = (/* XXX */ int)flp;
 
 		return fcntl(td, &fa);
 	    }
@@ -322,14 +322,14 @@
 	    {
 		caddr_t sg = stackgap_init();
 		flp = stackgap_alloc(&sg, sizeof(*flp));
-		error = copyin((caddr_t)SCARG(uap, arg), (caddr_t)&ifl,
+		error = copyin((caddr_t)uap->arg, (caddr_t)&ifl,
 			       ibcs2_flock_len);
 		if (error)
 			return error;
 		cvt_iflock2flock(&ifl, flp);
-		SCARG(&fa, fd) = SCARG(uap, fd);
-		SCARG(&fa, cmd) = F_SETLKW;
-		SCARG(&fa, arg) = (/* XXX */ int)flp;
+		fa.fd = uap->fd;
+		fa.cmd = F_SETLKW;
+		fa.arg = (/* XXX */ int)flp;
 		return fcntl(td, &fa);
 	    }
 	}
Index: i386/ibcs2/ibcs2_ioctl.c
===================================================================
RCS file: /home/ncvs/src/sys/i386/ibcs2/ibcs2_ioctl.c,v
retrieving revision 1.25
diff -u -r1.25 ibcs2_ioctl.c
--- i386/ibcs2/ibcs2_ioctl.c	17 Aug 2002 02:36:16 -0000	1.25
+++ i386/ibcs2/ibcs2_ioctl.c	12 Dec 2002 03:14:38 -0000
@@ -346,7 +346,7 @@
 
 	if ((error = fget(td, uap->fd, &fp)) != 0) {
 		DPRINTF(("ibcs2_ioctl(%d): bad fd %d ", p->p_pid,
-			 SCARG(uap, fd)));
+			 uap->fd));
 		return EBADF;
 	}
 
@@ -356,7 +356,7 @@
 		return EBADF;
 	}
 
-	switch (SCARG(uap, cmd)) {
+	switch (uap->cmd) {
 	case IBCS2_TCGETA:
 	case IBCS2_XCGETA:
 	case IBCS2_OXCGETA:
@@ -370,9 +370,9 @@
 			break;
 	
 		btios2stios (&bts, &sts);
-		if (SCARG(uap, cmd) == IBCS2_TCGETA) {
+		if (uap->cmd == IBCS2_TCGETA) {
 			stios2stio (&sts, &st);
-			error = copyout((caddr_t)&st, SCARG(uap, data),
+			error = copyout((caddr_t)&st, uap->data,
 					sizeof (st));
 #ifdef DEBUG_IBCS2
 			if (error)
@@ -381,7 +381,7 @@
 #endif
 			break;
 		} else {
-			error = copyout((caddr_t)&sts, SCARG(uap, data),
+			error = copyout((caddr_t)&sts, uap->data,
 					sizeof (sts));
 			break;
 		}
@@ -396,7 +396,7 @@
 		struct ibcs2_termios sts;
 		struct ibcs2_termio st;
 
-		if ((error = copyin(SCARG(uap, data), (caddr_t)&st,
+		if ((error = copyin(uap->data, (caddr_t)&st,
 				    sizeof(st))) != 0) {
 			DPRINTF(("ibcs2_ioctl(%d): TCSET copyin failed ",
 				 p->p_pid));
@@ -407,7 +407,7 @@
 		if ((error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bts,
 		    td->td_ucred, td)) != 0) {
 			DPRINTF(("ibcs2_ioctl(%d): TCSET ctl failed fd %d ",
-				 p->p_pid, SCARG(uap, fd)));
+				 p->p_pid, uap->fd));
 			break;
 		}
 
@@ -419,7 +419,7 @@
 		stio2stios(&st, &sts);
 		stios2btios(&sts, &bts);
 
-		error = fo_ioctl(fp, SCARG(uap, cmd) - IBCS2_TCSETA + TIOCSETA,
+		error = fo_ioctl(fp, uap->cmd - IBCS2_TCSETA + TIOCSETA,
 			      (caddr_t)&bts, td->td_ucred, td);
 		break;
 	    }
@@ -431,11 +431,11 @@
 		struct termios bts;
 		struct ibcs2_termios sts;
 
-		if ((error = copyin(SCARG(uap, data), (caddr_t)&sts,
+		if ((error = copyin(uap->data, (caddr_t)&sts,
 				    sizeof (sts))) != 0)
 			break;
 		stios2btios (&sts, &bts);
-		error = fo_ioctl(fp, SCARG(uap, cmd) - IBCS2_XCSETA + TIOCSETA,
+		error = fo_ioctl(fp, uap->cmd - IBCS2_XCSETA + TIOCSETA,
 			      (caddr_t)&bts, td->td_ucred, td);
 		break;
 	    }
@@ -447,11 +447,11 @@
 		struct termios bts;
 		struct ibcs2_termios sts;
 
-		if ((error = copyin(SCARG(uap, data), (caddr_t)&sts,
+		if ((error = copyin(uap->data, (caddr_t)&sts,
 				    sizeof (sts))) != 0)
 			break;
 		stios2btios (&sts, &bts);
-		error = fo_ioctl(fp, SCARG(uap, cmd) - IBCS2_OXCSETA + TIOCSETA,
+		error = fo_ioctl(fp, uap->cmd - IBCS2_OXCSETA + TIOCSETA,
 			      (caddr_t)&bts, td->td_ucred, td);
 		break;
 	    }
@@ -463,7 +463,7 @@
 
 	case IBCS2_TCXONC:
 	    {
-		switch ((int)SCARG(uap, data)) {
+		switch ((int)uap->data) {
 		case 0:
 		case 1:
 			DPRINTF(("ibcs2_ioctl(%d): TCXONC ", p->p_pid));
@@ -488,7 +488,7 @@
 	    {
 		int arg;
 
-		switch ((int)SCARG(uap, data)) {
+		switch ((int)uap->data) {
 		case 0:
 			arg = FREAD;
 			break;
@@ -508,12 +508,12 @@
 	    }
 
 	case IBCS2_TIOCGWINSZ:
-		SCARG(uap, cmd) = TIOCGWINSZ;
+		uap->cmd = TIOCGWINSZ;
 		error = ioctl(td, (struct ioctl_args *)uap);
 		break;
 
 	case IBCS2_TIOCSWINSZ:
-		SCARG(uap, cmd) = TIOCSWINSZ;
+		uap->cmd = TIOCSWINSZ;
 		error = ioctl(td, (struct ioctl_args *)uap);
 		break;
 
@@ -524,7 +524,7 @@
 		PROC_LOCK(p);
 		pg_id = p->p_pgrp->pg_id;
 		PROC_UNLOCK(p);
-		error = copyout((caddr_t)&pg_id, SCARG(uap, data),
+		error = copyout((caddr_t)&pg_id, uap->data,
 				sizeof(pg_id));
 		break;
 	    }
@@ -533,8 +533,8 @@
 	    {
 		struct setpgid_args sa;
 
-		SCARG(&sa, pid) = 0;
-		SCARG(&sa, pgid) = (int)SCARG(uap, data);
+		sa.pid = 0;
+		sa.pgid = (int)uap->data;
 		error = setpgid(td, &sa);
 		break;
 	    }
@@ -566,111 +566,111 @@
 		  p->p_session->s_ttyp->t_winsize.ws_ypixel;
 		SESS_UNLOCK(p->p_session);
 		PROC_UNLOCK(p);
-	        error = copyout((caddr_t)&ibcs2_jwinsize, SCARG(uap, data),
+	        error = copyout((caddr_t)&ibcs2_jwinsize, uap->data,
 			       sizeof(ibcs2_jwinsize));
 		break;
 	     }
 
 	/* keyboard and display ioctl's -- type 'K' */
 	case IBCS2_KDGKBMODE:        /* get keyboard translation mode */
-	        SCARG(uap, cmd) = KDGKBMODE;
-/* printf("ioctl KDGKBMODE = %x\n", SCARG(uap, cmd));*/
+	        uap->cmd = KDGKBMODE;
+/* printf("ioctl KDGKBMODE = %x\n", uap->cmd);*/
 	        error = ioctl(td, (struct ioctl_args *)uap);
 		break;
 
 	case IBCS2_KDSKBMODE:        /* set keyboard translation mode */
-	        SCARG(uap, cmd) = KDSKBMODE;
+	        uap->cmd = KDSKBMODE;
 	        error = ioctl(td, (struct ioctl_args *)uap);
 		break;
 
 	case IBCS2_KDMKTONE:        /* sound tone */
-	        SCARG(uap, cmd) = KDMKTONE;
+	        uap->cmd = KDMKTONE;
 	        error = ioctl(td, (struct ioctl_args *)uap);
 		break;
 
 	case IBCS2_KDGETMODE:        /* get text/graphics mode */  
-	        SCARG(uap, cmd) = KDGETMODE;
+	        uap->cmd = KDGETMODE;
 	        error = ioctl(td, (struct ioctl_args *)uap);
 		break;
 
 	case IBCS2_KDSETMODE:       /* set text/graphics mode */
-	        SCARG(uap, cmd) = KDSETMODE;
+	        uap->cmd = KDSETMODE;
 	        error = ioctl(td, (struct ioctl_args *)uap);
 		break;
 
 	case IBCS2_KDSBORDER:       /* set ega color border */
-	        SCARG(uap, cmd) = KDSBORDER;
+	        uap->cmd = KDSBORDER;
 	        error = ioctl(td, (struct ioctl_args *)uap);
 		break;
 
 	case IBCS2_KDGKBSTATE:
-	        SCARG(uap, cmd) = KDGKBSTATE;
+	        uap->cmd = KDGKBSTATE;
 	        error = ioctl(td, (struct ioctl_args *)uap);
 		break;
 
 	case IBCS2_KDSETRAD:
-	        SCARG(uap, cmd) = KDSETRAD;
+	        uap->cmd = KDSETRAD;
 	        error = ioctl(td, (struct ioctl_args *)uap);
 		break;
 
 	case IBCS2_KDENABIO:       /* enable direct I/O to ports */
-	        SCARG(uap, cmd) = KDENABIO;
+	        uap->cmd = KDENABIO;
 	        error = ioctl(td, (struct ioctl_args *)uap);
 		break;
 
 	case IBCS2_KDDISABIO:       /* disable direct I/O to ports */
-	        SCARG(uap, cmd) = KDDISABIO;
+	        uap->cmd = KDDISABIO;
 	        error = ioctl(td, (struct ioctl_args *)uap);
 		break;
 
 	case IBCS2_KIOCSOUND:       /* start sound generation */
-	        SCARG(uap, cmd) = KIOCSOUND;
+	        uap->cmd = KIOCSOUND;
 	        error = ioctl(td, (struct ioctl_args *)uap);
 		break;
 
 	case IBCS2_KDGKBTYPE:       /* get keyboard type */
-	        SCARG(uap, cmd) = KDGKBTYPE;
+	        uap->cmd = KDGKBTYPE;
 	        error = ioctl(td, (struct ioctl_args *)uap);
 		break;
 
 	case IBCS2_KDGETLED:       /* get keyboard LED status */
-	        SCARG(uap, cmd) = KDGETLED;
+	        uap->cmd = KDGETLED;
 	        error = ioctl(td, (struct ioctl_args *)uap);
 		break;
 
 	case IBCS2_KDSETLED:       /* set keyboard LED status */
-	        SCARG(uap, cmd) = KDSETLED;
+	        uap->cmd = KDSETLED;
 	        error = ioctl(td, (struct ioctl_args *)uap);
 		break;
 
 	    /* Xenix keyboard and display ioctl's from sys/kd.h -- type 'k' */
 	case IBCS2_GETFKEY:      /* Get function key */
-	        SCARG(uap, cmd) = GETFKEY;
+	        uap->cmd = GETFKEY;
 	        error = ioctl(td, (struct ioctl_args *)uap);
 		break;
 
 	case IBCS2_SETFKEY:      /* Set function key */
-	        SCARG(uap, cmd) = SETFKEY;
+	        uap->cmd = SETFKEY;
 	        error = ioctl(td, (struct ioctl_args *)uap);
 		break;
 
 	case IBCS2_GIO_SCRNMAP:      /* Get screen output map table */
-	        SCARG(uap, cmd) = GIO_SCRNMAP;
+	        uap->cmd = GIO_SCRNMAP;
 	        error = ioctl(td, (struct ioctl_args *)uap);
 		break;
 
 	case IBCS2_PIO_SCRNMAP:      /* Set screen output map table */
-	        SCARG(uap, cmd) = PIO_SCRNMAP;
+	        uap->cmd = PIO_SCRNMAP;
 	        error = ioctl(td, (struct ioctl_args *)uap);
 		break;
 
 	case IBCS2_GIO_KEYMAP:      /* Get keyboard map table */
-	        SCARG(uap, cmd) = GIO_KEYMAP;
+	        uap->cmd = GIO_KEYMAP;
 	        error = ioctl(td, (struct ioctl_args *)uap);
 		break;
 
 	case IBCS2_PIO_KEYMAP:      /* Set keyboard map table */
-	        SCARG(uap, cmd) = PIO_KEYMAP;
+	        uap->cmd = PIO_KEYMAP;
 	        error = ioctl(td, (struct ioctl_args *)uap);
 		break;
 
@@ -681,13 +681,13 @@
 
 	case IBCS2_FIONREAD:
 	case IBCS2_I_NREAD:     /* STREAMS */
-	        SCARG(uap, cmd) = FIONREAD;
+	        uap->cmd = FIONREAD;
 		error = ioctl(td, (struct ioctl_args *)uap);
 		break;
 
 	default:
 		DPRINTF(("ibcs2_ioctl(%d): unknown cmd 0x%lx ",
-			 td->proc->p_pid, SCARG(uap, cmd)));
+			 td->proc->p_pid, uap->cmd));
 		error = ENOSYS;
 		break;
 	}
Index: i386/ibcs2/ibcs2_ipc.c
===================================================================
RCS file: /home/ncvs/src/sys/i386/ibcs2/ibcs2_ipc.c,v
retrieving revision 1.17
diff -u -r1.17 ibcs2_ipc.c
--- i386/ibcs2/ibcs2_ipc.c	20 Mar 2002 05:45:58 -0000	1.17
+++ i386/ibcs2/ibcs2_ipc.c	12 Dec 2002 03:14:38 -0000
@@ -106,32 +106,31 @@
 	struct thread *td;
 	struct ibcs2_msgsys_args *uap;
 {
-	switch (SCARG(uap, which)) {
+	switch (uap->which) {
 	case 0:				/* msgget */
-		SCARG(uap, which) = 1;
+		uap->which = 1;
 		return msgsys(td, (struct msgsys_args *)uap);
 	case 1: {			/* msgctl */
 		int error;
 		struct msgsys_args margs;
 		caddr_t sg = stackgap_init();
 
-		SCARG(&margs, which) = 0;
-		SCARG(&margs, a2) = SCARG(uap, a2);
-		SCARG(&margs, a4) =
+		margs.which = 0;
+		margs.a2 = uap->a2;
+		margs.a4 =
 		    (int)stackgap_alloc(&sg, sizeof(struct msqid_ds));
-		SCARG(&margs, a3) = SCARG(uap, a3);
-		switch (SCARG(&margs, a3)) {
+		margs.a3 = uap->a3;
+		switch (margs.a3) {
 		case IBCS2_IPC_STAT:
 			error = msgsys(td, &margs);
 			if (!error)
 				cvt_msqid2imsqid(
-				    (struct msqid_ds *)SCARG(&margs, a4),
-				    (struct ibcs2_msqid_ds *)SCARG(uap, a4));
+				    (struct msqid_ds *)margs.a4,
+				    (struct ibcs2_msqid_ds *)uap->a4);
 			return error;
 		case IBCS2_IPC_SET:
-			cvt_imsqid2msqid((struct ibcs2_msqid_ds *)SCARG(uap,
-									a4),
-					 (struct msqid_ds *)SCARG(&margs, a4));
+			cvt_imsqid2msqid((struct ibcs2_msqid_ds *)uap->a4,
+					 (struct msqid_ds *)margs.a4);
 			return msgsys(td, &margs);
 		case IBCS2_IPC_RMID:
 			return msgsys(td, &margs);
@@ -139,10 +138,10 @@
 		return EINVAL;
 	}
 	case 2:				/* msgrcv */
-		SCARG(uap, which) = 3;
+		uap->which = 3;
 		return msgsys(td, (struct msgsys_args *)uap);
 	case 3:				/* msgsnd */
-		SCARG(uap, which) = 2;
+		uap->which = 2;
 		return msgsys(td, (struct msgsys_args *)uap);
 	default:
 		return EINVAL;
@@ -239,9 +238,9 @@
 {
 	int error;
 
-	switch (SCARG(uap, which)) {
+	switch (uap->which) {
 	case 0:					/* semctl */
-		switch(SCARG(uap, a4)) {
+		switch(uap->a4) {
 		case IBCS2_IPC_STAT:
 		    {
 			struct ibcs2_semid_ds *isp;
@@ -250,14 +249,14 @@
 			caddr_t sg = stackgap_init();
 
 
-			ssu = (union semun) SCARG(uap, a5);
+			ssu = (union semun) uap->a5;
 			sp = stackgap_alloc(&sg, sizeof(struct semid_ds));
 			sup = stackgap_alloc(&sg, sizeof(union semun));
 			sup->buf = sp;
-			SCARG(uap, a5) = (int)sup;
+			uap->a5 = (int)sup;
 			error = semsys(td, (struct semsys_args *)uap);
 			if (!error) {
-				SCARG(uap, a5) = (int)ssu.buf;
+				uap->a5 = (int)ssu.buf;
 				isp = stackgap_alloc(&sg, sizeof(*isp));
 				cvt_semid2isemid(sp, isp);
 				error = copyout((caddr_t)isp,
@@ -274,12 +273,12 @@
 
 			isp = stackgap_alloc(&sg, sizeof(*isp));
 			sp = stackgap_alloc(&sg, sizeof(*sp));
-			error = copyin((caddr_t)SCARG(uap, a5), (caddr_t)isp,
+			error = copyin((caddr_t)uap->a5, (caddr_t)isp,
 				       sizeof(*isp));
 			if (error)
 				return error;
 			cvt_isemid2semid(isp, sp);
-			SCARG(uap, a5) = (int)sp;
+			uap->a5 = (int)sp;
 			return semsys(td, (struct semsys_args *)uap);
 		    }
 		case IBCS2_SETVAL:
@@ -288,8 +287,8 @@
 			caddr_t sg = stackgap_init();
 
 			sp = stackgap_alloc(&sg, sizeof(*sp));
-			sp->val = (int) SCARG(uap, a5);
-			SCARG(uap, a5) = (int)sp;
+			sp->val = (int) uap->a5;
+			uap->a5 = (int)sp;
 			return semsys(td, (struct semsys_args *)uap);
 		    }
 		}
@@ -351,28 +350,28 @@
 {
 	int error;
 
-	switch (SCARG(uap, which)) {
+	switch (uap->which) {
 	case 0:						/* shmat */
 		return shmsys(td, (struct shmsys_args *)uap);
 
 	case 1:						/* shmctl */
-		switch(SCARG(uap, a3)) {
+		switch(uap->a3) {
 		case IBCS2_IPC_STAT:
 		    {
 			struct ibcs2_shmid_ds *isp;
 			struct shmid_ds *sp;
 			caddr_t sg = stackgap_init();
 
-			isp = (struct ibcs2_shmid_ds *)SCARG(uap, a4);
+			isp = (struct ibcs2_shmid_ds *)uap->a4;
 			sp = stackgap_alloc(&sg, sizeof(*sp));
-			SCARG(uap, a4) = (int)sp;
+			uap->a4 = (int)sp;
 			error = shmsys(td, (struct shmsys_args *)uap);
 			if (!error) {
-				SCARG(uap, a4) = (int)isp;
+				uap->a4 = (int)isp;
 				isp = stackgap_alloc(&sg, sizeof(*isp));
 				cvt_shmid2ishmid(sp, isp);
 				error = copyout((caddr_t)isp,
-						(caddr_t)SCARG(uap, a4),
+						(caddr_t)uap->a4,
 						sizeof(*isp));
 			}
 			return error;
@@ -385,12 +384,12 @@
 
 			isp = stackgap_alloc(&sg, sizeof(*isp));
 			sp = stackgap_alloc(&sg, sizeof(*sp));
-			error = copyin((caddr_t)SCARG(uap, a4), (caddr_t)isp,
+			error = copyin((caddr_t)uap->a4, (caddr_t)isp,
 				       sizeof(*isp));
 			if (error)
 				return error;
 			cvt_ishmid2shmid(isp, sp);
-			SCARG(uap, a4) = (int)sp;
+			uap->a4 = (int)sp;
 			return shmsys(td, (struct shmsys_args *)uap);
 		    }
 		}
Index: i386/ibcs2/ibcs2_misc.c
===================================================================
RCS file: /home/ncvs/src/sys/i386/ibcs2/ibcs2_misc.c,v
retrieving revision 1.41
diff -u -r1.41 ibcs2_misc.c
--- i386/ibcs2/ibcs2_misc.c	12 Aug 2002 01:45:40 -0000	1.41
+++ i386/ibcs2/ibcs2_misc.c	12 Dec 2002 03:14:38 -0000
@@ -105,14 +105,14 @@
 #define IBCS2_GETPSIZE		3
 #define IBCS2_GETDTABLESIZE	4
 	
-	switch (SCARG(uap, cmd)) {
+	switch (uap->cmd) {
 	case IBCS2_GETFSIZE:
 		td->td_retval[0] = td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur;
 		if (td->td_retval[0] == -1) td->td_retval[0] = 0x7fffffff;
 		return 0;
 	case IBCS2_SETFSIZE:	/* XXX - fix this */
 #ifdef notyet
-		rl.rlim_cur = SCARG(uap, newlimit);
+		rl.rlim_cur = uap->newlimit;
 		sra.resource = RLIMIT_FSIZE;
 		sra.rlp = &rl;
 		error = setrlimit(td, &sra);
@@ -122,7 +122,7 @@
 			DPRINTF(("failed "));
 		return error;
 #else
-		td->td_retval[0] = SCARG(uap, newlimit);
+		td->td_retval[0] = uap->newlimit;
 		return 0;
 #endif
 	case IBCS2_GETPSIZE:
@@ -148,24 +148,24 @@
 	struct wait_args w4;
         struct trapframe *tf = td->td_frame;
 	
-	SCARG(&w4, rusage) = NULL;
+	w4.rusage = NULL;
         if ((tf->tf_eflags & (PSL_Z|PSL_PF|PSL_N|PSL_V))
             == (PSL_Z|PSL_PF|PSL_N|PSL_V)) {
 		/* waitpid */
-		SCARG(&w4, pid) = SCARG(uap, a1);
-		SCARG(&w4, status) = (int *)SCARG(uap, a2);
-		SCARG(&w4, options) = SCARG(uap, a3);
+		w4.pid = uap->a1;
+		w4.status = (int *)uap->a2;
+		w4.options = uap->a3;
 	} else {
 		/* wait */
-		SCARG(&w4, pid) = WAIT_ANY;
-		SCARG(&w4, status) = (int *)SCARG(uap, a1);
-		SCARG(&w4, options) = 0;
+		w4.pid = WAIT_ANY;
+		w4.status = (int *)uap->a1;
+		w4.options = 0;
 	}
 	if ((error = wait4(td, &w4)) != 0)
 		return error;
-	if (SCARG(&w4, status))	{	/* this is real iBCS brain-damage */
-		error = copyin((caddr_t)SCARG(&w4, status), (caddr_t)&status,
-			       sizeof(SCARG(&w4, status)));
+	if (w4.status)	{	/* this is real iBCS brain-damage */
+		error = copyin((caddr_t)w4.status, (caddr_t)&status,
+			       sizeof(w4.status));
 		if(error)
 		  return error;
 
@@ -179,8 +179,8 @@
 
 		/* record result/status */
 		td->td_retval[1] = status;
-		return copyout((caddr_t)&status, (caddr_t)SCARG(&w4, status),
-			       sizeof(SCARG(&w4, status)));
+		return copyout((caddr_t)&status, (caddr_t)w4.status,
+			       sizeof(w4.status));
 	}
 
 	return 0;
@@ -194,10 +194,10 @@
 	struct execve_args ea;
 	caddr_t sg = stackgap_init();
 
-        CHECKALTEXIST(td, &sg, SCARG(uap, path));
-	SCARG(&ea, fname) = SCARG(uap, path);
-	SCARG(&ea, argv) = SCARG(uap, argp);
-	SCARG(&ea, envv) = NULL;
+        CHECKALTEXIST(td, &sg, uap->path);
+	ea.fname = uap->path;
+	ea.argv = uap->argp;
+	ea.envv = NULL;
 	return execve(td, &ea);
 }
 
@@ -207,7 +207,7 @@
         struct ibcs2_execve_args *uap;
 {
         caddr_t sg = stackgap_init();
-        CHECKALTEXIST(td, &sg, SCARG(uap, path));
+        CHECKALTEXIST(td, &sg, uap->path);
         return execve(td, (struct execve_args *)uap);
 }
 
@@ -218,8 +218,8 @@
 {
 	struct unmount_args um;
 
-	SCARG(&um, path) = SCARG(uap, name);
-	SCARG(&um, flags) = 0;
+	um.path = uap->name;
+	um.flags = 0;
 	return unmount(td, &um);
 }
 
@@ -229,7 +229,7 @@
 	struct ibcs2_mount_args *uap;
 {
 #ifdef notyet
-	int oflags = SCARG(uap, flags), nflags, error;
+	int oflags = uap->flags, nflags, error;
 	char fsname[MFSNAMELEN];
 
 	if (oflags & (IBCS2_MS_NOSUB | IBCS2_MS_SYS5))
@@ -243,15 +243,15 @@
 		nflags |= MNT_NOSUID;
 	if (oflags & IBCS2_MS_REMOUNT)
 		nflags |= MNT_UPDATE;
-	SCARG(uap, flags) = nflags;
+	uap->flags = nflags;
 
-	if (error = copyinstr((caddr_t)SCARG(uap, type), fsname, sizeof fsname,
+	if (error = copyinstr((caddr_t)uap->type, fsname, sizeof fsname,
 			      (u_int *)0))
 		return (error);
 
 	if (strcmp(fsname, "4.2") == 0) {
-		SCARG(uap, type) = (caddr_t)STACK_ALLOC();
-		if (error = copyout("ufs", SCARG(uap, type), sizeof("ufs")))
+		uap->type = (caddr_t)STACK_ALLOC();
+		if (error = copyout("ufs", uap->type, sizeof("ufs")))
 			return (error);
 	} else if (strcmp(fsname, "nfs") == 0) {
 		struct ibcs2_nfs_args sna;
@@ -259,14 +259,14 @@
 		struct nfs_args na;
 		struct sockaddr sa;
 
-		if (error = copyin(SCARG(uap, data), &sna, sizeof sna))
+		if (error = copyin(uap->data, &sna, sizeof sna))
 			return (error);
 		if (error = copyin(sna.addr, &sain, sizeof sain))
 			return (error);
 		bcopy(&sain, &sa, sizeof sa);
 		sa.sa_len = sizeof(sain);
-		SCARG(uap, data) = (caddr_t)STACK_ALLOC();
-		na.addr = (struct sockaddr *)((int)SCARG(uap, data) + sizeof na);
+		uap->data = (caddr_t)STACK_ALLOC();
+		na.addr = (struct sockaddr *)((int)uap->data + sizeof na);
 		na.sotype = SOCK_DGRAM;
 		na.proto = IPPROTO_UDP;
 		na.fh = (nfsv2fh_t *)sna.fh;
@@ -279,7 +279,7 @@
 
 		if (error = copyout(&sa, na.addr, sizeof sa))
 			return (error);
-		if (error = copyout(&na, SCARG(uap, data), sizeof na))
+		if (error = copyout(&na, uap->data, sizeof na))
 			return (error);
 	}
 	return (mount(td, uap));
@@ -317,7 +317,7 @@
 #define	BSD_DIRENT(cp)		((struct dirent *)(cp))
 #define	IBCS2_RECLEN(reclen)	(reclen + sizeof(u_short))
 
-	if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0)
+	if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
 		return (error);
 	if ((fp->f_flag & FREAD) == 0) {
 		fdrop(fp, td);
@@ -331,7 +331,7 @@
 
 	off = fp->f_offset;
 #define	DIRBLKSIZ	512		/* XXX we used to use ufs's DIRBLKSIZ */
-	buflen = max(DIRBLKSIZ, SCARG(uap, nbytes));
+	buflen = max(DIRBLKSIZ, uap->nbytes);
 	buflen = min(buflen, MAXBSIZE);
 	buf = malloc(buflen, M_TEMP, M_WAITOK);
 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
@@ -364,8 +364,8 @@
 	if ((error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, &ncookies, &cookies)) != 0)
 		goto out;
 	inp = buf;
-	outp = SCARG(uap, buf);
-	resid = SCARG(uap, nbytes);
+	outp = uap->buf;
+	resid = uap->nbytes;
 	if ((len = buflen - auio.uio_resid) <= 0)
 		goto eof;
 
@@ -434,11 +434,11 @@
 		resid -= IBCS2_RECLEN(reclen);
 	}
 	/* if we squished out the whole block, try again */
-	if (outp == SCARG(uap, buf))
+	if (outp == uap->buf)
 		goto again;
 	fp->f_offset = off;		/* update the vnode offset */
 eof:
-	td->td_retval[0] = SCARG(uap, nbytes) - resid;
+	td->td_retval[0] = uap->nbytes - resid;
 out:
 	VOP_UNLOCK(vp, 0, td);
 	fdrop(fp, td);
@@ -470,7 +470,7 @@
 	u_long *cookies = NULL, *cookiep;
 	int ncookies;
 
-	if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) {
+	if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0) {
 		if (error == EINVAL)
 			return read(td, (struct read_args *)uap);
 		else
@@ -492,7 +492,7 @@
 
 	DPRINTF(("ibcs2_read: read directory\n"));
 
-	buflen = max(DIRBLKSIZ, SCARG(uap, nbytes));
+	buflen = max(DIRBLKSIZ, uap->nbytes);
 	buflen = min(buflen, MAXBSIZE);
 	buf = malloc(buflen, M_TEMP, M_WAITOK);
 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
@@ -527,8 +527,8 @@
 		goto out;
 	}
 	inp = buf;
-	outp = SCARG(uap, buf);
-	resid = SCARG(uap, nbytes);
+	outp = uap->buf;
+	resid = uap->nbytes;
 	if ((len = buflen - auio.uio_resid) <= 0)
 		goto eof;
 
@@ -599,11 +599,11 @@
 		resid -= sizeof(struct ibcs2_direct);
 	}
 	/* if we squished out the whole block, try again */
-	if (outp == SCARG(uap, buf))
+	if (outp == uap->buf)
 		goto again;
 	fp->f_offset = off;		/* update the vnode offset */
 eof:
-	td->td_retval[0] = SCARG(uap, nbytes) - resid;
+	td->td_retval[0] = uap->nbytes - resid;
 out:
 	VOP_UNLOCK(vp, 0, td);
 	fdrop(fp, td);
@@ -620,17 +620,17 @@
 {
         caddr_t sg = stackgap_init();
 
-        CHECKALTCREAT(td, &sg, SCARG(uap, path));
-	if (S_ISFIFO(SCARG(uap, mode))) {
+        CHECKALTCREAT(td, &sg, uap->path);
+	if (S_ISFIFO(uap->mode)) {
                 struct mkfifo_args ap;
-                SCARG(&ap, path) = SCARG(uap, path);
-                SCARG(&ap, mode) = SCARG(uap, mode);
+                ap.path = uap->path;
+                ap.mode = uap->mode;
 		return mkfifo(td, &ap);
 	} else {
                 struct mknod_args ap;
-                SCARG(&ap, path) = SCARG(uap, path);
-                SCARG(&ap, mode) = SCARG(uap, mode);
-                SCARG(&ap, dev) = SCARG(uap, dev);
+                ap.path = uap->path;
+                ap.mode = uap->mode;
+                ap.dev = uap->dev;
                 return mknod(td, &ap);
 	}
 }
@@ -646,22 +646,22 @@
 	gid_t *gp;
 	caddr_t sg = stackgap_init();
 
-	SCARG(&sa, gidsetsize) = SCARG(uap, gidsetsize);
-	if (SCARG(uap, gidsetsize)) {
-		SCARG(&sa, gidset) = stackgap_alloc(&sg, NGROUPS_MAX *
+	sa.gidsetsize = uap->gidsetsize;
+	if (uap->gidsetsize) {
+		sa.gidset = stackgap_alloc(&sg, NGROUPS_MAX *
 						    sizeof(gid_t *));
-		iset = stackgap_alloc(&sg, SCARG(uap, gidsetsize) *
+		iset = stackgap_alloc(&sg, uap->gidsetsize *
 				      sizeof(ibcs2_gid_t));
 	}
 	if ((error = getgroups(td, &sa)) != 0)
 		return error;
-	if (SCARG(uap, gidsetsize) == 0)
+	if (uap->gidsetsize == 0)
 		return 0;
 
-	for (i = 0, gp = SCARG(&sa, gidset); i < td->td_retval[0]; i++)
+	for (i = 0, gp = sa.gidset; i < td->td_retval[0]; i++)
 		iset[i] = (ibcs2_gid_t)*gp++;
 	if (td->td_retval[0] && (error = copyout((caddr_t)iset,
-					  (caddr_t)SCARG(uap, gidset),
+					  (caddr_t)uap->gidset,
 					  sizeof(ibcs2_gid_t) * td->td_retval[0])))
 		return error;
         return 0;
@@ -678,18 +678,18 @@
 	gid_t *gp;
 	caddr_t sg = stackgap_init();
 
-	SCARG(&sa, gidsetsize) = SCARG(uap, gidsetsize);
-	SCARG(&sa, gidset) = stackgap_alloc(&sg, SCARG(&sa, gidsetsize) *
+	sa.gidsetsize = uap->gidsetsize;
+	sa.gidset = stackgap_alloc(&sg, sa.gidsetsize *
 					    sizeof(gid_t *));
-	iset = stackgap_alloc(&sg, SCARG(&sa, gidsetsize) *
+	iset = stackgap_alloc(&sg, sa.gidsetsize *
 			      sizeof(ibcs2_gid_t *));
-	if (SCARG(&sa, gidsetsize)) {
-		if ((error = copyin((caddr_t)SCARG(uap, gidset), (caddr_t)iset, 
+	if (sa.gidsetsize) {
+		if ((error = copyin((caddr_t)uap->gidset, (caddr_t)iset, 
 				   sizeof(ibcs2_gid_t *) *
-				   SCARG(uap, gidsetsize))) != 0)
+				   uap->gidsetsize)) != 0)
 			return error;
 	}
-	for (i = 0, gp = SCARG(&sa, gidset); i < SCARG(&sa, gidsetsize); i++)
+	for (i = 0, gp = sa.gidset; i < sa.gidsetsize; i++)
 		*gp++ = (gid_t)iset[i];
 	return setgroups(td, &sa);
 }
@@ -701,7 +701,7 @@
 {
 	struct setuid_args sa;
 
-	SCARG(&sa, uid) = (uid_t)SCARG(uap, uid);
+	sa.uid = (uid_t)uap->uid;
 	return setuid(td, &sa);
 }
 
@@ -712,7 +712,7 @@
 {
 	struct setgid_args sa;
 
-	SCARG(&sa, gid) = (gid_t)SCARG(uap, gid);
+	sa.gid = (gid_t)uap->gid;
 	return setgid(td, &sa);
 }
 
@@ -725,8 +725,8 @@
 
 	microtime(&tv);
 	td->td_retval[0] = tv.tv_sec;
-	if (SCARG(uap, tp))
-		return copyout((caddr_t)&tv.tv_sec, (caddr_t)SCARG(uap, tp),
+	if (uap->tp)
+		return copyout((caddr_t)&tv.tv_sec, (caddr_t)uap->tp,
 			       sizeof(ibcs2_time_t));
 	else
 		return 0;
@@ -737,7 +737,7 @@
 	struct thread *td;
 	struct ibcs2_pathconf_args *uap;
 {
-	SCARG(uap, name)++;	/* iBCS2 _PC_* defines are offset by one */
+	uap->name++;	/* iBCS2 _PC_* defines are offset by one */
         return pathconf(td, (struct pathconf_args *)uap);
 }
 
@@ -746,7 +746,7 @@
 	struct thread *td;
 	struct ibcs2_fpathconf_args *uap;
 {
-	SCARG(uap, name)++;	/* iBCS2 _PC_* defines are offset by one */
+	uap->name++;	/* iBCS2 _PC_* defines are offset by one */
         return fpathconf(td, (struct fpathconf_args *)uap);
 }
 
@@ -759,7 +759,7 @@
 	struct sysctl_args sa;
 	struct __getrlimit_args ga;
 
-	switch(SCARG(uap, name)) {
+	switch(uap->name) {
 	case IBCS2_SC_ARG_MAX:
 		mib[1] = KERN_ARGMAX;
 		break;
@@ -768,11 +768,11 @@
 	    {
 		caddr_t sg = stackgap_init();
 
-		SCARG(&ga, which) = RLIMIT_NPROC;
-		SCARG(&ga, rlp) = stackgap_alloc(&sg, sizeof(struct rlimit *));
+		ga.which = RLIMIT_NPROC;
+		ga.rlp = stackgap_alloc(&sg, sizeof(struct rlimit *));
 		if ((error = getrlimit(td, &ga)) != 0)
 			return error;
-		td->td_retval[0] = SCARG(&ga, rlp)->rlim_cur;
+		td->td_retval[0] = ga.rlp->rlim_cur;
 		return 0;
 	    }
 
@@ -788,11 +788,11 @@
 	    {
 		caddr_t sg = stackgap_init();
 
-		SCARG(&ga, which) = RLIMIT_NOFILE;
-		SCARG(&ga, rlp) = stackgap_alloc(&sg, sizeof(struct rlimit *));
+		ga.which = RLIMIT_NOFILE;
+		ga.rlp = stackgap_alloc(&sg, sizeof(struct rlimit *));
 		if ((error = getrlimit(td, &ga)) != 0)
 			return error;
-		td->td_retval[0] = SCARG(&ga, rlp)->rlim_cur;
+		td->td_retval[0] = ga.rlp->rlim_cur;
 		return 0;
 	    }
 		
@@ -822,12 +822,12 @@
 
 	mib[0] = CTL_KERN;
 	len = sizeof(value);
-	SCARG(&sa, name) = mib;
-	SCARG(&sa, namelen) = 2;
-	SCARG(&sa, old) = &value;
-	SCARG(&sa, oldlenp) = &len;
-	SCARG(&sa, new) = NULL;
-	SCARG(&sa, newlen) = 0;
+	sa.name = mib;
+	sa.namelen = 2;
+	sa.old = &value;
+	sa.oldlenp = &len;
+	sa.new = NULL;
+	sa.newlen = 0;
 	if ((error = __sysctl(td, &sa)) != 0)
 		return error;
 	td->td_retval[0] = value;
@@ -847,12 +847,12 @@
         itp = stackgap_alloc(&sg, sizeof(*itp));
 	oitp = stackgap_alloc(&sg, sizeof(*oitp));
         timevalclear(&itp->it_interval);
-        itp->it_value.tv_sec = SCARG(uap, sec);
+        itp->it_value.tv_sec = uap->sec;
         itp->it_value.tv_usec = 0;
 
-	SCARG(&sa, which) = ITIMER_REAL;
-	SCARG(&sa, itv) = itp;
-	SCARG(&sa, oitv) = oitp;
+	sa.which = ITIMER_REAL;
+	sa.itv = itp;
+	sa.oitv = oitp;
         error = setitimer(td, &sa);
 	if (error)
 		return error;
@@ -875,15 +875,15 @@
         struct rusage *ru = stackgap_alloc(&sg, sizeof(*ru));
 #define CONVTCK(r)      (r.tv_sec * hz + r.tv_usec / (1000000 / hz))
 
-	SCARG(&ga, who) = RUSAGE_SELF;
-	SCARG(&ga, rusage) = ru;
+	ga.who = RUSAGE_SELF;
+	ga.rusage = ru;
 	error = getrusage(td, &ga);
 	if (error)
                 return error;
         tms.tms_utime = CONVTCK(ru->ru_utime);
         tms.tms_stime = CONVTCK(ru->ru_stime);
 
-	SCARG(&ga, who) = RUSAGE_CHILDREN;
+	ga.who = RUSAGE_CHILDREN;
         error = getrusage(td, &ga);
 	if (error)
 		return error;
@@ -893,7 +893,7 @@
 	microtime(&t);
         td->td_retval[0] = CONVTCK(t);
 	
-	return copyout((caddr_t)&tms, (caddr_t)SCARG(uap, tp),
+	return copyout((caddr_t)&tms, (caddr_t)uap->tp,
 		       sizeof(struct tms));
 }
 
@@ -906,12 +906,12 @@
 	struct settimeofday_args sa;
 	caddr_t sg = stackgap_init();
 
-	SCARG(&sa, tv) = stackgap_alloc(&sg, sizeof(*SCARG(&sa, tv)));
-	SCARG(&sa, tzp) = NULL;
-	if ((error = copyin((caddr_t)SCARG(uap, timep),
-			   &(SCARG(&sa, tv)->tv_sec), sizeof(long))) != 0)
+	sa.tv = stackgap_alloc(&sg, sizeof(*sa.tv));
+	sa.tzp = NULL;
+	if ((error = copyin((caddr_t)uap->timep,
+			   &(sa.tv->tv_sec), sizeof(long))) != 0)
 		return error;
-	SCARG(&sa, tv)->tv_usec = 0;
+	sa.tv->tv_usec = 0;
 	if ((error = settimeofday(td, &sa)) != 0)
 		return EPERM;
 	return 0;
@@ -927,24 +927,24 @@
 	struct timeval *tp;
 	caddr_t sg = stackgap_init();
 
-        CHECKALTEXIST(td, &sg, SCARG(uap, path));
-	SCARG(&sa, path) = SCARG(uap, path);
-	if (SCARG(uap, buf)) {
+        CHECKALTEXIST(td, &sg, uap->path);
+	sa.path = uap->path;
+	if (uap->buf) {
 		struct ibcs2_utimbuf ubuf;
 
-		if ((error = copyin((caddr_t)SCARG(uap, buf), (caddr_t)&ubuf,
+		if ((error = copyin((caddr_t)uap->buf, (caddr_t)&ubuf,
 				   sizeof(ubuf))) != 0)
 			return error;
-		SCARG(&sa, tptr) = stackgap_alloc(&sg,
+		sa.tptr = stackgap_alloc(&sg,
 						  2 * sizeof(struct timeval *));
-		tp = (struct timeval *)SCARG(&sa, tptr);
+		tp = (struct timeval *)sa.tptr;
 		tp->tv_sec = ubuf.actime;
 		tp->tv_usec = 0;
 		tp++;
 		tp->tv_sec = ubuf.modtime;
 		tp->tv_usec = 0;
 	} else
-		SCARG(&sa, tptr) = NULL;
+		sa.tptr = NULL;
 	return utimes(td, &sa);
 }
 
@@ -956,9 +956,9 @@
 	int error;
 	struct setpriority_args sa;
 
-	SCARG(&sa, which) = PRIO_PROCESS;
-	SCARG(&sa, who) = 0;
-	SCARG(&sa, prio) = td->td_ksegrp->kg_nice + SCARG(uap, incr);
+	sa.which = PRIO_PROCESS;
+	sa.who = 0;
+	sa.prio = td->td_ksegrp->kg_nice + uap->incr;
 	if ((error = setpriority(td, &sa)) != 0)
 		return EPERM;
 	td->td_retval[0] = td->td_ksegrp->kg_nice;
@@ -975,7 +975,7 @@
 	struct ibcs2_pgrpsys_args *uap;
 {
 	struct proc *p = td->td_proc;
-	switch (SCARG(uap, type)) {
+	switch (uap->type) {
 	case 0:			/* getpgrp */
 		PROC_LOCK(p);
 		td->td_retval[0] = p->p_pgrp->pg_id;
@@ -986,8 +986,8 @@
 	    {
 		struct setpgid_args sa;
 
-		SCARG(&sa, pid) = 0;
-		SCARG(&sa, pgid) = 0;
+		sa.pid = 0;
+		sa.pgid = 0;
 		setpgid(td, &sa);
 		PROC_LOCK(p);
 		td->td_retval[0] = p->p_pgrp->pg_id;
@@ -999,8 +999,8 @@
 	    {
 		struct setpgid_args sa;
 
-		SCARG(&sa, pid) = SCARG(uap, pid);
-		SCARG(&sa, pgid) = SCARG(uap, pgid);
+		sa.pid = uap->pid;
+		sa.pgid = uap->pgid;
 		return setpgid(td, &sa);
 	    }
 
@@ -1030,7 +1030,7 @@
 	
         if ((error = suser(td)) != 0)
                 return EPERM;
-	switch(SCARG(uap, cmd)) {
+	switch(uap->cmd) {
 	case IBCS2_UNLOCK:
 	case IBCS2_PROCLOCK:
 	case IBCS2_TEXTLOCK:
@@ -1066,10 +1066,10 @@
         if (suser(td))
                 return EPERM;
 
-	switch(SCARG(uap, cmd)) {
+	switch(uap->cmd) {
 	case SCO_A_REBOOT:
 	case SCO_A_SHUTDOWN:
-		switch(SCARG(uap, func)) {
+		switch(uap->func) {
 			struct reboot_args r;
 		case SCO_AD_HALT:
 		case SCO_AD_PWRDOWN:
@@ -1101,7 +1101,7 @@
 #define IBCS2_GETFSTYP        2
 #define IBCS2_GETNFSTYP       3
 
-	switch(SCARG(uap, cmd)) {
+	switch(uap->cmd) {
 	case IBCS2_GETFSIND:
 	case IBCS2_GETFSTYP:
 	case IBCS2_GETNFSTYP:
@@ -1117,7 +1117,7 @@
 {
         caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	CHECKALTEXIST(td, &sg, uap->path);
 	return unlink(td, (struct unlink_args *)uap);
 }
 
@@ -1128,7 +1128,7 @@
 {
         caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	CHECKALTEXIST(td, &sg, uap->path);
 	return chdir(td, (struct chdir_args *)uap);
 }
 
@@ -1139,7 +1139,7 @@
 {
         caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	CHECKALTEXIST(td, &sg, uap->path);
 	return chmod(td, (struct chmod_args *)uap);
 }
 
@@ -1150,7 +1150,7 @@
 {
         caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	CHECKALTEXIST(td, &sg, uap->path);
 	return chown(td, (struct chown_args *)uap);
 }
 
@@ -1161,7 +1161,7 @@
 {
         caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	CHECKALTEXIST(td, &sg, uap->path);
 	return rmdir(td, (struct rmdir_args *)uap);
 }
 
@@ -1172,7 +1172,7 @@
 {
         caddr_t sg = stackgap_init();
 
-	CHECKALTCREAT(td, &sg, SCARG(uap, path));
+	CHECKALTCREAT(td, &sg, uap->path);
 	return mkdir(td, (struct mkdir_args *)uap);
 }
 
@@ -1183,8 +1183,8 @@
 {
         caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
-	CHECKALTCREAT(td, &sg, SCARG(uap, link));
+	CHECKALTEXIST(td, &sg, uap->path);
+	CHECKALTCREAT(td, &sg, uap->link);
 	return symlink(td, (struct symlink_args *)uap);
 }
 
@@ -1195,8 +1195,8 @@
 {
         caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(td, &sg, SCARG(uap, from));
-	CHECKALTCREAT(td, &sg, SCARG(uap, to));
+	CHECKALTEXIST(td, &sg, uap->from);
+	CHECKALTCREAT(td, &sg, uap->to);
 	return rename(td, (struct rename_args *)uap);
 }
 
@@ -1207,6 +1207,6 @@
 {
         caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	CHECKALTEXIST(td, &sg, uap->path);
 	return readlink(td, (struct readlink_args *) uap);
 }
Index: i386/ibcs2/ibcs2_signal.c
===================================================================
RCS file: /home/ncvs/src/sys/i386/ibcs2/ibcs2_signal.c,v
retrieving revision 1.25
diff -u -r1.25 ibcs2_signal.c
--- i386/ibcs2/ibcs2_signal.c	1 Oct 2002 17:15:51 -0000	1.25
+++ i386/ibcs2/ibcs2_signal.c	12 Dec 2002 03:14:38 -0000
@@ -199,8 +199,8 @@
 	int error;
 
 	sg = stackgap_init();
-	nisa = SCARG(uap, act);
-	oisa = SCARG(uap, oact);
+	nisa = uap->act;
+	oisa = uap->oact;
 
 	if (oisa != NULL)
 		obsa = stackgap_alloc(&sg, sizeof(struct sigaction));
@@ -217,9 +217,9 @@
 	} else
 		nbsa = NULL;
 
-	SCARG(&sa, sig) = ibcs2_to_bsd_sig[_SIG_IDX(SCARG(uap, sig))];
-	SCARG(&sa, act) = nbsa;
-	SCARG(&sa, oact) = obsa;
+	sa.sig = ibcs2_to_bsd_sig[_SIG_IDX(uap->sig)];
+	sa.act = nbsa;
+	sa.oact = obsa;
 
 	if ((error = sigaction(td, &sa)) != 0)
 		return error;
@@ -242,24 +242,24 @@
 {
 	struct proc *p = td->td_proc;
 	struct sigaction sa;
-	int signum = ibcs2_to_bsd_sig[_SIG_IDX(IBCS2_SIGNO(SCARG(uap, sig)))];
+	int signum = ibcs2_to_bsd_sig[_SIG_IDX(IBCS2_SIGNO(uap->sig))];
 	int error;
 	caddr_t sg = stackgap_init();
 
 	if (signum <= 0 || signum >= IBCS2_NSIG) {
-		if (IBCS2_SIGCALL(SCARG(uap, sig)) == IBCS2_SIGNAL_MASK ||
-		    IBCS2_SIGCALL(SCARG(uap, sig)) == IBCS2_SIGSET_MASK)
+		if (IBCS2_SIGCALL(uap->sig) == IBCS2_SIGNAL_MASK ||
+		    IBCS2_SIGCALL(uap->sig) == IBCS2_SIGSET_MASK)
 			td->td_retval[0] = (int)IBCS2_SIG_ERR;
 		return EINVAL;
 	}
 	
-	switch (IBCS2_SIGCALL(SCARG(uap, sig))) {
+	switch (IBCS2_SIGCALL(uap->sig)) {
 	case IBCS2_SIGSET_MASK:
 		/*
 		 * Check for SIG_HOLD action.
 		 * Otherwise, perform signal() except with different sa_flags.
 		 */
-		if (SCARG(uap, fp) != IBCS2_SIG_HOLD) {
+		if (uap->fp != IBCS2_SIG_HOLD) {
 			/* add sig to mask before exececuting signal handler */
 			sa.sa_flags = 0;
 			goto ibcs2_sigset;
@@ -273,9 +273,9 @@
 
 			SIGEMPTYSET(mask);
 			SIGADDSET(mask, signum);
-			SCARG(&sa, how) = SIG_BLOCK;
-			SCARG(&sa, set) = &mask;
-			SCARG(&sa, oset) = NULL;
+			sa.how = SIG_BLOCK;
+			sa.set = &mask;
+			sa.oset = NULL;
 			return sigprocmask(td, &sa);
 		}
 		
@@ -296,11 +296,11 @@
 		ibcs2_sigset:
 			nbsa = stackgap_alloc(&sg, sizeof(struct sigaction));
 			obsa = stackgap_alloc(&sg, sizeof(struct sigaction));
-			SCARG(&sa_args, sig) = signum;
-			SCARG(&sa_args, act) = nbsa;
-			SCARG(&sa_args, oact) = obsa;
+			sa_args.sig = signum;
+			sa_args.act = nbsa;
+			sa_args.oact = obsa;
 
-			sa.sa_handler = SCARG(uap, fp);
+			sa.sa_handler = uap->fp;
 			sigemptyset(&sa.sa_mask);
 #if 0
 			if (signum != SIGALRM)
@@ -321,7 +321,7 @@
 			td->td_retval[0] = (int)sa.sa_handler;
 
 			/* special sigset() check */
-                        if(IBCS2_SIGCALL(SCARG(uap, sig)) == IBCS2_SIGSET_MASK) {
+                        if(IBCS2_SIGCALL(uap->sig) == IBCS2_SIGSET_MASK) {
 				PROC_LOCK(p);
 			        /* check to make sure signal is not blocked */
                                 if(sigismember(&p->p_sigmask, signum)) {
@@ -343,9 +343,9 @@
 
 			SIGEMPTYSET(mask);
 			SIGADDSET(mask, signum);
-			SCARG(&sa, how) = SIG_UNBLOCK;
-			SCARG(&sa, set) = &mask;
-			SCARG(&sa, oset) = NULL;
+			sa.how = SIG_UNBLOCK;
+			sa.set = &mask;
+			sa.oset = NULL;
 			return sigprocmask(td, &sa);
 		}
 		
@@ -355,9 +355,9 @@
 			struct sigaction *bsa;
 
 			bsa = stackgap_alloc(&sg, sizeof(struct sigaction));
-			SCARG(&sa_args, sig) = signum;
-			SCARG(&sa_args, act) = bsa;
-			SCARG(&sa_args, oact) = NULL;
+			sa_args.sig = signum;
+			sa_args.act = bsa;
+			sa_args.oact = NULL;
 
 			sa.sa_handler = SIG_IGN;
 			sigemptyset(&sa.sa_mask);
@@ -380,7 +380,7 @@
 			mask = p->p_sigmask;
 			PROC_UNLOCK(p);
 			SIGDELSET(mask, signum);
-			SCARG(&sa, sigmask) = &mask;
+			sa.sigmask = &mask;
 			return sigsuspend(td, &sa);
 		}
 		
@@ -399,27 +399,27 @@
 	sigset_t bss;
 	int error = 0;
 
-	if (SCARG(uap, oset) != NULL) {
+	if (uap->oset != NULL) {
 		/* Fix the return value first if needed */
 		PROC_LOCK(p);
 		bsd_to_ibcs2_sigset(&p->p_sigmask, &iss);
 		PROC_UNLOCK(p);
-		if ((error = copyout(&iss, SCARG(uap, oset), sizeof(iss))) != 0)
+		if ((error = copyout(&iss, uap->oset, sizeof(iss))) != 0)
 			return error;
 	}
 		
-	if (SCARG(uap, set) == NULL)
+	if (uap->set == NULL)
 		/* Just examine */
 		return 0;
 
-	if ((error = copyin(SCARG(uap, set), &iss, sizeof(iss))) != 0)
+	if ((error = copyin(uap->set, &iss, sizeof(iss))) != 0)
 		return error;
 
 	ibcs2_to_bsd_sigset(&iss, &bss);
 
 	PROC_LOCK(p);
 
-	switch (SCARG(uap, how)) {
+	switch (uap->how) {
 	case IBCS2_SIG_BLOCK:
 		SIGSETOR(p->p_sigmask, bss);
 		SIG_CANTMASK(p->p_sigmask);
@@ -461,7 +461,7 @@
 	PROC_UNLOCK(p);
 	bsd_to_ibcs2_sigset(&bss, &iss);
 
-	return copyout(&iss, SCARG(uap, mask), sizeof(iss));
+	return copyout(&iss, uap->mask, sizeof(iss));
 }
 
 int
@@ -474,11 +474,11 @@
 	struct sigsuspend_args sa;
 	int error;
 
-	if ((error = copyin(SCARG(uap, mask), &sss, sizeof(sss))) != 0)
+	if ((error = copyin(uap->mask, &sss, sizeof(sss))) != 0)
 		return error;
 
 	ibcs2_to_bsd_sigset(&sss, &bss);
-	SCARG(&sa, sigmask) = &bss;
+	sa.sigmask = &bss;
 	return sigsuspend(td, &sa);
 }
 
@@ -494,7 +494,7 @@
 	PROC_LOCK(p);
 	mask = td->td_proc->p_sigmask;
 	PROC_UNLOCK(p);
-	SCARG(&sa, sigmask) = &mask;
+	sa.sigmask = &mask;
 	return sigsuspend(td, &sa);
 }
 
@@ -505,7 +505,7 @@
 {
 	struct kill_args ka;
 
-	SCARG(&ka, pid) = SCARG(uap, pid);
-	SCARG(&ka, signum) = ibcs2_to_bsd_sig[_SIG_IDX(SCARG(uap, signo))];
+	ka.pid = uap->pid;
+	ka.signum = ibcs2_to_bsd_sig[_SIG_IDX(uap->signo)];
 	return kill(td, &ka);
 }
Index: i386/ibcs2/ibcs2_stat.c
===================================================================
RCS file: /home/ncvs/src/sys/i386/ibcs2/ibcs2_stat.c,v
retrieving revision 1.16
diff -u -r1.16 ibcs2_stat.c
--- i386/ibcs2/ibcs2_stat.c	20 Mar 2002 05:45:58 -0000	1.16
+++ i386/ibcs2/ibcs2_stat.c	12 Dec 2002 03:14:38 -0000
@@ -106,8 +106,8 @@
 	struct nameidata nd;
 	caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
-	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td);
+	CHECKALTEXIST(td, &sg, uap->path);
+	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, td);
 	if ((error = namei(&nd)) != 0)
 		return (error);
 	NDFREE(&nd, NDF_ONLY_PNBUF);
@@ -117,7 +117,7 @@
 	if ((error = VFS_STATFS(mp, sp, td)) != 0)
 		return (error);
 	sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
-	return cvt_statfs(sp, (caddr_t)SCARG(uap, buf), SCARG(uap, len));
+	return cvt_statfs(sp, (caddr_t)uap->buf, uap->len);
 }
 
 int
@@ -130,7 +130,7 @@
 	register struct statfs *sp;
 	int error;
 
-	if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0)
+	if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
 		return (error);
 	mp = ((struct vnode *)fp->f_data)->v_mount;
 	sp = &mp->mnt_stat;
@@ -139,7 +139,7 @@
 	if (error != 0)
 		return (error);
 	sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
-	return cvt_statfs(sp, (caddr_t)SCARG(uap, buf), SCARG(uap, len));
+	return cvt_statfs(sp, (caddr_t)uap->buf, uap->len);
 }
 
 int
@@ -153,17 +153,17 @@
 	int error;
 	caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
-	SCARG(&cup, path) = SCARG(uap, path);
-	SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(st));
+	CHECKALTEXIST(td, &sg, uap->path);
+	cup.path = uap->path;
+	cup.ub = stackgap_alloc(&sg, sizeof(st));
 
 	if ((error = stat(td, &cup)) != 0)
 		return error;
 
-	if ((error = copyin(SCARG(&cup, ub), &st, sizeof(st))) != 0)
+	if ((error = copyin(cup.ub, &st, sizeof(st))) != 0)
 		return error;
 	bsd_stat2ibcs_stat(&st, &ibcs2_st);
-	return copyout((caddr_t)&ibcs2_st, (caddr_t)SCARG(uap, st),
+	return copyout((caddr_t)&ibcs2_st, (caddr_t)uap->st,
 		       ibcs2_stat_len);
 }
 
@@ -178,17 +178,17 @@
 	int error;
 	caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
-	SCARG(&cup, path) = SCARG(uap, path);
-	SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(st));
+	CHECKALTEXIST(td, &sg, uap->path);
+	cup.path = uap->path;
+	cup.ub = stackgap_alloc(&sg, sizeof(st));
 
 	if ((error = lstat(td, &cup)) != 0)
 		return error;
 
-	if ((error = copyin(SCARG(&cup, ub), &st, sizeof(st))) != 0)
+	if ((error = copyin(cup.ub, &st, sizeof(st))) != 0)
 		return error;
 	bsd_stat2ibcs_stat(&st, &ibcs2_st);
-	return copyout((caddr_t)&ibcs2_st, (caddr_t)SCARG(uap, st),
+	return copyout((caddr_t)&ibcs2_st, (caddr_t)uap->st,
 		       ibcs2_stat_len);
 }
 
@@ -203,16 +203,16 @@
 	int error;
 	caddr_t sg = stackgap_init();
 
-	SCARG(&cup, fd) = SCARG(uap, fd);
-	SCARG(&cup, sb) = stackgap_alloc(&sg, sizeof(st));
+	cup.fd = uap->fd;
+	cup.sb = stackgap_alloc(&sg, sizeof(st));
 
 	if ((error = fstat(td, &cup)) != 0)
 		return error;
 
-	if ((error = copyin(SCARG(&cup, sb), &st, sizeof(st))) != 0)
+	if ((error = copyin(cup.sb, &st, sizeof(st))) != 0)
 		return error;
 	bsd_stat2ibcs_stat(&st, &ibcs2_st);
-	return copyout((caddr_t)&ibcs2_st, (caddr_t)SCARG(uap, st),
+	return copyout((caddr_t)&ibcs2_st, (caddr_t)uap->st,
 		       ibcs2_stat_len);
 }
 
@@ -221,7 +221,7 @@
 	struct thread *td;
 	struct ibcs2_utssys_args *uap;
 {
-	switch (SCARG(uap, flag)) {
+	switch (uap->flag) {
 	case 0:			/* uname(2) */
 	{
 		char machine_name[9], *p;
@@ -245,7 +245,7 @@
 		DPRINTF(("IBCS2 uname: sys=%s rel=%s ver=%s node=%s mach=%s\n",
 			 sut.sysname, sut.release, sut.version, sut.nodename,
 			 sut.machine));
-		return copyout((caddr_t)&sut, (caddr_t)SCARG(uap, a1),
+		return copyout((caddr_t)&sut, (caddr_t)uap->a1,
 			       ibcs2_utsname_len);
 	}
 
Index: i386/ibcs2/ibcs2_sysi86.c
===================================================================
RCS file: /home/ncvs/src/sys/i386/ibcs2/ibcs2_sysi86.c,v
retrieving revision 1.16
diff -u -r1.16 ibcs2_sysi86.c
--- i386/ibcs2/ibcs2_sysi86.c	2 Jun 2002 20:05:48 -0000	1.16
+++ i386/ibcs2/ibcs2_sysi86.c	12 Dec 2002 03:14:38 -0000
@@ -53,14 +53,14 @@
 int
 ibcs2_sysi86(struct thread *td, struct ibcs2_sysi86_args *args)
 {
-	switch (SCARG(args, cmd)) {
+	switch (args->cmd) {
 	case SI86_FPHW: {	/* Floating Point information */
 		int val, error;
 
 		if (hw_float) val = IBCS2_FP_387;	/* FPU hardware */
 		else val = IBCS2_FP_SW;			/* FPU emulator */
 			
-		if ((error = copyout(&val, SCARG(args, arg), sizeof(val))) != 0)
+		if ((error = copyout(&val, args->arg, sizeof(val))) != 0)
 			return error;
 		return 0;
 		}
@@ -78,7 +78,7 @@
 		name[0] = CTL_KERN;
 		name[1] = KERN_HOSTNAME;
 		return (userland_sysctl(td, name, 2, 0, 0, 0, 
-			SCARG(args, arg), 7, 0));
+			args->arg, 7, 0));
 	}
 
 	case SI86_MEM:	/* size of physical memory */
@@ -88,7 +88,7 @@
 	default:
 #ifdef DIAGNOSTIC
 		printf("IBCS2: 'sysi86' function %d(0x%x) "
-			"not implemented yet\n", SCARG(args, cmd), args->cmd);
+			"not implemented yet\n", args->cmd, args->cmd);
 #endif
 		return EINVAL;
 	}
Index: i386/ibcs2/ibcs2_util.h
===================================================================
RCS file: /home/ncvs/src/sys/i386/ibcs2/ibcs2_util.h,v
retrieving revision 1.13
diff -u -r1.13 ibcs2_util.h
--- i386/ibcs2/ibcs2_util.h	20 Mar 2002 05:45:58 -0000	1.13
+++ i386/ibcs2/ibcs2_util.h	12 Dec 2002 03:14:38 -0000
@@ -52,10 +52,6 @@
 #include <sys/sysent.h>
 #include <sys/proc.h>
 
-#ifndef SCARG
-#define SCARG(p, x)  (p)->x
-#endif
-
 static __inline caddr_t stackgap_init(void);
 static __inline void *stackgap_alloc(caddr_t *, size_t);
 
Index: i386/ibcs2/ibcs2_xenix.c
===================================================================
RCS file: /home/ncvs/src/sys/i386/ibcs2/ibcs2_xenix.c,v
retrieving revision 1.28
diff -u -r1.28 ibcs2_xenix.c
--- i386/ibcs2/ibcs2_xenix.c	23 Sep 2002 18:54:31 -0000	1.28
+++ i386/ibcs2/ibcs2_xenix.c	12 Dec 2002 03:14:38 -0000
@@ -79,12 +79,12 @@
 	caddr_t sg = stackgap_init();
 
 	DPRINTF(("IBCS2: 'xenix rdchk'\n"));
-	SCARG(&sa, fd) = SCARG(uap, fd);
-	SCARG(&sa, com) = FIONREAD;
-	SCARG(&sa, data) = stackgap_alloc(&sg, sizeof(int));
+	sa.fd = uap->fd;
+	sa.com = FIONREAD;
+	sa.data = stackgap_alloc(&sg, sizeof(int));
 	if ((error = ioctl(td, &sa)) != 0)
 		return error;
-	td->td_retval[0] = (*((int*)SCARG(&sa, data))) ? 1 : 0;
+	td->td_retval[0] = (*((int*)sa.data)) ? 1 : 0;
 	return 0;
 }
 
@@ -96,9 +96,9 @@
 	struct ftruncate_args sa;
 
 	DPRINTF(("IBCS2: 'xenix chsize'\n"));
-	SCARG(&sa, fd) = SCARG(uap, fd);
-	SCARG(&sa, pad) = 0;
-	SCARG(&sa, length) = SCARG(uap, size);
+	sa.fd = uap->fd;
+	sa.pad = 0;
+	sa.length = uap->size;
 	return ftruncate(td, &sa);
 }
 
@@ -123,7 +123,7 @@
 	itb.timezone = tz.tz_minuteswest;
 	itb.dstflag = tz.tz_dsttime != DST_NONE;
 
-	return copyout((caddr_t)&itb, (caddr_t)SCARG(uap, tp),
+	return copyout((caddr_t)&itb, (caddr_t)uap->tp,
 		       sizeof(struct ibcs2_timeb));
 }
 
@@ -132,8 +132,8 @@
 {
 	long period;
 
-	DPRINTF(("IBCS2: 'xenix nap %d ms'\n", SCARG(uap, millisec)));
-	period = (long)SCARG(uap, millisec) / (1000/hz);
+	DPRINTF(("IBCS2: 'xenix nap %d ms'\n", uap->millisec));
+	period = (long)uap->millisec / (1000/hz);
 	if (period)
 		while (tsleep(&period, PPAUSE, "nap", period) 
 		       != EWOULDBLOCK) ;
@@ -200,22 +200,22 @@
         int error, flags;
 	caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	CHECKALTEXIST(td, &sg, uap->path);
 
         NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
-            SCARG(uap, path), td);
+            uap->path, td);
         if ((error = namei(&nd)) != 0)
                 return error;
         vp = nd.ni_vp;
 
         /* Flags == 0 means only check for existence. */
-        if (SCARG(uap, flags)) {
+        if (uap->flags) {
                 flags = 0;
-                if (SCARG(uap, flags) & IBCS2_R_OK)
+                if (uap->flags & IBCS2_R_OK)
                         flags |= VREAD;
-                if (SCARG(uap, flags) & IBCS2_W_OK)
+                if (uap->flags & IBCS2_W_OK)
                         flags |= VWRITE;
-                if (SCARG(uap, flags) & IBCS2_X_OK)
+                if (uap->flags & IBCS2_X_OK)
                         flags |= VEXEC;
                 if ((flags & VWRITE) == 0 || (error = vn_writechk(vp)) == 0)
                         error = VOP_ACCESS(vp, flags, cred, td);
Index: i386/svr4/svr4_machdep.c
===================================================================
RCS file: /home/ncvs/src/sys/i386/svr4/svr4_machdep.c,v
retrieving revision 1.26
diff -u -r1.26 svr4_machdep.c
--- i386/svr4/svr4_machdep.c	4 Apr 2002 17:49:46 -0000	1.26
+++ i386/svr4/svr4_machdep.c	12 Dec 2002 03:14:38 -0000
@@ -535,7 +535,7 @@
 			struct svr4_ssd ssd;
 			union descriptor bsd;
 
-			if ((error = copyin(SCARG(uap, a1), &ssd,
+			if ((error = copyin(uap->a1, &ssd,
 					    sizeof(ssd))) != 0) {
 				printf("Cannot copy arg1\n");
 				return error;
@@ -580,8 +580,8 @@
 				return error;
 			}
 
-			SCARG(&ua, op) = I386_SET_LDT;
-			SCARG(&ua, parms) = (char *) sap;
+			ua.op = I386_SET_LDT;
+			ua.parms = (char *) sap;
 
 			if ((error = copyout(&bsd, sa.desc, sizeof(bsd))) != 0) {
 				printf("Cannot copyout desc\n");
Index: ia64/ia32/ia32_misc.c
===================================================================
RCS file: /home/ncvs/src/sys/ia64/ia32/ia32_misc.c,v
retrieving revision 1.2
diff -u -r1.2 ia32_misc.c
--- ia64/ia32/ia32_misc.c	9 Oct 2002 22:27:24 -0000	1.2
+++ ia64/ia32/ia32_misc.c	12 Dec 2002 03:14:38 -0000
@@ -237,11 +237,11 @@
 	struct rusage32 *rusage32, ru32;
 	struct rusage *rusage = NULL, ru;
 
-	rusage32 = SCARG(uap, rusage);
+	rusage32 = uap->rusage;
 	if (rusage32) {
 		sg = stackgap_init();
 		rusage = stackgap_alloc(&sg, sizeof(struct rusage));
-		SCARG(uap, rusage) = (struct rusage32 *)rusage;
+		uap->rusage = (struct rusage32 *)rusage;
 	}
 	error = wait4(td, (struct wait_args *)uap);
 	if (error)
@@ -304,13 +304,13 @@
 	struct statfs *sp = NULL, stat;
 	int maxcount, count, i;
 
-	sp32 = SCARG(uap, buf);
-	maxcount = SCARG(uap, bufsize) / sizeof(struct statfs32);
+	sp32 = uap->buf;
+	maxcount = uap->bufsize / sizeof(struct statfs32);
 
 	if (sp32) {
 		sg = stackgap_init();
 		sp = stackgap_alloc(&sg, sizeof(struct statfs) * maxcount);
-		SCARG(uap, buf) = (struct statfs32 *)sp;
+		uap->buf = (struct statfs32 *)sp;
 	}
 	error = getfsstat(td, (struct getfsstat_args *) uap);
 	if (sp32 && !error) {
@@ -364,11 +364,11 @@
 	struct sigaltstack32 *p32, *op32, s32;
 	struct sigaltstack *p = NULL, *op = NULL, s;
 
-	p32 = SCARG(uap, ss);
+	p32 = uap->ss;
 	if (p32) {
 		sg = stackgap_init();
 		p = stackgap_alloc(&sg, sizeof(struct sigaltstack));
-		SCARG(uap, ss) = (struct sigaltstack32 *)p;
+		uap->ss = (struct sigaltstack32 *)p;
 		error = copyin(p32, &s32, sizeof(s32));
 		if (error)
 			return (error);
@@ -379,11 +379,11 @@
 		if (error)
 			return (error);
 	}
-	op32 = SCARG(uap, oss);
+	op32 = uap->oss;
 	if (op32) {
 		sg = stackgap_init();
 		op = stackgap_alloc(&sg, sizeof(struct sigaltstack));
-		SCARG(uap, oss) = (struct sigaltstack32 *)op;
+		uap->oss = (struct sigaltstack32 *)op;
 	}
 	error = sigaltstack(td, (struct sigaltstack_args *) uap);
 	if (error)
@@ -411,12 +411,12 @@
 	int count;
 
 	sg = stackgap_init();
-	CHECKALTEXIST(td, &sg, SCARG(uap, fname));
-	SCARG(&ap, fname) = SCARG(uap, fname);
+	CHECKALTEXIST(td, &sg, uap->fname);
+	ap.fname = uap->fname;
 
-	if (SCARG(uap, argv)) {
+	if (uap->argv) {
 		count = 0;
-		p32 = SCARG(uap, argv);
+		p32 = uap->argv;
 		do {
 			error = copyin(p32++, &arg, sizeof(arg));
 			if (error)
@@ -424,8 +424,8 @@
 			count++;
 		} while (arg != 0);
 		p = stackgap_alloc(&sg, count * sizeof(char *));
-		SCARG(&ap, argv) = p;
-		p32 = SCARG(uap, argv);
+		ap.argv = p;
+		p32 = uap->argv;
 		do {
 			error = copyin(p32++, &arg, sizeof(arg));
 			if (error)
@@ -433,9 +433,9 @@
 			*p++ = PTRIN(arg);
 		} while (arg != 0);
 	}
-	if (SCARG(uap, envv)) {
+	if (uap->envv) {
 		count = 0;
-		p32 = SCARG(uap, envv);
+		p32 = uap->envv;
 		do {
 			error = copyin(p32++, &arg, sizeof(arg));
 			if (error)
@@ -443,8 +443,8 @@
 			count++;
 		} while (arg != 0);
 		p = stackgap_alloc(&sg, count * sizeof(char *));
-		SCARG(&ap, envv) = p;
-		p32 = SCARG(uap, envv);
+		ap.envv = p;
+		p32 = uap->envv;
 		do {
 			error = copyin(p32++, &arg, sizeof(arg));
 			if (error)
@@ -489,10 +489,10 @@
 
 	if (fd != -1) {
 		struct pread_args r;
-		SCARG(&r, fd) = fd;
-		SCARG(&r, buf) = (void *) start;
-		SCARG(&r, nbyte) = end - start;
-		SCARG(&r, offset) = pos;
+		r.fd = fd;
+		r.buf = (void *) start;
+		r.nbyte = end - start;
+		r.offset = pos;
 		return (pread(td, &r));
 	} else {
 		while (start < end) {
@@ -507,13 +507,13 @@
 ia32_mmap(struct thread *td, struct ia32_mmap_args *uap)
 {
 	struct mmap_args ap;
-	vm_offset_t addr = (vm_offset_t) SCARG(uap, addr);
-	vm_size_t len	 = SCARG(uap, len);
-	int prot	 = SCARG(uap, prot);
-	int flags	 = SCARG(uap, flags);
-	int fd		 = SCARG(uap, fd);
-	off_t pos	 = (SCARG(uap, poslo)
-			    | ((off_t)SCARG(uap, poshi) << 32));
+	vm_offset_t addr = (vm_offset_t) uap->addr;
+	vm_size_t len	 = uap->len;
+	int prot	 = uap->prot;
+	int flags	 = uap->flags;
+	int fd		 = uap->fd;
+	off_t pos	 = (uap->poslo
+			    | ((off_t)uap->poshi << 32));
 	vm_size_t pageoff;
 	int error;
 
@@ -562,10 +562,10 @@
 					 prot, VM_PROT_ALL, 0);
 			if (rv != KERN_SUCCESS)
 				return (EINVAL);
-			SCARG(&r, fd) = fd;
-			SCARG(&r, buf) = (void *) start;
-			SCARG(&r, nbyte) = end - start;
-			SCARG(&r, offset) = pos;
+			r.fd = fd;
+			r.buf = (void *) start;
+			r.nbyte = end - start;
+			r.offset = pos;
 			error = pread(td, &r);
 			if (error)
 				return (error);
@@ -585,12 +585,12 @@
 		len = end - start;
 	}
 
-	SCARG(&ap, addr) = (void *) addr;
-	SCARG(&ap, len) = len;
-	SCARG(&ap, prot) = prot;
-	SCARG(&ap, flags) = flags;
-	SCARG(&ap, fd) = fd;
-	SCARG(&ap, pos) = pos;
+	ap.addr = (void *) addr;
+	ap.len = len;
+	ap.prot = prot;
+	ap.flags = flags;
+	ap.fd = fd;
+	ap.pos = pos;
 
 	return (mmap(td, &ap));
 }
@@ -608,11 +608,11 @@
 	struct itimerval32 *p32, *op32, s32;
 	struct itimerval *p = NULL, *op = NULL, s;
 
-	p32 = SCARG(uap, itv);
+	p32 = uap->itv;
 	if (p32) {
 		sg = stackgap_init();
 		p = stackgap_alloc(&sg, sizeof(struct itimerval));
-		SCARG(uap, itv) = (struct itimerval32 *)p;
+		uap->itv = (struct itimerval32 *)p;
 		error = copyin(p32, &s32, sizeof(s32));
 		if (error)
 			return (error);
@@ -622,11 +622,11 @@
 		if (error)
 			return (error);
 	}
-	op32 = SCARG(uap, oitv);
+	op32 = uap->oitv;
 	if (op32) {
 		sg = stackgap_init();
 		op = stackgap_alloc(&sg, sizeof(struct itimerval));
-		SCARG(uap, oitv) = (struct itimerval32 *)op;
+		uap->oitv = (struct itimerval32 *)op;
 	}
 	error = setitimer(td, (struct setitimer_args *) uap);
 	if (error)
@@ -650,11 +650,11 @@
 	struct timeval32 *p32, s32;
 	struct timeval *p = NULL, s;
 
-	p32 = SCARG(uap, tv);
+	p32 = uap->tv;
 	if (p32) {
 		sg = stackgap_init();
 		p = stackgap_alloc(&sg, sizeof(struct timeval));
-		SCARG(uap, tv) = (struct timeval32 *)p;
+		uap->tv = (struct timeval32 *)p;
 		error = copyin(p32, &s32, sizeof(s32));
 		if (error)
 			return (error);
@@ -678,11 +678,11 @@
 	struct timeval32 *p32, s32;
 	struct timeval *p = NULL, s;
 
-	p32 = SCARG(uap, tp);
+	p32 = uap->tp;
 	if (p32) {
 		sg = stackgap_init();
 		p = stackgap_alloc(&sg, sizeof(struct timeval));
-		SCARG(uap, tp) = (struct timeval32 *)p;
+		uap->tp = (struct timeval32 *)p;
 	}
 	error = gettimeofday(td, (struct gettimeofday_args *) uap);
 	if (error)
@@ -708,11 +708,11 @@
 	struct rusage32 *p32, s32;
 	struct rusage *p = NULL, s;
 
-	p32 = SCARG(uap, rusage);
+	p32 = uap->rusage;
 	if (p32) {
 		sg = stackgap_init();
 		p = stackgap_alloc(&sg, sizeof(struct rusage));
-		SCARG(uap, rusage) = (struct rusage32 *)p;
+		uap->rusage = (struct rusage32 *)p;
 	}
 	error = getrusage(td, (struct getrusage_args *) uap);
 	if (error)
@@ -763,28 +763,28 @@
 
 	sg = stackgap_init();
 
-	if (SCARG(uap, iovcnt) > (STACKGAPLEN / sizeof (struct iovec)))
+	if (uap->iovcnt > (STACKGAPLEN / sizeof (struct iovec)))
 		return (EINVAL);
 
-	osize = SCARG(uap, iovcnt) * sizeof (struct iovec32);
-	nsize = SCARG(uap, iovcnt) * sizeof (struct iovec);
+	osize = uap->iovcnt * sizeof (struct iovec32);
+	nsize = uap->iovcnt * sizeof (struct iovec);
 
 	oio = malloc(osize, M_TEMP, M_WAITOK);
 	nio = malloc(nsize, M_TEMP, M_WAITOK);
 
 	error = 0;
-	if ((error = copyin(SCARG(uap, iovp), oio, osize)))
+	if ((error = copyin(uap->iovp, oio, osize)))
 		goto punt;
-	for (i = 0; i < SCARG(uap, iovcnt); i++) {
+	for (i = 0; i < uap->iovcnt; i++) {
 		nio[i].iov_base = PTRIN(oio[i].iov_base);
 		nio[i].iov_len = oio[i].iov_len;
 	}
 
-	SCARG(&a, fd) = SCARG(uap, fd);
-	SCARG(&a, iovp) = stackgap_alloc(&sg, nsize);
-	SCARG(&a, iovcnt) = SCARG(uap, iovcnt);
+	a.fd = uap->fd;
+	a.iovp = stackgap_alloc(&sg, nsize);
+	a.iovcnt = uap->iovcnt;
 
-	if ((error = copyout(nio, (caddr_t)SCARG(&a, iovp), nsize)))
+	if ((error = copyout(nio, (caddr_t)a.iovp, nsize)))
 		goto punt;
 	error = readv(td, &a);
 
@@ -809,28 +809,28 @@
 
 	sg = stackgap_init();
 
-	if (SCARG(uap, iovcnt) > (STACKGAPLEN / sizeof (struct iovec)))
+	if (uap->iovcnt > (STACKGAPLEN / sizeof (struct iovec)))
 		return (EINVAL);
 
-	osize = SCARG(uap, iovcnt) * sizeof (struct iovec32);
-	nsize = SCARG(uap, iovcnt) * sizeof (struct iovec);
+	osize = uap->iovcnt * sizeof (struct iovec32);
+	nsize = uap->iovcnt * sizeof (struct iovec);
 
 	oio = malloc(osize, M_TEMP, M_WAITOK);
 	nio = malloc(nsize, M_TEMP, M_WAITOK);
 
 	error = 0;
-	if ((error = copyin(SCARG(uap, iovp), oio, osize)))
+	if ((error = copyin(uap->iovp, oio, osize)))
 		goto punt;
-	for (i = 0; i < SCARG(uap, iovcnt); i++) {
+	for (i = 0; i < uap->iovcnt; i++) {
 		nio[i].iov_base = PTRIN(oio[i].iov_base);
 		nio[i].iov_len = oio[i].iov_len;
 	}
 
-	SCARG(&a, fd) = SCARG(uap, fd);
-	SCARG(&a, iovp) = stackgap_alloc(&sg, nsize);
-	SCARG(&a, iovcnt) = SCARG(uap, iovcnt);
+	a.fd = uap->fd;
+	a.iovp = stackgap_alloc(&sg, nsize);
+	a.iovcnt = uap->iovcnt;
 
-	if ((error = copyout(nio, (caddr_t)SCARG(&a, iovp), nsize)))
+	if ((error = copyout(nio, (caddr_t)a.iovp, nsize)))
 		goto punt;
 	error = writev(td, &a);
 
@@ -848,11 +848,11 @@
 	struct timeval32 *p32, s32;
 	struct timeval *p = NULL, s;
 
-	p32 = SCARG(uap, tv);
+	p32 = uap->tv;
 	if (p32) {
 		sg = stackgap_init();
 		p = stackgap_alloc(&sg, sizeof(struct timeval));
-		SCARG(uap, tv) = (struct timeval32 *)p;
+		uap->tv = (struct timeval32 *)p;
 		error = copyin(p32, &s32, sizeof(s32));
 		if (error)
 			return (error);
@@ -873,11 +873,11 @@
 	struct timeval32 *p32, s32[2];
 	struct timeval *p = NULL, s[2];
 
-	p32 = SCARG(uap, tptr);
+	p32 = uap->tptr;
 	if (p32) {
 		sg = stackgap_init();
 		p = stackgap_alloc(&sg, 2*sizeof(struct timeval));
-		SCARG(uap, tptr) = (struct timeval32 *)p;
+		uap->tptr = (struct timeval32 *)p;
 		error = copyin(p32, s32, sizeof(s32));
 		if (error)
 			return (error);
@@ -900,11 +900,11 @@
 	struct timeval32 *p32, *op32, s32;
 	struct timeval *p = NULL, *op = NULL, s;
 
-	p32 = SCARG(uap, delta);
+	p32 = uap->delta;
 	if (p32) {
 		sg = stackgap_init();
 		p = stackgap_alloc(&sg, sizeof(struct timeval));
-		SCARG(uap, delta) = (struct timeval32 *)p;
+		uap->delta = (struct timeval32 *)p;
 		error = copyin(p32, &s32, sizeof(s32));
 		if (error)
 			return (error);
@@ -914,11 +914,11 @@
 		if (error)
 			return (error);
 	}
-	op32 = SCARG(uap, olddelta);
+	op32 = uap->olddelta;
 	if (op32) {
 		sg = stackgap_init();
 		op = stackgap_alloc(&sg, sizeof(struct timeval));
-		SCARG(uap, olddelta) = (struct timeval32 *)op;
+		uap->olddelta = (struct timeval32 *)op;
 	}
 	error = utimes(td, (struct utimes_args *) uap);
 	if (error)
@@ -942,11 +942,11 @@
 	struct statfs32 *p32, s32;
 	struct statfs *p = NULL, s;
 
-	p32 = SCARG(uap, buf);
+	p32 = uap->buf;
 	if (p32) {
 		sg = stackgap_init();
 		p = stackgap_alloc(&sg, sizeof(struct statfs));
-		SCARG(uap, buf) = (struct statfs32 *)p;
+		uap->buf = (struct statfs32 *)p;
 	}
 	error = statfs(td, (struct statfs_args *) uap);
 	if (error)
@@ -969,11 +969,11 @@
 	struct statfs32 *p32, s32;
 	struct statfs *p = NULL, s;
 
-	p32 = SCARG(uap, buf);
+	p32 = uap->buf;
 	if (p32) {
 		sg = stackgap_init();
 		p = stackgap_alloc(&sg, sizeof(struct statfs));
-		SCARG(uap, buf) = (struct statfs32 *)p;
+		uap->buf = (struct statfs32 *)p;
 	}
 	error = fstatfs(td, (struct fstatfs_args *) uap);
 	if (error)
@@ -1020,11 +1020,11 @@
 {
 	struct pread_args ap;
 
-	SCARG(&ap, fd) = SCARG(uap, fd);
-	SCARG(&ap, buf) = SCARG(uap, buf);
-	SCARG(&ap, nbyte) = SCARG(uap, nbyte);
-	SCARG(&ap, offset) = (SCARG(uap, offsetlo)
-			      | ((off_t)SCARG(uap, offsethi) << 32));
+	ap.fd = uap->fd;
+	ap.buf = uap->buf;
+	ap.nbyte = uap->nbyte;
+	ap.offset = (uap->offsetlo
+			      | ((off_t)uap->offsethi << 32));
 	return (pread(td, &ap));
 }
 
@@ -1033,11 +1033,11 @@
 {
 	struct pwrite_args ap;
 
-	SCARG(&ap, fd) = SCARG(uap, fd);
-	SCARG(&ap, buf) = SCARG(uap, buf);
-	SCARG(&ap, nbyte) = SCARG(uap, nbyte);
-	SCARG(&ap, offset) = (SCARG(uap, offsetlo)
-			      | ((off_t)SCARG(uap, offsethi) << 32));
+	ap.fd = uap->fd;
+	ap.buf = uap->buf;
+	ap.nbyte = uap->nbyte;
+	ap.offset = (uap->offsetlo
+			      | ((off_t)uap->offsethi << 32));
 	return (pwrite(td, &ap));
 }
 
@@ -1048,10 +1048,10 @@
 	struct lseek_args ap;
 	off_t pos;
 
-	SCARG(&ap, fd) = SCARG(uap, fd);
-	SCARG(&ap, offset) = (SCARG(uap, offsetlo)
-			      | ((off_t)SCARG(uap, offsethi) << 32));
-	SCARG(&ap, whence) = SCARG(uap, whence);
+	ap.fd = uap->fd;
+	ap.offset = (uap->offsetlo
+			      | ((off_t)uap->offsethi << 32));
+	ap.whence = uap->whence;
 	error = lseek(td, &ap);
 	/* Expand the quad return into two parts for eax and edx */
 	pos = *(off_t *)(td->td_retval);
@@ -1065,9 +1065,9 @@
 {
 	struct truncate_args ap;
 
-	SCARG(&ap, path) = SCARG(uap, path);
-	SCARG(&ap, length) = (SCARG(uap, lengthlo)
-			      | ((off_t)SCARG(uap, lengthhi) << 32));
+	ap.path = uap->path;
+	ap.length = (uap->lengthlo
+			      | ((off_t)uap->lengthhi << 32));
 	return (truncate(td, &ap));
 }
 
@@ -1076,9 +1076,9 @@
 {
 	struct ftruncate_args ap;
 
-	SCARG(&ap, fd) = SCARG(uap, fd);
-	SCARG(&ap, length) = (SCARG(uap, lengthlo)
-			      | ((off_t)SCARG(uap, lengthhi) << 32));
+	ap.fd = uap->fd;
+	ap.length = (uap->lengthlo
+			      | ((off_t)uap->lengthhi << 32));
 	return (ftruncate(td, &ap));
 }
 
@@ -1089,14 +1089,14 @@
 {
 	struct freebsd4_sendfile_args ap;
 
-	SCARG(&ap, fd) = SCARG(uap, fd);
-	SCARG(&ap, s) = SCARG(uap, s);
-	SCARG(&ap, offset) = (SCARG(uap, offsetlo)
-			      | ((off_t)SCARG(uap, offsethi) << 32));
-	SCARG(&ap, nbytes) = SCARG(uap, nbytes);	/* XXX check */
-	SCARG(&ap, hdtr) = SCARG(uap, hdtr);		/* XXX check */
-	SCARG(&ap, sbytes) = SCARG(uap, sbytes);	/* XXX FIXME!! */
-	SCARG(&ap, flags) = SCARG(uap, flags);
+	ap.fd = uap->fd;
+	ap.s = uap->s;
+	ap.offset = (uap->offsetlo
+			      | ((off_t)uap->offsethi << 32));
+	ap.nbytes = uap->nbytes;	/* XXX check */
+	ap.hdtr = uap->hdtr;		/* XXX check */
+	ap.sbytes = uap->sbytes;	/* XXX FIXME!! */
+	ap.flags = uap->flags;
 	return (freebsd4_sendfile(td, &ap));
 }
 #endif
@@ -1106,14 +1106,14 @@
 {
 	struct sendfile_args ap;
 
-	SCARG(&ap, fd) = SCARG(uap, fd);
-	SCARG(&ap, s) = SCARG(uap, s);
-	SCARG(&ap, offset) = (SCARG(uap, offsetlo)
-			      | ((off_t)SCARG(uap, offsethi) << 32));
-	SCARG(&ap, nbytes) = SCARG(uap, nbytes);	/* XXX check */
-	SCARG(&ap, hdtr) = SCARG(uap, hdtr);		/* XXX check */
-	SCARG(&ap, sbytes) = SCARG(uap, sbytes);	/* XXX FIXME!! */
-	SCARG(&ap, flags) = SCARG(uap, flags);
+	ap.fd = uap->fd;
+	ap.s = uap->s;
+	ap.offset = (uap->offsetlo
+			      | ((off_t)uap->offsethi << 32));
+	ap.nbytes = uap->nbytes;	/* XXX check */
+	ap.hdtr = uap->hdtr;		/* XXX check */
+	ap.sbytes = uap->sbytes;	/* XXX FIXME!! */
+	ap.flags = uap->flags;
 	return (sendfile(td, &ap));
 }
 
@@ -1163,11 +1163,11 @@
 	struct stat32 *p32, s32;
 	struct stat *p = NULL, s;
 
-	p32 = SCARG(uap, ub);
+	p32 = uap->ub;
 	if (p32) {
 		sg = stackgap_init();
 		p = stackgap_alloc(&sg, sizeof(struct stat));
-		SCARG(uap, ub) = (struct stat32 *)p;
+		uap->ub = (struct stat32 *)p;
 	}
 	error = stat(td, (struct stat_args *) uap);
 	if (error)
@@ -1190,11 +1190,11 @@
 	struct stat32 *p32, s32;
 	struct stat *p = NULL, s;
 
-	p32 = SCARG(uap, ub);
+	p32 = uap->ub;
 	if (p32) {
 		sg = stackgap_init();
 		p = stackgap_alloc(&sg, sizeof(struct stat));
-		SCARG(uap, ub) = (struct stat32 *)p;
+		uap->ub = (struct stat32 *)p;
 	}
 	error = fstat(td, (struct fstat_args *) uap);
 	if (error)
@@ -1217,11 +1217,11 @@
 	struct stat32 *p32, s32;
 	struct stat *p = NULL, s;
 
-	p32 = SCARG(uap, ub);
+	p32 = uap->ub;
 	if (p32) {
 		sg = stackgap_init();
 		p = stackgap_alloc(&sg, sizeof(struct stat));
-		SCARG(uap, ub) = (struct stat32 *)p;
+		uap->ub = (struct stat32 *)p;
 	}
 	error = lstat(td, (struct lstat_args *) uap);
 	if (error)
@@ -1285,11 +1285,11 @@
 	struct sigaction32 *p32, *op32, s32;
 	struct sigaction *p = NULL, *op = NULL, s;
 
-	p32 = SCARG(uap, act);
+	p32 = uap->act;
 	if (p32) {
 		sg = stackgap_init();
 		p = stackgap_alloc(&sg, sizeof(struct sigaction));
-		SCARG(uap, act) = (struct sigaction32 *)p;
+		uap->act = (struct sigaction32 *)p;
 		error = copyin(p32, &s32, sizeof(s32));
 		if (error)
 			return (error);
@@ -1300,11 +1300,11 @@
 		if (error)
 			return (error);
 	}
-	op32 = SCARG(uap, oact);
+	op32 = uap->oact;
 	if (op32) {
 		sg = stackgap_init();
 		op = stackgap_alloc(&sg, sizeof(struct sigaction));
-		SCARG(uap, oact) = (struct sigaction32 *)op;
+		uap->oact = (struct sigaction32 *)op;
 	}
 	error = sigaction(td, (struct sigaction_args *) uap);
 	if (error)
@@ -1331,11 +1331,11 @@
 	struct yyy32 *p32, s32;
 	struct yyy *p = NULL, s;
 
-	p32 = SCARG(uap, zzz);
+	p32 = uap->zzz;
 	if (p32) {
 		sg = stackgap_init();
 		p = stackgap_alloc(&sg, sizeof(struct yyy));
-		SCARG(uap, zzz) = (struct yyy32 *)p;
+		uap->zzz = (struct yyy32 *)p;
 		error = copyin(p32, &s32, sizeof(s32));
 		if (error)
 			return (error);
Index: ia64/ia32/ia32_util.h
===================================================================
RCS file: /home/ncvs/src/sys/ia64/ia32/ia32_util.h,v
retrieving revision 1.1
diff -u -r1.1 ia32_util.h
--- ia64/ia32/ia32_util.h	20 Jul 2002 02:56:10 -0000	1.1
+++ ia64/ia32/ia32_util.h	12 Dec 2002 03:14:38 -0000
@@ -37,11 +37,6 @@
 #include <sys/sysent.h>
 #include <sys/cdefs.h>
 
-
-#ifndef	SCARG
-#define	SCARG(p, x)  (p)->x
-#endif
-
 struct ia32_ps_strings {
 	u_int32_t ps_argvstr;	/* first of 0 or more argument strings */
 	int	ps_nargvstr;	/* the number of argument strings */
Index: ia64/ia64/sys_machdep.c
===================================================================
RCS file: /home/ncvs/src/sys/ia64/ia64/sys_machdep.c,v
retrieving revision 1.2
diff -u -r1.2 sys_machdep.c
--- ia64/ia64/sys_machdep.c	12 Sep 2001 08:37:40 -0000	1.2
+++ ia64/ia64/sys_machdep.c	12 Dec 2002 03:14:38 -0000
@@ -70,7 +70,7 @@
 {
 	int error = 0;
 
-	switch(SCARG(uap,op)) {
+	switch(uap->op) {
 	default:
 		error = EINVAL;
 		break;
Index: kern/kern_acct.c
===================================================================
RCS file: /home/ncvs/src/sys/kern/kern_acct.c,v
retrieving revision 1.55
diff -u -r1.55 kern_acct.c
--- kern/kern_acct.c	26 Nov 2002 18:04:12 -0000	1.55
+++ kern/kern_acct.c	12 Dec 2002 03:15:20 -0000
@@ -139,8 +139,8 @@
 	 * If accounting is to be started to a file, open that file for
 	 * appending and make sure it's a 'normal'.
 	 */
-	if (SCARG(uap, path) != NULL) {
-		NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path),
+	if (uap->path != NULL) {
+		NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, uap->path,
 		       td);
 		flags = FWRITE | O_APPEND;
 		error = vn_open(&nd, &flags, 0);
@@ -187,7 +187,7 @@
 		crfree(acctcred != NOCRED ? acctcred : savacctcred);
 		acctcred = savacctcred = NOCRED;
 	}
-	if (SCARG(uap, path) == NULL) {
+	if (uap->path == NULL) {
 		mtx_unlock(&acct_mtx);
 		goto done2;
 	}
Index: kern/kern_acl.c
===================================================================
RCS file: /home/ncvs/src/sys/kern/kern_acl.c,v
retrieving revision 1.32
diff -u -r1.32 kern_acl.c
--- kern/kern_acl.c	1 Aug 2002 01:04:16 -0000	1.32
+++ kern/kern_acl.c	12 Dec 2002 03:15:20 -0000
@@ -689,11 +689,11 @@
 	int error;
 
 	mtx_lock(&Giant);
-	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td);
+	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, td);
 	error = namei(&nd);
 	if (error == 0) {
-		error = vacl_get_acl(td, nd.ni_vp, SCARG(uap, type), 
-			    SCARG(uap, aclp));
+		error = vacl_get_acl(td, nd.ni_vp, uap->type, 
+			    uap->aclp);
 		NDFREE(&nd, 0);
 	}
 	mtx_unlock(&Giant);
@@ -712,11 +712,11 @@
 	int error;
 
 	mtx_lock(&Giant);
-	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td);
+	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, td);
 	error = namei(&nd);
 	if (error == 0) {
-		error = vacl_set_acl(td, nd.ni_vp, SCARG(uap, type),
-			    SCARG(uap, aclp));
+		error = vacl_set_acl(td, nd.ni_vp, uap->type,
+			    uap->aclp);
 		NDFREE(&nd, 0);
 	}
 	mtx_unlock(&Giant);
@@ -735,10 +735,10 @@
 	int error;
 
 	mtx_lock(&Giant);
-	error = getvnode(td->td_proc->p_fd, SCARG(uap, filedes), &fp);
+	error = getvnode(td->td_proc->p_fd, uap->filedes, &fp);
 	if (error == 0) {
 		error = vacl_get_acl(td, (struct vnode *)fp->f_data,
-			    SCARG(uap, type), SCARG(uap, aclp));
+			    uap->type, uap->aclp);
 		fdrop(fp, td);
 	}
 	mtx_unlock(&Giant);
@@ -757,10 +757,10 @@
 	int error;
 
 	mtx_lock(&Giant);
-	error = getvnode(td->td_proc->p_fd, SCARG(uap, filedes), &fp);
+	error = getvnode(td->td_proc->p_fd, uap->filedes, &fp);
 	if (error == 0) {
 		error = vacl_set_acl(td, (struct vnode *)fp->f_data,
-			    SCARG(uap, type), SCARG(uap, aclp));
+			    uap->type, uap->aclp);
 		fdrop(fp, td);
 	}
 	mtx_unlock(&Giant);
@@ -779,10 +779,10 @@
 	int error;
 
 	mtx_lock(&Giant);
-	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td);
+	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, td);
 	error = namei(&nd);
 	if (error == 0) {
-		error = vacl_delete(td, nd.ni_vp, SCARG(uap, type));
+		error = vacl_delete(td, nd.ni_vp, uap->type);
 		NDFREE(&nd, 0);
 	}
 	mtx_unlock(&Giant);
@@ -801,10 +801,10 @@
 	int error;
 
 	mtx_lock(&Giant);
-	error = getvnode(td->td_proc->p_fd, SCARG(uap, filedes), &fp);
+	error = getvnode(td->td_proc->p_fd, uap->filedes, &fp);
 	if (error == 0) {
 		error = vacl_delete(td, (struct vnode *)fp->f_data, 
-			    SCARG(uap, type));
+			    uap->type);
 		fdrop(fp, td);
 	}
 	mtx_unlock(&Giant);
@@ -823,11 +823,11 @@
 	int	error;
 
 	mtx_lock(&Giant);
-	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td);
+	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, td);
 	error = namei(&nd);
 	if (error == 0) {
-		error = vacl_aclcheck(td, nd.ni_vp, SCARG(uap, type),
-			    SCARG(uap, aclp));
+		error = vacl_aclcheck(td, nd.ni_vp, uap->type,
+			    uap->aclp);
 		NDFREE(&nd, 0);
 	}
 	mtx_unlock(&Giant);
@@ -846,10 +846,10 @@
 	int error;
 
 	mtx_lock(&Giant);
-	error = getvnode(td->td_proc->p_fd, SCARG(uap, filedes), &fp);
+	error = getvnode(td->td_proc->p_fd, uap->filedes, &fp);
 	if (error == 0) {
 		error = vacl_aclcheck(td, (struct vnode *)fp->f_data,
-			    SCARG(uap, type), SCARG(uap, aclp));
+			    uap->type, uap->aclp);
 		fdrop(fp, td);
 	}
 	mtx_unlock(&Giant);
Index: kern/kern_environment.c
===================================================================
RCS file: /home/ncvs/src/sys/kern/kern_environment.c,v
retrieving revision 1.26
diff -u -r1.26 kern_environment.c
--- kern/kern_environment.c	1 Nov 2002 20:46:53 -0000	1.26
+++ kern/kern_environment.c	12 Dec 2002 03:15:21 -0000
@@ -92,7 +92,7 @@
 	KASSERT(dynamic_kenv, ("kenv: dynamic_kenv = 0"));
 
 	error = 0;
-	if (SCARG(uap, what) == KENV_DUMP) {
+	if (uap->what == KENV_DUMP) {
 #ifdef MAC
 		error = mac_check_kenv_dump(td->td_ucred);
 		if (error)
@@ -100,7 +100,7 @@
 #endif
 		len = 0;
 		/* Return the size if called with a NULL buffer */
-		if (SCARG(uap, value) == NULL) {
+		if (uap->value == NULL) {
 			sx_slock(&kenv_lock);
 			for (i = 0; kenvp[i] != NULL; i++)
 				len += strlen(kenvp[i]) + 1;
@@ -110,9 +110,9 @@
 		}
 		done = 0;
 		sx_slock(&kenv_lock);
-		for (i = 0; kenvp[i] != NULL && done < SCARG(uap, len); i++) {
-			len = min(strlen(kenvp[i]) + 1, SCARG(uap, len) - done);
-			error = copyout(kenvp[i], SCARG(uap, value) + done,
+		for (i = 0; kenvp[i] != NULL && done < uap->len; i++) {
+			len = min(strlen(kenvp[i]) + 1, uap->len - done);
+			error = copyout(kenvp[i], uap->value + done,
 			    len);
 			if (error) {
 				sx_sunlock(&kenv_lock);
@@ -124,8 +124,8 @@
 		return (0);
 	}
 
-	if ((SCARG(uap, what) == KENV_SET) ||
-	    (SCARG(uap, what) == KENV_UNSET)) {
+	if ((uap->what == KENV_SET) ||
+	    (uap->what == KENV_UNSET)) {
 		error = suser(td);
 		if (error)
 			return (error);
@@ -133,11 +133,11 @@
 
 	name = malloc(KENV_MNAMELEN, M_TEMP, M_WAITOK);
 
-	error = copyinstr(SCARG(uap, name), name, KENV_MNAMELEN, NULL);
+	error = copyinstr(uap->name, name, KENV_MNAMELEN, NULL);
 	if (error)
 		goto done;
 
-	switch (SCARG(uap, what)) {
+	switch (uap->what) {
 	case KENV_GET:
 #ifdef MAC
 		error = mac_check_kenv_get(td->td_ucred, name);
@@ -150,16 +150,16 @@
 			goto done;
 		}
 		len = strlen(value) + 1;
-		if (len > SCARG(uap, len))
-			len = SCARG(uap, len);
-		error = copyout(value, SCARG(uap, value), len);
+		if (len > uap->len)
+			len = uap->len;
+		error = copyout(value, uap->value, len);
 		freeenv(value);
 		if (error)
 			goto done;
 		td->td_retval[0] = len;
 		break;
 	case KENV_SET:
-		len = SCARG(uap, len);
+		len = uap->len;
 		if (len < 1) {
 			error = EINVAL;
 			goto done;
@@ -167,7 +167,7 @@
 		if (len > KENV_MVALLEN)
 			len = KENV_MVALLEN;
 		value = malloc(len, M_TEMP, M_WAITOK);
-		error = copyinstr(SCARG(uap, value), value, len, NULL);
+		error = copyinstr(uap->value, value, len, NULL);
 		if (error) {
 			free(value, M_TEMP);
 			goto done;
Index: kern/kern_linker.c
===================================================================
RCS file: /home/ncvs/src/sys/kern/kern_linker.c,v
retrieving revision 1.97
diff -u -r1.97 kern_linker.c
--- kern/kern_linker.c	19 Nov 2002 22:12:42 -0000	1.97
+++ kern/kern_linker.c	12 Dec 2002 03:15:22 -0000
@@ -754,7 +754,7 @@
 		goto out;
 
 	pathname = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
-	if ((error = copyinstr(SCARG(uap, file), pathname, MAXPATHLEN,
+	if ((error = copyinstr(uap->file, pathname, MAXPATHLEN,
 	    NULL)) != 0)
 		goto out;
 
@@ -800,7 +800,7 @@
 	if ((error = suser(td)) != 0)
 		goto out;
 
-	lf = linker_find_file_by_id(SCARG(uap, fileid));
+	lf = linker_find_file_by_id(uap->fileid);
 	if (lf) {
 		KLD_DPF(FILE, ("kldunload: lf->userrefs=%d\n", lf->userrefs));
 		if (lf->userrefs == 0) {
@@ -841,7 +841,7 @@
 	td->td_retval[0] = -1;
 
 	pathname = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
-	if ((error = copyinstr(SCARG(uap, file), pathname, MAXPATHLEN,
+	if ((error = copyinstr(uap->file, pathname, MAXPATHLEN,
 	    NULL)) != 0)
 		goto out;
 
@@ -875,7 +875,7 @@
 
 	mtx_lock(&Giant);
 
-	if (SCARG(uap, fileid) == 0) {
+	if (uap->fileid == 0) {
 		mtx_lock(&kld_mtx);
 		if (TAILQ_FIRST(&linker_files))
 			td->td_retval[0] = TAILQ_FIRST(&linker_files)->id;
@@ -884,7 +884,7 @@
 		mtx_unlock(&kld_mtx);
 		goto out;
 	}
-	lf = linker_find_file_by_id(SCARG(uap, fileid));
+	lf = linker_find_file_by_id(uap->fileid);
 	if (lf) {
 		if (TAILQ_NEXT(lf, link))
 			td->td_retval[0] = TAILQ_NEXT(lf, link)->id;
@@ -916,12 +916,12 @@
 
 	mtx_lock(&Giant);
 
-	lf = linker_find_file_by_id(SCARG(uap, fileid));
+	lf = linker_find_file_by_id(uap->fileid);
 	if (lf == NULL) {
 		error = ENOENT;
 		goto out;
 	}
-	stat = SCARG(uap, stat);
+	stat = uap->stat;
 
 	/*
 	 * Check the version of the user's structure.
@@ -970,7 +970,7 @@
 #endif
 
 	mtx_lock(&Giant);
-	lf = linker_find_file_by_id(SCARG(uap, fileid));
+	lf = linker_find_file_by_id(uap->fileid);
 	if (lf) {
 		MOD_SLOCK;
 		mp = TAILQ_FIRST(&lf->modules);
@@ -1006,18 +1006,18 @@
 
 	mtx_lock(&Giant);
 
-	if ((error = copyin(SCARG(uap, data), &lookup, sizeof(lookup))) != 0)
+	if ((error = copyin(uap->data, &lookup, sizeof(lookup))) != 0)
 		goto out;
 	if (lookup.version != sizeof(lookup) ||
-	    SCARG(uap, cmd) != KLDSYM_LOOKUP) {
+	    uap->cmd != KLDSYM_LOOKUP) {
 		error = EINVAL;
 		goto out;
 	}
 	symstr = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
 	if ((error = copyinstr(lookup.symname, symstr, MAXPATHLEN, NULL)) != 0)
 		goto out;
-	if (SCARG(uap, fileid) != 0) {
-		lf = linker_find_file_by_id(SCARG(uap, fileid));
+	if (uap->fileid != 0) {
+		lf = linker_find_file_by_id(uap->fileid);
 		if (lf == NULL) {
 			error = ENOENT;
 			goto out;
@@ -1026,7 +1026,7 @@
 		    LINKER_SYMBOL_VALUES(lf, sym, &symval) == 0) {
 			lookup.symvalue = (uintptr_t) symval.value;
 			lookup.symsize = symval.size;
-			error = copyout(&lookup, SCARG(uap, data),
+			error = copyout(&lookup, uap->data,
 			    sizeof(lookup));
 		} else
 			error = ENOENT;
@@ -1037,7 +1037,7 @@
 			    LINKER_SYMBOL_VALUES(lf, sym, &symval) == 0) {
 				lookup.symvalue = (uintptr_t)symval.value;
 				lookup.symsize = symval.size;
-				error = copyout(&lookup, SCARG(uap, data),
+				error = copyout(&lookup, uap->data,
 				    sizeof(lookup));
 				break;
 			}
Index: kern/kern_mac.c
===================================================================
RCS file: /home/ncvs/src/sys/kern/kern_mac.c,v
retrieving revision 1.71
diff -u -r1.71 kern_mac.c
--- kern/kern_mac.c	9 Dec 2002 03:44:27 -0000	1.71
+++ kern/kern_mac.c	12 Dec 2002 03:15:22 -0000
@@ -3020,7 +3020,7 @@
 	struct ucred *tcred;
 	int error;
 
-	error = copyin(SCARG(uap, mac_p), &mac, sizeof(mac));
+	error = copyin(uap->mac_p, &mac, sizeof(mac));
 	if (error)
 		return (error);
 
@@ -3203,7 +3203,7 @@
 
 	buffer = malloc(mac.m_buflen, M_MACTEMP, M_WAITOK | M_ZERO);
 	mtx_lock(&Giant);				/* VFS */
-	error = fget(td, SCARG(uap, fd), &fp);
+	error = fget(td, uap->fd, &fp);
 	if (error)
 		goto out;
 
@@ -3405,7 +3405,7 @@
 
 	mtx_lock(&Giant);				/* VFS */
 
-	error = fget(td, SCARG(uap, fd), &fp);
+	error = fget(td, uap->fd, &fp);
 	if (error)
 		goto out;
 
@@ -3583,7 +3583,7 @@
 	char target[MAC_MAX_POLICY_NAME];
 	int error;
 
-	error = copyinstr(SCARG(uap, policy), target, sizeof(target), NULL);
+	error = copyinstr(uap->policy, target, sizeof(target), NULL);
 	if (error)
 		return (error);
 
@@ -3593,7 +3593,7 @@
 		if (strcmp(mpc->mpc_name, target) == 0 &&
 		    mpc->mpc_ops->mpo_syscall != NULL) {
 			error = mpc->mpc_ops->mpo_syscall(td,
-			    SCARG(uap, call), SCARG(uap, arg));
+			    uap->call, uap->arg);
 			goto out;
 		}
 	}
Index: kern/kern_module.c
===================================================================
RCS file: /home/ncvs/src/sys/kern/kern_module.c,v
retrieving revision 1.35
diff -u -r1.35 kern_module.c
--- kern/kern_module.c	26 Jun 2002 03:00:40 -0000	1.35
+++ kern/kern_module.c	12 Dec 2002 03:15:22 -0000
@@ -259,7 +259,7 @@
 	td->td_retval[0] = -1;
 
 	MOD_SLOCK;
-	if (SCARG(uap, modid) == 0) {
+	if (uap->modid == 0) {
 		mod = TAILQ_FIRST(&modules);
 		if (mod)
 			td->td_retval[0] = mod->id;
@@ -267,7 +267,7 @@
 			error = ENOENT;
 		goto done2;
 	}
-	mod = module_lookupbyid(SCARG(uap, modid));
+	mod = module_lookupbyid(uap->modid);
 	if (mod == NULL) {
 		error = ENOENT;
 		goto done2;
@@ -293,7 +293,7 @@
 	td->td_retval[0] = -1;
 
 	MOD_SLOCK;
-	mod = module_lookupbyid(SCARG(uap, modid));
+	mod = module_lookupbyid(uap->modid);
 	if (mod == NULL) {
 		error = ENOENT;
 	} else {
@@ -328,7 +328,7 @@
 	char *name;
 
 	MOD_SLOCK;
-	mod = module_lookupbyid(SCARG(uap, modid));
+	mod = module_lookupbyid(uap->modid);
 	if (mod == NULL) {
 		MOD_SUNLOCK;
 		return (ENOENT);
@@ -338,7 +338,7 @@
 	name = mod->name;
 	data = mod->data;
 	MOD_SUNLOCK;
-	stat = SCARG(uap, stat);
+	stat = uap->stat;
 
 	/*
 	 * Check the version of the user's structure.
@@ -380,7 +380,7 @@
 	char name[MAXMODNAME];
 	module_t mod;
 
-	if ((error = copyinstr(SCARG(uap, name), name, sizeof name, 0)) != 0)
+	if ((error = copyinstr(uap->name, name, sizeof name, 0)) != 0)
 		return (error);
 
 	MOD_SLOCK;
Index: kern/kern_time.c
===================================================================
RCS file: /home/ncvs/src/sys/kern/kern_time.c,v
retrieving revision 1.86
diff -u -r1.86 kern_time.c
--- kern/kern_time.c	3 Nov 2002 02:39:42 -0000	1.86
+++ kern/kern_time.c	12 Dec 2002 03:15:24 -0000
@@ -159,12 +159,12 @@
 {
 	struct timespec ats;
 
-	if (SCARG(uap, clock_id) != CLOCK_REALTIME)
+	if (uap->clock_id != CLOCK_REALTIME)
 		return (EINVAL);
 	mtx_lock(&Giant);
 	nanotime(&ats);
 	mtx_unlock(&Giant);
-	return (copyout(&ats, SCARG(uap, tp), sizeof(ats)));
+	return (copyout(&ats, uap->tp, sizeof(ats)));
 }
 
 #ifndef _SYS_SYSPROTO_H_
@@ -192,9 +192,9 @@
 #endif
 	if ((error = suser(td)) != 0)
 		return (error);
-	if (SCARG(uap, clock_id) != CLOCK_REALTIME)
+	if (uap->clock_id != CLOCK_REALTIME)
 		return (EINVAL);
-	if ((error = copyin(SCARG(uap, tp), &ats, sizeof(ats))) != 0)
+	if ((error = copyin(uap->tp, &ats, sizeof(ats))) != 0)
 		return (error);
 	if (ats.tv_nsec < 0 || ats.tv_nsec >= 1000000000)
 		return (EINVAL);
@@ -217,10 +217,10 @@
 	struct timespec ts;
 	int error;
 
-	if (SCARG(uap, clock_id) != CLOCK_REALTIME)
+	if (uap->clock_id != CLOCK_REALTIME)
 		return (EINVAL);
 	error = 0;
-	if (SCARG(uap, tp)) {
+	if (uap->tp) {
 		ts.tv_sec = 0;
 		/*
 		 * Round up the result of the division cheaply by adding 1.
@@ -228,7 +228,7 @@
 		 * would give 0.  Perfect rounding is unimportant.
 		 */
 		ts.tv_nsec = 1000000000 / tc_getfrequency() + 1;
-		error = copyout(&ts, SCARG(uap, tp), sizeof(ts));
+		error = copyout(&ts, uap->tp, sizeof(ts));
 	}
 	return (error);
 }
@@ -289,23 +289,23 @@
 	struct timespec rmt, rqt;
 	int error;
 
-	error = copyin(SCARG(uap, rqtp), &rqt, sizeof(rqt));
+	error = copyin(uap->rqtp, &rqt, sizeof(rqt));
 	if (error)
 		return (error);
 
 	mtx_lock(&Giant);
-	if (SCARG(uap, rmtp)) {
-		if (!useracc((caddr_t)SCARG(uap, rmtp), sizeof(rmt), 
+	if (uap->rmtp) {
+		if (!useracc((caddr_t)uap->rmtp, sizeof(rmt), 
 		    VM_PROT_WRITE)) {
 			error = EFAULT;
 			goto done2;
 		}
 	}
 	error = nanosleep1(td, &rqt, &rmt);
-	if (error && SCARG(uap, rmtp)) {
+	if (error && uap->rmtp) {
 		int error2;
 
-		error2 = copyout(&rmt, SCARG(uap, rmtp), sizeof(rmt));
+		error2 = copyout(&rmt, uap->rmtp, sizeof(rmt));
 		if (error2)	/* XXX shouldn't happen, did useracc() above */
 			error = error2;
 	}
Index: kern/sys_generic.c
===================================================================
RCS file: /home/ncvs/src/sys/kern/sys_generic.c,v
retrieving revision 1.115
diff -u -r1.115 sys_generic.c
--- kern/sys_generic.c	28 Sep 2002 17:14:55 -0000	1.115
+++ kern/sys_generic.c	12 Dec 2002 03:15:27 -0000
@@ -951,7 +951,7 @@
 	u_int ncoll, nfds;
 	size_t ni;
 
-	nfds = SCARG(uap, nfds);
+	nfds = uap->nfds;
 
 	mtx_lock(&Giant);
 	/*
@@ -971,12 +971,12 @@
 		bits = malloc(ni, M_TEMP, M_WAITOK);
 	else
 		bits = smallbits;
-	error = copyin(SCARG(uap, fds), bits, ni);
+	error = copyin(uap->fds, bits, ni);
 	if (error)
 		goto done_nosellock;
-	if (SCARG(uap, timeout) != INFTIM) {
-		atv.tv_sec = SCARG(uap, timeout) / 1000;
-		atv.tv_usec = (SCARG(uap, timeout) % 1000) * 1000;
+	if (uap->timeout != INFTIM) {
+		atv.tv_sec = uap->timeout / 1000;
+		atv.tv_usec = (uap->timeout % 1000) * 1000;
 		if (itimerfix(&atv)) {
 			error = EINVAL;
 			goto done_nosellock;
@@ -1044,7 +1044,7 @@
 	if (error == EWOULDBLOCK)
 		error = 0;
 	if (error == 0) {
-		error = copyout(bits, SCARG(uap, fds), ni);
+		error = copyout(bits, uap->fds, ni);
 		if (error)
 			goto out;
 	}
Index: kern/vfs_mount.c
===================================================================
RCS file: /home/ncvs/src/sys/kern/vfs_mount.c,v
retrieving revision 1.90
diff -u -r1.90 vfs_mount.c
--- kern/vfs_mount.c	7 Nov 2002 21:15:02 -0000	1.90
+++ kern/vfs_mount.c	12 Dec 2002 03:15:30 -0000
@@ -323,7 +323,7 @@
 	int error;
 	u_int iovlen, iovcnt;
 
-	iovcnt = SCARG(uap, iovcnt);
+	iovcnt = uap->iovcnt;
 	iovlen = iovcnt * sizeof (struct iovec);
 	/*
 	 * Check that we have an even number of iovec's
@@ -352,7 +352,7 @@
 		}
 		iov++;
 	}
-	error = vfs_nmount(td, SCARG(uap, flags), &auio);
+	error = vfs_nmount(td, uap->flags, &auio);
 finish:
 	if (needfree != NULL)
 		free(needfree, M_TEMP);
@@ -811,12 +811,12 @@
 	 * vfs_mount() actually takes a kernel string for `type' and
 	 * `path' now, so extract them.
 	 */
-	error = copyinstr(SCARG(uap, type), fstype, MFSNAMELEN, NULL);
+	error = copyinstr(uap->type, fstype, MFSNAMELEN, NULL);
 	if (error == 0)
-		error = copyinstr(SCARG(uap, path), fspath, MNAMELEN, NULL);
+		error = copyinstr(uap->path, fspath, MNAMELEN, NULL);
 	if (error == 0)
-		error = vfs_mount(td, fstype, fspath, SCARG(uap, flags),
-		    SCARG(uap, data));
+		error = vfs_mount(td, fstype, fspath, uap->flags,
+		    uap->data);
 	free(fstype, M_TEMP);
 	free(fspath, M_TEMP);
 	return (error);
@@ -1199,7 +1199,7 @@
 	struct nameidata nd;
 
 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
-	    SCARG(uap, path), td);
+	    uap->path, td);
 	if ((error = namei(&nd)) != 0)
 		return (error);
 	vp = nd.ni_vp;
@@ -1234,7 +1234,7 @@
 		return (EINVAL);
 	}
 	vput(vp);
-	return (dounmount(mp, SCARG(uap, flags), td));
+	return (dounmount(mp, uap->flags, td));
 }
 
 /*
Index: kern/vfs_syscalls.c
===================================================================
RCS file: /home/ncvs/src/sys/kern/vfs_syscalls.c,v
retrieving revision 1.297
diff -u -r1.297 vfs_syscalls.c
--- kern/vfs_syscalls.c	27 Oct 2002 23:23:51 -0000	1.297
+++ kern/vfs_syscalls.c	12 Dec 2002 03:15:30 -0000
@@ -191,7 +191,7 @@
 
 	if (jailed(td->td_ucred) && !prison_quotas)
 		return (EPERM);
-	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td);
+	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, td);
 	if ((error = namei(&nd)) != 0)
 		return (error);
 	NDFREE(&nd, NDF_ONLY_PNBUF);
@@ -199,8 +199,8 @@
 	vrele(nd.ni_vp);
 	if (error)
 		return (error);
-	error = VFS_QUOTACTL(mp, SCARG(uap, cmd), SCARG(uap, uid),
-	    SCARG(uap, arg), td);
+	error = VFS_QUOTACTL(mp, uap->cmd, uap->uid,
+	    uap->arg, td);
 	vn_finished_write(mp);
 	return (error);
 }
@@ -229,7 +229,7 @@
 	struct nameidata nd;
 	struct statfs sb;
 
-	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td);
+	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, td);
 	if ((error = namei(&nd)) != 0)
 		return (error);
 	mp = nd.ni_vp->v_mount;
@@ -250,7 +250,7 @@
 		sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0;
 		sp = &sb;
 	}
-	return (copyout(sp, SCARG(uap, buf), sizeof(*sp)));
+	return (copyout(sp, uap->buf, sizeof(*sp)));
 }
 
 /*
@@ -277,7 +277,7 @@
 	int error;
 	struct statfs sb;
 
-	if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0)
+	if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
 		return (error);
 	mp = ((struct vnode *)fp->f_data)->v_mount;
 	fdrop(fp, td);
@@ -298,7 +298,7 @@
 		sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0;
 		sp = &sb;
 	}
-	return (copyout(sp, SCARG(uap, buf), sizeof(*sp)));
+	return (copyout(sp, uap->buf, sizeof(*sp)));
 }
 
 /*
@@ -325,8 +325,8 @@
 	caddr_t sfsp;
 	long count, maxcount, error;
 
-	maxcount = SCARG(uap, bufsize) / sizeof(struct statfs);
-	sfsp = (caddr_t)SCARG(uap, buf);
+	maxcount = uap->bufsize / sizeof(struct statfs);
+	sfsp = (caddr_t)uap->buf;
 	count = 0;
 	mtx_lock(&mountlist_mtx);
 	for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) {
@@ -347,8 +347,8 @@
 			 * refresh the fsstat cache. MNT_NOWAIT or MNT_LAZY
 			 * overrides MNT_WAIT.
 			 */
-			if (((SCARG(uap, flags) & (MNT_LAZY|MNT_NOWAIT)) == 0 ||
-			    (SCARG(uap, flags) & MNT_WAIT)) &&
+			if (((uap->flags & (MNT_LAZY|MNT_NOWAIT)) == 0 ||
+			    (uap->flags & MNT_WAIT)) &&
 			    (error = VFS_STATFS(mp, sp, td))) {
 				mtx_lock(&mountlist_mtx);
 				nmp = TAILQ_NEXT(mp, mnt_list);
@@ -398,7 +398,7 @@
 	struct file *fp;
 	int error;
 
-	if ((error = getvnode(fdp, SCARG(uap, fd), &fp)) != 0)
+	if ((error = getvnode(fdp, uap->fd, &fp)) != 0)
 		return (error);
 	vp = (struct vnode *)fp->f_data;
 	VREF(vp);
@@ -539,7 +539,7 @@
 	if (error)
 		return (error);
 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
-	    SCARG(uap, path), td);
+	    uap->path, td);
 	mtx_lock(&Giant);
 	if ((error = change_dir(&nd, td)) != 0)
 		goto error;
@@ -809,9 +809,9 @@
 		syscallarg(int) mode;
 	} */ nuap;
 
-	SCARG(&nuap, path) = SCARG(uap, path);
-	SCARG(&nuap, mode) = SCARG(uap, mode);
-	SCARG(&nuap, flags) = O_WRONLY | O_CREAT | O_TRUNC;
+	nuap.path = uap->path;
+	nuap.mode = uap->mode;
+	nuap.flags = O_WRONLY | O_CREAT | O_TRUNC;
 	return (open(td, &nuap));
 }
 #endif /* COMPAT_43 */
@@ -1176,7 +1176,7 @@
 restart:
 	bwillwrite();
 	NDINIT(&nd, DELETE, LOCKPARENT|DOWHITEOUT, UIO_USERSPACE,
-	    SCARG(uap, path), td);
+	    uap->path, td);
 	error = namei(&nd);
 	if (error)
 		return (error);
@@ -1222,7 +1222,7 @@
 	} */ *uap;
 {
 
-	return (kern_unlink(td, SCARG(uap, path), UIO_USERSPACE));
+	return (kern_unlink(td, uap->path, UIO_USERSPACE));
 }
 
 int
@@ -1323,8 +1323,8 @@
 	}
 	vp = (struct vnode *)fp->f_data;
 	noneg = (vp->v_type != VCHR);
-	offset = SCARG(uap, offset);
-	switch (SCARG(uap, whence)) {
+	offset = uap->offset;
+	switch (uap->whence) {
 	case L_INCR:
 		if (noneg &&
 		    (fp->f_offset < 0 ||
@@ -1386,9 +1386,9 @@
 	} */ nuap;
 	int error;
 
-	SCARG(&nuap, fd) = SCARG(uap, fd);
-	SCARG(&nuap, offset) = SCARG(uap, offset);
-	SCARG(&nuap, whence) = SCARG(uap, whence);
+	nuap.fd = uap->fd;
+	nuap.offset = uap->offset;
+	nuap.whence = uap->whence;
 	error = lseek(td, &nuap);
 	return (error);
 }
@@ -1506,12 +1506,12 @@
 	int error;
 
 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE,
-	    SCARG(uap, path), td);
+	    uap->path, td);
 	if ((error = namei(&nd)) != 0)
 		return (error);
 	vp = nd.ni_vp;
 
-	error = vn_access(vp, SCARG(uap, flags), td->td_ucred, td);
+	error = vn_access(vp, uap->flags, td->td_ucred, td);
 	NDFREE(&nd, NDF_ONLY_PNBUF);
 	vput(vp);
 	return (error);
@@ -1542,7 +1542,7 @@
 	struct nameidata nd;
 
 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE,
-	    SCARG(uap, path), td);
+	    uap->path, td);
 	if ((error = namei(&nd)) != 0)
 		return (error);
 	NDFREE(&nd, NDF_ONLY_PNBUF);
@@ -1551,7 +1551,7 @@
 	if (error)
 		return (error);
 	cvtstat(&sb, &osb);
-	error = copyout(&osb, SCARG(uap, ub), sizeof (osb));
+	error = copyout(&osb, uap->ub, sizeof (osb));
 	return (error);
 }
 
@@ -1580,7 +1580,7 @@
 	struct nameidata nd;
 
 	NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE,
-	    SCARG(uap, path), td);
+	    uap->path, td);
 	if ((error = namei(&nd)) != 0)
 		return (error);
 	vp = nd.ni_vp;
@@ -1590,7 +1590,7 @@
 	if (error)
 		return (error);
 	cvtstat(&sb, &osb);
-	error = copyout(&osb, SCARG(uap, ub), sizeof (osb));
+	error = copyout(&osb, uap->ub, sizeof (osb));
 	return (error);
 }
 
@@ -1648,10 +1648,10 @@
 
 #ifdef LOOKUP_SHARED
 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKSHARED | LOCKLEAF | NOOBJ,
-	    UIO_USERSPACE, SCARG(uap, path), td);
+	    UIO_USERSPACE, uap->path, td);
 #else
 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE,
-	    SCARG(uap, path), td);
+	    uap->path, td);
 #endif
 	if ((error = namei(&nd)) != 0)
 		return (error);
@@ -1660,7 +1660,7 @@
 	vput(nd.ni_vp);
 	if (error)
 		return (error);
-	error = copyout(&sb, SCARG(uap, ub), sizeof (sb));
+	error = copyout(&sb, uap->ub, sizeof (sb));
 	return (error);
 }
 
@@ -1688,7 +1688,7 @@
 	struct nameidata nd;
 
 	NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE,
-	    SCARG(uap, path), td);
+	    uap->path, td);
 	if ((error = namei(&nd)) != 0)
 		return (error);
 	vp = nd.ni_vp;
@@ -1697,7 +1697,7 @@
 	vput(vp);
 	if (error)
 		return (error);
-	error = copyout(&sb, SCARG(uap, ub), sizeof (sb));
+	error = copyout(&sb, uap->ub, sizeof (sb));
 	return (error);
 }
 
@@ -1753,7 +1753,7 @@
 	struct nameidata nd;
 
 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE,
-	    SCARG(uap, path), td);
+	    uap->path, td);
 	if ((error = namei(&nd)) != 0)
 		return (error);
 	NDFREE(&nd, NDF_ONLY_PNBUF);
@@ -1762,7 +1762,7 @@
 	if (error)
 		return (error);
 	cvtnstat(&sb, &nsb);
-	error = copyout(&nsb, SCARG(uap, ub), sizeof (nsb));
+	error = copyout(&nsb, uap->ub, sizeof (nsb));
 	return (error);
 }
 
@@ -1791,7 +1791,7 @@
 	struct nameidata nd;
 
 	NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE,
-	    SCARG(uap, path), td);
+	    uap->path, td);
 	if ((error = namei(&nd)) != 0)
 		return (error);
 	vp = nd.ni_vp;
@@ -1801,7 +1801,7 @@
 	if (error)
 		return (error);
 	cvtnstat(&sb, &nsb);
-	error = copyout(&nsb, SCARG(uap, ub), sizeof (nsb));
+	error = copyout(&nsb, uap->ub, sizeof (nsb));
 	return (error);
 }
 
@@ -1827,7 +1827,7 @@
 	struct nameidata nd;
 
 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE,
-	    SCARG(uap, path), td);
+	    uap->path, td);
 	if ((error = namei(&nd)) != 0)
 		return (error);
 	NDFREE(&nd, NDF_ONLY_PNBUF);
@@ -1972,11 +1972,11 @@
 	int error;
 	struct nameidata nd;
 
-	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td);
+	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, td);
 	if ((error = namei(&nd)) != 0)
 		return (error);
 	NDFREE(&nd, NDF_ONLY_PNBUF);
-	error = setfflags(td, nd.ni_vp, SCARG(uap, flags));
+	error = setfflags(td, nd.ni_vp, uap->flags);
 	vrele(nd.ni_vp);
 	return error;
 }
@@ -1995,11 +1995,11 @@
 	int error;
 	struct nameidata nd;
 
-	NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), td);
+	NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, uap->path, td);
 	if ((error = namei(&nd)) != 0)
 		return (error);
 	NDFREE(&nd, NDF_ONLY_PNBUF);
-	error = setfflags(td, nd.ni_vp, SCARG(uap, flags));
+	error = setfflags(td, nd.ni_vp, uap->flags);
 	vrele(nd.ni_vp);
 	return error;
 }
@@ -2025,9 +2025,9 @@
 	struct file *fp;
 	int error;
 
-	if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0)
+	if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
 		return (error);
-	error = setfflags(td, (struct vnode *) fp->f_data, SCARG(uap, flags));
+	error = setfflags(td, (struct vnode *) fp->f_data, uap->flags);
 	fdrop(fp, td);
 	return (error);
 }
@@ -2119,11 +2119,11 @@
 	int error;
 	struct nameidata nd;
 
-	NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), td);
+	NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, uap->path, td);
 	if ((error = namei(&nd)) != 0)
 		return (error);
 	NDFREE(&nd, NDF_ONLY_PNBUF);
-	error = setfmode(td, nd.ni_vp, SCARG(uap, mode));
+	error = setfmode(td, nd.ni_vp, uap->mode);
 	vrele(nd.ni_vp);
 	return error;
 }
@@ -2150,10 +2150,10 @@
 	struct vnode *vp;
 	int error;
 
-	if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0)
+	if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
 		return (error);
 	vp = (struct vnode *)fp->f_data;
-	error = setfmode(td, (struct vnode *)fp->f_data, SCARG(uap, mode));
+	error = setfmode(td, (struct vnode *)fp->f_data, uap->mode);
 	fdrop(fp, td);
 	return (error);
 }
@@ -2294,11 +2294,11 @@
 	struct vnode *vp;
 	int error;
 
-	if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0)
+	if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
 		return (error);
 	vp = (struct vnode *)fp->f_data;
 	error = setfown(td, (struct vnode *)fp->f_data,
-		SCARG(uap, uid), SCARG(uap, gid));
+		uap->uid, uap->gid);
 	fdrop(fp, td);
 	return (error);
 }
@@ -2592,7 +2592,7 @@
 
 	if (uap->length < 0)
 		return(EINVAL);
-	if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0)
+	if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
 		return (error);
 	if ((fp->f_flag & FWRITE) == 0) {
 		fdrop(fp, td);
@@ -2614,7 +2614,7 @@
 #endif
 	else if ((error = vn_writechk(vp)) == 0) {
 		VATTR_NULL(&vattr);
-		vattr.va_size = SCARG(uap, length);
+		vattr.va_size = uap->length;
 		error = VOP_SETATTR(vp, &vattr, fp->f_cred, td);
 	}
 	VOP_UNLOCK(vp, 0, td);
@@ -2648,8 +2648,8 @@
 		syscallarg(off_t) length;
 	} */ nuap;
 
-	SCARG(&nuap, path) = SCARG(uap, path);
-	SCARG(&nuap, length) = SCARG(uap, length);
+	nuap.path = uap->path;
+	nuap.length = uap->length;
 	return (truncate(td, &nuap));
 }
 
@@ -2677,8 +2677,8 @@
 		syscallarg(off_t) length;
 	} */ nuap;
 
-	SCARG(&nuap, fd) = SCARG(uap, fd);
-	SCARG(&nuap, length) = SCARG(uap, length);
+	nuap.fd = uap->fd;
+	nuap.length = uap->length;
 	return (ftruncate(td, &nuap));
 }
 #endif /* COMPAT_43 || COMPAT_SUNOS */
@@ -2707,7 +2707,7 @@
 
 	GIANT_REQUIRED;
 
-	if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0)
+	if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
 		return (error);
 	vp = (struct vnode *)fp->f_data;
 	if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) {
@@ -3062,9 +3062,9 @@
 	long loff;
 
 	/* XXX arbitrary sanity limit on `count'. */
-	if (SCARG(uap, count) > 64 * 1024)
+	if (uap->count > 64 * 1024)
 		return (EINVAL);
-	if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0)
+	if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
 		return (error);
 	if ((fp->f_flag & FREAD) == 0) {
 		fdrop(fp, td);
@@ -3076,14 +3076,14 @@
 		fdrop(fp, td);
 		return (EINVAL);
 	}
-	aiov.iov_base = SCARG(uap, buf);
-	aiov.iov_len = SCARG(uap, count);
+	aiov.iov_base = uap->buf;
+	aiov.iov_len = uap->count;
 	auio.uio_iov = &aiov;
 	auio.uio_iovcnt = 1;
 	auio.uio_rw = UIO_READ;
 	auio.uio_segflg = UIO_USERSPACE;
 	auio.uio_td = td;
-	auio.uio_resid = SCARG(uap, count);
+	auio.uio_resid = uap->count;
 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
 	loff = auio.uio_offset = fp->f_offset;
 #ifdef MAC
@@ -3105,14 +3105,14 @@
 		kuio = auio;
 		kuio.uio_iov = &kiov;
 		kuio.uio_segflg = UIO_SYSSPACE;
-		kiov.iov_len = SCARG(uap, count);
-		MALLOC(dirbuf, caddr_t, SCARG(uap, count), M_TEMP, M_WAITOK);
+		kiov.iov_len = uap->count;
+		MALLOC(dirbuf, caddr_t, uap->count, M_TEMP, M_WAITOK);
 		kiov.iov_base = dirbuf;
 		error = VOP_READDIR(vp, &kuio, fp->f_cred, &eofflag,
 			    NULL, NULL);
 		fp->f_offset = kuio.uio_offset;
 		if (error == 0) {
-			readcnt = SCARG(uap, count) - kuio.uio_resid;
+			readcnt = uap->count - kuio.uio_resid;
 			edp = (struct dirent *)&dirbuf[readcnt];
 			for (dp = (struct dirent *)dirbuf; dp < edp; ) {
 #				if (BYTE_ORDER == LITTLE_ENDIAN)
@@ -3150,7 +3150,7 @@
 		fdrop(fp, td);
 		return (error);
 	}
-	if (SCARG(uap, count) == auio.uio_resid) {
+	if (uap->count == auio.uio_resid) {
 		if (union_dircheckp) {
 			error = union_dircheckp(td, &vp, fp);
 			if (error == -1)
@@ -3177,9 +3177,9 @@
 		}
 		VOP_UNLOCK(vp, 0, td);
 	}
-	error = copyout(&loff, SCARG(uap, basep), sizeof(long));
+	error = copyout(&loff, uap->basep, sizeof(long));
 	fdrop(fp, td);
-	td->td_retval[0] = SCARG(uap, count) - auio.uio_resid;
+	td->td_retval[0] = uap->count - auio.uio_resid;
 	return (error);
 }
 #endif /* COMPAT_43 */
@@ -3212,7 +3212,7 @@
 	long loff;
 	int error, eofflag;
 
-	if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0)
+	if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
 		return (error);
 	if ((fp->f_flag & FREAD) == 0) {
 		fdrop(fp, td);
@@ -3224,14 +3224,14 @@
 		fdrop(fp, td);
 		return (EINVAL);
 	}
-	aiov.iov_base = SCARG(uap, buf);
-	aiov.iov_len = SCARG(uap, count);
+	aiov.iov_base = uap->buf;
+	aiov.iov_len = uap->count;
 	auio.uio_iov = &aiov;
 	auio.uio_iovcnt = 1;
 	auio.uio_rw = UIO_READ;
 	auio.uio_segflg = UIO_USERSPACE;
 	auio.uio_td = td;
-	auio.uio_resid = SCARG(uap, count);
+	auio.uio_resid = uap->count;
 	/* vn_lock(vp, LK_SHARED | LK_RETRY, td); */
 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
 	loff = auio.uio_offset = fp->f_offset;
@@ -3247,7 +3247,7 @@
 		fdrop(fp, td);
 		return (error);
 	}
-	if (SCARG(uap, count) == auio.uio_resid) {
+	if (uap->count == auio.uio_resid) {
 		if (union_dircheckp) {
 			error = union_dircheckp(td, &vp, fp);
 			if (error == -1)
@@ -3274,10 +3274,10 @@
 		}
 		VOP_UNLOCK(vp, 0, td);
 	}
-	if (SCARG(uap, basep) != NULL) {
-		error = copyout(&loff, SCARG(uap, basep), sizeof(long));
+	if (uap->basep != NULL) {
+		error = copyout(&loff, uap->basep, sizeof(long));
 	}
-	td->td_retval[0] = SCARG(uap, count) - auio.uio_resid;
+	td->td_retval[0] = uap->count - auio.uio_resid;
 	fdrop(fp, td);
 	return (error);
 }
@@ -3327,7 +3327,7 @@
 	FILEDESC_LOCK(td->td_proc->p_fd);
 	fdp = td->td_proc->p_fd;
 	td->td_retval[0] = fdp->fd_cmask;
-	fdp->fd_cmask = SCARG(uap, newmask) & ALLPERMS;
+	fdp->fd_cmask = uap->newmask & ALLPERMS;
 	FILEDESC_UNLOCK(td->td_proc->p_fd);
 	return (0);
 }
@@ -3355,7 +3355,7 @@
 	int error;
 	struct nameidata nd;
 
-	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, SCARG(uap, path),
+	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->path,
 	    td);
 	if ((error = namei(&nd)) != 0)
 		return (error);
@@ -3508,11 +3508,11 @@
 	if (error)
 		return (error);
 
-	fmode = FFLAGS(SCARG(uap, flags));
+	fmode = FFLAGS(uap->flags);
 	/* why not allow a non-read/write open for our lockd? */
 	if (((fmode & (FREAD | FWRITE)) == 0) || (fmode & O_CREAT))
 		return (EINVAL);
-	error = copyin(SCARG(uap,u_fhp), &fhp, sizeof(fhp));
+	error = copyin(uap->u_fhp, &fhp, sizeof(fhp));
 	if (error)
 		return(error);
 	/* find the mount point */
@@ -3703,7 +3703,7 @@
 	if (error)
 		return (error);
 	
-	error = copyin(SCARG(uap, u_fhp), &fh, sizeof(fhandle_t));
+	error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t));
 	if (error)
 		return (error);
 
@@ -3715,7 +3715,7 @@
 	vput(vp);
 	if (error)
 		return (error);
-	error = copyout(&sb, SCARG(uap, sb), sizeof(sb));
+	error = copyout(&sb, uap->sb, sizeof(sb));
 	return (error);
 }
 
@@ -3750,7 +3750,7 @@
 	if (error)
 		return (error);
 
-	if ((error = copyin(SCARG(uap, u_fhp), &fh, sizeof(fhandle_t))) != 0)
+	if ((error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t))) != 0)
 		return (error);
 
 	if ((mp = vfs_getvfs(&fh.fh_fsid)) == NULL)
@@ -3773,7 +3773,7 @@
 		sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0;
 		sp = &sb;
 	}
-	return (copyout(sp, SCARG(uap, buf), sizeof(*sp)));
+	return (copyout(sp, uap->buf, sizeof(*sp)));
 }
 
 /*
Index: sys/sysent.h
===================================================================
RCS file: /home/ncvs/src/sys/sys/sysent.h,v
retrieving revision 1.39
diff -u -r1.39 sysent.h
--- sys/sysent.h	1 Sep 2002 21:41:24 -0000	1.39
+++ sys/sysent.h	12 Dec 2002 03:14:38 -0000
@@ -48,9 +48,6 @@
 #define SYF_ARGMASK	0x0000FFFF
 #define SYF_MPSAFE	0x00010000
 
-#define SCARG(p,k)	((p)->k)	/* get arg from args pointer */
-  /* placeholder till we integrate rest of lite2 syscallargs changes XXX */
-
 struct image_params;
 struct __sigset;
 struct trapframe;
