• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl>
3  * Copyright (c) 1993 Branko Lankester <branko@hacktic.nl>
4  * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com>
5  * Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl>
6  * Copyright (c) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation
7  *                     Linux for s390 port by D.J. Barrow
8  *                    <barrow_dj@mail.yahoo.com,djbarrow@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/user.h>
36 #include <sys/param.h>
37 #include <fcntl.h>
38 #if HAVE_SYS_UIO_H
39 # include <sys/uio.h>
40 #endif
41 
42 #if defined(IA64)
43 # include <asm/ptrace_offsets.h>
44 # include <asm/rse.h>
45 #endif
46 
47 #ifdef HAVE_SYS_REG_H
48 # include <sys/reg.h>
49 #elif defined(HAVE_LINUX_PTRACE_H)
50 # undef PTRACE_SYSCALL
51 # ifdef HAVE_STRUCT_IA64_FPREG
52 #  define ia64_fpreg XXX_ia64_fpreg
53 # endif
54 # ifdef HAVE_STRUCT_PT_ALL_USER_REGS
55 #  define pt_all_user_regs XXX_pt_all_user_regs
56 # endif
57 # ifdef HAVE_STRUCT_PTRACE_PEEKSIGINFO_ARGS
58 #  define ptrace_peeksiginfo_args XXX_ptrace_peeksiginfo_args
59 # endif
60 # include <linux/ptrace.h>
61 # undef ptrace_peeksiginfo_args
62 # undef ia64_fpreg
63 # undef pt_all_user_regs
64 #endif
65 
66 int
string_to_uint(const char * str)67 string_to_uint(const char *str)
68 {
69 	char *error;
70 	long value;
71 
72 	if (!*str)
73 		return -1;
74 	errno = 0;
75 	value = strtol(str, &error, 10);
76 	if (errno || *error || value < 0 || (long)(int)value != value)
77 		return -1;
78 	return (int)value;
79 }
80 
81 int
tv_nz(const struct timeval * a)82 tv_nz(const struct timeval *a)
83 {
84 	return a->tv_sec || a->tv_usec;
85 }
86 
87 int
tv_cmp(const struct timeval * a,const struct timeval * b)88 tv_cmp(const struct timeval *a, const struct timeval *b)
89 {
90 	if (a->tv_sec < b->tv_sec
91 	    || (a->tv_sec == b->tv_sec && a->tv_usec < b->tv_usec))
92 		return -1;
93 	if (a->tv_sec > b->tv_sec
94 	    || (a->tv_sec == b->tv_sec && a->tv_usec > b->tv_usec))
95 		return 1;
96 	return 0;
97 }
98 
99 double
tv_float(const struct timeval * tv)100 tv_float(const struct timeval *tv)
101 {
102 	return tv->tv_sec + tv->tv_usec/1000000.0;
103 }
104 
105 void
tv_add(struct timeval * tv,const struct timeval * a,const struct timeval * b)106 tv_add(struct timeval *tv, const struct timeval *a, const struct timeval *b)
107 {
108 	tv->tv_sec = a->tv_sec + b->tv_sec;
109 	tv->tv_usec = a->tv_usec + b->tv_usec;
110 	if (tv->tv_usec >= 1000000) {
111 		tv->tv_sec++;
112 		tv->tv_usec -= 1000000;
113 	}
114 }
115 
116 void
tv_sub(struct timeval * tv,const struct timeval * a,const struct timeval * b)117 tv_sub(struct timeval *tv, const struct timeval *a, const struct timeval *b)
118 {
119 	tv->tv_sec = a->tv_sec - b->tv_sec;
120 	tv->tv_usec = a->tv_usec - b->tv_usec;
121 	if (((long) tv->tv_usec) < 0) {
122 		tv->tv_sec--;
123 		tv->tv_usec += 1000000;
124 	}
125 }
126 
127 void
tv_div(struct timeval * tv,const struct timeval * a,int n)128 tv_div(struct timeval *tv, const struct timeval *a, int n)
129 {
130 	tv->tv_usec = (a->tv_sec % n * 1000000 + a->tv_usec + n / 2) / n;
131 	tv->tv_sec = a->tv_sec / n + tv->tv_usec / 1000000;
132 	tv->tv_usec %= 1000000;
133 }
134 
135 void
tv_mul(struct timeval * tv,const struct timeval * a,int n)136 tv_mul(struct timeval *tv, const struct timeval *a, int n)
137 {
138 	tv->tv_usec = a->tv_usec * n;
139 	tv->tv_sec = a->tv_sec * n + tv->tv_usec / 1000000;
140 	tv->tv_usec %= 1000000;
141 }
142 
143 const char *
xlookup(const struct xlat * xlat,int val)144 xlookup(const struct xlat *xlat, int val)
145 {
146 	for (; xlat->str != NULL; xlat++)
147 		if (xlat->val == val)
148 			return xlat->str;
149 	return NULL;
150 }
151 
152 #if !defined HAVE_STPCPY
153 char *
stpcpy(char * dst,const char * src)154 stpcpy(char *dst, const char *src)
155 {
156 	while ((*dst = *src++) != '\0')
157 		dst++;
158 	return dst;
159 }
160 #endif
161 
162 /* Find a next bit which is set.
163  * Starts testing at cur_bit.
164  * Returns -1 if no more bits are set.
165  *
166  * We never touch bytes we don't need to.
167  * On big-endian, array is assumed to consist of
168  * current_wordsize wide words: for example, is current_wordsize is 4,
169  * the bytes are walked in 3,2,1,0, 7,6,5,4, 11,10,9,8 ... sequence.
170  * On little-endian machines, word size is immaterial.
171  */
172 int
next_set_bit(const void * bit_array,unsigned cur_bit,unsigned size_bits)173 next_set_bit(const void *bit_array, unsigned cur_bit, unsigned size_bits)
174 {
175 	const unsigned endian = 1;
176 	int little_endian = *(char*)&endian;
177 
178 	const uint8_t *array = bit_array;
179 	unsigned pos = cur_bit / 8;
180 	unsigned pos_xor_mask = little_endian ? 0 : current_wordsize-1;
181 
182 	for (;;) {
183 		uint8_t bitmask;
184 		uint8_t cur_byte;
185 
186 		if (cur_bit >= size_bits)
187 			return -1;
188 		cur_byte = array[pos ^ pos_xor_mask];
189 		if (cur_byte == 0) {
190 			cur_bit = (cur_bit + 8) & (-8);
191 			pos++;
192 			continue;
193 		}
194 		bitmask = 1 << (cur_bit & 7);
195 		for (;;) {
196 			if (cur_byte & bitmask)
197 				return cur_bit;
198 			cur_bit++;
199 			if (cur_bit >= size_bits)
200 				return -1;
201 			bitmask <<= 1;
202 			/* This check *can't be* optimized out: */
203 			if (bitmask == 0)
204 				break;
205 		}
206 		pos++;
207 	}
208 }
209 /*
210  * Print entry in struct xlat table, if there.
211  */
212 void
printxval(const struct xlat * xlat,int val,const char * dflt)213 printxval(const struct xlat *xlat, int val, const char *dflt)
214 {
215 	const char *str = xlookup(xlat, val);
216 
217 	if (str)
218 		tprints(str);
219 	else
220 		tprintf("%#x /* %s */", val, dflt);
221 }
222 
223 /*
224  * Print 64bit argument at position arg_no and return the index of the next
225  * argument.
226  */
227 int
printllval(struct tcb * tcp,const char * format,int arg_no,bool align)228 printllval(struct tcb *tcp, const char *format, int arg_no, bool align)
229 {
230 #if SIZEOF_LONG > 4 && SIZEOF_LONG == SIZEOF_LONG_LONG
231 # if SUPPORTED_PERSONALITIES > 1
232 	if (current_wordsize > 4) {
233 # endif
234 		tprintf(format, tcp->u_arg[arg_no]);
235 		arg_no++;
236 # if SUPPORTED_PERSONALITIES > 1
237 	} else {
238 #  if defined(AARCH64) || defined(POWERPC64)
239 		if (align) {
240 			/* Align arg_no to the next even number. */
241 			arg_no = (arg_no + 1) & 0xe;
242 		}
243 #  endif
244 		tprintf(format, LONG_LONG(tcp->u_arg[arg_no], tcp->u_arg[arg_no + 1]));
245 		arg_no += 2;
246 	}
247 # endif /* SUPPORTED_PERSONALITIES */
248 #elif SIZEOF_LONG > 4
249 #  error Unsupported configuration: SIZEOF_LONG > 4 && SIZEOF_LONG_LONG > SIZEOF_LONG
250 #elif defined LINUX_MIPSN32
251 	tprintf(format, tcp->ext_arg[arg_no]);
252 	arg_no++;
253 #elif defined X32
254 	if (current_personality == 0) {
255 		tprintf(format, tcp->ext_arg[arg_no]);
256 		arg_no++;
257 	} else {
258 		tprintf(format, LONG_LONG(tcp->u_arg[arg_no], tcp->u_arg[arg_no + 1]));
259 		arg_no += 2;
260 	}
261 #else
262 # if defined __ARM_EABI__ || \
263      defined LINUX_MIPSO32 || \
264      defined POWERPC || \
265      defined XTENSA
266 	if (align) {
267 		/* Align arg_no to the next even number. */
268 		arg_no = (arg_no + 1) & 0xe;
269 	}
270 # endif
271 	tprintf(format, LONG_LONG(tcp->u_arg[arg_no], tcp->u_arg[arg_no + 1]));
272 	arg_no += 2;
273 #endif
274 
275 	return arg_no;
276 }
277 
278 /*
279  * Interpret `xlat' as an array of flags
280  * print the entries whose bits are on in `flags'
281  * return # of flags printed.
282  */
283 void
addflags(const struct xlat * xlat,int flags)284 addflags(const struct xlat *xlat, int flags)
285 {
286 	for (; xlat->str; xlat++) {
287 		if (xlat->val && (flags & xlat->val) == xlat->val) {
288 			tprintf("|%s", xlat->str);
289 			flags &= ~xlat->val;
290 		}
291 	}
292 	if (flags) {
293 		tprintf("|%#x", flags);
294 	}
295 }
296 
297 /*
298  * Interpret `xlat' as an array of flags.
299  * Print to static string the entries whose bits are on in `flags'
300  * Return static string.
301  */
302 const char *
sprintflags(const char * prefix,const struct xlat * xlat,int flags)303 sprintflags(const char *prefix, const struct xlat *xlat, int flags)
304 {
305 	static char outstr[1024];
306 	char *outptr;
307 	int found = 0;
308 
309 	outptr = stpcpy(outstr, prefix);
310 
311 	for (; xlat->str; xlat++) {
312 		if ((flags & xlat->val) == xlat->val) {
313 			if (found)
314 				*outptr++ = '|';
315 			outptr = stpcpy(outptr, xlat->str);
316 			found = 1;
317 			flags &= ~xlat->val;
318 			if (!flags)
319 				break;
320 		}
321 	}
322 	if (flags) {
323 		if (found)
324 			*outptr++ = '|';
325 		outptr += sprintf(outptr, "%#x", flags);
326 	}
327 
328 	return outstr;
329 }
330 
331 int
printflags(const struct xlat * xlat,int flags,const char * dflt)332 printflags(const struct xlat *xlat, int flags, const char *dflt)
333 {
334 	int n;
335 	const char *sep;
336 
337 	if (flags == 0 && xlat->val == 0) {
338 		tprints(xlat->str);
339 		return 1;
340 	}
341 
342 	sep = "";
343 	for (n = 0; xlat->str; xlat++) {
344 		if (xlat->val && (flags & xlat->val) == xlat->val) {
345 			tprintf("%s%s", sep, xlat->str);
346 			flags &= ~xlat->val;
347 			sep = "|";
348 			n++;
349 		}
350 	}
351 
352 	if (n) {
353 		if (flags) {
354 			tprintf("%s%#x", sep, flags);
355 			n++;
356 		}
357 	} else {
358 		if (flags) {
359 			tprintf("%#x", flags);
360 			if (dflt)
361 				tprintf(" /* %s */", dflt);
362 		} else {
363 			if (dflt)
364 				tprints("0");
365 		}
366 	}
367 
368 	return n;
369 }
370 
371 void
printnum(struct tcb * tcp,long addr,const char * fmt)372 printnum(struct tcb *tcp, long addr, const char *fmt)
373 {
374 	long num;
375 
376 	if (!addr) {
377 		tprints("NULL");
378 		return;
379 	}
380 	if (umove(tcp, addr, &num) < 0) {
381 		tprintf("%#lx", addr);
382 		return;
383 	}
384 	tprints("[");
385 	tprintf(fmt, num);
386 	tprints("]");
387 }
388 
389 void
printnum_int(struct tcb * tcp,long addr,const char * fmt)390 printnum_int(struct tcb *tcp, long addr, const char *fmt)
391 {
392 	int num;
393 
394 	if (!addr) {
395 		tprints("NULL");
396 		return;
397 	}
398 	if (umove(tcp, addr, &num) < 0) {
399 		tprintf("%#lx", addr);
400 		return;
401 	}
402 	tprints("[");
403 	tprintf(fmt, num);
404 	tprints("]");
405 }
406 
407 void
printfd(struct tcb * tcp,int fd)408 printfd(struct tcb *tcp, int fd)
409 {
410 	char path[PATH_MAX + 1];
411 
412 	if (show_fd_path && getfdpath(tcp, fd, path, sizeof(path)) >= 0)
413 		tprintf("%d<%s>", fd, path);
414 	else
415 		tprintf("%d", fd);
416 }
417 
418 void
printuid(const char * text,unsigned long uid)419 printuid(const char *text, unsigned long uid)
420 {
421 	tprintf((uid == -1) ? "%s%ld" : "%s%lu", text, uid);
422 }
423 
424 /*
425  * Quote string `instr' of length `size'
426  * Write up to (3 + `size' * 4) bytes to `outstr' buffer.
427  * If `len' is -1, treat `instr' as a NUL-terminated string
428  * and quote at most (`size' - 1) bytes.
429  *
430  * Returns 0 if len == -1 and NUL was seen, 1 otherwise.
431  * Note that if len >= 0, always returns 1.
432  */
433 int
string_quote(const char * instr,char * outstr,long len,int size)434 string_quote(const char *instr, char *outstr, long len, int size)
435 {
436 	const unsigned char *ustr = (const unsigned char *) instr;
437 	char *s = outstr;
438 	int usehex, c, i, eol;
439 
440 	eol = 0x100; /* this can never match a char */
441 	if (len == -1) {
442 		size--;
443 		eol = '\0';
444 	}
445 
446 	usehex = 0;
447 	if (xflag > 1)
448 		usehex = 1;
449 	else if (xflag) {
450 		/* Check for presence of symbol which require
451 		   to hex-quote the whole string. */
452 		for (i = 0; i < size; ++i) {
453 			c = ustr[i];
454 			/* Check for NUL-terminated string. */
455 			if (c == eol)
456 				break;
457 
458 			/* Force hex unless c is printable or whitespace */
459 			if (c > 0x7e) {
460 				usehex = 1;
461 				break;
462 			}
463 			/* In ASCII isspace is only these chars: "\t\n\v\f\r".
464 			 * They happen to have ASCII codes 9,10,11,12,13.
465 			 */
466 			if (c < ' ' && (unsigned)(c - 9) >= 5) {
467 				usehex = 1;
468 				break;
469 			}
470 		}
471 	}
472 
473 	*s++ = '\"';
474 
475 	if (usehex) {
476 		/* Hex-quote the whole string. */
477 		for (i = 0; i < size; ++i) {
478 			c = ustr[i];
479 			/* Check for NUL-terminated string. */
480 			if (c == eol)
481 				goto asciz_ended;
482 			*s++ = '\\';
483 			*s++ = 'x';
484 			*s++ = "0123456789abcdef"[c >> 4];
485 			*s++ = "0123456789abcdef"[c & 0xf];
486 		}
487 	} else {
488 		for (i = 0; i < size; ++i) {
489 			c = ustr[i];
490 			/* Check for NUL-terminated string. */
491 			if (c == eol)
492 				goto asciz_ended;
493 			switch (c) {
494 				case '\"': case '\\':
495 					*s++ = '\\';
496 					*s++ = c;
497 					break;
498 				case '\f':
499 					*s++ = '\\';
500 					*s++ = 'f';
501 					break;
502 				case '\n':
503 					*s++ = '\\';
504 					*s++ = 'n';
505 					break;
506 				case '\r':
507 					*s++ = '\\';
508 					*s++ = 'r';
509 					break;
510 				case '\t':
511 					*s++ = '\\';
512 					*s++ = 't';
513 					break;
514 				case '\v':
515 					*s++ = '\\';
516 					*s++ = 'v';
517 					break;
518 				default:
519 					if (c >= ' ' && c <= 0x7e)
520 						*s++ = c;
521 					else {
522 						/* Print \octal */
523 						*s++ = '\\';
524 						if (i + 1 < size
525 						    && ustr[i + 1] >= '0'
526 						    && ustr[i + 1] <= '9'
527 						) {
528 							/* Print \ooo */
529 							*s++ = '0' + (c >> 6);
530 							*s++ = '0' + ((c >> 3) & 0x7);
531 						} else {
532 							/* Print \[[o]o]o */
533 							if ((c >> 3) != 0) {
534 								if ((c >> 6) != 0)
535 									*s++ = '0' + (c >> 6);
536 								*s++ = '0' + ((c >> 3) & 0x7);
537 							}
538 						}
539 						*s++ = '0' + (c & 0x7);
540 					}
541 					break;
542 			}
543 		}
544 	}
545 
546 	*s++ = '\"';
547 	*s = '\0';
548 
549 	/* Return zero if we printed entire ASCIZ string (didn't truncate it) */
550 	if (len == -1 && ustr[i] == '\0') {
551 		/* We didn't see NUL yet (otherwise we'd jump to 'asciz_ended')
552 		 * but next char is NUL.
553 		 */
554 		return 0;
555 	}
556 
557 	return 1;
558 
559  asciz_ended:
560 	*s++ = '\"';
561 	*s = '\0';
562 	/* Return zero: we printed entire ASCIZ string (didn't truncate it) */
563 	return 0;
564 }
565 
566 /*
567  * Print path string specified by address `addr' and length `n'.
568  * If path length exceeds `n', append `...' to the output.
569  */
570 void
printpathn(struct tcb * tcp,long addr,int n)571 printpathn(struct tcb *tcp, long addr, int n)
572 {
573 	char path[MAXPATHLEN + 1];
574 	int nul_seen;
575 
576 	if (!addr) {
577 		tprints("NULL");
578 		return;
579 	}
580 
581 	/* Cap path length to the path buffer size */
582 	if (n > sizeof path - 1)
583 		n = sizeof path - 1;
584 
585 	/* Fetch one byte more to find out whether path length > n. */
586 	nul_seen = umovestr(tcp, addr, n + 1, path);
587 	if (nul_seen < 0)
588 		tprintf("%#lx", addr);
589 	else {
590 		char *outstr;
591 
592 		path[n] = '\0';
593 		n++;
594 		outstr = alloca(4 * n); /* 4*(n-1) + 3 for quotes and NUL */
595 		string_quote(path, outstr, -1, n);
596 		tprints(outstr);
597 		if (!nul_seen)
598 			tprints("...");
599 	}
600 }
601 
602 void
printpath(struct tcb * tcp,long addr)603 printpath(struct tcb *tcp, long addr)
604 {
605 	/* Size must correspond to char path[] size in printpathn */
606 	printpathn(tcp, addr, MAXPATHLEN);
607 }
608 
609 /*
610  * Print string specified by address `addr' and length `len'.
611  * If `len' < 0, treat the string as a NUL-terminated string.
612  * If string length exceeds `max_strlen', append `...' to the output.
613  */
614 void
printstr(struct tcb * tcp,long addr,long len)615 printstr(struct tcb *tcp, long addr, long len)
616 {
617 	static char *str = NULL;
618 	static char *outstr;
619 	int size;
620 	int ellipsis;
621 
622 	if (!addr) {
623 		tprints("NULL");
624 		return;
625 	}
626 	/* Allocate static buffers if they are not allocated yet. */
627 	if (!str) {
628 		unsigned int outstr_size = 4 * max_strlen + /*for quotes and NUL:*/ 3;
629 
630 		if (outstr_size / 4 != max_strlen)
631 			die_out_of_memory();
632 		str = malloc(max_strlen + 1);
633 		if (!str)
634 			die_out_of_memory();
635 		outstr = malloc(outstr_size);
636 		if (!outstr)
637 			die_out_of_memory();
638 	}
639 
640 	if (len == -1) {
641 		/*
642 		 * Treat as a NUL-terminated string: fetch one byte more
643 		 * because string_quote() quotes one byte less.
644 		 */
645 		size = max_strlen + 1;
646 		if (umovestr(tcp, addr, size, str) < 0) {
647 			tprintf("%#lx", addr);
648 			return;
649 		}
650 	}
651 	else {
652 		size = max_strlen;
653 		if (size > (unsigned long)len)
654 			size = (unsigned long)len;
655 		if (umoven(tcp, addr, size, str) < 0) {
656 			tprintf("%#lx", addr);
657 			return;
658 		}
659 	}
660 
661 	/* If string_quote didn't see NUL and (it was supposed to be ASCIZ str
662 	 * or we were requested to print more than -s NUM chars)...
663 	 */
664 	ellipsis = (string_quote(str, outstr, len, size) &&
665 			(len < 0 || len > max_strlen));
666 
667 	tprints(outstr);
668 	if (ellipsis)
669 		tprints("...");
670 }
671 
672 #if HAVE_SYS_UIO_H
673 void
dumpiov(struct tcb * tcp,int len,long addr)674 dumpiov(struct tcb *tcp, int len, long addr)
675 {
676 #if SUPPORTED_PERSONALITIES > 1
677 	union {
678 		struct { u_int32_t base; u_int32_t len; } *iov32;
679 		struct { u_int64_t base; u_int64_t len; } *iov64;
680 	} iovu;
681 #define iov iovu.iov64
682 #define sizeof_iov \
683 	(current_wordsize == 4 ? sizeof(*iovu.iov32) : sizeof(*iovu.iov64))
684 #define iov_iov_base(i) \
685 	(current_wordsize == 4 ? (uint64_t) iovu.iov32[i].base : iovu.iov64[i].base)
686 #define iov_iov_len(i) \
687 	(current_wordsize == 4 ? (uint64_t) iovu.iov32[i].len : iovu.iov64[i].len)
688 #else
689 	struct iovec *iov;
690 #define sizeof_iov sizeof(*iov)
691 #define iov_iov_base(i) iov[i].iov_base
692 #define iov_iov_len(i) iov[i].iov_len
693 #endif
694 	int i;
695 	unsigned size;
696 
697 	size = sizeof_iov * len;
698 	/* Assuming no sane program has millions of iovs */
699 	if ((unsigned)len > 1024*1024 /* insane or negative size? */
700 	    || (iov = malloc(size)) == NULL) {
701 		fprintf(stderr, "Out of memory\n");
702 		return;
703 	}
704 	if (umoven(tcp, addr, size, (char *) iov) >= 0) {
705 		for (i = 0; i < len; i++) {
706 			/* include the buffer number to make it easy to
707 			 * match up the trace with the source */
708 			tprintf(" * %lu bytes in buffer %d\n",
709 				(unsigned long)iov_iov_len(i), i);
710 			dumpstr(tcp, (long) iov_iov_base(i),
711 				iov_iov_len(i));
712 		}
713 	}
714 	free(iov);
715 #undef sizeof_iov
716 #undef iov_iov_base
717 #undef iov_iov_len
718 #undef iov
719 }
720 #endif
721 
722 void
dumpstr(struct tcb * tcp,long addr,int len)723 dumpstr(struct tcb *tcp, long addr, int len)
724 {
725 	static int strsize = -1;
726 	static unsigned char *str;
727 
728 	char outbuf[
729 		(
730 			(sizeof(
731 			"xx xx xx xx xx xx xx xx  xx xx xx xx xx xx xx xx  "
732 			"1234567890123456") + /*in case I'm off by few:*/ 4)
733 		/*align to 8 to make memset easier:*/ + 7) & -8
734 	];
735 	const unsigned char *src;
736 	int i;
737 
738 	memset(outbuf, ' ', sizeof(outbuf));
739 
740 	if (strsize < len + 16) {
741 		free(str);
742 		str = malloc(len + 16);
743 		if (!str) {
744 			strsize = -1;
745 			fprintf(stderr, "Out of memory\n");
746 			return;
747 		}
748 		strsize = len + 16;
749 	}
750 
751 	if (umoven(tcp, addr, len, (char *) str) < 0)
752 		return;
753 
754 	/* Space-pad to 16 bytes */
755 	i = len;
756 	while (i & 0xf)
757 		str[i++] = ' ';
758 
759 	i = 0;
760 	src = str;
761 	while (i < len) {
762 		char *dst = outbuf;
763 		/* Hex dump */
764 		do {
765 			if (i < len) {
766 				*dst++ = "0123456789abcdef"[*src >> 4];
767 				*dst++ = "0123456789abcdef"[*src & 0xf];
768 			}
769 			else {
770 				*dst++ = ' ';
771 				*dst++ = ' ';
772 			}
773 			dst++; /* space is there by memset */
774 			i++;
775 			if ((i & 7) == 0)
776 				dst++; /* space is there by memset */
777 			src++;
778 		} while (i & 0xf);
779 		/* ASCII dump */
780 		i -= 16;
781 		src -= 16;
782 		do {
783 			if (*src >= ' ' && *src < 0x7f)
784 				*dst++ = *src;
785 			else
786 				*dst++ = '.';
787 			src++;
788 		} while (++i & 0xf);
789 		*dst = '\0';
790 		tprintf(" | %05x  %s |\n", i - 16, outbuf);
791 	}
792 }
793 
794 #ifdef HAVE_PROCESS_VM_READV
795 /* C library supports this, but the kernel might not. */
796 static bool process_vm_readv_not_supported = 0;
797 #else
798 
799 /* Need to do this since process_vm_readv() is not yet available in libc.
800  * When libc is be updated, only "static bool process_vm_readv_not_supported"
801  * line should remain.
802  */
803 #if !defined(__NR_process_vm_readv)
804 # if defined(I386)
805 #  define __NR_process_vm_readv  347
806 # elif defined(X86_64)
807 #  define __NR_process_vm_readv  310
808 # elif defined(POWERPC)
809 #  define __NR_process_vm_readv  351
810 # endif
811 #endif
812 
813 #if defined(__NR_process_vm_readv)
814 static bool process_vm_readv_not_supported = 0;
815 /* Have to avoid duplicating with the C library headers. */
strace_process_vm_readv(pid_t pid,const struct iovec * lvec,unsigned long liovcnt,const struct iovec * rvec,unsigned long riovcnt,unsigned long flags)816 static ssize_t strace_process_vm_readv(pid_t pid,
817 		 const struct iovec *lvec,
818 		 unsigned long liovcnt,
819 		 const struct iovec *rvec,
820 		 unsigned long riovcnt,
821 		 unsigned long flags)
822 {
823 	return syscall(__NR_process_vm_readv, (long)pid, lvec, liovcnt, rvec, riovcnt, flags);
824 }
825 #define process_vm_readv strace_process_vm_readv
826 #else
827 static bool process_vm_readv_not_supported = 1;
828 # define process_vm_readv(...) (errno = ENOSYS, -1)
829 #endif
830 
831 #endif /* end of hack */
832 
833 #define PAGMASK	(~(PAGSIZ - 1))
834 /*
835  * move `len' bytes of data from process `pid'
836  * at address `addr' to our space at `laddr'
837  */
838 int
umoven(struct tcb * tcp,long addr,int len,char * laddr)839 umoven(struct tcb *tcp, long addr, int len, char *laddr)
840 {
841 	int pid = tcp->pid;
842 	int n, m, nread;
843 	union {
844 		long val;
845 		char x[sizeof(long)];
846 	} u;
847 
848 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
849 	if (current_wordsize < sizeof(addr))
850 		addr &= (1ul << 8 * current_wordsize) - 1;
851 #endif
852 
853 	if (!process_vm_readv_not_supported) {
854 		struct iovec local[1], remote[1];
855 		int r;
856 
857 		local[0].iov_base = laddr;
858 		remote[0].iov_base = (void*)addr;
859 		local[0].iov_len = remote[0].iov_len = len;
860 		r = process_vm_readv(pid, local, 1, remote, 1, 0);
861 		if (r == len)
862 			return 0;
863 		if (r >= 0) {
864 			error_msg("umoven: short read (%d < %d) @0x%lx",
865 				  r, len, addr);
866 			return -1;
867 		}
868 		switch (errno) {
869 			case ENOSYS:
870 				process_vm_readv_not_supported = 1;
871 				break;
872 			case ESRCH:
873 				/* the process is gone */
874 				return -1;
875 			case EFAULT: case EIO: case EPERM:
876 				/* address space is inaccessible */
877 				return -1;
878 			default:
879 				/* all the rest is strange and should be reported */
880 				perror_msg("process_vm_readv");
881 				return -1;
882 		}
883 	}
884 
885 	nread = 0;
886 	if (addr & (sizeof(long) - 1)) {
887 		/* addr not a multiple of sizeof(long) */
888 		n = addr - (addr & -sizeof(long)); /* residue */
889 		addr &= -sizeof(long); /* residue */
890 		errno = 0;
891 		u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
892 		switch (errno) {
893 			case 0:
894 				break;
895 			case ESRCH: case EINVAL:
896 				/* these could be seen if the process is gone */
897 				return -1;
898 			case EFAULT: case EIO: case EPERM:
899 				/* address space is inaccessible */
900 				return -1;
901 			default:
902 				/* all the rest is strange and should be reported */
903 				perror_msg("umoven: PTRACE_PEEKDATA pid:%d @0x%lx",
904 					    pid, addr);
905 				return -1;
906 		}
907 		m = MIN(sizeof(long) - n, len);
908 		memcpy(laddr, &u.x[n], m);
909 		addr += sizeof(long);
910 		laddr += m;
911 		nread += m;
912 		len -= m;
913 	}
914 	while (len) {
915 		errno = 0;
916 		u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
917 		switch (errno) {
918 			case 0:
919 				break;
920 			case ESRCH: case EINVAL:
921 				/* these could be seen if the process is gone */
922 				return -1;
923 			case EFAULT: case EIO: case EPERM:
924 				/* address space is inaccessible */
925 				if (nread) {
926 					perror_msg("umoven: short read (%d < %d) @0x%lx",
927 						   nread, nread + len, addr - nread);
928 				}
929 				return -1;
930 			default:
931 				/* all the rest is strange and should be reported */
932 				perror_msg("umoven: PTRACE_PEEKDATA pid:%d @0x%lx",
933 					    pid, addr);
934 				return -1;
935 		}
936 		m = MIN(sizeof(long), len);
937 		memcpy(laddr, u.x, m);
938 		addr += sizeof(long);
939 		laddr += m;
940 		nread += m;
941 		len -= m;
942 	}
943 
944 	return 0;
945 }
946 
947 /*
948  * Like `umove' but make the additional effort of looking
949  * for a terminating zero byte.
950  *
951  * Returns < 0 on error, > 0 if NUL was seen,
952  * (TODO if useful: return count of bytes including NUL),
953  * else 0 if len bytes were read but no NUL byte seen.
954  *
955  * Note: there is no guarantee we won't overwrite some bytes
956  * in laddr[] _after_ terminating NUL (but, of course,
957  * we never write past laddr[len-1]).
958  */
959 int
umovestr(struct tcb * tcp,long addr,int len,char * laddr)960 umovestr(struct tcb *tcp, long addr, int len, char *laddr)
961 {
962 #if SIZEOF_LONG == 4
963 	const unsigned long x01010101 = 0x01010101ul;
964 	const unsigned long x80808080 = 0x80808080ul;
965 #elif SIZEOF_LONG == 8
966 	const unsigned long x01010101 = 0x0101010101010101ul;
967 	const unsigned long x80808080 = 0x8080808080808080ul;
968 #else
969 # error SIZEOF_LONG > 8
970 #endif
971 
972 	int pid = tcp->pid;
973 	int n, m, nread;
974 	union {
975 		unsigned long val;
976 		char x[sizeof(long)];
977 	} u;
978 
979 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
980 	if (current_wordsize < sizeof(addr))
981 		addr &= (1ul << 8 * current_wordsize) - 1;
982 #endif
983 
984 	nread = 0;
985 	if (!process_vm_readv_not_supported) {
986 		struct iovec local[1], remote[1];
987 
988 		local[0].iov_base = laddr;
989 		remote[0].iov_base = (void*)addr;
990 
991 		while (len > 0) {
992 			int end_in_page;
993 			int r;
994 			int chunk_len;
995 
996 			/* Don't read kilobytes: most strings are short */
997 			chunk_len = len;
998 			if (chunk_len > 256)
999 				chunk_len = 256;
1000 			/* Don't cross pages. I guess otherwise we can get EFAULT
1001 			 * and fail to notice that terminating NUL lies
1002 			 * in the existing (first) page.
1003 			 * (I hope there aren't arches with pages < 4K)
1004 			 */
1005 			end_in_page = ((addr + chunk_len) & 4095);
1006 			r = chunk_len - end_in_page;
1007 			if (r > 0) /* if chunk_len > end_in_page */
1008 				chunk_len = r; /* chunk_len -= end_in_page */
1009 
1010 			local[0].iov_len = remote[0].iov_len = chunk_len;
1011 			r = process_vm_readv(pid, local, 1, remote, 1, 0);
1012 			if (r > 0) {
1013 				if (memchr(local[0].iov_base, '\0', r))
1014 					return 1;
1015 				local[0].iov_base += r;
1016 				remote[0].iov_base += r;
1017 				len -= r;
1018 				nread += r;
1019 				continue;
1020 			}
1021 			switch (errno) {
1022 				case ENOSYS:
1023 					process_vm_readv_not_supported = 1;
1024 					goto vm_readv_didnt_work;
1025 				case ESRCH:
1026 					/* the process is gone */
1027 					return -1;
1028 				case EFAULT: case EIO: case EPERM:
1029 					/* address space is inaccessible */
1030 					if (nread) {
1031 						perror_msg("umovestr: short read (%d < %d) @0x%lx",
1032 							   nread, nread + len, addr);
1033 					}
1034 					return -1;
1035 				default:
1036 					/* all the rest is strange and should be reported */
1037 					perror_msg("process_vm_readv");
1038 					return -1;
1039 			}
1040 		}
1041 		return 0;
1042 	}
1043  vm_readv_didnt_work:
1044 
1045 	if (addr & (sizeof(long) - 1)) {
1046 		/* addr not a multiple of sizeof(long) */
1047 		n = addr - (addr & -sizeof(long)); /* residue */
1048 		addr &= -sizeof(long); /* residue */
1049 		errno = 0;
1050 		u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
1051 		switch (errno) {
1052 			case 0:
1053 				break;
1054 			case ESRCH: case EINVAL:
1055 				/* these could be seen if the process is gone */
1056 				return -1;
1057 			case EFAULT: case EIO: case EPERM:
1058 				/* address space is inaccessible */
1059 				return -1;
1060 			default:
1061 				/* all the rest is strange and should be reported */
1062 				perror_msg("umovestr: PTRACE_PEEKDATA pid:%d @0x%lx",
1063 					    pid, addr);
1064 				return -1;
1065 		}
1066 		m = MIN(sizeof(long) - n, len);
1067 		memcpy(laddr, &u.x[n], m);
1068 		while (n & (sizeof(long) - 1))
1069 			if (u.x[n++] == '\0')
1070 				return 1;
1071 		addr += sizeof(long);
1072 		laddr += m;
1073 		nread += m;
1074 		len -= m;
1075 	}
1076 
1077 	while (len) {
1078 		errno = 0;
1079 		u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
1080 		switch (errno) {
1081 			case 0:
1082 				break;
1083 			case ESRCH: case EINVAL:
1084 				/* these could be seen if the process is gone */
1085 				return -1;
1086 			case EFAULT: case EIO: case EPERM:
1087 				/* address space is inaccessible */
1088 				if (nread) {
1089 					perror_msg("umovestr: short read (%d < %d) @0x%lx",
1090 						   nread, nread + len, addr - nread);
1091 				}
1092 				return -1;
1093 			default:
1094 				/* all the rest is strange and should be reported */
1095 				perror_msg("umovestr: PTRACE_PEEKDATA pid:%d @0x%lx",
1096 					   pid, addr);
1097 				return -1;
1098 		}
1099 		m = MIN(sizeof(long), len);
1100 		memcpy(laddr, u.x, m);
1101 		/* "If a NUL char exists in this word" */
1102 		if ((u.val - x01010101) & ~u.val & x80808080)
1103 			return 1;
1104 		addr += sizeof(long);
1105 		laddr += m;
1106 		nread += m;
1107 		len -= m;
1108 	}
1109 	return 0;
1110 }
1111 
1112 int
upeek(int pid,long off,long * res)1113 upeek(int pid, long off, long *res)
1114 {
1115 	long val;
1116 
1117 	errno = 0;
1118 	val = ptrace(PTRACE_PEEKUSER, (pid_t)pid, (char *) off, 0);
1119 	if (val == -1 && errno) {
1120 		if (errno != ESRCH) {
1121 			perror_msg("upeek: PTRACE_PEEKUSER pid:%d @0x%lx)", pid, off);
1122 		}
1123 		return -1;
1124 	}
1125 	*res = val;
1126 	return 0;
1127 }
1128 
1129 /* Note! On new kernels (about 2.5.46+), we use PTRACE_O_TRACECLONE
1130  * and PTRACE_O_TRACE[V]FORK for tracing children.
1131  * If you are adding a new arch which is only supported by newer kernels,
1132  * you most likely don't need to add any code below
1133  * beside a dummy "return 0" block in change_syscall().
1134  */
1135 
1136 /*
1137  * These #if's are huge, please indent them correctly.
1138  * It's easy to get confused otherwise.
1139  */
1140 
1141 #include "syscall.h"
1142 
1143 #ifndef CLONE_PTRACE
1144 # define CLONE_PTRACE    0x00002000
1145 #endif
1146 #ifndef CLONE_VFORK
1147 # define CLONE_VFORK     0x00004000
1148 #endif
1149 #ifndef CLONE_VM
1150 # define CLONE_VM        0x00000100
1151 #endif
1152 
1153 #ifdef IA64
1154 
1155 typedef unsigned long *arg_setup_state;
1156 
1157 static int
arg_setup(struct tcb * tcp,arg_setup_state * state)1158 arg_setup(struct tcb *tcp, arg_setup_state *state)
1159 {
1160 	unsigned long cfm, sof, sol;
1161 	long bsp;
1162 
1163 	if (ia64_ia32mode) {
1164 		/* Satisfy a false GCC warning.  */
1165 		*state = NULL;
1166 		return 0;
1167 	}
1168 
1169 	if (upeek(tcp->pid, PT_AR_BSP, &bsp) < 0)
1170 		return -1;
1171 	if (upeek(tcp->pid, PT_CFM, (long *) &cfm) < 0)
1172 		return -1;
1173 
1174 	sof = (cfm >> 0) & 0x7f;
1175 	sol = (cfm >> 7) & 0x7f;
1176 	bsp = (long) ia64_rse_skip_regs((unsigned long *) bsp, -sof + sol);
1177 
1178 	*state = (unsigned long *) bsp;
1179 	return 0;
1180 }
1181 
1182 # define arg_finish_change(tcp, state)	0
1183 
1184 static int
get_arg0(struct tcb * tcp,arg_setup_state * state,long * valp)1185 get_arg0(struct tcb *tcp, arg_setup_state *state, long *valp)
1186 {
1187 	int ret;
1188 
1189 	if (ia64_ia32mode)
1190 		ret = upeek(tcp->pid, PT_R11, valp);
1191 	else
1192 		ret = umoven(tcp,
1193 			      (unsigned long) ia64_rse_skip_regs(*state, 0),
1194 			      sizeof(long), (void *) valp);
1195 	return ret;
1196 }
1197 
1198 static int
get_arg1(struct tcb * tcp,arg_setup_state * state,long * valp)1199 get_arg1(struct tcb *tcp, arg_setup_state *state, long *valp)
1200 {
1201 	int ret;
1202 
1203 	if (ia64_ia32mode)
1204 		ret = upeek(tcp->pid, PT_R9, valp);
1205 	else
1206 		ret = umoven(tcp,
1207 			      (unsigned long) ia64_rse_skip_regs(*state, 1),
1208 			      sizeof(long), (void *) valp);
1209 	return ret;
1210 }
1211 
1212 static int
set_arg0(struct tcb * tcp,arg_setup_state * state,long val)1213 set_arg0(struct tcb *tcp, arg_setup_state *state, long val)
1214 {
1215 	int req = PTRACE_POKEDATA;
1216 	void *ap;
1217 
1218 	if (ia64_ia32mode) {
1219 		ap = (void *) (intptr_t) PT_R11;	 /* r11 == EBX */
1220 		req = PTRACE_POKEUSER;
1221 	} else
1222 		ap = ia64_rse_skip_regs(*state, 0);
1223 	errno = 0;
1224 	ptrace(req, tcp->pid, ap, val);
1225 	return errno ? -1 : 0;
1226 }
1227 
1228 static int
set_arg1(struct tcb * tcp,arg_setup_state * state,long val)1229 set_arg1(struct tcb *tcp, arg_setup_state *state, long val)
1230 {
1231 	int req = PTRACE_POKEDATA;
1232 	void *ap;
1233 
1234 	if (ia64_ia32mode) {
1235 		ap = (void *) (intptr_t) PT_R9;		/* r9 == ECX */
1236 		req = PTRACE_POKEUSER;
1237 	} else
1238 		ap = ia64_rse_skip_regs(*state, 1);
1239 	errno = 0;
1240 	ptrace(req, tcp->pid, ap, val);
1241 	return errno ? -1 : 0;
1242 }
1243 
1244 /* ia64 does not return the input arguments from functions (and syscalls)
1245    according to ia64 RSE (Register Stack Engine) behavior.  */
1246 
1247 # define restore_arg0(tcp, state, val) ((void) (state), 0)
1248 # define restore_arg1(tcp, state, val) ((void) (state), 0)
1249 
1250 #elif defined(SPARC) || defined(SPARC64)
1251 
1252 # if defined(SPARC64)
1253 #  undef PTRACE_GETREGS
1254 #  define PTRACE_GETREGS PTRACE_GETREGS64
1255 #  undef PTRACE_SETREGS
1256 #  define PTRACE_SETREGS PTRACE_SETREGS64
1257 # endif
1258 
1259 typedef struct pt_regs arg_setup_state;
1260 
1261 # define arg_setup(tcp, state) \
1262     (ptrace(PTRACE_GETREGS, (tcp)->pid, (char *) (state), 0))
1263 # define arg_finish_change(tcp, state) \
1264     (ptrace(PTRACE_SETREGS, (tcp)->pid, (char *) (state), 0))
1265 
1266 # define get_arg0(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O0], 0)
1267 # define get_arg1(tcp, state, valp) (*(valp) = (state)->u_regs[U_REG_O1], 0)
1268 # define set_arg0(tcp, state, val)  ((state)->u_regs[U_REG_O0] = (val), 0)
1269 # define set_arg1(tcp, state, val)  ((state)->u_regs[U_REG_O1] = (val), 0)
1270 # define restore_arg0(tcp, state, val) 0
1271 
1272 #else /* other architectures */
1273 
1274 # if defined S390 || defined S390X
1275 /* Note: this is only true for the `clone' system call, which handles
1276    arguments specially.  We could as well say that its first two arguments
1277    are swapped relative to other architectures, but that would just be
1278    another #ifdef in the calls.  */
1279 #  define arg0_offset	PT_GPR3
1280 #  define arg1_offset	PT_ORIGGPR2
1281 #  define restore_arg0(tcp, state, val) ((void) (state), 0)
1282 #  define restore_arg1(tcp, state, val) ((void) (state), 0)
1283 #  define arg0_index	1
1284 #  define arg1_index	0
1285 # elif defined(ALPHA) || defined(MIPS)
1286 #  define arg0_offset	REG_A0
1287 #  define arg1_offset	(REG_A0+1)
1288 # elif defined(POWERPC)
1289 #  define arg0_offset	(sizeof(unsigned long)*PT_R3)
1290 #  define arg1_offset	(sizeof(unsigned long)*PT_R4)
1291 #  define restore_arg0(tcp, state, val) ((void) (state), 0)
1292 # elif defined(HPPA)
1293 #  define arg0_offset	PT_GR26
1294 #  define arg1_offset	(PT_GR26-4)
1295 # elif defined(X86_64) || defined(X32)
1296 #  define arg0_offset	((long)(8*(current_personality ? RBX : RDI)))
1297 #  define arg1_offset	((long)(8*(current_personality ? RCX : RSI)))
1298 # elif defined(SH)
1299 #  define arg0_offset	(4*(REG_REG0+4))
1300 #  define arg1_offset	(4*(REG_REG0+5))
1301 # elif defined(SH64)
1302    /* ABI defines arg0 & 1 in r2 & r3 */
1303 #  define arg0_offset	(REG_OFFSET+16)
1304 #  define arg1_offset	(REG_OFFSET+24)
1305 #  define restore_arg0(tcp, state, val) 0
1306 # elif defined CRISV10 || defined CRISV32
1307 #  define arg0_offset	(4*PT_R11)
1308 #  define arg1_offset	(4*PT_ORIG_R10)
1309 #  define restore_arg0(tcp, state, val) 0
1310 #  define restore_arg1(tcp, state, val) 0
1311 #  define arg0_index	1
1312 #  define arg1_index	0
1313 # else
1314 #  define arg0_offset	0
1315 #  define arg1_offset	4
1316 #  if defined ARM
1317 #   define restore_arg0(tcp, state, val) 0
1318 #  endif
1319 # endif
1320 
1321 typedef int arg_setup_state;
1322 
1323 # define arg_setup(tcp, state)         (0)
1324 # define arg_finish_change(tcp, state) 0
1325 # define get_arg0(tcp, cookie, valp)   (upeek((tcp)->pid, arg0_offset, (valp)))
1326 # define get_arg1(tcp, cookie, valp)   (upeek((tcp)->pid, arg1_offset, (valp)))
1327 
1328 static int
set_arg0(struct tcb * tcp,void * cookie,long val)1329 set_arg0(struct tcb *tcp, void *cookie, long val)
1330 {
1331 	return ptrace(PTRACE_POKEUSER, tcp->pid, (char*)arg0_offset, val);
1332 }
1333 
1334 static int
set_arg1(struct tcb * tcp,void * cookie,long val)1335 set_arg1(struct tcb *tcp, void *cookie, long val)
1336 {
1337 	return ptrace(PTRACE_POKEUSER, tcp->pid, (char*)arg1_offset, val);
1338 }
1339 
1340 #endif /* architectures */
1341 
1342 #ifndef restore_arg0
1343 # define restore_arg0(tcp, state, val) set_arg0((tcp), (state), (val))
1344 #endif
1345 #ifndef restore_arg1
1346 # define restore_arg1(tcp, state, val) set_arg1((tcp), (state), (val))
1347 #endif
1348 
1349 #ifndef arg0_index
1350 # define arg0_index 0
1351 # define arg1_index 1
1352 #endif
1353 
1354 static int
change_syscall(struct tcb * tcp,arg_setup_state * state,int new)1355 change_syscall(struct tcb *tcp, arg_setup_state *state, int new)
1356 {
1357 #if defined(I386)
1358 	if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(ORIG_EAX * 4), new) < 0)
1359 		return -1;
1360 	return 0;
1361 #elif defined(X86_64)
1362 	if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(ORIG_RAX * 8), new) < 0)
1363 		return -1;
1364 	return 0;
1365 #elif defined(X32)
1366 	/* setbpt/clearbpt never used: */
1367 	/* X32 is only supported since about linux-3.0.30 */
1368 #elif defined(POWERPC)
1369 	if (ptrace(PTRACE_POKEUSER, tcp->pid,
1370 		   (char*)(sizeof(unsigned long)*PT_R0), new) < 0)
1371 		return -1;
1372 	return 0;
1373 #elif defined(S390) || defined(S390X)
1374 	/* s390 linux after 2.4.7 has a hook in entry.S to allow this */
1375 	if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_GPR2), new) < 0)
1376 		return -1;
1377 	return 0;
1378 #elif defined(M68K)
1379 	if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*PT_ORIG_D0), new) < 0)
1380 		return -1;
1381 	return 0;
1382 #elif defined(SPARC) || defined(SPARC64)
1383 	state->u_regs[U_REG_G1] = new;
1384 	return 0;
1385 #elif defined(MIPS)
1386 	if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_V0), new) < 0)
1387 		return -1;
1388 	return 0;
1389 #elif defined(ALPHA)
1390 	if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_A3), new) < 0)
1391 		return -1;
1392 	return 0;
1393 #elif defined(AVR32)
1394 	/* setbpt/clearbpt never used: */
1395 	/* AVR32 is only supported since about linux-2.6.19 */
1396 #elif defined(BFIN)
1397 	/* setbpt/clearbpt never used: */
1398 	/* Blackfin is only supported since about linux-2.6.23 */
1399 #elif defined(IA64)
1400 	if (ia64_ia32mode) {
1401 		switch (new) {
1402 		case 2:
1403 			break;	/* x86 SYS_fork */
1404 		case SYS_clone:
1405 			new = 120;
1406 			break;
1407 		default:
1408 			fprintf(stderr, "%s: unexpected syscall %d\n",
1409 				__FUNCTION__, new);
1410 			return -1;
1411 		}
1412 		if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_R1), new) < 0)
1413 			return -1;
1414 	} else if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_R15), new) < 0)
1415 		return -1;
1416 	return 0;
1417 #elif defined(HPPA)
1418 	if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_GR20), new) < 0)
1419 		return -1;
1420 	return 0;
1421 #elif defined(SH)
1422 	if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*(REG_REG0+3)), new) < 0)
1423 		return -1;
1424 	return 0;
1425 #elif defined(SH64)
1426 	/* Top half of reg encodes the no. of args n as 0x1n.
1427 	   Assume 0 args as kernel never actually checks... */
1428 	if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_SYSCALL),
1429 				0x100000 | new) < 0)
1430 		return -1;
1431 	return 0;
1432 #elif defined(CRISV10) || defined(CRISV32)
1433 	if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*PT_R9), new) < 0)
1434 		return -1;
1435 	return 0;
1436 #elif defined(ARM)
1437 	/* Some kernels support this, some (pre-2.6.16 or so) don't.  */
1438 # ifndef PTRACE_SET_SYSCALL
1439 #  define PTRACE_SET_SYSCALL 23
1440 # endif
1441 	if (ptrace(PTRACE_SET_SYSCALL, tcp->pid, 0, new & 0xffff) != 0)
1442 		return -1;
1443 	return 0;
1444 #elif defined(AARCH64)
1445 	/* setbpt/clearbpt never used: */
1446 	/* AARCH64 is only supported since about linux-3.0.31 */
1447 #elif defined(TILE)
1448 	/* setbpt/clearbpt never used: */
1449 	/* Tilera CPUs are only supported since about linux-2.6.34 */
1450 #elif defined(MICROBLAZE)
1451 	/* setbpt/clearbpt never used: */
1452 	/* microblaze is only supported since about linux-2.6.30 */
1453 #elif defined(OR1K)
1454 	/* never reached; OR1K is only supported by kernels since 3.1.0. */
1455 #elif defined(METAG)
1456 	/* setbpt/clearbpt never used: */
1457 	/* Meta is only supported since linux-3.7 */
1458 #elif defined(XTENSA)
1459 	/* setbpt/clearbpt never used: */
1460 	/* Xtensa is only supported since linux 2.6.13 */
1461 #elif defined(ARC)
1462 	/* setbpt/clearbpt never used: */
1463 	/* ARC only supported since 3.9 */
1464 #else
1465 #warning Do not know how to handle change_syscall for this architecture
1466 #endif /* architecture */
1467 	return -1;
1468 }
1469 
1470 int
setbpt(struct tcb * tcp)1471 setbpt(struct tcb *tcp)
1472 {
1473 	static int clone_scno[SUPPORTED_PERSONALITIES] = { SYS_clone };
1474 	arg_setup_state state;
1475 
1476 	if (tcp->flags & TCB_BPTSET) {
1477 		fprintf(stderr, "PANIC: TCB already set in pid %u\n", tcp->pid);
1478 		return -1;
1479 	}
1480 
1481 	/*
1482 	 * It's a silly kludge to initialize this with a search at runtime.
1483 	 * But it's better than maintaining another magic thing in the
1484 	 * godforsaken tables.
1485 	 */
1486 	if (clone_scno[current_personality] == 0) {
1487 		int i;
1488 		for (i = 0; i < nsyscalls; ++i)
1489 			if (sysent[i].sys_func == sys_clone) {
1490 				clone_scno[current_personality] = i;
1491 				break;
1492 			}
1493 	}
1494 
1495 	if (tcp->s_ent->sys_func == sys_fork) {
1496 		if (arg_setup(tcp, &state) < 0
1497 		    || get_arg0(tcp, &state, &tcp->inst[0]) < 0
1498 		    || get_arg1(tcp, &state, &tcp->inst[1]) < 0
1499 		    || change_syscall(tcp, &state,
1500 				      clone_scno[current_personality]) < 0
1501 		    || set_arg0(tcp, &state, CLONE_PTRACE|SIGCHLD) < 0
1502 		    || set_arg1(tcp, &state, 0) < 0
1503 		    || arg_finish_change(tcp, &state) < 0)
1504 			return -1;
1505 		tcp->u_arg[arg0_index] = CLONE_PTRACE|SIGCHLD;
1506 		tcp->u_arg[arg1_index] = 0;
1507 		tcp->flags |= TCB_BPTSET;
1508 		return 0;
1509 	}
1510 
1511 	if (tcp->s_ent->sys_func == sys_clone) {
1512 		/* ia64 calls directly `clone (CLONE_VFORK | CLONE_VM)'
1513 		   contrary to x86 vfork above.  Even on x86 we turn the
1514 		   vfork semantics into plain fork - each application must not
1515 		   depend on the vfork specifics according to POSIX.  We would
1516 		   hang waiting for the parent resume otherwise.  We need to
1517 		   clear also CLONE_VM but only in the CLONE_VFORK case as
1518 		   otherwise we would break pthread_create.  */
1519 
1520 		long new_arg0 = (tcp->u_arg[arg0_index] | CLONE_PTRACE);
1521 		if (new_arg0 & CLONE_VFORK)
1522 			new_arg0 &= ~(unsigned long)(CLONE_VFORK | CLONE_VM);
1523 		if (arg_setup(tcp, &state) < 0
1524 		 || set_arg0(tcp, &state, new_arg0) < 0
1525 		 || arg_finish_change(tcp, &state) < 0)
1526 			return -1;
1527 		tcp->inst[0] = tcp->u_arg[arg0_index];
1528 		tcp->inst[1] = tcp->u_arg[arg1_index];
1529 		tcp->flags |= TCB_BPTSET;
1530 		return 0;
1531 	}
1532 
1533 	fprintf(stderr, "PANIC: setbpt for syscall %ld on %u???\n",
1534 		tcp->scno, tcp->pid);
1535 	return -1;
1536 }
1537 
1538 int
clearbpt(struct tcb * tcp)1539 clearbpt(struct tcb *tcp)
1540 {
1541 	arg_setup_state state;
1542 	if (arg_setup(tcp, &state) < 0
1543 	    || change_syscall(tcp, &state, tcp->scno) < 0
1544 	    || restore_arg0(tcp, &state, tcp->inst[0]) < 0
1545 	    || restore_arg1(tcp, &state, tcp->inst[1]) < 0
1546 	    || arg_finish_change(tcp, &state))
1547 		if (errno != ESRCH)
1548 			return -1;
1549 	tcp->flags &= ~TCB_BPTSET;
1550 	return 0;
1551 }
1552