| #include <stdlib.h> | |
| #include "trace-cmd-local.h" | |
| #include "trace-local.h" | |
| /* | |
| * Structure to hold the mapping between host and guest. | |
| * @self - A pointer back to the guest's mapping (for the host copy to use) | |
| * @host_handle - The handle for the host for this mapping. | |
| * @guest_handle - The handle for the guest for this mapping. | |
| * @guest_vcpu - The vCPU # for this mapping. | |
| * @host_pid - The pid of the task on the host that runs when this vCPU executes. | |
| * @private - Private data for applications to use. | |
| */ | |
| struct tracecmd_cpu_map { | |
| struct tracecmd_cpu_map *self; | |
| struct tracecmd_input *host_handle; | |
| struct tracecmd_input *guest_handle; | |
| int guest_vcpu; | |
| int host_pid; | |
| void *private; | |
| }; | |
| static int cmp_map(const void *A, const void *B) | |
| { | |
| const struct tracecmd_cpu_map *a = A; | |
| const struct tracecmd_cpu_map *b = B; | |
| if (a->host_pid < b->host_pid) | |
| return -1; | |
| return a->host_pid > b->host_pid; | |
| } | |
| int tracecmd_map_vcpus(struct tracecmd_input **handles, int nr_handles) | |
| { | |
| struct tracecmd_input *host_handle = handles[0]; | |
| unsigned long long traceid; | |
| struct tracecmd_cpu_map *vcpu_maps = NULL; | |
| struct tracecmd_cpu_map *gmap; | |
| struct tracecmd_cpu_map *map; | |
| const int *cpu_pids; | |
| const char *name; | |
| int nr_vcpu_maps = 0; | |
| int vcpu_count; | |
| int mappings = 0; | |
| int ret; | |
| int i, k; | |
| /* handles[0] is the host handle, do for each guest handle */ | |
| for (i = 1; i < nr_handles; i++) { | |
| traceid = tracecmd_get_traceid(handles[i]); | |
| /* | |
| * Retrieve the host mapping of the guest for this handle. | |
| * cpu_pids is an array of pids that map 1-1 the host vcpus where | |
| * cpu_pids[vCPU_num] = host_task_pid | |
| */ | |
| ret = tracecmd_get_guest_cpumap(host_handle, traceid, | |
| &name, &vcpu_count, &cpu_pids); | |
| if (ret) | |
| continue; | |
| mappings++; | |
| gmap = calloc(sizeof(*gmap), vcpu_count); | |
| if (!gmap) | |
| goto fail; | |
| for (k = 0; k < vcpu_count; k++) { | |
| gmap[k].host_handle = handles[0]; | |
| gmap[k].guest_handle = handles[i]; | |
| gmap[k].guest_vcpu = k; | |
| gmap[k].host_pid = cpu_pids[k]; | |
| gmap[k].self = &gmap[k]; | |
| } | |
| trace_set_guest_map(handles[i], gmap); | |
| trace_set_guest_map_cnt(handles[i], vcpu_count); | |
| /* Update the host mapping of all guests to the host */ | |
| map = realloc(vcpu_maps, sizeof(*map) * (nr_vcpu_maps + vcpu_count)); | |
| if (!map) | |
| goto fail; | |
| memset(map + nr_vcpu_maps, 0, sizeof(*map) * (vcpu_count - nr_vcpu_maps)); | |
| vcpu_maps = map; | |
| map += nr_vcpu_maps; | |
| nr_vcpu_maps += vcpu_count; | |
| for (k = 0; k < vcpu_count; k++) | |
| map[k] = gmap[k]; | |
| } | |
| if (!vcpu_maps) | |
| return 0; | |
| /* We want to do a binary search via host_pid to find these mappings */ | |
| qsort(vcpu_maps, nr_vcpu_maps, sizeof(*map), cmp_map); | |
| trace_set_guest_map(handles[0], vcpu_maps); | |
| trace_set_guest_map_cnt(handles[0], nr_vcpu_maps); | |
| return mappings; | |
| fail: | |
| free(vcpu_maps); | |
| return -1; | |
| } | |
| __hidden void trace_guest_map_free(struct tracecmd_cpu_map *map) | |
| { | |
| free(map); | |
| } | |
| struct tracecmd_cpu_map *tracecmd_map_find_by_host_pid(struct tracecmd_input *handle, | |
| int host_pid) | |
| { | |
| struct tracecmd_cpu_map *map; | |
| struct tracecmd_cpu_map key; | |
| int nr_maps; | |
| map = trace_get_guest_map(handle); | |
| if (!map) | |
| return NULL; | |
| /* The handle could be from the guest, get the host handle */ | |
| handle = map->host_handle; | |
| /* And again, get the mapping of the host, as it has all the mappings */ | |
| map = trace_get_guest_map(handle); | |
| if (!map) | |
| return NULL; | |
| nr_maps = trace_get_guest_map_cnt(handle); | |
| key.host_pid = host_pid; | |
| map = bsearch(&key, map, nr_maps, sizeof(*map), cmp_map); | |
| return map ? map->self : NULL; | |
| } | |
| void tracecmd_map_set_private(struct tracecmd_cpu_map *map, void *priv) | |
| { | |
| /* Only set the guest private */ | |
| map = map->self; | |
| map->private = priv; | |
| } | |
| void *tracecmd_map_get_private(struct tracecmd_cpu_map *map) | |
| { | |
| /* Return the guest private */ | |
| map = map->self; | |
| return map->private; | |
| } | |
| struct tracecmd_input *tracecmd_map_get_guest(struct tracecmd_cpu_map *map) | |
| { | |
| return map->guest_handle; | |
| } | |
| int tracecmd_map_get_host_pid(struct tracecmd_cpu_map *map) | |
| { | |
| return map->host_pid; | |
| } | |
| struct tracecmd_cpu_map *tracecmd_get_cpu_map(struct tracecmd_input *handle, int cpu) | |
| { | |
| struct tracecmd_cpu_map *map; | |
| int cnt; | |
| map = trace_get_guest_map(handle); | |
| /* Make sure it's for the guest handle, as this could be a host handle */ | |
| map = map->self; | |
| cnt = trace_get_guest_map_cnt(map->guest_handle); | |
| if (cnt <= cpu) | |
| return NULL; | |
| return map + cpu; | |
| } |