Dmitry V. Levin
e83e157021
Suppress repeated empty lines left after automated code removal. This change was made by filtering every source code file through "cat -s".
969 lines
26 KiB
C
969 lines
26 KiB
C
/*
|
|
* Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl>
|
|
* Copyright (c) 1993 Branko Lankester <branko@hacktic.nl>
|
|
* Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com>
|
|
* Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl>
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. The name of the author may not be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* $Id$
|
|
*/
|
|
|
|
#include "defs.h"
|
|
|
|
#define _LINUX_SOCKET_H
|
|
#define _LINUX_FS_H
|
|
|
|
#define MS_RDONLY 1 /* Mount read-only */
|
|
#define MS_NOSUID 2 /* Ignore suid and sgid bits */
|
|
#define MS_NODEV 4 /* Disallow access to device special files */
|
|
#define MS_NOEXEC 8 /* Disallow program execution */
|
|
#define MS_SYNCHRONOUS 16 /* Writes are synced at once */
|
|
#define MS_REMOUNT 32 /* Alter flags of a mounted FS */
|
|
#define MS_MANDLOCK 64 /* Allow mandatory locks on an FS */
|
|
#define MS_DIRSYNC 128 /* Directory modifications are synchronous */
|
|
#define MS_NOATIME 1024 /* Do not update access times. */
|
|
#define MS_NODIRATIME 2048 /* Do not update directory access times */
|
|
#define MS_BIND 4096
|
|
#define MS_MOVE 8192
|
|
#define MS_REC 16384
|
|
#define MS_SILENT 32768
|
|
#define MS_POSIXACL (1<<16) /* VFS does not apply the umask */
|
|
#define MS_UNBINDABLE (1<<17) /* change to unbindable */
|
|
#define MS_PRIVATE (1<<18) /* change to private */
|
|
#define MS_SLAVE (1<<19) /* change to slave */
|
|
#define MS_SHARED (1<<20) /* change to shared */
|
|
#define MS_RELATIME (1<<21)
|
|
#define MS_KERNMOUNT (1<<22)
|
|
#define MS_I_VERSION (1<<23)
|
|
#define MS_STRICTATIME (1<<24)
|
|
#define MS_BORN (1<<29)
|
|
#define MS_ACTIVE (1<<30)
|
|
#define MS_NOUSER (1<<31)
|
|
#define MS_MGC_VAL 0xc0ed0000 /* Magic flag number */
|
|
#define MS_MGC_MSK 0xffff0000 /* Magic flag mask */
|
|
|
|
#include <sys/socket.h>
|
|
#include <netinet/in.h>
|
|
#include <arpa/inet.h>
|
|
|
|
#include <sys/syscall.h>
|
|
|
|
#ifdef HAVE_LINUX_CAPABILITY_H
|
|
#include <linux/capability.h>
|
|
#endif
|
|
|
|
#ifdef HAVE_ASM_CACHECTL_H
|
|
#include <asm/cachectl.h>
|
|
#endif
|
|
|
|
#ifdef HAVE_LINUX_USTNAME_H
|
|
#include <linux/utsname.h>
|
|
#endif
|
|
|
|
#ifdef HAVE_ASM_SYSMIPS_H
|
|
#include <asm/sysmips.h>
|
|
#endif
|
|
|
|
#include <linux/sysctl.h>
|
|
|
|
static const struct xlat mount_flags[] = {
|
|
{ MS_MGC_VAL, "MS_MGC_VAL" },
|
|
{ MS_RDONLY, "MS_RDONLY" },
|
|
{ MS_NOSUID, "MS_NOSUID" },
|
|
{ MS_NODEV, "MS_NODEV" },
|
|
{ MS_NOEXEC, "MS_NOEXEC" },
|
|
{ MS_SYNCHRONOUS,"MS_SYNCHRONOUS"},
|
|
{ MS_REMOUNT, "MS_REMOUNT" },
|
|
{ MS_RELATIME, "MS_RELATIME" },
|
|
{ MS_KERNMOUNT, "MS_KERNMOUNT" },
|
|
{ MS_I_VERSION, "MS_I_VERSION" },
|
|
{ MS_STRICTATIME,"MS_STRICTATIME"},
|
|
{ MS_BORN, "MS_BORN" },
|
|
{ MS_MANDLOCK, "MS_MANDLOCK" },
|
|
{ MS_NOATIME, "MS_NOATIME" },
|
|
{ MS_NODIRATIME,"MS_NODIRATIME" },
|
|
{ MS_BIND, "MS_BIND" },
|
|
{ MS_MOVE, "MS_MOVE" },
|
|
{ MS_REC, "MS_REC" },
|
|
{ MS_SILENT, "MS_SILENT" },
|
|
{ MS_POSIXACL, "MS_POSIXACL" },
|
|
{ MS_UNBINDABLE,"MS_UNBINDABLE" },
|
|
{ MS_PRIVATE, "MS_PRIVATE" },
|
|
{ MS_SLAVE, "MS_SLAVE" },
|
|
{ MS_SHARED, "MS_SHARED" },
|
|
{ MS_ACTIVE, "MS_ACTIVE" },
|
|
{ MS_NOUSER, "MS_NOUSER" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
int
|
|
sys_mount(struct tcb *tcp)
|
|
{
|
|
if (entering(tcp)) {
|
|
int ignore_type = 0, ignore_data = 0;
|
|
unsigned long flags = tcp->u_arg[3];
|
|
|
|
/* Discard magic */
|
|
if ((flags & MS_MGC_MSK) == MS_MGC_VAL)
|
|
flags &= ~MS_MGC_MSK;
|
|
|
|
if (flags & MS_REMOUNT)
|
|
ignore_type = 1;
|
|
else if (flags & (MS_BIND | MS_MOVE))
|
|
ignore_type = ignore_data = 1;
|
|
|
|
printpath(tcp, tcp->u_arg[0]);
|
|
tprints(", ");
|
|
|
|
printpath(tcp, tcp->u_arg[1]);
|
|
tprints(", ");
|
|
|
|
if (ignore_type && tcp->u_arg[2])
|
|
tprintf("%#lx", tcp->u_arg[2]);
|
|
else
|
|
printstr(tcp, tcp->u_arg[2], -1);
|
|
tprints(", ");
|
|
|
|
printflags(mount_flags, tcp->u_arg[3], "MS_???");
|
|
tprints(", ");
|
|
|
|
if (ignore_data && tcp->u_arg[4])
|
|
tprintf("%#lx", tcp->u_arg[4]);
|
|
else
|
|
printstr(tcp, tcp->u_arg[4], -1);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#define MNT_FORCE 0x00000001 /* Attempt to forcibily umount */
|
|
#define MNT_DETACH 0x00000002 /* Just detach from the tree */
|
|
#define MNT_EXPIRE 0x00000004 /* Mark for expiry */
|
|
|
|
static const struct xlat umount_flags[] = {
|
|
{ MNT_FORCE, "MNT_FORCE" },
|
|
{ MNT_DETACH, "MNT_DETACH" },
|
|
{ MNT_EXPIRE, "MNT_EXPIRE" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
int
|
|
sys_umount2(struct tcb *tcp)
|
|
{
|
|
if (entering(tcp)) {
|
|
printstr(tcp, tcp->u_arg[0], -1);
|
|
tprints(", ");
|
|
printflags(umount_flags, tcp->u_arg[1], "MNT_???");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* These are not macros, but enums. We just copy the values by hand
|
|
from Linux 2.6.9 here. */
|
|
static const struct xlat personality_options[] = {
|
|
{ 0, "PER_LINUX" },
|
|
{ 0x00800000, "PER_LINUX_32BIT"},
|
|
{ 0x04100001, "PER_SVR4" },
|
|
{ 0x05000002, "PER_SVR3" },
|
|
{ 0x07000003, "PER_SCOSVR3" },
|
|
{ 0x06000003, "PER_OSR5" },
|
|
{ 0x05000004, "PER_WYSEV386" },
|
|
{ 0x04000005, "PER_ISCR4" },
|
|
{ 0x00000006, "PER_BSD" },
|
|
{ 0x04000006, "PER_SUNOS" },
|
|
{ 0x05000007, "PER_XENIX" },
|
|
{ 0x00000008, "PER_LINUX32" },
|
|
{ 0x08000008, "PER_LINUX32_3GB"},
|
|
{ 0x04000009, "PER_IRIX32" },
|
|
{ 0x0400000a, "PER_IRIXN32" },
|
|
{ 0x0400000b, "PER_IRIX64" },
|
|
{ 0x0000000c, "PER_RISCOS" },
|
|
{ 0x0400000d, "PER_SOLARIS" },
|
|
{ 0x0410000e, "PER_UW7" },
|
|
{ 0x0000000f, "PER_OSF4" },
|
|
{ 0x00000010, "PER_HPUX" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
int
|
|
sys_personality(struct tcb *tcp)
|
|
{
|
|
if (entering(tcp))
|
|
printxval(personality_options, tcp->u_arg[0], "PER_???");
|
|
return 0;
|
|
}
|
|
|
|
#include <linux/reboot.h>
|
|
static const struct xlat bootflags1[] = {
|
|
{ LINUX_REBOOT_MAGIC1, "LINUX_REBOOT_MAGIC1" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
static const struct xlat bootflags2[] = {
|
|
{ LINUX_REBOOT_MAGIC2, "LINUX_REBOOT_MAGIC2" },
|
|
{ LINUX_REBOOT_MAGIC2A, "LINUX_REBOOT_MAGIC2A" },
|
|
{ LINUX_REBOOT_MAGIC2B, "LINUX_REBOOT_MAGIC2B" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
static const struct xlat bootflags3[] = {
|
|
{ LINUX_REBOOT_CMD_CAD_OFF, "LINUX_REBOOT_CMD_CAD_OFF" },
|
|
{ LINUX_REBOOT_CMD_RESTART, "LINUX_REBOOT_CMD_RESTART" },
|
|
{ LINUX_REBOOT_CMD_HALT, "LINUX_REBOOT_CMD_HALT" },
|
|
{ LINUX_REBOOT_CMD_CAD_ON, "LINUX_REBOOT_CMD_CAD_ON" },
|
|
{ LINUX_REBOOT_CMD_POWER_OFF, "LINUX_REBOOT_CMD_POWER_OFF" },
|
|
{ LINUX_REBOOT_CMD_RESTART2, "LINUX_REBOOT_CMD_RESTART2" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
int
|
|
sys_reboot(struct tcb *tcp)
|
|
{
|
|
if (entering(tcp)) {
|
|
printflags(bootflags1, tcp->u_arg[0], "LINUX_REBOOT_MAGIC_???");
|
|
tprints(", ");
|
|
printflags(bootflags2, tcp->u_arg[1], "LINUX_REBOOT_MAGIC_???");
|
|
tprints(", ");
|
|
printflags(bootflags3, tcp->u_arg[2], "LINUX_REBOOT_CMD_???");
|
|
if (tcp->u_arg[2] == LINUX_REBOOT_CMD_RESTART2) {
|
|
tprints(", ");
|
|
printstr(tcp, tcp->u_arg[3], -1);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#ifdef M68K
|
|
static const struct xlat cacheflush_scope[] = {
|
|
#ifdef FLUSH_SCOPE_LINE
|
|
{ FLUSH_SCOPE_LINE, "FLUSH_SCOPE_LINE" },
|
|
#endif
|
|
#ifdef FLUSH_SCOPE_PAGE
|
|
{ FLUSH_SCOPE_PAGE, "FLUSH_SCOPE_PAGE" },
|
|
#endif
|
|
#ifdef FLUSH_SCOPE_ALL
|
|
{ FLUSH_SCOPE_ALL, "FLUSH_SCOPE_ALL" },
|
|
#endif
|
|
{ 0, NULL },
|
|
};
|
|
|
|
static const struct xlat cacheflush_flags[] = {
|
|
#ifdef FLUSH_CACHE_BOTH
|
|
{ FLUSH_CACHE_BOTH, "FLUSH_CACHE_BOTH" },
|
|
#endif
|
|
#ifdef FLUSH_CACHE_DATA
|
|
{ FLUSH_CACHE_DATA, "FLUSH_CACHE_DATA" },
|
|
#endif
|
|
#ifdef FLUSH_CACHE_INSN
|
|
{ FLUSH_CACHE_INSN, "FLUSH_CACHE_INSN" },
|
|
#endif
|
|
{ 0, NULL },
|
|
};
|
|
|
|
int
|
|
sys_cacheflush(struct tcb *tcp)
|
|
{
|
|
if (entering(tcp)) {
|
|
/* addr */
|
|
tprintf("%#lx, ", tcp->u_arg[0]);
|
|
/* scope */
|
|
printxval(cacheflush_scope, tcp->u_arg[1], "FLUSH_SCOPE_???");
|
|
tprints(", ");
|
|
/* flags */
|
|
printflags(cacheflush_flags, tcp->u_arg[2], "FLUSH_CACHE_???");
|
|
/* len */
|
|
tprintf(", %lu", tcp->u_arg[3]);
|
|
}
|
|
return 0;
|
|
}
|
|
#endif /* M68K */
|
|
|
|
#ifdef BFIN
|
|
|
|
#include <bfin_sram.h>
|
|
|
|
static const struct xlat sram_alloc_flags[] = {
|
|
{ L1_INST_SRAM, "L1_INST_SRAM" },
|
|
{ L1_DATA_A_SRAM, "L1_DATA_A_SRAM" },
|
|
{ L1_DATA_B_SRAM, "L1_DATA_B_SRAM" },
|
|
{ L1_DATA_SRAM, "L1_DATA_SRAM" },
|
|
{ L2_SRAM, "L2_SRAM" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
int
|
|
sys_sram_alloc(struct tcb *tcp)
|
|
{
|
|
if (entering(tcp)) {
|
|
/* size */
|
|
tprintf("%lu, ", tcp->u_arg[0]);
|
|
/* flags */
|
|
printxval(sram_alloc_flags, tcp->u_arg[1], "???_SRAM");
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
#include <asm/cachectl.h>
|
|
|
|
static const struct xlat cacheflush_flags[] = {
|
|
{ ICACHE, "ICACHE" },
|
|
{ DCACHE, "DCACHE" },
|
|
{ BCACHE, "BCACHE" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
int
|
|
sys_cacheflush(struct tcb *tcp)
|
|
{
|
|
if (entering(tcp)) {
|
|
/* start addr */
|
|
tprintf("%#lx, ", tcp->u_arg[0]);
|
|
/* length */
|
|
tprintf("%ld, ", tcp->u_arg[1]);
|
|
/* flags */
|
|
printxval(cacheflush_flags, tcp->u_arg[1], "?CACHE");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifdef SH
|
|
static const struct xlat cacheflush_flags[] = {
|
|
#ifdef CACHEFLUSH_D_INVAL
|
|
{ CACHEFLUSH_D_INVAL, "CACHEFLUSH_D_INVAL" },
|
|
#endif
|
|
#ifdef CACHEFLUSH_D_WB
|
|
{ CACHEFLUSH_D_WB, "CACHEFLUSH_D_WB" },
|
|
#endif
|
|
#ifdef CACHEFLUSH_D_PURGE
|
|
{ CACHEFLUSH_D_PURGE, "CACHEFLUSH_D_PURGE" },
|
|
#endif
|
|
#ifdef CACHEFLUSH_I
|
|
{ CACHEFLUSH_I, "CACHEFLUSH_I" },
|
|
#endif
|
|
{ 0, NULL },
|
|
};
|
|
|
|
int
|
|
sys_cacheflush(struct tcb *tcp)
|
|
{
|
|
if (entering(tcp)) {
|
|
/* addr */
|
|
tprintf("%#lx, ", tcp->u_arg[0]);
|
|
/* len */
|
|
tprintf("%lu, ", tcp->u_arg[1]);
|
|
/* flags */
|
|
printflags(cacheflush_flags, tcp->u_arg[2], "CACHEFLUSH_???");
|
|
}
|
|
return 0;
|
|
}
|
|
#endif /* SH */
|
|
|
|
#ifdef SYS_capget
|
|
|
|
static const struct xlat capabilities[] = {
|
|
{ 1<<CAP_CHOWN, "CAP_CHOWN" },
|
|
{ 1<<CAP_DAC_OVERRIDE, "CAP_DAC_OVERRIDE"},
|
|
{ 1<<CAP_DAC_READ_SEARCH,"CAP_DAC_READ_SEARCH"},
|
|
{ 1<<CAP_FOWNER, "CAP_FOWNER" },
|
|
{ 1<<CAP_FSETID, "CAP_FSETID" },
|
|
{ 1<<CAP_KILL, "CAP_KILL" },
|
|
{ 1<<CAP_SETGID, "CAP_SETGID" },
|
|
{ 1<<CAP_SETUID, "CAP_SETUID" },
|
|
{ 1<<CAP_SETPCAP, "CAP_SETPCAP" },
|
|
{ 1<<CAP_LINUX_IMMUTABLE,"CAP_LINUX_IMMUTABLE"},
|
|
{ 1<<CAP_NET_BIND_SERVICE,"CAP_NET_BIND_SERVICE"},
|
|
{ 1<<CAP_NET_BROADCAST, "CAP_NET_BROADCAST"},
|
|
{ 1<<CAP_NET_ADMIN, "CAP_NET_ADMIN" },
|
|
{ 1<<CAP_NET_RAW, "CAP_NET_RAW" },
|
|
{ 1<<CAP_IPC_LOCK, "CAP_IPC_LOCK" },
|
|
{ 1<<CAP_IPC_OWNER, "CAP_IPC_OWNER" },
|
|
{ 1<<CAP_SYS_MODULE, "CAP_SYS_MODULE"},
|
|
{ 1<<CAP_SYS_RAWIO, "CAP_SYS_RAWIO" },
|
|
{ 1<<CAP_SYS_CHROOT, "CAP_SYS_CHROOT"},
|
|
{ 1<<CAP_SYS_PTRACE, "CAP_SYS_PTRACE"},
|
|
{ 1<<CAP_SYS_PACCT, "CAP_SYS_PACCT" },
|
|
{ 1<<CAP_SYS_ADMIN, "CAP_SYS_ADMIN" },
|
|
{ 1<<CAP_SYS_BOOT, "CAP_SYS_BOOT" },
|
|
{ 1<<CAP_SYS_NICE, "CAP_SYS_NICE" },
|
|
{ 1<<CAP_SYS_RESOURCE, "CAP_SYS_RESOURCE"},
|
|
{ 1<<CAP_SYS_TIME, "CAP_SYS_TIME" },
|
|
{ 1<<CAP_SYS_TTY_CONFIG,"CAP_SYS_TTY_CONFIG"},
|
|
#ifdef CAP_MKNOD
|
|
{ 1<<CAP_MKNOD, "CAP_MKNOD" },
|
|
#endif
|
|
#ifdef CAP_LEASE
|
|
{ 1<<CAP_LEASE, "CAP_LEASE" },
|
|
#endif
|
|
#ifdef CAP_AUDIT_WRITE
|
|
{ 1<<CAP_AUDIT_WRITE, "CAP_AUDIT_WRITE"},
|
|
#endif
|
|
#ifdef CAP_AUDIT_CONTROL
|
|
{ 1<<CAP_AUDIT_CONTROL, "CAP_AUDIT_CONTROL"},
|
|
#endif
|
|
#ifdef CAP_SETFCAP
|
|
{ 1<<CAP_SETFCAP, "CAP_SETFCAP" },
|
|
#endif
|
|
{ 0, NULL },
|
|
};
|
|
|
|
int
|
|
sys_capget(struct tcb *tcp)
|
|
{
|
|
/* cap_user_ types are _pointers_ to (small) structs. */
|
|
/* Structs themselves have no names defined. */
|
|
/* Have to use ugly hack to place them on stack. */
|
|
cap_user_header_t arg0;
|
|
cap_user_data_t arg1;
|
|
long a0[sizeof(*arg0) / sizeof(long) + 1];
|
|
long a1[sizeof(*arg1) / sizeof(long) + 1];
|
|
arg0 = (cap_user_header_t) a0;
|
|
arg1 = (cap_user_data_t ) a1;
|
|
|
|
if (!entering(tcp)) {
|
|
if (!tcp->u_arg[0])
|
|
tprints("NULL");
|
|
else if (!verbose(tcp))
|
|
tprintf("%#lx", tcp->u_arg[0]);
|
|
else if (umoven(tcp, tcp->u_arg[0], sizeof(*arg0), (char *) arg0) < 0)
|
|
tprints("???");
|
|
else {
|
|
tprintf("%#x, %d", arg0->version, arg0->pid);
|
|
}
|
|
tprints(", ");
|
|
if (!tcp->u_arg[1])
|
|
tprints("NULL");
|
|
else if (!verbose(tcp))
|
|
tprintf("%#lx", tcp->u_arg[1]);
|
|
else if (umoven(tcp, tcp->u_arg[1], sizeof(*arg1), (char *) arg1) < 0)
|
|
tprints("???");
|
|
else {
|
|
tprints("{");
|
|
printflags(capabilities, arg1->effective, "CAP_???");
|
|
tprints(", ");
|
|
printflags(capabilities, arg1->permitted, "CAP_???");
|
|
tprints(", ");
|
|
printflags(capabilities, arg1->inheritable, "CAP_???");
|
|
tprints("}");
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
sys_capset(struct tcb *tcp)
|
|
{
|
|
cap_user_header_t arg0;
|
|
cap_user_data_t arg1;
|
|
long a0[sizeof(*arg0) / sizeof(long) + 1];
|
|
long a1[sizeof(*arg1) / sizeof(long) + 1];
|
|
arg0 = (cap_user_header_t) a0;
|
|
arg1 = (cap_user_data_t ) a1;
|
|
|
|
if (entering(tcp)) {
|
|
if (!tcp->u_arg[0])
|
|
tprints("NULL");
|
|
else if (!verbose(tcp))
|
|
tprintf("%#lx", tcp->u_arg[0]);
|
|
else if (umoven(tcp, tcp->u_arg[0], sizeof(*arg0), (char *) arg0) < 0)
|
|
tprints("???");
|
|
else {
|
|
tprintf("%#x, %d", arg0->version, arg0->pid);
|
|
}
|
|
tprints(", ");
|
|
if (!tcp->u_arg[1])
|
|
tprints("NULL");
|
|
else if (!verbose(tcp))
|
|
tprintf("%#lx", tcp->u_arg[1]);
|
|
else if (umoven(tcp, tcp->u_arg[1], sizeof(*arg1), (char *) arg1) < 0)
|
|
tprints("???");
|
|
else {
|
|
tprints("{");
|
|
printflags(capabilities, arg1->effective, "CAP_???");
|
|
tprints(", ");
|
|
printflags(capabilities, arg1->permitted, "CAP_???");
|
|
tprints(", ");
|
|
printflags(capabilities, arg1->inheritable, "CAP_???");
|
|
tprints("}");
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#else
|
|
|
|
int sys_capget(struct tcb *tcp)
|
|
{
|
|
return printargs(tcp);
|
|
}
|
|
|
|
int sys_capset(struct tcb *tcp)
|
|
{
|
|
return printargs(tcp);
|
|
}
|
|
|
|
#endif
|
|
|
|
/* Linux 2.6.18+ headers removed CTL_PROC enum. */
|
|
# define CTL_PROC 4
|
|
# define CTL_CPU 10 /* older headers lack */
|
|
static const struct xlat sysctl_root[] = {
|
|
{ CTL_KERN, "CTL_KERN" },
|
|
{ CTL_VM, "CTL_VM" },
|
|
{ CTL_NET, "CTL_NET" },
|
|
{ CTL_PROC, "CTL_PROC" },
|
|
{ CTL_FS, "CTL_FS" },
|
|
{ CTL_DEBUG, "CTL_DEBUG" },
|
|
{ CTL_DEV, "CTL_DEV" },
|
|
{ CTL_BUS, "CTL_BUS" },
|
|
{ CTL_ABI, "CTL_ABI" },
|
|
{ CTL_CPU, "CTL_CPU" },
|
|
{ 0, NULL }
|
|
};
|
|
|
|
static const struct xlat sysctl_kern[] = {
|
|
{ KERN_OSTYPE, "KERN_OSTYPE" },
|
|
{ KERN_OSRELEASE, "KERN_OSRELEASE" },
|
|
{ KERN_OSREV, "KERN_OSREV" },
|
|
{ KERN_VERSION, "KERN_VERSION" },
|
|
{ KERN_SECUREMASK, "KERN_SECUREMASK" },
|
|
{ KERN_PROF, "KERN_PROF" },
|
|
{ KERN_NODENAME, "KERN_NODENAME" },
|
|
{ KERN_DOMAINNAME, "KERN_DOMAINNAME" },
|
|
#ifdef KERN_SECURELVL
|
|
{ KERN_SECURELVL, "KERN_SECURELVL" },
|
|
#endif
|
|
{ KERN_PANIC, "KERN_PANIC" },
|
|
#ifdef KERN_REALROOTDEV
|
|
{ KERN_REALROOTDEV, "KERN_REALROOTDEV" },
|
|
#endif
|
|
#ifdef KERN_JAVA_INTERPRETER
|
|
{ KERN_JAVA_INTERPRETER, "KERN_JAVA_INTERPRETER" },
|
|
#endif
|
|
#ifdef KERN_JAVA_APPLETVIEWER
|
|
{ KERN_JAVA_APPLETVIEWER, "KERN_JAVA_APPLETVIEWER" },
|
|
#endif
|
|
{ KERN_SPARC_REBOOT, "KERN_SPARC_REBOOT" },
|
|
{ KERN_CTLALTDEL, "KERN_CTLALTDEL" },
|
|
{ KERN_PRINTK, "KERN_PRINTK" },
|
|
{ KERN_NAMETRANS, "KERN_NAMETRANS" },
|
|
{ KERN_PPC_HTABRECLAIM, "KERN_PPC_HTABRECLAIM" },
|
|
{ KERN_PPC_ZEROPAGED, "KERN_PPC_ZEROPAGED" },
|
|
{ KERN_PPC_POWERSAVE_NAP, "KERN_PPC_POWERSAVE_NAP" },
|
|
{ KERN_MODPROBE, "KERN_MODPROBE" },
|
|
{ KERN_SG_BIG_BUFF, "KERN_SG_BIG_BUFF" },
|
|
{ KERN_ACCT, "KERN_ACCT" },
|
|
{ KERN_PPC_L2CR, "KERN_PPC_L2CR" },
|
|
{ KERN_RTSIGNR, "KERN_RTSIGNR" },
|
|
{ KERN_RTSIGMAX, "KERN_RTSIGMAX" },
|
|
{ KERN_SHMMAX, "KERN_SHMMAX" },
|
|
{ KERN_MSGMAX, "KERN_MSGMAX" },
|
|
{ KERN_MSGMNB, "KERN_MSGMNB" },
|
|
{ KERN_MSGPOOL, "KERN_MSGPOOL" },
|
|
{ 0, NULL }
|
|
};
|
|
|
|
static const struct xlat sysctl_vm[] = {
|
|
#ifdef VM_SWAPCTL
|
|
{ VM_SWAPCTL, "VM_SWAPCTL" },
|
|
#endif
|
|
#ifdef VM_UNUSED1
|
|
{ VM_UNUSED1, "VM_UNUSED1" },
|
|
#endif
|
|
#ifdef VM_SWAPOUT
|
|
{ VM_SWAPOUT, "VM_SWAPOUT" },
|
|
#endif
|
|
#ifdef VM_UNUSED2
|
|
{ VM_UNUSED2, "VM_UNUSED2" },
|
|
#endif
|
|
#ifdef VM_FREEPG
|
|
{ VM_FREEPG, "VM_FREEPG" },
|
|
#endif
|
|
#ifdef VM_UNUSED3
|
|
{ VM_UNUSED3, "VM_UNUSED3" },
|
|
#endif
|
|
#ifdef VM_BDFLUSH
|
|
{ VM_BDFLUSH, "VM_BDFLUSH" },
|
|
#endif
|
|
#ifdef VM_UNUSED4
|
|
{ VM_UNUSED4, "VM_UNUSED4" },
|
|
#endif
|
|
{ VM_OVERCOMMIT_MEMORY, "VM_OVERCOMMIT_MEMORY" },
|
|
#ifdef VM_BUFFERMEM
|
|
{ VM_BUFFERMEM, "VM_BUFFERMEM" },
|
|
#endif
|
|
#ifdef VM_UNUSED5
|
|
{ VM_UNUSED5, "VM_UNUSED5" },
|
|
#endif
|
|
#ifdef VM_PAGECACHE
|
|
{ VM_PAGECACHE, "VM_PAGECACHE" },
|
|
#endif
|
|
#ifdef VM_UNUSED7
|
|
{ VM_UNUSED7, "VM_UNUSED7" },
|
|
#endif
|
|
#ifdef VM_PAGERDAEMON
|
|
{ VM_PAGERDAEMON, "VM_PAGERDAEMON" },
|
|
#endif
|
|
#ifdef VM_UNUSED8
|
|
{ VM_UNUSED8, "VM_UNUSED8" },
|
|
#endif
|
|
#ifdef VM_PGT_CACHE
|
|
{ VM_PGT_CACHE, "VM_PGT_CACHE" },
|
|
#endif
|
|
#ifdef VM_UNUSED9
|
|
{ VM_UNUSED9, "VM_UNUSED9" },
|
|
#endif
|
|
{ VM_PAGE_CLUSTER, "VM_PAGE_CLUSTER" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
static const struct xlat sysctl_net[] = {
|
|
{ NET_CORE, "NET_CORE" },
|
|
{ NET_ETHER, "NET_ETHER" },
|
|
{ NET_802, "NET_802" },
|
|
{ NET_UNIX, "NET_UNIX" },
|
|
{ NET_IPV4, "NET_IPV4" },
|
|
{ NET_IPX, "NET_IPX" },
|
|
{ NET_ATALK, "NET_ATALK" },
|
|
{ NET_NETROM, "NET_NETROM" },
|
|
{ NET_AX25, "NET_AX25" },
|
|
{ NET_BRIDGE, "NET_BRIDGE" },
|
|
{ NET_ROSE, "NET_ROSE" },
|
|
{ NET_IPV6, "NET_IPV6" },
|
|
{ NET_X25, "NET_X25" },
|
|
{ NET_TR, "NET_TR" },
|
|
{ NET_DECNET, "NET_DECNET" },
|
|
{ 0, NULL }
|
|
};
|
|
|
|
static const struct xlat sysctl_net_core[] = {
|
|
{ NET_CORE_WMEM_MAX, "NET_CORE_WMEM_MAX" },
|
|
{ NET_CORE_RMEM_MAX, "NET_CORE_RMEM_MAX" },
|
|
{ NET_CORE_WMEM_DEFAULT, "NET_CORE_WMEM_DEFAULT" },
|
|
{ NET_CORE_RMEM_DEFAULT, "NET_CORE_RMEM_DEFAULT" },
|
|
{ NET_CORE_MAX_BACKLOG, "NET_CORE_MAX_BACKLOG" },
|
|
{ NET_CORE_FASTROUTE, "NET_CORE_FASTROUTE" },
|
|
{ NET_CORE_MSG_COST, "NET_CORE_MSG_COST" },
|
|
{ NET_CORE_MSG_BURST, "NET_CORE_MSG_BURST" },
|
|
{ NET_CORE_OPTMEM_MAX, "NET_CORE_OPTMEM_MAX" },
|
|
{ 0, NULL }
|
|
};
|
|
|
|
static const struct xlat sysctl_net_unix[] = {
|
|
{ NET_UNIX_DESTROY_DELAY, "NET_UNIX_DESTROY_DELAY" },
|
|
{ NET_UNIX_DELETE_DELAY, "NET_UNIX_DELETE_DELAY" },
|
|
{ 0, NULL }
|
|
};
|
|
|
|
static const struct xlat sysctl_net_ipv4[] = {
|
|
{ NET_IPV4_FORWARD, "NET_IPV4_FORWARD" },
|
|
{ NET_IPV4_DYNADDR, "NET_IPV4_DYNADDR" },
|
|
{ NET_IPV4_CONF, "NET_IPV4_CONF" },
|
|
{ NET_IPV4_NEIGH, "NET_IPV4_NEIGH" },
|
|
{ NET_IPV4_ROUTE, "NET_IPV4_ROUTE" },
|
|
{ NET_IPV4_FIB_HASH, "NET_IPV4_FIB_HASH" },
|
|
{ NET_IPV4_TCP_TIMESTAMPS, "NET_IPV4_TCP_TIMESTAMPS" },
|
|
{ NET_IPV4_TCP_WINDOW_SCALING, "NET_IPV4_TCP_WINDOW_SCALING" },
|
|
{ NET_IPV4_TCP_SACK, "NET_IPV4_TCP_SACK" },
|
|
{ NET_IPV4_TCP_RETRANS_COLLAPSE, "NET_IPV4_TCP_RETRANS_COLLAPSE" },
|
|
{ NET_IPV4_DEFAULT_TTL, "NET_IPV4_DEFAULT_TTL" },
|
|
{ NET_IPV4_AUTOCONFIG, "NET_IPV4_AUTOCONFIG" },
|
|
{ NET_IPV4_NO_PMTU_DISC, "NET_IPV4_NO_PMTU_DISC" },
|
|
{ NET_IPV4_TCP_SYN_RETRIES, "NET_IPV4_TCP_SYN_RETRIES" },
|
|
{ NET_IPV4_IPFRAG_HIGH_THRESH, "NET_IPV4_IPFRAG_HIGH_THRESH" },
|
|
{ NET_IPV4_IPFRAG_LOW_THRESH, "NET_IPV4_IPFRAG_LOW_THRESH" },
|
|
{ NET_IPV4_IPFRAG_TIME, "NET_IPV4_IPFRAG_TIME" },
|
|
{ NET_IPV4_TCP_MAX_KA_PROBES, "NET_IPV4_TCP_MAX_KA_PROBES" },
|
|
{ NET_IPV4_TCP_KEEPALIVE_TIME, "NET_IPV4_TCP_KEEPALIVE_TIME" },
|
|
{ NET_IPV4_TCP_KEEPALIVE_PROBES, "NET_IPV4_TCP_KEEPALIVE_PROBES" },
|
|
{ NET_IPV4_TCP_RETRIES1, "NET_IPV4_TCP_RETRIES1" },
|
|
{ NET_IPV4_TCP_RETRIES2, "NET_IPV4_TCP_RETRIES2" },
|
|
{ NET_IPV4_TCP_FIN_TIMEOUT, "NET_IPV4_TCP_FIN_TIMEOUT" },
|
|
{ NET_IPV4_IP_MASQ_DEBUG, "NET_IPV4_IP_MASQ_DEBUG" },
|
|
{ NET_TCP_SYNCOOKIES, "NET_TCP_SYNCOOKIES" },
|
|
{ NET_TCP_STDURG, "NET_TCP_STDURG" },
|
|
{ NET_TCP_RFC1337, "NET_TCP_RFC1337" },
|
|
{ NET_TCP_SYN_TAILDROP, "NET_TCP_SYN_TAILDROP" },
|
|
{ NET_TCP_MAX_SYN_BACKLOG, "NET_TCP_MAX_SYN_BACKLOG" },
|
|
{ NET_IPV4_LOCAL_PORT_RANGE, "NET_IPV4_LOCAL_PORT_RANGE" },
|
|
{ NET_IPV4_ICMP_ECHO_IGNORE_ALL, "NET_IPV4_ICMP_ECHO_IGNORE_ALL" },
|
|
{ NET_IPV4_ICMP_ECHO_IGNORE_BROADCASTS, "NET_IPV4_ICMP_ECHO_IGNORE_BROADCASTS" },
|
|
{ NET_IPV4_ICMP_SOURCEQUENCH_RATE, "NET_IPV4_ICMP_SOURCEQUENCH_RATE" },
|
|
{ NET_IPV4_ICMP_DESTUNREACH_RATE, "NET_IPV4_ICMP_DESTUNREACH_RATE" },
|
|
{ NET_IPV4_ICMP_TIMEEXCEED_RATE, "NET_IPV4_ICMP_TIMEEXCEED_RATE" },
|
|
{ NET_IPV4_ICMP_PARAMPROB_RATE, "NET_IPV4_ICMP_PARAMPROB_RATE" },
|
|
{ NET_IPV4_ICMP_ECHOREPLY_RATE, "NET_IPV4_ICMP_ECHOREPLY_RATE" },
|
|
{ NET_IPV4_ICMP_IGNORE_BOGUS_ERROR_RESPONSES, "NET_IPV4_ICMP_IGNORE_BOGUS_ERROR_RESPONSES" },
|
|
{ NET_IPV4_IGMP_MAX_MEMBERSHIPS, "NET_IPV4_IGMP_MAX_MEMBERSHIPS" },
|
|
{ 0, NULL }
|
|
};
|
|
|
|
static const struct xlat sysctl_net_ipv4_route[] = {
|
|
{ NET_IPV4_ROUTE_FLUSH, "NET_IPV4_ROUTE_FLUSH" },
|
|
{ NET_IPV4_ROUTE_MIN_DELAY, "NET_IPV4_ROUTE_MIN_DELAY" },
|
|
{ NET_IPV4_ROUTE_MAX_DELAY, "NET_IPV4_ROUTE_MAX_DELAY" },
|
|
{ NET_IPV4_ROUTE_GC_THRESH, "NET_IPV4_ROUTE_GC_THRESH" },
|
|
{ NET_IPV4_ROUTE_MAX_SIZE, "NET_IPV4_ROUTE_MAX_SIZE" },
|
|
{ NET_IPV4_ROUTE_GC_MIN_INTERVAL, "NET_IPV4_ROUTE_GC_MIN_INTERVAL" },
|
|
{ NET_IPV4_ROUTE_GC_TIMEOUT, "NET_IPV4_ROUTE_GC_TIMEOUT" },
|
|
{ NET_IPV4_ROUTE_GC_INTERVAL, "NET_IPV4_ROUTE_GC_INTERVAL" },
|
|
{ NET_IPV4_ROUTE_REDIRECT_LOAD, "NET_IPV4_ROUTE_REDIRECT_LOAD" },
|
|
{ NET_IPV4_ROUTE_REDIRECT_NUMBER, "NET_IPV4_ROUTE_REDIRECT_NUMBER" },
|
|
{ NET_IPV4_ROUTE_REDIRECT_SILENCE, "NET_IPV4_ROUTE_REDIRECT_SILENCE" },
|
|
{ NET_IPV4_ROUTE_ERROR_COST, "NET_IPV4_ROUTE_ERROR_COST" },
|
|
{ NET_IPV4_ROUTE_ERROR_BURST, "NET_IPV4_ROUTE_ERROR_BURST" },
|
|
{ NET_IPV4_ROUTE_GC_ELASTICITY, "NET_IPV4_ROUTE_GC_ELASTICITY" },
|
|
{ 0, NULL }
|
|
};
|
|
|
|
static const struct xlat sysctl_net_ipv4_conf[] = {
|
|
{ NET_IPV4_CONF_FORWARDING, "NET_IPV4_CONF_FORWARDING" },
|
|
{ NET_IPV4_CONF_MC_FORWARDING, "NET_IPV4_CONF_MC_FORWARDING" },
|
|
{ NET_IPV4_CONF_PROXY_ARP, "NET_IPV4_CONF_PROXY_ARP" },
|
|
{ NET_IPV4_CONF_ACCEPT_REDIRECTS, "NET_IPV4_CONF_ACCEPT_REDIRECTS" },
|
|
{ NET_IPV4_CONF_SECURE_REDIRECTS, "NET_IPV4_CONF_SECURE_REDIRECTS" },
|
|
{ NET_IPV4_CONF_SEND_REDIRECTS, "NET_IPV4_CONF_SEND_REDIRECTS" },
|
|
{ NET_IPV4_CONF_SHARED_MEDIA, "NET_IPV4_CONF_SHARED_MEDIA" },
|
|
{ NET_IPV4_CONF_RP_FILTER, "NET_IPV4_CONF_RP_FILTER" },
|
|
{ NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE, "NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE" },
|
|
{ NET_IPV4_CONF_BOOTP_RELAY, "NET_IPV4_CONF_BOOTP_RELAY" },
|
|
{ NET_IPV4_CONF_LOG_MARTIANS, "NET_IPV4_CONF_LOG_MARTIANS" },
|
|
{ 0, NULL }
|
|
};
|
|
|
|
static const struct xlat sysctl_net_ipv6[] = {
|
|
{ NET_IPV6_CONF, "NET_IPV6_CONF" },
|
|
{ NET_IPV6_NEIGH, "NET_IPV6_NEIGH" },
|
|
{ NET_IPV6_ROUTE, "NET_IPV6_ROUTE" },
|
|
{ 0, NULL }
|
|
};
|
|
|
|
static const struct xlat sysctl_net_ipv6_route[] = {
|
|
{ NET_IPV6_ROUTE_FLUSH, "NET_IPV6_ROUTE_FLUSH" },
|
|
{ NET_IPV6_ROUTE_GC_THRESH, "NET_IPV6_ROUTE_GC_THRESH" },
|
|
{ NET_IPV6_ROUTE_MAX_SIZE, "NET_IPV6_ROUTE_MAX_SIZE" },
|
|
{ NET_IPV6_ROUTE_GC_MIN_INTERVAL, "NET_IPV6_ROUTE_GC_MIN_INTERVAL" },
|
|
{ NET_IPV6_ROUTE_GC_TIMEOUT, "NET_IPV6_ROUTE_GC_TIMEOUT" },
|
|
{ NET_IPV6_ROUTE_GC_INTERVAL, "NET_IPV6_ROUTE_GC_INTERVAL" },
|
|
{ NET_IPV6_ROUTE_GC_ELASTICITY, "NET_IPV6_ROUTE_GC_ELASTICITY" },
|
|
{ 0, NULL }
|
|
};
|
|
|
|
int
|
|
sys_sysctl(struct tcb *tcp)
|
|
{
|
|
struct __sysctl_args info;
|
|
int *name;
|
|
unsigned long size;
|
|
|
|
if (umove(tcp, tcp->u_arg[0], &info) < 0)
|
|
return printargs(tcp);
|
|
|
|
size = sizeof(int) * (unsigned long) info.nlen;
|
|
name = (size / sizeof(int) != info.nlen) ? NULL : malloc(size);
|
|
if (name == NULL ||
|
|
umoven(tcp, (unsigned long) info.name, size, (char *) name) < 0) {
|
|
free(name);
|
|
if (entering(tcp))
|
|
tprintf("{%p, %d, %p, %p, %p, %Zu}",
|
|
info.name, info.nlen, info.oldval,
|
|
info.oldlenp, info.newval, info.newlen);
|
|
return 0;
|
|
}
|
|
|
|
if (entering(tcp)) {
|
|
int cnt = 0, max_cnt;
|
|
|
|
tprints("{{");
|
|
|
|
if (info.nlen == 0)
|
|
goto out;
|
|
printxval(sysctl_root, name[0], "CTL_???");
|
|
++cnt;
|
|
|
|
if (info.nlen == 1)
|
|
goto out;
|
|
switch (name[0]) {
|
|
case CTL_KERN:
|
|
tprints(", ");
|
|
printxval(sysctl_kern, name[1], "KERN_???");
|
|
++cnt;
|
|
break;
|
|
case CTL_VM:
|
|
tprints(", ");
|
|
printxval(sysctl_vm, name[1], "VM_???");
|
|
++cnt;
|
|
break;
|
|
case CTL_NET:
|
|
tprints(", ");
|
|
printxval(sysctl_net, name[1], "NET_???");
|
|
++cnt;
|
|
|
|
if (info.nlen == 2)
|
|
goto out;
|
|
switch (name[1]) {
|
|
case NET_CORE:
|
|
tprints(", ");
|
|
printxval(sysctl_net_core, name[2],
|
|
"NET_CORE_???");
|
|
break;
|
|
case NET_UNIX:
|
|
tprints(", ");
|
|
printxval(sysctl_net_unix, name[2],
|
|
"NET_UNIX_???");
|
|
break;
|
|
case NET_IPV4:
|
|
tprints(", ");
|
|
printxval(sysctl_net_ipv4, name[2],
|
|
"NET_IPV4_???");
|
|
|
|
if (info.nlen == 3)
|
|
goto out;
|
|
switch (name[2]) {
|
|
case NET_IPV4_ROUTE:
|
|
tprints(", ");
|
|
printxval(sysctl_net_ipv4_route,
|
|
name[3],
|
|
"NET_IPV4_ROUTE_???");
|
|
break;
|
|
case NET_IPV4_CONF:
|
|
tprints(", ");
|
|
printxval(sysctl_net_ipv4_conf,
|
|
name[3],
|
|
"NET_IPV4_CONF_???");
|
|
break;
|
|
default:
|
|
goto out;
|
|
}
|
|
break;
|
|
case NET_IPV6:
|
|
tprints(", ");
|
|
printxval(sysctl_net_ipv6, name[2],
|
|
"NET_IPV6_???");
|
|
|
|
if (info.nlen == 3)
|
|
goto out;
|
|
switch (name[2]) {
|
|
case NET_IPV6_ROUTE:
|
|
tprints(", ");
|
|
printxval(sysctl_net_ipv6_route,
|
|
name[3],
|
|
"NET_IPV6_ROUTE_???");
|
|
break;
|
|
default:
|
|
goto out;
|
|
}
|
|
break;
|
|
default:
|
|
goto out;
|
|
}
|
|
break;
|
|
default:
|
|
goto out;
|
|
}
|
|
out:
|
|
max_cnt = info.nlen;
|
|
if (abbrev(tcp) && max_cnt > max_strlen)
|
|
max_cnt = max_strlen;
|
|
while (cnt < max_cnt)
|
|
tprintf(", %x", name[cnt++]);
|
|
if (cnt < info.nlen)
|
|
tprints(", ...");
|
|
tprintf("}, %d, ", info.nlen);
|
|
} else {
|
|
size_t oldlen;
|
|
if (umove(tcp, (size_t)info.oldlenp, &oldlen) >= 0
|
|
&& info.nlen >= 2
|
|
&& ((name[0] == CTL_KERN
|
|
&& (name[1] == KERN_OSRELEASE
|
|
|| name[1] == KERN_OSTYPE
|
|
#ifdef KERN_JAVA_INTERPRETER
|
|
|| name[1] == KERN_JAVA_INTERPRETER
|
|
#endif
|
|
#ifdef KERN_JAVA_APPLETVIEWER
|
|
|| name[1] == KERN_JAVA_APPLETVIEWER
|
|
#endif
|
|
)))) {
|
|
printpath(tcp, (size_t)info.oldval);
|
|
tprintf(", %Zu, ", oldlen);
|
|
if (info.newval == 0)
|
|
tprints("NULL");
|
|
else if (syserror(tcp))
|
|
tprintf("%p", info.newval);
|
|
else
|
|
printpath(tcp, (size_t)info.newval);
|
|
tprintf(", %Zd", info.newlen);
|
|
} else {
|
|
tprintf("%p, %Zd, %p, %Zd", info.oldval, oldlen,
|
|
info.newval, info.newlen);
|
|
}
|
|
tprints("}");
|
|
}
|
|
|
|
free(name);
|
|
return 0;
|
|
}
|
|
|
|
#ifdef MIPS
|
|
|
|
#ifndef __NEW_UTS_LEN
|
|
#define __NEW_UTS_LEN 64
|
|
#endif
|
|
|
|
static const struct xlat sysmips_operations[] = {
|
|
{ SETNAME, "SETNAME" },
|
|
{ FLUSH_CACHE, "FLUSH_CACHE" },
|
|
{ MIPS_FIXADE, "MIPS_FIXADE" },
|
|
{ MIPS_RDNVRAM, "MIPS_RDNVRAM" },
|
|
{ MIPS_ATOMIC_SET, "MIPS_ATOMIC_SET" },
|
|
{ 0, NULL }
|
|
};
|
|
|
|
int sys_sysmips(struct tcb *tcp)
|
|
{
|
|
if (entering(tcp)) {
|
|
printxval(sysmips_operations, tcp->u_arg[0], "???");
|
|
if (!verbose(tcp)) {
|
|
tprintf("%ld, %ld, %ld", tcp->u_arg[1], tcp->u_arg[2], tcp->u_arg[3]);
|
|
} else if (tcp->u_arg[0] == SETNAME) {
|
|
char nodename[__NEW_UTS_LEN + 1];
|
|
if (umovestr(tcp, tcp->u_arg[1], (__NEW_UTS_LEN + 1), nodename) < 0)
|
|
tprintf(", %#lx", tcp->u_arg[1]);
|
|
else
|
|
tprintf(", \"%.*s\"", (int)(__NEW_UTS_LEN + 1), nodename);
|
|
} else if (tcp->u_arg[0] == MIPS_ATOMIC_SET) {
|
|
tprintf(", %#lx, 0x%lx", tcp->u_arg[1], tcp->u_arg[2]);
|
|
} else if (tcp->u_arg[0] == MIPS_FIXADE) {
|
|
tprintf(", 0x%lx", tcp->u_arg[1]);
|
|
} else {
|
|
tprintf("%ld, %ld, %ld", tcp->u_arg[1], tcp->u_arg[2], tcp->u_arg[3]);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#endif /* MIPS */
|