include/linux/elfnote.h

   1 #ifndef _LINUX_ELFNOTE_H
   2 #define _LINUX_ELFNOTE_H
   3 /*
   4  * Helper macros to generate ELF Note structures, which are put into a
   5  * PT_NOTE segment of the final vmlinux image.  These are useful for
   6  * including name-value pairs of metadata into the kernel binary (or
   7  * modules?) for use by external programs.
   8  *
   9  * Each note has three parts: a name, a type and a desc.  The name is
  10  * intended to distinguish the note's originator, so it would be a
  11  * company, project, subsystem, etc; it must be in a suitable form for
  12  * use in a section name.  The type is an integer which is used to tag
  13  * the data, and is considered to be within the "name" namespace (so
  14  * "FooCo"'s type 42 is distinct from "BarProj"'s type 42).  The
  15  * "desc" field is the actual data.  There are no constraints on the
  16  * desc field's contents, though typically they're fairly small.
  17  *
  18  * All notes from a given NAME are put into a section named
  19  * .note.NAME.  When the kernel image is finally linked, all the notes
  20  * are packed into a single .notes section, which is mapped into the
  21  * PT_NOTE segment.  Because notes for a given name are grouped into
  22  * the same section, they'll all be adjacent the output file.
  23  *
  24  * This file defines macros for both C and assembler use.  Their
  25  * syntax is slightly different, but they're semantically similar.
  26  *
  27  * See the ELF specification for more detail about ELF notes.
  28  */
  29
  30 #ifdef __ASSEMBLER__
  31 /*
  32  * Generate a structure with the same shape as Elf{32,64}_Nhdr (which
  33  * turn out to be the same size and shape), followed by the name and
  34  * desc data with appropriate padding.  The 'desctype' argument is the
  35  * assembler pseudo op defining the type of the data e.g. .asciz while
  36  * 'descdata' is the data itself e.g.  "hello, world".
  37  *
  38  * e.g. ELFNOTE(XYZCo, 42, .asciz, "forty-two")
  39  *      ELFNOTE(XYZCo, 12, .long, 0xdeadbeef)
  40  */
  41 #define ELFNOTE_START(name, type, flags)        \
  42 .pushsection .note.name, flags,@note    ;       \
  43   .balign 4                             ;       \
  44   .long 2f - 1f         /* namesz */    ;       \
  45   .long 4484f - 3f      /* descsz */    ;       \
  46   .long type                            ;       \
  47 1:.asciz #name                          ;       \
  48 2:.balign 4                             ;       \
  49 3:
  50
  51 #define ELFNOTE_END                             \
  52 4484:.balign 4                          ;       \
  53 .popsection                             ;
  54
  55 #define ELFNOTE(name, type, desc)               \
  56         ELFNOTE_START(name, type, "")           \
  57                 desc                    ;       \
  58         ELFNOTE_END
  59
  60 #else   /* !__ASSEMBLER__ */
  61 #include <linux/elf.h>
  62 /*
  63  * Use an anonymous structure which matches the shape of
  64  * Elf{32,64}_Nhdr, but includes the name and desc data.  The size and
  65  * type of name and desc depend on the macro arguments.  "name" must
  66  * be a literal string, and "desc" must be passed by value.  You may
  67  * only define one note per line, since __LINE__ is used to generate
  68  * unique symbols.
  69  */
  70 #define _ELFNOTE_PASTE(a,b)     a##b
  71 #define _ELFNOTE(size, name, unique, type, desc)                        \
  72         static const struct {                                           \
  73                 struct elf##size##_note _nhdr;                          \
  74                 unsigned char _name[sizeof(name)]                       \
  75                 __attribute__((aligned(sizeof(Elf##size##_Word))));     \
  76                 typeof(desc) _desc                                      \
  77                              __attribute__((aligned(sizeof(Elf##size##_Word)))); \
  78         } _ELFNOTE_PASTE(_note_, unique)                                \
  79                 __used                                                  \
  80                 __attribute__((section(".note." name),                  \
  81                                aligned(sizeof(Elf##size##_Word)),       \
  82                                unused)) = {                             \
  83                 {                                                       \
  84                         sizeof(name),                                   \
  85                         sizeof(desc),                                   \
  86                         type,                                           \
  87                 },                                                      \
  88                 name,                                                   \
  89                 desc                                                    \
  90         }
  91 #define ELFNOTE(size, name, type, desc)         \
  92         _ELFNOTE(size, name, __LINE__, type, desc)
  93
  94 #define ELFNOTE32(name, type, desc) ELFNOTE(32, name, type, desc)
  95 #define ELFNOTE64(name, type, desc) ELFNOTE(64, name, type, desc)
  96 #endif  /* __ASSEMBLER__ */
  97
  98 #endif /* _LINUX_ELFNOTE_H */