elfnote

QNX SDP8.0Utilities ReferenceUtilities

Display or modify the contents of an ELF note (QNX)

Syntax:

elfnote -p [-n name] [-q] [-t type] [-v] file

elfnote [-p] [-n name] [-t type] [-F fmt] -m value [-vq] file [outfile]

elfnote [-pv] [-S size] [-q][-x [exec | noexec]] file [outfile]

Runs on:

QNX OS, Linux, Microsoft Windows

Options:

-F fmt
Specifies how to interpret the elements of the -m option's argument.
  • x — The element at the corresponding position in the value string is interpreted as a hexadecimal representation of raw data. For example, if the note description contains numeric types, they must be given in the correct target endian order and represented in hexadecimal bytes. This is the default format if you specify -m.
  • n — The element at the corresponding position in the value string is interpreted as an unsigned integer with an optional size suffix (k, m, or g). The value can be specified as a decimal, octal (0...), or hexadecimal (0x...) number. The number is automatically converted to the correct endian order. This is the default format if you specify -S.
-m value
Modify the contents of the note, where value is a string that specifies a series of elements separated by a comma. Take the note format for QNT_STACK, for example, which consists of three fields:
  • The total size
  • The pre-allocated size
  • Whether the stack is executable
Thus, a 64K stack, 32K pre-allocated, non-executable note takes the form:
elfnote -nQNX -tQNT_STACK -Fn -m 64k,32k,1 file
The -F option determines how the individual elements are interpreted. Each -F option value specifies the conversion of one element in value; if the format string has fewer characters than there are elements in value, the format is applied repeatedly.
-n name
The note name to match.
-p
Display (print) the notes. If you also use -t to specify a note type, elfnote displays only that type of notes; otherwise, elfnote displays all the notes. If you specify the -m option, elfnote displays the value before modification.
-q
Quiet operation. Do not print warning or error messages.
-S size
The stack size. This option implies -n QNX, -t QNT_STACK, and -Fn.
-t type
The note type to match. Acceptable values are numbers or the following types (defined in <elfdefinitions.h>). When you specify defined types, -n GNU or -n QNX is implied. . The following symbolic names can be used with -t:
  • NT_GNU_BUILD_ID
  • QNT_DEBUG_FULLPATH
  • QNT_DEBUG_RELOC
  • QNT_STACK
  • QNT_GENERATOR
  • QNT_DEFAULT_LIB
  • QNT_CORE_SYSINFO
  • QNT_CORE_INFO
  • QNT_CORE_STATUS
  • QNT_CORE_GREG
  • QNT_CORE_FPREG
  • QNT_LINK_MAP — you can use coreinfo to display this note in core files.

You typically use elfnote to modify QNT_STACK, as described below.

-v
Increase verbosity.
-x [exec | noexec]
Specify whether to update the QNT_STACK note in the binary to request an executable stack:
  • exec — Update the binary to request an executable stack.
  • noexec — Update the binary to request a non-executable stack (the default for newly built binaries).
You can use this option on its own or combine it with -S to update the stack size as well. If you don't specify -S, the stack executability changes but the stack size does not.
Use -S and -x for the simplest setting of stack parameters.
  • Change stack to be executable, preserving existing size and allocation values:
    elfnote -x exec file
  • Change stack to be non-executable, preserving existing size and allocation values:
    elfnote -x noexec file

Description:

The elfnote utility displays or modifies the contents of a note in an Executable and Linkable Format file.

When you modify the contents of a note, you must specify -t. If -t does not specify a defined type, the note name is not implied and you must also specify -n.

Note:
  • You can't change the size of a note, only its contents.
  • Setting a stack size that's insufficient for the startup of the process, including space for arguments and environment variables (limited by _SC_ARG_MAX or ARG_MAX), may cause unexpected early failures of the process execution.
  • You must specify at least one of the following options: -p, -m, -S or -x; otherwise, elfnote fails.

Examples:

For ldrel-compatible behavior, use -S. For example, the following command allocates a stack size of 128k at thread creation time:
elfnote -S 128k file
The following examples explain how to modify QNT_STACK to set stack size and stack alloc using:
  • a raw hexadecimal value (either comma-separated or not), the equivalent command is:
    elfnote -t QNT_STACK -Fx -m 00,00,02,00,00,10,00,00,01,00,00,00 filename
  • a numeric format, the equivalent commands are:
    elfnote -S 131072 -x noexec filename elfnote -t QNT_STACK -Fn -m stack size,stack prealloc size,flags filename
    The only current flag is QNX_STACK_NOTEXECUTABLE 1.
    Note:
    Apply the n format string repeatedly to parse the individual, comma-separated numeric elements.
  • a mixed format, the equivalent commands are:
    elfnote -n QNX -t QNT_STACK -m 000002000010000001000000 filename
    elfnote -t QNT_STACK -Fx -m 00,00,02,00,00,10,00,00,01,00,00,00 filename
    elfnote -t QNT_STACK -Fn -m 128K,4K,1 filename
The following example assumes you have a binary containing a note with a name SP_NOTE and type 9, consisting of the four 32-bit values, 100, 200, 300, and 400. To display the note:
# elfnote -p -n SP_NOTE file
Note name = SP_NOTE, type = 9
        hex         : 64000000c80000002c01000090010000
Change the values to 16, 32, 48 and 64:
elfnote -n SP_NOTE -t 9 -F n -m 16,32,48,64 file
Display the changed note:
# elfnote -p -n SP_NOTE file
Note name = SP_NOTE, type = 9
        hex         : 10000000200000003000000040000000
Change the value back to the original by specifying a hex string:
elfnote -n SP_NOTE -t 9 -m 64000000c80000002c01000090010000 file
Display the result again:
# elfnote -p -n SP_NOTE file
Note name = SP_NOTE, type = 9
        hex         : 64000000c80000002c01000090010000
Page updated: