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