/* * Common code for probe-based Dynamic events. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA * * This code was copied from kernel/trace/trace_kprobe.c written by * Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com> * * Updates to make this generic: * Copyright (C) IBM Corporation, 2010-2011 * Author:     Srikar Dronamraju */ #include "trace_probe.h" const char *reserved_field_names[] = {	"common_type",	"common_flags",	"common_preempt_count",	"common_pid",	"common_tgid",	FIELD_STRING_IP,	FIELD_STRING_RETIP,	FIELD_STRING_FUNC,}; /* Printing  in basic type function template */#define DEFINE_BASIC_PRINT_TYPE_FUNC(type, fmt)				\int PRINT_TYPE_FUNC_NAME(type)(struct trace_seq *s, const char *name,	\				void *data, void *ent)			\{									\	trace_seq_printf(s, " %s=" fmt, name, *(type *)data);		\	return !trace_seq_has_overflowed(s);				\}									\const char PRINT_TYPE_FMT_NAME(type)[] = fmt;				\NOKPROBE_SYMBOL(PRINT_TYPE_FUNC_NAME(type)); DEFINE_BASIC_PRINT_TYPE_FUNC(u8 , "0x%x")DEFINE_BASIC_PRINT_TYPE_FUNC(u16, "0x%x")DEFINE_BASIC_PRINT_TYPE_FUNC(u32, "0x%x")DEFINE_BASIC_PRINT_TYPE_FUNC(u64, "0x%Lx")DEFINE_BASIC_PRINT_TYPE_FUNC(s8,  "%d")DEFINE_BASIC_PRINT_TYPE_FUNC(s16, "%d")DEFINE_BASIC_PRINT_TYPE_FUNC(s32, "%d")DEFINE_BASIC_PRINT_TYPE_FUNC(s64, "%Ld") /* Print type function for string type */int PRINT_TYPE_FUNC_NAME(string)(struct trace_seq *s, const char *name,				 void *data, void *ent){	int len = *(u32 *)data >> 16; 	if (!len)		trace_seq_printf(s, " %s=(fault)", name);	else		trace_seq_printf(s, " %s=\"%s\"", name,				 (const char *)get_loc_data(data, ent));	return !trace_seq_has_overflowed(s);}NOKPROBE_SYMBOL(PRINT_TYPE_FUNC_NAME(string)); const char PRINT_TYPE_FMT_NAME(string)[] = "\\\"%s\\\""; #define CHECK_FETCH_FUNCS(method, fn)			\	(((FETCH_FUNC_NAME(method, u8) == fn) ||	\	  (FETCH_FUNC_NAME(method, u16) == fn) ||	\	  (FETCH_FUNC_NAME(method, u32) == fn) ||	\	  (FETCH_FUNC_NAME(method, u64) == fn) ||	\	  (FETCH_FUNC_NAME(method, string) == fn) ||	\	  (FETCH_FUNC_NAME(method, string_size) == fn)) \	 && (fn != NULL)) /* Data fetch function templates */#define DEFINE_FETCH_reg(type)						\void FETCH_FUNC_NAME(reg, type)(struct pt_regs *regs, void *offset, void *dest)	\{									\	*(type *)dest = (type)regs_get_register(regs,			\				(unsigned int)((unsigned long)offset));	\}									\NOKPROBE_SYMBOL(FETCH_FUNC_NAME(reg, type));DEFINE_BASIC_FETCH_FUNCS(reg)/* No string on the register */#define fetch_reg_string	NULL#define fetch_reg_string_size	NULL #define DEFINE_FETCH_retval(type)					\void FETCH_FUNC_NAME(retval, type)(struct pt_regs *regs,		\				   void *dummy, void *dest)		\{									\	*(type *)dest = (type)regs_return_value(regs);			\}									\NOKPROBE_SYMBOL(FETCH_FUNC_NAME(retval, type));DEFINE_BASIC_FETCH_FUNCS(retval)/* No string on the retval */#define fetch_retval_string		NULL#define fetch_retval_string_size	NULL /* Dereference memory access function */struct deref_fetch_param {	struct fetch_param	orig;	long			offset;	fetch_func_t		fetch;	fetch_func_t		fetch_size;}; #define DEFINE_FETCH_deref(type)					\void FETCH_FUNC_NAME(deref, type)(struct pt_regs *regs,			\				  void *data, void *dest)		\{									\	struct deref_fetch_param *dprm = data;				\	unsigned long addr;						\	call_fetch(&dprm->orig, regs, &addr);				\	if (addr) {							\		addr += dprm->offset;					\		dprm->fetch(regs, (void *)addr, dest);			\	} else								\		*(type *)dest = 0;					\}									\NOKPROBE_SYMBOL(FETCH_FUNC_NAME(deref, type));DEFINE_BASIC_FETCH_FUNCS(deref)DEFINE_FETCH_deref(string) void FETCH_FUNC_NAME(deref, string_size)(struct pt_regs *regs,					 void *data, void *dest){	struct deref_fetch_param *dprm = data;	unsigned long addr; 	call_fetch(&dprm->orig, regs, &addr);	if (addr && dprm->fetch_size) {		addr += dprm->offset;		dprm->fetch_size(regs, (void *)addr, dest);	} else		*(string_size *)dest = 0;}NOKPROBE_SYMBOL(FETCH_FUNC_NAME(deref, string_size)); static void update_deref_fetch_param(struct deref_fetch_param *data){	if (CHECK_FETCH_FUNCS(deref, data->orig.fn))		update_deref_fetch_param(data->orig.data);	else if (CHECK_FETCH_FUNCS(symbol, data->orig.fn))		update_symbol_cache(data->orig.data);}NOKPROBE_SYMBOL(update_deref_fetch_param); static void free_deref_fetch_param(struct deref_fetch_param *data){	if (CHECK_FETCH_FUNCS(deref, data->orig.fn))		free_deref_fetch_param(data->orig.data);	else if (CHECK_FETCH_FUNCS(symbol, data->orig.fn))		free_symbol_cache(data->orig.data);	kfree(data);}NOKPROBE_SYMBOL(free_deref_fetch_param); /* Bitfield fetch function */struct bitfield_fetch_param {	struct fetch_param	orig;	unsigned char		hi_shift;	unsigned char		low_shift;}; #define DEFINE_FETCH_bitfield(type)					\void FETCH_FUNC_NAME(bitfield, type)(struct pt_regs *regs,		\				     void *data, void *dest)		\{									\	struct bitfield_fetch_param *bprm = data;			\	type buf = 0;							\	call_fetch(&bprm->orig, regs, &buf);				\	if (buf) {							\		buf <<= bprm->hi_shift;					\		buf >>= bprm->low_shift;				\	}								\	*(type *)dest = buf;						\}									\NOKPROBE_SYMBOL(FETCH_FUNC_NAME(bitfield, type));DEFINE_BASIC_FETCH_FUNCS(bitfield)#define fetch_bitfield_string		NULL#define fetch_bitfield_string_size	NULL static voidupdate_bitfield_fetch_param(struct bitfield_fetch_param *data){	/*	 * Don't check the bitfield itself, because this must be the	 * last fetch function.	 */	if (CHECK_FETCH_FUNCS(deref, data->orig.fn))		update_deref_fetch_param(data->orig.data);	else if (CHECK_FETCH_FUNCS(symbol, data->orig.fn))		update_symbol_cache(data->orig.data);} static voidfree_bitfield_fetch_param(struct bitfield_fetch_param *data){	/*	 * Don't check the bitfield itself, because this must be the	 * last fetch function.	 */	if (CHECK_FETCH_FUNCS(deref, data->orig.fn))		free_deref_fetch_param(data->orig.data);	else if (CHECK_FETCH_FUNCS(symbol, data->orig.fn))		free_symbol_cache(data->orig.data); 	kfree(data);} static const struct fetch_type *find_fetch_type(const char *type,						const struct fetch_type *ftbl){	int i; 	if (!type)		type = DEFAULT_FETCH_TYPE_STR; 	/* Special case: bitfield */	if (*type == 'b') {		unsigned long bs; 		type = strchr(type, '/');		if (!type)			goto fail; 		type++;		if (kstrtoul(type, 0, &bs))			goto fail; 		switch (bs) {		case 8:			return find_fetch_type("u8", ftbl);		case 16:			return find_fetch_type("u16", ftbl);		case 32:			return find_fetch_type("u32", ftbl);		case 64:			return find_fetch_type("u64", ftbl);		default:			goto fail;		}	} 	for (i = 0; ftbl[i].name; i++) {		if (strcmp(type, ftbl[i].name) == 0)			return &ftbl[i];	} fail:	return NULL;} /* Special function : only accept unsigned long */static void fetch_kernel_stack_address(struct pt_regs *regs, void *dummy, void *dest){	*(unsigned long *)dest = kernel_stack_pointer(regs);}NOKPROBE_SYMBOL(fetch_kernel_stack_address); static void fetch_user_stack_address(struct pt_regs *regs, void *dummy, void *dest){	*(unsigned long *)dest = user_stack_pointer(regs);}NOKPROBE_SYMBOL(fetch_user_stack_address); static fetch_func_t get_fetch_size_function(const struct fetch_type *type,					    fetch_func_t orig_fn,					    const struct fetch_type *ftbl){	int i; 	if (type != &ftbl[FETCH_TYPE_STRING])		return NULL;	/* Only string type needs size function */ 	for (i = 0; i < FETCH_MTD_END; i++)		if (type->fetch[i] == orig_fn)			return ftbl[FETCH_TYPE_STRSIZE].fetch[i]; 	WARN_ON(1);	/* This should not happen */ 	return NULL;} /* Split symbol and offset. */int traceprobe_split_symbol_offset(char *symbol, unsigned long *offset){	char *tmp;	int ret; 	if (!offset)		return -EINVAL; 	tmp = strchr(symbol, '+');	if (tmp) {		/* skip sign because kstrtoul doesn't accept '+' */		ret = kstrtoul(tmp + 1, 0, offset);		if (ret)			return ret; 		*tmp = '\0';	} else		*offset = 0; 	return 0;} #define PARAM_MAX_STACK (THREAD_SIZE / sizeof(unsigned long)) static int parse_probe_vars(char *arg, const struct fetch_type *t,			    struct fetch_param *f, bool is_return,			    bool is_kprobe){	int ret = 0;	unsigned long param; 	if (strcmp(arg, "retval") == 0) {		if (is_return)			f->fn = t->fetch[FETCH_MTD_retval];		else			ret = -EINVAL;	} else if (strncmp(arg, "stack", 5) == 0) {		if (arg[5] == '\0') {			if (strcmp(t->name, DEFAULT_FETCH_TYPE_STR))				return -EINVAL; 			if (is_kprobe)				f->fn = fetch_kernel_stack_address;			else				f->fn = fetch_user_stack_address;		} else if (isdigit(arg[5])) {			ret = kstrtoul(arg + 5, 10, &param);			if (ret || (is_kprobe && param > PARAM_MAX_STACK))				ret = -EINVAL;			else {				f->fn = t->fetch[FETCH_MTD_stack];				f->data = (void *)param;			}		} else			ret = -EINVAL;	} else		ret = -EINVAL; 	return ret;} /* Recursive argument parser */static int parse_probe_arg(char *arg, const struct fetch_type *t,		     struct fetch_param *f, bool is_return, bool is_kprobe,		     const struct fetch_type *ftbl){	unsigned long param;	long offset;	char *tmp;	int ret = 0; 	switch (arg[0]) {	case '$':		ret = parse_probe_vars(arg + 1, t, f, is_return, is_kprobe);		break; 	case '%':	/* named register */		ret = regs_query_register_offset(arg + 1);		if (ret >= 0) {			f->fn = t->fetch[FETCH_MTD_reg];			f->data = (void *)(unsigned long)ret;			ret = 0;		}		break; 	case '@':	/* memory, file-offset or symbol */		if (isdigit(arg[1])) {			ret = kstrtoul(arg + 1, 0, &param);			if (ret)				break; 			f->fn = t->fetch[FETCH_MTD_memory];			f->data = (void *)param;		} else if (arg[1] == '+') {			/* kprobes don't support file offsets */			if (is_kprobe)				return -EINVAL; 			ret = kstrtol(arg + 2, 0, &offset);			if (ret)				break; 			f->fn = t->fetch[FETCH_MTD_file_offset];			f->data = (void *)offset;		} else {			/* uprobes don't support symbols */			if (!is_kprobe)				return -EINVAL; 			ret = traceprobe_split_symbol_offset(arg + 1, &offset);			if (ret)				break; 			f->data = alloc_symbol_cache(arg + 1, offset);			if (f->data)				f->fn = t->fetch[FETCH_MTD_symbol];		}		break; 	case '+':	/* deref memory */		arg++;	/* Skip '+', because kstrtol() rejects it. */	case '-':		tmp = strchr(arg, '(');		if (!tmp)			break; 		*tmp = '\0';		ret = kstrtol(arg, 0, &offset); 		if (ret)			break; 		arg = tmp + 1;		tmp = strrchr(arg, ')'); 		if (tmp) {			struct deref_fetch_param	*dprm;			const struct fetch_type		*t2; 			t2 = find_fetch_type(NULL, ftbl);			*tmp = '\0';			dprm = kzalloc(sizeof(struct deref_fetch_param), GFP_KERNEL); 			if (!dprm)				return -ENOMEM; 			dprm->offset = offset;			dprm->fetch = t->fetch[FETCH_MTD_memory];			dprm->fetch_size = get_fetch_size_function(t,							dprm->fetch, ftbl);			ret = parse_probe_arg(arg, t2, &dprm->orig, is_return,							is_kprobe, ftbl);			if (ret)				kfree(dprm);			else {				f->fn = t->fetch[FETCH_MTD_deref];				f->data = (void *)dprm;			}		}		break;	}	if (!ret && !f->fn) {	/* Parsed, but do not find fetch method */		pr_info("%s type has no corresponding fetch method.\n", t->name);		ret = -EINVAL;	} 	return ret;} #define BYTES_TO_BITS(nb)	((BITS_PER_LONG * (nb)) / sizeof(long)) /* Bitfield type needs to be parsed into a fetch function */static int __parse_bitfield_probe_arg(const char *bf,				      const struct fetch_type *t,				      struct fetch_param *f){	struct bitfield_fetch_param *bprm;	unsigned long bw, bo;	char *tail; 	if (*bf != 'b')		return 0; 	bprm = kzalloc(sizeof(*bprm), GFP_KERNEL);	if (!bprm)		return -ENOMEM; 	bprm->orig = *f;	f->fn = t->fetch[FETCH_MTD_bitfield];	f->data = (void *)bprm;	bw = simple_strtoul(bf + 1, &tail, 0);	/* Use simple one */ 	if (bw == 0 || *tail != '@')		return -EINVAL; 	bf = tail + 1;	bo = simple_strtoul(bf, &tail, 0); 	if (tail == bf || *tail != '/')		return -EINVAL; 	bprm->hi_shift = BYTES_TO_BITS(t->size) - (bw + bo);	bprm->low_shift = bprm->hi_shift + bo; 	return (BYTES_TO_BITS(t->size) < (bw + bo)) ? -EINVAL : 0;

Lines 1–500 of 723. Load more