* bjm.c: Replace tprintf("str") with tprints("str").
* block.c: Likewise.
* desc.c: Likewise.
* file.c: Likewise.
* io.c: Likewise.
* ipc.c: Likewise.
* mem.c: Likewise.
* net.c: Likewise.
* proc.c: Likewise.
* process.c: Likewise.
* quota.c: Likewise.
* resource.c: Likewise.
* scsi.c: Likewise.
* signal.c: Likewise.
* sock.c: Likewise.
* strace.c: Likewise.
* stream.c: Likewise.
* syscall.c: Likewise.
* system.c: Likewise.
* term.c: Likewise.
* time.c: Likewise.
* util.c: Likewise.
Signed-off-by: Denys Vlasenko <dvlasenk@redhat.com>
{
if (entering(tcp)) {
printstr(tcp, tcp->u_arg[0], -1);
- tprintf(", ");
+ tprints(", ");
printxval(which, tcp->u_arg[1], "QM_???");
- tprintf(", ");
+ tprints(", ");
} else {
size_t ret;
} else if ((tcp->u_arg[1]==QM_MODULES) ||
(tcp->u_arg[1]==QM_DEPS) ||
(tcp->u_arg[1]==QM_REFS)) {
- tprintf("{");
+ tprints("{");
if (!abbrev(tcp)) {
char* data = malloc(tcp->u_arg[3]);
char* mod = data;
tprintf(" /* %Zu entries */ ", ret);
tprintf("}, %Zu", ret);
} else if (tcp->u_arg[1]==QM_SYMBOLS) {
- tprintf("{");
+ tprints("{");
if (!abbrev(tcp)) {
char* data = malloc(tcp->u_arg[3]);
struct module_symbol* sym = (struct module_symbol*)data;
{
struct blkpg_partition p;
- tprintf("{");
+ tprints("{");
printxval(blkpg_ops, blkpg->op, "BLKPG_???");
tprintf(", flags=%d, datalen=%d, ",
if (umove(tcp, arg, &blkpg) < 0)
tprintf(", %#lx", arg);
else {
- tprintf(", ");
+ tprints(", ");
print_blkpg_req(tcp, &blkpg);
}
}
int32_t l_pid; /* pid_t */
} fl32;
if (umove(tcp, addr, &fl32) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
fl.l_type = fl32.l_type;
#endif
{
if (umove(tcp, addr, &fl) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
}
- tprintf("{type=");
+ tprints("{type=");
printxval(lockfcmds, fl.l_type, "F_???");
- tprintf(", whence=");
+ tprints(", whence=");
printxval(whence, fl.l_whence, "SEEK_???");
tprintf(", start=%ld, len=%ld", fl.l_start, fl.l_len);
if (getlk)
tprintf(", pid=%lu}", (unsigned long) fl.l_pid);
else
- tprintf("}");
+ tprints("}");
}
#endif
struct flock64 fl;
if (umove(tcp, addr, &fl) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
- tprintf("{type=");
+ tprints("{type=");
printxval(lockfcmds, fl.l_type, "F_???");
- tprintf(", whence=");
+ tprints(", whence=");
printxval(whence, fl.l_whence, "SEEK_???");
tprintf(", start=%lld, len=%lld", (long long) fl.l_start, (long long) fl.l_len);
if (getlk)
tprintf(", pid=%lu}", (unsigned long) fl.l_pid);
else
- tprintf("}");
+ tprints("}");
}
#endif
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printxval(fcntlcmds, tcp->u_arg[1], "F_???");
switch (tcp->u_arg[1]) {
case F_SETFD:
- tprintf(", ");
+ tprints(", ");
printflags(fdflags, tcp->u_arg[2], "FD_???");
break;
case F_SETOWN: case F_DUPFD:
tprintf(", %ld", tcp->u_arg[2]);
break;
case F_SETFL:
- tprintf(", ");
+ tprints(", ");
tprint_open_modes(tcp->u_arg[2]);
break;
case F_SETLK: case F_SETLKW:
#ifdef F_FREESP
case F_FREESP:
#endif
- tprintf(", ");
+ tprints(", ");
printflock(tcp, tcp->u_arg[2], 0);
break;
#if _LFS64_LARGEFILE
#if defined(F_SETLKW64) && F_SETLKW64 + 0 != F_SETLKW
case F_SETLKW64:
#endif
- tprintf(", ");
+ tprints(", ");
printflock64(tcp, tcp->u_arg[2], 0);
break;
#endif
#ifdef F_NOTIFY
case F_NOTIFY:
- tprintf(", ");
+ tprints(", ");
printflags(notifyflags, tcp->u_arg[2], "DN_???");
break;
#endif
#ifdef F_SETLEASE
case F_SETLEASE:
- tprintf(", ");
+ tprints(", ");
printxval(lockfcmds, tcp->u_arg[2], "F_???");
break;
#endif
tcp->auxstr = sprint_open_modes(tcp->u_rval);
return RVAL_HEX|RVAL_STR;
case F_GETLK:
- tprintf(", ");
+ tprints(", ");
printflock(tcp, tcp->u_arg[2], 1);
break;
#if _LFS64_LARGEFILE
#if defined(F_GETLK64) && F_GETLK64+0 != F_GETLK
case F_GETLK64:
#endif
- tprintf(", ");
+ tprints(", ");
printflock64(tcp, tcp->u_arg[2], 1);
break;
#endif
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printflags(flockcmds, tcp->u_arg[1], "LOCK_???");
}
return 0;
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printfd(tcp, tcp->u_arg[1]);
if (flags_arg >= 0) {
- tprintf(", ");
+ tprints(", ");
printflags(open_mode_flags, tcp->u_arg[flags_arg], "O_???");
}
}
for (i = 0; i < 3; i++) {
arg = args[i+1];
if (arg == 0) {
- tprintf(", NULL");
+ tprints(", NULL");
continue;
}
if (!verbose(tcp)) {
continue;
}
if (umoven(tcp, arg, fdsize, (char *) fds) < 0) {
- tprintf(", [?]");
+ tprints(", [?]");
continue;
}
- tprintf(", [");
+ tprints(", [");
for (j = 0, sep = ""; j < nfds; j++) {
if (FD_ISSET(j, fds)) {
tprints(sep);
sep = " ";
}
}
- tprintf("]");
+ tprints("]");
}
free(fds);
- tprintf(", ");
+ tprints(", ");
printtv_bitness(tcp, args[4], bitness, 0);
}
else {
long args[5];
if (umoven(tcp, tcp->u_arg[0], sizeof args, (char *) args) < 0) {
- tprintf("[...]");
+ tprints("[...]");
return 0;
}
return decode_select(tcp, args, BITNESS_CURRENT);
static void
print_epoll_event(struct epoll_event *ev)
{
- tprintf("{");
+ tprints("{");
printflags(epollevents, ev->events, "EPOLL???");
/* We cannot know what format the program uses, so print u32 and u64
which will cover every value. */
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printxval(epollctls, tcp->u_arg[1], "EPOLL_CTL_???");
- tprintf(", ");
+ tprints(", ");
printfd(tcp, tcp->u_arg[2]);
- tprintf(", ");
+ tprints(", ");
if (tcp->u_arg[3] == 0)
- tprintf("NULL");
+ tprints("NULL");
else {
#ifdef HAVE_SYS_EPOLL_H
struct epoll_event ev;
print_epoll_event(&ev);
else
#endif
- tprintf("{...}");
+ tprints("{...}");
}
}
return 0;
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
if (syserror(tcp))
tprintf("%lx", tcp->u_arg[1]);
else if (tcp->u_rval == 0)
- tprintf("{}");
+ tprints("{}");
else {
#ifdef HAVE_SYS_EPOLL_H
struct epoll_event ev, *start, *cur, *end;
int failed = 0;
- tprintf("{");
+ tprints("{");
start = (struct epoll_event *) tcp->u_arg[1];
end = start + tcp->u_rval;
for (cur = start; cur < end; ++cur) {
if (cur > start)
- tprintf(", ");
+ tprints(", ");
if (umove(tcp, (long) cur, &ev) == 0)
print_epoll_event(&ev);
else {
- tprintf("?");
+ tprints("?");
failed = 1;
break;
}
}
- tprintf("}");
+ tprints("}");
if (failed)
tprintf(" %#lx", (long) start);
#else
- tprintf("{...}");
+ tprints("{...}");
#endif
}
tprintf(", %ld, %ld", tcp->u_arg[2], tcp->u_arg[3]);
{
epoll_wait_common(tcp);
if (exiting(tcp)) {
- tprintf(", ");
+ tprints(", ");
print_sigset(tcp, tcp->u_arg[4], 0);
}
return 0;
if (umove(tcp, tcp->u_arg[1], &user_id) == 0)
tprintf("{%lu}", user_id);
else
- tprintf("{...}");
+ tprints("{...}");
}
}
return 0;
nr = tcp->u_arg[1];
/* and if nr is negative? */
if (nr == 0)
- tprintf("{}");
+ tprints("{}");
else {
#ifdef HAVE_LIBAIO_H
long i;
enum iocb_sub sub;
struct iocb iocb;
if (i == 0)
- tprintf("{");
+ tprints("{");
else
- tprintf(", ");
+ tprints(", ");
if (umove(tcp, (unsigned long)iocbs, &iocbp) ||
umove(tcp, (unsigned long)iocbp, &iocb)) {
- tprintf("{...}");
+ tprints("{...}");
continue;
}
- tprintf("{");
+ tprints("{");
if (iocb.data)
tprintf("data:%p, ", iocb.data);
if (iocb.key)
switch (sub) {
case SUB_COMMON:
if (iocb.aio_lio_opcode == IO_CMD_PWRITE) {
- tprintf(", str:");
+ tprints(", str:");
printstr(tcp, (unsigned long)iocb.u.c.buf,
iocb.u.c.nbytes);
} else {
case SUB_NONE:
break;
}
- tprintf("}");
+ tprints("}");
}
if (i)
- tprintf("}");
+ tprints("}");
#else
#warning "libaio-devel is not available => no io_submit decoding"
tprintf("%#lx", tcp->u_arg[2]);
iocb.aio_reqprio, iocb.aio_fildes);
} else
#endif
- tprintf("{...}, ");
+ tprints("{...}, ");
} else {
if (tcp->u_rval < 0)
- tprintf("{...}");
+ tprints("{...}");
else {
#ifdef HAVE_LIBAIO_H
struct io_event event;
event.res, event.res2);
else
#endif
- tprintf("{...}");
+ tprints("{...}");
}
}
return 0;
tcp->u_arg[2]);
} else {
if (tcp->u_rval == 0) {
- tprintf("{}");
+ tprints("{}");
} else {
#ifdef HAVE_LIBAIO_H
struct io_event *events = (void *)tcp->u_arg[3];
struct io_event event;
if (i == 0)
- tprintf("{");
+ tprints("{");
else
- tprintf(", ");
+ tprints(", ");
if (umove(tcp, (unsigned long)events, &event) != 0) {
- tprintf("{...}");
+ tprints("{...}");
continue;
}
tprintf("{%p, %p, %ld, %ld}", event.data,
event.obj, event.res, event.res2);
}
- tprintf("}, ");
+ tprints("}, ");
#else
- tprintf("{...}");
+ tprints("{...}");
#endif
}
if (umove(tcp, tcp->u_arg[5], &data) < 0)
tprintf(", %#lx", tcp->u_arg[5]);
else {
- tprintf(", {");
+ tprints(", {");
if (data.len < sizeof(long))
tprintf("%#lx", (long)data.ss);
else
if (entering(tcp)) {
tprintf("%lu", tcp->u_arg[0]);
if (flags_arg >= 0) {
- tprintf(", ");
+ tprints(", ");
printflags(open_mode_flags, tcp->u_arg[flags_arg], "O_???");
}
}
print_dirfd(struct tcb *tcp, int fd)
{
if (fd == AT_FDCWD)
- tprintf("AT_FDCWD, ");
+ tprints("AT_FDCWD, ");
else {
printfd(tcp, fd);
- tprintf(", ");
+ tprints(", ");
}
}
#endif
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[offset]);
- tprintf(", ");
+ tprints(", ");
/* flags */
tprint_open_modes(tcp->u_arg[offset + 1]);
if (tcp->u_arg[offset + 1] & O_CREAT) {
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
/* flags */
printflags(openmodessol, tcp->u_arg[1] + 1, "O_???");
if (tcp->u_arg[1] & 0x100) {
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[offset]);
- tprintf(", ");
+ tprints(", ");
printflags(access_flags, tcp->u_arg[offset + 1], "?_OK");
}
return 0;
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
offset = tcp->ext_arg[1];
_whence = tcp->u_arg[2];
if (_whence == SEEK_SET)
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
offset = tcp->u_arg[1];
_whence = tcp->u_arg[2];
if (_whence == SEEK_SET)
if (entering(tcp)) {
int argn;
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
argn = printllval(tcp, "%lld", 1);
tprintf(", %ld", tcp->u_arg[argn]);
}
if (entering(tcp)) {
int argn;
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
if (tcp->u_arg[3] == SEEK_SET)
argn = printllval(tcp, "%llu, ", 1);
else
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printllval(tcp, "%llu", 1);
}
return 0;
struct solstat statbuf;
if (umove(tcp, addr, &statbuf) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
if (!abbrev(tcp)) {
tprintf("st_ctime=%s}", sprinttime(statbuf.st_ctime.tv_sec));
}
else
- tprintf("...}");
+ tprints("...}");
}
#if defined (SPARC64)
struct stat_sparc64 statbuf;
if (umove(tcp, addr, &statbuf) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
tprintf("st_atime=%s, ", sprinttime(statbuf.st_atime));
tprintf("st_mtime=%s, ", sprinttime(statbuf.st_mtime));
tprintf("st_ctime=%s", sprinttime(statbuf.st_ctime));
- tprintf("}");
+ tprints("}");
}
else
- tprintf("...}");
+ tprints("...}");
}
#endif /* SPARC64 */
#endif /* LINUXSPARC */
struct stat_powerpc32 statbuf;
if (umove(tcp, addr, &statbuf) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
tprintf("st_atime=%s, ", sprinttime(statbuf.st_atime));
tprintf("st_mtime=%s, ", sprinttime(statbuf.st_mtime));
tprintf("st_ctime=%s", sprinttime(statbuf.st_ctime));
- tprintf("}");
+ tprints("}");
}
else
- tprintf("...}");
+ tprints("...}");
}
#endif /* LINUX && POWERPC64 */
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printflags(fileflags, tcp->u_arg[1], "UF_???");
}
return 0;
tprintf("st_mtime=%s, ", sprinttime(statbuf->st_mtime));
tprintf("st_ctime=%s", sprinttime(statbuf->st_ctime));
#if HAVE_STRUCT_STAT_ST_FLAGS
- tprintf(", st_flags=");
+ tprints(", st_flags=");
printflags(fileflags, statbuf->st_flags, "UF_???");
#endif
#if HAVE_STRUCT_STAT_ST_ACLCNT
#if HAVE_STRUCT_STAT_ST_GEN
tprintf(", st_gen=%u", statbuf->st_gen);
#endif
- tprintf("}");
+ tprints("}");
}
else
- tprintf("...}");
+ tprints("...}");
}
struct stat statbuf;
if (!addr) {
- tprintf("NULL");
+ tprints("NULL");
return;
}
if (syserror(tcp) || !verbose(tcp)) {
#endif
if (umove(tcp, addr, &statbuf) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
#endif
if (!addr) {
- tprintf("NULL");
+ tprints("NULL");
return;
}
if (syserror(tcp) || !verbose(tcp)) {
#endif
if (umove(tcp, addr, &statbuf) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
tprintf("st_mtime=%s, ", sprinttime(statbuf.st_mtime));
tprintf("st_ctime=%s", sprinttime(statbuf.st_ctime));
#if HAVE_STRUCT_STAT_ST_FLAGS
- tprintf(", st_flags=");
+ tprints(", st_flags=");
printflags(fileflags, statbuf.st_flags, "UF_???");
#endif
#if HAVE_STRUCT_STAT_ST_ACLCNT
#if HAVE_STRUCT_STAT_ST_GEN
tprintf(", st_gen=%u", statbuf.st_gen);
#endif
- tprintf("}");
+ tprints("}");
}
else
- tprintf("...}");
+ tprints("...}");
}
#endif /* HAVE_STAT64 */
struct stat newstatbuf;
if (!addr) {
- tprintf("NULL");
+ tprints("NULL");
return;
}
if (syserror(tcp) || !verbose(tcp)) {
#endif /* LINUXSPARC */
if (umove(tcp, addr, &statbuf) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printstat(tcp, tcp->u_arg[1]);
}
#ifdef HAVE_STAT64
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printstat64(tcp, tcp->u_arg[1]);
}
if (entering(tcp)) {
print_dirfd(tcp, tcp->u_arg[0]);
printpath(tcp, tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
} else {
#ifdef POWERPC64
if (current_personality == 0)
#else
printstat(tcp, tcp->u_arg[2]);
#endif
- tprintf(", ");
+ tprints(", ");
printflags(fstatatflags, tcp->u_arg[3], "AT_???");
}
return 0;
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printoldstat(tcp, tcp->u_arg[1]);
}
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printstat(tcp, tcp->u_arg[1]);
}
#ifdef HAVE_STAT64
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printstat64(tcp, tcp->u_arg[1]);
}
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printoldstat(tcp, tcp->u_arg[1]);
}
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printstat(tcp, tcp->u_arg[1]);
}
#ifdef HAVE_STAT64
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printstat64(tcp, tcp->u_arg[1]);
}
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printoldstat(tcp, tcp->u_arg[1]);
}
if (entering(tcp)) {
tprintf("%ld, ", tcp->u_arg[0]);
printpath(tcp, tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
} else {
#ifdef _STAT64_VER
if (tcp->u_arg[0] == _STAT64_VER)
if (entering(tcp)) {
tprintf("%ld, ", tcp->u_arg[0]);
printpath(tcp, tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
} else {
#ifdef _STAT64_VER
if (tcp->u_arg[0] == _STAT64_VER)
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printxval(aclcmds, tcp->u_arg[1], "???ACL???");
tprintf(", %ld", tcp->u_arg[2]);
/*
if (tcp->u_arg[3])
tprintf(", %#lx", tcp->u_arg[3]);
else
- tprintf(", NULL");
+ tprints(", NULL");
}
return 0;
}
if (tcp->u_arg[3])
tprintf(", %#lx", tcp->u_arg[3]);
else
- tprintf(", NULL");
+ tprints(", NULL");
}
return 0;
}
if (tcp->u_arg[4])
tprintf(", %#lx", tcp->u_arg[4]);
else
- tprintf(", NULL");
+ tprints(", NULL");
}
return 0;
}
return;
}
if (umove(tcp, addr, &statbuf) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
#ifdef ALPHA
#ifdef _STATFS_F_FRSIZE
tprintf(", f_frsize=%lu", (unsigned long)statbuf.f_frsize);
#endif
- tprintf("}");
+ tprints("}");
}
int
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printstatfs(tcp, tcp->u_arg[1]);
}
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printstatfs(tcp, tcp->u_arg[1]);
}
return;
}
if (umove(tcp, addr, &statbuf) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
tprintf("{f_type=%s, f_bsize=%llu, f_blocks=%llu, f_bfree=%llu, ",
#ifdef _STATFS_F_FRSIZE
tprintf(", f_frsize=%llu", (unsigned long long)statbuf.f_frsize);
#endif
- tprintf("}");
+ tprints("}");
}
int
if (tcp->u_arg[1] == sizeof(struct statfs64))
printstatfs64(tcp, tcp->u_arg[2]);
else
- tprintf("{???}");
+ tprints("{???}");
}
return 0;
}
if (tcp->u_arg[1] == sizeof(struct statfs64))
printstatfs64(tcp, tcp->u_arg[2]);
else
- tprintf("{???}");
+ tprints("{???}");
}
return 0;
}
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printstatfs(tcp, tcp->u_arg[1]);
tprintf(", %lu", tcp->u_arg[2]);
if (syserror(tcp) || !verbose(tcp))
tprintf("%#lx", tcp->u_arg[1]);
else if (umove(tcp, tcp->u_arg[1], &statbuf) < 0)
- tprintf("{...}");
+ tprints("{...}");
else {
tprintf("{f_tfree=%lu, f_tinode=%lu, ",
statbuf.f_tfree, statbuf.f_tinode);
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printpath(tcp, tcp->u_arg[1]);
}
return 0;
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printpath(tcp, tcp->u_arg[1]);
}
return 0;
if (entering(tcp)) {
print_dirfd(tcp, tcp->u_arg[0]);
printpath(tcp, tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
print_dirfd(tcp, tcp->u_arg[2]);
printpath(tcp, tcp->u_arg[3]);
- tprintf(", ");
+ tprints(", ");
printfd(tcp, tcp->u_arg[4]);
}
return 0;
if (entering(tcp)) {
print_dirfd(tcp, tcp->u_arg[0]);
printpath(tcp, tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
printflags(unlinkatflags, tcp->u_arg[2], "AT_???");
}
return 0;
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printpath(tcp, tcp->u_arg[1]);
}
return 0;
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
print_dirfd(tcp, tcp->u_arg[1]);
printpath(tcp, tcp->u_arg[2]);
}
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[offset]);
- tprintf(", ");
+ tprints(", ");
} else {
if (syserror(tcp))
tprintf("%#lx", tcp->u_arg[offset + 1]);
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printpath(tcp, tcp->u_arg[1]);
}
return 0;
if (entering(tcp)) {
print_dirfd(tcp, tcp->u_arg[0]);
printpath(tcp, tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
print_dirfd(tcp, tcp->u_arg[2]);
printpath(tcp, tcp->u_arg[3]);
}
printpath(tcp, tcp->u_arg[1]);
printuid(", ", tcp->u_arg[2]);
printuid(", ", tcp->u_arg[3]);
- tprintf(", ");
+ tprints(", ");
printflags(fstatatflags, tcp->u_arg[4], "AT_???");
}
return 0;
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printtv_bitness(tcp, tcp->u_arg[1], BITNESS_32, 0);
}
return 0;
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[offset]);
- tprintf(", ");
+ tprints(", ");
if (tcp->u_arg[offset + 1] == 0)
- tprintf("NULL");
+ tprints("NULL");
else {
- tprintf("{");
+ tprints("{");
printtv_bitness(tcp, tcp->u_arg[offset + 1],
BITNESS_CURRENT, special);
- tprintf(", ");
+ tprints(", ");
printtv_bitness(tcp, tcp->u_arg[offset + 1]
+ sizeof(struct timeval),
BITNESS_CURRENT, special);
- tprintf("}");
+ tprints("}");
}
}
return 0;
if (entering(tcp)) {
print_dirfd(tcp, tcp->u_arg[0]);
decode_utimes(tcp, 1, 1);
- tprintf(", ");
+ tprints(", ");
printflags(utimensatflags, tcp->u_arg[3], "AT_???");
}
return 0;
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
if (!tcp->u_arg[1])
- tprintf("NULL");
+ tprints("NULL");
else if (!verbose(tcp))
tprintf("%#lx", tcp->u_arg[1]);
else if (umoven(tcp, tcp->u_arg[1],
2 * personality_wordsize[current_personality],
(char *) &u) < 0)
- tprintf("[?, ?]");
+ tprints("[?, ?]");
else if (personality_wordsize[current_personality]
== sizeof u.utl[0]) {
tprintf("[%s,", sprinttime(u.utl[0]));
return;
}
if (umove(tcp, addr, &d) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
tprintf("{d_ino=%ld, ", (unsigned long) d.d_ino);
- tprintf("d_name=");
+ tprints("d_name=");
printpathn(tcp, (long) ((struct dirent *) addr)->d_name, d.d_reclen);
- tprintf("}");
+ tprints("}");
}
int
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
if (syserror(tcp) || tcp->u_rval == 0 || !verbose(tcp))
tprintf("%#lx", tcp->u_arg[1]);
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
return 0;
}
if (syserror(tcp) || !verbose(tcp)) {
return 0;
}
if (!abbrev(tcp))
- tprintf("{");
+ tprints("{");
for (i = 0; i < len;) {
struct kernel_dirent *d = (struct kernel_dirent *) &buf[i];
#ifdef LINUX
}
#endif /* FREEBSD */
if (!d->d_reclen) {
- tprintf("/* d_reclen == 0, problem here */");
+ tprints("/* d_reclen == 0, problem here */");
break;
}
i += d->d_reclen;
dents++;
}
if (!abbrev(tcp))
- tprintf("}");
+ tprints("}");
else
tprintf("/* %u entries */", dents);
tprintf(", %lu", tcp->u_arg[2]);
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
return 0;
}
if (syserror(tcp) || !verbose(tcp)) {
return 0;
}
if (!abbrev(tcp))
- tprintf("{");
+ tprints("{");
for (i = 0; i < len;) {
struct dirent64 *d = (struct dirent64 *) &buf[i];
#if defined(LINUX) || defined(SVR4)
d->d_ino,
d->d_off);
#ifdef LINUX
- tprintf("d_type=");
+ tprints("d_type=");
printxval(direnttypes, d->d_type, "DT_???");
- tprintf(", ");
+ tprints(", ");
#endif
tprintf("d_reclen=%u, d_name=\"%s\"}",
d->d_reclen, d->d_name);
}
#endif /* SUNOS4 */
if (!d->d_reclen) {
- tprintf("/* d_reclen == 0, problem here */");
+ tprints("/* d_reclen == 0, problem here */");
break;
}
i += d->d_reclen;
dents++;
}
if (!abbrev(tcp))
- tprintf("}");
+ tprints("}");
else
tprintf("/* %u entries */", dents);
tprintf(", %lu", tcp->u_arg[2]);
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
return 0;
}
if (syserror(tcp) || !verbose(tcp)) {
return 0;
}
if (!abbrev(tcp))
- tprintf("{");
+ tprints("{");
for (i = 0; i < len;) {
struct kernel_dirent *d = (struct kernel_dirent *) &buf[i];
if (!abbrev(tcp)) {
d->d_namlen, d->d_namlen, d->d_name);
}
if (!d->d_reclen) {
- tprintf("/* d_reclen == 0, problem here */");
+ tprints("/* d_reclen == 0, problem here */");
break;
}
i += d->d_reclen;
dents++;
}
if (!abbrev(tcp))
- tprintf("}");
+ tprints("}");
else
tprintf("/* %u entries */", dents);
free(buf);
}
else {
if (tcp->u_arg[5] == 0)
- tprintf(", NULL");
+ tprints(", NULL");
else if (syserror(tcp)
|| umove(tcp, tcp->u_arg[5], &res) < 0)
tprintf(", %#lx", tcp->u_arg[5]);
if (exiting(tcp)) {
if (tcp->u_arg[0] == 0)
- tprintf("NULL");
+ tprints("NULL");
else if (syserror(tcp)
|| umove(tcp, tcp->u_arg[0], &res) < 0)
tprintf("%#lx", tcp->u_arg[0]);
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printstr(tcp, tcp->u_arg[1], -1);
print_xattr_val(tcp, 0, tcp->u_arg[2], tcp->u_arg[3], tcp->u_arg[3]);
- tprintf(", ");
+ tprints(", ");
printflags(xattrflags, tcp->u_arg[4], "XATTR_???");
}
return 0;
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printstr(tcp, tcp->u_arg[1], -1);
print_xattr_val(tcp, 0, tcp->u_arg[2], tcp->u_arg[3], tcp->u_arg[3]);
- tprintf(", ");
+ tprints(", ");
printflags(xattrflags, tcp->u_arg[4], "XATTR_???");
}
return 0;
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printstr(tcp, tcp->u_arg[1], -1);
} else {
print_xattr_val(tcp, syserror(tcp), tcp->u_arg[2], tcp->u_arg[3],
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printstr(tcp, tcp->u_arg[1], -1);
} else {
print_xattr_val(tcp, syserror(tcp), tcp->u_arg[2], tcp->u_arg[3],
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printstr(tcp, tcp->u_arg[1], -1);
}
return 0;
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printstr(tcp, tcp->u_arg[1], -1);
}
return 0;
if (entering(tcp)) {
int argn;
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
argn = printllval(tcp, "%lld", 1);
tprintf(", %ld, ", tcp->u_arg[argn++]);
printxval(advise, tcp->u_arg[argn], "POSIX_FADV_???");
if (entering(tcp)) {
int argn;
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
#if defined ARM || defined POWERPC
argn = printllval(tcp, "%lld, ", 2);
#else
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printpath(tcp, tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
printflags(inotify_modes, tcp->u_arg[2], "IN_???");
}
return 0;
if (entering(tcp)) {
int argn;
printfd(tcp, tcp->u_arg[0]); /* fd */
- tprintf(", ");
+ tprints(", ");
tprintf("%#lo, ", tcp->u_arg[1]); /* mode */
argn = printllval(tcp, "%llu, ", 2); /* offset */
printllval(tcp, "%llu", argn); /* len */
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
if (syserror(tcp))
tprintf("%#lx", tcp->u_arg[1]);
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
tprintf(", %lu", tcp->u_arg[2]);
}
int failed = 0;
if (!len) {
- tprintf("[]");
+ tprints("[]");
return;
}
size = len * sizeof_iov;
} else {
abbrev_end = end;
}
- tprintf("[");
+ tprints("[");
for (cur = addr; cur < end; cur += sizeof_iov) {
if (cur > addr)
- tprintf(", ");
+ tprints(", ");
if (cur >= abbrev_end) {
- tprintf("...");
+ tprints("...");
break;
}
if (umoven(tcp, cur, sizeof_iov, (char *) &iov) < 0) {
- tprintf("?");
+ tprints("?");
failed = 1;
break;
}
- tprintf("{");
+ tprints("{");
if (decode_iov)
printstr(tcp, (long) iov_iov_base, iov_iov_len);
else
tprintf("%#lx", (long) iov_iov_base);
tprintf(", %lu}", (unsigned long)iov_iov_len);
}
- tprintf("]");
+ tprints("]");
if (failed)
tprintf(" %#lx", addr);
#undef sizeof_iov
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
if (syserror(tcp)) {
tprintf("%#lx, %lu",
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
tprint_iov(tcp, tcp->u_arg[2], tcp->u_arg[1], 1);
tprintf(", %lu", tcp->u_arg[2]);
}
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
if (syserror(tcp))
tprintf("%#lx", tcp->u_arg[1]);
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
#if UNIXWARE
/* off_t is signed int */
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printfd(tcp, tcp->u_arg[1]);
tprintf(", %llu, %lu",
LONG_LONG(tcp->u_arg[2], tcp->u_arg[3]),
off_t offset;
if (!tcp->u_arg[5])
- tprintf(", NULL");
+ tprints(", NULL");
else {
struct sf_hdtr hdtr;
if (umove(tcp, tcp->u_arg[5], &hdtr) < 0)
tprintf(", %#lx", tcp->u_arg[5]);
else {
- tprintf(", { ");
+ tprints(", { ");
tprint_iov(tcp, hdtr.hdr_cnt, hdtr.headers, 1);
tprintf(", %u, ", hdtr.hdr_cnt);
tprint_iov(tcp, hdtr.trl_cnt, hdtr.trailers, 1);
}
}
if (!tcp->u_arg[6])
- tprintf(", NULL");
+ tprints(", NULL");
else if (umove(tcp, tcp->u_arg[6], &offset) < 0)
tprintf(", %#lx", tcp->u_arg[6]);
else
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
if (syserror(tcp))
tprintf("%#lx", tcp->u_arg[1]);
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
tprintf(", %lu, ", tcp->u_arg[2]);
printllval(tcp, "%llu", PREAD_OFFSET_ARG);
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
if (syserror(tcp)) {
tprintf("%#lx, %lu", tcp->u_arg[1], tcp->u_arg[2]);
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
tprint_iov(tcp, tcp->u_arg[2], tcp->u_arg[1], 1);
tprintf(", %lu, ", tcp->u_arg[2]);
printllval(tcp, "%llu", PREAD_OFFSET_ARG);
off_t offset;
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printfd(tcp, tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
if (!tcp->u_arg[2])
- tprintf("NULL");
+ tprints("NULL");
else if (umove(tcp, tcp->u_arg[2], &offset) < 0)
tprintf("%#lx", tcp->u_arg[2]);
else
loff_t offset;
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printfd(tcp, tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
if (!tcp->u_arg[2])
- tprintf("NULL");
+ tprints("NULL");
else if (umove(tcp, tcp->u_arg[2], &offset) < 0)
tprintf("%#lx", tcp->u_arg[2]);
else
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
if (syserror(tcp))
tprintf("%#lx", tcp->u_arg[1]);
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
tprintf(", %lu, ", tcp->u_arg[2]);
printllval(tcp, "%#llx", 3);
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
iop = ioctl_lookup(tcp->u_arg[1]);
if (iop) {
tprints(iop->symbol);
if (tcp->u_arg[0])
tprintf("%#lx", tcp->u_arg[0]);
else
- tprintf("IPC_PRIVATE");
- tprintf(", ");
+ tprints("IPC_PRIVATE");
+ tprints(", ");
if (printflags(resource_flags, tcp->u_arg[1] & ~0777, NULL) != 0)
- tprintf("|");
+ tprints("|");
tprintf("%#lo", tcp->u_arg[1] & 0777);
}
return 0;
#ifdef IPC_64
# define PRINTCTL(flagset, arg, dflt) \
- if ((arg) & IPC_64) tprintf("IPC_64|"); \
+ if ((arg) & IPC_64) tprints("IPC_64|"); \
printxval((flagset), (arg) &~ IPC_64, dflt)
#else
# define PRINTCTL printxval
} else {
tprintf("{%lu, ", mtype);
printstr(tcp, addr + sizeof(mtype), count);
- tprintf("}");
+ tprints("}");
}
tprintf(", %lu, ", count);
printflags(msg_flags, flags, "MSG_???");
} else {
tprintf("{%lu, ", mtype);
printstr(tcp, addr + sizeof(mtype), count);
- tprintf("}");
+ tprints("}");
}
tprintf(", %lu, %ld, ", count, msgtyp);
}
for (i = 0; i < max_count; ++i) {
struct sembuf sb;
if (i)
- tprintf(", ");
+ tprints(", ");
if (umove(tcp, addr + i * sizeof(struct sembuf), &sb) < 0) {
if (i) {
- tprintf("{???}");
+ tprints("{???}");
break;
} else {
tprintf("%#lx, %lu", addr, count);
}
} else {
if (!i)
- tprintf("{");
+ tprints("{");
tprintf("{%u, %d, ", sb.sem_num, sb.sem_op);
printflags(semop_flags, sb.sem_flg, "SEM_???");
- tprintf("}");
+ tprints("}");
}
}
if (i < max_count || max_count < count)
- tprintf(", ...");
+ tprints(", ...");
tprintf("}, %lu", count);
}
tprintf("%lu, ", tcp->u_arg[0]);
if (indirect_ipccall(tcp)) {
tprint_sembuf(tcp, tcp->u_arg[3], tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
printtv(tcp, tcp->u_arg[5]);
} else {
tprint_sembuf(tcp, tcp->u_arg[1], tcp->u_arg[2]);
- tprintf(", ");
+ tprints(", ");
printtv(tcp, tcp->u_arg[3]);
}
}
if (tcp->u_arg[0])
tprintf("%#lx", tcp->u_arg[0]);
else
- tprintf("IPC_PRIVATE");
+ tprints("IPC_PRIVATE");
tprintf(", %lu", tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
if (printflags(resource_flags, tcp->u_arg[2] & ~0777, NULL) != 0)
- tprintf("|");
+ tprints("|");
tprintf("%#lo", tcp->u_arg[2] & 0777);
}
return 0;
if (tcp->u_arg[0])
tprintf("%#lx", tcp->u_arg[0]);
else
- tprintf("IPC_PRIVATE");
+ tprints("IPC_PRIVATE");
tprintf(", %lu", tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
if (printflags(shm_resource_flags, tcp->u_arg[2] & ~0777, NULL) != 0)
- tprintf("|");
+ tprints("|");
tprintf("%#lo", tcp->u_arg[2] & 0777);
}
return 0;
tprintf("%lu", tcp->u_arg[0]);
if (indirect_ipccall(tcp)) {
tprintf(", %#lx", tcp->u_arg[3]);
- tprintf(", ");
+ tprints(", ");
printflags(shm_flags, tcp->u_arg[1], "SHM_???");
} else {
tprintf(", %#lx", tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
printflags(shm_flags, tcp->u_arg[2], "SHM_???");
}
if (syserror(tcp))
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
/* flags */
tprint_open_modes(tcp->u_arg[1]);
if (tcp->u_arg[1] & O_CREAT) {
/* mode */
tprintf(", %#lo, ", tcp->u_arg[2]);
if (umove(tcp, tcp->u_arg[3], &attr) < 0)
- tprintf("{ ??? }");
+ tprints("{ ??? }");
else
tprintf("{mq_maxmsg=%ld, mq_msgsize=%ld}",
attr.mq_maxmsg, attr.mq_msgsize);
printmqattr(struct tcb *tcp, long addr)
{
if (addr == 0)
- tprintf("NULL");
+ tprints("NULL");
else {
# ifndef HAVE_MQUEUE_H
tprintf("%#lx", addr);
# else
struct mq_attr attr;
if (umove(tcp, addr, &attr) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
- tprintf("{mq_flags=");
+ tprints("{mq_flags=");
tprint_open_modes(attr.mq_flags);
tprintf(", mq_maxmsg=%ld, mq_msgsize=%ld, mq_curmsg=%ld}",
attr.mq_maxmsg, attr.mq_msgsize, attr.mq_curmsgs);
if (entering(tcp)) {
tprintf("%ld, ", tcp->u_arg[0]);
printmqattr(tcp, tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
} else
printmqattr(tcp, tcp->u_arg[2]);
return 0;
if (flags & _MAP_CACHE_INCOHERENT) {
flags &= ~_MAP_CACHE_INCOHERENT;
if (home == MAP_CACHE_HOME_NONE) {
- tprintf("|MAP_CACHE_INCOHERENT");
+ tprints("|MAP_CACHE_INCOHERENT");
return flags;
}
- tprintf("|_MAP_CACHE_INCOHERENT");
+ tprints("|_MAP_CACHE_INCOHERENT");
}
switch (home) {
case 0: break;
- case MAP_CACHE_HOME_HERE: tprintf("|MAP_CACHE_HOME_HERE"); break;
- case MAP_CACHE_HOME_NONE: tprintf("|MAP_CACHE_HOME_NONE"); break;
- case MAP_CACHE_HOME_SINGLE: tprintf("|MAP_CACHE_HOME_SINGLE"); break;
- case MAP_CACHE_HOME_TASK: tprintf("|MAP_CACHE_HOME_TASK"); break;
- case MAP_CACHE_HOME_HASH: tprintf("|MAP_CACHE_HOME_HASH"); break;
+ case MAP_CACHE_HOME_HERE: tprints("|MAP_CACHE_HOME_HERE"); break;
+ case MAP_CACHE_HOME_NONE: tprints("|MAP_CACHE_HOME_NONE"); break;
+ case MAP_CACHE_HOME_SINGLE: tprints("|MAP_CACHE_HOME_SINGLE"); break;
+ case MAP_CACHE_HOME_TASK: tprints("|MAP_CACHE_HOME_TASK"); break;
+ case MAP_CACHE_HOME_HASH: tprints("|MAP_CACHE_HOME_HASH"); break;
default:
tprintf("|MAP_CACHE_HOME(%d)",
(home >> _MAP_CACHE_HOME_SHIFT) );
if (entering(tcp)) {
/* addr */
if (!u_arg[0])
- tprintf("NULL, ");
+ tprints("NULL, ");
else
tprintf("%#lx, ", u_arg[0]);
/* len */
tprintf("%lu, ", u_arg[1]);
/* prot */
printflags(mmap_prot, u_arg[2], "PROT_???");
- tprintf(", ");
+ tprints(", ");
/* flags */
#ifdef MAP_TYPE
printxval(mmap_flags, u_arg[3] & MAP_TYPE, "MAP_???");
printflags(mmap_flags, u_arg[3], "MAP_???");
#endif
/* fd */
- tprintf(", ");
+ tprints(", ");
printfd(tcp, u_arg[4]);
/* offset */
tprintf(", %#llx", offset);
tprintf("%lu, ", u_arg[1]);
/* prot */
printflags(mmap_prot, u_arg[2], "PROT_???");
- tprintf(", ");
+ tprints(", ");
/* flags */
#ifdef MAP_TYPE
printxval(mmap_flags, u_arg[3] & MAP_TYPE, "MAP_???");
printflags(mmap_flags, u_arg[3], "MAP_???");
#endif
/* fd */
- tprintf(", ");
+ tprints(", ");
printfd(tcp, u_arg[4]);
/* offset */
#if !defined(LINUX) || defined(ALPHA)
printflags(mctl_funcs, function, "MC_???");
/* arg */
arg = tcp->u_arg[3];
- tprintf(", ");
+ tprints(", ");
switch (function) {
case MC_SYNC:
printflags(mctl_sync, arg, "MS_???");
umoven(tcp, tcp->u_arg[2], len, vec) < 0)
tprintf("%#lx", tcp->u_arg[2]);
else {
- tprintf("[");
+ tprints("[");
for (i = 0; i < len; i++) {
if (abbrev(tcp) && i >= max_strlen) {
- tprintf("...");
+ tprints("...");
break;
}
- tprintf((vec[i] & 1) ? "1" : "0");
+ tprints((vec[i] & 1) ? "1" : "0");
}
- tprintf("]");
+ tprints("]");
}
free(vec);
}
else {
tprintf(", {entry_number:%d, ", copy.entry_number);
if (!verbose(tcp))
- tprintf("...}");
+ tprints("...}");
else {
print_ldt_entry(©);
}
tprintf("{entry_number:%d -> ",
copy.entry_number);
else
- tprintf("{entry_number:");
+ tprints("{entry_number:");
}
} else {
if (umove(tcp, tcp->u_arg[0], ©) != -1) {
tprintf("%d, ", copy.entry_number);
if (!verbose(tcp))
- tprintf("...}");
+ tprints("...}");
else {
print_ldt_entry(©);
}
if (umove(tcp, tcp->u_arg[0], ©) != -1) {
tprintf("{entry_number:%d, ", copy.entry_number);
if (!verbose(tcp))
- tprintf("...}");
+ tprints("...}");
else {
print_ldt_entry(©);
}
} else {
abbrev_end = end;
}
- tprintf(", {");
+ tprints(", {");
for (cur = ptr; cur < end; cur += sizeof(long)) {
if (cur > ptr)
- tprintf(", ");
+ tprints(", ");
if (cur >= abbrev_end) {
- tprintf("...");
+ tprints("...");
break;
}
if (umoven(tcp, cur, sizeof(n), (char *) &n) < 0) {
- tprintf("?");
+ tprints("?");
failed = 1;
break;
}
tprintf("%#0*lx", (int) sizeof(long) * 2 + 2, n);
}
- tprintf("}");
+ tprints("}");
if (failed)
tprintf(" %#lx", ptr);
} else
tprintf("%#lx, %lu, ", tcp->u_arg[0], tcp->u_arg[1]);
printxval(policies, tcp->u_arg[2], "MPOL_???");
get_nodes(tcp, tcp->u_arg[3], tcp->u_arg[4], 0);
- tprintf(", ");
+ tprints(", ");
printflags(mbindflags, tcp->u_arg[5], "MPOL_???");
}
return 0;
if (exiting(tcp)) {
int pol;
if (tcp->u_arg[0] == 0)
- tprintf("NULL");
+ tprints("NULL");
else if (syserror(tcp) || umove(tcp, tcp->u_arg[0], &pol) < 0)
tprintf("%#lx", tcp->u_arg[0]);
else
unsigned long npages = tcp->u_arg[1];
tprintf("%ld, %lu, ", tcp->u_arg[0], npages);
if (tcp->u_arg[2] == 0)
- tprintf("NULL, ");
+ tprints("NULL, ");
else {
int i;
long puser = tcp->u_arg[2];
- tprintf("{");
+ tprints("{");
for (i = 0; i < npages; ++i) {
void *p;
if (i > 0)
- tprintf(", ");
+ tprints(", ");
if (umove(tcp, puser, &p) < 0) {
- tprintf("???");
+ tprints("???");
break;
}
tprintf("%p", p);
puser += sizeof(void *);
}
- tprintf("}, ");
+ tprints("}, ");
}
if (tcp->u_arg[3] == 0)
- tprintf("NULL, ");
+ tprints("NULL, ");
else {
int i;
long nodeuser = tcp->u_arg[3];
- tprintf("{");
+ tprints("{");
for (i = 0; i < npages; ++i) {
int node;
if (i > 0)
- tprintf(", ");
+ tprints(", ");
if (umove(tcp, nodeuser, &node) < 0) {
- tprintf("???");
+ tprints("???");
break;
}
tprintf("%#x", node);
nodeuser += sizeof(int);
}
- tprintf("}, ");
+ tprints("}, ");
}
}
if (exiting(tcp)) {
unsigned long npages = tcp->u_arg[1];
if (tcp->u_arg[4] == 0)
- tprintf("NULL, ");
+ tprints("NULL, ");
else {
int i;
long statususer = tcp->u_arg[4];
- tprintf("{");
+ tprints("{");
for (i = 0; i < npages; ++i) {
int status;
if (i > 0)
- tprintf(", ");
+ tprints(", ");
if (umove(tcp, statususer, &status) < 0) {
- tprintf("???");
+ tprints("???");
break;
}
tprintf("%#x", status);
statususer += sizeof(int);
}
- tprintf("}, ");
+ tprints("}, ");
}
printflags(move_pages_flags, tcp->u_arg[5], "MPOL_???");
}
tprintf("%#lx, %#lx, ", tcp->u_arg[0], tcp->u_arg[1]);
entries = tcp->u_arg[1] >> 16;
if (!entries || !tcp->u_arg[2]) {
- tprintf("{}");
+ tprints("{}");
return 0;
}
cur = tcp->u_arg[2];
}
else
abbrev_end = end;
- tprintf("{");
+ tprints("{");
for (; cur < end; cur += sizeof(int)) {
if (cur > tcp->u_arg[2])
- tprintf(", ");
+ tprints(", ");
if (cur >= abbrev_end) {
- tprintf("...");
+ tprints("...");
break;
}
if (umove(tcp, cur, &entry) < 0) {
else
tprintf("%#08x", entry);
}
- tprintf("}");
+ tprints("}");
}
return 0;
char string_addr[100];
if (addr == 0) {
- tprintf("NULL");
+ tprints("NULL");
return;
}
if (!verbose(tcp)) {
memset(&addrbuf, 0, sizeof(addrbuf));
if (umoven(tcp, addr, addrlen, addrbuf.pad) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
addrbuf.pad[sizeof(addrbuf.pad) - 1] = '\0';
- tprintf("{sa_family=");
+ tprints("{sa_family=");
printxval(addrfams, addrbuf.sa.sa_family, "AF_???");
- tprintf(", ");
+ tprints(", ");
switch (addrbuf.sa.sa_family) {
case AF_UNIX:
if (addrlen == 2) {
- tprintf("NULL");
+ tprints("NULL");
} else if (addrbuf.sau.sun_path[0]) {
- tprintf("path=");
+ tprints("path=");
printpathn(tcp, addr + 2, strlen(addrbuf.sau.sun_path));
} else {
- tprintf("path=@");
+ tprints("path=@");
printpathn(tcp, addr + 3, strlen(addrbuf.sau.sun_path + 1));
}
break;
AF_X25 AF_ROSE etc. still need to be done */
default:
- tprintf("sa_data=");
+ tprints("sa_data=");
printstr(tcp, (long) &((struct sockaddr *) addr)->sa_data,
sizeof addrbuf.sa.sa_data);
break;
}
- tprintf("}");
+ tprints("}");
}
#if HAVE_SENDMSG
tprintf(", {cmsg_len=%u, cmsg_level=", (unsigned) cmsg->cmsg_len);
printxval(socketlayers, cmsg->cmsg_level, "SOL_???");
- tprintf(", cmsg_type=");
+ tprints(", cmsg_type=");
if (cmsg->cmsg_level == SOL_SOCKET) {
unsigned long cmsg_len;
int *fds = (int *) CMSG_DATA(cmsg);
int first = 1;
- tprintf(", {");
+ tprints(", {");
while ((char *) fds < ((char *) cmsg + cmsg_len)) {
if (!first)
- tprintf(", ");
+ tprints(", ");
tprintf("%d", *fds++);
first = 0;
}
- tprintf("}}");
+ tprints("}}");
free(cmsg);
return;
}
}
}
free(cmsg);
- tprintf(", ...}");
+ tprints(", ...}");
}
static void
if (msg->msg_controllen)
printcmsghdr(tcp, (unsigned long) msg->msg_control,
msg->msg_controllen);
- tprintf(", msg_flags=");
+ tprints(", msg_flags=");
printflags(msg_flags, msg->msg_flags, "MSG_???");
#else /* !HAVE_STRUCT_MSGHDR_MSG_CONTROL */
tprintf("msg_accrights=%#lx, msg_accrightslen=%u",
(unsigned long) msg->msg_accrights, msg->msg_accrightslen);
#endif /* !HAVE_STRUCT_MSGHDR_MSG_CONTROL */
- tprintf("}");
+ tprints("}");
}
static void
tprintf("%#lx", addr);
return;
}
- tprintf("{");
+ tprints("{");
do_msghdr(tcp, &mmsg.msg_hdr);
tprintf(", %u}", mmsg.msg_len);
}
flags &= ~SOCK_TYPE_MASK;
if (!flags)
return;
- tprintf("|");
+ tprints("|");
}
printflags(sock_type_flags, flags, "SOCK_???");
}
{
if (entering(tcp)) {
printxval(domains, tcp->u_arg[0], "PF_???");
- tprintf(", ");
+ tprints(", ");
tprint_sock_type(tcp, tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
switch (tcp->u_arg[0]) {
case PF_INET:
#ifdef PF_INET6
#ifdef PF_IPX
case PF_IPX:
/* BTW: I don't believe this.. */
- tprintf("[");
+ tprints("[");
printxval(domains, tcp->u_arg[2], "PF_???");
- tprintf("]");
+ tprints("]");
break;
#endif /* PF_IPX */
default:
} else {
printsock(tcp, tcp->u_arg[1], len);
}
- tprintf(", ");
+ tprints(", ");
printnum_int(tcp, tcp->u_arg[2], "%u");
}
if (flags_arg >= 0) {
- tprintf(", ");
+ tprints(", ");
printflags(sock_type_flags, tcp->u_arg[flags_arg],
"SOCK_???");
}
/* flags */
printflags(msg_flags, tcp->u_arg[3], "MSG_???");
/* to address */
- tprintf(", ");
+ tprints(", ");
printsock(tcp, tcp->u_arg[4], tcp->u_arg[5]);
/* to length */
tprintf(", %lu", tcp->u_arg[5]);
tprintf("%ld, ", tcp->u_arg[0]);
printmsghdr(tcp, tcp->u_arg[1]);
/* flags */
- tprintf(", ");
+ tprints(", ");
printflags(msg_flags, tcp->u_arg[2], "MSG_???");
}
return 0;
/* from address, len */
if (!tcp->u_arg[4] || !tcp->u_arg[5]) {
if (tcp->u_arg[4] == 0)
- tprintf(", NULL");
+ tprints(", NULL");
else
tprintf(", %#lx", tcp->u_arg[4]);
if (tcp->u_arg[5] == 0)
- tprintf(", NULL");
+ tprints(", NULL");
else
tprintf(", %#lx", tcp->u_arg[5]);
return 0;
}
if (umove(tcp, tcp->u_arg[5], &fromlen) < 0) {
- tprintf(", {...}, [?]");
+ tprints(", {...}, [?]");
return 0;
}
- tprintf(", ");
+ tprints(", ");
printsock(tcp, tcp->u_arg[4], tcp->u_arg[5]);
/* from length */
tprintf(", [%u]", fromlen);
else
printmsghdr(tcp, tcp->u_arg[1]);
/* flags */
- tprintf(", ");
+ tprints(", ");
printflags(msg_flags, tcp->u_arg[2], "MSG_???");
}
return 0;
} else {
tprintf("%#lx, %ld, ", tcp->u_arg[1], tcp->u_arg[2]);
printflags(msg_flags, tcp->u_arg[3], "MSG_???");
- tprintf(", ");
+ tprints(", ");
print_timespec(tcp, tcp->u_arg[4]);
}
return 0;
int fds[2];
if (umoven(tcp, tcp->u_arg[0], sizeof fds, (char *) fds) < 0)
- tprintf("[...]");
+ tprints("[...]");
else
tprintf("[%u, %u]", fds[0], fds[1]);
#elif defined(SPARC) || defined(SPARC64) || defined(SH) || defined(SVR4) || defined(FREEBSD) || defined(IA64)
#endif
}
if (flags_arg >= 0) {
- tprintf(", ");
+ tprints(", ");
printflags(open_mode_flags, tcp->u_arg[flags_arg], "O_???");
}
}
if (entering(tcp)) {
printxval(domains, tcp->u_arg[0], "PF_???");
- tprintf(", ");
+ tprints(", ");
tprint_sock_type(tcp, tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
switch (tcp->u_arg[0]) {
case PF_INET:
printxval(protocols, tcp->u_arg[2], "IPPROTO_???");
#ifdef PF_IPX
case PF_IPX:
/* BTW: I don't believe this.. */
- tprintf("[");
+ tprints("[");
printxval(domains, tcp->u_arg[2], "PF_???");
- tprintf("]");
+ tprints("]");
break;
#endif /* PF_IPX */
default:
}
#ifdef LINUX
if (umoven(tcp, tcp->u_arg[3], sizeof fds, (char *) fds) < 0)
- tprintf(", [...]");
+ tprints(", [...]");
else
tprintf(", [%u, %u]", fds[0], fds[1]);
#endif /* LINUX */
if (entering(tcp)) {
tprintf("%ld, ", tcp->u_arg[0]);
printxval(socketlayers, tcp->u_arg[1], "SOL_???");
- tprintf(", ");
+ tprints(", ");
switch (tcp->u_arg[1]) {
case SOL_SOCKET:
printxval(sockoptions, tcp->u_arg[2], "SO_???");
tprintf("%lu", tcp->u_arg[2]);
break;
}
- tprintf(", ");
+ tprints(", ");
} else {
int len;
if (syserror(tcp) || umove(tcp, tcp->u_arg[4], &len) < 0) {
struct icmp_filter filter;
if (!addr) {
- tprintf("NULL");
+ tprints("NULL");
return;
}
if (syserror(tcp) || !verbose(tcp)) {
return;
}
if (umove(tcp, addr, &filter) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
- tprintf("~(");
+ tprints("~(");
printflags(icmpfilterflags, ~filter.data, "ICMP_???");
- tprintf(")");
+ tprints(")");
}
#endif /* ICMP_FILTER */
printsockopt(struct tcb *tcp, int level, int name, long addr, int len)
{
printxval(socketlayers, level, "SOL_??");
- tprintf(", ");
+ tprints(", ");
switch (level) {
case SOL_SOCKET:
printxval(sockoptions, name, "SO_???");
switch (name) {
#if defined(ICMP_FILTER)
case ICMP_FILTER:
- tprintf(", ");
+ tprints(", ");
printicmpfilter(tcp, addr);
return 0;
#endif
/* default arg printing */
- tprintf(", ");
+ tprints(", ");
if (len == sizeof(int)) {
printnum_int(tcp, addr, "%d");
while (len >= (int) sizeof hdr) {
if (umove(tcp, addr, &hdr) < 0) break;
if (c++) {
- tprintf(", ");
+ tprints(", ");
}
else if (len > hdr.len + sizeof hdr) {
- tprintf("[");
+ tprints("[");
}
- tprintf("{");
+ tprints("{");
addr += sizeof hdr;
len -= sizeof hdr;
printsockopt(tcp, hdr.level, hdr.name, addr, hdr.len);
addr += hdr.len;
len -= hdr.len;
}
- tprintf("}");
+ tprints("}");
}
if (len > 0) {
- if (c++) tprintf(", ");
+ if (c++) tprints(", ");
printstr(tcp, addr, len);
}
- if (c > 1) tprintf("]");
+ if (c > 1) tprints("]");
}
#endif
if (entering(tcp)) {
int i;
printxval(sock_version, tcp->u_arg[0], "__NETLIB_???");
- tprintf(", ");
+ tprints(", ");
--tcp->u_nargs;
for (i = 0; i < tcp->u_nargs; i++)
tcp->u_arg[i] = tcp->u_arg[i + 1];
{
if (entering(tcp)) {
printxval(sock_version, tcp->u_arg[0], "__NETLIB_???");
- tprintf(", ");
+ tprints(", ");
if (tcp->u_arg[1] == 0) {
- tprintf("LOCALNAME, ");
+ tprints("LOCALNAME, ");
}
else if (tcp->u_arg[1] == 1) {
- tprintf("REMOTENAME, ");
+ tprints("REMOTENAME, ");
}
else {
tprintf("%ld, ", tcp->u_arg[1]);
} else {
printsock(tcp, tcp->u_arg[3], tcp->u_arg[4]);
}
- tprintf(", ");
+ tprints(", ");
printnum(tcp, tcp->u_arg[4], "%lu");
}
case PIOCSTOP:
case PIOCWSTOP:
if (arg == 0)
- tprintf(", NULL");
+ tprints(", NULL");
else if (syserror(tcp))
tprintf(", %#x", arg);
else if (umove(tcp, arg, &status) < 0)
- tprintf(", {...}");
+ tprints(", {...}");
else {
- tprintf(", {pr_flags=");
+ tprints(", {pr_flags=");
printflags(proc_status_flags, status.pr_flags, "PR_???");
if (status.pr_why) {
- tprintf(", pr_why=");
+ tprints(", pr_why=");
printxval(proc_status_why, status.pr_why,
"PR_???");
}
switch (status.pr_why) {
case PR_SIGNALLED:
case PR_JOBCONTROL:
- tprintf(", pr_what=");
+ tprints(", pr_what=");
printsignal(status.pr_what);
break;
case PR_FAULTED:
sysent[status.pr_what].sys_name);
break;
}
- tprintf(", ...}");
+ tprints(", ...}");
}
return 1;
case PIOCRUN:
if (arg == 0)
- tprintf(", NULL");
+ tprints(", NULL");
else if (umove(tcp, arg, &run) < 0)
- tprintf(", {...}");
+ tprints(", {...}");
else {
- tprintf(", {pr_flags=");
+ tprints(", {pr_flags=");
printflags(proc_run_flags, run.pr_flags, "PR???");
- tprintf(", ...}");
+ tprints(", ...}");
}
return 1;
#ifdef PIOCSET
case PIOCSET:
case PIOCRESET:
if (umove(tcp, arg, &val) < 0)
- tprintf(", [?]");
+ tprints(", [?]");
else {
- tprintf(", [");
+ tprints(", [");
printflags(proc_status_flags, val, "PR_???");
- tprintf("]");
+ tprints("]");
}
return 1;
#endif /* PIOCSET */
case PIOCUNKILL:
/* takes a pointer to a signal */
if (umove(tcp, arg, &val) < 0)
- tprintf(", [?]");
+ tprints(", [?]");
else {
- tprintf(", [");
+ tprints(", [");
printsignal(val);
- tprintf("]");
+ tprints("]");
}
return 1;
case PIOCSFORK:
case PIOCSTATUS:
case PIOCWAIT:
if (arg == 0)
- tprintf(", NULL");
+ tprints(", NULL");
else if (syserror(tcp))
tprintf(", %x", arg);
else if (umove(tcp, arg, &status) < 0)
- tprintf(", {...}");
+ tprints(", {...}");
else {
tprintf(", {state=%d, flags=", status.state);
printflags(proc_status_flags, status.flags, "PF_???");
- tprintf(", events=");
+ tprints(", events=");
printflags(proc_status_why, status.events, "S_???");
- tprintf(", why=");
+ tprints(", why=");
printxval(proc_status_why, status.why, "S_???");
tprintf(", val=%lu}", status.val);
}
return 1;
case PIOCBIS:
- tprintf(", ");
+ tprints(", ");
printflags(proc_status_why, arg, "S_???");
return 1;
return 1;
case PIOCSFL:
- tprintf(", ");
+ tprints(", ");
printflags(proc_status_flags, arg, "PF_???");
return 1;
case PIOCGFL:
if (syserror(tcp))
tprintf(", %#x", arg);
else if (umove(tcp, arg, &val) < 0)
- tprintf(", {...}");
+ tprints(", {...}");
else {
- tprintf(", [");
+ tprints(", [");
printflags(proc_status_flags, val, "PF_???");
- tprintf("]");
+ tprints("]");
}
return 1;
default:
/* special case: we stop tracing this process, finish line now */
tprintf("%ld) ", tcp->u_arg[0]);
tabto();
- tprintf("= ?");
+ tprints("= ?");
printtrailer();
return 0;
}
tprintf("stack_size=%#lx, ",
tcp->u_arg[ARG_STACKSIZE]);
# endif
- tprintf("flags=");
+ tprints("flags=");
if (!printflags(clone_flags, flags &~ CSIGNAL, NULL))
sep = "";
if ((flags & CSIGNAL) != 0)
tprintf(", {entry_number:%d, ",
copy.entry_number);
if (!verbose(tcp))
- tprintf("...}");
+ tprints("...}");
else
print_ldt_entry(©);
}
len = tcp->u_arg[0];
tprintf("%lu, ", len);
if (len == 0) {
- tprintf("[]");
+ tprints("[]");
return 0;
}
start = tcp->u_arg[1];
if (start == 0) {
- tprintf("NULL");
+ tprints("NULL");
return 0;
}
size = len * sizeof(gid);
} else {
abbrev_end = end;
}
- tprintf("[");
+ tprints("[");
for (cur = start; cur < end; cur += sizeof(gid)) {
if (cur > start)
- tprintf(", ");
+ tprints(", ");
if (cur >= abbrev_end) {
- tprintf("...");
+ tprints("...");
break;
}
if (umoven(tcp, cur, sizeof(gid), (char *) &gid) < 0) {
- tprintf("?");
+ tprints("?");
failed = 1;
break;
}
tprintf("%lu", (unsigned long) gid);
}
- tprintf("]");
+ tprints("]");
if (failed)
tprintf(" %#lx", tcp->u_arg[1]);
}
len = tcp->u_rval;
if (len == 0) {
- tprintf("[]");
+ tprints("[]");
return 0;
}
start = tcp->u_arg[1];
if (start == 0) {
- tprintf("NULL");
+ tprints("NULL");
return 0;
}
if (tcp->u_arg[0] == 0) {
} else {
abbrev_end = end;
}
- tprintf("[");
+ tprints("[");
for (cur = start; cur < end; cur += sizeof(gid)) {
if (cur > start)
- tprintf(", ");
+ tprints(", ");
if (cur >= abbrev_end) {
- tprintf("...");
+ tprints("...");
break;
}
if (umoven(tcp, cur, sizeof(gid), (char *) &gid) < 0) {
- tprintf("?");
+ tprints("?");
failed = 1;
break;
}
tprintf("%lu", (unsigned long) gid);
}
- tprintf("]");
+ tprints("]");
if (failed)
tprintf(" %#lx", tcp->u_arg[1]);
}
len = tcp->u_arg[0];
tprintf("%lu, ", len);
if (len == 0) {
- tprintf("[]");
+ tprints("[]");
return 0;
}
start = tcp->u_arg[1];
if (start == 0) {
- tprintf("NULL");
+ tprints("NULL");
return 0;
}
size = len * sizeof(gid);
} else {
abbrev_end = end;
}
- tprintf("[");
+ tprints("[");
for (cur = start; cur < end; cur += sizeof(gid)) {
if (cur > start)
- tprintf(", ");
+ tprints(", ");
if (cur >= abbrev_end) {
- tprintf("...");
+ tprints("...");
break;
}
if (umoven(tcp, cur, sizeof(gid), (char *) &gid) < 0) {
- tprintf("?");
+ tprints("?");
failed = 1;
break;
}
tprintf("%lu", (unsigned long) gid);
}
- tprintf("]");
+ tprints("]");
if (failed)
tprintf(" %#lx", tcp->u_arg[1]);
}
len = tcp->u_rval;
if (len == 0) {
- tprintf("[]");
+ tprints("[]");
return 0;
}
start = tcp->u_arg[1];
if (start == 0) {
- tprintf("NULL");
+ tprints("NULL");
return 0;
}
size = len * sizeof(gid);
} else {
abbrev_end = end;
}
- tprintf("[");
+ tprints("[");
for (cur = start; cur < end; cur += sizeof(gid)) {
if (cur > start)
- tprintf(", ");
+ tprints(", ");
if (cur >= abbrev_end) {
- tprintf("...");
+ tprints("...");
break;
}
if (umoven(tcp, cur, sizeof(gid), (char *) &gid) < 0) {
- tprintf("?");
+ tprints("?");
failed = 1;
break;
}
tprintf("%lu", (unsigned long) gid);
}
- tprintf("]");
+ tprints("]");
if (failed)
tprintf(" %#lx", tcp->u_arg[1]);
}
return;
}
- tprintf("[");
+ tprints("[");
for (i = 0; i < len; ++i) {
const char *t, *p;
- if (i) tprintf(", ");
+ if (i) tprints(", ");
if ((t = xlookup(procpriv_type, buf[i] & PS_TYPE)) &&
(p = xlookup(procpriv_priv, buf[i] & ~PS_TYPE)))
}
}
- if (dots) tprintf(" ...");
+ if (dots) tprints(" ...");
- tprintf("]");
+ tprints("]");
}
break;
default:
- tprintf(", ");
+ tprints(", ");
printpriv(tcp, tcp->u_arg[1], tcp->u_arg[2]);
tprintf(", %ld", tcp->u_arg[2]);
}
tprintf(", %#lx, %ld", tcp->u_arg[1], tcp->u_arg[2]);
}
else {
- tprintf(", ");
+ tprints(", ");
printpriv(tcp, tcp->u_arg[1], tcp->u_rval);
tprintf(", %ld", tcp->u_arg[2]);
}
if (!verbose(tcp))
tprintf(", %#lx", tcp->u_arg[1]);
else {
- tprintf(", [");
+ tprints(", [");
printargv(tcp, tcp->u_arg[1]);
- tprintf("]");
+ tprints("]");
}
}
return 0;
if (!verbose(tcp))
tprintf(", %#lx", tcp->u_arg[1]);
else {
- tprintf(", [");
+ tprints(", [");
printargv(tcp, tcp->u_arg[1]);
- tprintf("]");
+ tprints("]");
}
if (!verbose(tcp))
tprintf(", %#lx", tcp->u_arg[2]);
else if (abbrev(tcp))
printargc(", [/* %d var%s */]", tcp, tcp->u_arg[2]);
else {
- tprintf(", [");
+ tprints(", [");
printargv(tcp, tcp->u_arg[2]);
- tprintf("]");
+ tprints("]");
}
}
return 0;
}
if (status == 0)
- tprintf("]");
+ tprints("]");
else
tprintf(" | %#x]", status);
} else {
/* status */
if (!tcp->u_arg[1])
- tprintf("NULL");
+ tprints("NULL");
else if (syserror(tcp) || tcp->u_rval == 0)
tprintf("%#lx", tcp->u_arg[1]);
else if (umove(tcp, tcp->u_arg[1], &status) < 0)
- tprintf("[?]");
+ tprints("[?]");
else
#ifdef SUNOS4
exited =
#endif
printstatus(status);
/* options */
- tprintf(", ");
+ tprints(", ");
printflags(wait4_options, tcp->u_arg[2], "W???");
if (n == 4) {
- tprintf(", ");
+ tprints(", ");
/* usage */
if (!tcp->u_arg[3])
- tprintf("NULL");
+ tprints("NULL");
#ifdef LINUX
else if (tcp->u_rval > 0) {
#ifdef ALPHA
else {
/* siginfo */
if (!tcp->u_arg[2])
- tprintf("NULL");
+ tprints("NULL");
else if (syserror(tcp))
tprintf("%#lx", tcp->u_arg[2]);
else if (umove(tcp, tcp->u_arg[2], &si) < 0)
- tprintf("{???}");
+ tprints("{???}");
else
printsiginfo(&si, verbose(tcp));
/* options */
- tprintf(", ");
+ tprints(", ");
printflags(wait4_options, tcp->u_arg[3], "W???");
if (tcp->u_nargs > 4) {
/* usage */
- tprintf(", ");
+ tprints(", ");
if (!tcp->u_arg[4])
- tprintf("NULL");
+ tprints("NULL");
else if (tcp->u_error)
tprintf("%#lx", tcp->u_arg[4]);
else
if (syserror(tcp) || !verbose(tcp))
tprintf("%#lx", tcp->u_arg[0]);
else if (umove(tcp, tcp->u_arg[0], &uname) < 0)
- tprintf("{...}");
+ tprints("{...}");
else if (!abbrev(tcp)) {
tprintf("{sysname=\"%s\", nodename=\"%s\", ",
tprintf(", domainname=\"%s\"", uname.domainname);
#endif
#endif
- tprintf("}");
+ tprints("}");
}
else
tprintf("{sys=\"%s\", node=\"%s\", ...}",
case PTRACE_SETSIGINFO: {
siginfo_t si;
if (!tcp->u_arg[3])
- tprintf("NULL");
+ tprints("NULL");
else if (syserror(tcp))
tprintf("%#lx", tcp->u_arg[3]);
else if (umove(tcp, tcp->u_arg[3], &si) < 0)
- tprintf("{???}");
+ tprints("{???}");
else
printsiginfo(&si, verbose(tcp));
break;
case PTRACE_GETSIGINFO: {
siginfo_t si;
if (!tcp->u_arg[3])
- tprintf("NULL");
+ tprints("NULL");
else if (syserror(tcp))
tprintf("%#lx", tcp->u_arg[3]);
else if (umove(tcp, tcp->u_arg[3], &si) < 0)
- tprintf("{???}");
+ tprints("{???}");
else
printsiginfo(&si, verbose(tcp));
break;
if (cmd == FUTEX_WAKE_BITSET)
tprintf(", %lx", tcp->u_arg[5]);
else if (cmd == FUTEX_WAIT) {
- tprintf(", ");
+ tprints(", ");
printtv(tcp, tcp->u_arg[3]);
} else if (cmd == FUTEX_WAIT_BITSET) {
- tprintf(", ");
+ tprints(", ");
printtv(tcp, tcp->u_arg[3]);
tprintf(", %lx", tcp->u_arg[5]);
} else if (cmd == FUTEX_REQUEUE)
else if (cmd == FUTEX_WAKE_OP) {
tprintf(", %ld, %p, {", tcp->u_arg[3], (void *) tcp->u_arg[4]);
if ((tcp->u_arg[5] >> 28) & 8)
- tprintf("FUTEX_OP_OPARG_SHIFT|");
+ tprints("FUTEX_OP_OPARG_SHIFT|");
printxval(futexwakeops, (tcp->u_arg[5] >> 28) & 0x7, "FUTEX_OP_???");
tprintf(", %ld, ", (tcp->u_arg[5] >> 12) & 0xfff);
if ((tcp->u_arg[5] >> 24) & 8)
- tprintf("FUTEX_OP_OPARG_SHIFT|");
+ tprints("FUTEX_OP_OPARG_SHIFT|");
printxval(futexwakecmps, (tcp->u_arg[5] >> 24) & 0x7, "FUTEX_OP_CMP_???");
tprintf(", %ld}", tcp->u_arg[5] & 0xfff);
} else if (cmd == FUTEX_WAIT_REQUEUE_PI) {
- tprintf(", ");
+ tprints(", ");
printtv(tcp, tcp->u_arg[3]);
tprintf(", %p", (void *) tcp->u_arg[4]);
}
if (umove(tcp, list, &w) < 0)
break;
if (first)
- tprintf("{");
+ tprints("{");
else
- tprintf(", ");
+ tprints(", ");
first = 0;
tprintf("%lx", w);
}
tprintf(", %s}", (len >= sizeof(w) && len > min_len ?
"???" : "..."));
} else {
- tprintf(first ? "{}" : "}");
+ tprints(first ? "{}" : "}");
}
}
if (exiting(tcp)) {
unsigned u;
if (tcp->u_arg[0] == 0)
- tprintf("NULL, ");
+ tprints("NULL, ");
else if (umove(tcp, tcp->u_arg[0], &u) < 0)
tprintf("%#lx, ", tcp->u_arg[0]);
else
tprintf("[%u], ", u);
if (tcp->u_arg[1] == 0)
- tprintf("NULL, ");
+ tprints("NULL, ");
else if (umove(tcp, tcp->u_arg[1], &u) < 0)
tprintf("%#lx, ", tcp->u_arg[1]);
else
if (!abbrev(tcp)) {
tprintf("btime=%" PRIu64 ", ", dq.dqb_btime);
tprintf("itime=%" PRIu64 ", ", dq.dqb_itime);
- tprintf("valid=");
+ tprints("valid=");
printflags(if_dqblk_valid,
dq.dqb_valid, "QIF_???");
- tprintf("}");
+ tprints("}");
} else
- tprintf("...}");
+ tprints("...}");
break;
}
case Q_V1_GETQUOTA:
break;
}
tprintf("{version=%d, ", dq.d_version);
- tprintf("flags=");
+ tprints("flags=");
printflags(xfs_dqblk_flags,
dq.d_flags, "XFS_???_QUOTA");
tprintf(", fieldmask=%#x, ", dq.d_fieldmask);
tprintf("rtbtimer=%d, ", dq.d_rtbtimer);
tprintf("rtbwarns=%u}", dq.d_rtbwarns);
} else
- tprintf("...}");
+ tprints("...}");
break;
}
case Q_GETFMT:
tprintf("{???} %#lx", data);
break;
}
- tprintf("{");
+ tprints("{");
printxval(quota_formats, fmt, "QFMT_VFS_???");
- tprintf("}");
+ tprints("}");
break;
}
case Q_GETINFO:
tprintf("{bgrace=%" PRIu64 ", ", dq.dqi_bgrace);
tprintf("igrace=%" PRIu64 ", ", dq.dqi_igrace);
tprintf("flags=%#x, ", dq.dqi_flags);
- tprintf("valid=");
+ tprints("valid=");
printflags(if_dqinfo_valid, dq.dqi_valid, "IIF_???");
- tprintf("}");
+ tprints("}");
break;
}
case Q_V2_GETINFO:
}
tprintf("{version=%d, ", dq.qs_version);
if (abbrev(tcp)) {
- tprintf("...}");
+ tprints("...}");
break;
}
- tprintf("flags=");
+ tprints("flags=");
printflags(xfs_quota_flags,
dq.qs_flags, "XFS_QUOTA_???");
tprintf(", incoredqs=%u, ", dq.qs_incoredqs);
tprintf("{???} %#lx", data);
break;
}
- tprintf("{");
+ tprints("{");
printflags(xfs_quota_flags, flag, "XFS_QUOTA_???");
- tprintf("}");
+ tprints("}");
break;
}
default:
if (entering(tcp)) {
printxval(quotacmds, cmd, "Q_???");
- tprintf("|");
+ tprints("|");
printxval(quotatypes, type, "???QUOTA");
- tprintf(", ");
+ tprints(", ");
printstr(tcp, tcp->u_arg[1], -1);
- tprintf(", ");
+ tprints(", ");
switch (cmd) {
case Q_V1_QUOTAON:
case Q_QUOTAON:
tprintf("%#lx", tcp->u_arg[2]);
break;
}
- tprintf(", ");
+ tprints(", ");
} else {
if (!tcp->u_arg[3])
- tprintf("NULL");
+ tprints("NULL");
else
decode_cmd_data(tcp, cmd, tcp->u_arg[3]);
}
if (entering(tcp)) {
#ifdef SUNOS4
printxval(quotacmds, tcp->u_arg[0], "Q_???");
- tprintf(", ");
+ tprints(", ");
printstr(tcp, tcp->u_arg[1], -1);
#endif
#ifdef FREEBSD
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printxval(quotacmds, tcp->u_arg[1], "Q_???");
#endif
tprintf(", %lu, %#lx", tcp->u_arg[2], tcp->u_arg[3]);
} rlim;
if (umove(tcp, tcp->u_arg[1], &rlim) < 0)
- tprintf("{...}");
+ tprints("{...}");
else {
tprintf("{rlim_cur=%s,",
sprintrlim(rlim.rlim_cur == -1 ? RLIM_INFINITY
if (entering(tcp)) {
printxval(resources, tcp->u_arg[0], "RLIMIT_???");
- tprintf(", ");
+ tprints(", ");
}
else {
if (syserror(tcp) || !verbose(tcp))
print_rlimit32(tcp);
# endif
else if (umove(tcp, tcp->u_arg[1], &rlim) < 0)
- tprintf("{...}");
+ tprints("{...}");
else {
tprintf("{rlim_cur=%s,", sprintrlim(rlim.rlim_cur));
tprintf(" rlim_max=%s}", sprintrlim(rlim.rlim_max));
if (entering(tcp)) {
printxval(resources, tcp->u_arg[0], "RLIMIT_???");
- tprintf(", ");
+ tprints(", ");
if (!verbose(tcp))
tprintf("%#lx", tcp->u_arg[1]);
# if defined LINUX && (defined POWERPC64 || defined X86_64)
print_rlimit32(tcp);
# endif
else if (umove(tcp, tcp->u_arg[1], &rlim) < 0)
- tprintf("{...}");
+ tprints("{...}");
else {
tprintf("{rlim_cur=%s,", sprintrlim(rlim.rlim_cur));
tprintf(" rlim_max=%s}", sprintrlim(rlim.rlim_max));
if (entering(tcp)) {
printxval(resources, tcp->u_arg[0], "RLIMIT_???");
- tprintf(", ");
+ tprints(", ");
}
else {
if (syserror(tcp) || !verbose(tcp))
tprintf("%#lx", tcp->u_arg[1]);
else if (umove(tcp, tcp->u_arg[1], &rlim) < 0)
- tprintf("{...}");
+ tprints("{...}");
else {
tprintf("{rlim_cur=%s,", sprintrlim64(rlim.rlim_cur));
tprintf(" rlim_max=%s}", sprintrlim64(rlim.rlim_max));
if (entering(tcp)) {
printxval(resources, tcp->u_arg[0], "RLIMIT_???");
- tprintf(", ");
+ tprints(", ");
if (!verbose(tcp))
tprintf("%#lx", tcp->u_arg[1]);
else if (umove(tcp, tcp->u_arg[1], &rlim) < 0)
- tprintf("{...}");
+ tprints("{...}");
else {
tprintf("{rlim_cur=%s,", sprintrlim64(rlim.rlim_cur));
tprintf(" rlim_max=%s}", sprintrlim64(rlim.rlim_max));
} ru;
if (!addr)
- tprintf("NULL");
+ tprints("NULL");
else if (syserror(tcp) || !verbose(tcp))
tprintf("%#lx", addr);
else if (umove(tcp, addr, &ru) < 0)
- tprintf("{...}");
+ tprints("{...}");
else if (!abbrev(tcp)) {
tprintf("{ru_utime={%lu, %lu}, ru_stime={%lu, %lu}, ",
(long) ru.ru_utime.tv_sec, (long) ru.ru_utime.tv_usec,
struct rusage ru;
if (!addr)
- tprintf("NULL");
+ tprints("NULL");
else if (syserror(tcp) || !verbose(tcp))
tprintf("%#lx", addr);
else if (umove(tcp, addr, &ru) < 0)
- tprintf("{...}");
+ tprints("{...}");
else if (!abbrev(tcp)) {
tprintf("{ru_utime={%lu, %lu}, ru_stime={%lu, %lu}, ",
(long) ru.ru_utime.tv_sec, (long) ru.ru_utime.tv_usec,
{
if (entering(tcp)) {
printxval(usagewho, tcp->u_arg[0], "RUSAGE_???");
- tprintf(", ");
+ tprints(", ");
}
else
printrusage(tcp, tcp->u_arg[1]);
{
if (entering(tcp)) {
printxval(usagewho, tcp->u_arg[0], "RUSAGE_???");
- tprintf(", ");
+ tprints(", ");
}
else
printrusage32(tcp, tcp->u_arg[1]);
if (syserror(tcp) || !verbose(tcp))
tprintf("%#lx", tcp->u_arg[0]);
else if (umove(tcp, tcp->u_arg[0], &si) < 0)
- tprintf("{...}");
+ tprints("{...}");
else {
tprintf("{uptime=%lu, loads=[%lu, %lu, %lu] ",
si.uptime, si.loads[0], si.loads[1],
if (exiting(tcp)) {
if (tcp->u_arg[0] == 0)
- tprintf("NULL");
+ tprints("NULL");
else if (syserror(tcp))
tprintf("%#lx", tcp->u_arg[0]);
else if (umove(tcp, tcp->u_arg[0], &tbuf) < 0)
- tprintf("{...}");
+ tprints("{...}");
else {
tprintf("{tms_utime=%lu, tms_stime=%lu, ",
tbuf.tms_utime, tbuf.tms_stime);
tprintf(", %02x", buf[i]);
free(buf);
if (allocated != len)
- tprintf(", ...");
+ tprints(", ...");
}
static void
tprintf(", data[%u]=[", sg_io->dxfer_len);
printstr(tcp, (unsigned long) sg_io->dxferp,
sg_io->dxfer_len);
- tprintf("]");
+ tprints("]");
}
}
tprintf(", data[%u]=[", sg_io->dxfer_len);
printstr(tcp, (unsigned long) sg_io->dxferp,
sg_io->dxfer_len);
- tprintf("]");
+ tprints("]");
}
tprintf(", status=%02x, ", sg_io->status);
tprintf("masked_status=%02x, ", sg_io->masked_status);
if (umove(tcp, arg, &sg_io) < 0)
tprintf(", %#lx", arg);
else {
- tprintf(", ");
+ tprints(", ");
print_sg_io_req(tcp, &sg_io);
}
}
if (!syserror(tcp) && umove(tcp, arg, &sg_io) >= 0)
print_sg_io_res(tcp, &sg_io);
else
- tprintf("}");
+ tprints("}");
}
break;
default:
sigset_t ss;
if (!addr)
- tprintf("NULL");
+ tprints("NULL");
else if (copy_sigset(tcp, addr, &ss) < 0)
tprintf("%#lx", addr);
else
const char *code;
if (sip->si_signo == 0) {
- tprintf("{}");
+ tprints("{}");
return;
}
- tprintf("{si_signo=");
+ tprints("{si_signo=");
printsignal(sip->si_signo);
code = xlookup(siginfo_codes, sip->si_code);
if (!code) {
if (!sip->si_ptr)
break;
if (!verbose)
- tprintf(", ...");
+ tprints(", ...");
else
tprintf(", si_value={int=%u, ptr=%#lx}",
sip->si_int,
printsignal(sip->si_status);
#if LINUX
if (!verbose)
- tprintf(", ...");
+ tprints(", ...");
else
tprintf(", si_utime=%lu, si_stime=%lu",
sip->si_utime,
if (!sip->si_ptr)
break;
if (!verbose)
- tprintf(", ...");
+ tprints(", ...");
else {
tprintf(", si_value={int=%u, ptr=%#lx}",
sip->si_int,
}
}
}
- tprintf("}");
+ tprints("}");
}
#endif /* SVR4 || LINUX */
if (entering(tcp)) {
printsignal(tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
addr = tcp->u_arg[1];
} else {
addr = tcp->u_arg[2];
}
if (addr == 0)
- tprintf("NULL");
+ tprints("NULL");
else if (!verbose(tcp))
tprintf("%#lx", addr);
else if (umove(tcp, addr, &sv) < 0)
- tprintf("{...}");
+ tprints("{...}");
else {
switch ((int) sv.sv_handler) {
case (int) SIG_ERR:
- tprintf("{SIG_ERR}");
+ tprints("{SIG_ERR}");
break;
case (int) SIG_DFL:
- tprintf("{SIG_DFL}");
+ tprints("{SIG_DFL}");
break;
case (int) SIG_IGN:
if (tcp->u_arg[0] == SIGTRAP) {
tcp->flags |= TCB_SIGTRAPPED;
kill(tcp->pid, SIGSTOP);
}
- tprintf("{SIG_IGN}");
+ tprints("{SIG_IGN}");
break;
case (int) SIG_HOLD:
if (tcp->u_arg[0] == SIGTRAP) {
tcp->flags |= TCB_SIGTRAPPED;
kill(tcp->pid, SIGSTOP);
}
- tprintf("SIG_HOLD");
+ tprints("SIG_HOLD");
break;
default:
if (tcp->u_arg[0] == SIGTRAP) {
}
tprintf("{%#lx, ", (unsigned long) sv.sv_handler);
printsigmask(&sv.sv_mask, 0);
- tprintf(", ");
+ tprints(", ");
printflags(sigvec_flags, sv.sv_flags, "SV_???");
- tprintf("}");
+ tprints("}");
}
}
if (entering(tcp))
- tprintf(", ");
+ tprints(", ");
return 0;
}
else
addr = tcp->u_arg[1];
if (addr == 0)
- tprintf("NULL");
+ tprints("NULL");
else if (umove(tcp, addr, &ss) < 0)
tprintf("%#lx", addr);
else {
tprintf("ss_onstack %s}", ss.ss_onstack ? "YES" : "NO");
}
if (entering(tcp))
- tprintf(", ");
+ tprints(", ");
return 0;
}
if (entering(tcp)) {
printsignal(tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
addr = tcp->u_arg[1];
} else
addr = tcp->u_arg[2];
if (addr == 0)
- tprintf("NULL");
+ tprints("NULL");
else if (!verbose(tcp))
tprintf("%#lx", addr);
else if (umove(tcp, addr, &sa) < 0)
- tprintf("{...}");
+ tprints("{...}");
else {
/* Architectures using function pointers, like
* hppa, may need to manipulate the function pointer
* compiler from generating code to manipulate
* SA_HANDLER we cast the function pointers to long. */
if ((long)sa.SA_HANDLER == (long)SIG_ERR)
- tprintf("{SIG_ERR, ");
+ tprints("{SIG_ERR, ");
else if ((long)sa.SA_HANDLER == (long)SIG_DFL)
- tprintf("{SIG_DFL, ");
+ tprints("{SIG_DFL, ");
else if ((long)sa.SA_HANDLER == (long)SIG_IGN) {
#ifndef USE_PROCFS
if (tcp->u_arg[0] == SIGTRAP) {
kill(tcp->pid, SIGSTOP);
}
#endif /* !USE_PROCFS */
- tprintf("{SIG_IGN, ");
+ tprints("{SIG_IGN, ");
}
else {
#ifndef USE_PROCFS
long_to_sigset(sa.sa_mask, &sigset);
printsigmask(&sigset, 0);
#endif
- tprintf(", ");
+ tprints(", ");
printflags(sigact_flags, sa.sa_flags, "SA_???");
#ifdef SA_RESTORER
if (sa.sa_flags & SA_RESTORER)
tprintf(", %p", sa.sa_restorer);
#endif
- tprintf("}");
+ tprints("}");
}
}
if (entering(tcp))
- tprintf(", ");
+ tprints(", ");
#ifdef LINUX
else
tprintf(", %#lx", (unsigned long) sa.sa_restorer);
{
if (entering(tcp)) {
printsignal(tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
switch (tcp->u_arg[1]) {
case (long) SIG_ERR:
- tprintf("SIG_ERR");
+ tprints("SIG_ERR");
break;
case (long) SIG_DFL:
- tprintf("SIG_DFL");
+ tprints("SIG_DFL");
break;
case (long) SIG_IGN:
#ifndef USE_PROCFS
kill(tcp->pid, SIGSTOP);
}
#endif /* !USE_PROCFS */
- tprintf("SIG_IGN");
+ tprints("SIG_IGN");
break;
default:
#ifndef USE_PROCFS
if (entering(tcp)) {
if (umove(tcp, tcp->u_arg[0], &sigset) < 0)
- tprintf("[?]");
+ tprints("[?]");
else
printsigmask(&sigset, 0);
}
static void
printcontext(struct tcb *tcp, ucontext_t *ucp)
{
- tprintf("{");
+ tprints("{");
if (!abbrev(tcp)) {
- tprintf("uc_flags=");
+ tprints("uc_flags=");
printflags(ucontext_flags, ucp->uc_flags, "UC_???");
tprintf(", uc_link=%#lx, ", (unsigned long) ucp->uc_link);
}
- tprintf("uc_sigmask=");
+ tprints("uc_sigmask=");
printsigmask(&ucp->uc_sigmask, 0);
if (!abbrev(tcp)) {
tprintf(", uc_stack={ss_sp=%#lx, ss_size=%d, ss_flags=",
(unsigned long) ucp->uc_stack.ss_sp,
ucp->uc_stack.ss_size);
printflags(sigaltstack_flags, ucp->uc_stack.ss_flags, "SS_???");
- tprintf("}");
+ tprints("}");
}
- tprintf(", ...}");
+ tprints(", ...}");
}
int
if (tcp->u_error)
tprintf("%#lx", tcp->u_arg[0]);
else if (!tcp->u_arg[0])
- tprintf("NULL");
+ tprints("NULL");
else if (umove(tcp, tcp->u_arg[0], &uc) < 0)
- tprintf("{...}");
+ tprints("{...}");
else
printcontext(tcp, &uc);
}
if (entering(tcp)) {
if (!tcp->u_arg[0])
- tprintf("NULL");
+ tprints("NULL");
else if (umove(tcp, tcp->u_arg[0], &uc) < 0)
- tprintf("{...}");
+ tprints("{...}");
else
printcontext(tcp, &uc);
}
{
if (entering(tcp)) {
if (tcp->u_arg[0] == 0)
- tprintf("NULL");
+ tprints("NULL");
else if (print_stack_t(tcp, tcp->u_arg[0]) < 0)
return -1;
}
else {
- tprintf(", ");
+ tprints(", ");
if (tcp->u_arg[1] == 0)
- tprintf("NULL");
+ tprints("NULL");
else if (print_stack_t(tcp, tcp->u_arg[1]) < 0)
return -1;
}
#ifdef ALPHA
if (entering(tcp)) {
printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???");
- tprintf(", ");
+ tprints(", ");
printsigmask(tcp->u_arg[1], 0);
}
else if (!syserror(tcp)) {
if (entering(tcp)) {
#ifdef SVR4
if (tcp->u_arg[0] == 0)
- tprintf("0");
+ tprints("0");
else
#endif /* SVR4 */
printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???");
- tprintf(", ");
+ tprints(", ");
print_sigset(tcp, tcp->u_arg[1], 0);
- tprintf(", ");
+ tprints(", ");
}
else {
if (!tcp->u_arg[2])
- tprintf("NULL");
+ tprints("NULL");
else if (syserror(tcp))
tprintf("%#lx", tcp->u_arg[2]);
else
if (syserror(tcp))
tprintf("%#lx", tcp->u_arg[0]);
else if (copy_sigset(tcp, tcp->u_arg[0], &sigset) < 0)
- tprintf("[?]");
+ tprints("[?]");
else
printsigmask(&sigset, 0);
}
if (entering(tcp)) {
if (copy_sigset(tcp, tcp->u_arg[0], &sigset) < 0)
- tprintf("[?]");
+ tprints("[?]");
else
printsigmask(&sigset, 0);
}
/* Note: arg[3] is the length of the sigset. */
if (entering(tcp)) {
printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???");
- tprintf(", ");
+ tprints(", ");
if (!tcp->u_arg[1])
- tprintf("NULL, ");
+ tprints("NULL, ");
else if (copy_sigset_len(tcp, tcp->u_arg[1], &sigset, tcp->u_arg[3]) < 0)
tprintf("%#lx, ", tcp->u_arg[1]);
else {
printsigmask(&sigset, 1);
- tprintf(", ");
+ tprints(", ");
}
}
else {
if (!tcp->u_arg[2])
- tprintf("NULL");
+ tprints("NULL");
else if (syserror(tcp))
tprintf("%#lx", tcp->u_arg[2]);
else if (copy_sigset_len(tcp, tcp->u_arg[2], &sigset, tcp->u_arg[3]) < 0)
- tprintf("[?]");
+ tprints("[?]");
else
printsigmask(&sigset, 1);
tprintf(", %lu", tcp->u_arg[3]);
if (entering(tcp)) {
printsignal(tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
addr = tcp->u_arg[1];
} else
addr = tcp->u_arg[2];
if (addr == 0) {
- tprintf("NULL");
+ tprints("NULL");
goto after_sa;
}
if (!verbose(tcp)) {
r = umove(tcp, addr, &sa);
}
if (r < 0) {
- tprintf("{...}");
+ tprints("{...}");
goto after_sa;
}
/* Architectures using function pointers, like
* compiler from generating code to manipulate
* SA_HANDLER we cast the function pointers to long. */
if ((long)sa.__sa_handler == (long)SIG_ERR)
- tprintf("{SIG_ERR, ");
+ tprints("{SIG_ERR, ");
else if ((long)sa.__sa_handler == (long)SIG_DFL)
- tprintf("{SIG_DFL, ");
+ tprints("{SIG_DFL, ");
else if ((long)sa.__sa_handler == (long)SIG_IGN)
- tprintf("{SIG_IGN, ");
+ tprints("{SIG_IGN, ");
else
tprintf("{%#lx, ", (long) sa.__sa_handler);
/* Questionable code below.
else
memcpy(&sigset, &sa.sa_mask, sizeof(sigset));
printsigmask(&sigset, 1);
- tprintf(", ");
+ tprints(", ");
printflags(sigact_flags, sa.sa_flags, "SA_???");
#ifdef SA_RESTORER
if (sa.sa_flags & SA_RESTORER)
tprintf(", %p", sa.sa_restorer);
#endif
- tprintf("}");
+ tprints("}");
after_sa:
if (entering(tcp))
- tprintf(", ");
+ tprints(", ");
else
#ifdef LINUXSPARC
tprintf(", %#lx, %lu", tcp->u_arg[3], tcp->u_arg[4]);
tprintf("%#lx", tcp->u_arg[0]);
else if (copy_sigset_len(tcp, tcp->u_arg[0],
&sigset, tcp->u_arg[1]) < 0)
- tprintf("[?]");
+ tprints("[?]");
else
printsigmask(&sigset, 1);
}
if (entering(tcp)) {
sigset_t sigm;
if (copy_sigset_len(tcp, tcp->u_arg[0], &sigm, tcp->u_arg[1]) < 0)
- tprintf("[?]");
+ tprints("[?]");
else
printsigmask(&sigm, 1);
}
siginfo_t si;
tprintf("%lu, ", tcp->u_arg[0]);
printsignal(tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
if (umove(tcp, tcp->u_arg[2], &si) < 0)
tprintf("%#lx", tcp->u_arg[2]);
else
if (copy_sigset_len(tcp, tcp->u_arg[0],
&sigset, tcp->u_arg[3]) < 0)
- tprintf("[?]");
+ tprints("[?]");
else
printsigmask(&sigset, 1);
- tprintf(", ");
+ tprints(", ");
/* This is the only "return" parameter, */
if (tcp->u_arg[1] != 0)
return 0;
/* ... if it's NULL, can decode all on entry */
- tprintf("NULL, ");
+ tprints("NULL, ");
}
else if (tcp->u_arg[1] != 0) {
/* syscall exit, and u_arg[1] wasn't NULL */
tprintf("%#lx, ", tcp->u_arg[1]);
else {
printsiginfo(&si, verbose(tcp));
- tprintf(", ");
+ tprints(", ");
}
}
}
sys_restart_syscall(struct tcb *tcp)
{
if (entering(tcp))
- tprintf("<... resuming interrupted call ...>");
+ tprints("<... resuming interrupted call ...>");
return 0;
}
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
print_sigset(tcp, tcp->u_arg[1], 1);
tprintf(", %lu", tcp->u_arg[2]);
if (flags_arg >= 0) {
- tprintf(", ");
+ tprints(", ");
printflags(open_mode_flags, tcp->u_arg[flags_arg], "O_???");
}
}
&& ifc.ifc_buf == NULL)
tprintf(", {%d -> ", ifc.ifc_len);
else
- tprintf(", {");
+ tprints(", {");
}
return 0;
}
printxval(addrfams,
ifr.ifr_addr.sa_family,
"AF_???");
- tprintf(", ");
+ tprints(", ");
print_addr(tcp, ((long) tcp->u_arg[2]
+ offsetof(struct ifreq,
ifr_addr.sa_data)),
&ifr);
- tprintf("}");
+ tprints("}");
break;
case SIOCGIFHWADDR:
case SIOCSIFHWADDR:
break;
case SIOCGIFFLAGS:
case SIOCSIFFLAGS:
- tprintf("ifr_flags=");
+ tprints("ifr_flags=");
printflags(iffflags, ifr.ifr_flags, "IFF_???");
break;
case SIOCGIFMETRIC:
(unsigned) ifr.ifr_map.port);
break;
}
- tprintf("}");
+ tprints("}");
}
return 1;
case SIOCGIFCONF:
if (umove(tcp, tcp->u_arg[2], &ifc) < 0) {
- tprintf("???}");
+ tprints("???}");
return 1;
}
tprintf("%d, ", ifc.ifc_len);
if (syserror(tcp)) {
tprintf("%lx", (unsigned long) ifc.ifc_buf);
} else if (ifc.ifc_buf == NULL) {
- tprintf("NULL");
+ tprints("NULL");
} else {
int i;
unsigned nifra = ifc.ifc_len / sizeof(struct ifreq);
tprintf("%lx}", (unsigned long) ifc.ifc_buf);
return 1;
}
- tprintf("{");
+ tprints("{");
for (i = 0; i < nifra; ++i ) {
if (i > 0)
- tprintf(", ");
+ tprints(", ");
tprintf("{\"%s\", {",
ifra[i].ifr_name);
if (verbose(tcp)) {
printxval(addrfams,
ifra[i].ifr_addr.sa_family,
"AF_???");
- tprintf(", ");
+ tprints(", ");
print_addr(tcp, ((long) tcp->u_arg[2]
+ offsetof(struct ifreq,
ifr_addr.sa_data)
- (char *) &ifra[0])),
&ifra[i]);
} else
- tprintf("...");
- tprintf("}}");
+ tprints("...");
+ tprints("}}");
}
- tprintf("}");
+ tprints("}");
}
- tprintf("}");
+ tprints("}");
return 1;
#endif
default:
"cleanup: looking at pid %u\n", tcp->pid);
if (tcp_last &&
(!outfname || followfork < 2 || tcp_last == tcp)) {
- tprintf(" <unfinished ...>");
+ tprints(" <unfinished ...>");
printtrailer();
}
if (tcp->flags & TCB_ATTACHED)
#ifdef PR_INFO
if (tcp->status.PR_INFO.si_signo == what) {
printleader(tcp);
- tprintf(" siginfo=");
+ tprints(" siginfo=");
printsiginfo(&tcp->status.PR_INFO, 1);
printtrailer();
}
#endif
printleader(tcp);
if (ptrace(PTRACE_GETSIGINFO, pid, 0, &si) == 0) {
- tprintf("--- ");
+ tprints("--- ");
printsiginfo(&si, verbose(tcp));
tprintf(" (%s)" PC_FORMAT_STR " ---",
strsignal(WSTOPSIG(status))
* Finish the line then.
*/
tcp_last->flags |= TCB_REPRINT;
- tprintf(" <unfinished ...>");
+ tprints(" <unfinished ...>");
printtrailer();
}
detach(tcp, 0);
if (tcp_last) {
if (tcp_last->ptrace_errno) {
if (tcp_last->flags & TCB_INSYSCALL) {
- tprintf(" <unavailable>) ");
+ tprints(" <unavailable>) ");
tabto();
}
- tprintf("= ? <unavailable>\n");
+ tprints("= ? <unavailable>\n");
tcp_last->ptrace_errno = 0;
} else if (!outfname || followfork < 2 || tcp_last == tcp) {
tcp_last->flags |= TCB_REPRINT;
- tprintf(" <unfinished ...>\n");
+ tprints(" <unfinished ...>\n");
}
}
curcol = 0;
void
printtrailer(void)
{
- tprintf("\n");
+ tprints("\n");
tcp_last = NULL;
}
printstrbuf(struct tcb *tcp, struct strbuf *sbp, int getting)
{
if (sbp->maxlen == -1 && getting)
- tprintf("{maxlen=-1}");
+ tprints("{maxlen=-1}");
else {
- tprintf("{");
+ tprints("{");
if (getting)
tprintf("maxlen=%d, ", sbp->maxlen);
tprintf("len=%d, buf=", sbp->len);
printstr(tcp, (unsigned long) sbp->buf, sbp->len);
- tprintf("}");
+ tprints("}");
}
}
struct strbuf buf;
if (arg == 0)
- tprintf("NULL");
+ tprints("NULL");
else if (umove(tcp, arg, &buf) < 0)
- tprintf("{...}");
+ tprints("{...}");
else
printstrbuf(tcp, &buf, getting);
- tprintf(", ");
+ tprints(", ");
}
int
printstrbufarg(tcp, tcp->u_arg[i], 1);
/* pointer to flags */
if (tcp->u_arg[3] == 0)
- tprintf("NULL");
+ tprints("NULL");
else if (umove(tcp, tcp->u_arg[3], &flags) < 0)
- tprintf("[?]");
+ tprints("[?]");
else {
- tprintf("[");
+ tprints("[");
printflags(msgflags, flags, "RS_???");
- tprintf("]");
+ tprints("]");
}
/* decode return value */
switch (tcp->u_rval) {
printstrbufarg(tcp, tcp->u_arg[i], 1);
/* pointer to band */
printnum(tcp, tcp->u_arg[3], "%d");
- tprintf(", ");
+ tprints(", ");
/* pointer to flags */
if (tcp->u_arg[4] == 0)
- tprintf("NULL");
+ tprints("NULL");
else if (umove(tcp, tcp->u_arg[4], &flags) < 0)
- tprintf("[?]");
+ tprints("[?]");
else {
- tprintf("[");
+ tprints("[");
printflags(pmsgflags, flags, "MSG_???");
- tprintf("]");
+ tprints("]");
}
/* decode return value */
switch (tcp->u_rval) {
} else {
abbrev_end = end;
}
- tprintf("[");
+ tprints("[");
for (cur = start; cur < end; cur += sizeof(fds)) {
if (cur > start)
- tprintf(", ");
+ tprints(", ");
if (cur >= abbrev_end) {
- tprintf("...");
+ tprints("...");
break;
}
if (umoven(tcp, cur, sizeof fds, (char *) &fds) < 0) {
- tprintf("?");
+ tprints("?");
failed = 1;
break;
}
tprintf("{fd=%d}", fds.fd);
continue;
}
- tprintf("{fd=");
+ tprints("{fd=");
printfd(tcp, fds.fd);
- tprintf(", events=");
+ tprints(", events=");
printflags(pollflags, fds.events, "POLL???");
- tprintf("}");
+ tprints("}");
}
- tprintf("]");
+ tprints("]");
if (failed)
tprintf(" %#lx", start);
tprintf(", %d, ", nfds);
if (entering(tcp)) {
#ifdef INFTIM
if (tcp->u_arg[2] == INFTIM)
- tprintf("INFTIM");
+ tprints("INFTIM");
else
#endif
tprintf("%ld", tcp->u_arg[2]);
int rc = decode_poll(tcp, tcp->u_arg[2]);
if (entering(tcp)) {
print_timespec(tcp, tcp->u_arg[2]);
- tprintf(", ");
+ tprints(", ");
print_sigset(tcp, tcp->u_arg[3], 0);
tprintf(", %lu", tcp->u_arg[4]);
}
while (len >= (int) sizeof hdr) {
if (umove(tcp, addr, &hdr) < 0) break;
if (c++) {
- tprintf(", ");
+ tprints(", ");
}
else if (len > hdr.len + sizeof hdr) {
- tprintf("[");
+ tprints("[");
}
- tprintf("{level=");
+ tprints("{level=");
printxval(xti_level, hdr.level, "???");
- tprintf(", name=");
+ tprints(", name=");
switch (hdr.level) {
case XTI_GENERIC:
printxval(xti_generic, hdr.name, "XTI_???");
tprintf("%ld", hdr.name);
break;
}
- tprintf(", status=");
+ tprints(", status=");
printxval(transport_user_flags, hdr.status, "T_???");
addr += sizeof hdr;
len -= sizeof hdr;
if ((hdr.len -= sizeof hdr) > 0) {
if (hdr.len > len) break;
- tprintf(", val=");
+ tprints(", val=");
if (len == sizeof(int))
printnum(tcp, addr, "%d");
else
addr += hdr.len;
len -= hdr.len;
}
- tprintf("}");
+ tprints("}");
}
if (len > 0) {
- if (c++) tprintf(", ");
+ if (c++) tprints(", ");
printstr(tcp, addr, len);
}
- if (c > 1) tprintf("]");
+ if (c > 1) tprints("]");
}
#endif
#define GET(type, struct) \
do { \
if (len < sizeof m.struct) goto dump; \
- if (umove(tcp, addr, &m.struct) < 0) goto dump;\
- tprintf("{"); \
+ if (umove(tcp, addr, &m.struct) < 0) goto dump; \
+ tprints("{"); \
if (expect != type) { \
++c; \
- tprintf(#type); \
+ tprints(#type); \
} \
} \
while (0)
#define COMMA() \
- do { if (c++) tprintf(", "); } while (0)
+ do { if (c++) tprints(", "); } while (0)
#define STRUCT(struct, elem, print) \
m.struct.elem##_offset); \
} \
else { \
- tprintf(#elem "="); \
+ tprints(#elem "="); \
print(tcp, \
addr + m.struct.elem##_offset, \
m.struct.elem##_length); \
case T_OPTMGMT_REQ: /* manage opt req */
GET(T_OPTMGMT_REQ, optmgmt_req);
COMMA();
- tprintf("MGMT=");
+ tprints("MGMT=");
printflags(transport_user_flags, m.optmgmt_req.MGMT_flags,
"T_???");
STRUCT(optmgmt_req, OPT, print_optmgmt);
m.info_ack.ADDR_size, m.info_ack.OPT_size,
m.info_ack.TIDU_size);
printxval(service_type, m.info_ack.SERV_type, "T_???");
- tprintf(", CURRENT=");
+ tprints(", CURRENT=");
printxval(ts_state, m.info_ack.CURRENT_state, "TS_???");
- tprintf(", PROVIDER=");
+ tprints(", PROVIDER=");
printflags(provider_flags, m.info_ack.PROVIDER_flag, "???");
break;
#endif
case T_ERROR_ACK: /* error ack */
GET(T_ERROR_ACK, error_ack);
COMMA();
- tprintf("ERROR=");
+ tprints("ERROR=");
printxval(transport_user_options,
m.error_ack.ERROR_prim, "TI_???");
- tprintf(", TLI=");
+ tprints(", TLI=");
printxval(tli_errors, m.error_ack.TLI_error, "T???");
tprintf("UNIX=%s", strerror(m.error_ack.UNIX_error));
break;
case T_OK_ACK: /* ok ack */
GET(T_OK_ACK, ok_ack);
COMMA();
- tprintf("CORRECT=");
+ tprints("CORRECT=");
printxval(transport_user_options,
m.ok_ack.CORRECT_prim, "TI_???");
break;
case T_OPTMGMT_ACK: /* manage opt ack */
GET(T_OPTMGMT_ACK, optmgmt_ack);
COMMA();
- tprintf("MGMT=");
+ tprints("MGMT=");
printflags(transport_user_flags, m.optmgmt_ack.MGMT_flags,
"T_???");
STRUCT(optmgmt_ack, OPT, print_optmgmt);
break;
}
- if (c >= 0) tprintf("}");
+ if (c >= 0) tprints("}");
#undef ADDR
#undef COMMA
return 0;
if (umove(tcp, arg, &si) < 0) {
if (entering(tcp))
- tprintf(", {...}");
+ tprints(", {...}");
return 1;
}
if (entering(tcp)) {
} else
tprintf(", {ic_cmd=%#x", si.ic_cmd);
if (si.ic_timout == INFTIM)
- tprintf(", ic_timout=INFTIM, ");
+ tprints(", ic_timout=INFTIM, ");
else
tprintf(" ic_timout=%d, ", si.ic_timout);
}
}
if (in_and_out) {
if (entering(tcp))
- tprintf("/* in */ ");
+ tprints("/* in */ ");
else
- tprintf(", /* out */ ");
+ tprints(", /* out */ ");
}
if (in_and_out || entering(tcp))
tprintf("ic_len=%d, ic_dp=", si.ic_len);
if (entering(tcp))
break;
if (umove(tcp, (int) si.ic_dp, &udata) < 0)
- tprintf("{...}");
+ tprints("{...}");
else {
tprintf("{tidusize=%d, addrsize=%d, ",
udata.tidusize, udata.addrsize);
tprintf("servtype=%d, so_state=%d, ",
udata.servtype, udata.so_state);
tprintf("so_options=%d", udata.so_options);
- tprintf("}");
+ tprints("}");
}
break;
#endif /* SI_GETUDATA */
break;
}
if (exiting(tcp)) {
- tprintf("}");
+ tprints("}");
if (timod && tcp->u_rval && !syserror(tcp)) {
tcp->auxstr = xlookup(tli_errors, tcp->u_rval);
return RVAL_STR + 1;
case I_LOOK:
case I_FIND:
/* arg is a string */
- tprintf(", ");
+ tprints(", ");
printpath(tcp, arg);
return 1;
case I_POP:
return 1;
case I_FLUSH:
/* argument is an option */
- tprintf(", ");
+ tprints(", ");
printxval(stream_flush_options, arg, "FLUSH???");
return 1;
#ifdef I_FLUSHBAND
case I_FLUSHBAND:
/* argument is a pointer to a bandinfo struct */
if (umove(tcp, arg, &bi) < 0)
- tprintf(", {...}");
+ tprints(", {...}");
else {
tprintf(", {bi_pri=%d, bi_flag=", bi.bi_pri);
printflags(stream_flush_options, bi.bi_flag, "FLUSH???");
- tprintf("}");
+ tprints("}");
}
return 1;
#endif /* I_FLUSHBAND */
case I_SETSIG:
/* argument is a set of flags */
- tprintf(", ");
+ tprints(", ");
printflags(stream_setsig_flags, arg, "S_???");
return 1;
case I_GETSIG:
/* argument is a pointer to a set of flags */
if (syserror(tcp))
return 0;
- tprintf(", [");
+ tprints(", [");
if (umove(tcp, arg, &val) < 0)
- tprintf("?");
+ tprints("?");
else
printflags(stream_setsig_flags, val, "S_???");
- tprintf("]");
+ tprints("]");
return 1;
case I_PEEK:
/* argument is a pointer to a strpeek structure */
if (syserror(tcp) || !arg)
return 0;
if (umove(tcp, arg, &sp) < 0) {
- tprintf(", {...}");
+ tprints(", {...}");
return 1;
}
- tprintf(", {ctlbuf=");
+ tprints(", {ctlbuf=");
printstrbuf(tcp, &sp.ctlbuf, 1);
- tprintf(", databuf=");
+ tprints(", databuf=");
printstrbuf(tcp, &sp.databuf, 1);
- tprintf(", flags=");
+ tprints(", flags=");
printflags(msgflags, sp.flags, "RS_???");
- tprintf("}");
+ tprints("}");
return 1;
case I_SRDOPT:
/* argument is an option with flags */
- tprintf(", ");
+ tprints(", ");
printxval(stream_read_options, arg & RMODEMASK, "R???");
addflags(stream_read_flags, arg & ~RMODEMASK);
return 1;
/* argument is an pointer to an option with flags */
if (syserror(tcp))
return 0;
- tprintf(", [");
+ tprints(", [");
if (umove(tcp, arg, &val) < 0)
- tprintf("?");
+ tprints("?");
else {
printxval(stream_read_options,
arg & RMODEMASK, "R???");
addflags(stream_read_flags, arg & ~RMODEMASK);
}
- tprintf("]");
+ tprints("]");
return 1;
case I_NREAD:
#ifdef I_GETBAND
/* argument is a pointer to a decimal integer */
if (syserror(tcp))
return 0;
- tprintf(", ");
+ tprints(", ");
printnum(tcp, arg, "%d");
return 1;
case I_FDINSERT:
if (syserror(tcp) || !arg)
return 0;
if (umove(tcp, arg, &sfi) < 0) {
- tprintf(", {...}");
+ tprints(", {...}");
return 1;
}
- tprintf(", {ctlbuf=");
+ tprints(", {ctlbuf=");
printstrbuf(tcp, &sfi.ctlbuf, 1);
- tprintf(", databuf=");
+ tprints(", databuf=");
printstrbuf(tcp, &sfi.databuf, 1);
- tprintf(", flags=");
+ tprints(", flags=");
printflags(msgflags, sfi.flags, "RS_???");
tprintf(", filedes=%d, offset=%d}", sfi.fildes, sfi.offset);
return 1;
#ifdef I_SWROPT
case I_SWROPT:
/* argument is a set of flags */
- tprintf(", ");
+ tprints(", ");
printflags(stream_write_flags, arg, "SND???");
return 1;
#endif /* I_SWROPT */
/* argument is an pointer to an option with flags */
if (syserror(tcp))
return 0;
- tprintf(", [");
+ tprints(", [");
if (umove(tcp, arg, &val) < 0)
- tprintf("?");
+ tprints("?");
else
printflags(stream_write_flags, arg, "SND???");
- tprintf("]");
+ tprints("]");
return 1;
#endif /* I_GWROPT */
case I_SENDFD:
if (syserror(tcp) || !arg)
return 0;
if (umove(tcp, arg, &srf) < 0) {
- tprintf(", {...}");
+ tprints(", {...}");
return 1;
}
tprintf(", {fd=%d, uid=%lu, gid=%lu}", srf.fd,
if (syserror(tcp))
return 0;
if (arg == 0) {
- tprintf(", NULL");
+ tprints(", NULL");
return 1;
}
if (umove(tcp, arg, &sl) < 0) {
- tprintf(", {...}");
+ tprints(", {...}");
return 1;
}
tprintf(", {sl_nmods=%d, sl_modlist=[", sl.sl_nmods);
for (i = 0; i < tcp->u_rval; i++) {
if (i)
- tprintf(", ");
+ tprints(", ");
printpath(tcp, (int) sl.sl_modlist[i].l_name);
}
- tprintf("]}");
+ tprints("]}");
return 1;
#endif /* I_LIST */
#ifdef I_ATMARK
case I_ATMARK:
- tprintf(", ");
+ tprints(", ");
printxval(stream_atmark_options, arg, "???MARK");
return 1;
#endif /* I_ATMARK */
}
if (res != 1) {
- tprintf(") ");
+ tprints(") ");
tabto();
- tprintf("= ? <unavailable>");
+ tprints("= ? <unavailable>");
printtrailer();
tcp->flags &= ~TCB_INSYSCALL;
return res;
sys_res = (*sysent[tcp->scno].sys_func)(tcp);
}
- tprintf(") ");
+ tprints(") ");
tabto();
u_error = tcp->u_error;
if (!SCNO_IN_RANGE(tcp->scno) ||
switch (u_error) {
#ifdef LINUX
case ERESTARTSYS:
- tprintf("= ? ERESTARTSYS (To be restarted)");
+ tprints("= ? ERESTARTSYS (To be restarted)");
break;
case ERESTARTNOINTR:
- tprintf("= ? ERESTARTNOINTR (To be restarted)");
+ tprints("= ? ERESTARTNOINTR (To be restarted)");
break;
case ERESTARTNOHAND:
- tprintf("= ? ERESTARTNOHAND (To be restarted)");
+ tprints("= ? ERESTARTNOHAND (To be restarted)");
break;
case ERESTART_RESTARTBLOCK:
- tprintf("= ? ERESTART_RESTARTBLOCK (To be restarted)");
+ tprints("= ? ERESTART_RESTARTBLOCK (To be restarted)");
break;
#endif /* LINUX */
default:
}
else {
if (sys_res & RVAL_NONE)
- tprintf("= ?");
+ tprints("= ?");
else {
switch (sys_res & RVAL_MASK) {
case RVAL_HEX:
ignore_type = ignore_data = 1;
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printpath(tcp, tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
if (ignore_type && tcp->u_arg[2])
tprintf("%#lx", tcp->u_arg[2]);
else
printstr(tcp, tcp->u_arg[2], -1);
- tprintf(", ");
+ tprints(", ");
printflags(mount_flags, tcp->u_arg[3], "MS_???");
- tprintf(", ");
+ tprints(", ");
if (ignore_data && tcp->u_arg[4])
tprintf("%#lx", tcp->u_arg[4]);
{
if (entering(tcp)) {
printstr(tcp, tcp->u_arg[0], -1);
- tprintf(", ");
+ tprints(", ");
printflags(umount_flags, tcp->u_arg[1], "MNT_???");
}
return 0;
{
if (entering(tcp)) {
printflags(bootflags1, tcp->u_arg[0], "LINUX_REBOOT_MAGIC_???");
- tprintf(", ");
+ tprints(", ");
printflags(bootflags2, tcp->u_arg[1], "LINUX_REBOOT_MAGIC_???");
- tprintf(", ");
+ tprints(", ");
printflags(bootflags3, tcp->u_arg[2], "LINUX_REBOOT_CMD_???");
if (tcp->u_arg[2] == LINUX_REBOOT_CMD_RESTART2) {
- tprintf(", ");
+ tprints(", ");
printstr(tcp, tcp->u_arg[3], -1);
}
}
tprintf("%#lx, ", tcp->u_arg[0]);
/* scope */
printxval(cacheflush_scope, tcp->u_arg[1], "FLUSH_SCOPE_???");
- tprintf(", ");
+ tprints(", ");
/* flags */
printflags(cacheflush_flags, tcp->u_arg[2], "FLUSH_CACHE_???");
/* len */
tprintf("\"%s\", ", type);
}
printstr(tcp, tcp->u_arg[1], -1);
- tprintf(", ");
+ tprints(", ");
printflags(mountflags, tcp->u_arg[2] & ~M_NEWTYPE, "M_???");
- tprintf(", ");
+ tprints(", ");
if (strcmp(type, "4.2") == 0) {
struct ufs_args a;
struct nfs_args a;
if (umove(tcp, tcp->u_arg[3], &a) < 0)
return 0;
- tprintf("[");
+ tprints("[");
printsock(tcp, (int) a.addr);
- tprintf(", ");
+ tprints(", ");
printflags(nfsflags, a.flags, "NFSMNT_???");
tprintf(", ws:%u,rs:%u,to:%u,re:%u,",
a.wsize, a.rsize, a.timeo, a.retrans);
printstr(tcp, (int) a.netname, -1);
else
tprintf("%#lx", (unsigned long) a.netname);
- tprintf("]");
+ tprints("]");
} else if (strcmp(type, "rfs") == 0) {
struct rfs_args a;
struct token t;
if (umove(tcp, tcp->u_arg[3], &a) < 0)
return 0;
- tprintf("[");
+ tprints("[");
printstr(tcp, (int)a.rmtfs, -1);
if (umove(tcp, (int)a.token, &t) < 0)
return 0;
}
tprintf("{fl:%u, anon:%u, ", e.ex_flags, e.ex_anon);
printxval(ex_auth_flags, e.ex_auth, "AUTH_???");
- tprintf(", roots:[");
+ tprints(", roots:[");
if (e.ex_auth == AUTH_UNIX) {
for (i = 0; i < e.ex_u.exunix.rootaddrs.naddrs; i++) {
printsock(tcp,
(int)&e.ex_u.exunix.rootaddrs.addrvec[i]);
}
- tprintf("], writers:[");
+ tprints("], writers:[");
for (i = 0; i < e.ex_writeaddrs.naddrs; i++) {
printsock(tcp,
(int)&e.ex_writeaddrs.addrvec[i]);
}
- tprintf("]");
+ tprints("]");
} else {
for (i = 0; i < e.ex_u.exdes.nnames; i++) {
printsock(tcp,
(int)&e.ex_u.exdes.rootnames[i]);
- tprintf(", ");
+ tprints(", ");
}
tprintf("], window:%u", e.ex_u.exdes.window);
}
- tprintf("}");
+ tprints("}");
}
return 0;
}
{
if (entering(tcp)) {
printstr(tcp, tcp->u_arg[0], -1);
- tprintf(", ");
+ tprints(", ");
printxval(pathconflimits, tcp->u_arg[1], "_PC_???");
}
return 0;
{
if (entering(tcp)) {
printxval(sysinfo_options, tcp->u_arg[0], "SI_???");
- tprintf(", ");
+ tprints(", ");
}
else {
/* Technically some calls write values. So what. */
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printpath(tcp, tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
printflags(mount_flags, tcp->u_arg[2], "MS_???");
if (tcp->u_arg[2] & (MS_FSS | MS_DATA)) {
- tprintf(", ");
+ tprints(", ");
tprintf("%ld", tcp->u_arg[3]);
}
if (tcp->u_arg[2] & MS_DATA) {
int nfs_type = sysfs(GETFSIND, FSID_NFS);
- tprintf(", ");
+ tprints(", ");
if (tcp->u_arg[3] == nfs_type) {
struct nfs_args args;
if (umove(tcp, tcp->u_arg[4], &args) < 0)
tprintf("%#lx", tcp->u_arg[4]);
else {
- tprintf("addr=");
+ tprints("addr=");
printsock(tcp, (int) args.addr);
- tprintf(", flags=");
+ tprints(", flags=");
printflags(nfs_flags, args.flags, "NFSMNT_???");
- tprintf(", hostname=");
+ tprints(", hostname=");
printstr(tcp, (int) args.hostname, -1);
- tprintf(", ...}");
+ tprints(", ...}");
}
}
else
if (entering(tcp)) {
char fstyp[FSTYPSZ];
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printpath(tcp, tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
printflags(mount_flags, tcp->u_arg[2], "MS_???");
/* The doc sez that the file system type is given as a
fsindex, and we should use sysfs to work out the name.
tprintf(", \"%s\"", fstyp);
}
if (tcp->u_arg[2] & MS_DATA) {
- tprintf(", ");
+ tprints(", ");
#ifdef VX_MS_MASK
/* On UW7 they don't give us the defines and structs
we need to see what is going on. Bummer. */
if (umove(tcp, tcp->u_arg[4], &args) < 0)
tprintf("%#lx", tcp->u_arg[4]);
else {
- tprintf("{ flags=");
+ tprints("{ flags=");
printflags(vxfs_flags, args.mflags, "VX_MS_???");
if (args.mflags & VX_MS_SNAPSHOT) {
- tprintf(", snapof=");
+ tprints(", snapof=");
printstr(tcp,
(long) args.primaryspec,
-1);
if (args.snapsize > 0)
tprintf(", snapsize=%ld", args.snapsize);
}
- tprintf(" }");
+ tprints(" }");
}
}
else
#endif
if (strcmp(fstyp, "specfs") == 0) {
- tprintf("dev=");
+ tprints("dev=");
printstr(tcp, tcp->u_arg[4], -1);
}
else
tprintf("%#lx", tcp->u_arg[4]);
else {
struct netbuf addr;
- tprintf("{ addr=");
+ tprints("{ addr=");
if (umove(tcp, (int) args.addr, &addr) < 0) {
tprintf("%#lx", (long) args.addr);
}
else {
printsock(tcp, (int) addr.buf, addr.len);
}
- tprintf(", flags=");
+ tprints(", flags=");
printflags(nfs_flags, args.flags, "NFSMNT_???");
- tprintf(", hostname=");
+ tprints(", hostname=");
printstr(tcp, (int) args.hostname, -1);
- tprintf(", ...}");
+ tprints(", ...}");
}
}
else
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printpath(tcp, tcp->u_arg[1]);
- tprintf(", ...");
+ tprints(", ...");
}
return 0;
}
if (!entering(tcp)) {
if (!tcp->u_arg[0])
- tprintf("NULL");
+ 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)
- tprintf("???");
+ tprints("???");
else {
tprintf("%#x, %d", arg0->version, arg0->pid);
}
- tprintf(", ");
+ tprints(", ");
if (!tcp->u_arg[1])
- tprintf("NULL");
+ 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)
- tprintf("???");
+ tprints("???");
else {
- tprintf("{");
+ tprints("{");
printflags(capabilities, arg1->effective, "CAP_???");
- tprintf(", ");
+ tprints(", ");
printflags(capabilities, arg1->permitted, "CAP_???");
- tprintf(", ");
+ tprints(", ");
printflags(capabilities, arg1->inheritable, "CAP_???");
- tprintf("}");
+ tprints("}");
}
}
return 0;
if (entering(tcp)) {
if (!tcp->u_arg[0])
- tprintf("NULL");
+ 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)
- tprintf("???");
+ tprints("???");
else {
tprintf("%#x, %d", arg0->version, arg0->pid);
}
- tprintf(", ");
+ tprints(", ");
if (!tcp->u_arg[1])
- tprintf("NULL");
+ 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)
- tprintf("???");
+ tprints("???");
else {
- tprintf("{");
+ tprints("{");
printflags(capabilities, arg1->effective, "CAP_???");
- tprintf(", ");
+ tprints(", ");
printflags(capabilities, arg1->permitted, "CAP_???");
- tprintf(", ");
+ tprints(", ");
printflags(capabilities, arg1->inheritable, "CAP_???");
- tprintf("}");
+ tprints("}");
}
}
return 0;
if (entering(tcp)) {
int cnt = 0, max_cnt;
- tprintf("{{");
+ tprints("{{");
if (info.nlen == 0)
goto out;
goto out;
switch (name[0]) {
case CTL_KERN:
- tprintf(", ");
+ tprints(", ");
printxval(sysctl_kern, name[1], "KERN_???");
++cnt;
break;
case CTL_VM:
- tprintf(", ");
+ tprints(", ");
printxval(sysctl_vm, name[1], "VM_???");
++cnt;
break;
case CTL_NET:
- tprintf(", ");
+ tprints(", ");
printxval(sysctl_net, name[1], "NET_???");
++cnt;
goto out;
switch (name[1]) {
case NET_CORE:
- tprintf(", ");
+ tprints(", ");
printxval(sysctl_net_core, name[2],
"NET_CORE_???");
break;
case NET_UNIX:
- tprintf(", ");
+ tprints(", ");
printxval(sysctl_net_unix, name[2],
"NET_UNIX_???");
break;
case NET_IPV4:
- tprintf(", ");
+ tprints(", ");
printxval(sysctl_net_ipv4, name[2],
"NET_IPV4_???");
goto out;
switch (name[2]) {
case NET_IPV4_ROUTE:
- tprintf(", ");
+ tprints(", ");
printxval(sysctl_net_ipv4_route,
name[3],
"NET_IPV4_ROUTE_???");
break;
case NET_IPV4_CONF:
- tprintf(", ");
+ tprints(", ");
printxval(sysctl_net_ipv4_conf,
name[3],
"NET_IPV4_CONF_???");
}
break;
case NET_IPV6:
- tprintf(", ");
+ tprints(", ");
printxval(sysctl_net_ipv6, name[2],
"NET_IPV6_???");
goto out;
switch (name[2]) {
case NET_IPV6_ROUTE:
- tprintf(", ");
+ tprints(", ");
printxval(sysctl_net_ipv6_route,
name[3],
"NET_IPV6_ROUTE_???");
while (cnt < max_cnt)
tprintf(", %x", name[cnt++]);
if (cnt < info.nlen)
- tprintf(", ...");
+ tprints(", ...");
tprintf("}, %d, ", info.nlen);
} else {
size_t oldlen;
printpath(tcp, (size_t)info.oldval);
tprintf(", %Zu, ", oldlen);
if (info.newval == 0)
- tprintf("NULL");
+ tprints("NULL");
else if (syserror(tcp))
tprintf("%p", info.newval);
else
tprintf("%p, %Zd, %p, %Zd", info.oldval, oldlen,
info.newval, info.newlen);
}
- tprintf("}");
+ tprints("}");
}
free(name);
if (tcp->u_arg[1] < 0 || tcp->u_arg[1] > CTL_MAXNAME ||
(umoven(tcp, tcp->u_arg[0], tcp->u_arg[1] * sizeof(int),
(char *) (qoid + 2)) < 0))
- tprintf("[...], ");
+ tprints("[...], ");
else {
/* Use sysctl to ask the name of the current MIB
This uses the undocumented "Staff-functions" used
qoid[0] = 0; /* sysctl */
qoid[1] = 1; /* name */
i = sizeof(ctl);
- tprintf("[");
+ tprints("[");
if (sysctl(qoid, tcp->u_arg[1] + 2, ctl, &i, 0, 0) >= 0) {
numeric = !abbrev(tcp);
tprintf("%s%s", ctl, numeric ? ", " : "");
for (i = 0; i < tcp->u_arg[1]; i++)
tprintf("%s%d", i ? "." : "", qoid[i + 2]);
}
- tprintf("], ");
+ tprints("], ");
tprintf("%lu, ", tcp->u_arg[1]);
}
} else {
{
if (entering(tcp)) {
printstr(tcp, tcp->u_arg[0], -1);
- tprintf(", ");
+ tprints(", ");
}
else {
if (syserror(tcp)) {
else {
int val;
printnum(tcp, tcp->u_arg[1], "%#lx");
- tprintf(", ");
+ tprints(", ");
if (umove(tcp, tcp->u_arg[2], &val) < 0) {
tprintf("%#lx", tcp->u_arg[2]);
}
else {
- tprintf("[");
+ tprints("[");
printxval(ksym_flags, val, "STT_???");
- tprintf("]");
+ tprints("]");
}
}
}
tprintf("%#lx, %ld", tcp->u_arg[0], tcp->u_arg[1]);
return 0;
}
- tprintf("{id=");
+ tprints("{id=");
printxval(ssi_cmd, iov.tio_id.id_cmd, "SSISYS_???");
tprintf(":%d", iov.tio_id.id_ver);
switch (iov.tio_id.id_cmd) {
if (!verbose(tcp) || umove(tcp, arg, &tios) < 0)
return 0;
if (abbrev(tcp)) {
- tprintf(", {");
+ tprints(", {");
#ifndef FREEBSD
printxval(baud_options, tios.c_cflag & CBAUD, "B???");
#else
printxval(baud_options, tios.c_ispeed, "B???");
if (tios.c_ispeed != tios.c_ospeed) {
- tprintf(" (in)");
+ tprints(" (in)");
printxval(baud_options, tios.c_ospeed, "B???");
- tprintf(" (out)");
+ tprints(" (out)");
}
#endif
tprintf(" %sopost %sisig %sicanon %secho ...}",
if (!verbose(tcp) || umove(tcp, arg, &tio) < 0)
return 0;
if (abbrev(tcp)) {
- tprintf(", {");
+ tprints(", {");
printxval(baud_options, tio.c_cflag & CBAUD, "B???");
tprintf(" %sopost %sisig %sicanon %secho ...}",
(tio.c_oflag & OPOST) ? "" : "-",
/* ioctls with a direct decodable arg */
#ifdef TCXONC
case TCXONC:
- tprintf(", ");
+ tprints(", ");
printxval(tcxonc_options, arg, "TC???");
return 1;
#endif
#ifdef TCLFLSH
case TCFLSH:
- tprintf(", ");
+ tprints(", ");
printxval(tcflsh_options, arg, "TC???");
return 1;
#endif
case TIOCMSET:
if (umove(tcp, arg, &i) < 0)
return 0;
- tprintf(", [");
+ tprints(", [");
printflags(modem_flags, i, "TIOCM_???");
- tprintf("]");
+ tprints("]");
return 1;
#endif /* TIOCMGET */
#ifdef TIOCGPTN
case TIOCGPTN:
#endif
- tprintf(", ");
+ tprints(", ");
printnum_int(tcp, arg, "%d");
return 1;
#ifdef TIOCSTI
case TIOCSTI:
#endif
- tprintf(", ");
+ tprints(", ");
printstr(tcp, arg, 1);
return 1;
printtv_bitness(struct tcb *tcp, long addr, enum bitness_t bitness, int special)
{
if (addr == 0)
- tprintf("NULL");
+ tprints("NULL");
else if (!verbose(tcp))
tprintf("%#lx", addr);
else {
if (rc >= 0) {
if (special && tv.tv_sec == 0 &&
tv.tv_usec == UTIME_NOW)
- tprintf("UTIME_NOW");
+ tprints("UTIME_NOW");
else if (special && tv.tv_sec == 0 &&
tv.tv_usec == UTIME_OMIT)
- tprintf("UTIME_OMIT");
+ tprints("UTIME_OMIT");
else
tprint_timeval32(tcp, &tv);
}
if (rc >= 0) {
if (special && tv.tv_sec == 0 &&
tv.tv_usec == UTIME_NOW)
- tprintf("UTIME_NOW");
+ tprints("UTIME_NOW");
else if (special && tv.tv_sec == 0 &&
tv.tv_usec == UTIME_OMIT)
- tprintf("UTIME_OMIT");
+ tprints("UTIME_OMIT");
else
tprint_timeval(tcp, &tv);
}
}
if (rc < 0)
- tprintf("{...}");
+ tprints("{...}");
}
}
void print_timespec(struct tcb *tcp, long addr)
{
if (addr == 0)
- tprintf("NULL");
+ tprints("NULL");
else if (!verbose(tcp))
tprintf("%#lx", addr);
else {
(unsigned long) ts.tv_nsec);
}
if (rc < 0)
- tprintf("{...}");
+ tprints("{...}");
}
}
}
printtv(tcp, tcp->u_arg[0]);
#ifndef SVR4
- tprintf(", ");
+ tprints(", ");
printtv(tcp, tcp->u_arg[1]);
#endif /* !SVR4 */
}
}
printtv_bitness(tcp, tcp->u_arg[0], BITNESS_32, 0);
#ifndef SVR4
- tprintf(", ");
+ tprints(", ");
printtv_bitness(tcp, tcp->u_arg[1], BITNESS_32, 0);
#endif /* !SVR4 */
}
if (entering(tcp)) {
printtv(tcp, tcp->u_arg[0]);
#ifndef SVR4
- tprintf(", ");
+ tprints(", ");
printtv(tcp, tcp->u_arg[1]);
#endif /* !SVR4 */
}
if (entering(tcp)) {
printtv_bitness(tcp, tcp->u_arg[0], BITNESS_32, 0);
#ifndef SVR4
- tprintf(", ");
+ tprints(", ");
printtv_bitness(tcp, tcp->u_arg[1], BITNESS_32, 0);
#endif /* !SVR4 */
}
{
if (entering(tcp)) {
printtv(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
if (syserror(tcp))
tprintf("%#lx", tcp->u_arg[1]);
{
if (entering(tcp)) {
print_timespec(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
if (!tcp->u_arg[1] || is_restart_error(tcp))
print_timespec(tcp, tcp->u_arg[1]);
printitv_bitness(struct tcb *tcp, long addr, enum bitness_t bitness)
{
if (addr == 0)
- tprintf("NULL");
+ tprints("NULL");
else if (!verbose(tcp))
tprintf("%#lx", addr);
else {
rc = umove(tcp, addr, &itv);
if (rc >= 0) {
- tprintf("{it_interval=");
+ tprints("{it_interval=");
tprint_timeval32(tcp, &itv.it_interval);
- tprintf(", it_value=");
+ tprints(", it_value=");
tprint_timeval32(tcp, &itv.it_value);
- tprintf("}");
+ tprints("}");
}
} else {
struct itimerval itv;
rc = umove(tcp, addr, &itv);
if (rc >= 0) {
- tprintf("{it_interval=");
+ tprints("{it_interval=");
tprint_timeval(tcp, &itv.it_interval);
- tprintf(", it_value=");
+ tprints(", it_value=");
tprint_timeval(tcp, &itv.it_value);
- tprintf("}");
+ tprints("}");
}
}
if (rc < 0)
- tprintf("{...}");
+ tprints("{...}");
}
}
{
if (entering(tcp)) {
printxval(which, tcp->u_arg[0], "ITIMER_???");
- tprintf(", ");
+ tprints(", ");
} else {
if (syserror(tcp))
tprintf("%#lx", tcp->u_arg[1]);
{
if (entering(tcp)) {
printxval(which, tcp->u_arg[0], "ITIMER_???");
- tprintf(", ");
+ tprints(", ");
} else {
if (syserror(tcp))
tprintf("%#lx", tcp->u_arg[1]);
{
if (entering(tcp)) {
printxval(which, tcp->u_arg[0], "ITIMER_???");
- tprintf(", ");
+ tprints(", ");
printitv(tcp, tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
} else {
if (syserror(tcp))
tprintf("%#lx", tcp->u_arg[2]);
{
if (entering(tcp)) {
printxval(which, tcp->u_arg[0], "ITIMER_???");
- tprintf(", ");
+ tprints(", ");
printitv_bitness(tcp, tcp->u_arg[1], BITNESS_32);
- tprintf(", ");
+ tprints(", ");
} else {
if (syserror(tcp))
tprintf("%#lx", tcp->u_arg[2]);
if (umove(tcp, addr, &tx) < 0)
return -1;
- tprintf("{modes=");
+ tprints("{modes=");
printflags(adjtimex_modes, tx.modes, "ADJ_???");
tprintf(", offset=%d, freq=%d, maxerror=%d, ",
tx.offset, tx.freq, tx.maxerror);
tx.shift, tx.stabil, tx.jitcnt);
tprintf(", calcnt=%d, errcnt=%d, stbcnt=%d",
tx.calcnt, tx.errcnt, tx.stbcnt);
- tprintf("}");
+ tprints("}");
return 0;
}
#endif /* SUPPORTED_PERSONALITIES > 1 */
tprintf("tolerance=%ld, time=", tx.tolerance);
tprint_timeval(tcp, &tx.time);
#else
- tprintf("{modes=");
+ tprints("{modes=");
printflags(adjtimex_modes, tx.modes, "ADJ_???");
tprintf(", offset=%ld, freq=%ld, maxerror=%ld, ",
tx.offset, tx.freq, tx.maxerror);
tprintf(", calcnt=%ld, errcnt=%ld, stbcnt=%ld",
tx.calcnt, tx.errcnt, tx.stbcnt);
#endif
- tprintf("}");
+ tprints("}");
return 0;
}
{
if (exiting(tcp)) {
if (tcp->u_arg[0] == 0)
- tprintf("NULL");
+ tprints("NULL");
else if (syserror(tcp) || !verbose(tcp))
tprintf("%#lx", tcp->u_arg[0]);
else if (tprint_timex(tcp, tcp->u_arg[0]) < 0)
- tprintf("{...}");
+ tprints("{...}");
if (syserror(tcp))
return 0;
tcp->auxstr = xlookup(adjtimex_state, tcp->u_rval);
{
if (entering(tcp)) {
printxval(clocknames, tcp->u_arg[0], "CLOCK_???");
- tprintf(", ");
+ tprints(", ");
printtv(tcp, tcp->u_arg[1]);
}
return 0;
{
if (entering(tcp)) {
printxval(clocknames, tcp->u_arg[0], "CLOCK_???");
- tprintf(", ");
+ tprints(", ");
} else {
if (syserror(tcp))
tprintf("%#lx", tcp->u_arg[1]);
{
if (entering(tcp)) {
printxval(clocknames, tcp->u_arg[0], "CLOCK_???");
- tprintf(", ");
+ tprints(", ");
printflags(clockflags, tcp->u_arg[1], "TIMER_???");
- tprintf(", ");
+ tprints(", ");
printtv(tcp, tcp->u_arg[2]);
- tprintf(", ");
+ tprints(", ");
} else {
if (syserror(tcp))
tprintf("%#lx", tcp->u_arg[3]);
} sev;
if (umove(tcp, arg, &sev) < 0)
- tprintf("{...}");
+ tprints("{...}");
else {
tprintf("{%#x, ", sev.sigev_value);
if (sev.sigev_notify == SIGEV_SIGNAL)
else
tprintf("%u, ", sev.sigev_signo);
printxval(sigev_value, sev.sigev_notify + 1, "SIGEV_???");
- tprintf(", ");
+ tprints(", ");
if (sev.sigev_notify == SIGEV_THREAD_ID)
tprintf("{%d}", sev.un.tid);
else if (sev.sigev_notify == SIGEV_THREAD)
sev.un.thread.function,
sev.un.thread.attribute);
else
- tprintf("{...}");
- tprintf("}");
+ tprints("{...}");
+ tprints("}");
}
}
#endif
}
#endif
if (umove(tcp, arg, &sev) < 0)
- tprintf("{...}");
+ tprints("{...}");
else {
tprintf("{%p, ", sev.sigev_value.sival_ptr);
if (sev.sigev_notify == SIGEV_SIGNAL)
else
tprintf("%u, ", sev.sigev_signo);
printxval(sigev_value, sev.sigev_notify+1, "SIGEV_???");
- tprintf(", ");
+ tprints(", ");
if (sev.sigev_notify == SIGEV_THREAD_ID)
/* _pad[0] is the _tid field which might not be
present in the userlevel definition of the
tprintf("{%p, %p}", sev.sigev_notify_function,
sev.sigev_notify_attributes);
else
- tprintf("{...}");
- tprintf("}");
+ tprints("{...}");
+ tprints("}");
}
}
{
if (entering(tcp)) {
printxval(clocknames, tcp->u_arg[0], "CLOCK_???");
- tprintf(", ");
+ tprints(", ");
printsigevent(tcp, tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
} else {
int timer_id;
if (entering(tcp)) {
tprintf("%#lx, ", tcp->u_arg[0]);
printflags(clockflags, tcp->u_arg[1], "TIMER_???");
- tprintf(", ");
+ tprints(", ");
printitv(tcp, tcp->u_arg[2]);
- tprintf(", ");
+ tprints(", ");
} else {
if (syserror(tcp))
tprintf("%#lx", tcp->u_arg[3]);
tprintf("tm_wday=%d, tm_yday=%d, tm_isdst=%d}",
rt->tm_wday, rt->tm_yday, rt->tm_isdst);
else
- tprintf("...}");
+ tprints("...}");
}
int
if (umove(tcp, arg, &rt) < 0)
tprintf(", %#lx", arg);
else {
- tprintf(", ");
+ tprints(", ");
print_rtc(tcp, &rt);
}
}
if (syserror(tcp) || umove(tcp, arg, &rt) < 0)
tprintf(", %#lx", arg);
else {
- tprintf(", ");
+ tprints(", ");
print_rtc(tcp, &rt);
}
}
tprintf(", {enabled=%d, pending=%d, ",
wk.enabled, wk.pending);
print_rtc(tcp, &wk.time);
- tprintf("}");
+ tprints("}");
}
}
break;
tprintf(", {enabled=%d, pending=%d, ",
wk.enabled, wk.pending);
print_rtc(tcp, &wk.time);
- tprintf("}");
+ tprints("}");
}
}
break;
/* It does not matter that the kernel uses itimerspec. */
tprintf("%ld, ", tcp->u_arg[0]);
printxval(clocknames, tcp->u_arg[1], "CLOCK_???");
- tprintf(", ");
+ tprints(", ");
printflags(timerfdflags, tcp->u_arg[2], "TFD_???");
- tprintf(", ");
+ tprints(", ");
printitv(tcp, tcp->u_arg[3]);
}
return 0;
{
if (entering(tcp)) {
printxval(clocknames, tcp->u_arg[0], "CLOCK_???");
- tprintf(", ");
+ tprints(", ");
printflags(timerfdflags, tcp->u_arg[1], "TFD_???");
}
return 0;
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printflags(timerfdflags, tcp->u_arg[1], "TFD_???");
- tprintf(", ");
+ tprints(", ");
printitv(tcp, tcp->u_arg[2]);
- tprintf(", ");
+ tprints(", ");
printitv(tcp, tcp->u_arg[3]);
}
return 0;
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printitv(tcp, tcp->u_arg[1]);
}
return 0;
tprintf(" /* %s */", dflt);
} else {
if (dflt)
- tprintf("0");
+ tprints("0");
}
}
long num;
if (!addr) {
- tprintf("NULL");
+ tprints("NULL");
return;
}
if (umove(tcp, addr, &num) < 0) {
tprintf("%#lx", addr);
return;
}
- tprintf("[");
+ tprints("[");
tprintf(fmt, num);
- tprintf("]");
+ tprints("]");
}
void
int num;
if (!addr) {
- tprintf("NULL");
+ tprints("NULL");
return;
}
if (umove(tcp, addr, &num) < 0) {
tprintf("%#lx", addr);
return;
}
- tprintf("[");
+ tprints("[");
tprintf(fmt, num);
- tprintf("]");
+ tprints("]");
}
void
printpathn(struct tcb *tcp, long addr, int n)
{
if (!addr) {
- tprintf("NULL");
+ tprints("NULL");
return;
}
const char *fmt;
if (!addr) {
- tprintf("NULL");
+ tprints("NULL");
return;
}
/* Allocate static buffers if they are not allocated yet. */
long pc;
if (upeek(tcp, 4*PT_PC, &pc) < 0) {
- tprintf("[????????] ");
+ tprints("[????????] ");
return;
}
tprintf("[%08lx] ", pc);
long pc;
if (upeek(tcp, REG_PC, &pc) < 0) {
- tprintf("[????????????????] ");
+ tprints("[????????????????] ");
return;
}
tprintf("[%08lx] ", pc);
long pc;
if (upeek(tcp, PT_IAOQ0, &pc) < 0) {
- tprintf("[????????] ");
+ tprints("[????????] ");
return;
}
tprintf("[%08lx] ", pc);
long pc;
if (upeek(tcp, REG_EPC, &pc) < 0) {
- tprintf("[????????] ");
+ tprints("[????????] ");
return;
}
tprintf("[%08lx] ", pc);
long pc;
if (upeek(tcp, 4*REG_PC, &pc) < 0) {
- tprintf("[????????] ");
+ tprints("[????????] ");
return;
}
tprintf("[%08lx] ", pc);
long pc;
if (upeek(tcp, REG_PC, &pc) < 0) {
- tprintf("[????????????????] ");
+ tprints("[????????????????] ");
return;
}
tprintf("[%08lx] ", pc);
long pc;
if (upeek(tcp, REG_PC, &pc) < 0) {
- tprintf("[????????] ");
+ tprints("[????????] ");
return;
}
tprintf("[%08lx] ", pc);
projects / strace / commitdiff