granicus.if.org Git - strace/blob - system.c

   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
  68 static 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
  82 int
  83 sys_mount(tcp)
  84 struct 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
  99 int
 100 sys_umount2(tcp)
 101 struct 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
 114 static 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
 145 int
 146 sys_personality(tcp)
 147 struct tcb *tcp;
 148 {
 149         if (entering(tcp))
 150                 printxval(personality_options, tcp->u_arg[0], "PER_???");
 151         return 0;
 152 }
 153
 154 #ifdef M68K
 155 static 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
 168 static 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
 181 int
 182 sys_cacheflush(tcp)
 183 struct 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*/
 216 int
 217 sys_sync(tcp)
 218 struct tcb *tcp;
 219 {
 220         return 0;
 221 }
 222
 223 static 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
 238 int
 239 sys_reboot(tcp)
 240 struct 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
 252 int
 253 sys_sysacct(tcp)
 254 struct tcb *tcp;
 255 {
 256         if (entering(tcp)) {
 257                 printstr(tcp, tcp->u_arg[0], -1);
 258         }
 259         return 0;
 260 }
 261
 262 int
 263 sys_swapon(tcp)
 264 struct tcb *tcp;
 265 {
 266         if (entering(tcp)) {
 267                 printstr(tcp, tcp->u_arg[0], -1);
 268         }
 269         return 0;
 270 }
 271
 272 int
 273 sys_nfs_svc(tcp)
 274 struct tcb *tcp;
 275 {
 276         if (entering(tcp)) {
 277                 printsock(tcp, tcp->u_arg[0]);
 278         }
 279         return 0;
 280 }
 281
 282 static 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
 302 static 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
 327 int
 328 sys_mount(tcp)
 329 struct 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
 398 int
 399 sys_unmount(tcp)
 400 struct tcb *tcp;
 401 {
 402         if (entering(tcp)) {
 403                 printstr(tcp, tcp->u_arg[0], -1);
 404         }
 405         return 0;
 406 }
 407
 408 int
 409 sys_umount(tcp)
 410 struct tcb *tcp;
 411 {
 412         return sys_unmount(tcp);
 413 }
 414
 415 int
 416 sys_auditsys(tcp)
 417 struct tcb *tcp;
 418 {
 419         /* XXX - no information available */
 420         return printargs(tcp);
 421 }
 422
 423 static struct xlat ex_auth_flags[] = {
 424         { AUTH_UNIX,    "AUTH_UNIX"     },
 425         { AUTH_DES,     "AUTH_DES"      },
 426         { 0,            NULL            },
 427 };
 428
 429 int
 430 sys_exportfs(tcp)
 431 struct 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
 469 static 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
 497 static 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
 528 int
 529 sys_sysconf(tcp)
 530 struct tcb *tcp;
 531 {
 532         if (entering(tcp)) {
 533                 printxval(sysconflimits, tcp->u_arg[0], "_SC_???");
 534         }
 535         return 0;
 536 }
 537
 538 int
 539 sys_pathconf(tcp)
 540 struct 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
 550 int
 551 sys_fpathconf(tcp)
 552 struct 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
 573 static 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
 652 int
 653 sys_sysconfig(tcp)
 654 struct tcb *tcp;
 655 {
 656         if (entering(tcp))
 657                 printxval(sysconfig_options, tcp->u_arg[0], "_CONFIG_???");
 658         return 0;
 659 }
 660
 661 static 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
 686 int
 687 sys_sysinfo(tcp)
 688 struct 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
 709 static 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
 784 int
 785 sys_syssgi(tcp)
 786 struct 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>
 804 struct cred;
 805 struct 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
 811 static 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
 825 static 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
 846 int
 847 sys_mount(tcp)
 848 struct 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
 889 int
 890 sys_mount(tcp)
 891 struct 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
 907 int
 908 sys_capget(tcp)
 909 struct 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
 924 int
 925 sys_capset(tcp)
 926 struct 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
 943 int sys_capget(tcp)
 944 struct tcb *tcp;
 945 {
 946         return printargs(tcp);
 947 }
 948
 949 int sys_capset(tcp)
 950 struct tcb *tcp;
 951 {
 952         return printargs(tcp);
 953 }
 954
 955 #endif
 956
 957 #ifdef LINUX
 958 static 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
 969 static 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
1003 static 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
1017 static 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
1036 static 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
1049 static 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
1055 static 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
1098 static 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
1116 static 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
1131 static 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
1138 static 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
1149 int
1150 sys_sysctl(tcp)
1151 struct 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
1281 int sys_sysctl(tcp)
1282 struct tcb *tcp;
1283 {
1284         return printargs(tcp);
1285 }
1286 #endif
1287