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