1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Copyright 2012 Milan Jurik. All rights reserved.
  25  * Copyright (c) 2013, OmniTI Computer Consulting, Inc. All rights reserved.
  26  * Copyright (c) 2015, Joyent, Inc.
  27  */
  28 
  29 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T     */
  30 /*        All Rights Reserved   */
  31 
  32 #include <sys/param.h>
  33 #include <sys/types.h>
  34 #include <sys/systm.h>
  35 #include <sys/systrace.h>
  36 #include <sys/procfs.h>
  37 #include <sys/mman.h>
  38 #include <sys/int_types.h>
  39 #include <c2/audit.h>
  40 #include <sys/stat.h>
  41 #include <sys/times.h>
  42 #include <sys/statfs.h>
  43 #include <sys/stropts.h>
  44 #include <sys/statvfs.h>
  45 #include <sys/utsname.h>
  46 #include <sys/timex.h>
  47 #include <sys/socket.h>
  48 #include <sys/sendfile.h>
  49 
  50 struct hrtsysa;
  51 struct mmaplf32a;
  52 
  53 /*
  54  * This table is the switch used to transfer to the appropriate
  55  * routine for processing a system call.  Each row contains the
  56  * number of arguments expected, a switch that tells systrap()
  57  * in trap.c whether a setjmp() is not necessary, and a pointer
  58  * to the routine.
  59  */
  60 
  61 int     access(char *, int);
  62 int     alarm(int);
  63 int     auditsys(struct auditcalls *, rval_t *);
  64 int64_t brandsys(int, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t,
  65     uintptr_t);
  66 int     brk(caddr_t);
  67 int     chdir(char *);
  68 int     chmod(char *, int);
  69 int     chown(char *, uid_t, gid_t);
  70 int     chroot(char *);
  71 int     cladm(int, int, void *);
  72 int     close(int);
  73 int     exece(const char *, const char **, const char **);
  74 int     faccessat(int, char *, int, int);
  75 int     fchmodat(int, char *, int, int);
  76 int     fchownat(int, char *, uid_t, gid_t, int);
  77 int     fcntl(int, int, intptr_t);
  78 int64_t vfork();
  79 int64_t forksys(int, int);
  80 int     fstat(int, struct stat *);
  81 int     fdsync(int, int);
  82 int64_t getgid();
  83 int     ucredsys(int, int, void *);
  84 int64_t getpid();
  85 int64_t getuid();
  86 time_t  gtime();
  87 int     getloadavg(int *, int);
  88 int     rusagesys(int, void *, void *, void *, void *);
  89 int     getpagesizes(int, size_t *, int);
  90 int     gtty(int, intptr_t);
  91 #if defined(__i386) || defined(__amd64)
  92 int     hrtsys(struct hrtsysa *, rval_t *);
  93 #endif /* __i386 || __amd64 */
  94 int     ioctl(int, int, intptr_t);
  95 int     kill();
  96 int     labelsys(int, void *, void *, void *, void *, void *);
  97 int     link(char *, char *);
  98 int     linkat(int, char *, int, char *, int);
  99 off32_t lseek32(int32_t, off32_t, int32_t);
 100 off_t   lseek64(int, off_t, int);
 101 int     lgrpsys(int, long, void *);
 102 int     mmapobjsys(int, uint_t, mmapobj_result_t *, uint_t *, void *);
 103 int     mknod(char *, mode_t, dev_t);
 104 int     mknodat(int, char *, mode_t, dev_t);
 105 int     mount(long *, rval_t *);
 106 int     nice(int);
 107 int     nullsys();
 108 int     open(char *, int, int);
 109 int     openat(int, char *, int, int);
 110 int     pause();
 111 long    pcsample(void *, long);
 112 int     privsys(int, priv_op_t, priv_ptype_t, void *, size_t, int);
 113 int     profil(unsigned short *, size_t, ulong_t, uint_t);
 114 ssize_t pread(int, void *, size_t, off_t);
 115 ssize_t pwrite(int, void *, size_t, off_t);
 116 ssize_t read(int, void *, size_t);
 117 int     rename(char *, char *);
 118 int     renameat(int, char *, int, char *);
 119 void    rexit(int);
 120 int     semsys();
 121 int     setgid(gid_t);
 122 int     setpgrp(int, int, int);
 123 int     setuid(uid_t);
 124 uintptr_t       shmsys();
 125 uint64_t        sidsys(int, int, int, int);
 126 int     sigprocmask(int, sigset_t *, sigset_t *);
 127 int     sigsuspend(sigset_t);
 128 int     sigaltstack(struct sigaltstack *, struct sigaltstack *);
 129 int     sigaction(int, struct sigaction *, struct sigaction *);
 130 int     sigpending(int, sigset_t *);
 131 int     sigresend(int, siginfo_t *, sigset_t *);
 132 int     sigtimedwait(sigset_t *, siginfo_t *, timespec_t *);
 133 int     getsetcontext(int, void *);
 134 int     stat(char *, struct stat *);
 135 int     fstatat(int, char *, struct stat *, int);
 136 int     stime(time_t);
 137 int     stty(int, intptr_t);
 138 int     syssync();
 139 int     sysacct(char *);
 140 clock_t times(struct tms *);
 141 long    ulimit(int, long);
 142 int     getrlimit32(int, struct rlimit32 *);
 143 int     setrlimit32(int, struct rlimit32 *);
 144 int     umask(int);
 145 int     umount2(char *, int);
 146 int     unlink(char *);
 147 int     unlinkat(int, char *, int);
 148 int     utimesys(int, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
 149 int64_t utssys32(void *, int, int, void *);
 150 int64_t utssys64(void *, long, int, void *);
 151 int     uucopy(const void *, void *, size_t);
 152 ssize_t uucopystr(const char *, char *, size_t);
 153 ssize_t write(int, void *, size_t);
 154 ssize_t readv(int, struct iovec *, int);
 155 ssize_t writev(int, struct iovec *, int);
 156 ssize_t preadv(int, struct iovec *, int, off_t, off_t);
 157 ssize_t pwritev(int, struct iovec *, int, off_t, off_t);
 158 int     syslwp_park(int, uintptr_t, uintptr_t);
 159 int     rmdir(char *);
 160 int     mkdir(char *, int);
 161 int     mkdirat(int, char *, int);
 162 int     getdents32(int, void *, size_t);
 163 int     statfs32(char *, struct statfs32 *, int32_t, int32_t);
 164 int     fstatfs32(int32_t, struct statfs32 *, int32_t, int32_t);
 165 int     sysfs(int, long, long);
 166 int     getmsg(int, struct strbuf *, struct strbuf *, int *);
 167 int     pollsys(pollfd_t *, nfds_t, timespec_t *, sigset_t *);
 168 int     putmsg(int, struct strbuf *, struct strbuf *, int);
 169 int     uadmin();
 170 int     lstat(char *, struct stat *);
 171 int     symlink(char *, char *);
 172 int     symlinkat(char *, int, char *);
 173 ssize_t readlink(char *, char *, size_t);
 174 ssize_t readlinkat(int, char *, char *, size_t);
 175 int     resolvepath(char *, char *, size_t);
 176 int     setgroups(int, gid_t *);
 177 int     getgroups(int, gid_t *);
 178 int     fchdir(int);
 179 int     fchown(int, uid_t, uid_t);
 180 int     fchmod(int, int);
 181 int     getcwd(char *, size_t);
 182 int     statvfs(char *, struct statvfs *);
 183 int     fstatvfs(int, struct statvfs *);
 184 offset_t llseek32(int32_t, uint32_t, uint32_t, int);
 185 
 186 #if (defined(__i386) && !defined(__amd64)) || defined(__i386_COMPAT)
 187 int     sysi86(short, uintptr_t, uintptr_t, uintptr_t);
 188 #endif
 189 
 190 int     acl(const char *, int, int, void *);
 191 int     facl(int, int, int, void *);
 192 long    priocntlsys(int, procset_t *, int, caddr_t, caddr_t);
 193 int     waitsys(idtype_t, id_t, siginfo_t *, int);
 194 int     sigsendsys(procset_t *, int);
 195 int     mincore(caddr_t, size_t, char *);
 196 caddr_t smmap64(caddr_t, size_t, int, int, int, off_t);
 197 caddr_t smmap32(caddr32_t, size32_t, int, int, int, off32_t);
 198 int     smmaplf32(struct mmaplf32a *, rval_t *);
 199 int     mprotect(caddr_t, size_t, int);
 200 int     munmap(caddr_t, size_t);
 201 int     uname(struct utsname *);
 202 int     lchown(char *, uid_t, gid_t);
 203 int     getpmsg(int, struct strbuf *, struct strbuf *, int *, int *);
 204 int     putpmsg(int, struct strbuf *, struct strbuf *, int, int);
 205 int     memcntl(caddr_t, size_t, int, caddr_t, int, int);
 206 long    sysconfig(int);
 207 int     adjtime(struct timeval *, struct timeval *);
 208 long    systeminfo(int, char *, long);
 209 int     setegid(gid_t);
 210 int     seteuid(uid_t);
 211 
 212 int     setreuid(uid_t, uid_t);
 213 int     setregid(gid_t, gid_t);
 214 int     install_utrap(utrap_entry_t type, utrap_handler_t, utrap_handler_t *);
 215 #ifdef __sparc
 216 int     sparc_utrap_install(utrap_entry_t type, utrap_handler_t,
 217     utrap_handler_t, utrap_handler_t *, utrap_handler_t *);
 218 #endif
 219 
 220 int     syslwp_create(ucontext_t *, int, id_t *);
 221 void    syslwp_exit();
 222 int     syslwp_suspend(id_t);
 223 int     syslwp_continue(id_t);
 224 int     syslwp_private(int, int, uintptr_t);
 225 int     lwp_detach(id_t);
 226 int     lwp_info(timestruc_t *);
 227 int     lwp_kill(id_t, int);
 228 int     lwp_self();
 229 int64_t lwp_sigmask(int, uint_t, uint_t, uint_t, uint_t);
 230 int     yield();
 231 int     lwp_wait(id_t, id_t *);
 232 int     lwp_mutex_timedlock(lwp_mutex_t *, timespec_t *, uintptr_t);
 233 int     lwp_mutex_wakeup(lwp_mutex_t *, int);
 234 int     lwp_mutex_unlock(lwp_mutex_t *);
 235 int     lwp_mutex_trylock(lwp_mutex_t *, uintptr_t);
 236 int     lwp_mutex_register(lwp_mutex_t *, caddr_t);
 237 int     lwp_rwlock_sys(int, lwp_rwlock_t *, timespec_t *);
 238 int     lwp_sema_post(lwp_sema_t *);
 239 int     lwp_sema_timedwait(lwp_sema_t *, timespec_t *, int);
 240 int     lwp_sema_trywait(lwp_sema_t *);
 241 int     lwp_cond_wait(lwp_cond_t *, lwp_mutex_t *, timespec_t *, int);
 242 int     lwp_cond_signal(lwp_cond_t *);
 243 int     lwp_cond_broadcast(lwp_cond_t *);
 244 caddr_t schedctl();
 245 
 246 long    pathconf(char *, int);
 247 long    fpathconf(int, int);
 248 int     processor_bind(idtype_t, id_t, processorid_t, processorid_t *);
 249 int     processor_info(processorid_t, processor_info_t *);
 250 int     p_online(processorid_t, int);
 251 
 252 /*
 253  *      POSIX .4 system calls *
 254  */
 255 int     clock_gettime(clockid_t, timespec_t *);
 256 int     clock_settime(clockid_t, timespec_t *);
 257 int     clock_getres(clockid_t, timespec_t *);
 258 int     timer_create(clockid_t, struct sigevent *, timer_t *);
 259 int     timer_delete(timer_t);
 260 int     timer_settime(timer_t, int, itimerspec_t *, itimerspec_t *);
 261 int     timer_gettime(timer_t, itimerspec_t *);
 262 int     timer_getoverrun(timer_t);
 263 int     nanosleep(timespec_t *, timespec_t *);
 264 int     sigqueue(pid_t, int, void *, int, int);
 265 int     signotify(int, siginfo_t *, signotify_id_t *);
 266 
 267 int     getdents64(int, void *, size_t);
 268 int     stat64(char *, struct stat64 *);
 269 int     lstat64(char *, struct stat64 *);
 270 int     fstatat64(int, char *, struct stat64 *, int);
 271 int     fstat64(int, struct stat64 *);
 272 int     statvfs64(char *, struct statvfs64 *);
 273 int     fstatvfs64(int, struct statvfs64 *);
 274 int     setrlimit64(int, struct rlimit64 *);
 275 int     getrlimit64(int, struct rlimit64 *);
 276 int     pread64(int, void *, size32_t, uint32_t, uint32_t);
 277 int     pwrite64(int, void *, size32_t, uint32_t, uint32_t);
 278 int     open64(char *, int, int);
 279 int     openat64(int, char *, int, int);
 280 
 281 /*
 282  * NTP syscalls
 283  */
 284 
 285 int ntp_gettime(struct ntptimeval *);
 286 int ntp_adjtime(struct timex *);
 287 
 288 /*
 289  *      ++++++++++++++++++++++++
 290  *      ++  SunOS4.1 Buyback  ++
 291  *      ++++++++++++++++++++++++
 292  *
 293  *      fchroot, vhangup, gettimeofday
 294  */
 295 
 296 int     fchroot(int);
 297 int     vhangup();
 298 int     gettimeofday(struct timeval *);
 299 int     getitimer(uint_t, struct itimerval *);
 300 int     setitimer(uint_t, struct itimerval *, struct itimerval *);
 301 
 302 int     corectl(int, uintptr_t, uintptr_t, uintptr_t);
 303 int     modctl(int, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
 304 int64_t loadable_syscall();
 305 int64_t indir();
 306 
 307 long    tasksys(int, projid_t, uint_t, void *, size_t);
 308 long    rctlsys(int, char *, void *, void *, size_t, int);
 309 
 310 long    zone();
 311 
 312 int     so_socket(int, int, int, char *, int);
 313 int     so_socketpair(int[2]);
 314 int     bind(int, struct sockaddr *, socklen_t, int);
 315 int     listen(int, int, int);
 316 int     accept(int, struct sockaddr *, socklen_t *, int, int);
 317 int     connect(int, struct sockaddr *, socklen_t, int);
 318 int     shutdown(int, int, int);
 319 ssize_t recv(int, void *, size_t, int);
 320 ssize_t recvfrom(int, void *, size_t, int, struct sockaddr *, socklen_t *);
 321 ssize_t recvmsg(int, struct nmsghdr *, int);
 322 ssize_t send(int, void *, size_t, int);
 323 ssize_t sendmsg(int, struct nmsghdr *, int);
 324 ssize_t sendto(int, void *, size_t, int, struct sockaddr *, socklen_t);
 325 int     getpeername(int, struct sockaddr *, socklen_t *, int);
 326 int     getsockname(int, struct sockaddr *, socklen_t *, int);
 327 int     getsockopt(int, int, int, void *, socklen_t *, int);
 328 int     setsockopt(int, int, int, void *, socklen_t *, int);
 329 int     sockconfig(int, void *, void *, void *, void *);
 330 ssize_t sendfilev(int, int, const struct sendfilevec *, int, size_t *);
 331 int     getrandom(void *, size_t, int);
 332 
 333 typedef int64_t (*llfcn_t)();   /* for casting one-word returns */
 334 
 335 /*
 336  * Sysent initialization macros.
 337  *      These take the name string of the system call even though that isn't
 338  *      currently used in the sysent entry.  This might be useful someday.
 339  *
 340  * Initialization macro for system calls which take their args in the C style.
 341  * These system calls return the longlong_t return value and must call
 342  * set_errno() to return an error.  For SPARC, narg must be at most six.
 343  * For more args, use the SYSENT_AP() routine.
 344  *
 345  * We are able to return two distinct values to userland via the rval_t.
 346  * At this time, that corresponds to one 64-bit quantity, or two 32-bit
 347  * quantities.  The kernel does not currently need to return two 64-bit
 348  * values, or one 128 bit value(!), but we may do one day, so the calling
 349  * sequence between userland and the kernel should permit it.
 350  *
 351  * The interpretation of rval_t is provided by the sy_flags field
 352  * which is used to determine how to arrange the results in registers
 353  * (or on the stack) for return userland.
 354  */
 355         /* returns a 64-bit quantity for both ABIs */
 356 #define SYSENT_C(name, call, narg)      \
 357         { (narg), SE_64RVAL, NULL, NULL, (llfcn_t)(call) }
 358 
 359         /* returns one 32-bit value for both ABIs: r_val1 */
 360 #define SYSENT_CI(name, call, narg)     \
 361         { (narg), SE_32RVAL1, NULL, NULL, (llfcn_t)(call) }
 362 
 363         /* returns 2 32-bit values: r_val1 & r_val2 */
 364 #define SYSENT_2CI(name, call, narg)    \
 365         { (narg), SE_32RVAL1|SE_32RVAL2, NULL, NULL, (llfcn_t)(call) }
 366 
 367 /*
 368  * Initialization macro for system calls which take their args in the standard
 369  * Unix style of a pointer to the arg structure and a pointer to the rval_t.
 370  *
 371  * Deprecated wherever possible (slower on some architectures, and trickier
 372  * to maintain two flavours).
 373  */
 374 #define SYSENT_AP(name, call, narg)     \
 375         { (narg), SE_64RVAL, (call), NULL, syscall_ap }
 376 
 377 /*
 378  * Conditional constructors to build the tables without #ifdef clutter
 379  */
 380 #if defined(_LP64)
 381 #define IF_LP64(true, false)    true
 382 #else
 383 #define IF_LP64(true, false)    false
 384 #endif
 385 
 386 #if defined(__sparc)
 387 #define IF_sparc(true, false)   true
 388 #else
 389 #define IF_sparc(true, false)   false
 390 #endif
 391 
 392 #if defined(__i386) && !defined(__amd64)
 393 #define IF_i386(true, false)    true
 394 #else
 395 #define IF_i386(true, false)    false
 396 #endif
 397 
 398 #if defined(__i386) || defined(__amd64)
 399 #define IF_x86(true, false)     true
 400 #else
 401 #define IF_x86(true, false)     false
 402 #endif
 403 
 404 #if (defined(__i386) && !defined(__amd64)) || defined(__i386_COMPAT)
 405 #define IF_386_ABI(true, false) true
 406 #else
 407 #define IF_386_ABI(true, false) false
 408 #endif
 409 
 410 /*
 411  * Define system calls that return a native 'long' quantity i.e. a 32-bit
 412  * or 64-bit integer - depending on how the kernel is itself compiled
 413  * e.g. read(2) returns 'ssize_t' in the kernel and in userland.
 414  */
 415 #define SYSENT_CL(name, call, narg)     \
 416         IF_LP64(SYSENT_C(name, call, narg), SYSENT_CI(name, call, narg))
 417 
 418 /*
 419  * Initialization macro for loadable native system calls.
 420  */
 421 #define SYSENT_LOADABLE()       \
 422         { 0, SE_LOADABLE, (int (*)())nosys, NULL, loadable_syscall }
 423 
 424 /*
 425  * Initialization macro for loadable 32-bit compatibility system calls.
 426  */
 427 #define SYSENT_LOADABLE32()     SYSENT_LOADABLE()
 428 
 429 #define SYSENT_NOSYS()          SYSENT_C("nosys", nosys, 0)
 430 
 431 struct sysent nosys_ent = SYSENT_NOSYS();
 432 
 433 /*
 434  * Native sysent table.
 435  */
 436 struct sysent sysent[NSYSCALL] =
 437 {
 438         /*  0 */ IF_LP64(
 439                         SYSENT_NOSYS(),
 440                         SYSENT_C("indir",       indir,          1)),
 441         /*  1 */ SYSENT_CI("exit",              rexit,          1),
 442         /*  2 */ SYSENT_LOADABLE(),                     /* (was forkall) */
 443         /*  3 */ SYSENT_CL("read",              read,           3),
 444         /*  4 */ SYSENT_CL("write",             write,          3),
 445         /*  5 */ SYSENT_CI("open",              open,           3),
 446         /*  6 */ SYSENT_CI("close",             close,          1),
 447         /*  7 */ SYSENT_CI("linkat",            linkat,         5),
 448         /*  8 */ SYSENT_LOADABLE(),                     /* (was creat) */
 449         /*  9 */ SYSENT_CI("link",              link,           2),
 450         /* 10 */ SYSENT_CI("unlink",            unlink,         1),
 451         /* 11 */ SYSENT_CI("symlinkat",         symlinkat,      3),
 452         /* 12 */ SYSENT_CI("chdir",             chdir,          1),
 453         /* 13 */ SYSENT_CL("time",              gtime,          0),
 454         /* 14 */ SYSENT_CI("mknod",             mknod,          3),
 455         /* 15 */ SYSENT_CI("chmod",             chmod,          2),
 456         /* 16 */ SYSENT_CI("chown",             chown,          3),
 457         /* 17 */ SYSENT_CI("brk",               brk,            1),
 458         /* 18 */ SYSENT_CI("stat",              stat,           2),
 459         /* 19 */ IF_LP64(
 460                         SYSENT_CL("lseek",      lseek64,        3),
 461                         SYSENT_CL("lseek",      lseek32,        3)),
 462         /* 20 */ SYSENT_2CI("getpid",           getpid,         0),
 463         /* 21 */ SYSENT_AP("mount",             mount,          8),
 464         /* 22 */ SYSENT_CL("readlinkat",        readlinkat,     4),
 465         /* 23 */ SYSENT_CI("setuid",            setuid,         1),
 466         /* 24 */ SYSENT_2CI("getuid",           getuid,         0),
 467         /* 25 */ SYSENT_CI("stime",             stime,          1),
 468         /* 26 */ SYSENT_CL("pcsample",          pcsample,       2),
 469         /* 27 */ SYSENT_CI("alarm",             alarm,          1),
 470         /* 28 */ SYSENT_CI("fstat",             fstat,          2),
 471         /* 29 */ SYSENT_CI("pause",             pause,          0),
 472         /* 30 */ SYSENT_LOADABLE(),                     /* (was utime) */
 473         /* 31 */ SYSENT_CI("stty",              stty,           2),
 474         /* 32 */ SYSENT_CI("gtty",              gtty,           2),
 475         /* 33 */ SYSENT_CI("access",            access,         2),
 476         /* 34 */ SYSENT_CI("nice",              nice,           1),
 477         /* 35 */ IF_LP64(
 478                         SYSENT_NOSYS(),
 479                         SYSENT_CI("statfs",     statfs32,       4)),
 480         /* 36 */ SYSENT_CI("sync",              syssync,        0),
 481         /* 37 */ SYSENT_CI("kill",              kill,           2),
 482         /* 38 */ IF_LP64(
 483                         SYSENT_NOSYS(),
 484                         SYSENT_CI("fstatfs",    fstatfs32,      4)),
 485         /* 39 */ SYSENT_CI("setpgrp",           setpgrp,        3),
 486         /* 40 */ SYSENT_CI("uucopystr",         uucopystr,      3),
 487         /* 41 */ SYSENT_LOADABLE(),                     /* (was dup) */
 488         /* 42 */ SYSENT_LOADABLE(),                     /* pipe */
 489         /* 43 */ SYSENT_CL("times",             times,          1),
 490         /* 44 */ SYSENT_CI("prof",              profil,         4),
 491         /* 45 */ SYSENT_CI("faccessat",         faccessat,      4),
 492         /* 46 */ SYSENT_CI("setgid",            setgid,         1),
 493         /* 47 */ SYSENT_2CI("getgid",           getgid,         0),
 494         /* 48 */ SYSENT_CI("mknodat",           mknodat,        4),
 495         /* 49 */ SYSENT_LOADABLE(),                     /* msgsys */
 496         /* 50 */ IF_x86(
 497                         SYSENT_CI("sysi86",     sysi86,         4),
 498                         SYSENT_LOADABLE()),             /* (was sys3b) */
 499         /* 51 */ SYSENT_LOADABLE(),                     /* sysacct */
 500         /* 52 */ SYSENT_LOADABLE(),                     /* shmsys */
 501         /* 53 */ SYSENT_LOADABLE(),                     /* semsys */
 502         /* 54 */ SYSENT_CI("ioctl",             ioctl,          3),
 503         /* 55 */ SYSENT_CI("uadmin",            uadmin,         3),
 504         /* 56 */ SYSENT_CI("fchownat",          fchownat,       5),
 505         /* 57 */ IF_LP64(
 506                         SYSENT_2CI("utssys",    utssys64,       4),
 507                         SYSENT_2CI("utssys",    utssys32,       4)),
 508         /* 58 */ SYSENT_CI("fdsync",            fdsync,         2),
 509         /* 59 */ SYSENT_CI("exece",             exece,          3),
 510         /* 60 */ SYSENT_CI("umask",             umask,          1),
 511         /* 61 */ SYSENT_CI("chroot",            chroot,         1),
 512         /* 62 */ SYSENT_CI("fcntl",             fcntl,          3),
 513         /* 63 */ SYSENT_CI("ulimit",            ulimit,         2),
 514         /* 64 */ SYSENT_CI("renameat",          renameat,       4),
 515         /* 65 */ SYSENT_CI("unlinkat",          unlinkat,       3),
 516         /* 66 */ SYSENT_CI("fstatat",           fstatat,        4),
 517         /* 67 */ IF_LP64(
 518                         SYSENT_NOSYS(),
 519                         SYSENT_CI("fstatat64",  fstatat64,      4)),
 520         /* 68 */ SYSENT_CI("openat",            openat,         4),
 521         /* 69 */ IF_LP64(
 522                         SYSENT_NOSYS(),
 523                         SYSENT_CI("openat64",   openat64,       4)),
 524         /* 70 */ SYSENT_CI("tasksys",           tasksys,        5),
 525         /* 71 */ SYSENT_LOADABLE(),             /* acctctl */
 526         /* 72 */ SYSENT_LOADABLE(),             /* exacct */
 527         /* 73 */ SYSENT_CI("getpagesizes",      getpagesizes,   3),
 528         /* 74 */ SYSENT_CI("rctlsys",           rctlsys,        6),
 529         /* 75 */ SYSENT_2CI("sidsys",           sidsys,         4),
 530         /* 76 */ SYSENT_LOADABLE(),                     /* (was fsat) */
 531         /* 77 */ SYSENT_CI("lwp_park",          syslwp_park,    3),
 532         /* 78 */ SYSENT_CL("sendfilev",         sendfilev,      5),
 533         /* 79 */ SYSENT_CI("rmdir",             rmdir,          1),
 534         /* 80 */ SYSENT_CI("mkdir",             mkdir,          2),
 535         /* 81 */ IF_LP64(
 536                         SYSENT_CI("getdents",   getdents64,     3),
 537                         SYSENT_CI("getdents",   getdents32,     3)),
 538         /* 82 */ SYSENT_CI("privsys",           privsys,        6),
 539         /* 83 */ SYSENT_CI("ucredsys",          ucredsys,       3),
 540         /* 84 */ SYSENT_CI("sysfs",             sysfs,          3),
 541         /* 85 */ SYSENT_CI("getmsg",            getmsg,         4),
 542         /* 86 */ SYSENT_CI("putmsg",            putmsg,         4),
 543         /* 87 */ SYSENT_LOADABLE(),                     /* (was poll) */
 544         /* 88 */ SYSENT_CI("lstat",             lstat,          2),
 545         /* 89 */ SYSENT_CI("symlink",           symlink,        2),
 546         /* 90 */ SYSENT_CL("readlink",          readlink,       3),
 547         /* 91 */ SYSENT_CI("setgroups",         setgroups,      2),
 548         /* 92 */ SYSENT_CI("getgroups",         getgroups,      2),
 549         /* 93 */ SYSENT_CI("fchmod",            fchmod,         2),
 550         /* 94 */ SYSENT_CI("fchown",            fchown,         3),
 551         /* 95 */ SYSENT_CI("sigprocmask",       sigprocmask,    3),
 552         /* 96 */ SYSENT_CI("sigsuspend",        sigsuspend,     1),
 553         /* 97 */ SYSENT_CI("sigaltstack",       sigaltstack,    2),
 554         /* 98 */ SYSENT_CI("sigaction",         sigaction,      3),
 555         /* 99 */ SYSENT_CI("sigpending",        sigpending,     2),
 556         /* 100 */ SYSENT_CI("getsetcontext",    getsetcontext,  2),
 557         /* 101 */ SYSENT_CI("fchmodat",         fchmodat,       4),
 558         /* 102 */ SYSENT_CI("mkdirat",          mkdirat,        3),
 559         /* 103 */ SYSENT_CI("statvfs",          statvfs,        2),
 560         /* 104 */ SYSENT_CI("fstatvfs",         fstatvfs,       2),
 561         /* 105 */ SYSENT_CI("getloadavg",       getloadavg,     2),
 562         /* 106 */ SYSENT_LOADABLE(),            /* nfssys */
 563         /* 107 */ SYSENT_CI("waitsys",          waitsys,        4),
 564         /* 108 */ SYSENT_CI("sigsendset",       sigsendsys,     2),
 565         /* 109 */ IF_x86(
 566                         SYSENT_AP("hrtsys",     hrtsys,         5),
 567                         SYSENT_LOADABLE()),
 568         /* 110 */ SYSENT_CI("utimesys",         utimesys,       5),
 569         /* 111 */ SYSENT_CI("sigresend",        sigresend,      3),
 570         /* 112 */ SYSENT_CL("priocntlsys",      priocntlsys,    5),
 571         /* 113 */ SYSENT_CL("pathconf",         pathconf,       2),
 572         /* 114 */ SYSENT_CI("mincore",          mincore,        3),
 573         /* 115 */ IF_LP64(
 574                         SYSENT_CL("mmap",       smmap64,        6),
 575                         SYSENT_CL("mmap",       smmap32,        6)),
 576         /* 116 */ SYSENT_CI("mprotect",         mprotect,       3),
 577         /* 117 */ SYSENT_CI("munmap",           munmap,         2),
 578         /* 118 */ SYSENT_CL("fpathconf",        fpathconf,      2),
 579         /* 119 */ SYSENT_2CI("vfork",           vfork,          0),
 580         /* 120 */ SYSENT_CI("fchdir",           fchdir,         1),
 581         /* 121 */ SYSENT_CL("readv",            readv,          3),
 582         /* 122 */ SYSENT_CL("writev",           writev,         3),
 583         /* 123 */ SYSENT_CL("preadv",           preadv,         5),
 584         /* 124 */ SYSENT_CL("pwritev",          pwritev,        5),
 585         /* 125 */ SYSENT_LOADABLE(),                    /* (was fxstat) */
 586         /* 126 */ SYSENT_CI("getrandom",        getrandom,      3),
 587         /* 127 */ SYSENT_CI("mmapobj",          mmapobjsys,     5),
 588         /* 128 */ IF_LP64(
 589                         SYSENT_CI("setrlimit",  setrlimit64,    2),
 590                         SYSENT_CI("setrlimit",  setrlimit32,    2)),
 591         /* 129 */ IF_LP64(
 592                         SYSENT_CI("getrlimit",  getrlimit64,    2),
 593                         SYSENT_CI("getrlimit",  getrlimit32,    2)),
 594         /* 130 */ SYSENT_CI("lchown",           lchown,         3),
 595         /* 131 */ SYSENT_CI("memcntl",          memcntl,        6),
 596         /* 132 */ SYSENT_CI("getpmsg",          getpmsg,        5),
 597         /* 133 */ SYSENT_CI("putpmsg",          putpmsg,        5),
 598         /* 134 */ SYSENT_CI("rename",           rename,         2),
 599         /* 135 */ SYSENT_CI("uname",            uname,          1),
 600         /* 136 */ SYSENT_CI("setegid",          setegid,        1),
 601         /* 137 */ SYSENT_CL("sysconfig",        sysconfig,      1),
 602         /* 138 */ SYSENT_CI("adjtime",          adjtime,        2),
 603         /* 139 */ SYSENT_CL("systeminfo",       systeminfo,     3),
 604         /* 140 */ SYSENT_LOADABLE(),            /* sharefs */
 605         /* 141 */ SYSENT_CI("seteuid",          seteuid,        1),
 606         /* 142 */ SYSENT_2CI("forksys",         forksys,        2),
 607         /* 143 */ SYSENT_LOADABLE(),                    /* (was fork1) */
 608         /* 144 */ SYSENT_CI("sigtimedwait",     sigtimedwait,   3),
 609         /* 145 */ SYSENT_CI("lwp_info",         lwp_info,       1),
 610         /* 146 */ SYSENT_CI("yield",            yield,          0),
 611         /* 147 */ SYSENT_LOADABLE(),                /* (was lwp_sema_wait) */
 612         /* 148 */ SYSENT_CI("lwp_sema_post",    lwp_sema_post,  1),
 613         /* 149 */ SYSENT_CI("lwp_sema_trywait", lwp_sema_trywait, 1),
 614         /* 150 */ SYSENT_CI("lwp_detach",       lwp_detach,     1),
 615         /* 151 */ SYSENT_CI("corectl",          corectl,        4),
 616         /* 152 */ SYSENT_CI("modctl",           modctl,         6),
 617         /* 153 */ SYSENT_CI("fchroot",          fchroot,        1),
 618         /* 154 */ SYSENT_LOADABLE(),                    /* (was utimes) */
 619         /* 155 */ SYSENT_CI("vhangup",          vhangup,        0),
 620         /* 156 */ SYSENT_CI("gettimeofday",     gettimeofday,   1),
 621         /* 157 */ SYSENT_CI("getitimer",        getitimer,      2),
 622         /* 158 */ SYSENT_CI("setitimer",        setitimer,      3),
 623         /* 159 */ SYSENT_CI("lwp_create",       syslwp_create,  3),
 624         /* 160 */ SYSENT_CI("lwp_exit", (int (*)())syslwp_exit, 0),
 625         /* 161 */ SYSENT_CI("lwp_suspend",      syslwp_suspend, 1),
 626         /* 162 */ SYSENT_CI("lwp_continue",     syslwp_continue, 1),
 627         /* 163 */ SYSENT_CI("lwp_kill",         lwp_kill,       2),
 628         /* 164 */ SYSENT_CI("lwp_self",         lwp_self,       0),
 629         /* 165 */ SYSENT_2CI("lwp_sigmask",     lwp_sigmask,    5),
 630         /* 166 */ IF_x86(
 631                         SYSENT_CI("lwp_private", syslwp_private, 3),
 632                         SYSENT_NOSYS()),
 633         /* 167 */ SYSENT_CI("lwp_wait",         lwp_wait,       2),
 634         /* 168 */ SYSENT_CI("lwp_mutex_wakeup", lwp_mutex_wakeup,       2),
 635         /* 169 */ SYSENT_LOADABLE(),                /* (was lwp_mutex_lock) */
 636         /* 170 */ SYSENT_CI("lwp_cond_wait",    lwp_cond_wait,          4),
 637         /* 171 */ SYSENT_CI("lwp_cond_signal",  lwp_cond_signal,        1),
 638         /* 172 */ SYSENT_CI("lwp_cond_broadcast", lwp_cond_broadcast,   1),
 639         /* 173 */ SYSENT_CL("pread",            pread,          4),
 640         /* 174 */ SYSENT_CL("pwrite ",          pwrite,         4),
 641         /*
 642          * The 64-bit C library maps llseek() to lseek(), so this
 643          * is needed as a native syscall only on the 32-bit kernel.
 644          */
 645         /* 175 */ IF_LP64(
 646                         SYSENT_NOSYS(),
 647                         SYSENT_C("llseek",      llseek32,       4)),
 648         /* 176 */ SYSENT_LOADABLE(),            /* inst_sync */
 649         /* 177 */ SYSENT_CI("brandsys",         brandsys,       6),
 650         /* 178 */ SYSENT_LOADABLE(),            /* kaio */
 651         /* 179 */ SYSENT_LOADABLE(),            /* cpc */
 652         /* 180 */ SYSENT_CI("lgrpsys",          lgrpsys,        3),
 653         /* 181 */ SYSENT_CI("rusagesys",        rusagesys,      5),
 654         /* 182 */ SYSENT_LOADABLE(),            /* portfs */
 655         /* 183 */ SYSENT_CI("pollsys",          pollsys,        4),
 656         /* 184 */ SYSENT_CI("labelsys",         labelsys,       5),
 657         /* 185 */ SYSENT_CI("acl",              acl,            4),
 658         /* 186 */ SYSENT_AP("auditsys",         auditsys,       6),
 659         /* 187 */ SYSENT_CI("processor_bind",   processor_bind, 4),
 660         /* 188 */ SYSENT_CI("processor_info",   processor_info, 2),
 661         /* 189 */ SYSENT_CI("p_online",         p_online,       2),
 662         /* 190 */ SYSENT_CI("sigqueue",         sigqueue,       5),
 663         /* 191 */ SYSENT_CI("clock_gettime",    clock_gettime,  2),
 664         /* 192 */ SYSENT_CI("clock_settime",    clock_settime,  2),
 665         /* 193 */ SYSENT_CI("clock_getres",     clock_getres,   2),
 666         /* 194 */ SYSENT_CI("timer_create",     timer_create,   3),
 667         /* 195 */ SYSENT_CI("timer_delete",     timer_delete,   1),
 668         /* 196 */ SYSENT_CI("timer_settime",    timer_settime,  4),
 669         /* 197 */ SYSENT_CI("timer_gettime",    timer_gettime,  2),
 670         /* 198 */ SYSENT_CI("timer_getoverrun", timer_getoverrun, 1),
 671         /* 199 */ SYSENT_CI("nanosleep",        nanosleep,      2),
 672         /* 200 */ SYSENT_CI("facl",             facl,           4),
 673         /* 201 */ SYSENT_LOADABLE(),            /* door */
 674         /* 202 */ SYSENT_CI("setreuid",         setreuid,       2),
 675         /* 203 */ SYSENT_CI("setregid",         setregid,       2),
 676         /* 204 */ SYSENT_CI("install_utrap",    install_utrap,  3),
 677         /* 205 */ SYSENT_CI("signotify",        signotify,      3),
 678         /* 206 */ SYSENT_CL("schedctl",         schedctl,       0),
 679         /* 207 */ SYSENT_LOADABLE(),            /* pset */
 680         /* 208 */ IF_sparc(
 681                 SYSENT_CI("sparc_utrap_install", sparc_utrap_install, 5),
 682                 SYSENT_NOSYS()),
 683         /* 209 */ SYSENT_CI("resolvepath",      resolvepath,    3),
 684         /* 210 */ SYSENT_CI("lwp_mutex_timedlock", lwp_mutex_timedlock, 3),
 685         /* 211 */ SYSENT_CI("lwp_sema_timedwait", lwp_sema_timedwait,   3),
 686         /* 212 */ SYSENT_CI("lwp_rwlock_sys",   lwp_rwlock_sys, 3),
 687         /*
 688          * Syscalls 213-225: 32-bit system call support for large files.
 689          *
 690          * (The 64-bit C library transparently maps these system calls
 691          * back to their native versions, so almost all of them are only
 692          * needed as native syscalls on the 32-bit kernel).
 693          */
 694         /* 213 */ IF_LP64(
 695                         SYSENT_NOSYS(),
 696                         SYSENT_CI("getdents64", getdents64,     3)),
 697         /* 214 */ IF_LP64(
 698                         SYSENT_NOSYS(),
 699                         SYSENT_AP("smmaplf32",  smmaplf32,      7)),
 700         /* 215 */ IF_LP64(
 701                         SYSENT_NOSYS(),
 702                         SYSENT_CI("stat64",     stat64,         2)),
 703         /* 216 */ IF_LP64(
 704                         SYSENT_NOSYS(),
 705                         SYSENT_CI("lstat64",    lstat64,        2)),
 706         /* 217 */ IF_LP64(
 707                         SYSENT_NOSYS(),
 708                         SYSENT_CI("fstat64",    fstat64,        2)),
 709         /* 218 */ IF_LP64(
 710                         SYSENT_NOSYS(),
 711                         SYSENT_CI("statvfs64",  statvfs64,      2)),
 712         /* 219 */ IF_LP64(
 713                         SYSENT_NOSYS(),
 714                         SYSENT_CI("fstatvfs64", fstatvfs64,     2)),
 715         /* 220 */ IF_LP64(
 716                         SYSENT_NOSYS(),
 717                         SYSENT_CI("setrlimit64", setrlimit64,   2)),
 718         /* 221 */ IF_LP64(
 719                         SYSENT_NOSYS(),
 720                         SYSENT_CI("getrlimit64", getrlimit64,   2)),
 721         /* 222 */ IF_LP64(
 722                         SYSENT_NOSYS(),
 723                         SYSENT_CI("pread64",    pread64,        5)),
 724         /* 223 */ IF_LP64(
 725                         SYSENT_NOSYS(),
 726                         SYSENT_CI("pwrite64",   pwrite64,       5)),
 727         /* 224 */ SYSENT_LOADABLE(),                    /* (was creat64) */
 728         /* 225 */ IF_LP64(
 729                         SYSENT_NOSYS(),
 730                         SYSENT_CI("open64",     open64,         3)),
 731         /* 226 */ SYSENT_LOADABLE(),            /* rpcsys */
 732         /* 227 */ SYSENT_CL("zone",             zone,           5),
 733         /* 228 */ SYSENT_LOADABLE(),            /* autofssys */
 734         /* 229 */ SYSENT_CI("getcwd",           getcwd,         2),
 735         /* 230 */ SYSENT_CI("so_socket",        so_socket,      5),
 736         /* 231 */ SYSENT_CI("so_socketpair",    so_socketpair,  1),
 737         /* 232 */ SYSENT_CI("bind",             bind,           4),
 738         /* 233 */ SYSENT_CI("listen",           listen,         3),
 739         /* 234 */ SYSENT_CI("accept",           accept,         5),
 740         /* 235 */ SYSENT_CI("connect",          connect,        4),
 741         /* 236 */ SYSENT_CI("shutdown",         shutdown,       3),
 742         /* 237 */ SYSENT_CL("recv",             recv,           4),
 743         /* 238 */ SYSENT_CL("recvfrom",         recvfrom,       6),
 744         /* 239 */ SYSENT_CL("recvmsg",          recvmsg,        3),
 745         /* 240 */ SYSENT_CL("send",             send,           4),
 746         /* 241 */ SYSENT_CL("sendmsg",          sendmsg,        3),
 747         /* 242 */ SYSENT_CL("sendto",           sendto,         6),
 748         /* 243 */ SYSENT_CI("getpeername",      getpeername,    4),
 749         /* 244 */ SYSENT_CI("getsockname",      getsockname,    4),
 750         /* 245 */ SYSENT_CI("getsockopt",       getsockopt,     6),
 751         /* 246 */ SYSENT_CI("setsockopt",       setsockopt,     6),
 752         /* 247 */ SYSENT_CI("sockconfig",       sockconfig,     5),
 753         /* 248 */ SYSENT_CI("ntp_gettime",      ntp_gettime,    1),
 754         /* 249 */ SYSENT_CI("ntp_adjtime",      ntp_adjtime,    1),
 755         /* 250 */ SYSENT_CI("lwp_mutex_unlock", lwp_mutex_unlock,       1),
 756         /* 251 */ SYSENT_CI("lwp_mutex_trylock", lwp_mutex_trylock,     2),
 757         /* 252 */ SYSENT_CI("lwp_mutex_register", lwp_mutex_register,   2),
 758         /* 253 */ SYSENT_CI("cladm",            cladm,          3),
 759         /* 254 */ SYSENT_CI("uucopy",           uucopy,         3),
 760         /* 255 */ SYSENT_CI("umount2",          umount2,        2)
 761 };
 762 
 763 
 764 #ifdef _SYSCALL32_IMPL
 765 
 766 extern int ulimit32(int, int);
 767 extern ssize_t read32(int32_t, caddr32_t, size32_t);
 768 extern ssize_t write32(int32_t, caddr32_t, size32_t);
 769 extern ssize_t pread32(int32_t, caddr32_t, size32_t, off32_t);
 770 extern ssize_t pwrite32(int32_t, caddr32_t, size32_t, off32_t);
 771 extern ssize_t readv32(int32_t, caddr32_t, int32_t);
 772 extern ssize_t writev32(int32_t, caddr32_t, int32_t);
 773 extern ssize_t readlink32(caddr32_t, caddr32_t, size32_t);
 774 extern ssize_t readlinkat32(int, caddr32_t, caddr32_t, size32_t);
 775 extern int open32(char *, int, int);
 776 extern int openat32(int, char *, int, int);
 777 extern int stat32(char *, struct stat32 *);
 778 extern int fstatat32(int, char *, struct stat32 *, int);
 779 extern int lstat32(char *, struct stat32 *);
 780 extern int fstat32(int, struct stat32 *);
 781 extern int fstatat64_32(int, char *, struct stat64_32 *, int);
 782 extern int stat64_32(char *, struct stat64_32 *);
 783 extern int lstat64_32(char *, struct stat64_32 *);
 784 extern int fstat64_32(int, struct stat64_32 *);
 785 extern int getmsg32(int, struct strbuf32 *, struct strbuf32 *, int32_t *);
 786 extern int putmsg32(int, struct strbuf32 *, struct strbuf32 *, int32_t *);
 787 extern int getpmsg32(int, struct strbuf32 *, struct strbuf32 *, int32_t *,
 788     int32_t *);
 789 extern int putpmsg32(int, struct strbuf32 *, struct strbuf32 *, int32_t,
 790     int32_t);
 791 extern int getsetcontext32(int, void *);
 792 extern int statvfs32(char *, struct statvfs32 *);
 793 extern int fstatvfs32(int, struct statvfs32 *);
 794 extern int statvfs64_32(char *, struct statvfs64_32 *);
 795 extern int fstatvfs64_32(int, struct statvfs64_32 *);
 796 extern int sigaction32(int, struct sigaction32 *, struct sigaction32 *);
 797 extern clock32_t times32(struct tms32 *);
 798 extern int stime32(time32_t);
 799 extern int getpagesizes32(int, size32_t *, int);
 800 extern int sigaltstack32(struct sigaltstack32 *, struct sigaltstack32 *);
 801 extern int sigqueue32(pid_t, int, caddr32_t, int, int);
 802 extern offset_t llseek32(int32_t, uint32_t, uint32_t, int);
 803 extern int waitsys32(idtype_t, id_t, siginfo_t *, int);
 804 
 805 extern ssize_t recv32(int32_t, caddr32_t, size32_t, int32_t);
 806 extern ssize_t recvfrom32(int32_t, caddr32_t, size32_t, int32_t, caddr32_t,
 807     caddr32_t);
 808 extern ssize_t send32(int32_t, caddr32_t, size32_t, int32_t);
 809 extern ssize_t sendto32(int32_t, caddr32_t, size32_t, int32_t, caddr32_t,
 810     socklen_t);
 811 
 812 extern int privsys32(int, priv_op_t, priv_ptype_t, caddr32_t, size32_t, int);
 813 extern int ucredsys32(int, int, caddr32_t);
 814 
 815 /*
 816  * sysent table for ILP32 processes running on
 817  * a LP64 kernel.
 818  */
 819 struct sysent sysent32[NSYSCALL] =
 820 {
 821         /*  0 */ SYSENT_C("indir",              indir,          1),
 822         /*  1 */ SYSENT_CI("exit",      (int (*)())rexit,       1),
 823         /*  2 */ SYSENT_LOADABLE32(),                   /* (was forkall) */
 824         /*  3 */ SYSENT_CI("read",              read32,         3),
 825         /*  4 */ SYSENT_CI("write",             write32,        3),
 826         /*  5 */ SYSENT_CI("open",              open32,         3),
 827         /*  6 */ SYSENT_CI("close",             close,          1),
 828         /*  7 */ SYSENT_CI("linkat",            linkat,         5),
 829         /*  8 */ SYSENT_LOADABLE32(),                   /* (was creat32) */
 830         /*  9 */ SYSENT_CI("link",              link,           2),
 831         /* 10 */ SYSENT_CI("unlink",            unlink,         1),
 832         /* 11 */ SYSENT_CI("symlinkat",         symlinkat,      3),
 833         /* 12 */ SYSENT_CI("chdir",             chdir,          1),
 834         /* 13 */ SYSENT_CI("time",              gtime,          0),
 835         /* 14 */ SYSENT_CI("mknod",             mknod,          3),
 836         /* 15 */ SYSENT_CI("chmod",             chmod,          2),
 837         /* 16 */ SYSENT_CI("chown",             chown,          3),
 838         /* 17 */ SYSENT_CI("brk",               brk,            1),
 839         /* 18 */ SYSENT_CI("stat",              stat32,         2),
 840         /* 19 */ SYSENT_CI("lseek",             lseek32,        3),
 841         /* 20 */ SYSENT_2CI("getpid",           getpid,         0),
 842         /* 21 */ SYSENT_AP("mount",             mount,          8),
 843         /* 22 */ SYSENT_CI("readlinkat",        readlinkat32,   4),
 844         /* 23 */ SYSENT_CI("setuid",            setuid,         1),
 845         /* 24 */ SYSENT_2CI("getuid",           getuid,         0),
 846         /* 25 */ SYSENT_CI("stime",             stime32,        1),
 847         /* 26 */ SYSENT_CI("pcsample",          pcsample,       2),
 848         /* 27 */ SYSENT_CI("alarm",             alarm,          1),
 849         /* 28 */ SYSENT_CI("fstat",             fstat32,        2),
 850         /* 29 */ SYSENT_CI("pause",             pause,          0),
 851         /* 30 */ SYSENT_LOADABLE32(),                   /* (was utime) */
 852         /* 31 */ SYSENT_CI("stty",              stty,           2),
 853         /* 32 */ SYSENT_CI("gtty",              gtty,           2),
 854         /* 33 */ SYSENT_CI("access",            access,         2),
 855         /* 34 */ SYSENT_CI("nice",              nice,           1),
 856         /* 35 */ SYSENT_CI("statfs",            statfs32,       4),
 857         /* 36 */ SYSENT_CI("sync",              syssync,        0),
 858         /* 37 */ SYSENT_CI("kill",              kill,           2),
 859         /* 38 */ SYSENT_CI("fstatfs",           fstatfs32,      4),
 860         /* 39 */ SYSENT_CI("setpgrp",           setpgrp,        3),
 861         /* 40 */ SYSENT_CI("uucopystr",         uucopystr,      3),
 862         /* 41 */ SYSENT_LOADABLE32(),                   /* (was dup) */
 863         /* 42 */ SYSENT_LOADABLE32(),                   /* pipe */
 864         /* 43 */ SYSENT_CI("times",             times32,        1),
 865         /* 44 */ SYSENT_CI("prof",              profil,         4),
 866         /* 45 */ SYSENT_CI("faccessat",         faccessat,      4),
 867         /* 46 */ SYSENT_CI("setgid",            setgid,         1),
 868         /* 47 */ SYSENT_2CI("getgid",           getgid,         0),
 869         /* 48 */ SYSENT_CI("mknodat",           mknodat,        4),
 870         /* 49 */ SYSENT_LOADABLE32(),                   /* msgsys */
 871         /* 50 */ IF_386_ABI(
 872                         SYSENT_CI("sysi86",     sysi86,         4),
 873                         SYSENT_LOADABLE32()),           /* (was sys3b) */
 874         /* 51 */ SYSENT_LOADABLE32(),                   /* sysacct */
 875         /* 52 */ SYSENT_LOADABLE32(),                   /* shmsys */
 876         /* 53 */ SYSENT_LOADABLE32(),                   /* semsys */
 877         /* 54 */ SYSENT_CI("ioctl",             ioctl,          3),
 878         /* 55 */ SYSENT_CI("uadmin",            uadmin,         3),
 879         /* 56 */ SYSENT_CI("fchownat",          fchownat,       5),
 880         /* 57 */ SYSENT_2CI("utssys",           utssys32,       4),
 881         /* 58 */ SYSENT_CI("fdsync",            fdsync,         2),
 882         /* 59 */ SYSENT_CI("exece",             exece,          3),
 883         /* 60 */ SYSENT_CI("umask",             umask,          1),
 884         /* 61 */ SYSENT_CI("chroot",            chroot,         1),
 885         /* 62 */ SYSENT_CI("fcntl",             fcntl,          3),
 886         /* 63 */ SYSENT_CI("ulimit",            ulimit32,       2),
 887         /* 64 */ SYSENT_CI("renameat",          renameat,       4),
 888         /* 65 */ SYSENT_CI("unlinkat",          unlinkat,       3),
 889         /* 66 */ SYSENT_CI("fstatat",           fstatat32,      4),
 890         /* 67 */ SYSENT_CI("fstatat64",         fstatat64_32,   4),
 891         /* 68 */ SYSENT_CI("openat",            openat32,       4),
 892         /* 69 */ SYSENT_CI("openat64",          openat64,       4),
 893         /* 70 */ SYSENT_CI("tasksys",           tasksys,        5),
 894         /* 71 */ SYSENT_LOADABLE32(),           /* acctctl */
 895         /* 72 */ SYSENT_LOADABLE32(),           /* exacct */
 896         /* 73 */ SYSENT_CI("getpagesizes",      getpagesizes32, 3),
 897         /* 74 */ SYSENT_CI("rctlsys",           rctlsys,        6),
 898         /* 75 */ SYSENT_2CI("sidsys",           sidsys,         4),
 899         /* 76 */ SYSENT_LOADABLE32(),                   /* (was fsat) */
 900         /* 77 */ SYSENT_CI("lwp_park",          syslwp_park,    3),
 901         /* 78 */ SYSENT_CI("sendfilev",         sendfilev,      5),
 902         /* 79 */ SYSENT_CI("rmdir",             rmdir,          1),
 903         /* 80 */ SYSENT_CI("mkdir",             mkdir,          2),
 904         /* 81 */ SYSENT_CI("getdents",          getdents32,     3),
 905         /* 82 */ SYSENT_CI("privsys",           privsys32,      6),
 906         /* 83 */ SYSENT_CI("ucredsys",          ucredsys32,     3),
 907         /* 84 */ SYSENT_CI("sysfs",             sysfs,          3),
 908         /* 85 */ SYSENT_CI("getmsg",            getmsg32,       4),
 909         /* 86 */ SYSENT_CI("putmsg",            putmsg32,       4),
 910         /* 87 */ SYSENT_LOADABLE32(),                   /* (was poll) */
 911         /* 88 */ SYSENT_CI("lstat",             lstat32,        2),
 912         /* 89 */ SYSENT_CI("symlink",           symlink,        2),
 913         /* 90 */ SYSENT_CI("readlink",          readlink32,     3),
 914         /* 91 */ SYSENT_CI("setgroups",         setgroups,      2),
 915         /* 92 */ SYSENT_CI("getgroups",         getgroups,      2),
 916         /* 93 */ SYSENT_CI("fchmod",            fchmod,         2),
 917         /* 94 */ SYSENT_CI("fchown",            fchown,         3),
 918         /* 95 */ SYSENT_CI("sigprocmask",       sigprocmask,    3),
 919         /* 96 */ SYSENT_CI("sigsuspend",        sigsuspend,     1),
 920         /* 97 */ SYSENT_CI("sigaltstack",       sigaltstack32,  2),
 921         /* 98 */ SYSENT_CI("sigaction",         sigaction32,    3),
 922         /* 99 */ SYSENT_CI("sigpending",        sigpending,     2),
 923         /* 100 */ SYSENT_CI("getsetcontext",    getsetcontext32, 2),
 924         /* 101 */ SYSENT_CI("fchmodat",         fchmodat,       4),
 925         /* 102 */ SYSENT_CI("mkdirat",          mkdirat,        3),
 926         /* 103 */ SYSENT_CI("statvfs",          statvfs32,      2),
 927         /* 104 */ SYSENT_CI("fstatvfs",         fstatvfs32,     2),
 928         /* 105 */ SYSENT_CI("getloadavg",       getloadavg,     2),
 929         /* 106 */ SYSENT_LOADABLE32(),          /* nfssys */
 930         /* 107 */ SYSENT_CI("waitsys",          waitsys32,      4),
 931         /* 108 */ SYSENT_CI("sigsendset",       sigsendsys,     2),
 932         /* 109 */ IF_x86(
 933                         SYSENT_AP("hrtsys",     hrtsys,         5),
 934                         SYSENT_LOADABLE32()),
 935         /* 110 */ SYSENT_CI("utimesys",         utimesys,       5),
 936         /* 111 */ SYSENT_CI("sigresend",        sigresend,      3),
 937         /* 112 */ SYSENT_CI("priocntlsys",      priocntlsys,    5),
 938         /* 113 */ SYSENT_CI("pathconf",         pathconf,       2),
 939         /* 114 */ SYSENT_CI("mincore",          mincore,        3),
 940         /* 115 */ SYSENT_CI("mmap",             smmap32,        6),
 941         /* 116 */ SYSENT_CI("mprotect",         mprotect,       3),
 942         /* 117 */ SYSENT_CI("munmap",           munmap,         2),
 943         /* 118 */ SYSENT_CI("fpathconf",        fpathconf,      2),
 944         /* 119 */ SYSENT_2CI("vfork",           vfork,          0),
 945         /* 120 */ SYSENT_CI("fchdir",           fchdir,         1),
 946         /* 121 */ SYSENT_CI("readv",            readv32,        3),
 947         /* 122 */ SYSENT_CI("writev",           writev32,       3),
 948         /* 123 */ SYSENT_CI("preadv",           preadv,         5),
 949         /* 124 */ SYSENT_CI("pwritev",          pwritev,        5),
 950         /* 125 */ SYSENT_LOADABLE32(),          /*      was fxstat32    */
 951         /* 126 */ SYSENT_CI("getrandom",        getrandom,      3),
 952         /* 127 */ SYSENT_CI("mmapobj",          mmapobjsys,     5),
 953         /* 128 */ SYSENT_CI("setrlimit",        setrlimit32,    2),
 954         /* 129 */ SYSENT_CI("getrlimit",        getrlimit32,    2),
 955         /* 130 */ SYSENT_CI("lchown",           lchown,         3),
 956         /* 131 */ SYSENT_CI("memcntl",          memcntl,        6),
 957         /* 132 */ SYSENT_CI("getpmsg",          getpmsg32,      5),
 958         /* 133 */ SYSENT_CI("putpmsg",          putpmsg32,      5),
 959         /* 134 */ SYSENT_CI("rename",           rename,         2),
 960         /* 135 */ SYSENT_CI("uname",            uname,          1),
 961         /* 136 */ SYSENT_CI("setegid",          setegid,        1),
 962         /* 137 */ SYSENT_CI("sysconfig",        sysconfig,      1),
 963         /* 138 */ SYSENT_CI("adjtime",          adjtime,        2),
 964         /* 139 */ SYSENT_CI("systeminfo",       systeminfo,     3),
 965         /* 140 */ SYSENT_LOADABLE32(),          /* sharefs */
 966         /* 141 */ SYSENT_CI("seteuid",          seteuid,        1),
 967         /* 142 */ SYSENT_2CI("forksys",         forksys,        2),
 968         /* 143 */ SYSENT_LOADABLE32(),                  /* (was fork1) */
 969         /* 144 */ SYSENT_CI("sigtimedwait",     sigtimedwait,   3),
 970         /* 145 */ SYSENT_CI("lwp_info",         lwp_info,       1),
 971         /* 146 */ SYSENT_CI("yield",            yield,          0),
 972         /* 147 */ SYSENT_LOADABLE32(),              /* (was lwp_sema_wait) */
 973         /* 148 */ SYSENT_CI("lwp_sema_post",    lwp_sema_post,  1),
 974         /* 149 */ SYSENT_CI("lwp_sema_trywait", lwp_sema_trywait, 1),
 975         /* 150 */ SYSENT_CI("lwp_detach",       lwp_detach,     1),
 976         /* 151 */ SYSENT_CI("corectl",          corectl,        4),
 977         /* 152 */ SYSENT_CI("modctl",           modctl,         6),
 978         /* 153 */ SYSENT_CI("fchroot",          fchroot,        1),
 979         /* 154 */ SYSENT_LOADABLE32(),                  /* (was utimes) */
 980         /* 155 */ SYSENT_CI("vhangup",          vhangup,        0),
 981         /* 156 */ SYSENT_CI("gettimeofday",     gettimeofday,   1),
 982         /* 157 */ SYSENT_CI("getitimer",        getitimer,      2),
 983         /* 158 */ SYSENT_CI("setitimer",        setitimer,      3),
 984         /* 159 */ SYSENT_CI("lwp_create",       syslwp_create,  3),
 985         /* 160 */ SYSENT_CI("lwp_exit", (int (*)())syslwp_exit, 0),
 986         /* 161 */ SYSENT_CI("lwp_suspend",      syslwp_suspend, 1),
 987         /* 162 */ SYSENT_CI("lwp_continue",     syslwp_continue, 1),
 988         /* 163 */ SYSENT_CI("lwp_kill",         lwp_kill,       2),
 989         /* 164 */ SYSENT_CI("lwp_self",         lwp_self,       0),
 990         /* 165 */ SYSENT_2CI("lwp_sigmask",     lwp_sigmask,    5),
 991         /* 166 */ IF_x86(
 992                         SYSENT_CI("lwp_private", syslwp_private, 3),
 993                         SYSENT_NOSYS()),
 994         /* 167 */ SYSENT_CI("lwp_wait",         lwp_wait,       2),
 995         /* 168 */ SYSENT_CI("lwp_mutex_wakeup", lwp_mutex_wakeup,       2),
 996         /* 169 */ SYSENT_LOADABLE32(),              /* (was lwp_mutex_lock) */
 997         /* 170 */ SYSENT_CI("lwp_cond_wait",    lwp_cond_wait,          4),
 998         /* 171 */ SYSENT_CI("lwp_cond_signal",  lwp_cond_signal,        1),
 999         /* 172 */ SYSENT_CI("lwp_cond_broadcast", lwp_cond_broadcast,   1),
1000         /* 173 */ SYSENT_CI("pread",            pread32,                4),
1001         /* 174 */ SYSENT_CI("pwrite",           pwrite32,               4),
1002         /* 175 */ SYSENT_C("llseek",            llseek32,       4),
1003         /* 176 */ SYSENT_LOADABLE32(),          /* inst_sync */
1004         /* 177 */ SYSENT_CI("brandsys",         brandsys,       6),
1005         /* 178 */ SYSENT_LOADABLE32(),          /* kaio */
1006         /* 179 */ SYSENT_LOADABLE32(),          /* cpc */
1007         /* 180 */ SYSENT_CI("lgrpsys",          lgrpsys,        3),
1008         /* 181 */ SYSENT_CI("rusagesys",        rusagesys,      5),
1009         /* 182 */ SYSENT_LOADABLE32(),          /* portfs */
1010         /* 183 */ SYSENT_CI("pollsys",          pollsys,        4),
1011         /* 184 */ SYSENT_CI("labelsys",         labelsys,       5),
1012         /* 185 */ SYSENT_CI("acl",              acl,            4),
1013         /* 186 */ SYSENT_AP("auditsys",         auditsys,       6),
1014         /* 187 */ SYSENT_CI("processor_bind",   processor_bind, 4),
1015         /* 188 */ SYSENT_CI("processor_info",   processor_info, 2),
1016         /* 189 */ SYSENT_CI("p_online",         p_online,       2),
1017         /* 190 */ SYSENT_CI("sigqueue",         sigqueue32,     5),
1018         /* 191 */ SYSENT_CI("clock_gettime",    clock_gettime,  2),
1019         /* 192 */ SYSENT_CI("clock_settime",    clock_settime,  2),
1020         /* 193 */ SYSENT_CI("clock_getres",     clock_getres,   2),
1021         /* 194 */ SYSENT_CI("timer_create",     timer_create,   3),
1022         /* 195 */ SYSENT_CI("timer_delete",     timer_delete,   1),
1023         /* 196 */ SYSENT_CI("timer_settime",    timer_settime,  4),
1024         /* 197 */ SYSENT_CI("timer_gettime",    timer_gettime,  2),
1025         /* 198 */ SYSENT_CI("timer_getoverrun", timer_getoverrun, 1),
1026         /* 199 */ SYSENT_CI("nanosleep",        nanosleep,      2),
1027         /* 200 */ SYSENT_CI("facl",             facl,           4),
1028         /* 201 */ SYSENT_LOADABLE32(),          /* door */
1029         /* 202 */ SYSENT_CI("setreuid",         setreuid,       2),
1030         /* 203 */ SYSENT_CI("setregid",         setregid,       2),
1031         /* 204 */ SYSENT_CI("install_utrap",    install_utrap,  3),
1032         /* 205 */ SYSENT_CI("signotify",        signotify,      3),
1033         /* 206 */ SYSENT_CI("schedctl",         schedctl,       0),
1034         /* 207 */ SYSENT_LOADABLE32(),          /* pset */
1035         /* 208 */ SYSENT_LOADABLE32(),
1036         /* 209 */ SYSENT_CI("resolvepath",      resolvepath,    3),
1037         /* 210 */ SYSENT_CI("lwp_mutex_timedlock", lwp_mutex_timedlock, 3),
1038         /* 211 */ SYSENT_CI("lwp_sema_timedwait", lwp_sema_timedwait,   3),
1039         /* 212 */ SYSENT_CI("lwp_rwlock_sys",   lwp_rwlock_sys, 3),
1040         /*
1041          * Syscalls 213-225: 32-bit system call support for large files.
1042          */
1043         /* 213 */ SYSENT_CI("getdents64",       getdents64,     3),
1044         /* 214 */ SYSENT_AP("smmaplf32",        smmaplf32,      7),
1045         /* 215 */ SYSENT_CI("stat64",           stat64_32,      2),
1046         /* 216 */ SYSENT_CI("lstat64",          lstat64_32,     2),
1047         /* 217 */ SYSENT_CI("fstat64",          fstat64_32,     2),
1048         /* 218 */ SYSENT_CI("statvfs64",        statvfs64_32,   2),
1049         /* 219 */ SYSENT_CI("fstatvfs64",       fstatvfs64_32,  2),
1050         /* 220 */ SYSENT_CI("setrlimit64",      setrlimit64,    2),
1051         /* 221 */ SYSENT_CI("getrlimit64",      getrlimit64,    2),
1052         /* 222 */ SYSENT_CI("pread64",          pread64,        5),
1053         /* 223 */ SYSENT_CI("pwrite64",         pwrite64,       5),
1054         /* 224 */ SYSENT_LOADABLE32(),                  /* (was creat64) */
1055         /* 225 */ SYSENT_CI("open64",           open64,         3),
1056         /* 226 */ SYSENT_LOADABLE32(),          /* rpcsys */
1057         /* 227 */ SYSENT_CI("zone",             zone,           6),
1058         /* 228 */ SYSENT_LOADABLE32(),          /* autofssys */
1059         /* 229 */ SYSENT_CI("getcwd",           getcwd,         2),
1060         /* 230 */ SYSENT_CI("so_socket",        so_socket,      5),
1061         /* 231 */ SYSENT_CI("so_socketpair",    so_socketpair,  1),
1062         /* 232 */ SYSENT_CI("bind",             bind,           4),
1063         /* 233 */ SYSENT_CI("listen",           listen,         3),
1064         /* 234 */ SYSENT_CI("accept",           accept,         5),
1065         /* 235 */ SYSENT_CI("connect",          connect,        4),
1066         /* 236 */ SYSENT_CI("shutdown",         shutdown,       3),
1067         /* 237 */ SYSENT_CI("recv",             recv32,         4),
1068         /* 238 */ SYSENT_CI("recvfrom",         recvfrom32,     6),
1069         /* 239 */ SYSENT_CI("recvmsg",          recvmsg,        3),
1070         /* 240 */ SYSENT_CI("send",             send32,         4),
1071         /* 241 */ SYSENT_CI("sendmsg",          sendmsg,        3),
1072         /* 242 */ SYSENT_CI("sendto",           sendto32,       6),
1073         /* 243 */ SYSENT_CI("getpeername",      getpeername,    4),
1074         /* 244 */ SYSENT_CI("getsockname",      getsockname,    4),
1075         /* 245 */ SYSENT_CI("getsockopt",       getsockopt,     6),
1076         /* 246 */ SYSENT_CI("setsockopt",       setsockopt,     6),
1077         /* 247 */ SYSENT_CI("sockconfig",       sockconfig,     5),
1078         /* 248 */ SYSENT_CI("ntp_gettime",      ntp_gettime,    1),
1079         /* 249 */ SYSENT_CI("ntp_adjtime",      ntp_adjtime,    1),
1080         /* 250 */ SYSENT_CI("lwp_mutex_unlock", lwp_mutex_unlock,       1),
1081         /* 251 */ SYSENT_CI("lwp_mutex_trylock", lwp_mutex_trylock,     2),
1082         /* 252 */ SYSENT_CI("lwp_mutex_register", lwp_mutex_register,   2),
1083         /* 253 */ SYSENT_CI("cladm",            cladm,          3),
1084         /* 254 */ SYSENT_CI("uucopy",           uucopy,         3),
1085         /* 255 */ SYSENT_CI("umount2",          umount2,        2)
1086 };
1087 #endif /* _SYSCALL32_IMPL */
1088 
1089 /*
1090  * Space allocated and initialized in init_syscallnames().
1091  */
1092 char **syscallnames;
1093 
1094 systrace_sysent_t *systrace_sysent;
1095 void (*systrace_probe)(dtrace_id_t, uintptr_t, uintptr_t,
1096     uintptr_t, uintptr_t, uintptr_t, uintptr_t);
1097 
1098 /*ARGSUSED*/
1099 void
1100 systrace_stub(dtrace_id_t id, uintptr_t arg0, uintptr_t arg1,
1101     uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5)
1102 {}
1103 
1104 /*ARGSUSED*/
1105 int64_t
1106 dtrace_systrace_syscall(uintptr_t arg0, uintptr_t arg1, uintptr_t arg2,
1107     uintptr_t arg3, uintptr_t arg4, uintptr_t arg5)
1108 {
1109         systrace_sysent_t *sy = &systrace_sysent[curthread->t_sysnum];
1110         dtrace_id_t id;
1111         int64_t rval;
1112         proc_t *p;
1113 
1114         if ((id = sy->stsy_entry) != DTRACE_IDNONE)
1115                 (*systrace_probe)(id, arg0, arg1, arg2, arg3, arg4, arg5);
1116 
1117         /*
1118          * We want to explicitly allow DTrace consumers to stop a process
1119          * before it actually executes the meat of the syscall.
1120          */
1121         p = ttoproc(curthread);
1122         mutex_enter(&p->p_lock);
1123         if (curthread->t_dtrace_stop && !curthread->t_lwp->lwp_nostop) {
1124                 curthread->t_dtrace_stop = 0;
1125                 stop(PR_REQUESTED, 0);
1126         }
1127         mutex_exit(&p->p_lock);
1128 
1129         rval = (*sy->stsy_underlying)(arg0, arg1, arg2, arg3, arg4, arg5);
1130 
1131         if (ttolwp(curthread)->lwp_errno != 0)
1132                 rval = -1;
1133 
1134         if ((id = sy->stsy_return) != DTRACE_IDNONE)
1135                 (*systrace_probe)(id, (uintptr_t)rval, (uintptr_t)rval,
1136                     (uintptr_t)((int64_t)rval >> 32), 0, 0, 0);
1137 
1138         return (rval);
1139 }
1140 
1141 #ifdef _SYSCALL32_IMPL
1142 
1143 systrace_sysent_t *systrace_sysent32;
1144 
1145 /*ARGSUSED*/
1146 int64_t
1147 dtrace_systrace_syscall32(uintptr_t arg0, uintptr_t arg1, uintptr_t arg2,
1148     uintptr_t arg3, uintptr_t arg4, uintptr_t arg5)
1149 {
1150         systrace_sysent_t *sy = &systrace_sysent32[curthread->t_sysnum];
1151         dtrace_id_t id;
1152         int64_t rval;
1153         proc_t *p;
1154 
1155         if ((id = sy->stsy_entry) != DTRACE_IDNONE)
1156                 (*systrace_probe)(id, arg0, arg1, arg2, arg3, arg4, arg5);
1157 
1158         /*
1159          * We want to explicitly allow DTrace consumers to stop a process
1160          * before it actually executes the meat of the syscall.
1161          */
1162         p = ttoproc(curthread);
1163         mutex_enter(&p->p_lock);
1164         if (curthread->t_dtrace_stop && !curthread->t_lwp->lwp_nostop) {
1165                 curthread->t_dtrace_stop = 0;
1166                 stop(PR_REQUESTED, 0);
1167         }
1168         mutex_exit(&p->p_lock);
1169 
1170         rval = (*sy->stsy_underlying)(arg0, arg1, arg2, arg3, arg4, arg5);
1171 
1172         if (ttolwp(curthread)->lwp_errno != 0)
1173                 rval = -1;
1174 
1175         if ((id = sy->stsy_return) != DTRACE_IDNONE)
1176                 (*systrace_probe)(id, (uintptr_t)rval, (uintptr_t)rval,
1177                     (uintptr_t)((uint64_t)rval >> 32), 0, 0, 0);
1178 
1179         return (rval);
1180 }
1181 
1182 #endif
1183 
1184 void
1185 dtrace_systrace_rtt(void)
1186 {
1187         systrace_sysent_t *sy;
1188         dtrace_id_t id;
1189 
1190         if (get_udatamodel() == DATAMODEL_NATIVE) {
1191                 if (systrace_sysent == NULL)
1192                         return;
1193 
1194                 sy = &systrace_sysent[curthread->t_sysnum];
1195 #ifdef _SYSCALL32_IMPL
1196         } else {
1197                 if (systrace_sysent32 == NULL)
1198                         return;
1199 
1200                 sy = &systrace_sysent32[curthread->t_sysnum];
1201 #endif
1202         }
1203 
1204         if ((id = sy->stsy_return) != DTRACE_IDNONE)
1205                 (*systrace_probe)(id, 0, 0, 0, 0, 0, 0);
1206 }