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  * Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl>
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. The name of the author may not be used to endorse or promote products
  17  *    derived from this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  21  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  22  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  24  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  *
  30  *      $Id$
  31  */
  32
  33 #include "defs.h"
  34
  35 #ifdef LINUX
  36 #define _LINUX_SOCKET_H
  37 #define _LINUX_FS_H
  38
  39 #define MS_RDONLY        1      /* Mount read-only */
  40 #define MS_NOSUID        2      /* Ignore suid and sgid bits */
  41 #define MS_NODEV         4      /* Disallow access to device special files */
  42 #define MS_NOEXEC        8      /* Disallow program execution */
  43 #define MS_SYNCHRONOUS  16      /* Writes are synced at once */
  44 #define MS_REMOUNT      32      /* Alter flags of a mounted FS */
  45 #define MS_MANDLOCK     64      /* Allow mandatory locks on an FS */
  46 #define MS_DIRSYNC      128     /* Directory modifications are synchronous */
  47 #define MS_NOATIME      1024    /* Do not update access times. */
  48 #define MS_NODIRATIME   2048    /* Do not update directory access times */
  49 #define MS_BIND         4096
  50 #define MS_MOVE         8192
  51 #define MS_REC          16384
  52 #define MS_SILENT       32768
  53 #define MS_POSIXACL     (1<<16) /* VFS does not apply the umask */
  54 #define MS_UNBINDABLE   (1<<17) /* change to unbindable */
  55 #define MS_PRIVATE      (1<<18) /* change to private */
  56 #define MS_SLAVE        (1<<19) /* change to slave */
  57 #define MS_SHARED       (1<<20) /* change to shared */
  58 #define MS_RELATIME     (1<<21)
  59 #define MS_KERNMOUNT    (1<<22)
  60 #define MS_I_VERSION    (1<<23)
  61 #define MS_STRICTATIME  (1<<24)
  62 #define MS_BORN         (1<<29)
  63 #define MS_ACTIVE       (1<<30)
  64 #define MS_NOUSER       (1<<31)
  65 #define MS_MGC_VAL      0xc0ed0000      /* Magic flag number */
  66 #define MS_MGC_MSK      0xffff0000      /* Magic flag mask */
  67
  68 #include <sys/socket.h>
  69 #include <netinet/in.h>
  70 #include <arpa/inet.h>
  71
  72 #include <sys/syscall.h>
  73
  74 #ifdef HAVE_LINUX_CAPABILITY_H
  75 #include <linux/capability.h>
  76 #endif
  77
  78 #ifdef HAVE_ASM_CACHECTL_H
  79 #include <asm/cachectl.h>
  80 #endif
  81
  82 #ifdef HAVE_LINUX_USTNAME_H
  83 #include <linux/utsname.h>
  84 #endif
  85
  86 #ifdef HAVE_ASM_SYSMIPS_H
  87 #include <asm/sysmips.h>
  88 #endif
  89
  90 #include <linux/sysctl.h>
  91
  92 static const struct xlat mount_flags[] = {
  93         { MS_MGC_VAL,   "MS_MGC_VAL"    },
  94         { MS_RDONLY,    "MS_RDONLY"     },
  95         { MS_NOSUID,    "MS_NOSUID"     },
  96         { MS_NODEV,     "MS_NODEV"      },
  97         { MS_NOEXEC,    "MS_NOEXEC"     },
  98         { MS_SYNCHRONOUS,"MS_SYNCHRONOUS"},
  99         { MS_REMOUNT,   "MS_REMOUNT"    },
 100         { MS_RELATIME,  "MS_RELATIME"   },
 101         { MS_KERNMOUNT, "MS_KERNMOUNT"  },
 102         { MS_I_VERSION, "MS_I_VERSION"  },
 103         { MS_STRICTATIME,"MS_STRICTATIME"},
 104         { MS_BORN,      "MS_BORN"       },
 105         { MS_MANDLOCK,  "MS_MANDLOCK"   },
 106         { MS_NOATIME,   "MS_NOATIME"    },
 107         { MS_NODIRATIME,"MS_NODIRATIME" },
 108         { MS_BIND,      "MS_BIND"       },
 109         { MS_MOVE,      "MS_MOVE"       },
 110         { MS_REC,       "MS_REC"        },
 111         { MS_SILENT,    "MS_SILENT"     },
 112         { MS_POSIXACL,  "MS_POSIXACL"   },
 113         { MS_UNBINDABLE,"MS_UNBINDABLE" },
 114         { MS_PRIVATE,   "MS_PRIVATE"    },
 115         { MS_SLAVE,     "MS_SLAVE"      },
 116         { MS_SHARED,    "MS_SHARED"     },
 117         { MS_ACTIVE,    "MS_ACTIVE"     },
 118         { MS_NOUSER,    "MS_NOUSER"     },
 119         { 0,            NULL            },
 120 };
 121
 122 int
 123 sys_mount(struct tcb *tcp)
 124 {
 125         if (entering(tcp)) {
 126                 int ignore_type = 0, ignore_data = 0;
 127                 unsigned long flags = tcp->u_arg[3];
 128
 129                 /* Discard magic */
 130                 if ((flags & MS_MGC_MSK) == MS_MGC_VAL)
 131                         flags &= ~MS_MGC_MSK;
 132
 133                 if (flags & MS_REMOUNT)
 134                         ignore_type = 1;
 135                 else if (flags & (MS_BIND | MS_MOVE))
 136                         ignore_type = ignore_data = 1;
 137
 138                 printpath(tcp, tcp->u_arg[0]);
 139                 tprints(", ");
 140
 141                 printpath(tcp, tcp->u_arg[1]);
 142                 tprints(", ");
 143
 144                 if (ignore_type && tcp->u_arg[2])
 145                         tprintf("%#lx", tcp->u_arg[2]);
 146                 else
 147                         printstr(tcp, tcp->u_arg[2], -1);
 148                 tprints(", ");
 149
 150                 printflags(mount_flags, tcp->u_arg[3], "MS_???");
 151                 tprints(", ");
 152
 153                 if (ignore_data && tcp->u_arg[4])
 154                         tprintf("%#lx", tcp->u_arg[4]);
 155                 else
 156                         printstr(tcp, tcp->u_arg[4], -1);
 157         }
 158         return 0;
 159 }
 160
 161 #define MNT_FORCE       0x00000001      /* Attempt to forcibily umount */
 162 #define MNT_DETACH      0x00000002      /* Just detach from the tree */
 163 #define MNT_EXPIRE      0x00000004      /* Mark for expiry */
 164
 165 static const struct xlat umount_flags[] = {
 166         { MNT_FORCE,    "MNT_FORCE"     },
 167         { MNT_DETACH,   "MNT_DETACH"    },
 168         { MNT_EXPIRE,   "MNT_EXPIRE"    },
 169         { 0,            NULL            },
 170 };
 171
 172 int
 173 sys_umount2(struct tcb *tcp)
 174 {
 175         if (entering(tcp)) {
 176                 printstr(tcp, tcp->u_arg[0], -1);
 177                 tprints(", ");
 178                 printflags(umount_flags, tcp->u_arg[1], "MNT_???");
 179         }
 180         return 0;
 181 }
 182
 183 /* These are not macros, but enums.  We just copy the values by hand
 184    from Linux 2.6.9 here.  */
 185 static const struct xlat personality_options[] = {
 186         { 0,            "PER_LINUX"     },
 187         { 0x00800000,   "PER_LINUX_32BIT"},
 188         { 0x04100001,   "PER_SVR4"      },
 189         { 0x05000002,   "PER_SVR3"      },
 190         { 0x07000003,   "PER_SCOSVR3"   },
 191         { 0x06000003,   "PER_OSR5"      },
 192         { 0x05000004,   "PER_WYSEV386"  },
 193         { 0x04000005,   "PER_ISCR4"     },
 194         { 0x00000006,   "PER_BSD"       },
 195         { 0x04000006,   "PER_SUNOS"     },
 196         { 0x05000007,   "PER_XENIX"     },
 197         { 0x00000008,   "PER_LINUX32"   },
 198         { 0x08000008,   "PER_LINUX32_3GB"},
 199         { 0x04000009,   "PER_IRIX32"    },
 200         { 0x0400000a,   "PER_IRIXN32"   },
 201         { 0x0400000b,   "PER_IRIX64"    },
 202         { 0x0000000c,   "PER_RISCOS"    },
 203         { 0x0400000d,   "PER_SOLARIS"   },
 204         { 0x0410000e,   "PER_UW7"       },
 205         { 0x0000000f,   "PER_OSF4"      },
 206         { 0x00000010,   "PER_HPUX"      },
 207         { 0,            NULL            },
 208 };
 209
 210 int
 211 sys_personality(struct tcb *tcp)
 212 {
 213         if (entering(tcp))
 214                 printxval(personality_options, tcp->u_arg[0], "PER_???");
 215         return 0;
 216 }
 217
 218 #include <linux/reboot.h>
 219 static const struct xlat bootflags1[] = {
 220         { LINUX_REBOOT_MAGIC1,  "LINUX_REBOOT_MAGIC1"   },
 221         { 0,                    NULL                    },
 222 };
 223
 224 static const struct xlat bootflags2[] = {
 225         { LINUX_REBOOT_MAGIC2,  "LINUX_REBOOT_MAGIC2"   },
 226         { LINUX_REBOOT_MAGIC2A, "LINUX_REBOOT_MAGIC2A"  },
 227         { LINUX_REBOOT_MAGIC2B, "LINUX_REBOOT_MAGIC2B"  },
 228         { 0,                    NULL                    },
 229 };
 230
 231 static const struct xlat bootflags3[] = {
 232         { LINUX_REBOOT_CMD_CAD_OFF,     "LINUX_REBOOT_CMD_CAD_OFF"      },
 233         { LINUX_REBOOT_CMD_RESTART,     "LINUX_REBOOT_CMD_RESTART"      },
 234         { LINUX_REBOOT_CMD_HALT,        "LINUX_REBOOT_CMD_HALT"         },
 235         { LINUX_REBOOT_CMD_CAD_ON,      "LINUX_REBOOT_CMD_CAD_ON"       },
 236         { LINUX_REBOOT_CMD_POWER_OFF,   "LINUX_REBOOT_CMD_POWER_OFF"    },
 237         { LINUX_REBOOT_CMD_RESTART2,    "LINUX_REBOOT_CMD_RESTART2"     },
 238         { 0,                            NULL                            },
 239 };
 240
 241 int
 242 sys_reboot(struct tcb *tcp)
 243 {
 244         if (entering(tcp)) {
 245                 printflags(bootflags1, tcp->u_arg[0], "LINUX_REBOOT_MAGIC_???");
 246                 tprints(", ");
 247                 printflags(bootflags2, tcp->u_arg[1], "LINUX_REBOOT_MAGIC_???");
 248                 tprints(", ");
 249                 printflags(bootflags3, tcp->u_arg[2], "LINUX_REBOOT_CMD_???");
 250                 if (tcp->u_arg[2] == LINUX_REBOOT_CMD_RESTART2) {
 251                         tprints(", ");
 252                         printstr(tcp, tcp->u_arg[3], -1);
 253                 }
 254         }
 255         return 0;
 256 }
 257
 258 #ifdef M68K
 259 static const struct xlat cacheflush_scope[] = {
 260 #ifdef FLUSH_SCOPE_LINE
 261         { FLUSH_SCOPE_LINE,     "FLUSH_SCOPE_LINE" },
 262 #endif
 263 #ifdef FLUSH_SCOPE_PAGE
 264         { FLUSH_SCOPE_PAGE,     "FLUSH_SCOPE_PAGE" },
 265 #endif
 266 #ifdef FLUSH_SCOPE_ALL
 267         { FLUSH_SCOPE_ALL,      "FLUSH_SCOPE_ALL" },
 268 #endif
 269         { 0,                    NULL },
 270 };
 271
 272 static const struct xlat cacheflush_flags[] = {
 273 #ifdef FLUSH_CACHE_BOTH
 274         { FLUSH_CACHE_BOTH,     "FLUSH_CACHE_BOTH" },
 275 #endif
 276 #ifdef FLUSH_CACHE_DATA
 277         { FLUSH_CACHE_DATA,     "FLUSH_CACHE_DATA" },
 278 #endif
 279 #ifdef FLUSH_CACHE_INSN
 280         { FLUSH_CACHE_INSN,     "FLUSH_CACHE_INSN" },
 281 #endif
 282         { 0,                    NULL },
 283 };
 284
 285 int
 286 sys_cacheflush(struct tcb *tcp)
 287 {
 288         if (entering(tcp)) {
 289                 /* addr */
 290                 tprintf("%#lx, ", tcp->u_arg[0]);
 291                 /* scope */
 292                 printxval(cacheflush_scope, tcp->u_arg[1], "FLUSH_SCOPE_???");
 293                 tprints(", ");
 294                 /* flags */
 295                 printflags(cacheflush_flags, tcp->u_arg[2], "FLUSH_CACHE_???");
 296                 /* len */
 297                 tprintf(", %lu", tcp->u_arg[3]);
 298         }
 299         return 0;
 300 }
 301 #endif /* M68K */
 302
 303 #ifdef BFIN
 304
 305 #include <bfin_sram.h>
 306
 307 static const struct xlat sram_alloc_flags[] = {
 308         { L1_INST_SRAM,         "L1_INST_SRAM" },
 309         { L1_DATA_A_SRAM,       "L1_DATA_A_SRAM" },
 310         { L1_DATA_B_SRAM,       "L1_DATA_B_SRAM" },
 311         { L1_DATA_SRAM,         "L1_DATA_SRAM" },
 312         { L2_SRAM,              "L2_SRAM" },
 313         { 0,                    NULL },
 314 };
 315
 316 int
 317 sys_sram_alloc(struct tcb *tcp)
 318 {
 319         if (entering(tcp)) {
 320                 /* size */
 321                 tprintf("%lu, ", tcp->u_arg[0]);
 322                 /* flags */
 323                 printxval(sram_alloc_flags, tcp->u_arg[1], "???_SRAM");
 324         }
 325         return 1;
 326 }
 327
 328 #include <asm/cachectl.h>
 329
 330 static const struct xlat cacheflush_flags[] = {
 331         { ICACHE,       "ICACHE" },
 332         { DCACHE,       "DCACHE" },
 333         { BCACHE,       "BCACHE" },
 334         { 0,            NULL },
 335 };
 336
 337 int
 338 sys_cacheflush(struct tcb *tcp)
 339 {
 340         if (entering(tcp)) {
 341                 /* start addr */
 342                 tprintf("%#lx, ", tcp->u_arg[0]);
 343                 /* length */
 344                 tprintf("%ld, ", tcp->u_arg[1]);
 345                 /* flags */
 346                 printxval(cacheflush_flags, tcp->u_arg[1], "?CACHE");
 347         }
 348         return 0;
 349 }
 350
 351 #endif
 352
 353 #ifdef SH
 354 static const struct xlat cacheflush_flags[] = {
 355 #ifdef CACHEFLUSH_D_INVAL
 356         { CACHEFLUSH_D_INVAL,   "CACHEFLUSH_D_INVAL" },
 357 #endif
 358 #ifdef CACHEFLUSH_D_WB
 359         { CACHEFLUSH_D_WB,      "CACHEFLUSH_D_WB" },
 360 #endif
 361 #ifdef CACHEFLUSH_D_PURGE
 362         { CACHEFLUSH_D_PURGE,   "CACHEFLUSH_D_PURGE" },
 363 #endif
 364 #ifdef CACHEFLUSH_I
 365         { CACHEFLUSH_I,         "CACHEFLUSH_I" },
 366 #endif
 367         { 0,                    NULL },
 368 };
 369
 370 int
 371 sys_cacheflush(struct tcb *tcp)
 372 {
 373         if (entering(tcp)) {
 374                 /* addr */
 375                 tprintf("%#lx, ", tcp->u_arg[0]);
 376                 /* len */
 377                 tprintf("%lu, ", tcp->u_arg[1]);
 378                 /* flags */
 379                 printflags(cacheflush_flags, tcp->u_arg[2], "CACHEFLUSH_???");
 380         }
 381         return 0;
 382 }
 383 #endif /* SH */
 384
 385 #endif /* LINUX */
 386
 387 #ifdef SUNOS4
 388
 389 #include <sys/reboot.h>
 390 #define NFSCLIENT
 391 #define LOFS
 392 #define RFS
 393 #define PCFS
 394 #include <sys/mount.h>
 395 #include <sys/socket.h>
 396 #include <nfs/export.h>
 397 #include <rpc/types.h>
 398 #include <rpc/auth.h>
 399
 400 /*ARGSUSED*/
 401 int
 402 sys_sync(struct tcb *tcp)
 403 {
 404         return 0;
 405 }
 406
 407 static const struct xlat bootflags[] = {
 408         { RB_AUTOBOOT,  "RB_AUTOBOOT"   },      /* for system auto-booting itself */
 409         { RB_ASKNAME,   "RB_ASKNAME"    },      /* ask for file name to reboot from */
 410         { RB_SINGLE,    "RB_SINGLE"     },      /* reboot to single user only */
 411         { RB_NOSYNC,    "RB_NOSYNC"     },      /* dont sync before reboot */
 412         { RB_HALT,      "RB_HALT"       },      /* don't reboot, just halt */
 413         { RB_INITNAME,  "RB_INITNAME"   },      /* name given for /etc/init */
 414         { RB_NOBOOTRC,  "RB_NOBOOTRC"   },      /* don't run /etc/rc.boot */
 415         { RB_DEBUG,     "RB_DEBUG"      },      /* being run under debugger */
 416         { RB_DUMP,      "RB_DUMP"       },      /* dump system core */
 417         { RB_WRITABLE,  "RB_WRITABLE"   },      /* mount root read/write */
 418         { RB_STRING,    "RB_STRING"     },      /* pass boot args to prom monitor */
 419         { 0,            NULL            },
 420 };
 421
 422 int
 423 sys_reboot(struct tcb *tcp)
 424 {
 425         if (entering(tcp)) {
 426                 printflags(bootflags, tcp->u_arg[0], "RB_???");
 427                 if (tcp->u_arg[0] & RB_STRING) {
 428                         printstr(tcp, tcp->u_arg[1], -1);
 429                 }
 430         }
 431         return 0;
 432 }
 433
 434 int
 435 sys_sysacct(struct tcb *tcp)
 436 {
 437         if (entering(tcp)) {
 438                 printstr(tcp, tcp->u_arg[0], -1);
 439         }
 440         return 0;
 441 }
 442
 443 int
 444 sys_swapon(struct tcb *tcp)
 445 {
 446         if (entering(tcp)) {
 447                 printstr(tcp, tcp->u_arg[0], -1);
 448         }
 449         return 0;
 450 }
 451
 452 int
 453 sys_nfs_svc(struct tcb *tcp)
 454 {
 455         if (entering(tcp)) {
 456                 printsock(tcp, tcp->u_arg[0]);
 457         }
 458         return 0;
 459 }
 460
 461 static const struct xlat mountflags[] = {
 462         { M_RDONLY,     "M_RDONLY"      },
 463         { M_NOSUID,     "M_NOSUID"      },
 464         { M_NEWTYPE,    "M_NEWTYPE"     },
 465         { M_GRPID,      "M_GRPID"       },
 466 #ifdef  M_REMOUNT
 467         { M_REMOUNT,    "M_REMOUNT"     },
 468 #endif
 469 #ifdef  M_NOSUB
 470         { M_NOSUB,      "M_NOSUB"       },
 471 #endif
 472 #ifdef  M_MULTI
 473         { M_MULTI,      "M_MULTI"       },
 474 #endif
 475 #ifdef  M_SYS5
 476         { M_SYS5,       "M_SYS5"        },
 477 #endif
 478         { 0,            NULL            },
 479 };
 480
 481 static const struct xlat nfsflags[] = {
 482         { NFSMNT_SOFT,          "NFSMNT_SOFT"           },
 483         { NFSMNT_WSIZE,         "NFSMNT_WSIZE"          },
 484         { NFSMNT_RSIZE,         "NFSMNT_RSIZE"          },
 485         { NFSMNT_TIMEO,         "NFSMNT_TIMEO"          },
 486         { NFSMNT_RETRANS,       "NFSMNT_RETRANS"        },
 487         { NFSMNT_HOSTNAME,      "NFSMNT_HOSTNAME"       },
 488         { NFSMNT_INT,           "NFSMNT_INT"            },
 489         { NFSMNT_NOAC,          "NFSMNT_NOAC"           },
 490         { NFSMNT_ACREGMIN,      "NFSMNT_ACREGMIN"       },
 491         { NFSMNT_ACREGMAX,      "NFSMNT_ACREGMAX"       },
 492         { NFSMNT_ACDIRMIN,      "NFSMNT_ACDIRMIN"       },
 493         { NFSMNT_ACDIRMAX,      "NFSMNT_ACDIRMAX"       },
 494 #ifdef  NFSMNT_SECURE
 495         { NFSMNT_SECURE,        "NFSMNT_SECURE"         },
 496 #endif
 497 #ifdef  NFSMNT_NOCTO
 498         { NFSMNT_NOCTO,         "NFSMNT_NOCTO"          },
 499 #endif
 500 #ifdef  NFSMNT_POSIX
 501         { NFSMNT_POSIX,         "NFSMNT_POSIX"          },
 502 #endif
 503         { 0,                    NULL                    },
 504 };
 505
 506 int
 507 sys_mount(struct tcb *tcp)
 508 {
 509         char type[4];
 510
 511         if (entering(tcp)) {
 512                 if (!(tcp->u_arg[2] & M_NEWTYPE) || umovestr(tcp,
 513                                 tcp->u_arg[0],  sizeof type, type) < 0) {
 514                         tprintf("OLDTYPE:#%lx", tcp->u_arg[0]);
 515                 } else {
 516                         tprintf("\"%s\", ", type);
 517                 }
 518                 printstr(tcp, tcp->u_arg[1], -1);
 519                 tprints(", ");
 520                 printflags(mountflags, tcp->u_arg[2] & ~M_NEWTYPE, "M_???");
 521                 tprints(", ");
 522
 523                 if (strcmp(type, "4.2") == 0) {
 524                         struct ufs_args a;
 525                         if (umove(tcp, tcp->u_arg[3], &a) < 0)
 526                                 return 0;
 527                         printstr(tcp, (int)a.fspec, -1);
 528                 } else if (strcmp(type, "lo") == 0) {
 529                         struct lo_args a;
 530                         if (umove(tcp, tcp->u_arg[3], &a) < 0)
 531                                 return 0;
 532                         printstr(tcp, (int)a.fsdir, -1);
 533                 } else if (strcmp(type, "nfs") == 0) {
 534                         struct nfs_args a;
 535                         if (umove(tcp, tcp->u_arg[3], &a) < 0)
 536                                 return 0;
 537                         tprints("[");
 538                         printsock(tcp, (int) a.addr);
 539                         tprints(", ");
 540                         printflags(nfsflags, a.flags, "NFSMNT_???");
 541                         tprintf(", ws:%u,rs:%u,to:%u,re:%u,",
 542                                 a.wsize, a.rsize, a.timeo, a.retrans);
 543                         if (a.flags & NFSMNT_HOSTNAME && a.hostname)
 544                                 printstr(tcp, (int)a.hostname, -1);
 545                         else
 546                                 tprintf("%#lx", (unsigned long) a.hostname);
 547                         tprintf(",reg-min:%u,max:%u,dir-min:%u,max:%u,",
 548                                 a.acregmin, a.acregmax, a.acdirmin, a.acdirmax);
 549                         if ((a.flags & NFSMNT_SECURE) && a.netname)
 550                                 printstr(tcp, (int) a.netname, -1);
 551                         else
 552                                 tprintf("%#lx", (unsigned long) a.netname);
 553                         tprints("]");
 554                 } else if (strcmp(type, "rfs") == 0) {
 555                         struct rfs_args a;
 556                         struct token t;
 557                         if (umove(tcp, tcp->u_arg[3], &a) < 0)
 558                                 return 0;
 559                         tprints("[");
 560                         printstr(tcp, (int)a.rmtfs, -1);
 561                         if (umove(tcp, (int)a.token, &t) < 0)
 562                                 return 0;
 563                         tprintf(", %u, %s]", t.t_id, t.t_uname);
 564                 } else if (strcmp(type, "pcfs") == 0) {
 565                         struct pc_args a;
 566                         if (umove(tcp, tcp->u_arg[3], &a) < 0)
 567                                 return 0;
 568                         printstr(tcp, (int)a.fspec, -1);
 569                 }
 570         }
 571         return 0;
 572 }
 573
 574 int
 575 sys_unmount(struct tcb *tcp)
 576 {
 577         if (entering(tcp)) {
 578                 printstr(tcp, tcp->u_arg[0], -1);
 579         }
 580         return 0;
 581 }
 582
 583 int
 584 sys_umount(struct tcb *tcp)
 585 {
 586         return sys_unmount(tcp);
 587 }
 588
 589 int
 590 sys_auditsys(struct tcb *tcp)
 591 {
 592         /* XXX - no information available */
 593         return printargs(tcp);
 594 }
 595
 596 static const struct xlat ex_auth_flags[] = {
 597         { AUTH_UNIX,    "AUTH_UNIX"     },
 598         { AUTH_DES,     "AUTH_DES"      },
 599         { 0,            NULL            },
 600 };
 601
 602 int
 603 sys_exportfs(struct tcb *tcp)
 604 {
 605         struct export e;
 606         int i;
 607
 608         if (entering(tcp)) {
 609                 printstr(tcp, tcp->u_arg[0], -1);
 610                 if (umove(tcp, tcp->u_arg[1], &e) < 0) {
 611                         tprintf("%#lx", tcp->u_arg[1]);
 612                         return 0;
 613                 }
 614                 tprintf("{fl:%u, anon:%u, ", e.ex_flags, e.ex_anon);
 615                 printxval(ex_auth_flags, e.ex_auth, "AUTH_???");
 616                 tprints(", roots:[");
 617                 if (e.ex_auth == AUTH_UNIX) {
 618                         for (i = 0; i < e.ex_u.exunix.rootaddrs.naddrs; i++) {
 619                                 printsock(tcp,
 620                                         (int)&e.ex_u.exunix.rootaddrs.addrvec[i]);
 621                         }
 622                         tprints("], writers:[");
 623                         for (i = 0; i < e.ex_writeaddrs.naddrs; i++) {
 624                                 printsock(tcp,
 625                                         (int)&e.ex_writeaddrs.addrvec[i]);
 626                         }
 627                         tprints("]");
 628                 } else {
 629                         for (i = 0; i < e.ex_u.exdes.nnames; i++) {
 630                                 printsock(tcp,
 631                                         (int)&e.ex_u.exdes.rootnames[i]);
 632                                 tprints(", ");
 633                         }
 634                         tprintf("], window:%u", e.ex_u.exdes.window);
 635                 }
 636                 tprints("}");
 637         }
 638         return 0;
 639 }
 640
 641 static const struct xlat sysconflimits[] = {
 642 #ifdef  _SC_ARG_MAX
 643         { _SC_ARG_MAX,  "_SC_ARG_MAX"   },      /* space for argv & envp */
 644 #endif
 645 #ifdef  _SC_CHILD_MAX
 646         { _SC_CHILD_MAX,        "_SC_CHILD_MAX" },      /* maximum children per process??? */
 647 #endif
 648 #ifdef  _SC_CLK_TCK
 649         { _SC_CLK_TCK,  "_SC_CLK_TCK"   },      /* clock ticks/sec */
 650 #endif
 651 #ifdef  _SC_NGROUPS_MAX
 652         { _SC_NGROUPS_MAX,      "_SC_NGROUPS_MAX"       },      /* number of groups if multple supp. */
 653 #endif
 654 #ifdef  _SC_OPEN_MAX
 655         { _SC_OPEN_MAX, "_SC_OPEN_MAX"  },      /* max open files per process */
 656 #endif
 657 #ifdef  _SC_JOB_CONTROL
 658         { _SC_JOB_CONTROL,      "_SC_JOB_CONTROL"       },      /* do we have job control */
 659 #endif
 660 #ifdef  _SC_SAVED_IDS
 661         { _SC_SAVED_IDS,        "_SC_SAVED_IDS" },      /* do we have saved uid/gids */
 662 #endif
 663 #ifdef  _SC_VERSION
 664         { _SC_VERSION,  "_SC_VERSION"   },      /* POSIX version supported */
 665 #endif
 666         { 0,            NULL            },
 667 };
 668
 669 int
 670 sys_sysconf(struct tcb *tcp)
 671 {
 672         if (entering(tcp)) {
 673                 printxval(sysconflimits, tcp->u_arg[0], "_SC_???");
 674         }
 675         return 0;
 676 }
 677
 678 #endif /* SUNOS4 */
 679
 680 #if defined(SUNOS4) || defined(FREEBSD)
 681 static const struct xlat pathconflimits[] = {
 682 #ifdef  _PC_LINK_MAX
 683         { _PC_LINK_MAX, "_PC_LINK_MAX"  },      /* max links to file/dir */
 684 #endif
 685 #ifdef  _PC_MAX_CANON
 686         { _PC_MAX_CANON,        "_PC_MAX_CANON" },      /* max line length */
 687 #endif
 688 #ifdef  _PC_MAX_INPUT
 689         { _PC_MAX_INPUT,        "_PC_MAX_INPUT" },      /* max "packet" to a tty device */
 690 #endif
 691 #ifdef  _PC_NAME_MAX
 692         { _PC_NAME_MAX, "_PC_NAME_MAX"  },      /* max pathname component length */
 693 #endif
 694 #ifdef  _PC_PATH_MAX
 695         { _PC_PATH_MAX, "_PC_PATH_MAX"  },      /* max pathname length */
 696 #endif
 697 #ifdef  _PC_PIPE_BUF
 698         { _PC_PIPE_BUF, "_PC_PIPE_BUF"  },      /* size of a pipe */
 699 #endif
 700 #ifdef  _PC_CHOWN_RESTRICTED
 701         { _PC_CHOWN_RESTRICTED, "_PC_CHOWN_RESTRICTED"  },      /* can we give away files */
 702 #endif
 703 #ifdef  _PC_NO_TRUNC
 704         { _PC_NO_TRUNC, "_PC_NO_TRUNC"  },      /* trunc or error on >NAME_MAX */
 705 #endif
 706 #ifdef  _PC_VDISABLE
 707         { _PC_VDISABLE, "_PC_VDISABLE"  },      /* best char to shut off tty c_cc */
 708 #endif
 709         { 0,            NULL            },
 710 };
 711
 712
 713 int
 714 sys_pathconf(struct tcb *tcp)
 715 {
 716         if (entering(tcp)) {
 717                 printstr(tcp, tcp->u_arg[0], -1);
 718                 tprints(", ");
 719                 printxval(pathconflimits, tcp->u_arg[1], "_PC_???");
 720         }
 721         return 0;
 722 }
 723
 724 int
 725 sys_fpathconf(struct tcb *tcp)
 726 {
 727         if (entering(tcp)) {
 728                 tprintf("%lu, ", tcp->u_arg[0]);
 729                 printxval(pathconflimits, tcp->u_arg[1], "_PC_???");
 730         }
 731         return 0;
 732 }
 733
 734 #endif /* SUNOS4 || FREEBSD */
 735
 736 #ifdef SVR4
 737
 738 #ifdef HAVE_SYS_SYSCONFIG_H
 739 #include <sys/sysconfig.h>
 740 #endif /* HAVE_SYS_SYSCONFIG_H */
 741
 742 #include <sys/mount.h>
 743 #include <sys/systeminfo.h>
 744 #include <sys/utsname.h>
 745
 746 static const struct xlat sysconfig_options[] = {
 747 #ifdef _CONFIG_NGROUPS
 748         { _CONFIG_NGROUPS,              "_CONFIG_NGROUPS"               },
 749 #endif
 750 #ifdef _CONFIG_CHILD_MAX
 751         { _CONFIG_CHILD_MAX,            "_CONFIG_CHILD_MAX"             },
 752 #endif
 753 #ifdef _CONFIG_OPEN_FILES
 754         { _CONFIG_OPEN_FILES,           "_CONFIG_OPEN_FILES"            },
 755 #endif
 756 #ifdef _CONFIG_POSIX_VER
 757         { _CONFIG_POSIX_VER,            "_CONFIG_POSIX_VER"             },
 758 #endif
 759 #ifdef _CONFIG_PAGESIZE
 760         { _CONFIG_PAGESIZE,             "_CONFIG_PAGESIZE"              },
 761 #endif
 762 #ifdef _CONFIG_CLK_TCK
 763         { _CONFIG_CLK_TCK,              "_CONFIG_CLK_TCK"               },
 764 #endif
 765 #ifdef _CONFIG_XOPEN_VER
 766         { _CONFIG_XOPEN_VER,            "_CONFIG_XOPEN_VER"             },
 767 #endif
 768 #ifdef _CONFIG_PROF_TCK
 769         { _CONFIG_PROF_TCK,             "_CONFIG_PROF_TCK"              },
 770 #endif
 771 #ifdef _CONFIG_NPROC_CONF
 772         { _CONFIG_NPROC_CONF,           "_CONFIG_NPROC_CONF"            },
 773 #endif
 774 #ifdef _CONFIG_NPROC_ONLN
 775         { _CONFIG_NPROC_ONLN,           "_CONFIG_NPROC_ONLN"            },
 776 #endif
 777 #ifdef _CONFIG_AIO_LISTIO_MAX
 778         { _CONFIG_AIO_LISTIO_MAX,       "_CONFIG_AIO_LISTIO_MAX"        },
 779 #endif
 780 #ifdef _CONFIG_AIO_MAX
 781         { _CONFIG_AIO_MAX,              "_CONFIG_AIO_MAX"               },
 782 #endif
 783 #ifdef _CONFIG_AIO_PRIO_DELTA_MAX
 784         { _CONFIG_AIO_PRIO_DELTA_MAX,   "_CONFIG_AIO_PRIO_DELTA_MAX"    },
 785 #endif
 786 #ifdef _CONFIG_CONFIG_DELAYTIMER_MAX
 787         { _CONFIG_DELAYTIMER_MAX,       "_CONFIG_DELAYTIMER_MAX"        },
 788 #endif
 789 #ifdef _CONFIG_MQ_OPEN_MAX
 790         { _CONFIG_MQ_OPEN_MAX,          "_CONFIG_MQ_OPEN_MAX"           },
 791 #endif
 792 #ifdef _CONFIG_MQ_PRIO_MAX
 793         { _CONFIG_MQ_PRIO_MAX,          "_CONFIG_MQ_PRIO_MAX"           },
 794 #endif
 795 #ifdef _CONFIG_RTSIG_MAX
 796         { _CONFIG_RTSIG_MAX,            "_CONFIG_RTSIG_MAX"             },
 797 #endif
 798 #ifdef _CONFIG_SEM_NSEMS_MAX
 799         { _CONFIG_SEM_NSEMS_MAX,        "_CONFIG_SEM_NSEMS_MAX"         },
 800 #endif
 801 #ifdef _CONFIG_SEM_VALUE_MAX
 802         { _CONFIG_SEM_VALUE_MAX,        "_CONFIG_SEM_VALUE_MAX"         },
 803 #endif
 804 #ifdef _CONFIG_SIGQUEUE_MAX
 805         { _CONFIG_SIGQUEUE_MAX,         "_CONFIG_SIGQUEUE_MAX"          },
 806 #endif
 807 #ifdef _CONFIG_SIGRT_MIN
 808         { _CONFIG_SIGRT_MIN,            "_CONFIG_SIGRT_MIN"             },
 809 #endif
 810 #ifdef _CONFIG_SIGRT_MAX
 811         { _CONFIG_SIGRT_MAX,            "_CONFIG_SIGRT_MAX"             },
 812 #endif
 813 #ifdef _CONFIG_TIMER_MAX
 814         { _CONFIG_TIMER_MAX,            "_CONFIG_TIMER_MAX"             },
 815 #endif
 816 #ifdef _CONFIG_CONFIG_PHYS_PAGES
 817         { _CONFIG_PHYS_PAGES,           "_CONFIG_PHYS_PAGES"            },
 818 #endif
 819 #ifdef _CONFIG_AVPHYS_PAGES
 820         { _CONFIG_AVPHYS_PAGES,         "_CONFIG_AVPHYS_PAGES"          },
 821 #endif
 822         { 0,                            NULL                            },
 823 };
 824
 825 int
 826 sys_sysconfig(struct tcb *tcp)
 827 {
 828         if (entering(tcp))
 829                 printxval(sysconfig_options, tcp->u_arg[0], "_CONFIG_???");
 830         return 0;
 831 }
 832
 833 static const struct xlat sysinfo_options[] = {
 834         { SI_SYSNAME,           "SI_SYSNAME"            },
 835         { SI_HOSTNAME,          "SI_HOSTNAME"           },
 836         { SI_RELEASE,           "SI_RELEASE"            },
 837         { SI_VERSION,           "SI_VERSION"            },
 838         { SI_MACHINE,           "SI_MACHINE"            },
 839         { SI_ARCHITECTURE,      "SI_ARCHITECTURE"       },
 840         { SI_HW_SERIAL,         "SI_HW_SERIAL"          },
 841         { SI_HW_PROVIDER,       "SI_HW_PROVIDER"        },
 842         { SI_SRPC_DOMAIN,       "SI_SRPC_DOMAIN"        },
 843 #ifdef SI_SET_HOSTNAME
 844         { SI_SET_HOSTNAME,      "SI_SET_HOSTNAME"       },
 845 #endif
 846 #ifdef SI_SET_SRPC_DOMAIN
 847         { SI_SET_SRPC_DOMAIN,   "SI_SET_SRPC_DOMAIN"    },
 848 #endif
 849 #ifdef SI_SET_KERB_REALM
 850         { SI_SET_KERB_REALM,    "SI_SET_KERB_REALM"     },
 851 #endif
 852 #ifdef SI_KERB_REALM
 853         { SI_KERB_REALM,        "SI_KERB_REALM"         },
 854 #endif
 855         { 0,                    NULL                    },
 856 };
 857
 858 int
 859 sys_sysinfo(struct tcb *tcp)
 860 {
 861         if (entering(tcp)) {
 862                 printxval(sysinfo_options, tcp->u_arg[0], "SI_???");
 863                 tprints(", ");
 864         }
 865         else {
 866                 /* Technically some calls write values.  So what. */
 867                 if (syserror(tcp))
 868                         tprintf("%#lx", tcp->u_arg[1]);
 869                 else
 870                         printpath(tcp, tcp->u_arg[1]);
 871                 tprintf(", %lu", tcp->u_arg[2]);
 872         }
 873         return 0;
 874 }
 875
 876 #ifdef MIPS
 877
 878 #include <sys/syssgi.h>
 879
 880 static const struct xlat syssgi_options[] = {
 881         { SGI_SYSID,            "SGI_SYSID"             },
 882 #ifdef SGI_RDUBLK
 883         { SGI_RDUBLK,           "SGI_RDUBLK"            },
 884 #endif
 885         { SGI_TUNE,             "SGI_TUNE"              },
 886         { SGI_IDBG,             "SGI_IDBG"              },
 887         { SGI_INVENT,           "SGI_INVENT"            },
 888         { SGI_RDNAME,           "SGI_RDNAME"            },
 889         { SGI_SETLED,           "SGI_SETLED"            },
 890         { SGI_SETNVRAM,         "SGI_SETNVRAM"          },
 891         { SGI_GETNVRAM,         "SGI_GETNVRAM"          },
 892         { SGI_QUERY_FTIMER,     "SGI_QUERY_FTIMER"      },
 893         { SGI_QUERY_CYCLECNTR,  "SGI_QUERY_CYCLECNTR"   },
 894         { SGI_PROCSZ,           "SGI_PROCSZ"            },
 895         { SGI_SIGACTION,        "SGI_SIGACTION"         },
 896         { SGI_SIGPENDING,       "SGI_SIGPENDING"        },
 897         { SGI_SIGPROCMASK,      "SGI_SIGPROCMASK"       },
 898         { SGI_SIGSUSPEND,       "SGI_SIGSUSPEND"        },
 899         { SGI_SETSID,           "SGI_SETSID"            },
 900         { SGI_SETPGID,          "SGI_SETPGID"           },
 901         { SGI_SYSCONF,          "SGI_SYSCONF"           },
 902         { SGI_WAIT4,            "SGI_WAIT4"             },
 903         { SGI_PATHCONF,         "SGI_PATHCONF"          },
 904         { SGI_READB,            "SGI_READB"             },
 905         { SGI_WRITEB,           "SGI_WRITEB"            },
 906         { SGI_SETGROUPS,        "SGI_SETGROUPS"         },
 907         { SGI_GETGROUPS,        "SGI_GETGROUPS"         },
 908         { SGI_SETTIMEOFDAY,     "SGI_SETTIMEOFDAY"      },
 909         { SGI_SETTIMETRIM,      "SGI_SETTIMETRIM"       },
 910         { SGI_GETTIMETRIM,      "SGI_GETTIMETRIM"       },
 911         { SGI_SPROFIL,          "SGI_SPROFIL"           },
 912         { SGI_RUSAGE,           "SGI_RUSAGE"            },
 913         { SGI_SIGSTACK,         "SGI_SIGSTACK"          },
 914         { SGI_SIGSTATUS,        "SGI_SIGSTATUS"         },
 915         { SGI_NETPROC,          "SGI_NETPROC"           },
 916         { SGI_SIGALTSTACK,      "SGI_SIGALTSTACK"       },
 917         { SGI_BDFLUSHCNT,       "SGI_BDFLUSHCNT"        },
 918         { SGI_SSYNC,            "SGI_SSYNC"             },
 919         { SGI_NFSCNVT,          "SGI_NFSCNVT"           },
 920         { SGI_GETPGID,          "SGI_GETPGID"           },
 921         { SGI_GETSID,           "SGI_GETSID"            },
 922         { SGI_IOPROBE,          "SGI_IOPROBE"           },
 923         { SGI_CONFIG,           "SGI_CONFIG"            },
 924         { SGI_ELFMAP,           "SGI_ELFMAP"            },
 925         { SGI_MCONFIG,          "SGI_MCONFIG"           },
 926         { SGI_GETPLABEL,        "SGI_GETPLABEL"         },
 927         { SGI_SETPLABEL,        "SGI_SETPLABEL"         },
 928         { SGI_GETLABEL,         "SGI_GETLABEL"          },
 929         { SGI_SETLABEL,         "SGI_SETLABEL"          },
 930         { SGI_SATREAD,          "SGI_SATREAD"           },
 931         { SGI_SATWRITE,         "SGI_SATWRITE"          },
 932         { SGI_SATCTL,           "SGI_SATCTL"            },
 933         { SGI_LOADATTR,         "SGI_LOADATTR"          },
 934         { SGI_UNLOADATTR,       "SGI_UNLOADATTR"        },
 935 #ifdef SGI_RECVLMSG
 936         { SGI_RECVLMSG,         "SGI_RECVLMSG"          },
 937 #endif
 938         { SGI_PLANGMOUNT,       "SGI_PLANGMOUNT"        },
 939         { SGI_GETPSOACL,        "SGI_GETPSOACL"         },
 940         { SGI_SETPSOACL,        "SGI_SETPSOACL"         },
 941 #ifdef SGI_EAG_GET_ATTR
 942         { SGI_EAG_GET_ATTR,     "SGI_EAG_GET_ATTR"      },
 943 #endif
 944 #ifdef SGI_EAG_SET_ATTR
 945         { SGI_EAG_SET_ATTR,     "SGI_EAG_SET_ATTR"      },
 946 #endif
 947 #ifdef SGI_EAG_GET_PROCATTR
 948         { SGI_EAG_GET_PROCATTR, "SGI_EAG_GET_PROCATTR"  },
 949 #endif
 950 #ifdef SGI_EAG_SET_PROCATTR
 951         { SGI_EAG_SET_PROCATTR, "SGI_EAG_SET_PROCATTR"  },
 952 #endif
 953 #ifdef SGI_FREVOKE
 954         { SGI_FREVOKE,          "SGI_FREVOKE"           },
 955 #endif
 956 #ifdef SGI_SBE_GET_INFO
 957         { SGI_SBE_GET_INFO,     "SGI_SBE_GET_INFO"      },
 958 #endif
 959 #ifdef SGI_SBE_CLR_INFO
 960         { SGI_SBE_CLR_INFO,     "SGI_SBE_CLR_INFO"      },
 961 #endif
 962         { SGI_RMI_FIXECC,       "SGI_RMI_FIXECC"        },
 963         { SGI_R4K_CERRS,        "SGI_R4K_CERRS"         },
 964         { SGI_GET_EVCONF,       "SGI_GET_EVCONF"        },
 965         { SGI_MPCWAROFF,        "SGI_MPCWAROFF"         },
 966         { SGI_SET_AUTOPWRON,    "SGI_SET_AUTOPWRON"     },
 967         { SGI_SPIPE,            "SGI_SPIPE"             },
 968         { SGI_SYMTAB,           "SGI_SYMTAB"            },
 969 #ifdef SGI_SET_FPDEBUG
 970         { SGI_SET_FPDEBUG,      "SGI_SET_FPDEBUG"       },
 971 #endif
 972 #ifdef SGI_SET_FP_PRECISE
 973         { SGI_SET_FP_PRECISE,   "SGI_SET_FP_PRECISE"    },
 974 #endif
 975         { SGI_TOSSTSAVE,        "SGI_TOSSTSAVE"         },
 976         { SGI_FDHI,             "SGI_FDHI"              },
 977 #ifdef SGI_SET_CONFIG_SMM
 978         { SGI_SET_CONFIG_SMM,   "SGI_SET_CONFIG_SMM"    },
 979 #endif
 980 #ifdef SGI_SET_FP_PRESERVE
 981         { SGI_SET_FP_PRESERVE,  "SGI_SET_FP_PRESERVE"   },
 982 #endif
 983         { SGI_MINRSS,           "SGI_MINRSS"            },
 984 #ifdef SGI_GRIO
 985         { SGI_GRIO,             "SGI_GRIO"              },
 986 #endif
 987 #ifdef SGI_XLV_SET_TAB
 988         { SGI_XLV_SET_TAB,      "SGI_XLV_SET_TAB"       },
 989 #endif
 990 #ifdef SGI_XLV_GET_TAB
 991         { SGI_XLV_GET_TAB,      "SGI_XLV_GET_TAB"       },
 992 #endif
 993 #ifdef SGI_GET_FP_PRECISE
 994         { SGI_GET_FP_PRECISE,   "SGI_GET_FP_PRECISE"    },
 995 #endif
 996 #ifdef SGI_GET_CONFIG_SMM
 997         { SGI_GET_CONFIG_SMM,   "SGI_GET_CONFIG_SMM"    },
 998 #endif
 999 #ifdef SGI_FP_IMPRECISE_SUPP
1000         { SGI_FP_IMPRECISE_SUPP,"SGI_FP_IMPRECISE_SUPP" },
1001 #endif
1002 #ifdef SGI_CONFIG_NSMM_SUPP
1003         { SGI_CONFIG_NSMM_SUPP, "SGI_CONFIG_NSMM_SUPP"  },
1004 #endif
1005 #ifdef SGI_RT_TSTAMP_CREATE
1006         { SGI_RT_TSTAMP_CREATE, "SGI_RT_TSTAMP_CREATE"  },
1007 #endif
1008 #ifdef SGI_RT_TSTAMP_DELETE
1009         { SGI_RT_TSTAMP_DELETE, "SGI_RT_TSTAMP_DELETE"  },
1010 #endif
1011 #ifdef SGI_RT_TSTAMP_START
1012         { SGI_RT_TSTAMP_START,  "SGI_RT_TSTAMP_START"   },
1013 #endif
1014 #ifdef SGI_RT_TSTAMP_STOP
1015         { SGI_RT_TSTAMP_STOP,   "SGI_RT_TSTAMP_STOP"    },
1016 #endif
1017 #ifdef SGI_RT_TSTAMP_ADDR
1018         { SGI_RT_TSTAMP_ADDR,   "SGI_RT_TSTAMP_ADDR"    },
1019 #endif
1020 #ifdef SGI_RT_TSTAMP_MASK
1021         { SGI_RT_TSTAMP_MASK,   "SGI_RT_TSTAMP_MASK"    },
1022 #endif
1023 #ifdef SGI_RT_TSTAMP_EOB_MODE
1024         { SGI_RT_TSTAMP_EOB_MODE,"SGI_RT_TSTAMP_EOB_MODE"},
1025 #endif
1026 #ifdef SGI_USE_FP_BCOPY
1027         { SGI_USE_FP_BCOPY,     "SGI_USE_FP_BCOPY"      },
1028 #endif
1029 #ifdef SGI_GET_UST
1030         { SGI_GET_UST,          "SGI_GET_UST"           },
1031 #endif
1032 #ifdef SGI_SPECULATIVE_EXEC
1033         { SGI_SPECULATIVE_EXEC, "SGI_SPECULATIVE_EXEC"  },
1034 #endif
1035 #ifdef SGI_XLV_NEXT_RQST
1036         { SGI_XLV_NEXT_RQST,    "SGI_XLV_NEXT_RQST"     },
1037 #endif
1038 #ifdef SGI_XLV_ATTR_CURSOR
1039         { SGI_XLV_ATTR_CURSOR,  "SGI_XLV_ATTR_CURSOR"   },
1040 #endif
1041 #ifdef SGI_XLV_ATTR_GET
1042         { SGI_XLV_ATTR_GET,     "SGI_XLV_ATTR_GET"      },
1043 #endif
1044 #ifdef SGI_XLV_ATTR_SET
1045         { SGI_XLV_ATTR_SET,     "SGI_XLV_ATTR_SET"      },
1046 #endif
1047 #ifdef SGI_BTOOLSIZE
1048         { SGI_BTOOLSIZE,        "SGI_BTOOLSIZE"         },
1049 #endif
1050 #ifdef SGI_BTOOLGET
1051         { SGI_BTOOLGET,         "SGI_BTOOLGET"          },
1052 #endif
1053 #ifdef SGI_BTOOLREINIT
1054         { SGI_BTOOLREINIT,      "SGI_BTOOLREINIT"       },
1055 #endif
1056 #ifdef SGI_CREATE_UUID
1057         { SGI_CREATE_UUID,      "SGI_CREATE_UUID"       },
1058 #endif
1059 #ifdef SGI_NOFPE
1060         { SGI_NOFPE,            "SGI_NOFPE"             },
1061 #endif
1062 #ifdef SGI_OLD_SOFTFP
1063         { SGI_OLD_SOFTFP,       "SGI_OLD_SOFTFP"        },
1064 #endif
1065 #ifdef SGI_FS_INUMBERS
1066         { SGI_FS_INUMBERS,      "SGI_FS_INUMBERS"       },
1067 #endif
1068 #ifdef SGI_FS_BULKSTAT
1069         { SGI_FS_BULKSTAT,      "SGI_FS_BULKSTAT"       },
1070 #endif
1071 #ifdef SGI_RT_TSTAMP_WAIT
1072         { SGI_RT_TSTAMP_WAIT,   "SGI_RT_TSTAMP_WAIT"    },
1073 #endif
1074 #ifdef SGI_RT_TSTAMP_UPDATE
1075         { SGI_RT_TSTAMP_UPDATE, "SGI_RT_TSTAMP_UPDATE"  },
1076 #endif
1077 #ifdef SGI_PATH_TO_HANDLE
1078         { SGI_PATH_TO_HANDLE,   "SGI_PATH_TO_HANDLE"    },
1079 #endif
1080 #ifdef SGI_PATH_TO_FSHANDLE
1081         { SGI_PATH_TO_FSHANDLE, "SGI_PATH_TO_FSHANDLE"  },
1082 #endif
1083 #ifdef SGI_FD_TO_HANDLE
1084         { SGI_FD_TO_HANDLE,     "SGI_FD_TO_HANDLE"      },
1085 #endif
1086 #ifdef SGI_OPEN_BY_HANDLE
1087         { SGI_OPEN_BY_HANDLE,   "SGI_OPEN_BY_HANDLE"    },
1088 #endif
1089 #ifdef SGI_READLINK_BY_HANDLE
1090         { SGI_READLINK_BY_HANDLE,"SGI_READLINK_BY_HANDLE"},
1091 #endif
1092 #ifdef SGI_READ_DANGID
1093         { SGI_READ_DANGID,      "SGI_READ_DANGID"       },
1094 #endif
1095 #ifdef SGI_CONST
1096         { SGI_CONST,            "SGI_CONST"             },
1097 #endif
1098 #ifdef SGI_XFS_FSOPERATIONS
1099         { SGI_XFS_FSOPERATIONS, "SGI_XFS_FSOPERATIONS"  },
1100 #endif
1101 #ifdef SGI_SETASH
1102         { SGI_SETASH,           "SGI_SETASH"            },
1103 #endif
1104 #ifdef SGI_GETASH
1105         { SGI_GETASH,           "SGI_GETASH"            },
1106 #endif
1107 #ifdef SGI_SETPRID
1108         { SGI_SETPRID,          "SGI_SETPRID"           },
1109 #endif
1110 #ifdef SGI_GETPRID
1111         { SGI_GETPRID,          "SGI_GETPRID"           },
1112 #endif
1113 #ifdef SGI_SETSPINFO
1114         { SGI_SETSPINFO,        "SGI_SETSPINFO"         },
1115 #endif
1116 #ifdef SGI_GETSPINFO
1117         { SGI_GETSPINFO,        "SGI_GETSPINFO"         },
1118 #endif
1119 #ifdef SGI_SHAREII
1120         { SGI_SHAREII,          "SGI_SHAREII"           },
1121 #endif
1122 #ifdef SGI_NEWARRAYSESS
1123         { SGI_NEWARRAYSESS,     "SGI_NEWARRAYSESS"      },
1124 #endif
1125 #ifdef SGI_GETDFLTPRID
1126         { SGI_GETDFLTPRID,      "SGI_GETDFLTPRID"       },
1127 #endif
1128 #ifdef SGI_SET_DISMISSED_EXC_CNT
1129         { SGI_SET_DISMISSED_EXC_CNT,"SGI_SET_DISMISSED_EXC_CNT" },
1130 #endif
1131 #ifdef SGI_GET_DISMISSED_EXC_CNT
1132         { SGI_GET_DISMISSED_EXC_CNT,"SGI_GET_DISMISSED_EXC_CNT" },
1133 #endif
1134 #ifdef SGI_CYCLECNTR_SIZE
1135         { SGI_CYCLECNTR_SIZE,   "SGI_CYCLECNTR_SIZE"    },
1136 #endif
1137 #ifdef SGI_QUERY_FASTTIMER
1138         { SGI_QUERY_FASTTIMER,  "SGI_QUERY_FASTTIMER"   },
1139 #endif
1140 #ifdef SGI_PIDSINASH
1141         { SGI_PIDSINASH,        "SGI_PIDSINASH"         },
1142 #endif
1143 #ifdef SGI_ULI
1144         { SGI_ULI,              "SGI_ULI"               },
1145 #endif
1146 #ifdef SGI_LPG_SHMGET
1147         { SGI_LPG_SHMGET,       "SGI_LPG_SHMGET"        },
1148 #endif
1149 #ifdef SGI_LPG_MAP
1150         { SGI_LPG_MAP,          "SGI_LPG_MAP"           },
1151 #endif
1152 #ifdef SGI_CACHEFS_SYS
1153         { SGI_CACHEFS_SYS,      "SGI_CACHEFS_SYS"       },
1154 #endif
1155 #ifdef SGI_NFSNOTIFY
1156         { SGI_NFSNOTIFY,        "SGI_NFSNOTIFY"         },
1157 #endif
1158 #ifdef SGI_LOCKDSYS
1159         { SGI_LOCKDSYS,         "SGI_LOCKDSYS"          },
1160 #endif
1161 #ifdef SGI_EVENTCTR
1162         { SGI_EVENTCTR,         "SGI_EVENTCTR"          },
1163 #endif
1164 #ifdef SGI_GETPRUSAGE
1165         { SGI_GETPRUSAGE,       "SGI_GETPRUSAGE"        },
1166 #endif
1167 #ifdef SGI_PROCMASK_LOCATION
1168         { SGI_PROCMASK_LOCATION,"SGI_PROCMASK_LOCATION" },
1169 #endif
1170 #ifdef SGI_UNUSED
1171         { SGI_UNUSED,           "SGI_UNUSED"            },
1172 #endif
1173 #ifdef SGI_CKPT_SYS
1174         { SGI_CKPT_SYS,         "SGI_CKPT_SYS"          },
1175 #endif
1176 #ifdef SGI_CKPT_SYS
1177         { SGI_CKPT_SYS,         "SGI_CKPT_SYS"          },
1178 #endif
1179 #ifdef SGI_GETGRPPID
1180         { SGI_GETGRPPID,        "SGI_GETGRPPID"         },
1181 #endif
1182 #ifdef SGI_GETSESPID
1183         { SGI_GETSESPID,        "SGI_GETSESPID"         },
1184 #endif
1185 #ifdef SGI_ENUMASHS
1186         { SGI_ENUMASHS,         "SGI_ENUMASHS"          },
1187 #endif
1188 #ifdef SGI_SETASMACHID
1189         { SGI_SETASMACHID,      "SGI_SETASMACHID"       },
1190 #endif
1191 #ifdef SGI_GETASMACHID
1192         { SGI_GETASMACHID,      "SGI_GETASMACHID"       },
1193 #endif
1194 #ifdef SGI_GETARSESS
1195         { SGI_GETARSESS,        "SGI_GETARSESS"         },
1196 #endif
1197 #ifdef SGI_JOINARRAYSESS
1198         { SGI_JOINARRAYSESS,    "SGI_JOINARRAYSESS"     },
1199 #endif
1200 #ifdef SGI_SPROC_KILL
1201         { SGI_SPROC_KILL,       "SGI_SPROC_KILL"        },
1202 #endif
1203 #ifdef SGI_DBA_CONFIG
1204         { SGI_DBA_CONFIG,       "SGI_DBA_CONFIG"        },
1205 #endif
1206 #ifdef SGI_RELEASE_NAME
1207         { SGI_RELEASE_NAME,     "SGI_RELEASE_NAME"      },
1208 #endif
1209 #ifdef SGI_SYNCH_CACHE_HANDLER
1210         { SGI_SYNCH_CACHE_HANDLER,"SGI_SYNCH_CACHE_HANDLER"},
1211 #endif
1212 #ifdef SGI_SWASH_INIT
1213         { SGI_SWASH_INIT,       "SGI_SWASH_INIT"        },
1214 #endif
1215 #ifdef SGI_NUMA_MIGR_PAGE
1216         { SGI_NUMA_MIGR_PAGE,   "SGI_NUMA_MIGR_PAGE"    },
1217 #endif
1218 #ifdef SGI_NUMA_MIGR_PAGE_ALT
1219         { SGI_NUMA_MIGR_PAGE_ALT,"SGI_NUMA_MIGR_PAGE_ALT"},
1220 #endif
1221 #ifdef SGI_KAIO_USERINIT
1222         { SGI_KAIO_USERINIT,    "SGI_KAIO_USERINIT"     },
1223 #endif
1224 #ifdef SGI_KAIO_READ
1225         { SGI_KAIO_READ,        "SGI_KAIO_READ"         },
1226 #endif
1227 #ifdef SGI_KAIO_WRITE
1228         { SGI_KAIO_WRITE,       "SGI_KAIO_WRITE"        },
1229 #endif
1230 #ifdef SGI_KAIO_SUSPEND
1231         { SGI_KAIO_SUSPEND,     "SGI_KAIO_SUSPEND"      },
1232 #endif
1233 #ifdef SGI_KAIO_STATS
1234         { SGI_KAIO_STATS,       "SGI_KAIO_STATS"        },
1235 #endif
1236 #ifdef SGI_INITIAL_PT_SPROC
1237         { SGI_INITIAL_PT_SPROC, "SGI_INITIAL_PT_SPROC"  },
1238 #endif
1239         { 0,                    NULL                    },
1240 };
1241
1242 int
1243 sys_syssgi(struct tcb *tcp)
1244 {
1245         int i;
1246
1247         if (entering(tcp)) {
1248                 printxval(syssgi_options, tcp->u_arg[0], "SGI_???");
1249                 switch (tcp->u_arg[0]) {
1250                 default:
1251                         for (i = 1; i < tcp->u_nargs; i++)
1252                                 tprintf(", %#lx", tcp->u_arg[i]);
1253                         break;
1254                 }
1255         }
1256         return 0;
1257 }
1258
1259 #include <sys/types.h>
1260 #include <rpc/rpc.h>
1261 struct cred;
1262 struct uio;
1263 #include <sys/fsid.h>
1264 #include <sys/vnode.h>
1265 #include <sys/fs/nfs.h>
1266 #include <sys/fs/nfs_clnt.h>
1267
1268 static const struct xlat mount_flags[] = {
1269         { MS_RDONLY,    "MS_RDONLY"     },
1270         { MS_FSS,       "MS_FSS"        },
1271         { MS_DATA,      "MS_DATA"       },
1272         { MS_NOSUID,    "MS_NOSUID"     },
1273         { MS_REMOUNT,   "MS_REMOUNT"    },
1274         { MS_NOTRUNC,   "MS_NOTRUNC"    },
1275         { MS_GRPID,     "MS_GRPID"      },
1276         { MS_NODEV,     "MS_NODEV"      },
1277         { MS_BEFORE,    "MS_BEFORE"     },
1278         { MS_AFTER,     "MS_AFTER"      },
1279         { 0,            NULL            },
1280 };
1281
1282 static const struct xlat nfs_flags[] = {
1283         { NFSMNT_SOFT,          "NFSMNT_SOFT"           },
1284         { NFSMNT_WSIZE,         "NFSMNT_WSIZE"          },
1285         { NFSMNT_RSIZE,         "NFSMNT_RSIZE"          },
1286         { NFSMNT_TIMEO,         "NFSMNT_TIMEO"          },
1287         { NFSMNT_RETRANS,       "NFSMNT_RETRANS"        },
1288         { NFSMNT_HOSTNAME,      "NFSMNT_HOSTNAME"       },
1289 #ifdef NFSMNT_NOINT     /* IRIX 6 */
1290         { NFSMNT_NOINT,         "NFSMNT_NOINT"          },
1291 #endif
1292 #ifdef NFSMNT_INT       /* IRIX 5 */
1293         { NFSMNT_INT,           "NFSMNT_INT"            },
1294 #endif
1295         { NFSMNT_NOAC,          "NFSMNT_NOAC"           },
1296         { NFSMNT_ACREGMIN,      "NFSMNT_ACREGMIN"       },
1297         { NFSMNT_ACREGMAX,      "NFSMNT_ACREGMAX"       },
1298         { NFSMNT_ACDIRMIN,      "NFSMNT_ACDIRMIN"       },
1299         { NFSMNT_ACDIRMAX,      "NFSMNT_ACDIRMAX"       },
1300         { NFSMNT_PRIVATE,       "NFSMNT_PRIVATE"        },
1301         { NFSMNT_SYMTTL,        "NFSMNT_SYMTTL"         },
1302         { NFSMNT_LOOPBACK,      "NFSMNT_LOOPBACK"       },
1303         { NFSMNT_BASETYPE,      "NFSMNT_BASETYPE"       },
1304         { NFSMNT_NAMEMAX,       "NFSMNT_NAMEMAX"        },
1305 #ifdef NFSMNT_SHORTUID  /* IRIX 6 */
1306         { NFSMNT_SHORTUID,      "NFSMNT_SHORTUID"       },
1307 #endif
1308 #ifdef NFSMNT_ASYNCNLM  /* IRIX 6 */
1309         { NFSMNT_ASYNCNLM,      "NFSMNT_ASYNCNLM"       },
1310 #endif
1311         { 0,                    NULL                    },
1312 };
1313
1314 int
1315 sys_mount(struct tcb *tcp)
1316 {
1317         if (entering(tcp)) {
1318                 printpath(tcp, tcp->u_arg[0]);
1319                 tprints(", ");
1320                 printpath(tcp, tcp->u_arg[1]);
1321                 tprints(", ");
1322                 printflags(mount_flags, tcp->u_arg[2], "MS_???");
1323                 if (tcp->u_arg[2] & (MS_FSS | MS_DATA)) {
1324                         tprints(", ");
1325                         tprintf("%ld", tcp->u_arg[3]);
1326                 }
1327                 if (tcp->u_arg[2] & MS_DATA) {
1328                         int nfs_type = sysfs(GETFSIND, FSID_NFS);
1329
1330                         tprints(", ");
1331                         if (tcp->u_arg[3] == nfs_type) {
1332                                 struct nfs_args args;
1333                                 if (umove(tcp, tcp->u_arg[4], &args) < 0)
1334                                         tprintf("%#lx", tcp->u_arg[4]);
1335                                 else {
1336                                         tprints("addr=");
1337                                         printsock(tcp, (int) args.addr);
1338                                         tprints(", flags=");
1339                                         printflags(nfs_flags, args.flags, "NFSMNT_???");
1340                                         tprints(", hostname=");
1341                                         printstr(tcp, (int) args.hostname, -1);
1342                                         tprints(", ...}");
1343                                 }
1344                         }
1345                         else
1346                                 tprintf("%#lx", tcp->u_arg[4]);
1347                         tprintf(", %ld", tcp->u_arg[5]);
1348                 }
1349         }
1350         return 0;
1351 }
1352
1353 #else /* !MIPS */
1354
1355 #if UNIXWARE
1356
1357 #include <sys/types.h>
1358 #include <sys/fstyp.h>
1359 #include <sys/mount.h>
1360 #include <sys/xti.h>
1361
1362 #define NFSCLIENT       1
1363 #include <nfs/mount.h>
1364
1365 #include <sys/fs/vx_ioctl.h>
1366
1367 static const struct xlat mount_flags[] = {
1368         { MS_RDONLY,    "MS_RDONLY"     },
1369         { MS_FSS,       "MS_FSS"        },
1370         { MS_DATA,      "MS_DATA"       },
1371         { MS_HADBAD,    "MS_HADBAD"     },
1372         { MS_NOSUID,    "MS_NOSUID"     },
1373         { MS_REMOUNT,   "MS_REMOUNT"    },
1374         { MS_NOTRUNC,   "MS_NOTRUNC"    },
1375         { MS_SOFTMNT,   "MS_SOFTMNT"    },
1376         { MS_SYSSPACE,  "MS_SYSSPACE"   },
1377         { 0,            NULL            },
1378 };
1379
1380 #ifdef VX_MS_MASK
1381 static const struct xlat vxfs_flags[] = {
1382         { VX_MS_NOLOG,          "VX_MS_NOLOG"           },
1383         { VX_MS_BLKCLEAR,       "VX_MS_BLKCLEAR"        },
1384         { VX_MS_SNAPSHOT,       "VX_MS_SNAPSHOT"        },
1385         { VX_MS_NODATAINLOG,    "VX_MS_NODATAINLOG"     },
1386         { VX_MS_DELAYLOG,       "VX_MS_DELAYLOG"        },
1387         { VX_MS_TMPLOG,         "VX_MS_TMPLOG"          },
1388         { VX_MS_FILESET,        "VX_MS_FILESET"         },
1389
1390         { VX_MS_CACHE_DIRECT,   "VX_MS_CACHE_DIRECT"    },
1391         { VX_MS_CACHE_DSYNC,    "VX_MS_CACHE_DSYNC"     },
1392         { VX_MS_CACHE_CLOSESYNC,"VX_MS_CACHE_CLOSESYNC" },
1393         { VX_MS_CACHE_TMPCACHE, "VX_MS_CACHE_TMPCACHE"  },
1394
1395         { VX_MS_OSYNC_DIRECT,   "VX_MS_OSYNC_DIRECT"    },
1396         { VX_MS_OSYNC_DSYNC,    "VX_MS_OSYNC_DSYNC"     },
1397         { VX_MS_OSYNC_CLOSESYNC,"VX_MS_OSYNC_CLOSESYNC" },
1398         { VX_MS_OSYNC_DELAY,    "VX_MS_OSYNC_DELAY"     },
1399         { 0,                    NULL,                   },
1400 };
1401 #endif
1402
1403 static const struct xlat nfs_flags[] = {
1404         { NFSMNT_SOFT,          "NFSMNT_SOFT"           },
1405         { NFSMNT_WSIZE,         "NFSMNT_WSIZE"          },
1406         { NFSMNT_RSIZE,         "NFSMNT_RSIZE"          },
1407         { NFSMNT_TIMEO,         "NFSMNT_TIMEO"          },
1408         { NFSMNT_RETRANS,       "NFSMNT_RETRANS"        },
1409         { NFSMNT_HOSTNAME,      "NFSMNT_HOSTNAME"       },
1410         { NFSMNT_INT,           "NFSMNT_INT"            },
1411         { NFSMNT_NOAC,          "NFSMNT_NOAC"           },
1412         { NFSMNT_ACREGMIN,      "NFSMNT_ACREGMIN"       },
1413         { NFSMNT_ACREGMAX,      "NFSMNT_ACREGMAX"       },
1414         { NFSMNT_ACDIRMIN,      "NFSMNT_ACDIRMIN"       },
1415         { NFSMNT_ACDIRMAX,      "NFSMNT_ACDIRMAX"       },
1416         { NFSMNT_SECURE,        "NFSMNT_SECURE"         },
1417         { NFSMNT_NOCTO,         "NFSMNT_NOCTO"          },
1418         { NFSMNT_GRPID,         "NFSMNT_GRPID"          },
1419         { NFSMNT_RPCTIMESYNC,   "NFSMNT_RPCTIMESYNC"    },
1420         { NFSMNT_LWPSMAX,       "NFSMNT_LWPSMAX"        },
1421         { 0,                    NULL                    },
1422 };
1423
1424 int
1425 sys_mount(struct tcb *tcp)
1426 {
1427         if (entering(tcp)) {
1428                 char fstyp[FSTYPSZ];
1429                 printpath(tcp, tcp->u_arg[0]);
1430                 tprints(", ");
1431                 printpath(tcp, tcp->u_arg[1]);
1432                 tprints(", ");
1433                 printflags(mount_flags, tcp->u_arg[2], "MS_???");
1434                 /* The doc sez that the file system type is given as a
1435                    fsindex, and we should use sysfs to work out the name.
1436                    This appears to be untrue for UW.  Maybe it's untrue
1437                    for all SVR4's? */
1438                 if (tcp->u_arg[2] & (MS_FSS | MS_DATA)) {
1439                         if (umovestr(tcp, tcp->u_arg[3], FSTYPSZ, fstyp) < 0) {
1440                                 *fstyp = 0;
1441                                 tprintf(", %ld", tcp->u_arg[3]);
1442                         }
1443                         else
1444                                 tprintf(", \"%s\"", fstyp);
1445                 }
1446                 if (tcp->u_arg[2] & MS_DATA) {
1447                         tprints(", ");
1448 #ifdef VX_MS_MASK
1449                         /* On UW7 they don't give us the defines and structs
1450                            we need to see what is going on.  Bummer. */
1451                         if (strcmp(fstyp, "vxfs") == 0) {
1452                                 struct vx_mountargs5 args;
1453                                 if (umove(tcp, tcp->u_arg[4], &args) < 0)
1454                                         tprintf("%#lx", tcp->u_arg[4]);
1455                                 else {
1456                                         tprints("{ flags=");
1457                                         printflags(vxfs_flags, args.mflags, "VX_MS_???");
1458                                         if (args.mflags & VX_MS_SNAPSHOT) {
1459                                                 tprints(", snapof=");
1460                                                 printstr(tcp,
1461                                                           (long) args.primaryspec,
1462                                                           -1);
1463                                                 if (args.snapsize > 0)
1464                                                         tprintf(", snapsize=%ld", args.snapsize);
1465                                         }
1466                                         tprints(" }");
1467                                 }
1468                         }
1469                         else
1470 #endif
1471                         if (strcmp(fstyp, "specfs") == 0) {
1472                                 tprints("dev=");
1473                                 printstr(tcp, tcp->u_arg[4], -1);
1474                         }
1475                         else
1476                         if (strcmp(fstyp, "nfs") == 0) {
1477                                 struct nfs_args args;
1478                                 if (umove(tcp, tcp->u_arg[4], &args) < 0)
1479                                         tprintf("%#lx", tcp->u_arg[4]);
1480                                 else {
1481                                         struct netbuf addr;
1482                                         tprints("{ addr=");
1483                                         if (umove(tcp, (int) args.addr, &addr) < 0) {
1484                                                 tprintf("%#lx", (long) args.addr);
1485                                         }
1486                                         else {
1487                                                 printsock(tcp, (int) addr.buf, addr.len);
1488                                         }
1489                                         tprints(", flags=");
1490                                         printflags(nfs_flags, args.flags, "NFSMNT_???");
1491                                         tprints(", hostname=");
1492                                         printstr(tcp, (int) args.hostname, -1);
1493                                         tprints(", ...}");
1494                                 }
1495                         }
1496                         else
1497                                 tprintf("%#lx", tcp->u_arg[4]);
1498                         tprintf(", %ld", tcp->u_arg[5]);
1499                 }
1500         }
1501         return 0;
1502 }
1503
1504 #else /* !UNIXWARE */
1505
1506 int
1507 sys_mount(struct tcb *tcp)
1508 {
1509         if (entering(tcp)) {
1510                 printpath(tcp, tcp->u_arg[0]);
1511                 tprints(", ");
1512                 printpath(tcp, tcp->u_arg[1]);
1513                 tprints(", ...");
1514         }
1515         return 0;
1516 }
1517 #endif /* !UNIXWARE */
1518
1519 #endif /* !MIPS */
1520
1521 #endif /* SVR4 */
1522
1523 #ifdef SYS_capget
1524
1525 static const struct xlat capabilities[] = {
1526         { 1<<CAP_CHOWN,         "CAP_CHOWN"     },
1527         { 1<<CAP_DAC_OVERRIDE,  "CAP_DAC_OVERRIDE"},
1528         { 1<<CAP_DAC_READ_SEARCH,"CAP_DAC_READ_SEARCH"},
1529         { 1<<CAP_FOWNER,        "CAP_FOWNER"    },
1530         { 1<<CAP_FSETID,        "CAP_FSETID"    },
1531         { 1<<CAP_KILL,          "CAP_KILL"      },
1532         { 1<<CAP_SETGID,        "CAP_SETGID"    },
1533         { 1<<CAP_SETUID,        "CAP_SETUID"    },
1534         { 1<<CAP_SETPCAP,       "CAP_SETPCAP"   },
1535         { 1<<CAP_LINUX_IMMUTABLE,"CAP_LINUX_IMMUTABLE"},
1536         { 1<<CAP_NET_BIND_SERVICE,"CAP_NET_BIND_SERVICE"},
1537         { 1<<CAP_NET_BROADCAST, "CAP_NET_BROADCAST"},
1538         { 1<<CAP_NET_ADMIN,     "CAP_NET_ADMIN" },
1539         { 1<<CAP_NET_RAW,       "CAP_NET_RAW"   },
1540         { 1<<CAP_IPC_LOCK,      "CAP_IPC_LOCK"  },
1541         { 1<<CAP_IPC_OWNER,     "CAP_IPC_OWNER" },
1542         { 1<<CAP_SYS_MODULE,    "CAP_SYS_MODULE"},
1543         { 1<<CAP_SYS_RAWIO,     "CAP_SYS_RAWIO" },
1544         { 1<<CAP_SYS_CHROOT,    "CAP_SYS_CHROOT"},
1545         { 1<<CAP_SYS_PTRACE,    "CAP_SYS_PTRACE"},
1546         { 1<<CAP_SYS_PACCT,     "CAP_SYS_PACCT" },
1547         { 1<<CAP_SYS_ADMIN,     "CAP_SYS_ADMIN" },
1548         { 1<<CAP_SYS_BOOT,      "CAP_SYS_BOOT"  },
1549         { 1<<CAP_SYS_NICE,      "CAP_SYS_NICE"  },
1550         { 1<<CAP_SYS_RESOURCE,  "CAP_SYS_RESOURCE"},
1551         { 1<<CAP_SYS_TIME,      "CAP_SYS_TIME"  },
1552         { 1<<CAP_SYS_TTY_CONFIG,"CAP_SYS_TTY_CONFIG"},
1553 #ifdef CAP_MKNOD
1554         { 1<<CAP_MKNOD,         "CAP_MKNOD"     },
1555 #endif
1556 #ifdef CAP_LEASE
1557         { 1<<CAP_LEASE,         "CAP_LEASE"     },
1558 #endif
1559 #ifdef CAP_AUDIT_WRITE
1560         { 1<<CAP_AUDIT_WRITE,   "CAP_AUDIT_WRITE"},
1561 #endif
1562 #ifdef CAP_AUDIT_CONTROL
1563         { 1<<CAP_AUDIT_CONTROL, "CAP_AUDIT_CONTROL"},
1564 #endif
1565 #ifdef CAP_SETFCAP
1566         { 1<<CAP_SETFCAP,       "CAP_SETFCAP"   },
1567 #endif
1568         { 0,            NULL            },
1569 };
1570
1571
1572 int
1573 sys_capget(struct tcb *tcp)
1574 {
1575         /* cap_user_ types are _pointers_ to (small) structs. */
1576         /* Structs themselves have no names defined. */
1577         /* Have to use ugly hack to place them on stack. */
1578         cap_user_header_t arg0;
1579         cap_user_data_t   arg1;
1580         long a0[sizeof(*arg0) / sizeof(long) + 1];
1581         long a1[sizeof(*arg1) / sizeof(long) + 1];
1582         arg0 = (cap_user_header_t) a0;
1583         arg1 = (cap_user_data_t  ) a1;
1584
1585         if (!entering(tcp)) {
1586                 if (!tcp->u_arg[0])
1587                         tprints("NULL");
1588                 else if (!verbose(tcp))
1589                         tprintf("%#lx", tcp->u_arg[0]);
1590                 else if (umoven(tcp, tcp->u_arg[0], sizeof(*arg0), (char *) arg0) < 0)
1591                         tprints("???");
1592                 else {
1593                         tprintf("%#x, %d", arg0->version, arg0->pid);
1594                 }
1595                 tprints(", ");
1596                 if (!tcp->u_arg[1])
1597                         tprints("NULL");
1598                 else if (!verbose(tcp))
1599                         tprintf("%#lx", tcp->u_arg[1]);
1600                 else if (umoven(tcp, tcp->u_arg[1], sizeof(*arg1), (char *) arg1) < 0)
1601                         tprints("???");
1602                 else {
1603                         tprints("{");
1604                         printflags(capabilities, arg1->effective, "CAP_???");
1605                         tprints(", ");
1606                         printflags(capabilities, arg1->permitted, "CAP_???");
1607                         tprints(", ");
1608                         printflags(capabilities, arg1->inheritable, "CAP_???");
1609                         tprints("}");
1610                 }
1611         }
1612         return 0;
1613 }
1614
1615 int
1616 sys_capset(struct tcb *tcp)
1617 {
1618         cap_user_header_t arg0;
1619         cap_user_data_t   arg1;
1620         long a0[sizeof(*arg0) / sizeof(long) + 1];
1621         long a1[sizeof(*arg1) / sizeof(long) + 1];
1622         arg0 = (cap_user_header_t) a0;
1623         arg1 = (cap_user_data_t  ) a1;
1624
1625         if (entering(tcp)) {
1626                 if (!tcp->u_arg[0])
1627                         tprints("NULL");
1628                 else if (!verbose(tcp))
1629                         tprintf("%#lx", tcp->u_arg[0]);
1630                 else if (umoven(tcp, tcp->u_arg[0], sizeof(*arg0), (char *) arg0) < 0)
1631                         tprints("???");
1632                 else {
1633                         tprintf("%#x, %d", arg0->version, arg0->pid);
1634                 }
1635                 tprints(", ");
1636                 if (!tcp->u_arg[1])
1637                         tprints("NULL");
1638                 else if (!verbose(tcp))
1639                         tprintf("%#lx", tcp->u_arg[1]);
1640                 else if (umoven(tcp, tcp->u_arg[1], sizeof(*arg1), (char *) arg1) < 0)
1641                         tprints("???");
1642                 else {
1643                         tprints("{");
1644                         printflags(capabilities, arg1->effective, "CAP_???");
1645                         tprints(", ");
1646                         printflags(capabilities, arg1->permitted, "CAP_???");
1647                         tprints(", ");
1648                         printflags(capabilities, arg1->inheritable, "CAP_???");
1649                         tprints("}");
1650                 }
1651         }
1652         return 0;
1653 }
1654
1655 #else
1656
1657 int sys_capget(struct tcb *tcp)
1658 {
1659         return printargs(tcp);
1660 }
1661
1662 int sys_capset(struct tcb *tcp)
1663 {
1664         return printargs(tcp);
1665 }
1666
1667 #endif
1668
1669 #ifdef LINUX
1670 /* Linux 2.6.18+ headers removed CTL_PROC enum.  */
1671 # define CTL_PROC 4
1672 # define CTL_CPU 10             /* older headers lack */
1673 static const struct xlat sysctl_root[] = {
1674         { CTL_KERN, "CTL_KERN" },
1675         { CTL_VM, "CTL_VM" },
1676         { CTL_NET, "CTL_NET" },
1677         { CTL_PROC, "CTL_PROC" },
1678         { CTL_FS, "CTL_FS" },
1679         { CTL_DEBUG, "CTL_DEBUG" },
1680         { CTL_DEV, "CTL_DEV" },
1681         { CTL_BUS, "CTL_BUS" },
1682         { CTL_ABI, "CTL_ABI" },
1683         { CTL_CPU, "CTL_CPU" },
1684         { 0, NULL }
1685 };
1686
1687 static const struct xlat sysctl_kern[] = {
1688         { KERN_OSTYPE, "KERN_OSTYPE" },
1689         { KERN_OSRELEASE, "KERN_OSRELEASE" },
1690         { KERN_OSREV, "KERN_OSREV" },
1691         { KERN_VERSION, "KERN_VERSION" },
1692         { KERN_SECUREMASK, "KERN_SECUREMASK" },
1693         { KERN_PROF, "KERN_PROF" },
1694         { KERN_NODENAME, "KERN_NODENAME" },
1695         { KERN_DOMAINNAME, "KERN_DOMAINNAME" },
1696 #ifdef KERN_SECURELVL
1697         { KERN_SECURELVL, "KERN_SECURELVL" },
1698 #endif
1699         { KERN_PANIC, "KERN_PANIC" },
1700 #ifdef KERN_REALROOTDEV
1701         { KERN_REALROOTDEV, "KERN_REALROOTDEV" },
1702 #endif
1703 #ifdef KERN_JAVA_INTERPRETER
1704         { KERN_JAVA_INTERPRETER, "KERN_JAVA_INTERPRETER" },
1705 #endif
1706 #ifdef KERN_JAVA_APPLETVIEWER
1707         { KERN_JAVA_APPLETVIEWER, "KERN_JAVA_APPLETVIEWER" },
1708 #endif
1709         { KERN_SPARC_REBOOT, "KERN_SPARC_REBOOT" },
1710         { KERN_CTLALTDEL, "KERN_CTLALTDEL" },
1711         { KERN_PRINTK, "KERN_PRINTK" },
1712         { KERN_NAMETRANS, "KERN_NAMETRANS" },
1713         { KERN_PPC_HTABRECLAIM, "KERN_PPC_HTABRECLAIM" },
1714         { KERN_PPC_ZEROPAGED, "KERN_PPC_ZEROPAGED" },
1715         { KERN_PPC_POWERSAVE_NAP, "KERN_PPC_POWERSAVE_NAP" },
1716         { KERN_MODPROBE, "KERN_MODPROBE" },
1717         { KERN_SG_BIG_BUFF, "KERN_SG_BIG_BUFF" },
1718         { KERN_ACCT, "KERN_ACCT" },
1719         { KERN_PPC_L2CR, "KERN_PPC_L2CR" },
1720         { KERN_RTSIGNR, "KERN_RTSIGNR" },
1721         { KERN_RTSIGMAX, "KERN_RTSIGMAX" },
1722         { KERN_SHMMAX, "KERN_SHMMAX" },
1723         { KERN_MSGMAX, "KERN_MSGMAX" },
1724         { KERN_MSGMNB, "KERN_MSGMNB" },
1725         { KERN_MSGPOOL, "KERN_MSGPOOL" },
1726         { 0, NULL }
1727 };
1728
1729 static const struct xlat sysctl_vm[] = {
1730 #ifdef VM_SWAPCTL
1731         { VM_SWAPCTL, "VM_SWAPCTL" },
1732 #endif
1733 #ifdef VM_UNUSED1
1734         { VM_UNUSED1, "VM_UNUSED1" },
1735 #endif
1736 #ifdef VM_SWAPOUT
1737         { VM_SWAPOUT, "VM_SWAPOUT" },
1738 #endif
1739 #ifdef VM_UNUSED2
1740         { VM_UNUSED2, "VM_UNUSED2" },
1741 #endif
1742 #ifdef VM_FREEPG
1743         { VM_FREEPG, "VM_FREEPG" },
1744 #endif
1745 #ifdef VM_UNUSED3
1746         { VM_UNUSED3, "VM_UNUSED3" },
1747 #endif
1748 #ifdef VM_BDFLUSH
1749         { VM_BDFLUSH, "VM_BDFLUSH" },
1750 #endif
1751 #ifdef VM_UNUSED4
1752         { VM_UNUSED4, "VM_UNUSED4" },
1753 #endif
1754         { VM_OVERCOMMIT_MEMORY, "VM_OVERCOMMIT_MEMORY" },
1755 #ifdef VM_BUFFERMEM
1756         { VM_BUFFERMEM, "VM_BUFFERMEM" },
1757 #endif
1758 #ifdef VM_UNUSED5
1759         { VM_UNUSED5, "VM_UNUSED5" },
1760 #endif
1761 #ifdef VM_PAGECACHE
1762         { VM_PAGECACHE, "VM_PAGECACHE" },
1763 #endif
1764 #ifdef VM_UNUSED7
1765         { VM_UNUSED7, "VM_UNUSED7" },
1766 #endif
1767 #ifdef VM_PAGERDAEMON
1768         { VM_PAGERDAEMON, "VM_PAGERDAEMON" },
1769 #endif
1770 #ifdef VM_UNUSED8
1771         { VM_UNUSED8, "VM_UNUSED8" },
1772 #endif
1773 #ifdef VM_PGT_CACHE
1774         { VM_PGT_CACHE, "VM_PGT_CACHE" },
1775 #endif
1776 #ifdef VM_UNUSED9
1777         { VM_UNUSED9, "VM_UNUSED9" },
1778 #endif
1779         { VM_PAGE_CLUSTER, "VM_PAGE_CLUSTER" },
1780         { 0, NULL },
1781 };
1782
1783 static const struct xlat sysctl_net[] = {
1784         { NET_CORE, "NET_CORE" },
1785         { NET_ETHER, "NET_ETHER" },
1786         { NET_802, "NET_802" },
1787         { NET_UNIX, "NET_UNIX" },
1788         { NET_IPV4, "NET_IPV4" },
1789         { NET_IPX, "NET_IPX" },
1790         { NET_ATALK, "NET_ATALK" },
1791         { NET_NETROM, "NET_NETROM" },
1792         { NET_AX25, "NET_AX25" },
1793         { NET_BRIDGE, "NET_BRIDGE" },
1794         { NET_ROSE, "NET_ROSE" },
1795         { NET_IPV6, "NET_IPV6" },
1796         { NET_X25, "NET_X25" },
1797         { NET_TR, "NET_TR" },
1798         { NET_DECNET, "NET_DECNET" },
1799         { 0, NULL }
1800 };
1801
1802 static const struct xlat sysctl_net_core[] = {
1803         { NET_CORE_WMEM_MAX, "NET_CORE_WMEM_MAX" },
1804         { NET_CORE_RMEM_MAX, "NET_CORE_RMEM_MAX" },
1805         { NET_CORE_WMEM_DEFAULT, "NET_CORE_WMEM_DEFAULT" },
1806         { NET_CORE_RMEM_DEFAULT, "NET_CORE_RMEM_DEFAULT" },
1807         { NET_CORE_MAX_BACKLOG, "NET_CORE_MAX_BACKLOG" },
1808         { NET_CORE_FASTROUTE, "NET_CORE_FASTROUTE" },
1809         { NET_CORE_MSG_COST, "NET_CORE_MSG_COST" },
1810         { NET_CORE_MSG_BURST, "NET_CORE_MSG_BURST" },
1811         { NET_CORE_OPTMEM_MAX, "NET_CORE_OPTMEM_MAX" },
1812         { 0, NULL }
1813 };
1814
1815 static const struct xlat sysctl_net_unix[] = {
1816         { NET_UNIX_DESTROY_DELAY, "NET_UNIX_DESTROY_DELAY" },
1817         { NET_UNIX_DELETE_DELAY, "NET_UNIX_DELETE_DELAY" },
1818         { 0, NULL }
1819 };
1820
1821 static const struct xlat sysctl_net_ipv4[] = {
1822         { NET_IPV4_FORWARD, "NET_IPV4_FORWARD" },
1823         { NET_IPV4_DYNADDR, "NET_IPV4_DYNADDR" },
1824         { NET_IPV4_CONF, "NET_IPV4_CONF" },
1825         { NET_IPV4_NEIGH, "NET_IPV4_NEIGH" },
1826         { NET_IPV4_ROUTE, "NET_IPV4_ROUTE" },
1827         { NET_IPV4_FIB_HASH, "NET_IPV4_FIB_HASH" },
1828         { NET_IPV4_TCP_TIMESTAMPS, "NET_IPV4_TCP_TIMESTAMPS" },
1829         { NET_IPV4_TCP_WINDOW_SCALING, "NET_IPV4_TCP_WINDOW_SCALING" },
1830         { NET_IPV4_TCP_SACK, "NET_IPV4_TCP_SACK" },
1831         { NET_IPV4_TCP_RETRANS_COLLAPSE, "NET_IPV4_TCP_RETRANS_COLLAPSE" },
1832         { NET_IPV4_DEFAULT_TTL, "NET_IPV4_DEFAULT_TTL" },
1833         { NET_IPV4_AUTOCONFIG, "NET_IPV4_AUTOCONFIG" },
1834         { NET_IPV4_NO_PMTU_DISC, "NET_IPV4_NO_PMTU_DISC" },
1835         { NET_IPV4_TCP_SYN_RETRIES, "NET_IPV4_TCP_SYN_RETRIES" },
1836         { NET_IPV4_IPFRAG_HIGH_THRESH, "NET_IPV4_IPFRAG_HIGH_THRESH" },
1837         { NET_IPV4_IPFRAG_LOW_THRESH, "NET_IPV4_IPFRAG_LOW_THRESH" },
1838         { NET_IPV4_IPFRAG_TIME, "NET_IPV4_IPFRAG_TIME" },
1839         { NET_IPV4_TCP_MAX_KA_PROBES, "NET_IPV4_TCP_MAX_KA_PROBES" },
1840         { NET_IPV4_TCP_KEEPALIVE_TIME, "NET_IPV4_TCP_KEEPALIVE_TIME" },
1841         { NET_IPV4_TCP_KEEPALIVE_PROBES, "NET_IPV4_TCP_KEEPALIVE_PROBES" },
1842         { NET_IPV4_TCP_RETRIES1, "NET_IPV4_TCP_RETRIES1" },
1843         { NET_IPV4_TCP_RETRIES2, "NET_IPV4_TCP_RETRIES2" },
1844         { NET_IPV4_TCP_FIN_TIMEOUT, "NET_IPV4_TCP_FIN_TIMEOUT" },
1845         { NET_IPV4_IP_MASQ_DEBUG, "NET_IPV4_IP_MASQ_DEBUG" },
1846         { NET_TCP_SYNCOOKIES, "NET_TCP_SYNCOOKIES" },
1847         { NET_TCP_STDURG, "NET_TCP_STDURG" },
1848         { NET_TCP_RFC1337, "NET_TCP_RFC1337" },
1849         { NET_TCP_SYN_TAILDROP, "NET_TCP_SYN_TAILDROP" },
1850         { NET_TCP_MAX_SYN_BACKLOG, "NET_TCP_MAX_SYN_BACKLOG" },
1851         { NET_IPV4_LOCAL_PORT_RANGE, "NET_IPV4_LOCAL_PORT_RANGE" },
1852         { NET_IPV4_ICMP_ECHO_IGNORE_ALL, "NET_IPV4_ICMP_ECHO_IGNORE_ALL" },
1853         { NET_IPV4_ICMP_ECHO_IGNORE_BROADCASTS, "NET_IPV4_ICMP_ECHO_IGNORE_BROADCASTS" },
1854         { NET_IPV4_ICMP_SOURCEQUENCH_RATE, "NET_IPV4_ICMP_SOURCEQUENCH_RATE" },
1855         { NET_IPV4_ICMP_DESTUNREACH_RATE, "NET_IPV4_ICMP_DESTUNREACH_RATE" },
1856         { NET_IPV4_ICMP_TIMEEXCEED_RATE, "NET_IPV4_ICMP_TIMEEXCEED_RATE" },
1857         { NET_IPV4_ICMP_PARAMPROB_RATE, "NET_IPV4_ICMP_PARAMPROB_RATE" },
1858         { NET_IPV4_ICMP_ECHOREPLY_RATE, "NET_IPV4_ICMP_ECHOREPLY_RATE" },
1859         { NET_IPV4_ICMP_IGNORE_BOGUS_ERROR_RESPONSES, "NET_IPV4_ICMP_IGNORE_BOGUS_ERROR_RESPONSES" },
1860         { NET_IPV4_IGMP_MAX_MEMBERSHIPS, "NET_IPV4_IGMP_MAX_MEMBERSHIPS" },
1861         {  0, NULL }
1862 };
1863
1864 static const struct xlat sysctl_net_ipv4_route[] = {
1865         { NET_IPV4_ROUTE_FLUSH, "NET_IPV4_ROUTE_FLUSH" },
1866         { NET_IPV4_ROUTE_MIN_DELAY, "NET_IPV4_ROUTE_MIN_DELAY" },
1867         { NET_IPV4_ROUTE_MAX_DELAY, "NET_IPV4_ROUTE_MAX_DELAY" },
1868         { NET_IPV4_ROUTE_GC_THRESH, "NET_IPV4_ROUTE_GC_THRESH" },
1869         { NET_IPV4_ROUTE_MAX_SIZE, "NET_IPV4_ROUTE_MAX_SIZE" },
1870         { NET_IPV4_ROUTE_GC_MIN_INTERVAL, "NET_IPV4_ROUTE_GC_MIN_INTERVAL" },
1871         { NET_IPV4_ROUTE_GC_TIMEOUT, "NET_IPV4_ROUTE_GC_TIMEOUT" },
1872         { NET_IPV4_ROUTE_GC_INTERVAL, "NET_IPV4_ROUTE_GC_INTERVAL" },
1873         { NET_IPV4_ROUTE_REDIRECT_LOAD, "NET_IPV4_ROUTE_REDIRECT_LOAD" },
1874         { NET_IPV4_ROUTE_REDIRECT_NUMBER, "NET_IPV4_ROUTE_REDIRECT_NUMBER" },
1875         { NET_IPV4_ROUTE_REDIRECT_SILENCE, "NET_IPV4_ROUTE_REDIRECT_SILENCE" },
1876         { NET_IPV4_ROUTE_ERROR_COST, "NET_IPV4_ROUTE_ERROR_COST" },
1877         { NET_IPV4_ROUTE_ERROR_BURST, "NET_IPV4_ROUTE_ERROR_BURST" },
1878         { NET_IPV4_ROUTE_GC_ELASTICITY, "NET_IPV4_ROUTE_GC_ELASTICITY" },
1879         { 0, NULL }
1880 };
1881
1882 static const struct xlat sysctl_net_ipv4_conf[] = {
1883         { NET_IPV4_CONF_FORWARDING, "NET_IPV4_CONF_FORWARDING" },
1884         { NET_IPV4_CONF_MC_FORWARDING, "NET_IPV4_CONF_MC_FORWARDING" },
1885         { NET_IPV4_CONF_PROXY_ARP, "NET_IPV4_CONF_PROXY_ARP" },
1886         { NET_IPV4_CONF_ACCEPT_REDIRECTS, "NET_IPV4_CONF_ACCEPT_REDIRECTS" },
1887         { NET_IPV4_CONF_SECURE_REDIRECTS, "NET_IPV4_CONF_SECURE_REDIRECTS" },
1888         { NET_IPV4_CONF_SEND_REDIRECTS, "NET_IPV4_CONF_SEND_REDIRECTS" },
1889         { NET_IPV4_CONF_SHARED_MEDIA, "NET_IPV4_CONF_SHARED_MEDIA" },
1890         { NET_IPV4_CONF_RP_FILTER, "NET_IPV4_CONF_RP_FILTER" },
1891         { NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE, "NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE" },
1892         { NET_IPV4_CONF_BOOTP_RELAY, "NET_IPV4_CONF_BOOTP_RELAY" },
1893         { NET_IPV4_CONF_LOG_MARTIANS, "NET_IPV4_CONF_LOG_MARTIANS" },
1894         { 0, NULL }
1895 };
1896
1897 static const struct xlat sysctl_net_ipv6[] = {
1898         { NET_IPV6_CONF, "NET_IPV6_CONF" },
1899         { NET_IPV6_NEIGH, "NET_IPV6_NEIGH" },
1900         { NET_IPV6_ROUTE, "NET_IPV6_ROUTE" },
1901         { 0, NULL }
1902 };
1903
1904 static const struct xlat sysctl_net_ipv6_route[] = {
1905         { NET_IPV6_ROUTE_FLUSH, "NET_IPV6_ROUTE_FLUSH" },
1906         { NET_IPV6_ROUTE_GC_THRESH, "NET_IPV6_ROUTE_GC_THRESH" },
1907         { NET_IPV6_ROUTE_MAX_SIZE, "NET_IPV6_ROUTE_MAX_SIZE" },
1908         { NET_IPV6_ROUTE_GC_MIN_INTERVAL, "NET_IPV6_ROUTE_GC_MIN_INTERVAL" },
1909         { NET_IPV6_ROUTE_GC_TIMEOUT, "NET_IPV6_ROUTE_GC_TIMEOUT" },
1910         { NET_IPV6_ROUTE_GC_INTERVAL, "NET_IPV6_ROUTE_GC_INTERVAL" },
1911         { NET_IPV6_ROUTE_GC_ELASTICITY, "NET_IPV6_ROUTE_GC_ELASTICITY" },
1912         { 0, NULL }
1913 };
1914
1915 int
1916 sys_sysctl(struct tcb *tcp)
1917 {
1918         struct __sysctl_args info;
1919         int *name;
1920         unsigned long size;
1921
1922         if (umove(tcp, tcp->u_arg[0], &info) < 0)
1923                 return printargs(tcp);
1924
1925         size = sizeof(int) * (unsigned long) info.nlen;
1926         name = (size / sizeof(int) != info.nlen) ? NULL : malloc(size);
1927         if (name == NULL ||
1928             umoven(tcp, (unsigned long) info.name, size, (char *) name) < 0) {
1929                 free(name);
1930                 if (entering(tcp))
1931                         tprintf("{%p, %d, %p, %p, %p, %Zu}",
1932                                 info.name, info.nlen, info.oldval,
1933                                 info.oldlenp, info.newval, info.newlen);
1934                 return 0;
1935         }
1936
1937         if (entering(tcp)) {
1938                 int cnt = 0, max_cnt;
1939
1940                 tprints("{{");
1941
1942                 if (info.nlen == 0)
1943                         goto out;
1944                 printxval(sysctl_root, name[0], "CTL_???");
1945                 ++cnt;
1946
1947                 if (info.nlen == 1)
1948                         goto out;
1949                 switch (name[0]) {
1950                 case CTL_KERN:
1951                         tprints(", ");
1952                         printxval(sysctl_kern, name[1], "KERN_???");
1953                         ++cnt;
1954                         break;
1955                 case CTL_VM:
1956                         tprints(", ");
1957                         printxval(sysctl_vm, name[1], "VM_???");
1958                         ++cnt;
1959                         break;
1960                 case CTL_NET:
1961                         tprints(", ");
1962                         printxval(sysctl_net, name[1], "NET_???");
1963                         ++cnt;
1964
1965                         if (info.nlen == 2)
1966                                 goto out;
1967                         switch (name[1]) {
1968                         case NET_CORE:
1969                                 tprints(", ");
1970                                 printxval(sysctl_net_core, name[2],
1971                                           "NET_CORE_???");
1972                                 break;
1973                         case NET_UNIX:
1974                                 tprints(", ");
1975                                 printxval(sysctl_net_unix, name[2],
1976                                           "NET_UNIX_???");
1977                                 break;
1978                         case NET_IPV4:
1979                                 tprints(", ");
1980                                 printxval(sysctl_net_ipv4, name[2],
1981                                           "NET_IPV4_???");
1982
1983                                 if (info.nlen == 3)
1984                                         goto out;
1985                                 switch (name[2]) {
1986                                 case NET_IPV4_ROUTE:
1987                                         tprints(", ");
1988                                         printxval(sysctl_net_ipv4_route,
1989                                                   name[3],
1990                                                   "NET_IPV4_ROUTE_???");
1991                                         break;
1992                                 case NET_IPV4_CONF:
1993                                         tprints(", ");
1994                                         printxval(sysctl_net_ipv4_conf,
1995                                                   name[3],
1996                                                   "NET_IPV4_CONF_???");
1997                                         break;
1998                                 default:
1999                                         goto out;
2000                                 }
2001                                 break;
2002                         case NET_IPV6:
2003                                 tprints(", ");
2004                                 printxval(sysctl_net_ipv6, name[2],
2005                                           "NET_IPV6_???");
2006
2007                                 if (info.nlen == 3)
2008                                         goto out;
2009                                 switch (name[2]) {
2010                                 case NET_IPV6_ROUTE:
2011                                         tprints(", ");
2012                                         printxval(sysctl_net_ipv6_route,
2013                                                   name[3],
2014                                                   "NET_IPV6_ROUTE_???");
2015                                         break;
2016                                 default:
2017                                         goto out;
2018                                 }
2019                                 break;
2020                         default:
2021                                 goto out;
2022                         }
2023                         break;
2024                 default:
2025                         goto out;
2026                 }
2027         out:
2028                 max_cnt = info.nlen;
2029                 if (abbrev(tcp) && max_cnt > max_strlen)
2030                         max_cnt = max_strlen;
2031                 while (cnt < max_cnt)
2032                         tprintf(", %x", name[cnt++]);
2033                 if (cnt < info.nlen)
2034                         tprints(", ...");
2035                 tprintf("}, %d, ", info.nlen);
2036         } else {
2037                 size_t oldlen;
2038                 if (umove(tcp, (size_t)info.oldlenp, &oldlen) >= 0
2039                     && info.nlen >= 2
2040                     && ((name[0] == CTL_KERN
2041                          && (name[1] == KERN_OSRELEASE
2042                              || name[1] == KERN_OSTYPE
2043 #ifdef KERN_JAVA_INTERPRETER
2044                              || name[1] == KERN_JAVA_INTERPRETER
2045 #endif
2046 #ifdef KERN_JAVA_APPLETVIEWER
2047                              || name[1] == KERN_JAVA_APPLETVIEWER
2048 #endif
2049                                  )))) {
2050                         printpath(tcp, (size_t)info.oldval);
2051                         tprintf(", %Zu, ", oldlen);
2052                         if (info.newval == 0)
2053                                 tprints("NULL");
2054                         else if (syserror(tcp))
2055                                 tprintf("%p", info.newval);
2056                         else
2057                                 printpath(tcp, (size_t)info.newval);
2058                         tprintf(", %Zd", info.newlen);
2059                 } else {
2060                         tprintf("%p, %Zd, %p, %Zd", info.oldval, oldlen,
2061                                 info.newval, info.newlen);
2062                 }
2063                 tprints("}");
2064         }
2065
2066         free(name);
2067         return 0;
2068 }
2069 #else
2070 int sys_sysctl(struct tcb *tcp)
2071 {
2072         return printargs(tcp);
2073 }
2074 #endif
2075
2076 #ifdef FREEBSD
2077 #include <sys/sysctl.h>
2078
2079 int sys___sysctl(struct tcb *tcp)
2080 {
2081         int qoid[CTL_MAXNAME+2];
2082         char ctl[1024];
2083         size_t len;
2084         int i, numeric;
2085
2086         if (entering(tcp)) {
2087                 if (tcp->u_arg[1] < 0 || tcp->u_arg[1] > CTL_MAXNAME ||
2088                     (umoven(tcp, tcp->u_arg[0], tcp->u_arg[1] * sizeof(int),
2089                             (char *) (qoid + 2)) < 0))
2090                         tprints("[...], ");
2091                 else {
2092                         /* Use sysctl to ask the name of the current MIB
2093                            This uses the undocumented "Staff-functions" used
2094                            by the sysctl program. See kern_sysctl.c for
2095                            details. */
2096                         qoid[0] = 0; /* sysctl */
2097                         qoid[1] = 1; /* name */
2098                         i = sizeof(ctl);
2099                         tprints("[");
2100                         if (sysctl(qoid, tcp->u_arg[1] + 2, ctl, &i, 0, 0) >= 0) {
2101                                 numeric = !abbrev(tcp);
2102                                 tprintf("%s%s", ctl, numeric ? ", " : "");
2103                         } else
2104                                 numeric = 1;
2105                         if (numeric) {
2106                                 for (i = 0; i < tcp->u_arg[1]; i++)
2107                                         tprintf("%s%d", i ? "." : "", qoid[i + 2]);
2108                         }
2109                         tprints("], ");
2110                         tprintf("%lu, ", tcp->u_arg[1]);
2111                 }
2112         } else {
2113                 if (!syserror(tcp) && (umove(tcp, tcp->u_arg[3], &len) >= 0)) {
2114                         printstr(tcp, tcp->u_arg[2], len);
2115                         tprintf(", [%u], ", len);
2116                 } else
2117                         tprintf("%#lx, %#lx, ", tcp->u_arg[2], tcp->u_arg[3]);
2118                 printstr(tcp, tcp->u_arg[4], tcp->u_arg[5]);
2119                 tprintf(", %lu", tcp->u_arg[5]);
2120         }
2121         return 0;
2122 }
2123 #endif
2124
2125 #if UNIXWARE >= 2
2126
2127 #include <sys/ksym.h>
2128 #include <sys/elf.h>
2129
2130 static const struct xlat ksym_flags[] = {
2131         { STT_NOTYPE,   "STT_NOTYPE"    },
2132         { STT_FUNC,     "STT_FUNC"      },
2133         { STT_OBJECT,   "STT_OBJECT"    },
2134         { 0,            NULL            },
2135 };
2136
2137 int
2138 sys_getksym(struct tcb *tcp)
2139 {
2140         if (entering(tcp)) {
2141                 printstr(tcp, tcp->u_arg[0], -1);
2142                 tprints(", ");
2143         }
2144         else {
2145                 if (syserror(tcp)) {
2146                         tprintf("%#lx, %#lx",
2147                                 tcp->u_arg[1], tcp->u_arg[2]);
2148                 }
2149                 else {
2150                         int val;
2151                         printnum(tcp, tcp->u_arg[1], "%#lx");
2152                         tprints(", ");
2153                         if (umove(tcp, tcp->u_arg[2], &val) < 0) {
2154                                 tprintf("%#lx", tcp->u_arg[2]);
2155                         }
2156                         else {
2157                                 tprints("[");
2158                                 printxval(ksym_flags, val, "STT_???");
2159                                 tprints("]");
2160                         }
2161                 }
2162         }
2163
2164         return 0;
2165 }
2166
2167 #ifdef HAVE_SYS_NSCSYS_H
2168
2169 struct cred;
2170 #include <sys/nscsys.h>
2171
2172 static const struct xlat ssi_cmd[] = {
2173         { SSISYS_BADOP, "SSISYS_BADOP"  },
2174         { SSISYS_LDLVL_INIT,"SSISYS_LDLVL_INIT"},
2175         { SSISYS_LDLVL_GETVEC,"SSISYS_LDLVL_GETVEC"},
2176         { SSISYS_LDLVL_PUTVEC,"SSISYS_LDLVL_PUTVEC"},
2177         { SSISYS_LDLVL_PUTRCMDS,"SSISYS_LDLVL_PUTRCMDS"},
2178         { SSISYS_LDLVL_SETREXEC,"SSISYS_LDLVL_SETREXEC"},
2179         { SSISYS_CMS_CLUSTERID,"SSISYS_CMS_CLUSTERID"},
2180         { SSISYS_CFS_STATVFS,"SSISYS_CFS_STATVFS"},
2181         { SSISYS_NODE_GETNUM,"SSISYS_NODE_GETNUM"},
2182         { SSISYS_NODE_TABLE,"SSISYS_NODE_TABLE"},
2183         { SSISYS_NODE_DOWN,"SSISYS_NODE_DOWN"},
2184         { SSISYS_RECLAIM_CHILD,"SSISYS_RECLAIM_CHILD"},
2185         { SSISYS_IPC_GETINFO,"SSISYS_IPC_GETINFO"},
2186         { SSISYS_ICS_TEST,"SSISYS_ICS_TEST"},
2187         { SSISYS_NODE_PID,"SSISYS_NODE_PID"},
2188         { SSISYS_ISLOCAL,"SSISYS_ISLOCAL"},
2189         { SSISYS_CFS_ISSTACKED,"SSISYS_CFS_ISSTACKED"},
2190         { SSISYS_DNET_SYNC,"SSISYS_DNET_SYNC"},
2191         { SSISYS_CFS_WAIT_MODE,"SSISYS_CFS_WAIT_MODE"},
2192         { SSISYS_CFS_UMOUNT,"SSISYS_CFS_UMOUNT"},
2193         { SSISYS_LLSTAT,"SSISYS_LLSTAT" },
2194         { SSISYS_LTS_PERFTEST,"SSISYS_LTS_PERFTEST"},
2195         { SSISYS_LTS_CONFIG,"SSISYS_LTS_CONFIG"},
2196         { SSISYS_SNET_PERFTEST,"SSISYS_SNET_PERFTEST"},
2197         { SSISYS_IGNORE_HALFUP,"SSISYS_IGNORE_HALFUP"},
2198         { SSISYS_NODE_ROOTDEV,"SSISYS_NODE_ROOTDEV"},
2199         { SSISYS_GET_PRIMARY,"SSISYS_GET_PRIMARY"},
2200         { SSISYS_GET_SECONDARY,"SSISYS_GET_SECONDARY"},
2201         { SSISYS_GET_ROOTDISK,"SSISYS_GET_ROOTDISK"},
2202         { SSISYS_CLUSTERNODE_NUM,"SSISYS_CLUSTERNODE_NUM"},
2203         { SSISYS_CLUSTER_MEMBERSHIP,"SSISYS_CLUSTER_MEMBERSHIP"},
2204         { SSISYS_CLUSTER_DETAILEDTRANS,"SSISYS_CLUSTER_DETAILEDTRANS"},
2205         { SSISYS_CLUSTERNODE_INFO,"SSISYS_CLUSTERNODE_INFO"},
2206         { SSISYS_CLUSTERNODE_SETINFO,"SSISYS_CLUSTERNODE_SETINFO"},
2207         { SSISYS_CLUSTERNODE_AVAIL,"SSISYS_CLUSTERNODE_AVAIL"},
2208         { SSISYS_CLUSTER_MAXNODES,"SSISYS_CLUSTER_MAXNODES"},
2209         { SSISYS_SET_MEMPRIO,"SSISYS_SET_MEMPRIO"},
2210         { SSISYS_GET_USERS,"SSISYS_GET_USERS"},
2211         { SSISYS_FORCE_ROOT_NODE,"SSISYS_FORCE_ROOT_NODE"},
2212         { SSISYS_CVIP_SET,"SSISYS_CVIP_SET"},
2213         { SSISYS_CVIP_GET,"SSISYS_CVIP_GET"},
2214         { SSISYS_GET_NODE_COUNTS,"SSISYS_GET_NODE_COUNTS"},
2215         { SSISYS_GET_TRANSPORT,"SSISYS_GET_TRANSPORT"},
2216         { 0,            NULL            },
2217 };
2218
2219 int sys_ssisys(struct tcb *tcp)
2220 {
2221         struct ssisys_iovec iov;
2222         cls_nodeinfo_args_t cni;
2223         clusternode_info_t info;
2224
2225         if (entering(tcp)) {
2226                 ts_reclaim_child_inargs_t trc;
2227                 if (tcp->u_arg[1] != sizeof iov ||
2228                     umove(tcp, tcp->u_arg[0], &iov) < 0)
2229                 {
2230                         tprintf("%#lx, %ld", tcp->u_arg[0], tcp->u_arg[1]);
2231                         return 0;
2232                 }
2233                 tprints("{id=");
2234                 printxval(ssi_cmd, iov.tio_id.id_cmd, "SSISYS_???");
2235                 tprintf(":%d", iov.tio_id.id_ver);
2236                 switch (iov.tio_id.id_cmd) {
2237                     case SSISYS_RECLAIM_CHILD:
2238                         if (iov.tio_udatainlen != sizeof trc ||
2239                             umove(tcp, (long) iov.tio_udatain, &trc) < 0)
2240                                 goto bad;
2241                         tprintf(", in={pid=%ld, start=%ld}",
2242                                  trc.trc_pid, trc.trc_start);
2243                         break;
2244                     case SSISYS_CLUSTERNODE_INFO:
2245                         if (iov.tio_udatainlen != sizeof cni ||
2246                             umove(tcp, (long) iov.tio_udatain, &cni) < 0)
2247                                 goto bad;
2248                         tprintf(", in={node=%ld, len=%d}",
2249                                  cni.nodenum, cni.info_len);
2250                         break;
2251                     default:
2252                     bad:
2253                         if (iov.tio_udatainlen) {
2254                                 tprintf(", in=[/* %d bytes */]",
2255                                          iov.tio_udatainlen);
2256                         }
2257                 }
2258         }
2259         else {
2260                 if (tcp->u_arg[1] != sizeof iov ||
2261                     umove(tcp, tcp->u_arg[0], &iov) < 0)
2262                     goto done;
2263                 switch (iov.tio_id.id_cmd) {
2264                     case SSISYS_CLUSTERNODE_INFO:
2265                         if (iov.tio_udatainlen != sizeof cni ||
2266                             umove(tcp, (long) iov.tio_udatain, &cni) < 0)
2267                                 goto bad_out;
2268                         if (cni.info_len != sizeof info ||
2269                             iov.tio_udataoutlen != sizeof &info ||
2270                             umove(tcp, (long) iov.tio_udataout, &info) < 0)
2271                                 goto bad_out;
2272                         tprintf(", out={node=%ld, cpus=%d, online=%d}",
2273                                  info.node_num, info.node_totalcpus,
2274                                  info.node_onlinecpus);
2275                         break;
2276
2277                     default:
2278                     bad_out:
2279                         if (iov.tio_udataoutlen) {
2280                                 tprintf(", out=[/* %d bytes */]",
2281                                          iov.tio_udataoutlen);
2282                         }
2283                 }
2284             done:
2285                 tprintf("}, %ld", tcp->u_arg[1]);
2286         }
2287         return 0;
2288 }
2289
2290 #endif
2291
2292 #endif /* UNIXWARE > 2 */
2293
2294 #ifdef MIPS
2295
2296 #ifndef __NEW_UTS_LEN
2297 #define __NEW_UTS_LEN 64
2298 #endif
2299
2300 static const struct xlat sysmips_operations[] = {
2301         { SETNAME,              "SETNAME"       },
2302         { FLUSH_CACHE,          "FLUSH_CACHE"   },
2303         { MIPS_FIXADE,          "MIPS_FIXADE"   },
2304         { MIPS_RDNVRAM,         "MIPS_RDNVRAM"  },
2305         { MIPS_ATOMIC_SET,      "MIPS_ATOMIC_SET"       },
2306         { 0, NULL }
2307 };
2308
2309 int sys_sysmips(struct tcb *tcp)
2310 {
2311         if (entering(tcp)) {
2312                 printxval(sysmips_operations, tcp->u_arg[0], "???");
2313                 if (!verbose(tcp)) {
2314                         tprintf("%ld, %ld, %ld", tcp->u_arg[1], tcp->u_arg[2], tcp->u_arg[3]);
2315                 } else if (tcp->u_arg[0] == SETNAME) {
2316                         char nodename[__NEW_UTS_LEN + 1];
2317                         if (umovestr(tcp, tcp->u_arg[1], (__NEW_UTS_LEN + 1), nodename) < 0)
2318                                 tprintf(", %#lx", tcp->u_arg[1]);
2319                         else
2320                                 tprintf(", \"%s\"", nodename);
2321                 } else if (tcp->u_arg[0] == MIPS_ATOMIC_SET) {
2322                         tprintf(", %#lx, 0x%lx", tcp->u_arg[1], tcp->u_arg[2]);
2323                 } else if (tcp->u_arg[0] == MIPS_FIXADE) {
2324                         tprintf(", 0x%lx", tcp->u_arg[1]);
2325                 } else {
2326                         tprintf("%ld, %ld, %ld", tcp->u_arg[1], tcp->u_arg[2], tcp->u_arg[3]);
2327                 }
2328         }
2329
2330         return 0;
2331 }
2332
2333 #endif /* MIPS */