blob: 9d84021520cdf33ac44412d90be2e2cbab619dfe [file] [log] [blame]
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001/*
2 * Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl>
3 * Copyright (c) 1993 Branko Lankester <branko@hacktic.nl>
4 * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com>
Wichert Akkerman4dc8a2a1999-12-23 14:20:14 +00005 * Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl>
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00006 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. The name of the author may not be used to endorse or promote products
17 * derived from this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 *
30 * $Id$
31 */
32
33#include "defs.h"
34
35#ifdef LINUX
36#define _LINUX_SOCKET_H
Wichert Akkerman14cd9f01999-07-09 18:56:34 +000037#define _LINUX_FS_H
Wichert Akkerman76baf7c1999-02-19 00:21:36 +000038
Roland McGrathcbd33582005-02-02 04:36:11 +000039#define MS_RDONLY 1 /* Mount read-only */
40#define MS_NOSUID 2 /* Ignore suid and sgid bits */
41#define MS_NODEV 4 /* Disallow access to device special files */
42#define MS_NOEXEC 8 /* Disallow program execution */
43#define MS_SYNCHRONOUS 16 /* Writes are synced at once */
44#define MS_REMOUNT 32 /* Alter flags of a mounted FS */
45#define MS_MANDLOCK 64 /* Allow mandatory locks on an FS */
46#define MS_DIRSYNC 128 /* Directory modifications are synchronous */
47#define MS_NOATIME 1024 /* Do not update access times. */
48#define MS_NODIRATIME 2048 /* Do not update directory access times */
49#define MS_BIND 4096
50#define MS_MOVE 8192
51#define MS_REC 16384
52#define MS_VERBOSE 32768
53#define MS_POSIXACL (1<<16) /* VFS does not apply the umask */
54#define MS_ACTIVE (1<<30)
55#define MS_NOUSER (1<<31)
Wichert Akkerman76baf7c1999-02-19 00:21:36 +000056
57#include <sys/socket.h>
58#include <netinet/in.h>
59#include <arpa/inet.h>
60
Nate Sammons8d5860c1999-07-03 18:53:05 +000061#include <sys/syscall.h>
62
Nate Sammons8d5860c1999-07-03 18:53:05 +000063#ifdef SYS_capget
Wichert Akkerman76baf7c1999-02-19 00:21:36 +000064#include <linux/capability.h>
65#endif
66
Nate Sammons8d5860c1999-07-03 18:53:05 +000067#ifdef SYS_cacheflush
Wichert Akkerman2e2553a1999-05-09 00:29:58 +000068#include <asm/cachectl.h>
69#endif
70
Wichert Akkermand6b92492001-04-07 21:37:12 +000071#ifdef HAVE_LINUX_USTNAME_H
72#include <linux/utsname.h>
73#endif
74
Michal Ludvig39c0e942002-11-06 14:00:12 +000075#ifdef MIPS
Wichert Akkermand6b92492001-04-07 21:37:12 +000076#include <asm/sysmips.h>
77#endif
78
Wichert Akkerman22fe9d21999-05-27 12:00:57 +000079#include <linux/sysctl.h>
Wichert Akkerman22fe9d21999-05-27 12:00:57 +000080
Roland McGrathd9f816f2004-09-04 03:39:20 +000081static const struct xlat mount_flags[] = {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +000082 { MS_RDONLY, "MS_RDONLY" },
83 { MS_NOSUID, "MS_NOSUID" },
84 { MS_NODEV, "MS_NODEV" },
85 { MS_NOEXEC, "MS_NOEXEC" },
Wichert Akkerman76baf7c1999-02-19 00:21:36 +000086 { MS_SYNCHRONOUS,"MS_SYNCHRONOUS"},
Wichert Akkerman76baf7c1999-02-19 00:21:36 +000087 { MS_REMOUNT, "MS_REMOUNT" },
Roland McGrathcbd33582005-02-02 04:36:11 +000088 { MS_MANDLOCK, "MS_MANDLOCK" },
89 { MS_NOATIME, "MS_NOATIME" },
90 { MS_NODIRATIME,"MS_NODIRATIME" },
91 { MS_BIND, "MS_BIND" },
92 { MS_MOVE, "MS_MOVE" },
93 { MS_REC, "MS_REC" },
94 { MS_VERBOSE, "MS_VERBOSE" },
95 { MS_POSIXACL, "MS_POSIXACL" },
96 { MS_ACTIVE, "MS_ACTIVE" },
97 { MS_NOUSER, "MS_NOUSER" },
Wichert Akkerman76baf7c1999-02-19 00:21:36 +000098 { 0, NULL },
99};
100
101int
102sys_mount(tcp)
103struct tcb *tcp;
104{
105 if (entering(tcp)) {
106 printpath(tcp, tcp->u_arg[0]);
107 tprintf(", ");
108 printpath(tcp, tcp->u_arg[1]);
109 tprintf(", ");
Roland McGrathcbd33582005-02-02 04:36:11 +0000110 if ((tcp->u_arg[3] & (MS_BIND|MS_MOVE|MS_REMOUNT)) == 0)
111 printpath(tcp, tcp->u_arg[2]);
112 else
113 tprintf("%#lx", tcp->u_arg[2]);
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000114 tprintf(", ");
Roland McGrathb2dee132005-06-01 19:02:36 +0000115 printflags(mount_flags, tcp->u_arg[3], "MS_???");
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000116 tprintf(", %#lx", tcp->u_arg[4]);
117 }
118 return 0;
119}
120
Wichert Akkermandacfb6e1999-06-03 14:21:07 +0000121int
122sys_umount2(tcp)
123struct tcb *tcp;
124{
125 if (entering(tcp)) {
126 printstr(tcp, tcp->u_arg[0], -1);
127 tprintf(", ");
128 if (tcp->u_arg[1] & 1)
129 tprintf("MNT_FORCE");
130 else
131 tprintf("0");
132 }
133 return 0;
134}
135
Roland McGrathced50da2004-08-31 06:48:46 +0000136/* These are not macros, but enums. We just copy the values by hand
137 from Linux 2.6.9 here. */
Roland McGrathd9f816f2004-09-04 03:39:20 +0000138static const struct xlat personality_options[] = {
Roland McGrathced50da2004-08-31 06:48:46 +0000139 { 0, "PER_LINUX" },
140 { 0x00800000, "PER_LINUX_32BIT"},
141 { 0x04100001, "PER_SVR4" },
142 { 0x05000002, "PER_SVR3" },
143 { 0x07000003, "PER_SCOSVR3" },
144 { 0x06000003, "PER_OSR5" },
145 { 0x05000004, "PER_WYSEV386" },
146 { 0x04000005, "PER_ISCR4" },
147 { 0x00000006, "PER_BSD" },
148 { 0x04000006, "PER_SUNOS" },
149 { 0x05000007, "PER_XENIX" },
150 { 0x00000008, "PER_LINUX32" },
151 { 0x08000008, "PER_LINUX32_3GB"},
152 { 0x04000009, "PER_IRIX32" },
153 { 0x0400000a, "PER_IRIXN32" },
154 { 0x0400000b, "PER_IRIX64" },
155 { 0x0000000c, "PER_RISCOS" },
156 { 0x0400000d, "PER_SOLARIS" },
157 { 0x0410000e, "PER_UW7" },
158 { 0x0000000f, "PER_OSF4" },
159 { 0x00000010, "PER_HPUX" },
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000160 { 0, NULL },
161};
162
163int
164sys_personality(tcp)
165struct tcb *tcp;
166{
167 if (entering(tcp))
168 printxval(personality_options, tcp->u_arg[0], "PER_???");
169 return 0;
170}
171
Wichert Akkerman5ae21ea2000-05-01 01:53:59 +0000172#include <linux/reboot.h>
Roland McGrathd9f816f2004-09-04 03:39:20 +0000173static const struct xlat bootflags1[] = {
Wichert Akkerman5ae21ea2000-05-01 01:53:59 +0000174 { LINUX_REBOOT_MAGIC1, "LINUX_REBOOT_MAGIC1" },
175 { 0, NULL },
176};
177
Roland McGrathd9f816f2004-09-04 03:39:20 +0000178static const struct xlat bootflags2[] = {
Wichert Akkerman5ae21ea2000-05-01 01:53:59 +0000179 { LINUX_REBOOT_MAGIC2, "LINUX_REBOOT_MAGIC2" },
180 { LINUX_REBOOT_MAGIC2A, "LINUX_REBOOT_MAGIC2A" },
181 { LINUX_REBOOT_MAGIC2B, "LINUX_REBOOT_MAGIC2B" },
182 { 0, NULL },
183};
184
Roland McGrathd9f816f2004-09-04 03:39:20 +0000185static const struct xlat bootflags3[] = {
Wichert Akkerman5ae21ea2000-05-01 01:53:59 +0000186 { LINUX_REBOOT_CMD_CAD_OFF, "LINUX_REBOOT_CMD_CAD_OFF" },
187 { LINUX_REBOOT_CMD_RESTART, "LINUX_REBOOT_CMD_RESTART" },
188 { LINUX_REBOOT_CMD_HALT, "LINUX_REBOOT_CMD_HALT" },
189 { LINUX_REBOOT_CMD_CAD_ON, "LINUX_REBOOT_CMD_CAD_ON" },
190 { LINUX_REBOOT_CMD_POWER_OFF, "LINUX_REBOOT_CMD_POWER_OFF" },
191 { LINUX_REBOOT_CMD_RESTART2, "LINUX_REBOOT_CMD_RESTART2" },
192 { 0, NULL },
193};
194
195int
196sys_reboot(tcp)
197struct tcb *tcp;
198{
199 if (entering(tcp)) {
Roland McGrathb2dee132005-06-01 19:02:36 +0000200 printflags(bootflags1, tcp->u_arg[0], "LINUX_REBOOT_MAGIC_???");
Wichert Akkerman5ae21ea2000-05-01 01:53:59 +0000201 tprintf(", ");
Roland McGrathb2dee132005-06-01 19:02:36 +0000202 printflags(bootflags2, tcp->u_arg[1], "LINUX_REBOOT_MAGIC_???");
Wichert Akkerman5ae21ea2000-05-01 01:53:59 +0000203 tprintf(", ");
Roland McGrathb2dee132005-06-01 19:02:36 +0000204 printflags(bootflags3, tcp->u_arg[2], "LINUX_REBOOT_CMD_???");
Wichert Akkerman5ae21ea2000-05-01 01:53:59 +0000205 if (tcp->u_arg[2] == LINUX_REBOOT_CMD_RESTART2) {
206 tprintf(", ");
207 printstr(tcp, tcp->u_arg[3], -1);
208 }
209 }
210 return 0;
211}
212
Wichert Akkerman2e2553a1999-05-09 00:29:58 +0000213#ifdef M68K
Roland McGrathd9f816f2004-09-04 03:39:20 +0000214static const struct xlat cacheflush_scope[] = {
Wichert Akkerman2e2553a1999-05-09 00:29:58 +0000215#ifdef FLUSH_SCOPE_LINE
216 { FLUSH_SCOPE_LINE, "FLUSH_SCOPE_LINE" },
217#endif
218#ifdef FLUSH_SCOPE_PAGE
219 { FLUSH_SCOPE_PAGE, "FLUSH_SCOPE_PAGE" },
220#endif
221#ifdef FLUSH_SCOPE_ALL
222 { FLUSH_SCOPE_ALL, "FLUSH_SCOPE_ALL" },
223#endif
224 { 0, NULL },
225};
226
Roland McGrathd9f816f2004-09-04 03:39:20 +0000227static const struct xlat cacheflush_flags[] = {
Wichert Akkerman2e2553a1999-05-09 00:29:58 +0000228#ifdef FLUSH_CACHE_BOTH
229 { FLUSH_CACHE_BOTH, "FLUSH_CACHE_BOTH" },
230#endif
231#ifdef FLUSH_CACHE_DATA
232 { FLUSH_CACHE_DATA, "FLUSH_CACHE_DATA" },
233#endif
234#ifdef FLUSH_CACHE_INSN
235 { FLUSH_CACHE_INSN, "FLUSH_CACHE_INSN" },
236#endif
237 { 0, NULL },
238};
239
240int
241sys_cacheflush(tcp)
242struct tcb *tcp;
243{
244 if (entering(tcp)) {
245 /* addr */
246 tprintf("%#lx, ", tcp->u_arg[0]);
247 /* scope */
248 printxval(cacheflush_scope, tcp->u_arg[1], "FLUSH_SCOPE_???");
249 tprintf(", ");
250 /* flags */
Roland McGrathb2dee132005-06-01 19:02:36 +0000251 printflags(cacheflush_flags, tcp->u_arg[2], "FLUSH_CACHE_???");
Wichert Akkerman2e2553a1999-05-09 00:29:58 +0000252 /* len */
253 tprintf(", %lu", tcp->u_arg[3]);
254 }
255 return 0;
256}
257#endif /* M68K */
258
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000259#endif /* LINUX */
260
261#ifdef SUNOS4
262
263#include <sys/reboot.h>
264#define NFSCLIENT
265#define LOFS
266#define RFS
267#define PCFS
268#include <sys/mount.h>
269#include <sys/socket.h>
270#include <nfs/export.h>
271#include <rpc/types.h>
272#include <rpc/auth.h>
273
274/*ARGSUSED*/
275int
276sys_sync(tcp)
277struct tcb *tcp;
278{
279 return 0;
280}
281
Roland McGrathd9f816f2004-09-04 03:39:20 +0000282static const struct xlat bootflags[] = {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000283 { RB_AUTOBOOT, "RB_AUTOBOOT" }, /* for system auto-booting itself */
284 { RB_ASKNAME, "RB_ASKNAME" }, /* ask for file name to reboot from */
285 { RB_SINGLE, "RB_SINGLE" }, /* reboot to single user only */
286 { RB_NOSYNC, "RB_NOSYNC" }, /* dont sync before reboot */
287 { RB_HALT, "RB_HALT" }, /* don't reboot, just halt */
288 { RB_INITNAME, "RB_INITNAME" }, /* name given for /etc/init */
289 { RB_NOBOOTRC, "RB_NOBOOTRC" }, /* don't run /etc/rc.boot */
290 { RB_DEBUG, "RB_DEBUG" }, /* being run under debugger */
291 { RB_DUMP, "RB_DUMP" }, /* dump system core */
292 { RB_WRITABLE, "RB_WRITABLE" }, /* mount root read/write */
293 { RB_STRING, "RB_STRING" }, /* pass boot args to prom monitor */
294 { 0, NULL },
295};
296
297int
298sys_reboot(tcp)
299struct tcb *tcp;
300{
301 if (entering(tcp)) {
Roland McGrathb2dee132005-06-01 19:02:36 +0000302 printflags(bootflags, tcp->u_arg[0], "RB_???");
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000303 if (tcp->u_arg[0] & RB_STRING) {
304 printstr(tcp, tcp->u_arg[1], -1);
305 }
306 }
307 return 0;
308}
309
310int
311sys_sysacct(tcp)
312struct tcb *tcp;
313{
314 if (entering(tcp)) {
315 printstr(tcp, tcp->u_arg[0], -1);
316 }
317 return 0;
318}
319
320int
321sys_swapon(tcp)
322struct tcb *tcp;
323{
324 if (entering(tcp)) {
325 printstr(tcp, tcp->u_arg[0], -1);
326 }
327 return 0;
328}
329
330int
331sys_nfs_svc(tcp)
332struct tcb *tcp;
333{
334 if (entering(tcp)) {
335 printsock(tcp, tcp->u_arg[0]);
336 }
337 return 0;
338}
339
Roland McGrathd9f816f2004-09-04 03:39:20 +0000340static const struct xlat mountflags[] = {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000341 { M_RDONLY, "M_RDONLY" },
342 { M_NOSUID, "M_NOSUID" },
343 { M_NEWTYPE, "M_NEWTYPE" },
344 { M_GRPID, "M_GRPID" },
345#ifdef M_REMOUNT
346 { M_REMOUNT, "M_REMOUNT" },
347#endif
348#ifdef M_NOSUB
349 { M_NOSUB, "M_NOSUB" },
350#endif
351#ifdef M_MULTI
352 { M_MULTI, "M_MULTI" },
353#endif
354#ifdef M_SYS5
355 { M_SYS5, "M_SYS5" },
356#endif
357 { 0, NULL },
358};
359
Roland McGrathd9f816f2004-09-04 03:39:20 +0000360static const struct xlat nfsflags[] = {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000361 { NFSMNT_SOFT, "NFSMNT_SOFT" },
362 { NFSMNT_WSIZE, "NFSMNT_WSIZE" },
363 { NFSMNT_RSIZE, "NFSMNT_RSIZE" },
364 { NFSMNT_TIMEO, "NFSMNT_TIMEO" },
365 { NFSMNT_RETRANS, "NFSMNT_RETRANS" },
366 { NFSMNT_HOSTNAME, "NFSMNT_HOSTNAME" },
367 { NFSMNT_INT, "NFSMNT_INT" },
368 { NFSMNT_NOAC, "NFSMNT_NOAC" },
369 { NFSMNT_ACREGMIN, "NFSMNT_ACREGMIN" },
370 { NFSMNT_ACREGMAX, "NFSMNT_ACREGMAX" },
371 { NFSMNT_ACDIRMIN, "NFSMNT_ACDIRMIN" },
372 { NFSMNT_ACDIRMAX, "NFSMNT_ACDIRMAX" },
373#ifdef NFSMNT_SECURE
374 { NFSMNT_SECURE, "NFSMNT_SECURE" },
375#endif
376#ifdef NFSMNT_NOCTO
377 { NFSMNT_NOCTO, "NFSMNT_NOCTO" },
378#endif
379#ifdef NFSMNT_POSIX
380 { NFSMNT_POSIX, "NFSMNT_POSIX" },
381#endif
382 { 0, NULL },
383};
384
385int
386sys_mount(tcp)
387struct tcb *tcp;
388{
389 char type[4];
390
391 if (entering(tcp)) {
392 if (!(tcp->u_arg[2] & M_NEWTYPE) || umovestr(tcp,
393 tcp->u_arg[0], sizeof type, type) < 0) {
394 tprintf("OLDTYPE:#%lx", tcp->u_arg[0]);
395 } else {
396 tprintf("\"%s\", ", type);
397 }
398 printstr(tcp, tcp->u_arg[1], -1);
399 tprintf(", ");
Roland McGrathb2dee132005-06-01 19:02:36 +0000400 printflags(mountflags, tcp->u_arg[2] & ~M_NEWTYPE, "M_???");
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000401 tprintf(", ");
402
403 if (strcmp(type, "4.2") == 0) {
404 struct ufs_args a;
405 if (umove(tcp, tcp->u_arg[3], &a) < 0)
406 return 0;
407 printstr(tcp, (int)a.fspec, -1);
408 } else if (strcmp(type, "lo") == 0) {
409 struct lo_args a;
410 if (umove(tcp, tcp->u_arg[3], &a) < 0)
411 return 0;
412 printstr(tcp, (int)a.fsdir, -1);
413 } else if (strcmp(type, "nfs") == 0) {
414 struct nfs_args a;
415 if (umove(tcp, tcp->u_arg[3], &a) < 0)
416 return 0;
417 tprintf("[");
418 printsock(tcp, (int) a.addr);
419 tprintf(", ");
Roland McGrathb2dee132005-06-01 19:02:36 +0000420 printflags(nfsflags, a.flags, "NFSMNT_???");
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000421 tprintf(", ws:%u,rs:%u,to:%u,re:%u,",
422 a.wsize, a.rsize, a.timeo, a.retrans);
423 if (a.flags & NFSMNT_HOSTNAME && a.hostname)
424 printstr(tcp, (int)a.hostname, -1);
425 else
426 tprintf("%#lx", (unsigned long) a.hostname);
427 tprintf(",reg-min:%u,max:%u,dir-min:%u,max:%u,",
428 a.acregmin, a.acregmax, a.acdirmin, a.acdirmax);
429 if ((a.flags & NFSMNT_SECURE) && a.netname)
430 printstr(tcp, (int) a.netname, -1);
431 else
432 tprintf("%#lx", (unsigned long) a.netname);
433 tprintf("]");
434 } else if (strcmp(type, "rfs") == 0) {
435 struct rfs_args a;
436 struct token t;
437 if (umove(tcp, tcp->u_arg[3], &a) < 0)
438 return 0;
439 tprintf("[");
440 printstr(tcp, (int)a.rmtfs, -1);
441 if (umove(tcp, (int)a.token, &t) < 0)
442 return 0;
443 tprintf(", %u, %s]", t.t_id, t.t_uname);
444 } else if (strcmp(type, "pcfs") == 0) {
445 struct pc_args a;
446 if (umove(tcp, tcp->u_arg[3], &a) < 0)
447 return 0;
448 printstr(tcp, (int)a.fspec, -1);
449 }
450 }
451 return 0;
452}
453
454int
455sys_unmount(tcp)
456struct tcb *tcp;
457{
458 if (entering(tcp)) {
459 printstr(tcp, tcp->u_arg[0], -1);
460 }
461 return 0;
462}
463
464int
465sys_umount(tcp)
466struct tcb *tcp;
467{
468 return sys_unmount(tcp);
469}
470
471int
472sys_auditsys(tcp)
473struct tcb *tcp;
474{
475 /* XXX - no information available */
476 return printargs(tcp);
477}
478
Roland McGrathd9f816f2004-09-04 03:39:20 +0000479static const struct xlat ex_auth_flags[] = {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000480 { AUTH_UNIX, "AUTH_UNIX" },
481 { AUTH_DES, "AUTH_DES" },
482 { 0, NULL },
483};
484
485int
486sys_exportfs(tcp)
487struct tcb *tcp;
488{
489 struct export e;
490 int i;
491
492 if (entering(tcp)) {
493 printstr(tcp, tcp->u_arg[0], -1);
494 if (umove(tcp, tcp->u_arg[1], &e) < 0) {
495 tprintf("%#lx", tcp->u_arg[1]);
496 return 0;
497 }
498 tprintf("{fl:%u, anon:%u, ", e.ex_flags, e.ex_anon);
499 printxval(ex_auth_flags, e.ex_auth, "AUTH_???");
500 tprintf(", roots:[");
501 if (e.ex_auth == AUTH_UNIX) {
502 for (i=0; i<e.ex_u.exunix.rootaddrs.naddrs; i++) {
503 printsock(tcp,
504 (int)&e.ex_u.exunix.rootaddrs.addrvec[i]);
505 }
506 tprintf("], writers:[");
507 for (i=0; i<e.ex_writeaddrs.naddrs; i++) {
508 printsock(tcp,
509 (int)&e.ex_writeaddrs.addrvec[i]);
510 }
511 tprintf("]");
512 } else {
513 for (i=0; i<e.ex_u.exdes.nnames; i++) {
514 printsock(tcp,
515 (int)&e.ex_u.exdes.rootnames[i]);
516 tprintf(", ");
517 }
518 tprintf("], window:%u", e.ex_u.exdes.window);
519 }
520 tprintf("}");
521 }
522 return 0;
523}
524
Roland McGrathd9f816f2004-09-04 03:39:20 +0000525static const struct xlat sysconflimits[] = {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000526#ifdef _SC_ARG_MAX
527 { _SC_ARG_MAX, "_SC_ARG_MAX" }, /* space for argv & envp */
528#endif
529#ifdef _SC_CHILD_MAX
530 { _SC_CHILD_MAX, "_SC_CHILD_MAX" }, /* maximum children per process??? */
531#endif
532#ifdef _SC_CLK_TCK
533 { _SC_CLK_TCK, "_SC_CLK_TCK" }, /* clock ticks/sec */
534#endif
535#ifdef _SC_NGROUPS_MAX
536 { _SC_NGROUPS_MAX, "_SC_NGROUPS_MAX" }, /* number of groups if multple supp. */
537#endif
538#ifdef _SC_OPEN_MAX
539 { _SC_OPEN_MAX, "_SC_OPEN_MAX" }, /* max open files per process */
540#endif
541#ifdef _SC_JOB_CONTROL
542 { _SC_JOB_CONTROL, "_SC_JOB_CONTROL" }, /* do we have job control */
543#endif
544#ifdef _SC_SAVED_IDS
545 { _SC_SAVED_IDS, "_SC_SAVED_IDS" }, /* do we have saved uid/gids */
546#endif
547#ifdef _SC_VERSION
548 { _SC_VERSION, "_SC_VERSION" }, /* POSIX version supported */
549#endif
550 { 0, NULL },
551};
552
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +0000553int
554sys_sysconf(tcp)
555struct tcb *tcp;
556{
557 if (entering(tcp)) {
558 printxval(sysconflimits, tcp->u_arg[0], "_SC_???");
559 }
560 return 0;
561}
562
563#endif /* SUNOS4 */
564
565#if defined(SUNOS4) || defined(FREEBSD)
Roland McGrathd9f816f2004-09-04 03:39:20 +0000566static const struct xlat pathconflimits[] = {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000567#ifdef _PC_LINK_MAX
568 { _PC_LINK_MAX, "_PC_LINK_MAX" }, /* max links to file/dir */
569#endif
570#ifdef _PC_MAX_CANON
571 { _PC_MAX_CANON, "_PC_MAX_CANON" }, /* max line length */
572#endif
573#ifdef _PC_MAX_INPUT
574 { _PC_MAX_INPUT, "_PC_MAX_INPUT" }, /* max "packet" to a tty device */
575#endif
576#ifdef _PC_NAME_MAX
577 { _PC_NAME_MAX, "_PC_NAME_MAX" }, /* max pathname component length */
578#endif
579#ifdef _PC_PATH_MAX
580 { _PC_PATH_MAX, "_PC_PATH_MAX" }, /* max pathname length */
581#endif
582#ifdef _PC_PIPE_BUF
583 { _PC_PIPE_BUF, "_PC_PIPE_BUF" }, /* size of a pipe */
584#endif
585#ifdef _PC_CHOWN_RESTRICTED
586 { _PC_CHOWN_RESTRICTED, "_PC_CHOWN_RESTRICTED" }, /* can we give away files */
587#endif
588#ifdef _PC_NO_TRUNC
589 { _PC_NO_TRUNC, "_PC_NO_TRUNC" }, /* trunc or error on >NAME_MAX */
590#endif
591#ifdef _PC_VDISABLE
592 { _PC_VDISABLE, "_PC_VDISABLE" }, /* best char to shut off tty c_cc */
593#endif
594 { 0, NULL },
595};
596
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000597
598int
599sys_pathconf(tcp)
600struct tcb *tcp;
601{
602 if (entering(tcp)) {
603 printstr(tcp, tcp->u_arg[0], -1);
604 tprintf(", ");
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +0000605 printxval(pathconflimits, tcp->u_arg[1], "_PC_???");
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000606 }
607 return 0;
608}
609
610int
611sys_fpathconf(tcp)
612struct tcb *tcp;
613{
614 if (entering(tcp)) {
615 tprintf("%lu, ", tcp->u_arg[0]);
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +0000616 printxval(pathconflimits, tcp->u_arg[1], "_PC_???");
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000617 }
618 return 0;
619}
620
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +0000621#endif /* SUNOS4 || FREEBSD */
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000622
623#ifdef SVR4
624
625#ifdef HAVE_SYS_SYSCONFIG_H
626#include <sys/sysconfig.h>
627#endif /* HAVE_SYS_SYSCONFIG_H */
628
629#include <sys/mount.h>
630#include <sys/systeminfo.h>
631#include <sys/utsname.h>
632
Roland McGrathd9f816f2004-09-04 03:39:20 +0000633static const struct xlat sysconfig_options[] = {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000634#ifdef _CONFIG_NGROUPS
635 { _CONFIG_NGROUPS, "_CONFIG_NGROUPS" },
636#endif
637#ifdef _CONFIG_CHILD_MAX
638 { _CONFIG_CHILD_MAX, "_CONFIG_CHILD_MAX" },
639#endif
640#ifdef _CONFIG_OPEN_FILES
641 { _CONFIG_OPEN_FILES, "_CONFIG_OPEN_FILES" },
642#endif
643#ifdef _CONFIG_POSIX_VER
644 { _CONFIG_POSIX_VER, "_CONFIG_POSIX_VER" },
645#endif
646#ifdef _CONFIG_PAGESIZE
647 { _CONFIG_PAGESIZE, "_CONFIG_PAGESIZE" },
648#endif
649#ifdef _CONFIG_CLK_TCK
650 { _CONFIG_CLK_TCK, "_CONFIG_CLK_TCK" },
651#endif
652#ifdef _CONFIG_XOPEN_VER
653 { _CONFIG_XOPEN_VER, "_CONFIG_XOPEN_VER" },
654#endif
655#ifdef _CONFIG_PROF_TCK
656 { _CONFIG_PROF_TCK, "_CONFIG_PROF_TCK" },
657#endif
658#ifdef _CONFIG_NPROC_CONF
659 { _CONFIG_NPROC_CONF, "_CONFIG_NPROC_CONF" },
660#endif
661#ifdef _CONFIG_NPROC_ONLN
662 { _CONFIG_NPROC_ONLN, "_CONFIG_NPROC_ONLN" },
663#endif
664#ifdef _CONFIG_AIO_LISTIO_MAX
665 { _CONFIG_AIO_LISTIO_MAX, "_CONFIG_AIO_LISTIO_MAX" },
666#endif
667#ifdef _CONFIG_AIO_MAX
668 { _CONFIG_AIO_MAX, "_CONFIG_AIO_MAX" },
669#endif
670#ifdef _CONFIG_AIO_PRIO_DELTA_MAX
671 { _CONFIG_AIO_PRIO_DELTA_MAX, "_CONFIG_AIO_PRIO_DELTA_MAX" },
672#endif
673#ifdef _CONFIG_CONFIG_DELAYTIMER_MAX
674 { _CONFIG_DELAYTIMER_MAX, "_CONFIG_DELAYTIMER_MAX" },
675#endif
676#ifdef _CONFIG_MQ_OPEN_MAX
677 { _CONFIG_MQ_OPEN_MAX, "_CONFIG_MQ_OPEN_MAX" },
678#endif
679#ifdef _CONFIG_MQ_PRIO_MAX
680 { _CONFIG_MQ_PRIO_MAX, "_CONFIG_MQ_PRIO_MAX" },
681#endif
682#ifdef _CONFIG_RTSIG_MAX
683 { _CONFIG_RTSIG_MAX, "_CONFIG_RTSIG_MAX" },
684#endif
685#ifdef _CONFIG_SEM_NSEMS_MAX
686 { _CONFIG_SEM_NSEMS_MAX, "_CONFIG_SEM_NSEMS_MAX" },
687#endif
688#ifdef _CONFIG_SEM_VALUE_MAX
689 { _CONFIG_SEM_VALUE_MAX, "_CONFIG_SEM_VALUE_MAX" },
690#endif
691#ifdef _CONFIG_SIGQUEUE_MAX
692 { _CONFIG_SIGQUEUE_MAX, "_CONFIG_SIGQUEUE_MAX" },
693#endif
694#ifdef _CONFIG_SIGRT_MIN
695 { _CONFIG_SIGRT_MIN, "_CONFIG_SIGRT_MIN" },
696#endif
697#ifdef _CONFIG_SIGRT_MAX
698 { _CONFIG_SIGRT_MAX, "_CONFIG_SIGRT_MAX" },
699#endif
700#ifdef _CONFIG_TIMER_MAX
701 { _CONFIG_TIMER_MAX, "_CONFIG_TIMER_MAX" },
702#endif
703#ifdef _CONFIG_CONFIG_PHYS_PAGES
704 { _CONFIG_PHYS_PAGES, "_CONFIG_PHYS_PAGES" },
705#endif
706#ifdef _CONFIG_AVPHYS_PAGES
707 { _CONFIG_AVPHYS_PAGES, "_CONFIG_AVPHYS_PAGES" },
708#endif
709 { 0, NULL },
710};
711
712int
713sys_sysconfig(tcp)
714struct tcb *tcp;
715{
716 if (entering(tcp))
717 printxval(sysconfig_options, tcp->u_arg[0], "_CONFIG_???");
718 return 0;
719}
720
Roland McGrathd9f816f2004-09-04 03:39:20 +0000721static const struct xlat sysinfo_options[] = {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000722 { SI_SYSNAME, "SI_SYSNAME" },
723 { SI_HOSTNAME, "SI_HOSTNAME" },
724 { SI_RELEASE, "SI_RELEASE" },
725 { SI_VERSION, "SI_VERSION" },
726 { SI_MACHINE, "SI_MACHINE" },
727 { SI_ARCHITECTURE, "SI_ARCHITECTURE" },
728 { SI_HW_SERIAL, "SI_HW_SERIAL" },
729 { SI_HW_PROVIDER, "SI_HW_PROVIDER" },
730 { SI_SRPC_DOMAIN, "SI_SRPC_DOMAIN" },
731#ifdef SI_SET_HOSTNAME
732 { SI_SET_HOSTNAME, "SI_SET_HOSTNAME" },
733#endif
734#ifdef SI_SET_SRPC_DOMAIN
735 { SI_SET_SRPC_DOMAIN, "SI_SET_SRPC_DOMAIN" },
736#endif
737#ifdef SI_SET_KERB_REALM
738 { SI_SET_KERB_REALM, "SI_SET_KERB_REALM" },
739#endif
740#ifdef SI_KERB_REALM
741 { SI_KERB_REALM, "SI_KERB_REALM" },
742#endif
743 { 0, NULL },
744};
745
746int
747sys_sysinfo(tcp)
748struct tcb *tcp;
749{
750 if (entering(tcp)) {
751 printxval(sysinfo_options, tcp->u_arg[0], "SI_???");
752 tprintf(", ");
753 }
754 else {
755 /* Technically some calls write values. So what. */
756 if (syserror(tcp))
757 tprintf("%#lx", tcp->u_arg[1]);
758 else
759 printpath(tcp, tcp->u_arg[1]);
760 tprintf(", %lu", tcp->u_arg[2]);
761 }
762 return 0;
763}
764
765#ifdef MIPS
766
767#include <sys/syssgi.h>
768
Roland McGrathd9f816f2004-09-04 03:39:20 +0000769static const struct xlat syssgi_options[] = {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000770 { SGI_SYSID, "SGI_SYSID" },
Wichert Akkerman8829a551999-06-11 13:18:40 +0000771#ifdef SGI_RDUBLK
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000772 { SGI_RDUBLK, "SGI_RDUBLK" },
Wichert Akkerman8829a551999-06-11 13:18:40 +0000773#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000774 { SGI_TUNE, "SGI_TUNE" },
775 { SGI_IDBG, "SGI_IDBG" },
776 { SGI_INVENT, "SGI_INVENT" },
777 { SGI_RDNAME, "SGI_RDNAME" },
778 { SGI_SETLED, "SGI_SETLED" },
779 { SGI_SETNVRAM, "SGI_SETNVRAM" },
780 { SGI_GETNVRAM, "SGI_GETNVRAM" },
781 { SGI_QUERY_FTIMER, "SGI_QUERY_FTIMER" },
782 { SGI_QUERY_CYCLECNTR, "SGI_QUERY_CYCLECNTR" },
783 { SGI_PROCSZ, "SGI_PROCSZ" },
784 { SGI_SIGACTION, "SGI_SIGACTION" },
785 { SGI_SIGPENDING, "SGI_SIGPENDING" },
786 { SGI_SIGPROCMASK, "SGI_SIGPROCMASK" },
787 { SGI_SIGSUSPEND, "SGI_SIGSUSPEND" },
788 { SGI_SETSID, "SGI_SETSID" },
789 { SGI_SETPGID, "SGI_SETPGID" },
790 { SGI_SYSCONF, "SGI_SYSCONF" },
791 { SGI_WAIT4, "SGI_WAIT4" },
792 { SGI_PATHCONF, "SGI_PATHCONF" },
793 { SGI_READB, "SGI_READB" },
794 { SGI_WRITEB, "SGI_WRITEB" },
795 { SGI_SETGROUPS, "SGI_SETGROUPS" },
796 { SGI_GETGROUPS, "SGI_GETGROUPS" },
797 { SGI_SETTIMEOFDAY, "SGI_SETTIMEOFDAY" },
798 { SGI_SETTIMETRIM, "SGI_SETTIMETRIM" },
799 { SGI_GETTIMETRIM, "SGI_GETTIMETRIM" },
800 { SGI_SPROFIL, "SGI_SPROFIL" },
801 { SGI_RUSAGE, "SGI_RUSAGE" },
802 { SGI_SIGSTACK, "SGI_SIGSTACK" },
803 { SGI_SIGSTATUS, "SGI_SIGSTATUS" },
804 { SGI_NETPROC, "SGI_NETPROC" },
805 { SGI_SIGALTSTACK, "SGI_SIGALTSTACK" },
806 { SGI_BDFLUSHCNT, "SGI_BDFLUSHCNT" },
807 { SGI_SSYNC, "SGI_SSYNC" },
808 { SGI_NFSCNVT, "SGI_NFSCNVT" },
809 { SGI_GETPGID, "SGI_GETPGID" },
810 { SGI_GETSID, "SGI_GETSID" },
811 { SGI_IOPROBE, "SGI_IOPROBE" },
812 { SGI_CONFIG, "SGI_CONFIG" },
813 { SGI_ELFMAP, "SGI_ELFMAP" },
814 { SGI_MCONFIG, "SGI_MCONFIG" },
815 { SGI_GETPLABEL, "SGI_GETPLABEL" },
816 { SGI_SETPLABEL, "SGI_SETPLABEL" },
817 { SGI_GETLABEL, "SGI_GETLABEL" },
818 { SGI_SETLABEL, "SGI_SETLABEL" },
819 { SGI_SATREAD, "SGI_SATREAD" },
820 { SGI_SATWRITE, "SGI_SATWRITE" },
821 { SGI_SATCTL, "SGI_SATCTL" },
822 { SGI_LOADATTR, "SGI_LOADATTR" },
823 { SGI_UNLOADATTR, "SGI_UNLOADATTR" },
824#ifdef SGI_RECVLMSG
825 { SGI_RECVLMSG, "SGI_RECVLMSG" },
826#endif
827 { SGI_PLANGMOUNT, "SGI_PLANGMOUNT" },
828 { SGI_GETPSOACL, "SGI_GETPSOACL" },
829 { SGI_SETPSOACL, "SGI_SETPSOACL" },
Wichert Akkerman8829a551999-06-11 13:18:40 +0000830#ifdef SGI_EAG_GET_ATTR
831 { SGI_EAG_GET_ATTR, "SGI_EAG_GET_ATTR" },
832#endif
833#ifdef SGI_EAG_SET_ATTR
834 { SGI_EAG_SET_ATTR, "SGI_EAG_SET_ATTR" },
835#endif
836#ifdef SGI_EAG_GET_PROCATTR
837 { SGI_EAG_GET_PROCATTR, "SGI_EAG_GET_PROCATTR" },
838#endif
839#ifdef SGI_EAG_SET_PROCATTR
840 { SGI_EAG_SET_PROCATTR, "SGI_EAG_SET_PROCATTR" },
841#endif
842#ifdef SGI_FREVOKE
843 { SGI_FREVOKE, "SGI_FREVOKE" },
844#endif
845#ifdef SGI_SBE_GET_INFO
846 { SGI_SBE_GET_INFO, "SGI_SBE_GET_INFO" },
847#endif
848#ifdef SGI_SBE_CLR_INFO
849 { SGI_SBE_CLR_INFO, "SGI_SBE_CLR_INFO" },
850#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000851 { SGI_RMI_FIXECC, "SGI_RMI_FIXECC" },
852 { SGI_R4K_CERRS, "SGI_R4K_CERRS" },
853 { SGI_GET_EVCONF, "SGI_GET_EVCONF" },
854 { SGI_MPCWAROFF, "SGI_MPCWAROFF" },
855 { SGI_SET_AUTOPWRON, "SGI_SET_AUTOPWRON" },
856 { SGI_SPIPE, "SGI_SPIPE" },
857 { SGI_SYMTAB, "SGI_SYMTAB" },
858#ifdef SGI_SET_FPDEBUG
859 { SGI_SET_FPDEBUG, "SGI_SET_FPDEBUG" },
860#endif
Wichert Akkerman8829a551999-06-11 13:18:40 +0000861#ifdef SGI_SET_FP_PRECISE
862 { SGI_SET_FP_PRECISE, "SGI_SET_FP_PRECISE" },
863#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000864 { SGI_TOSSTSAVE, "SGI_TOSSTSAVE" },
865 { SGI_FDHI, "SGI_FDHI" },
Wichert Akkerman8829a551999-06-11 13:18:40 +0000866#ifdef SGI_SET_CONFIG_SMM
867 { SGI_SET_CONFIG_SMM, "SGI_SET_CONFIG_SMM" },
868#endif
869#ifdef SGI_SET_FP_PRESERVE
870 { SGI_SET_FP_PRESERVE, "SGI_SET_FP_PRESERVE" },
871#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +0000872 { SGI_MINRSS, "SGI_MINRSS" },
Wichert Akkerman8829a551999-06-11 13:18:40 +0000873#ifdef SGI_GRIO
874 { SGI_GRIO, "SGI_GRIO" },
875#endif
876#ifdef SGI_XLV_SET_TAB
877 { SGI_XLV_SET_TAB, "SGI_XLV_SET_TAB" },
878#endif
879#ifdef SGI_XLV_GET_TAB
880 { SGI_XLV_GET_TAB, "SGI_XLV_GET_TAB" },
881#endif
882#ifdef SGI_GET_FP_PRECISE
883 { SGI_GET_FP_PRECISE, "SGI_GET_FP_PRECISE" },
884#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000885#ifdef SGI_GET_CONFIG_SMM
Wichert Akkerman8829a551999-06-11 13:18:40 +0000886 { SGI_GET_CONFIG_SMM, "SGI_GET_CONFIG_SMM" },
887#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000888#ifdef SGI_FP_IMPRECISE_SUPP
Wichert Akkerman8829a551999-06-11 13:18:40 +0000889 { SGI_FP_IMPRECISE_SUPP,"SGI_FP_IMPRECISE_SUPP" },
890#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000891#ifdef SGI_CONFIG_NSMM_SUPP
Wichert Akkerman8829a551999-06-11 13:18:40 +0000892 { SGI_CONFIG_NSMM_SUPP, "SGI_CONFIG_NSMM_SUPP" },
893#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000894#ifdef SGI_RT_TSTAMP_CREATE
Wichert Akkerman8829a551999-06-11 13:18:40 +0000895 { SGI_RT_TSTAMP_CREATE, "SGI_RT_TSTAMP_CREATE" },
896#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000897#ifdef SGI_RT_TSTAMP_DELETE
Wichert Akkerman8829a551999-06-11 13:18:40 +0000898 { SGI_RT_TSTAMP_DELETE, "SGI_RT_TSTAMP_DELETE" },
899#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000900#ifdef SGI_RT_TSTAMP_START
Wichert Akkerman8829a551999-06-11 13:18:40 +0000901 { SGI_RT_TSTAMP_START, "SGI_RT_TSTAMP_START" },
902#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000903#ifdef SGI_RT_TSTAMP_STOP
Wichert Akkerman8829a551999-06-11 13:18:40 +0000904 { SGI_RT_TSTAMP_STOP, "SGI_RT_TSTAMP_STOP" },
905#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000906#ifdef SGI_RT_TSTAMP_ADDR
Wichert Akkerman8829a551999-06-11 13:18:40 +0000907 { SGI_RT_TSTAMP_ADDR, "SGI_RT_TSTAMP_ADDR" },
908#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000909#ifdef SGI_RT_TSTAMP_MASK
Wichert Akkerman8829a551999-06-11 13:18:40 +0000910 { SGI_RT_TSTAMP_MASK, "SGI_RT_TSTAMP_MASK" },
911#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000912#ifdef SGI_RT_TSTAMP_EOB_MODE
Wichert Akkerman8829a551999-06-11 13:18:40 +0000913 { SGI_RT_TSTAMP_EOB_MODE,"SGI_RT_TSTAMP_EOB_MODE"},
914#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000915#ifdef SGI_USE_FP_BCOPY
Wichert Akkerman8829a551999-06-11 13:18:40 +0000916 { SGI_USE_FP_BCOPY, "SGI_USE_FP_BCOPY" },
917#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000918#ifdef SGI_GET_UST
Wichert Akkerman8829a551999-06-11 13:18:40 +0000919 { SGI_GET_UST, "SGI_GET_UST" },
920#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000921#ifdef SGI_SPECULATIVE_EXEC
Wichert Akkerman8829a551999-06-11 13:18:40 +0000922 { SGI_SPECULATIVE_EXEC, "SGI_SPECULATIVE_EXEC" },
923#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000924#ifdef SGI_XLV_NEXT_RQST
Wichert Akkerman8829a551999-06-11 13:18:40 +0000925 { SGI_XLV_NEXT_RQST, "SGI_XLV_NEXT_RQST" },
926#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000927#ifdef SGI_XLV_ATTR_CURSOR
Wichert Akkerman8829a551999-06-11 13:18:40 +0000928 { SGI_XLV_ATTR_CURSOR, "SGI_XLV_ATTR_CURSOR" },
929#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000930#ifdef SGI_XLV_ATTR_GET
Wichert Akkerman8829a551999-06-11 13:18:40 +0000931 { SGI_XLV_ATTR_GET, "SGI_XLV_ATTR_GET" },
932#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000933#ifdef SGI_XLV_ATTR_SET
Wichert Akkerman8829a551999-06-11 13:18:40 +0000934 { SGI_XLV_ATTR_SET, "SGI_XLV_ATTR_SET" },
935#endif
936#ifdef SGI_BTOOLSIZE
937 { SGI_BTOOLSIZE, "SGI_BTOOLSIZE" },
938#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000939#ifdef SGI_BTOOLGET
Wichert Akkerman8829a551999-06-11 13:18:40 +0000940 { SGI_BTOOLGET, "SGI_BTOOLGET" },
941#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000942#ifdef SGI_BTOOLREINIT
Wichert Akkerman8829a551999-06-11 13:18:40 +0000943 { SGI_BTOOLREINIT, "SGI_BTOOLREINIT" },
944#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000945#ifdef SGI_CREATE_UUID
Wichert Akkerman8829a551999-06-11 13:18:40 +0000946 { SGI_CREATE_UUID, "SGI_CREATE_UUID" },
947#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000948#ifdef SGI_NOFPE
Wichert Akkerman8829a551999-06-11 13:18:40 +0000949 { SGI_NOFPE, "SGI_NOFPE" },
950#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000951#ifdef SGI_OLD_SOFTFP
Wichert Akkerman8829a551999-06-11 13:18:40 +0000952 { SGI_OLD_SOFTFP, "SGI_OLD_SOFTFP" },
953#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000954#ifdef SGI_FS_INUMBERS
Wichert Akkerman8829a551999-06-11 13:18:40 +0000955 { SGI_FS_INUMBERS, "SGI_FS_INUMBERS" },
956#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000957#ifdef SGI_FS_BULKSTAT
Wichert Akkerman8829a551999-06-11 13:18:40 +0000958 { SGI_FS_BULKSTAT, "SGI_FS_BULKSTAT" },
959#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000960#ifdef SGI_RT_TSTAMP_WAIT
Wichert Akkerman8829a551999-06-11 13:18:40 +0000961 { SGI_RT_TSTAMP_WAIT, "SGI_RT_TSTAMP_WAIT" },
962#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000963#ifdef SGI_RT_TSTAMP_UPDATE
Wichert Akkerman8829a551999-06-11 13:18:40 +0000964 { SGI_RT_TSTAMP_UPDATE, "SGI_RT_TSTAMP_UPDATE" },
965#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000966#ifdef SGI_PATH_TO_HANDLE
Wichert Akkerman8829a551999-06-11 13:18:40 +0000967 { SGI_PATH_TO_HANDLE, "SGI_PATH_TO_HANDLE" },
968#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000969#ifdef SGI_PATH_TO_FSHANDLE
Wichert Akkerman8829a551999-06-11 13:18:40 +0000970 { SGI_PATH_TO_FSHANDLE, "SGI_PATH_TO_FSHANDLE" },
971#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000972#ifdef SGI_FD_TO_HANDLE
Wichert Akkerman8829a551999-06-11 13:18:40 +0000973 { SGI_FD_TO_HANDLE, "SGI_FD_TO_HANDLE" },
974#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000975#ifdef SGI_OPEN_BY_HANDLE
Wichert Akkerman8829a551999-06-11 13:18:40 +0000976 { SGI_OPEN_BY_HANDLE, "SGI_OPEN_BY_HANDLE" },
977#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000978#ifdef SGI_READLINK_BY_HANDLE
Wichert Akkerman8829a551999-06-11 13:18:40 +0000979 { SGI_READLINK_BY_HANDLE,"SGI_READLINK_BY_HANDLE"},
980#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000981#ifdef SGI_READ_DANGID
Wichert Akkerman8829a551999-06-11 13:18:40 +0000982 { SGI_READ_DANGID, "SGI_READ_DANGID" },
983#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000984#ifdef SGI_CONST
Wichert Akkerman8829a551999-06-11 13:18:40 +0000985 { SGI_CONST, "SGI_CONST" },
986#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000987#ifdef SGI_XFS_FSOPERATIONS
Wichert Akkerman8829a551999-06-11 13:18:40 +0000988 { SGI_XFS_FSOPERATIONS, "SGI_XFS_FSOPERATIONS" },
989#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000990#ifdef SGI_SETASH
Wichert Akkerman8829a551999-06-11 13:18:40 +0000991 { SGI_SETASH, "SGI_SETASH" },
992#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000993#ifdef SGI_GETASH
Wichert Akkerman8829a551999-06-11 13:18:40 +0000994 { SGI_GETASH, "SGI_GETASH" },
995#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000996#ifdef SGI_SETPRID
Wichert Akkerman8829a551999-06-11 13:18:40 +0000997 { SGI_SETPRID, "SGI_SETPRID" },
998#endif
Roland McGrathced50da2004-08-31 06:48:46 +0000999#ifdef SGI_GETPRID
Wichert Akkerman8829a551999-06-11 13:18:40 +00001000 { SGI_GETPRID, "SGI_GETPRID" },
1001#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001002#ifdef SGI_SETSPINFO
Wichert Akkerman8829a551999-06-11 13:18:40 +00001003 { SGI_SETSPINFO, "SGI_SETSPINFO" },
1004#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001005#ifdef SGI_GETSPINFO
Wichert Akkerman8829a551999-06-11 13:18:40 +00001006 { SGI_GETSPINFO, "SGI_GETSPINFO" },
1007#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001008#ifdef SGI_SHAREII
Wichert Akkerman8829a551999-06-11 13:18:40 +00001009 { SGI_SHAREII, "SGI_SHAREII" },
1010#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001011#ifdef SGI_NEWARRAYSESS
Wichert Akkerman8829a551999-06-11 13:18:40 +00001012 { SGI_NEWARRAYSESS, "SGI_NEWARRAYSESS" },
1013#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001014#ifdef SGI_GETDFLTPRID
Wichert Akkerman8829a551999-06-11 13:18:40 +00001015 { SGI_GETDFLTPRID, "SGI_GETDFLTPRID" },
1016#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001017#ifdef SGI_SET_DISMISSED_EXC_CNT
Wichert Akkerman8829a551999-06-11 13:18:40 +00001018 { SGI_SET_DISMISSED_EXC_CNT,"SGI_SET_DISMISSED_EXC_CNT" },
1019#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001020#ifdef SGI_GET_DISMISSED_EXC_CNT
Wichert Akkerman8829a551999-06-11 13:18:40 +00001021 { SGI_GET_DISMISSED_EXC_CNT,"SGI_GET_DISMISSED_EXC_CNT" },
1022#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001023#ifdef SGI_CYCLECNTR_SIZE
Wichert Akkerman8829a551999-06-11 13:18:40 +00001024 { SGI_CYCLECNTR_SIZE, "SGI_CYCLECNTR_SIZE" },
1025#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001026#ifdef SGI_QUERY_FASTTIMER
Wichert Akkerman8829a551999-06-11 13:18:40 +00001027 { SGI_QUERY_FASTTIMER, "SGI_QUERY_FASTTIMER" },
1028#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001029#ifdef SGI_PIDSINASH
Wichert Akkerman8829a551999-06-11 13:18:40 +00001030 { SGI_PIDSINASH, "SGI_PIDSINASH" },
1031#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001032#ifdef SGI_ULI
Wichert Akkerman8829a551999-06-11 13:18:40 +00001033 { SGI_ULI, "SGI_ULI" },
1034#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001035#ifdef SGI_LPG_SHMGET
Wichert Akkerman8829a551999-06-11 13:18:40 +00001036 { SGI_LPG_SHMGET, "SGI_LPG_SHMGET" },
1037#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001038#ifdef SGI_LPG_MAP
Wichert Akkerman8829a551999-06-11 13:18:40 +00001039 { SGI_LPG_MAP, "SGI_LPG_MAP" },
1040#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001041#ifdef SGI_CACHEFS_SYS
Wichert Akkerman8829a551999-06-11 13:18:40 +00001042 { SGI_CACHEFS_SYS, "SGI_CACHEFS_SYS" },
1043#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001044#ifdef SGI_NFSNOTIFY
Wichert Akkerman8829a551999-06-11 13:18:40 +00001045 { SGI_NFSNOTIFY, "SGI_NFSNOTIFY" },
1046#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001047#ifdef SGI_LOCKDSYS
Wichert Akkerman8829a551999-06-11 13:18:40 +00001048 { SGI_LOCKDSYS, "SGI_LOCKDSYS" },
1049#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001050#ifdef SGI_EVENTCTR
Wichert Akkerman8829a551999-06-11 13:18:40 +00001051 { SGI_EVENTCTR, "SGI_EVENTCTR" },
1052#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001053#ifdef SGI_GETPRUSAGE
Wichert Akkerman8829a551999-06-11 13:18:40 +00001054 { SGI_GETPRUSAGE, "SGI_GETPRUSAGE" },
1055#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001056#ifdef SGI_PROCMASK_LOCATION
Wichert Akkerman8829a551999-06-11 13:18:40 +00001057 { SGI_PROCMASK_LOCATION,"SGI_PROCMASK_LOCATION" },
1058#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001059#ifdef SGI_UNUSED
Wichert Akkerman8829a551999-06-11 13:18:40 +00001060 { SGI_UNUSED, "SGI_UNUSED" },
1061#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001062#ifdef SGI_CKPT_SYS
Wichert Akkerman8829a551999-06-11 13:18:40 +00001063 { SGI_CKPT_SYS, "SGI_CKPT_SYS" },
1064#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001065#ifdef SGI_CKPT_SYS
Wichert Akkerman8829a551999-06-11 13:18:40 +00001066 { SGI_CKPT_SYS, "SGI_CKPT_SYS" },
1067#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001068#ifdef SGI_GETGRPPID
Wichert Akkerman8829a551999-06-11 13:18:40 +00001069 { SGI_GETGRPPID, "SGI_GETGRPPID" },
1070#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001071#ifdef SGI_GETSESPID
Wichert Akkerman8829a551999-06-11 13:18:40 +00001072 { SGI_GETSESPID, "SGI_GETSESPID" },
1073#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001074#ifdef SGI_ENUMASHS
Wichert Akkerman8829a551999-06-11 13:18:40 +00001075 { SGI_ENUMASHS, "SGI_ENUMASHS" },
1076#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001077#ifdef SGI_SETASMACHID
Wichert Akkerman8829a551999-06-11 13:18:40 +00001078 { SGI_SETASMACHID, "SGI_SETASMACHID" },
1079#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001080#ifdef SGI_GETASMACHID
Wichert Akkerman8829a551999-06-11 13:18:40 +00001081 { SGI_GETASMACHID, "SGI_GETASMACHID" },
1082#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001083#ifdef SGI_GETARSESS
Wichert Akkerman8829a551999-06-11 13:18:40 +00001084 { SGI_GETARSESS, "SGI_GETARSESS" },
1085#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001086#ifdef SGI_JOINARRAYSESS
Wichert Akkerman8829a551999-06-11 13:18:40 +00001087 { SGI_JOINARRAYSESS, "SGI_JOINARRAYSESS" },
1088#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001089#ifdef SGI_SPROC_KILL
Wichert Akkerman8829a551999-06-11 13:18:40 +00001090 { SGI_SPROC_KILL, "SGI_SPROC_KILL" },
1091#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001092#ifdef SGI_DBA_CONFIG
Wichert Akkerman8829a551999-06-11 13:18:40 +00001093 { SGI_DBA_CONFIG, "SGI_DBA_CONFIG" },
1094#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001095#ifdef SGI_RELEASE_NAME
Wichert Akkerman8829a551999-06-11 13:18:40 +00001096 { SGI_RELEASE_NAME, "SGI_RELEASE_NAME" },
1097#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001098#ifdef SGI_SYNCH_CACHE_HANDLER
Wichert Akkerman8829a551999-06-11 13:18:40 +00001099 { SGI_SYNCH_CACHE_HANDLER,"SGI_SYNCH_CACHE_HANDLER"},
1100#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001101#ifdef SGI_SWASH_INIT
Wichert Akkerman8829a551999-06-11 13:18:40 +00001102 { SGI_SWASH_INIT, "SGI_SWASH_INIT" },
1103#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001104#ifdef SGI_NUMA_MIGR_PAGE
Wichert Akkerman8829a551999-06-11 13:18:40 +00001105 { SGI_NUMA_MIGR_PAGE, "SGI_NUMA_MIGR_PAGE" },
1106#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001107#ifdef SGI_NUMA_MIGR_PAGE_ALT
Wichert Akkerman8829a551999-06-11 13:18:40 +00001108 { SGI_NUMA_MIGR_PAGE_ALT,"SGI_NUMA_MIGR_PAGE_ALT"},
1109#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001110#ifdef SGI_KAIO_USERINIT
Wichert Akkerman8829a551999-06-11 13:18:40 +00001111 { SGI_KAIO_USERINIT, "SGI_KAIO_USERINIT" },
1112#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001113#ifdef SGI_KAIO_READ
Wichert Akkerman8829a551999-06-11 13:18:40 +00001114 { SGI_KAIO_READ, "SGI_KAIO_READ" },
1115#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001116#ifdef SGI_KAIO_WRITE
Wichert Akkerman8829a551999-06-11 13:18:40 +00001117 { SGI_KAIO_WRITE, "SGI_KAIO_WRITE" },
1118#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001119#ifdef SGI_KAIO_SUSPEND
Wichert Akkerman8829a551999-06-11 13:18:40 +00001120 { SGI_KAIO_SUSPEND, "SGI_KAIO_SUSPEND" },
1121#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001122#ifdef SGI_KAIO_STATS
Wichert Akkerman8829a551999-06-11 13:18:40 +00001123 { SGI_KAIO_STATS, "SGI_KAIO_STATS" },
1124#endif
Roland McGrathced50da2004-08-31 06:48:46 +00001125#ifdef SGI_INITIAL_PT_SPROC
Wichert Akkerman8829a551999-06-11 13:18:40 +00001126 { SGI_INITIAL_PT_SPROC, "SGI_INITIAL_PT_SPROC" },
1127#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001128 { 0, NULL },
1129};
1130
1131int
1132sys_syssgi(tcp)
1133struct tcb *tcp;
1134{
1135 int i;
1136
1137 if (entering(tcp)) {
1138 printxval(syssgi_options, tcp->u_arg[0], "SGI_???");
1139 switch (tcp->u_arg[0]) {
1140 default:
1141 for (i = 1; i < tcp->u_nargs; i++)
1142 tprintf(", %#lx", tcp->u_arg[i]);
1143 break;
1144 }
1145 }
1146 return 0;
1147}
1148
1149#include <sys/types.h>
1150#include <rpc/rpc.h>
1151struct cred;
1152struct uio;
1153#include <sys/fsid.h>
1154#include <sys/vnode.h>
1155#include <sys/fs/nfs.h>
1156#include <sys/fs/nfs_clnt.h>
1157
Roland McGrathd9f816f2004-09-04 03:39:20 +00001158static const struct xlat mount_flags[] = {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001159 { MS_RDONLY, "MS_RDONLY" },
1160 { MS_FSS, "MS_FSS" },
1161 { MS_DATA, "MS_DATA" },
1162 { MS_NOSUID, "MS_NOSUID" },
1163 { MS_REMOUNT, "MS_REMOUNT" },
1164 { MS_NOTRUNC, "MS_NOTRUNC" },
1165 { MS_GRPID, "MS_GRPID" },
1166 { MS_NODEV, "MS_NODEV" },
1167 { MS_BEFORE, "MS_BEFORE" },
1168 { MS_AFTER, "MS_AFTER" },
1169 { 0, NULL },
1170};
1171
Roland McGrathd9f816f2004-09-04 03:39:20 +00001172static const struct xlat nfs_flags[] = {
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001173 { NFSMNT_SOFT, "NFSMNT_SOFT" },
1174 { NFSMNT_WSIZE, "NFSMNT_WSIZE" },
1175 { NFSMNT_RSIZE, "NFSMNT_RSIZE" },
1176 { NFSMNT_TIMEO, "NFSMNT_TIMEO" },
1177 { NFSMNT_RETRANS, "NFSMNT_RETRANS" },
1178 { NFSMNT_HOSTNAME, "NFSMNT_HOSTNAME" },
Wichert Akkerman8829a551999-06-11 13:18:40 +00001179#ifdef NFSMNT_NOINT /* IRIX 6 */
1180 { NFSMNT_NOINT, "NFSMNT_NOINT" },
1181#endif
1182#ifdef NFSMNT_INT /* IRIX 5 */
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001183 { NFSMNT_INT, "NFSMNT_INT" },
Wichert Akkerman8829a551999-06-11 13:18:40 +00001184#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001185 { NFSMNT_NOAC, "NFSMNT_NOAC" },
1186 { NFSMNT_ACREGMIN, "NFSMNT_ACREGMIN" },
1187 { NFSMNT_ACREGMAX, "NFSMNT_ACREGMAX" },
1188 { NFSMNT_ACDIRMIN, "NFSMNT_ACDIRMIN" },
1189 { NFSMNT_ACDIRMAX, "NFSMNT_ACDIRMAX" },
1190 { NFSMNT_PRIVATE, "NFSMNT_PRIVATE" },
1191 { NFSMNT_SYMTTL, "NFSMNT_SYMTTL" },
1192 { NFSMNT_LOOPBACK, "NFSMNT_LOOPBACK" },
1193 { NFSMNT_BASETYPE, "NFSMNT_BASETYPE" },
1194 { NFSMNT_NAMEMAX, "NFSMNT_NAMEMAX" },
Wichert Akkerman8829a551999-06-11 13:18:40 +00001195#ifdef NFSMNT_SHORTUID /* IRIX 6 */
1196 { NFSMNT_SHORTUID, "NFSMNT_SHORTUID" },
1197#endif
1198#ifdef NFSMNT_ASYNCNLM /* IRIX 6 */
1199 { NFSMNT_ASYNCNLM, "NFSMNT_ASYNCNLM" },
1200#endif
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001201 { 0, NULL },
1202};
1203
1204int
1205sys_mount(tcp)
1206struct tcb *tcp;
1207{
1208 if (entering(tcp)) {
1209 printpath(tcp, tcp->u_arg[0]);
1210 tprintf(", ");
1211 printpath(tcp, tcp->u_arg[1]);
1212 tprintf(", ");
Roland McGrathb2dee132005-06-01 19:02:36 +00001213 printflags(mount_flags, tcp->u_arg[2], "MS_???");
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001214 if (tcp->u_arg[2] & (MS_FSS | MS_DATA)) {
1215 tprintf(", ");
1216 tprintf("%ld", tcp->u_arg[3]);
1217 }
1218 if (tcp->u_arg[2] & MS_DATA) {
1219 int nfs_type = sysfs(GETFSIND, FSID_NFS);
1220
1221 tprintf(", ");
1222 if (tcp->u_arg[3] == nfs_type) {
1223 struct nfs_args args;
1224 if (umove(tcp, tcp->u_arg[4], &args) < 0)
1225 tprintf("%#lx", tcp->u_arg[4]);
1226 else {
1227 tprintf("addr=");
1228 printsock(tcp, (int) args.addr);
1229 tprintf(", flags=");
Roland McGrathb2dee132005-06-01 19:02:36 +00001230 printflags(nfs_flags, args.flags, "NFSMNT_???");
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001231 tprintf(", hostname=");
1232 printstr(tcp, (int) args.hostname, -1);
1233 tprintf(", ...}");
1234 }
1235 }
1236 else
1237 tprintf("%#lx", tcp->u_arg[4]);
1238 tprintf(", %ld", tcp->u_arg[5]);
1239 }
1240 }
1241 return 0;
1242}
1243
1244#else /* !MIPS */
1245
Wichert Akkerman3377df71999-11-26 13:14:41 +00001246#if UNIXWARE
1247
1248#include <sys/types.h>
1249#include <sys/fstyp.h>
1250#include <sys/mount.h>
1251#include <sys/xti.h>
1252
1253#define NFSCLIENT 1
1254#include <nfs/mount.h>
1255
1256#include <sys/fs/vx_ioctl.h>
1257
Roland McGrathd9f816f2004-09-04 03:39:20 +00001258static const struct xlat mount_flags[] = {
Wichert Akkerman3377df71999-11-26 13:14:41 +00001259 { MS_RDONLY, "MS_RDONLY" },
1260 { MS_FSS, "MS_FSS" },
1261 { MS_DATA, "MS_DATA" },
1262 { MS_HADBAD, "MS_HADBAD" },
1263 { MS_NOSUID, "MS_NOSUID" },
1264 { MS_REMOUNT, "MS_REMOUNT" },
1265 { MS_NOTRUNC, "MS_NOTRUNC" },
1266 { MS_SOFTMNT, "MS_SOFTMNT" },
1267 { MS_SYSSPACE, "MS_SYSSPACE" },
1268 { 0, NULL },
1269};
1270
1271#ifdef VX_MS_MASK
Roland McGrathd9f816f2004-09-04 03:39:20 +00001272static const struct xlat vxfs_flags[] = {
Wichert Akkerman3377df71999-11-26 13:14:41 +00001273 { VX_MS_NOLOG, "VX_MS_NOLOG" },
1274 { VX_MS_BLKCLEAR, "VX_MS_BLKCLEAR" },
1275 { VX_MS_SNAPSHOT, "VX_MS_SNAPSHOT" },
1276 { VX_MS_NODATAINLOG, "VX_MS_NODATAINLOG" },
1277 { VX_MS_DELAYLOG, "VX_MS_DELAYLOG" },
1278 { VX_MS_TMPLOG, "VX_MS_TMPLOG" },
1279 { VX_MS_FILESET, "VX_MS_FILESET" },
1280
1281 { VX_MS_CACHE_DIRECT, "VX_MS_CACHE_DIRECT" },
1282 { VX_MS_CACHE_DSYNC, "VX_MS_CACHE_DSYNC" },
1283 { VX_MS_CACHE_CLOSESYNC,"VX_MS_CACHE_CLOSESYNC" },
1284 { VX_MS_CACHE_TMPCACHE, "VX_MS_CACHE_TMPCACHE" },
1285
1286 { VX_MS_OSYNC_DIRECT, "VX_MS_OSYNC_DIRECT" },
1287 { VX_MS_OSYNC_DSYNC, "VX_MS_OSYNC_DSYNC" },
1288 { VX_MS_OSYNC_CLOSESYNC,"VX_MS_OSYNC_CLOSESYNC" },
1289 { VX_MS_OSYNC_DELAY, "VX_MS_OSYNC_DELAY" },
1290 { 0, NULL, },
1291};
1292#endif
1293
Roland McGrathd9f816f2004-09-04 03:39:20 +00001294static const struct xlat nfs_flags[] = {
Wichert Akkerman3377df71999-11-26 13:14:41 +00001295 { NFSMNT_SOFT, "NFSMNT_SOFT" },
1296 { NFSMNT_WSIZE, "NFSMNT_WSIZE" },
1297 { NFSMNT_RSIZE, "NFSMNT_RSIZE" },
1298 { NFSMNT_TIMEO, "NFSMNT_TIMEO" },
1299 { NFSMNT_RETRANS, "NFSMNT_RETRANS" },
1300 { NFSMNT_HOSTNAME, "NFSMNT_HOSTNAME" },
1301 { NFSMNT_INT, "NFSMNT_INT" },
1302 { NFSMNT_NOAC, "NFSMNT_NOAC" },
1303 { NFSMNT_ACREGMIN, "NFSMNT_ACREGMIN" },
1304 { NFSMNT_ACREGMAX, "NFSMNT_ACREGMAX" },
1305 { NFSMNT_ACDIRMIN, "NFSMNT_ACDIRMIN" },
1306 { NFSMNT_ACDIRMAX, "NFSMNT_ACDIRMAX" },
1307 { NFSMNT_SECURE, "NFSMNT_SECURE" },
1308 { NFSMNT_NOCTO, "NFSMNT_NOCTO" },
1309 { NFSMNT_GRPID, "NFSMNT_GRPID" },
1310 { NFSMNT_RPCTIMESYNC, "NFSMNT_RPCTIMESYNC" },
1311 { NFSMNT_LWPSMAX, "NFSMNT_LWPSMAX" },
1312 { 0, NULL },
1313};
1314
1315int
1316sys_mount(tcp)
1317struct tcb *tcp;
1318{
1319 if (entering(tcp)) {
1320 char fstyp [FSTYPSZ];
1321 printpath(tcp, tcp->u_arg[0]);
1322 tprintf(", ");
1323 printpath(tcp, tcp->u_arg[1]);
1324 tprintf(", ");
Roland McGrathb2dee132005-06-01 19:02:36 +00001325 printflags(mount_flags, tcp->u_arg[2], "MS_???");
Wichert Akkerman3377df71999-11-26 13:14:41 +00001326 /* The doc sez that the file system type is given as a
1327 fsindex, and we should use sysfs to work out the name.
1328 This appears to be untrue for UW. Maybe it's untrue
1329 for all SVR4's? */
1330 if (tcp->u_arg[2] & (MS_FSS | MS_DATA)) {
1331 if (umovestr(tcp, tcp->u_arg[3], FSTYPSZ, fstyp) < 0) {
1332 *fstyp = 0;
1333 tprintf(", %ld", tcp->u_arg[3]);
1334 }
1335 else
1336 tprintf(", \"%s\"", fstyp);
1337 }
1338 if (tcp->u_arg[2] & MS_DATA) {
1339 tprintf(", ");
1340#ifdef VX_MS_MASK
1341 /* On UW7 they don't give us the defines and structs
1342 we need to see what is going on. Bummer. */
1343 if (strcmp (fstyp, "vxfs") == 0) {
1344 struct vx_mountargs5 args;
1345 if (umove(tcp, tcp->u_arg[4], &args) < 0)
1346 tprintf("%#lx", tcp->u_arg[4]);
1347 else {
1348 tprintf("{ flags=");
Roland McGrathb2dee132005-06-01 19:02:36 +00001349 printflags(vxfs_flags, args.mflags, "VX_MS_???");
Wichert Akkerman3377df71999-11-26 13:14:41 +00001350 if (args.mflags & VX_MS_SNAPSHOT) {
1351 tprintf (", snapof=");
1352 printstr (tcp,
Roland McGrathced50da2004-08-31 06:48:46 +00001353 (long) args.primaryspec,
Wichert Akkerman3377df71999-11-26 13:14:41 +00001354 -1);
1355 if (args.snapsize > 0)
1356 tprintf (", snapsize=%ld", args.snapsize);
1357 }
1358 tprintf(" }");
1359 }
1360 }
1361 else
1362#endif
1363 if (strcmp (fstyp, "specfs") == 0) {
1364 tprintf ("dev=");
1365 printstr (tcp, tcp->u_arg[4], -1);
1366 }
1367 else
1368 if (strcmp (fstyp, "nfs") == 0) {
1369 struct nfs_args args;
1370 if (umove(tcp, tcp->u_arg[4], &args) < 0)
1371 tprintf("%#lx", tcp->u_arg[4]);
1372 else {
1373 struct netbuf addr;
1374 tprintf("{ addr=");
1375 if (umove (tcp, (int) args.addr, &addr) < 0) {
1376 tprintf ("%#lx", (long) args.addr);
1377 }
1378 else {
1379 printsock(tcp, (int) addr.buf, addr.len);
1380 }
1381 tprintf(", flags=");
Roland McGrathb2dee132005-06-01 19:02:36 +00001382 printflags(nfs_flags, args.flags, "NFSMNT_???");
Wichert Akkerman3377df71999-11-26 13:14:41 +00001383 tprintf(", hostname=");
1384 printstr(tcp, (int) args.hostname, -1);
1385 tprintf(", ...}");
1386 }
1387 }
1388 else
1389 tprintf("%#lx", tcp->u_arg[4]);
1390 tprintf(", %ld", tcp->u_arg[5]);
1391 }
1392 }
1393 return 0;
1394}
1395
1396#else /* !UNIXWARE */
1397
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001398int
1399sys_mount(tcp)
1400struct tcb *tcp;
1401{
1402 if (entering(tcp)) {
1403 printpath(tcp, tcp->u_arg[0]);
1404 tprintf(", ");
1405 printpath(tcp, tcp->u_arg[1]);
1406 tprintf(", ...");
1407 }
1408 return 0;
1409}
Wichert Akkermanea78f0f1999-11-29 15:34:02 +00001410#endif /* !UNIXWARE */
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001411
1412#endif /* !MIPS */
1413
1414#endif /* SVR4 */
1415
Nate Sammons8d5860c1999-07-03 18:53:05 +00001416#ifdef SYS_capget
Wichert Akkermanc7926982000-04-10 22:22:31 +00001417
Roland McGrathd9f816f2004-09-04 03:39:20 +00001418static const struct xlat capabilities[] = {
Wichert Akkermanc7926982000-04-10 22:22:31 +00001419 { 1<<CAP_CHOWN, "CAP_CHOWN" },
1420 { 1<<CAP_DAC_OVERRIDE, "CAP_DAC_OVERRIDE"},
1421 { 1<<CAP_DAC_READ_SEARCH,"CAP_DAC_READ_SEARCH"},
1422 { 1<<CAP_FOWNER, "CAP_FOWNER" },
1423 { 1<<CAP_FSETID, "CAP_FSETID" },
1424 { 1<<CAP_KILL, "CAP_KILL" },
1425 { 1<<CAP_SETGID, "CAP_SETGID" },
1426 { 1<<CAP_SETUID, "CAP_SETUID" },
1427 { 1<<CAP_SETPCAP, "CAP_SETPCAP" },
1428 { 1<<CAP_LINUX_IMMUTABLE,"CAP_LINUX_IMMUTABLE"},
1429 { 1<<CAP_NET_BIND_SERVICE,"CAP_NET_BIND_SERVICE"},
1430 { 1<<CAP_NET_BROADCAST, "CAP_NET_BROADCAST"},
1431 { 1<<CAP_NET_ADMIN, "CAP_NET_ADMIN" },
1432 { 1<<CAP_NET_RAW, "CAP_NET_RAW" },
1433 { 1<<CAP_IPC_LOCK, "CAP_IPC_LOCK" },
1434 { 1<<CAP_IPC_OWNER, "CAP_IPC_OWNER" },
1435 { 1<<CAP_SYS_MODULE, "CAP_SYS_MODULE"},
1436 { 1<<CAP_SYS_RAWIO, "CAP_SYS_RAWIO" },
1437 { 1<<CAP_SYS_CHROOT, "CAP_SYS_CHROOT"},
1438 { 1<<CAP_SYS_PTRACE, "CAP_SYS_PTRACE"},
1439 { 1<<CAP_SYS_PACCT, "CAP_SYS_PACCT" },
1440 { 1<<CAP_SYS_ADMIN, "CAP_SYS_ADMIN" },
1441 { 1<<CAP_SYS_BOOT, "CAP_SYS_BOOT" },
1442 { 1<<CAP_SYS_NICE, "CAP_SYS_NICE" },
1443 { 1<<CAP_SYS_RESOURCE, "CAP_SYS_RESOURCE"},
1444 { 1<<CAP_SYS_TIME, "CAP_SYS_TIME" },
1445 { 1<<CAP_SYS_TTY_CONFIG,"CAP_SYS_TTY_CONFIG"},
1446 { 0, NULL },
1447};
1448
1449
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001450int
1451sys_capget(tcp)
1452struct tcb *tcp;
1453{
Wichert Akkermanc7926982000-04-10 22:22:31 +00001454 static cap_user_header_t arg0 = NULL;
1455 static cap_user_data_t arg1 = NULL;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001456
1457 if(!entering(tcp)) {
Wichert Akkermanc7926982000-04-10 22:22:31 +00001458 if (!arg0) {
1459 if ((arg0 = malloc(sizeof(*arg0))) == NULL) {
Roland McGrath46100d02005-06-01 18:55:42 +00001460 fprintf(stderr, "out of memory\n");
Wichert Akkermanc7926982000-04-10 22:22:31 +00001461 tprintf("%#lx, %#lx", tcp->u_arg[0], tcp->u_arg[1]);
Wichert Akkerman5ae21ea2000-05-01 01:53:59 +00001462 return -1;
Wichert Akkermanc7926982000-04-10 22:22:31 +00001463 }
1464 }
1465 if (!arg1) {
1466 if ((arg1 = malloc(sizeof(*arg1))) == NULL) {
Roland McGrath46100d02005-06-01 18:55:42 +00001467 fprintf(stderr, "out of memory\n");
Wichert Akkermanc7926982000-04-10 22:22:31 +00001468 tprintf("%#lx, %#lx", tcp->u_arg[0], tcp->u_arg[1]);
Wichert Akkerman5ae21ea2000-05-01 01:53:59 +00001469 return -1;
Wichert Akkermanc7926982000-04-10 22:22:31 +00001470 }
1471 }
1472
1473 if (!tcp->u_arg[0])
1474 tprintf("NULL");
1475 else if (!verbose(tcp))
1476 tprintf("%#lx", tcp->u_arg[0]);
1477 else if (umoven(tcp, tcp->u_arg[0], sizeof(*arg0), (char *) arg0) < 0)
1478 tprintf("???");
1479 else {
1480 tprintf("%#x, %d", arg0->version, arg0->pid);
1481 }
1482 tprintf(", ");
1483 if (!tcp->u_arg[1])
1484 tprintf("NULL");
1485 else if (!verbose(tcp))
1486 tprintf("%#lx", tcp->u_arg[1]);
1487 else if (umoven(tcp, tcp->u_arg[1], sizeof(*arg1), (char *) arg1) < 0)
1488 tprintf("???");
1489 else {
1490 tprintf("{");
Roland McGrathb2dee132005-06-01 19:02:36 +00001491 printflags(capabilities, arg1->effective, "CAP_???");
Wichert Akkermanc7926982000-04-10 22:22:31 +00001492 tprintf(", ");
Roland McGrathb2dee132005-06-01 19:02:36 +00001493 printflags(capabilities, arg1->permitted, "CAP_???");
Wichert Akkermanc7926982000-04-10 22:22:31 +00001494 tprintf(", ");
Roland McGrathb2dee132005-06-01 19:02:36 +00001495 printflags(capabilities, arg1->inheritable, "CAP_???");
Wichert Akkermanc7926982000-04-10 22:22:31 +00001496 tprintf("}");
Roland McGrathced50da2004-08-31 06:48:46 +00001497 }
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001498 }
1499 return 0;
1500}
1501
1502int
1503sys_capset(tcp)
1504struct tcb *tcp;
1505{
Wichert Akkermanc7926982000-04-10 22:22:31 +00001506 static cap_user_header_t arg0 = NULL;
1507 static cap_user_data_t arg1 = NULL;
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001508
Wichert Akkermanc7926982000-04-10 22:22:31 +00001509 if(entering(tcp)) {
1510 if (!arg0) {
1511 if ((arg0 = malloc(sizeof(*arg0))) == NULL) {
Roland McGrath46100d02005-06-01 18:55:42 +00001512 fprintf(stderr, "out of memory\n");
Wichert Akkermanc7926982000-04-10 22:22:31 +00001513 tprintf("%#lx, %#lx", tcp->u_arg[0], tcp->u_arg[1]);
Wichert Akkerman5ae21ea2000-05-01 01:53:59 +00001514 return -1;
Wichert Akkermanc7926982000-04-10 22:22:31 +00001515 }
1516 }
1517 if (!arg1) {
1518 if ((arg1 = malloc(sizeof(*arg1))) == NULL) {
Roland McGrath46100d02005-06-01 18:55:42 +00001519 fprintf(stderr, "out of memory\n");
Wichert Akkermanc7926982000-04-10 22:22:31 +00001520 tprintf("%#lx, %#lx", tcp->u_arg[0], tcp->u_arg[1]);
Wichert Akkerman5ae21ea2000-05-01 01:53:59 +00001521 return -1;
Wichert Akkermanc7926982000-04-10 22:22:31 +00001522 }
1523 }
1524
1525 if (!tcp->u_arg[0])
1526 tprintf("NULL");
1527 else if (!verbose(tcp))
1528 tprintf("%#lx", tcp->u_arg[0]);
1529 else if (umoven(tcp, tcp->u_arg[0], sizeof(*arg0), (char *) arg0) < 0)
1530 tprintf("???");
1531 else {
1532 tprintf("%#x, %d", arg0->version, arg0->pid);
1533 }
1534 tprintf(", ");
1535 if (!tcp->u_arg[1])
1536 tprintf("NULL");
1537 else if (!verbose(tcp))
1538 tprintf("%#lx", tcp->u_arg[1]);
1539 else if (umoven(tcp, tcp->u_arg[1], sizeof(*arg1), (char *) arg1) < 0)
1540 tprintf("???");
1541 else {
1542 tprintf("{");
Roland McGrathb2dee132005-06-01 19:02:36 +00001543 printflags(capabilities, arg1->effective, "CAP_???");
Wichert Akkermanc7926982000-04-10 22:22:31 +00001544 tprintf(", ");
Roland McGrathb2dee132005-06-01 19:02:36 +00001545 printflags(capabilities, arg1->permitted, "CAP_???");
Wichert Akkermanc7926982000-04-10 22:22:31 +00001546 tprintf(", ");
Roland McGrathb2dee132005-06-01 19:02:36 +00001547 printflags(capabilities, arg1->inheritable, "CAP_???");
Wichert Akkermanc7926982000-04-10 22:22:31 +00001548 tprintf("}");
Roland McGrathced50da2004-08-31 06:48:46 +00001549 }
Wichert Akkerman76baf7c1999-02-19 00:21:36 +00001550 }
1551 return 0;
1552}
1553
1554#else
1555
1556int sys_capget(tcp)
1557struct tcb *tcp;
1558{
1559 return printargs(tcp);
1560}
1561
1562int sys_capset(tcp)
1563struct tcb *tcp;
1564{
1565 return printargs(tcp);
1566}
1567
1568#endif
1569
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001570#ifdef LINUX
Roland McGrathd9f816f2004-09-04 03:39:20 +00001571static const struct xlat sysctl_root[] = {
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001572 { CTL_KERN, "CTL_KERN" },
1573 { CTL_VM, "CTL_VM" },
1574 { CTL_NET, "CTL_NET" },
1575 { CTL_PROC, "CTL_PROC" },
1576 { CTL_FS, "CTL_FS" },
1577 { CTL_DEBUG, "CTL_DEBUG" },
1578 { CTL_DEV, "CTL_DEV" },
1579 { 0, NULL }
1580};
1581
Roland McGrathd9f816f2004-09-04 03:39:20 +00001582static const struct xlat sysctl_kern[] = {
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001583 { KERN_OSTYPE, "KERN_OSTYPE" },
1584 { KERN_OSRELEASE, "KERN_OSRELEASE" },
1585 { KERN_OSREV, "KERN_OSREV" },
1586 { KERN_VERSION, "KERN_VERSION" },
1587 { KERN_SECUREMASK, "KERN_SECUREMASK" },
1588 { KERN_PROF, "KERN_PROF" },
1589 { KERN_NODENAME, "KERN_NODENAME" },
1590 { KERN_DOMAINNAME, "KERN_DOMAINNAME" },
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001591#ifdef KERN_SECURELVL
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001592 { KERN_SECURELVL, "KERN_SECURELVL" },
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001593#endif
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001594 { KERN_PANIC, "KERN_PANIC" },
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001595#ifdef KERN_REALROOTDEV
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001596 { KERN_REALROOTDEV, "KERN_REALROOTDEV" },
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001597#endif
1598#ifdef KERN_JAVA_INTERPRETER
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001599 { KERN_JAVA_INTERPRETER, "KERN_JAVA_INTERPRETER" },
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001600#endif
1601#ifdef KERN_JAVA_APPLETVIEWER
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001602 { KERN_JAVA_APPLETVIEWER, "KERN_JAVA_APPLETVIEWER" },
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001603#endif
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001604 { KERN_SPARC_REBOOT, "KERN_SPARC_REBOOT" },
1605 { KERN_CTLALTDEL, "KERN_CTLALTDEL" },
1606 { KERN_PRINTK, "KERN_PRINTK" },
1607 { KERN_NAMETRANS, "KERN_NAMETRANS" },
1608 { KERN_PPC_HTABRECLAIM, "KERN_PPC_HTABRECLAIM" },
1609 { KERN_PPC_ZEROPAGED, "KERN_PPC_ZEROPAGED" },
1610 { KERN_PPC_POWERSAVE_NAP, "KERN_PPC_POWERSAVE_NAP" },
1611 { KERN_MODPROBE, "KERN_MODPROBE" },
1612 { KERN_SG_BIG_BUFF, "KERN_SG_BIG_BUFF" },
1613 { KERN_ACCT, "KERN_ACCT" },
1614 { KERN_PPC_L2CR, "KERN_PPC_L2CR" },
1615 { KERN_RTSIGNR, "KERN_RTSIGNR" },
1616 { KERN_RTSIGMAX, "KERN_RTSIGMAX" },
1617 { KERN_SHMMAX, "KERN_SHMMAX" },
1618 { KERN_MSGMAX, "KERN_MSGMAX" },
1619 { KERN_MSGMNB, "KERN_MSGMNB" },
1620 { KERN_MSGPOOL, "KERN_MSGPOOL" },
1621 { 0, NULL }
1622};
1623
Roland McGrathd9f816f2004-09-04 03:39:20 +00001624static const struct xlat sysctl_vm[] = {
Roland McGratha796fd02004-03-01 22:10:54 +00001625#ifdef VM_SWAPCTL
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001626 { VM_SWAPCTL, "VM_SWAPCTL" },
Roland McGratha796fd02004-03-01 22:10:54 +00001627#endif
1628#ifdef VM_UNUSED1
1629 { VM_UNUSED1, "VM_UNUSED1" },
1630#endif
1631#ifdef VM_SWAPOUT
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001632 { VM_SWAPOUT, "VM_SWAPOUT" },
Roland McGratha796fd02004-03-01 22:10:54 +00001633#endif
1634#ifdef VM_UNUSED2
1635 { VM_UNUSED2, "VM_UNUSED2" },
1636#endif
1637#ifdef VM_FREEPG
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001638 { VM_FREEPG, "VM_FREEPG" },
Roland McGratha796fd02004-03-01 22:10:54 +00001639#endif
1640#ifdef VM_UNUSED3
1641 { VM_UNUSED3, "VM_UNUSED3" },
1642#endif
1643#ifdef VM_BDFLUSH
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001644 { VM_BDFLUSH, "VM_BDFLUSH" },
Roland McGratha796fd02004-03-01 22:10:54 +00001645#endif
1646#ifdef VM_UNUSED4
1647 { VM_UNUSED4, "VM_UNUSED4" },
1648#endif
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001649 { VM_OVERCOMMIT_MEMORY, "VM_OVERCOMMIT_MEMORY" },
Roland McGratha796fd02004-03-01 22:10:54 +00001650#ifdef VM_BUFFERMEM
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001651 { VM_BUFFERMEM, "VM_BUFFERMEM" },
Roland McGratha796fd02004-03-01 22:10:54 +00001652#endif
1653#ifdef VM_UNUSED5
1654 { VM_UNUSED5, "VM_UNUSED5" },
1655#endif
1656#ifdef VM_PAGECACHE
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001657 { VM_PAGECACHE, "VM_PAGECACHE" },
Roland McGratha796fd02004-03-01 22:10:54 +00001658#endif
1659#ifdef VM_UNUSED7
1660 { VM_UNUSED7, "VM_UNUSED7" },
1661#endif
1662#ifdef VM_PAGERDAEMON
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001663 { VM_PAGERDAEMON, "VM_PAGERDAEMON" },
Roland McGratha796fd02004-03-01 22:10:54 +00001664#endif
1665#ifdef VM_UNUSED8
1666 { VM_UNUSED8, "VM_UNUSED8" },
1667#endif
1668#ifdef VM_PGT_CACHE
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001669 { VM_PGT_CACHE, "VM_PGT_CACHE" },
Roland McGratha796fd02004-03-01 22:10:54 +00001670#endif
1671#ifdef VM_UNUSED9
1672 { VM_UNUSED9, "VM_UNUSED9" },
1673#endif
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001674 { VM_PAGE_CLUSTER, "VM_PAGE_CLUSTER" },
1675 { 0, NULL },
1676};
1677
Roland McGrathd9f816f2004-09-04 03:39:20 +00001678static const struct xlat sysctl_net[] = {
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001679 { NET_CORE, "NET_CORE" },
1680 { NET_ETHER, "NET_ETHER" },
1681 { NET_802, "NET_802" },
1682 { NET_UNIX, "NET_UNIX" },
1683 { NET_IPV4, "NET_IPV4" },
1684 { NET_IPX, "NET_IPX" },
1685 { NET_ATALK, "NET_ATALK" },
1686 { NET_NETROM, "NET_NETROM" },
1687 { NET_AX25, "NET_AX25" },
1688 { NET_BRIDGE, "NET_BRIDGE" },
1689 { NET_ROSE, "NET_ROSE" },
1690 { NET_IPV6, "NET_IPV6" },
1691 { NET_X25, "NET_X25" },
1692 { NET_TR, "NET_TR" },
1693 { NET_DECNET, "NET_DECNET" },
1694 { 0, NULL }
1695};
1696
Roland McGrathd9f816f2004-09-04 03:39:20 +00001697static const struct xlat sysctl_net_core[] = {
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001698 { NET_CORE_WMEM_MAX, "NET_CORE_WMEM_MAX" },
1699 { NET_CORE_RMEM_MAX, "NET_CORE_RMEM_MAX" },
1700 { NET_CORE_WMEM_DEFAULT, "NET_CORE_WMEM_DEFAULT" },
1701 { NET_CORE_RMEM_DEFAULT, "NET_CORE_RMEM_DEFAULT" },
1702 { NET_CORE_MAX_BACKLOG, "NET_CORE_MAX_BACKLOG" },
1703 { NET_CORE_FASTROUTE, "NET_CORE_FASTROUTE" },
1704 { NET_CORE_MSG_COST, "NET_CORE_MSG_COST" },
1705 { NET_CORE_MSG_BURST, "NET_CORE_MSG_BURST" },
1706 { NET_CORE_OPTMEM_MAX, "NET_CORE_OPTMEM_MAX" },
1707 { 0, NULL }
1708};
1709
Roland McGrathd9f816f2004-09-04 03:39:20 +00001710static const struct xlat sysctl_net_unix[] = {
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001711 { NET_UNIX_DESTROY_DELAY, "NET_UNIX_DESTROY_DELAY" },
1712 { NET_UNIX_DELETE_DELAY, "NET_UNIX_DELETE_DELAY" },
1713 { 0, NULL }
1714};
1715
Roland McGrathd9f816f2004-09-04 03:39:20 +00001716static const struct xlat sysctl_net_ipv4[] = {
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001717 { NET_IPV4_FORWARD, "NET_IPV4_FORWARD" },
1718 { NET_IPV4_DYNADDR, "NET_IPV4_DYNADDR" },
1719 { NET_IPV4_CONF, "NET_IPV4_CONF" },
1720 { NET_IPV4_NEIGH, "NET_IPV4_NEIGH" },
1721 { NET_IPV4_ROUTE, "NET_IPV4_ROUTE" },
1722 { NET_IPV4_FIB_HASH, "NET_IPV4_FIB_HASH" },
1723 { NET_IPV4_TCP_TIMESTAMPS, "NET_IPV4_TCP_TIMESTAMPS" },
1724 { NET_IPV4_TCP_WINDOW_SCALING, "NET_IPV4_TCP_WINDOW_SCALING" },
1725 { NET_IPV4_TCP_SACK, "NET_IPV4_TCP_SACK" },
1726 { NET_IPV4_TCP_RETRANS_COLLAPSE, "NET_IPV4_TCP_RETRANS_COLLAPSE" },
1727 { NET_IPV4_DEFAULT_TTL, "NET_IPV4_DEFAULT_TTL" },
1728 { NET_IPV4_AUTOCONFIG, "NET_IPV4_AUTOCONFIG" },
1729 { NET_IPV4_NO_PMTU_DISC, "NET_IPV4_NO_PMTU_DISC" },
1730 { NET_IPV4_TCP_SYN_RETRIES, "NET_IPV4_TCP_SYN_RETRIES" },
1731 { NET_IPV4_IPFRAG_HIGH_THRESH, "NET_IPV4_IPFRAG_HIGH_THRESH" },
1732 { NET_IPV4_IPFRAG_LOW_THRESH, "NET_IPV4_IPFRAG_LOW_THRESH" },
1733 { NET_IPV4_IPFRAG_TIME, "NET_IPV4_IPFRAG_TIME" },
1734 { NET_IPV4_TCP_MAX_KA_PROBES, "NET_IPV4_TCP_MAX_KA_PROBES" },
1735 { NET_IPV4_TCP_KEEPALIVE_TIME, "NET_IPV4_TCP_KEEPALIVE_TIME" },
1736 { NET_IPV4_TCP_KEEPALIVE_PROBES, "NET_IPV4_TCP_KEEPALIVE_PROBES" },
1737 { NET_IPV4_TCP_RETRIES1, "NET_IPV4_TCP_RETRIES1" },
1738 { NET_IPV4_TCP_RETRIES2, "NET_IPV4_TCP_RETRIES2" },
1739 { NET_IPV4_TCP_FIN_TIMEOUT, "NET_IPV4_TCP_FIN_TIMEOUT" },
1740 { NET_IPV4_IP_MASQ_DEBUG, "NET_IPV4_IP_MASQ_DEBUG" },
1741 { NET_TCP_SYNCOOKIES, "NET_TCP_SYNCOOKIES" },
1742 { NET_TCP_STDURG, "NET_TCP_STDURG" },
1743 { NET_TCP_RFC1337, "NET_TCP_RFC1337" },
1744 { NET_TCP_SYN_TAILDROP, "NET_TCP_SYN_TAILDROP" },
1745 { NET_TCP_MAX_SYN_BACKLOG, "NET_TCP_MAX_SYN_BACKLOG" },
1746 { NET_IPV4_LOCAL_PORT_RANGE, "NET_IPV4_LOCAL_PORT_RANGE" },
1747 { NET_IPV4_ICMP_ECHO_IGNORE_ALL, "NET_IPV4_ICMP_ECHO_IGNORE_ALL" },
1748 { NET_IPV4_ICMP_ECHO_IGNORE_BROADCASTS, "NET_IPV4_ICMP_ECHO_IGNORE_BROADCASTS" },
1749 { NET_IPV4_ICMP_SOURCEQUENCH_RATE, "NET_IPV4_ICMP_SOURCEQUENCH_RATE" },
1750 { NET_IPV4_ICMP_DESTUNREACH_RATE, "NET_IPV4_ICMP_DESTUNREACH_RATE" },
1751 { NET_IPV4_ICMP_TIMEEXCEED_RATE, "NET_IPV4_ICMP_TIMEEXCEED_RATE" },
1752 { NET_IPV4_ICMP_PARAMPROB_RATE, "NET_IPV4_ICMP_PARAMPROB_RATE" },
1753 { NET_IPV4_ICMP_ECHOREPLY_RATE, "NET_IPV4_ICMP_ECHOREPLY_RATE" },
1754 { NET_IPV4_ICMP_IGNORE_BOGUS_ERROR_RESPONSES, "NET_IPV4_ICMP_IGNORE_BOGUS_ERROR_RESPONSES" },
1755 { NET_IPV4_IGMP_MAX_MEMBERSHIPS, "NET_IPV4_IGMP_MAX_MEMBERSHIPS" },
1756 { 0, NULL }
1757};
1758
Roland McGrathd9f816f2004-09-04 03:39:20 +00001759static const struct xlat sysctl_net_ipv4_route[] = {
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001760 { NET_IPV4_ROUTE_FLUSH, "NET_IPV4_ROUTE_FLUSH" },
1761 { NET_IPV4_ROUTE_MIN_DELAY, "NET_IPV4_ROUTE_MIN_DELAY" },
1762 { NET_IPV4_ROUTE_MAX_DELAY, "NET_IPV4_ROUTE_MAX_DELAY" },
1763 { NET_IPV4_ROUTE_GC_THRESH, "NET_IPV4_ROUTE_GC_THRESH" },
1764 { NET_IPV4_ROUTE_MAX_SIZE, "NET_IPV4_ROUTE_MAX_SIZE" },
1765 { NET_IPV4_ROUTE_GC_MIN_INTERVAL, "NET_IPV4_ROUTE_GC_MIN_INTERVAL" },
1766 { NET_IPV4_ROUTE_GC_TIMEOUT, "NET_IPV4_ROUTE_GC_TIMEOUT" },
1767 { NET_IPV4_ROUTE_GC_INTERVAL, "NET_IPV4_ROUTE_GC_INTERVAL" },
1768 { NET_IPV4_ROUTE_REDIRECT_LOAD, "NET_IPV4_ROUTE_REDIRECT_LOAD" },
1769 { NET_IPV4_ROUTE_REDIRECT_NUMBER, "NET_IPV4_ROUTE_REDIRECT_NUMBER" },
1770 { NET_IPV4_ROUTE_REDIRECT_SILENCE, "NET_IPV4_ROUTE_REDIRECT_SILENCE" },
1771 { NET_IPV4_ROUTE_ERROR_COST, "NET_IPV4_ROUTE_ERROR_COST" },
1772 { NET_IPV4_ROUTE_ERROR_BURST, "NET_IPV4_ROUTE_ERROR_BURST" },
1773 { NET_IPV4_ROUTE_GC_ELASTICITY, "NET_IPV4_ROUTE_GC_ELASTICITY" },
1774 { 0, NULL }
1775};
1776
Roland McGrathd9f816f2004-09-04 03:39:20 +00001777static const struct xlat sysctl_net_ipv4_conf[] = {
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001778 { NET_IPV4_CONF_FORWARDING, "NET_IPV4_CONF_FORWARDING" },
1779 { NET_IPV4_CONF_MC_FORWARDING, "NET_IPV4_CONF_MC_FORWARDING" },
1780 { NET_IPV4_CONF_PROXY_ARP, "NET_IPV4_CONF_PROXY_ARP" },
1781 { NET_IPV4_CONF_ACCEPT_REDIRECTS, "NET_IPV4_CONF_ACCEPT_REDIRECTS" },
1782 { NET_IPV4_CONF_SECURE_REDIRECTS, "NET_IPV4_CONF_SECURE_REDIRECTS" },
1783 { NET_IPV4_CONF_SEND_REDIRECTS, "NET_IPV4_CONF_SEND_REDIRECTS" },
1784 { NET_IPV4_CONF_SHARED_MEDIA, "NET_IPV4_CONF_SHARED_MEDIA" },
1785 { NET_IPV4_CONF_RP_FILTER, "NET_IPV4_CONF_RP_FILTER" },
1786 { NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE, "NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE" },
1787 { NET_IPV4_CONF_BOOTP_RELAY, "NET_IPV4_CONF_BOOTP_RELAY" },
1788 { NET_IPV4_CONF_LOG_MARTIANS, "NET_IPV4_CONF_LOG_MARTIANS" },
1789 { 0, NULL }
1790};
1791
Roland McGrathd9f816f2004-09-04 03:39:20 +00001792static const struct xlat sysctl_net_ipv6[] = {
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001793 { NET_IPV6_CONF, "NET_IPV6_CONF" },
1794 { NET_IPV6_NEIGH, "NET_IPV6_NEIGH" },
1795 { NET_IPV6_ROUTE, "NET_IPV6_ROUTE" },
1796 { 0, NULL }
1797};
1798
Roland McGrathd9f816f2004-09-04 03:39:20 +00001799static const struct xlat sysctl_net_ipv6_route[] = {
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001800 { NET_IPV6_ROUTE_FLUSH, "NET_IPV6_ROUTE_FLUSH" },
1801 { NET_IPV6_ROUTE_GC_THRESH, "NET_IPV6_ROUTE_GC_THRESH" },
1802 { NET_IPV6_ROUTE_MAX_SIZE, "NET_IPV6_ROUTE_MAX_SIZE" },
1803 { NET_IPV6_ROUTE_GC_MIN_INTERVAL, "NET_IPV6_ROUTE_GC_MIN_INTERVAL" },
1804 { NET_IPV6_ROUTE_GC_TIMEOUT, "NET_IPV6_ROUTE_GC_TIMEOUT" },
1805 { NET_IPV6_ROUTE_GC_INTERVAL, "NET_IPV6_ROUTE_GC_INTERVAL" },
1806 { NET_IPV6_ROUTE_GC_ELASTICITY, "NET_IPV6_ROUTE_GC_ELASTICITY" },
1807 { 0, NULL }
1808};
1809
1810int
1811sys_sysctl(tcp)
1812struct tcb *tcp;
1813{
1814 struct __sysctl_args info;
1815 int *name;
Roland McGrathaa524c82005-06-01 19:22:06 +00001816 unsigned long size;
1817
Roland McGrath2cbe44e2005-05-26 23:21:09 +00001818 if (umove (tcp, tcp->u_arg[0], &info) < 0)
1819 return printargs(tcp);
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001820
Roland McGrathaa524c82005-06-01 19:22:06 +00001821 size = sizeof (int) * (unsigned long) info.nlen;
1822 name = (size / sizeof (int) != info.nlen) ? NULL : malloc (size);
Roland McGrath2cbe44e2005-05-26 23:21:09 +00001823 if (name == NULL ||
Roland McGrathaa524c82005-06-01 19:22:06 +00001824 umoven(tcp, (unsigned long) info.name, size, (char *) name) < 0) {
1825 free(name);
1826 if (entering(tcp))
1827 tprintf("{%p, %d, %p, %p, %p, %Zu}",
1828 info.name, info.nlen, info.oldval,
1829 info.oldlenp, info.newval, info.newlen);
Roland McGrath2cbe44e2005-05-26 23:21:09 +00001830 return 0;
1831 }
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001832
1833 if (entering(tcp)) {
Roland McGrathaa524c82005-06-01 19:22:06 +00001834 int cnt = 0, max_cnt;
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001835
1836 tprintf("{{");
1837
1838 if (info.nlen == 0)
1839 goto out;
1840 printxval(sysctl_root, name[0], "CTL_???");
1841 ++cnt;
1842
1843 if (info.nlen == 1)
1844 goto out;
1845 switch (name[0]) {
1846 case CTL_KERN:
1847 tprintf(", ");
1848 printxval(sysctl_kern, name[1], "KERN_???");
1849 ++cnt;
1850 break;
1851 case CTL_VM:
1852 tprintf(", ");
1853 printxval(sysctl_vm, name[1], "VM_???");
1854 ++cnt;
1855 break;
1856 case CTL_NET:
1857 tprintf(", ");
1858 printxval(sysctl_net, name[1], "NET_???");
1859 ++cnt;
1860
1861 if (info.nlen == 2)
1862 goto out;
1863 switch (name[1]) {
1864 case NET_CORE:
1865 tprintf(", ");
1866 printxval(sysctl_net_core, name[2],
1867 "NET_CORE_???");
1868 break;
1869 case NET_UNIX:
1870 tprintf(", ");
1871 printxval(sysctl_net_unix, name[2],
1872 "NET_UNIX_???");
1873 break;
1874 case NET_IPV4:
1875 tprintf(", ");
1876 printxval(sysctl_net_ipv4, name[2],
1877 "NET_IPV4_???");
1878
1879 if (info.nlen == 3)
1880 goto out;
1881 switch (name[2]) {
1882 case NET_IPV4_ROUTE:
1883 tprintf(", ");
1884 printxval(sysctl_net_ipv4_route,
1885 name[3],
1886 "NET_IPV4_ROUTE_???");
1887 break;
1888 case NET_IPV4_CONF:
1889 tprintf(", ");
1890 printxval(sysctl_net_ipv4_conf,
1891 name[3],
1892 "NET_IPV4_CONF_???");
1893 break;
1894 default:
1895 goto out;
1896 }
1897 break;
1898 case NET_IPV6:
1899 tprintf(", ");
1900 printxval(sysctl_net_ipv6, name[2],
1901 "NET_IPV6_???");
1902
1903 if (info.nlen == 3)
1904 goto out;
1905 switch (name[2]) {
1906 case NET_IPV6_ROUTE:
1907 tprintf(", ");
1908 printxval(sysctl_net_ipv6_route,
1909 name[3],
1910 "NET_IPV6_ROUTE_???");
1911 break;
1912 default:
1913 goto out;
1914 }
1915 break;
1916 default:
1917 goto out;
1918 }
1919 break;
1920 default:
1921 goto out;
1922 }
1923 out:
Roland McGrath8e4a3e62006-01-12 11:03:46 +00001924 max_cnt = info.nlen;
1925 if (abbrev(tcp) && max_cnt > max_strlen)
1926 max_cnt = max_strlen;
Roland McGrathaa524c82005-06-01 19:22:06 +00001927 while (cnt < max_cnt)
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001928 tprintf(", %x", name[cnt++]);
Roland McGrathaa524c82005-06-01 19:22:06 +00001929 if (cnt < info.nlen)
1930 tprintf(", ...");
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001931 tprintf("}, %d, ", info.nlen);
1932 } else {
1933 size_t oldlen;
Roland McGrathaa524c82005-06-01 19:22:06 +00001934 if (umove(tcp, (size_t)info.oldlenp, &oldlen) >= 0
1935 && info.nlen >= 2
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001936 && ((name[0] == CTL_KERN
1937 && (name[1] == KERN_OSRELEASE
1938 || name[1] == KERN_OSTYPE
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001939#ifdef KERN_JAVA_INTERPRETER
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001940 || name[1] == KERN_JAVA_INTERPRETER
Wichert Akkerman9ce1a631999-08-29 23:15:07 +00001941#endif
1942#ifdef KERN_JAVA_APPLETVIEWER
1943 || name[1] == KERN_JAVA_APPLETVIEWER
1944#endif
1945 )))) {
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001946 printpath(tcp, (size_t)info.oldval);
Wichert Akkerman8b1b40c2000-02-03 21:58:30 +00001947 tprintf(", %Zu, ", oldlen);
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001948 if (info.newval == 0)
1949 tprintf("NULL");
1950 else if (syserror(tcp))
1951 tprintf("%p", info.newval);
1952 else
1953 printpath(tcp, (size_t)info.newval);
1954 tprintf(", %Zd", info.newlen);
1955 } else {
Wichert Akkerman8b1b40c2000-02-03 21:58:30 +00001956 tprintf("%p, %Zd, %p, %Zd", info.oldval, oldlen,
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001957 info.newval, info.newlen);
1958 }
1959 tprintf("}");
1960 }
Roland McGrath2cbe44e2005-05-26 23:21:09 +00001961
1962 free(name);
Wichert Akkerman22fe9d21999-05-27 12:00:57 +00001963 return 0;
1964}
1965#else
1966int sys_sysctl(tcp)
1967struct tcb *tcp;
1968{
1969 return printargs(tcp);
1970}
1971#endif
1972
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001973#ifdef FREEBSD
1974#include <sys/sysctl.h>
1975
1976int sys___sysctl(tcp)
1977struct tcb *tcp;
1978{
1979 int qoid[CTL_MAXNAME+2];
1980 char ctl[1024];
1981 size_t len;
1982 int i, numeric;
Roland McGrathced50da2004-08-31 06:48:46 +00001983
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00001984 if (entering(tcp)) {
1985 if (tcp->u_arg[1] < 0 || tcp->u_arg[1] > CTL_MAXNAME ||
1986 (umoven(tcp, tcp->u_arg[0], tcp->u_arg[1] * sizeof(int),
1987 (char *) (qoid + 2)) < 0))
1988 tprintf("[...], ");
1989 else {
1990 /* Use sysctl to ask the name of the current MIB
1991 This uses the undocumented "Staff-functions" used
1992 by the sysctl program. See kern_sysctl.c for
1993 details. */
1994 qoid[0] = 0; /* sysctl */
1995 qoid[1] = 1; /* name */
1996 i = sizeof(ctl);
1997 tprintf("[");
1998 if (sysctl(qoid, tcp->u_arg[1] + 2, ctl, &i, 0, 0) >= 0) {
1999 numeric = !abbrev(tcp);
2000 tprintf("%s%s", ctl, numeric ? ", " : "");
2001 } else
2002 numeric = 1;
2003 if (numeric) {
2004 for (i = 0; i < tcp->u_arg[1]; i++)
2005 tprintf("%s%d", i ? "." : "", qoid[i + 2]);
2006 }
2007 tprintf("], ");
2008 tprintf("%lu, ", tcp->u_arg[1]);
2009 }
2010 } else {
2011 if (!syserror(tcp) && (umove(tcp, tcp->u_arg[3], &len) >= 0)) {
2012 printstr(tcp, tcp->u_arg[2], len);
2013 tprintf(", [%u], ", len);
Roland McGrathced50da2004-08-31 06:48:46 +00002014 } else
Wichert Akkermanbf79f2e2000-09-01 21:03:06 +00002015 tprintf("%#lx, %#lx, ", tcp->u_arg[2], tcp->u_arg[3]);
2016 printstr(tcp, tcp->u_arg[4], tcp->u_arg[5]);
2017 tprintf(", %lu", tcp->u_arg[5]);
2018 }
2019 return 0;
2020}
2021#endif
Wichert Akkerman16a03d22000-08-10 02:14:04 +00002022
2023#if UNIXWARE >= 2
2024
2025#include <sys/ksym.h>
2026#include <sys/elf.h>
2027
Roland McGrathd9f816f2004-09-04 03:39:20 +00002028static const struct xlat ksym_flags[] = {
Roland McGrathced50da2004-08-31 06:48:46 +00002029 { STT_NOTYPE, "STT_NOTYPE" },
2030 { STT_FUNC, "STT_FUNC" },
2031 { STT_OBJECT, "STT_OBJECT" },
Wichert Akkerman16a03d22000-08-10 02:14:04 +00002032 { 0, NULL },
2033};
2034
2035int
2036sys_getksym(tcp)
2037struct tcb *tcp;
2038{
2039 if (entering (tcp)) {
2040 printstr(tcp, tcp->u_arg[0], -1);
2041 tprintf(", ");
2042 }
2043 else {
2044 if (syserror(tcp)) {
2045 tprintf("%#lx, %#lx",
2046 tcp->u_arg[1], tcp->u_arg[2]);
2047 }
2048 else {
2049 int val;
2050 printnum (tcp, tcp->u_arg[1], "%#lx");
2051 tprintf(", ");
2052 if (umove(tcp, tcp->u_arg[2], &val) < 0) {
2053 tprintf("%#lx", tcp->u_arg[2]);
2054 }
2055 else {
2056 tprintf("[");
2057 printxval (ksym_flags, val, "STT_???");
2058 tprintf("]");
2059 }
2060 }
2061 }
2062
2063 return 0;
2064}
2065
Roland McGrath5ef24ab2004-02-20 02:22:35 +00002066#ifdef HAVE_SYS_NSCSYS_H
John Hughes4e36a812001-04-18 15:11:51 +00002067
John Hughes0aadba42001-10-16 18:19:52 +00002068struct cred;
John Hughes4e36a812001-04-18 15:11:51 +00002069#include <sys/nscsys.h>
2070
Roland McGrathd9f816f2004-09-04 03:39:20 +00002071static const struct xlat ssi_cmd [] = {
John Hughes4e36a812001-04-18 15:11:51 +00002072 { SSISYS_BADOP, "SSISYS_BADOP" },
2073 { SSISYS_LDLVL_INIT,"SSISYS_LDLVL_INIT"},
2074 { SSISYS_LDLVL_GETVEC,"SSISYS_LDLVL_GETVEC"},
2075 { SSISYS_LDLVL_PUTVEC,"SSISYS_LDLVL_PUTVEC"},
2076 { SSISYS_LDLVL_PUTRCMDS,"SSISYS_LDLVL_PUTRCMDS"},
2077 { SSISYS_LDLVL_SETREXEC,"SSISYS_LDLVL_SETREXEC"},
2078 { SSISYS_CMS_CLUSTERID,"SSISYS_CMS_CLUSTERID"},
2079 { SSISYS_CFS_STATVFS,"SSISYS_CFS_STATVFS"},
2080 { SSISYS_NODE_GETNUM,"SSISYS_NODE_GETNUM"},
2081 { SSISYS_NODE_TABLE,"SSISYS_NODE_TABLE"},
2082 { SSISYS_NODE_DOWN,"SSISYS_NODE_DOWN"},
2083 { SSISYS_RECLAIM_CHILD,"SSISYS_RECLAIM_CHILD"},
2084 { SSISYS_IPC_GETINFO,"SSISYS_IPC_GETINFO"},
2085 { SSISYS_ICS_TEST,"SSISYS_ICS_TEST"},
2086 { SSISYS_NODE_PID,"SSISYS_NODE_PID"},
2087 { SSISYS_ISLOCAL,"SSISYS_ISLOCAL"},
2088 { SSISYS_CFS_ISSTACKED,"SSISYS_CFS_ISSTACKED"},
2089 { SSISYS_DNET_SYNC,"SSISYS_DNET_SYNC"},
2090 { SSISYS_CFS_WAIT_MODE,"SSISYS_CFS_WAIT_MODE"},
2091 { SSISYS_CFS_UMOUNT,"SSISYS_CFS_UMOUNT"},
2092 { SSISYS_LLSTAT,"SSISYS_LLSTAT" },
2093 { SSISYS_LTS_PERFTEST,"SSISYS_LTS_PERFTEST"},
2094 { SSISYS_LTS_CONFIG,"SSISYS_LTS_CONFIG"},
2095 { SSISYS_SNET_PERFTEST,"SSISYS_SNET_PERFTEST"},
2096 { SSISYS_IGNORE_HALFUP,"SSISYS_IGNORE_HALFUP"},
2097 { SSISYS_NODE_ROOTDEV,"SSISYS_NODE_ROOTDEV"},
2098 { SSISYS_GET_PRIMARY,"SSISYS_GET_PRIMARY"},
2099 { SSISYS_GET_SECONDARY,"SSISYS_GET_SECONDARY"},
2100 { SSISYS_GET_ROOTDISK,"SSISYS_GET_ROOTDISK"},
2101 { SSISYS_CLUSTERNODE_NUM,"SSISYS_CLUSTERNODE_NUM"},
2102 { SSISYS_CLUSTER_MEMBERSHIP,"SSISYS_CLUSTER_MEMBERSHIP"},
2103 { SSISYS_CLUSTER_DETAILEDTRANS,"SSISYS_CLUSTER_DETAILEDTRANS"},
2104 { SSISYS_CLUSTERNODE_INFO,"SSISYS_CLUSTERNODE_INFO"},
2105 { SSISYS_CLUSTERNODE_SETINFO,"SSISYS_CLUSTERNODE_SETINFO"},
2106 { SSISYS_CLUSTERNODE_AVAIL,"SSISYS_CLUSTERNODE_AVAIL"},
2107 { SSISYS_CLUSTER_MAXNODES,"SSISYS_CLUSTER_MAXNODES"},
2108 { SSISYS_SET_MEMPRIO,"SSISYS_SET_MEMPRIO"},
2109 { SSISYS_GET_USERS,"SSISYS_GET_USERS"},
2110 { SSISYS_FORCE_ROOT_NODE,"SSISYS_FORCE_ROOT_NODE"},
2111 { SSISYS_CVIP_SET,"SSISYS_CVIP_SET"},
2112 { SSISYS_CVIP_GET,"SSISYS_CVIP_GET"},
2113 { SSISYS_GET_NODE_COUNTS,"SSISYS_GET_NODE_COUNTS"},
2114 { SSISYS_GET_TRANSPORT,"SSISYS_GET_TRANSPORT"},
2115 { 0, NULL },
2116};
2117
2118int sys_ssisys (tcp)
2119struct tcb *tcp;
2120{
2121 struct ssisys_iovec iov;
John Hughes2d8b2c52001-10-18 14:52:24 +00002122 cls_nodeinfo_args_t cni;
2123 clusternode_info_t info;
2124
John Hughes4e36a812001-04-18 15:11:51 +00002125 if (entering (tcp)) {
John Hughes0aadba42001-10-16 18:19:52 +00002126 ts_reclaim_child_inargs_t trc;
John Hughes4e36a812001-04-18 15:11:51 +00002127 if (tcp->u_arg[1] != sizeof iov ||
2128 umove (tcp, tcp->u_arg[0], &iov) < 0)
2129 {
2130 tprintf ("%#lx, %ld", tcp->u_arg[0], tcp->u_arg[1]);
2131 return 0;
2132 }
2133 tprintf ("{id=");
2134 printxval(ssi_cmd, iov.tio_id.id_cmd, "SSISYS_???");
2135 tprintf (":%d", iov.tio_id.id_ver);
2136 switch (iov.tio_id.id_cmd) {
John Hughes0aadba42001-10-16 18:19:52 +00002137 case SSISYS_RECLAIM_CHILD:
2138 if (iov.tio_udatainlen != sizeof trc ||
2139 umove (tcp, (long) iov.tio_udatain, &trc) < 0)
2140 goto bad;
2141 tprintf (", in={pid=%ld, start=%ld}",
Roland McGrath5ef24ab2004-02-20 02:22:35 +00002142 trc.trc_pid, trc.trc_start);
John Hughes0aadba42001-10-16 18:19:52 +00002143 break;
2144 case SSISYS_CLUSTERNODE_INFO:
2145 if (iov.tio_udatainlen != sizeof cni ||
2146 umove (tcp, (long) iov.tio_udatain, &cni) < 0)
2147 goto bad;
2148 tprintf (", in={node=%ld, len=%d}",
2149 cni.nodenum, cni.info_len);
2150 break;
John Hughes4e36a812001-04-18 15:11:51 +00002151 default:
John Hughes0aadba42001-10-16 18:19:52 +00002152 bad:
John Hughes4e36a812001-04-18 15:11:51 +00002153 if (iov.tio_udatainlen) {
2154 tprintf (", in=[/* %d bytes */]",
2155 iov.tio_udatainlen);
2156 }
2157 }
2158 }
2159 else {
John Hughes2d8b2c52001-10-18 14:52:24 +00002160 if (tcp->u_arg[1] != sizeof iov ||
2161 umove (tcp, tcp->u_arg[0], &iov) < 0)
2162 goto done;
John Hughes4e36a812001-04-18 15:11:51 +00002163 switch (iov.tio_id.id_cmd) {
John Hughes2d8b2c52001-10-18 14:52:24 +00002164 case SSISYS_CLUSTERNODE_INFO:
2165 if (iov.tio_udatainlen != sizeof cni ||
2166 umove (tcp, (long) iov.tio_udatain, &cni) < 0)
2167 goto bad_out;
Roland McGrathced50da2004-08-31 06:48:46 +00002168 if (cni.info_len != sizeof info ||
Roland McGrath5ef24ab2004-02-20 02:22:35 +00002169 iov.tio_udataoutlen != sizeof &info ||
John Hughes2d8b2c52001-10-18 14:52:24 +00002170 umove (tcp, (long) iov.tio_udataout, &info) < 0)
2171 goto bad_out;
2172 tprintf (", out={node=%ld, cpus=%d, online=%d}",
2173 info.node_num, info.node_totalcpus,
2174 info.node_onlinecpus);
2175 break;
Roland McGrathced50da2004-08-31 06:48:46 +00002176
John Hughes4e36a812001-04-18 15:11:51 +00002177 default:
John Hughes2d8b2c52001-10-18 14:52:24 +00002178 bad_out:
John Hughes4e36a812001-04-18 15:11:51 +00002179 if (iov.tio_udataoutlen) {
2180 tprintf (", out=[/* %d bytes */]",
2181 iov.tio_udataoutlen);
2182 }
2183 }
John Hughes2d8b2c52001-10-18 14:52:24 +00002184 done:
John Hughes4e36a812001-04-18 15:11:51 +00002185 tprintf ("}, %ld", tcp->u_arg[1]);
2186 }
2187 return 0;
2188}
2189
Roland McGrath5ef24ab2004-02-20 02:22:35 +00002190#endif
John Hughes4e36a812001-04-18 15:11:51 +00002191
Roland McGrath5ef24ab2004-02-20 02:22:35 +00002192#endif /* UNIXWARE > 2 */
Wichert Akkerman0cbfb322001-02-19 13:35:53 +00002193
2194#ifdef MIPS
2195
Wichert Akkermand6b92492001-04-07 21:37:12 +00002196#ifndef __NEW_UTS_LEN
2197#define __NEW_UTS_LEN 64
2198#endif
2199
Roland McGrathd9f816f2004-09-04 03:39:20 +00002200static const struct xlat sysmips_operations[] = {
Wichert Akkerman0cbfb322001-02-19 13:35:53 +00002201 { SETNAME, "SETNAME" },
2202 { FLUSH_CACHE, "FLUSH_CACHE" },
2203 { MIPS_FIXADE, "MIPS_FIXADE" },
2204 { MIPS_RDNVRAM, "MIPS_RDNVRAM" },
2205 { MIPS_ATOMIC_SET, "MIPS_ATOMIC_SET" },
2206 { 0, NULL }
2207};
2208
2209int sys_sysmips(tcp)
2210struct tcb *tcp;
2211{
2212 if (entering(tcp)) {
Wichert Akkerman3472dd52001-04-10 10:27:52 +00002213 printxval(sysmips_operations, tcp->u_arg[0], "???");
Wichert Akkerman0cbfb322001-02-19 13:35:53 +00002214 if (!verbose(tcp)) {
Wichert Akkerman3472dd52001-04-10 10:27:52 +00002215 tprintf("%ld, %ld, %ld", tcp->u_arg[1], tcp->u_arg[2], tcp->u_arg[3]);
Wichert Akkerman0cbfb322001-02-19 13:35:53 +00002216 } else if (tcp->u_arg[0]==SETNAME) {
Wichert Akkerman3472dd52001-04-10 10:27:52 +00002217 char nodename[__NEW_UTS_LEN + 1];
2218 if (umovestr(tcp, tcp->u_arg[1], (__NEW_UTS_LEN + 1), nodename) < 0)
Wichert Akkerman0cbfb322001-02-19 13:35:53 +00002219 tprintf(", %#lx", tcp->u_arg[1]);
2220 else
2221 tprintf(", \"%s\"", nodename);
Wichert Akkerman3472dd52001-04-10 10:27:52 +00002222 } else if (tcp->u_arg[0] == MIPS_ATOMIC_SET) {
2223 tprintf(", %#lx, 0x%lx", tcp->u_arg[1], tcp->u_arg[2]);
2224 } else if (tcp->u_arg[0] == MIPS_FIXADE) {
2225 tprintf(", 0x%lx", tcp->u_arg[1]);
Wichert Akkerman0cbfb322001-02-19 13:35:53 +00002226 } else {
Wichert Akkerman3472dd52001-04-10 10:27:52 +00002227 tprintf("%ld, %ld, %ld", tcp->u_arg[1], tcp->u_arg[2], tcp->u_arg[3]);
Wichert Akkerman0cbfb322001-02-19 13:35:53 +00002228 }
2229 }
2230
2231 return 0;
2232}
2233
2234#endif /* MIPS */