Lines Matching full:be
11 Tracepoints (see Documentation/trace/tracepoints.rst) can be used
15 Not all tracepoints can be traced using the event tracing system;
18 tracing information should be printed.
26 The events which are available for tracing can be found in the file
52 file. All of the events in a subsystem can be specified via the syntax
58 The set_event file may also be used to enable events associated to only
64 loaded, the string will be saved and when a module is that matches ``<module>``
67 The text before ``:mod:`` will be parsed to specify specific events that the
131 be used to parse the binary trace stream, and is also the place to
132 find the field names that can be used in event filters (see section 5).
134 It also displays the format string that will be used to print the
180 Trace events can be filtered in the kernel by associating boolean
185 values don't match will be discarded. An event with no filter
192 A filter expression consists of one or more 'predicates' that can be
200 Parentheses can be used to provide arbitrary logical groupings and
201 double-quotes can be used to prevent the shell from interpreting
204 The field-names available for use in filters can be found in the
243 The ".function" postfix can only be attached to values of size long, and can only
244 be compared with "==" or "!=".
246 Cpumask fields or scalar fields that encode a CPU number can be filtered using
278 an error message can be seen by looking at the filter e.g.::
289 the filter string; the error message should still be useful though
299 faults (the pointer points to memory that should not be accessed), then the
300 string compare will be treated as not matching.
314 For convenience, filters for every event in a subsystem can be set or
318 filter, or if the filter can't be applied for any other reason, the
323 fields can be guaranteed to propagate successfully to all events.
381 Trace events can be made to conditionally invoke trigger 'commands'
383 examples would be enabling or disabling other trace events or invoking
389 be invoked if the event being invoked passes the associated filter.
402 disabled in a "soft" mode. That is, the tracepoint will be called,
403 but just will not be traced, unless of course it's actually enabled.
404 This scheme allows triggers to be invoked even for events that aren't
405 enabled, and also allows the current event filter implementation to be
453 That is, the tracepoint will be called, but just will not be traced.
457 For example, the following trigger causes kmalloc events to be
484 Note that there can be any number of enable/disable_event triggers
485 per triggering event, but there can only be one trigger per
490 could be combined into a single filter on kmem:kmalloc though).
521 The latter can also be removed more simply by the following (without
527 Note that there can be only one stacktrace trigger per triggering
532 This command causes a snapshot to be triggered whenever the
556 Note that there can be only one snapshot trigger per triggering
587 Note that there can be only one traceon or traceoff trigger per
604 more complex relationships than can be expressed through a simple
606 commands may be simply too cumbersome. An example might be an
613 will, which can be used to either augment the existing trace stream
663 If field_name contains [n], the field is considered to be a static array.
666 be a dynamic array, which will only take as much space in the event as
671 in-kernel API described below can't be used with dynamic arrays. The
672 other non-piecewise in-kernel APIs can, however, be used with dynamic
676 must be passed to synth_event_create(). This will ensure that the
680 At this point, the event object is ready to be used for generating new
684 allows events to be created dynamically and without the need to create
688 first be created using synth_event_gen_cmd_start() or
691 representing a 'type field_name;' field specification should be
693 event along with an array of struct synth_field_desc should be
720 Once the synthetic event object has been created, it can then be
724 "intfield", the following call should be made::
729 the field is considered to be an array.
731 A group of fields can also be added all at once using an array of
738 synth_event_add_field_str() can be used to add it as-is; it will
741 Once all the fields have been added, the event should be finalized and
746 At this point, the event object is ready to be used for tracing new
755 array of values to be set. A second option can be used to avoid the
765 synth_event_trace_array() functions can be used.
768 representing the synthetic event (which can be retrieved using
775 above, code like the following could be used::
786 All vals should be cast to u64, and string vals are just pointers to
787 strings, cast to u64. Strings will be copied into space reserved in
790 Alternatively, the synth_event_trace_array() function can be used to
792 representing the synthetic event (which can be retrieved using
799 above, code like the following could be used::
812 match the number of field in the synthetic event, and which must be in
815 All vals should be cast to u64, and string vals are just pointers to
816 strings, cast to u64. Strings will be copied into space reserved in
820 is needed. The trace_get_event_file() function can be used to get
828 Before tracing the event, it should be enabled in some way, otherwise
832 can be used (which is not specific to synthetic events, so does need
833 the "synthetic" system name to be specified explicitly).
845 Finally, synth_event_trace_array() can be used to actually trace the
846 event, which should be visible in the trace buffer afterwards::
851 To remove the synthetic event, the event should be disabled, and the
852 trace instance should be 'put' back using trace_put_event_file()::
858 If those have been successful, synth_event_delete() can be called to
876 struct synth_event_trace_state object, which will be zeroed before use and
880 reserved in the trace buffer, the individual fields can be set. There
887 synth_event_add_next_val() should be used. Each call is passed the
890 field is set, the 'cursor' points to the next field, which will be set
893 this method would be (without error-handling code)::
916 To assign the values in any order, synth_event_add_val() should be
920 the above examples using this method would be (without error-handling
935 can be used but not both at the same time.
937 Finally, the event won't be actually traced until it's 'closed',
943 Note that synth_event_trace_end() must be called at the end regardless
952 functions can be used.
955 should first be created using kprobe_event_gen_cmd_start(). The name
956 of the event and the probe location should be specified along with one
957 or args each representing a probe field should be supplied to this
980 Once the kprobe event object has been created, it can then be
981 populated with more fields. Fields can be added using
984 couple additional fields, the following call could be made::
988 Once all the fields have been added, the event should be finalized and
999 At this point, the event object is ready to be used for tracing new
1002 Similarly, a kretprobe event can be created using
1009 Similar to the synthetic event case, code like the following can be
1017 Finally, also similar to synthetic events, the following code can be
1030 synthetic and kprobe interfaces, which can be used as examples.
1033 layer that can be used to generate trace event commands. The
1034 generated command strings can then be passed to the command-parsing
1041 a command string, which finally causes the command to be executed
1058 The dynevent_cmd initialization needs to be given a user-specified
1059 buffer and the length of the buffer (MAX_DYNEVENT_CMD_LEN can be used
1060 for this purpose - at 2k it's generally too big to be comfortably put
1062 is meant to be used to check that further API calls are for the
1064 callback that will be called to actually execute the event-specific
1067 Once that's done, the command string can be built up by successive
1104 neither part of the pair is NULL), along with a character to be used
1105 to add an operator between the pair (here none) and a separator to be
1108 There's also a dynevent_str_add() function that can be used to simply
1111 Any number of dynevent_*_add() calls can be made to build up the string