tracefs_event_systems(3) — Linux manual page

NAME | SYNOPSIS | DESCRIPTION | RETURN VALUE | EXAMPLE | FILES | SEE ALSO | AUTHOR | REPORTING BUGS | LICENSE | RESOURCES | COPYING | NOTES | COLOPHON

LIBTRACEFS(3)               libtracefs Manual              LIBTRACEFS(3)

NAME         top

       tracefs_event_systems, tracefs_system_events,
       tracefs_event_enable, tracefs_event_disable,
       tracefs_event_is_enabled - Work with trace systems and events.

SYNOPSIS         top

       #include <tracefs.h>

       enum tracefs_event_state {
               TRACEFS_ERROR = -1,
               TRACEFS_ALL_DISABLED = 0,
               TRACEFS_ALL_ENABLED = 1,
               TRACEFS_SOME_ENABLED = 2,
       };

       char **tracefs_event_systems(const char *tracing_dir);
       char **tracefs_system_events(const char *tracing_dir, const char *system);
       int tracefs_event_enable(struct tracefs_instance *instance, const char *system,
                                  const char *event);
       int tracefs_event_disable(struct tracefs_instance *instance, const char *system,
                                   const char *event);
       enum tracefs_enable_state tracefs_event_is_enabled(struct tracefs_instance *instance,
                                const char *system, const char *event);

DESCRIPTION         top

       Trace systems and events related APIs.

       The tracefs_event_systems() function returns array of strings
       with the names of all registered trace systems, located in the
       given tracing_dir directory. This could be NULL or the location
       of the tracefs mount point for the trace systems of the local
       machine, or it may be a path to a copy of the tracefs directory
       from another machine. The last entry in the array is a NULL
       pointer. The array must be freed with tracefs_list_free() API.

       The tracefs_system_events() function returns array of strings
       with the names of all registered trace events for given trace
       system specified by system, located in the given tracing_dir
       directory. This could be NULL or the location of the tracefs
       mount point for the trace systems of the local machine, or it may
       be a path to a copy of the tracefs directory from another
       machine. The last entry in the array as a NULL pointer. The array
       must be freed with tracefs_list_free() API.

       The tracefs_event_enable() function enables a given event based
       on the system and event passed in for the given instance. If
       instance is NULL, then the top level tracing directory is used.
       If system and event are both NULL, then all events are enabled
       for the instance. If event is NULL then all events within the
       system are enabled. If system is NULL, then all systems are
       searched and any event within a system that matches event is
       enabled. Both system and event may be regular expressions as
       defined by regex(3).

       The tracefs_event_disable() function disables the events that
       match the system and event parameters for the given instance.
       What events are disable follow the same rules as
       tracefs_event_enable() for matching events. That is, if instance
       is NULL, then the top level tracing directory is used. If both
       system and event are NULL then all events are disabled for the
       given instance, and so on.

       The tracefs_event_is_enabled() returns if an event is enabled, a
       set of events are enabled, a system is enabled, or all events are
       enabled. If both system and event are NULL, then it returns the
       enable state of all events. If system is not NULL and event is
       NULL, then it will check if all the events in all the systems
       that system and return the enable state of those events. If
       system is NULL and event is not NULL, then it will match all the
       events in all systems that match event and return their enabled
       state. If both system and event are not NULL, then it will return
       the enabled state of all matching events. The enabled state is
       defined as:

       TRACEFS_ERROR - An error occurred including no event were
       matched.

       TRACEFS_ALL_DISABLED - All matching events are disabled.

       TRACEFS_ALL_ENABLED - All matching events are enabled.

       TRACEFS_SOME_ENABLED - Some matching events were enabled while
       others were not.

RETURN VALUE         top

       The tracefs_event_systems() and tracefs_system_events() functions
       return an array of strings. The last element in that array is a
       NULL pointer. The array must be freed with tracefs_list_free()
       API. In case of an error, NULL is returned.

       Both tracefs_event_enable() and tracefs_event_disable() return 0
       if they found any matching events (Note it does not check the
       previous status of the event. If tracefs_event_enable() finds an
       event that is already enabled, and there are no other errors,
       then it will return 0). If an error occurs, even if other events
       were found, it will return -1 and errno will be set. If no errors
       occur, but no events are found that match the system and event
       parameters, then -1 is returned and errno is not set.

       The tracefs_event_is_enabled() returns the enabled status of the
       matching events or TRACEFS_ERROR on error.

EXAMPLE         top

           #include <tracefs.h>

           char **systems = tracefs_event_systems(NULL);

                   if (systems) {
                           int i = 0;
                           /* Got registered trace systems from the top trace instance */
                           while (systems[i]) {
                                   char **events = tracefs_system_events(NULL, systems[i]);
                                   if (events) {
                                           /* Got registered events in system[i] from the top trace instance */
                                           int j = 0;

                                           while (events[j]) {
                                                   /* Got event[j] in system[i] from the top trace instance */
                                                   j++;
                                           }
                                           tracefs_list_free(events);
                                   }
                                   i++;
                           }
                           tracefs_list_free(systems);
                   }
           ....
           static int records_walk(struct tep_event *tep, struct tep_record *record, int cpu, void *context)
           {
                   /* Got recorded event on cpu */
                   return 0;
           }
           ...
           struct tep_handle *tep = tracefs_local_events(NULL);

                   if (!tep) {
                           /* Failed to initialise tep handler with local events */
                           ...
                   }

                   errno = 0;
                   ret = tracefs_event_enable(NULL, "sched", NULL);
                   if (ret < 0 && !errno)
                           printf("Could not find 'sched' events\n");
                   tracefs_event_enable(NULL, "irq", "irq_handler_\(enter\|exit\)");

                   if (tracefs_iterate_raw_events(tep, NULL, NULL, 0, records_walk, NULL) < 0) {
                           /* Error walking through the recorded raw events */
                   }

                   /* Disable all events */
                   tracefs_event_disable(NULL, NULL, NULL);
                   tep_free(tep);

FILES         top

           tracefs.h
                   Header file to include in order to have access to the library APIs.
           -ltracefs
                   Linker switch to add when building a program that uses the library.

SEE ALSO         top

       libtracefs(3), libtraceevent(3), trace-cmd(1)

AUTHOR         top

           Steven Rostedt <rostedt@goodmis.org[1]>
           Tzvetomir Stoyanov <tz.stoyanov@gmail.com[2]>

REPORTING BUGS         top

       Report bugs to <linux-trace-devel@vger.kernel.org[3]>

LICENSE         top

       libtracefs is Free Software licensed under the GNU LGPL 2.1

RESOURCES         top

       https://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git/ 

COPYING         top

       Copyright (C) 2020 VMware, Inc. Free use of this software is
       granted under the terms of the GNU Public License (GPL).

NOTES         top

        1. rostedt@goodmis.org
           mailto:rostedt@goodmis.org

        2. tz.stoyanov@gmail.com
           mailto:tz.stoyanov@gmail.com

        3. linux-trace-devel@vger.kernel.org
           mailto:linux-trace-devel@vger.kernel.org

COLOPHON         top

       This page is part of the libtracefs (Linux kernel trace file
       system library) project.  Information about the project can be
       found at ⟨https://www.trace-cmd.org/⟩.  If you have a bug report
       for this manual page, see ⟨https://www.trace-cmd.org/⟩.  This
       page was obtained from the project's upstream Git repository
       ⟨https://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git⟩ on
       2024-06-14.  (At that time, the date of the most recent commit
       that was found in the repository was 2024-05-17.)  If you
       discover any rendering problems in this HTML version of the page,
       or you believe there is a better or more up-to-date source for
       the page, or you have corrections or improvements to the
       information in this COLOPHON (which is not part of the original
       manual page), send a mail to man-pages@man7.org

libtracefs 1.7.0               12/22/2023                  LIBTRACEFS(3)