Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 1 | /* |
| 2 | * Common code for probe-based Dynamic events. |
| 3 | * |
| 4 | * This program is free software; you can redistribute it and/or modify |
| 5 | * it under the terms of the GNU General Public License version 2 as |
| 6 | * published by the Free Software Foundation. |
| 7 | * |
| 8 | * This program is distributed in the hope that it will be useful, |
| 9 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 11 | * GNU General Public License for more details. |
| 12 | * |
| 13 | * You should have received a copy of the GNU General Public License |
| 14 | * along with this program; if not, write to the Free Software |
| 15 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 16 | * |
| 17 | * This code was copied from kernel/trace/trace_kprobe.c written by |
| 18 | * Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com> |
| 19 | * |
| 20 | * Updates to make this generic: |
| 21 | * Copyright (C) IBM Corporation, 2010-2011 |
| 22 | * Author: Srikar Dronamraju |
| 23 | */ |
| 24 | |
| 25 | #include "trace_probe.h" |
| 26 | |
| 27 | const char *reserved_field_names[] = { |
| 28 | "common_type", |
| 29 | "common_flags", |
| 30 | "common_preempt_count", |
| 31 | "common_pid", |
| 32 | "common_tgid", |
| 33 | FIELD_STRING_IP, |
| 34 | FIELD_STRING_RETIP, |
| 35 | FIELD_STRING_FUNC, |
| 36 | }; |
| 37 | |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 38 | /* Printing in basic type function template */ |
Masami Hiramatsu | 17ce3dc | 2016-08-18 17:57:50 +0900 | [diff] [blame] | 39 | #define DEFINE_BASIC_PRINT_TYPE_FUNC(tname, type, fmt) \ |
| 40 | int PRINT_TYPE_FUNC_NAME(tname)(struct trace_seq *s, const char *name, \ |
Masami Hiramatsu | 3da0f18 | 2014-04-17 17:18:28 +0900 | [diff] [blame] | 41 | void *data, void *ent) \ |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 42 | { \ |
Steven Rostedt (Red Hat) | d2b0191 | 2014-11-12 17:19:51 -0500 | [diff] [blame] | 43 | trace_seq_printf(s, " %s=" fmt, name, *(type *)data); \ |
| 44 | return !trace_seq_has_overflowed(s); \ |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 45 | } \ |
Masami Hiramatsu | 17ce3dc | 2016-08-18 17:57:50 +0900 | [diff] [blame] | 46 | const char PRINT_TYPE_FMT_NAME(tname)[] = fmt; \ |
| 47 | NOKPROBE_SYMBOL(PRINT_TYPE_FUNC_NAME(tname)); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 48 | |
Masami Hiramatsu | bdca79c2 | 2016-08-18 17:59:21 +0900 | [diff] [blame] | 49 | DEFINE_BASIC_PRINT_TYPE_FUNC(u8, u8, "%u") |
| 50 | DEFINE_BASIC_PRINT_TYPE_FUNC(u16, u16, "%u") |
| 51 | DEFINE_BASIC_PRINT_TYPE_FUNC(u32, u32, "%u") |
| 52 | DEFINE_BASIC_PRINT_TYPE_FUNC(u64, u64, "%Lu") |
Masami Hiramatsu | 17ce3dc | 2016-08-18 17:57:50 +0900 | [diff] [blame] | 53 | DEFINE_BASIC_PRINT_TYPE_FUNC(s8, s8, "%d") |
| 54 | DEFINE_BASIC_PRINT_TYPE_FUNC(s16, s16, "%d") |
| 55 | DEFINE_BASIC_PRINT_TYPE_FUNC(s32, s32, "%d") |
| 56 | DEFINE_BASIC_PRINT_TYPE_FUNC(s64, s64, "%Ld") |
| 57 | DEFINE_BASIC_PRINT_TYPE_FUNC(x8, u8, "0x%x") |
| 58 | DEFINE_BASIC_PRINT_TYPE_FUNC(x16, u16, "0x%x") |
| 59 | DEFINE_BASIC_PRINT_TYPE_FUNC(x32, u32, "0x%x") |
| 60 | DEFINE_BASIC_PRINT_TYPE_FUNC(x64, u64, "0x%Lx") |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 61 | |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 62 | /* Print type function for string type */ |
Masami Hiramatsu | 3da0f18 | 2014-04-17 17:18:28 +0900 | [diff] [blame] | 63 | int PRINT_TYPE_FUNC_NAME(string)(struct trace_seq *s, const char *name, |
| 64 | void *data, void *ent) |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 65 | { |
| 66 | int len = *(u32 *)data >> 16; |
| 67 | |
| 68 | if (!len) |
Steven Rostedt (Red Hat) | d2b0191 | 2014-11-12 17:19:51 -0500 | [diff] [blame] | 69 | trace_seq_printf(s, " %s=(fault)", name); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 70 | else |
Steven Rostedt (Red Hat) | d2b0191 | 2014-11-12 17:19:51 -0500 | [diff] [blame] | 71 | trace_seq_printf(s, " %s=\"%s\"", name, |
| 72 | (const char *)get_loc_data(data, ent)); |
| 73 | return !trace_seq_has_overflowed(s); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 74 | } |
Masami Hiramatsu | 3da0f18 | 2014-04-17 17:18:28 +0900 | [diff] [blame] | 75 | NOKPROBE_SYMBOL(PRINT_TYPE_FUNC_NAME(string)); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 76 | |
Namhyung Kim | b26c74e | 2013-11-26 14:19:59 +0900 | [diff] [blame] | 77 | const char PRINT_TYPE_FMT_NAME(string)[] = "\\\"%s\\\""; |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 78 | |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 79 | #define CHECK_FETCH_FUNCS(method, fn) \ |
| 80 | (((FETCH_FUNC_NAME(method, u8) == fn) || \ |
| 81 | (FETCH_FUNC_NAME(method, u16) == fn) || \ |
| 82 | (FETCH_FUNC_NAME(method, u32) == fn) || \ |
| 83 | (FETCH_FUNC_NAME(method, u64) == fn) || \ |
| 84 | (FETCH_FUNC_NAME(method, string) == fn) || \ |
| 85 | (FETCH_FUNC_NAME(method, string_size) == fn)) \ |
| 86 | && (fn != NULL)) |
| 87 | |
| 88 | /* Data fetch function templates */ |
| 89 | #define DEFINE_FETCH_reg(type) \ |
Masami Hiramatsu | 3da0f18 | 2014-04-17 17:18:28 +0900 | [diff] [blame] | 90 | void FETCH_FUNC_NAME(reg, type)(struct pt_regs *regs, void *offset, void *dest) \ |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 91 | { \ |
| 92 | *(type *)dest = (type)regs_get_register(regs, \ |
| 93 | (unsigned int)((unsigned long)offset)); \ |
Masami Hiramatsu | 3da0f18 | 2014-04-17 17:18:28 +0900 | [diff] [blame] | 94 | } \ |
| 95 | NOKPROBE_SYMBOL(FETCH_FUNC_NAME(reg, type)); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 96 | DEFINE_BASIC_FETCH_FUNCS(reg) |
| 97 | /* No string on the register */ |
| 98 | #define fetch_reg_string NULL |
| 99 | #define fetch_reg_string_size NULL |
| 100 | |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 101 | #define DEFINE_FETCH_retval(type) \ |
Masami Hiramatsu | 3da0f18 | 2014-04-17 17:18:28 +0900 | [diff] [blame] | 102 | void FETCH_FUNC_NAME(retval, type)(struct pt_regs *regs, \ |
| 103 | void *dummy, void *dest) \ |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 104 | { \ |
| 105 | *(type *)dest = (type)regs_return_value(regs); \ |
Masami Hiramatsu | 3da0f18 | 2014-04-17 17:18:28 +0900 | [diff] [blame] | 106 | } \ |
| 107 | NOKPROBE_SYMBOL(FETCH_FUNC_NAME(retval, type)); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 108 | DEFINE_BASIC_FETCH_FUNCS(retval) |
| 109 | /* No string on the retval */ |
| 110 | #define fetch_retval_string NULL |
| 111 | #define fetch_retval_string_size NULL |
| 112 | |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 113 | /* Dereference memory access function */ |
| 114 | struct deref_fetch_param { |
| 115 | struct fetch_param orig; |
| 116 | long offset; |
Hyeoncheol Lee | 3925f4a | 2013-07-01 13:44:32 +0900 | [diff] [blame] | 117 | fetch_func_t fetch; |
| 118 | fetch_func_t fetch_size; |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 119 | }; |
| 120 | |
| 121 | #define DEFINE_FETCH_deref(type) \ |
Masami Hiramatsu | 3da0f18 | 2014-04-17 17:18:28 +0900 | [diff] [blame] | 122 | void FETCH_FUNC_NAME(deref, type)(struct pt_regs *regs, \ |
| 123 | void *data, void *dest) \ |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 124 | { \ |
| 125 | struct deref_fetch_param *dprm = data; \ |
| 126 | unsigned long addr; \ |
| 127 | call_fetch(&dprm->orig, regs, &addr); \ |
| 128 | if (addr) { \ |
| 129 | addr += dprm->offset; \ |
Hyeoncheol Lee | 3925f4a | 2013-07-01 13:44:32 +0900 | [diff] [blame] | 130 | dprm->fetch(regs, (void *)addr, dest); \ |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 131 | } else \ |
| 132 | *(type *)dest = 0; \ |
Masami Hiramatsu | 3da0f18 | 2014-04-17 17:18:28 +0900 | [diff] [blame] | 133 | } \ |
| 134 | NOKPROBE_SYMBOL(FETCH_FUNC_NAME(deref, type)); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 135 | DEFINE_BASIC_FETCH_FUNCS(deref) |
| 136 | DEFINE_FETCH_deref(string) |
Hyeoncheol Lee | 3925f4a | 2013-07-01 13:44:32 +0900 | [diff] [blame] | 137 | |
Masami Hiramatsu | 3da0f18 | 2014-04-17 17:18:28 +0900 | [diff] [blame] | 138 | void FETCH_FUNC_NAME(deref, string_size)(struct pt_regs *regs, |
| 139 | void *data, void *dest) |
Hyeoncheol Lee | 3925f4a | 2013-07-01 13:44:32 +0900 | [diff] [blame] | 140 | { |
| 141 | struct deref_fetch_param *dprm = data; |
| 142 | unsigned long addr; |
| 143 | |
| 144 | call_fetch(&dprm->orig, regs, &addr); |
| 145 | if (addr && dprm->fetch_size) { |
| 146 | addr += dprm->offset; |
| 147 | dprm->fetch_size(regs, (void *)addr, dest); |
| 148 | } else |
| 149 | *(string_size *)dest = 0; |
| 150 | } |
Masami Hiramatsu | 3da0f18 | 2014-04-17 17:18:28 +0900 | [diff] [blame] | 151 | NOKPROBE_SYMBOL(FETCH_FUNC_NAME(deref, string_size)); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 152 | |
Masami Hiramatsu | 3da0f18 | 2014-04-17 17:18:28 +0900 | [diff] [blame] | 153 | static void update_deref_fetch_param(struct deref_fetch_param *data) |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 154 | { |
| 155 | if (CHECK_FETCH_FUNCS(deref, data->orig.fn)) |
| 156 | update_deref_fetch_param(data->orig.data); |
| 157 | else if (CHECK_FETCH_FUNCS(symbol, data->orig.fn)) |
| 158 | update_symbol_cache(data->orig.data); |
| 159 | } |
Masami Hiramatsu | 3da0f18 | 2014-04-17 17:18:28 +0900 | [diff] [blame] | 160 | NOKPROBE_SYMBOL(update_deref_fetch_param); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 161 | |
Masami Hiramatsu | 3da0f18 | 2014-04-17 17:18:28 +0900 | [diff] [blame] | 162 | static void free_deref_fetch_param(struct deref_fetch_param *data) |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 163 | { |
| 164 | if (CHECK_FETCH_FUNCS(deref, data->orig.fn)) |
| 165 | free_deref_fetch_param(data->orig.data); |
| 166 | else if (CHECK_FETCH_FUNCS(symbol, data->orig.fn)) |
| 167 | free_symbol_cache(data->orig.data); |
| 168 | kfree(data); |
| 169 | } |
Masami Hiramatsu | 3da0f18 | 2014-04-17 17:18:28 +0900 | [diff] [blame] | 170 | NOKPROBE_SYMBOL(free_deref_fetch_param); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 171 | |
| 172 | /* Bitfield fetch function */ |
| 173 | struct bitfield_fetch_param { |
| 174 | struct fetch_param orig; |
| 175 | unsigned char hi_shift; |
| 176 | unsigned char low_shift; |
| 177 | }; |
| 178 | |
| 179 | #define DEFINE_FETCH_bitfield(type) \ |
Masami Hiramatsu | 3da0f18 | 2014-04-17 17:18:28 +0900 | [diff] [blame] | 180 | void FETCH_FUNC_NAME(bitfield, type)(struct pt_regs *regs, \ |
| 181 | void *data, void *dest) \ |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 182 | { \ |
| 183 | struct bitfield_fetch_param *bprm = data; \ |
| 184 | type buf = 0; \ |
| 185 | call_fetch(&bprm->orig, regs, &buf); \ |
| 186 | if (buf) { \ |
| 187 | buf <<= bprm->hi_shift; \ |
| 188 | buf >>= bprm->low_shift; \ |
| 189 | } \ |
| 190 | *(type *)dest = buf; \ |
Masami Hiramatsu | 3da0f18 | 2014-04-17 17:18:28 +0900 | [diff] [blame] | 191 | } \ |
| 192 | NOKPROBE_SYMBOL(FETCH_FUNC_NAME(bitfield, type)); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 193 | DEFINE_BASIC_FETCH_FUNCS(bitfield) |
| 194 | #define fetch_bitfield_string NULL |
| 195 | #define fetch_bitfield_string_size NULL |
| 196 | |
Masami Hiramatsu | fbc1963 | 2014-04-17 17:18:00 +0900 | [diff] [blame] | 197 | static void |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 198 | update_bitfield_fetch_param(struct bitfield_fetch_param *data) |
| 199 | { |
| 200 | /* |
| 201 | * Don't check the bitfield itself, because this must be the |
| 202 | * last fetch function. |
| 203 | */ |
| 204 | if (CHECK_FETCH_FUNCS(deref, data->orig.fn)) |
| 205 | update_deref_fetch_param(data->orig.data); |
| 206 | else if (CHECK_FETCH_FUNCS(symbol, data->orig.fn)) |
| 207 | update_symbol_cache(data->orig.data); |
| 208 | } |
| 209 | |
Masami Hiramatsu | fbc1963 | 2014-04-17 17:18:00 +0900 | [diff] [blame] | 210 | static void |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 211 | free_bitfield_fetch_param(struct bitfield_fetch_param *data) |
| 212 | { |
| 213 | /* |
| 214 | * Don't check the bitfield itself, because this must be the |
| 215 | * last fetch function. |
| 216 | */ |
| 217 | if (CHECK_FETCH_FUNCS(deref, data->orig.fn)) |
| 218 | free_deref_fetch_param(data->orig.data); |
| 219 | else if (CHECK_FETCH_FUNCS(symbol, data->orig.fn)) |
| 220 | free_symbol_cache(data->orig.data); |
| 221 | |
| 222 | kfree(data); |
| 223 | } |
| 224 | |
Omar Sandoval | 35abb67 | 2016-06-08 18:38:02 -0700 | [diff] [blame] | 225 | void FETCH_FUNC_NAME(comm, string)(struct pt_regs *regs, |
| 226 | void *data, void *dest) |
| 227 | { |
| 228 | int maxlen = get_rloc_len(*(u32 *)dest); |
| 229 | u8 *dst = get_rloc_data(dest); |
| 230 | long ret; |
| 231 | |
| 232 | if (!maxlen) |
| 233 | return; |
| 234 | |
| 235 | ret = strlcpy(dst, current->comm, maxlen); |
| 236 | *(u32 *)dest = make_data_rloc(ret, get_rloc_offs(*(u32 *)dest)); |
| 237 | } |
| 238 | NOKPROBE_SYMBOL(FETCH_FUNC_NAME(comm, string)); |
| 239 | |
| 240 | void FETCH_FUNC_NAME(comm, string_size)(struct pt_regs *regs, |
| 241 | void *data, void *dest) |
| 242 | { |
| 243 | *(u32 *)dest = strlen(current->comm) + 1; |
| 244 | } |
| 245 | NOKPROBE_SYMBOL(FETCH_FUNC_NAME(comm, string_size)); |
| 246 | |
Namhyung Kim | 34fee3a | 2013-11-26 14:56:28 +0900 | [diff] [blame] | 247 | static const struct fetch_type *find_fetch_type(const char *type, |
| 248 | const struct fetch_type *ftbl) |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 249 | { |
| 250 | int i; |
| 251 | |
| 252 | if (!type) |
| 253 | type = DEFAULT_FETCH_TYPE_STR; |
| 254 | |
| 255 | /* Special case: bitfield */ |
| 256 | if (*type == 'b') { |
| 257 | unsigned long bs; |
| 258 | |
| 259 | type = strchr(type, '/'); |
| 260 | if (!type) |
| 261 | goto fail; |
| 262 | |
| 263 | type++; |
Daniel Walter | bcd83ea | 2012-09-26 22:08:38 +0200 | [diff] [blame] | 264 | if (kstrtoul(type, 0, &bs)) |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 265 | goto fail; |
| 266 | |
| 267 | switch (bs) { |
| 268 | case 8: |
Namhyung Kim | 34fee3a | 2013-11-26 14:56:28 +0900 | [diff] [blame] | 269 | return find_fetch_type("u8", ftbl); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 270 | case 16: |
Namhyung Kim | 34fee3a | 2013-11-26 14:56:28 +0900 | [diff] [blame] | 271 | return find_fetch_type("u16", ftbl); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 272 | case 32: |
Namhyung Kim | 34fee3a | 2013-11-26 14:56:28 +0900 | [diff] [blame] | 273 | return find_fetch_type("u32", ftbl); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 274 | case 64: |
Namhyung Kim | 34fee3a | 2013-11-26 14:56:28 +0900 | [diff] [blame] | 275 | return find_fetch_type("u64", ftbl); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 276 | default: |
| 277 | goto fail; |
| 278 | } |
| 279 | } |
| 280 | |
Namhyung Kim | 34fee3a | 2013-11-26 14:56:28 +0900 | [diff] [blame] | 281 | for (i = 0; ftbl[i].name; i++) { |
| 282 | if (strcmp(type, ftbl[i].name) == 0) |
| 283 | return &ftbl[i]; |
| 284 | } |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 285 | |
| 286 | fail: |
| 287 | return NULL; |
| 288 | } |
| 289 | |
| 290 | /* Special function : only accept unsigned long */ |
Masami Hiramatsu | 3da0f18 | 2014-04-17 17:18:28 +0900 | [diff] [blame] | 291 | static void fetch_kernel_stack_address(struct pt_regs *regs, void *dummy, void *dest) |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 292 | { |
| 293 | *(unsigned long *)dest = kernel_stack_pointer(regs); |
| 294 | } |
Masami Hiramatsu | 3da0f18 | 2014-04-17 17:18:28 +0900 | [diff] [blame] | 295 | NOKPROBE_SYMBOL(fetch_kernel_stack_address); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 296 | |
Masami Hiramatsu | 3da0f18 | 2014-04-17 17:18:28 +0900 | [diff] [blame] | 297 | static void fetch_user_stack_address(struct pt_regs *regs, void *dummy, void *dest) |
Namhyung Kim | b079d37 | 2013-07-03 18:34:23 +0900 | [diff] [blame] | 298 | { |
| 299 | *(unsigned long *)dest = user_stack_pointer(regs); |
| 300 | } |
Masami Hiramatsu | 3da0f18 | 2014-04-17 17:18:28 +0900 | [diff] [blame] | 301 | NOKPROBE_SYMBOL(fetch_user_stack_address); |
Namhyung Kim | b079d37 | 2013-07-03 18:34:23 +0900 | [diff] [blame] | 302 | |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 303 | static fetch_func_t get_fetch_size_function(const struct fetch_type *type, |
Namhyung Kim | 34fee3a | 2013-11-26 14:56:28 +0900 | [diff] [blame] | 304 | fetch_func_t orig_fn, |
| 305 | const struct fetch_type *ftbl) |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 306 | { |
| 307 | int i; |
| 308 | |
Namhyung Kim | 34fee3a | 2013-11-26 14:56:28 +0900 | [diff] [blame] | 309 | if (type != &ftbl[FETCH_TYPE_STRING]) |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 310 | return NULL; /* Only string type needs size function */ |
| 311 | |
| 312 | for (i = 0; i < FETCH_MTD_END; i++) |
| 313 | if (type->fetch[i] == orig_fn) |
Namhyung Kim | 34fee3a | 2013-11-26 14:56:28 +0900 | [diff] [blame] | 314 | return ftbl[FETCH_TYPE_STRSIZE].fetch[i]; |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 315 | |
| 316 | WARN_ON(1); /* This should not happen */ |
| 317 | |
| 318 | return NULL; |
| 319 | } |
| 320 | |
| 321 | /* Split symbol and offset. */ |
Masami Hiramatsu | d434dae | 2018-03-17 21:38:10 +0900 | [diff] [blame] | 322 | int traceprobe_split_symbol_offset(char *symbol, long *offset) |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 323 | { |
| 324 | char *tmp; |
| 325 | int ret; |
| 326 | |
| 327 | if (!offset) |
| 328 | return -EINVAL; |
| 329 | |
Masami Hiramatsu | d434dae | 2018-03-17 21:38:10 +0900 | [diff] [blame] | 330 | tmp = strpbrk(symbol, "+-"); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 331 | if (tmp) { |
Masami Hiramatsu | d434dae | 2018-03-17 21:38:10 +0900 | [diff] [blame] | 332 | ret = kstrtol(tmp, 0, offset); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 333 | if (ret) |
| 334 | return ret; |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 335 | *tmp = '\0'; |
| 336 | } else |
| 337 | *offset = 0; |
| 338 | |
| 339 | return 0; |
| 340 | } |
| 341 | |
| 342 | #define PARAM_MAX_STACK (THREAD_SIZE / sizeof(unsigned long)) |
| 343 | |
| 344 | static int parse_probe_vars(char *arg, const struct fetch_type *t, |
Namhyung Kim | b079d37 | 2013-07-03 18:34:23 +0900 | [diff] [blame] | 345 | struct fetch_param *f, bool is_return, |
| 346 | bool is_kprobe) |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 347 | { |
| 348 | int ret = 0; |
| 349 | unsigned long param; |
| 350 | |
| 351 | if (strcmp(arg, "retval") == 0) { |
| 352 | if (is_return) |
| 353 | f->fn = t->fetch[FETCH_MTD_retval]; |
| 354 | else |
| 355 | ret = -EINVAL; |
| 356 | } else if (strncmp(arg, "stack", 5) == 0) { |
| 357 | if (arg[5] == '\0') { |
Namhyung Kim | b079d37 | 2013-07-03 18:34:23 +0900 | [diff] [blame] | 358 | if (strcmp(t->name, DEFAULT_FETCH_TYPE_STR)) |
| 359 | return -EINVAL; |
| 360 | |
| 361 | if (is_kprobe) |
| 362 | f->fn = fetch_kernel_stack_address; |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 363 | else |
Namhyung Kim | b079d37 | 2013-07-03 18:34:23 +0900 | [diff] [blame] | 364 | f->fn = fetch_user_stack_address; |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 365 | } else if (isdigit(arg[5])) { |
Daniel Walter | bcd83ea | 2012-09-26 22:08:38 +0200 | [diff] [blame] | 366 | ret = kstrtoul(arg + 5, 10, ¶m); |
Namhyung Kim | b079d37 | 2013-07-03 18:34:23 +0900 | [diff] [blame] | 367 | if (ret || (is_kprobe && param > PARAM_MAX_STACK)) |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 368 | ret = -EINVAL; |
| 369 | else { |
| 370 | f->fn = t->fetch[FETCH_MTD_stack]; |
| 371 | f->data = (void *)param; |
| 372 | } |
| 373 | } else |
| 374 | ret = -EINVAL; |
Omar Sandoval | 35abb67 | 2016-06-08 18:38:02 -0700 | [diff] [blame] | 375 | } else if (strcmp(arg, "comm") == 0) { |
| 376 | if (strcmp(t->name, "string") != 0 && |
| 377 | strcmp(t->name, "string_size") != 0) |
| 378 | return -EINVAL; |
| 379 | f->fn = t->fetch[FETCH_MTD_comm]; |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 380 | } else |
| 381 | ret = -EINVAL; |
| 382 | |
| 383 | return ret; |
| 384 | } |
| 385 | |
| 386 | /* Recursive argument parser */ |
| 387 | static int parse_probe_arg(char *arg, const struct fetch_type *t, |
Stephen Rothwell | d9a16d3 | 2015-03-12 16:58:34 +1100 | [diff] [blame] | 388 | struct fetch_param *f, bool is_return, bool is_kprobe, |
| 389 | const struct fetch_type *ftbl) |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 390 | { |
| 391 | unsigned long param; |
| 392 | long offset; |
| 393 | char *tmp; |
Namhyung Kim | 34fee3a | 2013-11-26 14:56:28 +0900 | [diff] [blame] | 394 | int ret = 0; |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 395 | |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 396 | switch (arg[0]) { |
| 397 | case '$': |
Namhyung Kim | b079d37 | 2013-07-03 18:34:23 +0900 | [diff] [blame] | 398 | ret = parse_probe_vars(arg + 1, t, f, is_return, is_kprobe); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 399 | break; |
| 400 | |
| 401 | case '%': /* named register */ |
| 402 | ret = regs_query_register_offset(arg + 1); |
| 403 | if (ret >= 0) { |
| 404 | f->fn = t->fetch[FETCH_MTD_reg]; |
| 405 | f->data = (void *)(unsigned long)ret; |
| 406 | ret = 0; |
| 407 | } |
| 408 | break; |
| 409 | |
Namhyung Kim | b7e0bf3 | 2013-11-25 13:42:47 +0900 | [diff] [blame] | 410 | case '@': /* memory, file-offset or symbol */ |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 411 | if (isdigit(arg[1])) { |
Daniel Walter | bcd83ea | 2012-09-26 22:08:38 +0200 | [diff] [blame] | 412 | ret = kstrtoul(arg + 1, 0, ¶m); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 413 | if (ret) |
| 414 | break; |
| 415 | |
| 416 | f->fn = t->fetch[FETCH_MTD_memory]; |
| 417 | f->data = (void *)param; |
Namhyung Kim | b7e0bf3 | 2013-11-25 13:42:47 +0900 | [diff] [blame] | 418 | } else if (arg[1] == '+') { |
| 419 | /* kprobes don't support file offsets */ |
| 420 | if (is_kprobe) |
| 421 | return -EINVAL; |
| 422 | |
| 423 | ret = kstrtol(arg + 2, 0, &offset); |
| 424 | if (ret) |
| 425 | break; |
| 426 | |
| 427 | f->fn = t->fetch[FETCH_MTD_file_offset]; |
| 428 | f->data = (void *)offset; |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 429 | } else { |
Namhyung Kim | b079d37 | 2013-07-03 18:34:23 +0900 | [diff] [blame] | 430 | /* uprobes don't support symbols */ |
| 431 | if (!is_kprobe) |
| 432 | return -EINVAL; |
| 433 | |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 434 | ret = traceprobe_split_symbol_offset(arg + 1, &offset); |
| 435 | if (ret) |
| 436 | break; |
| 437 | |
| 438 | f->data = alloc_symbol_cache(arg + 1, offset); |
| 439 | if (f->data) |
| 440 | f->fn = t->fetch[FETCH_MTD_symbol]; |
| 441 | } |
| 442 | break; |
| 443 | |
| 444 | case '+': /* deref memory */ |
Daniel Walter | bcd83ea | 2012-09-26 22:08:38 +0200 | [diff] [blame] | 445 | arg++; /* Skip '+', because kstrtol() rejects it. */ |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 446 | case '-': |
| 447 | tmp = strchr(arg, '('); |
| 448 | if (!tmp) |
| 449 | break; |
| 450 | |
| 451 | *tmp = '\0'; |
Daniel Walter | bcd83ea | 2012-09-26 22:08:38 +0200 | [diff] [blame] | 452 | ret = kstrtol(arg, 0, &offset); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 453 | |
| 454 | if (ret) |
| 455 | break; |
| 456 | |
| 457 | arg = tmp + 1; |
| 458 | tmp = strrchr(arg, ')'); |
| 459 | |
| 460 | if (tmp) { |
| 461 | struct deref_fetch_param *dprm; |
| 462 | const struct fetch_type *t2; |
| 463 | |
Namhyung Kim | 34fee3a | 2013-11-26 14:56:28 +0900 | [diff] [blame] | 464 | t2 = find_fetch_type(NULL, ftbl); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 465 | *tmp = '\0'; |
| 466 | dprm = kzalloc(sizeof(struct deref_fetch_param), GFP_KERNEL); |
| 467 | |
| 468 | if (!dprm) |
| 469 | return -ENOMEM; |
| 470 | |
| 471 | dprm->offset = offset; |
Hyeoncheol Lee | 3925f4a | 2013-07-01 13:44:32 +0900 | [diff] [blame] | 472 | dprm->fetch = t->fetch[FETCH_MTD_memory]; |
| 473 | dprm->fetch_size = get_fetch_size_function(t, |
| 474 | dprm->fetch, ftbl); |
Srikar Dronamraju | f3f096c | 2012-04-11 16:00:43 +0530 | [diff] [blame] | 475 | ret = parse_probe_arg(arg, t2, &dprm->orig, is_return, |
Stephen Rothwell | d9a16d3 | 2015-03-12 16:58:34 +1100 | [diff] [blame] | 476 | is_kprobe, ftbl); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 477 | if (ret) |
| 478 | kfree(dprm); |
| 479 | else { |
| 480 | f->fn = t->fetch[FETCH_MTD_deref]; |
| 481 | f->data = (void *)dprm; |
| 482 | } |
| 483 | } |
| 484 | break; |
| 485 | } |
| 486 | if (!ret && !f->fn) { /* Parsed, but do not find fetch method */ |
| 487 | pr_info("%s type has no corresponding fetch method.\n", t->name); |
| 488 | ret = -EINVAL; |
| 489 | } |
| 490 | |
| 491 | return ret; |
| 492 | } |
| 493 | |
| 494 | #define BYTES_TO_BITS(nb) ((BITS_PER_LONG * (nb)) / sizeof(long)) |
| 495 | |
| 496 | /* Bitfield type needs to be parsed into a fetch function */ |
| 497 | static int __parse_bitfield_probe_arg(const char *bf, |
| 498 | const struct fetch_type *t, |
| 499 | struct fetch_param *f) |
| 500 | { |
| 501 | struct bitfield_fetch_param *bprm; |
| 502 | unsigned long bw, bo; |
| 503 | char *tail; |
| 504 | |
| 505 | if (*bf != 'b') |
| 506 | return 0; |
| 507 | |
| 508 | bprm = kzalloc(sizeof(*bprm), GFP_KERNEL); |
| 509 | if (!bprm) |
| 510 | return -ENOMEM; |
| 511 | |
| 512 | bprm->orig = *f; |
| 513 | f->fn = t->fetch[FETCH_MTD_bitfield]; |
| 514 | f->data = (void *)bprm; |
| 515 | bw = simple_strtoul(bf + 1, &tail, 0); /* Use simple one */ |
| 516 | |
| 517 | if (bw == 0 || *tail != '@') |
| 518 | return -EINVAL; |
| 519 | |
| 520 | bf = tail + 1; |
| 521 | bo = simple_strtoul(bf, &tail, 0); |
| 522 | |
| 523 | if (tail == bf || *tail != '/') |
| 524 | return -EINVAL; |
| 525 | |
| 526 | bprm->hi_shift = BYTES_TO_BITS(t->size) - (bw + bo); |
| 527 | bprm->low_shift = bprm->hi_shift + bo; |
| 528 | |
| 529 | return (BYTES_TO_BITS(t->size) < (bw + bo)) ? -EINVAL : 0; |
| 530 | } |
| 531 | |
| 532 | /* String length checking wrapper */ |
| 533 | int traceprobe_parse_probe_arg(char *arg, ssize_t *size, |
Stephen Rothwell | d9a16d3 | 2015-03-12 16:58:34 +1100 | [diff] [blame] | 534 | struct probe_arg *parg, bool is_return, bool is_kprobe, |
| 535 | const struct fetch_type *ftbl) |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 536 | { |
| 537 | const char *t; |
| 538 | int ret; |
| 539 | |
| 540 | if (strlen(arg) > MAX_ARGSTR_LEN) { |
| 541 | pr_info("Argument is too long.: %s\n", arg); |
| 542 | return -ENOSPC; |
| 543 | } |
| 544 | parg->comm = kstrdup(arg, GFP_KERNEL); |
| 545 | if (!parg->comm) { |
| 546 | pr_info("Failed to allocate memory for command '%s'.\n", arg); |
| 547 | return -ENOMEM; |
| 548 | } |
| 549 | t = strchr(parg->comm, ':'); |
| 550 | if (t) { |
| 551 | arg[t - parg->comm] = '\0'; |
| 552 | t++; |
| 553 | } |
Omar Sandoval | 35abb67 | 2016-06-08 18:38:02 -0700 | [diff] [blame] | 554 | /* |
| 555 | * The default type of $comm should be "string", and it can't be |
| 556 | * dereferenced. |
| 557 | */ |
| 558 | if (!t && strcmp(arg, "$comm") == 0) |
| 559 | t = "string"; |
Namhyung Kim | 34fee3a | 2013-11-26 14:56:28 +0900 | [diff] [blame] | 560 | parg->type = find_fetch_type(t, ftbl); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 561 | if (!parg->type) { |
| 562 | pr_info("Unsupported type: %s\n", t); |
| 563 | return -EINVAL; |
| 564 | } |
| 565 | parg->offset = *size; |
| 566 | *size += parg->type->size; |
Stephen Rothwell | d9a16d3 | 2015-03-12 16:58:34 +1100 | [diff] [blame] | 567 | ret = parse_probe_arg(arg, parg->type, &parg->fetch, is_return, |
| 568 | is_kprobe, ftbl); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 569 | |
| 570 | if (ret >= 0 && t != NULL) |
| 571 | ret = __parse_bitfield_probe_arg(t, parg->type, &parg->fetch); |
| 572 | |
| 573 | if (ret >= 0) { |
| 574 | parg->fetch_size.fn = get_fetch_size_function(parg->type, |
Namhyung Kim | 34fee3a | 2013-11-26 14:56:28 +0900 | [diff] [blame] | 575 | parg->fetch.fn, |
| 576 | ftbl); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 577 | parg->fetch_size.data = parg->fetch.data; |
| 578 | } |
| 579 | |
| 580 | return ret; |
| 581 | } |
| 582 | |
| 583 | /* Return 1 if name is reserved or already used by another argument */ |
| 584 | int traceprobe_conflict_field_name(const char *name, |
| 585 | struct probe_arg *args, int narg) |
| 586 | { |
| 587 | int i; |
| 588 | |
| 589 | for (i = 0; i < ARRAY_SIZE(reserved_field_names); i++) |
| 590 | if (strcmp(reserved_field_names[i], name) == 0) |
| 591 | return 1; |
| 592 | |
| 593 | for (i = 0; i < narg; i++) |
| 594 | if (strcmp(args[i].name, name) == 0) |
| 595 | return 1; |
| 596 | |
| 597 | return 0; |
| 598 | } |
| 599 | |
| 600 | void traceprobe_update_arg(struct probe_arg *arg) |
| 601 | { |
| 602 | if (CHECK_FETCH_FUNCS(bitfield, arg->fetch.fn)) |
| 603 | update_bitfield_fetch_param(arg->fetch.data); |
| 604 | else if (CHECK_FETCH_FUNCS(deref, arg->fetch.fn)) |
| 605 | update_deref_fetch_param(arg->fetch.data); |
| 606 | else if (CHECK_FETCH_FUNCS(symbol, arg->fetch.fn)) |
| 607 | update_symbol_cache(arg->fetch.data); |
| 608 | } |
| 609 | |
| 610 | void traceprobe_free_probe_arg(struct probe_arg *arg) |
| 611 | { |
| 612 | if (CHECK_FETCH_FUNCS(bitfield, arg->fetch.fn)) |
| 613 | free_bitfield_fetch_param(arg->fetch.data); |
| 614 | else if (CHECK_FETCH_FUNCS(deref, arg->fetch.fn)) |
| 615 | free_deref_fetch_param(arg->fetch.data); |
| 616 | else if (CHECK_FETCH_FUNCS(symbol, arg->fetch.fn)) |
| 617 | free_symbol_cache(arg->fetch.data); |
| 618 | |
| 619 | kfree(arg->name); |
| 620 | kfree(arg->comm); |
| 621 | } |
| 622 | |
| 623 | int traceprobe_command(const char *buf, int (*createfn)(int, char **)) |
| 624 | { |
| 625 | char **argv; |
| 626 | int argc, ret; |
| 627 | |
| 628 | argc = 0; |
| 629 | ret = 0; |
| 630 | argv = argv_split(GFP_KERNEL, buf, &argc); |
| 631 | if (!argv) |
| 632 | return -ENOMEM; |
| 633 | |
| 634 | if (argc) |
| 635 | ret = createfn(argc, argv); |
| 636 | |
| 637 | argv_free(argv); |
| 638 | |
| 639 | return ret; |
| 640 | } |
| 641 | |
| 642 | #define WRITE_BUFSIZE 4096 |
| 643 | |
| 644 | ssize_t traceprobe_probes_write(struct file *file, const char __user *buffer, |
| 645 | size_t count, loff_t *ppos, |
| 646 | int (*createfn)(int, char **)) |
| 647 | { |
| 648 | char *kbuf, *tmp; |
| 649 | int ret = 0; |
| 650 | size_t done = 0; |
| 651 | size_t size; |
| 652 | |
| 653 | kbuf = kmalloc(WRITE_BUFSIZE, GFP_KERNEL); |
| 654 | if (!kbuf) |
| 655 | return -ENOMEM; |
| 656 | |
| 657 | while (done < count) { |
| 658 | size = count - done; |
| 659 | |
| 660 | if (size >= WRITE_BUFSIZE) |
| 661 | size = WRITE_BUFSIZE - 1; |
| 662 | |
| 663 | if (copy_from_user(kbuf, buffer + done, size)) { |
| 664 | ret = -EFAULT; |
| 665 | goto out; |
| 666 | } |
| 667 | kbuf[size] = '\0'; |
| 668 | tmp = strchr(kbuf, '\n'); |
| 669 | |
| 670 | if (tmp) { |
| 671 | *tmp = '\0'; |
| 672 | size = tmp - kbuf + 1; |
| 673 | } else if (done + size < count) { |
Joe Perches | a395d6a | 2016-03-22 14:28:09 -0700 | [diff] [blame] | 674 | pr_warn("Line length is too long: Should be less than %d\n", |
| 675 | WRITE_BUFSIZE); |
Srikar Dronamraju | 8ab83f5 | 2012-04-09 14:41:44 +0530 | [diff] [blame] | 676 | ret = -EINVAL; |
| 677 | goto out; |
| 678 | } |
| 679 | done += size; |
| 680 | /* Remove comments */ |
| 681 | tmp = strchr(kbuf, '#'); |
| 682 | |
| 683 | if (tmp) |
| 684 | *tmp = '\0'; |
| 685 | |
| 686 | ret = traceprobe_command(kbuf, createfn); |
| 687 | if (ret) |
| 688 | goto out; |
| 689 | } |
| 690 | ret = done; |
| 691 | |
| 692 | out: |
| 693 | kfree(kbuf); |
| 694 | |
| 695 | return ret; |
| 696 | } |
Namhyung Kim | 5bf652a | 2013-07-03 16:09:02 +0900 | [diff] [blame] | 697 | |
| 698 | static int __set_print_fmt(struct trace_probe *tp, char *buf, int len, |
| 699 | bool is_return) |
| 700 | { |
| 701 | int i; |
| 702 | int pos = 0; |
| 703 | |
| 704 | const char *fmt, *arg; |
| 705 | |
| 706 | if (!is_return) { |
| 707 | fmt = "(%lx)"; |
| 708 | arg = "REC->" FIELD_STRING_IP; |
| 709 | } else { |
| 710 | fmt = "(%lx <- %lx)"; |
| 711 | arg = "REC->" FIELD_STRING_FUNC ", REC->" FIELD_STRING_RETIP; |
| 712 | } |
| 713 | |
| 714 | /* When len=0, we just calculate the needed length */ |
| 715 | #define LEN_OR_ZERO (len ? len - pos : 0) |
| 716 | |
| 717 | pos += snprintf(buf + pos, LEN_OR_ZERO, "\"%s", fmt); |
| 718 | |
| 719 | for (i = 0; i < tp->nr_args; i++) { |
| 720 | pos += snprintf(buf + pos, LEN_OR_ZERO, " %s=%s", |
| 721 | tp->args[i].name, tp->args[i].type->fmt); |
| 722 | } |
| 723 | |
| 724 | pos += snprintf(buf + pos, LEN_OR_ZERO, "\", %s", arg); |
| 725 | |
| 726 | for (i = 0; i < tp->nr_args; i++) { |
| 727 | if (strcmp(tp->args[i].type->name, "string") == 0) |
| 728 | pos += snprintf(buf + pos, LEN_OR_ZERO, |
| 729 | ", __get_str(%s)", |
| 730 | tp->args[i].name); |
| 731 | else |
| 732 | pos += snprintf(buf + pos, LEN_OR_ZERO, ", REC->%s", |
| 733 | tp->args[i].name); |
| 734 | } |
| 735 | |
| 736 | #undef LEN_OR_ZERO |
| 737 | |
| 738 | /* return the length of print_fmt */ |
| 739 | return pos; |
| 740 | } |
| 741 | |
| 742 | int set_print_fmt(struct trace_probe *tp, bool is_return) |
| 743 | { |
| 744 | int len; |
| 745 | char *print_fmt; |
| 746 | |
| 747 | /* First: called with 0 length to calculate the needed length */ |
| 748 | len = __set_print_fmt(tp, NULL, 0, is_return); |
| 749 | print_fmt = kmalloc(len + 1, GFP_KERNEL); |
| 750 | if (!print_fmt) |
| 751 | return -ENOMEM; |
| 752 | |
| 753 | /* Second: actually write the @print_fmt */ |
| 754 | __set_print_fmt(tp, print_fmt, len + 1, is_return); |
| 755 | tp->call.print_fmt = print_fmt; |
| 756 | |
| 757 | return 0; |
| 758 | } |