tracefs_find_cid_pid(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_find_cid_pid, tracefs_instance_find_cid_pid,
       tracefs_time_conversion - helper functions to handle tracing
       guests

SYNOPSIS         top

       #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         top

       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         top

       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         top

           #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         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)