自学教程：C++ tprints函数代码示例

static voidbtrfs_print_tree_search(struct tcb *tcp, struct btrfs_ioctl_search_key *key,			uint64_t buf_addr, uint64_t buf_size, bool print_size){	if (entering(tcp)) {		tprintf("{key={tree_id=");		btrfs_print_objectid(key->tree_id);		if (key->min_objectid != BTRFS_FIRST_FREE_OBJECTID ||		    !abbrev(tcp)) {			tprints(", min_objectid=");			btrfs_print_objectid(key->min_objectid);		}		if (key->max_objectid != BTRFS_LAST_FREE_OBJECTID ||		    !abbrev(tcp)) {			tprints(", max_objectid=");			btrfs_print_objectid(key->max_objectid);		}		print_key_value(tcp, key, min_offset);		print_key_value(tcp, key, max_offset);		print_key_value(tcp, key, min_transid);		print_key_value(tcp, key, max_transid);		tprints(", min_type=");		btrfs_print_key_type(key->min_type);		tprints(", max_type=");		btrfs_print_key_type(key->max_type);		tprintf(", nr_items=%u}", key->nr_items);		if (print_size)			tprintf(", buf_size=%" PRIu64, buf_size);		tprints("}");	} else {		tprintf("{key={nr_items=%u}", key->nr_items);		if (print_size)			tprintf(", buf_size=%" PRIu64, buf_size);		tprints(", buf=");		if (abbrev(tcp))			tprints("...");		else {			struct btrfs_ioctl_search_header sh;			print_array(tcp, buf_addr, key->nr_items,				    &sh, sizeof(sh),				    umoven_or_printaddr,				    print_btrfs_ioctl_search_header, 0);		}		tprints("}");	}}

static voidtprint_sembuf(struct tcb *tcp, long addr, unsigned long count){	unsigned long i, max_count;	if (abbrev(tcp))		max_count = (max_strlen < count) ? max_strlen : count;	else		max_count = count;	if (!max_count) {		tprintf("%#lx, %lu", addr, count);		return;	}	for (i = 0; i < max_count; ++i) {		struct sembuf sb;		if (i)			tprints(", ");		if (umove(tcp, addr + i * sizeof(struct sembuf), &sb) < 0) {			if (i) {				tprints("{???}");				break;			} else {				tprintf("%#lx, %lu", addr, count);				return;			}		} else {			if (!i)				tprints("{");			tprintf("{%u, %d, ", sb.sem_num, sb.sem_op);			printflags(semop_flags, sb.sem_flg, "SEM_???");			tprints("}");		}	}	if (i < max_count || max_count < count)		tprints(", ...");	tprintf("}, %lu", count);}

intsys_sigsetmask(struct tcb *tcp){	if (entering(tcp)) {		tprints(sprintsigmask_long("", tcp->u_arg[0]));	}	else if (!syserror(tcp)) {		tcp->auxstr = sprintsigmask_long("old mask ", tcp->u_rval);		return RVAL_HEX | RVAL_STR;	}	return 0;}

static intdo_eventfd(struct tcb *tcp, int flags_arg){	if (entering(tcp)) {		tprintf("%lu", tcp->u_arg[0]);		if (flags_arg >= 0) {			tprints(", ");			printflags(open_mode_flags, tcp->u_arg[flags_arg], "O_???");		}	}	return 0;}

static intdo_pipe(struct tcb *tcp, int flags_arg){	if (exiting(tcp)) {		decode_pair_fd(tcp, tcp->u_arg[0]);		if (flags_arg >= 0) {			tprints(", ");			printflags(open_mode_flags, tcp->u_arg[flags_arg], "O_???");		}	}	return 0;}

intsys_setsockopt(struct tcb *tcp){	if (entering(tcp)) {		printfd(tcp, tcp->u_arg[0]);		tprints(", ");		printsockopt(tcp, tcp->u_arg[1], tcp->u_arg[2],			      tcp->u_arg[3], tcp->u_arg[4]);		tprintf(", %lu", tcp->u_arg[4]);	}	return 0;}

static void printicmpfilter(struct tcb *tcp, long addr){	struct icmp_filter	filter;	if (!addr) {		tprints("NULL");		return;	}	if (syserror(tcp) || !verbose(tcp)) {		tprintf("%#lx", addr);		return;	}	if (umove(tcp, addr, &filter) < 0) {		tprints("{...}");		return;	}	tprints("~(");	printflags(icmpfilterflags, ~filter.data, "ICMP_???");	tprints(")");}

static voiddecode_erase_info_user64(struct tcb *const tcp, const kernel_ulong_t addr){	struct erase_info_user64 einfo64;	tprints(", ");	if (umove_or_printaddr(tcp, addr, &einfo64))		return;	tprintf("{start=%#" PRIx64 ", length=%#" PRIx64 "}",		(uint64_t) einfo64.start, (uint64_t) einfo64.length);}

static voiddecode_mtd_ecc_stats(struct tcb *const tcp, const kernel_ulong_t addr){	struct mtd_ecc_stats es;	tprints(", ");	if (umove_or_printaddr(tcp, addr, &es))		return;	tprintf("{corrected=%#x, failed=%#x, badblocks=%#x, bbtblocks=%#x}",		es.corrected, es.failed, es.badblocks, es.bbtblocks);}

static voiddecode_otp_info(struct tcb *const tcp, const kernel_ulong_t addr){	struct otp_info oinfo;	tprints(", ");	if (umove_or_printaddr(tcp, addr, &oinfo))		return;	tprintf("{start=%#x, length=%#x, locked=%u}",		oinfo.start, oinfo.length, oinfo.locked);}

static voidprint_mreq(struct tcb *tcp, long addr, unsigned int len){	struct ip_mreq mreq;	if (len < sizeof(mreq)) {		printstr(tcp, addr, len);		return;	}	if (umove(tcp, addr, &mreq) < 0) {		tprintf("%#lx", addr);		return;	}	tprints("{imr_multiaddr=inet_addr(");	print_quoted_string(inet_ntoa(mreq.imr_multiaddr),			    16, QUOTE_0_TERMINATED);	tprints("), imr_interface=inet_addr(");	print_quoted_string(inet_ntoa(mreq.imr_interface),			    16, QUOTE_0_TERMINATED);	tprints(")}");}

intsys_getrlimit(struct tcb *tcp){	if (entering(tcp)) {		printxval(resources, tcp->u_arg[0], "RLIMIT_???");		tprints(", ");	}	else {		decode_rlimit(tcp, tcp->u_arg[1]);	}	return 0;}

intsys_epoll_pwait(struct tcb *tcp){	epoll_wait_common(tcp);	if (exiting(tcp)) {		tprints(", ");		/* NB: kernel requires arg[5] == NSIG / 8 */		print_sigset_addr_len(tcp, tcp->u_arg[4], tcp->u_arg[5]);		tprintf(", %lu", tcp->u_arg[5]);	}	return 0;}

static voidprint_scm_rights(struct tcb *tcp, const void *cmsg_data, const size_t data_len){	const int *fds = cmsg_data;	const size_t nfds = data_len / sizeof(*fds);	size_t i;	tprints("[");	for (i = 0; i < nfds; ++i) {		if (i)			tprints(", ");		if (abbrev(tcp) && i >= max_strlen) {			tprints("...");			break;		}		printfd(tcp, fds[i]);	}	tprints("]");}

intosf_statfs(struct tcb *tcp){	if (entering(tcp)) {		printpath(tcp, tcp->u_arg[0]);		tprints(", ");	} else {		printstatfs(tcp, tcp->u_arg[1]);		tprintf(", %lu", tcp->u_arg[2]);	}	return 0;}

intsys_mbind(struct tcb *tcp){	if (entering(tcp)) {		tprintf("%#lx, %lu, ", tcp->u_arg[0], tcp->u_arg[1]);		printxval(policies, tcp->u_arg[2], "MPOL_???");		get_nodes(tcp, tcp->u_arg[3], tcp->u_arg[4], 0);		tprints(", ");		printflags(mbindflags, tcp->u_arg[5], "MPOL_???");	}	return 0;}

intsys_write(struct tcb *tcp){	if (entering(tcp)) {		printfd(tcp, tcp->u_arg[0]);		tprints(", ");		printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);		dump_bytes(tcp, tcp->u_arg[1], tcp->u_arg[2]);		tprintf(", %lu", tcp->u_arg[2]);	}	return 0;}

voidprint_loff_t(struct tcb *tcp, long addr){	loff_t offset;	if (!addr)		tprints("NULL");	else if (umove(tcp, addr, &offset) < 0)		tprintf("%#lx", addr);	else		tprintf("[%llu]", (unsigned long long int) offset);}

intsys_ppoll(struct tcb *tcp){	int rc = decode_poll(tcp, tcp->u_arg[2]);	if (entering(tcp)) {		print_timespec(tcp, tcp->u_arg[2]);		tprints(", ");		print_sigset(tcp, tcp->u_arg[3], 0);		tprintf(", %lu", tcp->u_arg[4]);	}	return rc;}

intsys_rt_sigsuspend(struct tcb *tcp){	if (entering(tcp)) {		sigset_t sigm;		if (copy_sigset_len(tcp, tcp->u_arg[0], &sigm, tcp->u_arg[1]) < 0)			tprints("[?]");		else			printsigmask(&sigm, 1);	}	return 0;}

voidprint_sigset(struct tcb *tcp, long addr, int rt){	sigset_t ss;	if (!addr)		tprints("NULL");	else if (copy_sigset(tcp, addr, &ss) < 0)		tprintf("%#lx", addr);	else		printsigmask(&ss, rt);}

static voidprint_scm_rights(struct tcb *tcp, const void *cmsg_data,		 const size_t data_len){	const int *fds = cmsg_data;	const char *end = (const char *) cmsg_data + data_len;	bool seen = false;	if (sizeof(*fds) > data_len)		return;	tprints(", [");	while ((const char *) fds < end) {		if (seen)			tprints(", ");		else			seen = true;		printfd(tcp, *fds++);	}	tprints("]");}

intsys_sigaltstack(struct tcb *tcp){	if (entering(tcp)) {		print_stack_t(tcp, tcp->u_arg[0]);	}	else {		tprints(", ");		print_stack_t(tcp, tcp->u_arg[1]);	}	return 0;}

static booldecode_rtnl_link_stats(struct tcb *const tcp,		       const kernel_ulong_t addr,		       const unsigned int len,		       const void *const opaque_data){	struct rtnl_link_stats st;	const unsigned int min_size =		offsetofend(struct rtnl_link_stats, tx_compressed);	const unsigned int def_size = sizeof(st);	const unsigned int size =		(len >= def_size) ? def_size :				    ((len == min_size) ? min_size : 0);	if (!size)		return false;	if (!umoven_or_printaddr(tcp, addr, size, &st)) {		PRINT_FIELD_U("{", st, rx_packets);		PRINT_FIELD_U(", ", st, tx_packets);		PRINT_FIELD_U(", ", st, rx_bytes);		PRINT_FIELD_U(", ", st, tx_bytes);		PRINT_FIELD_U(", ", st, rx_errors);		PRINT_FIELD_U(", ", st, tx_errors);		PRINT_FIELD_U(", ", st, rx_dropped);		PRINT_FIELD_U(", ", st, tx_dropped);		PRINT_FIELD_U(", ", st, multicast);		PRINT_FIELD_U(", ", st, collisions);		PRINT_FIELD_U(", ", st, rx_length_errors);		PRINT_FIELD_U(", ", st, rx_over_errors);		PRINT_FIELD_U(", ", st, rx_crc_errors);		PRINT_FIELD_U(", ", st, rx_frame_errors);		PRINT_FIELD_U(", ", st, rx_fifo_errors);		PRINT_FIELD_U(", ", st, rx_missed_errors);		PRINT_FIELD_U(", ", st, tx_aborted_errors);		PRINT_FIELD_U(", ", st, tx_carrier_errors);		PRINT_FIELD_U(", ", st, tx_fifo_errors);		PRINT_FIELD_U(", ", st, tx_heartbeat_errors);		PRINT_FIELD_U(", ", st, tx_window_errors);		PRINT_FIELD_U(", ", st, rx_compressed);		PRINT_FIELD_U(", ", st, tx_compressed);#ifdef HAVE_STRUCT_RTNL_LINK_STATS_RX_NOHANDLER		if (len >= def_size)			PRINT_FIELD_U(", ", st, rx_nohandler);#endif		tprints("}");	}	return true;}

intsys_pwritev(struct tcb *tcp){	if (entering(tcp)) {		printfd(tcp, tcp->u_arg[0]);		tprints(", ");		tprint_iov(tcp, tcp->u_arg[2], tcp->u_arg[1], 1);		tprintf(", %lu, ", tcp->u_arg[2]);		print_llu_from_low_high_val(tcp, 3);	}	return 0;}

intsys_pwrite(struct tcb *tcp){	if (entering(tcp)) {		printfd(tcp, tcp->u_arg[0]);		tprints(", ");		printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);		tprintf(", %lu, ", tcp->u_arg[2]);		printllval(tcp, "%llu", PREAD_OFFSET_ARG);	}	return 0;}

static voidprint_cap_bits(const uint32_t lo, const uint32_t hi){	if (lo || !hi)		printflags(cap_mask0, lo, "CAP_???");	if (hi) {		if (lo)			tprints("|");		printflags(cap_mask1, hi, "CAP_???");	}}

static voiddecode_old_sigaction(struct tcb *tcp, long addr){	struct old_sigaction sa;#if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4	if (current_wordsize != sizeof(sa.__sa_handler) && current_wordsize == 4) {		struct old_sigaction32 sa32;		if (umove_or_printaddr(tcp, addr, &sa32))			return;		memset(&sa, 0, sizeof(sa));		sa.__sa_handler = (void*)(uintptr_t)sa32.__sa_handler;		sa.sa_flags = sa32.sa_flags;#if HAVE_SA_RESTORER && defined SA_RESTORER		sa.sa_restorer = (void*)(uintptr_t)sa32.sa_restorer;#endif		sa.sa_mask = sa32.sa_mask;	} else#endif	if (umove_or_printaddr(tcp, addr, &sa))		return;	/* Architectures using function pointers, like	 * hppa, may need to manipulate the function pointer	 * to compute the result of a comparison. However,	 * the __sa_handler function pointer exists only in	 * the address space of the traced process, and can't	 * be manipulated by strace. In order to prevent the	 * compiler from generating code to manipulate	 * __sa_handler we cast the function pointers to long. */	tprints("{");	if ((long)sa.__sa_handler == (long)SIG_ERR)		tprints("SIG_ERR");	else if ((long)sa.__sa_handler == (long)SIG_DFL)		tprints("SIG_DFL");	else if ((long)sa.__sa_handler == (long)SIG_IGN)		tprints("SIG_IGN");	else		printaddr((long) sa.__sa_handler);	tprints(", ");#ifdef MIPS	tprintsigmask_addr("", sa.sa_mask);#else	tprintsigmask_val("", sa.sa_mask);#endif	tprints(", ");	printflags(sigact_flags, sa.sa_flags, "SA_???");#if HAVE_SA_RESTORER && defined SA_RESTORER	if (sa.sa_flags & SA_RESTORER)		tprintf(", %p", sa.sa_restorer);#endif	tprints("}");}

voidprintsigevent(struct tcb *tcp, long arg){	struct sigevent sev;#if SUPPORTED_PERSONALITIES > 1	if (current_wordsize == 4) {		printsigevent32(tcp, arg);		return;	}#endif	if (umove(tcp, arg, &sev) < 0)		tprints("{...}");	else {		tprintf("{%p, ", sev.sigev_value.sival_ptr);		if (sev.sigev_notify == SIGEV_SIGNAL)			tprintf("%s, ", signame(sev.sigev_signo));		else			tprintf("%u, ", sev.sigev_signo);		printxval(sigev_value, sev.sigev_notify, "SIGEV_???");		tprints(", ");		if (sev.sigev_notify == SIGEV_THREAD_ID)#if defined(HAVE_STRUCT_SIGEVENT__SIGEV_UN__PAD)			/* _pad[0] is the _tid field which might not be			   present in the userlevel definition of the			   struct.  */			tprintf("{%d}", sev._sigev_un._pad[0]);#elif defined(HAVE_STRUCT_SIGEVENT___PAD)			tprintf("{%d}", sev.__pad[0]);#else# warning unfamiliar struct sigevent => incomplete SIGEV_THREAD_ID decoding			tprints("{...}");#endif		else if (sev.sigev_notify == SIGEV_THREAD)			tprintf("{%p, %p}", sev.sigev_notify_function,				sev.sigev_notify_attributes);		else			tprints("{...}");		tprints("}");	}