lkml.org 
[lkml]   [2012]   [May]   [23]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    SubjectRe: [PATCH 2/3] tracing: Extract out common code for kprobes/uprobes traceevents
    From
    Date
    On Tue, 2012-04-03 at 06:34 +0530, Srikar Dronamraju wrote:
    > From: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
    >
    > Move parts of trace_kprobe.c that can be shared with upcoming
    > trace_uprobe.c. Common code to kernel/trace/trace_probe.h and
    > kernel/trace/trace_probe.c. There are no functional changes.
    >
    > Signed-off-by: Srikar Dronamraju <srikar@linux.vnet.ibm.com>

    Masami,

    Can you ack this patch if you agree with it.

    Thanks,

    -- Steve

    > ---
    >
    > Changelog:
    > (v5)
    > - Extracted out int to bool changes to a separate patch.
    > - Fix a bug in kprobe_trace_self_tests_init that was introduced
    > in previous patchset.
    >
    > (v7)
    > - Modified Copyright as suggested by Steven Rostedt.
    >
    > kernel/trace/Kconfig | 4
    > kernel/trace/Makefile | 1
    > kernel/trace/trace_kprobe.c | 889 +------------------------------------------
    > kernel/trace/trace_probe.c | 835 ++++++++++++++++++++++++++++++++++++++++
    > kernel/trace/trace_probe.h | 160 ++++++++
    > 5 files changed, 1018 insertions(+), 871 deletions(-)
    > create mode 100644 kernel/trace/trace_probe.c
    > create mode 100644 kernel/trace/trace_probe.h
    >
    > diff --git a/kernel/trace/Kconfig b/kernel/trace/Kconfig
    > index a1d2849..ce5a5c5 100644
    > --- a/kernel/trace/Kconfig
    > +++ b/kernel/trace/Kconfig
    > @@ -373,6 +373,7 @@ config KPROBE_EVENT
    > depends on HAVE_REGS_AND_STACK_ACCESS_API
    > bool "Enable kprobes-based dynamic events"
    > select TRACING
    > + select PROBE_EVENTS
    > default y
    > help
    > This allows the user to add tracing events (similar to tracepoints)
    > @@ -385,6 +386,9 @@ config KPROBE_EVENT
    > This option is also required by perf-probe subcommand of perf tools.
    > If you want to use perf tools, this option is strongly recommended.
    >
    > +config PROBE_EVENTS
    > + def_bool n
    > +
    > config DYNAMIC_FTRACE
    > bool "enable/disable ftrace tracepoints dynamically"
    > depends on FUNCTION_TRACER
    > diff --git a/kernel/trace/Makefile b/kernel/trace/Makefile
    > index 5f39a07..fa10d5c 100644
    > --- a/kernel/trace/Makefile
    > +++ b/kernel/trace/Makefile
    > @@ -61,5 +61,6 @@ endif
    > ifeq ($(CONFIG_TRACING),y)
    > obj-$(CONFIG_KGDB_KDB) += trace_kdb.o
    > endif
    > +obj-$(CONFIG_PROBE_EVENTS) += trace_probe.o
    >
    > libftrace-y := ftrace.o
    > diff --git a/kernel/trace/trace_kprobe.c b/kernel/trace/trace_kprobe.c
    > index 4f935f8..f8b7773 100644
    > --- a/kernel/trace/trace_kprobe.c
    > +++ b/kernel/trace/trace_kprobe.c
    > @@ -19,547 +19,15 @@
    >
    > #include <linux/module.h>
    > #include <linux/uaccess.h>
    > -#include <linux/kprobes.h>
    > -#include <linux/seq_file.h>
    > -#include <linux/slab.h>
    > -#include <linux/smp.h>
    > -#include <linux/debugfs.h>
    > -#include <linux/types.h>
    > -#include <linux/string.h>
    > -#include <linux/ctype.h>
    > -#include <linux/ptrace.h>
    > -#include <linux/perf_event.h>
    > -#include <linux/stringify.h>
    > -#include <linux/limits.h>
    > -#include <asm/bitsperlong.h>
    > -
    > -#include "trace.h"
    > -#include "trace_output.h"
    > -
    > -#define MAX_TRACE_ARGS 128
    > -#define MAX_ARGSTR_LEN 63
    > -#define MAX_EVENT_NAME_LEN 64
    > -#define MAX_STRING_SIZE PATH_MAX
    > -#define KPROBE_EVENT_SYSTEM "kprobes"
    > -
    > -/* Reserved field names */
    > -#define FIELD_STRING_IP "__probe_ip"
    > -#define FIELD_STRING_RETIP "__probe_ret_ip"
    > -#define FIELD_STRING_FUNC "__probe_func"
    > -
    > -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 function type */
    > -typedef int (*print_type_func_t)(struct trace_seq *, const char *, void *,
    > - void *);
    > -#define PRINT_TYPE_FUNC_NAME(type) print_type_##type
    > -#define PRINT_TYPE_FMT_NAME(type) print_type_format_##type
    > -
    > -/* Printing in basic type function template */
    > -#define DEFINE_BASIC_PRINT_TYPE_FUNC(type, fmt, cast) \
    > -static __kprobes int PRINT_TYPE_FUNC_NAME(type)(struct trace_seq *s, \
    > - const char *name, \
    > - void *data, void *ent)\
    > -{ \
    > - return trace_seq_printf(s, " %s=" fmt, name, (cast)*(type *)data);\
    > -} \
    > -static const char PRINT_TYPE_FMT_NAME(type)[] = fmt;
    > -
    > -DEFINE_BASIC_PRINT_TYPE_FUNC(u8, "%x", unsigned int)
    > -DEFINE_BASIC_PRINT_TYPE_FUNC(u16, "%x", unsigned int)
    > -DEFINE_BASIC_PRINT_TYPE_FUNC(u32, "%lx", unsigned long)
    > -DEFINE_BASIC_PRINT_TYPE_FUNC(u64, "%llx", unsigned long long)
    > -DEFINE_BASIC_PRINT_TYPE_FUNC(s8, "%d", int)
    > -DEFINE_BASIC_PRINT_TYPE_FUNC(s16, "%d", int)
    > -DEFINE_BASIC_PRINT_TYPE_FUNC(s32, "%ld", long)
    > -DEFINE_BASIC_PRINT_TYPE_FUNC(s64, "%lld", long long)
    > -
    > -/* data_rloc: data relative location, compatible with u32 */
    > -#define make_data_rloc(len, roffs) \
    > - (((u32)(len) << 16) | ((u32)(roffs) & 0xffff))
    > -#define get_rloc_len(dl) ((u32)(dl) >> 16)
    > -#define get_rloc_offs(dl) ((u32)(dl) & 0xffff)
    > -
    > -static inline void *get_rloc_data(u32 *dl)
    > -{
    > - return (u8 *)dl + get_rloc_offs(*dl);
    > -}
    > -
    > -/* For data_loc conversion */
    > -static inline void *get_loc_data(u32 *dl, void *ent)
    > -{
    > - return (u8 *)ent + get_rloc_offs(*dl);
    > -}
    > -
    > -/*
    > - * Convert data_rloc to data_loc:
    > - * data_rloc stores the offset from data_rloc itself, but data_loc
    > - * stores the offset from event entry.
    > - */
    > -#define convert_rloc_to_loc(dl, offs) ((u32)(dl) + (offs))
    > -
    > -/* For defining macros, define string/string_size types */
    > -typedef u32 string;
    > -typedef u32 string_size;
    > -
    > -/* Print type function for string type */
    > -static __kprobes int PRINT_TYPE_FUNC_NAME(string)(struct trace_seq *s,
    > - const char *name,
    > - void *data, void *ent)
    > -{
    > - int len = *(u32 *)data >> 16;
    > -
    > - if (!len)
    > - return trace_seq_printf(s, " %s=(fault)", name);
    > - else
    > - return trace_seq_printf(s, " %s=\"%s\"", name,
    > - (const char *)get_loc_data(data, ent));
    > -}
    > -static const char PRINT_TYPE_FMT_NAME(string)[] = "\\\"%s\\\"";
    > -
    > -/* Data fetch function type */
    > -typedef void (*fetch_func_t)(struct pt_regs *, void *, void *);
    > -
    > -struct fetch_param {
    > - fetch_func_t fn;
    > - void *data;
    > -};
    > -
    > -static __kprobes void call_fetch(struct fetch_param *fprm,
    > - struct pt_regs *regs, void *dest)
    > -{
    > - return fprm->fn(regs, fprm->data, dest);
    > -}
    > -
    > -#define FETCH_FUNC_NAME(method, type) fetch_##method##_##type
    > -/*
    > - * Define macro for basic types - we don't need to define s* types, because
    > - * we have to care only about bitwidth at recording time.
    > - */
    > -#define DEFINE_BASIC_FETCH_FUNCS(method) \
    > -DEFINE_FETCH_##method(u8) \
    > -DEFINE_FETCH_##method(u16) \
    > -DEFINE_FETCH_##method(u32) \
    > -DEFINE_FETCH_##method(u64)
    > -
    > -#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) \
    > -static __kprobes 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)); \
    > -}
    > -DEFINE_BASIC_FETCH_FUNCS(reg)
    > -/* No string on the register */
    > -#define fetch_reg_string NULL
    > -#define fetch_reg_string_size NULL
    > -
    > -#define DEFINE_FETCH_stack(type) \
    > -static __kprobes void FETCH_FUNC_NAME(stack, type)(struct pt_regs *regs,\
    > - void *offset, void *dest) \
    > -{ \
    > - *(type *)dest = (type)regs_get_kernel_stack_nth(regs, \
    > - (unsigned int)((unsigned long)offset)); \
    > -}
    > -DEFINE_BASIC_FETCH_FUNCS(stack)
    > -/* No string on the stack entry */
    > -#define fetch_stack_string NULL
    > -#define fetch_stack_string_size NULL
    > -
    > -#define DEFINE_FETCH_retval(type) \
    > -static __kprobes void FETCH_FUNC_NAME(retval, type)(struct pt_regs *regs,\
    > - void *dummy, void *dest) \
    > -{ \
    > - *(type *)dest = (type)regs_return_value(regs); \
    > -}
    > -DEFINE_BASIC_FETCH_FUNCS(retval)
    > -/* No string on the retval */
    > -#define fetch_retval_string NULL
    > -#define fetch_retval_string_size NULL
    > -
    > -#define DEFINE_FETCH_memory(type) \
    > -static __kprobes void FETCH_FUNC_NAME(memory, type)(struct pt_regs *regs,\
    > - void *addr, void *dest) \
    > -{ \
    > - type retval; \
    > - if (probe_kernel_address(addr, retval)) \
    > - *(type *)dest = 0; \
    > - else \
    > - *(type *)dest = retval; \
    > -}
    > -DEFINE_BASIC_FETCH_FUNCS(memory)
    > -/*
    > - * Fetch a null-terminated string. Caller MUST set *(u32 *)dest with max
    > - * length and relative data location.
    > - */
    > -static __kprobes void FETCH_FUNC_NAME(memory, string)(struct pt_regs *regs,
    > - void *addr, void *dest)
    > -{
    > - long ret;
    > - int maxlen = get_rloc_len(*(u32 *)dest);
    > - u8 *dst = get_rloc_data(dest);
    > - u8 *src = addr;
    > - mm_segment_t old_fs = get_fs();
    > - if (!maxlen)
    > - return;
    > - /*
    > - * Try to get string again, since the string can be changed while
    > - * probing.
    > - */
    > - set_fs(KERNEL_DS);
    > - pagefault_disable();
    > - do
    > - ret = __copy_from_user_inatomic(dst++, src++, 1);
    > - while (dst[-1] && ret == 0 && src - (u8 *)addr < maxlen);
    > - dst[-1] = '\0';
    > - pagefault_enable();
    > - set_fs(old_fs);
    > -
    > - if (ret < 0) { /* Failed to fetch string */
    > - ((u8 *)get_rloc_data(dest))[0] = '\0';
    > - *(u32 *)dest = make_data_rloc(0, get_rloc_offs(*(u32 *)dest));
    > - } else
    > - *(u32 *)dest = make_data_rloc(src - (u8 *)addr,
    > - get_rloc_offs(*(u32 *)dest));
    > -}
    > -/* Return the length of string -- including null terminal byte */
    > -static __kprobes void FETCH_FUNC_NAME(memory, string_size)(struct pt_regs *regs,
    > - void *addr, void *dest)
    > -{
    > - int ret, len = 0;
    > - u8 c;
    > - mm_segment_t old_fs = get_fs();
    > -
    > - set_fs(KERNEL_DS);
    > - pagefault_disable();
    > - do {
    > - ret = __copy_from_user_inatomic(&c, (u8 *)addr + len, 1);
    > - len++;
    > - } while (c && ret == 0 && len < MAX_STRING_SIZE);
    > - pagefault_enable();
    > - set_fs(old_fs);
    > -
    > - if (ret < 0) /* Failed to check the length */
    > - *(u32 *)dest = 0;
    > - else
    > - *(u32 *)dest = len;
    > -}
    > -
    > -/* Memory fetching by symbol */
    > -struct symbol_cache {
    > - char *symbol;
    > - long offset;
    > - unsigned long addr;
    > -};
    > -
    > -static unsigned long update_symbol_cache(struct symbol_cache *sc)
    > -{
    > - sc->addr = (unsigned long)kallsyms_lookup_name(sc->symbol);
    > - if (sc->addr)
    > - sc->addr += sc->offset;
    > - return sc->addr;
    > -}
    > -
    > -static void free_symbol_cache(struct symbol_cache *sc)
    > -{
    > - kfree(sc->symbol);
    > - kfree(sc);
    > -}
    > -
    > -static struct symbol_cache *alloc_symbol_cache(const char *sym, long offset)
    > -{
    > - struct symbol_cache *sc;
    > -
    > - if (!sym || strlen(sym) == 0)
    > - return NULL;
    > - sc = kzalloc(sizeof(struct symbol_cache), GFP_KERNEL);
    > - if (!sc)
    > - return NULL;
    > -
    > - sc->symbol = kstrdup(sym, GFP_KERNEL);
    > - if (!sc->symbol) {
    > - kfree(sc);
    > - return NULL;
    > - }
    > - sc->offset = offset;
    >
    > - update_symbol_cache(sc);
    > - return sc;
    > -}
    > -
    > -#define DEFINE_FETCH_symbol(type) \
    > -static __kprobes void FETCH_FUNC_NAME(symbol, type)(struct pt_regs *regs,\
    > - void *data, void *dest) \
    > -{ \
    > - struct symbol_cache *sc = data; \
    > - if (sc->addr) \
    > - fetch_memory_##type(regs, (void *)sc->addr, dest); \
    > - else \
    > - *(type *)dest = 0; \
    > -}
    > -DEFINE_BASIC_FETCH_FUNCS(symbol)
    > -DEFINE_FETCH_symbol(string)
    > -DEFINE_FETCH_symbol(string_size)
    > -
    > -/* Dereference memory access function */
    > -struct deref_fetch_param {
    > - struct fetch_param orig;
    > - long offset;
    > -};
    > -
    > -#define DEFINE_FETCH_deref(type) \
    > -static __kprobes 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; \
    > - fetch_memory_##type(regs, (void *)addr, dest); \
    > - } else \
    > - *(type *)dest = 0; \
    > -}
    > -DEFINE_BASIC_FETCH_FUNCS(deref)
    > -DEFINE_FETCH_deref(string)
    > -DEFINE_FETCH_deref(string_size)
    > -
    > -static __kprobes 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);
    > -}
    > -
    > -static __kprobes 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);
    > -}
    > -
    > -/* Bitfield fetch function */
    > -struct bitfield_fetch_param {
    > - struct fetch_param orig;
    > - unsigned char hi_shift;
    > - unsigned char low_shift;
    > -};
    > +#include "trace_probe.h"
    >
    > -#define DEFINE_FETCH_bitfield(type) \
    > -static __kprobes 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; \
    > -}
    > -DEFINE_BASIC_FETCH_FUNCS(bitfield)
    > -#define fetch_bitfield_string NULL
    > -#define fetch_bitfield_string_size NULL
    > -
    > -static __kprobes void
    > -update_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 __kprobes void
    > -free_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);
    > -}
    > -
    > -/* Default (unsigned long) fetch type */
    > -#define __DEFAULT_FETCH_TYPE(t) u##t
    > -#define _DEFAULT_FETCH_TYPE(t) __DEFAULT_FETCH_TYPE(t)
    > -#define DEFAULT_FETCH_TYPE _DEFAULT_FETCH_TYPE(BITS_PER_LONG)
    > -#define DEFAULT_FETCH_TYPE_STR __stringify(DEFAULT_FETCH_TYPE)
    > -
    > -/* Fetch types */
    > -enum {
    > - FETCH_MTD_reg = 0,
    > - FETCH_MTD_stack,
    > - FETCH_MTD_retval,
    > - FETCH_MTD_memory,
    > - FETCH_MTD_symbol,
    > - FETCH_MTD_deref,
    > - FETCH_MTD_bitfield,
    > - FETCH_MTD_END,
    > -};
    > -
    > -#define ASSIGN_FETCH_FUNC(method, type) \
    > - [FETCH_MTD_##method] = FETCH_FUNC_NAME(method, type)
    > -
    > -#define __ASSIGN_FETCH_TYPE(_name, ptype, ftype, _size, sign, _fmttype) \
    > - {.name = _name, \
    > - .size = _size, \
    > - .is_signed = sign, \
    > - .print = PRINT_TYPE_FUNC_NAME(ptype), \
    > - .fmt = PRINT_TYPE_FMT_NAME(ptype), \
    > - .fmttype = _fmttype, \
    > - .fetch = { \
    > -ASSIGN_FETCH_FUNC(reg, ftype), \
    > -ASSIGN_FETCH_FUNC(stack, ftype), \
    > -ASSIGN_FETCH_FUNC(retval, ftype), \
    > -ASSIGN_FETCH_FUNC(memory, ftype), \
    > -ASSIGN_FETCH_FUNC(symbol, ftype), \
    > -ASSIGN_FETCH_FUNC(deref, ftype), \
    > -ASSIGN_FETCH_FUNC(bitfield, ftype), \
    > - } \
    > - }
    > -
    > -#define ASSIGN_FETCH_TYPE(ptype, ftype, sign) \
    > - __ASSIGN_FETCH_TYPE(#ptype, ptype, ftype, sizeof(ftype), sign, #ptype)
    > -
    > -#define FETCH_TYPE_STRING 0
    > -#define FETCH_TYPE_STRSIZE 1
    > -
    > -/* Fetch type information table */
    > -static const struct fetch_type {
    > - const char *name; /* Name of type */
    > - size_t size; /* Byte size of type */
    > - int is_signed; /* Signed flag */
    > - print_type_func_t print; /* Print functions */
    > - const char *fmt; /* Fromat string */
    > - const char *fmttype; /* Name in format file */
    > - /* Fetch functions */
    > - fetch_func_t fetch[FETCH_MTD_END];
    > -} fetch_type_table[] = {
    > - /* Special types */
    > - [FETCH_TYPE_STRING] = __ASSIGN_FETCH_TYPE("string", string, string,
    > - sizeof(u32), 1, "__data_loc char[]"),
    > - [FETCH_TYPE_STRSIZE] = __ASSIGN_FETCH_TYPE("string_size", u32,
    > - string_size, sizeof(u32), 0, "u32"),
    > - /* Basic types */
    > - ASSIGN_FETCH_TYPE(u8, u8, 0),
    > - ASSIGN_FETCH_TYPE(u16, u16, 0),
    > - ASSIGN_FETCH_TYPE(u32, u32, 0),
    > - ASSIGN_FETCH_TYPE(u64, u64, 0),
    > - ASSIGN_FETCH_TYPE(s8, u8, 1),
    > - ASSIGN_FETCH_TYPE(s16, u16, 1),
    > - ASSIGN_FETCH_TYPE(s32, u32, 1),
    > - ASSIGN_FETCH_TYPE(s64, u64, 1),
    > -};
    > -
    > -static const struct fetch_type *find_fetch_type(const char *type)
    > -{
    > - 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 (strict_strtoul(type, 0, &bs))
    > - goto fail;
    > - switch (bs) {
    > - case 8:
    > - return find_fetch_type("u8");
    > - case 16:
    > - return find_fetch_type("u16");
    > - case 32:
    > - return find_fetch_type("u32");
    > - case 64:
    > - return find_fetch_type("u64");
    > - default:
    > - goto fail;
    > - }
    > - }
    > -
    > - for (i = 0; i < ARRAY_SIZE(fetch_type_table); i++)
    > - if (strcmp(type, fetch_type_table[i].name) == 0)
    > - return &fetch_type_table[i];
    > -fail:
    > - return NULL;
    > -}
    > -
    > -/* Special function : only accept unsigned long */
    > -static __kprobes void fetch_stack_address(struct pt_regs *regs,
    > - void *dummy, void *dest)
    > -{
    > - *(unsigned long *)dest = kernel_stack_pointer(regs);
    > -}
    > -
    > -static fetch_func_t get_fetch_size_function(const struct fetch_type *type,
    > - fetch_func_t orig_fn)
    > -{
    > - int i;
    > -
    > - if (type != &fetch_type_table[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 fetch_type_table[FETCH_TYPE_STRSIZE].fetch[i];
    > -
    > - WARN_ON(1); /* This should not happen */
    > - return NULL;
    > -}
    > +#define KPROBE_EVENT_SYSTEM "kprobes"
    >
    > /**
    > * Kprobe event core functions
    > */
    >
    > -struct probe_arg {
    > - struct fetch_param fetch;
    > - struct fetch_param fetch_size;
    > - unsigned int offset; /* Offset from argument entry */
    > - const char *name; /* Name of this argument */
    > - const char *comm; /* Command of this argument */
    > - const struct fetch_type *type; /* Type of this argument */
    > -};
    > -
    > -/* Flags for trace_probe */
    > -#define TP_FLAG_TRACE 1
    > -#define TP_FLAG_PROFILE 2
    > -#define TP_FLAG_REGISTERED 4
    > -
    > struct trace_probe {
    > struct list_head list;
    > struct kretprobe rp; /* Use rp.kp for kprobe use */
    > @@ -631,18 +99,6 @@ static int kprobe_dispatcher(struct kprobe *kp, struct pt_regs *regs);
    > static int kretprobe_dispatcher(struct kretprobe_instance *ri,
    > struct pt_regs *regs);
    >
    > -/* Check the name is good for event/group/fields */
    > -static int is_good_name(const char *name)
    > -{
    > - if (!isalpha(*name) && *name != '_')
    > - return 0;
    > - while (*++name != '\0') {
    > - if (!isalpha(*name) && !isdigit(*name) && *name != '_')
    > - return 0;
    > - }
    > - return 1;
    > -}
    > -
    > /*
    > * Allocate new trace_probe and initialize it (including kprobes).
    > */
    > @@ -702,34 +158,12 @@ static struct trace_probe *alloc_trace_probe(const char *group,
    > return ERR_PTR(ret);
    > }
    >
    > -static void update_probe_arg(struct probe_arg *arg)
    > -{
    > - if (CHECK_FETCH_FUNCS(bitfield, arg->fetch.fn))
    > - update_bitfield_fetch_param(arg->fetch.data);
    > - else if (CHECK_FETCH_FUNCS(deref, arg->fetch.fn))
    > - update_deref_fetch_param(arg->fetch.data);
    > - else if (CHECK_FETCH_FUNCS(symbol, arg->fetch.fn))
    > - update_symbol_cache(arg->fetch.data);
    > -}
    > -
    > -static void free_probe_arg(struct probe_arg *arg)
    > -{
    > - if (CHECK_FETCH_FUNCS(bitfield, arg->fetch.fn))
    > - free_bitfield_fetch_param(arg->fetch.data);
    > - else if (CHECK_FETCH_FUNCS(deref, arg->fetch.fn))
    > - free_deref_fetch_param(arg->fetch.data);
    > - else if (CHECK_FETCH_FUNCS(symbol, arg->fetch.fn))
    > - free_symbol_cache(arg->fetch.data);
    > - kfree(arg->name);
    > - kfree(arg->comm);
    > -}
    > -
    > static void free_trace_probe(struct trace_probe *tp)
    > {
    > int i;
    >
    > for (i = 0; i < tp->nr_args; i++)
    > - free_probe_arg(&tp->args[i]);
    > + traceprobe_free_probe_arg(&tp->args[i]);
    >
    > kfree(tp->call.class->system);
    > kfree(tp->call.name);
    > @@ -787,7 +221,7 @@ static int __register_trace_probe(struct trace_probe *tp)
    > return -EINVAL;
    >
    > for (i = 0; i < tp->nr_args; i++)
    > - update_probe_arg(&tp->args[i]);
    > + traceprobe_update_arg(&tp->args[i]);
    >
    > /* Set/clear disabled flag according to tp->flag */
    > if (trace_probe_is_enabled(tp))
    > @@ -919,227 +353,6 @@ static struct notifier_block trace_probe_module_nb = {
    > .priority = 1 /* Invoked after kprobe module callback */
    > };
    >
    > -/* Split symbol and offset. */
    > -static int split_symbol_offset(char *symbol, unsigned long *offset)
    > -{
    > - char *tmp;
    > - int ret;
    > -
    > - if (!offset)
    > - return -EINVAL;
    > -
    > - tmp = strchr(symbol, '+');
    > - if (tmp) {
    > - /* skip sign because strict_strtol doesn't accept '+' */
    > - ret = strict_strtoul(tmp + 1, 0, offset);
    > - if (ret)
    > - return ret;
    > - *tmp = '\0';
    > - } else
    > - *offset = 0;
    > - return 0;
    > -}
    > -
    > -#define PARAM_MAX_ARGS 16
    > -#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)
    > -{
    > - 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) == 0)
    > - f->fn = fetch_stack_address;
    > - else
    > - ret = -EINVAL;
    > - } else if (isdigit(arg[5])) {
    > - ret = strict_strtoul(arg + 5, 10, &param);
    > - if (ret || 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)
    > -{
    > - int ret = 0;
    > - unsigned long param;
    > - long offset;
    > - char *tmp;
    > -
    > - switch (arg[0]) {
    > - case '$':
    > - ret = parse_probe_vars(arg + 1, t, f, is_return);
    > - 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 or symbol */
    > - if (isdigit(arg[1])) {
    > - ret = strict_strtoul(arg + 1, 0, &param);
    > - if (ret)
    > - break;
    > - f->fn = t->fetch[FETCH_MTD_memory];
    > - f->data = (void *)param;
    > - } else {
    > - ret = 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 strict_strtol() rejects it. */
    > - case '-':
    > - tmp = strchr(arg, '(');
    > - if (!tmp)
    > - break;
    > - *tmp = '\0';
    > - ret = strict_strtol(arg, 0, &offset);
    > - if (ret)
    > - break;
    > - arg = tmp + 1;
    > - tmp = strrchr(arg, ')');
    > - if (tmp) {
    > - struct deref_fetch_param *dprm;
    > - const struct fetch_type *t2 = find_fetch_type(NULL);
    > - *tmp = '\0';
    > - dprm = kzalloc(sizeof(struct deref_fetch_param),
    > - GFP_KERNEL);
    > - if (!dprm)
    > - return -ENOMEM;
    > - dprm->offset = offset;
    > - ret = __parse_probe_arg(arg, t2, &dprm->orig,
    > - is_return);
    > - 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;
    > -}
    > -
    > -/* String length checking wrapper */
    > -static int parse_probe_arg(char *arg, struct trace_probe *tp,
    > - struct probe_arg *parg, bool is_return)
    > -{
    > - const char *t;
    > - int ret;
    > -
    > - if (strlen(arg) > MAX_ARGSTR_LEN) {
    > - pr_info("Argument is too long.: %s\n", arg);
    > - return -ENOSPC;
    > - }
    > - parg->comm = kstrdup(arg, GFP_KERNEL);
    > - if (!parg->comm) {
    > - pr_info("Failed to allocate memory for command '%s'.\n", arg);
    > - return -ENOMEM;
    > - }
    > - t = strchr(parg->comm, ':');
    > - if (t) {
    > - arg[t - parg->comm] = '\0';
    > - t++;
    > - }
    > - parg->type = find_fetch_type(t);
    > - if (!parg->type) {
    > - pr_info("Unsupported type: %s\n", t);
    > - return -EINVAL;
    > - }
    > - parg->offset = tp->size;
    > - tp->size += parg->type->size;
    > - ret = __parse_probe_arg(arg, parg->type, &parg->fetch, is_return);
    > - if (ret >= 0 && t != NULL)
    > - ret = __parse_bitfield_probe_arg(t, parg->type, &parg->fetch);
    > - if (ret >= 0) {
    > - parg->fetch_size.fn = get_fetch_size_function(parg->type,
    > - parg->fetch.fn);
    > - parg->fetch_size.data = parg->fetch.data;
    > - }
    > - return ret;
    > -}
    > -
    > -/* Return 1 if name is reserved or already used by another argument */
    > -static int conflict_field_name(const char *name,
    > - struct probe_arg *args, int narg)
    > -{
    > - int i;
    > - for (i = 0; i < ARRAY_SIZE(reserved_field_names); i++)
    > - if (strcmp(reserved_field_names[i], name) == 0)
    > - return 1;
    > - for (i = 0; i < narg; i++)
    > - if (strcmp(args[i].name, name) == 0)
    > - return 1;
    > - return 0;
    > -}
    > -
    > static int create_trace_probe(int argc, char **argv)
    > {
    > /*
    > @@ -1240,7 +453,7 @@ static int create_trace_probe(int argc, char **argv)
    > /* a symbol specified */
    > symbol = argv[1];
    > /* TODO: support .init module functions */
    > - ret = split_symbol_offset(symbol, &offset);
    > + ret = traceprobe_split_symbol_offset(symbol, &offset);
    > if (ret) {
    > pr_info("Failed to parse symbol.\n");
    > return ret;
    > @@ -1302,7 +515,8 @@ static int create_trace_probe(int argc, char **argv)
    > goto error;
    > }
    >
    > - if (conflict_field_name(tp->args[i].name, tp->args, i)) {
    > + if (traceprobe_conflict_field_name(tp->args[i].name,
    > + tp->args, i)) {
    > pr_info("Argument[%d] name '%s' conflicts with "
    > "another field.\n", i, argv[i]);
    > ret = -EINVAL;
    > @@ -1310,7 +524,8 @@ static int create_trace_probe(int argc, char **argv)
    > }
    >
    > /* Parse fetch argument */
    > - ret = parse_probe_arg(arg, tp, &tp->args[i], is_return);
    > + ret = traceprobe_parse_probe_arg(arg, &tp->size, &tp->args[i],
    > + is_return);
    > if (ret) {
    > pr_info("Parse error at argument[%d]. (%d)\n", i, ret);
    > goto error;
    > @@ -1412,70 +627,11 @@ static int probes_open(struct inode *inode, struct file *file)
    > return seq_open(file, &probes_seq_op);
    > }
    >
    > -static int command_trace_probe(const char *buf)
    > -{
    > - char **argv;
    > - int argc = 0, ret = 0;
    > -
    > - argv = argv_split(GFP_KERNEL, buf, &argc);
    > - if (!argv)
    > - return -ENOMEM;
    > -
    > - if (argc)
    > - ret = create_trace_probe(argc, argv);
    > -
    > - argv_free(argv);
    > - return ret;
    > -}
    > -
    > -#define WRITE_BUFSIZE 4096
    > -
    > static ssize_t probes_write(struct file *file, const char __user *buffer,
    > size_t count, loff_t *ppos)
    > {
    > - char *kbuf, *tmp;
    > - int ret;
    > - size_t done;
    > - size_t size;
    > -
    > - kbuf = kmalloc(WRITE_BUFSIZE, GFP_KERNEL);
    > - if (!kbuf)
    > - return -ENOMEM;
    > -
    > - ret = done = 0;
    > - while (done < count) {
    > - size = count - done;
    > - if (size >= WRITE_BUFSIZE)
    > - size = WRITE_BUFSIZE - 1;
    > - if (copy_from_user(kbuf, buffer + done, size)) {
    > - ret = -EFAULT;
    > - goto out;
    > - }
    > - kbuf[size] = '\0';
    > - tmp = strchr(kbuf, '\n');
    > - if (tmp) {
    > - *tmp = '\0';
    > - size = tmp - kbuf + 1;
    > - } else if (done + size < count) {
    > - pr_warning("Line length is too long: "
    > - "Should be less than %d.", WRITE_BUFSIZE);
    > - ret = -EINVAL;
    > - goto out;
    > - }
    > - done += size;
    > - /* Remove comments */
    > - tmp = strchr(kbuf, '#');
    > - if (tmp)
    > - *tmp = '\0';
    > -
    > - ret = command_trace_probe(kbuf);
    > - if (ret)
    > - goto out;
    > - }
    > - ret = done;
    > -out:
    > - kfree(kbuf);
    > - return ret;
    > + return traceprobe_probes_write(file, buffer, count, ppos,
    > + create_trace_probe);
    > }
    >
    > static const struct file_operations kprobe_events_ops = {
    > @@ -1711,16 +867,6 @@ print_kretprobe_event(struct trace_iterator *iter, int flags,
    > return TRACE_TYPE_PARTIAL_LINE;
    > }
    >
    > -#undef DEFINE_FIELD
    > -#define DEFINE_FIELD(type, item, name, is_signed) \
    > - do { \
    > - ret = trace_define_field(event_call, #type, name, \
    > - offsetof(typeof(field), item), \
    > - sizeof(field.item), is_signed, \
    > - FILTER_OTHER); \
    > - if (ret) \
    > - return ret; \
    > - } while (0)
    >
    > static int kprobe_event_define_fields(struct ftrace_event_call *event_call)
    > {
    > @@ -2051,8 +1197,9 @@ static __init int kprobe_trace_self_tests_init(void)
    >
    > pr_info("Testing kprobe tracing: ");
    >
    > - ret = command_trace_probe("p:testprobe kprobe_trace_selftest_target "
    > - "$stack $stack0 +0($stack)");
    > + ret = traceprobe_command("p:testprobe kprobe_trace_selftest_target "
    > + "$stack $stack0 +0($stack)",
    > + create_trace_probe);
    > if (WARN_ON_ONCE(ret)) {
    > pr_warning("error on probing function entry.\n");
    > warn++;
    > @@ -2066,8 +1213,8 @@ static __init int kprobe_trace_self_tests_init(void)
    > enable_trace_probe(tp, TP_FLAG_TRACE);
    > }
    >
    > - ret = command_trace_probe("r:testprobe2 kprobe_trace_selftest_target "
    > - "$retval");
    > + ret = traceprobe_command("r:testprobe2 kprobe_trace_selftest_target "
    > + "$retval", create_trace_probe);
    > if (WARN_ON_ONCE(ret)) {
    > pr_warning("error on probing function return.\n");
    > warn++;
    > @@ -2101,13 +1248,13 @@ static __init int kprobe_trace_self_tests_init(void)
    > } else
    > disable_trace_probe(tp, TP_FLAG_TRACE);
    >
    > - ret = command_trace_probe("-:testprobe");
    > + ret = traceprobe_command("-:testprobe", create_trace_probe);
    > if (WARN_ON_ONCE(ret)) {
    > pr_warning("error on deleting a probe.\n");
    > warn++;
    > }
    >
    > - ret = command_trace_probe("-:testprobe2");
    > + ret = traceprobe_command("-:testprobe2", create_trace_probe);
    > if (WARN_ON_ONCE(ret)) {
    > pr_warning("error on deleting a probe.\n");
    > warn++;
    > diff --git a/kernel/trace/trace_probe.c b/kernel/trace/trace_probe.c
    > new file mode 100644
    > index 0000000..deb375a
    > --- /dev/null
    > +++ b/kernel/trace/trace_probe.c
    > @@ -0,0 +1,835 @@
    > +/*
    > + * 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 function type */
    > +#define PRINT_TYPE_FUNC_NAME(type) print_type_##type
    > +#define PRINT_TYPE_FMT_NAME(type) print_type_format_##type
    > +
    > +/* Printing in basic type function template */
    > +#define DEFINE_BASIC_PRINT_TYPE_FUNC(type, fmt, cast) \
    > +static __kprobes int PRINT_TYPE_FUNC_NAME(type)(struct trace_seq *s, \
    > + const char *name, \
    > + void *data, void *ent)\
    > +{ \
    > + return trace_seq_printf(s, " %s=" fmt, name, (cast)*(type *)data);\
    > +} \
    > +static const char PRINT_TYPE_FMT_NAME(type)[] = fmt;
    > +
    > +DEFINE_BASIC_PRINT_TYPE_FUNC(u8, "%x", unsigned int)
    > +DEFINE_BASIC_PRINT_TYPE_FUNC(u16, "%x", unsigned int)
    > +DEFINE_BASIC_PRINT_TYPE_FUNC(u32, "%lx", unsigned long)
    > +DEFINE_BASIC_PRINT_TYPE_FUNC(u64, "%llx", unsigned long long)
    > +DEFINE_BASIC_PRINT_TYPE_FUNC(s8, "%d", int)
    > +DEFINE_BASIC_PRINT_TYPE_FUNC(s16, "%d", int)
    > +DEFINE_BASIC_PRINT_TYPE_FUNC(s32, "%ld", long)
    > +DEFINE_BASIC_PRINT_TYPE_FUNC(s64, "%lld", long long)
    > +
    > +static inline void *get_rloc_data(u32 *dl)
    > +{
    > + return (u8 *)dl + get_rloc_offs(*dl);
    > +}
    > +
    > +/* For data_loc conversion */
    > +static inline void *get_loc_data(u32 *dl, void *ent)
    > +{
    > + return (u8 *)ent + get_rloc_offs(*dl);
    > +}
    > +
    > +/* For defining macros, define string/string_size types */
    > +typedef u32 string;
    > +typedef u32 string_size;
    > +
    > +/* Print type function for string type */
    > +static __kprobes int PRINT_TYPE_FUNC_NAME(string)(struct trace_seq *s,
    > + const char *name,
    > + void *data, void *ent)
    > +{
    > + int len = *(u32 *)data >> 16;
    > +
    > + if (!len)
    > + return trace_seq_printf(s, " %s=(fault)", name);
    > + else
    > + return trace_seq_printf(s, " %s=\"%s\"", name,
    > + (const char *)get_loc_data(data, ent));
    > +}
    > +
    > +static const char PRINT_TYPE_FMT_NAME(string)[] = "\\\"%s\\\"";
    > +
    > +#define FETCH_FUNC_NAME(method, type) fetch_##method##_##type
    > +/*
    > + * Define macro for basic types - we don't need to define s* types, because
    > + * we have to care only about bitwidth at recording time.
    > + */
    > +#define DEFINE_BASIC_FETCH_FUNCS(method) \
    > +DEFINE_FETCH_##method(u8) \
    > +DEFINE_FETCH_##method(u16) \
    > +DEFINE_FETCH_##method(u32) \
    > +DEFINE_FETCH_##method(u64)
    > +
    > +#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) \
    > +static __kprobes 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)); \
    > +}
    > +DEFINE_BASIC_FETCH_FUNCS(reg)
    > +/* No string on the register */
    > +#define fetch_reg_string NULL
    > +#define fetch_reg_string_size NULL
    > +
    > +#define DEFINE_FETCH_stack(type) \
    > +static __kprobes void FETCH_FUNC_NAME(stack, type)(struct pt_regs *regs,\
    > + void *offset, void *dest) \
    > +{ \
    > + *(type *)dest = (type)regs_get_kernel_stack_nth(regs, \
    > + (unsigned int)((unsigned long)offset)); \
    > +}
    > +DEFINE_BASIC_FETCH_FUNCS(stack)
    > +/* No string on the stack entry */
    > +#define fetch_stack_string NULL
    > +#define fetch_stack_string_size NULL
    > +
    > +#define DEFINE_FETCH_retval(type) \
    > +static __kprobes void FETCH_FUNC_NAME(retval, type)(struct pt_regs *regs,\
    > + void *dummy, void *dest) \
    > +{ \
    > + *(type *)dest = (type)regs_return_value(regs); \
    > +}
    > +DEFINE_BASIC_FETCH_FUNCS(retval)
    > +/* No string on the retval */
    > +#define fetch_retval_string NULL
    > +#define fetch_retval_string_size NULL
    > +
    > +#define DEFINE_FETCH_memory(type) \
    > +static __kprobes void FETCH_FUNC_NAME(memory, type)(struct pt_regs *regs,\
    > + void *addr, void *dest) \
    > +{ \
    > + type retval; \
    > + if (probe_kernel_address(addr, retval)) \
    > + *(type *)dest = 0; \
    > + else \
    > + *(type *)dest = retval; \
    > +}
    > +DEFINE_BASIC_FETCH_FUNCS(memory)
    > +/*
    > + * Fetch a null-terminated string. Caller MUST set *(u32 *)dest with max
    > + * length and relative data location.
    > + */
    > +static __kprobes void FETCH_FUNC_NAME(memory, string)(struct pt_regs *regs,
    > + void *addr, void *dest)
    > +{
    > + int maxlen;
    > + long ret;
    > +
    > + maxlen = get_rloc_len(*(u32 *)dest);
    > + u8 *dst = get_rloc_data(dest);
    > + u8 *src = addr;
    > + mm_segment_t old_fs = get_fs();
    > +
    > + if (!maxlen)
    > + return;
    > +
    > + /*
    > + * Try to get string again, since the string can be changed while
    > + * probing.
    > + */
    > + set_fs(KERNEL_DS);
    > + pagefault_disable();
    > +
    > + do
    > + ret = __copy_from_user_inatomic(dst++, src++, 1);
    > + while (dst[-1] && ret == 0 && src - (u8 *)addr < maxlen);
    > +
    > + dst[-1] = '\0';
    > + pagefault_enable();
    > + set_fs(old_fs);
    > +
    > + if (ret < 0) { /* Failed to fetch string */
    > + ((u8 *)get_rloc_data(dest))[0] = '\0';
    > + *(u32 *)dest = make_data_rloc(0, get_rloc_offs(*(u32 *)dest));
    > + } else {
    > + *(u32 *)dest = make_data_rloc(src - (u8 *)addr,
    > + get_rloc_offs(*(u32 *)dest));
    > + }
    > +}
    > +
    > +/* Return the length of string -- including null terminal byte */
    > +static __kprobes void FETCH_FUNC_NAME(memory, string_size)(struct pt_regs *regs,
    > + void *addr, void *dest)
    > +{
    > + mm_segment_t old_fs;
    > + int ret, len = 0;
    > + u8 c;
    > +
    > + old_fs = get_fs();
    > + set_fs(KERNEL_DS);
    > + pagefault_disable();
    > +
    > + do {
    > + ret = __copy_from_user_inatomic(&c, (u8 *)addr + len, 1);
    > + len++;
    > + } while (c && ret == 0 && len < MAX_STRING_SIZE);
    > +
    > + pagefault_enable();
    > + set_fs(old_fs);
    > +
    > + if (ret < 0) /* Failed to check the length */
    > + *(u32 *)dest = 0;
    > + else
    > + *(u32 *)dest = len;
    > +}
    > +
    > +/* Memory fetching by symbol */
    > +struct symbol_cache {
    > + char *symbol;
    > + long offset;
    > + unsigned long addr;
    > +};
    > +
    > +static unsigned long update_symbol_cache(struct symbol_cache *sc)
    > +{
    > + sc->addr = (unsigned long)kallsyms_lookup_name(sc->symbol);
    > +
    > + if (sc->addr)
    > + sc->addr += sc->offset;
    > +
    > + return sc->addr;
    > +}
    > +
    > +static void free_symbol_cache(struct symbol_cache *sc)
    > +{
    > + kfree(sc->symbol);
    > + kfree(sc);
    > +}
    > +
    > +static struct symbol_cache *alloc_symbol_cache(const char *sym, long offset)
    > +{
    > + struct symbol_cache *sc;
    > +
    > + if (!sym || strlen(sym) == 0)
    > + return NULL;
    > +
    > + sc = kzalloc(sizeof(struct symbol_cache), GFP_KERNEL);
    > + if (!sc)
    > + return NULL;
    > +
    > + sc->symbol = kstrdup(sym, GFP_KERNEL);
    > + if (!sc->symbol) {
    > + kfree(sc);
    > + return NULL;
    > + }
    > + sc->offset = offset;
    > + update_symbol_cache(sc);
    > +
    > + return sc;
    > +}
    > +
    > +#define DEFINE_FETCH_symbol(type) \
    > +static __kprobes void FETCH_FUNC_NAME(symbol, type)(struct pt_regs *regs,\
    > + void *data, void *dest) \
    > +{ \
    > + struct symbol_cache *sc = data; \
    > + if (sc->addr) \
    > + fetch_memory_##type(regs, (void *)sc->addr, dest); \
    > + else \
    > + *(type *)dest = 0; \
    > +}
    > +DEFINE_BASIC_FETCH_FUNCS(symbol)
    > +DEFINE_FETCH_symbol(string)
    > +DEFINE_FETCH_symbol(string_size)
    > +
    > +/* Dereference memory access function */
    > +struct deref_fetch_param {
    > + struct fetch_param orig;
    > + long offset;
    > +};
    > +
    > +#define DEFINE_FETCH_deref(type) \
    > +static __kprobes 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; \
    > + fetch_memory_##type(regs, (void *)addr, dest); \
    > + } else \
    > + *(type *)dest = 0; \
    > +}
    > +DEFINE_BASIC_FETCH_FUNCS(deref)
    > +DEFINE_FETCH_deref(string)
    > +DEFINE_FETCH_deref(string_size)
    > +
    > +static __kprobes 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);
    > +}
    > +
    > +static __kprobes 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);
    > +}
    > +
    > +/* Bitfield fetch function */
    > +struct bitfield_fetch_param {
    > + struct fetch_param orig;
    > + unsigned char hi_shift;
    > + unsigned char low_shift;
    > +};
    > +
    > +#define DEFINE_FETCH_bitfield(type) \
    > +static __kprobes 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; \
    > +}
    > +
    > +DEFINE_BASIC_FETCH_FUNCS(bitfield)
    > +#define fetch_bitfield_string NULL
    > +#define fetch_bitfield_string_size NULL
    > +
    > +static __kprobes void
    > +update_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 __kprobes void
    > +free_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);
    > +}
    > +
    > +/* Default (unsigned long) fetch type */
    > +#define __DEFAULT_FETCH_TYPE(t) u##t
    > +#define _DEFAULT_FETCH_TYPE(t) __DEFAULT_FETCH_TYPE(t)
    > +#define DEFAULT_FETCH_TYPE _DEFAULT_FETCH_TYPE(BITS_PER_LONG)
    > +#define DEFAULT_FETCH_TYPE_STR __stringify(DEFAULT_FETCH_TYPE)
    > +
    > +#define ASSIGN_FETCH_FUNC(method, type) \
    > + [FETCH_MTD_##method] = FETCH_FUNC_NAME(method, type)
    > +
    > +#define __ASSIGN_FETCH_TYPE(_name, ptype, ftype, _size, sign, _fmttype) \
    > + {.name = _name, \
    > + .size = _size, \
    > + .is_signed = sign, \
    > + .print = PRINT_TYPE_FUNC_NAME(ptype), \
    > + .fmt = PRINT_TYPE_FMT_NAME(ptype), \
    > + .fmttype = _fmttype, \
    > + .fetch = { \
    > +ASSIGN_FETCH_FUNC(reg, ftype), \
    > +ASSIGN_FETCH_FUNC(stack, ftype), \
    > +ASSIGN_FETCH_FUNC(retval, ftype), \
    > +ASSIGN_FETCH_FUNC(memory, ftype), \
    > +ASSIGN_FETCH_FUNC(symbol, ftype), \
    > +ASSIGN_FETCH_FUNC(deref, ftype), \
    > +ASSIGN_FETCH_FUNC(bitfield, ftype), \
    > + } \
    > + }
    > +
    > +#define ASSIGN_FETCH_TYPE(ptype, ftype, sign) \
    > + __ASSIGN_FETCH_TYPE(#ptype, ptype, ftype, sizeof(ftype), sign, #ptype)
    > +
    > +#define FETCH_TYPE_STRING 0
    > +#define FETCH_TYPE_STRSIZE 1
    > +
    > +/* Fetch type information table */
    > +static const struct fetch_type fetch_type_table[] = {
    > + /* Special types */
    > + [FETCH_TYPE_STRING] = __ASSIGN_FETCH_TYPE("string", string, string,
    > + sizeof(u32), 1, "__data_loc char[]"),
    > + [FETCH_TYPE_STRSIZE] = __ASSIGN_FETCH_TYPE("string_size", u32,
    > + string_size, sizeof(u32), 0, "u32"),
    > + /* Basic types */
    > + ASSIGN_FETCH_TYPE(u8, u8, 0),
    > + ASSIGN_FETCH_TYPE(u16, u16, 0),
    > + ASSIGN_FETCH_TYPE(u32, u32, 0),
    > + ASSIGN_FETCH_TYPE(u64, u64, 0),
    > + ASSIGN_FETCH_TYPE(s8, u8, 1),
    > + ASSIGN_FETCH_TYPE(s16, u16, 1),
    > + ASSIGN_FETCH_TYPE(s32, u32, 1),
    > + ASSIGN_FETCH_TYPE(s64, u64, 1),
    > +};
    > +
    > +static const struct fetch_type *find_fetch_type(const char *type)
    > +{
    > + 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 (strict_strtoul(type, 0, &bs))
    > + goto fail;
    > +
    > + switch (bs) {
    > + case 8:
    > + return find_fetch_type("u8");
    > + case 16:
    > + return find_fetch_type("u16");
    > + case 32:
    > + return find_fetch_type("u32");
    > + case 64:
    > + return find_fetch_type("u64");
    > + default:
    > + goto fail;
    > + }
    > + }
    > +
    > + for (i = 0; i < ARRAY_SIZE(fetch_type_table); i++)
    > + if (strcmp(type, fetch_type_table[i].name) == 0)
    > + return &fetch_type_table[i];
    > +
    > +fail:
    > + return NULL;
    > +}
    > +
    > +/* Special function : only accept unsigned long */
    > +static __kprobes void fetch_stack_address(struct pt_regs *regs,
    > + void *dummy, void *dest)
    > +{
    > + *(unsigned long *)dest = kernel_stack_pointer(regs);
    > +}
    > +
    > +static fetch_func_t get_fetch_size_function(const struct fetch_type *type,
    > + fetch_func_t orig_fn)
    > +{
    > + int i;
    > +
    > + if (type != &fetch_type_table[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 fetch_type_table[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 strict_strtol doesn't accept '+' */
    > + ret = strict_strtoul(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)
    > +{
    > + 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) == 0)
    > + f->fn = fetch_stack_address;
    > + else
    > + ret = -EINVAL;
    > + } else if (isdigit(arg[5])) {
    > + ret = strict_strtoul(arg + 5, 10, &param);
    > + if (ret || 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)
    > +{
    > + unsigned long param;
    > + long offset;
    > + char *tmp;
    > + int ret;
    > +
    > + ret = 0;
    > + switch (arg[0]) {
    > + case '$':
    > + ret = parse_probe_vars(arg + 1, t, f, is_return);
    > + 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 or symbol */
    > + if (isdigit(arg[1])) {
    > + ret = strict_strtoul(arg + 1, 0, &param);
    > + if (ret)
    > + break;
    > +
    > + f->fn = t->fetch[FETCH_MTD_memory];
    > + f->data = (void *)param;
    > + } else {
    > + 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 strict_strtol() rejects it. */
    > + case '-':
    > + tmp = strchr(arg, '(');
    > + if (!tmp)
    > + break;
    > +
    > + *tmp = '\0';
    > + ret = strict_strtol(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);
    > + *tmp = '\0';
    > + dprm = kzalloc(sizeof(struct deref_fetch_param), GFP_KERNEL);
    > +
    > + if (!dprm)
    > + return -ENOMEM;
    > +
    > + dprm->offset = offset;
    > + ret = parse_probe_arg(arg, t2, &dprm->orig, is_return);
    > + 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;
    > +}
    > +
    > +/* String length checking wrapper */
    > +int traceprobe_parse_probe_arg(char *arg, ssize_t *size,
    > + struct probe_arg *parg, bool is_return)
    > +{
    > + const char *t;
    > + int ret;
    > +
    > + if (strlen(arg) > MAX_ARGSTR_LEN) {
    > + pr_info("Argument is too long.: %s\n", arg);
    > + return -ENOSPC;
    > + }
    > + parg->comm = kstrdup(arg, GFP_KERNEL);
    > + if (!parg->comm) {
    > + pr_info("Failed to allocate memory for command '%s'.\n", arg);
    > + return -ENOMEM;
    > + }
    > + t = strchr(parg->comm, ':');
    > + if (t) {
    > + arg[t - parg->comm] = '\0';
    > + t++;
    > + }
    > + parg->type = find_fetch_type(t);
    > + if (!parg->type) {
    > + pr_info("Unsupported type: %s\n", t);
    > + return -EINVAL;
    > + }
    > + parg->offset = *size;
    > + *size += parg->type->size;
    > + ret = parse_probe_arg(arg, parg->type, &parg->fetch, is_return);
    > +
    > + if (ret >= 0 && t != NULL)
    > + ret = __parse_bitfield_probe_arg(t, parg->type, &parg->fetch);
    > +
    > + if (ret >= 0) {
    > + parg->fetch_size.fn = get_fetch_size_function(parg->type,
    > + parg->fetch.fn);
    > + parg->fetch_size.data = parg->fetch.data;
    > + }
    > +
    > + return ret;
    > +}
    > +
    > +/* Return 1 if name is reserved or already used by another argument */
    > +int traceprobe_conflict_field_name(const char *name,
    > + struct probe_arg *args, int narg)
    > +{
    > + int i;
    > +
    > + for (i = 0; i < ARRAY_SIZE(reserved_field_names); i++)
    > + if (strcmp(reserved_field_names[i], name) == 0)
    > + return 1;
    > +
    > + for (i = 0; i < narg; i++)
    > + if (strcmp(args[i].name, name) == 0)
    > + return 1;
    > +
    > + return 0;
    > +}
    > +
    > +void traceprobe_update_arg(struct probe_arg *arg)
    > +{
    > + if (CHECK_FETCH_FUNCS(bitfield, arg->fetch.fn))
    > + update_bitfield_fetch_param(arg->fetch.data);
    > + else if (CHECK_FETCH_FUNCS(deref, arg->fetch.fn))
    > + update_deref_fetch_param(arg->fetch.data);
    > + else if (CHECK_FETCH_FUNCS(symbol, arg->fetch.fn))
    > + update_symbol_cache(arg->fetch.data);
    > +}
    > +
    > +void traceprobe_free_probe_arg(struct probe_arg *arg)
    > +{
    > + if (CHECK_FETCH_FUNCS(bitfield, arg->fetch.fn))
    > + free_bitfield_fetch_param(arg->fetch.data);
    > + else if (CHECK_FETCH_FUNCS(deref, arg->fetch.fn))
    > + free_deref_fetch_param(arg->fetch.data);
    > + else if (CHECK_FETCH_FUNCS(symbol, arg->fetch.fn))
    > + free_symbol_cache(arg->fetch.data);
    > +
    > + kfree(arg->name);
    > + kfree(arg->comm);
    > +}
    > +
    > +int traceprobe_command(const char *buf, int (*createfn)(int, char **))
    > +{
    > + char **argv;
    > + int argc, ret;
    > +
    > + argc = 0;
    > + ret = 0;
    > + argv = argv_split(GFP_KERNEL, buf, &argc);
    > + if (!argv)
    > + return -ENOMEM;
    > +
    > + if (argc)
    > + ret = createfn(argc, argv);
    > +
    > + argv_free(argv);
    > +
    > + return ret;
    > +}
    > +
    > +#define WRITE_BUFSIZE 128
    > +
    > +ssize_t traceprobe_probes_write(struct file *file, const char __user *buffer,
    > + size_t count, loff_t *ppos,
    > + int (*createfn)(int, char **))
    > +{
    > + char *kbuf, *tmp;
    > + int ret = 0;
    > + size_t done = 0;
    > + size_t size;
    > +
    > + kbuf = kmalloc(WRITE_BUFSIZE, GFP_KERNEL);
    > + if (!kbuf)
    > + return -ENOMEM;
    > +
    > + while (done < count) {
    > + size = count - done;
    > +
    > + if (size >= WRITE_BUFSIZE)
    > + size = WRITE_BUFSIZE - 1;
    > +
    > + if (copy_from_user(kbuf, buffer + done, size)) {
    > + ret = -EFAULT;
    > + goto out;
    > + }
    > + kbuf[size] = '\0';
    > + tmp = strchr(kbuf, '\n');
    > +
    > + if (tmp) {
    > + *tmp = '\0';
    > + size = tmp - kbuf + 1;
    > + } else if (done + size < count) {
    > + pr_warning("Line length is too long: "
    > + "Should be less than %d.", WRITE_BUFSIZE);
    > + ret = -EINVAL;
    > + goto out;
    > + }
    > + done += size;
    > + /* Remove comments */
    > + tmp = strchr(kbuf, '#');
    > +
    > + if (tmp)
    > + *tmp = '\0';
    > +
    > + ret = traceprobe_command(kbuf, createfn);
    > + if (ret)
    > + goto out;
    > + }
    > + ret = done;
    > +
    > +out:
    > + kfree(kbuf);
    > +
    > + return ret;
    > +}
    > diff --git a/kernel/trace/trace_probe.h b/kernel/trace/trace_probe.h
    > new file mode 100644
    > index 0000000..2df9a18
    > --- /dev/null
    > +++ b/kernel/trace/trace_probe.h
    > @@ -0,0 +1,160 @@
    > +/*
    > + * Common header file 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.h written by
    > + * Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
    > + *
    > + * Updates to make this generic:
    > + * Copyright (C) IBM Corporation, 2010-2011
    > + * Author: Srikar Dronamraju
    > + */
    > +
    > +#include <linux/seq_file.h>
    > +#include <linux/slab.h>
    > +#include <linux/smp.h>
    > +#include <linux/debugfs.h>
    > +#include <linux/types.h>
    > +#include <linux/string.h>
    > +#include <linux/ctype.h>
    > +#include <linux/ptrace.h>
    > +#include <linux/perf_event.h>
    > +#include <linux/kprobes.h>
    > +#include <linux/stringify.h>
    > +#include <linux/limits.h>
    > +#include <linux/uaccess.h>
    > +#include <asm/bitsperlong.h>
    > +
    > +#include "trace.h"
    > +#include "trace_output.h"
    > +
    > +#define MAX_TRACE_ARGS 128
    > +#define MAX_ARGSTR_LEN 63
    > +#define MAX_EVENT_NAME_LEN 64
    > +#define MAX_STRING_SIZE PATH_MAX
    > +
    > +/* Reserved field names */
    > +#define FIELD_STRING_IP "__probe_ip"
    > +#define FIELD_STRING_RETIP "__probe_ret_ip"
    > +#define FIELD_STRING_FUNC "__probe_func"
    > +
    > +#undef DEFINE_FIELD
    > +#define DEFINE_FIELD(type, item, name, is_signed) \
    > + do { \
    > + ret = trace_define_field(event_call, #type, name, \
    > + offsetof(typeof(field), item), \
    > + sizeof(field.item), is_signed, \
    > + FILTER_OTHER); \
    > + if (ret) \
    > + return ret; \
    > + } while (0)
    > +
    > +
    > +/* Flags for trace_probe */
    > +#define TP_FLAG_TRACE 1
    > +#define TP_FLAG_PROFILE 2
    > +#define TP_FLAG_REGISTERED 4
    > +
    > +
    > +/* data_rloc: data relative location, compatible with u32 */
    > +#define make_data_rloc(len, roffs) \
    > + (((u32)(len) << 16) | ((u32)(roffs) & 0xffff))
    > +#define get_rloc_len(dl) ((u32)(dl) >> 16)
    > +#define get_rloc_offs(dl) ((u32)(dl) & 0xffff)
    > +
    > +/*
    > + * Convert data_rloc to data_loc:
    > + * data_rloc stores the offset from data_rloc itself, but data_loc
    > + * stores the offset from event entry.
    > + */
    > +#define convert_rloc_to_loc(dl, offs) ((u32)(dl) + (offs))
    > +
    > +/* Data fetch function type */
    > +typedef void (*fetch_func_t)(struct pt_regs *, void *, void *);
    > +/* Printing function type */
    > +typedef int (*print_type_func_t)(struct trace_seq *, const char *, void *, void *);
    > +
    > +/* Fetch types */
    > +enum {
    > + FETCH_MTD_reg = 0,
    > + FETCH_MTD_stack,
    > + FETCH_MTD_retval,
    > + FETCH_MTD_memory,
    > + FETCH_MTD_symbol,
    > + FETCH_MTD_deref,
    > + FETCH_MTD_bitfield,
    > + FETCH_MTD_END,
    > +};
    > +
    > +/* Fetch type information table */
    > +struct fetch_type {
    > + const char *name; /* Name of type */
    > + size_t size; /* Byte size of type */
    > + int is_signed; /* Signed flag */
    > + print_type_func_t print; /* Print functions */
    > + const char *fmt; /* Fromat string */
    > + const char *fmttype; /* Name in format file */
    > + /* Fetch functions */
    > + fetch_func_t fetch[FETCH_MTD_END];
    > +};
    > +
    > +struct fetch_param {
    > + fetch_func_t fn;
    > + void *data;
    > +};
    > +
    > +struct probe_arg {
    > + struct fetch_param fetch;
    > + struct fetch_param fetch_size;
    > + unsigned int offset; /* Offset from argument entry */
    > + const char *name; /* Name of this argument */
    > + const char *comm; /* Command of this argument */
    > + const struct fetch_type *type; /* Type of this argument */
    > +};
    > +
    > +static inline __kprobes void call_fetch(struct fetch_param *fprm,
    > + struct pt_regs *regs, void *dest)
    > +{
    > + return fprm->fn(regs, fprm->data, dest);
    > +}
    > +
    > +/* Check the name is good for event/group/fields */
    > +static inline int is_good_name(const char *name)
    > +{
    > + if (!isalpha(*name) && *name != '_')
    > + return 0;
    > + while (*++name != '\0') {
    > + if (!isalpha(*name) && !isdigit(*name) && *name != '_')
    > + return 0;
    > + }
    > + return 1;
    > +}
    > +
    > +extern int traceprobe_parse_probe_arg(char *arg, ssize_t *size,
    > + struct probe_arg *parg, bool is_return);
    > +
    > +extern int traceprobe_conflict_field_name(const char *name,
    > + struct probe_arg *args, int narg);
    > +
    > +extern void traceprobe_update_arg(struct probe_arg *arg);
    > +extern void traceprobe_free_probe_arg(struct probe_arg *arg);
    > +
    > +extern int traceprobe_split_symbol_offset(char *symbol, unsigned long *offset);
    > +
    > +extern ssize_t traceprobe_probes_write(struct file *file,
    > + const char __user *buffer, size_t count, loff_t *ppos,
    > + int (*createfn)(int, char**));
    > +
    > +extern int traceprobe_command(const char *buf, int (*createfn)(int, char**));
    >




    \
     
     \ /
      Last update: 2012-05-23 13:01    [W:0.190 / U:0.208 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site