bpf: introduce bpf subcommand BPF_TASK_FD_QUERY

Currently, suppose a userspace application has loaded a bpf program
and attached it to a tracepoint/kprobe/uprobe, and a bpf
introspection tool, e.g., bpftool, wants to show which bpf program
is attached to which tracepoint/kprobe/uprobe. Such attachment
information will be really useful to understand the overall bpf
deployment in the system.

There is a name field (16 bytes) for each program, which could
be used to encode the attachment point. There are some drawbacks
for this approaches. First, bpftool user (e.g., an admin) may not
really understand the association between the name and the
attachment point. Second, if one program is attached to multiple
places, encoding a proper name which can imply all these
attachments becomes difficult.

This patch introduces a new bpf subcommand BPF_TASK_FD_QUERY.
Given a pid and fd, if the <pid, fd> is associated with a
tracepoint/kprobe/uprobe perf event, BPF_TASK_FD_QUERY will return
   . prog_id
   . tracepoint name, or
   . k[ret]probe funcname + offset or kernel addr, or
   . u[ret]probe filename + offset
to the userspace.
The user can use "bpftool prog" to find more information about
bpf program itself with prog_id.

Acked-by: Martin KaFai Lau <kafai@fb.com>
Signed-off-by: Yonghong Song <yhs@fb.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

1 files changed, 131 insertions, 0 deletions

diff --git a/kernel/bpf/syscall.c b/kernel/bpf/syscall.c
index 788456c18617..388d4feda348 100644
--- a/kernel/bpf/syscall.c
+++ b/kernel/bpf/syscall.c
@@ -18,7 +18,9 @@
 #include <linux/vmalloc.h>
 #include <linux/mmzone.h>
 #include <linux/anon_inodes.h>
+#include <linux/fdtable.h>
 #include <linux/file.h>
+#include <linux/fs.h>
 #include <linux/license.h>
 #include <linux/filter.h>
 #include <linux/version.h>
@@ -2178,6 +2180,132 @@ static int bpf_btf_get_fd_by_id(const union bpf_attr *attr)
         return btf_get_fd_by_id(attr->btf_id);
 }
 
+static int bpf_task_fd_query_copy(const union bpf_attr *attr,
+                                    union bpf_attr __user *uattr,
+                                    u32 prog_id, u32 fd_type,
+                                    const char *buf, u64 probe_offset,
+                                    u64 probe_addr)
+{
+        char __user *ubuf = u64_to_user_ptr(attr->task_fd_query.buf);
+        u32 len = buf ? strlen(buf) : 0, input_len;
+        int err = 0;
+
+        if (put_user(len, &uattr->task_fd_query.buf_len))
+                return -EFAULT;
+        input_len = attr->task_fd_query.buf_len;
+        if (input_len && ubuf) {
+                if (!len) {
+                        /* nothing to copy, just make ubuf NULL terminated */
+                        char zero = '\0';
+
+                        if (put_user(zero, ubuf))
+                                return -EFAULT;
+                } else if (input_len >= len + 1) {
+                        /* ubuf can hold the string with NULL terminator */
+                        if (copy_to_user(ubuf, buf, len + 1))
+                                return -EFAULT;
+                } else {
+                        /* ubuf cannot hold the string with NULL terminator,
+                         * do a partial copy with NULL terminator.
+                         */
+                        char zero = '\0';
+
+                        err = -ENOSPC;
+                        if (copy_to_user(ubuf, buf, input_len - 1))
+                                return -EFAULT;
+                        if (put_user(zero, ubuf + input_len - 1))
+                                return -EFAULT;
+                }
+        }
+
+        if (put_user(prog_id, &uattr->task_fd_query.prog_id) ||
+            put_user(fd_type, &uattr->task_fd_query.fd_type) ||
+            put_user(probe_offset, &uattr->task_fd_query.probe_offset) ||
+            put_user(probe_addr, &uattr->task_fd_query.probe_addr))
+                return -EFAULT;
+
+        return err;
+}
+
+#define BPF_TASK_FD_QUERY_LAST_FIELD task_fd_query.probe_addr
+
+static int bpf_task_fd_query(const union bpf_attr *attr,
+                             union bpf_attr __user *uattr)
+{
+        pid_t pid = attr->task_fd_query.pid;
+        u32 fd = attr->task_fd_query.fd;
+        const struct perf_event *event;
+        struct files_struct *files;
+        struct task_struct *task;
+        struct file *file;
+        int err;
+
+        if (CHECK_ATTR(BPF_TASK_FD_QUERY))
+                return -EINVAL;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
+        if (attr->task_fd_query.flags != 0)
+                return -EINVAL;
+
+        task = get_pid_task(find_vpid(pid), PIDTYPE_PID);
+        if (!task)
+                return -ENOENT;
+
+        files = get_files_struct(task);
+        put_task_struct(task);
+        if (!files)
+                return -ENOENT;
+
+        err = 0;
+        spin_lock(&files->file_lock);
+        file = fcheck_files(files, fd);
+        if (!file)
+                err = -EBADF;
+        else
+                get_file(file);
+        spin_unlock(&files->file_lock);
+        put_files_struct(files);
+
+        if (err)
+                goto out;
+
+        if (file->f_op == &bpf_raw_tp_fops) {
+                struct bpf_raw_tracepoint *raw_tp = file->private_data;
+                struct bpf_raw_event_map *btp = raw_tp->btp;
+
+                err = bpf_task_fd_query_copy(attr, uattr,
+                                             raw_tp->prog->aux->id,
+                                             BPF_FD_TYPE_RAW_TRACEPOINT,
+                                             btp->tp->name, 0, 0);
+                goto put_file;
+        }
+
+        event = perf_get_event(file);
+        if (!IS_ERR(event)) {
+                u64 probe_offset, probe_addr;
+                u32 prog_id, fd_type;
+                const char *buf;
+
+                err = bpf_get_perf_event_info(event, &prog_id, &fd_type,
+                                              &buf, &probe_offset,
+                                              &probe_addr);
+                if (!err)
+                        err = bpf_task_fd_query_copy(attr, uattr, prog_id,
+                                                     fd_type, buf,
+                                                     probe_offset,
+                                                     probe_addr);
+                goto put_file;
+        }
+
+        err = -ENOTSUPP;
+put_file:
+        fput(file);
+out:
+        return err;
+}
+
 SYSCALL_DEFINE3(bpf, int, cmd, union bpf_attr __user *, uattr, unsigned int, size)
 {
         union bpf_attr attr = {};
@@ -2264,6 +2392,9 @@ SYSCALL_DEFINE3(bpf, int, cmd, union bpf_attr __user *, uattr, unsigned int, siz
         case BPF_BTF_GET_FD_BY_ID:
                 err = bpf_btf_get_fd_by_id(&attr);
                 break;
+        case BPF_TASK_FD_QUERY:
+                err = bpf_task_fd_query(&attr, uattr);
+                break;
         default:
                 err = -EINVAL;
                 break;