iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

perf parse-events: Remove array remnants

Browse Source 
parse_events_array was set up by event term parsing, which no longer
exists. Remove this struct and references to it.

Signed-off-by: Ian Rogers <irogers@google.com>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Eduard Zingerman <eddyz87@gmail.com>
Cc: He Kuang <hekuang@huawei.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Kan Liang <kan.liang@linux.intel.com>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Rob Herring <robh@kernel.org>
Cc: Wang Nan <wangnan0@huawei.com>
Cc: Wang ShaoBo <bobo.shaobowang@huawei.com>
Cc: YueHaibing <yuehaibing@huawei.com>
Cc: bpf@vger.kernel.org
Link: https://lore.kernel.org/r/20230728001212.457900-4-irogers@google.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
This commit is contained in:
Ian Rogers
2023-07-27 17:12:12 -07:00
committed by Arnaldo Carvalho de Melo
parent 30f4ade33d
commit c9b57eb8dc
3 changed files with 0 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

101
tools/perf/util/bpf-loader.c
View File

@ -1088,16 +1088,12 @@ enum bpf_map_op_type {
enum bpf_map_key_type { enum bpf_map_key_type {
BPF_MAP_KEY_ALL, BPF_MAP_KEY_ALL,
BPF_MAP_KEY_RANGES,
}; };
struct bpf_map_op { struct bpf_map_op {
struct list_head list; struct list_head list;
enum bpf_map_op_type op_type; enum bpf_map_op_type op_type;
enum bpf_map_key_type key_type; enum bpf_map_key_type key_type;
union {
struct parse_events_array array;
} k;
union { union {
u64 value; u64 value;
struct evsel *evsel; struct evsel *evsel;
@ -1113,8 +1109,6 @@ bpf_map_op__delete(struct bpf_map_op *op)
{ {
if (!list_empty(&op->list)) if (!list_empty(&op->list))
list_del_init(&op->list); list_del_init(&op->list);
if (op->key_type == BPF_MAP_KEY_RANGES)
parse_events__clear_array(&op->k.array);
free(op); free(op);
} }
@ -1193,18 +1187,6 @@ bpf_map_op_setkey(struct bpf_map_op *op, struct parse_events_term *term)
if (!term) if (!term)
return 0; return 0;
if (term->array.nr_ranges) {
size_t memsz = term->array.nr_ranges *
sizeof(op->k.array.ranges[0]);
op->k.array.ranges = memdup(term->array.ranges, memsz);
if (!op->k.array.ranges) {
pr_debug("Not enough memory to alloc indices for map\n");
return -ENOMEM;
}
op->key_type = BPF_MAP_KEY_RANGES;
op->k.array.nr_ranges = term->array.nr_ranges;
}
return 0; return 0;
} }
@ -1241,18 +1223,6 @@ bpf_map_op__clone(struct bpf_map_op *op)
} }
INIT_LIST_HEAD(&newop->list); INIT_LIST_HEAD(&newop->list);
if (op->key_type == BPF_MAP_KEY_RANGES) {
size_t memsz = op->k.array.nr_ranges *
sizeof(op->k.array.ranges[0]);
newop->k.array.ranges = memdup(op->k.array.ranges, memsz);
if (!newop->k.array.ranges) {
pr_debug("Failed to alloc indices for map\n");
free(newop);
return NULL;
}
}
return newop; return newop;
} }
@ -1453,40 +1423,6 @@ struct bpf_obj_config__map_func bpf_obj_config__map_funcs[] = {
{"event", bpf_map__config_event}, {"event", bpf_map__config_event},
}; };
static int
config_map_indices_range_check(struct parse_events_term *term,
struct bpf_map *map,
const char *map_name)
{
struct parse_events_array *array = &term->array;
unsigned int i;
if (!array->nr_ranges)
return 0;
if (!array->ranges) {
pr_debug("ERROR: map %s: array->nr_ranges is %d but range array is NULL\n",
map_name, (int)array->nr_ranges);
return -BPF_LOADER_ERRNO__INTERNAL;
}
if (!map) {
pr_debug("Map '%s' is invalid\n", map_name);
return -BPF_LOADER_ERRNO__INTERNAL;
}
for (i = 0; i < array->nr_ranges; i++) {
unsigned int start = array->ranges[i].start;
size_t length = array->ranges[i].length;
unsigned int idx = start + length - 1;
if (idx >= bpf_map__max_entries(map)) {
pr_debug("ERROR: index %d too large\n", idx);
return -BPF_LOADER_ERRNO__OBJCONF_MAP_IDX2BIG;
}
}
return 0;
}
static int static int
bpf__obj_config_map(struct bpf_object *obj, bpf__obj_config_map(struct bpf_object *obj,
struct parse_events_term *term, struct parse_events_term *term,
@ -1522,12 +1458,6 @@ bpf__obj_config_map(struct bpf_object *obj,
goto out; goto out;
} }
*key_scan_pos += strlen(map_opt);
err = config_map_indices_range_check(term, map, map_name);
if (err)
goto out;
*key_scan_pos -= strlen(map_opt);
for (i = 0; i < ARRAY_SIZE(bpf_obj_config__map_funcs); i++) { for (i = 0; i < ARRAY_SIZE(bpf_obj_config__map_funcs); i++) {
struct bpf_obj_config__map_func *func = struct bpf_obj_config__map_func *func =
&bpf_obj_config__map_funcs[i]; &bpf_obj_config__map_funcs[i];
@ -1576,7 +1506,6 @@ typedef int (*map_config_func_t)(const char *name, int map_fd,
const struct bpf_map *map, const struct bpf_map *map,
struct bpf_map_op *op, struct bpf_map_op *op,
void *pkey, void *arg); void *pkey, void *arg);
static int static int
foreach_key_array_all(map_config_func_t func, foreach_key_array_all(map_config_func_t func,
void *arg, const char *name, void *arg, const char *name,
@ -1597,32 +1526,6 @@ foreach_key_array_all(map_config_func_t func,
return 0; return 0;
} }
static int
foreach_key_array_ranges(map_config_func_t func, void *arg,
const char *name, int map_fd,
const struct bpf_map *map,
struct bpf_map_op *op)
{
unsigned int i, j;
int err;
for (i = 0; i < op->k.array.nr_ranges; i++) {
unsigned int start = op->k.array.ranges[i].start;
size_t length = op->k.array.ranges[i].length;
for (j = 0; j < length; j++) {
unsigned int idx = start + j;
err = func(name, map_fd, map, op, &idx, arg);
if (err) {
pr_debug("ERROR: failed to insert value to %s[%u]\n",
name, idx);
return err;
}
}
}
return 0;
}
static int static int
bpf_map_config_foreach_key(struct bpf_map *map, bpf_map_config_foreach_key(struct bpf_map *map,
@ -1663,10 +1566,6 @@ bpf_map_config_foreach_key(struct bpf_map *map,
err = foreach_key_array_all(func, arg, name, err = foreach_key_array_all(func, arg, name,
map_fd, map, op); map_fd, map, op);
break; break;
case BPF_MAP_KEY_RANGES:
err = foreach_key_array_ranges(func, arg, name,
map_fd, map, op);
break;
default: default:
pr_debug("ERROR: keytype for map '%s' invalid\n", pr_debug("ERROR: keytype for map '%s' invalid\n",
name); name);

8
tools/perf/util/parse-events.c
View File

@ -2716,9 +2716,6 @@ int parse_events_term__clone(struct parse_events_term **new,
void parse_events_term__delete(struct parse_events_term *term) void parse_events_term__delete(struct parse_events_term *term)
{ {
if (term->array.nr_ranges)
zfree(&term->array.ranges);
if (term->type_val != PARSE_EVENTS__TERM_TYPE_NUM) if (term->type_val != PARSE_EVENTS__TERM_TYPE_NUM)
zfree(&term->val.str); zfree(&term->val.str);
@ -2769,11 +2766,6 @@ void parse_events_terms__delete(struct list_head *terms)
free(terms); free(terms);
} }
void parse_events__clear_array(struct parse_events_array *a)
{
zfree(&a->ranges);
}
void parse_events_evlist_error(struct parse_events_state *parse_state, void parse_events_evlist_error(struct parse_events_state *parse_state,
int idx, const char *str) int idx, const char *str)
{ {

10
tools/perf/util/parse-events.h
View File

@ -81,17 +81,8 @@ enum {
__PARSE_EVENTS__TERM_TYPE_NR, __PARSE_EVENTS__TERM_TYPE_NR,
}; };
struct parse_events_array {
size_t nr_ranges;
struct {
unsigned int start;
size_t length;
} *ranges;
};
struct parse_events_term { struct parse_events_term {
char *config; char *config;
struct parse_events_array array;
union { union {
char *str; char *str;
u64 num; u64 num;
@ -162,7 +153,6 @@ int parse_events_term__clone(struct parse_events_term **new,
void parse_events_term__delete(struct parse_events_term *term); void parse_events_term__delete(struct parse_events_term *term);
void parse_events_terms__delete(struct list_head *terms); void parse_events_terms__delete(struct list_head *terms);
void parse_events_terms__purge(struct list_head *terms); void parse_events_terms__purge(struct list_head *terms);
void parse_events__clear_array(struct parse_events_array *a);
int parse_events__modifier_event(struct list_head *list, char *str, bool add); int parse_events__modifier_event(struct list_head *list, char *str, bool add);
int parse_events__modifier_group(struct list_head *list, char *event_mod); int parse_events__modifier_group(struct list_head *list, char *event_mod);
int parse_events_name(struct list_head *list, const char *name); int parse_events_name(struct list_head *list, const char *name);