Commit | Line | Data |
---|---|---|
0c4e727b JR |
1 | /* |
2 | * Copyright (C) 2020 EfficiOS, Inc. | |
3 | * | |
4 | * SPDX-License-Identifier: GPL-2.0-only | |
5 | * | |
6 | */ | |
7 | ||
8 | #include "uprobe.h" | |
9 | ||
10 | #include <sys/types.h> | |
11 | #include <sys/stat.h> | |
12 | #include <unistd.h> | |
13 | ||
14 | #include "common/compat/getenv.h" | |
15 | #include "common/string-utils/string-utils.h" | |
16 | #include "common/utils.h" | |
17 | #include "lttng/constant.h" | |
18 | ||
19 | #include "command.h" | |
20 | ||
21 | /* | |
22 | * Walk the directories in the PATH environment variable to find the target | |
23 | * binary passed as parameter. | |
24 | * | |
25 | * On success, the full path of the binary is copied in binary_full_path out | |
26 | * parameter. This buffer is allocated by the caller and must be at least | |
27 | * LTTNG_PATH_MAX bytes long. | |
28 | * On failure, returns -1; | |
29 | */ | |
30 | static | |
31 | int walk_command_search_path(const char *binary, char *binary_full_path) | |
32 | { | |
33 | char *tentative_binary_path = NULL; | |
34 | char *command_search_path = NULL; | |
35 | char *curr_search_dir_end = NULL; | |
36 | char *curr_search_dir = NULL; | |
37 | struct stat stat_output; | |
38 | int ret = 0; | |
39 | ||
40 | command_search_path = lttng_secure_getenv("PATH"); | |
41 | if (!command_search_path) { | |
42 | ret = -1; | |
43 | goto end; | |
44 | } | |
45 | ||
46 | /* | |
47 | * Duplicate the $PATH string as the char pointer returned by getenv() should | |
48 | * not be modified. | |
49 | */ | |
50 | command_search_path = strdup(command_search_path); | |
51 | if (!command_search_path) { | |
52 | ret = -1; | |
53 | goto end; | |
54 | } | |
55 | ||
56 | /* | |
57 | * This char array is used to concatenate path to binary to look for | |
58 | * the binary. | |
59 | */ | |
60 | tentative_binary_path = zmalloc(LTTNG_PATH_MAX * sizeof(char)); | |
61 | if (!tentative_binary_path) { | |
62 | ret = -1; | |
63 | goto alloc_error; | |
64 | } | |
65 | ||
66 | curr_search_dir = command_search_path; | |
67 | do { | |
68 | /* | |
69 | * Split on ':'. The return value of this call points to the | |
70 | * matching character. | |
71 | */ | |
72 | curr_search_dir_end = strchr(curr_search_dir, ':'); | |
73 | if (curr_search_dir_end != NULL) { | |
74 | /* | |
75 | * Add a NULL byte to the end of the first token so it | |
76 | * can be used as a string. | |
77 | */ | |
78 | curr_search_dir_end[0] = '\0'; | |
79 | } | |
80 | ||
81 | /* Empty the tentative path */ | |
82 | memset(tentative_binary_path, 0, LTTNG_PATH_MAX * sizeof(char)); | |
83 | ||
84 | /* | |
85 | * Build the tentative path to the binary using the current | |
86 | * search directory and the name of the binary. | |
87 | */ | |
88 | ret = snprintf(tentative_binary_path, LTTNG_PATH_MAX, "%s/%s", | |
89 | curr_search_dir, binary); | |
90 | if (ret < 0) { | |
91 | goto free_binary_path; | |
92 | } | |
93 | if (ret < LTTNG_PATH_MAX) { | |
94 | /* | |
95 | * Use STAT(2) to see if the file exists. | |
96 | */ | |
97 | ret = stat(tentative_binary_path, &stat_output); | |
98 | if (ret == 0) { | |
99 | /* | |
100 | * Verify that it is a regular file or a | |
101 | * symlink and not a special file (e.g. | |
102 | * device). | |
103 | */ | |
104 | if (S_ISREG(stat_output.st_mode) | |
105 | || S_ISLNK(stat_output.st_mode)) { | |
106 | /* | |
107 | * Found a match, set the out parameter | |
108 | * and return success. | |
109 | */ | |
110 | ret = lttng_strncpy(binary_full_path, | |
111 | tentative_binary_path, | |
112 | LTTNG_PATH_MAX); | |
113 | if (ret == -1) { | |
114 | ERR("Source path does not fit " | |
115 | "in destination buffer."); | |
116 | } | |
117 | goto free_binary_path; | |
118 | } | |
119 | } | |
120 | } | |
121 | /* Go to the next entry in the $PATH variable. */ | |
122 | curr_search_dir = curr_search_dir_end + 1; | |
123 | } while (curr_search_dir_end != NULL); | |
124 | ||
125 | free_binary_path: | |
126 | free(tentative_binary_path); | |
127 | alloc_error: | |
128 | free(command_search_path); | |
129 | end: | |
130 | return ret; | |
131 | } | |
132 | ||
133 | /* | |
134 | * Check if the symbol field passed by the user is in fact an address or an | |
135 | * offset from a symbol. Those two instrumentation types are not supported yet. | |
136 | * It's expected to be a common mistake because of the existing --probe option | |
137 | * that does support these formats. | |
138 | * | |
139 | * Here are examples of these unsupported formats for the --userspace-probe | |
140 | * option: | |
141 | * elf:/path/to/binary:0x400430 | |
142 | * elf:/path/to/binary:4194364 | |
143 | * elf:/path/to/binary:my_symbol+0x323 | |
144 | * elf:/path/to/binary:my_symbol+43 | |
145 | */ | |
146 | static | |
147 | int warn_userspace_probe_syntax(const char *symbol) | |
148 | { | |
149 | int ret; | |
150 | ||
151 | /* Check if the symbol field is an hex address. */ | |
152 | ret = sscanf(symbol, "0x%*x"); | |
153 | if (ret > 0) { | |
154 | /* If there is a match, print a warning and return an error. */ | |
155 | ERR("Userspace probe on address not supported yet."); | |
156 | ret = CMD_UNSUPPORTED; | |
157 | goto error; | |
158 | } | |
159 | ||
160 | /* Check if the symbol field is an decimal address. */ | |
161 | ret = sscanf(symbol, "%*u"); | |
162 | if (ret > 0) { | |
163 | /* If there is a match, print a warning and return an error. */ | |
164 | ERR("Userspace probe on address not supported yet."); | |
165 | ret = CMD_UNSUPPORTED; | |
166 | goto error; | |
167 | } | |
168 | ||
169 | /* Check if the symbol field is symbol+hex_offset. */ | |
170 | ret = sscanf(symbol, "%*[^+]+0x%*x"); | |
171 | if (ret > 0) { | |
172 | /* If there is a match, print a warning and return an error. */ | |
173 | ERR("Userspace probe on symbol+offset not supported yet."); | |
174 | ret = CMD_UNSUPPORTED; | |
175 | goto error; | |
176 | } | |
177 | ||
178 | /* Check if the symbol field is symbol+decimal_offset. */ | |
179 | ret = sscanf(symbol, "%*[^+]+%*u"); | |
180 | if (ret > 0) { | |
181 | /* If there is a match, print a warning and return an error. */ | |
182 | ERR("Userspace probe on symbol+offset not supported yet."); | |
183 | ret = CMD_UNSUPPORTED; | |
184 | goto error; | |
185 | } | |
186 | ||
187 | ret = 0; | |
188 | ||
189 | error: | |
190 | return ret; | |
191 | } | |
192 | ||
193 | /* | |
194 | * Parse userspace probe options | |
195 | * Set the userspace probe fields in the lttng_event struct and set the | |
196 | * target_path to the path to the binary. | |
197 | */ | |
198 | LTTNG_HIDDEN | |
199 | int parse_userspace_probe_opts(const char *opt, | |
200 | struct lttng_userspace_probe_location **probe_location) | |
201 | { | |
202 | int ret = CMD_SUCCESS; | |
203 | int num_token; | |
204 | char **tokens = NULL; | |
205 | char *target_path = NULL; | |
206 | char *unescaped_target_path = NULL; | |
207 | char *real_target_path = NULL; | |
208 | char *symbol_name = NULL, *probe_name = NULL, *provider_name = NULL; | |
209 | struct lttng_userspace_probe_location *probe_location_local = NULL; | |
210 | struct lttng_userspace_probe_location_lookup_method *lookup_method = NULL; | |
211 | ||
212 | assert(opt); | |
213 | ||
214 | /* | |
215 | * userspace probe fields are separated by ':'. | |
216 | */ | |
217 | tokens = strutils_split(opt, ':', 1); | |
218 | num_token = strutils_array_of_strings_len(tokens); | |
219 | ||
220 | /* | |
221 | * Early sanity check that the number of parameter is between 2 and 4 | |
222 | * inclusively. | |
223 | * elf:PATH:SYMBOL | |
224 | * std:PATH:PROVIDER_NAME:PROBE_NAME | |
225 | * PATH:SYMBOL (same behavior as ELF) | |
226 | */ | |
227 | if (num_token < 2 || num_token > 4) { | |
228 | ret = CMD_ERROR; | |
229 | goto end; | |
230 | } | |
231 | ||
232 | /* | |
233 | * Looking up the first parameter will tell the technique to use to | |
234 | * interpret the userspace probe/function description. | |
235 | */ | |
236 | switch (num_token) { | |
237 | case 2: | |
238 | /* When the probe type is omitted we assume ELF for now. */ | |
239 | case 3: | |
240 | if (num_token == 3 && strcmp(tokens[0], "elf") == 0) { | |
241 | target_path = tokens[1]; | |
242 | symbol_name = tokens[2]; | |
243 | } else if (num_token == 2) { | |
244 | target_path = tokens[0]; | |
245 | symbol_name = tokens[1]; | |
246 | } else { | |
247 | ret = CMD_ERROR; | |
248 | goto end; | |
249 | } | |
250 | lookup_method = | |
251 | lttng_userspace_probe_location_lookup_method_function_elf_create(); | |
252 | if (!lookup_method) { | |
253 | WARN("Failed to create ELF lookup method"); | |
254 | ret = CMD_ERROR; | |
255 | goto end; | |
256 | } | |
257 | break; | |
258 | case 4: | |
259 | if (strcmp(tokens[0], "sdt") == 0) { | |
260 | target_path = tokens[1]; | |
261 | provider_name = tokens[2]; | |
262 | probe_name = tokens[3]; | |
263 | } else { | |
264 | ret = CMD_ERROR; | |
265 | goto end; | |
266 | } | |
267 | lookup_method = | |
268 | lttng_userspace_probe_location_lookup_method_tracepoint_sdt_create(); | |
269 | if (!lookup_method) { | |
270 | WARN("Failed to create SDT lookup method"); | |
271 | ret = CMD_ERROR; | |
272 | goto end; | |
273 | } | |
274 | break; | |
275 | default: | |
276 | ret = CMD_ERROR; | |
277 | goto end; | |
278 | } | |
279 | ||
280 | /* strutils_unescape_string allocates a new char *. */ | |
281 | unescaped_target_path = strutils_unescape_string(target_path, 0); | |
282 | if (!unescaped_target_path) { | |
283 | ret = CMD_ERROR; | |
284 | goto end; | |
285 | } | |
286 | ||
287 | /* | |
288 | * If there is not forward slash in the path. Walk the $PATH else | |
289 | * expand. | |
290 | */ | |
291 | if (strchr(unescaped_target_path, '/') == NULL) { | |
292 | /* Walk the $PATH variable to find the targeted binary. */ | |
293 | real_target_path = zmalloc(LTTNG_PATH_MAX * sizeof(char)); | |
294 | if (!real_target_path) { | |
295 | PERROR("Error allocating path buffer"); | |
296 | ret = CMD_ERROR; | |
297 | goto end; | |
298 | } | |
299 | ret = walk_command_search_path(unescaped_target_path, real_target_path); | |
300 | if (ret) { | |
301 | ERR("Binary not found."); | |
302 | ret = CMD_ERROR; | |
303 | goto end; | |
304 | } | |
305 | } else { | |
306 | /* | |
307 | * Expand references to `/./` and `/../`. This function does not check | |
308 | * if the file exists. This call returns an allocated buffer on | |
309 | * success. | |
310 | */ | |
311 | real_target_path = utils_expand_path_keep_symlink(unescaped_target_path); | |
312 | if (!real_target_path) { | |
313 | ERR("Error expanding the path to binary."); | |
314 | ret = CMD_ERROR; | |
315 | goto end; | |
316 | } | |
317 | ||
318 | /* | |
319 | * Check if the file exists using access(2), If it does not, | |
320 | * return an error. | |
321 | */ | |
322 | ret = access(real_target_path, F_OK); | |
323 | if (ret) { | |
324 | ERR("Cannot find binary at path: %s.", real_target_path); | |
325 | ret = CMD_ERROR; | |
326 | goto end; | |
327 | } | |
328 | } | |
329 | ||
330 | switch (lttng_userspace_probe_location_lookup_method_get_type(lookup_method)) { | |
331 | case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF: | |
332 | /* | |
333 | * Check for common mistakes in userspace probe description syntax. | |
334 | */ | |
335 | ret = warn_userspace_probe_syntax(symbol_name); | |
336 | if (ret) { | |
337 | goto end; | |
338 | } | |
339 | ||
340 | probe_location_local = lttng_userspace_probe_location_function_create( | |
341 | real_target_path, symbol_name, lookup_method); | |
342 | if (!probe_location_local) { | |
343 | WARN("Failed to create function probe location"); | |
344 | ret = CMD_ERROR; | |
345 | goto end; | |
346 | } | |
347 | ||
348 | /* Ownership transferred to probe_location. */ | |
349 | lookup_method = NULL; | |
350 | break; | |
351 | case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT: | |
352 | probe_location_local = lttng_userspace_probe_location_tracepoint_create( | |
353 | real_target_path, provider_name, probe_name, lookup_method); | |
354 | if (!probe_location_local) { | |
355 | WARN("Failed to create function probe location"); | |
356 | ret = CMD_ERROR; | |
357 | goto end; | |
358 | } | |
359 | ||
360 | /* Ownership transferred to probe_location. */ | |
361 | lookup_method = NULL; | |
362 | break; | |
363 | default: | |
364 | ret = CMD_ERROR; | |
365 | goto end; | |
366 | } | |
367 | ||
368 | /* | |
369 | * Everything went fine, transfer ownership of probe location to | |
370 | * caller. | |
371 | */ | |
372 | *probe_location = probe_location_local; | |
373 | probe_location_local = NULL; | |
374 | ||
375 | end: | |
376 | lttng_userspace_probe_location_destroy(probe_location_local); | |
377 | lttng_userspace_probe_location_lookup_method_destroy(lookup_method); | |
378 | strutils_free_null_terminated_array_of_strings(tokens); | |
379 | /* | |
380 | * Freeing both char * here makes the error handling simplier. free() | |
381 | * performs not action if the pointer is NULL. | |
382 | */ | |
383 | free(real_target_path); | |
384 | free(unescaped_target_path); | |
385 | ||
386 | return ret; | |
387 | } |