[prev in list] [next in list] [prev in thread] [next in thread]
List: openbsd-tech
Subject: Re: Removing syscall(2) from libc and kernel
From: "Theo de Raadt" <deraadt () openbsd ! org>
Date: 2023-10-29 15:27:45
Message-ID: 34774.1698593265 () cvs ! openbsd ! org
[Download RAW message or body]
Here's the newest version of all 3 diffs:
- kernel diff, can be tested alone
- userland diff, can be tested alone
- syscalls.master cleanup, would happen afterwards, and conflicts a bit.
the ports team has repaired a majority of the syscall fallout in non-go
programs. The effort for go is still ongoing, I do not think it will take
very long. Fingers crossed.
go is the worst because the unix-hater club at the root of their
development team (this is my interpretation of what has happened) showed their
hate to ioctl() -- it is obviously such an evil type-unsafe call that people
need to be shown the even more evil type-unsafe syscall(). the application
community became aware of syscall() and embraced it for this purpose, then
when glibc refused to add new syscall stubs, a related community picked up
syscall() use there also, for all sorts of crazy seperate reasions. On linux,
syscall() is way more of a shitshow [go check their manual page for a subset
of the details that must be kept in mind] than on *BSD operating systems.
*BSD trees handled the 64-bit transition in a cleaner way: first side-stepping
the stdarg problem using a seperate __syscall() function and using pads, later
solving it by changing the ABI so the pads were not needed and the special casesn
are decomposed in the kernel. This was also easier because we were able to
stop userland from calling __syscall() initially and syscall() as a later step.
Index: sys/arch/alpha/alpha/trap.c
===================================================================
RCS file: /cvs/src/sys/arch/alpha/alpha/trap.c,v
diff -u -p -u -r1.108 trap.c
--- sys/arch/alpha/alpha/trap.c 8 Mar 2023 04:43:07 -0000 1.108
+++ sys/arch/alpha/alpha/trap.c 28 Oct 2023 15:11:05 -0000
@@ -497,17 +497,15 @@ dopanic:
* a3, and v0 from the frame before returning to the user process.
*/
void
-syscall(code, framep)
- u_int64_t code;
- struct trapframe *framep;
+syscall(u_int64_t code, struct trapframe *framep)
{
- const struct sysent *callp;
+ const struct sysent *callp = sysent;
struct proc *p;
- int error, indirect = -1;
+ int error = ENOSYS;
u_int64_t opc;
u_long rval[2];
u_long args[10]; /* XXX */
- u_int hidden, nargs;
+ u_int nargs;
atomic_add_int(&uvmexp.syscalls, 1);
p = curproc;
@@ -515,24 +513,11 @@ syscall(code, framep)
framep->tf_regs[FRAME_SP] = alpha_pal_rdusp();
opc = framep->tf_regs[FRAME_PC] - 4;
- switch(code) {
- case SYS_syscall:
- indirect = code;
- code = framep->tf_regs[FRAME_A0];
- hidden = 1;
- break;
- default:
- hidden = 0;
- }
-
- error = 0;
- callp = sysent;
- if (code >= SYS_MAXSYSCALL)
- callp += SYS_syscall;
- else
- callp += code;
+ if (code <= 0 || code >= SYS_MAXSYSCALL)
+ goto bad;
+ callp += code;
- nargs = callp->sy_narg + hidden;
+ nargs = callp->sy_narg;
switch (nargs) {
default:
if (nargs > 10) /* XXX */
@@ -559,7 +544,7 @@ syscall(code, framep)
rval[0] = 0;
rval[1] = 0;
- error = mi_syscall(p, code, indirect, callp, args + hidden, rval);
+ error = mi_syscall(p, code, callp, args, rval);
switch (error) {
case 0:
Index: sys/arch/amd64/amd64/locore.S
===================================================================
RCS file: /cvs/src/sys/arch/amd64/amd64/locore.S,v
diff -u -p -u -r1.141 locore.S
--- sys/arch/amd64/amd64/locore.S 24 Oct 2023 13:20:09 -0000 1.141
+++ sys/arch/amd64/amd64/locore.S 28 Oct 2023 15:11:05 -0000
@@ -508,6 +508,7 @@ ENTRY(savectx)
lfence
END(savectx)
+// XXX this should not behave like a nop
IDTVEC(syscall32)
sysret /* go away please */
END(Xsyscall32)
Index: sys/arch/amd64/amd64/trap.c
===================================================================
RCS file: /cvs/src/sys/arch/amd64/amd64/trap.c,v
diff -u -p -u -r1.101 trap.c
--- sys/arch/amd64/amd64/trap.c 5 Jul 2023 12:58:55 -0000 1.101
+++ sys/arch/amd64/amd64/trap.c 28 Oct 2023 15:11:05 -0000
@@ -553,7 +553,7 @@ syscall(struct trapframe *frame)
caddr_t params;
const struct sysent *callp;
struct proc *p;
- int error, indirect = -1;
+ int error = ENOSYS;
size_t argsize, argoff;
register_t code, args[9], rval[2], *argp;
@@ -570,26 +570,9 @@ syscall(struct trapframe *frame)
argp = &args[0];
argoff = 0;
- switch (code) {
- case SYS_syscall:
- /*
- * Code is first argument, followed by actual args.
- */
- indirect = code;
- code = frame->tf_rdi;
- argp = &args[1];
- argoff = 1;
- break;
- default:
- break;
- }
-
- callp = sysent;
- if (code < 0 || code >= SYS_MAXSYSCALL)
- callp += SYS_syscall;
- else
- callp += code;
-
+ if (code <= 0 || code >= SYS_MAXSYSCALL)
+ goto bad;
+ callp = sysent + code;
argsize = (callp->sy_argsize >> 3) + argoff;
if (argsize) {
switch (MIN(argsize, 6)) {
@@ -620,7 +603,7 @@ syscall(struct trapframe *frame)
rval[0] = 0;
rval[1] = 0;
- error = mi_syscall(p, code, indirect, callp, argp, rval);
+ error = mi_syscall(p, code, callp, argp, rval);
switch (error) {
case 0:
Index: sys/arch/arm/arm/syscall.c
===================================================================
RCS file: /cvs/src/sys/arch/arm/arm/syscall.c,v
diff -u -p -u -r1.26 syscall.c
--- sys/arch/arm/arm/syscall.c 11 Feb 2023 23:07:26 -0000 1.26
+++ sys/arch/arm/arm/syscall.c 28 Oct 2023 15:11:05 -0000
@@ -93,8 +93,8 @@ void
swi_handler(trapframe_t *frame)
{
struct proc *p = curproc;
- const struct sysent *callp;
- int code, error, indirect = -1;
+ const struct sysent *callp = sysent;
+ int code, error = ENOSYS;
u_int nap = 4, nargs;
register_t *ap, *args, copyargs[MAXARGS], rval[2];
@@ -103,32 +103,19 @@ swi_handler(trapframe_t *frame)
/* Before enabling interrupts, save FPU state */
vfp_save();
- /* Re-enable interrupts if they were enabled previously */
- if (__predict_true((frame->tf_spsr & PSR_I) == 0))
- enable_interrupts(PSR_I);
+ enable_interrupts(PSR_I);
p->p_addr->u_pcb.pcb_tf = frame;
/* Skip over speculation-blocking barrier. */
frame->tf_pc += 8;
- code = frame->tf_r12;
-
ap = &frame->tf_r0;
- switch (code) {
- case SYS_syscall:
- indirect = code;
- code = *ap++;
- nap--;
- break;
- }
-
- callp = sysent;
- if (code < 0 || code >= SYS_MAXSYSCALL)
- callp += SYS_syscall;
- else
- callp += code;
+ code = frame->tf_r12;
+ if (code <= 0 || code >= SYS_MAXSYSCALL)
+ goto bad;
+ callp += code;
nargs = callp->sy_argsize / sizeof(register_t);
if (nargs <= nap) {
@@ -145,27 +132,23 @@ swi_handler(trapframe_t *frame)
rval[0] = 0;
rval[1] = frame->tf_r1;
- error = mi_syscall(p, code, indirect, callp, args, rval);
+ error = mi_syscall(p, code, callp, args, rval);
switch (error) {
case 0:
frame->tf_r0 = rval[0];
frame->tf_r1 = rval[1];
-
frame->tf_spsr &= ~PSR_C; /* carry bit */
break;
-
case ERESTART:
/*
* Reconstruct the pc to point at the swi.
*/
frame->tf_pc -= 12;
break;
-
case EJUSTRETURN:
/* nothing to do */
break;
-
default:
bad:
frame->tf_r0 = error;
Index: sys/arch/arm64/arm64/syscall.c
===================================================================
RCS file: /cvs/src/sys/arch/arm64/arm64/syscall.c,v
diff -u -p -u -r1.14 syscall.c
--- sys/arch/arm64/arm64/syscall.c 13 Apr 2023 02:19:04 -0000 1.14
+++ sys/arch/arm64/arm64/syscall.c 28 Oct 2023 15:11:05 -0000
@@ -33,7 +33,7 @@ svc_handler(trapframe_t *frame)
{
struct proc *p = curproc;
const struct sysent *callp;
- int code, error, indirect = -1;
+ int code, error = ENOSYS;
u_int nap = 8, nargs;
register_t *ap, *args, copyargs[MAXARGS], rval[2];
@@ -50,19 +50,9 @@ svc_handler(trapframe_t *frame)
ap = &frame->tf_x[0];
- switch (code) {
- case SYS_syscall:
- indirect = code;
- code = *ap++;
- nap--;
- break;
- }
-
- callp = sysent;
- if (code < 0 || code >= SYS_MAXSYSCALL)
- callp += SYS_syscall;
- else
- callp += code;
+ if (code <= 0 || code >= SYS_MAXSYSCALL)
+ goto bad;
+ callp = sysent + code;
nargs = callp->sy_argsize / sizeof(register_t);
if (nargs <= nap) {
@@ -79,25 +69,22 @@ svc_handler(trapframe_t *frame)
rval[0] = 0;
rval[1] = 0;
- error = mi_syscall(p, code, indirect, callp, args, rval);
+ error = mi_syscall(p, code, callp, args, rval);
switch (error) {
case 0:
frame->tf_x[0] = rval[0];
frame->tf_spsr &= ~PSR_C; /* carry bit */
break;
-
case ERESTART:
/*
* Reconstruct the pc to point at the svc.
*/
frame->tf_elr -= 12;
break;
-
case EJUSTRETURN:
/* nothing to do */
break;
-
default:
bad:
frame->tf_x[0] = error;
Index: sys/arch/hppa/hppa/trap.c
===================================================================
RCS file: /cvs/src/sys/arch/hppa/hppa/trap.c,v
diff -u -p -u -r1.161 trap.c
--- sys/arch/hppa/hppa/trap.c 11 Feb 2023 23:07:26 -0000 1.161
+++ sys/arch/hppa/hppa/trap.c 28 Oct 2023 15:11:05 -0000
@@ -764,8 +764,8 @@ void
syscall(struct trapframe *frame)
{
struct proc *p = curproc;
- const struct sysent *callp;
- int retq, code, argsize, argoff, error, indirect = -1;
+ const struct sysent *callp = sysent;
+ int code, argsize, argoff, error = ENOSYS;
register_t args[8], rval[2];
#ifdef DIAGNOSTIC
int oldcpl = curcpu()->ci_cpl;
@@ -778,29 +778,16 @@ syscall(struct trapframe *frame)
p->p_md.md_regs = frame;
- argoff = 4; retq = 0;
- switch (code = frame->tf_t1) {
- case SYS_syscall:
- indirect = code;
- code = frame->tf_arg0;
- args[0] = frame->tf_arg1;
- args[1] = frame->tf_arg2;
- args[2] = frame->tf_arg3;
- argoff = 3;
- break;
- default:
- args[0] = frame->tf_arg0;
- args[1] = frame->tf_arg1;
- args[2] = frame->tf_arg2;
- args[3] = frame->tf_arg3;
- break;
- }
-
- callp = sysent;
- if (code < 0 || code >= SYS_MAXSYSCALL)
- callp += SYS_syscall;
- else
- callp += code;
+ argoff = 4;
+ code = frame->tf_t1;
+ args[0] = frame->tf_arg0;
+ args[1] = frame->tf_arg1;
+ args[2] = frame->tf_arg2;
+ args[3] = frame->tf_arg3;
+
+ if (code <= 0 || code >= SYS_MAXSYSCALL)
+ goto bad;
+ callp += code;
if ((argsize = callp->sy_argsize)) {
register_t *s, *e, t;
@@ -830,7 +817,7 @@ syscall(struct trapframe *frame)
*/
i = 0;
switch (code) {
- case SYS_lseek: retq = 0;
+ case SYS_lseek:
case SYS_truncate:
case SYS_ftruncate: i = 2; break;
case SYS_preadv:
@@ -851,12 +838,12 @@ syscall(struct trapframe *frame)
rval[0] = 0;
rval[1] = frame->tf_ret1;
- error = mi_syscall(p, code, indirect, callp, args, rval);
+ error = mi_syscall(p, code, callp, args, rval);
switch (error) {
case 0:
frame->tf_ret0 = rval[0];
- frame->tf_ret1 = rval[!retq];
+ frame->tf_ret1 = rval[1];
frame->tf_t1 = 0;
break;
case ERESTART:
@@ -872,7 +859,7 @@ syscall(struct trapframe *frame)
break;
}
- ast(p);
+ ast(p); // XXX why?
mi_syscall_return(p, code, error, rval);
Index: sys/arch/i386/i386/trap.c
===================================================================
RCS file: /cvs/src/sys/arch/i386/i386/trap.c,v
diff -u -p -u -r1.162 trap.c
--- sys/arch/i386/i386/trap.c 16 Apr 2023 06:43:49 -0000 1.162
+++ sys/arch/i386/i386/trap.c 28 Oct 2023 15:11:05 -0000
@@ -516,9 +516,9 @@ void
syscall(struct trapframe *frame)
{
caddr_t params;
- const struct sysent *callp;
- struct proc *p;
- int error, indirect = -1;
+ const struct sysent *callp = sysent;
+ struct proc *p = curproc;
+ int error = ENOSYS;
register_t code, args[8], rval[2];
#ifdef DIAGNOSTIC
int ocpl = lapic_tpr;
@@ -540,38 +540,22 @@ syscall(struct trapframe *frame)
}
#endif
- p = curproc;
p->p_md.md_regs = frame;
- code = frame->tf_eax;
-
- params = (caddr_t)frame->tf_esp + sizeof(int);
- switch (code) {
- case SYS_syscall:
- /*
- * Code is first argument, followed by actual args.
- */
- indirect = code;
- copyin(params, &code, sizeof(int));
- params += sizeof(int);
- break;
- default:
- break;
- }
+ code = frame->tf_eax;
+ if (code <= 0 || code >= SYS_MAXSYSCALL)
+ goto bad;
+ callp += code;
- callp = sysent;
- if (code < 0 || code >= SYS_MAXSYSCALL)
- callp += SYS_syscall;
- else
- callp += code;
argsize = callp->sy_argsize;
+ params = (caddr_t)frame->tf_esp + sizeof(int);
if (argsize && (error = copyin(params, args, argsize)))
goto bad;
rval[0] = 0;
rval[1] = frame->tf_edx;
- error = mi_syscall(p, code, indirect, callp, args, rval);
+ error = mi_syscall(p, code, callp, args, rval);
switch (error) {
case 0:
Index: sys/arch/m88k/m88k/trap.c
===================================================================
RCS file: /cvs/src/sys/arch/m88k/m88k/trap.c,v
diff -u -p -u -r1.128 trap.c
--- sys/arch/m88k/m88k/trap.c 2 Aug 2023 06:14:46 -0000 1.128
+++ sys/arch/m88k/m88k/trap.c 28 Oct 2023 15:32:21 -0000
@@ -1153,9 +1153,9 @@ void
m88100_syscall(register_t code, struct trapframe *tf)
{
int i, nap;
- const struct sysent *callp;
+ const struct sysent *callp = sysent;
struct proc *p = curproc;
- int error, indirect = -1;
+ int error = ENOSYS;
register_t args[8] __aligned(8);
register_t rval[2] __aligned(8);
register_t *ap;
@@ -1170,21 +1170,11 @@ m88100_syscall(register_t code, struct t
* For syscall, r2 has the actual code.
*/
ap = &tf->tf_r[2];
- nap = 8; /* r2-r9 */
-
- switch (code) {
- case SYS_syscall:
- indirect = code;
- code = *ap++;
- nap--;
- break;
- }
+ nap = 8; /* r2-r9 */
- callp = sysent;
- if (code < 0 || code >= SYS_MAXSYSCALL)
- callp += SYS_syscall;
- else
- callp += code;
+ if (code <= 0 || code >= SYS_MAXSYSCALL)
+ goto bad;
+ callp += code;
i = callp->sy_argsize / sizeof(register_t);
if (i > sizeof(args) / sizeof(register_t))
@@ -1200,7 +1190,7 @@ m88100_syscall(register_t code, struct t
rval[0] = 0;
rval[1] = tf->tf_r[3];
- error = mi_syscall(p, code, indirect, callp, args, rval);
+ error = mi_syscall(p, code, callp, args, rval);
/*
* system call will look like:
@@ -1266,9 +1256,9 @@ void
m88110_syscall(register_t code, struct trapframe *tf)
{
int i, nap;
- const struct sysent *callp;
+ const struct sysent *callp = sysent;
struct proc *p = curproc;
- int error;
+ int error = ENOSYS;
register_t args[8] __aligned(8);
register_t rval[2] __aligned(8);
register_t *ap;
@@ -1285,18 +1275,9 @@ m88110_syscall(register_t code, struct t
ap = &tf->tf_r[2];
nap = 8; /* r2-r9 */
- switch (code) {
- case SYS_syscall:
- code = *ap++;
- nap--;
- break;
- }
-
- callp = sysent;
- if (code < 0 || code >= SYS_MAXSYSCALL)
- callp += SYS_syscall;
- else
- callp += code;
+ if (code <= 0 || code >= SYS_MAXSYSCALL)
+ goto bad;
+ callp += code;
i = callp->sy_argsize / sizeof(register_t);
if (i > sizeof(args) / sizeof(register_t))
Index: sys/arch/mips64/mips64/trap.c
===================================================================
RCS file: /cvs/src/sys/arch/mips64/mips64/trap.c,v
diff -u -p -u -r1.167 trap.c
--- sys/arch/mips64/mips64/trap.c 26 Apr 2023 16:53:59 -0000 1.167
+++ sys/arch/mips64/mips64/trap.c 28 Oct 2023 15:11:05 -0000
@@ -396,14 +396,12 @@ fault_common_no_miss:
case T_SYSCALL+T_USER:
{
struct trapframe *locr0 = p->p_md.md_regs;
- const struct sysent *callp;
- unsigned int code, indirect = -1;
+ const struct sysent *callp = sysent;
+ unsigned int code;
register_t tpc;
uint32_t branch = 0;
- int error, numarg;
- struct args {
- register_t i[8];
- } args;
+ int error = ENOSYS, numarg;
+ register_t args[8];
register_t rval[2];
atomic_inc_int(&uvmexp.syscalls);
@@ -422,51 +420,22 @@ fault_common_no_miss:
trapframe->pc, 0, branch);
} else
locr0->pc += 4;
- callp = sysent;
code = locr0->v0;
- switch (code) {
- case SYS_syscall:
- /*
- * Code is first argument, followed by actual args.
- */
- indirect = code;
- code = locr0->a0;
- if (code >= SYS_MAXSYSCALL)
- callp += SYS_syscall;
- else
- callp += code;
- numarg = callp->sy_argsize / sizeof(register_t);
- args.i[0] = locr0->a1;
- args.i[1] = locr0->a2;
- args.i[2] = locr0->a3;
- if (numarg > 3) {
- args.i[3] = locr0->a4;
- args.i[4] = locr0->a5;
- args.i[5] = locr0->a6;
- args.i[6] = locr0->a7;
- if (numarg > 7)
- if ((error = copyin((void *)locr0->sp,
- &args.i[7], sizeof(register_t))))
- goto bad;
- }
- break;
- default:
- if (code >= SYS_MAXSYSCALL)
- callp += SYS_syscall;
- else
- callp += code;
-
- numarg = callp->sy_narg;
- args.i[0] = locr0->a0;
- args.i[1] = locr0->a1;
- args.i[2] = locr0->a2;
- args.i[3] = locr0->a3;
- if (numarg > 4) {
- args.i[4] = locr0->a4;
- args.i[5] = locr0->a5;
- args.i[6] = locr0->a6;
- args.i[7] = locr0->a7;
- }
+
+ if (code <= 0 || code >= SYS_MAXSYSCALL)
+ goto bad;
+ callp += code;
+
+ numarg = callp->sy_narg;
+ args[0] = locr0->a0;
+ args[1] = locr0->a1;
+ args[2] = locr0->a2;
+ args[3] = locr0->a3;
+ if (numarg > 4) {
+ args[4] = locr0->a4;
+ args[5] = locr0->a5;
+ args[6] = locr0->a6;
+ args[7] = locr0->a7;
}
rval[0] = 0;
@@ -477,29 +446,24 @@ fault_common_no_miss:
TRAPSIZE : trppos[ci->ci_cpuid]) - 1].code = code;
#endif
- error = mi_syscall(p, code, indirect, callp, args.i, rval);
+ error = mi_syscall(p, code, callp, args, rval);
switch (error) {
case 0:
locr0->v0 = rval[0];
locr0->a3 = 0;
break;
-
case ERESTART:
locr0->pc = tpc;
break;
-
case EJUSTRETURN:
break; /* nothing to do */
-
default:
- bad:
locr0->v0 = error;
locr0->a3 = 1;
}
mi_syscall_return(p, code, error, rval);
-
return;
}
Index: sys/arch/powerpc/powerpc/trap.c
===================================================================
RCS file: /cvs/src/sys/arch/powerpc/powerpc/trap.c,v
diff -u -p -u -r1.131 trap.c
--- sys/arch/powerpc/powerpc/trap.c 11 Feb 2023 23:07:27 -0000 1.131
+++ sys/arch/powerpc/powerpc/trap.c 28 Oct 2023 15:11:05 -0000
@@ -239,11 +239,11 @@ trap(struct trapframe *frame)
struct vm_map *map;
vaddr_t va;
int access_type;
- const struct sysent *callp;
+ const struct sysent *callp = sysent;
size_t argsize;
- register_t code, error;
+ register_t code, error = ENOSYS;
register_t *params, rval[2], args[10];
- int n, indirect = -1;
+ int n;
if (frame->srr1 & PSL_PR) {
type |= EXC_USER;
@@ -360,27 +360,13 @@ trap(struct trapframe *frame)
case EXC_SC|EXC_USER:
uvmexp.syscalls++;
- code = frame->fixreg[0];
params = frame->fixreg + FIRSTARG;
- switch (code) {
- case SYS_syscall:
- /*
- * code is first argument,
- * followed by actual args.
- */
- indirect = code;
- code = *params++;
- break;
- default:
- break;
- }
+ code = frame->fixreg[0];
+ if (code <= 0 || code >= SYS_MAXSYSCALL)
+ goto bad;
+ callp += code;
- callp = sysent;
- if (code < 0 || code >= SYS_MAXSYSCALL)
- callp += SYS_syscall;
- else
- callp += code;
argsize = callp->sy_argsize;
n = NARGREG - (params - (frame->fixreg + FIRSTARG));
if (argsize > n * sizeof(register_t)) {
@@ -395,7 +381,7 @@ trap(struct trapframe *frame)
rval[0] = 0;
rval[1] = frame->fixreg[FIRSTARG + 1];
- error = mi_syscall(p, code, indirect, callp, params, rval);
+ error = mi_syscall(p, code, callp, params, rval);
switch (error) {
case 0:
Index: sys/arch/powerpc64/powerpc64/syscall.c
===================================================================
RCS file: /cvs/src/sys/arch/powerpc64/powerpc64/syscall.c,v
diff -u -p -u -r1.11 syscall.c
--- sys/arch/powerpc64/powerpc64/syscall.c 11 Feb 2023 23:07:27 -0000 1.11
+++ sys/arch/powerpc64/powerpc64/syscall.c 28 Oct 2023 15:11:05 -0000
@@ -30,27 +30,17 @@ void
syscall(struct trapframe *frame)
{
struct proc *p = curproc;
- const struct sysent *callp;
- int code, error, indirect = -1;
+ const struct sysent *callp = sysent;
+ int code, error = ENOSYS;
int nap = 8, nargs;
register_t *ap, *args, copyargs[MAXARGS], rval[2];
- code = frame->fixreg[0];
ap = &frame->fixreg[3];
+ code = frame->fixreg[0];
+ if (code <= 0 || code >= SYS_MAXSYSCALL)
+ goto bad;
+ callp += code;
- switch (code) {
- case SYS_syscall:
- indirect = code;
- code = *ap++;
- nap--;
- break;
- }
-
- callp = sysent;
- if (code < 0 || code >= SYS_MAXSYSCALL)
- callp += SYS_syscall;
- else
- callp += code;
nargs = callp->sy_argsize / sizeof(register_t);
if (nargs <= nap) {
args = ap;
@@ -66,7 +56,7 @@ syscall(struct trapframe *frame)
rval[0] = 0;
rval[1] = 0;
- error = mi_syscall(p, code, indirect, callp, args, rval);
+ error = mi_syscall(p, code, callp, args, rval);
switch (error) {
case 0:
@@ -74,15 +64,12 @@ syscall(struct trapframe *frame)
frame->fixreg[3] = rval[0];
frame->cr &= ~0x10000000;
break;
-
case ERESTART:
frame->srr0 -= 4;
break;
-
case EJUSTRETURN:
/* nothing to do */
break;
-
default:
bad:
frame->fixreg[0] = error;
Index: sys/arch/riscv64/riscv64/syscall.c
===================================================================
RCS file: /cvs/src/sys/arch/riscv64/riscv64/syscall.c,v
diff -u -p -u -r1.16 syscall.c
--- sys/arch/riscv64/riscv64/syscall.c 13 Apr 2023 02:19:05 -0000 1.16
+++ sys/arch/riscv64/riscv64/syscall.c 28 Oct 2023 15:11:05 -0000
@@ -39,33 +39,20 @@ void
svc_handler(trapframe_t *frame)
{
struct proc *p = curproc;
- const struct sysent *callp;
- int code, error, indirect = -1;
+ const struct sysent *callp = sysent;
+ int code, error = ENOSYS;
u_int nap = 8, nargs;
register_t *ap, *args, copyargs[MAXARGS], rval[2];
uvmexp.syscalls++;
- /* Re-enable interrupts if they were enabled previously */
- if (__predict_true(frame->tf_scause & EXCP_INTR))
- intr_enable();
-
ap = &frame->tf_a[0];
code = frame->tf_t[0];
- switch (code) {
- case SYS_syscall:
- indirect = code;
- code = *ap++;
- nap--;
- break;
- }
+ if (code <= 0 || code >= SYS_MAXSYSCALL)
+ goto bad;
+ callp += code;
- callp = sysent;
- if (code < 0 || code >= SYS_MAXSYSCALL)
- callp += SYS_syscall;
- else
- callp += code;
nargs = callp->sy_argsize / sizeof(register_t);
if (nargs <= nap) {
args = ap;
@@ -81,21 +68,18 @@ svc_handler(trapframe_t *frame)
rval[0] = 0;
rval[1] = 0;
- error = mi_syscall(p, code, indirect, callp, args, rval);
+ error = mi_syscall(p, code, callp, args, rval);
switch (error) {
case 0:
frame->tf_a[0] = rval[0];
frame->tf_t[0] = 0; /* syscall succeeded */
break;
-
case ERESTART:
frame->tf_sepc -= 4; /* prev instruction */
break;
-
case EJUSTRETURN:
break;
-
default:
bad:
frame->tf_a[0] = error;
Index: sys/arch/sh/sh/trap.c
===================================================================
RCS file: /cvs/src/sys/arch/sh/sh/trap.c,v
diff -u -p -u -r1.54 trap.c
--- sys/arch/sh/sh/trap.c 11 Feb 2023 23:07:27 -0000 1.54
+++ sys/arch/sh/sh/trap.c 28 Oct 2023 15:11:05 -0000
@@ -516,44 +516,20 @@ syscall(struct proc *p, struct trapframe
{
caddr_t params;
const struct sysent *callp;
- int error, opc, indirect = -1;
- int argoff, argsize;
+ int error = ENOSYS, opc;
+ int argsize;
register_t code, args[8], rval[2];
uvmexp.syscalls++;
opc = tf->tf_spc;
code = tf->tf_r0;
-
params = (caddr_t)tf->tf_r15;
- switch (code) {
- case SYS_syscall:
- /*
- * Code is first argument, followed by actual args.
- */
- indirect = code;
- code = tf->tf_r4;
- argoff = 1;
- break;
- default:
- argoff = 0;
- break;
- }
-
- callp = sysent;
- if (code < 0 || code >= SYS_MAXSYSCALL)
- callp += SYS_syscall;
- else
- callp += code;
+ if (code <= 0 || code >= SYS_MAXSYSCALL)
+ goto bad;
+ callp = sysent + code;
argsize = callp->sy_argsize;
-#ifdef DIAGNOSTIC
- if (argsize > sizeof args) {
- callp += SYS_syscall - code;
- argsize = callp->sy_argsize;
- }
-#endif
-
if (argsize) {
register_t *ap;
int off_t_arg;
@@ -570,19 +546,16 @@ syscall(struct proc *p, struct trapframe
}
ap = args;
- switch (argoff) {
- case 0: *ap++ = tf->tf_r4; argsize -= sizeof(int);
- case 1: *ap++ = tf->tf_r5; argsize -= sizeof(int);
- case 2: *ap++ = tf->tf_r6; argsize -= sizeof(int);
- /*
- * off_t args aren't split between register
- * and stack, but rather r7 is skipped and
- * the entire off_t is on the stack.
- */
- if (argoff + off_t_arg == 3)
- break;
+ *ap++ = tf->tf_r4; argsize -= sizeof(int);
+ *ap++ = tf->tf_r5; argsize -= sizeof(int);
+ *ap++ = tf->tf_r6; argsize -= sizeof(int);
+ /*
+ * off_t args aren't split between register
+ * and stack, but rather r7 is skipped and
+ * the entire off_t is on the stack.
+ */
+ if (off_t_arg != 3) {
*ap++ = tf->tf_r7; argsize -= sizeof(int);
- break;
}
if (argsize > 0) {
@@ -594,7 +567,7 @@ syscall(struct proc *p, struct trapframe
rval[0] = 0;
rval[1] = tf->tf_r1;
- error = mi_syscall(p, code, indirect, callp, args, rval);
+ error = mi_syscall(p, code, callp, args, rval);
switch (error) {
case 0:
Index: sys/arch/sparc64/sparc64/trap.c
===================================================================
RCS file: /cvs/src/sys/arch/sparc64/sparc64/trap.c,v
diff -u -p -u -r1.115 trap.c
--- sys/arch/sparc64/sparc64/trap.c 11 Feb 2023 23:07:28 -0000 1.115
+++ sys/arch/sparc64/sparc64/trap.c 28 Oct 2023 15:11:05 -0000
@@ -1109,9 +1109,10 @@ syscall(struct trapframe *tf, register_t
int64_t *ap;
const struct sysent *callp;
struct proc *p = curproc;
- int error, new, indirect = -1;
+ int error = ENOSYS, new;
register_t args[8];
register_t rval[2];
+ register_t *argp;
if ((tf->tf_out[6] & 1) == 0)
sigexit(p, SIGILL);
@@ -1137,44 +1138,31 @@ syscall(struct trapframe *tf, register_t
ap = &tf->tf_out[0];
nap = 6;
- switch (code) {
- case SYS_syscall:
- indirect = code;
- code = *ap++;
- nap--;
- break;
- }
-
- callp = sysent;
- if (code < 0 || code >= SYS_MAXSYSCALL)
- callp += SYS_syscall;
- else {
- register_t *argp;
-
- callp += code;
- i = callp->sy_narg; /* Why divide? */
- if (i > nap) { /* usually false */
- if (i > 8)
- panic("syscall nargs");
- /* Read the whole block in */
- if ((error = copyin((caddr_t)tf->tf_out[6]
- + BIAS + offsetof(struct frame, fr_argx),
- &args[nap], (i - nap) * sizeof(register_t))))
- goto bad;
- i = nap;
- }
- /*
- * It should be faster to do <= 6 longword copies than
- * to call bcopy
- */
- for (argp = args; i--;)
- *argp++ = *ap++;
+ if (code <= 0 || code >= SYS_MAXSYSCALL)
+ goto bad;
+ callp = sysent + code;
+ i = callp->sy_narg; /* Why divide? */
+ if (i > nap) { /* usually false */
+ if (i > 8)
+ panic("syscall nargs");
+ /* Read the whole block in */
+ if ((error = copyin((caddr_t)tf->tf_out[6]
+ + BIAS + offsetof(struct frame, fr_argx),
+ &args[nap], (i - nap) * sizeof(register_t))))
+ goto bad;
+ i = nap;
}
+ /*
+ * It should be faster to do <= 6 longword copies than
+ * to call bcopy
+ */
+ for (argp = args; i--;)
+ *argp++ = *ap++;
rval[0] = 0;
rval[1] = 0;
- error = mi_syscall(p, code, indirect, callp, args, rval);
+ error = mi_syscall(p, code, callp, args, rval);
switch (error) {
vaddr_t dest;
Index: sys/kern/kern_ktrace.c
===================================================================
RCS file: /cvs/src/sys/kern/kern_ktrace.c,v
diff -u -p -u -r1.112 kern_ktrace.c
--- sys/kern/kern_ktrace.c 11 May 2023 09:51:33 -0000 1.112
+++ sys/kern/kern_ktrace.c 28 Oct 2023 15:11:05 -0000
@@ -160,7 +160,7 @@ ktrsyscall(struct proc *p, register_t co
u_int nargs = 0;
int i;
- if ((code & KTRC_CODE_MASK) == SYS_sysctl) {
+ if (code == SYS_sysctl) {
/*
* The sysctl encoding stores the mib[]
* array because it is interesting.
Index: sys/sys/ktrace.h
===================================================================
RCS file: /cvs/src/sys/sys/ktrace.h,v
diff -u -p -u -r1.46 ktrace.h
--- sys/sys/ktrace.h 23 Feb 2023 01:33:20 -0000 1.46
+++ sys/sys/ktrace.h 28 Oct 2023 15:11:05 -0000
@@ -76,8 +76,6 @@ struct ktr_header {
#define KTR_SYSCALL 1
struct ktr_syscall {
int ktr_code; /* syscall number */
-#define KTRC_CODE_MASK 0x0000ffff
-#define KTRC_CODE_SYSCALL 0x20000000
int ktr_argsize; /* size of arguments */
/*
* followed by ktr_argsize/sizeof(register_t) "register_t"s
Index: sys/sys/syscall_mi.h
===================================================================
RCS file: /cvs/src/sys/sys/syscall_mi.h,v
diff -u -p -u -r1.28 syscall_mi.h
--- sys/sys/syscall_mi.h 11 Feb 2023 23:07:23 -0000 1.28
+++ sys/sys/syscall_mi.h 28 Oct 2023 15:11:05 -0000
@@ -51,8 +51,8 @@
* The MD setup for a system call has been done; here's the MI part.
*/
static inline int
-mi_syscall(struct proc *p, register_t code, int indirect,
- const struct sysent *callp, register_t *argp, register_t retval[2])
+mi_syscall(struct proc *p, register_t code, const struct sysent *callp,
+ register_t *argp, register_t retval[2])
{
uint64_t tval;
int lock = !(callp->sy_flags & SY_NOLOCK);
@@ -73,15 +73,8 @@ mi_syscall(struct proc *p, register_t co
#ifdef KTRACE
if (KTRPOINT(p, KTR_SYSCALL)) {
/* convert to mask, then include with code */
- switch (indirect) {
- case SYS_syscall:
- indirect = KTRC_CODE_SYSCALL;
- break;
- default:
- indirect = 0;
- }
KERNEL_LOCK();
- ktrsyscall(p, code | indirect, callp->sy_argsize, argp);
+ ktrsyscall(p, code, callp->sy_argsize, argp);
KERNEL_UNLOCK();
}
#endif
Index: usr.bin/kdump/kdump.c
===================================================================
RCS file: /cvs/src/usr.bin/kdump/kdump.c,v
diff -u -p -u -r1.158 kdump.c
--- usr.bin/kdump/kdump.c 21 Aug 2023 01:37:56 -0000 1.158
+++ usr.bin/kdump/kdump.c 28 Oct 2023 15:11:05 -0000
@@ -926,9 +926,6 @@ ktrsyscall(struct ktr_syscall *ktr, size
narg = ktr->ktr_argsize / sizeof(register_t);
sep = '\0';
- if (ktr->ktr_code & KTRC_CODE_SYSCALL)
- (void)printf("(via syscall) ");
- code = ktr->ktr_code & KTRC_CODE_MASK;
if (code >= SYS_MAXSYSCALL || code < 0)
(void)printf("[%d]", code);
else
Index: include/unistd.h
===================================================================
RCS file: /cvs/src/include/unistd.h,v
diff -u -p -u -r1.107 unistd.h
--- include/unistd.h 7 Jan 2023 05:24:58 -0000 1.107
+++ include/unistd.h 23 Oct 2023 21:10:08 -0000
@@ -522,7 +522,6 @@ int setthrname(pid_t, const char *);
void setusershell(void);
int strtofflags(char **, u_int32_t *, u_int32_t *);
int swapctl(int cmd, const void *arg, int misc);
-int syscall(int, ...);
int getentropy(void *, size_t);
int pledge(const char *, const char *);
int unveil(const char *, const char *);
Index: lib/libc/Symbols.list
===================================================================
RCS file: /cvs/src/lib/libc/Symbols.list,v
diff -u -p -u -r1.83 Symbols.list
--- lib/libc/Symbols.list 20 Aug 2023 15:17:53 -0000 1.83
+++ lib/libc/Symbols.list 23 Oct 2023 21:10:08 -0000
@@ -434,7 +434,6 @@ symlink
symlinkat
sync
sysarch
-syscall
timer_create
timer_delete
timer_getoverrun
Index: lib/libc/hidden/unistd.h
===================================================================
RCS file: /cvs/src/lib/libc/hidden/unistd.h,v
diff -u -p -u -r1.12 unistd.h
--- lib/libc/hidden/unistd.h 18 May 2023 16:11:09 -0000 1.12
+++ lib/libc/hidden/unistd.h 23 Oct 2023 21:10:08 -0000
@@ -157,7 +157,6 @@ PROTO_NORMAL(swapctl);
PROTO_NORMAL(symlink);
PROTO_NORMAL(symlinkat);
PROTO_NORMAL(sync);
-PROTO_NORMAL(syscall);
PROTO_NORMAL(sysconf);
PROTO_DEPRECATED(tcgetpgrp);
PROTO_DEPRECATED(tcsetpgrp);
Index: lib/libc/sys/Makefile.inc
===================================================================
RCS file: /cvs/src/lib/libc/sys/Makefile.inc,v
diff -u -p -u -r1.174 Makefile.inc
--- lib/libc/sys/Makefile.inc 20 Aug 2023 15:17:53 -0000 1.174
+++ lib/libc/sys/Makefile.inc 23 Oct 2023 21:10:08 -0000
@@ -8,7 +8,7 @@
# modules with non-default implementations on at least one architecture:
SRCS+= Ovfork.S brk.S ${CERROR} \
sbrk.S sigpending.S sigprocmask.S \
- sigsuspend.S syscall.S tfork_thread.S
+ sigsuspend.S tfork_thread.S
# glue to offer userland wrappers for some syscalls
SRCS+= posix_madvise.c pthread_sigmask.c \
@@ -216,7 +216,7 @@ MAN+= __get_tcb.2 __thrsigdivert.2 __thr
shmctl.2 shmget.2 shutdown.2 sigaction.2 sigaltstack.2 sigpending.2 \
sigprocmask.2 sigreturn.2 sigsuspend.2 socket.2 \
socketpair.2 stat.2 statfs.2 swapctl.2 symlink.2 \
- sync.2 sysarch.2 syscall.2 sysctl.2 thrkill.2 truncate.2 \
+ sync.2 sysarch.2 sysctl.2 thrkill.2 truncate.2 \
umask.2 unlink.2 unveil.2 utimes.2 utrace.2 vfork.2 \
wait.2 waitid.2 write.2 \
ypconnect.2
Index: lib/libc/sys/syscall.2
===================================================================
RCS file: /cvs/src/lib/libc/sys/syscall.2,v
diff -u -p -u -r1.16 syscall.2
--- lib/libc/sys/syscall.2 22 Feb 2023 07:04:50 -0000 1.16
+++ lib/libc/sys/syscall.2 23 Oct 2023 21:10:08 -0000
@@ -1,68 +0,0 @@
-.\" $OpenBSD: syscall.2,v 1.16 2023/02/22 07:04:50 jmc Exp $
-.\" $NetBSD: syscall.2,v 1.4 1995/02/27 12:38:53 cgd Exp $
-.\"
-.\" Copyright (c) 1980, 1991, 1993
-.\" The Regents of the University of California. All rights reserved.
-.\"
-.\" Redistribution and use in source and binary forms, with or without
-.\" modification, are permitted provided that the following conditions
-.\" are met:
-.\" 1. Redistributions of source code must retain the above copyright
-.\" notice, this list of conditions and the following disclaimer.
-.\" 2. Redistributions in binary form must reproduce the above copyright
-.\" notice, this list of conditions and the following disclaimer in the
-.\" documentation and/or other materials provided with the distribution.
-.\" 3. Neither the name of the University nor the names of its contributors
-.\" may be used to endorse or promote products derived from this software
-.\" without specific prior written permission.
-.\"
-.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
-.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-.\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
-.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
-.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
-.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
-.\" SUCH DAMAGE.
-.\"
-.\" @(#)syscall.2 8.1 (Berkeley) 6/16/93
-.\"
-.Dd $Mdocdate: February 22 2023 $
-.Dt SYSCALL 2
-.Os
-.Sh NAME
-.Nm syscall
-.Nd indirect system call
-.Sh SYNOPSIS
-.In sys/syscall.h
-.In unistd.h
-.Ft int
-.Fn syscall "int number" "..."
-.Sh DESCRIPTION
-.Fn syscall
-performs the system call whose assembly language
-interface has the specified
-.Fa number
-with the specified arguments.
-Symbolic constants for system calls can be found in the header file
-.In sys/syscall.h .
-.Sh RETURN VALUES
-The return values are defined by the system call being invoked.
-In general, for system calls returning
-.Va int ,
-a 0 return value indicates success.
-A \-1 return value indicates an error,
-and an error code is stored in
-.Va errno .
-.Sh HISTORY
-The predecessor of these functions, the former
-.Fn indir
-system call, first appeared in
-.At v4 .
-The
-.Fn syscall
-function first appeared in
-.Bx 3 .
Index: kern/syscalls.master
===================================================================
RCS file: /cvs/src/sys/kern/syscalls.master,v
diff -u -p -u -r1.250 syscalls.master
--- kern/syscalls.master 20 Aug 2023 15:13:43 -0000 1.250
+++ kern/syscalls.master 28 Oct 2023 15:21:00 -0000
@@ -12,8 +12,6 @@
; compatibility options defined in syscalls.conf
;
; types:
-; INDIR included, but don't define the syscall args structure,
-; and allow it to be "really" varargs
; NOARGS included, but don't define the syscall args structure
; NODEF included, but don't define the syscall number
; NOLOCK don't acquire the kernel lock when calling this syscall
@@ -48,7 +46,7 @@
; redistributions should be placed in the reserved range at the end
; of the current calls.
-0 INDIR { int sys_syscall(int number, ...); }
+0 UNIMPL stupidsyscall
1 STD { void sys_exit(int rval); }
2 STD { int sys_fork(void); }
3 STD NOLOCK { ssize_t sys_read(int fd, void *buf, size_t nbyte); }
Index: kern/makesyscalls.sh
===================================================================
RCS file: /cvs/src/sys/kern/makesyscalls.sh,v
diff -u -p -u -r1.20 makesyscalls.sh
--- kern/makesyscalls.sh 7 Apr 2023 09:43:38 -0000 1.20
+++ kern/makesyscalls.sh 28 Oct 2023 15:23:20 -0000
@@ -296,10 +296,6 @@ function parseline() {
# arguments, they must still have arguments specified for
# the remaining argument "positions," because of the way the
# kernel system call argument handling works.
- #
- # Indirect system calls, e.g. syscall(), are exceptions to this
- # rule, since they are handled entirely by machine-dependent code
- # and do not need argument structures built.
isvarargs = 0;
while (f <= end) {
@@ -326,59 +322,50 @@ function parseline() {
}
# must see another argument after varargs notice.
if (isvarargs) {
- if (argc == varargc && $2 != "INDIR")
+ if (argc == varargc)
parserr($f, "argument definition")
} else
varargc = argc;
}
function putent(nodefs, compatwrap) {
- # output syscall declaration for switch table. INDIR functions
- # get none, since they always have sys_nosys() for their table
- # entries.
- if (nodefs != "INDIR") {
- prototype = "(struct proc *, void *, register_t *)"
- if (compatwrap == "")
- printf("int\t%s%s;\n", funcname,
- prototype) > sysprotos
- else
- printf("int\t%s_%s%s;\n", compatwrap, funcname,
- prototype) > sysprotos
- }
+ # output syscall declaration for switch table.
+ prototype = "(struct proc *, void *, register_t *)"
+ if (compatwrap == "")
+ printf("int\t%s%s;\n", funcname,
+ prototype) > sysprotos
+ else
+ printf("int\t%s_%s%s;\n", compatwrap, funcname,
+ prototype) > sysprotos
# output syscall switch entry
- if (nodefs == "INDIR") {
- printf("\t{ 0, 0, %s,\n\t sys_nosys },\t\t\t/* %d = %s (indir) */\n", \
- sycall_flags, syscall, funcalias) > sysent
- } else {
-# printf("\t{ { %d", argc) > sysent
-# for (i = 1; i <= argc; i++) {
-# if (i == 5) # wrap the line
-# printf(",\n\t ") > sysent
-# else
-# printf(", ") > sysent
-# printf("s(%s)", argtypenospc[i]) > sysent
-# }
- printf("\t{ %d, ", argc) > sysent
- if (argc == 0)
- printf("0") > sysent
- else if (compatwrap == "")
- printf("s(struct %s_args)", funcname) > sysent
- else
- printf("s(struct %s_%s_args)", compatwrap,
- funcname) > sysent
- if (compatwrap == "")
- wfn = sprintf("%s", funcname);
- else
- wfn = sprintf("%s(%s)", compatwrap, funcname);
- printf(", %s,\n\t %s },", sycall_flags, wfn) > sysent
- for (i = 0; i < (33 - length(wfn)) / 8; i++)
- printf("\t") > sysent
- if (compatwrap == "")
- printf("/* %d = %s */\n", syscall, funcalias) > sysent
- else
- printf("/* %d = %s %s */\n", syscall, compatwrap,
- funcalias) > sysent
- }
+# printf("\t{ { %d", argc) > sysent
+# for (i = 1; i <= argc; i++) {
+# if (i == 5) # wrap the line
+# printf(",\n\t ") > sysent
+# else
+# printf(", ") > sysent
+# printf("s(%s)", argtypenospc[i]) > sysent
+# }
+ printf("\t{ %d, ", argc) > sysent
+ if (argc == 0)
+ printf("0") > sysent
+ else if (compatwrap == "")
+ printf("s(struct %s_args)", funcname) > sysent
+ else
+ printf("s(struct %s_%s_args)", compatwrap,
+ funcname) > sysent
+ if (compatwrap == "")
+ wfn = sprintf("%s", funcname);
+ else
+ wfn = sprintf("%s(%s)", compatwrap, funcname);
+ printf(", %s,\n\t %s },", sycall_flags, wfn) > sysent
+ for (i = 0; i < (33 - length(wfn)) / 8; i++)
+ printf("\t") > sysent
+ if (compatwrap == "")
+ printf("/* %d = %s */\n", syscall, funcalias) > sysent
+ else
+ printf("/* %d = %s %s */\n", syscall, compatwrap,
+ funcalias) > sysent
# output syscall name for names table
if (compatwrap == "")
@@ -389,7 +376,7 @@ function putent(nodefs, compatwrap) {
funcalias, syscall, compatwrap, funcalias) > sysnames
# output syscall number of header, if appropriate
- if (nodefs == "" || nodefs == "NOARGS" || nodefs == "INDIR") {
+ if (nodefs == "" || nodefs == "NOARGS") {
# output a prototype, to be used to generate lint stubs in
# libc.
printf("/* syscall: \"%s\" ret: \"%s\" args:", funcalias,
@@ -410,7 +397,7 @@ function putent(nodefs, compatwrap) {
compatwrap, funcalias) > sysnumhdr
# output syscall argument structure, if it has arguments
- if (argc != 0 && nodefs != "NOARGS" && nodefs != "INDIR") {
+ if (argc != 0 && nodefs != "NOARGS") {
if (compatwrap == "")
printf("\nstruct %s_args {\n", funcname) > sysarghdr
else
@@ -428,7 +415,7 @@ $2 == "STD" {
syscall++
next
}
-$2 == "NODEF" || $2 == "NOARGS" || $2 == "INDIR" {
+$2 == "NODEF" || $2 == "NOARGS" {
parseline()
putent($2, "")
syscall++
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic