Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0 */
2 : : /*
3 : : * Traceprobe fetch helper inlines
4 : : */
5 : :
6 : : static nokprobe_inline void
7 : : fetch_store_raw(unsigned long val, struct fetch_insn *code, void *buf)
8 : : {
9 [ # # # # : 0 : switch (code->size) {
# ]
10 : : case 1:
11 : 0 : *(u8 *)buf = (u8)val;
12 : : break;
13 : : case 2:
14 : 0 : *(u16 *)buf = (u16)val;
15 : : break;
16 : : case 4:
17 : 0 : *(u32 *)buf = (u32)val;
18 : : break;
19 : : case 8:
20 : : //TBD: 32bit signed
21 : 0 : *(u64 *)buf = (u64)val;
22 : : break;
23 : : default:
24 : 0 : *(unsigned long *)buf = val;
25 : : }
26 : : }
27 : :
28 : : static nokprobe_inline void
29 : : fetch_apply_bitfield(struct fetch_insn *code, void *buf)
30 : : {
31 [ # # # # : 0 : switch (code->basesize) {
# ]
32 : : case 1:
33 : 0 : *(u8 *)buf <<= code->lshift;
34 : 0 : *(u8 *)buf >>= code->rshift;
35 : : break;
36 : : case 2:
37 : 0 : *(u16 *)buf <<= code->lshift;
38 : 0 : *(u16 *)buf >>= code->rshift;
39 : : break;
40 : : case 4:
41 : 0 : *(u32 *)buf <<= code->lshift;
42 : 0 : *(u32 *)buf >>= code->rshift;
43 : : break;
44 : : case 8:
45 : 0 : *(u64 *)buf <<= code->lshift;
46 : 0 : *(u64 *)buf >>= code->rshift;
47 : : break;
48 : : }
49 : : }
50 : :
51 : : /*
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.
55 : : */
56 : : static int
57 : : process_fetch_insn(struct fetch_insn *code, struct pt_regs *regs,
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);
69 : :
70 : : /* From the 2nd stage, routine is same */
71 : : static nokprobe_inline int
72 : : process_fetch_insn_bottom(struct fetch_insn *code, unsigned long val,
73 : : void *dest, void *base)
74 : : {
75 : : struct fetch_insn *s3 = NULL;
76 : : int total = 0, ret = 0, i = 0;
77 : : u32 loc = 0;
78 : : unsigned long lval = val;
79 : :
80 : : stage2:
81 : : /* 2nd stage: dereference memory if needed */
82 : : do {
83 [ # # ]: 0 : if (code->op == FETCH_OP_DEREF) {
84 : 0 : lval = val;
85 : 0 : ret = probe_mem_read(&val, (void *)val + code->offset,
86 : : sizeof(val));
87 [ # # ]: 0 : } else if (code->op == FETCH_OP_UDEREF) {
88 : 0 : lval = val;
89 : 0 : ret = probe_mem_read_user(&val,
90 : 0 : (void *)val + code->offset, sizeof(val));
91 : : } else
92 : : break;
93 [ # # ]: 0 : if (ret)
94 : 0 : return ret;
95 : 0 : code++;
96 : : } while (1);
97 : :
98 : : s3 = code;
99 : : stage3:
100 : : /* 3rd stage: store value to buffer */
101 [ # # ]: 0 : if (unlikely(!dest)) {
102 [ # # ]: 0 : if (code->op == FETCH_OP_ST_STRING) {
103 : 0 : ret = fetch_store_strlen(val + code->offset);
104 : 0 : code++;
105 : : goto array;
106 [ # # ]: 0 : } else if (code->op == FETCH_OP_ST_USTRING) {
107 : 0 : ret += fetch_store_strlen_user(val + code->offset);
108 : 0 : code++;
109 : : goto array;
110 : : } else
111 : : return -EILSEQ;
112 : : }
113 : :
114 [ # # # # : 0 : switch (code->op) {
# # ]
115 : : case FETCH_OP_ST_RAW:
116 : 0 : fetch_store_raw(val, code, dest);
117 : : break;
118 : : case FETCH_OP_ST_MEM:
119 : 0 : probe_mem_read(dest, (void *)val + code->offset, code->size);
120 : : break;
121 : : case FETCH_OP_ST_UMEM:
122 : 0 : probe_mem_read_user(dest, (void *)val + code->offset, code->size);
123 : : break;
124 : : case FETCH_OP_ST_STRING:
125 : 0 : loc = *(u32 *)dest;
126 : 0 : ret = fetch_store_string(val + code->offset, dest, base);
127 : : break;
128 : : case FETCH_OP_ST_USTRING:
129 : 0 : loc = *(u32 *)dest;
130 : 0 : ret = fetch_store_string_user(val + code->offset, dest, base);
131 : : break;
132 : : default:
133 : : return -EILSEQ;
134 : : }
135 : 0 : code++;
136 : :
137 : : /* 4th stage: modify stored value if needed */
138 [ # # ]: 0 : if (code->op == FETCH_OP_MOD_BF) {
139 : : fetch_apply_bitfield(code, dest);
140 : 0 : code++;
141 : : }
142 : :
143 : : array:
144 : : /* the last stage: Loop on array */
145 [ # # ]: 0 : if (code->op == FETCH_OP_LP_ARRAY) {
146 : 0 : total += ret;
147 [ # # ]: 0 : if (++i < code->param) {
148 : : code = s3;
149 [ # # ]: 0 : if (s3->op != FETCH_OP_ST_STRING &&
150 : : s3->op != FETCH_OP_ST_USTRING) {
151 : 0 : dest += s3->size;
152 : 0 : val += s3->size;
153 : : goto stage3;
154 : : }
155 : 0 : code--;
156 : 0 : val = lval + sizeof(char *);
157 [ # # ]: 0 : if (dest) {
158 : 0 : dest += sizeof(u32);
159 : 0 : *(u32 *)dest = update_data_loc(loc, ret);
160 : : }
161 : : goto stage2;
162 : : }
163 : 0 : code++;
164 : 0 : ret = total;
165 : : }
166 : :
167 [ # # ]: 0 : return code->op == FETCH_OP_END ? ret : -EILSEQ;
168 : : }
169 : :
170 : : /* Sum up total data length for dynamic arraies (strings) */
171 : : static nokprobe_inline int
172 : : __get_data_size(struct trace_probe *tp, struct pt_regs *regs)
173 : : {
174 : : struct probe_arg *arg;
175 : : int i, len, ret = 0;
176 : :
177 [ # # # # : 0 : for (i = 0; i < tp->nr_args; i++) {
# # # # ]
178 : : arg = tp->args + i;
179 [ # # # # : 0 : if (unlikely(arg->dynamic)) {
# # # # ]
180 : 0 : len = process_fetch_insn(arg->code, regs, NULL, NULL);
181 [ # # # # : 0 : if (len > 0)
# # # # ]
182 : 0 : ret += len;
183 : : }
184 : : }
185 : :
186 : 0 : return ret;
187 : : }
188 : :
189 : : /* Store the value of each argument */
190 : : static nokprobe_inline void
191 : : store_trace_args(void *data, struct trace_probe *tp, struct pt_regs *regs,
192 : : int header_size, int maxlen)
193 : : {
194 : : struct probe_arg *arg;
195 : : void *base = data - header_size;
196 : 0 : void *dyndata = data + tp->size;
197 : : u32 *dl; /* Data location */
198 : : int ret, i;
199 : :
200 [ # # # # : 0 : for (i = 0; i < tp->nr_args; i++) {
# # # # ]
201 : : arg = tp->args + i;
202 : 0 : dl = data + arg->offset;
203 : : /* Point the dynamic data area if needed */
204 [ # # # # : 0 : if (unlikely(arg->dynamic))
# # # # ]
205 : 0 : *dl = make_data_loc(maxlen, dyndata - base);
206 : 0 : ret = process_fetch_insn(arg->code, regs, dl, base);
207 [ # # # # : 0 : if (unlikely(ret < 0 && arg->dynamic)) {
# # # # #
# # # # #
# # ]
208 : 0 : *dl = make_data_loc(0, dyndata - base);
209 : : } else {
210 : 0 : dyndata += ret;
211 : 0 : maxlen -= ret;
212 : : }
213 : : }
214 : : }
215 : :
216 : : static inline int
217 : 0 : print_probe_args(struct trace_seq *s, struct probe_arg *args, int nr_args,
218 : : u8 *data, void *field)
219 : : {
220 : : void *p;
221 : : int i, j;
222 : :
223 [ # # ]: 0 : for (i = 0; i < nr_args; i++) {
224 : 0 : struct probe_arg *a = args + i;
225 : :
226 : 0 : trace_seq_printf(s, " %s=", a->name);
227 [ # # ]: 0 : if (likely(!a->count)) {
228 [ # # ]: 0 : if (!a->type->print(s, data + a->offset, field))
229 : : return -ENOMEM;
230 : 0 : continue;
231 : : }
232 : 0 : trace_seq_putc(s, '{');
233 : 0 : p = data + a->offset;
234 [ # # ]: 0 : for (j = 0; j < a->count; j++) {
235 [ # # ]: 0 : if (!a->type->print(s, p, field))
236 : : return -ENOMEM;
237 [ # # ]: 0 : trace_seq_putc(s, j == a->count - 1 ? '}' : ',');
238 : 0 : p += a->type->size;
239 : : }
240 : : }
241 : : return 0;
242 : : }
|
