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