sys/amd64/linux/syscalls.master

   1  $FreeBSD$
   2
   3 ;       @(#)syscalls.master     8.1 (Berkeley) 7/19/93
   4 ; System call name/number master file (or rather, slave, from LINUX).
   5 ; Processed to create linux_sysent.c, linux_proto.h and linux_syscall.h.
   6
   7 ; Columns: number audit type nargs name alt{name,tag,rtyp}/comments
   8 ;       number  system call number, must be in order
   9 ;       audit   the audit event associated with the system call
  10 ;               A value of AUE_NULL means no auditing, but it also means that
  11 ;               there is no audit event for the call at this time. For the
  12 ;               case where the event exists, but we don't want auditing, the
  13 ;               event should be #defined to AUE_NULL in audit_kevents.h.
  14 ;       type    one of STD, NOPROTO, UNIMPL
  15 ;       name    pseudo-prototype of syscall routine
  16 ;               If one of the following alts is different, then all appear:
  17 ;       altname name of system call if different
  18 ;       alttag  name of args struct tag if different from [o]`name'"_args"
  19 ;       altrtyp return type if not int (bogus - syscalls always return int)
  20 ;               for UNIMPL, name continues with comments
  21
  22 ; types:
  23 ;       STD     always included
  24 ;       UNIMPL  not implemented, placeholder only
  25 ;       NOPROTO same as STD except do not create structure or
  26 ;               function prototype in sys/sysproto.h.  Does add a
  27 ;               definition to syscall.h besides adding a sysent.
  28
  29 #include <sys/param.h>
  30 #include <sys/sysent.h>
  31 #include <sys/sysproto.h>
  32 #include <compat/linux/linux_sysproto.h>
  33 #include <amd64/linux/linux.h>
  34 #include <amd64/linux/linux_proto.h>
  35
  36 ; Isn't pretty, but there seems to be no other way to trap nosys
  37 #define nosys   linux_nosys
  38
  39 ; #ifdef's, etc. may be included, and are copied to the output files.
  40
  41 0       AUE_NULL        NOPROTO {
  42                 int read(
  43                     int fd,
  44                     char *buf,
  45                     l_size_t nbyte
  46                 );
  47         }
  48 1       AUE_NULL        NOPROTO {
  49                 int write(
  50                     int fd,
  51                     char *buf,
  52                     l_size_t nbyte
  53                 );
  54         }
  55 2       AUE_OPEN_RWTC   STD {
  56                 int linux_open(
  57                     char *path,
  58                     l_int flags,
  59                     l_mode_t mode
  60                 );
  61         }
  62 3       AUE_CLOSE       NOPROTO {
  63                 int close(
  64                     int fd
  65                 );
  66         }
  67 4       AUE_STAT        STD {
  68                 int linux_newstat(
  69                     char *path,
  70                     struct l_newstat *buf
  71                 );
  72         }
  73 5       AUE_FSTAT       STD {
  74                 int linux_newfstat(
  75                     l_uint fd,
  76                     struct l_newstat *buf
  77                 );
  78         }
  79 6       AUE_LSTAT       STD {
  80                 int linux_newlstat(
  81                     char *path,
  82                     struct l_newstat *buf
  83                 );
  84         }
  85 7       AUE_POLL        NOPROTO {
  86                 int poll(
  87                     struct pollfd *fds,
  88                     u_int nfds,
  89                     int timeout
  90                 );
  91         }
  92 8       AUE_LSEEK       STD {
  93                 int linux_lseek(
  94                     l_uint fdes,
  95                     l_off_t off,
  96                     l_int whence
  97                 );
  98         }
  99 9       AUE_MMAP        STD {
 100                 int linux_mmap2(
 101                     l_ulong addr,
 102                     l_ulong len,
 103                     l_ulong prot,
 104                     l_ulong flags,
 105                     l_ulong fd,
 106                     l_ulong pgoff
 107                 );
 108         }
 109 10      AUE_MPROTECT    STD {
 110                 int linux_mprotect(
 111                     l_ulong addr,
 112                     l_size_t len,
 113                     l_ulong prot
 114                 );
 115         }
 116 11      AUE_MUNMAP      NOPROTO {
 117                 int munmap(
 118                     void *addr,
 119                     l_size_t len
 120                 );
 121         }
 122 12      AUE_NULL        STD {
 123                 int linux_brk(
 124                     l_ulong dsend
 125                 );
 126         }
 127 13      AUE_NULL        STD {
 128                 int linux_rt_sigaction(
 129                     l_int sig,
 130                     l_sigaction_t *act,
 131                     l_sigaction_t *oact,
 132                     l_size_t sigsetsize
 133                 );
 134         }
 135 14      AUE_NULL        STD {
 136                 int linux_rt_sigprocmask(
 137                     l_int how,
 138                     l_sigset_t *mask,
 139                     l_sigset_t *omask,
 140                     l_size_t sigsetsize
 141                 );
 142         }
 143 15      AUE_NULL        STD {
 144                 int linux_rt_sigreturn(
 145                     struct l_ucontext *ucp
 146                 );
 147         }
 148 16      AUE_IOCTL       STD {
 149                 int linux_ioctl(
 150                     l_uint fd,
 151                     l_uint cmd,
 152                     l_ulong arg
 153                 );
 154         }
 155 17      AUE_PREAD       STD {
 156                 int linux_pread(
 157                     l_uint fd,
 158                     char *buf,
 159                     l_size_t nbyte,
 160                     l_loff_t offset
 161                 );
 162         }
 163 18      AUE_PWRITE      STD {
 164                 int linux_pwrite(
 165                     l_uint fd,
 166                     char *buf,
 167                     l_size_t nbyte,
 168                     l_loff_t offset
 169                 );
 170         }
 171 19      AUE_READV       NOPROTO {
 172                 int readv(
 173                     int fd,
 174                     struct iovec *iovp,
 175                     u_int iovcnt
 176                 );
 177         }
 178 20      AUE_WRITEV      NOPROTO {
 179                 int writev(
 180                     int fd,
 181                     struct iovec *iovp,
 182                     u_int iovcnt
 183                 );
 184         }
 185 21      AUE_ACCESS      STD {
 186                 int linux_access(
 187                     char *path,
 188                     l_int amode
 189                 );
 190         }
 191 22      AUE_PIPE        STD {
 192                 int linux_pipe(
 193                     l_int *pipefds
 194                 );
 195         }
 196 23      AUE_SELECT      STD {
 197                 int linux_select(
 198                     l_int nfds,
 199                     l_fd_set *readfds,
 200                     l_fd_set *writefds,
 201                     l_fd_set *exceptfds,
 202                     struct l_timeval *timeout
 203                 );
 204         }
 205 24      AUE_NULL        NOPROTO {
 206                 int sched_yield(void);
 207         }
 208 25      AUE_NULL        STD {
 209                 int linux_mremap(
 210                     l_ulong addr,
 211                     l_ulong old_len,
 212                     l_ulong new_len,
 213                     l_ulong flags,
 214                     l_ulong new_addr
 215                 );
 216         }
 217 26      AUE_MSYNC       STD {
 218                 int linux_msync(
 219                     l_ulong addr,
 220                     l_size_t len,
 221                     l_int fl
 222                 );
 223         }
 224 27      AUE_MINCORE     STD {
 225                 int linux_mincore(
 226                     l_ulong start,
 227                     l_size_t len,
 228                     u_char *vec
 229                 );
 230         }
 231 28      AUE_MADVISE     STD {
 232                 int linux_madvise(
 233                     l_ulong addr,
 234                     l_size_t len,
 235                     l_int behav
 236                 );
 237         }
 238 29      AUE_NULL        STD {
 239                 int linux_shmget(
 240                     l_key_t key,
 241                     l_size_t size,
 242                     l_int shmflg
 243                 );
 244         }
 245 30      AUE_NULL        STD {
 246                 int linux_shmat(
 247                     l_int shmid,
 248                     char *shmaddr,
 249                     l_int shmflg
 250                 );
 251         }
 252 31      AUE_NULL        STD {
 253                 int linux_shmctl(
 254                     l_int shmid,
 255                     l_int cmd,
 256                     struct l_shmid_ds *buf
 257                 );
 258         }
 259 32      AUE_DUP         NOPROTO {
 260                 int dup(
 261                     u_int fd
 262                 );
 263         }
 264 33      AUE_DUP2        NOPROTO {
 265                 int dup2(
 266                     u_int from,
 267                     u_int to
 268                 );
 269         }
 270 34      AUE_NULL        STD {
 271                 int linux_pause(void);
 272         }
 273 35      AUE_NULL        STD {
 274                 int linux_nanosleep(
 275                     const struct l_timespec *rqtp,
 276                     struct l_timespec *rmtp
 277                 );
 278         }
 279 36      AUE_GETITIMER   STD {
 280                 int linux_getitimer(
 281                     l_int which,
 282                     struct l_itimerval *itv
 283                 );
 284         }
 285 37      AUE_NULL        STD {
 286                 int linux_alarm(
 287                     l_uint secs
 288                 );
 289         }
 290 38      AUE_SETITIMER   STD {
 291                 int linux_setitimer(
 292                     l_int which,
 293                     struct l_itimerval *itv,
 294                     struct l_itimerval *oitv
 295                 );
 296         }
 297 39      AUE_GETPID      STD {
 298                 int linux_getpid(void);
 299         }
 300 40      AUE_SENDFILE    STD {
 301                 int linux_sendfile(
 302                     l_int out,
 303                     l_int in,
 304                     l_off_t *offset,
 305                     l_size_t count
 306                 );
 307         }
 308 41      AUE_SOCKET      STD {
 309                 int linux_socket(
 310                     l_int domain,
 311                     l_int type,
 312                     l_int protocol
 313                 );
 314         }
 315 42      AUE_CONNECT     STD {
 316                 int linux_connect(
 317                     l_int s,
 318                     l_uintptr_t name,
 319                     l_int namelen
 320                 );
 321         }
 322 43      AUE_ACCEPT      STD {
 323                 int linux_accept(
 324                     l_int s,
 325                     l_uintptr_t addr,
 326                     l_uintptr_t namelen
 327                 );
 328         }
 329 44      AUE_SENDTO      STD {
 330                 int linux_sendto(
 331                     l_int s,
 332                     l_uintptr_t msg,
 333                     l_size_t len,
 334                     l_uint flags,
 335                     l_uintptr_t to,
 336                     l_int tolen
 337                 );
 338         }
 339 45      AUE_RECVFROM    STD {
 340                 int linux_recvfrom(
 341                     l_int s,
 342                     l_uintptr_t buf,
 343                     l_size_t len,
 344                     l_uint flags,
 345                     l_uintptr_t from,
 346                     l_uintptr_t fromlen
 347                 );
 348         }
 349 46      AUE_SENDMSG     STD {
 350                 int linux_sendmsg(
 351                     l_int s,
 352                     l_uintptr_t msg,
 353                     l_uint flags
 354                 );
 355         }
 356 47      AUE_RECVMSG     STD {
 357                 int linux_recvmsg(
 358                     l_int s,
 359                     l_uintptr_t msg,
 360                     l_uint flags
 361                 );
 362         }
 363 48      AUE_NULL        STD {
 364                 int linux_shutdown(
 365                     l_int s,
 366                     l_int how
 367                 );
 368         }
 369 49      AUE_BIND        STD {
 370                 int linux_bind(
 371                     l_int s,
 372                     l_uintptr_t name,
 373                     l_int namelen
 374                 );
 375         }
 376 50      AUE_LISTEN      STD {
 377                 int linux_listen(
 378                     l_int s,
 379                     l_int backlog
 380                 );
 381         }
 382 51      AUE_GETSOCKNAME STD {
 383                 int linux_getsockname(
 384                     l_int s,
 385                     l_uintptr_t addr,
 386                     l_uintptr_t namelen
 387                 );
 388         }
 389 52      AUE_GETPEERNAME STD {
 390                 int linux_getpeername(
 391                     l_int s,
 392                     l_uintptr_t addr,
 393                     l_uintptr_t namelen
 394                 );
 395         }
 396 53      AUE_SOCKETPAIR  STD {
 397                 int linux_socketpair(
 398                     l_int domain,
 399                     l_int type,
 400                     l_int protocol,
 401                     l_uintptr_t rsv
 402                 );
 403         }
 404 54      AUE_SETSOCKOPT  STD {
 405                 int linux_setsockopt(
 406                     l_int s,
 407                     l_int level,
 408                     l_int optname,
 409                     l_uintptr_t optval,
 410                     l_int optlen
 411                 );
 412         }
 413 55      AUE_GETSOCKOPT  STD {
 414                 int linux_getsockopt(
 415                     l_int s,
 416                     l_int level,
 417                     l_int optname,
 418                     l_uintptr_t optval,
 419                     l_uintptr_t optlen
 420                 );
 421         }
 422 56      AUE_RFORK       STD {
 423                 int linux_clone(
 424                     l_ulong flags,
 425                     void *stack,
 426                     void *parent_tidptr,
 427                     void *child_tidptr,
 428                     void *tls
 429                 );
 430         }
 431 57      AUE_FORK        STD {
 432                 int linux_fork(void);
 433         }
 434 58      AUE_VFORK       STD {
 435                 int linux_vfork(void);
 436         }
 437 59      AUE_EXECVE      STD {
 438                 int linux_execve(
 439                     char *path,
 440                     char **argp,
 441                     char **envp
 442                 );
 443         }
 444 60      AUE_EXIT        STD {
 445                 void linux_exit(
 446                     l_int rval
 447                 );
 448         }
 449 61      AUE_WAIT4       STD {
 450                 int linux_wait4(
 451                     l_pid_t pid,
 452                     l_int *status,
 453                     l_int options,
 454                     struct rusage *rusage
 455                 );
 456         }
 457 62      AUE_KILL        STD {
 458                 int linux_kill(
 459                     l_pid_t pid,
 460                     l_int signum
 461                 );
 462         }
 463 63      AUE_NULL        STD {
 464                 int linux_newuname(
 465                     struct l_new_utsname *buf
 466                 );
 467         }
 468 64      AUE_NULL        STD {
 469                 int linux_semget(
 470                     l_key_t key,
 471                     l_int nsems,
 472                     l_int semflg
 473                 );
 474         }
 475 65      AUE_NULL        STD {
 476                 int linux_semop(
 477                     l_int semid,
 478                     struct l_sembuf *tsops,
 479                     l_uint nsops
 480                 );
 481         }
 482 66      AUE_NULL        STD {
 483                 int linux_semctl(
 484                     l_int semid,
 485                     l_int semnum,
 486                     l_int cmd,
 487                     union l_semun arg
 488                 );
 489         }
 490 67      AUE_NULL        STD {
 491                 int linux_shmdt(
 492                     char *shmaddr
 493                 );
 494         }
 495 68      AUE_NULL        STD {
 496                 int linux_msgget(
 497                     l_key_t key,
 498                     l_int msgflg
 499                 );
 500         }
 501 69      AUE_NULL        STD {
 502                 int linux_msgsnd(
 503                     l_int msqid,
 504                     struct l_msgbuf *msgp,
 505                     l_size_t msgsz,
 506                     l_int msgflg
 507                 );
 508         }
 509 70      AUE_NULL        STD {
 510                 int linux_msgrcv(
 511                     l_int msqid,
 512                     struct l_msgbuf *msgp,
 513                     l_size_t msgsz,
 514                     l_long msgtyp,
 515                     l_int msgflg
 516                 );
 517         }
 518 71      AUE_NULL        STD {
 519                 int linux_msgctl(
 520                     l_int msqid,
 521                     l_int cmd,
 522                     struct l_msqid_ds *buf
 523                 );
 524         }
 525 72      AUE_FCNTL       STD {
 526                 int linux_fcntl(
 527                     l_uint fd,
 528                     l_uint cmd,
 529                     l_ulong arg
 530                 );
 531         }
 532 73      AUE_FLOCK       NOPROTO {
 533                 int flock(
 534                     int fd,
 535                     int how
 536                 );
 537         }
 538 74      AUE_FSYNC       NOPROTO {
 539                 int fsync(
 540                     int fd
 541                 );
 542         }
 543 75      AUE_NULL        STD {
 544                 int linux_fdatasync(
 545                     l_uint fd
 546                 );
 547         }
 548 76      AUE_TRUNCATE    STD {
 549                 int linux_truncate(
 550                     char *path,
 551                     l_long length
 552                 );
 553         }
 554 77      AUE_FTRUNCATE   STD {
 555                 int linux_ftruncate(
 556                     l_int fd,
 557                     l_ulong length
 558                 );
 559         }
 560 78      AUE_GETDIRENTRIES       STD  {
 561                 int linux_getdents(
 562                     l_uint fd,
 563                     void *dent,
 564                     l_uint count
 565                 );
 566         }
 567 79      AUE_GETCWD      STD {
 568                 int linux_getcwd(
 569                     char *buf,
 570                     l_ulong bufsize
 571                 );
 572         }
 573 80      AUE_CHDIR       STD {
 574                 int linux_chdir(
 575                     char *path
 576                 );
 577         }
 578 81      AUE_FCHDIR      NOPROTO {
 579                 int fchdir(
 580                     int fd
 581                 );
 582         }
 583 82      AUE_RENAME      STD {
 584                 int linux_rename(
 585                     char *from,
 586                     char *to
 587                 );
 588         }
 589 83      AUE_MKDIR       STD {
 590                 int linux_mkdir(
 591                     char *path,
 592                     l_mode_t mode
 593                 );
 594         }
 595 84      AUE_RMDIR       STD {
 596                 int linux_rmdir(
 597                     char *path
 598                 );
 599         }
 600 85      AUE_CREAT       STD {
 601                 int linux_creat(
 602                     char *path,
 603                     l_mode_t mode
 604                 );
 605         }
 606 86      AUE_LINK        STD {
 607                 int linux_link(
 608                     char *path,
 609                     char *to
 610                 );
 611         }
 612 87      AUE_UNLINK      STD {
 613                 int linux_unlink(
 614                     char *path
 615                 );
 616         }
 617 88      AUE_SYMLINK     STD {
 618                 int linux_symlink(
 619                     char *path,
 620                     char *to
 621                 );
 622         }
 623 89      AUE_READLINK    STD {
 624                 int linux_readlink(
 625                     char *name,
 626                     char *buf,
 627                     l_int count
 628                 );
 629         }
 630 90      AUE_CHMOD       STD {
 631                 int linux_chmod(
 632                     char *path,
 633                     l_mode_t mode
 634                 );
 635         }
 636 91      AUE_FCHMOD      NOPROTO {
 637                 int fchmod(
 638                     int fd,
 639                     int mode
 640                 );
 641         }
 642 92      AUE_LCHOWN      STD {
 643                 int linux_chown(
 644                     char *path,
 645                     l_uid_t uid,
 646                     l_gid_t gid
 647                 );
 648         }
 649 93      AUE_FCHOWN      NOPROTO {
 650                 int fchown(
 651                     int fd,
 652                     int uid,
 653                     int gid
 654                 );
 655         }
 656 94      AUE_LCHOWN      STD {
 657                 int linux_lchown(
 658                     char *path,
 659                     l_uid_t uid,
 660                     l_gid_t gid
 661                 );
 662         }
 663 95      AUE_UMASK       NOPROTO {
 664                 int umask(
 665                     int newmask
 666                 );
 667         }
 668 96      AUE_NULL        NOPROTO {
 669                 int gettimeofday(
 670                     struct l_timeval *tp,
 671                     struct timezone *tzp
 672                 );
 673         }
 674 97      AUE_GETRLIMIT   STD {
 675                 int linux_getrlimit(
 676                     l_uint resource,
 677                     struct l_rlimit *rlim
 678                 );
 679         }
 680 98      AUE_GETRUSAGE   NOPROTO {
 681                 int getrusage(
 682                     int who,
 683                     struct rusage *rusage
 684                 );
 685         }
 686 99      AUE_NULL        STD {
 687                 int linux_sysinfo(
 688                     struct l_sysinfo *info
 689                 );
 690         }
 691 100     AUE_NULL        STD {
 692                 int linux_times(
 693                     struct l_times_argv *buf
 694                 );
 695         }
 696 101     AUE_PTRACE      STD {
 697                 int linux_ptrace(
 698                     l_long req,
 699                     l_long pid,
 700                     l_ulong addr,
 701                     l_ulong data
 702                 );
 703         }
 704 102     AUE_GETUID      STD {
 705                 int linux_getuid(void);
 706         }
 707 103     AUE_NULL        STD {
 708                 int linux_syslog(
 709                     l_int type,
 710                     char *buf,
 711                     l_int len
 712                 );
 713         }
 714 104     AUE_GETGID      STD {
 715                 int linux_getgid(void);
 716         }
 717 105     AUE_SETUID      NOPROTO {
 718                 int setuid(
 719                     uid_t uid
 720                 );
 721         }
 722 106     AUE_SETGID      NOPROTO {
 723                 int setgid(
 724                     gid_t gid
 725                 );
 726         }
 727 107     AUE_GETEUID     NOPROTO {
 728                 int geteuid(void);
 729         }
 730 108     AUE_GETEGID     NOPROTO {
 731                 int getegid(void);
 732         }
 733 109     AUE_SETPGRP     NOPROTO {
 734                 int setpgid(
 735                     int pid,
 736                     int pgid
 737                 );
 738         }
 739 110     AUE_GETPPID     STD {
 740                 int linux_getppid(void);
 741         }
 742 111     AUE_GETPGRP     NOPROTO {
 743                 int getpgrp(void);
 744         }
 745 112     AUE_SETSID      NOPROTO {
 746                 int setsid(void);
 747         }
 748 113     AUE_SETREUID    NOPROTO {
 749                 int setreuid(
 750                     uid_t ruid,
 751                     uid_t euid
 752                 );
 753         }
 754 114     AUE_SETREGID    NOPROTO {
 755                 int setregid(
 756                     gid_t rgid,
 757                     gid_t egid
 758                 );
 759         }
 760 115     AUE_GETGROUPS   STD {
 761                 int linux_getgroups(
 762                     l_int gidsetsize,
 763                     l_gid_t *grouplist
 764                 );
 765         }
 766 116     AUE_SETGROUPS   STD {
 767                 int linux_setgroups(
 768                     l_int gidsetsize,
 769                     l_gid_t *grouplist
 770                 );
 771         }
 772 117     AUE_SETRESUID   NOPROTO {
 773                 int setresuid(
 774                     uid_t ruid,
 775                     uid_t euid,
 776                     uid_t suid
 777                 );
 778         }
 779 118     AUE_GETRESUID   NOPROTO {
 780                 int getresuid(
 781                     uid_t *ruid,
 782                     uid_t *euid,
 783                     uid_t *suid
 784                 );
 785         }
 786 119     AUE_SETRESGID   NOPROTO {
 787                 int setresgid(
 788                     gid_t rgid,
 789                     gid_t egid,
 790                     gid_t sgid
 791                 );
 792         }
 793 120     AUE_GETRESGID   NOPROTO {
 794                 int getresgid(
 795                     gid_t *rgid,
 796                     gid_t *egid,
 797                     gid_t *sgid
 798                 );
 799         }
 800 121     AUE_GETPGID     NOPROTO {
 801                 int getpgid(
 802                     int pid
 803                 );
 804         }
 805 122     AUE_SETFSUID    STD {
 806                 int linux_setfsuid(
 807                     l_uid_t uid
 808                 );
 809         }
 810 123     AUE_SETFSGID    STD {
 811                 int linux_setfsgid(
 812                     l_gid_t gid
 813                 );
 814         }
 815 124     AUE_GETSID      STD {
 816                 int linux_getsid(
 817                     l_pid_t pid
 818                 );
 819         }
 820 125     AUE_CAPGET      STD {
 821                 int linux_capget(
 822                     struct l_user_cap_header *hdrp,
 823                     struct l_user_cap_data *datap
 824                 );
 825         }
 826 126     AUE_CAPSET      STD {
 827                 int linux_capset(
 828                     struct l_user_cap_header *hdrp,
 829                     struct l_user_cap_data *datap
 830                 );
 831         }
 832 127     AUE_NULL        STD {
 833                 int linux_rt_sigpending(
 834                     l_sigset_t *set,
 835                     l_size_t sigsetsize
 836                 );
 837         }
 838 128     AUE_NULL        STD {
 839                 int linux_rt_sigtimedwait(
 840                     l_sigset_t *mask,
 841                     l_siginfo_t *ptr,
 842                     struct l_timeval *timeout,
 843                     l_size_t sigsetsize
 844                 );
 845         }
 846 129     AUE_NULL        STD {
 847                 int linux_rt_sigqueueinfo(
 848                     l_pid_t pid,
 849                     l_int sig,
 850                     l_siginfo_t *info
 851                 );
 852         }
 853 130     AUE_NULL        STD {
 854                 int linux_rt_sigsuspend(
 855                     l_sigset_t *newset,
 856                     l_size_t sigsetsize
 857                 );
 858         }
 859 131     AUE_NULL        STD {
 860                 int linux_sigaltstack(
 861                     l_stack_t *uss,
 862                     l_stack_t *uoss
 863                 );
 864         }
 865 132     AUE_UTIME       STD {
 866                 int linux_utime(
 867                     char *fname,
 868                     struct l_utimbuf *times
 869                 );
 870         }
 871 133     AUE_MKNOD       STD {
 872                 int linux_mknod(
 873                     char *path,
 874                     l_mode_t mode,
 875                     l_uint dev
 876                 );
 877         }
 878 134     AUE_USELIB      UNIMPL  uselib
 879 135     AUE_PERSONALITY STD {
 880                 int linux_personality(
 881                     l_uint per
 882                 );
 883         }
 884 136     AUE_NULL        STD {
 885                 int linux_ustat(
 886                     l_uint dev,
 887                     struct l_ustat *ubuf
 888                 );
 889         }
 890 137     AUE_STATFS      STD {
 891                 int linux_statfs(
 892                     char *path,
 893                     struct l_statfs_buf *buf
 894                 );
 895         }
 896 138     AUE_FSTATFS     STD {
 897                 int linux_fstatfs(
 898                     l_uint fd,
 899                     struct l_statfs_buf *buf
 900                 );
 901         }
 902 139     AUE_NULL        STD {
 903                 int linux_sysfs(
 904                     l_int option,
 905                     l_ulong arg1,
 906                     l_ulong arg2
 907                 );
 908         }
 909 140     AUE_GETPRIORITY STD {
 910                 int linux_getpriority(
 911                     l_int which,
 912                     l_int who
 913                 );
 914         }
 915 141     AUE_SETPRIORITY NOPROTO {
 916                 int setpriority(
 917                     int which,
 918                     int who,
 919                     int prio
 920                 );
 921         }
 922 142     AUE_SCHED_SETPARAM      STD {
 923                 int linux_sched_setparam(
 924                     l_pid_t pid,
 925                     struct sched_param *param
 926                 );
 927         }
 928 143     AUE_SCHED_GETPARAM      STD {
 929                 int linux_sched_getparam(
 930                     l_pid_t pid,
 931                     struct sched_param *param
 932                 );
 933         }
 934 144     AUE_SCHED_SETSCHEDULER  STD  {
 935                 int linux_sched_setscheduler(
 936                     l_pid_t pid,
 937                     l_int policy,
 938                     struct sched_param *param
 939                 );
 940         }
 941 145     AUE_SCHED_GETSCHEDULER  STD  {
 942                 int linux_sched_getscheduler(
 943                     l_pid_t pid
 944                 );
 945         }
 946 146     AUE_SCHED_GET_PRIORITY_MAX      STD  {
 947                 int linux_sched_get_priority_max(
 948                     l_int policy
 949                 );
 950         }
 951 147     AUE_SCHED_GET_PRIORITY_MIN      STD  {
 952                 int linux_sched_get_priority_min(
 953                     l_int policy
 954                 );
 955         }
 956 148     AUE_SCHED_RR_GET_INTERVAL       STD  {
 957                 int linux_sched_rr_get_interval(
 958                     l_pid_t pid,
 959                     struct l_timespec *interval
 960                 );
 961         }
 962 149     AUE_MLOCK       NOPROTO {
 963                 int mlock(
 964                     const void *addr,
 965                     size_t len
 966                 );
 967         }
 968 150     AUE_MUNLOCK     NOPROTO {
 969                 int munlock(
 970                     const void *addr,
 971                     size_t len
 972                 );
 973         }
 974 151     AUE_MLOCKALL    NOPROTO {
 975                 int mlockall(
 976                     int how
 977                 );
 978         }
 979 152     AUE_MUNLOCKALL  NOPROTO {
 980                 int munlockall(void);
 981         }
 982 153     AUE_NULL        STD {
 983                 int linux_vhangup(void);
 984         }
 985 154     AUE_NULL        STD {
 986                 int linux_modify_ldt(void);
 987         }
 988 155     AUE_PIVOT_ROOT  STD {
 989                 int linux_pivot_root(void);
 990         }
 991 156     AUE_SYSCTL      STD {
 992                 int linux_sysctl(
 993                     struct l___sysctl_args *args
 994                 );
 995         }
 996 157     AUE_PRCTL       STD {
 997                 int linux_prctl(
 998                     l_int option,
 999                     l_uintptr_t arg2,
1000                     l_uintptr_t arg3,
1001                     l_uintptr_t arg4,
1002                     l_uintptr_t arg5
1003                 );
1004         }
1005 158     AUE_PRCTL       STD {
1006                 int linux_arch_prctl(
1007                     l_int code,
1008                     l_ulong addr
1009                 );
1010         }
1011 159     AUE_ADJTIME     STD {
1012                 int linux_adjtimex(void);
1013         }
1014 160     AUE_SETRLIMIT   STD {
1015                 int linux_setrlimit(
1016                     l_uint resource,
1017                     struct l_rlimit *rlim
1018                 );
1019         }
1020 161     AUE_CHROOT      NOPROTO {
1021                 int chroot(
1022                     char *path
1023                 );
1024         }
1025 162     AUE_SYNC        NOPROTO {
1026                 int sync(void);
1027         }
1028 163     AUE_ACCT        NOPROTO {
1029                 int acct(
1030                     char *path
1031                 );
1032         }
1033 164     AUE_SETTIMEOFDAY        NOPROTO {
1034                 int settimeofday(
1035                     struct l_timeval *tv,
1036                     struct timezone *tzp
1037                 );
1038         }
1039 165     AUE_MOUNT       STD {
1040                 int linux_mount(
1041                     char *specialfile,
1042                     char *dir,
1043                     char *filesystemtype,
1044                     l_ulong rwflag,
1045                     void *data
1046                 );
1047         }
1048 166     AUE_UMOUNT      STD {
1049                 int linux_umount(
1050                     char *path,
1051                     l_int flags
1052                 );
1053         }
1054 167     AUE_SWAPON      NOPROTO {
1055                 int swapon(
1056                     char *name
1057                 );
1058         }
1059 168     AUE_SWAPOFF     STD {
1060                 int linux_swapoff(void);
1061         }
1062 169     AUE_REBOOT      STD {
1063                 int linux_reboot(
1064                     l_int magic1,
1065                     l_int magic2,
1066                     l_uint cmd,
1067                     void *arg
1068                 );
1069         }
1070 170     AUE_SYSCTL      STD {
1071                 int linux_sethostname(
1072                     char *hostname,
1073                     l_int len
1074                 );
1075         }
1076 171     AUE_SYSCTL      STD {
1077                 int linux_setdomainname(
1078                     char *name,
1079                     l_int len
1080                 );
1081         }
1082 172     AUE_NULL        STD {
1083                 int linux_iopl(
1084                     l_uint level
1085                 );
1086         }
1087 173     AUE_NULL        STD {
1088                 int linux_ioperm(void);
1089         }
1090 174     AUE_NULL        UNIMPL  create_module
1091 175     AUE_NULL        STD {
1092                 int linux_init_module(void);
1093         }
1094 176     AUE_NULL        STD {
1095                 int linux_delete_module(void);
1096         }
1097 177     AUE_NULL        UNIMPL  get_kernel_syms
1098 178     AUE_NULL        UNIMPL  query_module
1099 179     AUE_QUOTACTL    STD {
1100                 int linux_quotactl(void);
1101         }
1102 180     AUE_NULL        UNIMPL  nfsservctl
1103 181     AUE_GETPMSG     UNIMPL  getpmsg
1104 182     AUE_PUTPMSG     UNIMPL  putpmsg
1105 183     AUE_NULL        UNIMPL  afs_syscall
1106 184     AUE_NULL        UNIMPL  tuxcall
1107 185     AUE_NULL        UNIMPL  security
1108 186     AUE_NULL        STD {
1109                 int linux_gettid(void);
1110         }
1111 187     AUE_NULL        STD {
1112                 int linux_readahead(void);
1113         }
1114 188     AUE_NULL        STD {
1115                 int linux_setxattr(
1116                     const char *path,
1117                     const char *name,
1118                     const char *value,
1119                     l_size_t size,
1120                     l_int flags
1121                 );
1122         }
1123 189     AUE_NULL        STD {
1124                 int linux_lsetxattr(
1125                     const char *path,
1126                     const char *name,
1127                     const char *value,
1128                     l_size_t size,
1129                     l_int flags
1130                 );
1131         }
1132 190     AUE_NULL        STD {
1133                 int linux_fsetxattr(
1134                     l_int fd,
1135                     const char *name,
1136                     const char *value,
1137                     l_size_t size,
1138                     l_int flags
1139                 );
1140         }
1141 191     AUE_NULL        STD {
1142                 int linux_getxattr(
1143                     const char *path,
1144                     const char *name,
1145                     char *value,
1146                     l_size_t size
1147                 );
1148         }
1149 192     AUE_NULL        STD {
1150                 int linux_lgetxattr(
1151                     const char *path,
1152                     const char *name,
1153                     char *value,
1154                     l_size_t size
1155                 );
1156         }
1157 193     AUE_NULL        STD {
1158                 int linux_fgetxattr(
1159                     l_int fd,
1160                     const char *name,
1161                     char *value,
1162                     l_size_t size
1163                 );
1164         }
1165 194     AUE_NULL        STD {
1166                 int linux_listxattr(
1167                     const char *path,
1168                     const char *list,
1169                     l_size_t size
1170                 );
1171         }
1172 195     AUE_NULL        STD {
1173                 int linux_llistxattr(
1174                     const char *path,
1175                     const char *list,
1176                     l_size_t size
1177                 );
1178         }
1179 196     AUE_NULL        STD {
1180                 int linux_flistxattr(
1181                     l_int fd,
1182                     const char *list,
1183                     l_size_t size
1184                 );
1185         }
1186 197     AUE_NULL        STD {
1187                 int linux_removexattr(
1188                     const char *path,
1189                     const char *name
1190                 );
1191         }
1192 198     AUE_NULL        STD {
1193                 int linux_lremovexattr(
1194                     const char *path,
1195                     const char *name
1196                 );
1197         }
1198 199     AUE_NULL        STD {
1199                 int linux_fremovexattr(
1200                     l_int fd,
1201                     const char *name
1202                 );
1203         }
1204 200     AUE_NULL        STD {
1205                 int linux_tkill(
1206                     l_pid_t tid,
1207                     l_int sig
1208                 );
1209         }
1210 201     AUE_NULL        STD {
1211                 int linux_time(
1212                     l_time_t *tm
1213                 );
1214         }
1215 202     AUE_NULL        STD {
1216                 int linux_sys_futex(
1217                     void *uaddr,
1218                     l_int op,
1219                     l_int val,
1220                     struct l_timespec *timeout,
1221                     void *uaddr2,
1222                     l_int val3
1223                 );
1224         }
1225 203     AUE_NULL        STD {
1226                 int linux_sched_setaffinity(
1227                     l_pid_t pid,
1228                     l_uint len,
1229                     l_ulong *user_mask_ptr
1230                 );
1231         }
1232 204     AUE_NULL        STD {
1233                 int linux_sched_getaffinity(
1234                     l_pid_t pid,
1235                     l_uint len,
1236                     l_ulong *user_mask_ptr
1237                 );
1238         }
1239 205     AUE_NULL        UNIMPL  set_thread_area
1240 206     AUE_NULL        STD {
1241                 int linux_io_setup(void);
1242         }
1243 207     AUE_NULL        STD {
1244                 int linux_io_destroy(void);
1245         }
1246 208     AUE_NULL        STD {
1247                 int linux_io_getevents(void);
1248         }
1249 209     AUE_NULL        STD {
1250                 int linux_io_submit(void);
1251         }
1252 210     AUE_NULL        STD {
1253                 int linux_io_cancel(void);
1254         }
1255 211     AUE_NULL        UNIMPL  get_thread_area
1256 212     AUE_NULL        STD {
1257                 int linux_lookup_dcookie(void);
1258         }
1259 213     AUE_NULL        STD {
1260                 int linux_epoll_create(
1261                     l_int size
1262                 );
1263         }
1264 214     AUE_NULL        UNIMPL  epoll_ctl_old
1265 215     AUE_NULL        UNIMPL  epoll_wait_old
1266 216     AUE_NULL        STD {
1267                 int linux_remap_file_pages(void);
1268         }
1269 217     AUE_GETDIRENTRIES       STD  {
1270                 int linux_getdents64(
1271                     l_uint fd,
1272                     void *dirent,
1273                     l_uint count
1274                 );
1275         }
1276 218     AUE_NULL        STD {
1277                 int linux_set_tid_address(
1278                     l_int *tidptr
1279                 );
1280         }
1281 219     AUE_NULL        STD {
1282                 int linux_restart_syscall(void);
1283         }
1284 220     AUE_NULL        STD {
1285                 int linux_semtimedop(void);
1286         }
1287 221     AUE_NULL        STD {
1288                 int linux_fadvise64(
1289                     l_int fd,
1290                     l_loff_t offset,
1291                     l_size_t len,
1292                     l_int advice
1293                 );
1294         }
1295 222     AUE_NULL        STD {
1296                 int linux_timer_create(
1297                     clockid_t clock_id,
1298                     struct sigevent *evp,
1299                     l_timer_t *timerid
1300                 );
1301         }
1302 223     AUE_NULL        STD {
1303                 int linux_timer_settime(
1304                     l_timer_t timerid,
1305                     l_int flags,
1306                     const struct itimerspec *new,
1307                     struct itimerspec *old
1308                 );
1309         }
1310 224     AUE_NULL        STD {
1311                 int linux_timer_gettime(
1312                     l_timer_t timerid,
1313                     struct itimerspec *setting
1314                 );
1315         }
1316 225     AUE_NULL        STD {
1317                 int linux_timer_getoverrun(
1318                     l_timer_t timerid
1319                 );
1320         }
1321 226     AUE_NULL        STD {
1322                 int linux_timer_delete(
1323                     l_timer_t timerid
1324                 );
1325         }
1326 227     AUE_CLOCK_SETTIME       STD {
1327                 int linux_clock_settime(
1328                     clockid_t which,
1329                     struct l_timespec *tp
1330                 );
1331         }
1332 228     AUE_NULL        STD {
1333                 int linux_clock_gettime(
1334                     clockid_t which,
1335                     struct l_timespec *tp
1336                 );
1337         }
1338 229     AUE_NULL        STD {
1339                 int linux_clock_getres(
1340                     clockid_t which,
1341                     struct l_timespec *tp
1342                 );
1343         }
1344 230     AUE_NULL        STD {
1345                 int linux_clock_nanosleep(
1346                     clockid_t which,
1347                     l_int flags,
1348                     struct l_timespec *rqtp,
1349                     struct l_timespec *rmtp
1350                 );
1351         }
1352 231     AUE_EXIT        STD {
1353                 int linux_exit_group(
1354                     l_int error_code
1355                 );
1356         }
1357 232     AUE_NULL        STD {
1358                 int linux_epoll_wait(
1359                     l_int epfd,
1360                     struct epoll_event *events,
1361                     l_int maxevents,
1362                     l_int timeout
1363                 );
1364         }
1365 233     AUE_NULL        STD {
1366                 int linux_epoll_ctl(
1367                     l_int epfd,
1368                     l_int op,
1369                     l_int fd,
1370                     struct epoll_event *event
1371                 );
1372         }
1373 234     AUE_NULL        STD {
1374                 int linux_tgkill(
1375                     l_pid_t tgid,
1376                     l_pid_t pid,
1377                     l_int sig
1378                 );
1379         }
1380 235     AUE_UTIMES      STD {
1381                 int linux_utimes(
1382                     char *fname,
1383                     struct l_timeval *tptr
1384                 );
1385         }
1386 236     AUE_NULL        UNIMPL  vserver
1387 237     AUE_NULL        STD {
1388                 int linux_mbind(void);
1389         }
1390 238     AUE_NULL        STD {
1391                 int linux_set_mempolicy(void);
1392         }
1393 239     AUE_NULL        STD {
1394                 int linux_get_mempolicy(void);
1395         }
1396 240     AUE_NULL        STD {
1397                 int linux_mq_open(
1398                     const char *name,
1399                     l_int oflag,
1400                     l_mode_t mode,
1401                     struct mq_attr *attr
1402                 );
1403         }
1404 241     AUE_NULL        STD {
1405                 int linux_mq_unlink(
1406                     const char *name
1407                 );
1408         }
1409 242     AUE_NULL        STD {
1410                 int linux_mq_timedsend(
1411                     l_mqd_t mqd,
1412                     const char *msg_ptr,
1413                     l_size_t msg_len,
1414                     l_uint msg_prio,
1415                     const struct l_timespec *abs_timeout
1416                 );
1417         }
1418 243     AUE_NULL        STD {
1419                 int linux_mq_timedreceive(
1420                     l_mqd_t mqd,
1421                     char *msg_ptr,
1422                     l_size_t msg_len,
1423                     l_uint *msg_prio,
1424                     const struct l_timespec *abs_timeout
1425                 );
1426         }
1427 244     AUE_NULL        STD {
1428                 int linux_mq_notify(
1429                     l_mqd_t mqd,
1430                     const struct l_timespec *abs_timeout
1431                 );
1432         }
1433 245     AUE_NULL        STD {
1434                 int linux_mq_getsetattr(
1435                     l_mqd_t mqd,
1436                     const struct mq_attr *attr,
1437                     struct mq_attr *oattr
1438                 );
1439         }
1440 246     AUE_NULL        STD {
1441                 int linux_kexec_load(void);
1442         }
1443 247     AUE_WAIT6       STD {
1444                 int linux_waitid(
1445                     l_int idtype,
1446                     l_pid_t id,
1447                     l_siginfo_t *info,
1448                     l_int options,
1449                     struct rusage *rusage
1450                 );
1451         }
1452 248     AUE_NULL        STD {
1453                 int linux_add_key(void);
1454         }
1455 249     AUE_NULL        STD {
1456                 int linux_request_key(void);
1457         }
1458 250     AUE_NULL        STD {
1459                 int linux_keyctl(void);
1460         }
1461 251     AUE_NULL        STD {
1462                 int linux_ioprio_set(void);
1463         }
1464 252     AUE_NULL        STD {
1465                 int linux_ioprio_get(void);
1466         }
1467 253     AUE_NULL        STD {
1468                 int linux_inotify_init(void);
1469         }
1470 254     AUE_NULL        STD {
1471                 int linux_inotify_add_watch(void);
1472         }
1473 255     AUE_NULL        STD {
1474                 int linux_inotify_rm_watch(void);
1475         }
1476 256     AUE_NULL        STD {
1477                 int linux_migrate_pages(void);
1478         }
1479 257     AUE_OPEN_RWTC   STD {
1480                 int linux_openat(
1481                     l_int dfd,
1482                     const char *filename,
1483                     l_int flags,
1484                     l_mode_t mode
1485                 );
1486         }
1487 258     AUE_MKDIRAT     STD {
1488                 int linux_mkdirat(
1489                     l_int dfd,
1490                     const char *pathname,
1491                     l_mode_t mode
1492                 );
1493         }
1494 259     AUE_MKNODAT     STD {
1495                 int linux_mknodat(
1496                     l_int dfd,
1497                     const char *filename,
1498                     l_mode_t mode,
1499                     l_uint dev
1500                 );
1501         }
1502 260     AUE_FCHOWNAT    STD {
1503                 int linux_fchownat(
1504                     l_int dfd,
1505                     const char *filename,
1506                     l_uid_t uid,
1507                     l_gid_t gid,
1508                     l_int flag
1509                 );
1510         }
1511 261     AUE_FUTIMESAT   STD {
1512                 int linux_futimesat(
1513                     l_int dfd,
1514                     char *filename,
1515                     struct l_timeval *utimes
1516                 );
1517         }
1518 262     AUE_FSTATAT     STD {
1519                 int linux_newfstatat(
1520                     l_int dfd,
1521                     char *pathname,
1522                     struct l_stat64 *statbuf,
1523                     l_int flag
1524                 );
1525         }
1526 263     AUE_UNLINKAT    STD {
1527                 int linux_unlinkat(
1528                     l_int dfd,
1529                     const char *pathname,
1530                     l_int flag
1531                 );
1532         }
1533 264     AUE_RENAMEAT    STD {
1534                 int linux_renameat(
1535                     l_int olddfd,
1536                     const char *oldname,
1537                     l_int newdfd,
1538                     const char *newname
1539                 );
1540         }
1541 265     AUE_LINKAT      STD {
1542                 int linux_linkat(
1543                     l_int olddfd,
1544                     const char *oldname,
1545                     l_int newdfd,
1546                     const char *newname,
1547                     l_int flag
1548                 );
1549         }
1550 266     AUE_SYMLINKAT   STD {
1551                 int linux_symlinkat(
1552                     const char *oldname,
1553                     l_int newdfd,
1554                     const char *newname
1555                 );
1556         }
1557 267     AUE_READLINKAT  STD {
1558                 int linux_readlinkat(
1559                     l_int dfd,
1560                     const char *path,
1561                     char *buf,
1562                     l_int bufsiz
1563                 );
1564         }
1565 268     AUE_FCHMODAT    STD {
1566                 int linux_fchmodat(
1567                     l_int dfd,
1568                     const char *filename,
1569                     l_mode_t mode
1570                 );
1571         }
1572 269     AUE_FACCESSAT   STD {
1573                 int linux_faccessat(
1574                     l_int dfd,
1575                     const char *filename,
1576                     l_int amode
1577                 );
1578         }
1579 270     AUE_SELECT      STD {
1580                 int linux_pselect6(
1581                     l_int nfds,
1582                     l_fd_set *readfds,
1583                     l_fd_set *writefds,
1584                     l_fd_set *exceptfds,
1585                     struct l_timespec *tsp,
1586                     l_uintptr_t *sig
1587                 );
1588         }
1589 271     AUE_POLL        STD {
1590                 int linux_ppoll(
1591                     struct pollfd *fds,
1592                     l_uint nfds,
1593                     struct l_timespec *tsp,
1594                     l_sigset_t *sset,
1595                     l_size_t ssize
1596                 );
1597         }
1598 272     AUE_NULL        STD {
1599                 int linux_unshare(void);
1600         }
1601 273     AUE_NULL        STD {
1602                 int linux_set_robust_list(
1603                     struct linux_robust_list_head *head,
1604                     l_size_t len
1605                 );
1606         }
1607 274     AUE_NULL        STD {
1608                 int linux_get_robust_list(
1609                     l_int pid,
1610                     struct linux_robust_list_head **head,
1611                     l_size_t *len
1612                 );
1613         }
1614 275     AUE_NULL        STD {
1615                 int linux_splice(
1616                     int fd_in,
1617                     l_loff_t *off_in,
1618                     int fd_out,
1619                     l_loff_t *off_out,
1620                     l_size_t len,
1621                     l_uint flags
1622                 );
1623         }
1624 276     AUE_NULL        STD {
1625                 int linux_tee(void);
1626         }
1627 277     AUE_NULL        STD {
1628                 int linux_sync_file_range(
1629                     l_int fd,
1630                     l_loff_t offset,
1631                     l_loff_t nbytes,
1632                     l_uint flags
1633                 );
1634         }
1635 278     AUE_NULL        STD {
1636                 int linux_vmsplice(void);
1637         }
1638 279     AUE_NULL        STD {
1639                 int linux_move_pages(void);
1640         }
1641 280     AUE_FUTIMESAT   STD {
1642                 int linux_utimensat(
1643                     l_int dfd,
1644                     const char *pathname,
1645                     const struct l_timespec *times,
1646                     l_int flags
1647                 );
1648         }
1649 281     AUE_NULL        STD {
1650                 int linux_epoll_pwait(
1651                     l_int epfd,
1652                     struct epoll_event *events,
1653                     l_int maxevents,
1654                     l_int timeout,
1655                     l_sigset_t *mask,
1656                     l_size_t sigsetsize
1657                 );
1658         }
1659 282     AUE_NULL        STD {
1660                 int linux_signalfd(void);
1661         }
1662 283     AUE_NULL        STD {
1663                 int linux_timerfd_create(
1664                     l_int clockid,
1665                     l_int flags
1666                 );
1667         }
1668 284     AUE_NULL        STD {
1669                 int linux_eventfd(
1670                     l_uint initval
1671                 );
1672         }
1673 285     AUE_NULL        STD {
1674                 int linux_fallocate(
1675                     l_int fd,
1676                     l_int mode,
1677                     l_loff_t offset,
1678                     l_loff_t len
1679                 );
1680         }
1681 286     AUE_NULL        STD {
1682                 int linux_timerfd_settime(
1683                     l_int fd,
1684                     l_int flags,
1685                     const struct l_itimerspec *new_value,
1686                     struct l_itimerspec *old_value
1687                 );
1688         }
1689 287     AUE_NULL        STD {
1690                 int linux_timerfd_gettime(
1691                     l_int fd,
1692                     struct l_itimerspec *old_value
1693                 );
1694         }
1695 288     AUE_ACCEPT      STD {
1696                 int linux_accept4(
1697                     l_int s,
1698                     l_uintptr_t addr,
1699                     l_uintptr_t namelen,
1700                     l_int flags
1701                 );
1702         }
1703 ; Linux 2.6.27:
1704 289     AUE_NULL        STD {
1705                 int linux_signalfd4(void);
1706         }
1707 290     AUE_NULL        STD {
1708                 int linux_eventfd2(
1709                     l_uint initval,
1710                     l_int flags
1711                 );
1712         }
1713 291     AUE_NULL        STD {
1714                 int linux_epoll_create1(
1715                     l_int flags
1716                 );
1717         }
1718 292     AUE_NULL        STD {
1719                 int linux_dup3(
1720                     l_uint oldfd,
1721                     l_uint newfd,
1722                     l_int flags
1723                 );
1724         }
1725 293     AUE_NULL        STD {
1726                 int linux_pipe2(
1727                     l_int *pipefds,
1728                     l_int flags
1729                 );
1730         }
1731 294     AUE_NULL        STD {
1732                 int linux_inotify_init1(
1733                     l_int flags
1734                 );
1735         }
1736 ; Linux 2.6.30:
1737 295     AUE_NULL        STD {
1738                 int linux_preadv(
1739                     l_ulong fd,
1740                     struct iovec *vec,
1741                     l_ulong vlen,
1742                     l_ulong pos_l,
1743                     l_ulong pos_h
1744                 );
1745         }
1746 296     AUE_NULL        STD {
1747                 int linux_pwritev(
1748                     l_ulong fd,
1749                     struct iovec *vec,
1750                     l_ulong vlen,
1751                     l_ulong pos_l,
1752                     l_ulong pos_h
1753                 );
1754         }
1755 ; Linux 2.6.31:
1756 297     AUE_NULL        STD {
1757                 int linux_rt_tgsigqueueinfo(
1758                     l_pid_t tgid,
1759                     l_pid_t tid,
1760                     l_int sig,
1761                     l_siginfo_t *uinfo
1762                 );
1763         }
1764 298     AUE_NULL        STD {
1765                 int linux_perf_event_open(void);
1766         }
1767 ; Linux 2.6.33:
1768 299     AUE_NULL        STD {
1769                 int linux_recvmmsg(
1770                     l_int s,
1771                     struct l_mmsghdr *msg,
1772                     l_uint vlen,
1773                     l_uint flags,
1774                     struct l_timespec *timeout
1775                 );
1776         }
1777 ; Linux 2.6.37:
1778 300     AUE_NULL        STD {
1779                 int linux_fanotify_init(void);
1780         }
1781 301     AUE_NULL        STD {
1782                 int linux_fanotify_mark(void);
1783         }
1784 ; Linux 2.6.36:
1785 302     AUE_NULL        STD {
1786                 int linux_prlimit64(
1787                     l_pid_t pid,
1788                     l_uint resource,
1789                     struct rlimit *new,
1790                     struct rlimit *old
1791                 );
1792         }
1793 ; Linux 2.6.39 (glibc 2.14):
1794 303     AUE_NULL        STD {
1795                 int linux_name_to_handle_at(void);
1796         }
1797 304     AUE_NULL        STD {
1798                 int linux_open_by_handle_at(void);
1799         }
1800 305     AUE_NULL        STD {
1801                 int linux_clock_adjtime(void);
1802         }
1803 306     AUE_SYNC        STD {
1804                 int linux_syncfs(
1805                     l_int fd
1806                 );
1807         }
1808 ; Linux 3.0 (glibc 2.14):
1809 307     AUE_NULL        STD {
1810                 int linux_sendmmsg(
1811                     l_int s,
1812                     struct l_mmsghdr *msg,
1813                     l_uint vlen,
1814                     l_uint flags
1815                 );
1816         }
1817 308     AUE_NULL        STD {
1818                 int linux_setns(
1819                     l_int fd,
1820                     l_int nstype
1821                 );
1822         }
1823 ; Linux 2.6.19 (no glibc wrapper):
1824 309     AUE_NULL        STD {
1825                 int linux_getcpu(
1826                     l_uint *cpu,
1827                     l_uint *node,
1828                     void *cache
1829                 );
1830         }
1831 ; Linux 3.2 (glibc 2.15):
1832 310     AUE_NULL        STD {
1833                 int linux_process_vm_readv(
1834                     l_pid_t pid,
1835                     const struct iovec *lvec,
1836                     l_ulong liovcnt,
1837                     const struct iovec *rvec,
1838                     l_ulong riovcnt,
1839                     l_ulong flags
1840                 );
1841         }
1842 311     AUE_NULL        STD {
1843                 int linux_process_vm_writev(
1844                     l_pid_t pid,
1845                     const struct iovec *lvec,
1846                     l_ulong liovcnt,
1847                     const struct iovec *rvec,
1848                     l_ulong riovcnt,
1849                     l_ulong flags
1850                 );
1851         }
1852 ; Linux 3.5 (no glibc wrapper):
1853 312     AUE_NULL        STD {
1854                 int linux_kcmp(
1855                     l_pid_t pid1,
1856                     l_pid_t pid2,
1857                     l_int type,
1858                     l_ulong idx1,
1859                     l_ulong idx
1860                 );
1861         }
1862 ; Linux 3.8 (no glibc wrapper):
1863 313     AUE_NULL        STD {
1864                 int linux_finit_module(
1865                     l_int fd,
1866                     const char *uargs,
1867                     l_int flags
1868                 );
1869         }
1870 ; Linux 3.14:
1871 314     AUE_NULL        STD {
1872                 int linux_sched_setattr(
1873                     l_pid_t pid,
1874                     void *attr,
1875                     l_uint flags
1876                 );
1877         }
1878 315     AUE_NULL        STD {
1879                 int linux_sched_getattr(
1880                     l_pid_t pid,
1881                     void *attr,
1882                     l_uint size,
1883                     l_uint flags
1884                 );
1885         }
1886 ; Linux 3.15:
1887 316     AUE_NULL        STD {
1888                 int linux_renameat2(
1889                     l_int olddfd,
1890                     const char *oldname,
1891                     l_int newdfd,
1892                     const char *newname,
1893                     l_uint flags
1894                 );
1895         }
1896 ; Linux 3.17:
1897 317     AUE_NULL        STD {
1898                 int linux_seccomp(
1899                     l_uint op,
1900                     l_uint flags,
1901                     const char *uargs
1902                 );
1903         }
1904 318     AUE_NULL        STD {
1905                 int linux_getrandom(
1906                     char *buf,
1907                     l_size_t count,
1908                     l_uint flags
1909                 );
1910         }
1911 319     AUE_NULL        STD {
1912                 int linux_memfd_create(
1913                     const char *uname_ptr,
1914                     l_uint flags
1915                 );
1916         }
1917 320     AUE_NULL        STD {
1918                 int linux_kexec_file_load(
1919                     l_int kernel_fd,
1920                     l_int initrd_fd,
1921                     l_ulong cmdline_len,
1922                     const char *cmdline_ptr,
1923                     l_ulong flags
1924                 );
1925         }
1926 ; Linux 3.18:
1927 321     AUE_NULL        STD {
1928                 int linux_bpf(
1929                     l_int cmd,
1930                     void *attr,
1931                     l_uint size
1932                 );
1933         }
1934 ; Linux 3.19:
1935 322     AUE_NULL        STD {
1936                 int linux_execveat(
1937                     l_int dfd,
1938                     const char *filename,
1939                     const char **argv,
1940                     const char **envp,
1941                     l_int flags
1942                 );
1943         }
1944 ; Linux 4.2:
1945 323     AUE_NULL        STD {
1946                 int linux_userfaultfd(
1947                     l_int flags
1948                 );
1949         }
1950 ; Linux 4.3:
1951 324     AUE_NULL        STD {
1952                 int linux_membarrier(
1953                     l_int cmd,
1954                     l_int flags
1955                 );
1956         }
1957 ; Linux 4.4:
1958 325     AUE_NULL        STD {
1959                 int linux_mlock2(
1960                     l_ulong start,
1961                     l_size_t len,
1962                     l_int flags
1963                 );
1964         }
1965 ; Linux 4.5:
1966 326     AUE_NULL        STD {
1967                 int linux_copy_file_range(
1968                     l_int fd_in,
1969                     l_loff_t *off_in,
1970                     l_int fd_out,
1971                     l_loff_t *off_out,
1972                     l_size_t len,
1973                     l_uint flags
1974                 );
1975         }
1976 ; Linux 4.6:
1977 327     AUE_NULL        STD {
1978                 int linux_preadv2(
1979                     l_ulong fd,
1980                     const struct iovec *vec,
1981                     l_ulong vlen,
1982                     l_ulong pos_l,
1983                     l_ulong pos_h,
1984                     l_int flags
1985                 );
1986         }
1987 328     AUE_NULL        STD {
1988                 int linux_pwritev2(
1989                     l_ulong fd,
1990                     const struct iovec *vec,
1991                     l_ulong vlen,
1992                     l_ulong pos_l,
1993                     l_ulong pos_h,
1994                     l_int flags
1995                 );
1996         }
1997 ; Linux 4.8:
1998 329     AUE_NULL        STD {
1999                 int linux_pkey_mprotect(
2000                     l_ulong start,
2001                     l_size_t len,
2002                     l_ulong prot,
2003                     l_int pkey
2004                 );
2005         }
2006 330     AUE_NULL        STD {
2007                 int linux_pkey_alloc(
2008                     l_ulong flags,
2009                     l_ulong init_val
2010                 );
2011         }
2012 331     AUE_NULL        STD {
2013                 int linux_pkey_free(
2014                     l_int pkey
2015                 );
2016         }
2017 ; Linux 4.11:
2018 332     AUE_NULL        STD {
2019                 int linux_statx(
2020                     l_int dirfd,
2021                     const char *pathname,
2022                     l_uint flags,
2023                     l_uint mask,
2024                     void *statxbuf
2025                 );
2026         }
2027 ; Linux 4.18:
2028 333     AUE_NULL        STD {
2029                 int linux_io_pgetevents(void);
2030         }
2031 334     AUE_NULL        STD {
2032                 int linux_rseq(void);
2033         }
2034 ; Linux 5.0:
2035 335-423 AUE_NULL        UNIMPL  nosys
2036 424     AUE_NULL        STD {
2037                 int linux_pidfd_send_signal(
2038                     l_int pidfd,
2039                     l_int sig,
2040                     l_siginfo_t *info,
2041                     l_uint flags
2042                 );
2043         }
2044 425     AUE_NULL        STD {
2045                 int linux_io_uring_setup(void);
2046         }
2047 426     AUE_NULL        STD {
2048                 int linux_io_uring_enter(void);
2049         }
2050 427     AUE_NULL        STD {
2051                 int linux_io_uring_register(void);
2052         }
2053 ; please, keep this line at the end.
2054 428     AUE_NULL        UNIMPL  nosys
2055 ; vim: syntax=off