Commit | Line | Data |
---|---|---|
6086d29d YS |
1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* Copyright (c) 2020 Facebook */ | |
3 | #include <linux/bpf.h> | |
4 | #include <linux/fs.h> | |
5 | #include <linux/filter.h> | |
6 | #include <linux/kernel.h> | |
951cf368 | 7 | #include <linux/btf_ids.h> |
6086d29d YS |
8 | |
9 | struct bpf_iter_seq_map_info { | |
3f9969f2 | 10 | u32 map_id; |
6086d29d YS |
11 | }; |
12 | ||
13 | static void *bpf_map_seq_start(struct seq_file *seq, loff_t *pos) | |
14 | { | |
15 | struct bpf_iter_seq_map_info *info = seq->private; | |
16 | struct bpf_map *map; | |
17 | ||
3f9969f2 | 18 | map = bpf_map_get_curr_or_next(&info->map_id); |
6086d29d YS |
19 | if (!map) |
20 | return NULL; | |
21 | ||
3f9969f2 YS |
22 | if (*pos == 0) |
23 | ++*pos; | |
6086d29d YS |
24 | return map; |
25 | } | |
26 | ||
27 | static void *bpf_map_seq_next(struct seq_file *seq, void *v, loff_t *pos) | |
28 | { | |
29 | struct bpf_iter_seq_map_info *info = seq->private; | |
6086d29d YS |
30 | |
31 | ++*pos; | |
3f9969f2 | 32 | ++info->map_id; |
6086d29d | 33 | bpf_map_put((struct bpf_map *)v); |
3f9969f2 | 34 | return bpf_map_get_curr_or_next(&info->map_id); |
6086d29d YS |
35 | } |
36 | ||
37 | struct bpf_iter__bpf_map { | |
38 | __bpf_md_ptr(struct bpf_iter_meta *, meta); | |
39 | __bpf_md_ptr(struct bpf_map *, map); | |
40 | }; | |
41 | ||
42 | DEFINE_BPF_ITER_FUNC(bpf_map, struct bpf_iter_meta *meta, struct bpf_map *map) | |
43 | ||
44 | static int __bpf_map_seq_show(struct seq_file *seq, void *v, bool in_stop) | |
45 | { | |
46 | struct bpf_iter__bpf_map ctx; | |
47 | struct bpf_iter_meta meta; | |
48 | struct bpf_prog *prog; | |
49 | int ret = 0; | |
50 | ||
51 | ctx.meta = &meta; | |
52 | ctx.map = v; | |
53 | meta.seq = seq; | |
54 | prog = bpf_iter_get_info(&meta, in_stop); | |
55 | if (prog) | |
56 | ret = bpf_iter_run_prog(prog, &ctx); | |
57 | ||
58 | return ret; | |
59 | } | |
60 | ||
61 | static int bpf_map_seq_show(struct seq_file *seq, void *v) | |
62 | { | |
63 | return __bpf_map_seq_show(seq, v, false); | |
64 | } | |
65 | ||
66 | static void bpf_map_seq_stop(struct seq_file *seq, void *v) | |
67 | { | |
68 | if (!v) | |
69 | (void)__bpf_map_seq_show(seq, v, true); | |
70 | else | |
71 | bpf_map_put((struct bpf_map *)v); | |
72 | } | |
73 | ||
74 | static const struct seq_operations bpf_map_seq_ops = { | |
75 | .start = bpf_map_seq_start, | |
76 | .next = bpf_map_seq_next, | |
77 | .stop = bpf_map_seq_stop, | |
78 | .show = bpf_map_seq_show, | |
79 | }; | |
80 | ||
951cf368 YS |
81 | BTF_ID_LIST(btf_bpf_map_id) |
82 | BTF_ID(struct, bpf_map) | |
83 | ||
14fc6bd6 | 84 | static const struct bpf_iter_seq_info bpf_map_seq_info = { |
15172a46 YS |
85 | .seq_ops = &bpf_map_seq_ops, |
86 | .init_seq_private = NULL, | |
87 | .fini_seq_private = NULL, | |
88 | .seq_priv_size = sizeof(struct bpf_iter_seq_map_info), | |
14fc6bd6 YS |
89 | }; |
90 | ||
91 | static struct bpf_iter_reg bpf_map_reg_info = { | |
92 | .target = "bpf_map", | |
3c32cc1b YS |
93 | .ctx_arg_info_size = 1, |
94 | .ctx_arg_info = { | |
95 | { offsetof(struct bpf_iter__bpf_map, map), | |
96 | PTR_TO_BTF_ID_OR_NULL }, | |
97 | }, | |
14fc6bd6 | 98 | .seq_info = &bpf_map_seq_info, |
15172a46 YS |
99 | }; |
100 | ||
5e7b3020 YS |
101 | static int bpf_iter_attach_map(struct bpf_prog *prog, |
102 | union bpf_iter_link_info *linfo, | |
103 | struct bpf_iter_aux_info *aux) | |
a5cbe05a | 104 | { |
d6c4503c | 105 | u32 key_acc_size, value_acc_size, key_size, value_size; |
5e7b3020 | 106 | struct bpf_map *map; |
d6c4503c | 107 | bool is_percpu = false; |
5e7b3020 YS |
108 | int err = -EINVAL; |
109 | ||
110 | if (!linfo->map.map_fd) | |
111 | return -EBADF; | |
112 | ||
113 | map = bpf_map_get_with_uref(linfo->map.map_fd); | |
114 | if (IS_ERR(map)) | |
115 | return PTR_ERR(map); | |
d6c4503c YS |
116 | |
117 | if (map->map_type == BPF_MAP_TYPE_PERCPU_HASH || | |
d3cc2ab5 YS |
118 | map->map_type == BPF_MAP_TYPE_LRU_PERCPU_HASH || |
119 | map->map_type == BPF_MAP_TYPE_PERCPU_ARRAY) | |
d6c4503c YS |
120 | is_percpu = true; |
121 | else if (map->map_type != BPF_MAP_TYPE_HASH && | |
d3cc2ab5 YS |
122 | map->map_type != BPF_MAP_TYPE_LRU_HASH && |
123 | map->map_type != BPF_MAP_TYPE_ARRAY) | |
5e7b3020 | 124 | goto put_map; |
d6c4503c YS |
125 | |
126 | key_acc_size = prog->aux->max_rdonly_access; | |
127 | value_acc_size = prog->aux->max_rdwr_access; | |
128 | key_size = map->key_size; | |
129 | if (!is_percpu) | |
130 | value_size = map->value_size; | |
131 | else | |
132 | value_size = round_up(map->value_size, 8) * num_possible_cpus(); | |
133 | ||
5e7b3020 YS |
134 | if (key_acc_size > key_size || value_acc_size > value_size) { |
135 | err = -EACCES; | |
136 | goto put_map; | |
137 | } | |
d6c4503c | 138 | |
5e7b3020 | 139 | aux->map = map; |
d6c4503c | 140 | return 0; |
5e7b3020 YS |
141 | |
142 | put_map: | |
143 | bpf_map_put_with_uref(map); | |
144 | return err; | |
145 | } | |
146 | ||
147 | static void bpf_iter_detach_map(struct bpf_iter_aux_info *aux) | |
148 | { | |
149 | bpf_map_put_with_uref(aux->map); | |
a5cbe05a YS |
150 | } |
151 | ||
152 | DEFINE_BPF_ITER_FUNC(bpf_map_elem, struct bpf_iter_meta *meta, | |
153 | struct bpf_map *map, void *key, void *value) | |
154 | ||
155 | static const struct bpf_iter_reg bpf_map_elem_reg_info = { | |
156 | .target = "bpf_map_elem", | |
5e7b3020 YS |
157 | .attach_target = bpf_iter_attach_map, |
158 | .detach_target = bpf_iter_detach_map, | |
a5cbe05a YS |
159 | .ctx_arg_info_size = 2, |
160 | .ctx_arg_info = { | |
161 | { offsetof(struct bpf_iter__bpf_map_elem, key), | |
162 | PTR_TO_RDONLY_BUF_OR_NULL }, | |
163 | { offsetof(struct bpf_iter__bpf_map_elem, value), | |
164 | PTR_TO_RDWR_BUF_OR_NULL }, | |
165 | }, | |
166 | }; | |
167 | ||
6086d29d YS |
168 | static int __init bpf_map_iter_init(void) |
169 | { | |
a5cbe05a YS |
170 | int ret; |
171 | ||
951cf368 | 172 | bpf_map_reg_info.ctx_arg_info[0].btf_id = *btf_bpf_map_id; |
a5cbe05a YS |
173 | ret = bpf_iter_reg_target(&bpf_map_reg_info); |
174 | if (ret) | |
175 | return ret; | |
176 | ||
177 | return bpf_iter_reg_target(&bpf_map_elem_reg_info); | |
6086d29d YS |
178 | } |
179 | ||
180 | late_initcall(bpf_map_iter_init); |