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

Cache object: a3ada9b7a5c8f390c423d3b80f416ed9


[ 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.