d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ctf: Add definitions for CTFv3

Browse Source 
These are based on definitions added to binutils' libctf.  Specifically:
- Type IDs are now encoded in 32 bits rather than 16, changing the
  layout of ctf_type_t, ctf_array_t, ctf_member_t and ctf_lmember_t.
- Type info is encoded in 32 bits rather than 16.  The type "kind" is
  extended from 5 bits to 6, and the type "vlen" is extended from 10
  bits to 25.

The main upside is that we remove the current limit, imposed by CTFv2,
of 2^{15} distinct types in the main kernel executable.  Other limits,
such as that on the number of elements in an enum, imposed by the vlen
limit, are also raised.

This change adds v2 and v3 flavours of macros and type definitions which
differ between the two versions.  Compatibility is preserved for now by
having generic names refer to the v2 definitions, so, e.g., ctf_type_t
is still a v2 type.

No functional change intended.

Reviewed by:	Domagoj Stolfa
MFC after:	1 month
Sponsored by:	The FreeBSD Foundation
Differential Revision:	https://reviews.freebsd.org/D34360
This commit is contained in:
Mark Johnston 2022-03-07 08:44:02 -05:00
parent cab9382a2c
commit 994297b01b
2 changed files with 227 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

208
cddl/contrib/opensolaris/lib/libctf/common/ctf.5
View File

@ -11,7 +11,7 @@
.\" .\"
.\" Copyright (c) 2014 Joyent, Inc. .\" Copyright (c) 2014 Joyent, Inc.
.\" .\"
.Dd Sep 26, 2014 .Dd February 28, 2022
.Dt CTF 5 .Dt CTF 5
.Os .Os
.Sh NAME .Sh NAME
@ -65,11 +65,11 @@ data can be obtained through libctf.
The The
.Nm .Nm
file format is broken down into seven different sections. file format is broken down into seven different sections.
The first section is the The first two sections are the
.Sy preamble .Sy preamble
and and
.Sy header , .Sy header ,
which describes the version of the which describe the version of the
.Nm .Nm
file, the links it has to other file, the links it has to other
.Nm .Nm
@ -129,15 +129,22 @@ and the type information that comes from the
module. module.
This means that a module only has types that are unique to itself and the most This means that a module only has types that are unique to itself and the most
common types in the kernel are not duplicated. common types in the kernel are not duplicated.
Uniquification is not used when building kernel modules on
.Fx .
.Sh FILE FORMAT .Sh FILE FORMAT
This documents version This documents version
.Em two .Em three
of the of the
.Nm .Nm
file format. file format.
All applications and tools on The
.Fx .Xr ctfconvert 1
currently produce and operate on this version. and
.Xr ctfmerge 1
utilities emit
.Nm
version 3, and all other applications and libraries can operate on
versions 2 and 3.
.Lp .Lp
The file format can be summarized with the following image, the The file format can be summarized with the following image, the
following sections will cover this in more detail. following sections will cover this in more detail.
@ -164,7 +171,7 @@ following sections will cover this in more detail.
||||||| +-- magic - vers flags ||||||| +-- magic - vers flags
||||||| | | | | ||||||| | | | |
||||||| +------+------+------+------+ ||||||| +------+------+------+------+
+---------| 0xcf | 0xf1 | 0x02 | 0x00 | +---------| 0xcf | 0xf1 | 0x03 | 0x00 |
|||||| +------+------+------+------+ |||||| +------+------+------+------+
|||||| 0 1 2 3 4 |||||| 0 1 2 3 4
|||||| ||||||
@ -191,7 +198,7 @@ following sections will cover this in more detail.
|||| +------+------+------+-----+ |||| +------+------+------+-----+
+----------| 0x00 | 0x42 | 0x36 | ... | +----------| 0x00 | 0x42 | 0x36 | ... |
||| +------+------+------+-----+ ||| +------+------+------+-----+
||| cth_objtoff +0x2 +0x4 +0x6 cth_funcoff ||| cth_objtoff +0x4 +0x8 +0xc cth_funcoff
||| |||
||| + CTF_TYPE_INFO + CTF_TYPE_INFO ||| + CTF_TYPE_INFO + CTF_TYPE_INFO
||| | + Return type | ||| | + Return type |
@ -199,7 +206,7 @@ following sections will cover this in more detail.
||| +--------+------+------+-----+ ||| +--------+------+------+-----+
+---------| 0x2c10 | 0x08 | 0x0c | ... | +---------| 0x2c10 | 0x08 | 0x0c | ... |
|| +--------+------+------+-----+ || +--------+------+------+-----+
|| cth_funcff +0x2 +0x4 +0x6 cth_typeoff || cth_funcff +0x4 +0x8 +0xc cth_typeoff
|| ||
|| + ctf_stype_t for type 1 || + ctf_stype_t for type 1
|| | integer + integer encoding || | integer + integer encoding
@ -208,7 +215,7 @@ following sections will cover this in more detail.
|| +--------------------+-----------+-----+ || +--------------------+-----------+-----+
+--------| 0x19 * 0xc01 * 0x0 | 0x1000000 | ... | +--------| 0x19 * 0xc01 * 0x0 | 0x1000000 | ... |
| +--------------------+-----------+-----+ | +--------------------+-----------+-----+
| cth_typeoff +0x08 +0x0c cth_stroff | cth_typeoff +0x0c +0x10 cth_stroff
| |
| +--- str 0 | +--- str 0
| | +--- str 1 + str 2 | | +--- str 1 + str 2
@ -265,7 +272,7 @@ member defines the version of the
.Nm .Nm
file. file.
The current version is The current version is
.Li 2 . .Li 3 .
It is possible to encounter an unsupported version. It is possible to encounter an unsupported version.
In that case, software should not try to parse the format, as it may have In that case, software should not try to parse the format, as it may have
changed. changed.
@ -296,7 +303,7 @@ always refer to the
.Sy uncompressed .Sy uncompressed
data. data.
.Lp .Lp
In version two of the In versions two and three of the
.Nm .Nm
file format, the file format, the
.Sy header .Sy header
@ -327,7 +334,7 @@ typedef struct ctf_header {
After the After the
.Sy preamble , .Sy preamble ,
the next two members the next two members
.Em cth_parlablel .Em cth_parlabel
and and
.Em cth_parname , .Em cth_parname ,
are used to identify the parent. are used to identify the parent.
@ -364,7 +371,7 @@ file.
The difference between members indicates the size of the section itself. The difference between members indicates the size of the section itself.
Different offsets have different alignment requirements. Different offsets have different alignment requirements.
The start of the The start of the
.Em cth_objotoff .Em cth_objtoff
and and
.Em cth_funcoff .Em cth_funcoff
must be two byte aligned, while the sections must be two byte aligned, while the sections
@ -381,9 +388,9 @@ section, one should subtract the offset of the section from the following one.
For example, the size of the For example, the size of the
.Sy types .Sy types
section can be calculated by subtracting section can be calculated by subtracting
.Em cth_stroff .Em cth_typeoff
from from
.Em cth_typeoff . .Em cth_stroff .
.Lp .Lp
Finally, the member Finally, the member
.Em cth_strlen .Em cth_strlen
@ -402,16 +409,20 @@ Through the
data, types are referred to by identifiers. data, types are referred to by identifiers.
A given A given
.Nm .Nm
file supports up to 32767 (0x7fff) types. file supports up to 2147483646 (0x7ffffffe) types.
.Nm
version 2 had a much smaller limit of 32767 types.
The first valid type identifier is 0x1. The first valid type identifier is 0x1.
When a given When a given
.Nm .Nm
file is a child, indicated by a non-zero entry for the file is a child, indicated by a non-zero entry for the
.Sy header Ns 's .Sy header Ns 's
.Em cth_parname , .Em cth_parname ,
then the first valid type identifier is 0x8000 and the last is 0xffff. then the first valid type identifier is 0x80000000 and the last is 0xfffffffe.
In this case, type identifiers 0x1 through 0x7fff are references to the In this case, type identifiers 0x1 through 0x7ffffffe are references to the
parent. parent.
0x7fffffff and 0xffffffff are not treated as valid type identifiers so as to
enable the use of -1 as an error value.
.Lp .Lp
The type identifier zero is a sentinel value used to indicate that there The type identifier zero is a sentinel value used to indicate that there
is no type information available or it is an unknown type. is no type information available or it is an unknown type.
@ -444,7 +455,7 @@ container.
Every Every
.Nm .Nm
type begins with metadata encoded into a type begins with metadata encoded into a
.Sy uint16_t . .Sy uint32_t .
This encoded information tells us three different pieces of information: This encoded information tells us three different pieces of information:
.Bl -bullet -offset indent -compact .Bl -bullet -offset indent -compact
.It .It
@ -455,16 +466,9 @@ Whether this type is a root type or not
The length of the variable data The length of the variable data
.El .El
.Lp .Lp
The 16 bits that make up the encoding are broken down such that you have The 32 bits that make up the encoding are broken down into six bits
five bits for the kind, one bit for indicating whether or not it is a for the kind (bits 26 to 31), one bit for the root type flag (bit 25),
root type, and 10 bits for the variable length. and 25 bits for the length of the variable data.
This is laid out as follows:
.Bd -literal -offset indent
+--------------------+
| kind | root | vlen |
+--------------------+
15 11 10 9 0
.Ed
.Lp .Lp
The current version of the file format defines 14 different kinds. The current version of the file format defines 14 different kinds.
The interpretation of these different kinds will be discussed in the section The interpretation of these different kinds will be discussed in the section
@ -502,7 +506,7 @@ That type is not considered a
type. type.
If a type is a If a type is a
.Sy root .Sy root
type, then it will have bit 10 set. type, then it will have bit 25 set.
.Lp .Lp
The variable length section is specific to each kind and is discussed in the The variable length section is specific to each kind and is discussed in the
section section
@ -512,13 +516,13 @@ The following macros are useful for constructing and deconstructing the encoded
type information: type information:
.Bd -literal -offset indent .Bd -literal -offset indent
#define CTF_MAX_VLEN 0x3ff #define CTF_V3_MAX_VLEN 0x00ffffff
#define CTF_INFO_KIND(info) (((info) & 0xf800) >> 11) #define CTF_V3_INFO_KIND(info) (((info) & 0xfc000000) >> 26)
#define CTF_INFO_ISROOT(info) (((info) & 0x0400) >> 10) #define CTF_V3_INFO_ISROOT(info) (((info) & 0x02000000) >> 25)
#define CTF_INFO_VLEN(info) (((info) & CTF_MAX_VLEN)) #define CTF_V3_INFO_VLEN(info) (((info) & CTF_V3_MAX_VLEN))
#define CTF_TYPE_INFO(kind, isroot, vlen) \\ #define CTF_V3_TYPE_INFO(kind, isroot, vlen) \\
(((kind) << 11) | (((isroot) ? 1 : 0) << 10) | ((vlen) & CTF_MAX_VLEN)) (((kind) << 26) | (((isroot) ? 1 : 0) << 25) | ((vlen) & CTF_V3_MAX_VLEN))
.Ed .Ed
.Ss The Label Section .Ss The Label Section
When consuming When consuming
@ -536,6 +540,11 @@ releases, that they are not used together by tools, particularly when a child
needs to refer to a type in the parent. needs to refer to a type in the parent.
Because they are linked using the type identifiers, if the wrong parent is used Because they are linked using the type identifiers, if the wrong parent is used
then the wrong type will be encountered. then the wrong type will be encountered.
Note that this mechanism is not currently used on
.Fx .
In particular, kernel modules built on
.Fx
each contain a complete type graph.
.Lp .Lp
Each label is encoded in the file format using the following eight byte Each label is encoded in the file format using the following eight byte
structure: structure:
@ -573,7 +582,7 @@ The object section provides a mapping from ELF symbols of type
.Sy STT_OBJECT .Sy STT_OBJECT
in the symbol table to a type identifier. in the symbol table to a type identifier.
Every entry in this section is a Every entry in this section is a
.Sy uint16_t .Sy uint32_t
which contains a type identifier as described in the section which contains a type identifier as described in the section
.Sx Type Identifiers . .Sx Type Identifiers .
If there is no information for an object, then the type identifier 0x0 If there is no information for an object, then the type identifier 0x0
@ -617,14 +626,17 @@ section and skipping the correct symbols:
#include <stdio.h> #include <stdio.h>
/* /*
* Given the start of the object section in the CTF file, the number of symbols, * Given the start of the object section in a CTFv3 file, the number of symbols,
* and the ELF Data sections for the symbol table and the string table, this * and the ELF Data sections for the symbol table and the string table, this
* prints the type identifiers that correspond to objects. Note, a more robust * prints the type identifiers that correspond to objects. Note, a more robust
* implementation should ensure that they don't walk beyond the end of the CTF * implementation should ensure that they don't walk beyond the end of the CTF
* object section. * object section.
*
* An implementation that handles CTFv2 must take into account the fact that
* type identifiers are 16 bits wide rather than 32 bits wide.
*/ */
static int static int
walk_symbols(uint16_t *objtoff, Elf_Data *symdata, Elf_Data *strdata, walk_symbols(uint32_t *objtoff, Elf_Data *symdata, Elf_Data *strdata,
long nsyms) long nsyms)
{ {
long i; long i;
@ -667,9 +679,9 @@ Unlike with objects, because functions have a variable number of arguments, they
start with a type encoding as defined in start with a type encoding as defined in
.Sx Type Encoding , .Sx Type Encoding ,
which is the size of a which is the size of a
.Sy uint16_t . .Sy uint32_t .
For functions which have no type information available, they are encoded as For functions which have no type information available, they are encoded as
.Li CTF_TYPE_INFO(CTF_K_UNKNOWN, 0, 0) . .Li CTF_V3_TYPE_INFO(CTF_K_UNKNOWN, 0, 0) .
Functions with arguments are encoded differently. Functions with arguments are encoded differently.
Here, the variable length is turned into the number of arguments in the Here, the variable length is turned into the number of arguments in the
function. function.
@ -677,12 +689,12 @@ If a function is a
.Sy varargs .Sy varargs
type function, then the number of arguments is increased by one. type function, then the number of arguments is increased by one.
Functions with type information are encoded as: Functions with type information are encoded as:
.Li CTF_TYPE_INFO(CTF_K_FUNCTION, 0, nargs) . .Li CTF_V3_TYPE_INFO(CTF_K_FUNCTION, 0, nargs) .
.Lp .Lp
For functions that have no type information, nothing else is encoded, and the For functions that have no type information, nothing else is encoded, and the
next function is encoded. next function is encoded.
For functions with type information, the next For functions with type information, the next
.Sy uint16_t .Sy uint32_t
is encoded with the type identifier of the return type of the function. is encoded with the type identifier of the return type of the function.
It is followed by each of the type identifiers of the arguments, if any exist, It is followed by each of the type identifiers of the arguments, if any exist,
in the order that they appear in the function. in the order that they appear in the function.
@ -723,29 +735,29 @@ The base of the type information comes in two forms, a short form and a long
form, each of which may be followed by a variable number of arguments. form, each of which may be followed by a variable number of arguments.
The following definitions describe the short and long forms: The following definitions describe the short and long forms:
.Bd -literal .Bd -literal
#define CTF_MAX_SIZE 0xfffe /* max size of a type in bytes */ #define CTF_V3_MAX_SIZE 0xfffffffe /* max size of a type in bytes */
#define CTF_LSIZE_SENT 0xffff /* sentinel for ctt_size */ #define CTF_V3_LSIZE_SENT 0xffffffff /* sentinel for ctt_size */
#define CTF_MAX_LSIZE UINT64_MAX #define CTF_V3_MAX_LSIZE UINT64_MAX
typedef struct ctf_stype { struct ctf_stype_v3 {
uint32_t ctt_name; /* reference to name in string table */ uint32_t ctt_name; /* reference to name in string table */
uint16_t ctt_info; /* encoded kind, variant length */ uint32_t ctt_info; /* encoded kind, variant length */
union { union {
uint16_t _size; /* size of entire type in bytes */ uint32_t _size; /* size of entire type in bytes */
uint16_t _type; /* reference to another type */ uint32_t _type; /* reference to another type */
} _u; } _u;
} ctf_stype_t; };
typedef struct ctf_type { struct ctf_type_v3 {
uint32_t ctt_name; /* reference to name in string table */ uint32_t ctt_name; /* reference to name in string table */
uint16_t ctt_info; /* encoded kind, variant length */ uint32_t ctt_info; /* encoded kind, variant length */
union { union {
uint16_t _size; /* always CTF_LSIZE_SENT */ uint32_t _size; /* always CTF_LSIZE_SENT */
uint16_t _type; /* do not use */ uint32_t _type; /* do not use */
} _u; } _u;
uint32_t ctt_lsizehi; /* high 32 bits of type size in bytes */ uint32_t ctt_lsizehi; /* high 32 bits of type size in bytes */
uint32_t ctt_lsizelo; /* low 32 bits of type size in bytes */ uint32_t ctt_lsizelo; /* low 32 bits of type size in bytes */
} ctf_type_t; };
#define ctt_size _u._size /* for fundamental types that have a size */ #define ctt_size _u._size /* for fundamental types that have a size */
#define ctt_type _u._type /* for types that reference another type */ #define ctt_type _u._type /* for types that reference another type */
@ -754,29 +766,29 @@ typedef struct ctf_type {
Type sizes are stored in Type sizes are stored in
.Sy bytes . .Sy bytes .
The basic small form uses a The basic small form uses a
.Sy uint16_t .Sy uint32_t
to store the number of bytes. to store the number of bytes.
If the number of bytes in a structure would exceed 0xfffe, then the alternate If the number of bytes in a structure would exceed 0xfffffffe, then the
form, the alternate form, the
.Sy ctf_type_t , .Sy struct ctf_type_v3 ,
is used instead. is used instead.
To indicate that the larger form is being used, the member To indicate that the larger form is being used, the member
.Em ctt_size .Em ctt_size
is set to value of is set to value of
.Sy CTF_LSIZE_SENT .Sy CTF_V3_LSIZE_SENT
(0xffff). (0xffffffff).
In general, when going through the type section, consumers use the In general, when going through the type section, consumers use the
.Sy ctf_type_t .Sy struct ctf_type_v3
structure, but pay attention to the value of the member structure, but pay attention to the value of the member
.Em ctt_size .Em ctt_size
to determine whether they should increment their scan by the size of the to determine whether they should increment their scan by the size of
.Sy ctf_stype_t .Sy struct ctf_stype_v3
or or
.Sy ctf_type_t . .Sy struct ctf_type_v3 .
Not all kinds of types use Not all kinds of types use
.Sy ctt_size . .Sy ctt_size .
Those which do not, will always use the Those which do not, will always use the
.Sy ctf_stype_t .Sy struct ctf_stype_v3
structure. structure.
The individual sections for each kind have more information. The individual sections for each kind have more information.
.Lp .Lp
@ -798,7 +810,7 @@ The next member, the
is encoded as described in the section is encoded as described in the section
.Sx Type Encoding . .Sx Type Encoding .
The type's kind tells us how to interpret the remaining data in the The type's kind tells us how to interpret the remaining data in the
.Sy ctf_type_t .Sy struct ctf_type_v3
and any variable length data that may exist. and any variable length data that may exist.
The rest of this section will be broken down into the interpretation of the The rest of this section will be broken down into the interpretation of the
various kinds. various kinds.
@ -936,11 +948,11 @@ With arrays, the
member is set to zero. member is set to zero.
The structure that follows an array is defined as: The structure that follows an array is defined as:
.Bd -literal .Bd -literal
typedef struct ctf_array { struct ctf_array_v3 {
uint16_t cta_contents; /* reference to type of array contents */ uint32_t cta_contents; /* reference to type of array contents */
uint16_t cta_index; /* reference to type of array index */ uint32_t cta_index; /* reference to type of array index */
uint32_t cta_nelems; /* number of elements */ uint32_t cta_nelems; /* number of elements */
} ctf_array_t; };
.Ed .Ed
.Lp .Lp
The The
@ -948,7 +960,7 @@ The
and and
.Em cta_index .Em cta_index
members of the members of the
.Sy ctf_array_t .Sy struct ctf_array_v3
are type identifiers which are encoded as per the section are type identifiers which are encoded as per the section
.Sx Type Identifiers . .Sx Type Identifiers .
The member The member
@ -971,17 +983,23 @@ member is not used here.
The variable argument list contains the type identifiers for the arguments of The variable argument list contains the type identifiers for the arguments of
the function, if any. the function, if any.
Each one is represented by a Each one is represented by a
.Sy uint16_t .Sy uint32_t
and encoded according to the and encoded according to the
.Sx Type Identifiers .Sx Type Identifiers
section. section.
If the function's last argument is of type varargs, then it is also written out, If the function's last argument is of type varargs, then it is also written out,
but the type identifier is zero. but the type identifier is zero.
This is included in the count of the function's arguments. This is included in the count of the function's arguments.
An extra type identifier may follow the argument and return type identifiers In
in order to maintain four-byte alignment for the following type definition. .Nm
version 2, an extra type identifier may follow the argument and return type
identifiers in order to maintain four-byte alignment for the following type
definition.
Such a type identifier is not included in the argument count and has a value Such a type identifier is not included in the argument count and has a value
of zero. of zero.
In
.Nm
version 3, four-byte alignment occurs naturally and no padding is used.
.Ss Encoding of Structures and Unions .Ss Encoding of Structures and Unions
Structures and Unions, which are encoded with Structures and Unions, which are encoded with
.Sy CTF_K_STRUCT .Sy CTF_K_STRUCT
@ -1000,23 +1018,22 @@ is the size of the structure and union.
There are two different structures which are used to encode members in the There are two different structures which are used to encode members in the
variable list. variable list.
When the size of a structure or union is greater than or equal to the large When the size of a structure or union is greater than or equal to the large
member threshold, 8192, then a different structure is used to encode the member, member threshold, 536870912, then a different structure is used to encode the
all members are encoded using the same structure. member; all members are encoded using the same structure.
The structure for members is as follows: The structure for members is as follows:
.Bd -literal .Bd -literal
typedef struct ctf_member { struct ctf_member_v3 {
uint32_t ctm_name; /* reference to name in string table */ uint32_t ctm_name; /* reference to name in string table */
uint16_t ctm_type; /* reference to type of member */ uint32_t ctm_type; /* reference to type of member */
uint16_t ctm_offset; /* offset of this member in bits */ uint32_t ctm_offset; /* offset of this member in bits */
} ctf_member_t; };
typedef struct ctf_lmember { struct ctf_lmember_v3 {
uint32_t ctlm_name; /* reference to name in string table */ uint32_t ctlm_name; /* reference to name in string table */
uint16_t ctlm_type; /* reference to type of member */ uint32_t ctlm_type; /* reference to type of member */
uint16_t ctlm_pad; /* padding */
uint32_t ctlm_offsethi; /* high 32 bits of member offset in bits */ uint32_t ctlm_offsethi; /* high 32 bits of member offset in bits */
uint32_t ctlm_offsetlo; /* low 32 bits of member offset in bits */ uint32_t ctlm_offsetlo; /* low 32 bits of member offset in bits */
} ctf_lmember_t; };
.Ed .Ed
.Lp .Lp
Both the Both the
@ -1045,13 +1062,13 @@ at which the member begins.
Note that a compiler may lay out a type with padding. Note that a compiler may lay out a type with padding.
This means that the difference in offset between two consecutive members may be This means that the difference in offset between two consecutive members may be
larger than the size of the member. larger than the size of the member.
When the size of the overall structure is strictly less than 8192 bytes, the When the size of the overall structure is strictly less than 536870912 bytes,
normal structure, the normal structure,
.Sy ctf_member_t , .Sy struct ctf_member_v3 ,
is used and the offset in bits is stored in the member is used and the offset in bits is stored in the member
.Em ctm_offset . .Em ctm_offset .
However, when the size of the structure is greater than or equal to 8192 bytes, However, when the size of the structure is greater than or equal to 536870912
then the number of bits is split into two 32-bit quantities. bytes, then the number of bits is split into two 32-bit quantities.
One member, One member,
.Em ctlm_offsethi , .Em ctlm_offsethi ,
represents the upper 32 bits of the offset, while the other member, represents the upper 32 bits of the offset, while the other member,
@ -1114,7 +1131,7 @@ actual type in the parent, otherwise the definition may be in another
.Nm .Nm
container or may not be known at all. container or may not be known at all.
The only member of the The only member of the
.Sy ctf_type_t .Sy struct ctf_type_v3
that matters for a forward declaration is the that matters for a forward declaration is the
.Em ctt_name .Em ctt_name
which points to the name of the forward reference in the string table as which points to the name of the forward reference in the string table as
@ -1216,6 +1233,9 @@ The type of the section must be
The section should have a link set to the symbol table and its address The section should have a link set to the symbol table and its address
alignment must be 4. alignment must be 4.
.Sh SEE ALSO .Sh SEE ALSO
.Xr ctfconvert 1 ,
.Xr ctfdump 1 ,
.Xr ctfmerge 1 ,
.Xr dtrace 1 , .Xr dtrace 1 ,
.Xr elf 3 , .Xr elf 3 ,
.Xr gelf 3 , .Xr gelf 3 ,

139
sys/sys/ctf.h
View File

@ -4,6 +4,7 @@
* SPDX-License-Identifier: ISC * SPDX-License-Identifier: ISC
* *
* Copyright (c) 2016 Martin Pieuchot <mpi@openbsd.org> * Copyright (c) 2016 Martin Pieuchot <mpi@openbsd.org>
* Copyright (c) 2022 The FreeBSD Foundation
* *
* Permission to use, copy, modify, and distribute this software for any * Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above * purpose with or without fee is hereby granted, provided that the above
@ -57,16 +58,25 @@ typedef struct ctf_lblent {
__uint32_t ctl_typeidx; __uint32_t ctl_typeidx;
} ctf_lblent_t; } ctf_lblent_t;
typedef struct ctf_stype { struct ctf_stype_v2 {
__uint32_t ctt_name; __uint32_t ctt_name;
__uint16_t ctt_info; __uint16_t ctt_info;
union { union {
__uint16_t _size; __uint16_t _size;
__uint16_t _type; __uint16_t _type;
} _u; } _u;
} ctf_stype_t; };
typedef struct ctf_type { struct ctf_stype_v3 {
__uint32_t ctt_name;
__uint32_t ctt_info;
union {
__uint32_t _size;
__uint32_t _type;
} _u;
};
struct ctf_type_v2 {
__uint32_t ctt_name; __uint32_t ctt_name;
__uint16_t ctt_info; __uint16_t ctt_info;
union { union {
@ -75,32 +85,63 @@ typedef struct ctf_type {
} _u; } _u;
__uint32_t ctt_lsizehi; __uint32_t ctt_lsizehi;
__uint32_t ctt_lsizelo; __uint32_t ctt_lsizelo;
} ctf_type_t; };
struct ctf_type_v3 {
__uint32_t ctt_name;
__uint32_t ctt_info;
union {
__uint32_t _size;
__uint32_t _type;
} _u;
__uint32_t ctt_lsizehi;
__uint32_t ctt_lsizelo;
};
#define ctt_size _u._size #define ctt_size _u._size
#define ctt_type _u._type #define ctt_type _u._type
typedef struct ctf_array { struct ctf_array_v2 {
__uint16_t cta_contents; __uint16_t cta_contents;
__uint16_t cta_index; __uint16_t cta_index;
__uint32_t cta_nelems; __uint32_t cta_nelems;
} ctf_array_t; };
typedef struct ctf_member { struct ctf_array_v3 {
__uint32_t cta_contents;
__uint32_t cta_index;
__uint32_t cta_nelems;
};
struct ctf_member_v2 {
__uint32_t ctm_name; __uint32_t ctm_name;
__uint16_t ctm_type; __uint16_t ctm_type;
__uint16_t ctm_offset; __uint16_t ctm_offset;
} ctf_member_t; };
typedef struct ctf_lmember { struct ctf_member_v3 {
__uint32_t ctm_name;
__uint32_t ctm_type;
__uint32_t ctm_offset;
};
struct ctf_lmember_v2 {
__uint32_t ctlm_name; __uint32_t ctlm_name;
__uint16_t ctlm_type; __uint16_t ctlm_type;
__uint16_t ctlm_pad; __uint16_t ctlm_pad;
__uint32_t ctlm_offsethi; __uint32_t ctlm_offsethi;
__uint32_t ctlm_offsetlo; __uint32_t ctlm_offsetlo;
} ctf_lmember_t; };
#define CTF_LSTRUCT_THRESH 8192 struct ctf_lmember_v3 {
__uint32_t ctlm_name;
__uint32_t ctlm_type;
__uint32_t ctlm_offsethi;
__uint32_t ctlm_offsetlo;
};
#define CTF_V2_LSTRUCT_THRESH (1 << 13)
#define CTF_V3_LSTRUCT_THRESH (1 << 29)
typedef struct ctf_enum { typedef struct ctf_enum {
__uint32_t cte_name; __uint32_t cte_name;
@ -109,23 +150,41 @@ typedef struct ctf_enum {
#define CTF_MAGIC 0xcff1 #define CTF_MAGIC 0xcff1
#define CTF_VERSION CTF_VERSION_2 #define CTF_VERSION CTF_VERSION_2
#define CTF_VERSION_3 3
#define CTF_VERSION_2 2 #define CTF_VERSION_2 2
#define CTF_VERSION_1 1 #define CTF_VERSION_1 1
#define CTF_MAX_NAME 0x7fffffff #define CTF_MAX_NAME 0x7fffffff
#define CTF_MAX_VLEN 0x03ff
#define CTF_MAX_SIZE 0xfffe
#define CTF_LSIZE_SENT (CTF_MAX_SIZE + 1) /* sentinel for cts vs ctt */
#define CTF_PARENT_SHIFT 15 #define CTF_V2_MAX_VLEN 0x03ff
#define CTF_MAX_TYPE 0xffff #define CTF_V2_MAX_SIZE 0xfffe
#define CTF_TYPE_ISPARENT(id) ((id) < 0x8000) #define CTF_V2_LSIZE_SENT (CTF_V2_MAX_SIZE + 1) /* sentinel for cts vs ctt */
#define CTF_TYPE_ISCHILD(id) ((id) > 0x7fff)
#define CTF_TYPE_TO_INDEX(t) ((t) & 0x7fff)
#define CTF_INDEX_TO_TYPE(t, c) (((t) & 0x7fff) | ((c) != 0 ? 0x8000 : 0))
#define CTF_TYPE_INFO(k, r, l) \ #define CTF_V3_MAX_VLEN 0x00ffffff
((k) << 11) | ((r) != 0 ? (1 << 10) : 0) | ((l) & ((1 << 10) - 1)) #define CTF_V3_MAX_SIZE 0xfffffffeu
#define CTF_V3_LSIZE_SENT (CTF_V3_MAX_SIZE + 1)
#define CTF_V2_PARENT_SHIFT 15
#define CTF_V2_MAX_TYPE 0xffff
#define CTF_V2_TYPE_ISPARENT(id) ((id) < 0x8000)
#define CTF_V2_TYPE_ISCHILD(id) ((id) > 0x7fff)
#define CTF_V2_TYPE_TO_INDEX(type) ((type) & 0x7fff)
#define CTF_V2_INDEX_TO_TYPE(type, ischild) \
(((type) & 0x7fff) | ((ischild) != 0 ? 0x8000 : 0))
#define CTF_V2_TYPE_INFO(kind, isroot, vlen) \
(((kind) << 11) | ((isroot) != 0 ? (1 << 10) : 0) | \
((vlen) & CTF_V2_MAX_VLEN))
#define CTF_V3_PARENT_SHIFT 31
#define CTF_V3_MAX_TYPE 0xfffffffeu
#define CTF_V3_TYPE_ISPARENT(id) ((__uint32_t)(id) < 0x80000000u)
#define CTF_V3_TYPE_ISCHILD(id) ((__uint32_t)(id) > 0x7fffffffu)
#define CTF_V3_TYPE_TO_INDEX(type) ((type) & 0x7fffffffu)
#define CTF_V3_INDEX_TO_TYPE(type, ischild) \
(((type) & 0x7fffffffu) | ((ischild) != 0 ? 0x80000000u : 0))
#define CTF_V3_TYPE_INFO(kind, isroot, vlen) \
(((kind) << 26) | ((isroot) != 0 ? (1 << 25) : 0) | \
((vlen) & CTF_V3_MAX_VLEN))
#define CTF_STRTAB_0 0 #define CTF_STRTAB_0 0
#define CTF_STRTAB_1 1 #define CTF_STRTAB_1 1
@ -135,9 +194,14 @@ typedef struct ctf_enum {
/* /*
* Info macro. * Info macro.
*/ */
#define CTF_INFO_VLEN(i) (((i) & CTF_MAX_VLEN)) #define CTF_V2_INFO_VLEN(i) ((i) & CTF_V2_MAX_VLEN)
#define CTF_INFO_ISROOT(i) (((i) & 0x0400) >> 10) #define CTF_V2_INFO_ISROOT(i) (((i) & 0x0400) >> 10)
#define CTF_INFO_KIND(i) (((i) & 0xf800) >> 11) #define CTF_V2_INFO_KIND(i) (((i) & 0xf800) >> 11)
#define CTF_V3_INFO_VLEN(i) ((i) & CTF_V3_MAX_VLEN)
#define CTF_V3_INFO_ISROOT(i) (((i) & 0x02000000) >> 25)
#define CTF_V3_INFO_KIND(i) (((i) & 0xfc000000) >> 26)
#define CTF_K_UNKNOWN 0 #define CTF_K_UNKNOWN 0
#define CTF_K_INTEGER 1 #define CTF_K_INTEGER 1
#define CTF_K_FLOAT 2 #define CTF_K_FLOAT 2
@ -152,7 +216,7 @@ typedef struct ctf_enum {
#define CTF_K_VOLATILE 11 #define CTF_K_VOLATILE 11
#define CTF_K_CONST 12 #define CTF_K_CONST 12
#define CTF_K_RESTRICT 13 #define CTF_K_RESTRICT 13
#define CTF_K_MAX 31 #define CTF_K_MAX 63
/* /*
* Integer/Float Encoding macro. * Integer/Float Encoding macro.
@ -211,4 +275,27 @@ typedef struct ctf_enum {
#define CTF_OFFSET_TO_LMEMHI(off) ((__uint32_t)((__uint64_t)(off) >> 32)) #define CTF_OFFSET_TO_LMEMHI(off) ((__uint32_t)((__uint64_t)(off) >> 32))
#define CTF_OFFSET_TO_LMEMLO(off) ((__uint32_t)(off)) #define CTF_OFFSET_TO_LMEMLO(off) ((__uint32_t)(off))
/*
* Compatibility for pre-v3 code.
*/
typedef struct ctf_array_v2 ctf_array_t;
typedef struct ctf_member_v2 ctf_member_t;
typedef struct ctf_lmember_v2 ctf_lmember_t;
typedef struct ctf_type_v2 ctf_type_t;
typedef struct ctf_stype_v2 ctf_stype_t;
#define CTF_INFO_KIND CTF_V2_INFO_KIND
#define CTF_INFO_VLEN CTF_V2_INFO_VLEN
#define CTF_INFO_ISROOT CTF_V2_INFO_ISROOT
#define CTF_TYPE_INFO CTF_V2_TYPE_INFO
#define CTF_TYPE_ISPARENT CTF_V2_TYPE_ISPARENT
#define CTF_TYPE_ISCHILD CTF_V2_TYPE_ISCHILD
#define CTF_TYPE_TO_INDEX CTF_V2_TYPE_TO_INDEX
#define CTF_INDEX_TO_TYPE CTF_V2_INDEX_TO_TYPE
#define CTF_LSIZE_SENT CTF_V2_LSIZE_SENT
#define CTF_LSTRUCT_THRESH CTF_V2_LSTRUCT_THRESH
#define CTF_MAX_SIZE CTF_V2_MAX_SIZE
#define CTF_MAX_TYPE CTF_V2_MAX_TYPE
#define CTF_MAX_VLEN CTF_V2_MAX_VLEN
#endif /* _SYS_CTF_H_ */ #endif /* _SYS_CTF_H_ */