6 files changed, 576 insertions, 1 deletions

diff --git a/tools/perf/Documentation/perf-buildid-cache.txt b/tools/perf/Documentation/perf-buildid-cache.txt
index e9a8349a7172..fd77d81ea748 100644
--- a/tools/perf/Documentation/perf-buildid-cache.txt
+++ b/tools/perf/Documentation/perf-buildid-cache.txt
@@ -21,6 +21,19 @@ OPTIONS
 -a::
 --add=::
         Add specified file to the cache.
+-k::
+--kcore::
+        Add specified kcore file to the cache. For the current host that is
+        /proc/kcore which requires root permissions to read. Be aware that
+        running 'perf buildid-cache' as root may update root's build-id cache
+        not the user's. Use the -v option to see where the file is created.
+        Note that the copied file contains only code sections not the whole core
+        image. Note also that files "kallsyms" and "modules" must also be in the
+        same directory and are also copied.  All 3 files are created with read
+        permissions for root only. kcore will not be added if there is already a
+        kcore in the cache (with the same build-id) that has the same modules at
+        the same addresses. Use the -v option to see if a copy of kcore is
+        actually made.
 -r::
 --remove=::
         Remove specified file from the cache.
diff --git a/tools/perf/builtin-buildid-cache.c b/tools/perf/builtin-buildid-cache.c
index c96c8fa38243..8140b7b249fa 100644
--- a/tools/perf/builtin-buildid-cache.c
+++ b/tools/perf/builtin-buildid-cache.c
@@ -6,6 +6,11 @@
  * Copyright (C) 2010, Red Hat Inc.
  * Copyright (C) 2010, Arnaldo Carvalho de Melo <acme@redhat.com>
  */
+#include <sys/types.h>
+#include <sys/time.h>
+#include <time.h>
+#include <dirent.h>
+#include <unistd.h>
 #include "builtin.h"
 #include "perf.h"
 #include "util/cache.h"
@@ -17,6 +22,140 @@
 #include "util/session.h"
 #include "util/symbol.h"
 
+static int build_id_cache__kcore_buildid(const char *proc_dir, char *sbuildid)
+{
+        char root_dir[PATH_MAX];
+        char notes[PATH_MAX];
+        u8 build_id[BUILD_ID_SIZE];
+        char *p;
+
+        strlcpy(root_dir, proc_dir, sizeof(root_dir));
+
+        p = strrchr(root_dir, '/');
+        if (!p)
+                return -1;
+        *p = '\0';
+
+        scnprintf(notes, sizeof(notes), "%s/sys/kernel/notes", root_dir);
+
+        if (sysfs__read_build_id(notes, build_id, sizeof(build_id)))
+                return -1;
+
+        build_id__sprintf(build_id, sizeof(build_id), sbuildid);
+
+        return 0;
+}
+
+static int build_id_cache__kcore_dir(char *dir, size_t sz)
+{
+        struct timeval tv;
+        struct tm tm;
+        char dt[32];
+
+        if (gettimeofday(&tv, NULL) || !localtime_r(&tv.tv_sec, &tm))
+                return -1;
+
+        if (!strftime(dt, sizeof(dt), "%Y%m%d%H%M%S", &tm))
+                return -1;
+
+        scnprintf(dir, sz, "%s%02u", dt, (unsigned)tv.tv_usec / 10000);
+
+        return 0;
+}
+
+static int build_id_cache__kcore_existing(const char *from_dir, char *to_dir,
+                                          size_t to_dir_sz)
+{
+        char from[PATH_MAX];
+        char to[PATH_MAX];
+        struct dirent *dent;
+        int ret = -1;
+        DIR *d;
+
+        d = opendir(to_dir);
+        if (!d)
+                return -1;
+
+        scnprintf(from, sizeof(from), "%s/modules", from_dir);
+
+        while (1) {
+                dent = readdir(d);
+                if (!dent)
+                        break;
+                if (dent->d_type != DT_DIR)
+                        continue;
+                scnprintf(to, sizeof(to), "%s/%s/modules", to_dir,
+                          dent->d_name);
+                if (!compare_proc_modules(from, to)) {
+                        scnprintf(to, sizeof(to), "%s/%s", to_dir,
+                                  dent->d_name);
+                        strlcpy(to_dir, to, to_dir_sz);
+                        ret = 0;
+                        break;
+                }
+        }
+
+        closedir(d);
+
+        return ret;
+}
+
+static int build_id_cache__add_kcore(const char *filename, const char *debugdir)
+{
+        char dir[32], sbuildid[BUILD_ID_SIZE * 2 + 1];
+        char from_dir[PATH_MAX], to_dir[PATH_MAX];
+        char *p;
+
+        strlcpy(from_dir, filename, sizeof(from_dir));
+
+        p = strrchr(from_dir, '/');
+        if (!p || strcmp(p + 1, "kcore"))
+                return -1;
+        *p = '\0';
+
+        if (build_id_cache__kcore_buildid(from_dir, sbuildid))
+                return -1;
+
+        scnprintf(to_dir, sizeof(to_dir), "%s/[kernel.kcore]/%s",
+                  debugdir, sbuildid);
+
+        if (!build_id_cache__kcore_existing(from_dir, to_dir, sizeof(to_dir))) {
+                pr_debug("same kcore found in %s\n", to_dir);
+                return 0;
+        }
+
+        if (build_id_cache__kcore_dir(dir, sizeof(dir)))
+                return -1;
+
+        scnprintf(to_dir, sizeof(to_dir), "%s/[kernel.kcore]/%s/%s",
+                  debugdir, sbuildid, dir);
+
+        if (mkdir_p(to_dir, 0755))
+                return -1;
+
+        if (kcore_copy(from_dir, to_dir)) {
+                /* Remove YYYYmmddHHMMSShh directory */
+                if (!rmdir(to_dir)) {
+                        p = strrchr(to_dir, '/');
+                        if (p)
+                                *p = '\0';
+                        /* Try to remove buildid directory */
+                        if (!rmdir(to_dir)) {
+                                p = strrchr(to_dir, '/');
+                                if (p)
+                                        *p = '\0';
+                                /* Try to remove [kernel.kcore] directory */
+                                rmdir(to_dir);
+                        }
+                }
+                return -1;
+        }
+
+        pr_debug("kcore added to build-id cache directory %s\n", to_dir);
+
+        return 0;
+}
+
 static int build_id_cache__add_file(const char *filename, const char *debugdir)
 {
         char sbuild_id[BUILD_ID_SIZE * 2 + 1];
@@ -130,11 +269,14 @@ int cmd_buildid_cache(int argc, const char **argv,
         char const *add_name_list_str = NULL,
                    *remove_name_list_str = NULL,
                    *missing_filename = NULL,
-                   *update_name_list_str = NULL;
+                   *update_name_list_str = NULL,
+                   *kcore_filename;
 
         const struct option buildid_cache_options[] = {
         OPT_STRING('a', "add", &add_name_list_str,
                    "file list", "file(s) to add"),
+        OPT_STRING('k', "kcore", &kcore_filename,
+                   "file", "kcore file to add"),
         OPT_STRING('r', "remove", &remove_name_list_str, "file list",
                     "file(s) to remove"),
         OPT_STRING('M', "missing", &missing_filename, "file",
@@ -217,5 +359,9 @@ int cmd_buildid_cache(int argc, const char **argv,
                 }
         }
 
+        if (kcore_filename &&
+            build_id_cache__add_kcore(kcore_filename, debugdir))
+                pr_warning("Couldn't add %s\n", kcore_filename);
+
         return ret;
 }
diff --git a/tools/perf/util/symbol-elf.c b/tools/perf/util/symbol-elf.c
index 499c71d30225..d6b8af3ce344 100644
--- a/tools/perf/util/symbol-elf.c
+++ b/tools/perf/util/symbol-elf.c
@@ -1202,6 +1202,372 @@ static off_t kcore__write(struct kcore *kcore)
         return elf_update(kcore->elf, ELF_C_WRITE);
 }
 
+struct phdr_data {
+        off_t offset;
+        u64 addr;
+        u64 len;
+};
+
+struct kcore_copy_info {
+        u64 stext;
+        u64 etext;
+        u64 first_symbol;
+        u64 last_symbol;
+        u64 first_module;
+        u64 last_module_symbol;
+        struct phdr_data kernel_map;
+        struct phdr_data modules_map;
+};
+
+static int kcore_copy__process_kallsyms(void *arg, const char *name, char type,
+                                        u64 start)
+{
+        struct kcore_copy_info *kci = arg;
+
+        if (!symbol_type__is_a(type, MAP__FUNCTION))
+                return 0;
+
+        if (strchr(name, '[')) {
+                if (start > kci->last_module_symbol)
+                        kci->last_module_symbol = start;
+                return 0;
+        }
+
+        if (!kci->first_symbol || start < kci->first_symbol)
+                kci->first_symbol = start;
+
+        if (!kci->last_symbol || start > kci->last_symbol)
+                kci->last_symbol = start;
+
+        if (!strcmp(name, "_stext")) {
+                kci->stext = start;
+                return 0;
+        }
+
+        if (!strcmp(name, "_etext")) {
+                kci->etext = start;
+                return 0;
+        }
+
+        return 0;
+}
+
+static int kcore_copy__parse_kallsyms(struct kcore_copy_info *kci,
+                                      const char *dir)
+{
+        char kallsyms_filename[PATH_MAX];
+
+        scnprintf(kallsyms_filename, PATH_MAX, "%s/kallsyms", dir);
+
+        if (symbol__restricted_filename(kallsyms_filename, "/proc/kallsyms"))
+                return -1;
+
+        if (kallsyms__parse(kallsyms_filename, kci,
+                            kcore_copy__process_kallsyms) < 0)
+                return -1;
+
+        return 0;
+}
+
+static int kcore_copy__process_modules(void *arg,
+                                       const char *name __maybe_unused,
+                                       u64 start)
+{
+        struct kcore_copy_info *kci = arg;
+
+        if (!kci->first_module || start < kci->first_module)
+                kci->first_module = start;
+
+        return 0;
+}
+
+static int kcore_copy__parse_modules(struct kcore_copy_info *kci,
+                                     const char *dir)
+{
+        char modules_filename[PATH_MAX];
+
+        scnprintf(modules_filename, PATH_MAX, "%s/modules", dir);
+
+        if (symbol__restricted_filename(modules_filename, "/proc/modules"))
+                return -1;
+
+        if (modules__parse(modules_filename, kci,
+                           kcore_copy__process_modules) < 0)
+                return -1;
+
+        return 0;
+}
+
+static void kcore_copy__map(struct phdr_data *p, u64 start, u64 end, u64 pgoff,
+                            u64 s, u64 e)
+{
+        if (p->addr || s < start || s >= end)
+                return;
+
+        p->addr = s;
+        p->offset = (s - start) + pgoff;
+        p->len = e < end ? e - s : end - s;
+}
+
+static int kcore_copy__read_map(u64 start, u64 len, u64 pgoff, void *data)
+{
+        struct kcore_copy_info *kci = data;
+        u64 end = start + len;
+
+        kcore_copy__map(&kci->kernel_map, start, end, pgoff, kci->stext,
+                        kci->etext);
+
+        kcore_copy__map(&kci->modules_map, start, end, pgoff, kci->first_module,
+                        kci->last_module_symbol);
+
+        return 0;
+}
+
+static int kcore_copy__read_maps(struct kcore_copy_info *kci, Elf *elf)
+{
+        if (elf_read_maps(elf, true, kcore_copy__read_map, kci) < 0)
+                return -1;
+
+        return 0;
+}
+
+static int kcore_copy__calc_maps(struct kcore_copy_info *kci, const char *dir,
+                                 Elf *elf)
+{
+        if (kcore_copy__parse_kallsyms(kci, dir))
+                return -1;
+
+        if (kcore_copy__parse_modules(kci, dir))
+                return -1;
+
+        if (kci->stext)
+                kci->stext = round_down(kci->stext, page_size);
+        else
+                kci->stext = round_down(kci->first_symbol, page_size);
+
+        if (kci->etext) {
+                kci->etext = round_up(kci->etext, page_size);
+        } else if (kci->last_symbol) {
+                kci->etext = round_up(kci->last_symbol, page_size);
+                kci->etext += page_size;
+        }
+
+        kci->first_module = round_down(kci->first_module, page_size);
+
+        if (kci->last_module_symbol) {
+                kci->last_module_symbol = round_up(kci->last_module_symbol,
+                                                   page_size);
+                kci->last_module_symbol += page_size;
+        }
+
+        if (!kci->stext || !kci->etext)
+                return -1;
+
+        if (kci->first_module && !kci->last_module_symbol)
+                return -1;
+
+        return kcore_copy__read_maps(kci, elf);
+}
+
+static int kcore_copy__copy_file(const char *from_dir, const char *to_dir,
+                                 const char *name)
+{
+        char from_filename[PATH_MAX];
+        char to_filename[PATH_MAX];
+
+        scnprintf(from_filename, PATH_MAX, "%s/%s", from_dir, name);
+        scnprintf(to_filename, PATH_MAX, "%s/%s", to_dir, name);
+
+        return copyfile_mode(from_filename, to_filename, 0400);
+}
+
+static int kcore_copy__unlink(const char *dir, const char *name)
+{
+        char filename[PATH_MAX];
+
+        scnprintf(filename, PATH_MAX, "%s/%s", dir, name);
+
+        return unlink(filename);
+}
+
+static int kcore_copy__compare_fds(int from, int to)
+{
+        char *buf_from;
+        char *buf_to;
+        ssize_t ret;
+        size_t len;
+        int err = -1;
+
+        buf_from = malloc(page_size);
+        buf_to = malloc(page_size);
+        if (!buf_from || !buf_to)
+                goto out;
+
+        while (1) {
+                /* Use read because mmap won't work on proc files */
+                ret = read(from, buf_from, page_size);
+                if (ret < 0)
+                        goto out;
+
+                if (!ret)
+                        break;
+
+                len = ret;
+
+                if (readn(to, buf_to, len) != (int)len)
+                        goto out;
+
+                if (memcmp(buf_from, buf_to, len))
+                        goto out;
+        }
+
+        err = 0;
+out:
+        free(buf_to);
+        free(buf_from);
+        return err;
+}
+
+static int kcore_copy__compare_files(const char *from_filename,
+                                     const char *to_filename)
+{
+        int from, to, err = -1;
+
+        from = open(from_filename, O_RDONLY);
+        if (from < 0)
+                return -1;
+
+        to = open(to_filename, O_RDONLY);
+        if (to < 0)
+                goto out_close_from;
+
+        err = kcore_copy__compare_fds(from, to);
+
+        close(to);
+out_close_from:
+        close(from);
+        return err;
+}
+
+static int kcore_copy__compare_file(const char *from_dir, const char *to_dir,
+                                    const char *name)
+{
+        char from_filename[PATH_MAX];
+        char to_filename[PATH_MAX];
+
+        scnprintf(from_filename, PATH_MAX, "%s/%s", from_dir, name);
+        scnprintf(to_filename, PATH_MAX, "%s/%s", to_dir, name);
+
+        return kcore_copy__compare_files(from_filename, to_filename);
+}
+
+/**
+ * kcore_copy - copy kallsyms, modules and kcore from one directory to another.
+ * @from_dir: from directory
+ * @to_dir: to directory
+ *
+ * This function copies kallsyms, modules and kcore files from one directory to
+ * another.  kallsyms and modules are copied entirely.  Only code segments are
+ * copied from kcore.  It is assumed that two segments suffice: one for the
+ * kernel proper and one for all the modules.  The code segments are determined
+ * from kallsyms and modules files.  The kernel map starts at _stext or the
+ * lowest function symbol, and ends at _etext or the highest function symbol.
+ * The module map starts at the lowest module address and ends at the highest
+ * module symbol.  Start addresses are rounded down to the nearest page.  End
+ * addresses are rounded up to the nearest page.  An extra page is added to the
+ * highest kernel symbol and highest module symbol to, hopefully, encompass that
+ * symbol too.  Because it contains only code sections, the resulting kcore is
+ * unusual.  One significant peculiarity is that the mapping (start -> pgoff)
+ * is not the same for the kernel map and the modules map.  That happens because
+ * the data is copied adjacently whereas the original kcore has gaps.  Finally,
+ * kallsyms and modules files are compared with their copies to check that
+ * modules have not been loaded or unloaded while the copies were taking place.
+ *
+ * Return: %0 on success, %-1 on failure.
+ */
+int kcore_copy(const char *from_dir, const char *to_dir)
+{
+        struct kcore kcore;
+        struct kcore extract;
+        size_t count = 2;
+        int idx = 0, err = -1;
+        off_t offset = page_size, sz, modules_offset = 0;
+        struct kcore_copy_info kci = { .stext = 0, };
+        char kcore_filename[PATH_MAX];
+        char extract_filename[PATH_MAX];
+
+        if (kcore_copy__copy_file(from_dir, to_dir, "kallsyms"))
+                return -1;
+
+        if (kcore_copy__copy_file(from_dir, to_dir, "modules"))
+                goto out_unlink_kallsyms;
+
+        scnprintf(kcore_filename, PATH_MAX, "%s/kcore", from_dir);
+        scnprintf(extract_filename, PATH_MAX, "%s/kcore", to_dir);
+
+        if (kcore__open(&kcore, kcore_filename))
+                goto out_unlink_modules;
+
+        if (kcore_copy__calc_maps(&kci, from_dir, kcore.elf))
+                goto out_kcore_close;
+
+        if (kcore__init(&extract, extract_filename, kcore.elfclass, false))
+                goto out_kcore_close;
+
+        if (!kci.modules_map.addr)
+                count -= 1;
+
+        if (kcore__copy_hdr(&kcore, &extract, count))
+                goto out_extract_close;
+
+        if (kcore__add_phdr(&extract, idx++, offset, kci.kernel_map.addr,
+                            kci.kernel_map.len))
+                goto out_extract_close;
+
+        if (kci.modules_map.addr) {
+                modules_offset = offset + kci.kernel_map.len;
+                if (kcore__add_phdr(&extract, idx, modules_offset,
+                                    kci.modules_map.addr, kci.modules_map.len))
+                        goto out_extract_close;
+        }
+
+        sz = kcore__write(&extract);
+        if (sz < 0 || sz > offset)
+                goto out_extract_close;
+
+        if (copy_bytes(kcore.fd, kci.kernel_map.offset, extract.fd, offset,
+                       kci.kernel_map.len))
+                goto out_extract_close;
+
+        if (modules_offset && copy_bytes(kcore.fd, kci.modules_map.offset,
+                                         extract.fd, modules_offset,
+                                         kci.modules_map.len))
+                goto out_extract_close;
+
+        if (kcore_copy__compare_file(from_dir, to_dir, "modules"))
+                goto out_extract_close;
+
+        if (kcore_copy__compare_file(from_dir, to_dir, "kallsyms"))
+                goto out_extract_close;
+
+        err = 0;
+
+out_extract_close:
+        kcore__close(&extract);
+        if (err)
+                unlink(extract_filename);
+out_kcore_close:
+        kcore__close(&kcore);
+out_unlink_modules:
+        if (err)
+                kcore_copy__unlink(to_dir, "modules");
+out_unlink_kallsyms:
+        if (err)
+                kcore_copy__unlink(to_dir, "kallsyms");
+
+        return err;
+}
+
 int kcore_extract__create(struct kcore_extract *kce)
 {
         struct kcore kcore;
diff --git a/tools/perf/util/symbol-minimal.c b/tools/perf/util/symbol-minimal.c
index 928556d2508f..2d2dd0532b5a 100644
--- a/tools/perf/util/symbol-minimal.c
+++ b/tools/perf/util/symbol-minimal.c
@@ -317,6 +317,12 @@ void kcore_extract__delete(struct kcore_extract *kce __maybe_unused)
 {
 }
 
+int kcore_copy(const char *from_dir __maybe_unused,
+               const char *to_dir __maybe_unused)
+{
+        return -1;
+}
+
 void symbol__elf_init(void)
 {
 }
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index 76a9e933a7a5..b66c1eefc313 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -893,6 +893,47 @@ static int read_proc_modules(const char *filename, struct rb_root *modules)
         return 0;
 }
 
+int compare_proc_modules(const char *from, const char *to)
+{
+        struct rb_root from_modules = RB_ROOT;
+        struct rb_root to_modules = RB_ROOT;
+        struct rb_node *from_node, *to_node;
+        struct module_info *from_m, *to_m;
+        int ret = -1;
+
+        if (read_proc_modules(from, &from_modules))
+                return -1;
+
+        if (read_proc_modules(to, &to_modules))
+                goto out_delete_from;
+
+        from_node = rb_first(&from_modules);
+        to_node = rb_first(&to_modules);
+        while (from_node) {
+                if (!to_node)
+                        break;
+
+                from_m = rb_entry(from_node, struct module_info, rb_node);
+                to_m = rb_entry(to_node, struct module_info, rb_node);
+
+                if (from_m->start != to_m->start ||
+                    strcmp(from_m->name, to_m->name))
+                        break;
+
+                from_node = rb_next(from_node);
+                to_node = rb_next(to_node);
+        }
+
+        if (!from_node && !to_node)
+                ret = 0;
+
+        delete_modules(&to_modules);
+out_delete_from:
+        delete_modules(&from_modules);
+
+        return ret;
+}
+
 static int do_validate_kcore_modules(const char *filename, struct map *map,
                                   struct map_groups *kmaps)
 {
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index fb107e13e925..07de8fea2f48 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -270,4 +270,7 @@ struct kcore_extract {
 int kcore_extract__create(struct kcore_extract *kce);
 void kcore_extract__delete(struct kcore_extract *kce);
 
+int kcore_copy(const char *from_dir, const char *to_dir);
+int compare_proc_modules(const char *from, const char *to);
+
 #endif /* __PERF_SYMBOL */