---
name: "tracefs_instance_find_cid_pid"
section: "3"
platform: "linux"
package: "libtracefs-doc"
version: "1.8.1-1"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/tracefs_find_cid_pid"
---

# tracefs\_instance\_find\_cid\_pid(3)

helper functions to handle tracing guests

Part of [tracefs\_find\_cid\_pid(3)](/tracefs_find_cid_pid/3.md).

## 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)](/libtracefs/3.md), [**libtraceevent**(3)](/libtraceevent/3.md), [**trace-cmd**(1)](/trace-cmd/1.md)

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