Home | History | Annotate | Download | only in strace
      1 /*
      2  * Copyright (c) 1991, 1992 Paul Kranenburg <pk (at) cs.few.eur.nl>
      3  * Copyright (c) 1993 Branko Lankester <branko (at) hacktic.nl>
      4  * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs (at) world.std.com>
      5  * Copyright (c) 1996-1999 Wichert Akkerman <wichert (at) cistron.nl>
      6  * Copyright (c) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation
      7  *                     Linux for s390 port by D.J. Barrow
      8  *                    <barrow_dj (at) mail.yahoo.com,djbarrow (at) de.ibm.com>
      9  * All rights reserved.
     10  *
     11  * Redistribution and use in source and binary forms, with or without
     12  * modification, are permitted provided that the following conditions
     13  * are met:
     14  * 1. Redistributions of source code must retain the above copyright
     15  *    notice, this list of conditions and the following disclaimer.
     16  * 2. Redistributions in binary form must reproduce the above copyright
     17  *    notice, this list of conditions and the following disclaimer in the
     18  *    documentation and/or other materials provided with the distribution.
     19  * 3. The name of the author may not be used to endorse or promote products
     20  *    derived from this software without specific prior written permission.
     21  *
     22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     24  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     25  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     27  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     31  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     32  */
     33 
     34 #include "defs.h"
     35 #include <sys/param.h>
     36 #include <fcntl.h>
     37 #include <stdarg.h>
     38 #ifdef HAVE_SYS_XATTR_H
     39 # include <sys/xattr.h>
     40 #endif
     41 #include <sys/uio.h>
     42 #include <asm/unistd.h>
     43 
     44 #include "scno.h"
     45 #include "regs.h"
     46 #include "ptrace.h"
     47 
     48 int
     49 string_to_uint_ex(const char *const str, char **const endptr,
     50 		  const unsigned int max_val, const char *const accepted_ending)
     51 {
     52 	char *end;
     53 	long val;
     54 
     55 	if (!*str)
     56 		return -1;
     57 
     58 	errno = 0;
     59 	val = strtol(str, &end, 10);
     60 
     61 	if (str == end || val < 0 || (unsigned long) val > max_val
     62 	    || (val == LONG_MAX && errno == ERANGE))
     63 		return -1;
     64 
     65 	if (*end && (!accepted_ending || !strchr(accepted_ending, *end)))
     66 		return -1;
     67 
     68 	if (endptr)
     69 		*endptr = end;
     70 
     71 	return (int) val;
     72 }
     73 
     74 int
     75 string_to_uint(const char *const str)
     76 {
     77 	return string_to_uint_upto(str, INT_MAX);
     78 }
     79 
     80 int
     81 tv_nz(const struct timeval *a)
     82 {
     83 	return a->tv_sec || a->tv_usec;
     84 }
     85 
     86 int
     87 tv_cmp(const struct timeval *a, const struct timeval *b)
     88 {
     89 	if (a->tv_sec < b->tv_sec
     90 	    || (a->tv_sec == b->tv_sec && a->tv_usec < b->tv_usec))
     91 		return -1;
     92 	if (a->tv_sec > b->tv_sec
     93 	    || (a->tv_sec == b->tv_sec && a->tv_usec > b->tv_usec))
     94 		return 1;
     95 	return 0;
     96 }
     97 
     98 double
     99 tv_float(const struct timeval *tv)
    100 {
    101 	return tv->tv_sec + tv->tv_usec/1000000.0;
    102 }
    103 
    104 void
    105 tv_add(struct timeval *tv, const struct timeval *a, const struct timeval *b)
    106 {
    107 	tv->tv_sec = a->tv_sec + b->tv_sec;
    108 	tv->tv_usec = a->tv_usec + b->tv_usec;
    109 	if (tv->tv_usec >= 1000000) {
    110 		tv->tv_sec++;
    111 		tv->tv_usec -= 1000000;
    112 	}
    113 }
    114 
    115 void
    116 tv_sub(struct timeval *tv, const struct timeval *a, const struct timeval *b)
    117 {
    118 	tv->tv_sec = a->tv_sec - b->tv_sec;
    119 	tv->tv_usec = a->tv_usec - b->tv_usec;
    120 	if (((long) tv->tv_usec) < 0) {
    121 		tv->tv_sec--;
    122 		tv->tv_usec += 1000000;
    123 	}
    124 }
    125 
    126 void
    127 tv_div(struct timeval *tv, const struct timeval *a, int n)
    128 {
    129 	tv->tv_usec = (a->tv_sec % n * 1000000 + a->tv_usec + n / 2) / n;
    130 	tv->tv_sec = a->tv_sec / n + tv->tv_usec / 1000000;
    131 	tv->tv_usec %= 1000000;
    132 }
    133 
    134 void
    135 tv_mul(struct timeval *tv, const struct timeval *a, int n)
    136 {
    137 	tv->tv_usec = a->tv_usec * n;
    138 	tv->tv_sec = a->tv_sec * n + tv->tv_usec / 1000000;
    139 	tv->tv_usec %= 1000000;
    140 }
    141 
    142 const char *
    143 xlookup(const struct xlat *xlat, const uint64_t val)
    144 {
    145 	for (; xlat->str != NULL; xlat++)
    146 		if (xlat->val == val)
    147 			return xlat->str;
    148 	return NULL;
    149 }
    150 
    151 static int
    152 xlat_bsearch_compare(const void *a, const void *b)
    153 {
    154 	const uint64_t val1 = *(const uint64_t *) a;
    155 	const uint64_t val2 = ((const struct xlat *) b)->val;
    156 	return (val1 > val2) ? 1 : (val1 < val2) ? -1 : 0;
    157 }
    158 
    159 const char *
    160 xlat_search(const struct xlat *xlat, const size_t nmemb, const uint64_t val)
    161 {
    162 	const struct xlat *e =
    163 		bsearch((const void*) &val,
    164 			xlat, nmemb, sizeof(*xlat), xlat_bsearch_compare);
    165 
    166 	return e ? e->str : NULL;
    167 }
    168 
    169 #if !defined HAVE_STPCPY
    170 char *
    171 stpcpy(char *dst, const char *src)
    172 {
    173 	while ((*dst = *src++) != '\0')
    174 		dst++;
    175 	return dst;
    176 }
    177 #endif
    178 
    179 /* Find a next bit which is set.
    180  * Starts testing at cur_bit.
    181  * Returns -1 if no more bits are set.
    182  *
    183  * We never touch bytes we don't need to.
    184  * On big-endian, array is assumed to consist of
    185  * current_wordsize wide words: for example, is current_wordsize is 4,
    186  * the bytes are walked in 3,2,1,0, 7,6,5,4, 11,10,9,8 ... sequence.
    187  * On little-endian machines, word size is immaterial.
    188  */
    189 int
    190 next_set_bit(const void *bit_array, unsigned cur_bit, unsigned size_bits)
    191 {
    192 	const unsigned endian = 1;
    193 	int little_endian = * (char *) (void *) &endian;
    194 
    195 	const uint8_t *array = bit_array;
    196 	unsigned pos = cur_bit / 8;
    197 	unsigned pos_xor_mask = little_endian ? 0 : current_wordsize-1;
    198 
    199 	for (;;) {
    200 		uint8_t bitmask;
    201 		uint8_t cur_byte;
    202 
    203 		if (cur_bit >= size_bits)
    204 			return -1;
    205 		cur_byte = array[pos ^ pos_xor_mask];
    206 		if (cur_byte == 0) {
    207 			cur_bit = (cur_bit + 8) & (-8);
    208 			pos++;
    209 			continue;
    210 		}
    211 		bitmask = 1 << (cur_bit & 7);
    212 		for (;;) {
    213 			if (cur_byte & bitmask)
    214 				return cur_bit;
    215 			cur_bit++;
    216 			if (cur_bit >= size_bits)
    217 				return -1;
    218 			bitmask <<= 1;
    219 			/* This check *can't be* optimized out: */
    220 			if (bitmask == 0)
    221 				break;
    222 		}
    223 		pos++;
    224 	}
    225 }
    226 
    227 /**
    228  * Print entry in struct xlat table, if there.
    229  *
    230  * @param val  Value to search a literal representation for.
    231  * @param dflt String (abbreviated in comment syntax) which should be emitted
    232  *             if no appropriate xlat value has been found.
    233  * @param xlat (And the following arguments) Pointers to arrays of xlat values.
    234  *             The last argument should be NULL.
    235  * @return     1 if appropriate xlat value has been found, 0 otherwise.
    236  */
    237 int
    238 printxvals(const uint64_t val, const char *dflt, const struct xlat *xlat, ...)
    239 {
    240 	va_list args;
    241 
    242 	va_start(args, xlat);
    243 	for (; xlat; xlat = va_arg(args, const struct xlat *)) {
    244 		const char *str = xlookup(xlat, val);
    245 
    246 		if (str) {
    247 			tprints(str);
    248 			va_end(args);
    249 			return 1;
    250 		}
    251 	}
    252 	/* No hits -- print raw # instead. */
    253 	tprintf("%#" PRIx64, val);
    254 	if (dflt)
    255 		tprintf(" /* %s */", dflt);
    256 
    257 	va_end(args);
    258 
    259 	return 0;
    260 }
    261 
    262 /**
    263  * Print entry in sorted struct xlat table, if it is there.
    264  *
    265  * @param xlat      Pointer to an array of xlat values (not terminated with
    266  *                  XLAT_END).
    267  * @param xlat_size Number of xlat elements present in array (usually ARRAY_SIZE
    268  *                  if array is declared in the unit's scope and not
    269  *                  terminated with XLAT_END).
    270  * @param val       Value to search literal representation for.
    271  * @param dflt      String (abbreviated in comment syntax) which should be
    272  *                  emitted if no appropriate xlat value has been found.
    273  * @return          1 if appropriate xlat value has been found, 0
    274  *                  otherwise.
    275  */
    276 int
    277 printxval_searchn(const struct xlat *xlat, size_t xlat_size, uint64_t val,
    278 	const char *dflt)
    279 {
    280 	const char *s = xlat_search(xlat, xlat_size, val);
    281 
    282 	if (s) {
    283 		tprints(s);
    284 		return 1;
    285 	}
    286 
    287 	tprintf("%#" PRIx64, val);
    288 	if (dflt)
    289 		tprintf(" /* %s */", dflt);
    290 
    291 	return 0;
    292 }
    293 
    294 /*
    295  * Fetch 64bit argument at position arg_no and
    296  * return the index of the next argument.
    297  */
    298 int
    299 getllval(struct tcb *tcp, unsigned long long *val, int arg_no)
    300 {
    301 #if SIZEOF_KERNEL_LONG_T > 4
    302 # ifndef current_klongsize
    303 	if (current_klongsize < SIZEOF_KERNEL_LONG_T) {
    304 #  if defined(AARCH64) || defined(POWERPC64)
    305 		/* Align arg_no to the next even number. */
    306 		arg_no = (arg_no + 1) & 0xe;
    307 #  endif /* AARCH64 || POWERPC64 */
    308 		*val = ULONG_LONG(tcp->u_arg[arg_no], tcp->u_arg[arg_no + 1]);
    309 		arg_no += 2;
    310 	} else
    311 # endif /* !current_klongsize */
    312 	{
    313 		*val = tcp->u_arg[arg_no];
    314 		arg_no++;
    315 	}
    316 #else /* SIZEOF_KERNEL_LONG_T == 4 */
    317 # if defined __ARM_EABI__ || \
    318      defined LINUX_MIPSO32 || \
    319      defined POWERPC || \
    320      defined XTENSA
    321 	/* Align arg_no to the next even number. */
    322 	arg_no = (arg_no + 1) & 0xe;
    323 # elif defined SH
    324 	/*
    325 	 * The SH4 ABI does allow long longs in odd-numbered registers, but
    326 	 * does not allow them to be split between registers and memory - and
    327 	 * there are only four argument registers for normal functions.  As a
    328 	 * result, pread, for example, takes an extra padding argument before
    329 	 * the offset.  This was changed late in the 2.4 series (around 2.4.20).
    330 	 */
    331 	if (arg_no == 3)
    332 		arg_no++;
    333 # endif /* __ARM_EABI__ || LINUX_MIPSO32 || POWERPC || XTENSA || SH */
    334 	*val = ULONG_LONG(tcp->u_arg[arg_no], tcp->u_arg[arg_no + 1]);
    335 	arg_no += 2;
    336 #endif
    337 
    338 	return arg_no;
    339 }
    340 
    341 /*
    342  * Print 64bit argument at position arg_no and
    343  * return the index of the next argument.
    344  */
    345 int
    346 printllval(struct tcb *tcp, const char *format, int arg_no)
    347 {
    348 	unsigned long long val = 0;
    349 
    350 	arg_no = getllval(tcp, &val, arg_no);
    351 	tprintf(format, val);
    352 	return arg_no;
    353 }
    354 
    355 /*
    356  * Interpret `xlat' as an array of flags
    357  * print the entries whose bits are on in `flags'
    358  * return # of flags printed.
    359  */
    360 void
    361 addflags(const struct xlat *xlat, uint64_t flags)
    362 {
    363 	for (; xlat->str; xlat++) {
    364 		if (xlat->val && (flags & xlat->val) == xlat->val) {
    365 			tprintf("|%s", xlat->str);
    366 			flags &= ~xlat->val;
    367 		}
    368 	}
    369 	if (flags) {
    370 		tprintf("|%#" PRIx64, flags);
    371 	}
    372 }
    373 
    374 /*
    375  * Interpret `xlat' as an array of flags.
    376  * Print to static string the entries whose bits are on in `flags'
    377  * Return static string.
    378  */
    379 const char *
    380 sprintflags(const char *prefix, const struct xlat *xlat, uint64_t flags)
    381 {
    382 	static char outstr[1024];
    383 	char *outptr;
    384 	int found = 0;
    385 
    386 	outptr = stpcpy(outstr, prefix);
    387 
    388 	if (flags == 0 && xlat->val == 0 && xlat->str) {
    389 		strcpy(outptr, xlat->str);
    390 		return outstr;
    391 	}
    392 
    393 	for (; xlat->str; xlat++) {
    394 		if (xlat->val && (flags & xlat->val) == xlat->val) {
    395 			if (found)
    396 				*outptr++ = '|';
    397 			outptr = stpcpy(outptr, xlat->str);
    398 			found = 1;
    399 			flags &= ~xlat->val;
    400 			if (!flags)
    401 				break;
    402 		}
    403 	}
    404 	if (flags) {
    405 		if (found)
    406 			*outptr++ = '|';
    407 		outptr += sprintf(outptr, "%#" PRIx64, flags);
    408 	}
    409 
    410 	return outstr;
    411 }
    412 
    413 int
    414 printflags64(const struct xlat *xlat, uint64_t flags, const char *dflt)
    415 {
    416 	int n;
    417 	const char *sep;
    418 
    419 	if (flags == 0 && xlat->val == 0 && xlat->str) {
    420 		tprints(xlat->str);
    421 		return 1;
    422 	}
    423 
    424 	sep = "";
    425 	for (n = 0; xlat->str; xlat++) {
    426 		if (xlat->val && (flags & xlat->val) == xlat->val) {
    427 			tprintf("%s%s", sep, xlat->str);
    428 			flags &= ~xlat->val;
    429 			sep = "|";
    430 			n++;
    431 		}
    432 	}
    433 
    434 	if (n) {
    435 		if (flags) {
    436 			tprintf("%s%#" PRIx64, sep, flags);
    437 			n++;
    438 		}
    439 	} else {
    440 		if (flags) {
    441 			tprintf("%#" PRIx64, flags);
    442 			if (dflt)
    443 				tprintf(" /* %s */", dflt);
    444 		} else {
    445 			if (dflt)
    446 				tprints("0");
    447 		}
    448 	}
    449 
    450 	return n;
    451 }
    452 
    453 void
    454 printaddr(const kernel_ulong_t addr)
    455 {
    456 	if (!addr)
    457 		tprints("NULL");
    458 	else
    459 		tprintf("%#" PRI_klx, addr);
    460 }
    461 
    462 #define DEF_PRINTNUM(name, type) \
    463 bool									\
    464 printnum_ ## name(struct tcb *const tcp, const kernel_ulong_t addr,	\
    465 		  const char *const fmt)				\
    466 {									\
    467 	type num;							\
    468 	if (umove_or_printaddr(tcp, addr, &num))			\
    469 		return false;						\
    470 	tprints("[");							\
    471 	tprintf(fmt, num);						\
    472 	tprints("]");							\
    473 	return true;							\
    474 }
    475 
    476 #define DEF_PRINTNUM_ADDR(name, type) \
    477 bool									\
    478 printnum_addr_ ## name(struct tcb *tcp, const kernel_ulong_t addr)	\
    479 {									\
    480 	type num;							\
    481 	if (umove_or_printaddr(tcp, addr, &num))			\
    482 		return false;						\
    483 	tprints("[");							\
    484 	printaddr(num);							\
    485 	tprints("]");							\
    486 	return true;							\
    487 }
    488 
    489 #define DEF_PRINTPAIR(name, type) \
    490 bool									\
    491 printpair_ ## name(struct tcb *const tcp, const kernel_ulong_t addr,	\
    492 		   const char *const fmt)				\
    493 {									\
    494 	type pair[2];							\
    495 	if (umove_or_printaddr(tcp, addr, &pair))			\
    496 		return false;						\
    497 	tprints("[");							\
    498 	tprintf(fmt, pair[0]);						\
    499 	tprints(", ");							\
    500 	tprintf(fmt, pair[1]);						\
    501 	tprints("]");							\
    502 	return true;							\
    503 }
    504 
    505 DEF_PRINTNUM(int, int)
    506 DEF_PRINTNUM_ADDR(int, unsigned int)
    507 DEF_PRINTPAIR(int, int)
    508 DEF_PRINTNUM(short, short)
    509 DEF_PRINTNUM(int64, uint64_t)
    510 DEF_PRINTNUM_ADDR(int64, uint64_t)
    511 DEF_PRINTPAIR(int64, uint64_t)
    512 
    513 #ifndef current_wordsize
    514 bool
    515 printnum_long_int(struct tcb *const tcp, const kernel_ulong_t addr,
    516 		  const char *const fmt_long, const char *const fmt_int)
    517 {
    518 	if (current_wordsize > sizeof(int)) {
    519 		return printnum_int64(tcp, addr, fmt_long);
    520 	} else {
    521 		return printnum_int(tcp, addr, fmt_int);
    522 	}
    523 }
    524 
    525 bool
    526 printnum_addr_long_int(struct tcb *tcp, const kernel_ulong_t addr)
    527 {
    528 	if (current_wordsize > sizeof(int)) {
    529 		return printnum_addr_int64(tcp, addr);
    530 	} else {
    531 		return printnum_addr_int(tcp, addr);
    532 	}
    533 }
    534 #endif /* !current_wordsize */
    535 
    536 #ifndef current_klongsize
    537 bool
    538 printnum_addr_klong_int(struct tcb *tcp, const kernel_ulong_t addr)
    539 {
    540 	if (current_klongsize > sizeof(int)) {
    541 		return printnum_addr_int64(tcp, addr);
    542 	} else {
    543 		return printnum_addr_int(tcp, addr);
    544 	}
    545 }
    546 #endif /* !current_klongsize */
    547 
    548 const char *
    549 sprinttime(time_t t)
    550 {
    551 	struct tm *tmp;
    552 	static char buf[sizeof(int) * 3 * 6 + sizeof("+0000")];
    553 
    554 	if (t == 0) {
    555 		strcpy(buf, "0");
    556 		return buf;
    557 	}
    558 	tmp = localtime(&t);
    559 	if (tmp)
    560 		strftime(buf, sizeof(buf), "%FT%T%z", tmp);
    561 	else
    562 		snprintf(buf, sizeof(buf), "%lu", (unsigned long) t);
    563 
    564 	return buf;
    565 }
    566 
    567 enum sock_proto
    568 getfdproto(struct tcb *tcp, int fd)
    569 {
    570 #ifdef HAVE_SYS_XATTR_H
    571 	size_t bufsize = 256;
    572 	char buf[bufsize];
    573 	ssize_t r;
    574 	char path[sizeof("/proc/%u/fd/%u") + 2 * sizeof(int)*3];
    575 
    576 	if (fd < 0)
    577 		return SOCK_PROTO_UNKNOWN;
    578 
    579 	sprintf(path, "/proc/%u/fd/%u", tcp->pid, fd);
    580 	r = getxattr(path, "system.sockprotoname", buf, bufsize - 1);
    581 	if (r <= 0)
    582 		return SOCK_PROTO_UNKNOWN;
    583 	else {
    584 		/*
    585 		 * This is a protection for the case when the kernel
    586 		 * side does not append a null byte to the buffer.
    587 		 */
    588 		buf[r] = '\0';
    589 
    590 		return get_proto_by_name(buf);
    591 	}
    592 #else
    593 	return SOCK_PROTO_UNKNOWN;
    594 #endif
    595 }
    596 
    597 void
    598 printfd(struct tcb *tcp, int fd)
    599 {
    600 	char path[PATH_MAX + 1];
    601 	if (show_fd_path && getfdpath(tcp, fd, path, sizeof(path)) >= 0) {
    602 		static const char socket_prefix[] = "socket:[";
    603 		const size_t socket_prefix_len = sizeof(socket_prefix) - 1;
    604 		const size_t path_len = strlen(path);
    605 
    606 		tprintf("%d<", fd);
    607 		if (show_fd_path > 1 &&
    608 		    strncmp(path, socket_prefix, socket_prefix_len) == 0 &&
    609 		    path[path_len - 1] == ']') {
    610 			unsigned long inode =
    611 				strtoul(path + socket_prefix_len, NULL, 10);
    612 
    613 			if (!print_sockaddr_by_inode_cached(inode)) {
    614 				const enum sock_proto proto =
    615 					getfdproto(tcp, fd);
    616 				if (!print_sockaddr_by_inode(inode, proto))
    617 					tprints(path);
    618 			}
    619 		} else {
    620 			print_quoted_string(path, path_len,
    621 					    QUOTE_OMIT_LEADING_TRAILING_QUOTES);
    622 		}
    623 		tprints(">");
    624 	} else
    625 		tprintf("%d", fd);
    626 }
    627 
    628 /*
    629  * Quote string `instr' of length `size'
    630  * Write up to (3 + `size' * 4) bytes to `outstr' buffer.
    631  *
    632  * If QUOTE_0_TERMINATED `style' flag is set,
    633  * treat `instr' as a NUL-terminated string,
    634  * checking up to (`size' + 1) bytes of `instr'.
    635  *
    636  * If QUOTE_OMIT_LEADING_TRAILING_QUOTES `style' flag is set,
    637  * do not add leading and trailing quoting symbols.
    638  *
    639  * Returns 0 if QUOTE_0_TERMINATED is set and NUL was seen, 1 otherwise.
    640  * Note that if QUOTE_0_TERMINATED is not set, always returns 1.
    641  */
    642 int
    643 string_quote(const char *instr, char *outstr, const unsigned int size,
    644 	     const unsigned int style)
    645 {
    646 	const unsigned char *ustr = (const unsigned char *) instr;
    647 	char *s = outstr;
    648 	unsigned int i;
    649 	int usehex, c, eol;
    650 
    651 	if (style & QUOTE_0_TERMINATED)
    652 		eol = '\0';
    653 	else
    654 		eol = 0x100; /* this can never match a char */
    655 
    656 	usehex = 0;
    657 	if ((xflag > 1) || (style & QUOTE_FORCE_HEX)) {
    658 		usehex = 1;
    659 	} else if (xflag) {
    660 		/* Check for presence of symbol which require
    661 		   to hex-quote the whole string. */
    662 		for (i = 0; i < size; ++i) {
    663 			c = ustr[i];
    664 			/* Check for NUL-terminated string. */
    665 			if (c == eol)
    666 				break;
    667 
    668 			/* Force hex unless c is printable or whitespace */
    669 			if (c > 0x7e) {
    670 				usehex = 1;
    671 				break;
    672 			}
    673 			/* In ASCII isspace is only these chars: "\t\n\v\f\r".
    674 			 * They happen to have ASCII codes 9,10,11,12,13.
    675 			 */
    676 			if (c < ' ' && (unsigned)(c - 9) >= 5) {
    677 				usehex = 1;
    678 				break;
    679 			}
    680 		}
    681 	}
    682 
    683 	if (!(style & QUOTE_OMIT_LEADING_TRAILING_QUOTES))
    684 		*s++ = '\"';
    685 
    686 	if (usehex) {
    687 		/* Hex-quote the whole string. */
    688 		for (i = 0; i < size; ++i) {
    689 			c = ustr[i];
    690 			/* Check for NUL-terminated string. */
    691 			if (c == eol)
    692 				goto asciz_ended;
    693 			*s++ = '\\';
    694 			*s++ = 'x';
    695 			*s++ = "0123456789abcdef"[c >> 4];
    696 			*s++ = "0123456789abcdef"[c & 0xf];
    697 		}
    698 	} else {
    699 		for (i = 0; i < size; ++i) {
    700 			c = ustr[i];
    701 			/* Check for NUL-terminated string. */
    702 			if (c == eol)
    703 				goto asciz_ended;
    704 			if ((i == (size - 1)) &&
    705 			    (style & QUOTE_OMIT_TRAILING_0) && (c == '\0'))
    706 				goto asciz_ended;
    707 			switch (c) {
    708 				case '\"': case '\\':
    709 					*s++ = '\\';
    710 					*s++ = c;
    711 					break;
    712 				case '\f':
    713 					*s++ = '\\';
    714 					*s++ = 'f';
    715 					break;
    716 				case '\n':
    717 					*s++ = '\\';
    718 					*s++ = 'n';
    719 					break;
    720 				case '\r':
    721 					*s++ = '\\';
    722 					*s++ = 'r';
    723 					break;
    724 				case '\t':
    725 					*s++ = '\\';
    726 					*s++ = 't';
    727 					break;
    728 				case '\v':
    729 					*s++ = '\\';
    730 					*s++ = 'v';
    731 					break;
    732 				default:
    733 					if (c >= ' ' && c <= 0x7e)
    734 						*s++ = c;
    735 					else {
    736 						/* Print \octal */
    737 						*s++ = '\\';
    738 						if (i + 1 < size
    739 						    && ustr[i + 1] >= '0'
    740 						    && ustr[i + 1] <= '9'
    741 						) {
    742 							/* Print \ooo */
    743 							*s++ = '0' + (c >> 6);
    744 							*s++ = '0' + ((c >> 3) & 0x7);
    745 						} else {
    746 							/* Print \[[o]o]o */
    747 							if ((c >> 3) != 0) {
    748 								if ((c >> 6) != 0)
    749 									*s++ = '0' + (c >> 6);
    750 								*s++ = '0' + ((c >> 3) & 0x7);
    751 							}
    752 						}
    753 						*s++ = '0' + (c & 0x7);
    754 					}
    755 					break;
    756 			}
    757 		}
    758 	}
    759 
    760 	if (!(style & QUOTE_OMIT_LEADING_TRAILING_QUOTES))
    761 		*s++ = '\"';
    762 	*s = '\0';
    763 
    764 	/* Return zero if we printed entire ASCIZ string (didn't truncate it) */
    765 	if (style & QUOTE_0_TERMINATED && ustr[i] == '\0') {
    766 		/* We didn't see NUL yet (otherwise we'd jump to 'asciz_ended')
    767 		 * but next char is NUL.
    768 		 */
    769 		return 0;
    770 	}
    771 
    772 	return 1;
    773 
    774  asciz_ended:
    775 	if (!(style & QUOTE_OMIT_LEADING_TRAILING_QUOTES))
    776 		*s++ = '\"';
    777 	*s = '\0';
    778 	/* Return zero: we printed entire ASCIZ string (didn't truncate it) */
    779 	return 0;
    780 }
    781 
    782 #ifndef ALLOCA_CUTOFF
    783 # define ALLOCA_CUTOFF	4032
    784 #endif
    785 #define use_alloca(n) ((n) <= ALLOCA_CUTOFF)
    786 
    787 /*
    788  * Quote string `str' of length `size' and print the result.
    789  *
    790  * If QUOTE_0_TERMINATED `style' flag is set,
    791  * treat `str' as a NUL-terminated string and
    792  * quote at most (`size' - 1) bytes.
    793  *
    794  * If QUOTE_OMIT_LEADING_TRAILING_QUOTES `style' flag is set,
    795  * do not add leading and trailing quoting symbols.
    796  *
    797  * Returns 0 if QUOTE_0_TERMINATED is set and NUL was seen, 1 otherwise.
    798  * Note that if QUOTE_0_TERMINATED is not set, always returns 1.
    799  */
    800 int
    801 print_quoted_string(const char *str, unsigned int size,
    802 		    const unsigned int style)
    803 {
    804 	char *buf;
    805 	char *outstr;
    806 	unsigned int alloc_size;
    807 	int rc;
    808 
    809 	if (size && style & QUOTE_0_TERMINATED)
    810 		--size;
    811 
    812 	alloc_size = 4 * size;
    813 	if (alloc_size / 4 != size) {
    814 		error_msg("Out of memory");
    815 		tprints("???");
    816 		return -1;
    817 	}
    818 	alloc_size += 1 + (style & QUOTE_OMIT_LEADING_TRAILING_QUOTES ? 0 : 2);
    819 
    820 	if (use_alloca(alloc_size)) {
    821 		outstr = alloca(alloc_size);
    822 		buf = NULL;
    823 	} else {
    824 		outstr = buf = malloc(alloc_size);
    825 		if (!buf) {
    826 			error_msg("Out of memory");
    827 			tprints("???");
    828 			return -1;
    829 		}
    830 	}
    831 
    832 	rc = string_quote(str, outstr, size, style);
    833 	tprints(outstr);
    834 
    835 	free(buf);
    836 	return rc;
    837 }
    838 
    839 /*
    840  * Print path string specified by address `addr' and length `n'.
    841  * If path length exceeds `n', append `...' to the output.
    842  */
    843 void
    844 printpathn(struct tcb *const tcp, const kernel_ulong_t addr, unsigned int n)
    845 {
    846 	char path[PATH_MAX + 1];
    847 	int nul_seen;
    848 
    849 	if (!addr) {
    850 		tprints("NULL");
    851 		return;
    852 	}
    853 
    854 	/* Cap path length to the path buffer size */
    855 	if (n > sizeof path - 1)
    856 		n = sizeof path - 1;
    857 
    858 	/* Fetch one byte more to find out whether path length > n. */
    859 	nul_seen = umovestr(tcp, addr, n + 1, path);
    860 	if (nul_seen < 0)
    861 		printaddr(addr);
    862 	else {
    863 		path[n++] = '\0';
    864 		print_quoted_string(path, n, QUOTE_0_TERMINATED);
    865 		if (!nul_seen)
    866 			tprints("...");
    867 	}
    868 }
    869 
    870 void
    871 printpath(struct tcb *const tcp, const kernel_ulong_t addr)
    872 {
    873 	/* Size must correspond to char path[] size in printpathn */
    874 	printpathn(tcp, addr, PATH_MAX);
    875 }
    876 
    877 /*
    878  * Print string specified by address `addr' and length `len'.
    879  * If `user_style' has QUOTE_0_TERMINATED bit set, treat the string
    880  * as a NUL-terminated string.
    881  * Pass `user_style' on to `string_quote'.
    882  * Append `...' to the output if either the string length exceeds `max_strlen',
    883  * or QUOTE_0_TERMINATED bit is set and the string length exceeds `len'.
    884  */
    885 void
    886 printstr_ex(struct tcb *const tcp, const kernel_ulong_t addr,
    887 	    const kernel_ulong_t len, const unsigned int user_style)
    888 {
    889 	static char *str = NULL;
    890 	static char *outstr;
    891 	unsigned int size;
    892 	unsigned int style = user_style;
    893 	int rc;
    894 	int ellipsis;
    895 
    896 	if (!addr) {
    897 		tprints("NULL");
    898 		return;
    899 	}
    900 	/* Allocate static buffers if they are not allocated yet. */
    901 	if (!str) {
    902 		unsigned int outstr_size = 4 * max_strlen + /*for quotes and NUL:*/ 3;
    903 
    904 		if (outstr_size / 4 != max_strlen)
    905 			die_out_of_memory();
    906 		str = xmalloc(max_strlen + 1);
    907 		outstr = xmalloc(outstr_size);
    908 	}
    909 
    910 	/* Fetch one byte more because string_quote may look one byte ahead. */
    911 	size = max_strlen + 1;
    912 
    913 	if (size > len)
    914 		size = len;
    915 	if (style & QUOTE_0_TERMINATED)
    916 		rc = umovestr(tcp, addr, size, str);
    917 	else
    918 		rc = umoven(tcp, addr, size, str);
    919 
    920 	if (rc < 0) {
    921 		printaddr(addr);
    922 		return;
    923 	}
    924 
    925 	if (size > max_strlen)
    926 		size = max_strlen;
    927 	else
    928 		str[size] = '\xff';
    929 
    930 	/* If string_quote didn't see NUL and (it was supposed to be ASCIZ str
    931 	 * or we were requested to print more than -s NUM chars)...
    932 	 */
    933 	ellipsis = string_quote(str, outstr, size, style)
    934 		   && len
    935 		   && ((style & QUOTE_0_TERMINATED)
    936 		       || len > max_strlen);
    937 
    938 	tprints(outstr);
    939 	if (ellipsis)
    940 		tprints("...");
    941 }
    942 
    943 void
    944 dumpiov_upto(struct tcb *const tcp, const int len, const kernel_ulong_t addr,
    945 	     kernel_ulong_t data_size)
    946 {
    947 #if ANY_WORDSIZE_LESS_THAN_KERNEL_LONG
    948 	union {
    949 		struct { uint32_t base; uint32_t len; } *iov32;
    950 		struct { uint64_t base; uint64_t len; } *iov64;
    951 	} iovu;
    952 #define iov iovu.iov64
    953 #define sizeof_iov \
    954 	(current_wordsize == 4 ? sizeof(*iovu.iov32) : sizeof(*iovu.iov64))
    955 #define iov_iov_base(i) \
    956 	(current_wordsize == 4 ? (uint64_t) iovu.iov32[i].base : iovu.iov64[i].base)
    957 #define iov_iov_len(i) \
    958 	(current_wordsize == 4 ? (uint64_t) iovu.iov32[i].len : iovu.iov64[i].len)
    959 #else
    960 	struct iovec *iov;
    961 #define sizeof_iov sizeof(*iov)
    962 #define iov_iov_base(i) ptr_to_kulong(iov[i].iov_base)
    963 #define iov_iov_len(i) iov[i].iov_len
    964 #endif
    965 	int i;
    966 	unsigned size;
    967 
    968 	size = sizeof_iov * len;
    969 	/* Assuming no sane program has millions of iovs */
    970 	if ((unsigned)len > 1024*1024 /* insane or negative size? */
    971 	    || (iov = malloc(size)) == NULL) {
    972 		error_msg("Out of memory");
    973 		return;
    974 	}
    975 	if (umoven(tcp, addr, size, iov) >= 0) {
    976 		for (i = 0; i < len; i++) {
    977 			kernel_ulong_t iov_len = iov_iov_len(i);
    978 			if (iov_len > data_size)
    979 				iov_len = data_size;
    980 			if (!iov_len)
    981 				break;
    982 			data_size -= iov_len;
    983 			/* include the buffer number to make it easy to
    984 			 * match up the trace with the source */
    985 			tprintf(" * %" PRI_klu " bytes in buffer %d\n", iov_len, i);
    986 			dumpstr(tcp, iov_iov_base(i), iov_len);
    987 		}
    988 	}
    989 	free(iov);
    990 #undef sizeof_iov
    991 #undef iov_iov_base
    992 #undef iov_iov_len
    993 #undef iov
    994 }
    995 
    996 void
    997 dumpstr(struct tcb *const tcp, const kernel_ulong_t addr, const int len)
    998 {
    999 	static int strsize = -1;
   1000 	static unsigned char *str;
   1001 
   1002 	char outbuf[
   1003 		(
   1004 			(sizeof(
   1005 			"xx xx xx xx xx xx xx xx  xx xx xx xx xx xx xx xx  "
   1006 			"1234567890123456") + /*in case I'm off by few:*/ 4)
   1007 		/*align to 8 to make memset easier:*/ + 7) & -8
   1008 	];
   1009 	const unsigned char *src;
   1010 	int i;
   1011 
   1012 	memset(outbuf, ' ', sizeof(outbuf));
   1013 
   1014 	if (strsize < len + 16) {
   1015 		free(str);
   1016 		str = malloc(len + 16);
   1017 		if (!str) {
   1018 			strsize = -1;
   1019 			error_msg("Out of memory");
   1020 			return;
   1021 		}
   1022 		strsize = len + 16;
   1023 	}
   1024 
   1025 	if (umoven(tcp, addr, len, str) < 0)
   1026 		return;
   1027 
   1028 	/* Space-pad to 16 bytes */
   1029 	i = len;
   1030 	while (i & 0xf)
   1031 		str[i++] = ' ';
   1032 
   1033 	i = 0;
   1034 	src = str;
   1035 	while (i < len) {
   1036 		char *dst = outbuf;
   1037 		/* Hex dump */
   1038 		do {
   1039 			if (i < len) {
   1040 				*dst++ = "0123456789abcdef"[*src >> 4];
   1041 				*dst++ = "0123456789abcdef"[*src & 0xf];
   1042 			}
   1043 			else {
   1044 				*dst++ = ' ';
   1045 				*dst++ = ' ';
   1046 			}
   1047 			dst++; /* space is there by memset */
   1048 			i++;
   1049 			if ((i & 7) == 0)
   1050 				dst++; /* space is there by memset */
   1051 			src++;
   1052 		} while (i & 0xf);
   1053 		/* ASCII dump */
   1054 		i -= 16;
   1055 		src -= 16;
   1056 		do {
   1057 			if (*src >= ' ' && *src < 0x7f)
   1058 				*dst++ = *src;
   1059 			else
   1060 				*dst++ = '.';
   1061 			src++;
   1062 		} while (++i & 0xf);
   1063 		*dst = '\0';
   1064 		tprintf(" | %05x  %s |\n", i - 16, outbuf);
   1065 	}
   1066 }
   1067 
   1068 static bool process_vm_readv_not_supported = 0;
   1069 #ifndef HAVE_PROCESS_VM_READV
   1070 /*
   1071  * Need to do this since process_vm_readv() is not yet available in libc.
   1072  * When libc is be updated, only "static bool process_vm_readv_not_supported"
   1073  * line should remain.
   1074  */
   1075 /* Have to avoid duplicating with the C library headers. */
   1076 static ssize_t strace_process_vm_readv(pid_t pid,
   1077 		 const struct iovec *lvec,
   1078 		 unsigned long liovcnt,
   1079 		 const struct iovec *rvec,
   1080 		 unsigned long riovcnt,
   1081 		 unsigned long flags)
   1082 {
   1083 	return syscall(__NR_process_vm_readv, (long)pid, lvec, liovcnt, rvec, riovcnt, flags);
   1084 }
   1085 # define process_vm_readv strace_process_vm_readv
   1086 #endif /* !HAVE_PROCESS_VM_READV */
   1087 
   1088 static ssize_t
   1089 vm_read_mem(const pid_t pid, void *const laddr,
   1090 	    const kernel_ulong_t raddr, const size_t len)
   1091 {
   1092 	const unsigned long truncated_raddr = raddr;
   1093 
   1094 	if (raddr != (kernel_ulong_t) truncated_raddr) {
   1095 		errno = EIO;
   1096 		return -1;
   1097 	}
   1098 
   1099 	const struct iovec local = {
   1100 		.iov_base = laddr,
   1101 		.iov_len = len
   1102 	};
   1103 	const struct iovec remote = {
   1104 		.iov_base = (void *) truncated_raddr,
   1105 		.iov_len = len
   1106 	};
   1107 
   1108 	return process_vm_readv(pid, &local, 1, &remote, 1, 0);
   1109 }
   1110 
   1111 /*
   1112  * move `len' bytes of data from process `pid'
   1113  * at address `addr' to our space at `our_addr'
   1114  */
   1115 int
   1116 umoven(struct tcb *const tcp, kernel_ulong_t addr, unsigned int len,
   1117        void *const our_addr)
   1118 {
   1119 	char *laddr = our_addr;
   1120 	int pid = tcp->pid;
   1121 	unsigned int n, m, nread;
   1122 	union {
   1123 		long val;
   1124 		char x[sizeof(long)];
   1125 	} u;
   1126 
   1127 #if ANY_WORDSIZE_LESS_THAN_KERNEL_LONG
   1128 	if (current_wordsize < sizeof(addr)
   1129 	    && (addr & (~ (kernel_ulong_t) -1U))) {
   1130 		return -1;
   1131 	}
   1132 #endif
   1133 
   1134 	if (!process_vm_readv_not_supported) {
   1135 		int r = vm_read_mem(pid, laddr, addr, len);
   1136 		if ((unsigned int) r == len)
   1137 			return 0;
   1138 		if (r >= 0) {
   1139 			error_msg("umoven: short read (%u < %u) @0x%" PRI_klx,
   1140 				  (unsigned int) r, len, addr);
   1141 			return -1;
   1142 		}
   1143 		switch (errno) {
   1144 			case ENOSYS:
   1145 				process_vm_readv_not_supported = 1;
   1146 				break;
   1147 			case EPERM:
   1148 				/* operation not permitted, try PTRACE_PEEKDATA */
   1149 				break;
   1150 			case ESRCH:
   1151 				/* the process is gone */
   1152 				return -1;
   1153 			case EFAULT: case EIO:
   1154 				/* address space is inaccessible */
   1155 				return -1;
   1156 			default:
   1157 				/* all the rest is strange and should be reported */
   1158 				perror_msg("process_vm_readv");
   1159 				return -1;
   1160 		}
   1161 	}
   1162 
   1163 	nread = 0;
   1164 	if (addr & (sizeof(long) - 1)) {
   1165 		/* addr not a multiple of sizeof(long) */
   1166 		n = addr & (sizeof(long) - 1);	/* residue */
   1167 		addr &= -sizeof(long);		/* aligned address */
   1168 		errno = 0;
   1169 		u.val = ptrace(PTRACE_PEEKDATA, pid, addr, 0);
   1170 		switch (errno) {
   1171 			case 0:
   1172 				break;
   1173 			case ESRCH: case EINVAL:
   1174 				/* these could be seen if the process is gone */
   1175 				return -1;
   1176 			case EFAULT: case EIO: case EPERM:
   1177 				/* address space is inaccessible */
   1178 				return -1;
   1179 			default:
   1180 				/* all the rest is strange and should be reported */
   1181 				perror_msg("umoven: PTRACE_PEEKDATA pid:%d @0x%" PRI_klx,
   1182 					    pid, addr);
   1183 				return -1;
   1184 		}
   1185 		m = MIN(sizeof(long) - n, len);
   1186 		memcpy(laddr, &u.x[n], m);
   1187 		addr += sizeof(long);
   1188 		laddr += m;
   1189 		nread += m;
   1190 		len -= m;
   1191 	}
   1192 	while (len) {
   1193 		errno = 0;
   1194 		u.val = ptrace(PTRACE_PEEKDATA, pid, addr, 0);
   1195 		switch (errno) {
   1196 			case 0:
   1197 				break;
   1198 			case ESRCH: case EINVAL:
   1199 				/* these could be seen if the process is gone */
   1200 				return -1;
   1201 			case EFAULT: case EIO: case EPERM:
   1202 				/* address space is inaccessible */
   1203 				if (nread) {
   1204 					perror_msg("umoven: short read (%u < %u) @0x%" PRI_klx,
   1205 						   nread, nread + len, addr - nread);
   1206 				}
   1207 				return -1;
   1208 			default:
   1209 				/* all the rest is strange and should be reported */
   1210 				perror_msg("umoven: PTRACE_PEEKDATA pid:%d @0x%" PRI_klx,
   1211 					    pid, addr);
   1212 				return -1;
   1213 		}
   1214 		m = MIN(sizeof(long), len);
   1215 		memcpy(laddr, u.x, m);
   1216 		addr += sizeof(long);
   1217 		laddr += m;
   1218 		nread += m;
   1219 		len -= m;
   1220 	}
   1221 
   1222 	return 0;
   1223 }
   1224 
   1225 int
   1226 umoven_or_printaddr(struct tcb *const tcp, const kernel_ulong_t addr,
   1227 		    const unsigned int len, void *const our_addr)
   1228 {
   1229 	if (!addr || !verbose(tcp) || (exiting(tcp) && syserror(tcp)) ||
   1230 	    umoven(tcp, addr, len, our_addr) < 0) {
   1231 		printaddr(addr);
   1232 		return -1;
   1233 	}
   1234 	return 0;
   1235 }
   1236 
   1237 int
   1238 umoven_or_printaddr_ignore_syserror(struct tcb *const tcp,
   1239 				    const kernel_ulong_t addr,
   1240 				    const unsigned int len,
   1241 				    void *const our_addr)
   1242 {
   1243 	if (!addr || !verbose(tcp) || umoven(tcp, addr, len, our_addr) < 0) {
   1244 		printaddr(addr);
   1245 		return -1;
   1246 	}
   1247 	return 0;
   1248 }
   1249 
   1250 /*
   1251  * Like `umove' but make the additional effort of looking
   1252  * for a terminating zero byte.
   1253  *
   1254  * Returns < 0 on error, > 0 if NUL was seen,
   1255  * (TODO if useful: return count of bytes including NUL),
   1256  * else 0 if len bytes were read but no NUL byte seen.
   1257  *
   1258  * Note: there is no guarantee we won't overwrite some bytes
   1259  * in laddr[] _after_ terminating NUL (but, of course,
   1260  * we never write past laddr[len-1]).
   1261  */
   1262 int
   1263 umovestr(struct tcb *const tcp, kernel_ulong_t addr, unsigned int len, char *laddr)
   1264 {
   1265 	const unsigned long x01010101 = (unsigned long) 0x0101010101010101ULL;
   1266 	const unsigned long x80808080 = (unsigned long) 0x8080808080808080ULL;
   1267 
   1268 	int pid = tcp->pid;
   1269 	unsigned int n, m, nread;
   1270 	union {
   1271 		unsigned long val;
   1272 		char x[sizeof(long)];
   1273 	} u;
   1274 
   1275 #if ANY_WORDSIZE_LESS_THAN_KERNEL_LONG
   1276 	if (current_wordsize < sizeof(addr)
   1277 	    && (addr & (~ (kernel_ulong_t) -1U))) {
   1278 		return -1;
   1279 	}
   1280 #endif
   1281 
   1282 	nread = 0;
   1283 	if (!process_vm_readv_not_supported) {
   1284 		const size_t page_size = get_pagesize();
   1285 		const size_t page_mask = page_size - 1;
   1286 
   1287 		while (len > 0) {
   1288 			unsigned int chunk_len;
   1289 			unsigned int end_in_page;
   1290 
   1291 			/*
   1292 			 * Don't cross pages, otherwise we can get EFAULT
   1293 			 * and fail to notice that terminating NUL lies
   1294 			 * in the existing (first) page.
   1295 			 */
   1296 			chunk_len = len > page_size ? page_size : len;
   1297 			end_in_page = (addr + chunk_len) & page_mask;
   1298 			if (chunk_len > end_in_page) /* crosses to the next page */
   1299 				chunk_len -= end_in_page;
   1300 
   1301 			int r = vm_read_mem(pid, laddr, addr, chunk_len);
   1302 			if (r > 0) {
   1303 				if (memchr(laddr, '\0', r))
   1304 					return 1;
   1305 				addr += r;
   1306 				laddr += r;
   1307 				nread += r;
   1308 				len -= r;
   1309 				continue;
   1310 			}
   1311 			switch (errno) {
   1312 				case ENOSYS:
   1313 					process_vm_readv_not_supported = 1;
   1314 					goto vm_readv_didnt_work;
   1315 				case ESRCH:
   1316 					/* the process is gone */
   1317 					return -1;
   1318 				case EPERM:
   1319 					/* operation not permitted, try PTRACE_PEEKDATA */
   1320 					if (!nread)
   1321 						goto vm_readv_didnt_work;
   1322 					/* fall through */
   1323 				case EFAULT: case EIO:
   1324 					/* address space is inaccessible */
   1325 					if (nread) {
   1326 						perror_msg("umovestr: short read (%d < %d) @0x%" PRI_klx,
   1327 							   nread, nread + len, addr - nread);
   1328 					}
   1329 					return -1;
   1330 				default:
   1331 					/* all the rest is strange and should be reported */
   1332 					perror_msg("process_vm_readv");
   1333 					return -1;
   1334 			}
   1335 		}
   1336 		return 0;
   1337 	}
   1338  vm_readv_didnt_work:
   1339 
   1340 	if (addr & (sizeof(long) - 1)) {
   1341 		/* addr not a multiple of sizeof(long) */
   1342 		n = addr & (sizeof(long) - 1);	/* residue */
   1343 		addr &= -sizeof(long);		/* aligned address */
   1344 		errno = 0;
   1345 		u.val = ptrace(PTRACE_PEEKDATA, pid, addr, 0);
   1346 		switch (errno) {
   1347 			case 0:
   1348 				break;
   1349 			case ESRCH: case EINVAL:
   1350 				/* these could be seen if the process is gone */
   1351 				return -1;
   1352 			case EFAULT: case EIO: case EPERM:
   1353 				/* address space is inaccessible */
   1354 				return -1;
   1355 			default:
   1356 				/* all the rest is strange and should be reported */
   1357 				perror_msg("umovestr: PTRACE_PEEKDATA pid:%d @0x%" PRI_klx,
   1358 					    pid, addr);
   1359 				return -1;
   1360 		}
   1361 		m = MIN(sizeof(long) - n, len);
   1362 		memcpy(laddr, &u.x[n], m);
   1363 		while (n & (sizeof(long) - 1))
   1364 			if (u.x[n++] == '\0')
   1365 				return 1;
   1366 		addr += sizeof(long);
   1367 		laddr += m;
   1368 		nread += m;
   1369 		len -= m;
   1370 	}
   1371 
   1372 	while (len) {
   1373 		errno = 0;
   1374 		u.val = ptrace(PTRACE_PEEKDATA, pid, addr, 0);
   1375 		switch (errno) {
   1376 			case 0:
   1377 				break;
   1378 			case ESRCH: case EINVAL:
   1379 				/* these could be seen if the process is gone */
   1380 				return -1;
   1381 			case EFAULT: case EIO: case EPERM:
   1382 				/* address space is inaccessible */
   1383 				if (nread) {
   1384 					perror_msg("umovestr: short read (%d < %d) @0x%" PRI_klx,
   1385 						   nread, nread + len, addr - nread);
   1386 				}
   1387 				return -1;
   1388 			default:
   1389 				/* all the rest is strange and should be reported */
   1390 				perror_msg("umovestr: PTRACE_PEEKDATA pid:%d @0x%" PRI_klx,
   1391 					   pid, addr);
   1392 				return -1;
   1393 		}
   1394 		m = MIN(sizeof(long), len);
   1395 		memcpy(laddr, u.x, m);
   1396 		/* "If a NUL char exists in this word" */
   1397 		if ((u.val - x01010101) & ~u.val & x80808080)
   1398 			return 1;
   1399 		addr += sizeof(long);
   1400 		laddr += m;
   1401 		nread += m;
   1402 		len -= m;
   1403 	}
   1404 	return 0;
   1405 }
   1406 
   1407 /*
   1408  * Iteratively fetch and print up to nmemb elements of elem_size size
   1409  * from the array that starts at tracee's address start_addr.
   1410  *
   1411  * Array elements are being fetched to the address specified by elem_buf.
   1412  *
   1413  * The fetcher callback function specified by umoven_func should follow
   1414  * the same semantics as umoven_or_printaddr function.
   1415  *
   1416  * The printer callback function specified by print_func is expected
   1417  * to print something; if it returns false, no more iterations will be made.
   1418  *
   1419  * The pointer specified by opaque_data is passed to each invocation
   1420  * of print_func callback function.
   1421  *
   1422  * This function prints:
   1423  * - "NULL", if start_addr is NULL;
   1424  * - "[]", if nmemb is 0;
   1425  * - start_addr, if nmemb * elem_size overflows or wraps around;
   1426  * - nothing, if the first element cannot be fetched
   1427  *   (if umoven_func returns non-zero), but it is assumed that
   1428  *   umoven_func has printed the address it failed to fetch data from;
   1429  * - elements of the array, delimited by ", ", with the array itself
   1430  *   enclosed with [] brackets.
   1431  *
   1432  * If abbrev(tcp) is true, then
   1433  * - the maximum number of elements printed equals to max_strlen;
   1434  * - "..." is printed instead of max_strlen+1 element
   1435  *   and no more iterations will be made.
   1436  *
   1437  * This function returns true only if
   1438  * - umoven_func has been called at least once AND
   1439  * - umoven_func has not returned false.
   1440  */
   1441 bool
   1442 print_array(struct tcb *const tcp,
   1443 	    const kernel_ulong_t start_addr,
   1444 	    const size_t nmemb,
   1445 	    void *const elem_buf,
   1446 	    const size_t elem_size,
   1447 	    int (*const umoven_func)(struct tcb *,
   1448 				     kernel_ulong_t,
   1449 				     unsigned int,
   1450 				     void *),
   1451 	    bool (*const print_func)(struct tcb *,
   1452 				     void *elem_buf,
   1453 				     size_t elem_size,
   1454 				     void *opaque_data),
   1455 	    void *const opaque_data)
   1456 {
   1457 	if (!start_addr) {
   1458 		tprints("NULL");
   1459 		return false;
   1460 	}
   1461 
   1462 	if (!nmemb) {
   1463 		tprints("[]");
   1464 		return false;
   1465 	}
   1466 
   1467 	const size_t size = nmemb * elem_size;
   1468 	const kernel_ulong_t end_addr = start_addr + size;
   1469 
   1470 	if (end_addr <= start_addr || size / elem_size != nmemb) {
   1471 		printaddr(start_addr);
   1472 		return false;
   1473 	}
   1474 
   1475 	const kernel_ulong_t abbrev_end =
   1476 		(abbrev(tcp) && max_strlen < nmemb) ?
   1477 			start_addr + elem_size * max_strlen : end_addr;
   1478 	kernel_ulong_t cur;
   1479 
   1480 	for (cur = start_addr; cur < end_addr; cur += elem_size) {
   1481 		if (cur != start_addr)
   1482 			tprints(", ");
   1483 
   1484 		if (umoven_func(tcp, cur, elem_size, elem_buf))
   1485 			break;
   1486 
   1487 		if (cur == start_addr)
   1488 			tprints("[");
   1489 
   1490 		if (cur >= abbrev_end) {
   1491 			tprints("...");
   1492 			cur = end_addr;
   1493 			break;
   1494 		}
   1495 
   1496 		if (!print_func(tcp, elem_buf, elem_size, opaque_data)) {
   1497 			cur = end_addr;
   1498 			break;
   1499 		}
   1500 	}
   1501 	if (cur != start_addr)
   1502 		tprints("]");
   1503 
   1504 	return cur >= end_addr;
   1505 }
   1506 
   1507 int
   1508 printargs(struct tcb *tcp)
   1509 {
   1510 	const int n = tcp->s_ent->nargs;
   1511 	int i;
   1512 	for (i = 0; i < n; ++i)
   1513 		tprintf("%s%#" PRI_klx, i ? ", " : "", tcp->u_arg[i]);
   1514 	return RVAL_DECODED;
   1515 }
   1516 
   1517 int
   1518 printargs_u(struct tcb *tcp)
   1519 {
   1520 	const int n = tcp->s_ent->nargs;
   1521 	int i;
   1522 	for (i = 0; i < n; ++i)
   1523 		tprintf("%s%u", i ? ", " : "",
   1524 			(unsigned int) tcp->u_arg[i]);
   1525 	return RVAL_DECODED;
   1526 }
   1527 
   1528 int
   1529 printargs_d(struct tcb *tcp)
   1530 {
   1531 	const int n = tcp->s_ent->nargs;
   1532 	int i;
   1533 	for (i = 0; i < n; ++i)
   1534 		tprintf("%s%d", i ? ", " : "",
   1535 			(int) tcp->u_arg[i]);
   1536 	return RVAL_DECODED;
   1537 }
   1538 
   1539 #if defined _LARGEFILE64_SOURCE && defined HAVE_OPEN64
   1540 # define open_file open64
   1541 #else
   1542 # define open_file open
   1543 #endif
   1544 
   1545 int
   1546 read_int_from_file(const char *const fname, int *const pvalue)
   1547 {
   1548 	const int fd = open_file(fname, O_RDONLY);
   1549 	if (fd < 0)
   1550 		return -1;
   1551 
   1552 	long lval;
   1553 	char buf[sizeof(lval) * 3];
   1554 	int n = read(fd, buf, sizeof(buf) - 1);
   1555 	int saved_errno = errno;
   1556 	close(fd);
   1557 
   1558 	if (n < 0) {
   1559 		errno = saved_errno;
   1560 		return -1;
   1561 	}
   1562 
   1563 	buf[n] = '\0';
   1564 	char *endptr = 0;
   1565 	errno = 0;
   1566 	lval = strtol(buf, &endptr, 10);
   1567 	if (!endptr || (*endptr && '\n' != *endptr)
   1568 #if INT_MAX < LONG_MAX
   1569 	    || lval > INT_MAX || lval < INT_MIN
   1570 #endif
   1571 	    || ERANGE == errno) {
   1572 		if (!errno)
   1573 			errno = EINVAL;
   1574 		return -1;
   1575 	}
   1576 
   1577 	*pvalue = (int) lval;
   1578 	return 0;
   1579 }
   1580