Page MenuHomeFreeBSD
Differential D24566 Diff 78522 contrib/elftoolchain/readelf/readelf.c

Changeset View

Standalone View

View Options

contrib/elftoolchain/readelf/readelf.c

Show All 40 Lines
#include <libgen.h> #include <libgen.h>
#include <stdarg.h> #include <stdarg.h>
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <time.h> #include <time.h>
#include <unistd.h> #include <unistd.h>
#include <zlib.h>
#include <libcasper.h> #include <libcasper.h>
#include <casper/cap_fileargs.h> #include <casper/cap_fileargs.h>
#include "_elftc.h" #include "_elftc.h"
ELFTC_VCSID("$Id: readelf.c 3769 2019-06-29 15:15:02Z emaste $"); ELFTC_VCSID("$Id: readelf.c 3769 2019-06-29 15:15:02Z emaste $");
Show All 25 Lines
#define RE_SS 0x00002000 #define RE_SS 0x00002000
#define RE_S 0x00004000 #define RE_S 0x00004000
#define RE_T 0x00008000 #define RE_T 0x00008000
#define RE_U 0x00010000 #define RE_U 0x00010000
#define RE_VV 0x00020000 #define RE_VV 0x00020000
#define RE_WW 0x00040000 #define RE_WW 0x00040000
#define RE_W 0x00080000 #define RE_W 0x00080000
#define RE_X 0x00100000 #define RE_X 0x00100000
#define RE_Z 0x00200000
/* /*
* dwarf dump options. * dwarf dump options.
*/ */
#define DW_A 0x00000001 #define DW_A 0x00000001
#define DW_FF 0x00000002 #define DW_FF 0x00000002
#define DW_F 0x00000004 #define DW_F 0x00000004
#define DW_I 0x00000008 #define DW_I 0x00000008
▲ Show 20 Lines • Show All 86 Lines • ▼ Show 20 Linesenum options
OPTION_DEBUG_DUMP OPTION_DEBUG_DUMP
}; };
static struct option longopts[] = { static struct option longopts[] = {
{"all", no_argument, NULL, 'a'}, {"all", no_argument, NULL, 'a'},
{"arch-specific", no_argument, NULL, 'A'}, {"arch-specific", no_argument, NULL, 'A'},
{"archive-index", no_argument, NULL, 'c'}, {"archive-index", no_argument, NULL, 'c'},
{"debug-dump", optional_argument, NULL, OPTION_DEBUG_DUMP}, {"debug-dump", optional_argument, NULL, OPTION_DEBUG_DUMP},
{"decompress", no_argument, 0, 'z'},
{"dynamic", no_argument, NULL, 'd'}, {"dynamic", no_argument, NULL, 'd'},
{"file-header", no_argument, NULL, 'h'}, {"file-header", no_argument, NULL, 'h'},
{"full-section-name", no_argument, NULL, 'N'}, {"full-section-name", no_argument, NULL, 'N'},
{"headers", no_argument, NULL, 'e'}, {"headers", no_argument, NULL, 'e'},
{"help", no_argument, 0, 'H'}, {"help", no_argument, 0, 'H'},
{"hex-dump", required_argument, NULL, 'x'}, {"hex-dump", required_argument, NULL, 'x'},
{"histogram", no_argument, NULL, 'I'}, {"histogram", no_argument, NULL, 'I'},
{"notes", no_argument, NULL, 'n'}, {"notes", no_argument, NULL, 'n'},
{"program-headers", no_argument, NULL, 'l'}, {"program-headers", no_argument, NULL, 'l'},
{"relocs", no_argument, NULL, 'r'}, {"relocs", no_argument, NULL, 'r'},
{"sections", no_argument, NULL, 'S'}, {"sections", no_argument, NULL, 'S'},
{"section-headers", no_argument, NULL, 'S'}, {"section-headers", no_argument, NULL, 'S'},
{"section-groups", no_argument, NULL, 'g'}, {"section-groups", no_argument, NULL, 'g'},
{"section-details", no_argument, NULL, 't'}, {"section-details", no_argument, NULL, 't'},
{"segments", no_argument, NULL, 'l'}, {"segments", no_argument, NULL, 'l'},
{"string-dump", required_argument, NULL, 'p'}, {"string-dump", required_argument, NULL, 'p'},
{"symbols", no_argument, NULL, 's'}, {"symbols", no_argument, NULL, 's'},
{"syms", no_argument, NULL, 's'}, {"syms", no_argument, NULL, 's'},
{"unwind", no_argument, NULL, 'u'}, {"unwind", no_argument, NULL, 'u'},
{"use-dynamic", no_argument, NULL, 'D'}, {"use-dynamic", no_argument, NULL, 'D'},
{"version-info", no_argument, 0, 'V'}, {"version-info", no_argument, 0, 'V'},
{"version", no_argument, 0, 'v'}, {"version", no_argument, 0, 'v'},
{"wide", no_argument, 0, 'W'}, {"wide", no_argument, 0, 'W'},
{NULL, 0, NULL, 0} {NULL, 0, NULL, 0}
emasteUnsubmitted
Done
Inline Actions

in contrast to the comment above these were already sorted by long option name, so this one should be added in order

emaste: in contrast to the comment above these were already sorted by long option name, so this one…
}; };
struct eflags_desc { struct eflags_desc {
uint64_t flag; uint64_t flag;
const char *desc; const char *desc;
}; };
struct flag_desc { struct flag_desc {
▲ Show 20 Lines • Show All 6,604 Lines • ▼ Show 20 Lines if ((data = elf_getdata(s->scn, NULL)) == NULL) {
return (0); return (0);
} }
if (gelf_getsym(data, i, &sym) != &sym) if (gelf_getsym(data, i, &sym) != &sym)
return (0); return (0);
return (sym.st_value); return (sym.st_value);
} }
/*
* Decompress a data section if needed (using ZLIB).
*/
static int decompress_section(struct section *s, unsigned char **buffer,
uint64_t *sz) {
emasteUnsubmitted
Done
Inline Actions

{ goes on next line

readelf.c is trickier to deal with using clang-format because much of the existing code is non-compliant. Clang has a tool for formatting just a patch:

http://clang.llvm.org/docs/ClangFormat.html#script-for-patch-reformatting

emaste: `{` goes on next line readelf.c is trickier to deal with using clang-format because much of…
GElf_Shdr sh;
if (gelf_getshdr(s->scn, &sh) == NULL)
errx(EXIT_FAILURE, "gelf_getshdr() failed: %s", elf_errmsg(-1));
emasteUnsubmitted
Done
Inline Actions

does not need wrapping

emaste: does not need wrapping
if (sh.sh_flags & SHF_COMPRESSED) {
int ret;
GElf_Chdr chdr;
Elf64_Xword compressed_size;
unsigned char *compressed_data_buffer = NULL;
Elf64_Xword inflated_size;
unsigned char *uncompressed_data_buffer = NULL;
Elf64_Xword uncompressed_size;
z_stream strm;
if (gelf_getchdr(s->scn, &chdr) == NULL)
errx(EXIT_FAILURE, "gelf_getchdr() failed: %s", elf_errmsg(-1));
if (chdr.ch_type != ELFCOMPRESS_ZLIB)
goto fail;
emasteUnsubmitted
Done
Inline Actions

indentation

emaste: indentation
markjUnsubmitted
Done
Inline Actions

Why do we goto fail here but call errx() in the error case immediately above?

markj: Why do we `goto fail` here but call `errx()` in the error case immediately above?
tig_freebsdfoundation.orgAuthorUnsubmitted
Done
Inline Actions

Now that I looked at it, it makes more sense to warn the user that compression type is not supported. Would that be a reasonable way to address this?

tig_freebsdfoundation.org: Now that I looked at it, it makes more sense to warn the user that compression type is not…
markjUnsubmitted
Done
Inline Actions

Something like "unknown compression type: %d"? Or perhaps I don't understand your question.

markj: Something like "unknown compression type: %d"? Or perhaps I don't understand your question.
tig_freebsdfoundation.orgAuthorUnsubmitted
Done
Inline Actions

That makes sense. I'll use this format.

tig_freebsdfoundation.org: That makes sense. I'll use this format.
compressed_data_buffer = *buffer;
emasteUnsubmitted
Done
Inline Actions

indentation

emaste: indentation
compressed_size = *sz;
inflated_size = 0;
uncompressed_size = chdr.ch_size;
uncompressed_data_buffer = malloc(uncompressed_size);
compressed_data_buffer += sizeof(chdr);
compressed_size -= sizeof(chdr);
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
strm.opaque = Z_NULL;
strm.avail_in = compressed_size;
strm.avail_out = uncompressed_size;
ret = inflateInit(&strm);
if (ret != Z_OK)
goto fail;
/*
* The section can contain several compressed buffers,
* so decompress in a loop until all data is inflated.
*/
emasteUnsubmitted
Done
Inline Actions

extra EOL whitespace

emaste: extra EOL whitespace
while (inflated_size < compressed_size) {
strm.next_in = compressed_data_buffer + inflated_size;
strm.next_out = uncompressed_data_buffer + inflated_size;
ret = inflate(&strm, Z_FINISH);
if (ret != Z_STREAM_END) {
goto fail;
}
inflated_size = uncompressed_size - strm.avail_out;
ret = inflateReset(&strm);
if (ret != Z_OK)
goto fail;
}
if (strm.avail_out != 0) {
goto fail;
}
ret = inflateEnd(&strm);
if (ret != Z_OK)
goto fail;
free(*buffer);
markjUnsubmitted
Not Done
Inline Actions

So this frees the buffer passed by the caller, in one case it's d_buf from a libelf data descriptor. In other words, we are making assumptions about how libelf is allocating data buffers and that seems a bit fragile. I think it would be better for this function not to make any such assumptions and avoid replacing the input buffer with the output buffer. Just malloc() and return the output buffer (and its size) using separate parameters.

markj: So this frees the buffer passed by the caller, in one case it's `d_buf` from a libelf data…
tig_freebsdfoundation.orgAuthorUnsubmitted
Done
Inline Actions

One question I have about this is if the decompression is unsuccessful, do we want to pass back the original buffer and size or just check the return value from the caller side?

tig_freebsdfoundation.org: One question I have about this is if the decompression is unsuccessful, do we want to pass back…
markjUnsubmitted
Not Done
Inline Actions

I think it's better to simply have the caller check the return value and decide which buffer to use. It's a bit more code, but not much, and is easier to follow. The caller has to know whether to free the returned buffer anyway.

markj: I think it's better to simply have the caller check the return value and decide which buffer to…
*buffer = uncompressed_data_buffer;
*sz = uncompressed_size;
return (1);
fail:
free(uncompressed_data_buffer);
warnx("decompress_section failed: %s", elf_errmsg(-1));
markjUnsubmitted
Not Done
Inline Actions

All of the error paths that lead to the fail label do not result from a libelf error, so I believe elf_errmsg() will give you garbage here.

markj: All of the error paths that lead to the `fail` label do not result from a libelf error, so I…
tig_freebsdfoundation.orgAuthorUnsubmitted
Not Done
Inline Actions

I can see that now. Would it be good if I just warnx("decompress_section failed")? I'm not experienced in producing error messages would appreciate any suggestions.

tig_freebsdfoundation.org: I can see that now. Would it be good if I just warnx("decompress_section failed")? I'm not…
markjUnsubmitted
Not Done
Inline Actions

Per the zlib documentation, strm.msg will be set to an error string upon a failure, so you could print that. I would suggest checking it for NULL and just printing the error number in that case as a robustness measure.

markj: Per the zlib documentation, `strm.msg` will be set to an error string upon a failure, so you…
tig_freebsdfoundation.orgAuthorUnsubmitted
Not Done
Inline Actions

Could you specify what you mean by "checking it for NULL and just printing the error number"? I'm not sure which error number you are referring to

tig_freebsdfoundation.org: Could you specify what you mean by "checking it for NULL and just printing the error number"?
markjUnsubmitted
Not Done
Inline Actions

When reporting errors from zlib, you can print strm.msg as part of the error description. I'm not sure that it is guaranteed to be set for all errors (it would be worth reviewing the zlib docs), in which case you could print the error number that you had compared with Z_OK.

markj: When reporting errors from zlib, you can print `strm.msg` as part of the error description. I'm…
tig_freebsdfoundation.orgAuthorUnsubmitted
Not Done
Inline Actions

I looked at zlib manual and it seems like strm.msg handles most errors. In the rare case where there is an error but strm.msg is NULL printing the error number would be helpful.

tig_freebsdfoundation.org: I looked at zlib manual and it seems like strm.msg handles most errors. In the rare case where…
return (0);
}
return (1);
markjUnsubmitted
Done
Inline Actions

I think you want to call inflateEnd() as part of the cleanup here.

Also the indentation looks wrong; goto labels should not have any indentation.

markj: I think you want to call inflateEnd() as part of the cleanup here. Also the indentation looks…
}
static void static void
hex_dump(struct readelf *re) hex_dump(struct readelf *re)
{ {
struct section *s; struct section *s;
Elf_Data *d; Elf_Data *d;
uint8_t *buf; uint8_t *buf;
size_t sz, nbytes; size_t sz, nbytes;
uint64_t addr; uint64_t addr;
int elferr, i, j; int elferr, i, j;
for (i = 1; (size_t) i < re->shnum; i++) { for (i = 1; (size_t) i < re->shnum; i++) {
emasteUnsubmitted
Done
Inline Actions

extra blank line

emaste: extra blank line
s = &re->sl[i]; s = &re->sl[i];
if (find_dumpop(re, (size_t) i, s->name, HEX_DUMP, -1) == NULL) if (find_dumpop(re, (size_t) i, s->name, HEX_DUMP, -1) == NULL)
continue; continue;
(void) elf_errno(); (void) elf_errno();
if ((d = elf_getdata(s->scn, NULL)) == NULL && if ((d = elf_getdata(s->scn, NULL)) == NULL &&
(d = elf_rawdata(s->scn, NULL)) == NULL) { (d = elf_rawdata(s->scn, NULL)) == NULL) {
elferr = elf_errno(); elferr = elf_errno();
if (elferr != 0) if (elferr != 0)
warnx("elf_getdata failed: %s", warnx("elf_getdata failed: %s",
elf_errmsg(elferr)); elf_errmsg(elferr));
continue; continue;
} }
(void) elf_errno(); (void) elf_errno();
if (d->d_size <= 0 || d->d_buf == NULL) { if (d->d_size <= 0 || d->d_buf == NULL) {
printf("\nSection '%s' has no data to dump.\n", printf("\nSection '%s' has no data to dump.\n",
s->name); s->name);
continue; continue;
} }
addr = s->addr;
if (re->options & RE_Z) {
decompress_section(s, (unsigned char **) &d->d_buf, &d->d_size);
markjUnsubmitted
Done
Inline Actions

We are not checking the return value here. If it should be ignored, add a (void) cast of the return value - that's the conventional way to indicate that the return value is being ignored deliberately.

markj: We are not checking the return value here. If it should be ignored, add a `(void)` cast of the…
}
buf = d->d_buf; buf = d->d_buf;
sz = d->d_size; sz = d->d_size;
addr = s->addr;
printf("\nHex dump of section '%s':\n", s->name); printf("\nHex dump of section '%s':\n", s->name);
while (sz > 0) { while (sz > 0) {
printf(" 0x%8.8jx ", (uintmax_t)addr); printf(" 0x%8.8jx ", (uintmax_t)addr);
nbytes = sz > 16? 16 : sz; nbytes = sz > 16? 16 : sz;
for (j = 0; j < 16; j++) { for (j = 0; j < 16; j++) {
if ((size_t)j < nbytes) if ((size_t)j < nbytes)
printf("%2.2x", buf[j]); printf("%2.2x", buf[j]);
else else
Show All 38 Lines if ((d = elf_getdata(s->scn, NULL)) == NULL &&
continue; continue;
} }
(void) elf_errno(); (void) elf_errno();
if (d->d_size <= 0 || d->d_buf == NULL) { if (d->d_size <= 0 || d->d_buf == NULL) {
printf("\nSection '%s' has no data to dump.\n", printf("\nSection '%s' has no data to dump.\n",
s->name); s->name);
continue; continue;
} }
buf_end = (unsigned char *) d->d_buf + d->d_size;
start = (unsigned char *) d->d_buf;
found = 0; found = 0;
if (re->options & RE_Z) {
decompress_section(s, (unsigned char **) &d->d_buf, &d->d_size);
}
start = (unsigned char *) d->d_buf;
buf_end = start + d->d_size;
printf("\nString dump of section '%s':\n", s->name); printf("\nString dump of section '%s':\n", s->name);
for (;;) { for (;;) {
while (start < buf_end && !isprint(*start)) while (start < buf_end && !isprint(*start))
start++; start++;
if (start >= buf_end) if (start >= buf_end)
break; break;
end = start + 1; end = start + 1;
while (end < buf_end && isprint(*end)) while (end < buf_end && isprint(*end))
▲ Show 20 Lines • Show All 663 Lines • ▼ Show 20 Linesmain(int argc, char **argv)
unsigned long si; unsigned long si;
int fd, opt, i; int fd, opt, i;
char *ep; char *ep;
re = &re_storage; re = &re_storage;
memset(re, 0, sizeof(*re)); memset(re, 0, sizeof(*re));
STAILQ_INIT(&re->v_dumpop); STAILQ_INIT(&re->v_dumpop);
while ((opt = getopt_long(argc, argv, "AacDdegHhIi:lNnp:rSstuVvWw::x:", while ((opt = getopt_long(argc, argv, "AacDdegHhIi:lNnp:rSstuVvWw::x:z",
longopts, NULL)) != -1) { longopts, NULL)) != -1) {
switch(opt) { switch(opt) {
case '?': case '?':
readelf_usage(EXIT_SUCCESS); readelf_usage(EXIT_SUCCESS);
break; break;
case 'A': case 'A':
re->options |= RE_AA; re->options |= RE_AA;
break; break;
▲ Show 20 Lines • Show All 79 Lines • ▼ Show 20 Lines case 'x':
re->options |= RE_X; re->options |= RE_X;
si = strtoul(optarg, &ep, 10); si = strtoul(optarg, &ep, 10);
if (*ep == '\0') if (*ep == '\0')
add_dumpop(re, (size_t) si, NULL, HEX_DUMP, add_dumpop(re, (size_t) si, NULL, HEX_DUMP,
DUMP_BY_INDEX); DUMP_BY_INDEX);
else else
add_dumpop(re, 0, optarg, HEX_DUMP, add_dumpop(re, 0, optarg, HEX_DUMP,
DUMP_BY_NAME); DUMP_BY_NAME);
break;
case 'z':
re->options |= RE_Z;
break; break;
case OPTION_DEBUG_DUMP: case OPTION_DEBUG_DUMP:
re->options |= RE_W; re->options |= RE_W;
parse_dwarf_op_long(re, optarg); parse_dwarf_op_long(re, optarg);
} }
} }
argv += optind; argv += optind;
Show All 40 Lines