+++ /dev/null
-Babeltrace API documentation
-
-Babeltrace provides trace read and write libraries, as well as a trace
-converter. A plugin can be created for any trace format to allow its
-conversion to/from another trace format.
-
-The main format expected to be converted to/from is the Common Trace
-Format (CTF). The latest version of the CTF specification can be found at:
- git tree: git://git.efficios.com/ctf.git
- gitweb: http://git.efficios.com/?p=ctf.git
-
-This document describes the main concepts to use the libbabeltrace,
-which exposes the Babeltrace trace reading capability.
-
-
-TERMINOLOGY
-¯¯¯¯¯¯¯¯¯¯¯
-
-* A "callback" is a reference to a piece of executable code (such as a
- function) that is passed as an argument to another piece of code
- (like another function).
-
-* A "context" is a structure that represents an object in which a trace
- collection is opened.
-
-* An "iterator" is a structure that enables the user to traverse a trace.
-
-* A "trace handle" is a unique identifier representing a trace file.
- It allows the user to manipulate a trace directly.
-
-* The "declaration" of a field or an event, is the structure which contains
- the representaion of an object as declared in the metadata. All the
- declarations of all events and fields can be accessed as soon as the trace is
- open, but of course they contain no trace data, just the layout.
-
-* The "definition" of a field or an event is the structure in which the actual
- trace data is contained. When we read an event in the trace, we access its
- definition and we can access all the field definitions contained in all the
- scopes of this event to the get the actual data.
-
-* "Scopes" allow specifying the level at which the information about the
- current event must be fetched: event header, event payload, event context,
- stream context. Compound-type (arrays, structures, sequences and variants)
- fields are relative scopes which contain fields.
-
-
-USAGE
-¯¯¯¯¯¯
-
-Context:
-
-In order to use libbabeltrace to read a trace, the first step is to create a
-context structure and to add a trace to it. This is done using the
-bt_context_create() and bt_context_add_trace() functions. As long as this
-context structure is allocated and the trace is valid, the trace can be
-manipulated by the library.
-
-The context can be destroyed by calling one more bt_context_put() than
-bt_context_get(), functions which respectively decrement and increment the
-refcount of the context. These functions ensures that the context won't be
-destroyed when it is in use.
-
-Once a trace is added to the context, it can be read and seeked using iterators
-and callbacks.
-
-
-Iterator:
-
-An iterator can be created using the bt_iter_create() function. As of now, only
-ctf iterator are supported. These are used to traverse a ctf-formatted trace.
-Such iterators can be created with bt_ctf_iter_create().
-
-While creating an iterator, a begin and an end position may be specified. To do
-so, one or two struct bt_iter_pos must be passed. Such struct have two
-attributes: type and u. "type" is the seek type, can be either:
- BT_SEEK_TIME
- BT_SEEK_RESTORE
- BT_SEEK_CUR
- BT_SEEK_BEGIN
- BT_SEEK_END
-and "u" is a union of the seek time (if using BT_SEEK_TIME) and the restore
-position (if using BT_SEEK_RESTORE).
-
-Once the iterator is created, various functions become available. We have
-bt_ctf_iter_read_event() which returns the ctf event of the trace where the
-iterator is set. There is also bt_ctf_iter_destroy() which frees the iterator.
-Note that only one iterator can be created in a context at the same time. If
-more than one iterator is being created for the same context, the second
-creation will return NULL. The previous iterator must be destroyed before
-creation of the new iterator. In the future, creation of multiples iterators
-will be allowed.
-
-The bt_ctf_iter_read_event_flags() function has the same behaviour as
-bt_ctf_iter_read_event() but takes an additionnal flag pointer. This flag is
-used to inform the user if a special condition occured while reading the event.
-As of now, only the BT_ITER_LOST_EVENTS is handled, it informs the user that
-some events were discarded by the tracer. To get the number of events lost
-immediately prior to the last event read, the user can call the
-bt_ctf_get_lost_events_count() function.
-
-Finally, we have the bt_ctf_get_iter() function which returns a struct bt_iter
-with which the iterator can be moved using one of these functions:
- bt_iter_next(), moves the iterator to the next event
- bt_iter_set_pos(), moves the iterator to the specified position
-
-To get the current position (struct bt_iter_pos) of the iterator, the function
-bt_iter_get_pos() must be used. To create an arbitrary position based on a
-specific time, bt_iter_create_time_pos() is the function to use. The
-bt_iter_pos structure returned by these two functions must be freed with
-bt_iter_free_pos() after use.
-
-
-CTF Event:
-
-A CTF event is obtained from an iterator via the bt_ctf_iter_read_event()
-function or via the call_data parameter of a callback. To read the data of a
-CTF event :
- * bt_ctf_event_name() returns the name of the event;
- * bt_ctf_get_timestamp() returns the timestamp of the event
- offsetted with the system clock
- source (in ns);
- * bt_ctf_get_cycles() returns the timestamp of the event as
- written in the packet (in cycles).
-
-The payload of an event is divided in various scopes depending on the type of
-information. There are six top-level scopes (defined in the ctf_scope enum)
-which can be accessed by the bt_ctf_get_top_level_scope() function :
- BT_TRACE_PACKET_HEADER = 0,
- BT_STREAM_PACKET_CONTEXT = 1,
- BT_STREAM_EVENT_HEADER = 2,
- BT_STREAM_EVENT_CONTEXT = 3,
- BT_EVENT_CONTEXT = 4,
- BT_EVENT_FIELDS = 5.
-
-In order to access a field or a field list, the user needs to pass a scope as
-argument, this scope can be a top-level scope or a scope relative to an
-arbitrary field in the case of compound types (array, sequence, structure or
-variant)
-
-For more information on each scope, see the CTF specifications.
-
-The bt_ctf_get_field_list() function gives access to the list of fields in the
-current event. The bt_ctf_get_field() function gives acces to of a specific
-field of an event.
-
-The bt_ctf_get_event_decl_list() and bt_ctf_get_decl_fields() functions give
-respectively access to the list of the events declared in a trace and the list
-of the fields declared in an event.
-
-Once the field is obtained, we can obtain its name and type using the
-bt_ctf_field_name() and bt_ctf_field_type() functions respectively. The
-possible types are defined in the ctf_type_id enum:
- CTF_TYPE_UNKNOWN = 0,
- CTF_TYPE_INTEGER,
- CTF_TYPE_FLOAT,
- CTF_TYPE_ENUM,
- CTF_TYPE_STRING,
- CTF_TYPE_STRUCT,
- CTF_TYPE_UNTAGGED_VARIANT,
- CTF_TYPE_VARIANT,
- CTF_TYPE_ARRAY,
- CTF_TYPE_SEQUENCE,
- NR_CTF_TYPES.
-
-Depending on the field type, we can get informations about the field with the
-following functions:
- * bt_ctf_get_index() return the element at the index
- position of an array of a sequence;
-
- * bt_ctf_get_array_len() return the length of an array;
-
- * bt_ctf_get_int_signedness() return the signedness of an integer;
-
- * bt_ctf_get_int_base() return the base of an integer;
-
- * bt_ctf_get_int_byte_order() return the byte order of an integer;
-
- * bt_ctf_get_int_len() return the size in bits of an integer;
-
- * bt_ctf_get_encoding() return the encoding of an int or a
- string defined in the
- ctf_string_encoding enum:
- CTF_STRING_NONE = 0,
- CTF_STRING_UTF8,
- CTF_STRING_ASCII,
- CTF_STRING_UNKNOWN.
-
-All of these functions require a field declaration as parameter, depending on
-the source type of data (struct definition* or struct bt_ctf_field_decl*), the
-user might have to call bt_ctf_get_decl_from_def() or
-bt_ctf_get_decl_from_field_decl().
-
-The following functions give access to the value associated with a field
-defintion:
- * bt_ctf_get_uint64();
- * bt_ctf_get_int64();
- * bt_ctf_get_char_array();
- * bt_ctf_get_string();
- * bt_ctf_get_enum_int();
- * bt_ctf_get_enum_str().
-
-If the field does not exist or is not of the type requested, the value returned
-with these four functions is undefined. To check if an error occured, use the
-bt_ctf_field_get_error() function after accessing a field. If no error
-occured, the function will return 0.
-
-It is also possible to access the declaration fields, the same way as the
-definition ones. bt_ctf_get_event_decl_list() sets a list to an array of
-bt_ctf_event_decl pointers and bt_ctf_get_event_decl_fields() sets a list to an
-array of bt_ctf_field_decl pointers. From the first type, the name of the
-event can be obtained with bt_ctf_get_decl_event_name(). For the second type,
-the field decl name is obtained with bt_ctf_get_decl_field_name().
-
-The declaration functions allow the user to list the events, fields and
-contexts fields enabled in the trace once it is opened, whereas the definition
-functions apply on the current event being read.
-
-
-Callback:
-
-The iterator allow the user to read the trace, in order to access the events
-and fields, the user can either call the functions listed previously on each
-event, or register callbacks functions that are called when specific (or all)
-events are read.
-
-This is done with the bt_ctf_iter_add_callback() function. It requires a valid
-ctf iterator as the first argument. Here are all arguments:
- iter: trace collection iterator (input)
- event: event to target. 0 for all events.
- private_data: private data pointer to pass to the callback
- flags: specific flags controlling the behavior of this callback
- (or'd).
- callback: function pointer to call
- depends: struct bt_dependency detailing the required computation
- results. Ends with 0.
- weak_depends: struct bt_dependency detailing the optional computation
- results that can be optionally consumed by this
- callback.
- provides: struct bt_dependency detailing the computation results
- provided by this callback.
- Ends with 0.
-
-"depends", "weak_depends" and "provides" memory is handled by the babeltrace
-library after this call succeeds or fails. These objects can still be used by
-the caller until the babeltrace iterator is destroyed, but they belong to the
-babeltrace library.
-
-As of now the flags and dependencies are not used, the callbacks are
-processed in FIFO order.
-
-Note: once implemented, the dependency graph will be calculated when
-bt_ctf_iter_read_event() is executed after a bt_ctf_iter_add_callback(). It is
-valid to create/add callbacks/read/add more callbacks/read some more.
-
-The callback function passed to bt_ctf_iter_add_callback() must return a
-bt_cb_ret value:
- BT_CB_OK = 0,
- BT_CB_OK_STOP = 1,
- BT_CB_ERROR_STOP = 2,
- BT_CB_ERROR_CONTINUE = 3.
-
-
-Trace handle:
-
-When a trace is added to a context, bt_context_add_trace() returns a trace
-handle id. This id is associated with its corresponding trace handle. With
-that id, it is possible to manipulate directly the trace.
-
- * bt_trace_handle_get_path()
- -> returns the path of the trace handle (path to the trace).
-
- * bt_trace_handle_get_timestamp_begin()
- * bt_trace_handle_get_timestamp_end()
- -> return the creation/destruction timestamps (in ns or cycles
- depending on the type specified) of the buffers of a
- trace.
-
- * bt_ctf_event_get_handle_id()
- -> returns the handle id associated with an event.
-
-
-For more information on CTF, see the CTF documentation.
projects / babeltrace.git / blobdiff