aboutsummaryrefslogtreecommitdiff
path: root/sys/kern/syscalls.master
blob: 8f47a4980b4fbbf19d20f1f5282d5e282fea5411 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
 $FreeBSD$
;	from: @(#)syscalls.master	8.2 (Berkeley) 1/13/94
;
; System call name/number master file.
; Processed to created init_sysent.c, syscalls.c and syscall.h.

; Columns: number audit [M]type name alt{name,tag,rtyp}/comments
;	number	system call number, must be in order
;	audit	the audit event associated with the system call
;		A value of AUE_NULL means no auditing, but it also means that
;		there is no audit event for the call at this time. For the
;		case where the event exists, but we don't want auditing, the
;		event should be #defined to AUE_NULL in audit_kevents.h.
;	type	one of [M]STD, [M]OBSOL, [M]UNIMPL, [M]COMPAT, [M]CPT_NOA,
;		[M]LIBCOMPAT, [M]NODEF, [M]NOARGS, [M]NOPROTO, [M]NOIMPL,
;		[M]NOSTD, [M]COMPAT4
;	name	psuedo-prototype of syscall routine
;		If one of the following alts is different, then all appear:
;	altname	name of system call if different
;	alttag	name of args struct tag if different from [o]`name'"_args"
;	altrtyp	return type if not int (bogus - syscalls always return int)
;		for UNIMPL/OBSOL, name continues with comments

; types:
;	[M]	e.g. like MSTD -- means the system call is MP-safe.  If no
;		M prefix is used, the syscall wrapper will obtain the Giant
;		lock for the syscall.
;	STD	always included
;	COMPAT	included on COMPAT #ifdef
;	COMPAT4	included on COMPAT4 #ifdef (FreeBSD 4 compat)
;	LIBCOMPAT included on COMPAT #ifdef, and placed in syscall.h
;	OBSOL	obsolete, not included in system, only specifies name
;	UNIMPL	not implemented, placeholder only
;	NOSTD	implemented but as a lkm that can be statically
;			compiled in sysent entry will be filled with lkmsys
;			so the SYSCALL_MODULE macro works
;
; Please copy any additions and changes to the following compatability tables:
; sys/compat/freebsd32/syscalls.master

; #ifdef's, etc. may be included, and are copied to the output files.

#include <sys/param.h>
#include <sys/sysent.h>
#include <sys/sysproto.h>

; Reserved/unimplemented system calls in the range 0-150 inclusive
; are reserved for use in future Berkeley releases.
; Additional system calls implemented in vendor and other
; redistributions should be placed in the reserved range at the end
; of the current calls.

0	AUE_NULL	MSTD	{ int nosys(void); } syscall nosys_args int
1	AUE_EXIT	MSTD	{ void sys_exit(int rval); } exit \
				    sys_exit_args void
2	AUE_FORK	MSTD	{ int fork(void); }
3	AUE_NULL	MSTD	{ ssize_t read(int fd, void *buf, \
				    size_t nbyte); }
4	AUE_NULL	MSTD	{ ssize_t write(int fd, const void *buf, \
				    size_t nbyte); }
5	AUE_OPEN_RWTC	MSTD	{ int open(char *path, int flags, int mode); }
; XXX should be		{ int open(const char *path, int flags, ...); }
; but we're not ready for `const' or varargs.
; XXX man page says `mode_t mode'.
6	AUE_CLOSE	MSTD	{ int close(int fd); }
7	AUE_WAIT4	MSTD	{ int wait4(int pid, int *status, \
				    int options, struct rusage *rusage); } \
				    wait4 wait_args int
8	AUE_O_CREAT	MCOMPAT	{ int creat(char *path, int mode); }
9	AUE_LINK	MSTD	{ int link(char *path, char *link); }
10	AUE_UNLINK	MSTD	{ int unlink(char *path); }
11	AUE_NULL	OBSOL	execv
12	AUE_CHDIR	MSTD	{ int chdir(char *path); }
13	AUE_FCHDIR	MSTD	{ int fchdir(int fd); }
14	AUE_MKNOD	MSTD	{ int mknod(char *path, int mode, int dev); }
15	AUE_CHMOD	MSTD	{ int chmod(char *path, int mode); }
16	AUE_CHOWN	MSTD	{ int chown(char *path, int uid, int gid); }
17	AUE_NULL	MSTD	{ int obreak(char *nsize); } break \
				    obreak_args int
18	AUE_GETFSSTAT	MCOMPAT4	{ int getfsstat(struct ostatfs *buf, \
				    long bufsize, int flags); }
19	AUE_LSEEK	MCOMPAT	{ long lseek(int fd, long offset, \
				    int whence); }
20	AUE_GETPID	MSTD	{ pid_t getpid(void); }
21	AUE_MOUNT	STD	{ int mount(char *type, char *path, \
				    int flags, caddr_t data); }
; XXX `path' should have type `const char *' but we're not ready for that.
22	AUE_UMOUNT	STD	{ int unmount(char *path, int flags); }
23	AUE_SETUID	MSTD	{ int setuid(uid_t uid); }
24	AUE_GETUID	MSTD	{ uid_t getuid(void); }
25	AUE_GETEUID	MSTD	{ uid_t geteuid(void); }
26	AUE_PTRACE	MSTD	{ int ptrace(int req, pid_t pid, \
				    caddr_t addr, int data); }
27	AUE_RECVMSG	MSTD	{ int recvmsg(int s, struct msghdr *msg, \
				    int flags); }
28	AUE_SENDMSG	MSTD	{ int sendmsg(int s, struct msghdr *msg, \
				    int flags); }
29	AUE_RECVFROM	MSTD	{ int recvfrom(int s, caddr_t buf, \
				    size_t len, int flags, \
				    struct sockaddr * __restrict from, \
				    __socklen_t * __restrict fromlenaddr); }
30	AUE_ACCEPT	MSTD	{ int accept(int s, \
				    struct sockaddr * __restrict name, \
				    __socklen_t * __restrict anamelen); }
31	AUE_GETPEERNAME	MSTD	{ int getpeername(int fdes, \
				    struct sockaddr * __restrict asa, \
				    __socklen_t * __restrict alen); }
32	AUE_GETSOCKNAME	MSTD	{ int getsockname(int fdes, \
				    struct sockaddr * __restrict asa, \
				    __socklen_t * __restrict alen); }
33	AUE_ACCESS	MSTD	{ int access(char *path, int flags); }
34	AUE_CHFLAGS	MSTD	{ int chflags(char *path, int flags); }
35	AUE_FCHFLAGS	MSTD	{ int fchflags(int fd, int flags); }
36	AUE_SYNC	MSTD	{ int sync(void); }
37	AUE_KILL	MSTD	{ int kill(int pid, int signum); }
38	AUE_STAT	MCOMPAT	{ int stat(char *path, struct ostat *ub); }
39	AUE_GETPPID	MSTD	{ pid_t getppid(void); }
40	AUE_LSTAT	MCOMPAT	{ int lstat(char *path, struct ostat *ub); }
41	AUE_DUP		MSTD	{ int dup(u_int fd); }
42	AUE_PIPE	MSTD	{ int pipe(void); }
43	AUE_GETEGID	MSTD	{ gid_t getegid(void); }
44	AUE_PROFILE	MSTD	{ int profil(caddr_t samples, size_t size, \
				    size_t offset, u_int scale); }
45	AUE_KTRACE	MSTD	{ int ktrace(const char *fname, int ops, \
				    int facs, int pid); }
46	AUE_SIGACTION	MCOMPAT	{ int sigaction(int signum, \
				    struct osigaction *nsa, \
				    struct osigaction *osa); }
47	AUE_GETGID	MSTD	{ gid_t getgid(void); }
48	AUE_SIGPROCMASK	MCOMPAT	{ int sigprocmask(int how, osigset_t mask); }
; XXX note nonstandard (bogus) calling convention - the libc stub passes
; us the mask, not a pointer to it, and we return the old mask as the
; (int) return value.
49	AUE_GETLOGIN	MSTD	{ int getlogin(char *namebuf, u_int \
				    namelen); }
50	AUE_SETLOGIN	MSTD	{ int setlogin(char *namebuf); }
51	AUE_ACCT	MSTD	{ int acct(char *path); }
52	AUE_SIGPENDING	MCOMPAT	{ int sigpending(void); }
53	AUE_SIGPENDING	MSTD	{ int sigaltstack(stack_t *ss, \
				    stack_t *oss); }
54	AUE_IOCTL	MSTD	{ int ioctl(int fd, u_long com, \
				    caddr_t data); }
55	AUE_REBOOT	MSTD	{ int reboot(int opt); }
56	AUE_REVOKE	MSTD	{ int revoke(char *path); }
57	AUE_SYMLINK	MSTD	{ int symlink(char *path, char *link); }
58	AUE_READLINK	MSTD	{ int readlink(char *path, char *buf, \
				    int count); }
59	AUE_EXECVE	MSTD	{ int execve(char *fname, char **argv, \
				    char **envv); }
60	AUE_UMASK	MSTD	{ int umask(int newmask); } umask umask_args \
				    int
61	AUE_CHROOT	MSTD	{ int chroot(char *path); }
62	AUE_FSTAT	MCOMPAT	{ int fstat(int fd, struct ostat *sb); }
63	AUE_NULL	MCOMPAT	{ int getkerninfo(int op, char *where, \
				    size_t *size, int arg); } getkerninfo \
				    getkerninfo_args int
64	AUE_O_GETPAGESIZE	MCOMPAT	{ int getpagesize(void); } getpagesize \
				    getpagesize_args int
65	AUE_MSYNC	MSTD	{ int msync(void *addr, size_t len, \
				    int flags); }
66	AUE_VFORK	MSTD	{ int vfork(void); }
67	AUE_NULL	OBSOL	vread
68	AUE_NULL	OBSOL	vwrite
69	AUE_SBRK	MSTD	{ int sbrk(int incr); }
70	AUE_SSTK	MSTD	{ int sstk(int incr); }
71	AUE_MMAP	MCOMPAT	{ int mmap(void *addr, int len, int prot, \
				    int flags, int fd, long pos); }
72	AUE_O_VADVISE	MSTD	{ int ovadvise(int anom); } vadvise \
				    ovadvise_args int
73	AUE_MUNMAP	MSTD	{ int munmap(void *addr, size_t len); }
74	AUE_MPROTECT	MSTD	{ int mprotect(const void *addr, size_t len, \
				    int prot); }
75	AUE_MADVISE	MSTD	{ int madvise(void *addr, size_t len, \
				    int behav); }
76	AUE_NULL	OBSOL	vhangup
77	AUE_NULL	OBSOL	vlimit
78	AUE_MINCORE	MSTD	{ int mincore(const void *addr, size_t len, \
				    char *vec); }
79	AUE_GETGROUPS	MSTD	{ int getgroups(u_int gidsetsize, \
				    gid_t *gidset); }
80	AUE_SETGROUPS	MSTD	{ int setgroups(u_int gidsetsize, \
				    gid_t *gidset); }
81	AUE_GETPGRP	MSTD	{ int getpgrp(void); }
82	AUE_SETPGRP	MSTD	{ int setpgid(int pid, int pgid); }
83	AUE_SETITIMER	MSTD	{ int setitimer(u_int which, struct \
				    itimerval *itv, struct itimerval *oitv); }
84	AUE_WAIT4	MCOMPAT	{ int wait(void); }
85	AUE_SWAPON	MSTD	{ int swapon(char *name); }
86	AUE_GETITIMER	MSTD	{ int getitimer(u_int which, \
				    struct itimerval *itv); }
87	AUE_SYSCTL	MCOMPAT	{ int gethostname(char *hostname, \
				    u_int len); } gethostname \
				    gethostname_args int
88	AUE_SYSCTL	MCOMPAT	{ int sethostname(char *hostname, \
				    u_int len); } sethostname \
				    sethostname_args int
89	AUE_GETDTABLESIZE	MSTD	{ int getdtablesize(void); }
90	AUE_DUP2	MSTD	{ int dup2(u_int from, u_int to); }
91	AUE_NULL	UNIMPL	getdopt
92	AUE_FCNTL	MSTD	{ int fcntl(int fd, int cmd, long arg); }
; XXX should be	{ int fcntl(int fd, int cmd, ...); }
; but we're not ready for varargs.
93	AUE_SELECT	MSTD	{ int select(int nd, fd_set *in, fd_set *ou, \
				    fd_set *ex, struct timeval *tv); }
94	AUE_NULL	UNIMPL	setdopt
95	AUE_FSYNC	MSTD	{ int fsync(int fd); }
96	AUE_SETPRIORITY	MSTD	{ int setpriority(int which, int who, \
				    int prio); }
97	AUE_SOCKET	MSTD	{ int socket(int domain, int type, \
				    int protocol); }
98	AUE_CONNECT	MSTD	{ int connect(int s, caddr_t name, \
				    int namelen); }
99	AUE_ACCEPT	MCPT_NOA { int accept(int s, caddr_t name, \
				    int *anamelen); } accept accept_args int
100	AUE_GETPRIORITY	MSTD	{ int getpriority(int which, int who); }
101	AUE_SEND	MCOMPAT	{ int send(int s, caddr_t buf, int len, \
				    int flags); }
102	AUE_RECV	MCOMPAT	{ int recv(int s, caddr_t buf, int len, \
				    int flags); }
103	AUE_SIGRETURN	MCOMPAT	{ int sigreturn( \
				    struct osigcontext *sigcntxp); }
104	AUE_BIND	MSTD	{ int bind(int s, caddr_t name, \
				    int namelen); }
105	AUE_SETSOCKOPT	MSTD	{ int setsockopt(int s, int level, int name, \
				    caddr_t val, int valsize); }
106	AUE_LISTEN	MSTD	{ int listen(int s, int backlog); }
107	AUE_NULL	OBSOL	vtimes
108	AUE_NULL	MCOMPAT	{ int sigvec(int signum, struct sigvec *nsv, \
				    struct sigvec *osv); }
109	AUE_NULL	MCOMPAT	{ int sigblock(int mask); }
110	AUE_NULL	MCOMPAT	{ int sigsetmask(int mask); }
111	AUE_NULL	MCOMPAT	{ int sigsuspend(osigset_t mask); }
; XXX note nonstandard (bogus) calling convention - the libc stub passes
; us the mask, not a pointer to it.
112	AUE_NULL	MCOMPAT	{ int sigstack(struct sigstack *nss, \
				    struct sigstack *oss); }
113	AUE_RECVMSG	MCOMPAT	{ int recvmsg(int s, struct omsghdr *msg, \
				    int flags); }
114	AUE_SENDMSG	MCOMPAT	{ int sendmsg(int s, caddr_t msg, \
				    int flags); }
115	AUE_NULL	OBSOL	vtrace
116	AUE_GETTIMEOFDAY	MSTD	{ int gettimeofday(struct timeval *tp, \
				    struct timezone *tzp); }
117	AUE_GETRUSAGE	MSTD	{ int getrusage(int who, \
				    struct rusage *rusage); }
118	AUE_GETSOCKOPT	MSTD	{ int getsockopt(int s, int level, int name, \
				    caddr_t val, int *avalsize); }
119	AUE_NULL	UNIMPL	resuba (BSD/OS 2.x)
120	AUE_READV	MSTD	{ int readv(int fd, struct iovec *iovp, \
				    u_int iovcnt); }
121	AUE_WRITEV	MSTD	{ int writev(int fd, struct iovec *iovp, \
				    u_int iovcnt); }
122	AUE_SETTIMEOFDAY	MSTD	{ int settimeofday(struct timeval *tv, \
				    struct timezone *tzp); }
123	AUE_FCHOWN	MSTD	{ int fchown(int fd, int uid, int gid); }
124	AUE_FCHMOD	MSTD	{ int fchmod(int fd, int mode); }
125	AUE_RECVFROM	MCPT_NOA { int recvfrom(int s, caddr_t buf, \
				    size_t len, int flags, caddr_t from, int \
				    *fromlenaddr); } recvfrom recvfrom_args \
				    int
126	AUE_SETREUID	MSTD	{ int setreuid(int ruid, int euid); }
127	AUE_SETREGID	MSTD	{ int setregid(int rgid, int egid); }
128	AUE_RENAME	MSTD	{ int rename(char *from, char *to); }
129	AUE_TRUNCATE	MCOMPAT	{ int truncate(char *path, long length); }
130	AUE_FTRUNCATE	MCOMPAT	{ int ftruncate(int fd, long length); }
131	AUE_FLOCK	MSTD	{ int flock(int fd, int how); }
132	AUE_MKFIFO	MSTD	{ int mkfifo(char *path, int mode); }
133	AUE_SENDTO	MSTD	{ int sendto(int s, caddr_t buf, size_t len, \
				    int flags, caddr_t to, int tolen); }
134	AUE_SHUTDOWN	MSTD	{ int shutdown(int s, int how); }
135	AUE_SOCKETPAIR	MSTD	{ int socketpair(int domain, int type, \
				    int protocol, int *rsv); }
136	AUE_MKDIR	MSTD	{ int mkdir(char *path, int mode); }
137	AUE_RMDIR	MSTD	{ int rmdir(char *path); }
138	AUE_UTIMES	MSTD	{ int utimes(char *path, \
				    struct timeval *tptr); }
139	AUE_NULL	OBSOL	4.2 sigreturn
140	AUE_ADJTIME	MSTD	{ int adjtime(struct timeval *delta, \
				    struct timeval *olddelta); }
141	AUE_GETPEERNAME	MCOMPAT	{ int getpeername(int fdes, caddr_t asa, \
				    int *alen); }
142	AUE_SYSCTL	MCOMPAT	{ long gethostid(void); }
143	AUE_SYSCTL	MCOMPAT	{ int sethostid(long hostid); }
144	AUE_GETRLIMIT	MCOMPAT	{ int getrlimit(u_int which, struct \
				    orlimit *rlp); }
145	AUE_SETRLIMIT	MCOMPAT	{ int setrlimit(u_int which, \
				    struct orlimit *rlp); }
146	AUE_KILLPG	MCOMPAT	{ int killpg(int pgid, int signum); }
147	AUE_SETSID	MSTD	{ int setsid(void); }
148	AUE_QUOTACTL	MSTD	{ int quotactl(char *path, int cmd, int uid, \
				    caddr_t arg); }
149	AUE_O_QUOTA	MCOMPAT	{ int quota(void); }
150	AUE_GETSOCKNAME	MCPT_NOA	{ int getsockname(int fdec, \
				    caddr_t asa, int *alen); } getsockname \
				    getsockname_args int

; Syscalls 151-180 inclusive are reserved for vendor-specific
; system calls.  (This includes various calls added for compatibity
; with other Unix variants.)
; Some of these calls are now supported by BSD...
151	AUE_NULL	UNIMPL	sem_lock (BSD/OS 2.x)
152	AUE_NULL	UNIMPL	sem_wakeup (BSD/OS 2.x)
153	AUE_NULL	UNIMPL	asyncdaemon (BSD/OS 2.x)
154	AUE_NULL	UNIMPL	nosys
; 155 is initialized by the NFS code, if present.
155	AUE_NFSSVC	MNOIMPL	{ int nfssvc(int flag, caddr_t argp); }
156	AUE_GETDIRENTRIES	COMPAT	{ int getdirentries(int fd, char *buf, \
				    u_int count, long *basep); }
157	AUE_STATFS	MCOMPAT4	{ int statfs(char *path, \
				    struct ostatfs *buf); }
158	AUE_FSTATFS	MCOMPAT4	{ int fstatfs(int fd, \
				    struct ostatfs *buf); }
159	AUE_NULL	UNIMPL	nosys
160	AUE_LGETFH	MSTD	{ int lgetfh(char *fname, \
				    struct fhandle *fhp); }
161	AUE_NFS_GETFH	MSTD	{ int getfh(char *fname, \
				    struct fhandle *fhp); }
162	AUE_SYSCTL	MSTD	{ int getdomainname(char *domainname, \
				    int len); }
163	AUE_SYSCTL	MSTD	{ int setdomainname(char *domainname, \
				    int len); }
164	AUE_NULL	MSTD	{ int uname(struct utsname *name); }
165	AUE_NULL	MSTD	{ int sysarch(int op, char *parms); }
166	AUE_NULL	MSTD	{ int rtprio(int function, pid_t pid, \
				    struct rtprio *rtp); }
167	AUE_NULL	UNIMPL	nosys
168	AUE_NULL	UNIMPL	nosys
; 169 is initialized by the SYSVSEM code if present or loaded
169	AUE_SEMSYS	MNOSTD	{ int semsys(int which, int a2, int a3, \
				    int a4, int a5); }
; 169 is initialized by the SYSVMSG code if present or loaded
; XXX should be	{ int semsys(int which, ...); }
170	AUE_MSGSYS	MNOSTD	{ int msgsys(int which, int a2, int a3, \
				    int a4, int a5, int a6); }
; 169 is initialized by the SYSVSHM code if present or loaded
; XXX should be	{ int msgsys(int which, ...); }
171	AUE_SHMSYS	MNOSTD	{ int shmsys(int which, int a2, int a3, \
				    int a4); }
; XXX should be	{ int shmsys(int which, ...); }
172	AUE_NULL	UNIMPL	nosys
173	AUE_PREAD	MSTD	{ ssize_t pread(int fd, void *buf, \
				    size_t nbyte, int pad, off_t offset); }
174	AUE_PWRITE	MSTD	{ ssize_t pwrite(int fd, const void *buf, \
				    size_t nbyte, int pad, off_t offset); }
175	AUE_NULL	UNIMPL	nosys
176	AUE_ADJTIME	MSTD	{ int ntp_adjtime(struct timex *tp); }
177	AUE_NULL	UNIMPL	sfork (BSD/OS 2.x)
178	AUE_NULL	UNIMPL	getdescriptor (BSD/OS 2.x)
179	AUE_NULL	UNIMPL	setdescriptor (BSD/OS 2.x)
180	AUE_NULL	UNIMPL	nosys

; Syscalls 181-199 are used by/reserved for BSD
181	AUE_SETGID	MSTD	{ int setgid(gid_t gid); }
182	AUE_SETEGID	MSTD	{ int setegid(gid_t egid); }
183	AUE_SETEUID	MSTD	{ int seteuid(uid_t euid); }
184	AUE_NULL	UNIMPL	lfs_bmapv
185	AUE_NULL	UNIMPL	lfs_markv
186	AUE_NULL	UNIMPL	lfs_segclean
187	AUE_NULL	UNIMPL	lfs_segwait
188	AUE_STAT	MSTD	{ int stat(char *path, struct stat *ub); }
189	AUE_FSTAT	MSTD	{ int fstat(int fd, struct stat *sb); }
190	AUE_LSTAT	MSTD	{ int lstat(char *path, struct stat *ub); }
191	AUE_PATHCONF	MSTD	{ int pathconf(char *path, int name); }
192	AUE_FPATHCONF	MSTD	{ int fpathconf(int fd, int name); }
193	AUE_NULL	UNIMPL	nosys
194	AUE_GETRLIMIT	MSTD	{ int getrlimit(u_int which, \
				    struct rlimit *rlp); } getrlimit \
				    __getrlimit_args int
195	AUE_SETRLIMIT	MSTD	{ int setrlimit(u_int which, \
				    struct rlimit *rlp); } setrlimit \
				    __setrlimit_args int
196	AUE_GETDIRENTRIES	MSTD	{ int getdirentries(int fd, char *buf, \
				    u_int count, long *basep); }
197	AUE_MMAP	MSTD	{ caddr_t mmap(caddr_t addr, size_t len, \
				    int prot, int flags, int fd, int pad, \
				    off_t pos); }
198	AUE_NULL	MSTD	{ int nosys(void); } __syscall \
				    __syscall_args int
199	AUE_LSEEK	MSTD	{ off_t lseek(int fd, int pad, off_t offset, \
				    int whence); }
200	AUE_TRUNCATE	MSTD	{ int truncate(char *path, int pad, \
				    off_t length); }
201	AUE_FTRUNCATE	MSTD	{ int ftruncate(int fd, int pad, \
				    off_t length); }
202	AUE_SYSCTL	MSTD	{ int __sysctl(int *name, u_int namelen, \
				    void *old, size_t *oldlenp, void *new, \
				    size_t newlen); } __sysctl sysctl_args int
203	AUE_MLOCK	MSTD	{ int mlock(const void *addr, size_t len); }
204	AUE_MUNLOCK	MSTD	{ int munlock(const void *addr, size_t len); }
205	AUE_UNDELETE	MSTD	{ int undelete(char *path); }
206	AUE_FUTIMES	MSTD	{ int futimes(int fd, struct timeval *tptr); }
207	AUE_GETPGID	MSTD	{ int getpgid(pid_t pid); }
208	AUE_NULL	UNIMPL	newreboot (NetBSD)
209	AUE_POLL	MSTD	{ int poll(struct pollfd *fds, u_int nfds, \
				    int timeout); }

;
; The following are reserved for loadable syscalls
;
210	AUE_NULL	NODEF	lkmnosys lkmnosys nosys_args int
211	AUE_NULL	NODEF	lkmnosys lkmnosys nosys_args int
212	AUE_NULL	NODEF	lkmnosys lkmnosys nosys_args int
213	AUE_NULL	NODEF	lkmnosys lkmnosys nosys_args int
214	AUE_NULL	NODEF	lkmnosys lkmnosys nosys_args int
215	AUE_NULL	NODEF	lkmnosys lkmnosys nosys_args int
216	AUE_NULL	NODEF	lkmnosys lkmnosys nosys_args int
217	AUE_NULL	NODEF	lkmnosys lkmnosys nosys_args int
218	AUE_NULL	NODEF	lkmnosys lkmnosys nosys_args int
219	AUE_NULL	NODEF	lkmnosys lkmnosys nosys_args int

;
; The following were introduced with NetBSD/4.4Lite-2
220	AUE_SEMCTL	MNOSTD	{ int __semctl(int semid, int semnum, \
				    int cmd, union semun *arg); }
221	AUE_SEMGET	MNOSTD	{ int semget(key_t key, int nsems, \
				    int semflg); }
222	AUE_SEMOP	MNOSTD	{ int semop(int semid, struct sembuf *sops, \
				    size_t nsops); }
223	AUE_NULL	UNIMPL	semconfig
224	AUE_MSGCTL	MNOSTD	{ int msgctl(int msqid, int cmd, \
				    struct msqid_ds *buf); }
225	AUE_MSGGET	MNOSTD	{ int msgget(key_t key, int msgflg); }
226	AUE_MSGSND	MNOSTD	{ int msgsnd(int msqid, const void *msgp, \
				    size_t msgsz, int msgflg); }
227	AUE_MSGRCV	MNOSTD	{ int msgrcv(int msqid, void *msgp, \
				    size_t msgsz, long msgtyp, int msgflg); }
228	AUE_SHMAT	MNOSTD	{ int shmat(int shmid, const void *shmaddr, \
				    int shmflg); }
229	AUE_SHMCTL	MNOSTD	{ int shmctl(int shmid, int cmd, \
				    struct shmid_ds *buf); }
230	AUE_SHMDT	MNOSTD	{ int shmdt(const void *shmaddr); }
231	AUE_SHMGET	MNOSTD	{ int shmget(key_t key, size_t size, \
				    int shmflg); }
;
232	AUE_NULL	MSTD	{ int clock_gettime(clockid_t clock_id, \
				    struct timespec *tp); }
233	AUE_NULL	MSTD	{ int clock_settime(clockid_t clock_id, \
				    const struct timespec *tp); }
234	AUE_NULL	MSTD	{ int clock_getres(clockid_t clock_id, \
				    struct timespec *tp); }
235	AUE_NULL	MSTD	{ int timer_create(clockid_t clock_id, \
				    struct sigevent *evp, timer_t *timerid); }
236	AUE_NULL	MSTD	{ int timer_delete(timer_t timerid); }
237	AUE_NULL	MSTD	{ int timer_settime(timer_t timerid, int flags, \
				    const struct itimerspec *value, \
				    struct itimerspec *ovalue); }
238	AUE_NULL	MSTD	{ int timer_gettime(timer_t timerid, struct \
				    itimerspec *value); }
239	AUE_NULL	MSTD	{ int timer_getoverrun(timer_t timerid); }
240	AUE_NULL	MSTD	{ int nanosleep(const struct timespec *rqtp, \
				    struct timespec *rmtp); }
241	AUE_NULL	UNIMPL	nosys
242	AUE_NULL	UNIMPL	nosys
243	AUE_NULL	UNIMPL	nosys
244	AUE_NULL	UNIMPL	nosys
245	AUE_NULL	UNIMPL	nosys
246	AUE_NULL	UNIMPL	nosys
247	AUE_NULL	UNIMPL	nosys
248	AUE_NULL	MSTD	{ int ntp_gettime(struct ntptimeval *ntvp); }
249	AUE_NULL	UNIMPL	nosys
; syscall numbers initially used in OpenBSD
250	AUE_MINHERIT	MSTD	{ int minherit(void *addr, size_t len, \
				    int inherit); }
251	AUE_RFORK	MSTD	{ int rfork(int flags); }
252	AUE_POLL	MSTD	{ int openbsd_poll(struct pollfd *fds, \
				    u_int nfds, int timeout); }
253	AUE_ISSETUGID	MSTD	{ int issetugid(void); }
254	AUE_LCHOWN	MSTD	{ int lchown(char *path, int uid, int gid); }
255	AUE_NULL	MNOSTD	{ int aio_read(struct aiocb *aiocbp); }
256	AUE_NULL	MNOSTD	{ int aio_write(struct aiocb *aiocbp); }
257	AUE_NULL	MNOSTD	{ int lio_listio(int mode, \
				    struct aiocb * const *acb_list, \
				    int nent, struct sigevent *sig); }
258	AUE_NULL	UNIMPL	nosys
259	AUE_NULL	UNIMPL	nosys
260	AUE_NULL	UNIMPL	nosys
261	AUE_NULL	UNIMPL	nosys
262	AUE_NULL	UNIMPL	nosys
263	AUE_NULL	UNIMPL	nosys
264	AUE_NULL	UNIMPL	nosys
265	AUE_NULL	UNIMPL	nosys
266	AUE_NULL	UNIMPL	nosys
267	AUE_NULL	UNIMPL	nosys
268	AUE_NULL	UNIMPL	nosys
269	AUE_NULL	UNIMPL	nosys
270	AUE_NULL	UNIMPL	nosys
271	AUE_NULL	UNIMPL	nosys
272	AUE_O_GETDENTS	MSTD	{ int getdents(int fd, char *buf, \
				    size_t count); }
273	AUE_NULL	UNIMPL	nosys
274	AUE_LCHMOD	MSTD	{ int lchmod(char *path, mode_t mode); }
275	AUE_LCHOWN	MNOPROTO { int lchown(char *path, uid_t uid, \
				    gid_t gid); } netbsd_lchown lchown_args \
				    int
276	AUE_LUTIMES	MSTD	{ int lutimes(char *path, \
				    struct timeval *tptr); }
277	AUE_MSYNC	MNOPROTO	{ int msync(void *addr, size_t len, \
				    int flags); } netbsd_msync msync_args int
278	AUE_STAT	MSTD	{ int nstat(char *path, struct nstat *ub); }
279	AUE_FSTAT	MSTD	{ int nfstat(int fd, struct nstat *sb); }
280	AUE_LSTAT	MSTD	{ int nlstat(char *path, struct nstat *ub); }
281	AUE_NULL	UNIMPL	nosys
282	AUE_NULL	UNIMPL	nosys
283	AUE_NULL	UNIMPL	nosys
284	AUE_NULL	UNIMPL	nosys
285	AUE_NULL	UNIMPL	nosys
286	AUE_NULL	UNIMPL	nosys
287	AUE_NULL	UNIMPL	nosys
288	AUE_NULL	UNIMPL	nosys
; 289 and 290 from NetBSD (OpenBSD: 267 and 268)
289	AUE_NULL	MSTD	{ ssize_t preadv(int fd, struct iovec *iovp, \
					u_int iovcnt, off_t offset); }
290	AUE_NULL	MSTD	{ ssize_t pwritev(int fd, struct iovec *iovp, \
					u_int iovcnt, off_t offset); }
291	AUE_NULL	UNIMPL	nosys
292	AUE_NULL	UNIMPL	nosys
293	AUE_NULL	UNIMPL	nosys
294	AUE_NULL	UNIMPL	nosys
295	AUE_NULL	UNIMPL	nosys
296	AUE_NULL	UNIMPL	nosys
; XXX 297 is 300 in NetBSD 
297	AUE_FHSTATFS	MCOMPAT4	{ int fhstatfs( \
				    const struct fhandle *u_fhp, \
				    struct ostatfs *buf); }
298	AUE_FHOPEN	MSTD	{ int fhopen(const struct fhandle *u_fhp, \
				    int flags); }
299	AUE_FHSTAT	MSTD	{ int fhstat(const struct fhandle *u_fhp, \
				    struct stat *sb); }
; syscall numbers for FreeBSD
300	AUE_NULL	MSTD	{ int modnext(int modid); }
301	AUE_NULL	MSTD	{ int modstat(int modid, \
				    struct module_stat *stat); }
302	AUE_NULL	MSTD	{ int modfnext(int modid); }
303	AUE_NULL	MSTD	{ int modfind(const char *name); }
304	AUE_MODLOAD	MSTD	{ int kldload(const char *file); }
305	AUE_MODUNLOAD	MSTD	{ int kldunload(int fileid); }
306	AUE_NULL	MSTD	{ int kldfind(const char *file); }
307	AUE_NULL	MSTD	{ int kldnext(int fileid); }
308	AUE_NULL	MSTD	{ int kldstat(int fileid, struct \
				    kld_file_stat* stat); }
309	AUE_NULL	MSTD	{ int kldfirstmod(int fileid); }
310	AUE_GETSID	MSTD	{ int getsid(pid_t pid); }
311	AUE_SETRESUID	MSTD	{ int setresuid(uid_t ruid, uid_t euid, \
				    uid_t suid); }
312	AUE_SETRESGID	MSTD	{ int setresgid(gid_t rgid, gid_t egid, \
				    gid_t sgid); }
313	AUE_NULL	OBSOL	signanosleep
314	AUE_NULL	MNOSTD	{ int aio_return(struct aiocb *aiocbp); }
315	AUE_NULL	MNOSTD	{ int aio_suspend( \
				    struct aiocb * const * aiocbp, int nent, \
				    const struct timespec *timeout); }
316	AUE_NULL	MNOSTD	{ int aio_cancel(int fd, \
				    struct aiocb *aiocbp); }
317	AUE_NULL	MNOSTD	{ int aio_error(struct aiocb *aiocbp); }
318	AUE_NULL	MNOSTD	{ int oaio_read(struct oaiocb *aiocbp); }
319	AUE_NULL	MNOSTD	{ int oaio_write(struct oaiocb *aiocbp); }
320	AUE_NULL	MNOSTD	{ int olio_listio(int mode, \
				    struct oaiocb * const *acb_list, \
				    int nent, struct osigevent *sig); }
321	AUE_NULL	MSTD	{ int yield(void); }
322	AUE_NULL	OBSOL	thr_sleep
323	AUE_NULL	OBSOL	thr_wakeup
324	AUE_MLOCKALL	MSTD	{ int mlockall(int how); }
325	AUE_MUNLOCKALL	MSTD	{ int munlockall(void); }
326	AUE_NULL	MSTD	{ int __getcwd(u_char *buf, u_int buflen); }

327	AUE_NULL	MSTD	{ int sched_setparam (pid_t pid, \
				    const struct sched_param *param); }
328	AUE_NULL	MSTD	{ int sched_getparam (pid_t pid, struct \
				    sched_param *param); }

329	AUE_NULL	MSTD	{ int sched_setscheduler (pid_t pid, int \
				    policy, const struct sched_param \
				    *param); }
330	AUE_NULL	MSTD	{ int sched_getscheduler (pid_t pid); }

331	AUE_NULL	MSTD	{ int sched_yield (void); }
332	AUE_NULL	MSTD	{ int sched_get_priority_max (int policy); }
333	AUE_NULL	MSTD	{ int sched_get_priority_min (int policy); }
334	AUE_NULL	MSTD	{ int sched_rr_get_interval (pid_t pid, \
				    struct timespec *interval); }
335	AUE_NULL	MSTD	{ int utrace(const void *addr, size_t len); }
336	AUE_SENDFILE	MCOMPAT4	{ int sendfile(int fd, int s, \
				    off_t offset, size_t nbytes, \
				    struct sf_hdtr *hdtr, off_t *sbytes, \
				    int flags); }
337	AUE_NULL	MSTD	{ int kldsym(int fileid, int cmd, \
				    void *data); }
338	AUE_JAIL	MSTD	{ int jail(struct jail *jail); }
339	AUE_NULL	UNIMPL	pioctl
340	AUE_SIGPROCMASK	MSTD	{ int sigprocmask(int how, \
				    const sigset_t *set, sigset_t *oset); }
341	AUE_SIGSUSPEND	MSTD	{ int sigsuspend(const sigset_t *sigmask); }
342	AUE_SIGACTION	MCOMPAT4	{ int sigaction(int sig, const \
				    struct sigaction *act, \
				    struct sigaction *oact); }
343	AUE_SIGPENDING	MSTD	{ int sigpending(sigset_t *set); }
344	AUE_SIGRETURN	MCOMPAT4	{ int sigreturn( \
				    const struct ucontext4 *sigcntxp); }
345	AUE_SIGWAIT	MSTD	{ int sigtimedwait(const sigset_t *set, \
				    siginfo_t *info, \
				    const struct timespec *timeout); }
346	AUE_NULL	MSTD	{ int sigwaitinfo(const sigset_t *set, \
				    siginfo_t *info); }
347	AUE_NULL	MSTD	{ int __acl_get_file(const char *path, \
				    acl_type_t type, struct acl *aclp); }
348	AUE_NULL	MSTD	{ int __acl_set_file(const char *path, \
				    acl_type_t type, struct acl *aclp); }
349	AUE_NULL	MSTD	{ int __acl_get_fd(int filedes, \
				    acl_type_t type, struct acl *aclp); }
350	AUE_NULL	MSTD	{ int __acl_set_fd(int filedes, \
				    acl_type_t type, struct acl *aclp); }
351	AUE_NULL	MSTD	{ int __acl_delete_file(const char *path, \
				    acl_type_t type); }
352	AUE_NULL	MSTD	{ int __acl_delete_fd(int filedes, \
				    acl_type_t type); }
353	AUE_NULL	MSTD	{ int __acl_aclcheck_file(const char *path, \
				    acl_type_t type, struct acl *aclp); }
354	AUE_NULL	MSTD	{ int __acl_aclcheck_fd(int filedes, \
				    acl_type_t type, struct acl *aclp); }
355	AUE_NULL	MSTD	{ int extattrctl(const char *path, int cmd, \
				    const char *filename, int attrnamespace, \
				    const char *attrname); }
356	AUE_NULL	MSTD	{ int extattr_set_file(const char *path, \
				    int attrnamespace, const char *attrname, \
				    void *data, size_t nbytes); }
357	AUE_NULL	MSTD	{ ssize_t extattr_get_file(const char *path, \
				    int attrnamespace, const char *attrname, \
				    void *data, size_t nbytes); }
358	AUE_NULL	MSTD	{ int extattr_delete_file(const char *path, \
				    int attrnamespace, \
				    const char *attrname); }
359	AUE_NULL	MNOSTD	{ int aio_waitcomplete( \
				    struct aiocb **aiocbp, \
				    struct timespec *timeout); }
360	AUE_GETRESUID	MSTD	{ int getresuid(uid_t *ruid, uid_t *euid, \
				    uid_t *suid); }
361	AUE_GETRESGID	MSTD	{ int getresgid(gid_t *rgid, gid_t *egid, \
				    gid_t *sgid); }
362	AUE_NULL	MSTD	{ int kqueue(void); }
363	AUE_NULL	MSTD	{ int kevent(int fd, \
				    struct kevent *changelist, int nchanges, \
				    struct kevent *eventlist, int nevents, \
				    const struct timespec *timeout); }
364	AUE_NULL	UNIMPL	__cap_get_proc
365	AUE_NULL	UNIMPL	__cap_set_proc
366	AUE_NULL	UNIMPL	__cap_get_fd
367	AUE_NULL	UNIMPL	__cap_get_file
368	AUE_NULL	UNIMPL	__cap_set_fd
369	AUE_NULL	UNIMPL	__cap_set_file
370	AUE_NULL	NODEF	lkmressys lkmressys nosys_args int
371	AUE_NULL	MSTD	{ int extattr_set_fd(int fd, \
				    int attrnamespace, const char *attrname, \
				    void *data, size_t nbytes); }
372	AUE_NULL	MSTD	{ ssize_t extattr_get_fd(int fd, \
				    int attrnamespace, const char *attrname, \
				    void *data, size_t nbytes); }
373	AUE_NULL	MSTD	{ int extattr_delete_fd(int fd, \
				    int attrnamespace, \
				    const char *attrname); }
374	AUE_NULL	MSTD	{ int __setugid(int flag); }
375	AUE_NULL	NOIMPL	{ int nfsclnt(int flag, caddr_t argp); }
376	AUE_EACCESS	MSTD	{ int eaccess(char *path, int flags); }
377	AUE_NULL	UNIMPL	afs_syscall
378	AUE_NMOUNT	STD	{ int nmount(struct iovec *iovp, \
				    unsigned int iovcnt, int flags); }
379	AUE_NULL	MSTD	{ int kse_exit(void); }
380	AUE_NULL	MSTD	{ int kse_wakeup(struct kse_mailbox *mbx); }
381	AUE_NULL	MSTD	{ int kse_create(struct kse_mailbox *mbx, \
				    int newgroup); }
382	AUE_NULL	MSTD	{ int kse_thr_interrupt( \
				    struct kse_thr_mailbox *tmbx, int cmd, \
				    long data); }
383	AUE_NULL	MSTD	{ int kse_release(struct timespec *timeout); }
384	AUE_NULL	MSTD	{ int __mac_get_proc(struct mac *mac_p); }
385	AUE_NULL	MSTD	{ int __mac_set_proc(struct mac *mac_p); }
386	AUE_NULL	MSTD	{ int __mac_get_fd(int fd, \
				    struct mac *mac_p); }
387	AUE_NULL	MSTD	{ int __mac_get_file(const char *path_p, \
				    struct mac *mac_p); }
388	AUE_NULL	MSTD	{ int __mac_set_fd(int fd, \
				    struct mac *mac_p); }
389	AUE_NULL	MSTD	{ int __mac_set_file(const char *path_p, \
				    struct mac *mac_p); }
390	AUE_NULL	MSTD	{ int kenv(int what, const char *name, \
				    char *value, int len); }
391	AUE_LCHFLAGS	MSTD	{ int lchflags(const char *path, int flags); }
392	AUE_NULL	MSTD	{ int uuidgen(struct uuid *store, \
				    int count); }
393	AUE_SENDFILE	MSTD	{ int sendfile(int fd, int s, off_t offset, \
				    size_t nbytes, struct sf_hdtr *hdtr, \
				    off_t *sbytes, int flags); }
394	AUE_NULL	MSTD	{ int mac_syscall(const char *policy, \
				    int call, void *arg); }
395	AUE_GETFSSTAT	MSTD	{ int getfsstat(struct statfs *buf, \
				    long bufsize, int flags); }
396	AUE_STATFS	MSTD	{ int statfs(char *path, \
				    struct statfs *buf); }
397	AUE_FSTATFS	MSTD	{ int fstatfs(int fd, struct statfs *buf); }
398	AUE_NULL	MSTD	{ int fhstatfs(const struct fhandle *u_fhp, \
				    struct statfs *buf); }
399	AUE_NULL	UNIMPL	nosys
400	AUE_NULL	MNOSTD	{ int ksem_close(semid_t id); }
401	AUE_NULL	MNOSTD	{ int ksem_post(semid_t id); }
402	AUE_NULL	MNOSTD	{ int ksem_wait(semid_t id); }
403	AUE_NULL	MNOSTD	{ int ksem_trywait(semid_t id); }
404	AUE_NULL	MNOSTD	{ int ksem_init(semid_t *idp, \
				    unsigned int value); }
405	AUE_NULL	MNOSTD	{ int ksem_open(semid_t *idp, \
				    const char *name, int oflag, \
				    mode_t mode, unsigned int value); }
406	AUE_NULL	MNOSTD	{ int ksem_unlink(const char *name); }
407	AUE_NULL	MNOSTD	{ int ksem_getvalue(semid_t id, int *val); }
408	AUE_NULL	MNOSTD	{ int ksem_destroy(semid_t id); }
409	AUE_NULL	MSTD	{ int __mac_get_pid(pid_t pid, \
				    struct mac *mac_p); }
410	AUE_NULL	MSTD	{ int __mac_get_link(const char *path_p, \
				    struct mac *mac_p); }
411	AUE_NULL	MSTD	{ int __mac_set_link(const char *path_p, \
				    struct mac *mac_p); }
412	AUE_NULL	MSTD	{ int extattr_set_link(const char *path, \
				    int attrnamespace, const char *attrname, \
				    void *data, size_t nbytes); }
413	AUE_NULL	MSTD	{ ssize_t extattr_get_link(const char *path, \
				    int attrnamespace, const char *attrname, \
				    void *data, size_t nbytes); }
414	AUE_NULL	MSTD	{ int extattr_delete_link(const char *path, \
				    int attrnamespace, \
				    const char *attrname); }
415	AUE_NULL	MSTD	{ int __mac_execve(char *fname, char **argv, \
				    char **envv, struct mac *mac_p); }
416	AUE_SIGACTION	MSTD	{ int sigaction(int sig, \
				    const struct sigaction *act, \
				    struct sigaction *oact); }
417	AUE_SIGRETURN	MSTD	{ int sigreturn( \
				    const struct __ucontext *sigcntxp); }
418	AUE_NULL	UNIMPL	__xstat
419	AUE_NULL	UNIMPL	__xfstat
420	AUE_NULL	UNIMPL	__xlstat
421	AUE_NULL	MSTD	{ int getcontext(struct __ucontext *ucp); }
422	AUE_NULL	MSTD	{ int setcontext( \
				    const struct __ucontext *ucp); }
423	AUE_NULL	MSTD	{ int swapcontext(struct __ucontext *oucp, \
				    const struct __ucontext *ucp); }
424	AUE_SWAPOFF	MSTD	{ int swapoff(const char *name); }
425	AUE_NULL	MSTD	{ int __acl_get_link(const char *path, \
				    acl_type_t type, struct acl *aclp); }
426	AUE_NULL	MSTD	{ int __acl_set_link(const char *path, \
				    acl_type_t type, struct acl *aclp); }
427	AUE_NULL	MSTD	{ int __acl_delete_link(const char *path, \
				    acl_type_t type); }
428	AUE_NULL	MSTD	{ int __acl_aclcheck_link(const char *path, \
				    acl_type_t type, struct acl *aclp); }
429	AUE_SIGWAIT	MSTD	{ int sigwait(const sigset_t *set, \
				    int *sig); }
430	AUE_NULL	MSTD	{ int thr_create(ucontext_t *ctx, long *id, \
				    int flags); }
431	AUE_NULL	MSTD	{ void thr_exit(long *state); }
432	AUE_NULL	MSTD	{ int thr_self(long *id); }
433	AUE_NULL	MSTD	{ int thr_kill(long id, int sig); }
434	AUE_NULL	MSTD	{ int _umtx_lock(struct umtx *umtx); }
435	AUE_NULL	MSTD	{ int _umtx_unlock(struct umtx *umtx); }
436	AUE_NULL	MSTD	{ int jail_attach(int jid); }
437	AUE_NULL	MSTD	{ ssize_t extattr_list_fd(int fd, \
				    int attrnamespace, void *data, \
				    size_t nbytes); }
438	AUE_NULL	MSTD	{ ssize_t extattr_list_file( \
				    const char *path, int attrnamespace, \
				    void *data, size_t nbytes); }
439	AUE_NULL	MSTD	{ ssize_t extattr_list_link( \
				    const char *path, int attrnamespace, \
				    void *data, size_t nbytes); }
440	AUE_NULL	MSTD	{ int kse_switchin( \
				    struct kse_thr_mailbox *tmbx, \
				    int flags); }
441	AUE_NULL	MNOSTD	{ int ksem_timedwait(semid_t id, \
				    const struct timespec *abstime); }
442	AUE_NULL	MSTD	{ int thr_suspend( \
				    const struct timespec *timeout); }
443	AUE_NULL	MSTD	{ int thr_wake(long id); }
444	AUE_NULL	MSTD	{ int kldunloadf(int fileid, int flags); }
445	AUE_AUDIT	MSTD	{ int audit(const void *record, \
				    u_int length); }
446	AUE_AUDITON	MSTD	{ int auditon(int cmd, void *data, \
				    u_int length); }
447	AUE_GETAUID	MSTD	{ int getauid(uid_t *auid); }
448	AUE_SETAUID	MSTD	{ int setauid(uid_t *auid); }
449	AUE_GETAUDIT	MSTD	{ int getaudit(struct auditinfo *auditinfo); }
450	AUE_SETAUDIT	MSTD	{ int setaudit(struct auditinfo *auditinfo); }
451	AUE_GETAUDIT_ADDR	MSTD	{ int getaudit_addr( \
				    struct auditinfo_addr *auditinfo_addr, \
				    u_int length); }
452	AUE_SETAUDIT_ADDR	MSTD	{ int setaudit_addr( \
				    struct auditinfo_addr *auditinfo_addr, \
				    u_int length); }
453	AUE_AUDITCTL	MSTD	{ int auditctl(char *path); }
454	AUE_NULL	MSTD	{ int _umtx_op(struct umtx *umtx, int op, \
				    long id, void *uaddr, void *uaddr2); }
455	AUE_NULL	MSTD	{ int thr_new(struct thr_param *param, \
				    int param_size); }
456	AUE_NULL	MSTD	{ int sigqueue(pid_t pid, int signum, void *value); }
457	AUE_NULL	MNOSTD	{ int mq_open(const char *path, int flags, \
				    mode_t mode, const struct mq_attr *attr); }
458	AUE_NULL	MNOSTD	{ int mq_setattr(mqd_t mqd,		\
				    const struct mq_attr *attr,		\
				    struct mq_attr *oattr); }
459	AUE_NULL	MNOSTD	{ int mq_timedreceive(mqd_t mqd,	\
				    char *msg_ptr, size_t msg_len,	\
				    unsigned *msg_prio,			\
				    const struct timespec *abs_timeout); }
460	AUE_NULL	MNOSTD  { int mq_timedsend(mqd_t mqd,		\
				    const char *msg_ptr, size_t msg_len,\
				    unsigned msg_prio,			\
				    const struct timespec *abs_timeout);}
461	AUE_NULL	MNOSTD	{ int mq_notify(mqd_t mqd,		\
				    const struct sigevent *sigev); }
462	AUE_NULL	MNOSTD	{ int mq_unlink(const char *path); }
463	AUE_NULL	MSTD	{ int abort2(const char *why, int nargs, void **args); }
464	AUE_NULL	MSTD	{ int thr_set_name(long id, const char *name); }
; Please copy any additions and changes to the following compatability tables:
; sys/compat/freebsd32/syscalls.master