system.c revision dacfb6ebd630641d851b6df94c3b4587969a6cfb
1/* 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> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. The name of the author may not be used to endorse or promote products 16 * derived from this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 * 29 * $Id$ 30 */ 31 32#include "defs.h" 33 34#ifdef LINUX 35#define _LINUX_SOCKET_H 36 37#define MS_RDONLY 1 /* Mount read-only */ 38#define MS_NOSUID 2 /* Ignore suid and sgid bits */ 39#define MS_NODEV 4 /* Disallow access to device special files */ 40#define MS_NOEXEC 8 /* Disallow program execution */ 41#define MS_SYNCHRONOUS 16 /* Writes are synced at once */ 42#define MS_REMOUNT 32 /* Alter flags of a mounted FS */ 43 44#include <sys/socket.h> 45#include <netinet/in.h> 46#include <arpa/inet.h> 47 48#ifdef __NR_personality 49/* Workaround for kernel namespace pollution. */ 50#define _LINUX_PTRACE_H 51#define sys_personality kernel_sys_personality 52#include <linux/personality.h> 53#undef sys_personality 54#endif /* __NR_personality */ 55 56#ifdef __NR_capget 57#include <linux/capability.h> 58#endif 59 60#ifdef __NR_cacheflush 61#include <asm/cachectl.h> 62#endif 63 64#ifdef LINUX 65#include <linux/sysctl.h> 66#endif 67 68static struct xlat mount_flags[] = { 69 { MS_RDONLY, "MS_RDONLY" }, 70 { MS_NOSUID, "MS_NOSUID" }, 71 { MS_NODEV, "MS_NODEV" }, 72 { MS_NOEXEC, "MS_NOEXEC" }, 73#ifdef MS_SYNCHRONOUS 74 { MS_SYNCHRONOUS,"MS_SYNCHRONOUS"}, 75#else 76 { MS_SYNC, "MS_SYNC" }, 77#endif 78 { MS_REMOUNT, "MS_REMOUNT" }, 79 { 0, NULL }, 80}; 81 82int 83sys_mount(tcp) 84struct tcb *tcp; 85{ 86 if (entering(tcp)) { 87 printpath(tcp, tcp->u_arg[0]); 88 tprintf(", "); 89 printpath(tcp, tcp->u_arg[1]); 90 tprintf(", "); 91 printpath(tcp, tcp->u_arg[2]); 92 tprintf(", "); 93 printflags(mount_flags, tcp->u_arg[3]); 94 tprintf(", %#lx", tcp->u_arg[4]); 95 } 96 return 0; 97} 98 99int 100sys_umount2(tcp) 101struct tcb *tcp; 102{ 103 if (entering(tcp)) { 104 printstr(tcp, tcp->u_arg[0], -1); 105 tprintf(", "); 106 if (tcp->u_arg[1] & 1) 107 tprintf("MNT_FORCE"); 108 else 109 tprintf("0"); 110 } 111 return 0; 112} 113 114static struct xlat personality_options[] = { 115#ifdef PER_LINUX 116 { PER_LINUX, "PER_LINUX" }, 117#endif 118#ifdef PER_LINUX_32BIT 119 { PER_LINUX_32BIT, "PER_LINUX" }, 120#endif 121#ifdef PER_SVR4 122 { PER_SVR4, "PER_SVR4" }, 123#endif 124#ifdef PER_SVR3 125 { PER_SVR3, "PER_SVR3" }, 126#endif 127#ifdef PER_SCOSVR3 128 { PER_SCOSVR3, "PER_SCOSVR3" }, 129#endif 130#ifdef PER_WYSEV386 131 { PER_WYSEV386, "PER_WYSEV386" }, 132#endif 133#ifdef PER_ISCR4 134 { PER_ISCR4, "PER_ISCR4" }, 135#endif 136#ifdef PER_BSD 137 { PER_BSD, "PER_BSD" }, 138#endif 139#ifdef PER_XENIX 140 { PER_XENIX, "PER_XENIX" }, 141#endif 142 { 0, NULL }, 143}; 144 145int 146sys_personality(tcp) 147struct tcb *tcp; 148{ 149 if (entering(tcp)) 150 printxval(personality_options, tcp->u_arg[0], "PER_???"); 151 return 0; 152} 153 154#ifdef M68K 155static struct xlat cacheflush_scope[] = { 156#ifdef FLUSH_SCOPE_LINE 157 { FLUSH_SCOPE_LINE, "FLUSH_SCOPE_LINE" }, 158#endif 159#ifdef FLUSH_SCOPE_PAGE 160 { FLUSH_SCOPE_PAGE, "FLUSH_SCOPE_PAGE" }, 161#endif 162#ifdef FLUSH_SCOPE_ALL 163 { FLUSH_SCOPE_ALL, "FLUSH_SCOPE_ALL" }, 164#endif 165 { 0, NULL }, 166}; 167 168static struct xlat cacheflush_flags[] = { 169#ifdef FLUSH_CACHE_BOTH 170 { FLUSH_CACHE_BOTH, "FLUSH_CACHE_BOTH" }, 171#endif 172#ifdef FLUSH_CACHE_DATA 173 { FLUSH_CACHE_DATA, "FLUSH_CACHE_DATA" }, 174#endif 175#ifdef FLUSH_CACHE_INSN 176 { FLUSH_CACHE_INSN, "FLUSH_CACHE_INSN" }, 177#endif 178 { 0, NULL }, 179}; 180 181int 182sys_cacheflush(tcp) 183struct tcb *tcp; 184{ 185 if (entering(tcp)) { 186 /* addr */ 187 tprintf("%#lx, ", tcp->u_arg[0]); 188 /* scope */ 189 printxval(cacheflush_scope, tcp->u_arg[1], "FLUSH_SCOPE_???"); 190 tprintf(", "); 191 /* flags */ 192 printflags(cacheflush_flags, tcp->u_arg[2]); 193 /* len */ 194 tprintf(", %lu", tcp->u_arg[3]); 195 } 196 return 0; 197} 198#endif /* M68K */ 199 200#endif /* LINUX */ 201 202#ifdef SUNOS4 203 204#include <sys/reboot.h> 205#define NFSCLIENT 206#define LOFS 207#define RFS 208#define PCFS 209#include <sys/mount.h> 210#include <sys/socket.h> 211#include <nfs/export.h> 212#include <rpc/types.h> 213#include <rpc/auth.h> 214 215/*ARGSUSED*/ 216int 217sys_sync(tcp) 218struct tcb *tcp; 219{ 220 return 0; 221} 222 223static struct xlat bootflags[] = { 224 { RB_AUTOBOOT, "RB_AUTOBOOT" }, /* for system auto-booting itself */ 225 { RB_ASKNAME, "RB_ASKNAME" }, /* ask for file name to reboot from */ 226 { RB_SINGLE, "RB_SINGLE" }, /* reboot to single user only */ 227 { RB_NOSYNC, "RB_NOSYNC" }, /* dont sync before reboot */ 228 { RB_HALT, "RB_HALT" }, /* don't reboot, just halt */ 229 { RB_INITNAME, "RB_INITNAME" }, /* name given for /etc/init */ 230 { RB_NOBOOTRC, "RB_NOBOOTRC" }, /* don't run /etc/rc.boot */ 231 { RB_DEBUG, "RB_DEBUG" }, /* being run under debugger */ 232 { RB_DUMP, "RB_DUMP" }, /* dump system core */ 233 { RB_WRITABLE, "RB_WRITABLE" }, /* mount root read/write */ 234 { RB_STRING, "RB_STRING" }, /* pass boot args to prom monitor */ 235 { 0, NULL }, 236}; 237 238int 239sys_reboot(tcp) 240struct tcb *tcp; 241{ 242 if (entering(tcp)) { 243 if (!printflags(bootflags, tcp->u_arg[0])) 244 tprintf("RB_???"); 245 if (tcp->u_arg[0] & RB_STRING) { 246 printstr(tcp, tcp->u_arg[1], -1); 247 } 248 } 249 return 0; 250} 251 252int 253sys_sysacct(tcp) 254struct tcb *tcp; 255{ 256 if (entering(tcp)) { 257 printstr(tcp, tcp->u_arg[0], -1); 258 } 259 return 0; 260} 261 262int 263sys_swapon(tcp) 264struct tcb *tcp; 265{ 266 if (entering(tcp)) { 267 printstr(tcp, tcp->u_arg[0], -1); 268 } 269 return 0; 270} 271 272int 273sys_nfs_svc(tcp) 274struct tcb *tcp; 275{ 276 if (entering(tcp)) { 277 printsock(tcp, tcp->u_arg[0]); 278 } 279 return 0; 280} 281 282static struct xlat mountflags[] = { 283 { M_RDONLY, "M_RDONLY" }, 284 { M_NOSUID, "M_NOSUID" }, 285 { M_NEWTYPE, "M_NEWTYPE" }, 286 { M_GRPID, "M_GRPID" }, 287#ifdef M_REMOUNT 288 { M_REMOUNT, "M_REMOUNT" }, 289#endif 290#ifdef M_NOSUB 291 { M_NOSUB, "M_NOSUB" }, 292#endif 293#ifdef M_MULTI 294 { M_MULTI, "M_MULTI" }, 295#endif 296#ifdef M_SYS5 297 { M_SYS5, "M_SYS5" }, 298#endif 299 { 0, NULL }, 300}; 301 302static struct xlat nfsflags[] = { 303 { NFSMNT_SOFT, "NFSMNT_SOFT" }, 304 { NFSMNT_WSIZE, "NFSMNT_WSIZE" }, 305 { NFSMNT_RSIZE, "NFSMNT_RSIZE" }, 306 { NFSMNT_TIMEO, "NFSMNT_TIMEO" }, 307 { NFSMNT_RETRANS, "NFSMNT_RETRANS" }, 308 { NFSMNT_HOSTNAME, "NFSMNT_HOSTNAME" }, 309 { NFSMNT_INT, "NFSMNT_INT" }, 310 { NFSMNT_NOAC, "NFSMNT_NOAC" }, 311 { NFSMNT_ACREGMIN, "NFSMNT_ACREGMIN" }, 312 { NFSMNT_ACREGMAX, "NFSMNT_ACREGMAX" }, 313 { NFSMNT_ACDIRMIN, "NFSMNT_ACDIRMIN" }, 314 { NFSMNT_ACDIRMAX, "NFSMNT_ACDIRMAX" }, 315#ifdef NFSMNT_SECURE 316 { NFSMNT_SECURE, "NFSMNT_SECURE" }, 317#endif 318#ifdef NFSMNT_NOCTO 319 { NFSMNT_NOCTO, "NFSMNT_NOCTO" }, 320#endif 321#ifdef NFSMNT_POSIX 322 { NFSMNT_POSIX, "NFSMNT_POSIX" }, 323#endif 324 { 0, NULL }, 325}; 326 327int 328sys_mount(tcp) 329struct tcb *tcp; 330{ 331 char type[4]; 332 333 if (entering(tcp)) { 334 if (!(tcp->u_arg[2] & M_NEWTYPE) || umovestr(tcp, 335 tcp->u_arg[0], sizeof type, type) < 0) { 336 tprintf("OLDTYPE:#%lx", tcp->u_arg[0]); 337 } else { 338 tprintf("\"%s\", ", type); 339 } 340 printstr(tcp, tcp->u_arg[1], -1); 341 tprintf(", "); 342 if (!printflags(mountflags, tcp->u_arg[2] & ~M_NEWTYPE)) 343 tprintf("0"); 344 tprintf(", "); 345 346 if (strcmp(type, "4.2") == 0) { 347 struct ufs_args a; 348 if (umove(tcp, tcp->u_arg[3], &a) < 0) 349 return 0; 350 printstr(tcp, (int)a.fspec, -1); 351 } else if (strcmp(type, "lo") == 0) { 352 struct lo_args a; 353 if (umove(tcp, tcp->u_arg[3], &a) < 0) 354 return 0; 355 printstr(tcp, (int)a.fsdir, -1); 356 } else if (strcmp(type, "nfs") == 0) { 357 struct nfs_args a; 358 if (umove(tcp, tcp->u_arg[3], &a) < 0) 359 return 0; 360 tprintf("["); 361 printsock(tcp, (int) a.addr); 362 tprintf(", "); 363 if (!printflags(nfsflags, a.flags)) 364 tprintf("NFSMNT_???"); 365 tprintf(", ws:%u,rs:%u,to:%u,re:%u,", 366 a.wsize, a.rsize, a.timeo, a.retrans); 367 if (a.flags & NFSMNT_HOSTNAME && a.hostname) 368 printstr(tcp, (int)a.hostname, -1); 369 else 370 tprintf("%#lx", (unsigned long) a.hostname); 371 tprintf(",reg-min:%u,max:%u,dir-min:%u,max:%u,", 372 a.acregmin, a.acregmax, a.acdirmin, a.acdirmax); 373 if ((a.flags & NFSMNT_SECURE) && a.netname) 374 printstr(tcp, (int) a.netname, -1); 375 else 376 tprintf("%#lx", (unsigned long) a.netname); 377 tprintf("]"); 378 } else if (strcmp(type, "rfs") == 0) { 379 struct rfs_args a; 380 struct token t; 381 if (umove(tcp, tcp->u_arg[3], &a) < 0) 382 return 0; 383 tprintf("["); 384 printstr(tcp, (int)a.rmtfs, -1); 385 if (umove(tcp, (int)a.token, &t) < 0) 386 return 0; 387 tprintf(", %u, %s]", t.t_id, t.t_uname); 388 } else if (strcmp(type, "pcfs") == 0) { 389 struct pc_args a; 390 if (umove(tcp, tcp->u_arg[3], &a) < 0) 391 return 0; 392 printstr(tcp, (int)a.fspec, -1); 393 } 394 } 395 return 0; 396} 397 398int 399sys_unmount(tcp) 400struct tcb *tcp; 401{ 402 if (entering(tcp)) { 403 printstr(tcp, tcp->u_arg[0], -1); 404 } 405 return 0; 406} 407 408int 409sys_umount(tcp) 410struct tcb *tcp; 411{ 412 return sys_unmount(tcp); 413} 414 415int 416sys_auditsys(tcp) 417struct tcb *tcp; 418{ 419 /* XXX - no information available */ 420 return printargs(tcp); 421} 422 423static struct xlat ex_auth_flags[] = { 424 { AUTH_UNIX, "AUTH_UNIX" }, 425 { AUTH_DES, "AUTH_DES" }, 426 { 0, NULL }, 427}; 428 429int 430sys_exportfs(tcp) 431struct tcb *tcp; 432{ 433 struct export e; 434 int i; 435 436 if (entering(tcp)) { 437 printstr(tcp, tcp->u_arg[0], -1); 438 if (umove(tcp, tcp->u_arg[1], &e) < 0) { 439 tprintf("%#lx", tcp->u_arg[1]); 440 return 0; 441 } 442 tprintf("{fl:%u, anon:%u, ", e.ex_flags, e.ex_anon); 443 printxval(ex_auth_flags, e.ex_auth, "AUTH_???"); 444 tprintf(", roots:["); 445 if (e.ex_auth == AUTH_UNIX) { 446 for (i=0; i<e.ex_u.exunix.rootaddrs.naddrs; i++) { 447 printsock(tcp, 448 (int)&e.ex_u.exunix.rootaddrs.addrvec[i]); 449 } 450 tprintf("], writers:["); 451 for (i=0; i<e.ex_writeaddrs.naddrs; i++) { 452 printsock(tcp, 453 (int)&e.ex_writeaddrs.addrvec[i]); 454 } 455 tprintf("]"); 456 } else { 457 for (i=0; i<e.ex_u.exdes.nnames; i++) { 458 printsock(tcp, 459 (int)&e.ex_u.exdes.rootnames[i]); 460 tprintf(", "); 461 } 462 tprintf("], window:%u", e.ex_u.exdes.window); 463 } 464 tprintf("}"); 465 } 466 return 0; 467} 468 469static struct xlat sysconflimits[] = { 470#ifdef _SC_ARG_MAX 471 { _SC_ARG_MAX, "_SC_ARG_MAX" }, /* space for argv & envp */ 472#endif 473#ifdef _SC_CHILD_MAX 474 { _SC_CHILD_MAX, "_SC_CHILD_MAX" }, /* maximum children per process??? */ 475#endif 476#ifdef _SC_CLK_TCK 477 { _SC_CLK_TCK, "_SC_CLK_TCK" }, /* clock ticks/sec */ 478#endif 479#ifdef _SC_NGROUPS_MAX 480 { _SC_NGROUPS_MAX, "_SC_NGROUPS_MAX" }, /* number of groups if multple supp. */ 481#endif 482#ifdef _SC_OPEN_MAX 483 { _SC_OPEN_MAX, "_SC_OPEN_MAX" }, /* max open files per process */ 484#endif 485#ifdef _SC_JOB_CONTROL 486 { _SC_JOB_CONTROL, "_SC_JOB_CONTROL" }, /* do we have job control */ 487#endif 488#ifdef _SC_SAVED_IDS 489 { _SC_SAVED_IDS, "_SC_SAVED_IDS" }, /* do we have saved uid/gids */ 490#endif 491#ifdef _SC_VERSION 492 { _SC_VERSION, "_SC_VERSION" }, /* POSIX version supported */ 493#endif 494 { 0, NULL }, 495}; 496 497static struct xlat pathconflimits[] = { 498#ifdef _PC_LINK_MAX 499 { _PC_LINK_MAX, "_PC_LINK_MAX" }, /* max links to file/dir */ 500#endif 501#ifdef _PC_MAX_CANON 502 { _PC_MAX_CANON, "_PC_MAX_CANON" }, /* max line length */ 503#endif 504#ifdef _PC_MAX_INPUT 505 { _PC_MAX_INPUT, "_PC_MAX_INPUT" }, /* max "packet" to a tty device */ 506#endif 507#ifdef _PC_NAME_MAX 508 { _PC_NAME_MAX, "_PC_NAME_MAX" }, /* max pathname component length */ 509#endif 510#ifdef _PC_PATH_MAX 511 { _PC_PATH_MAX, "_PC_PATH_MAX" }, /* max pathname length */ 512#endif 513#ifdef _PC_PIPE_BUF 514 { _PC_PIPE_BUF, "_PC_PIPE_BUF" }, /* size of a pipe */ 515#endif 516#ifdef _PC_CHOWN_RESTRICTED 517 { _PC_CHOWN_RESTRICTED, "_PC_CHOWN_RESTRICTED" }, /* can we give away files */ 518#endif 519#ifdef _PC_NO_TRUNC 520 { _PC_NO_TRUNC, "_PC_NO_TRUNC" }, /* trunc or error on >NAME_MAX */ 521#endif 522#ifdef _PC_VDISABLE 523 { _PC_VDISABLE, "_PC_VDISABLE" }, /* best char to shut off tty c_cc */ 524#endif 525 { 0, NULL }, 526}; 527 528int 529sys_sysconf(tcp) 530struct tcb *tcp; 531{ 532 if (entering(tcp)) { 533 printxval(sysconflimits, tcp->u_arg[0], "_SC_???"); 534 } 535 return 0; 536} 537 538int 539sys_pathconf(tcp) 540struct tcb *tcp; 541{ 542 if (entering(tcp)) { 543 printstr(tcp, tcp->u_arg[0], -1); 544 tprintf(", "); 545 printxval(pathconflimits, tcp->u_arg[1], "_SC_???"); 546 } 547 return 0; 548} 549 550int 551sys_fpathconf(tcp) 552struct tcb *tcp; 553{ 554 if (entering(tcp)) { 555 tprintf("%lu, ", tcp->u_arg[0]); 556 printxval(pathconflimits, tcp->u_arg[1], "_SC_???"); 557 } 558 return 0; 559} 560 561#endif /* SUNOS4 */ 562 563#ifdef SVR4 564 565#ifdef HAVE_SYS_SYSCONFIG_H 566#include <sys/sysconfig.h> 567#endif /* HAVE_SYS_SYSCONFIG_H */ 568 569#include <sys/mount.h> 570#include <sys/systeminfo.h> 571#include <sys/utsname.h> 572 573static struct xlat sysconfig_options[] = { 574#ifdef _CONFIG_NGROUPS 575 { _CONFIG_NGROUPS, "_CONFIG_NGROUPS" }, 576#endif 577#ifdef _CONFIG_CHILD_MAX 578 { _CONFIG_CHILD_MAX, "_CONFIG_CHILD_MAX" }, 579#endif 580#ifdef _CONFIG_OPEN_FILES 581 { _CONFIG_OPEN_FILES, "_CONFIG_OPEN_FILES" }, 582#endif 583#ifdef _CONFIG_POSIX_VER 584 { _CONFIG_POSIX_VER, "_CONFIG_POSIX_VER" }, 585#endif 586#ifdef _CONFIG_PAGESIZE 587 { _CONFIG_PAGESIZE, "_CONFIG_PAGESIZE" }, 588#endif 589#ifdef _CONFIG_CLK_TCK 590 { _CONFIG_CLK_TCK, "_CONFIG_CLK_TCK" }, 591#endif 592#ifdef _CONFIG_XOPEN_VER 593 { _CONFIG_XOPEN_VER, "_CONFIG_XOPEN_VER" }, 594#endif 595#ifdef _CONFIG_PROF_TCK 596 { _CONFIG_PROF_TCK, "_CONFIG_PROF_TCK" }, 597#endif 598#ifdef _CONFIG_NPROC_CONF 599 { _CONFIG_NPROC_CONF, "_CONFIG_NPROC_CONF" }, 600#endif 601#ifdef _CONFIG_NPROC_ONLN 602 { _CONFIG_NPROC_ONLN, "_CONFIG_NPROC_ONLN" }, 603#endif 604#ifdef _CONFIG_AIO_LISTIO_MAX 605 { _CONFIG_AIO_LISTIO_MAX, "_CONFIG_AIO_LISTIO_MAX" }, 606#endif 607#ifdef _CONFIG_AIO_MAX 608 { _CONFIG_AIO_MAX, "_CONFIG_AIO_MAX" }, 609#endif 610#ifdef _CONFIG_AIO_PRIO_DELTA_MAX 611 { _CONFIG_AIO_PRIO_DELTA_MAX, "_CONFIG_AIO_PRIO_DELTA_MAX" }, 612#endif 613#ifdef _CONFIG_CONFIG_DELAYTIMER_MAX 614 { _CONFIG_DELAYTIMER_MAX, "_CONFIG_DELAYTIMER_MAX" }, 615#endif 616#ifdef _CONFIG_MQ_OPEN_MAX 617 { _CONFIG_MQ_OPEN_MAX, "_CONFIG_MQ_OPEN_MAX" }, 618#endif 619#ifdef _CONFIG_MQ_PRIO_MAX 620 { _CONFIG_MQ_PRIO_MAX, "_CONFIG_MQ_PRIO_MAX" }, 621#endif 622#ifdef _CONFIG_RTSIG_MAX 623 { _CONFIG_RTSIG_MAX, "_CONFIG_RTSIG_MAX" }, 624#endif 625#ifdef _CONFIG_SEM_NSEMS_MAX 626 { _CONFIG_SEM_NSEMS_MAX, "_CONFIG_SEM_NSEMS_MAX" }, 627#endif 628#ifdef _CONFIG_SEM_VALUE_MAX 629 { _CONFIG_SEM_VALUE_MAX, "_CONFIG_SEM_VALUE_MAX" }, 630#endif 631#ifdef _CONFIG_SIGQUEUE_MAX 632 { _CONFIG_SIGQUEUE_MAX, "_CONFIG_SIGQUEUE_MAX" }, 633#endif 634#ifdef _CONFIG_SIGRT_MIN 635 { _CONFIG_SIGRT_MIN, "_CONFIG_SIGRT_MIN" }, 636#endif 637#ifdef _CONFIG_SIGRT_MAX 638 { _CONFIG_SIGRT_MAX, "_CONFIG_SIGRT_MAX" }, 639#endif 640#ifdef _CONFIG_TIMER_MAX 641 { _CONFIG_TIMER_MAX, "_CONFIG_TIMER_MAX" }, 642#endif 643#ifdef _CONFIG_CONFIG_PHYS_PAGES 644 { _CONFIG_PHYS_PAGES, "_CONFIG_PHYS_PAGES" }, 645#endif 646#ifdef _CONFIG_AVPHYS_PAGES 647 { _CONFIG_AVPHYS_PAGES, "_CONFIG_AVPHYS_PAGES" }, 648#endif 649 { 0, NULL }, 650}; 651 652int 653sys_sysconfig(tcp) 654struct tcb *tcp; 655{ 656 if (entering(tcp)) 657 printxval(sysconfig_options, tcp->u_arg[0], "_CONFIG_???"); 658 return 0; 659} 660 661static struct xlat sysinfo_options[] = { 662 { SI_SYSNAME, "SI_SYSNAME" }, 663 { SI_HOSTNAME, "SI_HOSTNAME" }, 664 { SI_RELEASE, "SI_RELEASE" }, 665 { SI_VERSION, "SI_VERSION" }, 666 { SI_MACHINE, "SI_MACHINE" }, 667 { SI_ARCHITECTURE, "SI_ARCHITECTURE" }, 668 { SI_HW_SERIAL, "SI_HW_SERIAL" }, 669 { SI_HW_PROVIDER, "SI_HW_PROVIDER" }, 670 { SI_SRPC_DOMAIN, "SI_SRPC_DOMAIN" }, 671#ifdef SI_SET_HOSTNAME 672 { SI_SET_HOSTNAME, "SI_SET_HOSTNAME" }, 673#endif 674#ifdef SI_SET_SRPC_DOMAIN 675 { SI_SET_SRPC_DOMAIN, "SI_SET_SRPC_DOMAIN" }, 676#endif 677#ifdef SI_SET_KERB_REALM 678 { SI_SET_KERB_REALM, "SI_SET_KERB_REALM" }, 679#endif 680#ifdef SI_KERB_REALM 681 { SI_KERB_REALM, "SI_KERB_REALM" }, 682#endif 683 { 0, NULL }, 684}; 685 686int 687sys_sysinfo(tcp) 688struct tcb *tcp; 689{ 690 if (entering(tcp)) { 691 printxval(sysinfo_options, tcp->u_arg[0], "SI_???"); 692 tprintf(", "); 693 } 694 else { 695 /* Technically some calls write values. So what. */ 696 if (syserror(tcp)) 697 tprintf("%#lx", tcp->u_arg[1]); 698 else 699 printpath(tcp, tcp->u_arg[1]); 700 tprintf(", %lu", tcp->u_arg[2]); 701 } 702 return 0; 703} 704 705#ifdef MIPS 706 707#include <sys/syssgi.h> 708 709static struct xlat syssgi_options[] = { 710 { SGI_SYSID, "SGI_SYSID" }, 711 { SGI_RDUBLK, "SGI_RDUBLK" }, 712 { SGI_TUNE, "SGI_TUNE" }, 713 { SGI_IDBG, "SGI_IDBG" }, 714 { SGI_INVENT, "SGI_INVENT" }, 715 { SGI_RDNAME, "SGI_RDNAME" }, 716 { SGI_SETLED, "SGI_SETLED" }, 717 { SGI_SETNVRAM, "SGI_SETNVRAM" }, 718 { SGI_GETNVRAM, "SGI_GETNVRAM" }, 719 { SGI_QUERY_FTIMER, "SGI_QUERY_FTIMER" }, 720 { SGI_QUERY_CYCLECNTR, "SGI_QUERY_CYCLECNTR" }, 721 { SGI_PROCSZ, "SGI_PROCSZ" }, 722 { SGI_SIGACTION, "SGI_SIGACTION" }, 723 { SGI_SIGPENDING, "SGI_SIGPENDING" }, 724 { SGI_SIGPROCMASK, "SGI_SIGPROCMASK" }, 725 { SGI_SIGSUSPEND, "SGI_SIGSUSPEND" }, 726 { SGI_SETSID, "SGI_SETSID" }, 727 { SGI_SETPGID, "SGI_SETPGID" }, 728 { SGI_SYSCONF, "SGI_SYSCONF" }, 729 { SGI_WAIT4, "SGI_WAIT4" }, 730 { SGI_PATHCONF, "SGI_PATHCONF" }, 731 { SGI_READB, "SGI_READB" }, 732 { SGI_WRITEB, "SGI_WRITEB" }, 733 { SGI_SETGROUPS, "SGI_SETGROUPS" }, 734 { SGI_GETGROUPS, "SGI_GETGROUPS" }, 735 { SGI_SETTIMEOFDAY, "SGI_SETTIMEOFDAY" }, 736 { SGI_SETTIMETRIM, "SGI_SETTIMETRIM" }, 737 { SGI_GETTIMETRIM, "SGI_GETTIMETRIM" }, 738 { SGI_SPROFIL, "SGI_SPROFIL" }, 739 { SGI_RUSAGE, "SGI_RUSAGE" }, 740 { SGI_SIGSTACK, "SGI_SIGSTACK" }, 741 { SGI_SIGSTATUS, "SGI_SIGSTATUS" }, 742 { SGI_NETPROC, "SGI_NETPROC" }, 743 { SGI_SIGALTSTACK, "SGI_SIGALTSTACK" }, 744 { SGI_BDFLUSHCNT, "SGI_BDFLUSHCNT" }, 745 { SGI_SSYNC, "SGI_SSYNC" }, 746 { SGI_NFSCNVT, "SGI_NFSCNVT" }, 747 { SGI_GETPGID, "SGI_GETPGID" }, 748 { SGI_GETSID, "SGI_GETSID" }, 749 { SGI_IOPROBE, "SGI_IOPROBE" }, 750 { SGI_CONFIG, "SGI_CONFIG" }, 751 { SGI_ELFMAP, "SGI_ELFMAP" }, 752 { SGI_MCONFIG, "SGI_MCONFIG" }, 753 { SGI_GETPLABEL, "SGI_GETPLABEL" }, 754 { SGI_SETPLABEL, "SGI_SETPLABEL" }, 755 { SGI_GETLABEL, "SGI_GETLABEL" }, 756 { SGI_SETLABEL, "SGI_SETLABEL" }, 757 { SGI_SATREAD, "SGI_SATREAD" }, 758 { SGI_SATWRITE, "SGI_SATWRITE" }, 759 { SGI_SATCTL, "SGI_SATCTL" }, 760 { SGI_LOADATTR, "SGI_LOADATTR" }, 761 { SGI_UNLOADATTR, "SGI_UNLOADATTR" }, 762#ifdef SGI_RECVLMSG 763 { SGI_RECVLMSG, "SGI_RECVLMSG" }, 764#endif 765 { SGI_PLANGMOUNT, "SGI_PLANGMOUNT" }, 766 { SGI_GETPSOACL, "SGI_GETPSOACL" }, 767 { SGI_SETPSOACL, "SGI_SETPSOACL" }, 768 { SGI_RMI_FIXECC, "SGI_RMI_FIXECC" }, 769 { SGI_R4K_CERRS, "SGI_R4K_CERRS" }, 770 { SGI_GET_EVCONF, "SGI_GET_EVCONF" }, 771 { SGI_MPCWAROFF, "SGI_MPCWAROFF" }, 772 { SGI_SET_AUTOPWRON, "SGI_SET_AUTOPWRON" }, 773 { SGI_SPIPE, "SGI_SPIPE" }, 774 { SGI_SYMTAB, "SGI_SYMTAB" }, 775#ifdef SGI_SET_FPDEBUG 776 { SGI_SET_FPDEBUG, "SGI_SET_FPDEBUG" }, 777#endif 778 { SGI_TOSSTSAVE, "SGI_TOSSTSAVE" }, 779 { SGI_FDHI, "SGI_FDHI" }, 780 { SGI_MINRSS, "SGI_MINRSS" }, 781 { 0, NULL }, 782}; 783 784int 785sys_syssgi(tcp) 786struct tcb *tcp; 787{ 788 int i; 789 790 if (entering(tcp)) { 791 printxval(syssgi_options, tcp->u_arg[0], "SGI_???"); 792 switch (tcp->u_arg[0]) { 793 default: 794 for (i = 1; i < tcp->u_nargs; i++) 795 tprintf(", %#lx", tcp->u_arg[i]); 796 break; 797 } 798 } 799 return 0; 800} 801 802#include <sys/types.h> 803#include <rpc/rpc.h> 804struct cred; 805struct uio; 806#include <sys/fsid.h> 807#include <sys/vnode.h> 808#include <sys/fs/nfs.h> 809#include <sys/fs/nfs_clnt.h> 810 811static struct xlat mount_flags[] = { 812 { MS_RDONLY, "MS_RDONLY" }, 813 { MS_FSS, "MS_FSS" }, 814 { MS_DATA, "MS_DATA" }, 815 { MS_NOSUID, "MS_NOSUID" }, 816 { MS_REMOUNT, "MS_REMOUNT" }, 817 { MS_NOTRUNC, "MS_NOTRUNC" }, 818 { MS_GRPID, "MS_GRPID" }, 819 { MS_NODEV, "MS_NODEV" }, 820 { MS_BEFORE, "MS_BEFORE" }, 821 { MS_AFTER, "MS_AFTER" }, 822 { 0, NULL }, 823}; 824 825static struct xlat nfs_flags[] = { 826 { NFSMNT_SOFT, "NFSMNT_SOFT" }, 827 { NFSMNT_WSIZE, "NFSMNT_WSIZE" }, 828 { NFSMNT_RSIZE, "NFSMNT_RSIZE" }, 829 { NFSMNT_TIMEO, "NFSMNT_TIMEO" }, 830 { NFSMNT_RETRANS, "NFSMNT_RETRANS" }, 831 { NFSMNT_HOSTNAME, "NFSMNT_HOSTNAME" }, 832 { NFSMNT_INT, "NFSMNT_INT" }, 833 { NFSMNT_NOAC, "NFSMNT_NOAC" }, 834 { NFSMNT_ACREGMIN, "NFSMNT_ACREGMIN" }, 835 { NFSMNT_ACREGMAX, "NFSMNT_ACREGMAX" }, 836 { NFSMNT_ACDIRMIN, "NFSMNT_ACDIRMIN" }, 837 { NFSMNT_ACDIRMAX, "NFSMNT_ACDIRMAX" }, 838 { NFSMNT_PRIVATE, "NFSMNT_PRIVATE" }, 839 { NFSMNT_SYMTTL, "NFSMNT_SYMTTL" }, 840 { NFSMNT_LOOPBACK, "NFSMNT_LOOPBACK" }, 841 { NFSMNT_BASETYPE, "NFSMNT_BASETYPE" }, 842 { NFSMNT_NAMEMAX, "NFSMNT_NAMEMAX" }, 843 { 0, NULL }, 844}; 845 846int 847sys_mount(tcp) 848struct tcb *tcp; 849{ 850 if (entering(tcp)) { 851 printpath(tcp, tcp->u_arg[0]); 852 tprintf(", "); 853 printpath(tcp, tcp->u_arg[1]); 854 tprintf(", "); 855 printflags(mount_flags, tcp->u_arg[2]); 856 if (tcp->u_arg[2] & (MS_FSS | MS_DATA)) { 857 tprintf(", "); 858 tprintf("%ld", tcp->u_arg[3]); 859 } 860 if (tcp->u_arg[2] & MS_DATA) { 861 int nfs_type = sysfs(GETFSIND, FSID_NFS); 862 863 tprintf(", "); 864 if (tcp->u_arg[3] == nfs_type) { 865 struct nfs_args args; 866 if (umove(tcp, tcp->u_arg[4], &args) < 0) 867 tprintf("%#lx", tcp->u_arg[4]); 868 else { 869 tprintf("addr="); 870 printsock(tcp, (int) args.addr); 871 tprintf(", flags="); 872 if (!printflags(nfs_flags, args.flags)) 873 tprintf("NFSMNT_???"); 874 tprintf(", hostname="); 875 printstr(tcp, (int) args.hostname, -1); 876 tprintf(", ...}"); 877 } 878 } 879 else 880 tprintf("%#lx", tcp->u_arg[4]); 881 tprintf(", %ld", tcp->u_arg[5]); 882 } 883 } 884 return 0; 885} 886 887#else /* !MIPS */ 888 889int 890sys_mount(tcp) 891struct tcb *tcp; 892{ 893 if (entering(tcp)) { 894 printpath(tcp, tcp->u_arg[0]); 895 tprintf(", "); 896 printpath(tcp, tcp->u_arg[1]); 897 tprintf(", ..."); 898 } 899 return 0; 900} 901 902#endif /* !MIPS */ 903 904#endif /* SVR4 */ 905 906#ifdef __NR_capget 907int 908sys_capget(tcp) 909struct tcb *tcp; 910{ 911 cap_user_header_t arg0; 912 cap_user_data_t arg1; 913 914 if(!entering(tcp)) { 915 arg0 = (cap_user_header_t)tcp->u_arg[0]; 916 arg1 = (cap_user_data_t)tcp->u_arg[1]; 917 tprintf("{%lx, %d}, ", (unsigned long)arg0->version, arg0->pid); 918 tprintf("{%lx, %lx, %lx}", (unsigned long)arg1->effective, 919 (unsigned long)arg1->permitted, (unsigned long)arg1->inheritable); 920 } 921 return 0; 922} 923 924int 925sys_capset(tcp) 926struct tcb *tcp; 927{ 928 cap_user_header_t arg0; 929 cap_user_data_t arg1; 930 931 if(entering(tcp)) { 932 arg0 = (cap_user_header_t)tcp->u_arg[0]; 933 arg1 = (cap_user_data_t)tcp->u_arg[1]; 934 tprintf("{%lx, %d}, ", (unsigned long)arg0->version, arg0->pid); 935 tprintf("{%lx, %lx, %lx}", (unsigned long)arg1->effective, 936 (unsigned long)arg1->permitted, (unsigned long)arg1->inheritable); 937 } 938 return 0; 939} 940 941#else 942 943int sys_capget(tcp) 944struct tcb *tcp; 945{ 946 return printargs(tcp); 947} 948 949int sys_capset(tcp) 950struct tcb *tcp; 951{ 952 return printargs(tcp); 953} 954 955#endif 956 957#ifdef LINUX 958static struct xlat sysctl_root[] = { 959 { CTL_KERN, "CTL_KERN" }, 960 { CTL_VM, "CTL_VM" }, 961 { CTL_NET, "CTL_NET" }, 962 { CTL_PROC, "CTL_PROC" }, 963 { CTL_FS, "CTL_FS" }, 964 { CTL_DEBUG, "CTL_DEBUG" }, 965 { CTL_DEV, "CTL_DEV" }, 966 { 0, NULL } 967}; 968 969static struct xlat sysctl_kern[] = { 970 { KERN_OSTYPE, "KERN_OSTYPE" }, 971 { KERN_OSRELEASE, "KERN_OSRELEASE" }, 972 { KERN_OSREV, "KERN_OSREV" }, 973 { KERN_VERSION, "KERN_VERSION" }, 974 { KERN_SECUREMASK, "KERN_SECUREMASK" }, 975 { KERN_PROF, "KERN_PROF" }, 976 { KERN_NODENAME, "KERN_NODENAME" }, 977 { KERN_DOMAINNAME, "KERN_DOMAINNAME" }, 978 { KERN_SECURELVL, "KERN_SECURELVL" }, 979 { KERN_PANIC, "KERN_PANIC" }, 980 { KERN_REALROOTDEV, "KERN_REALROOTDEV" }, 981 { KERN_JAVA_INTERPRETER, "KERN_JAVA_INTERPRETER" }, 982 { KERN_JAVA_APPLETVIEWER, "KERN_JAVA_APPLETVIEWER" }, 983 { KERN_SPARC_REBOOT, "KERN_SPARC_REBOOT" }, 984 { KERN_CTLALTDEL, "KERN_CTLALTDEL" }, 985 { KERN_PRINTK, "KERN_PRINTK" }, 986 { KERN_NAMETRANS, "KERN_NAMETRANS" }, 987 { KERN_PPC_HTABRECLAIM, "KERN_PPC_HTABRECLAIM" }, 988 { KERN_PPC_ZEROPAGED, "KERN_PPC_ZEROPAGED" }, 989 { KERN_PPC_POWERSAVE_NAP, "KERN_PPC_POWERSAVE_NAP" }, 990 { KERN_MODPROBE, "KERN_MODPROBE" }, 991 { KERN_SG_BIG_BUFF, "KERN_SG_BIG_BUFF" }, 992 { KERN_ACCT, "KERN_ACCT" }, 993 { KERN_PPC_L2CR, "KERN_PPC_L2CR" }, 994 { KERN_RTSIGNR, "KERN_RTSIGNR" }, 995 { KERN_RTSIGMAX, "KERN_RTSIGMAX" }, 996 { KERN_SHMMAX, "KERN_SHMMAX" }, 997 { KERN_MSGMAX, "KERN_MSGMAX" }, 998 { KERN_MSGMNB, "KERN_MSGMNB" }, 999 { KERN_MSGPOOL, "KERN_MSGPOOL" }, 1000 { 0, NULL } 1001}; 1002 1003static struct xlat sysctl_vm[] = { 1004 { VM_SWAPCTL, "VM_SWAPCTL" }, 1005 { VM_SWAPOUT, "VM_SWAPOUT" }, 1006 { VM_FREEPG, "VM_FREEPG" }, 1007 { VM_BDFLUSH, "VM_BDFLUSH" }, 1008 { VM_OVERCOMMIT_MEMORY, "VM_OVERCOMMIT_MEMORY" }, 1009 { VM_BUFFERMEM, "VM_BUFFERMEM" }, 1010 { VM_PAGECACHE, "VM_PAGECACHE" }, 1011 { VM_PAGERDAEMON, "VM_PAGERDAEMON" }, 1012 { VM_PGT_CACHE, "VM_PGT_CACHE" }, 1013 { VM_PAGE_CLUSTER, "VM_PAGE_CLUSTER" }, 1014 { 0, NULL }, 1015}; 1016 1017static struct xlat sysctl_net[] = { 1018 { NET_CORE, "NET_CORE" }, 1019 { NET_ETHER, "NET_ETHER" }, 1020 { NET_802, "NET_802" }, 1021 { NET_UNIX, "NET_UNIX" }, 1022 { NET_IPV4, "NET_IPV4" }, 1023 { NET_IPX, "NET_IPX" }, 1024 { NET_ATALK, "NET_ATALK" }, 1025 { NET_NETROM, "NET_NETROM" }, 1026 { NET_AX25, "NET_AX25" }, 1027 { NET_BRIDGE, "NET_BRIDGE" }, 1028 { NET_ROSE, "NET_ROSE" }, 1029 { NET_IPV6, "NET_IPV6" }, 1030 { NET_X25, "NET_X25" }, 1031 { NET_TR, "NET_TR" }, 1032 { NET_DECNET, "NET_DECNET" }, 1033 { 0, NULL } 1034}; 1035 1036static struct xlat sysctl_net_core[] = { 1037 { NET_CORE_WMEM_MAX, "NET_CORE_WMEM_MAX" }, 1038 { NET_CORE_RMEM_MAX, "NET_CORE_RMEM_MAX" }, 1039 { NET_CORE_WMEM_DEFAULT, "NET_CORE_WMEM_DEFAULT" }, 1040 { NET_CORE_RMEM_DEFAULT, "NET_CORE_RMEM_DEFAULT" }, 1041 { NET_CORE_MAX_BACKLOG, "NET_CORE_MAX_BACKLOG" }, 1042 { NET_CORE_FASTROUTE, "NET_CORE_FASTROUTE" }, 1043 { NET_CORE_MSG_COST, "NET_CORE_MSG_COST" }, 1044 { NET_CORE_MSG_BURST, "NET_CORE_MSG_BURST" }, 1045 { NET_CORE_OPTMEM_MAX, "NET_CORE_OPTMEM_MAX" }, 1046 { 0, NULL } 1047}; 1048 1049static struct xlat sysctl_net_unix[] = { 1050 { NET_UNIX_DESTROY_DELAY, "NET_UNIX_DESTROY_DELAY" }, 1051 { NET_UNIX_DELETE_DELAY, "NET_UNIX_DELETE_DELAY" }, 1052 { 0, NULL } 1053}; 1054 1055static struct xlat sysctl_net_ipv4[] = { 1056 { NET_IPV4_FORWARD, "NET_IPV4_FORWARD" }, 1057 { NET_IPV4_DYNADDR, "NET_IPV4_DYNADDR" }, 1058 { NET_IPV4_CONF, "NET_IPV4_CONF" }, 1059 { NET_IPV4_NEIGH, "NET_IPV4_NEIGH" }, 1060 { NET_IPV4_ROUTE, "NET_IPV4_ROUTE" }, 1061 { NET_IPV4_FIB_HASH, "NET_IPV4_FIB_HASH" }, 1062 { NET_IPV4_TCP_TIMESTAMPS, "NET_IPV4_TCP_TIMESTAMPS" }, 1063 { NET_IPV4_TCP_WINDOW_SCALING, "NET_IPV4_TCP_WINDOW_SCALING" }, 1064 { NET_IPV4_TCP_SACK, "NET_IPV4_TCP_SACK" }, 1065 { NET_IPV4_TCP_RETRANS_COLLAPSE, "NET_IPV4_TCP_RETRANS_COLLAPSE" }, 1066 { NET_IPV4_DEFAULT_TTL, "NET_IPV4_DEFAULT_TTL" }, 1067 { NET_IPV4_AUTOCONFIG, "NET_IPV4_AUTOCONFIG" }, 1068 { NET_IPV4_NO_PMTU_DISC, "NET_IPV4_NO_PMTU_DISC" }, 1069 { NET_IPV4_TCP_SYN_RETRIES, "NET_IPV4_TCP_SYN_RETRIES" }, 1070 { NET_IPV4_IPFRAG_HIGH_THRESH, "NET_IPV4_IPFRAG_HIGH_THRESH" }, 1071 { NET_IPV4_IPFRAG_LOW_THRESH, "NET_IPV4_IPFRAG_LOW_THRESH" }, 1072 { NET_IPV4_IPFRAG_TIME, "NET_IPV4_IPFRAG_TIME" }, 1073 { NET_IPV4_TCP_MAX_KA_PROBES, "NET_IPV4_TCP_MAX_KA_PROBES" }, 1074 { NET_IPV4_TCP_KEEPALIVE_TIME, "NET_IPV4_TCP_KEEPALIVE_TIME" }, 1075 { NET_IPV4_TCP_KEEPALIVE_PROBES, "NET_IPV4_TCP_KEEPALIVE_PROBES" }, 1076 { NET_IPV4_TCP_RETRIES1, "NET_IPV4_TCP_RETRIES1" }, 1077 { NET_IPV4_TCP_RETRIES2, "NET_IPV4_TCP_RETRIES2" }, 1078 { NET_IPV4_TCP_FIN_TIMEOUT, "NET_IPV4_TCP_FIN_TIMEOUT" }, 1079 { NET_IPV4_IP_MASQ_DEBUG, "NET_IPV4_IP_MASQ_DEBUG" }, 1080 { NET_TCP_SYNCOOKIES, "NET_TCP_SYNCOOKIES" }, 1081 { NET_TCP_STDURG, "NET_TCP_STDURG" }, 1082 { NET_TCP_RFC1337, "NET_TCP_RFC1337" }, 1083 { NET_TCP_SYN_TAILDROP, "NET_TCP_SYN_TAILDROP" }, 1084 { NET_TCP_MAX_SYN_BACKLOG, "NET_TCP_MAX_SYN_BACKLOG" }, 1085 { NET_IPV4_LOCAL_PORT_RANGE, "NET_IPV4_LOCAL_PORT_RANGE" }, 1086 { NET_IPV4_ICMP_ECHO_IGNORE_ALL, "NET_IPV4_ICMP_ECHO_IGNORE_ALL" }, 1087 { NET_IPV4_ICMP_ECHO_IGNORE_BROADCASTS, "NET_IPV4_ICMP_ECHO_IGNORE_BROADCASTS" }, 1088 { NET_IPV4_ICMP_SOURCEQUENCH_RATE, "NET_IPV4_ICMP_SOURCEQUENCH_RATE" }, 1089 { NET_IPV4_ICMP_DESTUNREACH_RATE, "NET_IPV4_ICMP_DESTUNREACH_RATE" }, 1090 { NET_IPV4_ICMP_TIMEEXCEED_RATE, "NET_IPV4_ICMP_TIMEEXCEED_RATE" }, 1091 { NET_IPV4_ICMP_PARAMPROB_RATE, "NET_IPV4_ICMP_PARAMPROB_RATE" }, 1092 { NET_IPV4_ICMP_ECHOREPLY_RATE, "NET_IPV4_ICMP_ECHOREPLY_RATE" }, 1093 { NET_IPV4_ICMP_IGNORE_BOGUS_ERROR_RESPONSES, "NET_IPV4_ICMP_IGNORE_BOGUS_ERROR_RESPONSES" }, 1094 { NET_IPV4_IGMP_MAX_MEMBERSHIPS, "NET_IPV4_IGMP_MAX_MEMBERSHIPS" }, 1095 { 0, NULL } 1096}; 1097 1098static struct xlat sysctl_net_ipv4_route[] = { 1099 { NET_IPV4_ROUTE_FLUSH, "NET_IPV4_ROUTE_FLUSH" }, 1100 { NET_IPV4_ROUTE_MIN_DELAY, "NET_IPV4_ROUTE_MIN_DELAY" }, 1101 { NET_IPV4_ROUTE_MAX_DELAY, "NET_IPV4_ROUTE_MAX_DELAY" }, 1102 { NET_IPV4_ROUTE_GC_THRESH, "NET_IPV4_ROUTE_GC_THRESH" }, 1103 { NET_IPV4_ROUTE_MAX_SIZE, "NET_IPV4_ROUTE_MAX_SIZE" }, 1104 { NET_IPV4_ROUTE_GC_MIN_INTERVAL, "NET_IPV4_ROUTE_GC_MIN_INTERVAL" }, 1105 { NET_IPV4_ROUTE_GC_TIMEOUT, "NET_IPV4_ROUTE_GC_TIMEOUT" }, 1106 { NET_IPV4_ROUTE_GC_INTERVAL, "NET_IPV4_ROUTE_GC_INTERVAL" }, 1107 { NET_IPV4_ROUTE_REDIRECT_LOAD, "NET_IPV4_ROUTE_REDIRECT_LOAD" }, 1108 { NET_IPV4_ROUTE_REDIRECT_NUMBER, "NET_IPV4_ROUTE_REDIRECT_NUMBER" }, 1109 { NET_IPV4_ROUTE_REDIRECT_SILENCE, "NET_IPV4_ROUTE_REDIRECT_SILENCE" }, 1110 { NET_IPV4_ROUTE_ERROR_COST, "NET_IPV4_ROUTE_ERROR_COST" }, 1111 { NET_IPV4_ROUTE_ERROR_BURST, "NET_IPV4_ROUTE_ERROR_BURST" }, 1112 { NET_IPV4_ROUTE_GC_ELASTICITY, "NET_IPV4_ROUTE_GC_ELASTICITY" }, 1113 { 0, NULL } 1114}; 1115 1116static struct xlat sysctl_net_ipv4_conf[] = { 1117 { NET_IPV4_CONF_FORWARDING, "NET_IPV4_CONF_FORWARDING" }, 1118 { NET_IPV4_CONF_MC_FORWARDING, "NET_IPV4_CONF_MC_FORWARDING" }, 1119 { NET_IPV4_CONF_PROXY_ARP, "NET_IPV4_CONF_PROXY_ARP" }, 1120 { NET_IPV4_CONF_ACCEPT_REDIRECTS, "NET_IPV4_CONF_ACCEPT_REDIRECTS" }, 1121 { NET_IPV4_CONF_SECURE_REDIRECTS, "NET_IPV4_CONF_SECURE_REDIRECTS" }, 1122 { NET_IPV4_CONF_SEND_REDIRECTS, "NET_IPV4_CONF_SEND_REDIRECTS" }, 1123 { NET_IPV4_CONF_SHARED_MEDIA, "NET_IPV4_CONF_SHARED_MEDIA" }, 1124 { NET_IPV4_CONF_RP_FILTER, "NET_IPV4_CONF_RP_FILTER" }, 1125 { NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE, "NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE" }, 1126 { NET_IPV4_CONF_BOOTP_RELAY, "NET_IPV4_CONF_BOOTP_RELAY" }, 1127 { NET_IPV4_CONF_LOG_MARTIANS, "NET_IPV4_CONF_LOG_MARTIANS" }, 1128 { 0, NULL } 1129}; 1130 1131static struct xlat sysctl_net_ipv6[] = { 1132 { NET_IPV6_CONF, "NET_IPV6_CONF" }, 1133 { NET_IPV6_NEIGH, "NET_IPV6_NEIGH" }, 1134 { NET_IPV6_ROUTE, "NET_IPV6_ROUTE" }, 1135 { 0, NULL } 1136}; 1137 1138static struct xlat sysctl_net_ipv6_route[] = { 1139 { NET_IPV6_ROUTE_FLUSH, "NET_IPV6_ROUTE_FLUSH" }, 1140 { NET_IPV6_ROUTE_GC_THRESH, "NET_IPV6_ROUTE_GC_THRESH" }, 1141 { NET_IPV6_ROUTE_MAX_SIZE, "NET_IPV6_ROUTE_MAX_SIZE" }, 1142 { NET_IPV6_ROUTE_GC_MIN_INTERVAL, "NET_IPV6_ROUTE_GC_MIN_INTERVAL" }, 1143 { NET_IPV6_ROUTE_GC_TIMEOUT, "NET_IPV6_ROUTE_GC_TIMEOUT" }, 1144 { NET_IPV6_ROUTE_GC_INTERVAL, "NET_IPV6_ROUTE_GC_INTERVAL" }, 1145 { NET_IPV6_ROUTE_GC_ELASTICITY, "NET_IPV6_ROUTE_GC_ELASTICITY" }, 1146 { 0, NULL } 1147}; 1148 1149int 1150sys_sysctl(tcp) 1151struct tcb *tcp; 1152{ 1153 struct __sysctl_args info; 1154 int *name; 1155 umove (tcp, tcp->u_arg[0], &info); 1156 1157 name = alloca (sizeof (int) * info.nlen); 1158 umoven(tcp, (size_t) info.name, sizeof (int) * info.nlen, (char *) name); 1159 1160 if (entering(tcp)) { 1161 int cnt = 0; 1162 1163 tprintf("{{"); 1164 1165 if (info.nlen == 0) 1166 goto out; 1167 printxval(sysctl_root, name[0], "CTL_???"); 1168 ++cnt; 1169 1170 if (info.nlen == 1) 1171 goto out; 1172 switch (name[0]) { 1173 case CTL_KERN: 1174 tprintf(", "); 1175 printxval(sysctl_kern, name[1], "KERN_???"); 1176 ++cnt; 1177 break; 1178 case CTL_VM: 1179 tprintf(", "); 1180 printxval(sysctl_vm, name[1], "VM_???"); 1181 ++cnt; 1182 break; 1183 case CTL_NET: 1184 tprintf(", "); 1185 printxval(sysctl_net, name[1], "NET_???"); 1186 ++cnt; 1187 1188 if (info.nlen == 2) 1189 goto out; 1190 switch (name[1]) { 1191 case NET_CORE: 1192 tprintf(", "); 1193 printxval(sysctl_net_core, name[2], 1194 "NET_CORE_???"); 1195 break; 1196 case NET_UNIX: 1197 tprintf(", "); 1198 printxval(sysctl_net_unix, name[2], 1199 "NET_UNIX_???"); 1200 break; 1201 case NET_IPV4: 1202 tprintf(", "); 1203 printxval(sysctl_net_ipv4, name[2], 1204 "NET_IPV4_???"); 1205 1206 if (info.nlen == 3) 1207 goto out; 1208 switch (name[2]) { 1209 case NET_IPV4_ROUTE: 1210 tprintf(", "); 1211 printxval(sysctl_net_ipv4_route, 1212 name[3], 1213 "NET_IPV4_ROUTE_???"); 1214 break; 1215 case NET_IPV4_CONF: 1216 tprintf(", "); 1217 printxval(sysctl_net_ipv4_conf, 1218 name[3], 1219 "NET_IPV4_CONF_???"); 1220 break; 1221 default: 1222 goto out; 1223 } 1224 break; 1225 case NET_IPV6: 1226 tprintf(", "); 1227 printxval(sysctl_net_ipv6, name[2], 1228 "NET_IPV6_???"); 1229 1230 if (info.nlen == 3) 1231 goto out; 1232 switch (name[2]) { 1233 case NET_IPV6_ROUTE: 1234 tprintf(", "); 1235 printxval(sysctl_net_ipv6_route, 1236 name[3], 1237 "NET_IPV6_ROUTE_???"); 1238 break; 1239 default: 1240 goto out; 1241 } 1242 break; 1243 default: 1244 goto out; 1245 } 1246 break; 1247 default: 1248 goto out; 1249 } 1250 out: 1251 while (cnt < info.nlen) 1252 tprintf(", %x", name[cnt++]); 1253 tprintf("}, %d, ", info.nlen); 1254 } else { 1255 size_t oldlen; 1256 umove(tcp, (size_t)info.oldlenp, &oldlen); 1257 if (info.nlen >= 2 1258 && ((name[0] == CTL_KERN 1259 && (name[1] == KERN_OSRELEASE 1260 || name[1] == KERN_OSTYPE 1261 || name[1] == KERN_JAVA_INTERPRETER 1262 || name[1] == KERN_JAVA_APPLETVIEWER)))) { 1263 printpath(tcp, (size_t)info.oldval); 1264 tprintf(", %d, ", oldlen); 1265 if (info.newval == 0) 1266 tprintf("NULL"); 1267 else if (syserror(tcp)) 1268 tprintf("%p", info.newval); 1269 else 1270 printpath(tcp, (size_t)info.newval); 1271 tprintf(", %Zd", info.newlen); 1272 } else { 1273 tprintf("%p, %d, %p, %Zd", info.oldval, oldlen, 1274 info.newval, info.newlen); 1275 } 1276 tprintf("}"); 1277 } 1278 return 0; 1279} 1280#else 1281int sys_sysctl(tcp) 1282struct tcb *tcp; 1283{ 1284 return printargs(tcp); 1285} 1286#endif 1287 1288