1 /*
   2  * This file and its contents are supplied under the terms of the
   3  * Common Development and Distribution License ("CDDL"), version 1.0.
   4  * You may only use this file in accordance with the terms of version
   5  * 1.0 of the CDDL.
   6  *
   7  * A full copy of the text of the CDDL should have accompanied this
   8  * source.  A copy of the CDDL is also available via the Internet at
   9  * http://www.illumos.org/license/CDDL.
  10  */
  11 
  12 /*
  13  * Copyright 2019 Joyent, Inc.
  14  */
  15 
  16 /*
  17  * Main conversion entry points. This has been designed such that there can be
  18  * any number of different conversion backends. Currently we only have one that
  19  * understands DWARFv2 (and bits of DWARFv4). Each backend should be placed in
  20  * the ctf_converters list and each will be tried in turn.
  21  */
  22 
  23 #include <libctf_impl.h>
  24 #include <gelf.h>
  25 
  26 ctf_convert_f ctf_converters[] = {
  27         ctf_dwarf_convert
  28 };
  29 
  30 #define NCONVERTS       (sizeof (ctf_converters) / sizeof (ctf_convert_f))
  31 
  32 typedef enum ctf_convert_source {
  33         CTFCONV_SOURCE_NONE = 0x0,
  34         CTFCONV_SOURCE_UNKNOWN = 0x01,
  35         CTFCONV_SOURCE_C = 0x02,
  36         CTFCONV_SOURCE_S = 0x04
  37 } ctf_convert_source_t;
  38 
  39 static void
  40 ctf_convert_ftypes(Elf *elf, ctf_convert_source_t *types)
  41 {
  42         int i;
  43         Elf_Scn *scn = NULL, *strscn;
  44         *types = CTFCONV_SOURCE_NONE;
  45         GElf_Shdr shdr;
  46         Elf_Data *data, *strdata;
  47 
  48         while ((scn = elf_nextscn(elf, scn)) != NULL) {
  49 
  50                 if (gelf_getshdr(scn, &shdr) == NULL)
  51                         return;
  52 
  53                 if (shdr.sh_type == SHT_SYMTAB)
  54                         break;
  55         }
  56 
  57         if (scn == NULL)
  58                 return;
  59 
  60         if ((strscn = elf_getscn(elf, shdr.sh_link)) == NULL)
  61                 return;
  62 
  63         if ((data = elf_getdata(scn, NULL)) == NULL)
  64                 return;
  65 
  66         if ((strdata = elf_getdata(strscn, NULL)) == NULL)
  67                 return;
  68 
  69         for (i = 0; i < shdr.sh_size / shdr.sh_entsize; i++) {
  70                 GElf_Sym sym;
  71                 const char *file;
  72                 size_t len;
  73 
  74                 if (gelf_getsym(data, i, &sym) == NULL)
  75                         return;
  76 
  77                 if (GELF_ST_TYPE(sym.st_info) != STT_FILE)
  78                         continue;
  79 
  80                 file = (const char *)((uintptr_t)strdata->d_buf + sym.st_name);
  81                 len = strlen(file);
  82                 if (len < 2 || file[len - 2] != '.') {
  83                         *types |= CTFCONV_SOURCE_UNKNOWN;
  84                         continue;
  85                 }
  86 
  87                 switch (file[len - 1]) {
  88                 case 'c':
  89                         *types |= CTFCONV_SOURCE_C;
  90                         break;
  91                 case 'h':
  92                         /* We traditionally ignore header files... */
  93                         break;
  94                 case 's':
  95                         *types |= CTFCONV_SOURCE_S;
  96                         break;
  97                 default:
  98                         *types |= CTFCONV_SOURCE_UNKNOWN;
  99                         break;
 100                 }
 101         }
 102 }
 103 
 104 static ctf_file_t *
 105 ctf_elfconvert(int fd, Elf *elf, const char *label, uint_t nthrs, uint_t flags,
 106     int *errp, char *errbuf, size_t errlen)
 107 {
 108         int err, i;
 109         ctf_file_t *fp = NULL;
 110         boolean_t notsup = B_TRUE;
 111         ctf_convert_source_t type;
 112 
 113         if (errp == NULL)
 114                 errp = &err;
 115 
 116         if (elf == NULL) {
 117                 *errp = EINVAL;
 118                 return (NULL);
 119         }
 120 
 121         if (flags & ~CTF_CONVERT_F_IGNNONC) {
 122                 *errp = EINVAL;
 123                 return (NULL);
 124         }
 125 
 126         if (elf_kind(elf) != ELF_K_ELF) {
 127                 *errp = ECTF_FMT;
 128                 return (NULL);
 129         }
 130 
 131         ctf_convert_ftypes(elf, &type);
 132         ctf_dprintf("got types: %d\n", type);
 133         if (flags & CTF_CONVERT_F_IGNNONC) {
 134                 if (type == CTFCONV_SOURCE_NONE ||
 135                     (type & CTFCONV_SOURCE_UNKNOWN)) {
 136                         *errp = ECTF_CONVNOCSRC;
 137                         return (NULL);
 138                 }
 139         }
 140 
 141         for (i = 0; i < NCONVERTS; i++) {
 142                 ctf_conv_status_t cs;
 143 
 144                 fp = NULL;
 145                 cs = ctf_converters[i](fd, elf, nthrs, errp, &fp, errbuf,
 146                     errlen);
 147                 if (cs == CTF_CONV_SUCCESS) {
 148                         notsup = B_FALSE;
 149                         break;
 150                 }
 151                 if (cs == CTF_CONV_ERROR) {
 152                         fp = NULL;
 153                         notsup = B_FALSE;
 154                         break;
 155                 }
 156         }
 157 
 158         if (notsup == B_TRUE) {
 159                 if ((flags & CTF_CONVERT_F_IGNNONC) != 0 &&
 160                     (type & CTFCONV_SOURCE_C) == 0) {
 161                         *errp = ECTF_CONVNOCSRC;
 162                         return (NULL);
 163                 }
 164                 *errp = ECTF_NOCONVBKEND;
 165                 return (NULL);
 166         }
 167 
 168         /*
 169          * Succsesful conversion.
 170          */
 171         if (fp != NULL && label != NULL) {
 172                 if (ctf_add_label(fp, label, fp->ctf_typemax, 0) == CTF_ERR) {
 173                         *errp = ctf_errno(fp);
 174                         ctf_close(fp);
 175                         return (NULL);
 176                 }
 177                 if (ctf_update(fp) == CTF_ERR) {
 178                         *errp = ctf_errno(fp);
 179                         ctf_close(fp);
 180                         return (NULL);
 181                 }
 182         }
 183 
 184         return (fp);
 185 }
 186 
 187 ctf_file_t *
 188 ctf_fdconvert(int fd, const char *label, uint_t nthrs, uint_t flags, int *errp,
 189     char *errbuf, size_t errlen)
 190 {
 191         int err;
 192         Elf *elf;
 193         ctf_file_t *fp;
 194 
 195         if (errp == NULL)
 196                 errp = &err;
 197 
 198         elf = elf_begin(fd, ELF_C_READ, NULL);
 199         if (elf == NULL) {
 200                 *errp = ECTF_FMT;
 201                 return (NULL);
 202         }
 203 
 204         fp = ctf_elfconvert(fd, elf, label, nthrs, flags, errp, errbuf, errlen);
 205 
 206         (void) elf_end(elf);
 207         return (fp);
 208 }