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
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
|
$NetBSD: syscalls.master,v 1.309 2021/11/01 05:07:17 thorpej Exp $
; @(#)syscalls.master 8.2 (Berkeley) 1/13/94
; NetBSD system call name/number "master" file.
; (See syscalls.conf to see what it is processed into.)
;
; Fields: number type [type-dependent ...]
; number system call number, must be in order
; type one of STD, OBSOL, UNIMPL, IGNORED, NODEF, NOARGS, or one of
; the compatibility options defined in syscalls.conf.
;
; Optional fields are specified after the type field
; (NOTE! they *must* be specified in this order):
; MODULAR modname :attempt to autoload system call module if not present
; RUMP: generate rump syscall entry point
;
; types:
; STD always included
; OBSOL obsolete, not included in system
; IGNORED syscall is a null op, but always succeeds
; UNIMPL unimplemented, not included in system
; EXCL implemented, but not included in system
; NODEF included, but don't define the syscall number
; NOARGS included, but don't define the syscall args structure
; INDIR included, but don't define the syscall args structure,
; and allow it to be "really" varargs.
; NOERR included, syscall does not set errno
; EXTERN implemented, but as 3rd party module
;
; arguments:
; PAD argument not part of the C interface, used only for padding
;
; The compat options are defined in the syscalls.conf file, and the
; compat option name is prefixed to the syscall name. Other than
; that, they're like NODEF (for 'compat' options), or STD (for
; 'libcompat' options).
;
; The type-dependent arguments are as follows:
; For STD, NODEF, NOARGS, and compat syscalls:
; { return_type|prefix|compat(optional)|basename(pseudo-proto); } [alias]
; For other syscalls:
; [comment]
;
; #ifdef's, etc. may be included, and are copied to the output files.
; #include's are copied to the syscall names and switch definition files only.
#ifdef _KERNEL_OPT
#include "opt_modular.h"
#include "opt_ntp.h"
#include "opt_sysv.h"
#endif
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/signal.h>
#include <sys/socket.h>
#include <sys/mount.h>
#include <sys/sched.h>
#include <sys/idtype.h>
#include <sys/syscallargs.h>
#include <sys/acl.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 INDIR { int|sys||syscall(int code, \
... register_t args[SYS_MAXSYSARGS]); }
1 STD { void|sys||exit(int rval); }
2 STD { int|sys||fork(void); }
3 STD RUMP { ssize_t|sys||read(int fd, void *buf, size_t nbyte); }
4 STD RUMP { ssize_t|sys||write(int fd, const void *buf, \
size_t nbyte); }
5 STD RUMP { int|sys||open(const char *path, \
int flags, ... mode_t mode); }
6 STD RUMP { int|sys||close(int fd); }
7 COMPAT_50 MODULAR compat_50 { int|sys||wait4(pid_t pid, int *status, \
int options, struct rusage50 *rusage); }
8 COMPAT_43 MODULAR compat_43 \
{ int|sys||creat(const char *path, mode_t mode); } ocreat
9 STD RUMP { int|sys||link(const char *path, const char *link); }
10 STD RUMP { int|sys||unlink(const char *path); }
11 OBSOL execv
12 STD RUMP { int|sys||chdir(const char *path); }
13 STD RUMP { int|sys||fchdir(int fd); }
14 COMPAT_50 MODULAR compat_50 RUMP \
{ int|sys||mknod(const char *path, mode_t mode, uint32_t dev); }
15 STD RUMP { int|sys||chmod(const char *path, mode_t mode); }
16 STD RUMP { int|sys||chown(const char *path, uid_t uid, \
gid_t gid); }
17 STD { int|sys||obreak(char *nsize); } break
18 COMPAT_20 MODULAR compat_20 { int|sys||getfsstat(struct statfs12 *buf, \
long bufsize, int flags); }
19 COMPAT_43 MODULAR compat_43 \
{ long|sys||lseek(int fd, long offset, int whence); }\
olseek
20 NOERR RUMP { pid_t|sys||getpid_with_ppid(void); } getpid
21 COMPAT_40 MODULAR compat_40 \
{ int|sys||mount(const char *type, const char *path, \
int flags, void *data); }
22 STD RUMP { int|sys||unmount(const char *path, int flags); }
23 STD RUMP { int|sys||setuid(uid_t uid); }
24 NOERR RUMP { uid_t|sys||getuid_with_euid(void); } getuid
25 NOERR RUMP { uid_t|sys||geteuid(void); }
26 STD MODULAR ptrace \
{ int|sys||ptrace(int req, pid_t pid, void *addr, \
int data); }
27 STD RUMP { ssize_t|sys||recvmsg(int s, struct msghdr *msg, \
int flags); }
28 STD RUMP { ssize_t|sys||sendmsg(int s, \
const struct msghdr *msg, int flags); }
29 STD RUMP { ssize_t|sys||recvfrom(int s, void *buf, size_t len, \
int flags, struct sockaddr *from, \
socklen_t *fromlenaddr); }
30 STD RUMP { int|sys||accept(int s, struct sockaddr *name, \
socklen_t *anamelen); }
31 STD RUMP { int|sys||getpeername(int fdes, struct sockaddr *asa, \
socklen_t *alen); }
32 STD RUMP { int|sys||getsockname(int fdes, struct sockaddr *asa, \
socklen_t *alen); }
33 STD RUMP { int|sys||access(const char *path, int flags); }
34 STD RUMP { int|sys||chflags(const char *path, u_long flags); }
35 STD RUMP { int|sys||fchflags(int fd, u_long flags); }
36 NOERR RUMP { void|sys||sync(void); }
37 STD { int|sys||kill(pid_t pid, int signum); }
38 COMPAT_43 MODULAR compat_43 \
{ int|sys||stat(const char *path, struct stat43 *ub); } stat43
39 NOERR RUMP { pid_t|sys||getppid(void); }
40 COMPAT_43 MODULAR compat_43 \
{ int|sys||lstat(const char *path, \
struct stat43 *ub); } lstat43
41 STD RUMP { int|sys||dup(int fd); }
42 STD RUMP { int|sys||pipe(void); }
43 NOERR RUMP { gid_t|sys||getegid(void); }
44 STD { int|sys||profil(char *samples, size_t size, \
u_long offset, u_int scale); }
45 STD RUMP { int|sys||ktrace(const char *fname, int ops, \
int facs, pid_t pid); }
46 COMPAT_13 MODULAR compat_13 { int|sys||sigaction(int signum, \
const struct sigaction13 *nsa, \
struct sigaction13 *osa); } sigaction13
47 NOERR RUMP { gid_t|sys||getgid_with_egid(void); } getgid
48 COMPAT_13 MODULAR compat_13 { int|sys||sigprocmask(int how, \
int mask); } sigprocmask13
49 STD RUMP { int|sys||__getlogin(char *namebuf, size_t namelen); }
50 STD RUMP { int|sys||__setlogin(const char *namebuf); }
51 STD { int|sys||acct(const char *path); }
52 COMPAT_13 MODULAR compat_13 { int|sys||sigpending(void); } sigpending13
53 COMPAT_13 MODULAR compat_13 { int|sys||sigaltstack( \
const struct sigaltstack13 *nss, \
struct sigaltstack13 *oss); } sigaltstack13
54 STD RUMP { int|sys||ioctl(int fd, \
u_long com, ... void *data); }
55 COMPAT_12 MODULAR compat_12 { int|sys||reboot(int opt); } oreboot
56 STD RUMP { int|sys||revoke(const char *path); }
57 STD RUMP { int|sys||symlink(const char *path, \
const char *link); }
58 STD RUMP { ssize_t|sys||readlink(const char *path, char *buf, \
size_t count); }
59 STD { int|sys||execve(const char *path, \
char * const *argp, char * const *envp); }
60 STD RUMP { mode_t|sys||umask(mode_t newmask); }
61 STD RUMP { int|sys||chroot(const char *path); }
62 COMPAT_43 MODULAR compat_43 \
{ int|sys||fstat(int fd, struct stat43 *sb); } fstat43
63 COMPAT_43 MODULAR compat_43 \
{ int|sys||getkerninfo(int op, char *where, int *size, \
int arg); } ogetkerninfo
64 COMPAT_43 MODULAR compat_43 \
{ int|sys||getpagesize(void); } ogetpagesize
65 COMPAT_12 MODULAR compat_12 { int|sys||msync(void *addr, size_t len); }
; XXX COMPAT_??? for 4.4BSD-compatible vfork(2)?
66 STD { int|sys||vfork(void); }
67 OBSOL vread
68 OBSOL vwrite
69 OBSOL sbrk
70 OBSOL sstk
71 COMPAT_43 MODULAR compat_43 \
{ int|sys||mmap(void *addr, size_t len, int prot, \
int flags, int fd, long pos); } ommap
72 STD { int|sys||ovadvise(int anom); } vadvise
73 STD { int|sys||munmap(void *addr, size_t len); }
74 STD { int|sys||mprotect(void *addr, size_t len, \
int prot); }
75 STD { int|sys||madvise(void *addr, size_t len, \
int behav); }
76 OBSOL vhangup
77 OBSOL vlimit
78 STD { int|sys||mincore(void *addr, size_t len, \
char *vec); }
79 STD RUMP { int|sys||getgroups(int gidsetsize, \
gid_t *gidset); }
80 STD RUMP { int|sys||setgroups(int gidsetsize, \
const gid_t *gidset); }
81 STD RUMP { int|sys||getpgrp(void); }
82 STD RUMP { int|sys||setpgid(pid_t pid, pid_t pgid); }
83 COMPAT_50 MODULAR compat_50 { int|sys||setitimer(int which, \
const struct itimerval50 *itv, \
struct itimerval50 *oitv); }
84 COMPAT_43 MODULAR compat_43 { int|sys||wait(void); } owait
85 COMPAT_12 MODULAR compat_12 { int|sys||swapon(const char *name); } \
oswapon
86 COMPAT_50 MODULAR compat_50 { int|sys||getitimer(int which, \
struct itimerval50 *itv); }
87 COMPAT_43 MODULAR compat_43 \
{ int|sys||gethostname(char *hostname, u_int len); } \
ogethostname
88 COMPAT_43 MODULAR compat_43 \
{ int|sys||sethostname(char *hostname, u_int len); } \
osethostname
89 COMPAT_43 MODULAR compat_43 \
{ int|sys||getdtablesize(void); } ogetdtablesize
90 STD RUMP { int|sys||dup2(int from, int to); }
91 STD RUMP { ssize_t|sys||getrandom(void *buf, size_t buflen, \
unsigned int flags); }
92 STD RUMP { int|sys||fcntl(int fd, int cmd, ... void *arg); }
93 COMPAT_50 MODULAR compat_50 RUMP \
{ int|sys||select(int nd, fd_set *in, fd_set *ou, \
fd_set *ex, struct timeval50 *tv); }
94 UNIMPL setdopt
95 STD RUMP { int|sys||fsync(int fd); }
96 STD { int|sys||setpriority(int which, id_t who, int prio); }
97 COMPAT_30 MODULAR compat_30 \
{ int|sys||socket(int domain, int type, int protocol); }
98 STD RUMP { int|sys||connect(int s, const struct sockaddr *name, \
socklen_t namelen); }
99 COMPAT_43 MODULAR compat_43 \
{ int|sys||accept(int s, void *name, \
socklen_t *anamelen); } oaccept
100 STD { int|sys||getpriority(int which, id_t who); }
101 COMPAT_43 MODULAR compat_43 { int|sys||send(int s, void *buf, int len, \
int flags); } osend
102 COMPAT_43 MODULAR compat_43 { int|sys||recv(int s, void *buf, int len, \
int flags); } orecv
103 COMPAT_13 MODULAR compat_13 \
{ int|sys||sigreturn(struct sigcontext13 *sigcntxp); } \
sigreturn13
104 STD RUMP { int|sys||bind(int s, const struct sockaddr *name, \
socklen_t namelen); }
105 STD RUMP { int|sys||setsockopt(int s, int level, int name, \
const void *val, socklen_t valsize); }
106 STD RUMP { int|sys||listen(int s, int backlog); }
107 OBSOL vtimes
108 COMPAT_43 MODULAR compat_43 \
{ int|sys||sigvec(int signum, struct sigvec *nsv, \
struct sigvec *osv); } osigvec
109 COMPAT_43 MODULAR compat { int|sys||sigblock(int mask); } osigblock
110 COMPAT_43 MODULAR compat { int|sys||sigsetmask(int mask); } osigsetmask
111 COMPAT_13 MODULAR compat { int|sys||sigsuspend(int mask); } sigsuspend13
112 COMPAT_43 MODULAR compat_43 { int|sys||sigstack(struct sigstack *nss, \
struct sigstack *oss); } osigstack
113 COMPAT_43 MODULAR compat_43 \
{ int|sys||recvmsg(int s, struct omsghdr *msg, \
int flags); } orecvmsg
114 COMPAT_43 MODULAR compat_43 \
{ int|sys||sendmsg(int s, void *msg, int flags); } osendmsg
115 OBSOL vtrace
116 COMPAT_50 MODULAR compat_50 \
{ int|sys||gettimeofday(struct timeval50 *tp, void *tzp); }
117 COMPAT_50 MODULAR compat_50 \
{ int|sys||getrusage(int who, struct rusage50 *rusage); }
118 STD RUMP { int|sys||getsockopt(int s, int level, int name, \
void *val, socklen_t *avalsize); }
119 OBSOL resuba
120 STD RUMP { ssize_t|sys||readv(int fd, \
const struct iovec *iovp, int iovcnt); }
121 STD RUMP { ssize_t|sys||writev(int fd, \
const struct iovec *iovp, int iovcnt); }
122 COMPAT_50 MODULAR compat_50 \
{ int|sys||settimeofday(const struct timeval50 *tv, \
const void *tzp); }
123 STD RUMP { int|sys||fchown(int fd, uid_t uid, gid_t gid); }
124 STD RUMP { int|sys||fchmod(int fd, mode_t mode); }
125 COMPAT_43 MODULAR compat_43 \
{ int|sys||recvfrom(int s, void *buf, size_t len, \
int flags, void *from, socklen_t *fromlenaddr); } \
orecvfrom
126 STD RUMP { int|sys||setreuid(uid_t ruid, uid_t euid); }
127 STD RUMP { int|sys||setregid(gid_t rgid, gid_t egid); }
128 STD RUMP { int|sys||rename(const char *from, const char *to); }
129 COMPAT_43 MODULAR compat_43 \
{ int|sys||truncate(const char *path, long length); } otruncate
130 COMPAT_43 MODULAR compat_43 \
{ int|sys||ftruncate(int fd, long length); } oftruncate
131 STD RUMP { int|sys||flock(int fd, int how); }
132 STD RUMP { int|sys||mkfifo(const char *path, mode_t mode); }
133 STD RUMP { ssize_t|sys||sendto(int s, const void *buf, \
size_t len, int flags, const struct sockaddr *to, \
socklen_t tolen); }
134 STD RUMP { int|sys||shutdown(int s, int how); }
135 STD RUMP { int|sys||socketpair(int domain, int type, \
int protocol, int *rsv); }
136 STD RUMP { int|sys||mkdir(const char *path, mode_t mode); }
137 STD RUMP { int|sys||rmdir(const char *path); }
138 COMPAT_50 MODULAR compat_50 RUMP { int|sys||utimes(const char *path, \
const struct timeval50 *tptr); }
139 OBSOL 4.2 sigreturn
140 COMPAT_50 MODULAR compat_50 \
{ int|sys||adjtime(const struct timeval50 *delta, \
struct timeval50 *olddelta); }
141 COMPAT_43 MODULAR compat_43 \
{ int|sys||getpeername(int fdes, void *asa, \
socklen_t *alen); } ogetpeername
142 COMPAT_43 MODULAR compat_43 \
{ int32_t|sys||gethostid(void); } ogethostid
143 COMPAT_43 MODULAR compat_43 \
{ int|sys||sethostid(int32_t hostid); } osethostid
144 COMPAT_43 MODULAR compat_43 \
{ int|sys||getrlimit(int which, \
struct orlimit *rlp); } ogetrlimit
145 COMPAT_43 MODULAR compat_43 { int|sys||setrlimit(int which, \
const struct orlimit *rlp); } osetrlimit
146 COMPAT_43 MODULAR compat_43 \
{ int|sys||killpg(int pgid, int signum); } okillpg
147 STD RUMP { int|sys||setsid(void); }
148 COMPAT_50 MODULAR compat_50_quota \
{ int|sys||quotactl(const char *path, \
int cmd, int uid, void *arg); }
149 COMPAT_43 MODULAR compat_43 { int|sys||quota(void); } oquota
150 COMPAT_43 MODULAR compat_43 { int|sys||getsockname(int fdec, \
void *asa, socklen_t *alen); } ogetsockname
; 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 UNIMPL
152 UNIMPL
153 UNIMPL
154 UNIMPL
155 STD MODULAR nfsserver RUMP { int|sys||nfssvc(int flag, void *argp); }
156 COMPAT_43 MODULAR compat_43 \
{ int|sys||getdirentries(int fd, char *buf, \
u_int count, long *basep); } ogetdirentries
157 COMPAT_20 MODULAR compat_20 { int|sys||statfs(const char *path, \
struct statfs12 *buf); }
158 COMPAT_20 MODULAR compat_20 \
{ int|sys||fstatfs(int fd, struct statfs12 *buf); }
159 UNIMPL
160 UNIMPL
161 COMPAT_30 MODULAR compat_30 { int|sys||getfh(const char *fname, \
struct compat_30_fhandle *fhp); }
162 COMPAT_09 MODULAR compat_09 \
{ int|sys||getdomainname(char *domainname, int len); } \
ogetdomainname
163 COMPAT_09 MODULAR compat_09 \
{ int|sys||setdomainname(char *domainname, int len); } \
osetdomainname
164 COMPAT_09 MODULAR compat \
{ int|sys||uname(struct outsname *name); } ouname
165 STD { int|sys||sysarch(int op, void *parms); }
166 STD { int|sys||__futex(int *uaddr, int op, int val, \
const struct timespec *timeout, \
int *uaddr2, int val2, int val3); }
167 STD { int|sys||__futex_set_robust_list(void *head, \
size_t len); }
168 STD { int|sys||__futex_get_robust_list(lwpid_t lwpid, \
void **headp, size_t *lenp); }
; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
#if !defined(_LP64)
169 COMPAT_10 MODULAR compat_sysv_10 \
{ int|sys||semsys(int which, int a2, int a3, int a4, \
int a5); } osemsys
#else
169 EXCL 1.0 semsys
#endif
; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
#if !defined(_LP64)
170 COMPAT_10 MODULAR compat_sysv_10 \
{ int|sys||msgsys(int which, int a2, int a3, int a4, \
int a5, int a6); } omsgsys
#else
170 EXCL 1.0 msgsys
#endif
; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
#if !defined(_LP64)
171 COMPAT_10 MODULAR compat_sysv_10 \
{ int|sys||shmsys(int which, int a2, int a3, int a4); } \
oshmsys
#else
171 EXCL 1.0 shmsys
#endif
172 UNIMPL
173 STD RUMP { ssize_t|sys||pread(int fd, void *buf, \
size_t nbyte, int PAD, off_t offset); }
174 STD RUMP { ssize_t|sys||pwrite(int fd, const void *buf, \
size_t nbyte, int PAD, off_t offset); }
; For some reason, ntp_gettime doesn't want to raise SIGSYS when it's excluded.
175 COMPAT_30 MODULAR compat_30 \
{ int|sys||ntp_gettime(struct ntptimeval30 *ntvp); }
#if defined(NTP) || !defined(_KERNEL_OPT)
176 STD { int|sys||ntp_adjtime(struct timex *tp); }
#else
176 EXCL ntp_adjtime
#endif
177 STD { int|sys||timerfd_create(clockid_t clock_id, \
int flags); }
178 STD { int|sys||timerfd_settime(int fd, int flags, \
const struct itimerspec *new_value, \
struct itimerspec *old_value); }
179 STD { int|sys||timerfd_gettime(int fd, \
struct itimerspec *curr_value); }
180 UNIMPL
; Syscalls 180-199 are used by/reserved for BSD
181 STD RUMP { int|sys||setgid(gid_t gid); }
182 STD RUMP { int|sys||setegid(gid_t egid); }
183 STD RUMP { int|sys||seteuid(uid_t euid); }
184 STD MODULAR lfs { int|sys||lfs_bmapv(fsid_t *fsidp, \
struct block_info *blkiov, int blkcnt); }
185 STD MODULAR lfs { int|sys||lfs_markv(fsid_t *fsidp, \
struct block_info *blkiov, int blkcnt); }
186 STD MODULAR lfs { int|sys||lfs_segclean(fsid_t *fsidp, u_long segment); }
187 COMPAT_50 MODULAR compat_50 { int|sys||lfs_segwait(fsid_t *fsidp, \
struct timeval50 *tv); }
188 COMPAT_12 MODULAR compat_12 \
{ int|sys||stat(const char *path, struct stat12 *ub); } stat12
189 COMPAT_12 MODULAR compat_12 \
{ int|sys||fstat(int fd, struct stat12 *sb); } fstat12
190 COMPAT_12 MODULAR compat_12 { int|sys||lstat(const char *path, \
struct stat12 *ub); } lstat12
191 STD RUMP { long|sys||pathconf(const char *path, int name); }
192 STD RUMP { long|sys||fpathconf(int fd, int name); }
193 STD RUMP { int|sys||getsockopt2(int s, int level, int name, \
void *val, socklen_t *avalsize); }
194 STD RUMP { int|sys||getrlimit(int which, \
struct rlimit *rlp); }
195 STD RUMP { int|sys||setrlimit(int which, \
const struct rlimit *rlp); }
196 COMPAT_12 MODULAR compat_12 \
{ int|sys||getdirentries(int fd, char *buf, \
u_int count, long *basep); }
197 STD { void *|sys||mmap(void *addr, size_t len, int prot, \
int flags, int fd, long PAD, off_t pos); }
198 INDIR { quad_t|sys||__syscall(quad_t code, \
... register_t args[SYS_MAXSYSARGS]); }
199 STD RUMP { off_t|sys||lseek(int fd, int PAD, off_t offset, \
int whence); }
200 STD RUMP { int|sys||truncate(const char *path, int PAD, \
off_t length); }
201 STD RUMP { int|sys||ftruncate(int fd, int PAD, off_t length); }
202 STD RUMP { int|sys||__sysctl(const int *name, u_int namelen, \
void *oldv, size_t *oldlenp, const void *newv, \
size_t newlen); }
203 STD { int|sys||mlock(const void *addr, size_t len); }
204 STD { int|sys||munlock(const void *addr, size_t len); }
205 STD { int|sys||undelete(const char *path); }
206 COMPAT_50 MODULAR compat_50 RUMP { int|sys||futimes(int fd, \
const struct timeval50 *tptr); }
207 STD RUMP { pid_t|sys||getpgid(pid_t pid); }
208 STD RUMP { int|sys||reboot(int opt, char *bootstr); }
209 STD RUMP { int|sys||poll(struct pollfd *fds, u_int nfds, \
int timeout); }
;
; Syscalls 210-219 are reserved for dynamically loaded syscalls
;
210 EXTERN MODULAR openafs { int|sys||afssys(long id, long a1, long a2, \
long a3, long a4, long a5, long a6); }
211 UNIMPL
212 UNIMPL
213 UNIMPL
214 UNIMPL
215 UNIMPL
216 UNIMPL
217 UNIMPL
218 UNIMPL
219 UNIMPL
; System calls 220-300 are reserved for use by NetBSD
220 COMPAT_14 MODULAR compat_sysv_14 \
{ int|sys||__semctl(int semid, int semnum, int cmd, \
union __semun *arg); }
221 STD MODULAR sysv_ipc { int|sys||semget(key_t key, int nsems, \
int semflg); }
222 STD MODULAR sysv_ipc { int|sys||semop(int semid, struct sembuf *sops, \
size_t nsops); }
223 STD MODULAR sysv_ipc { int|sys||semconfig(int flag); }
224 COMPAT_14 MODULAR compat_sysv_14 { int|sys||msgctl(int msqid, int cmd, \
struct msqid_ds14 *buf); }
225 STD MODULAR sysv_ipc { int|sys||msgget(key_t key, int msgflg); }
226 STD MODULAR sysv_ipc { int|sys||msgsnd(int msqid, const void *msgp, \
size_t msgsz, int msgflg); }
227 STD MODULAR sysv_ipc { ssize_t|sys||msgrcv(int msqid, void *msgp, \
size_t msgsz, long msgtyp, int msgflg); }
228 STD MODULAR sysv_ipc { void *|sys||shmat(int shmid, \
const void *shmaddr, int shmflg); }
229 COMPAT_14 MODULAR compat_sysv_14 { int|sys||shmctl(int shmid, int cmd, \
struct shmid_ds14 *buf); }
230 STD MODULAR sysv_ipc { int|sys||shmdt(const void *shmaddr); }
231 STD MODULAR sysv_ipc { int|sys||shmget(key_t key, size_t size, \
int shmflg); }
232 COMPAT_50 MODULAR compat_50 \
{ int|sys||clock_gettime(clockid_t clock_id, \
struct timespec50 *tp); }
233 COMPAT_50 MODULAR compat_50 \
{ int|sys||clock_settime(clockid_t clock_id, \
const struct timespec50 *tp); }
234 COMPAT_50 MODULAR compat_50 \
{ int|sys||clock_getres(clockid_t clock_id, \
struct timespec50 *tp); }
235 STD RUMP { int|sys||timer_create(clockid_t clock_id, \
struct sigevent *evp, timer_t *timerid); }
236 STD RUMP { int|sys||timer_delete(timer_t timerid); }
237 COMPAT_50 MODULAR compat_50 { int|sys||timer_settime(timer_t timerid, \
int flags, const struct itimerspec50 *value, \
struct itimerspec50 *ovalue); }
238 COMPAT_50 MODULAR compat_50 { int|sys||timer_gettime(timer_t timerid, \
struct itimerspec50 *value); }
239 STD RUMP { int|sys||timer_getoverrun(timer_t timerid); }
;
; Syscalls 240-269 are reserved for other IEEE Std1003.1b syscalls
;
240 COMPAT_50 MODULAR compat_50 \
{ int|sys||nanosleep(const struct timespec50 *rqtp, \
struct timespec50 *rmtp); }
241 STD RUMP { int|sys||fdatasync(int fd); }
242 STD { int|sys||mlockall(int flags); }
243 STD { int|sys||munlockall(void); }
244 COMPAT_50 MODULAR compat_50 \
{ int|sys||__sigtimedwait(const sigset_t *set, \
siginfo_t *info, struct timespec50 *timeout); }
245 STD { int|sys||sigqueueinfo(pid_t pid, \
const siginfo_t *info); }
246 STD RUMP { int|sys||modctl(int cmd, void *arg); }
247 STD MODULAR ksem RUMP { int|sys||_ksem_init(unsigned int value, intptr_t *idp); }
248 STD MODULAR ksem RUMP { int|sys||_ksem_open(const char *name, int oflag, \
mode_t mode, unsigned int value, intptr_t *idp); }
249 STD MODULAR ksem RUMP { int|sys||_ksem_unlink(const char *name); }
250 STD MODULAR ksem RUMP { int|sys||_ksem_close(intptr_t id); }
251 STD MODULAR ksem RUMP { int|sys||_ksem_post(intptr_t id); }
252 STD MODULAR ksem RUMP { int|sys||_ksem_wait(intptr_t id); }
253 STD MODULAR ksem RUMP { int|sys||_ksem_trywait(intptr_t id); }
254 STD MODULAR ksem RUMP { int|sys||_ksem_getvalue(intptr_t id, \
unsigned int *value); }
255 STD MODULAR ksem RUMP { int|sys||_ksem_destroy(intptr_t id); }
256 STD MODULAR ksem RUMP { int|sys||_ksem_timedwait(intptr_t id, \
const struct timespec *abstime); }
257 STD MODULAR mqueue \
{ mqd_t|sys||mq_open(const char * name, int oflag, \
mode_t mode, struct mq_attr *attr); }
258 STD MODULAR mqueue { int|sys||mq_close(mqd_t mqdes); }
259 STD MODULAR mqueue { int|sys||mq_unlink(const char *name); }
260 STD MODULAR mqueue \
{ int|sys||mq_getattr(mqd_t mqdes, \
struct mq_attr *mqstat); }
261 STD MODULAR mqueue \
{ int|sys||mq_setattr(mqd_t mqdes, \
const struct mq_attr *mqstat, \
struct mq_attr *omqstat); }
262 STD MODULAR mqueue \
{ int|sys||mq_notify(mqd_t mqdes, \
const struct sigevent *notification); }
263 STD MODULAR mqueue \
{ int|sys||mq_send(mqd_t mqdes, const char *msg_ptr, \
size_t msg_len, unsigned msg_prio); }
264 STD MODULAR mqueue \
{ ssize_t|sys||mq_receive(mqd_t mqdes, char *msg_ptr, \
size_t msg_len, unsigned *msg_prio); }
265 COMPAT_50 MODULAR compat_50 \
{ int|sys||mq_timedsend(mqd_t mqdes, \
const char *msg_ptr, size_t msg_len, \
unsigned msg_prio, \
const struct timespec50 *abs_timeout); }
266 COMPAT_50 MODULAR compat_50 \
{ ssize_t|sys||mq_timedreceive(mqd_t mqdes, \
char *msg_ptr, size_t msg_len, unsigned *msg_prio, \
const struct timespec50 *abs_timeout); }
267 STD { int|sys||eventfd(unsigned int val, int flags); }
268 UNIMPL
269 UNIMPL
270 STD RUMP { int|sys||__posix_rename(const char *from, \
const char *to); }
271 STD { int|sys||swapctl(int cmd, void *arg, int misc); }
272 COMPAT_30 MODULAR compat_30 \
{ int|sys||getdents(int fd, char *buf, size_t count); }
273 STD { int|sys||minherit(void *addr, size_t len, \
int inherit); }
274 STD RUMP { int|sys||lchmod(const char *path, mode_t mode); }
275 STD RUMP { int|sys||lchown(const char *path, uid_t uid, \
gid_t gid); }
276 COMPAT_50 MODULAR compat_50 RUMP { int|sys||lutimes(const char *path, \
const struct timeval50 *tptr); }
277 STD { int|sys|13|msync(void *addr, size_t len, int flags); }
278 COMPAT_30 MODULAR compat_30 \
{ int|sys|13|stat(const char *path, struct stat13 *ub); }
279 COMPAT_30 MODULAR compat_30 \
{ int|sys|13|fstat(int fd, struct stat13 *sb); }
280 COMPAT_30 MODULAR compat_30 \
{ int|sys|13|lstat(const char *path, struct stat13 *ub); }
281 STD { int|sys|14|sigaltstack(const stack_t *nss, \
stack_t *oss); }
282 STD { int|sys|14|vfork(void); }
283 STD RUMP { int|sys||__posix_chown(const char *path, uid_t uid, \
gid_t gid); }
284 STD RUMP { int|sys||__posix_fchown(int fd, uid_t uid, \
gid_t gid); }
285 STD RUMP { int|sys||__posix_lchown(const char *path, uid_t uid, \
gid_t gid); }
286 STD RUMP { pid_t|sys||getsid(pid_t pid); }
287 STD { pid_t|sys||__clone(int flags, void *stack); }
288 STD RUMP { int|sys||fktrace(int fd, int ops, \
int facs, pid_t pid); }
289 STD RUMP { ssize_t|sys||preadv(int fd, \
const struct iovec *iovp, int iovcnt, \
int PAD, off_t offset); }
290 STD RUMP { ssize_t|sys||pwritev(int fd, \
const struct iovec *iovp, int iovcnt, \
int PAD, off_t offset); }
291 COMPAT_16 MODULAR compat_16 { int|sys|14|sigaction(int signum, \
const struct sigaction *nsa, \
struct sigaction *osa); }
292 STD { int|sys|14|sigpending(sigset_t *set); }
293 STD { int|sys|14|sigprocmask(int how, \
const sigset_t *set, \
sigset_t *oset); }
294 STD { int|sys|14|sigsuspend(const sigset_t *set); }
295 COMPAT_16 MODULAR compat_16 \
{ int|sys|14|sigreturn(struct sigcontext *sigcntxp); }
296 STD RUMP { int|sys||__getcwd(char *bufp, size_t length); }
297 STD RUMP { int|sys||fchroot(int fd); }
298 COMPAT_30 MODULAR compat_30 \
{ int|sys||fhopen(const struct compat_30_fhandle *fhp, int flags); }
299 COMPAT_30 MODULAR compat_30 \
{ int|sys||fhstat(const struct compat_30_fhandle *fhp, \
struct stat13 *sb); }
300 COMPAT_20 MODULAR compat_20 \
{ int|sys||fhstatfs(const struct compat_30_fhandle *fhp, \
struct statfs12 *buf); }
301 COMPAT_50 MODULAR compat_sysv_50 \
{ int|sys|13|__semctl(int semid, int semnum, int cmd, \
... union __semun *arg); }
302 COMPAT_50 MODULAR compat_sysv_50 \
{ int|sys|13|msgctl(int msqid, int cmd, struct msqid_ds *buf); }
303 COMPAT_50 MODULAR compat_sysv_50 \
{ int|sys|13|shmctl(int shmid, int cmd, \
struct shmid_ds13 *buf); }
304 STD RUMP { int|sys||lchflags(const char *path, u_long flags); }
305 NOERR RUMP { int|sys||issetugid(void); }
306 STD RUMP { int|sys||utrace(const char *label, void *addr, \
size_t len); }
307 STD { int|sys||getcontext(struct __ucontext *ucp); }
308 STD { int|sys||setcontext(const struct __ucontext *ucp); }
309 STD { int|sys||_lwp_create(const struct __ucontext *ucp, \
u_long flags, lwpid_t *new_lwp); }
310 STD { int|sys||_lwp_exit(void); }
311 STD { lwpid_t|sys||_lwp_self(void); }
312 STD { int|sys||_lwp_wait(lwpid_t wait_for, \
lwpid_t *departed); }
313 STD { int|sys||_lwp_suspend(lwpid_t target); }
314 STD { int|sys||_lwp_continue(lwpid_t target); }
315 STD { int|sys||_lwp_wakeup(lwpid_t target); }
316 STD { void *|sys||_lwp_getprivate(void); }
317 STD { void|sys||_lwp_setprivate(void *ptr); }
318 STD { int|sys||_lwp_kill(lwpid_t target, int signo); }
319 STD { int|sys||_lwp_detach(lwpid_t target); }
320 COMPAT_50 MODULAR compat_50 \
{ int|sys||_lwp_park(const struct timespec50 *ts, \
lwpid_t unpark, const void *hint, \
const void *unparkhint); }
321 STD { int|sys||_lwp_unpark(lwpid_t target, const void *hint); }
322 STD { ssize_t|sys||_lwp_unpark_all(const lwpid_t *targets, \
size_t ntargets, const void *hint); }
323 STD { int|sys||_lwp_setname(lwpid_t target, \
const char *name); }
324 STD { int|sys||_lwp_getname(lwpid_t target, \
char *name, size_t len); }
325 STD { int|sys||_lwp_ctl(int features, \
struct lwpctl **address); }
; Syscalls 326-339 reserved for LWP syscalls.
326 UNIMPL
327 UNIMPL
328 UNIMPL
329 UNIMPL
; SA system calls.
330 COMPAT_60 MODULAR compat_60 \
{ int|sys||sa_register(void *newv, void **oldv, \
int flags, ssize_t stackinfo_offset); }
331 COMPAT_60 MODULAR compat_60 \
{ int|sys||sa_stacks(int num, stack_t *stacks); }
332 COMPAT_60 MODULAR compat_60 \
{ int|sys||sa_enable(void); }
333 COMPAT_60 MODULAR compat_60 \
{ int|sys||sa_setconcurrency(int concurrency); }
334 COMPAT_60 MODULAR compat_60 \
{ int|sys||sa_yield(void); }
335 COMPAT_60 MODULAR compat_60 \
{ int|sys||sa_preempt(int sa_id); }
336 OBSOL sys_sa_unblockyield
;
; Syscalls 337-339 are reserved for other scheduler activation syscalls.
;
337 UNIMPL
338 UNIMPL
339 UNIMPL
340 STD { int|sys||__sigaction_sigtramp(int signum, \
const struct sigaction *nsa, \
struct sigaction *osa, \
const void *tramp, int vers); }
341 OBSOL sys_pmc_get_info
342 OBSOL sys_pmc_control
343 STD { int|sys||rasctl(void *addr, size_t len, int op); }
344 STD RUMP { int|sys||kqueue(void); }
345 COMPAT_50 MODULAR compat_50 RUMP { int|sys||kevent(int fd, \
const struct kevent *changelist, size_t nchanges, \
struct kevent *eventlist, size_t nevents, \
const struct timespec50 *timeout); }
; Scheduling system calls.
346 STD { int|sys||_sched_setparam(pid_t pid, lwpid_t lid, \
int policy, const struct sched_param *params); }
347 STD { int|sys||_sched_getparam(pid_t pid, lwpid_t lid, \
int *policy, struct sched_param *params); }
348 STD { int|sys||_sched_setaffinity(pid_t pid, lwpid_t lid, \
size_t size, const cpuset_t *cpuset); }
349 STD { int|sys||_sched_getaffinity(pid_t pid, lwpid_t lid, \
size_t size, cpuset_t *cpuset); }
350 STD { int|sys||sched_yield(void); }
351 STD { int|sys||_sched_protect(int priority); }
352 UNIMPL
353 UNIMPL
354 STD RUMP { int|sys||fsync_range(int fd, int flags, off_t start, \
off_t length); }
355 STD { int|sys||uuidgen(struct uuid *store, int count); }
356 COMPAT_90 MODULAR compat_90 { \
int|sys||getvfsstat(struct statvfs90 *buf, \
size_t bufsize, int flags); }
357 COMPAT_90 MODULAR compat_90 { int|sys||statvfs1(const char *path, \
struct statvfs90 *buf, int flags); }
358 COMPAT_90 MODULAR compat_90 { int|sys||fstatvfs1(int fd, \
struct statvfs90 *buf, int flags); }
359 COMPAT_30 MODULAR compat_30 { int|sys||fhstatvfs1( \
const struct compat_30_fhandle *fhp, \
struct statvfs90 *buf, int flags); }
360 STD RUMP { int|sys||extattrctl(const char *path, int cmd, \
const char *filename, int attrnamespace, \
const char *attrname); }
361 STD RUMP { int|sys||extattr_set_file(const char *path, \
int attrnamespace, const char *attrname, \
const void *data, size_t nbytes); }
362 STD RUMP { ssize_t|sys||extattr_get_file(const char *path, \
int attrnamespace, const char *attrname, \
void *data, size_t nbytes); }
363 STD RUMP { int|sys||extattr_delete_file(const char *path, \
int attrnamespace, const char *attrname); }
364 STD RUMP { int|sys||extattr_set_fd(int fd, \
int attrnamespace, const char *attrname, \
const void *data, size_t nbytes); }
365 STD RUMP { ssize_t|sys||extattr_get_fd(int fd, \
int attrnamespace, const char *attrname, \
void *data, size_t nbytes); }
366 STD RUMP { int|sys||extattr_delete_fd(int fd, \
int attrnamespace, const char *attrname); }
367 STD RUMP { int|sys||extattr_set_link(const char *path, \
int attrnamespace, const char *attrname, \
const void *data, size_t nbytes); }
368 STD RUMP { ssize_t|sys||extattr_get_link(const char *path, \
int attrnamespace, const char *attrname, \
void *data, size_t nbytes); }
369 STD RUMP { int|sys||extattr_delete_link(const char *path, \
int attrnamespace, const char *attrname); }
370 STD RUMP { ssize_t|sys||extattr_list_fd(int fd, \
int attrnamespace, void *data, size_t nbytes); }
371 STD RUMP { ssize_t|sys||extattr_list_file(const char *path, \
int attrnamespace, void *data, size_t nbytes); }
372 STD RUMP { ssize_t|sys||extattr_list_link(const char *path, \
int attrnamespace, void *data, size_t nbytes); }
373 COMPAT_50 MODULAR compat_50 RUMP \
{ int|sys||pselect(int nd, fd_set *in, fd_set *ou, \
fd_set *ex, const struct timespec50 *ts, \
const sigset_t *mask); }
374 COMPAT_50 MODULAR compat_50 RUMP \
{ int|sys||pollts(struct pollfd *fds, u_int nfds, \
const struct timespec50 *ts, const sigset_t *mask); }
375 STD RUMP { int|sys||setxattr(const char *path, \
const char *name, const void *value, size_t size, \
int flags); }
376 STD RUMP { int|sys||lsetxattr(const char *path, \
const char *name, const void *value, size_t size, \
int flags); }
377 STD RUMP { int|sys||fsetxattr(int fd, \
const char *name, const void *value, size_t size, \
int flags); }
378 STD RUMP { int|sys||getxattr(const char *path, \
const char *name, void *value, size_t size); }
379 STD RUMP { int|sys||lgetxattr(const char *path, \
const char *name, void *value, size_t size); }
380 STD RUMP { int|sys||fgetxattr(int fd, \
const char *name, void *value, size_t size); }
381 STD RUMP { int|sys||listxattr(const char *path, \
char *list, size_t size); }
382 STD RUMP { int|sys||llistxattr(const char *path, \
char *list, size_t size); }
383 STD RUMP { int|sys||flistxattr(int fd, \
char *list, size_t size); }
384 STD RUMP { int|sys||removexattr(const char *path, \
const char *name); }
385 STD RUMP { int|sys||lremovexattr(const char *path, \
const char *name); }
386 STD RUMP { int|sys||fremovexattr(int fd, \
const char *name); }
387 COMPAT_50 MODULAR compat_50 RUMP \
{ int|sys|30|stat(const char *path, struct stat30 *ub); }
388 COMPAT_50 MODULAR compat_50 RUMP \
{ int|sys|30|fstat(int fd, struct stat30 *sb); }
389 COMPAT_50 MODULAR compat_50 RUMP \
{ int|sys|30|lstat(const char *path, struct stat30 *ub); }
390 STD RUMP { int|sys|30|getdents(int fd, char *buf, size_t count); }
391 IGNORED old posix_fadvise
392 COMPAT_30 MODULAR compat_30 \
{ int|sys|30|fhstat(const struct compat_30_fhandle \
*fhp, struct stat30 *sb); }
393 COMPAT_50 MODULAR compat_30 \
{ int|sys|30|ntp_gettime(struct ntptimeval50 *ntvp); }
394 STD RUMP { int|sys|30|socket(int domain, int type, int protocol); }
395 STD RUMP { int|sys|30|getfh(const char *fname, void *fhp, \
size_t *fh_size); }
396 STD RUMP { int|sys|40|fhopen(const void *fhp, size_t fh_size,\
int flags); }
397 COMPAT_90 MODULAR compat_90 { \
int|sys||fhstatvfs1(const void *fhp, \
size_t fh_size, struct statvfs90 *buf, int flags); }
398 COMPAT_50 MODULAR compat_50 RUMP { int|sys|40|fhstat(const void *fhp, \
size_t fh_size, struct stat30 *sb); }
; Asynchronous I/O system calls
399 STD MODULAR aio RUMP \
{ int|sys||aio_cancel(int fildes, struct aiocb *aiocbp); }
400 STD MODULAR aio RUMP \
{ int|sys||aio_error(const struct aiocb *aiocbp); }
401 STD MODULAR aio RUMP \
{ int|sys||aio_fsync(int op, struct aiocb *aiocbp); }
402 STD MODULAR aio RUMP \
{ int|sys||aio_read(struct aiocb *aiocbp); }
403 STD MODULAR aio RUMP \
{ int|sys||aio_return(struct aiocb *aiocbp); }
404 COMPAT_50 MODULAR compat \
{ int|sys||aio_suspend(const struct aiocb *const *list, \
int nent, const struct timespec50 *timeout); }
405 STD MODULAR aio RUMP \
{ int|sys||aio_write(struct aiocb *aiocbp); }
406 STD MODULAR aio RUMP \
{ int|sys||lio_listio(int mode, struct aiocb *const *list, \
int nent, struct sigevent *sig); }
407 UNIMPL
408 UNIMPL
409 UNIMPL
410 STD RUMP { int|sys|50|mount(const char *type, \
const char *path, int flags, void *data, \
size_t data_len); }
411 STD { void *|sys||mremap(void *old_address, \
size_t old_size, void *new_address, \
size_t new_size, int flags); }
; Processor-sets system calls
412 STD { int|sys||pset_create(psetid_t *psid); }
413 STD { int|sys||pset_destroy(psetid_t psid); }
414 STD { int|sys||pset_assign(psetid_t psid, cpuid_t cpuid, \
psetid_t *opsid); }
415 STD { int|sys||_pset_bind(idtype_t idtype, id_t first_id, \
id_t second_id, psetid_t psid, psetid_t *opsid); }
416 NOERR RUMP { int|sys|50|posix_fadvise(int fd, int PAD, \
off_t offset, off_t len, int advice); }
417 STD RUMP { int|sys|50|select(int nd, fd_set *in, fd_set *ou, \
fd_set *ex, struct timeval *tv); }
418 STD RUMP { int|sys|50|gettimeofday(struct timeval *tp, \
void *tzp); }
419 STD RUMP { int|sys|50|settimeofday(const struct timeval *tv, \
const void *tzp); }
420 STD RUMP { int|sys|50|utimes(const char *path, \
const struct timeval *tptr); }
421 STD RUMP { int|sys|50|adjtime(const struct timeval *delta, \
struct timeval *olddelta); }
422 STD MODULAR lfs { int|sys|50|lfs_segwait(fsid_t *fsidp, \
struct timeval *tv); }
423 STD RUMP { int|sys|50|futimes(int fd, \
const struct timeval *tptr); }
424 STD RUMP { int|sys|50|lutimes(const char *path, \
const struct timeval *tptr); }
425 STD RUMP { int|sys|50|setitimer(int which, \
const struct itimerval *itv, \
struct itimerval *oitv); }
426 STD RUMP { int|sys|50|getitimer(int which, \
struct itimerval *itv); }
427 STD RUMP { int|sys|50|clock_gettime(clockid_t clock_id, \
struct timespec *tp); }
428 STD RUMP { int|sys|50|clock_settime(clockid_t clock_id, \
const struct timespec *tp); }
429 STD RUMP { int|sys|50|clock_getres(clockid_t clock_id, \
struct timespec *tp); }
430 STD RUMP { int|sys|50|nanosleep(const struct timespec *rqtp, \
struct timespec *rmtp); }
431 STD { int|sys|50|__sigtimedwait(const sigset_t *set, \
siginfo_t *info, \
struct timespec *timeout); }
432 STD MODULAR mqueue \
{ int|sys|50|mq_timedsend(mqd_t mqdes, \
const char *msg_ptr, size_t msg_len, \
unsigned msg_prio, \
const struct timespec *abs_timeout); }
433 STD MODULAR mqueue \
{ ssize_t|sys|50|mq_timedreceive(mqd_t mqdes, \
char *msg_ptr, size_t msg_len, unsigned *msg_prio, \
const struct timespec *abs_timeout); }
434 COMPAT_60 MODULAR compat_60 \
{ int|sys||_lwp_park(const struct timespec *ts, \
lwpid_t unpark, const void *hint, \
const void *unparkhint); }
435 STD RUMP { int|sys|50|kevent(int fd, \
const struct kevent *changelist, size_t nchanges, \
struct kevent *eventlist, size_t nevents, \
const struct timespec *timeout); }
436 STD RUMP { int|sys|50|pselect(int nd, fd_set *in, fd_set *ou, \
fd_set *ex, const struct timespec *ts, \
const sigset_t *mask); }
437 STD RUMP { int|sys|50|pollts(struct pollfd *fds, u_int nfds, \
const struct timespec *ts, const sigset_t *mask); }
438 STD MODULAR aio RUMP { int|sys|50|aio_suspend( \
const struct aiocb *const *list, \
int nent, const struct timespec *timeout); }
439 STD RUMP { int|sys|50|stat(const char *path, struct stat *ub); }
440 STD RUMP { int|sys|50|fstat(int fd, struct stat *sb); }
441 STD RUMP { int|sys|50|lstat(const char *path, struct stat *ub); }
442 STD MODULAR sysv_ipc { int|sys|50|__semctl(int semid, int semnum, \
int cmd, ... union __semun *arg); }
443 STD MODULAR sysv_ipc { int|sys|50|shmctl(int shmid, int cmd, \
struct shmid_ds *buf); }
444 STD MODULAR sysv_ipc { int|sys|50|msgctl(int msqid, int cmd, \
struct msqid_ds *buf); }
445 STD { int|sys|50|getrusage(int who, struct rusage *rusage); }
446 STD RUMP { int|sys|50|timer_settime(timer_t timerid, \
int flags, const struct itimerspec *value, \
struct itimerspec *ovalue); }
447 STD RUMP { int|sys|50|timer_gettime(timer_t timerid, struct \
itimerspec *value); }
#if defined(NTP) || !defined(_KERNEL_OPT)
448 STD { int|sys|50|ntp_gettime(struct ntptimeval *ntvp); }
#else
448 EXCL ___ntp_gettime50
#endif
449 STD { int|sys|50|wait4(pid_t pid, int *status, \
int options, struct rusage *rusage); }
450 STD RUMP { int|sys|50|mknod(const char *path, mode_t mode, \
dev_t dev); }
451 STD RUMP { int|sys|50|fhstat(const void *fhp, \
size_t fh_size, struct stat *sb); }
; 452 only ever appeared in 5.99.x and can be reused after netbsd-7
452 OBSOL 5.99 quotactl
453 STD RUMP { int|sys||pipe2(int *fildes, int flags); }
454 STD RUMP { int|sys||dup3(int from, int to, int flags); }
455 STD RUMP { int|sys||kqueue1(int flags); }
456 STD RUMP { int|sys||paccept(int s, struct sockaddr *name, \
socklen_t *anamelen, const sigset_t *mask, \
int flags); }
457 STD RUMP { int|sys||linkat(int fd1, const char *name1, \
int fd2, const char *name2, int flags); }
458 STD RUMP { int|sys||renameat(int fromfd, const char *from, \
int tofd, const char *to); }
459 STD RUMP { int|sys||mkfifoat(int fd, const char *path, \
mode_t mode); }
460 STD RUMP { int|sys||mknodat(int fd, const char *path, \
mode_t mode, int PAD, dev_t dev); }
461 STD RUMP { int|sys||mkdirat(int fd, const char *path, \
mode_t mode); }
462 STD RUMP { int|sys||faccessat(int fd, const char *path, \
int amode, int flag); }
463 STD RUMP { int|sys||fchmodat(int fd, const char *path, \
mode_t mode, int flag); }
464 STD RUMP { int|sys||fchownat(int fd, const char *path, \
uid_t owner, gid_t group, int flag); }
465 STD { int|sys||fexecve(int fd, \
char * const *argp, char * const *envp); }
466 STD RUMP { int|sys||fstatat(int fd, const char *path, \
struct stat *buf, int flag); }
467 STD RUMP { int|sys||utimensat(int fd, const char *path, \
const struct timespec *tptr, int flag); }
468 STD RUMP { int|sys||openat(int fd, const char *path, \
int oflags, ... mode_t mode); }
469 STD RUMP { ssize_t|sys||readlinkat(int fd, const char *path, \
char *buf, size_t bufsize); }
470 STD RUMP { int|sys||symlinkat(const char *path1, int fd, \
const char *path2); }
471 STD RUMP { int|sys||unlinkat(int fd, const char *path, \
int flag); }
472 STD RUMP { int|sys||futimens(int fd, \
const struct timespec *tptr); }
473 STD RUMP { int|sys||__quotactl(const char *path, \
struct quotactl_args *args); }
474 NOERR { int|sys||posix_spawn(pid_t *pid, const char *path, \
const struct posix_spawn_file_actions *file_actions, \
const struct posix_spawnattr *attrp, \
char *const *argv, char *const *envp); }
475 STD RUMP { int|sys||recvmmsg(int s, struct mmsghdr *mmsg, \
unsigned int vlen, unsigned int flags, \
struct timespec *timeout); }
476 STD RUMP { int|sys||sendmmsg(int s, struct mmsghdr *mmsg, \
unsigned int vlen, unsigned int flags); }
477 NOERR RUMP { int|sys||clock_nanosleep(clockid_t clock_id, \
int flags, const struct timespec *rqtp, \
struct timespec *rmtp); }
478 STD { int|sys|60|_lwp_park(clockid_t clock_id, int flags, \
struct timespec *ts, lwpid_t unpark, \
const void *hint, const void *unparkhint); }
479 NOERR RUMP { int|sys||posix_fallocate(int fd, int PAD, off_t pos, \
off_t len); }
480 STD RUMP { int|sys||fdiscard(int fd, int PAD, off_t pos, \
off_t len); }
481 STD { int|sys||wait6(idtype_t idtype, id_t id, \
int *status, int options, struct wrusage *wru, \
siginfo_t *info); }
482 STD RUMP { int|sys||clock_getcpuclockid2(idtype_t idtype, \
id_t id, clockid_t *clock_id); }
483 STD RUMP { int|sys|90|getvfsstat(struct statvfs *buf, \
size_t bufsize, int flags); }
484 STD RUMP { int|sys|90|statvfs1(const char *path, \
struct statvfs *buf, int flags); }
485 STD RUMP { int|sys|90|fstatvfs1(int fd, \
struct statvfs *buf, int flags); }
486 STD RUMP { int|sys|90|fhstatvfs1(const void *fhp, \
size_t fh_size, struct statvfs *buf, int flags); }
487 STD { int|sys||__acl_get_link(const char *path, \
acl_type_t type, struct acl *aclp); }
488 STD { int|sys||__acl_set_link(const char *path, \
acl_type_t type, struct acl *aclp); }
489 STD { int|sys||__acl_delete_link(const char *path, \
acl_type_t type); }
490 STD { int|sys||__acl_aclcheck_link(const char *path, \
acl_type_t type, struct acl *aclp); }
491 STD { int|sys||__acl_get_file(const char *path, \
acl_type_t type, struct acl *aclp); }
492 STD { int|sys||__acl_set_file(const char *path, \
acl_type_t type, struct acl *aclp); }
493 STD { int|sys||__acl_get_fd(int filedes, acl_type_t type, \
struct acl *aclp); }
494 STD { int|sys||__acl_set_fd(int filedes, acl_type_t type, \
struct acl *aclp); }
495 STD { int|sys||__acl_delete_file(const char *path, \
acl_type_t type); }
496 STD { int|sys||__acl_delete_fd(int filedes, \
acl_type_t type); }
497 STD { int|sys||__acl_aclcheck_file(const char *path, \
acl_type_t type, struct acl *aclp); }
498 STD { int|sys||__acl_aclcheck_fd(int filedes, \
acl_type_t type, struct acl *aclp); }
499 STD RUMP { long|sys||lpathconf(const char *path, int name); }
|