doc: fix build when sphinx reports version to stderr
[dpdk.git] / buildtools / pmdinfogen / pmdinfogen.c
1 /* SPDX-License-Identifier: GPL-2.0
2  * Postprocess pmd object files to export hw support
3  *
4  * Copyright 2016 Neil Horman <nhorman@tuxdriver.com>
5  * Based in part on modpost.c from the linux kernel
6  */
7
8 #include <stdio.h>
9 #include <ctype.h>
10 #include <string.h>
11 #include <limits.h>
12 #include <stdbool.h>
13 #include <errno.h>
14 #include <libgen.h>
15
16 #include <rte_common.h>
17 #include "pmdinfogen.h"
18
19 #ifdef RTE_ARCH_64
20 #define ADDR_SIZE 64
21 #else
22 #define ADDR_SIZE 32
23 #endif
24
25 static int use_stdin, use_stdout;
26
27 static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)
28 {
29         if (sym)
30                 return elf->strtab + sym->st_name;
31         else
32                 return "(unknown)";
33 }
34
35 static void *grab_file(const char *filename, unsigned long *size)
36 {
37         struct stat st;
38         void *map = MAP_FAILED;
39         int fd = -1;
40
41         if (!use_stdin) {
42                 fd = open(filename, O_RDONLY);
43                 if (fd < 0)
44                         return NULL;
45         } else {
46                 /* from stdin, use a temporary file to mmap */
47                 FILE *infile;
48                 char buffer[1024];
49                 int n;
50
51                 infile = tmpfile();
52                 if (infile == NULL) {
53                         perror("tmpfile");
54                         return NULL;
55                 }
56                 fd = dup(fileno(infile));
57                 fclose(infile);
58                 if (fd < 0)
59                         return NULL;
60
61                 n = read(STDIN_FILENO, buffer, sizeof(buffer));
62                 while (n > 0) {
63                         if (write(fd, buffer, n) != n)
64                                 goto failed;
65                         n = read(STDIN_FILENO, buffer, sizeof(buffer));
66                 }
67         }
68
69         if (fstat(fd, &st))
70                 goto failed;
71
72         *size = st.st_size;
73         map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
74
75 failed:
76         close(fd);
77         if (map == MAP_FAILED)
78                 return NULL;
79         return map;
80 }
81
82 /**
83   * Return a copy of the next line in a mmap'ed file.
84   * spaces in the beginning of the line is trimmed away.
85   * Return a pointer to a static buffer.
86   **/
87 static void release_file(void *file, unsigned long size)
88 {
89         munmap(file, size);
90 }
91
92
93 static void *get_sym_value(struct elf_info *info, const Elf_Sym *sym)
94 {
95         return RTE_PTR_ADD(info->hdr,
96                 info->sechdrs[sym->st_shndx].sh_offset + sym->st_value);
97 }
98
99 static Elf_Sym *find_sym_in_symtab(struct elf_info *info,
100                                    const char *name, Elf_Sym *last)
101 {
102         Elf_Sym *idx;
103         if (last)
104                 idx = last+1;
105         else
106                 idx = info->symtab_start;
107
108         for (; idx < info->symtab_stop; idx++) {
109                 const char *n = sym_name(info, idx);
110                 if (!strncmp(n, name, strlen(name)))
111                         return idx;
112         }
113         return NULL;
114 }
115
116 static int parse_elf(struct elf_info *info, const char *filename)
117 {
118         unsigned int i;
119         Elf_Ehdr *hdr;
120         Elf_Shdr *sechdrs;
121         Elf_Sym  *sym;
122         int endian;
123         unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U;
124
125         hdr = grab_file(filename, &info->size);
126         if (!hdr) {
127                 perror(filename);
128                 exit(1);
129         }
130         info->hdr = hdr;
131         if (info->size < sizeof(*hdr)) {
132                 /* file too small, assume this is an empty .o file */
133                 return 0;
134         }
135         /* Is this a valid ELF file? */
136         if ((hdr->e_ident[EI_MAG0] != ELFMAG0) ||
137             (hdr->e_ident[EI_MAG1] != ELFMAG1) ||
138             (hdr->e_ident[EI_MAG2] != ELFMAG2) ||
139             (hdr->e_ident[EI_MAG3] != ELFMAG3)) {
140                 /* Not an ELF file - silently ignore it */
141                 return 0;
142         }
143
144         if (!hdr->e_ident[EI_DATA]) {
145                 /* Unknown endian */
146                 return 0;
147         }
148
149         endian = hdr->e_ident[EI_DATA];
150
151         /* Fix endianness in ELF header */
152         hdr->e_type      = TO_NATIVE(endian, 16, hdr->e_type);
153         hdr->e_machine   = TO_NATIVE(endian, 16, hdr->e_machine);
154         hdr->e_version   = TO_NATIVE(endian, 32, hdr->e_version);
155         hdr->e_entry     = TO_NATIVE(endian, ADDR_SIZE, hdr->e_entry);
156         hdr->e_phoff     = TO_NATIVE(endian, ADDR_SIZE, hdr->e_phoff);
157         hdr->e_shoff     = TO_NATIVE(endian, ADDR_SIZE, hdr->e_shoff);
158         hdr->e_flags     = TO_NATIVE(endian, 32, hdr->e_flags);
159         hdr->e_ehsize    = TO_NATIVE(endian, 16, hdr->e_ehsize);
160         hdr->e_phentsize = TO_NATIVE(endian, 16, hdr->e_phentsize);
161         hdr->e_phnum     = TO_NATIVE(endian, 16, hdr->e_phnum);
162         hdr->e_shentsize = TO_NATIVE(endian, 16, hdr->e_shentsize);
163         hdr->e_shnum     = TO_NATIVE(endian, 16, hdr->e_shnum);
164         hdr->e_shstrndx  = TO_NATIVE(endian, 16, hdr->e_shstrndx);
165
166         sechdrs = RTE_PTR_ADD(hdr, hdr->e_shoff);
167         info->sechdrs = sechdrs;
168
169         /* Check if file offset is correct */
170         if (hdr->e_shoff > info->size) {
171                 fprintf(stderr, "section header offset=%lu in file '%s' "
172                       "is bigger than filesize=%lu\n",
173                       (unsigned long)hdr->e_shoff,
174                       filename, info->size);
175                 return 0;
176         }
177
178         if (hdr->e_shnum == SHN_UNDEF) {
179                 /*
180                  * There are more than 64k sections,
181                  * read count from .sh_size.
182                  */
183                 info->num_sections =
184                         TO_NATIVE(endian, ADDR_SIZE, sechdrs[0].sh_size);
185         } else {
186                 info->num_sections = hdr->e_shnum;
187         }
188         if (hdr->e_shstrndx == SHN_XINDEX)
189                 info->secindex_strings =
190                         TO_NATIVE(endian, 32, sechdrs[0].sh_link);
191         else
192                 info->secindex_strings = hdr->e_shstrndx;
193
194         /* Fix endianness in section headers */
195         for (i = 0; i < info->num_sections; i++) {
196                 sechdrs[i].sh_name      =
197                         TO_NATIVE(endian, 32, sechdrs[i].sh_name);
198                 sechdrs[i].sh_type      =
199                         TO_NATIVE(endian, 32, sechdrs[i].sh_type);
200                 sechdrs[i].sh_flags     =
201                         TO_NATIVE(endian, 32, sechdrs[i].sh_flags);
202                 sechdrs[i].sh_addr      =
203                         TO_NATIVE(endian, ADDR_SIZE, sechdrs[i].sh_addr);
204                 sechdrs[i].sh_offset    =
205                         TO_NATIVE(endian, ADDR_SIZE, sechdrs[i].sh_offset);
206                 sechdrs[i].sh_size      =
207                         TO_NATIVE(endian, ADDR_SIZE, sechdrs[i].sh_size);
208                 sechdrs[i].sh_link      =
209                         TO_NATIVE(endian, 32, sechdrs[i].sh_link);
210                 sechdrs[i].sh_info      =
211                         TO_NATIVE(endian, 32, sechdrs[i].sh_info);
212                 sechdrs[i].sh_addralign =
213                         TO_NATIVE(endian, ADDR_SIZE, sechdrs[i].sh_addralign);
214                 sechdrs[i].sh_entsize   =
215                         TO_NATIVE(endian, ADDR_SIZE, sechdrs[i].sh_entsize);
216         }
217         /* Find symbol table. */
218         for (i = 1; i < info->num_sections; i++) {
219                 int nobits = sechdrs[i].sh_type == SHT_NOBITS;
220
221                 if (!nobits && sechdrs[i].sh_offset > info->size) {
222                         fprintf(stderr, "%s is truncated. "
223                               "sechdrs[i].sh_offset=%lu > sizeof(*hrd)=%zu\n",
224                               filename, (unsigned long)sechdrs[i].sh_offset,
225                               sizeof(*hdr));
226                         return 0;
227                 }
228
229                 if (sechdrs[i].sh_type == SHT_SYMTAB) {
230                         unsigned int sh_link_idx;
231                         symtab_idx = i;
232                         info->symtab_start = RTE_PTR_ADD(hdr,
233                                 sechdrs[i].sh_offset);
234                         info->symtab_stop  = RTE_PTR_ADD(hdr,
235                                 sechdrs[i].sh_offset + sechdrs[i].sh_size);
236                         sh_link_idx = sechdrs[i].sh_link;
237                         info->strtab       = RTE_PTR_ADD(hdr,
238                                 sechdrs[sh_link_idx].sh_offset);
239                 }
240
241                 /* 32bit section no. table? ("more than 64k sections") */
242                 if (sechdrs[i].sh_type == SHT_SYMTAB_SHNDX) {
243                         symtab_shndx_idx = i;
244                         info->symtab_shndx_start = RTE_PTR_ADD(hdr,
245                                 sechdrs[i].sh_offset);
246                         info->symtab_shndx_stop  = RTE_PTR_ADD(hdr,
247                                 sechdrs[i].sh_offset + sechdrs[i].sh_size);
248                 }
249         }
250         if (!info->symtab_start)
251                 fprintf(stderr, "%s has no symtab?\n", filename);
252         else {
253                 /* Fix endianness in symbols */
254                 for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {
255                         sym->st_shndx = TO_NATIVE(endian, 16, sym->st_shndx);
256                         sym->st_name  = TO_NATIVE(endian, 32, sym->st_name);
257                         sym->st_value = TO_NATIVE(endian, ADDR_SIZE, sym->st_value);
258                         sym->st_size  = TO_NATIVE(endian, ADDR_SIZE, sym->st_size);
259                 }
260         }
261
262         if (symtab_shndx_idx != ~0U) {
263                 Elf32_Word *p;
264                 if (symtab_idx != sechdrs[symtab_shndx_idx].sh_link)
265                         fprintf(stderr,
266                               "%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n",
267                               filename, sechdrs[symtab_shndx_idx].sh_link,
268                               symtab_idx);
269                 /* Fix endianness */
270                 for (p = info->symtab_shndx_start; p < info->symtab_shndx_stop;
271                      p++)
272                         *p = TO_NATIVE(endian, 32, *p);
273         }
274
275         return 1;
276 }
277
278 static void parse_elf_finish(struct elf_info *info)
279 {
280         struct pmd_driver *tmp, *idx = info->drivers;
281         release_file(info->hdr, info->size);
282         while (idx) {
283                 tmp = idx->next;
284                 free(idx);
285                 idx = tmp;
286         }
287 }
288
289 struct opt_tag {
290         const char *suffix;
291         const char *json_id;
292 };
293
294 static const struct opt_tag opt_tags[] = {
295         {"_param_string_export", "params"},
296         {"_kmod_dep_export", "kmod"},
297 };
298
299 static int complete_pmd_entry(struct elf_info *info, struct pmd_driver *drv)
300 {
301         const char *tname;
302         int i;
303         char tmpsymname[128];
304         Elf_Sym *tmpsym;
305
306         drv->name = get_sym_value(info, drv->name_sym);
307
308         for (i = 0; i < PMD_OPT_MAX; i++) {
309                 memset(tmpsymname, 0, 128);
310                 sprintf(tmpsymname, "__%s%s", drv->name, opt_tags[i].suffix);
311                 tmpsym = find_sym_in_symtab(info, tmpsymname, NULL);
312                 if (!tmpsym)
313                         continue;
314                 drv->opt_vals[i] = get_sym_value(info, tmpsym);
315         }
316
317         memset(tmpsymname, 0, 128);
318         sprintf(tmpsymname, "__%s_pci_tbl_export", drv->name);
319
320         tmpsym = find_sym_in_symtab(info, tmpsymname, NULL);
321
322
323         /*
324          * If this returns NULL, then this is a PMD_VDEV, because
325          * it has no pci table reference
326          */
327         if (!tmpsym) {
328                 drv->pci_tbl = NULL;
329                 return 0;
330         }
331
332         tname = get_sym_value(info, tmpsym);
333         tmpsym = find_sym_in_symtab(info, tname, NULL);
334         if (!tmpsym)
335                 return -ENOENT;
336
337         drv->pci_tbl = (struct rte_pci_id *)get_sym_value(info, tmpsym);
338         if (!drv->pci_tbl)
339                 return -ENOENT;
340
341         return 0;
342 }
343
344 static int locate_pmd_entries(struct elf_info *info)
345 {
346         Elf_Sym *last = NULL;
347         struct pmd_driver *new;
348
349         info->drivers = NULL;
350
351         do {
352                 new = calloc(sizeof(struct pmd_driver), 1);
353                 if (new == NULL) {
354                         fprintf(stderr, "Failed to calloc memory\n");
355                         return -1;
356                 }
357                 new->name_sym = find_sym_in_symtab(info, "this_pmd_name", last);
358                 last = new->name_sym;
359                 if (!new->name_sym)
360                         free(new);
361                 else {
362                         if (complete_pmd_entry(info, new)) {
363                                 fprintf(stderr,
364                                         "Failed to complete pmd entry\n");
365                                 free(new);
366                         } else {
367                                 new->next = info->drivers;
368                                 info->drivers = new;
369                         }
370                 }
371         } while (last);
372
373         return 0;
374 }
375
376 static void output_pmd_info_string(struct elf_info *info, char *outfile)
377 {
378         FILE *ofd;
379         struct pmd_driver *drv;
380         struct rte_pci_id *pci_ids;
381         int idx = 0;
382
383         if (use_stdout)
384                 ofd = stdout;
385         else {
386                 ofd = fopen(outfile, "w+");
387                 if (!ofd) {
388                         fprintf(stderr, "Unable to open output file\n");
389                         return;
390                 }
391         }
392
393         drv = info->drivers;
394
395         while (drv) {
396                 fprintf(ofd, "const char %s_pmd_info[] __attribute__((used)) = "
397                         "\"PMD_INFO_STRING= {",
398                         drv->name);
399                 fprintf(ofd, "\\\"name\\\" : \\\"%s\\\", ", drv->name);
400
401                 for (idx = 0; idx < PMD_OPT_MAX; idx++) {
402                         if (drv->opt_vals[idx])
403                                 fprintf(ofd, "\\\"%s\\\" : \\\"%s\\\", ",
404                                         opt_tags[idx].json_id,
405                                         drv->opt_vals[idx]);
406                 }
407
408                 pci_ids = drv->pci_tbl;
409                 fprintf(ofd, "\\\"pci_ids\\\" : [");
410
411                 while (pci_ids && pci_ids->device_id) {
412                         fprintf(ofd, "[%d, %d, %d, %d]",
413                                 pci_ids->vendor_id, pci_ids->device_id,
414                                 pci_ids->subsystem_vendor_id,
415                                 pci_ids->subsystem_device_id);
416                         pci_ids++;
417                         if (pci_ids->device_id)
418                                 fprintf(ofd, ",");
419                         else
420                                 fprintf(ofd, " ");
421                 }
422                 fprintf(ofd, "]}\";\n");
423                 drv = drv->next;
424         }
425
426         fclose(ofd);
427 }
428
429 int main(int argc, char **argv)
430 {
431         struct elf_info info = {0};
432         int rc = 1;
433
434         if (argc < 3) {
435                 fprintf(stderr,
436                         "usage: %s <object file> <c output file>\n",
437                         basename(argv[0]));
438                 exit(127);
439         }
440         use_stdin = !strcmp(argv[1], "-");
441         use_stdout = !strcmp(argv[2], "-");
442         parse_elf(&info, argv[1]);
443
444         if (locate_pmd_entries(&info) < 0)
445                 exit(1);
446
447         if (info.drivers) {
448                 output_pmd_info_string(&info, argv[2]);
449                 rc = 0;
450         } else {
451                 fprintf(stderr, "No drivers registered\n");
452         }
453
454         parse_elf_finish(&info);
455         exit(rc);
456 }