Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Common code for probe-based Dynamic events.
0004  *
0005  * This code was copied from kernel/trace/trace_kprobe.c written by
0006  * Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
0007  *
0008  * Updates to make this generic:
0009  * Copyright (C) IBM Corporation, 2010-2011
0010  * Author:     Srikar Dronamraju
0011  */
0012 #define pr_fmt(fmt) "trace_probe: " fmt
0013 
0014 #include "trace_probe.h"
0015 
0016 #undef C
0017 #define C(a, b)     b
0018 
0019 static const char *trace_probe_err_text[] = { ERRORS };
0020 
0021 static const char *reserved_field_names[] = {
0022     "common_type",
0023     "common_flags",
0024     "common_preempt_count",
0025     "common_pid",
0026     "common_tgid",
0027     FIELD_STRING_IP,
0028     FIELD_STRING_RETIP,
0029     FIELD_STRING_FUNC,
0030 };
0031 
0032 /* Printing  in basic type function template */
0033 #define DEFINE_BASIC_PRINT_TYPE_FUNC(tname, type, fmt)          \
0034 int PRINT_TYPE_FUNC_NAME(tname)(struct trace_seq *s, void *data, void *ent)\
0035 {                                   \
0036     trace_seq_printf(s, fmt, *(type *)data);            \
0037     return !trace_seq_has_overflowed(s);                \
0038 }                                   \
0039 const char PRINT_TYPE_FMT_NAME(tname)[] = fmt;
0040 
0041 DEFINE_BASIC_PRINT_TYPE_FUNC(u8,  u8,  "%u")
0042 DEFINE_BASIC_PRINT_TYPE_FUNC(u16, u16, "%u")
0043 DEFINE_BASIC_PRINT_TYPE_FUNC(u32, u32, "%u")
0044 DEFINE_BASIC_PRINT_TYPE_FUNC(u64, u64, "%Lu")
0045 DEFINE_BASIC_PRINT_TYPE_FUNC(s8,  s8,  "%d")
0046 DEFINE_BASIC_PRINT_TYPE_FUNC(s16, s16, "%d")
0047 DEFINE_BASIC_PRINT_TYPE_FUNC(s32, s32, "%d")
0048 DEFINE_BASIC_PRINT_TYPE_FUNC(s64, s64, "%Ld")
0049 DEFINE_BASIC_PRINT_TYPE_FUNC(x8,  u8,  "0x%x")
0050 DEFINE_BASIC_PRINT_TYPE_FUNC(x16, u16, "0x%x")
0051 DEFINE_BASIC_PRINT_TYPE_FUNC(x32, u32, "0x%x")
0052 DEFINE_BASIC_PRINT_TYPE_FUNC(x64, u64, "0x%Lx")
0053 
0054 int PRINT_TYPE_FUNC_NAME(symbol)(struct trace_seq *s, void *data, void *ent)
0055 {
0056     trace_seq_printf(s, "%pS", (void *)*(unsigned long *)data);
0057     return !trace_seq_has_overflowed(s);
0058 }
0059 const char PRINT_TYPE_FMT_NAME(symbol)[] = "%pS";
0060 
0061 /* Print type function for string type */
0062 int PRINT_TYPE_FUNC_NAME(string)(struct trace_seq *s, void *data, void *ent)
0063 {
0064     int len = *(u32 *)data >> 16;
0065 
0066     if (!len)
0067         trace_seq_puts(s, "(fault)");
0068     else
0069         trace_seq_printf(s, "\"%s\"",
0070                  (const char *)get_loc_data(data, ent));
0071     return !trace_seq_has_overflowed(s);
0072 }
0073 
0074 const char PRINT_TYPE_FMT_NAME(string)[] = "\\\"%s\\\"";
0075 
0076 /* Fetch type information table */
0077 static const struct fetch_type probe_fetch_types[] = {
0078     /* Special types */
0079     __ASSIGN_FETCH_TYPE("string", string, string, sizeof(u32), 1,
0080                 "__data_loc char[]"),
0081     __ASSIGN_FETCH_TYPE("ustring", string, string, sizeof(u32), 1,
0082                 "__data_loc char[]"),
0083     /* Basic types */
0084     ASSIGN_FETCH_TYPE(u8,  u8,  0),
0085     ASSIGN_FETCH_TYPE(u16, u16, 0),
0086     ASSIGN_FETCH_TYPE(u32, u32, 0),
0087     ASSIGN_FETCH_TYPE(u64, u64, 0),
0088     ASSIGN_FETCH_TYPE(s8,  u8,  1),
0089     ASSIGN_FETCH_TYPE(s16, u16, 1),
0090     ASSIGN_FETCH_TYPE(s32, u32, 1),
0091     ASSIGN_FETCH_TYPE(s64, u64, 1),
0092     ASSIGN_FETCH_TYPE_ALIAS(x8,  u8,  u8,  0),
0093     ASSIGN_FETCH_TYPE_ALIAS(x16, u16, u16, 0),
0094     ASSIGN_FETCH_TYPE_ALIAS(x32, u32, u32, 0),
0095     ASSIGN_FETCH_TYPE_ALIAS(x64, u64, u64, 0),
0096     ASSIGN_FETCH_TYPE_ALIAS(symbol, ADDR_FETCH_TYPE, ADDR_FETCH_TYPE, 0),
0097 
0098     ASSIGN_FETCH_TYPE_END
0099 };
0100 
0101 static const struct fetch_type *find_fetch_type(const char *type)
0102 {
0103     int i;
0104 
0105     if (!type)
0106         type = DEFAULT_FETCH_TYPE_STR;
0107 
0108     /* Special case: bitfield */
0109     if (*type == 'b') {
0110         unsigned long bs;
0111 
0112         type = strchr(type, '/');
0113         if (!type)
0114             goto fail;
0115 
0116         type++;
0117         if (kstrtoul(type, 0, &bs))
0118             goto fail;
0119 
0120         switch (bs) {
0121         case 8:
0122             return find_fetch_type("u8");
0123         case 16:
0124             return find_fetch_type("u16");
0125         case 32:
0126             return find_fetch_type("u32");
0127         case 64:
0128             return find_fetch_type("u64");
0129         default:
0130             goto fail;
0131         }
0132     }
0133 
0134     for (i = 0; probe_fetch_types[i].name; i++) {
0135         if (strcmp(type, probe_fetch_types[i].name) == 0)
0136             return &probe_fetch_types[i];
0137     }
0138 
0139 fail:
0140     return NULL;
0141 }
0142 
0143 static struct trace_probe_log trace_probe_log;
0144 
0145 void trace_probe_log_init(const char *subsystem, int argc, const char **argv)
0146 {
0147     trace_probe_log.subsystem = subsystem;
0148     trace_probe_log.argc = argc;
0149     trace_probe_log.argv = argv;
0150     trace_probe_log.index = 0;
0151 }
0152 
0153 void trace_probe_log_clear(void)
0154 {
0155     memset(&trace_probe_log, 0, sizeof(trace_probe_log));
0156 }
0157 
0158 void trace_probe_log_set_index(int index)
0159 {
0160     trace_probe_log.index = index;
0161 }
0162 
0163 void __trace_probe_log_err(int offset, int err_type)
0164 {
0165     char *command, *p;
0166     int i, len = 0, pos = 0;
0167 
0168     if (!trace_probe_log.argv)
0169         return;
0170 
0171     /* Recalculate the length and allocate buffer */
0172     for (i = 0; i < trace_probe_log.argc; i++) {
0173         if (i == trace_probe_log.index)
0174             pos = len;
0175         len += strlen(trace_probe_log.argv[i]) + 1;
0176     }
0177     command = kzalloc(len, GFP_KERNEL);
0178     if (!command)
0179         return;
0180 
0181     if (trace_probe_log.index >= trace_probe_log.argc) {
0182         /**
0183          * Set the error position is next to the last arg + space.
0184          * Note that len includes the terminal null and the cursor
0185          * appears at pos + 1.
0186          */
0187         pos = len;
0188         offset = 0;
0189     }
0190 
0191     /* And make a command string from argv array */
0192     p = command;
0193     for (i = 0; i < trace_probe_log.argc; i++) {
0194         len = strlen(trace_probe_log.argv[i]);
0195         strcpy(p, trace_probe_log.argv[i]);
0196         p[len] = ' ';
0197         p += len + 1;
0198     }
0199     *(p - 1) = '\0';
0200 
0201     tracing_log_err(NULL, trace_probe_log.subsystem, command,
0202             trace_probe_err_text, err_type, pos + offset);
0203 
0204     kfree(command);
0205 }
0206 
0207 /* Split symbol and offset. */
0208 int traceprobe_split_symbol_offset(char *symbol, long *offset)
0209 {
0210     char *tmp;
0211     int ret;
0212 
0213     if (!offset)
0214         return -EINVAL;
0215 
0216     tmp = strpbrk(symbol, "+-");
0217     if (tmp) {
0218         ret = kstrtol(tmp, 0, offset);
0219         if (ret)
0220             return ret;
0221         *tmp = '\0';
0222     } else
0223         *offset = 0;
0224 
0225     return 0;
0226 }
0227 
0228 /* @buf must has MAX_EVENT_NAME_LEN size */
0229 int traceprobe_parse_event_name(const char **pevent, const char **pgroup,
0230                 char *buf, int offset)
0231 {
0232     const char *slash, *event = *pevent;
0233     int len;
0234 
0235     slash = strchr(event, '/');
0236     if (!slash)
0237         slash = strchr(event, '.');
0238 
0239     if (slash) {
0240         if (slash == event) {
0241             trace_probe_log_err(offset, NO_GROUP_NAME);
0242             return -EINVAL;
0243         }
0244         if (slash - event + 1 > MAX_EVENT_NAME_LEN) {
0245             trace_probe_log_err(offset, GROUP_TOO_LONG);
0246             return -EINVAL;
0247         }
0248         strlcpy(buf, event, slash - event + 1);
0249         if (!is_good_name(buf)) {
0250             trace_probe_log_err(offset, BAD_GROUP_NAME);
0251             return -EINVAL;
0252         }
0253         *pgroup = buf;
0254         *pevent = slash + 1;
0255         offset += slash - event + 1;
0256         event = *pevent;
0257     }
0258     len = strlen(event);
0259     if (len == 0) {
0260         if (slash) {
0261             *pevent = NULL;
0262             return 0;
0263         }
0264         trace_probe_log_err(offset, NO_EVENT_NAME);
0265         return -EINVAL;
0266     } else if (len > MAX_EVENT_NAME_LEN) {
0267         trace_probe_log_err(offset, EVENT_TOO_LONG);
0268         return -EINVAL;
0269     }
0270     if (!is_good_name(event)) {
0271         trace_probe_log_err(offset, BAD_EVENT_NAME);
0272         return -EINVAL;
0273     }
0274     return 0;
0275 }
0276 
0277 #define PARAM_MAX_STACK (THREAD_SIZE / sizeof(unsigned long))
0278 
0279 static int parse_probe_vars(char *arg, const struct fetch_type *t,
0280             struct fetch_insn *code, unsigned int flags, int offs)
0281 {
0282     unsigned long param;
0283     int ret = 0;
0284     int len;
0285 
0286     if (flags & TPARG_FL_TPOINT) {
0287         if (code->data)
0288             return -EFAULT;
0289         code->data = kstrdup(arg, GFP_KERNEL);
0290         if (!code->data)
0291             return -ENOMEM;
0292         code->op = FETCH_OP_TP_ARG;
0293     } else if (strcmp(arg, "retval") == 0) {
0294         if (flags & TPARG_FL_RETURN) {
0295             code->op = FETCH_OP_RETVAL;
0296         } else {
0297             trace_probe_log_err(offs, RETVAL_ON_PROBE);
0298             ret = -EINVAL;
0299         }
0300     } else if ((len = str_has_prefix(arg, "stack"))) {
0301         if (arg[len] == '\0') {
0302             code->op = FETCH_OP_STACKP;
0303         } else if (isdigit(arg[len])) {
0304             ret = kstrtoul(arg + len, 10, &param);
0305             if (ret) {
0306                 goto inval_var;
0307             } else if ((flags & TPARG_FL_KERNEL) &&
0308                     param > PARAM_MAX_STACK) {
0309                 trace_probe_log_err(offs, BAD_STACK_NUM);
0310                 ret = -EINVAL;
0311             } else {
0312                 code->op = FETCH_OP_STACK;
0313                 code->param = (unsigned int)param;
0314             }
0315         } else
0316             goto inval_var;
0317     } else if (strcmp(arg, "comm") == 0 || strcmp(arg, "COMM") == 0) {
0318         code->op = FETCH_OP_COMM;
0319 #ifdef CONFIG_HAVE_FUNCTION_ARG_ACCESS_API
0320     } else if (((flags & TPARG_FL_MASK) ==
0321             (TPARG_FL_KERNEL | TPARG_FL_FENTRY)) &&
0322            (len = str_has_prefix(arg, "arg"))) {
0323         ret = kstrtoul(arg + len, 10, &param);
0324         if (ret) {
0325             goto inval_var;
0326         } else if (!param || param > PARAM_MAX_STACK) {
0327             trace_probe_log_err(offs, BAD_ARG_NUM);
0328             return -EINVAL;
0329         }
0330         code->op = FETCH_OP_ARG;
0331         code->param = (unsigned int)param - 1;
0332 #endif
0333     } else
0334         goto inval_var;
0335 
0336     return ret;
0337 
0338 inval_var:
0339     trace_probe_log_err(offs, BAD_VAR);
0340     return -EINVAL;
0341 }
0342 
0343 static int str_to_immediate(char *str, unsigned long *imm)
0344 {
0345     if (isdigit(str[0]))
0346         return kstrtoul(str, 0, imm);
0347     else if (str[0] == '-')
0348         return kstrtol(str, 0, (long *)imm);
0349     else if (str[0] == '+')
0350         return kstrtol(str + 1, 0, (long *)imm);
0351     return -EINVAL;
0352 }
0353 
0354 static int __parse_imm_string(char *str, char **pbuf, int offs)
0355 {
0356     size_t len = strlen(str);
0357 
0358     if (str[len - 1] != '"') {
0359         trace_probe_log_err(offs + len, IMMSTR_NO_CLOSE);
0360         return -EINVAL;
0361     }
0362     *pbuf = kstrndup(str, len - 1, GFP_KERNEL);
0363     if (!*pbuf)
0364         return -ENOMEM;
0365     return 0;
0366 }
0367 
0368 /* Recursive argument parser */
0369 static int
0370 parse_probe_arg(char *arg, const struct fetch_type *type,
0371         struct fetch_insn **pcode, struct fetch_insn *end,
0372         unsigned int flags, int offs)
0373 {
0374     struct fetch_insn *code = *pcode;
0375     unsigned long param;
0376     int deref = FETCH_OP_DEREF;
0377     long offset = 0;
0378     char *tmp;
0379     int ret = 0;
0380 
0381     switch (arg[0]) {
0382     case '$':
0383         ret = parse_probe_vars(arg + 1, type, code, flags, offs);
0384         break;
0385 
0386     case '%':   /* named register */
0387         if (flags & TPARG_FL_TPOINT) {
0388             /* eprobes do not handle registers */
0389             trace_probe_log_err(offs, BAD_VAR);
0390             break;
0391         }
0392         ret = regs_query_register_offset(arg + 1);
0393         if (ret >= 0) {
0394             code->op = FETCH_OP_REG;
0395             code->param = (unsigned int)ret;
0396             ret = 0;
0397         } else
0398             trace_probe_log_err(offs, BAD_REG_NAME);
0399         break;
0400 
0401     case '@':   /* memory, file-offset or symbol */
0402         if (isdigit(arg[1])) {
0403             ret = kstrtoul(arg + 1, 0, &param);
0404             if (ret) {
0405                 trace_probe_log_err(offs, BAD_MEM_ADDR);
0406                 break;
0407             }
0408             /* load address */
0409             code->op = FETCH_OP_IMM;
0410             code->immediate = param;
0411         } else if (arg[1] == '+') {
0412             /* kprobes don't support file offsets */
0413             if (flags & TPARG_FL_KERNEL) {
0414                 trace_probe_log_err(offs, FILE_ON_KPROBE);
0415                 return -EINVAL;
0416             }
0417             ret = kstrtol(arg + 2, 0, &offset);
0418             if (ret) {
0419                 trace_probe_log_err(offs, BAD_FILE_OFFS);
0420                 break;
0421             }
0422 
0423             code->op = FETCH_OP_FOFFS;
0424             code->immediate = (unsigned long)offset;  // imm64?
0425         } else {
0426             /* uprobes don't support symbols */
0427             if (!(flags & TPARG_FL_KERNEL)) {
0428                 trace_probe_log_err(offs, SYM_ON_UPROBE);
0429                 return -EINVAL;
0430             }
0431             /* Preserve symbol for updating */
0432             code->op = FETCH_NOP_SYMBOL;
0433             code->data = kstrdup(arg + 1, GFP_KERNEL);
0434             if (!code->data)
0435                 return -ENOMEM;
0436             if (++code == end) {
0437                 trace_probe_log_err(offs, TOO_MANY_OPS);
0438                 return -EINVAL;
0439             }
0440             code->op = FETCH_OP_IMM;
0441             code->immediate = 0;
0442         }
0443         /* These are fetching from memory */
0444         if (++code == end) {
0445             trace_probe_log_err(offs, TOO_MANY_OPS);
0446             return -EINVAL;
0447         }
0448         *pcode = code;
0449         code->op = FETCH_OP_DEREF;
0450         code->offset = offset;
0451         break;
0452 
0453     case '+':   /* deref memory */
0454     case '-':
0455         if (arg[1] == 'u') {
0456             deref = FETCH_OP_UDEREF;
0457             arg[1] = arg[0];
0458             arg++;
0459         }
0460         if (arg[0] == '+')
0461             arg++;  /* Skip '+', because kstrtol() rejects it. */
0462         tmp = strchr(arg, '(');
0463         if (!tmp) {
0464             trace_probe_log_err(offs, DEREF_NEED_BRACE);
0465             return -EINVAL;
0466         }
0467         *tmp = '\0';
0468         ret = kstrtol(arg, 0, &offset);
0469         if (ret) {
0470             trace_probe_log_err(offs, BAD_DEREF_OFFS);
0471             break;
0472         }
0473         offs += (tmp + 1 - arg) + (arg[0] != '-' ? 1 : 0);
0474         arg = tmp + 1;
0475         tmp = strrchr(arg, ')');
0476         if (!tmp) {
0477             trace_probe_log_err(offs + strlen(arg),
0478                         DEREF_OPEN_BRACE);
0479             return -EINVAL;
0480         } else {
0481             const struct fetch_type *t2 = find_fetch_type(NULL);
0482 
0483             *tmp = '\0';
0484             ret = parse_probe_arg(arg, t2, &code, end, flags, offs);
0485             if (ret)
0486                 break;
0487             if (code->op == FETCH_OP_COMM ||
0488                 code->op == FETCH_OP_DATA) {
0489                 trace_probe_log_err(offs, COMM_CANT_DEREF);
0490                 return -EINVAL;
0491             }
0492             if (++code == end) {
0493                 trace_probe_log_err(offs, TOO_MANY_OPS);
0494                 return -EINVAL;
0495             }
0496             *pcode = code;
0497 
0498             code->op = deref;
0499             code->offset = offset;
0500         }
0501         break;
0502     case '\\':  /* Immediate value */
0503         if (arg[1] == '"') {    /* Immediate string */
0504             ret = __parse_imm_string(arg + 2, &tmp, offs + 2);
0505             if (ret)
0506                 break;
0507             code->op = FETCH_OP_DATA;
0508             code->data = tmp;
0509         } else {
0510             ret = str_to_immediate(arg + 1, &code->immediate);
0511             if (ret)
0512                 trace_probe_log_err(offs + 1, BAD_IMM);
0513             else
0514                 code->op = FETCH_OP_IMM;
0515         }
0516         break;
0517     }
0518     if (!ret && code->op == FETCH_OP_NOP) {
0519         /* Parsed, but do not find fetch method */
0520         trace_probe_log_err(offs, BAD_FETCH_ARG);
0521         ret = -EINVAL;
0522     }
0523     return ret;
0524 }
0525 
0526 #define BYTES_TO_BITS(nb)   ((BITS_PER_LONG * (nb)) / sizeof(long))
0527 
0528 /* Bitfield type needs to be parsed into a fetch function */
0529 static int __parse_bitfield_probe_arg(const char *bf,
0530                       const struct fetch_type *t,
0531                       struct fetch_insn **pcode)
0532 {
0533     struct fetch_insn *code = *pcode;
0534     unsigned long bw, bo;
0535     char *tail;
0536 
0537     if (*bf != 'b')
0538         return 0;
0539 
0540     bw = simple_strtoul(bf + 1, &tail, 0);  /* Use simple one */
0541 
0542     if (bw == 0 || *tail != '@')
0543         return -EINVAL;
0544 
0545     bf = tail + 1;
0546     bo = simple_strtoul(bf, &tail, 0);
0547 
0548     if (tail == bf || *tail != '/')
0549         return -EINVAL;
0550     code++;
0551     if (code->op != FETCH_OP_NOP)
0552         return -EINVAL;
0553     *pcode = code;
0554 
0555     code->op = FETCH_OP_MOD_BF;
0556     code->lshift = BYTES_TO_BITS(t->size) - (bw + bo);
0557     code->rshift = BYTES_TO_BITS(t->size) - bw;
0558     code->basesize = t->size;
0559 
0560     return (BYTES_TO_BITS(t->size) < (bw + bo)) ? -EINVAL : 0;
0561 }
0562 
0563 /* String length checking wrapper */
0564 static int traceprobe_parse_probe_arg_body(const char *argv, ssize_t *size,
0565         struct probe_arg *parg, unsigned int flags, int offset)
0566 {
0567     struct fetch_insn *code, *scode, *tmp = NULL;
0568     char *t, *t2, *t3;
0569     char *arg;
0570     int ret, len;
0571 
0572     arg = kstrdup(argv, GFP_KERNEL);
0573     if (!arg)
0574         return -ENOMEM;
0575 
0576     ret = -EINVAL;
0577     len = strlen(arg);
0578     if (len > MAX_ARGSTR_LEN) {
0579         trace_probe_log_err(offset, ARG_TOO_LONG);
0580         goto out;
0581     } else if (len == 0) {
0582         trace_probe_log_err(offset, NO_ARG_BODY);
0583         goto out;
0584     }
0585 
0586     ret = -ENOMEM;
0587     parg->comm = kstrdup(arg, GFP_KERNEL);
0588     if (!parg->comm)
0589         goto out;
0590 
0591     ret = -EINVAL;
0592     t = strchr(arg, ':');
0593     if (t) {
0594         *t = '\0';
0595         t2 = strchr(++t, '[');
0596         if (t2) {
0597             *t2++ = '\0';
0598             t3 = strchr(t2, ']');
0599             if (!t3) {
0600                 offset += t2 + strlen(t2) - arg;
0601                 trace_probe_log_err(offset,
0602                             ARRAY_NO_CLOSE);
0603                 goto out;
0604             } else if (t3[1] != '\0') {
0605                 trace_probe_log_err(offset + t3 + 1 - arg,
0606                             BAD_ARRAY_SUFFIX);
0607                 goto out;
0608             }
0609             *t3 = '\0';
0610             if (kstrtouint(t2, 0, &parg->count) || !parg->count) {
0611                 trace_probe_log_err(offset + t2 - arg,
0612                             BAD_ARRAY_NUM);
0613                 goto out;
0614             }
0615             if (parg->count > MAX_ARRAY_LEN) {
0616                 trace_probe_log_err(offset + t2 - arg,
0617                             ARRAY_TOO_BIG);
0618                 goto out;
0619             }
0620         }
0621     }
0622 
0623     /*
0624      * Since $comm and immediate string can not be dereferenced,
0625      * we can find those by strcmp. But ignore for eprobes.
0626      */
0627     if (!(flags & TPARG_FL_TPOINT) &&
0628         (strcmp(arg, "$comm") == 0 || strcmp(arg, "$COMM") == 0 ||
0629          strncmp(arg, "\\\"", 2) == 0)) {
0630         /* The type of $comm must be "string", and not an array. */
0631         if (parg->count || (t && strcmp(t, "string")))
0632             goto out;
0633         parg->type = find_fetch_type("string");
0634     } else
0635         parg->type = find_fetch_type(t);
0636     if (!parg->type) {
0637         trace_probe_log_err(offset + (t ? (t - arg) : 0), BAD_TYPE);
0638         goto out;
0639     }
0640     parg->offset = *size;
0641     *size += parg->type->size * (parg->count ?: 1);
0642 
0643     ret = -ENOMEM;
0644     if (parg->count) {
0645         len = strlen(parg->type->fmttype) + 6;
0646         parg->fmt = kmalloc(len, GFP_KERNEL);
0647         if (!parg->fmt)
0648             goto out;
0649         snprintf(parg->fmt, len, "%s[%d]", parg->type->fmttype,
0650              parg->count);
0651     }
0652 
0653     code = tmp = kcalloc(FETCH_INSN_MAX, sizeof(*code), GFP_KERNEL);
0654     if (!code)
0655         goto out;
0656     code[FETCH_INSN_MAX - 1].op = FETCH_OP_END;
0657 
0658     ret = parse_probe_arg(arg, parg->type, &code, &code[FETCH_INSN_MAX - 1],
0659                   flags, offset);
0660     if (ret)
0661         goto fail;
0662 
0663     ret = -EINVAL;
0664     /* Store operation */
0665     if (!strcmp(parg->type->name, "string") ||
0666         !strcmp(parg->type->name, "ustring")) {
0667         if (code->op != FETCH_OP_DEREF && code->op != FETCH_OP_UDEREF &&
0668             code->op != FETCH_OP_IMM && code->op != FETCH_OP_COMM &&
0669             code->op != FETCH_OP_DATA && code->op != FETCH_OP_TP_ARG) {
0670             trace_probe_log_err(offset + (t ? (t - arg) : 0),
0671                         BAD_STRING);
0672             goto fail;
0673         }
0674         if ((code->op == FETCH_OP_IMM || code->op == FETCH_OP_COMM ||
0675              code->op == FETCH_OP_DATA) || code->op == FETCH_OP_TP_ARG ||
0676              parg->count) {
0677             /*
0678              * IMM, DATA and COMM is pointing actual address, those
0679              * must be kept, and if parg->count != 0, this is an
0680              * array of string pointers instead of string address
0681              * itself.
0682              */
0683             code++;
0684             if (code->op != FETCH_OP_NOP) {
0685                 trace_probe_log_err(offset, TOO_MANY_OPS);
0686                 goto fail;
0687             }
0688         }
0689         /* If op == DEREF, replace it with STRING */
0690         if (!strcmp(parg->type->name, "ustring") ||
0691             code->op == FETCH_OP_UDEREF)
0692             code->op = FETCH_OP_ST_USTRING;
0693         else
0694             code->op = FETCH_OP_ST_STRING;
0695         code->size = parg->type->size;
0696         parg->dynamic = true;
0697     } else if (code->op == FETCH_OP_DEREF) {
0698         code->op = FETCH_OP_ST_MEM;
0699         code->size = parg->type->size;
0700     } else if (code->op == FETCH_OP_UDEREF) {
0701         code->op = FETCH_OP_ST_UMEM;
0702         code->size = parg->type->size;
0703     } else {
0704         code++;
0705         if (code->op != FETCH_OP_NOP) {
0706             trace_probe_log_err(offset, TOO_MANY_OPS);
0707             goto fail;
0708         }
0709         code->op = FETCH_OP_ST_RAW;
0710         code->size = parg->type->size;
0711     }
0712     scode = code;
0713     /* Modify operation */
0714     if (t != NULL) {
0715         ret = __parse_bitfield_probe_arg(t, parg->type, &code);
0716         if (ret) {
0717             trace_probe_log_err(offset + t - arg, BAD_BITFIELD);
0718             goto fail;
0719         }
0720     }
0721     ret = -EINVAL;
0722     /* Loop(Array) operation */
0723     if (parg->count) {
0724         if (scode->op != FETCH_OP_ST_MEM &&
0725             scode->op != FETCH_OP_ST_STRING &&
0726             scode->op != FETCH_OP_ST_USTRING) {
0727             trace_probe_log_err(offset + (t ? (t - arg) : 0),
0728                         BAD_STRING);
0729             goto fail;
0730         }
0731         code++;
0732         if (code->op != FETCH_OP_NOP) {
0733             trace_probe_log_err(offset, TOO_MANY_OPS);
0734             goto fail;
0735         }
0736         code->op = FETCH_OP_LP_ARRAY;
0737         code->param = parg->count;
0738     }
0739     code++;
0740     code->op = FETCH_OP_END;
0741 
0742     ret = 0;
0743     /* Shrink down the code buffer */
0744     parg->code = kcalloc(code - tmp + 1, sizeof(*code), GFP_KERNEL);
0745     if (!parg->code)
0746         ret = -ENOMEM;
0747     else
0748         memcpy(parg->code, tmp, sizeof(*code) * (code - tmp + 1));
0749 
0750 fail:
0751     if (ret) {
0752         for (code = tmp; code < tmp + FETCH_INSN_MAX; code++)
0753             if (code->op == FETCH_NOP_SYMBOL ||
0754                 code->op == FETCH_OP_DATA)
0755                 kfree(code->data);
0756     }
0757     kfree(tmp);
0758 out:
0759     kfree(arg);
0760 
0761     return ret;
0762 }
0763 
0764 /* Return 1 if name is reserved or already used by another argument */
0765 static int traceprobe_conflict_field_name(const char *name,
0766                       struct probe_arg *args, int narg)
0767 {
0768     int i;
0769 
0770     for (i = 0; i < ARRAY_SIZE(reserved_field_names); i++)
0771         if (strcmp(reserved_field_names[i], name) == 0)
0772             return 1;
0773 
0774     for (i = 0; i < narg; i++)
0775         if (strcmp(args[i].name, name) == 0)
0776             return 1;
0777 
0778     return 0;
0779 }
0780 
0781 int traceprobe_parse_probe_arg(struct trace_probe *tp, int i, const char *arg,
0782                 unsigned int flags)
0783 {
0784     struct probe_arg *parg = &tp->args[i];
0785     const char *body;
0786 
0787     /* Increment count for freeing args in error case */
0788     tp->nr_args++;
0789 
0790     body = strchr(arg, '=');
0791     if (body) {
0792         if (body - arg > MAX_ARG_NAME_LEN) {
0793             trace_probe_log_err(0, ARG_NAME_TOO_LONG);
0794             return -EINVAL;
0795         } else if (body == arg) {
0796             trace_probe_log_err(0, NO_ARG_NAME);
0797             return -EINVAL;
0798         }
0799         parg->name = kmemdup_nul(arg, body - arg, GFP_KERNEL);
0800         body++;
0801     } else {
0802         /* If argument name is omitted, set "argN" */
0803         parg->name = kasprintf(GFP_KERNEL, "arg%d", i + 1);
0804         body = arg;
0805     }
0806     if (!parg->name)
0807         return -ENOMEM;
0808 
0809     if (!is_good_name(parg->name)) {
0810         trace_probe_log_err(0, BAD_ARG_NAME);
0811         return -EINVAL;
0812     }
0813     if (traceprobe_conflict_field_name(parg->name, tp->args, i)) {
0814         trace_probe_log_err(0, USED_ARG_NAME);
0815         return -EINVAL;
0816     }
0817     /* Parse fetch argument */
0818     return traceprobe_parse_probe_arg_body(body, &tp->size, parg, flags,
0819                            body - arg);
0820 }
0821 
0822 void traceprobe_free_probe_arg(struct probe_arg *arg)
0823 {
0824     struct fetch_insn *code = arg->code;
0825 
0826     while (code && code->op != FETCH_OP_END) {
0827         if (code->op == FETCH_NOP_SYMBOL ||
0828             code->op == FETCH_OP_DATA)
0829             kfree(code->data);
0830         code++;
0831     }
0832     kfree(arg->code);
0833     kfree(arg->name);
0834     kfree(arg->comm);
0835     kfree(arg->fmt);
0836 }
0837 
0838 int traceprobe_update_arg(struct probe_arg *arg)
0839 {
0840     struct fetch_insn *code = arg->code;
0841     long offset;
0842     char *tmp;
0843     char c;
0844     int ret = 0;
0845 
0846     while (code && code->op != FETCH_OP_END) {
0847         if (code->op == FETCH_NOP_SYMBOL) {
0848             if (code[1].op != FETCH_OP_IMM)
0849                 return -EINVAL;
0850 
0851             tmp = strpbrk(code->data, "+-");
0852             if (tmp)
0853                 c = *tmp;
0854             ret = traceprobe_split_symbol_offset(code->data,
0855                                  &offset);
0856             if (ret)
0857                 return ret;
0858 
0859             code[1].immediate =
0860                 (unsigned long)kallsyms_lookup_name(code->data);
0861             if (tmp)
0862                 *tmp = c;
0863             if (!code[1].immediate)
0864                 return -ENOENT;
0865             code[1].immediate += offset;
0866         }
0867         code++;
0868     }
0869     return 0;
0870 }
0871 
0872 /* When len=0, we just calculate the needed length */
0873 #define LEN_OR_ZERO (len ? len - pos : 0)
0874 static int __set_print_fmt(struct trace_probe *tp, char *buf, int len,
0875                enum probe_print_type ptype)
0876 {
0877     struct probe_arg *parg;
0878     int i, j;
0879     int pos = 0;
0880     const char *fmt, *arg;
0881 
0882     switch (ptype) {
0883     case PROBE_PRINT_NORMAL:
0884         fmt = "(%lx)";
0885         arg = ", REC->" FIELD_STRING_IP;
0886         break;
0887     case PROBE_PRINT_RETURN:
0888         fmt = "(%lx <- %lx)";
0889         arg = ", REC->" FIELD_STRING_FUNC ", REC->" FIELD_STRING_RETIP;
0890         break;
0891     case PROBE_PRINT_EVENT:
0892         fmt = "";
0893         arg = "";
0894         break;
0895     default:
0896         WARN_ON_ONCE(1);
0897         return 0;
0898     }
0899 
0900     pos += snprintf(buf + pos, LEN_OR_ZERO, "\"%s", fmt);
0901 
0902     for (i = 0; i < tp->nr_args; i++) {
0903         parg = tp->args + i;
0904         pos += snprintf(buf + pos, LEN_OR_ZERO, " %s=", parg->name);
0905         if (parg->count) {
0906             pos += snprintf(buf + pos, LEN_OR_ZERO, "{%s",
0907                     parg->type->fmt);
0908             for (j = 1; j < parg->count; j++)
0909                 pos += snprintf(buf + pos, LEN_OR_ZERO, ",%s",
0910                         parg->type->fmt);
0911             pos += snprintf(buf + pos, LEN_OR_ZERO, "}");
0912         } else
0913             pos += snprintf(buf + pos, LEN_OR_ZERO, "%s",
0914                     parg->type->fmt);
0915     }
0916 
0917     pos += snprintf(buf + pos, LEN_OR_ZERO, "\"%s", arg);
0918 
0919     for (i = 0; i < tp->nr_args; i++) {
0920         parg = tp->args + i;
0921         if (parg->count) {
0922             if ((strcmp(parg->type->name, "string") == 0) ||
0923                 (strcmp(parg->type->name, "ustring") == 0))
0924                 fmt = ", __get_str(%s[%d])";
0925             else
0926                 fmt = ", REC->%s[%d]";
0927             for (j = 0; j < parg->count; j++)
0928                 pos += snprintf(buf + pos, LEN_OR_ZERO,
0929                         fmt, parg->name, j);
0930         } else {
0931             if ((strcmp(parg->type->name, "string") == 0) ||
0932                 (strcmp(parg->type->name, "ustring") == 0))
0933                 fmt = ", __get_str(%s)";
0934             else
0935                 fmt = ", REC->%s";
0936             pos += snprintf(buf + pos, LEN_OR_ZERO,
0937                     fmt, parg->name);
0938         }
0939     }
0940 
0941     /* return the length of print_fmt */
0942     return pos;
0943 }
0944 #undef LEN_OR_ZERO
0945 
0946 int traceprobe_set_print_fmt(struct trace_probe *tp, enum probe_print_type ptype)
0947 {
0948     struct trace_event_call *call = trace_probe_event_call(tp);
0949     int len;
0950     char *print_fmt;
0951 
0952     /* First: called with 0 length to calculate the needed length */
0953     len = __set_print_fmt(tp, NULL, 0, ptype);
0954     print_fmt = kmalloc(len + 1, GFP_KERNEL);
0955     if (!print_fmt)
0956         return -ENOMEM;
0957 
0958     /* Second: actually write the @print_fmt */
0959     __set_print_fmt(tp, print_fmt, len + 1, ptype);
0960     call->print_fmt = print_fmt;
0961 
0962     return 0;
0963 }
0964 
0965 int traceprobe_define_arg_fields(struct trace_event_call *event_call,
0966                  size_t offset, struct trace_probe *tp)
0967 {
0968     int ret, i;
0969 
0970     /* Set argument names as fields */
0971     for (i = 0; i < tp->nr_args; i++) {
0972         struct probe_arg *parg = &tp->args[i];
0973         const char *fmt = parg->type->fmttype;
0974         int size = parg->type->size;
0975 
0976         if (parg->fmt)
0977             fmt = parg->fmt;
0978         if (parg->count)
0979             size *= parg->count;
0980         ret = trace_define_field(event_call, fmt, parg->name,
0981                      offset + parg->offset, size,
0982                      parg->type->is_signed,
0983                      FILTER_OTHER);
0984         if (ret)
0985             return ret;
0986     }
0987     return 0;
0988 }
0989 
0990 static void trace_probe_event_free(struct trace_probe_event *tpe)
0991 {
0992     kfree(tpe->class.system);
0993     kfree(tpe->call.name);
0994     kfree(tpe->call.print_fmt);
0995     kfree(tpe);
0996 }
0997 
0998 int trace_probe_append(struct trace_probe *tp, struct trace_probe *to)
0999 {
1000     if (trace_probe_has_sibling(tp))
1001         return -EBUSY;
1002 
1003     list_del_init(&tp->list);
1004     trace_probe_event_free(tp->event);
1005 
1006     tp->event = to->event;
1007     list_add_tail(&tp->list, trace_probe_probe_list(to));
1008 
1009     return 0;
1010 }
1011 
1012 void trace_probe_unlink(struct trace_probe *tp)
1013 {
1014     list_del_init(&tp->list);
1015     if (list_empty(trace_probe_probe_list(tp)))
1016         trace_probe_event_free(tp->event);
1017     tp->event = NULL;
1018 }
1019 
1020 void trace_probe_cleanup(struct trace_probe *tp)
1021 {
1022     int i;
1023 
1024     for (i = 0; i < tp->nr_args; i++)
1025         traceprobe_free_probe_arg(&tp->args[i]);
1026 
1027     if (tp->event)
1028         trace_probe_unlink(tp);
1029 }
1030 
1031 int trace_probe_init(struct trace_probe *tp, const char *event,
1032              const char *group, bool alloc_filter)
1033 {
1034     struct trace_event_call *call;
1035     size_t size = sizeof(struct trace_probe_event);
1036     int ret = 0;
1037 
1038     if (!event || !group)
1039         return -EINVAL;
1040 
1041     if (alloc_filter)
1042         size += sizeof(struct trace_uprobe_filter);
1043 
1044     tp->event = kzalloc(size, GFP_KERNEL);
1045     if (!tp->event)
1046         return -ENOMEM;
1047 
1048     INIT_LIST_HEAD(&tp->event->files);
1049     INIT_LIST_HEAD(&tp->event->class.fields);
1050     INIT_LIST_HEAD(&tp->event->probes);
1051     INIT_LIST_HEAD(&tp->list);
1052     list_add(&tp->list, &tp->event->probes);
1053 
1054     call = trace_probe_event_call(tp);
1055     call->class = &tp->event->class;
1056     call->name = kstrdup(event, GFP_KERNEL);
1057     if (!call->name) {
1058         ret = -ENOMEM;
1059         goto error;
1060     }
1061 
1062     tp->event->class.system = kstrdup(group, GFP_KERNEL);
1063     if (!tp->event->class.system) {
1064         ret = -ENOMEM;
1065         goto error;
1066     }
1067 
1068     return 0;
1069 
1070 error:
1071     trace_probe_cleanup(tp);
1072     return ret;
1073 }
1074 
1075 static struct trace_event_call *
1076 find_trace_event_call(const char *system, const char *event_name)
1077 {
1078     struct trace_event_call *tp_event;
1079     const char *name;
1080 
1081     list_for_each_entry(tp_event, &ftrace_events, list) {
1082         if (!tp_event->class->system ||
1083             strcmp(system, tp_event->class->system))
1084             continue;
1085         name = trace_event_name(tp_event);
1086         if (!name || strcmp(event_name, name))
1087             continue;
1088         return tp_event;
1089     }
1090 
1091     return NULL;
1092 }
1093 
1094 int trace_probe_register_event_call(struct trace_probe *tp)
1095 {
1096     struct trace_event_call *call = trace_probe_event_call(tp);
1097     int ret;
1098 
1099     lockdep_assert_held(&event_mutex);
1100 
1101     if (find_trace_event_call(trace_probe_group_name(tp),
1102                   trace_probe_name(tp)))
1103         return -EEXIST;
1104 
1105     ret = register_trace_event(&call->event);
1106     if (!ret)
1107         return -ENODEV;
1108 
1109     ret = trace_add_event_call(call);
1110     if (ret)
1111         unregister_trace_event(&call->event);
1112 
1113     return ret;
1114 }
1115 
1116 int trace_probe_add_file(struct trace_probe *tp, struct trace_event_file *file)
1117 {
1118     struct event_file_link *link;
1119 
1120     link = kmalloc(sizeof(*link), GFP_KERNEL);
1121     if (!link)
1122         return -ENOMEM;
1123 
1124     link->file = file;
1125     INIT_LIST_HEAD(&link->list);
1126     list_add_tail_rcu(&link->list, &tp->event->files);
1127     trace_probe_set_flag(tp, TP_FLAG_TRACE);
1128     return 0;
1129 }
1130 
1131 struct event_file_link *trace_probe_get_file_link(struct trace_probe *tp,
1132                           struct trace_event_file *file)
1133 {
1134     struct event_file_link *link;
1135 
1136     trace_probe_for_each_link(link, tp) {
1137         if (link->file == file)
1138             return link;
1139     }
1140 
1141     return NULL;
1142 }
1143 
1144 int trace_probe_remove_file(struct trace_probe *tp,
1145                 struct trace_event_file *file)
1146 {
1147     struct event_file_link *link;
1148 
1149     link = trace_probe_get_file_link(tp, file);
1150     if (!link)
1151         return -ENOENT;
1152 
1153     list_del_rcu(&link->list);
1154     kvfree_rcu(link);
1155 
1156     if (list_empty(&tp->event->files))
1157         trace_probe_clear_flag(tp, TP_FLAG_TRACE);
1158 
1159     return 0;
1160 }
1161 
1162 /*
1163  * Return the smallest index of different type argument (start from 1).
1164  * If all argument types and name are same, return 0.
1165  */
1166 int trace_probe_compare_arg_type(struct trace_probe *a, struct trace_probe *b)
1167 {
1168     int i;
1169 
1170     /* In case of more arguments */
1171     if (a->nr_args < b->nr_args)
1172         return a->nr_args + 1;
1173     if (a->nr_args > b->nr_args)
1174         return b->nr_args + 1;
1175 
1176     for (i = 0; i < a->nr_args; i++) {
1177         if ((b->nr_args <= i) ||
1178             ((a->args[i].type != b->args[i].type) ||
1179              (a->args[i].count != b->args[i].count) ||
1180              strcmp(a->args[i].name, b->args[i].name)))
1181             return i + 1;
1182     }
1183 
1184     return 0;
1185 }
1186 
1187 bool trace_probe_match_command_args(struct trace_probe *tp,
1188                     int argc, const char **argv)
1189 {
1190     char buf[MAX_ARGSTR_LEN + 1];
1191     int i;
1192 
1193     if (tp->nr_args < argc)
1194         return false;
1195 
1196     for (i = 0; i < argc; i++) {
1197         snprintf(buf, sizeof(buf), "%s=%s",
1198              tp->args[i].name, tp->args[i].comm);
1199         if (strcmp(buf, argv[i]))
1200             return false;
1201     }
1202     return true;
1203 }
1204 
1205 int trace_probe_create(const char *raw_command, int (*createfn)(int, const char **))
1206 {
1207     int argc = 0, ret = 0;
1208     char **argv;
1209 
1210     argv = argv_split(GFP_KERNEL, raw_command, &argc);
1211     if (!argv)
1212         return -ENOMEM;
1213 
1214     if (argc)
1215         ret = createfn(argc, (const char **)argv);
1216 
1217     argv_free(argv);
1218 
1219     return ret;
1220 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!