cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

pids.c (5712B)


      1// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
      2/* Copyright (C) 2020 Facebook */
      3#include <errno.h>
      4#include <linux/err.h>
      5#include <stdbool.h>
      6#include <stdio.h>
      7#include <stdlib.h>
      8#include <string.h>
      9#include <unistd.h>
     10
     11#include <bpf/bpf.h>
     12#include <bpf/hashmap.h>
     13
     14#include "main.h"
     15#include "skeleton/pid_iter.h"
     16
     17#ifdef BPFTOOL_WITHOUT_SKELETONS
     18
     19int build_obj_refs_table(struct hashmap **map, enum bpf_obj_type type)
     20{
     21	return -ENOTSUP;
     22}
     23void delete_obj_refs_table(struct hashmap *map) {}
     24void emit_obj_refs_plain(struct hashmap *map, __u32 id, const char *prefix) {}
     25void emit_obj_refs_json(struct hashmap *map, __u32 id, json_writer_t *json_writer) {}
     26
     27#else /* BPFTOOL_WITHOUT_SKELETONS */
     28
     29#include "pid_iter.skel.h"
     30
     31static void add_ref(struct hashmap *map, struct pid_iter_entry *e)
     32{
     33	struct hashmap_entry *entry;
     34	struct obj_refs *refs;
     35	struct obj_ref *ref;
     36	int err, i;
     37	void *tmp;
     38
     39	hashmap__for_each_key_entry(map, entry, u32_as_hash_field(e->id)) {
     40		refs = entry->value;
     41
     42		for (i = 0; i < refs->ref_cnt; i++) {
     43			if (refs->refs[i].pid == e->pid)
     44				return;
     45		}
     46
     47		tmp = realloc(refs->refs, (refs->ref_cnt + 1) * sizeof(*ref));
     48		if (!tmp) {
     49			p_err("failed to re-alloc memory for ID %u, PID %d, COMM %s...",
     50			      e->id, e->pid, e->comm);
     51			return;
     52		}
     53		refs->refs = tmp;
     54		ref = &refs->refs[refs->ref_cnt];
     55		ref->pid = e->pid;
     56		memcpy(ref->comm, e->comm, sizeof(ref->comm));
     57		refs->ref_cnt++;
     58
     59		return;
     60	}
     61
     62	/* new ref */
     63	refs = calloc(1, sizeof(*refs));
     64	if (!refs) {
     65		p_err("failed to alloc memory for ID %u, PID %d, COMM %s...",
     66		      e->id, e->pid, e->comm);
     67		return;
     68	}
     69
     70	refs->refs = malloc(sizeof(*refs->refs));
     71	if (!refs->refs) {
     72		free(refs);
     73		p_err("failed to alloc memory for ID %u, PID %d, COMM %s...",
     74		      e->id, e->pid, e->comm);
     75		return;
     76	}
     77	ref = &refs->refs[0];
     78	ref->pid = e->pid;
     79	memcpy(ref->comm, e->comm, sizeof(ref->comm));
     80	refs->ref_cnt = 1;
     81	refs->has_bpf_cookie = e->has_bpf_cookie;
     82	refs->bpf_cookie = e->bpf_cookie;
     83
     84	err = hashmap__append(map, u32_as_hash_field(e->id), refs);
     85	if (err)
     86		p_err("failed to append entry to hashmap for ID %u: %s",
     87		      e->id, strerror(errno));
     88}
     89
     90static int __printf(2, 0)
     91libbpf_print_none(__maybe_unused enum libbpf_print_level level,
     92		  __maybe_unused const char *format,
     93		  __maybe_unused va_list args)
     94{
     95	return 0;
     96}
     97
     98int build_obj_refs_table(struct hashmap **map, enum bpf_obj_type type)
     99{
    100	struct pid_iter_entry *e;
    101	char buf[4096 / sizeof(*e) * sizeof(*e)];
    102	struct pid_iter_bpf *skel;
    103	int err, ret, fd = -1, i;
    104	libbpf_print_fn_t default_print;
    105
    106	*map = hashmap__new(hash_fn_for_key_as_id, equal_fn_for_key_as_id, NULL);
    107	if (IS_ERR(*map)) {
    108		p_err("failed to create hashmap for PID references");
    109		return -1;
    110	}
    111
    112	skel = pid_iter_bpf__open();
    113	if (!skel) {
    114		p_err("failed to open PID iterator skeleton");
    115		return -1;
    116	}
    117
    118	skel->rodata->obj_type = type;
    119
    120	/* we don't want output polluted with libbpf errors if bpf_iter is not
    121	 * supported
    122	 */
    123	default_print = libbpf_set_print(libbpf_print_none);
    124	err = pid_iter_bpf__load(skel);
    125	libbpf_set_print(default_print);
    126	if (err) {
    127		/* too bad, kernel doesn't support BPF iterators yet */
    128		err = 0;
    129		goto out;
    130	}
    131	err = pid_iter_bpf__attach(skel);
    132	if (err) {
    133		/* if we loaded above successfully, attach has to succeed */
    134		p_err("failed to attach PID iterator: %d", err);
    135		goto out;
    136	}
    137
    138	fd = bpf_iter_create(bpf_link__fd(skel->links.iter));
    139	if (fd < 0) {
    140		err = -errno;
    141		p_err("failed to create PID iterator session: %d", err);
    142		goto out;
    143	}
    144
    145	while (true) {
    146		ret = read(fd, buf, sizeof(buf));
    147		if (ret < 0) {
    148			if (errno == EAGAIN)
    149				continue;
    150			err = -errno;
    151			p_err("failed to read PID iterator output: %d", err);
    152			goto out;
    153		}
    154		if (ret == 0)
    155			break;
    156		if (ret % sizeof(*e)) {
    157			err = -EINVAL;
    158			p_err("invalid PID iterator output format");
    159			goto out;
    160		}
    161		ret /= sizeof(*e);
    162
    163		e = (void *)buf;
    164		for (i = 0; i < ret; i++, e++) {
    165			add_ref(*map, e);
    166		}
    167	}
    168	err = 0;
    169out:
    170	if (fd >= 0)
    171		close(fd);
    172	pid_iter_bpf__destroy(skel);
    173	return err;
    174}
    175
    176void delete_obj_refs_table(struct hashmap *map)
    177{
    178	struct hashmap_entry *entry;
    179	size_t bkt;
    180
    181	if (!map)
    182		return;
    183
    184	hashmap__for_each_entry(map, entry, bkt) {
    185		struct obj_refs *refs = entry->value;
    186
    187		free(refs->refs);
    188		free(refs);
    189	}
    190
    191	hashmap__free(map);
    192}
    193
    194void emit_obj_refs_json(struct hashmap *map, __u32 id,
    195			json_writer_t *json_writer)
    196{
    197	struct hashmap_entry *entry;
    198
    199	if (hashmap__empty(map))
    200		return;
    201
    202	hashmap__for_each_key_entry(map, entry, u32_as_hash_field(id)) {
    203		struct obj_refs *refs = entry->value;
    204		int i;
    205
    206		if (refs->ref_cnt == 0)
    207			break;
    208
    209		if (refs->has_bpf_cookie)
    210			jsonw_lluint_field(json_writer, "bpf_cookie", refs->bpf_cookie);
    211
    212		jsonw_name(json_writer, "pids");
    213		jsonw_start_array(json_writer);
    214		for (i = 0; i < refs->ref_cnt; i++) {
    215			struct obj_ref *ref = &refs->refs[i];
    216
    217			jsonw_start_object(json_writer);
    218			jsonw_int_field(json_writer, "pid", ref->pid);
    219			jsonw_string_field(json_writer, "comm", ref->comm);
    220			jsonw_end_object(json_writer);
    221		}
    222		jsonw_end_array(json_writer);
    223		break;
    224	}
    225}
    226
    227void emit_obj_refs_plain(struct hashmap *map, __u32 id, const char *prefix)
    228{
    229	struct hashmap_entry *entry;
    230
    231	if (hashmap__empty(map))
    232		return;
    233
    234	hashmap__for_each_key_entry(map, entry, u32_as_hash_field(id)) {
    235		struct obj_refs *refs = entry->value;
    236		int i;
    237
    238		if (refs->ref_cnt == 0)
    239			break;
    240
    241		if (refs->has_bpf_cookie)
    242			printf("\n\tbpf_cookie %llu", (unsigned long long) refs->bpf_cookie);
    243
    244		printf("%s", prefix);
    245		for (i = 0; i < refs->ref_cnt; i++) {
    246			struct obj_ref *ref = &refs->refs[i];
    247
    248			printf("%s%s(%d)", i == 0 ? "" : ", ", ref->comm, ref->pid);
    249		}
    250		break;
    251	}
    252}
    253
    254
    255#endif