[RFC bpf-next v4 0/6] Share user memory to BPF program through task storage map.

Kui-Feng Lee
2024-08-16T19:12:18Z

Some of BPF schedulers (sched_ext) need hints from user programs to do
a better job. For example, a scheduler can handle a task in a
different way if it knows a task is doing GC. So, we need an efficient
way to share the information between user programs and BPF
programs. Sharing memory between user programs and BPF programs is
what this patchset does.

== REQUIREMENT ==

This patchset enables every task in every process to share a small
chunk of memory of it's own with a BPF scheduler. So, they can update
the hints without expensive overhead of syscalls. It also wants every
task sees only the data/memory belong to the task/or the task's
process.

== DESIGN ==

This patchset enables BPF prorams to embed __uptr; uptr in the values
of task storage maps. A uptr field can only be set by user programs by
updating map element value through a syscall. A uptr points to a block
of memory allocated by the user program updating the element
value. The memory will be pinned to ensure it staying in the core
memory and to avoid a page fault when the BPF program accesses it.

For example, the following code fragment is a part of a BPF program
that embeds a __uptr field "udata" in the value type "struct
value_type" of the task storage map "datamap". The size of the memory
pointed by a uptr is determized by its type. Here we have "struct
user_data". The BPF program can read and write this block of memory
directly.

File task_ls_uptr.c:

struct user_data {
int a;
int b;
int result;
};

struct value_type {
struct user_data __uptr *udata;
};

struct {
__uint(type, BPF_MAP_TYPE_TASK_STORAGE);
__uint(map_flags, BPF_F_NO_PREALLOC);
__type(key, int);
__type(value, struct value_type);
} datamap SEC(".maps");

pid_t target_pid = 0;

SEC("tp_btf/sys_enter")
int BPF_PROG(on_enter, struct pt_regs *regs, long id)
{
struct task_struct *task;
struct value_type *ptr;
struct user_data *udata;

task = bpf_get_current_task_btf();
if (task->pid != target_pid)
return 0;

ptr = bpf_task_storage_get(&datamap, task, 0,
BPF_LOCAL_STORAGE_GET_F_CREATE);
if (!ptr)
return 0;

udata = ptr->udata;
if (udata)
udata->result = udata->a + udata->b;

return 0;
}

The following code fragment is a corresponding user program. It calls
bpf_map_update_elem() to update "datamap" and point "udata" to a the
memory block residing in one page. The memory pointed by "udata" will
be shared between the BPF program and the user program and should not
cross multiple pages.

static void test_uptr(void)
{
struct task_ls_uptr *skel = NULL;
static struct user_data user_data __attribute__((aligned(16))) = {
.a = 1,
.b = 2,
.result = 0,
};
struct value_type value;
int task_fd = -1;
int err;

value.udata = &user_data;

task_fd = sys_pidfd_open(getpid(), 0);
if (!ASSERT_NEQ(task_fd, -1, "sys_pidfd_open"))
goto out;

skel = task_ls_uptr__open_and_load();
if (!ASSERT_OK_PTR(skel, "skel_open_and_load"))
goto out;

err = bpf_map_update_elem(bpf_map__fd(skel->maps.datamap), &task_fd, &value, 0);
if (!ASSERT_OK(err, "update datamap"))
goto out;

skel->bss->target_pid = syscall(SYS_gettid);

err = task_ls_uptr__attach(skel);
if (!ASSERT_OK(err, "skel_attach"))
goto out;

syscall(SYS_gettid);
syscall(SYS_gettid);

ASSERT_EQ(user_data->a + user_data->b, user_data->result, "result");
out:
task_ls_uptr__destroy(skel);
close(task_fd);
munmap(user_data, sizeof(user_data));
}

== MEMORY ==

In order to use memory efficiently, we don't want to pin a large
number of pages. To archieve that, user programs should collect the
memory blocks pointed by uptrs together to share memory pages if
possible. It avoid the situation that pin one page for each thread in
a process. Instead, we can have several threads pointing their uptrs
to the same page but with different offsets.

Although it is not necessary, avoiding the memory pointed by an uptr
crossing the boundary of a page can prevent an additional mapping in
the kernel address space.

== RESTRICT ==

The memory pointed by a uptr should reside in one memory
page. Crossing multi-pages is not supported at the moment.

Only task storage map have been supported at the moment.

The values of uptrs can only be updated by user programs through
syscalls.

bpf_map_lookup_elem() from userspace returns zeroed values for uptrs
to prevent leaking information of the kernel.

---

Changes from v3:

- Merge part 4 and 5 as the new part 4 in order to cease the warning
of unused functions from CI.

Changes from v1:

- Rename BPF_KPTR_USER to BPF_UPTR.

- Restrict uptr to one page.

- Mark uptr with PTR_TO_MEM | PTR_MAY_BE_NULL and with the size of
the target type.

- Move uptr away from bpf_obj_memcpy() by introducing
bpf_obj_uptrcpy() and copy_map_uptr_locked().

- Remove the BPF_FROM_USER flag.

- Align the meory pointed by an uptr in the test case. Remove the
uptr of mmapped memory.

v3: https://lore.kernel.org/all/20240814033010.2980635-1-thinker.li@gmail.com/
v1: https://lore.kernel.org/all/20240807235755.1435806-1-thinker.li@gmail.com/

Kui-Feng Lee (6):
bpf: define BPF_UPTR a new enumerator of btf_field_type.
bpf: Parse and support "uptr" tag.
bpf: Handle BPF_UPTR in verifier.
bpf: pin, translate, and unpin __uptr from syscalls.
libbpf: define __uptr.
selftests/bpf: test __uptr on the value of a task storage map.

include/linux/bpf.h | 36 ++++
kernel/bpf/bpf_local_storage.c | 23 ++-
kernel/bpf/btf.c | 5 +
kernel/bpf/helpers.c | 20 ++
kernel/bpf/syscall.c | 174 +++++++++++++++++-
kernel/bpf/verifier.c | 37 +++-
tools/lib/bpf/bpf_helpers.h | 1 +
.../bpf/prog_tests/task_local_storage.c | 106 +++++++++++
.../selftests/bpf/progs/task_ls_uptr.c | 65 +++++++
9 files changed, 458 insertions(+), 9 deletions(-)
create mode 100644 tools/testing/selftests/bpf/progs/task_ls_uptr.c

--
2.34.1