One Level Up Top Level

userspace/kp_symbol.c - ktap

Global variables defined

Functions defined

Macros defined

Source code

  1. /*
  2. * symbol.c
  3. *
  4. * This file is part of ktap by Jovi Zhangwei.
  5. *
  6. * Copyright (C) 2013 Azat Khuzhin <a3at.mail@gmail.com>.
  7. *
  8. * ktap is free software; you can redistribute it and/or modify it
  9. * under the terms and conditions of the GNU General Public License,
  10. * version 2, as published by the Free Software Foundation.
  11. *
  12. * ktap is distributed in the hope it will be useful, but WITHOUT
  13. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14. * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15. * more details.
  16. *
  17. * You should have received a copy of the GNU General Public License along with
  18. * this program; if not, write to the Free Software Foundation, Inc.,
  19. * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  20. */

  22. #include <stdio.h>
  23. #include <stdlib.h>

  25. #include <sys/types.h>
  26. #include <sys/stat.h>
  27. #include <unistd.h>
  28. #include <fcntl.h>
  29. #include <string.h>
  30. #include <linux/limits.h>

  32. #include <libelf.h>

  34. #include "../include/ktap_types.h"
  35. #include "kp_symbol.h"

  37. ‌const char *dbg_link_name = ".gnu_debuglink";
  38. ‌const char *dbg_bin_dir = "/usr/lib/debug";

  40. ‌static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
  41.                     GElf_Shdr *shp, const char *name)
  42. {
  43.     Elf_Scn *scn = NULL;

  45.     /* Elf is corrupted/truncated, avoid calling elf_strptr. */
  46.     if (!elf_rawdata(elf_getscn(elf, ep->e_shstrndx), NULL))
  47.         return NULL;

  49.     while ((scn = elf_nextscn(elf, scn)) != NULL) {
  50.         char *str;

  52.         gelf_getshdr(scn, shp);
  53.         str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
  54.         if (!strcmp(name, str))
  55.             break;
  56.     }

  58.     return scn;
  59. }

  61. /**
  62. * @return v_addr of "LOAD" program header, that have zero offset.
  63. */
  64. ‌static int find_load_address(Elf *elf, vaddr_t *load_address)
  65. {
  66.     GElf_Phdr phdr;
  67.     size_t i, phdrnum;

  69.     if (elf_getphdrnum(elf, &phdrnum))
  70.         return -1;

  72.     for (i = 0; i < phdrnum; i++) {
  73.         if (gelf_getphdr(elf, i, &phdr) == NULL)
  74.             return -1;

  76.         if (phdr.p_type != PT_LOAD || phdr.p_offset != 0)
  77.             continue;

  79.         *load_address = phdr.p_vaddr;
  80.         return 0;
  81.     }

  83.     /* cannot found load address */
  84.     return -1;
  85. }

  87. ‌static size_t elf_symbols(GElf_Shdr shdr)
  88. {
  89.     return shdr.sh_size / shdr.sh_entsize;
  90. }

  92. ‌static int dso_symbols(Elf *elf, symbol_actor actor, void *arg)
  93. {
  94.     Elf_Data *elf_data = NULL;
  95.     Elf_Scn *scn = NULL;
  96.     GElf_Sym sym;
  97.     GElf_Shdr shdr;
  98.     int symbols_count = 0;
  99.     vaddr_t load_address;

  101.     if (find_load_address(elf, &load_address))
  102.         return -1;

  104.     while ((scn = elf_nextscn(elf, scn))) {
  105.         int i;

  107.         gelf_getshdr(scn, &shdr);

  109.         if (shdr.sh_type != SHT_SYMTAB)
  110.             continue;

  112.         elf_data = elf_getdata(scn, elf_data);

  114.         for (i = 0; i < elf_symbols(shdr); i++) {
  115.             char *name;
  116.             vaddr_t addr;
  117.             int ret;

  119.             gelf_getsym(elf_data, i, &sym);

  121.             if (GELF_ST_TYPE(sym.st_info) != STT_FUNC)
  122.                 continue;

  124.             name = elf_strptr(elf, shdr.sh_link, sym.st_name);
  125.             addr = sym.st_value - load_address;

  127.             ret = actor(name, addr, arg);
  128.             if (ret)
  129.                 return ret;

  131.             ++symbols_count;
  132.         }
  133.     }

  135.     return symbols_count;
  136. }

  138. ‌#define SDT_NOTE_TYPE 3
  139. ‌#define SDT_NOTE_COUNT 3
  140. ‌#define SDT_NOTE_SCN ".note.stapsdt"
  141. ‌#define SDT_NOTE_NAME "stapsdt"

  143. ‌static vaddr_t sdt_note_addr(Elf *elf, const char *data, size_t len, int type)
  144. {
  145.     vaddr_t vaddr;

  147.     /*
  148.      * Three addresses need to be obtained :
  149.      * Marker location, address of base section and semaphore location
  150.      */
  151.     union {
  152.         Elf64_Addr a64[3];
  153.         Elf32_Addr a32[3];
  154.     } buf;

  156.     /*
  157.      * dst and src are required for translation from file to memory
  158.      * representation
  159.      */
  160.     Elf_Data dst = {
  161.         .d_buf = &buf, .d_type = ELF_T_ADDR, .d_version = EV_CURRENT,
  162.         .d_size = gelf_fsize(elf, ELF_T_ADDR, SDT_NOTE_COUNT, EV_CURRENT),
  163.         .d_off = 0, .d_align = 0
  164.     };

  166.     Elf_Data src = {
  167.         .d_buf = (void *) data, .d_type = ELF_T_ADDR,
  168.         .d_version = EV_CURRENT, .d_size = dst.d_size, .d_off = 0,
  169.         .d_align = 0
  170.     };

  172.     /* Check the type of each of the notes */
  173.     if (type != SDT_NOTE_TYPE)
  174.         return 0;

  176.     if (len < dst.d_size + SDT_NOTE_COUNT)
  177.         return 0;

  179.     /* Translation from file representation to memory representation */
  180.     if (gelf_xlatetom(elf, &dst, &src,
  181.               elf_getident(elf, NULL)[EI_DATA]) == NULL)
  182.         return 0; /* TODO */

  184.     memcpy(&vaddr, &buf, sizeof(vaddr));

  186.     return vaddr;
  187. }

  189. ‌static const char *sdt_note_name(Elf *elf, GElf_Nhdr *nhdr, const char *data)
  190. {
  191.     const char *provider = data + gelf_fsize(elf,
  192.         ELF_T_ADDR, SDT_NOTE_COUNT, EV_CURRENT);
  193.     const char *name = (const char *)memchr(provider, '\0',
  194.         data + nhdr->n_descsz - provider);

  196.     if (name++ == NULL)
  197.         return NULL;

  199.     return name;
  200. }

  202. ‌static const char *sdt_note_data(const Elf_Data *data, size_t off)
  203. {
  204.     return ((data->d_buf) + off);
  205. }

  207. ‌static int dso_sdt_notes(Elf *elf, symbol_actor actor, void *arg)
  208. {
  209.     GElf_Ehdr ehdr;
  210.     Elf_Scn *scn = NULL;
  211.     Elf_Data *data;
  212.     GElf_Shdr shdr;
  213.     size_t shstrndx;
  214.     size_t next;
  215.     GElf_Nhdr nhdr;
  216.     size_t name_off, desc_off, offset;
  217.     vaddr_t vaddr = 0;
  218.     int symbols_count = 0;

  220.     if (gelf_getehdr(elf, &ehdr) == NULL)
  221.         return 0;
  222.     if (elf_getshdrstrndx(elf, &shstrndx) != 0)
  223.         return 0;

  225.     /*
  226.      * Look for section type = SHT_NOTE, flags = no SHF_ALLOC
  227.      * and name = .note.stapsdt
  228.      */
  229.     scn = elf_section_by_name(elf, &ehdr, &shdr, SDT_NOTE_SCN);
  230.     if (!scn)
  231.         return 0;
  232.     if (!(shdr.sh_type == SHT_NOTE) || (shdr.sh_flags & SHF_ALLOC))
  233.         return 0;

  235.     data = elf_getdata(scn, NULL);

  237.     for (offset = 0;
  238.         (next = gelf_getnote(data, offset, &nhdr, &name_off, &desc_off)) > 0;
  239.         offset = next) {
  240.         const char *name;
  241.         int ret;

  243.         if (nhdr.n_namesz != sizeof(SDT_NOTE_NAME) ||
  244.             memcmp(data->d_buf + name_off, SDT_NOTE_NAME,
  245.                 sizeof(SDT_NOTE_NAME)))
  246.             continue;

  248.         name = sdt_note_name(elf, &nhdr, sdt_note_data(data, desc_off));
  249.         if (!name)
  250.             continue;

  252.         vaddr = sdt_note_addr(elf, sdt_note_data(data, desc_off),
  253.                     nhdr.n_descsz, nhdr.n_type);
  254.         if (!vaddr)
  255.             continue;

  257.         ret = actor(name, vaddr, arg);
  258.         if (ret)
  259.             return ret;

  261.         ++symbols_count;
  262.     }

  264.     return symbols_count;
  265. }

  267. ‌int dso_follow_debuglink(Elf *elf,
  268.              const char *orig_exec,
  269.              int type,
  270.              symbol_actor actor,
  271.              void *arg)
  272. {
  273.     GElf_Ehdr ehdr;
  274.     size_t shstrndx, orig_exec_dir_len;
  275.     GElf_Shdr shdr;
  276.     Elf_Scn *dbg_link_scn;
  277.     Elf_Data *dbg_link_scn_data;
  278.     char *dbg_link, *dbg_bin, *last_slash;
  279.     int symbols_count;

  281.     /* First try to find the .gnu_debuglink section in the binary. */
  282.     if (gelf_getehdr(elf, &ehdr) == NULL)
  283.         return 0;
  284.     if (elf_getshdrstrndx(elf, &shstrndx) != 0)
  285.         return 0;

  287.     dbg_link_scn = elf_section_by_name(elf, &ehdr, &shdr, dbg_link_name);
  288.     if (dbg_link_scn == NULL)
  289.         return 0;

  291.     /* Debug link section found, read of the content (only get the first
  292.        string, no checksum checking atm). This is debug binary file name. */
  293.     dbg_link_scn_data = elf_getdata(dbg_link_scn, NULL);
  294.     if (dbg_link_scn_data == NULL ||
  295.         dbg_link_scn_data->d_size <= 0 ||
  296.         dbg_link_scn_data->d_buf == NULL)
  297.         return 0;

  299.     /* Now compose debug executable name */
  300.     dbg_link = (char *)(dbg_link_scn_data->d_buf);
  301.     dbg_bin = malloc(strlen(dbg_bin_dir) + 1 +
  302.              strlen(orig_exec) + 1 +
  303.              strlen(dbg_link) + 1);
  304.     if (!dbg_bin)
  305.         return 0;

  307.     orig_exec_dir_len = PATH_MAX;
  308.     last_slash = strrchr(orig_exec, '/');
  309.     if (last_slash != NULL)
  310.         orig_exec_dir_len = last_slash - orig_exec;

  312.     sprintf(dbg_bin, "%s/%.*s/%s",
  313.         dbg_bin_dir, (int)orig_exec_dir_len, orig_exec, dbg_link);

  315.     /* Retry symbol seach with the debug binary */
  316.     symbols_count = parse_dso_symbols(dbg_bin, type, actor, arg);

  318.     free(dbg_bin);

  320.     return symbols_count;
  321. }

  323. ‌int parse_dso_symbols(const char *exec, int type, symbol_actor actor, void *arg)
  324. {
  325.     int symbols_count = 0;
  326.     Elf *elf;
  327.     int fd;

  329.     if (elf_version(EV_CURRENT) == EV_NONE)
  330.         return -1;

  332.     fd = open(exec, O_RDONLY);
  333.     if (fd < 0)
  334.         return -1;

  336.     elf = elf_begin(fd, ELF_C_READ, NULL);
  337.     if (elf) {
  338.         switch (type) {
  339.         case FIND_SYMBOL:
  340.             symbols_count = dso_symbols(elf, actor, arg);
  341.             if (symbols_count != 0)
  342.                 break;
  343.             /* If no symbols found, try in the debuglink binary. */
  344.             symbols_count = dso_follow_debuglink(elf,
  345.                                  exec,
  346.                                  type,
  347.                                  actor,
  348.                                  arg);
  349.             break;
  350.         case FIND_STAPSDT_NOTE:
  351.             symbols_count = dso_sdt_notes(elf, actor, arg);
  352.             break;
  353.         }

  355.         elf_end(elf);
  356.     }

  358.     close(fd);
  359.     return symbols_count;
  360. }

One Level Up Top Level