The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/compat/svr4/syscalls.master

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1  $FreeBSD: releng/11.2/sys/compat/svr4/syscalls.master 302096 2016-06-23 00:29:03Z brooks $
    2 ;       from: @(#)syscalls.master       8.1 (Berkeley) 7/19/93
    3 ;
    4 ; System call name/number master file (or rather, slave, from SVR4).
    5 ; Processed to create svr4_sysent.c, svr4_syscalls.c and svr4_syscall.h.
    6 
    7 ; Columns: number 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, OBSOL, UNIMPL, COMPAT
   15 ;       name    psuedo-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/OBSOL, name continues with comments
   21 
   22 ; types:
   23 ;       STD     always included
   24 ;       COMPAT  included on COMPAT #ifdef
   25 ;       OBSOL   obsolete, not included in system, only specifies name
   26 ;       UNIMPL  not implemented, placeholder only
   27 
   28 ; #ifdef's, etc. may be included, and are copied to the output files.
   29 
   30 #include <sys/types.h>
   31 #include <sys/sysent.h>
   32 #include <sys/sysproto.h>
   33 #include <netinet/in.h>
   34 
   35 #include <compat/svr4/svr4.h>
   36 #include <compat/svr4/svr4_types.h>
   37 #include <compat/svr4/svr4_signal.h>
   38 #include <compat/svr4/svr4_proto.h>
   39 
   40 0       AUE_NULL        UNIMPL  unused
   41 1       AUE_NULL        NOPROTO { void sys_exit(int rval); } exit \
   42                                     sys_exit_args void
   43 2       AUE_NULL        NOPROTO { int fork(void); }
   44 3       AUE_NULL        NOPROTO { int read(int fd, char *buf, u_int nbyte); }
   45 4       AUE_NULL        NOPROTO { int write(int fd, char *buf, u_int nbyte); }
   46 5       AUE_NULL        STD     { int svr4_sys_open(char *path, int flags, \
   47                                     int mode); }
   48 6       AUE_NULL        NOPROTO { int close(int fd); }
   49 7       AUE_NULL        STD     { int svr4_sys_wait(int *status); }
   50 8       AUE_NULL        STD     { int svr4_sys_creat(char *path, int mode); }
   51 9       AUE_NULL        NOPROTO { int link(char *path, char *link); }
   52 10      AUE_NULL        NOPROTO { int unlink(char *path); }
   53 11      AUE_NULL        STD     { int svr4_sys_execv(char *path, char **argp); }
   54 12      AUE_NULL        NOPROTO { int chdir(char *path); }
   55 13      AUE_NULL        STD     { int svr4_sys_time(time_t *t); }
   56 14      AUE_NULL        STD     { int svr4_sys_mknod(char* path, int mode, int dev); }
   57 15      AUE_NULL        NOPROTO { int chmod(char *path, int mode); }
   58 16      AUE_NULL        NOPROTO { int chown(char *path, uid_t uid, gid_t gid); }
   59 17      AUE_NULL        STD     { int svr4_sys_break(caddr_t nsize); }
   60 18      AUE_NULL        STD     { int svr4_sys_stat(char* path, \
   61                                     struct svr4_stat* ub); }
   62 19      AUE_NULL        NOPROTO { int lseek(int filedes, off_t *offset, \
   63                                     int whence); }
   64 20      AUE_NULL        NOPROTO { pid_t getpid(void); }
   65 21      AUE_NULL        UNIMPL  old_mount
   66 22      AUE_NULL        UNIMPL  sysv_umount
   67 23      AUE_NULL        NOPROTO { int setuid(uid_t uid); }
   68 24      AUE_NULL        NOPROTO { uid_t getuid(void); }
   69 25      AUE_NULL        UNIMPL  stime
   70 26      AUE_NULL        UNIMPL  ptrace
   71 27      AUE_NULL        STD     { int svr4_sys_alarm(unsigned sec); }
   72 28      AUE_NULL        STD     { int svr4_sys_fstat(int fd, \
   73                                     struct svr4_stat *sb); }
   74 29      AUE_NULL        STD     { int svr4_sys_pause(void); }
   75 30      AUE_NULL        STD     { int svr4_sys_utime(char *path, \
   76                                     struct svr4_utimbuf *ubuf); }
   77 31      AUE_NULL        UNIMPL  stty
   78 32      AUE_NULL        UNIMPL  gtty
   79 33      AUE_NULL        STD     { int svr4_sys_access(char *path, \
   80                                     int amode); }
   81 34      AUE_NULL        STD     { int svr4_sys_nice(int prio); }
   82 35      AUE_NULL        UNIMPL  statfs
   83 36      AUE_NULL        NOPROTO { int sync(void); }
   84 37      AUE_NULL        STD     { int svr4_sys_kill(int pid, int signum); }
   85 38      AUE_NULL        UNIMPL  fstatfs
   86 39      AUE_NULL        STD     { int svr4_sys_pgrpsys(int cmd, int pid, \
   87                                     int pgid); }
   88 40      AUE_NULL        UNIMPL  xenix
   89 41      AUE_NULL        NOPROTO { int dup(u_int fd); }
   90 42      AUE_NULL        STD     { int svr4_pipe(void); }
   91 43      AUE_NULL        STD     { int svr4_sys_times(struct tms *tp); }
   92 44      AUE_NULL        UNIMPL  profil
   93 45      AUE_NULL        UNIMPL  plock
   94 46      AUE_NULL        NOPROTO { int setgid(gid_t gid); }
   95 47      AUE_NULL        NOPROTO { gid_t getgid(void); }
   96 48      AUE_NULL        STD     { int svr4_sys_signal(int signum, \
   97                                     svr4_sig_t handler); }
   98 49      AUE_NULL        STD     { int svr4_sys_msgsys(int what, int a2, \
   99                                     int a3, int a4, int a5); }
  100 50      AUE_NULL        STD     { int svr4_sys_sysarch(int op, void *a1); }
  101 51      AUE_NULL        UNIMPL  acct
  102 52      AUE_NULL        STD     { int svr4_sys_shmsys(int what, int a2, \
  103                                     int a3, int a4, int a5); }
  104 53      AUE_NULL        STD     { int svr4_sys_semsys(int what, int a2, \
  105                                     int a3, int a4, int a5); }
  106 54      AUE_NULL        STD     { int svr4_sys_ioctl(int fd, u_long com, \
  107                                     caddr_t data); }
  108 55      AUE_NULL        UNIMPL  uadmin
  109 56      AUE_NULL        UNIMPL  exch
  110 57      AUE_NULL        STD     { int svr4_sys_utssys(void *a1, void *a2, \
  111                                     int sel, void *a3); }
  112 58      AUE_NULL        NOPROTO { int fsync(int fd); }
  113 59      AUE_NULL        STD     { int svr4_sys_execve(char *path, \
  114                                     char **argp, char **envp); }
  115 60      AUE_NULL        NOPROTO { int umask(int newmask); }
  116 61      AUE_NULL        NOPROTO { int chroot(char *path); }
  117 62      AUE_NULL        STD     { int svr4_sys_fcntl(int fd, int cmd, \
  118                                     char *arg); }
  119 63      AUE_NULL        STD     { int svr4_sys_ulimit(int cmd, \
  120                                     long newlimit); }
  121 64      AUE_NULL        UNIMPL  reserved
  122 65      AUE_NULL        UNIMPL  reserved
  123 66      AUE_NULL        UNIMPL  reserved
  124 67      AUE_NULL        UNIMPL  reserved
  125 68      AUE_NULL        UNIMPL  reserved
  126 69      AUE_NULL        UNIMPL  reserved
  127 70      AUE_NULL        UNIMPL  advfs
  128 71      AUE_NULL        UNIMPL  unadvfs
  129 72      AUE_NULL        UNIMPL  rmount
  130 73      AUE_NULL        UNIMPL  rumount
  131 74      AUE_NULL        UNIMPL  rfstart
  132 75      AUE_NULL        UNIMPL  sigret
  133 76      AUE_NULL        UNIMPL  rdebug
  134 77      AUE_NULL        UNIMPL  rfstop
  135 78      AUE_NULL        UNIMPL  rfsys
  136 79      AUE_NULL        NOPROTO { int rmdir(char *path); }
  137 80      AUE_NULL        NOPROTO { int mkdir(char *path, int mode); }
  138 81      AUE_NULL        STD     { int svr4_sys_getdents(int fd, char *buf, \
  139                                     int nbytes); }
  140 82      AUE_NULL        UNIMPL  libattach
  141 83      AUE_NULL        UNIMPL  libdetach
  142 84      AUE_NULL        UNIMPL  sysfs
  143 85      AUE_NULL        STD     { int svr4_sys_getmsg(int fd, \
  144                                     struct svr4_strbuf *ctl, \
  145                                     struct svr4_strbuf *dat, int *flags); }
  146 86      AUE_NULL        STD     { int svr4_sys_putmsg(int fd, \
  147                                     struct svr4_strbuf *ctl, \
  148                                     struct svr4_strbuf *dat, int flags); }
  149 87      AUE_NULL        STD     { int svr4_sys_poll(struct pollfd *fds, \
  150                                     unsigned int nfds, int timeout); }
  151 88      AUE_NULL        STD     { int svr4_sys_lstat(char *path, \
  152                                     struct svr4_stat *ub); }
  153 89      AUE_NULL        NOPROTO { int symlink(char *path, char *link); }
  154 90      AUE_NULL        NOPROTO { int readlink(char *path, char *buf, \
  155                                     int count); }
  156 91      AUE_NULL        NOPROTO { int getgroups(u_int gidsetsize, \
  157                                     gid_t *gidset); }
  158 92      AUE_NULL        NOPROTO { int setgroups(u_int gidsetsize, \
  159                                     gid_t *gidset); }
  160 93      AUE_NULL        NOPROTO { int fchmod(int fd, int mode); }
  161 94      AUE_NULL        NOPROTO { int fchown(int fd, int uid, int gid); }
  162 95      AUE_NULL        STD     { int svr4_sys_sigprocmask(int how, \
  163                                     svr4_sigset_t *set, \
  164                                     svr4_sigset_t *oset); }
  165 96      AUE_NULL        STD     { int svr4_sys_sigsuspend( \
  166                                     svr4_sigset_t *ss); }
  167 97      AUE_NULL        STD     { int svr4_sys_sigaltstack( \
  168                                     struct svr4_sigaltstack *nss, \
  169                                     struct svr4_sigaltstack *oss); }
  170 98      AUE_NULL        STD     { int svr4_sys_sigaction(int signum, \
  171                                     struct svr4_sigaction *nsa, \
  172                                     struct svr4_sigaction *osa); }
  173 99      AUE_NULL        STD     { int svr4_sys_sigpending(int what, \
  174                                     svr4_sigset_t *mask); }
  175 100     AUE_NULL        STD     { int svr4_sys_context(int func, \
  176                                     struct svr4_ucontext *uc); }
  177 101     AUE_NULL        UNIMPL  evsys
  178 102     AUE_NULL        UNIMPL  evtrapret
  179 103     AUE_NULL        STD     { int svr4_sys_statvfs(char *path, \
  180                                     struct svr4_statvfs *fs); }
  181 104     AUE_NULL        STD     { int svr4_sys_fstatvfs(int fd, \
  182                                     struct svr4_statvfs *fs); }
  183 105     AUE_NULL        UNIMPL  whoknows
  184 106     AUE_NULL        UNIMPL  nfssvc
  185 107     AUE_NULL        STD     { int svr4_sys_waitsys(int grp, int id, \
  186                                     union svr4_siginfo *info, int options); }
  187 108     AUE_NULL        UNIMPL  sigsendsys
  188 109     AUE_NULL        STD     { int svr4_sys_hrtsys(int cmd, int fun, \
  189                                     int sub, void *rv1, void *rv2); }
  190 110     AUE_NULL        UNIMPL  acancel
  191 111     AUE_NULL        UNIMPL  async
  192 112     AUE_NULL        UNIMPL  priocntlsys
  193 113     AUE_NULL        STD     { int svr4_sys_pathconf(char *path, \
  194                                     int name); }
  195 114     AUE_NULL        UNIMPL  mincore
  196 115     AUE_NULL        STD     { caddr_t svr4_sys_mmap(caddr_t addr, \
  197                                     svr4_size_t len, int prot, int flags, \
  198                                     int fd, svr4_off_t pos); }
  199 116     AUE_NULL        NOPROTO { int mprotect(void *addr, int len, \
  200                                     int prot); }
  201 117     AUE_NULL        NOPROTO { int munmap(void *addr, int len); }
  202 118     AUE_NULL        STD     { int svr4_sys_fpathconf(int fd, int name); }
  203 119     AUE_NULL        NOPROTO { int vfork(void); }
  204 120     AUE_NULL        NOPROTO { int fchdir(int fd); }
  205 121     AUE_NULL        NOPROTO { int readv(int fd, struct iovec *iovp, \
  206                                     u_int iovcnt); }
  207 122     AUE_NULL        NOPROTO { int writev(int fd, struct iovec *iovp, \
  208                                     u_int iovcnt); }
  209 123     AUE_NULL        STD     { int svr4_sys_xstat(int two, char *path, \
  210                                     struct svr4_xstat *ub); }
  211 124     AUE_NULL        STD     { int svr4_sys_lxstat(int two, char *path, \
  212                                     struct svr4_xstat *ub); }
  213 125     AUE_NULL        STD     { int svr4_sys_fxstat(int two, int fd, \
  214                                     struct svr4_xstat *sb); }
  215 126     AUE_NULL        STD     { int svr4_sys_xmknod(int two, char *path, \
  216                                     svr4_mode_t mode, svr4_dev_t dev); }
  217 127     AUE_NULL        UNIMPL  clocal
  218 128     AUE_NULL        STD     { int svr4_sys_setrlimit(int which, \
  219                                     const struct svr4_rlimit *rlp); }
  220 129     AUE_NULL        STD     { int svr4_sys_getrlimit(int which, \
  221                                     struct svr4_rlimit *rlp); }
  222 130     AUE_NULL        NOPROTO { int lchown(char *path, uid_t uid, \
  223                                     gid_t gid); }
  224 131     AUE_NULL        STD     { int svr4_sys_memcntl(void * addr, \
  225                                     svr4_size_t len, int cmd, void * arg, \
  226                                     int attr, int mask); }
  227 132     AUE_NULL        UNIMPL  getpmsg
  228 133     AUE_NULL        UNIMPL  putpmsg
  229 134     AUE_NULL        NOPROTO { int rename(char *from, char *to); }
  230 135     AUE_NULL        STD     { int svr4_sys_uname( \
  231                                     struct svr4_utsname* name, int dummy); }
  232 136     AUE_NULL        NOPROTO { int setegid(gid_t egid); }
  233 137     AUE_NULL        STD     { int svr4_sys_sysconfig(int name); }
  234 138     AUE_NULL        NOPROTO { int adjtime(struct timeval *delta, \
  235                                     struct timeval *olddelta); }
  236 139     AUE_NULL        STD     { long svr4_sys_systeminfo(int what, \
  237                                     char *buf, long len); }
  238 140     AUE_NULL        UNIMPL  notused
  239 141     AUE_NULL        NOPROTO { int seteuid(uid_t euid); }
  240 142     AUE_NULL        UNIMPL  vtrace
  241 ; fork1
  242 143     AUE_NULL        UNIMPL  { int fork(void); } 
  243 144     AUE_NULL        UNIMPL  sigtimedwait
  244 145     AUE_NULL        UNIMPL  lwp_info
  245 146     AUE_NULL        UNIMPL  yield
  246 147     AUE_NULL        UNIMPL  lwp_sema_wait
  247 148     AUE_NULL        UNIMPL  lwp_sema_post
  248 149     AUE_NULL        UNIMPL  lwp_sema_trywait
  249 150     AUE_NULL        UNIMPL  notused
  250 151     AUE_NULL        UNIMPL  notused
  251 152     AUE_NULL        UNIMPL  modctl
  252 153     AUE_NULL        STD     { int svr4_sys_fchroot(int fd); }
  253 154     AUE_NULL        STD     { int svr4_sys_utimes(char *path, \
  254                                     struct timeval *tptr); }
  255 155     AUE_NULL        STD     { int svr4_sys_vhangup(void); }
  256 156     AUE_NULL        STD     { int svr4_sys_gettimeofday( \
  257                                     struct timeval *tp); }
  258 157     AUE_NULL        NOPROTO { int getitimer(u_int which, \
  259                                     struct itimerval *itv); }
  260 158     AUE_NULL        NOPROTO { int setitimer(u_int which, \
  261                                     struct itimerval *itv, \
  262                                     struct itimerval *oitv); }
  263 159     AUE_NULL        UNIMPL  lwp_create
  264 160     AUE_NULL        UNIMPL  lwp_exit
  265 161     AUE_NULL        UNIMPL  lwp_suspend
  266 162     AUE_NULL        UNIMPL  lwp_continue
  267 163     AUE_NULL        UNIMPL  lwp_kill
  268 164     AUE_NULL        UNIMPL  lwp_self
  269 165     AUE_NULL        UNIMPL  lwp_getprivate
  270 166     AUE_NULL        UNIMPL  lwp_setprivate
  271 167     AUE_NULL        UNIMPL  lwp_wait
  272 168     AUE_NULL        UNIMPL  lwp_mutex_unlock
  273 169     AUE_NULL        UNIMPL  lwp_mutex_lock
  274 170     AUE_NULL        UNIMPL  lwp_cond_wait
  275 171     AUE_NULL        UNIMPL  lwp_cond_signal
  276 172     AUE_NULL        UNIMPL  lwp_cond_broadcast
  277 173     AUE_NULL        UNIMPL  { ssize_t svr4_sys_pread(int fd, void *buf, \
  278                                     size_t nbyte, svr4_off_t off); }
  279 174     AUE_NULL        UNIMPL  { ssize_t svr4_sys_pwrite(int fd, \
  280                                     const void *buf, size_t nbyte, \
  281                                     svr4_off_t off); }
  282 175     AUE_NULL        STD     { svr4_off64_t svr4_sys_llseek(int fd, \
  283                                     long offset1, long offset2, int whence); }
  284 176     AUE_NULL        UNIMPL  inst_sync
  285 177     AUE_NULL        UNIMPL  whoknows
  286 178     AUE_NULL        UNIMPL  kaio
  287 179     AUE_NULL        UNIMPL  whoknows
  288 180     AUE_NULL        UNIMPL  whoknows
  289 181     AUE_NULL        UNIMPL  whoknows
  290 182     AUE_NULL        UNIMPL  whoknows
  291 183     AUE_NULL        UNIMPL  whoknows
  292 184     AUE_NULL        UNIMPL  tsolsys
  293 185     AUE_NULL        STD     { int svr4_sys_acl(char *path, int cmd, \
  294                                     int num, struct svr4_aclent *buf); }
  295 186     AUE_NULL        STD     { int svr4_sys_auditsys(int code, int a1, \
  296                                     int a2, int a3, int a4, int a5); }
  297 187     AUE_NULL        UNIMPL  processor_bind
  298 188     AUE_NULL        UNIMPL  processor_info
  299 189     AUE_NULL        UNIMPL  p_online
  300 190     AUE_NULL        UNIMPL  sigqueue
  301 191     AUE_NULL        UNIMPL  clock_gettime
  302 192     AUE_NULL        UNIMPL  clock_settime
  303 193     AUE_NULL        UNIMPL  clock_getres
  304 194     AUE_NULL        UNIMPL  timer_create
  305 195     AUE_NULL        UNIMPL  timer_delete
  306 196     AUE_NULL        UNIMPL  timer_settime
  307 197     AUE_NULL        UNIMPL  timer_gettime
  308 198     AUE_NULL        UNIMPL  timer_overrun
  309 199     AUE_NULL        NOPROTO { int nanosleep( \
  310                                     const struct timespec *rqtp, \
  311                                     struct timespec *rmtp); }
  312 200     AUE_NULL        STD     { int svr4_sys_facl(int fd, int cmd, \
  313                                     int num, struct svr4_aclent *buf); }
  314 201     AUE_NULL        UNIMPL  door
  315 202     AUE_NULL        NOPROTO { int setreuid(int ruid, int euid); }
  316 203     AUE_NULL        NOPROTO { int setregid(int rgid, int egid); }
  317 204     AUE_NULL        UNIMPL  install_utrap
  318 205     AUE_NULL        UNIMPL  signotify
  319 206     AUE_NULL        UNIMPL  schedctl
  320 207     AUE_NULL        UNIMPL  pset
  321 208     AUE_NULL        UNIMPL  whoknows
  322 209     AUE_NULL        STD     { int svr4_sys_resolvepath(const char *path, \
  323                                     char *buf, size_t bufsiz); }
  324 210     AUE_NULL        UNIMPL  signotifywait
  325 211     AUE_NULL        UNIMPL  lwp_sigredirect
  326 212     AUE_NULL        UNIMPL  lwp_alarm
  327 213     AUE_NULL        STD     { int svr4_sys_getdents64(int fd, \
  328                                     struct svr4_dirent64 *dp, int nbytes); }
  329 ;213    AUE_NULL        UNIMPL  getdents64
  330 214     AUE_NULL        STD     { caddr_t svr4_sys_mmap64(void *addr, \
  331                                     svr4_size_t len, int prot, int flags, \
  332                                     int fd, svr4_off64_t pos); }
  333 215     AUE_NULL        STD     { int svr4_sys_stat64(char *path, \
  334                                     struct svr4_stat64 *sb); }
  335 216     AUE_NULL        STD     { int svr4_sys_lstat64(char *path, \
  336                                     struct svr4_stat64 *sb); }
  337 217     AUE_NULL        STD     { int svr4_sys_fstat64(int fd, \
  338                                     struct svr4_stat64 *sb); }
  339 218     AUE_NULL        STD     { int svr4_sys_statvfs64(char *path, \
  340                                     struct svr4_statvfs64 *fs); }
  341 219     AUE_NULL        STD     { int svr4_sys_fstatvfs64(int fd, \
  342                                     struct svr4_statvfs64 *fs); }
  343 220     AUE_NULL        STD     { int svr4_sys_setrlimit64(int which, \
  344                                     const struct svr4_rlimit64 *rlp); }
  345 221     AUE_NULL        STD     { int svr4_sys_getrlimit64(int which, \
  346                                     struct svr4_rlimit64 *rlp); }
  347 222     AUE_NULL        UNIMPL  pread64
  348 223     AUE_NULL        UNIMPL  pwrite64
  349 224     AUE_NULL        STD     { int svr4_sys_creat64(char *path, \
  350                                     int mode); }
  351 225     AUE_NULL        STD     { int svr4_sys_open64(char *path, int flags, \
  352                                     int mode); }
  353 226     AUE_NULL        UNIMPL  rpcsys
  354 227     AUE_NULL        UNIMPL  whoknows
  355 228     AUE_NULL        UNIMPL  whoknows
  356 229     AUE_NULL        UNIMPL  whoknows
  357 230     AUE_NULL        STD     { int svr4_sys_socket(int domain, int type, \
  358                                     int protocol); }
  359 231     AUE_NULL        NOPROTO { int socketpair(int domain, int type, \
  360                                     int protocol, int *rsv); }
  361 232     AUE_NULL        NOPROTO { int bind(int s, \
  362                                     const struct sockaddr *name, \
  363                                     int namelen); }
  364 233     AUE_NULL        NOPROTO { int listen(int s, int backlog); }
  365 234     AUE_NULL        NOPROTO { int accept(int s, struct sockaddr *name, \
  366                                     int *anamelen); }
  367 235     AUE_NULL        NOPROTO { int connect(int s, \
  368                                     const struct sockaddr *name, \
  369                                     int namelen); }
  370 236     AUE_NULL        NOPROTO { int shutdown(int s, int how); }
  371 237     AUE_NULL        STD     { int svr4_sys_recv(int s, caddr_t buf, \
  372                                     int len, int flags); }
  373 238     AUE_NULL        NOPROTO { ssize_t recvfrom(int s, void *buf, \
  374                                     size_t len, int flags, \
  375                                     struct sockaddr *from, \
  376                                     int *fromlenaddr); }
  377 239     AUE_NULL        NOPROTO { ssize_t recvmsg(int s, struct msghdr *msg, \
  378                                     int flags); }
  379 240     AUE_NULL        STD     { int svr4_sys_send(int s, caddr_t buf, \
  380                                     int len, int flags); }
  381 241     AUE_NULL        NOPROTO { ssize_t sendmsg(int s, \
  382                                     const struct msghdr *msg, int flags); }
  383 242     AUE_NULL        STD     { ssize_t svr4_sys_sendto(int s, void *buf, \
  384                                     size_t len, int flags, \
  385                                     struct sockaddr *to, int tolen); }
  386 243     AUE_NULL        NOPROTO { int getpeername(int fdes, \
  387                                     struct sockaddr *asa, int *alen); }
  388 244     AUE_NULL        NOPROTO { int getsockname(int fdes, \
  389                                     struct sockaddr *asa, int *alen); }
  390 245     AUE_NULL        NOPROTO { int getsockopt(int s, int level, int name, \
  391                                     void *val, int *avalsize); }
  392 246     AUE_NULL        NOPROTO { int setsockopt(int s, int level, int name, \
  393                                     const void *val, int valsize); }
  394 247     AUE_NULL        UNIMPL  sockconfig
  395 248     AUE_NULL        UNIMPL  { int ntp_gettime(struct ntptimeval *ntvp); }
  396 249     AUE_NULL        UNIMPL  { int ntp_adjtime(struct timex *tp); }

Cache object: f8e44e3f6b6911f4eec2129cdb45b876


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.