bpf: Refactor bpf_iter_reg to have separate seq_info member

There is no functionality change for this patch.
Struct bpf_iter_reg is used to register a bpf_iter target,
which includes information for both prog_load, link_create
and seq_file creation.

This patch puts fields related seq_file creation into
a different structure. This will be useful for map
elements iterator where one iterator covers different
map types and different map types may have different
seq_ops, init/fini private_data function and
private_data size.

Signed-off-by: Yonghong Song <yhs@fb.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Link: https://lore.kernel.org/bpf/20200723184109.590030-1-yhs@fb.com

diff --git a/include/linux/bpf.h b/include/linux/bpf.h
index 72221ae..127067f 100644 (file)
--- a/include/linux/bpf.h
+++ b/include/linux/bpf.h
@@ -37,6 +37,15 @@ struct seq_operations;
 extern struct idr btf_idr;
 extern spinlock_t btf_idr_lock;
 
+typedef int (*bpf_iter_init_seq_priv_t)(void *private_data);
+typedef void (*bpf_iter_fini_seq_priv_t)(void *private_data);
+struct bpf_iter_seq_info {
+       const struct seq_operations *seq_ops;
+       bpf_iter_init_seq_priv_t init_seq_private;
+       bpf_iter_fini_seq_priv_t fini_seq_private;
+       u32 seq_priv_size;
+};
+
 /* map is generic key/value storage optionally accesible by eBPF programs */
 struct bpf_map_ops {
        /* funcs callable from userspace (via syscall) */
@@ -1189,18 +1198,12 @@ int bpf_obj_get_user(const char __user *pathname, int flags);
        extern int bpf_iter_ ## target(args);                   \
        int __init bpf_iter_ ## target(args) { return 0; }
 
-typedef int (*bpf_iter_init_seq_priv_t)(void *private_data);
-typedef void (*bpf_iter_fini_seq_priv_t)(void *private_data);
-
 #define BPF_ITER_CTX_ARG_MAX 2
 struct bpf_iter_reg {
        const char *target;
-       const struct seq_operations *seq_ops;
-       bpf_iter_init_seq_priv_t init_seq_private;
-       bpf_iter_fini_seq_priv_t fini_seq_private;
-       u32 seq_priv_size;
        u32 ctx_arg_info_size;
        struct bpf_ctx_arg_aux ctx_arg_info[BPF_ITER_CTX_ARG_MAX];
+       const struct bpf_iter_seq_info *seq_info;
 };
 
 struct bpf_iter_meta {

diff --git a/kernel/bpf/bpf_iter.c b/kernel/bpf/bpf_iter.c
index dd612b8..5b2387d 100644 (file)
--- a/kernel/bpf/bpf_iter.c
+++ b/kernel/bpf/bpf_iter.c
@@ -218,8 +218,8 @@ static int iter_release(struct inode *inode, struct file *file)
        iter_priv = container_of(seq->private, struct bpf_iter_priv_data,
                                 target_private);
 
-       if (iter_priv->tinfo->reg_info->fini_seq_private)
-               iter_priv->tinfo->reg_info->fini_seq_private(seq->private);
+       if (iter_priv->tinfo->reg_info->seq_info->fini_seq_private)
+               iter_priv->tinfo->reg_info->seq_info->fini_seq_private(seq->private);
 
        bpf_prog_put(iter_priv->prog);
        seq->private = iter_priv;
@@ -433,16 +433,16 @@ static int prepare_seq_file(struct file *file, struct bpf_iter_link *link)
 
        tinfo = link->tinfo;
        total_priv_dsize = offsetof(struct bpf_iter_priv_data, target_private) +
-                          tinfo->reg_info->seq_priv_size;
-       priv_data = __seq_open_private(file, tinfo->reg_info->seq_ops,
+                          tinfo->reg_info->seq_info->seq_priv_size;
+       priv_data = __seq_open_private(file, tinfo->reg_info->seq_info->seq_ops,
                                       total_priv_dsize);
        if (!priv_data) {
                err = -ENOMEM;
                goto release_prog;
        }
 
-       if (tinfo->reg_info->init_seq_private) {
-               err = tinfo->reg_info->init_seq_private(priv_data->target_private);
+       if (tinfo->reg_info->seq_info->init_seq_private) {
+               err = tinfo->reg_info->seq_info->init_seq_private(priv_data->target_private);
                if (err)
                        goto release_seq_file;
        }

diff --git a/kernel/bpf/map_iter.c b/kernel/bpf/map_iter.c
index 5926c76..1a69241 100644 (file)
--- a/kernel/bpf/map_iter.c
+++ b/kernel/bpf/map_iter.c
@@ -81,17 +81,21 @@ static const struct seq_operations bpf_map_seq_ops = {
 BTF_ID_LIST(btf_bpf_map_id)
 BTF_ID(struct, bpf_map)
 
-static struct bpf_iter_reg bpf_map_reg_info = {
-       .target                 = "bpf_map",
+static const struct bpf_iter_seq_info bpf_map_seq_info = {
        .seq_ops                = &bpf_map_seq_ops,
        .init_seq_private       = NULL,
        .fini_seq_private       = NULL,
        .seq_priv_size          = sizeof(struct bpf_iter_seq_map_info),
+};
+
+static struct bpf_iter_reg bpf_map_reg_info = {
+       .target                 = "bpf_map",
        .ctx_arg_info_size      = 1,
        .ctx_arg_info           = {
                { offsetof(struct bpf_iter__bpf_map, map),
                  PTR_TO_BTF_ID_OR_NULL },
        },
+       .seq_info               = &bpf_map_seq_info,
 };
 
 static int __init bpf_map_iter_init(void)

diff --git a/kernel/bpf/prog_iter.c b/kernel/bpf/prog_iter.c
index 6541b57..53a73c8 100644 (file)
--- a/kernel/bpf/prog_iter.c
+++ b/kernel/bpf/prog_iter.c
@@ -81,17 +81,21 @@ static const struct seq_operations bpf_prog_seq_ops = {
 BTF_ID_LIST(btf_bpf_prog_id)
 BTF_ID(struct, bpf_prog)
 
-static struct bpf_iter_reg bpf_prog_reg_info = {
-       .target                 = "bpf_prog",
+static const struct bpf_iter_seq_info bpf_prog_seq_info = {
        .seq_ops                = &bpf_prog_seq_ops,
        .init_seq_private       = NULL,
        .fini_seq_private       = NULL,
        .seq_priv_size          = sizeof(struct bpf_iter_seq_prog_info),
+};
+
+static struct bpf_iter_reg bpf_prog_reg_info = {
+       .target                 = "bpf_prog",
        .ctx_arg_info_size      = 1,
        .ctx_arg_info           = {
                { offsetof(struct bpf_iter__bpf_prog, prog),
                  PTR_TO_BTF_ID_OR_NULL },
        },
+       .seq_info               = &bpf_prog_seq_info,
 };
 
 static int __init bpf_prog_iter_init(void)

diff --git a/kernel/bpf/task_iter.c b/kernel/bpf/task_iter.c
index 1039e52..6d9cd23 100644 (file)
--- a/kernel/bpf/task_iter.c
+++ b/kernel/bpf/task_iter.c
@@ -319,25 +319,32 @@ BTF_ID_LIST(btf_task_file_ids)
 BTF_ID(struct, task_struct)
 BTF_ID(struct, file)
 
-static struct bpf_iter_reg task_reg_info = {
-       .target                 = "task",
+static const struct bpf_iter_seq_info task_seq_info = {
        .seq_ops                = &task_seq_ops,
        .init_seq_private       = init_seq_pidns,
        .fini_seq_private       = fini_seq_pidns,
        .seq_priv_size          = sizeof(struct bpf_iter_seq_task_info),
+};
+
+static struct bpf_iter_reg task_reg_info = {
+       .target                 = "task",
        .ctx_arg_info_size      = 1,
        .ctx_arg_info           = {
                { offsetof(struct bpf_iter__task, task),
                  PTR_TO_BTF_ID_OR_NULL },
        },
+       .seq_info               = &task_seq_info,
 };
 
-static struct bpf_iter_reg task_file_reg_info = {
-       .target                 = "task_file",
+static const struct bpf_iter_seq_info task_file_seq_info = {
        .seq_ops                = &task_file_seq_ops,
        .init_seq_private       = init_seq_pidns,
        .fini_seq_private       = fini_seq_pidns,
        .seq_priv_size          = sizeof(struct bpf_iter_seq_task_file_info),
+};
+
+static struct bpf_iter_reg task_file_reg_info = {
+       .target                 = "task_file",
        .ctx_arg_info_size      = 2,
        .ctx_arg_info           = {
                { offsetof(struct bpf_iter__task_file, task),
@@ -345,6 +352,7 @@ static struct bpf_iter_reg task_file_reg_info = {
                { offsetof(struct bpf_iter__task_file, file),
                  PTR_TO_BTF_ID_OR_NULL },
        },
+       .seq_info               = &task_file_seq_info,
 };
 
 static int __init task_iter_init(void)

diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index f891392..cb288fd 100644 (file)
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -2947,17 +2947,21 @@ static void bpf_iter_fini_tcp(void *priv_data)
        bpf_iter_fini_seq_net(priv_data);
 }
 
-static struct bpf_iter_reg tcp_reg_info = {
-       .target                 = "tcp",
+static const struct bpf_iter_seq_info tcp_seq_info = {
        .seq_ops                = &bpf_iter_tcp_seq_ops,
        .init_seq_private       = bpf_iter_init_tcp,
        .fini_seq_private       = bpf_iter_fini_tcp,
        .seq_priv_size          = sizeof(struct tcp_iter_state),
+};
+
+static struct bpf_iter_reg tcp_reg_info = {
+       .target                 = "tcp",
        .ctx_arg_info_size      = 1,
        .ctx_arg_info           = {
                { offsetof(struct bpf_iter__tcp, sk_common),
                  PTR_TO_BTF_ID_OR_NULL },
        },
+       .seq_info               = &tcp_seq_info,
 };
 
 static void __init bpf_iter_register(void)

diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index 0fb5e4e..1bc50ec 100644 (file)
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -3208,17 +3208,21 @@ static void bpf_iter_fini_udp(void *priv_data)
        bpf_iter_fini_seq_net(priv_data);
 }
 
-static struct bpf_iter_reg udp_reg_info = {
-       .target                 = "udp",
+static const struct bpf_iter_seq_info udp_seq_info = {
        .seq_ops                = &bpf_iter_udp_seq_ops,
        .init_seq_private       = bpf_iter_init_udp,
        .fini_seq_private       = bpf_iter_fini_udp,
        .seq_priv_size          = sizeof(struct udp_iter_state),
+};
+
+static struct bpf_iter_reg udp_reg_info = {
+       .target                 = "udp",
        .ctx_arg_info_size      = 1,
        .ctx_arg_info           = {
                { offsetof(struct bpf_iter__udp, udp_sk),
                  PTR_TO_BTF_ID_OR_NULL },
        },
+       .seq_info               = &udp_seq_info,
 };
 
 static void __init bpf_iter_register(void)

diff --git a/net/ipv6/route.c b/net/ipv6/route.c
index 33f5efb..8bfc57b 100644 (file)
--- a/net/ipv6/route.c
+++ b/net/ipv6/route.c
@@ -6427,17 +6427,21 @@ DEFINE_BPF_ITER_FUNC(ipv6_route, struct bpf_iter_meta *meta, struct fib6_info *r
 BTF_ID_LIST(btf_fib6_info_id)
 BTF_ID(struct, fib6_info)
 
-static struct bpf_iter_reg ipv6_route_reg_info = {
-       .target                 = "ipv6_route",
+static const struct bpf_iter_seq_info ipv6_route_seq_info = {
        .seq_ops                = &ipv6_route_seq_ops,
        .init_seq_private       = bpf_iter_init_seq_net,
        .fini_seq_private       = bpf_iter_fini_seq_net,
        .seq_priv_size          = sizeof(struct ipv6_route_iter),
+};
+
+static struct bpf_iter_reg ipv6_route_reg_info = {
+       .target                 = "ipv6_route",
        .ctx_arg_info_size      = 1,
        .ctx_arg_info           = {
                { offsetof(struct bpf_iter__ipv6_route, rt),
                  PTR_TO_BTF_ID_OR_NULL },
        },
+       .seq_info               = &ipv6_route_seq_info,
 };
 
 static int __init bpf_iter_register(void)

diff --git a/net/netlink/af_netlink.c b/net/netlink/af_netlink.c
index d8921b8..b5f30d7 100644 (file)
--- a/net/netlink/af_netlink.c
+++ b/net/netlink/af_netlink.c
@@ -2807,17 +2807,21 @@ static const struct rhashtable_params netlink_rhashtable_params = {
 BTF_ID_LIST(btf_netlink_sock_id)
 BTF_ID(struct, netlink_sock)
 
-static struct bpf_iter_reg netlink_reg_info = {
-       .target                 = "netlink",
+static const struct bpf_iter_seq_info netlink_seq_info = {
        .seq_ops                = &netlink_seq_ops,
        .init_seq_private       = bpf_iter_init_seq_net,
        .fini_seq_private       = bpf_iter_fini_seq_net,
        .seq_priv_size          = sizeof(struct nl_seq_iter),
+};
+
+static struct bpf_iter_reg netlink_reg_info = {
+       .target                 = "netlink",
        .ctx_arg_info_size      = 1,
        .ctx_arg_info           = {
                { offsetof(struct bpf_iter__netlink, sk),
                  PTR_TO_BTF_ID_OR_NULL },
        },
+       .seq_info               = &netlink_seq_info,
 };
 
 static int __init bpf_iter_register(void)