[PATCH bpf-next v2 4/6] bpf: Update the struct_ops of a bpf_link.

Kui-Feng Lee
2023-02-23T01:13:04Z

By improving the BPF_LINK_UPDATE command of bpf(), it should allow you
to conveniently switch between different struct_ops on a single
bpf_link. This would enable smoother transitions from one struct_ops
to another.

The struct_ops maps passing along with BPF_LINK_UPDATE should have the
BPF_F_LINK flag.

Signed-off-by: Kui-Feng Lee <kuifeng@meta.com>
---
include/linux/bpf.h | 1 +
include/uapi/linux/bpf.h | 8 +++--
kernel/bpf/bpf_struct_ops.c | 69 +++++++++++++++++++++++++++++++++++++
kernel/bpf/syscall.c | 32 +++++++++++++++++
4 files changed, 108 insertions(+), 2 deletions(-)

diff --git a/include/linux/bpf.h b/include/linux/bpf.h
index 7508ca89e814..9797d9d87a3e 100644
--- a/include/linux/bpf.h
+++ b/include/linux/bpf.h
@@ -1409,6 +1409,7 @@ struct bpf_link_ops {
void (*show_fdinfo)(const struct bpf_link *link, struct seq_file *seq);
int (*fill_link_info)(const struct bpf_link *link,
struct bpf_link_info *info);
+ int (*update_struct_ops)(struct bpf_link *link, struct bpf_map *new_map);
};

struct bpf_tramp_link {
diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h
index cd0ff39981e8..0702e88f7c08 100644
--- a/include/uapi/linux/bpf.h
+++ b/include/uapi/linux/bpf.h
@@ -1555,8 +1555,12 @@ union bpf_attr {

struct { /* struct used by BPF_LINK_UPDATE command */
__u32 link_fd; /* link fd */
- /* new program fd to update link with */
- __u32 new_prog_fd;
+ union {
+ /* new program fd to update link with */
+ __u32 new_prog_fd;
+ /* new struct_ops map fd to update link with */
+ __u32 new_map_fd;
+ };
__u32 flags; /* extra flags */
/* expected link's program fd; is specified only if
* BPF_F_REPLACE flag is set in flags */
diff --git a/kernel/bpf/bpf_struct_ops.c b/kernel/bpf/bpf_struct_ops.c
index cfc69033c1b8..700dc95a6daa 100644
--- a/kernel/bpf/bpf_struct_ops.c
+++ b/kernel/bpf/bpf_struct_ops.c
@@ -961,11 +961,80 @@ static int bpf_struct_ops_map_link_fill_link_info(const struct bpf_link *link,
return 0;
}

+static int bpf_struct_ops_map_link_update(struct bpf_link *link, struct bpf_map *new_map)
+{
+ struct bpf_struct_ops_value *kvalue;
+ struct bpf_struct_ops_map *st_map, *old_st_map;
+ struct bpf_struct_ops_link *st_link;
+ struct bpf_map *old_map;
+ int err = 0;
+
+ if (new_map->map_type != BPF_MAP_TYPE_STRUCT_OPS)
+ return -EINVAL;
+
+ /* Ensure that the registration of the struct_ops matches the
+ * value of the pointer within the link.
+ */
+ mutex_lock(&update_mutex);
+
+ st_link = container_of(link, struct bpf_struct_ops_link, link);
+
+ old_map = st_link->map;
+ if (!old_map) {
+ err = -EINVAL;
+ goto err_out;
+ }
+
+ /* The new and old struct_ops must be the same type. */
+ st_map = container_of(new_map, struct bpf_struct_ops_map, map);
+
+ if (!(new_map->map_flags & BPF_F_LINK)) {
+ err = -EINVAL;
+ goto err_out;
+ }
+
+ old_st_map = container_of(old_map, struct bpf_struct_ops_map, map);
+ if (st_map->st_ops != old_st_map->st_ops) {
+ err = -EINVAL;
+ goto err_out;
+ }
+
+ err = bpf_struct_ops_transit_state_check(st_map, BPF_STRUCT_OPS_STATE_UNREG,
+ BPF_STRUCT_OPS_STATE_INUSE);
+ if (err)
+ goto err_out;
+
+ kvalue = &st_map->kvalue;
+
+ set_memory_rox((long)st_map->image, 1);
+ err = st_map->st_ops->update(kvalue->data, old_st_map->kvalue.data);
+ if (err) {
+ bpf_struct_ops_restore_unreg(st_map);
+
+ set_memory_nx((long)st_map->image, 1);
+ set_memory_rw((long)st_map->image, 1);
+ goto err_out;
+ }
+
+ bpf_map_inc(new_map);
+ rcu_assign_pointer(st_link->map, new_map);
+
+ bpf_struct_ops_transit_state(old_st_map, BPF_STRUCT_OPS_STATE_INUSE,
+ BPF_STRUCT_OPS_STATE_TOBEUNREG);
+ bpf_struct_ops_put(&old_st_map->kvalue.data);
+
+err_out:
+ mutex_unlock(&update_mutex);
+
+ return err;
+}
+
static const struct bpf_link_ops bpf_struct_ops_map_lops = {
.dealloc = bpf_struct_ops_map_link_dealloc,
.detach = bpf_struct_ops_map_link_detach,
.show_fdinfo = bpf_struct_ops_map_link_show_fdinfo,
.fill_link_info = bpf_struct_ops_map_link_fill_link_info,
+ .update_struct_ops = bpf_struct_ops_map_link_update,
};

int bpf_struct_ops_link_create(union bpf_attr *attr)
diff --git a/kernel/bpf/syscall.c b/kernel/bpf/syscall.c
index 2670de8dd0d4..423e6b7a6b41 100644
--- a/kernel/bpf/syscall.c
+++ b/kernel/bpf/syscall.c
@@ -4647,6 +4647,30 @@ static int link_create(union bpf_attr *attr, bpfptr_t uattr)
return ret;
}

+static int link_update_struct_ops(struct bpf_link *link, union bpf_attr *attr)
+{
+ struct bpf_map *new_map;
+ int ret = 0;
+
+ new_map = bpf_map_get(attr->link_update.new_map_fd);
+ if (IS_ERR(new_map))
+ return -EINVAL;
+
+ if (new_map->map_type != BPF_MAP_TYPE_STRUCT_OPS) {
+ ret = -EINVAL;
+ goto out_put_map;
+ }
+
+ if (link->ops->update_struct_ops)
+ ret = link->ops->update_struct_ops(link, new_map);
+ else
+ ret = -EINVAL;
+
+out_put_map:
+ bpf_map_put(new_map);
+ return ret;
+}
+
#define BPF_LINK_UPDATE_LAST_FIELD link_update.old_prog_fd

static int link_update(union bpf_attr *attr)
@@ -4667,6 +4691,14 @@ static int link_update(union bpf_attr *attr)
if (IS_ERR(link))
return PTR_ERR(link);

+ if (link->ops->update_struct_ops) {
+ if (flags) /* always replace the existing one */
+ ret = -EINVAL;
+ else
+ ret = link_update_struct_ops(link, attr);
+ goto out_put_link;
+ }
+
new_prog = bpf_prog_get(attr->link_update.new_prog_fd);
if (IS_ERR(new_prog)) {
ret = PTR_ERR(new_prog);
--
2.30.2