# tracefs_find_cid_pid

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


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


* * *