1
2
3
4
5
6
7
8
9
10#include <sys/types.h>
11#include <sys/time.h>
12#include <time.h>
13#include <dirent.h>
14#include <errno.h>
15#include <unistd.h>
16#include "builtin.h"
17#include "perf.h"
18#include "namespaces.h"
19#include "util/cache.h"
20#include "util/debug.h"
21#include "util/header.h"
22#include <subcmd/parse-options.h>
23#include "util/strlist.h"
24#include "util/build-id.h"
25#include "util/session.h"
26#include "util/symbol.h"
27#include "util/time-utils.h"
28#include "util/probe-file.h"
29
30static int build_id_cache__kcore_buildid(const char *proc_dir, char *sbuildid)
31{
32 char root_dir[PATH_MAX];
33 char *p;
34
35 strlcpy(root_dir, proc_dir, sizeof(root_dir));
36
37 p = strrchr(root_dir, '/');
38 if (!p)
39 return -1;
40 *p = '\0';
41 return sysfs__sprintf_build_id(root_dir, sbuildid);
42}
43
44static int build_id_cache__kcore_dir(char *dir, size_t sz)
45{
46 return fetch_current_timestamp(dir, sz);
47}
48
49static bool same_kallsyms_reloc(const char *from_dir, char *to_dir)
50{
51 char from[PATH_MAX];
52 char to[PATH_MAX];
53 const char *name;
54 u64 addr1 = 0, addr2 = 0;
55 int i, err = -1;
56
57 scnprintf(from, sizeof(from), "%s/kallsyms", from_dir);
58 scnprintf(to, sizeof(to), "%s/kallsyms", to_dir);
59
60 for (i = 0; (name = ref_reloc_sym_names[i]) != NULL; i++) {
61 err = kallsyms__get_function_start(from, name, &addr1);
62 if (!err)
63 break;
64 }
65
66 if (err)
67 return false;
68
69 if (kallsyms__get_function_start(to, name, &addr2))
70 return false;
71
72 return addr1 == addr2;
73}
74
75static int build_id_cache__kcore_existing(const char *from_dir, char *to_dir,
76 size_t to_dir_sz)
77{
78 char from[PATH_MAX];
79 char to[PATH_MAX];
80 char to_subdir[PATH_MAX];
81 struct dirent *dent;
82 int ret = -1;
83 DIR *d;
84
85 d = opendir(to_dir);
86 if (!d)
87 return -1;
88
89 scnprintf(from, sizeof(from), "%s/modules", from_dir);
90
91 while (1) {
92 dent = readdir(d);
93 if (!dent)
94 break;
95 if (dent->d_type != DT_DIR)
96 continue;
97 scnprintf(to, sizeof(to), "%s/%s/modules", to_dir,
98 dent->d_name);
99 scnprintf(to_subdir, sizeof(to_subdir), "%s/%s",
100 to_dir, dent->d_name);
101 if (!compare_proc_modules(from, to) &&
102 same_kallsyms_reloc(from_dir, to_subdir)) {
103 strlcpy(to_dir, to_subdir, to_dir_sz);
104 ret = 0;
105 break;
106 }
107 }
108
109 closedir(d);
110
111 return ret;
112}
113
114static int build_id_cache__add_kcore(const char *filename, bool force)
115{
116 char dir[32], sbuildid[SBUILD_ID_SIZE];
117 char from_dir[PATH_MAX], to_dir[PATH_MAX];
118 char *p;
119
120 strlcpy(from_dir, filename, sizeof(from_dir));
121
122 p = strrchr(from_dir, '/');
123 if (!p || strcmp(p + 1, "kcore"))
124 return -1;
125 *p = '\0';
126
127 if (build_id_cache__kcore_buildid(from_dir, sbuildid) < 0)
128 return -1;
129
130 scnprintf(to_dir, sizeof(to_dir), "%s/%s/%s",
131 buildid_dir, DSO__NAME_KCORE, sbuildid);
132
133 if (!force &&
134 !build_id_cache__kcore_existing(from_dir, to_dir, sizeof(to_dir))) {
135 pr_debug("same kcore found in %s\n", to_dir);
136 return 0;
137 }
138
139 if (build_id_cache__kcore_dir(dir, sizeof(dir)))
140 return -1;
141
142 scnprintf(to_dir, sizeof(to_dir), "%s/%s/%s/%s",
143 buildid_dir, DSO__NAME_KCORE, sbuildid, dir);
144
145 if (mkdir_p(to_dir, 0755))
146 return -1;
147
148 if (kcore_copy(from_dir, to_dir)) {
149
150 if (!rmdir(to_dir)) {
151 p = strrchr(to_dir, '/');
152 if (p)
153 *p = '\0';
154
155 if (!rmdir(to_dir)) {
156 p = strrchr(to_dir, '/');
157 if (p)
158 *p = '\0';
159
160 rmdir(to_dir);
161 }
162 }
163 return -1;
164 }
165
166 pr_debug("kcore added to build-id cache directory %s\n", to_dir);
167
168 return 0;
169}
170
171static int build_id_cache__add_file(const char *filename, struct nsinfo *nsi)
172{
173 char sbuild_id[SBUILD_ID_SIZE];
174 u8 build_id[BUILD_ID_SIZE];
175 int err;
176 struct nscookie nsc;
177
178 nsinfo__mountns_enter(nsi, &nsc);
179 err = filename__read_build_id(filename, &build_id, sizeof(build_id));
180 nsinfo__mountns_exit(&nsc);
181 if (err < 0) {
182 pr_debug("Couldn't read a build-id in %s\n", filename);
183 return -1;
184 }
185
186 build_id__sprintf(build_id, sizeof(build_id), sbuild_id);
187 err = build_id_cache__add_s(sbuild_id, filename, nsi,
188 false, false);
189 pr_debug("Adding %s %s: %s\n", sbuild_id, filename,
190 err ? "FAIL" : "Ok");
191 return err;
192}
193
194static int build_id_cache__remove_file(const char *filename, struct nsinfo *nsi)
195{
196 u8 build_id[BUILD_ID_SIZE];
197 char sbuild_id[SBUILD_ID_SIZE];
198 struct nscookie nsc;
199
200 int err;
201
202 nsinfo__mountns_enter(nsi, &nsc);
203 err = filename__read_build_id(filename, &build_id, sizeof(build_id));
204 nsinfo__mountns_exit(&nsc);
205 if (err < 0) {
206 pr_debug("Couldn't read a build-id in %s\n", filename);
207 return -1;
208 }
209
210 build_id__sprintf(build_id, sizeof(build_id), sbuild_id);
211 err = build_id_cache__remove_s(sbuild_id);
212 pr_debug("Removing %s %s: %s\n", sbuild_id, filename,
213 err ? "FAIL" : "Ok");
214
215 return err;
216}
217
218static int build_id_cache__purge_path(const char *pathname, struct nsinfo *nsi)
219{
220 struct strlist *list;
221 struct str_node *pos;
222 int err;
223
224 err = build_id_cache__list_build_ids(pathname, nsi, &list);
225 if (err)
226 goto out;
227
228 strlist__for_each_entry(pos, list) {
229 err = build_id_cache__remove_s(pos->s);
230 pr_debug("Removing %s %s: %s\n", pos->s, pathname,
231 err ? "FAIL" : "Ok");
232 if (err)
233 break;
234 }
235 strlist__delete(list);
236
237out:
238 pr_debug("Purging %s: %s\n", pathname, err ? "FAIL" : "Ok");
239
240 return err;
241}
242
243static int build_id_cache__purge_all(void)
244{
245 struct strlist *list;
246 struct str_node *pos;
247 int err = 0;
248 char *buf;
249
250 list = build_id_cache__list_all(false);
251 if (!list) {
252 pr_debug("Failed to get buildids: -%d\n", errno);
253 return -EINVAL;
254 }
255
256 strlist__for_each_entry(pos, list) {
257 buf = build_id_cache__origname(pos->s);
258 err = build_id_cache__remove_s(pos->s);
259 pr_debug("Removing %s (%s): %s\n", buf, pos->s,
260 err ? "FAIL" : "Ok");
261 free(buf);
262 if (err)
263 break;
264 }
265 strlist__delete(list);
266
267 pr_debug("Purged all: %s\n", err ? "FAIL" : "Ok");
268 return err;
269}
270
271static bool dso__missing_buildid_cache(struct dso *dso, int parm __maybe_unused)
272{
273 char filename[PATH_MAX];
274 u8 build_id[BUILD_ID_SIZE];
275
276 if (dso__build_id_filename(dso, filename, sizeof(filename), false) &&
277 filename__read_build_id(filename, build_id,
278 sizeof(build_id)) != sizeof(build_id)) {
279 if (errno == ENOENT)
280 return false;
281
282 pr_warning("Problems with %s file, consider removing it from the cache\n",
283 filename);
284 } else if (memcmp(dso->build_id, build_id, sizeof(dso->build_id))) {
285 pr_warning("Problems with %s file, consider removing it from the cache\n",
286 filename);
287 }
288
289 return true;
290}
291
292static int build_id_cache__fprintf_missing(struct perf_session *session, FILE *fp)
293{
294 perf_session__fprintf_dsos_buildid(session, fp, dso__missing_buildid_cache, 0);
295 return 0;
296}
297
298static int build_id_cache__update_file(const char *filename, struct nsinfo *nsi)
299{
300 u8 build_id[BUILD_ID_SIZE];
301 char sbuild_id[SBUILD_ID_SIZE];
302 struct nscookie nsc;
303
304 int err;
305
306 nsinfo__mountns_enter(nsi, &nsc);
307 err = filename__read_build_id(filename, &build_id, sizeof(build_id));
308 nsinfo__mountns_exit(&nsc);
309 if (err < 0) {
310 pr_debug("Couldn't read a build-id in %s\n", filename);
311 return -1;
312 }
313 err = 0;
314
315 build_id__sprintf(build_id, sizeof(build_id), sbuild_id);
316 if (build_id_cache__cached(sbuild_id))
317 err = build_id_cache__remove_s(sbuild_id);
318
319 if (!err)
320 err = build_id_cache__add_s(sbuild_id, filename, nsi, false,
321 false);
322
323 pr_debug("Updating %s %s: %s\n", sbuild_id, filename,
324 err ? "FAIL" : "Ok");
325
326 return err;
327}
328
329static int build_id_cache__show_all(void)
330{
331 struct strlist *bidlist;
332 struct str_node *nd;
333 char *buf;
334
335 bidlist = build_id_cache__list_all(true);
336 if (!bidlist) {
337 pr_debug("Failed to get buildids: -%d\n", errno);
338 return -1;
339 }
340 strlist__for_each_entry(nd, bidlist) {
341 buf = build_id_cache__origname(nd->s);
342 fprintf(stdout, "%s %s\n", nd->s, buf);
343 free(buf);
344 }
345 strlist__delete(bidlist);
346 return 0;
347}
348
349int cmd_buildid_cache(int argc, const char **argv)
350{
351 struct strlist *list;
352 struct str_node *pos;
353 int ret = 0;
354 int ns_id = -1;
355 bool force = false;
356 bool list_files = false;
357 bool opts_flag = false;
358 bool purge_all = false;
359 char const *add_name_list_str = NULL,
360 *remove_name_list_str = NULL,
361 *purge_name_list_str = NULL,
362 *missing_filename = NULL,
363 *update_name_list_str = NULL,
364 *kcore_filename = NULL;
365 char sbuf[STRERR_BUFSIZE];
366
367 struct perf_data data = {
368 .mode = PERF_DATA_MODE_READ,
369 };
370 struct perf_session *session = NULL;
371 struct nsinfo *nsi = NULL;
372
373 const struct option buildid_cache_options[] = {
374 OPT_STRING('a', "add", &add_name_list_str,
375 "file list", "file(s) to add"),
376 OPT_STRING('k', "kcore", &kcore_filename,
377 "file", "kcore file to add"),
378 OPT_STRING('r', "remove", &remove_name_list_str, "file list",
379 "file(s) to remove"),
380 OPT_STRING('p', "purge", &purge_name_list_str, "file list",
381 "file(s) to remove (remove old caches too)"),
382 OPT_BOOLEAN('P', "purge-all", &purge_all, "purge all cached files"),
383 OPT_BOOLEAN('l', "list", &list_files, "list all cached files"),
384 OPT_STRING('M', "missing", &missing_filename, "file",
385 "to find missing build ids in the cache"),
386 OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
387 OPT_STRING('u', "update", &update_name_list_str, "file list",
388 "file(s) to update"),
389 OPT_INCR('v', "verbose", &verbose, "be more verbose"),
390 OPT_INTEGER(0, "target-ns", &ns_id, "target pid for namespace context"),
391 OPT_END()
392 };
393 const char * const buildid_cache_usage[] = {
394 "perf buildid-cache [<options>]",
395 NULL
396 };
397
398 argc = parse_options(argc, argv, buildid_cache_options,
399 buildid_cache_usage, 0);
400
401 opts_flag = add_name_list_str || kcore_filename ||
402 remove_name_list_str || purge_name_list_str ||
403 missing_filename || update_name_list_str ||
404 purge_all;
405
406 if (argc || !(list_files || opts_flag))
407 usage_with_options(buildid_cache_usage, buildid_cache_options);
408
409
410 if (list_files && opts_flag) {
411 usage_with_options_msg(buildid_cache_usage,
412 buildid_cache_options, "-l is exclusive.\n");
413 }
414
415 if (ns_id > 0)
416 nsi = nsinfo__new(ns_id);
417
418 if (missing_filename) {
419 data.path = missing_filename;
420 data.force = force;
421
422 session = perf_session__new(&data, false, NULL);
423 if (session == NULL)
424 return -1;
425 }
426
427 if (symbol__init(session ? &session->header.env : NULL) < 0)
428 goto out;
429
430 setup_pager();
431
432 if (list_files) {
433 ret = build_id_cache__show_all();
434 goto out;
435 }
436
437 if (add_name_list_str) {
438 list = strlist__new(add_name_list_str, NULL);
439 if (list) {
440 strlist__for_each_entry(pos, list)
441 if (build_id_cache__add_file(pos->s, nsi)) {
442 if (errno == EEXIST) {
443 pr_debug("%s already in the cache\n",
444 pos->s);
445 continue;
446 }
447 pr_warning("Couldn't add %s: %s\n",
448 pos->s, str_error_r(errno, sbuf, sizeof(sbuf)));
449 }
450
451 strlist__delete(list);
452 }
453 }
454
455 if (remove_name_list_str) {
456 list = strlist__new(remove_name_list_str, NULL);
457 if (list) {
458 strlist__for_each_entry(pos, list)
459 if (build_id_cache__remove_file(pos->s, nsi)) {
460 if (errno == ENOENT) {
461 pr_debug("%s wasn't in the cache\n",
462 pos->s);
463 continue;
464 }
465 pr_warning("Couldn't remove %s: %s\n",
466 pos->s, str_error_r(errno, sbuf, sizeof(sbuf)));
467 }
468
469 strlist__delete(list);
470 }
471 }
472
473 if (purge_name_list_str) {
474 list = strlist__new(purge_name_list_str, NULL);
475 if (list) {
476 strlist__for_each_entry(pos, list)
477 if (build_id_cache__purge_path(pos->s, nsi)) {
478 if (errno == ENOENT) {
479 pr_debug("%s wasn't in the cache\n",
480 pos->s);
481 continue;
482 }
483 pr_warning("Couldn't remove %s: %s\n",
484 pos->s, str_error_r(errno, sbuf, sizeof(sbuf)));
485 }
486
487 strlist__delete(list);
488 }
489 }
490
491 if (purge_all) {
492 if (build_id_cache__purge_all()) {
493 pr_warning("Couldn't remove some caches. Error: %s.\n",
494 str_error_r(errno, sbuf, sizeof(sbuf)));
495 }
496 }
497
498 if (missing_filename)
499 ret = build_id_cache__fprintf_missing(session, stdout);
500
501 if (update_name_list_str) {
502 list = strlist__new(update_name_list_str, NULL);
503 if (list) {
504 strlist__for_each_entry(pos, list)
505 if (build_id_cache__update_file(pos->s, nsi)) {
506 if (errno == ENOENT) {
507 pr_debug("%s wasn't in the cache\n",
508 pos->s);
509 continue;
510 }
511 pr_warning("Couldn't update %s: %s\n",
512 pos->s, str_error_r(errno, sbuf, sizeof(sbuf)));
513 }
514
515 strlist__delete(list);
516 }
517 }
518
519 if (kcore_filename && build_id_cache__add_kcore(kcore_filename, force))
520 pr_warning("Couldn't add %s\n", kcore_filename);
521
522out:
523 perf_session__delete(session);
524 nsinfo__zput(nsi);
525
526 return ret;
527}
528
