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 #define _LINUX_SOCKET_H
  36 #define _LINUX_FS_H
  37
  38 #define MS_RDONLY        1      /* Mount read-only */
  39 #define MS_NOSUID        2      /* Ignore suid and sgid bits */
  40 #define MS_NODEV         4      /* Disallow access to device special files */
  41 #define MS_NOEXEC        8      /* Disallow program execution */
  42 #define MS_SYNCHRONOUS  16      /* Writes are synced at once */
  43 #define MS_REMOUNT      32      /* Alter flags of a mounted FS */
  44 #define MS_MANDLOCK     64      /* Allow mandatory locks on an FS */
  45 #define MS_DIRSYNC      128     /* Directory modifications are synchronous */
  46 #define MS_NOATIME      1024    /* Do not update access times. */
  47 #define MS_NODIRATIME   2048    /* Do not update directory access times */
  48 #define MS_BIND         4096
  49 #define MS_MOVE         8192
  50 #define MS_REC          16384
  51 #define MS_SILENT       32768
  52 #define MS_POSIXACL     (1<<16) /* VFS does not apply the umask */
  53 #define MS_UNBINDABLE   (1<<17) /* change to unbindable */
  54 #define MS_PRIVATE      (1<<18) /* change to private */
  55 #define MS_SLAVE        (1<<19) /* change to slave */
  56 #define MS_SHARED       (1<<20) /* change to shared */
  57 #define MS_RELATIME     (1<<21)
  58 #define MS_KERNMOUNT    (1<<22)
  59 #define MS_I_VERSION    (1<<23)
  60 #define MS_STRICTATIME  (1<<24)
  61 #define MS_BORN         (1<<29)
  62 #define MS_ACTIVE       (1<<30)
  63 #define MS_NOUSER       (1<<31)
  64 #define MS_MGC_VAL      0xc0ed0000      /* Magic flag number */
  65 #define MS_MGC_MSK      0xffff0000      /* Magic flag mask */
  66
  67 #include <sys/socket.h>
  68 #include <netinet/in.h>
  69 #include <arpa/inet.h>
  70
  71 #include <sys/syscall.h>
  72
  73 #ifdef HAVE_LINUX_CAPABILITY_H
  74 #include <linux/capability.h>
  75 #endif
  76
  77 #ifdef HAVE_ASM_CACHECTL_H
  78 #include <asm/cachectl.h>
  79 #endif
  80
  81 #ifdef HAVE_LINUX_USTNAME_H
  82 #include <linux/utsname.h>
  83 #endif
  84
  85 #ifdef HAVE_ASM_SYSMIPS_H
  86 #include <asm/sysmips.h>
  87 #endif
  88
  89 #include <linux/sysctl.h>
  90
  91 static const struct xlat mount_flags[] = {
  92         { MS_MGC_VAL,   "MS_MGC_VAL"    },
  93         { MS_RDONLY,    "MS_RDONLY"     },
  94         { MS_NOSUID,    "MS_NOSUID"     },
  95         { MS_NODEV,     "MS_NODEV"      },
  96         { MS_NOEXEC,    "MS_NOEXEC"     },
  97         { MS_SYNCHRONOUS,"MS_SYNCHRONOUS"},
  98         { MS_REMOUNT,   "MS_REMOUNT"    },
  99         { MS_RELATIME,  "MS_RELATIME"   },
 100         { MS_KERNMOUNT, "MS_KERNMOUNT"  },
 101         { MS_I_VERSION, "MS_I_VERSION"  },
 102         { MS_STRICTATIME,"MS_STRICTATIME"},
 103         { MS_BORN,      "MS_BORN"       },
 104         { MS_MANDLOCK,  "MS_MANDLOCK"   },
 105         { MS_NOATIME,   "MS_NOATIME"    },
 106         { MS_NODIRATIME,"MS_NODIRATIME" },
 107         { MS_BIND,      "MS_BIND"       },
 108         { MS_MOVE,      "MS_MOVE"       },
 109         { MS_REC,       "MS_REC"        },
 110         { MS_SILENT,    "MS_SILENT"     },
 111         { MS_POSIXACL,  "MS_POSIXACL"   },
 112         { MS_UNBINDABLE,"MS_UNBINDABLE" },
 113         { MS_PRIVATE,   "MS_PRIVATE"    },
 114         { MS_SLAVE,     "MS_SLAVE"      },
 115         { MS_SHARED,    "MS_SHARED"     },
 116         { MS_ACTIVE,    "MS_ACTIVE"     },
 117         { MS_NOUSER,    "MS_NOUSER"     },
 118         { 0,            NULL            },
 119 };
 120
 121 int
 122 sys_mount(struct tcb *tcp)
 123 {
 124         if (entering(tcp)) {
 125                 int ignore_type = 0, ignore_data = 0;
 126                 unsigned long flags = tcp->u_arg[3];
 127
 128                 /* Discard magic */
 129                 if ((flags & MS_MGC_MSK) == MS_MGC_VAL)
 130                         flags &= ~MS_MGC_MSK;
 131
 132                 if (flags & MS_REMOUNT)
 133                         ignore_type = 1;
 134                 else if (flags & (MS_BIND | MS_MOVE))
 135                         ignore_type = ignore_data = 1;
 136
 137                 printpath(tcp, tcp->u_arg[0]);
 138                 tprints(", ");
 139
 140                 printpath(tcp, tcp->u_arg[1]);
 141                 tprints(", ");
 142
 143                 if (ignore_type && tcp->u_arg[2])
 144                         tprintf("%#lx", tcp->u_arg[2]);
 145                 else
 146                         printstr(tcp, tcp->u_arg[2], -1);
 147                 tprints(", ");
 148
 149                 printflags(mount_flags, tcp->u_arg[3], "MS_???");
 150                 tprints(", ");
 151
 152                 if (ignore_data && tcp->u_arg[4])
 153                         tprintf("%#lx", tcp->u_arg[4]);
 154                 else
 155                         printstr(tcp, tcp->u_arg[4], -1);
 156         }
 157         return 0;
 158 }
 159
 160 #define MNT_FORCE       0x00000001      /* Attempt to forcibily umount */
 161 #define MNT_DETACH      0x00000002      /* Just detach from the tree */
 162 #define MNT_EXPIRE      0x00000004      /* Mark for expiry */
 163
 164 static const struct xlat umount_flags[] = {
 165         { MNT_FORCE,    "MNT_FORCE"     },
 166         { MNT_DETACH,   "MNT_DETACH"    },
 167         { MNT_EXPIRE,   "MNT_EXPIRE"    },
 168         { 0,            NULL            },
 169 };
 170
 171 int
 172 sys_umount2(struct tcb *tcp)
 173 {
 174         if (entering(tcp)) {
 175                 printstr(tcp, tcp->u_arg[0], -1);
 176                 tprints(", ");
 177                 printflags(umount_flags, tcp->u_arg[1], "MNT_???");
 178         }
 179         return 0;
 180 }
 181
 182 /* These are not macros, but enums.  We just copy the values by hand
 183    from Linux 2.6.9 here.  */
 184 static const struct xlat personality_options[] = {
 185         { 0,            "PER_LINUX"     },
 186         { 0x00800000,   "PER_LINUX_32BIT"},
 187         { 0x04100001,   "PER_SVR4"      },
 188         { 0x05000002,   "PER_SVR3"      },
 189         { 0x07000003,   "PER_SCOSVR3"   },
 190         { 0x06000003,   "PER_OSR5"      },
 191         { 0x05000004,   "PER_WYSEV386"  },
 192         { 0x04000005,   "PER_ISCR4"     },
 193         { 0x00000006,   "PER_BSD"       },
 194         { 0x04000006,   "PER_SUNOS"     },
 195         { 0x05000007,   "PER_XENIX"     },
 196         { 0x00000008,   "PER_LINUX32"   },
 197         { 0x08000008,   "PER_LINUX32_3GB"},
 198         { 0x04000009,   "PER_IRIX32"    },
 199         { 0x0400000a,   "PER_IRIXN32"   },
 200         { 0x0400000b,   "PER_IRIX64"    },
 201         { 0x0000000c,   "PER_RISCOS"    },
 202         { 0x0400000d,   "PER_SOLARIS"   },
 203         { 0x0410000e,   "PER_UW7"       },
 204         { 0x0000000f,   "PER_OSF4"      },
 205         { 0x00000010,   "PER_HPUX"      },
 206         { 0,            NULL            },
 207 };
 208
 209 int
 210 sys_personality(struct tcb *tcp)
 211 {
 212         if (entering(tcp))
 213                 printxval(personality_options, tcp->u_arg[0], "PER_???");
 214         return 0;
 215 }
 216
 217 enum {
 218         SYSLOG_ACTION_CLOSE = 0,
 219         SYSLOG_ACTION_OPEN,
 220         SYSLOG_ACTION_READ,
 221         SYSLOG_ACTION_READ_ALL,
 222         SYSLOG_ACTION_READ_CLEAR,
 223         SYSLOG_ACTION_CLEAR,
 224         SYSLOG_ACTION_CONSOLE_OFF,
 225         SYSLOG_ACTION_CONSOLE_ON,
 226         SYSLOG_ACTION_CONSOLE_LEVEL,
 227         SYSLOG_ACTION_SIZE_UNREAD,
 228         SYSLOG_ACTION_SIZE_BUFFER
 229 };
 230
 231 static const struct xlat syslog_action_type[] = {
 232         { SYSLOG_ACTION_CLOSE,          "SYSLOG_ACTION_CLOSE"           },
 233         { SYSLOG_ACTION_OPEN,           "SYSLOG_ACTION_OPEN"            },
 234         { SYSLOG_ACTION_READ,           "SYSLOG_ACTION_READ"            },
 235         { SYSLOG_ACTION_READ_ALL,       "SYSLOG_ACTION_READ_ALL"        },
 236         { SYSLOG_ACTION_READ_CLEAR,     "SYSLOG_ACTION_READ_CLEAR"      },
 237         { SYSLOG_ACTION_CLEAR,          "SYSLOG_ACTION_CLEAR"           },
 238         { SYSLOG_ACTION_CONSOLE_OFF,    "SYSLOG_ACTION_CONSOLE_OFF"     },
 239         { SYSLOG_ACTION_CONSOLE_ON,     "SYSLOG_ACTION_CONSOLE_ON"      },
 240         { SYSLOG_ACTION_CONSOLE_LEVEL,  "SYSLOG_ACTION_CONSOLE_LEVEL"   },
 241         { SYSLOG_ACTION_SIZE_UNREAD,    "SYSLOG_ACTION_SIZE_UNREAD"     },
 242         { SYSLOG_ACTION_SIZE_BUFFER,    "SYSLOG_ACTION_SIZE_BUFFER"     },
 243         { 0,                            NULL                            }
 244 };
 245
 246 int
 247 sys_syslog(struct tcb *tcp)
 248 {
 249         int type = tcp->u_arg[0];
 250
 251         if (entering(tcp)) {
 252                 /* type */
 253                 printxval(syslog_action_type, type, "SYSLOG_ACTION_???");
 254                 tprints(", ");
 255         }
 256
 257         switch (type) {
 258                 case SYSLOG_ACTION_READ:
 259                 case SYSLOG_ACTION_READ_ALL:
 260                 case SYSLOG_ACTION_READ_CLEAR:
 261                         if (entering(tcp))
 262                                 return 0;
 263                         break;
 264                 default:
 265                         if (entering(tcp)) {
 266                                 tprintf("%#lx, %lu",
 267                                         tcp->u_arg[1], tcp->u_arg[2]);
 268                         }
 269                         return 0;
 270         }
 271
 272         /* bufp */
 273         if (syserror(tcp))
 274                 tprintf("%#lx", tcp->u_arg[1]);
 275         else
 276                 printstr(tcp, tcp->u_arg[1], tcp->u_rval);
 277         /* len */
 278         tprintf(", %d", (int) tcp->u_arg[2]);
 279
 280         return 0;
 281 }
 282
 283 #include <linux/reboot.h>
 284 static const struct xlat bootflags1[] = {
 285         { LINUX_REBOOT_MAGIC1,  "LINUX_REBOOT_MAGIC1"   },
 286         { 0,                    NULL                    },
 287 };
 288
 289 static const struct xlat bootflags2[] = {
 290         { LINUX_REBOOT_MAGIC2,  "LINUX_REBOOT_MAGIC2"   },
 291         { LINUX_REBOOT_MAGIC2A, "LINUX_REBOOT_MAGIC2A"  },
 292         { LINUX_REBOOT_MAGIC2B, "LINUX_REBOOT_MAGIC2B"  },
 293         { 0,                    NULL                    },
 294 };
 295
 296 static const struct xlat bootflags3[] = {
 297         { LINUX_REBOOT_CMD_CAD_OFF,     "LINUX_REBOOT_CMD_CAD_OFF"      },
 298         { LINUX_REBOOT_CMD_RESTART,     "LINUX_REBOOT_CMD_RESTART"      },
 299         { LINUX_REBOOT_CMD_HALT,        "LINUX_REBOOT_CMD_HALT"         },
 300         { LINUX_REBOOT_CMD_CAD_ON,      "LINUX_REBOOT_CMD_CAD_ON"       },
 301         { LINUX_REBOOT_CMD_POWER_OFF,   "LINUX_REBOOT_CMD_POWER_OFF"    },
 302         { LINUX_REBOOT_CMD_RESTART2,    "LINUX_REBOOT_CMD_RESTART2"     },
 303         { 0,                            NULL                            },
 304 };
 305
 306 int
 307 sys_reboot(struct tcb *tcp)
 308 {
 309         if (entering(tcp)) {
 310                 printflags(bootflags1, tcp->u_arg[0], "LINUX_REBOOT_MAGIC_???");
 311                 tprints(", ");
 312                 printflags(bootflags2, tcp->u_arg[1], "LINUX_REBOOT_MAGIC_???");
 313                 tprints(", ");
 314                 printflags(bootflags3, tcp->u_arg[2], "LINUX_REBOOT_CMD_???");
 315                 if (tcp->u_arg[2] == LINUX_REBOOT_CMD_RESTART2) {
 316                         tprints(", ");
 317                         printstr(tcp, tcp->u_arg[3], -1);
 318                 }
 319         }
 320         return 0;
 321 }
 322
 323 #ifdef M68K
 324 static const struct xlat cacheflush_scope[] = {
 325 #ifdef FLUSH_SCOPE_LINE
 326         { FLUSH_SCOPE_LINE,     "FLUSH_SCOPE_LINE" },
 327 #endif
 328 #ifdef FLUSH_SCOPE_PAGE
 329         { FLUSH_SCOPE_PAGE,     "FLUSH_SCOPE_PAGE" },
 330 #endif
 331 #ifdef FLUSH_SCOPE_ALL
 332         { FLUSH_SCOPE_ALL,      "FLUSH_SCOPE_ALL" },
 333 #endif
 334         { 0,                    NULL },
 335 };
 336
 337 static const struct xlat cacheflush_flags[] = {
 338 #ifdef FLUSH_CACHE_BOTH
 339         { FLUSH_CACHE_BOTH,     "FLUSH_CACHE_BOTH" },
 340 #endif
 341 #ifdef FLUSH_CACHE_DATA
 342         { FLUSH_CACHE_DATA,     "FLUSH_CACHE_DATA" },
 343 #endif
 344 #ifdef FLUSH_CACHE_INSN
 345         { FLUSH_CACHE_INSN,     "FLUSH_CACHE_INSN" },
 346 #endif
 347         { 0,                    NULL },
 348 };
 349
 350 int
 351 sys_cacheflush(struct tcb *tcp)
 352 {
 353         if (entering(tcp)) {
 354                 /* addr */
 355                 tprintf("%#lx, ", tcp->u_arg[0]);
 356                 /* scope */
 357                 printxval(cacheflush_scope, tcp->u_arg[1], "FLUSH_SCOPE_???");
 358                 tprints(", ");
 359                 /* flags */
 360                 printflags(cacheflush_flags, tcp->u_arg[2], "FLUSH_CACHE_???");
 361                 /* len */
 362                 tprintf(", %lu", tcp->u_arg[3]);
 363         }
 364         return 0;
 365 }
 366 #endif /* M68K */
 367
 368 #ifdef BFIN
 369
 370 #include <bfin_sram.h>
 371
 372 static const struct xlat sram_alloc_flags[] = {
 373         { L1_INST_SRAM,         "L1_INST_SRAM" },
 374         { L1_DATA_A_SRAM,       "L1_DATA_A_SRAM" },
 375         { L1_DATA_B_SRAM,       "L1_DATA_B_SRAM" },
 376         { L1_DATA_SRAM,         "L1_DATA_SRAM" },
 377         { L2_SRAM,              "L2_SRAM" },
 378         { 0,                    NULL },
 379 };
 380
 381 int
 382 sys_sram_alloc(struct tcb *tcp)
 383 {
 384         if (entering(tcp)) {
 385                 /* size */
 386                 tprintf("%lu, ", tcp->u_arg[0]);
 387                 /* flags */
 388                 printxval(sram_alloc_flags, tcp->u_arg[1], "???_SRAM");
 389         }
 390         return 1;
 391 }
 392
 393 #include <asm/cachectl.h>
 394
 395 static const struct xlat cacheflush_flags[] = {
 396         { ICACHE,       "ICACHE" },
 397         { DCACHE,       "DCACHE" },
 398         { BCACHE,       "BCACHE" },
 399         { 0,            NULL },
 400 };
 401
 402 int
 403 sys_cacheflush(struct tcb *tcp)
 404 {
 405         if (entering(tcp)) {
 406                 /* start addr */
 407                 tprintf("%#lx, ", tcp->u_arg[0]);
 408                 /* length */
 409                 tprintf("%ld, ", tcp->u_arg[1]);
 410                 /* flags */
 411                 printxval(cacheflush_flags, tcp->u_arg[1], "?CACHE");
 412         }
 413         return 0;
 414 }
 415
 416 #endif
 417
 418 #ifdef SH
 419 static const struct xlat cacheflush_flags[] = {
 420 #ifdef CACHEFLUSH_D_INVAL
 421         { CACHEFLUSH_D_INVAL,   "CACHEFLUSH_D_INVAL" },
 422 #endif
 423 #ifdef CACHEFLUSH_D_WB
 424         { CACHEFLUSH_D_WB,      "CACHEFLUSH_D_WB" },
 425 #endif
 426 #ifdef CACHEFLUSH_D_PURGE
 427         { CACHEFLUSH_D_PURGE,   "CACHEFLUSH_D_PURGE" },
 428 #endif
 429 #ifdef CACHEFLUSH_I
 430         { CACHEFLUSH_I,         "CACHEFLUSH_I" },
 431 #endif
 432         { 0,                    NULL },
 433 };
 434
 435 int
 436 sys_cacheflush(struct tcb *tcp)
 437 {
 438         if (entering(tcp)) {
 439                 /* addr */
 440                 tprintf("%#lx, ", tcp->u_arg[0]);
 441                 /* len */
 442                 tprintf("%lu, ", tcp->u_arg[1]);
 443                 /* flags */
 444                 printflags(cacheflush_flags, tcp->u_arg[2], "CACHEFLUSH_???");
 445         }
 446         return 0;
 447 }
 448 #endif /* SH */
 449
 450 #ifdef SYS_capget
 451
 452 static const struct xlat capabilities[] = {
 453         { 1<<CAP_CHOWN,         "CAP_CHOWN"     },
 454         { 1<<CAP_DAC_OVERRIDE,  "CAP_DAC_OVERRIDE"},
 455         { 1<<CAP_DAC_READ_SEARCH,"CAP_DAC_READ_SEARCH"},
 456         { 1<<CAP_FOWNER,        "CAP_FOWNER"    },
 457         { 1<<CAP_FSETID,        "CAP_FSETID"    },
 458         { 1<<CAP_KILL,          "CAP_KILL"      },
 459         { 1<<CAP_SETGID,        "CAP_SETGID"    },
 460         { 1<<CAP_SETUID,        "CAP_SETUID"    },
 461         { 1<<CAP_SETPCAP,       "CAP_SETPCAP"   },
 462         { 1<<CAP_LINUX_IMMUTABLE,"CAP_LINUX_IMMUTABLE"},
 463         { 1<<CAP_NET_BIND_SERVICE,"CAP_NET_BIND_SERVICE"},
 464         { 1<<CAP_NET_BROADCAST, "CAP_NET_BROADCAST"},
 465         { 1<<CAP_NET_ADMIN,     "CAP_NET_ADMIN" },
 466         { 1<<CAP_NET_RAW,       "CAP_NET_RAW"   },
 467         { 1<<CAP_IPC_LOCK,      "CAP_IPC_LOCK"  },
 468         { 1<<CAP_IPC_OWNER,     "CAP_IPC_OWNER" },
 469         { 1<<CAP_SYS_MODULE,    "CAP_SYS_MODULE"},
 470         { 1<<CAP_SYS_RAWIO,     "CAP_SYS_RAWIO" },
 471         { 1<<CAP_SYS_CHROOT,    "CAP_SYS_CHROOT"},
 472         { 1<<CAP_SYS_PTRACE,    "CAP_SYS_PTRACE"},
 473         { 1<<CAP_SYS_PACCT,     "CAP_SYS_PACCT" },
 474         { 1<<CAP_SYS_ADMIN,     "CAP_SYS_ADMIN" },
 475         { 1<<CAP_SYS_BOOT,      "CAP_SYS_BOOT"  },
 476         { 1<<CAP_SYS_NICE,      "CAP_SYS_NICE"  },
 477         { 1<<CAP_SYS_RESOURCE,  "CAP_SYS_RESOURCE"},
 478         { 1<<CAP_SYS_TIME,      "CAP_SYS_TIME"  },
 479         { 1<<CAP_SYS_TTY_CONFIG,"CAP_SYS_TTY_CONFIG"},
 480 #ifdef CAP_MKNOD
 481         { 1<<CAP_MKNOD,         "CAP_MKNOD"     },
 482 #endif
 483 #ifdef CAP_LEASE
 484         { 1<<CAP_LEASE,         "CAP_LEASE"     },
 485 #endif
 486 #ifdef CAP_AUDIT_WRITE
 487         { 1<<CAP_AUDIT_WRITE,   "CAP_AUDIT_WRITE"},
 488 #endif
 489 #ifdef CAP_AUDIT_CONTROL
 490         { 1<<CAP_AUDIT_CONTROL, "CAP_AUDIT_CONTROL"},
 491 #endif
 492 #ifdef CAP_SETFCAP
 493         { 1<<CAP_SETFCAP,       "CAP_SETFCAP"   },
 494 #endif
 495         { 0,            NULL            },
 496 };
 497
 498 int
 499 sys_capget(struct tcb *tcp)
 500 {
 501         /* cap_user_ types are _pointers_ to (small) structs. */
 502         /* Structs themselves have no names defined. */
 503         /* Have to use ugly hack to place them on stack. */
 504         cap_user_header_t arg0;
 505         cap_user_data_t   arg1;
 506         long a0[sizeof(*arg0) / sizeof(long) + 1];
 507         long a1[sizeof(*arg1) / sizeof(long) + 1];
 508         arg0 = (cap_user_header_t) a0;
 509         arg1 = (cap_user_data_t  ) a1;
 510
 511         if (!entering(tcp)) {
 512                 if (!tcp->u_arg[0])
 513                         tprints("NULL");
 514                 else if (!verbose(tcp))
 515                         tprintf("%#lx", tcp->u_arg[0]);
 516                 else if (umoven(tcp, tcp->u_arg[0], sizeof(*arg0), (char *) arg0) < 0)
 517                         tprints("???");
 518                 else {
 519                         tprintf("%#x, %d", arg0->version, arg0->pid);
 520                 }
 521                 tprints(", ");
 522                 if (!tcp->u_arg[1])
 523                         tprints("NULL");
 524                 else if (!verbose(tcp))
 525                         tprintf("%#lx", tcp->u_arg[1]);
 526                 else if (umoven(tcp, tcp->u_arg[1], sizeof(*arg1), (char *) arg1) < 0)
 527                         tprints("???");
 528                 else {
 529                         tprints("{");
 530                         printflags(capabilities, arg1->effective, "CAP_???");
 531                         tprints(", ");
 532                         printflags(capabilities, arg1->permitted, "CAP_???");
 533                         tprints(", ");
 534                         printflags(capabilities, arg1->inheritable, "CAP_???");
 535                         tprints("}");
 536                 }
 537         }
 538         return 0;
 539 }
 540
 541 int
 542 sys_capset(struct tcb *tcp)
 543 {
 544         cap_user_header_t arg0;
 545         cap_user_data_t   arg1;
 546         long a0[sizeof(*arg0) / sizeof(long) + 1];
 547         long a1[sizeof(*arg1) / sizeof(long) + 1];
 548         arg0 = (cap_user_header_t) a0;
 549         arg1 = (cap_user_data_t  ) a1;
 550
 551         if (entering(tcp)) {
 552                 if (!tcp->u_arg[0])
 553                         tprints("NULL");
 554                 else if (!verbose(tcp))
 555                         tprintf("%#lx", tcp->u_arg[0]);
 556                 else if (umoven(tcp, tcp->u_arg[0], sizeof(*arg0), (char *) arg0) < 0)
 557                         tprints("???");
 558                 else {
 559                         tprintf("%#x, %d", arg0->version, arg0->pid);
 560                 }
 561                 tprints(", ");
 562                 if (!tcp->u_arg[1])
 563                         tprints("NULL");
 564                 else if (!verbose(tcp))
 565                         tprintf("%#lx", tcp->u_arg[1]);
 566                 else if (umoven(tcp, tcp->u_arg[1], sizeof(*arg1), (char *) arg1) < 0)
 567                         tprints("???");
 568                 else {
 569                         tprints("{");
 570                         printflags(capabilities, arg1->effective, "CAP_???");
 571                         tprints(", ");
 572                         printflags(capabilities, arg1->permitted, "CAP_???");
 573                         tprints(", ");
 574                         printflags(capabilities, arg1->inheritable, "CAP_???");
 575                         tprints("}");
 576                 }
 577         }
 578         return 0;
 579 }
 580
 581 #else
 582
 583 int sys_capget(struct tcb *tcp)
 584 {
 585         return printargs(tcp);
 586 }
 587
 588 int sys_capset(struct tcb *tcp)
 589 {
 590         return printargs(tcp);
 591 }
 592
 593 #endif
 594
 595 /* Linux 2.6.18+ headers removed CTL_PROC enum.  */
 596 # define CTL_PROC 4
 597 # define CTL_CPU 10             /* older headers lack */
 598 static const struct xlat sysctl_root[] = {
 599         { CTL_KERN, "CTL_KERN" },
 600         { CTL_VM, "CTL_VM" },
 601         { CTL_NET, "CTL_NET" },
 602         { CTL_PROC, "CTL_PROC" },
 603         { CTL_FS, "CTL_FS" },
 604         { CTL_DEBUG, "CTL_DEBUG" },
 605         { CTL_DEV, "CTL_DEV" },
 606         { CTL_BUS, "CTL_BUS" },
 607         { CTL_ABI, "CTL_ABI" },
 608         { CTL_CPU, "CTL_CPU" },
 609         { 0, NULL }
 610 };
 611
 612 static const struct xlat sysctl_kern[] = {
 613         { KERN_OSTYPE, "KERN_OSTYPE" },
 614         { KERN_OSRELEASE, "KERN_OSRELEASE" },
 615         { KERN_OSREV, "KERN_OSREV" },
 616         { KERN_VERSION, "KERN_VERSION" },
 617         { KERN_SECUREMASK, "KERN_SECUREMASK" },
 618         { KERN_PROF, "KERN_PROF" },
 619         { KERN_NODENAME, "KERN_NODENAME" },
 620         { KERN_DOMAINNAME, "KERN_DOMAINNAME" },
 621 #ifdef KERN_SECURELVL
 622         { KERN_SECURELVL, "KERN_SECURELVL" },
 623 #endif
 624         { KERN_PANIC, "KERN_PANIC" },
 625 #ifdef KERN_REALROOTDEV
 626         { KERN_REALROOTDEV, "KERN_REALROOTDEV" },
 627 #endif
 628 #ifdef KERN_JAVA_INTERPRETER
 629         { KERN_JAVA_INTERPRETER, "KERN_JAVA_INTERPRETER" },
 630 #endif
 631 #ifdef KERN_JAVA_APPLETVIEWER
 632         { KERN_JAVA_APPLETVIEWER, "KERN_JAVA_APPLETVIEWER" },
 633 #endif
 634         { KERN_SPARC_REBOOT, "KERN_SPARC_REBOOT" },
 635         { KERN_CTLALTDEL, "KERN_CTLALTDEL" },
 636         { KERN_PRINTK, "KERN_PRINTK" },
 637         { KERN_NAMETRANS, "KERN_NAMETRANS" },
 638         { KERN_PPC_HTABRECLAIM, "KERN_PPC_HTABRECLAIM" },
 639         { KERN_PPC_ZEROPAGED, "KERN_PPC_ZEROPAGED" },
 640         { KERN_PPC_POWERSAVE_NAP, "KERN_PPC_POWERSAVE_NAP" },
 641         { KERN_MODPROBE, "KERN_MODPROBE" },
 642         { KERN_SG_BIG_BUFF, "KERN_SG_BIG_BUFF" },
 643         { KERN_ACCT, "KERN_ACCT" },
 644         { KERN_PPC_L2CR, "KERN_PPC_L2CR" },
 645         { KERN_RTSIGNR, "KERN_RTSIGNR" },
 646         { KERN_RTSIGMAX, "KERN_RTSIGMAX" },
 647         { KERN_SHMMAX, "KERN_SHMMAX" },
 648         { KERN_MSGMAX, "KERN_MSGMAX" },
 649         { KERN_MSGMNB, "KERN_MSGMNB" },
 650         { KERN_MSGPOOL, "KERN_MSGPOOL" },
 651         { 0, NULL }
 652 };
 653
 654 static const struct xlat sysctl_vm[] = {
 655 #ifdef VM_SWAPCTL
 656         { VM_SWAPCTL, "VM_SWAPCTL" },
 657 #endif
 658 #ifdef VM_UNUSED1
 659         { VM_UNUSED1, "VM_UNUSED1" },
 660 #endif
 661 #ifdef VM_SWAPOUT
 662         { VM_SWAPOUT, "VM_SWAPOUT" },
 663 #endif
 664 #ifdef VM_UNUSED2
 665         { VM_UNUSED2, "VM_UNUSED2" },
 666 #endif
 667 #ifdef VM_FREEPG
 668         { VM_FREEPG, "VM_FREEPG" },
 669 #endif
 670 #ifdef VM_UNUSED3
 671         { VM_UNUSED3, "VM_UNUSED3" },
 672 #endif
 673 #ifdef VM_BDFLUSH
 674         { VM_BDFLUSH, "VM_BDFLUSH" },
 675 #endif
 676 #ifdef VM_UNUSED4
 677         { VM_UNUSED4, "VM_UNUSED4" },
 678 #endif
 679         { VM_OVERCOMMIT_MEMORY, "VM_OVERCOMMIT_MEMORY" },
 680 #ifdef VM_BUFFERMEM
 681         { VM_BUFFERMEM, "VM_BUFFERMEM" },
 682 #endif
 683 #ifdef VM_UNUSED5
 684         { VM_UNUSED5, "VM_UNUSED5" },
 685 #endif
 686 #ifdef VM_PAGECACHE
 687         { VM_PAGECACHE, "VM_PAGECACHE" },
 688 #endif
 689 #ifdef VM_UNUSED7
 690         { VM_UNUSED7, "VM_UNUSED7" },
 691 #endif
 692 #ifdef VM_PAGERDAEMON
 693         { VM_PAGERDAEMON, "VM_PAGERDAEMON" },
 694 #endif
 695 #ifdef VM_UNUSED8
 696         { VM_UNUSED8, "VM_UNUSED8" },
 697 #endif
 698 #ifdef VM_PGT_CACHE
 699         { VM_PGT_CACHE, "VM_PGT_CACHE" },
 700 #endif
 701 #ifdef VM_UNUSED9
 702         { VM_UNUSED9, "VM_UNUSED9" },
 703 #endif
 704         { VM_PAGE_CLUSTER, "VM_PAGE_CLUSTER" },
 705         { 0, NULL },
 706 };
 707
 708 static const struct xlat sysctl_net[] = {
 709         { NET_CORE, "NET_CORE" },
 710         { NET_ETHER, "NET_ETHER" },
 711         { NET_802, "NET_802" },
 712         { NET_UNIX, "NET_UNIX" },
 713         { NET_IPV4, "NET_IPV4" },
 714         { NET_IPX, "NET_IPX" },
 715         { NET_ATALK, "NET_ATALK" },
 716         { NET_NETROM, "NET_NETROM" },
 717         { NET_AX25, "NET_AX25" },
 718         { NET_BRIDGE, "NET_BRIDGE" },
 719         { NET_ROSE, "NET_ROSE" },
 720         { NET_IPV6, "NET_IPV6" },
 721         { NET_X25, "NET_X25" },
 722         { NET_TR, "NET_TR" },
 723         { NET_DECNET, "NET_DECNET" },
 724         { 0, NULL }
 725 };
 726
 727 static const struct xlat sysctl_net_core[] = {
 728         { NET_CORE_WMEM_MAX, "NET_CORE_WMEM_MAX" },
 729         { NET_CORE_RMEM_MAX, "NET_CORE_RMEM_MAX" },
 730         { NET_CORE_WMEM_DEFAULT, "NET_CORE_WMEM_DEFAULT" },
 731         { NET_CORE_RMEM_DEFAULT, "NET_CORE_RMEM_DEFAULT" },
 732         { NET_CORE_MAX_BACKLOG, "NET_CORE_MAX_BACKLOG" },
 733         { NET_CORE_FASTROUTE, "NET_CORE_FASTROUTE" },
 734         { NET_CORE_MSG_COST, "NET_CORE_MSG_COST" },
 735         { NET_CORE_MSG_BURST, "NET_CORE_MSG_BURST" },
 736         { NET_CORE_OPTMEM_MAX, "NET_CORE_OPTMEM_MAX" },
 737         { 0, NULL }
 738 };
 739
 740 static const struct xlat sysctl_net_unix[] = {
 741         { NET_UNIX_DESTROY_DELAY, "NET_UNIX_DESTROY_DELAY" },
 742         { NET_UNIX_DELETE_DELAY, "NET_UNIX_DELETE_DELAY" },
 743         { 0, NULL }
 744 };
 745
 746 static const struct xlat sysctl_net_ipv4[] = {
 747         { NET_IPV4_FORWARD, "NET_IPV4_FORWARD" },
 748         { NET_IPV4_DYNADDR, "NET_IPV4_DYNADDR" },
 749         { NET_IPV4_CONF, "NET_IPV4_CONF" },
 750         { NET_IPV4_NEIGH, "NET_IPV4_NEIGH" },
 751         { NET_IPV4_ROUTE, "NET_IPV4_ROUTE" },
 752         { NET_IPV4_FIB_HASH, "NET_IPV4_FIB_HASH" },
 753         { NET_IPV4_TCP_TIMESTAMPS, "NET_IPV4_TCP_TIMESTAMPS" },
 754         { NET_IPV4_TCP_WINDOW_SCALING, "NET_IPV4_TCP_WINDOW_SCALING" },
 755         { NET_IPV4_TCP_SACK, "NET_IPV4_TCP_SACK" },
 756         { NET_IPV4_TCP_RETRANS_COLLAPSE, "NET_IPV4_TCP_RETRANS_COLLAPSE" },
 757         { NET_IPV4_DEFAULT_TTL, "NET_IPV4_DEFAULT_TTL" },
 758         { NET_IPV4_AUTOCONFIG, "NET_IPV4_AUTOCONFIG" },
 759         { NET_IPV4_NO_PMTU_DISC, "NET_IPV4_NO_PMTU_DISC" },
 760         { NET_IPV4_TCP_SYN_RETRIES, "NET_IPV4_TCP_SYN_RETRIES" },
 761         { NET_IPV4_IPFRAG_HIGH_THRESH, "NET_IPV4_IPFRAG_HIGH_THRESH" },
 762         { NET_IPV4_IPFRAG_LOW_THRESH, "NET_IPV4_IPFRAG_LOW_THRESH" },
 763         { NET_IPV4_IPFRAG_TIME, "NET_IPV4_IPFRAG_TIME" },
 764         { NET_IPV4_TCP_MAX_KA_PROBES, "NET_IPV4_TCP_MAX_KA_PROBES" },
 765         { NET_IPV4_TCP_KEEPALIVE_TIME, "NET_IPV4_TCP_KEEPALIVE_TIME" },
 766         { NET_IPV4_TCP_KEEPALIVE_PROBES, "NET_IPV4_TCP_KEEPALIVE_PROBES" },
 767         { NET_IPV4_TCP_RETRIES1, "NET_IPV4_TCP_RETRIES1" },
 768         { NET_IPV4_TCP_RETRIES2, "NET_IPV4_TCP_RETRIES2" },
 769         { NET_IPV4_TCP_FIN_TIMEOUT, "NET_IPV4_TCP_FIN_TIMEOUT" },
 770         { NET_IPV4_IP_MASQ_DEBUG, "NET_IPV4_IP_MASQ_DEBUG" },
 771         { NET_TCP_SYNCOOKIES, "NET_TCP_SYNCOOKIES" },
 772         { NET_TCP_STDURG, "NET_TCP_STDURG" },
 773         { NET_TCP_RFC1337, "NET_TCP_RFC1337" },
 774         { NET_TCP_SYN_TAILDROP, "NET_TCP_SYN_TAILDROP" },
 775         { NET_TCP_MAX_SYN_BACKLOG, "NET_TCP_MAX_SYN_BACKLOG" },
 776         { NET_IPV4_LOCAL_PORT_RANGE, "NET_IPV4_LOCAL_PORT_RANGE" },
 777         { NET_IPV4_ICMP_ECHO_IGNORE_ALL, "NET_IPV4_ICMP_ECHO_IGNORE_ALL" },
 778         { NET_IPV4_ICMP_ECHO_IGNORE_BROADCASTS, "NET_IPV4_ICMP_ECHO_IGNORE_BROADCASTS" },
 779         { NET_IPV4_ICMP_SOURCEQUENCH_RATE, "NET_IPV4_ICMP_SOURCEQUENCH_RATE" },
 780         { NET_IPV4_ICMP_DESTUNREACH_RATE, "NET_IPV4_ICMP_DESTUNREACH_RATE" },
 781         { NET_IPV4_ICMP_TIMEEXCEED_RATE, "NET_IPV4_ICMP_TIMEEXCEED_RATE" },
 782         { NET_IPV4_ICMP_PARAMPROB_RATE, "NET_IPV4_ICMP_PARAMPROB_RATE" },
 783         { NET_IPV4_ICMP_ECHOREPLY_RATE, "NET_IPV4_ICMP_ECHOREPLY_RATE" },
 784         { NET_IPV4_ICMP_IGNORE_BOGUS_ERROR_RESPONSES, "NET_IPV4_ICMP_IGNORE_BOGUS_ERROR_RESPONSES" },
 785         { NET_IPV4_IGMP_MAX_MEMBERSHIPS, "NET_IPV4_IGMP_MAX_MEMBERSHIPS" },
 786         {  0, NULL }
 787 };
 788
 789 static const struct xlat sysctl_net_ipv4_route[] = {
 790         { NET_IPV4_ROUTE_FLUSH, "NET_IPV4_ROUTE_FLUSH" },
 791         { NET_IPV4_ROUTE_MIN_DELAY, "NET_IPV4_ROUTE_MIN_DELAY" },
 792         { NET_IPV4_ROUTE_MAX_DELAY, "NET_IPV4_ROUTE_MAX_DELAY" },
 793         { NET_IPV4_ROUTE_GC_THRESH, "NET_IPV4_ROUTE_GC_THRESH" },
 794         { NET_IPV4_ROUTE_MAX_SIZE, "NET_IPV4_ROUTE_MAX_SIZE" },
 795         { NET_IPV4_ROUTE_GC_MIN_INTERVAL, "NET_IPV4_ROUTE_GC_MIN_INTERVAL" },
 796         { NET_IPV4_ROUTE_GC_TIMEOUT, "NET_IPV4_ROUTE_GC_TIMEOUT" },
 797         { NET_IPV4_ROUTE_GC_INTERVAL, "NET_IPV4_ROUTE_GC_INTERVAL" },
 798         { NET_IPV4_ROUTE_REDIRECT_LOAD, "NET_IPV4_ROUTE_REDIRECT_LOAD" },
 799         { NET_IPV4_ROUTE_REDIRECT_NUMBER, "NET_IPV4_ROUTE_REDIRECT_NUMBER" },
 800         { NET_IPV4_ROUTE_REDIRECT_SILENCE, "NET_IPV4_ROUTE_REDIRECT_SILENCE" },
 801         { NET_IPV4_ROUTE_ERROR_COST, "NET_IPV4_ROUTE_ERROR_COST" },
 802         { NET_IPV4_ROUTE_ERROR_BURST, "NET_IPV4_ROUTE_ERROR_BURST" },
 803         { NET_IPV4_ROUTE_GC_ELASTICITY, "NET_IPV4_ROUTE_GC_ELASTICITY" },
 804         { 0, NULL }
 805 };
 806
 807 static const struct xlat sysctl_net_ipv4_conf[] = {
 808         { NET_IPV4_CONF_FORWARDING, "NET_IPV4_CONF_FORWARDING" },
 809         { NET_IPV4_CONF_MC_FORWARDING, "NET_IPV4_CONF_MC_FORWARDING" },
 810         { NET_IPV4_CONF_PROXY_ARP, "NET_IPV4_CONF_PROXY_ARP" },
 811         { NET_IPV4_CONF_ACCEPT_REDIRECTS, "NET_IPV4_CONF_ACCEPT_REDIRECTS" },
 812         { NET_IPV4_CONF_SECURE_REDIRECTS, "NET_IPV4_CONF_SECURE_REDIRECTS" },
 813         { NET_IPV4_CONF_SEND_REDIRECTS, "NET_IPV4_CONF_SEND_REDIRECTS" },
 814         { NET_IPV4_CONF_SHARED_MEDIA, "NET_IPV4_CONF_SHARED_MEDIA" },
 815         { NET_IPV4_CONF_RP_FILTER, "NET_IPV4_CONF_RP_FILTER" },
 816         { NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE, "NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE" },
 817         { NET_IPV4_CONF_BOOTP_RELAY, "NET_IPV4_CONF_BOOTP_RELAY" },
 818         { NET_IPV4_CONF_LOG_MARTIANS, "NET_IPV4_CONF_LOG_MARTIANS" },
 819         { 0, NULL }
 820 };
 821
 822 static const struct xlat sysctl_net_ipv6[] = {
 823         { NET_IPV6_CONF, "NET_IPV6_CONF" },
 824         { NET_IPV6_NEIGH, "NET_IPV6_NEIGH" },
 825         { NET_IPV6_ROUTE, "NET_IPV6_ROUTE" },
 826         { 0, NULL }
 827 };
 828
 829 static const struct xlat sysctl_net_ipv6_route[] = {
 830         { NET_IPV6_ROUTE_FLUSH, "NET_IPV6_ROUTE_FLUSH" },
 831         { NET_IPV6_ROUTE_GC_THRESH, "NET_IPV6_ROUTE_GC_THRESH" },
 832         { NET_IPV6_ROUTE_MAX_SIZE, "NET_IPV6_ROUTE_MAX_SIZE" },
 833         { NET_IPV6_ROUTE_GC_MIN_INTERVAL, "NET_IPV6_ROUTE_GC_MIN_INTERVAL" },
 834         { NET_IPV6_ROUTE_GC_TIMEOUT, "NET_IPV6_ROUTE_GC_TIMEOUT" },
 835         { NET_IPV6_ROUTE_GC_INTERVAL, "NET_IPV6_ROUTE_GC_INTERVAL" },
 836         { NET_IPV6_ROUTE_GC_ELASTICITY, "NET_IPV6_ROUTE_GC_ELASTICITY" },
 837         { 0, NULL }
 838 };
 839
 840 int
 841 sys_sysctl(struct tcb *tcp)
 842 {
 843         struct __sysctl_args info;
 844         int *name;
 845         unsigned long size;
 846
 847         if (umove(tcp, tcp->u_arg[0], &info) < 0)
 848                 return printargs(tcp);
 849
 850         size = sizeof(int) * (unsigned long) info.nlen;
 851         name = (size / sizeof(int) != info.nlen) ? NULL : malloc(size);
 852         if (name == NULL ||
 853             umoven(tcp, (unsigned long) info.name, size, (char *) name) < 0) {
 854                 free(name);
 855                 if (entering(tcp))
 856                         tprintf("{%p, %d, %p, %p, %p, %Zu}",
 857                                 info.name, info.nlen, info.oldval,
 858                                 info.oldlenp, info.newval, info.newlen);
 859                 return 0;
 860         }
 861
 862         if (entering(tcp)) {
 863                 int cnt = 0, max_cnt;
 864
 865                 tprints("{{");
 866
 867                 if (info.nlen == 0)
 868                         goto out;
 869                 printxval(sysctl_root, name[0], "CTL_???");
 870                 ++cnt;
 871
 872                 if (info.nlen == 1)
 873                         goto out;
 874                 switch (name[0]) {
 875                 case CTL_KERN:
 876                         tprints(", ");
 877                         printxval(sysctl_kern, name[1], "KERN_???");
 878                         ++cnt;
 879                         break;
 880                 case CTL_VM:
 881                         tprints(", ");
 882                         printxval(sysctl_vm, name[1], "VM_???");
 883                         ++cnt;
 884                         break;
 885                 case CTL_NET:
 886                         tprints(", ");
 887                         printxval(sysctl_net, name[1], "NET_???");
 888                         ++cnt;
 889
 890                         if (info.nlen == 2)
 891                                 goto out;
 892                         switch (name[1]) {
 893                         case NET_CORE:
 894                                 tprints(", ");
 895                                 printxval(sysctl_net_core, name[2],
 896                                           "NET_CORE_???");
 897                                 break;
 898                         case NET_UNIX:
 899                                 tprints(", ");
 900                                 printxval(sysctl_net_unix, name[2],
 901                                           "NET_UNIX_???");
 902                                 break;
 903                         case NET_IPV4:
 904                                 tprints(", ");
 905                                 printxval(sysctl_net_ipv4, name[2],
 906                                           "NET_IPV4_???");
 907
 908                                 if (info.nlen == 3)
 909                                         goto out;
 910                                 switch (name[2]) {
 911                                 case NET_IPV4_ROUTE:
 912                                         tprints(", ");
 913                                         printxval(sysctl_net_ipv4_route,
 914                                                   name[3],
 915                                                   "NET_IPV4_ROUTE_???");
 916                                         break;
 917                                 case NET_IPV4_CONF:
 918                                         tprints(", ");
 919                                         printxval(sysctl_net_ipv4_conf,
 920                                                   name[3],
 921                                                   "NET_IPV4_CONF_???");
 922                                         break;
 923                                 default:
 924                                         goto out;
 925                                 }
 926                                 break;
 927                         case NET_IPV6:
 928                                 tprints(", ");
 929                                 printxval(sysctl_net_ipv6, name[2],
 930                                           "NET_IPV6_???");
 931
 932                                 if (info.nlen == 3)
 933                                         goto out;
 934                                 switch (name[2]) {
 935                                 case NET_IPV6_ROUTE:
 936                                         tprints(", ");
 937                                         printxval(sysctl_net_ipv6_route,
 938                                                   name[3],
 939                                                   "NET_IPV6_ROUTE_???");
 940                                         break;
 941                                 default:
 942                                         goto out;
 943                                 }
 944                                 break;
 945                         default:
 946                                 goto out;
 947                         }
 948                         break;
 949                 default:
 950                         goto out;
 951                 }
 952         out:
 953                 max_cnt = info.nlen;
 954                 if (abbrev(tcp) && max_cnt > max_strlen)
 955                         max_cnt = max_strlen;
 956                 while (cnt < max_cnt)
 957                         tprintf(", %x", name[cnt++]);
 958                 if (cnt < info.nlen)
 959                         tprints(", ...");
 960                 tprintf("}, %d, ", info.nlen);
 961         } else {
 962                 size_t oldlen;
 963                 if (umove(tcp, (size_t)info.oldlenp, &oldlen) >= 0
 964                     && info.nlen >= 2
 965                     && ((name[0] == CTL_KERN
 966                          && (name[1] == KERN_OSRELEASE
 967                              || name[1] == KERN_OSTYPE
 968 #ifdef KERN_JAVA_INTERPRETER
 969                              || name[1] == KERN_JAVA_INTERPRETER
 970 #endif
 971 #ifdef KERN_JAVA_APPLETVIEWER
 972                              || name[1] == KERN_JAVA_APPLETVIEWER
 973 #endif
 974                                  )))) {
 975                         printpath(tcp, (size_t)info.oldval);
 976                         tprintf(", %Zu, ", oldlen);
 977                         if (info.newval == 0)
 978                                 tprints("NULL");
 979                         else if (syserror(tcp))
 980                                 tprintf("%p", info.newval);
 981                         else
 982                                 printpath(tcp, (size_t)info.newval);
 983                         tprintf(", %Zd", info.newlen);
 984                 } else {
 985                         tprintf("%p, %Zd, %p, %Zd", info.oldval, oldlen,
 986                                 info.newval, info.newlen);
 987                 }
 988                 tprints("}");
 989         }
 990
 991         free(name);
 992         return 0;
 993 }
 994
 995 #ifdef MIPS
 996
 997 #ifndef __NEW_UTS_LEN
 998 #define __NEW_UTS_LEN 64
 999 #endif
1000
1001 static const struct xlat sysmips_operations[] = {
1002         { SETNAME,              "SETNAME"       },
1003         { FLUSH_CACHE,          "FLUSH_CACHE"   },
1004         { MIPS_FIXADE,          "MIPS_FIXADE"   },
1005         { MIPS_RDNVRAM,         "MIPS_RDNVRAM"  },
1006         { MIPS_ATOMIC_SET,      "MIPS_ATOMIC_SET"       },
1007         { 0, NULL }
1008 };
1009
1010 int sys_sysmips(struct tcb *tcp)
1011 {
1012         if (entering(tcp)) {
1013                 printxval(sysmips_operations, tcp->u_arg[0], "???");
1014                 if (!verbose(tcp)) {
1015                         tprintf("%ld, %ld, %ld", tcp->u_arg[1], tcp->u_arg[2], tcp->u_arg[3]);
1016                 } else if (tcp->u_arg[0] == SETNAME) {
1017                         char nodename[__NEW_UTS_LEN + 1];
1018                         if (umovestr(tcp, tcp->u_arg[1], (__NEW_UTS_LEN + 1), nodename) < 0)
1019                                 tprintf(", %#lx", tcp->u_arg[1]);
1020                         else
1021                                 tprintf(", \"%.*s\"", (int)(__NEW_UTS_LEN + 1), nodename);
1022                 } else if (tcp->u_arg[0] == MIPS_ATOMIC_SET) {
1023                         tprintf(", %#lx, 0x%lx", tcp->u_arg[1], tcp->u_arg[2]);
1024                 } else if (tcp->u_arg[0] == MIPS_FIXADE) {
1025                         tprintf(", 0x%lx", tcp->u_arg[1]);
1026                 } else {
1027                         tprintf("%ld, %ld, %ld", tcp->u_arg[1], tcp->u_arg[2], tcp->u_arg[3]);
1028                 }
1029         }
1030
1031         return 0;
1032 }
1033
1034 #endif /* MIPS */