1 /* SPDX-License-Identifier: GPL-2.0 */
3 * Traceprobe fetch helper inlines
6 static nokprobe_inline void
7 fetch_store_raw(unsigned long val, struct fetch_insn *code, void *buf)
14 *(u16 *)buf = (u16)val;
17 *(u32 *)buf = (u32)val;
21 *(u64 *)buf = (u64)val;
24 *(unsigned long *)buf = val;
28 static nokprobe_inline void
29 fetch_apply_bitfield(struct fetch_insn *code, void *buf)
31 switch (code->basesize) {
33 *(u8 *)buf <<= code->lshift;
34 *(u8 *)buf >>= code->rshift;
37 *(u16 *)buf <<= code->lshift;
38 *(u16 *)buf >>= code->rshift;
41 *(u32 *)buf <<= code->lshift;
42 *(u32 *)buf >>= code->rshift;
45 *(u64 *)buf <<= code->lshift;
46 *(u64 *)buf >>= code->rshift;
52 * These functions must be defined for each callsite.
53 * Return consumed dynamic data size (>= 0), or error (< 0).
54 * If dest is NULL, don't store result and return required dynamic data size.
57 process_fetch_insn(struct fetch_insn *code, void *rec,
58 void *dest, void *base);
59 static nokprobe_inline int fetch_store_strlen(unsigned long addr);
60 static nokprobe_inline int
61 fetch_store_string(unsigned long addr, void *dest, void *base);
62 static nokprobe_inline int fetch_store_strlen_user(unsigned long addr);
63 static nokprobe_inline int
64 fetch_store_string_user(unsigned long addr, void *dest, void *base);
65 static nokprobe_inline int
66 probe_mem_read(void *dest, void *src, size_t size);
67 static nokprobe_inline int
68 probe_mem_read_user(void *dest, void *src, size_t size);
70 static nokprobe_inline int
71 fetch_store_symstrlen(unsigned long addr)
73 char namebuf[KSYM_SYMBOL_LEN];
76 ret = sprint_symbol(namebuf, addr);
84 * Fetch a null-terminated symbol string + offset. Caller MUST set *(u32 *)buf
85 * with max length and relative data location.
87 static nokprobe_inline int
88 fetch_store_symstring(unsigned long addr, void *dest, void *base)
90 int maxlen = get_loc_len(*(u32 *)dest);
93 if (unlikely(!maxlen))
96 __dest = get_loc_data(dest, base);
98 return sprint_symbol(__dest, addr);
101 /* From the 2nd stage, routine is same */
102 static nokprobe_inline int
103 process_fetch_insn_bottom(struct fetch_insn *code, unsigned long val,
104 void *dest, void *base)
106 struct fetch_insn *s3 = NULL;
107 int total = 0, ret = 0, i = 0;
109 unsigned long lval = val;
112 /* 2nd stage: dereference memory if needed */
114 if (code->op == FETCH_OP_DEREF) {
116 ret = probe_mem_read(&val, (void *)val + code->offset,
118 } else if (code->op == FETCH_OP_UDEREF) {
120 ret = probe_mem_read_user(&val,
121 (void *)val + code->offset, sizeof(val));
131 /* 3rd stage: store value to buffer */
132 if (unlikely(!dest)) {
134 case FETCH_OP_ST_STRING:
135 ret = fetch_store_strlen(val + code->offset);
138 case FETCH_OP_ST_USTRING:
139 ret = fetch_store_strlen_user(val + code->offset);
142 case FETCH_OP_ST_SYMSTR:
143 ret = fetch_store_symstrlen(val + code->offset);
152 case FETCH_OP_ST_RAW:
153 fetch_store_raw(val, code, dest);
155 case FETCH_OP_ST_MEM:
156 probe_mem_read(dest, (void *)val + code->offset, code->size);
158 case FETCH_OP_ST_UMEM:
159 probe_mem_read_user(dest, (void *)val + code->offset, code->size);
161 case FETCH_OP_ST_STRING:
163 ret = fetch_store_string(val + code->offset, dest, base);
165 case FETCH_OP_ST_USTRING:
167 ret = fetch_store_string_user(val + code->offset, dest, base);
169 case FETCH_OP_ST_SYMSTR:
171 ret = fetch_store_symstring(val + code->offset, dest, base);
178 /* 4th stage: modify stored value if needed */
179 if (code->op == FETCH_OP_MOD_BF) {
180 fetch_apply_bitfield(code, dest);
185 /* the last stage: Loop on array */
186 if (code->op == FETCH_OP_LP_ARRAY) {
190 if (++i < code->param) {
192 if (s3->op != FETCH_OP_ST_STRING &&
193 s3->op != FETCH_OP_ST_USTRING) {
199 val = lval + sizeof(char *);
202 *(u32 *)dest = update_data_loc(loc, ret);
210 return code->op == FETCH_OP_END ? ret : -EILSEQ;
213 /* Sum up total data length for dynamic arrays (strings) */
214 static nokprobe_inline int
215 __get_data_size(struct trace_probe *tp, struct pt_regs *regs)
217 struct probe_arg *arg;
220 for (i = 0; i < tp->nr_args; i++) {
222 if (unlikely(arg->dynamic)) {
223 len = process_fetch_insn(arg->code, regs, NULL, NULL);
232 /* Store the value of each argument */
233 static nokprobe_inline void
234 store_trace_args(void *data, struct trace_probe *tp, void *rec,
235 int header_size, int maxlen)
237 struct probe_arg *arg;
238 void *base = data - header_size;
239 void *dyndata = data + tp->size;
240 u32 *dl; /* Data location */
243 for (i = 0; i < tp->nr_args; i++) {
245 dl = data + arg->offset;
246 /* Point the dynamic data area if needed */
247 if (unlikely(arg->dynamic))
248 *dl = make_data_loc(maxlen, dyndata - base);
249 ret = process_fetch_insn(arg->code, rec, dl, base);
250 if (arg->dynamic && likely(ret > 0)) {
258 print_probe_args(struct trace_seq *s, struct probe_arg *args, int nr_args,
259 u8 *data, void *field)
264 for (i = 0; i < nr_args; i++) {
265 struct probe_arg *a = args + i;
267 trace_seq_printf(s, " %s=", a->name);
268 if (likely(!a->count)) {
269 if (!a->type->print(s, data + a->offset, field))
273 trace_seq_putc(s, '{');
274 p = data + a->offset;
275 for (j = 0; j < a->count; j++) {
276 if (!a->type->print(s, p, field))
278 trace_seq_putc(s, j == a->count - 1 ? '}' : ',');