From mboxrd@z Thu Jan 1 00:00:00 1970 From: Roman Gushchin Subject: Re: [PATCH bpf-next 2/3] bpf: add bpffs pretty print for cgroup local storage maps Date: Mon, 10 Dec 2018 18:18:58 +0000 Message-ID: <20181210181852.GA28954@tower.DHCP.thefacebook.com> References: <20181208005315.3500-1-guro@fb.com> <20181208005315.3500-2-guro@fb.com> <20181209015627.tkyspsafhwl3ak5b@kafai-mbp.dhcp.thefacebook.com> Mime-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable Cc: Roman Gushchin , "netdev@vger.kernel.org" , Kernel Team , "linux-kernel@vger.kernel.org" , "Alexei Starovoitov" , Daniel Borkmann To: Martin Lau Return-path: In-Reply-To: <20181209015627.tkyspsafhwl3ak5b@kafai-mbp.dhcp.thefacebook.com> Content-Language: en-US Content-ID: <425FAA4079CE3942B4070CDDF991A41A@namprd15.prod.outlook.com> Sender: linux-kernel-owner@vger.kernel.org List-Id: netdev.vger.kernel.org On Sat, Dec 08, 2018 at 05:56:30PM -0800, Martin Lau wrote: > On Fri, Dec 07, 2018 at 04:53:14PM -0800, Roman Gushchin wrote: > > Implement bpffs pretty printing for cgroup local storage maps > > (both shared and per-cpu). > > Output example (captured for tools/testing/selftests/bpf/netcnt_prog.c)= : > >=20 > > Shared: > > $ cat /sys/fs/bpf/map_2 > > # WARNING!! The output is for debug purpose only > > # WARNING!! The output format will change > > {4294968594,1}: {9999,1039896} > >=20 > > Per-cpu: > > $ cat /sys/fs/bpf/map_1 > > # WARNING!! The output is for debug purpose only > > # WARNING!! The output format will change > > {4294968594,1}: { > > cpu0: {0,0,0,0,0} > > cpu1: {0,0,0,0,0} > > cpu2: {1,104,0,0,0} > > cpu3: {0,0,0,0,0} > > } > >=20 > > Signed-off-by: Roman Gushchin > > Cc: Alexei Starovoitov > > Cc: Daniel Borkmann > > --- > > include/linux/btf.h | 10 +++++ > > kernel/bpf/local_storage.c | 90 +++++++++++++++++++++++++++++++++++++- > > 2 files changed, 99 insertions(+), 1 deletion(-) > >=20 > > diff --git a/include/linux/btf.h b/include/linux/btf.h > > index 8c2199b5d250..ac67bc4cbfd9 100644 > > --- a/include/linux/btf.h > > +++ b/include/linux/btf.h > > @@ -5,6 +5,7 @@ > > #define _LINUX_BTF_H 1 > > =20 > > #include > > +#include > > =20 > > struct btf; > > struct btf_type; > > @@ -63,4 +64,13 @@ static inline const char *btf_name_by_offset(const s= truct btf *btf, > > } > > #endif > > =20 > > +static inline const struct btf_type *btf_orig_type(const struct btf *b= tf, > > + const struct btf_type *t) > > +{ > > + while (t && BTF_INFO_KIND(t->info) =3D=3D BTF_KIND_TYPEDEF) > > + t =3D btf_type_by_id(btf, t->type); > Only typedef is allowed? Not even const? > If that is not the case, can btf_type_id_size() be reused? > The "type following" has already been done once and then remembered > in the verification time. >=20 > If cgroup_storage_check_btf() can only allow typedef, please > move "btf_orig_type()" to the local_storage.c. >=20 > > + > > + return t; > > +} > > + > > #endif > > diff --git a/kernel/bpf/local_storage.c b/kernel/bpf/local_storage.c > > index b65017dead44..7b51fe1aba3c 100644 > > --- a/kernel/bpf/local_storage.c > > +++ b/kernel/bpf/local_storage.c > > @@ -1,11 +1,13 @@ > > //SPDX-License-Identifier: GPL-2.0 > > #include > > #include > > +#include > > #include > > #include > > #include > > #include > > #include > > +#include > > =20 > > DEFINE_PER_CPU(struct bpf_cgroup_storage*, bpf_cgroup_storage[MAX_BPF_= CGROUP_STORAGE_TYPE]); > > =20 > > @@ -308,6 +310,91 @@ static int cgroup_storage_delete_elem(struct bpf_m= ap *map, void *key) > > return -EINVAL; > > } > > =20 > > +static int cgroup_storage_check_btf(const struct bpf_map *map, > > + const struct btf *btf, > > + const struct btf_type *key_type, > Actually, in "map_check_btf()" (just before cgroup_storage_check_btf() > is called), btf_type_id_size() has already been called > to get the true size and the resolved type (i.e. BTF_INFO_KIND_STRUCT her= e) > in order to reject "key_size !=3D map->key_size". Hence, the key_type > passed to cgroup_storage_check_btf() here will not be KIND_TYPEDEF or > KIND_CONST. So, the type here is a structure, and its fields are typedefs of ints. Looks like reusing btf_type_id_size() is the best approach. >=20 > > + const struct btf_type *value_type) > > +{ > > + const struct btf_type *st, *t; > > + struct btf_member *m; > > + > > + /* Key is expected to be of struct bpf_cgroup_storage_key type, > > + * which is: > > + * struct bpf_cgroup_storage_key { > > + * __u64 cgroup_inode_id; > > + * __u32 attach_type; > > + * }; > > + */ > > + > > + /* > > + * Key_type must be a structure (or a typedef of a structure) with > > + * two members. > > + */ > > + st =3D btf_orig_type(btf, key_type); > > + if (BTF_INFO_KIND(st->info) !=3D BTF_KIND_STRUCT || > > + BTF_INFO_VLEN(st->info) !=3D 2) > > + return -EINVAL; > > + > > + /* > > + * The first field must be a 64 bit integer at 0 offset. > > + */ > > + m =3D (struct btf_member *)(st + 1); > > + t =3D btf_orig_type(btf, btf_type_by_id(btf, m->type)); > > + if (!t || BTF_INFO_KIND(t->info) !=3D BTF_KIND_INT || m->offset || > > + t->size !=3D > > + FIELD_SIZEOF(struct bpf_cgroup_storage_key, cgroup_inode_id)) > Instead of t->size, > BTF_INT_BITS() and BTF_INT_OFFSET() need to be checked (please refer to t= he > key_type check in array_map_check_btf()). Gotcha. >=20 > I think exposing "btf_type_int_is_regular()" from btf.c will be easier he= re. > Actually, add "btf_type_is_reg_int(t, expected_size)" to btf.h and btf.c, > like (uncompiled and untested code): >=20 > /* > * Not a bit field and it must be the expected size. > */ > bool btf_type_is_reg_int(const struct btf_type *t, u32 expected_size) > { > u8 nr_bits, nr_bytes; > u32 int_data; >=20 > if (!btf_type_is_int(t)) > return false; >=20 > int_data =3D btf_type_int(t); > nr_bits =3D BTF_INT_BITS(int_data); > nr_bytes =3D BITS_ROUNDUP_BYTES(nr_bits); > if (BITS_PER_BYTE_MASKED(nr_bits) || > BTF_INT_OFFSET(int_data) || > nr_bytes !=3D expected_size) > return false; >=20 > return true; > } Looks good to me. Will implement in v2. Thanks!