LIBTRACEFS(3)                  libtracefs Manual                 LIBTRACEFS(3)

NAME
       tracefs_find_cid_pid, tracefs_instance_find_cid_pid,
       tracefs_time_conversion - helper functions to handle tracing guests

SYNOPSIS
       #include <tracefs.h>

       char *tracefs_find_cid_pid(int cid);
       char *tracefs_instance_find_cid_pid(struct tracefs_instance *instance, int cid);
       int tracefs_time_conversion(int cpu, int *shift, int *multi, long long *offset);

DESCRIPTION
       The tracefs_find_cid_pid() will use tracing to follow the wakeups of
       connecting to the given cid in order to find the pid of the guest
       thread that belongs to the vsocket cid. It will then read the proc file
       system to find the thread leader, and it will return the pid of the
       thread leader.

       The tracefs_instance_find_cid_pid() is the same as
       tracefs_find_cid_pid() but defines the instance to use to perform the
       tracing in. If NULL it will use the top level buffer to perform the
       tracing.

       The tracefs_time_conversion() will return the values used by the kernel
       to convert the raw time stamp counter into nanoseconds for the given
       cpu. Pointers for shift, multi and offset can be NULL to be ignored,
       otherwise they are set with the shift, multiplier and offset
       repectively.

RETURN VALUE
       Both tracefs_find_cid_pid() and tracefs_instance_find_cid_pid() will
       return the pid of the guest main thread that belongs to the cid, or -1
       on error (or not found).

EXAMPLE
           #include <stdlib.h>
           #include <unistd.h>
           #include <tracefs.h>

           #define MAX_CID         256

           static void find_cid(struct tracefs_instance *instance, int cid)
           {
                   int pid;

                   pid = tracefs_instance_find_cid_pid(instance, cid);
                   if (pid >= 0)
                           printf("%d\t%d\n", cid, pid);
           }

           static int find_cids(void)
           {
                   struct tracefs_instance *instance;
                   char *name;
                   int cid;
                   int ret;

                   ret = asprintf(&name, "vsock_find-%d\n", getpid());
                   if (ret < 0)
                           return ret;

                   instance = tracefs_instance_create(name);
                   free(name);
                   if (!instance)
                           return -1;

                   for (cid = 0; cid < MAX_CID; cid++)
                           find_cid(instance, cid);

                   tracefs_event_disable(instance, NULL, NULL);
                   tracefs_instance_destroy(instance);
                   tracefs_instance_free(instance);
                   return 0;
           }

           struct time_info {
                   int             shift;
                   int             multi;
           };

           static void show_time_conversion(void)
           {
                   struct time_info *tinfo;
                   int cpus;
                   int cpu;
                   int ret;

                   cpus = sysconf(_SC_NPROCESSORS_CONF);
                   tinfo = calloc(cpus, sizeof(*tinfo));
                   if (!tinfo)
                           exit(-1);

                   for (cpu = 0; cpu < cpus; cpu++) {
                           ret  = tracefs_time_conversion(cpu,
                                                           &tinfo[cpu].shift,
                                                           &tinfo[cpu].multi,
                                                           NULL);
                           if (ret)
                                   break;
                   }
                   if (cpu != cpus) {
                           if (!cpu) {
                                   perror("tracefs_time_conversion");
                                   exit(-1);
                           }
                           printf("Only read %d of %d CPUs", cpu, cpus);
                           cpus = cpu + 1;
                   }

                   /* Check if all the shift and mult values are the same */
                   for (cpu = 1; cpu < cpus; cpu++) {
                           if (tinfo[cpu - 1].shift != tinfo[cpu].shift)
                                   break;
                           if (tinfo[cpu - 1].multi != tinfo[cpu].multi)
                                   break;
                   }

                   if (cpu == cpus) {
                           printf("All cpus have:\n");
                           printf(" shift:  %d\n", tinfo[0].shift);
                           printf(" multi:  %d\n", tinfo[0].multi);
                           printf("\n");
                           return;
                   }

                   for (cpu = 0; cpu < cpus; cpu++) {
                           printf("CPU: %d\n", cpu);
                           printf(" shift:  %d\n", tinfo[cpu].shift);
                           printf(" multi:  %d\n", tinfo[cpu].multi);
                           printf("\n");
                   }
           }

           int main(int argc, char *argv[])
           {
                   show_time_conversion();
                   find_cids();
                   exit(0);
           }

FILES
           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
       libtracefs(3), libtraceevent(3), trace-cmd(1)

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

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

LICENSE
       libtracefs is Free Software licensed under the GNU LGPL 2.1

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

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

NOTES
        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

libtracefs 1.8.0                  01/13/2024                     LIBTRACEFS(3)