forked from luck/tmp_suning_uos_patched
Merge branch 'bpf-prog-map-ID'
Martin KaFai Lau says:
====================
Introduce bpf ID
This patch series:
1) Introduce ID for both bpf_prog and bpf_map.
2) Add bpf commands to iterate the prog IDs and map
IDs of the system.
3) Add bpf commands to get a prog/map fd from an ID
4) Add bpf command to get prog/map info from a fd.
The prog/map info is a jump start in this patchset
and it is not meant to be a complete list. They can
be extended in the future patches.
v3:
- I suspect v2 may not have applied cleanly.
In particular, patch 1 has conflict with a recent
change in struct bpf_prog_aux introduced at a similar time frame:
8726679a0f ("bpf: teach verifier to track stack depth")
v3 should have fixed it.
v2:
Compiler warning fixes:
- Remove lockdep_is_held() usage. Add comment
to explain the lock situation instead.
- Add static for idr related variables
- Add __user to the uattr param in bpf_prog_get_info_by_fd()
and bpf_map_get_info_by_fd().
====================
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller
commit
286556c0b6
|
|
@ -900,6 +900,7 @@ struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *prog)
|
|||
bpf_jit_binary_lock_ro(header);
|
||||
prog->bpf_func = (void *)ctx.image;
|
||||
prog->jited = 1;
|
||||
prog->jited_len = image_size;
|
||||
|
||||
out_off:
|
||||
kfree(ctx.offset);
|
||||
|
|
|
|||
|
|
@ -1052,6 +1052,7 @@ struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *fp)
|
|||
|
||||
fp->bpf_func = (void *)image;
|
||||
fp->jited = 1;
|
||||
fp->jited_len = alloclen;
|
||||
|
||||
bpf_flush_icache(bpf_hdr, (u8 *)bpf_hdr + (bpf_hdr->pages * PAGE_SIZE));
|
||||
|
||||
|
|
|
|||
|
|
@ -1329,6 +1329,7 @@ struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *fp)
|
|||
bpf_jit_binary_lock_ro(header);
|
||||
fp->bpf_func = (void *) jit.prg_buf;
|
||||
fp->jited = 1;
|
||||
fp->jited_len = jit.size;
|
||||
free_addrs:
|
||||
kfree(jit.addrs);
|
||||
out:
|
||||
|
|
|
|||
|
|
@ -1560,6 +1560,7 @@ struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *prog)
|
|||
|
||||
prog->bpf_func = (void *)ctx.image;
|
||||
prog->jited = 1;
|
||||
prog->jited_len = image_size;
|
||||
|
||||
out_off:
|
||||
kfree(ctx.offset);
|
||||
|
|
|
|||
|
|
@ -1167,6 +1167,7 @@ struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *prog)
|
|||
bpf_jit_binary_lock_ro(header);
|
||||
prog->bpf_func = (void *)image;
|
||||
prog->jited = 1;
|
||||
prog->jited_len = proglen;
|
||||
} else {
|
||||
prog = orig_prog;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -46,6 +46,7 @@ struct bpf_map {
|
|||
u32 max_entries;
|
||||
u32 map_flags;
|
||||
u32 pages;
|
||||
u32 id;
|
||||
struct user_struct *user;
|
||||
const struct bpf_map_ops *ops;
|
||||
struct work_struct work;
|
||||
|
|
@ -172,6 +173,7 @@ struct bpf_prog_aux {
|
|||
u32 used_map_cnt;
|
||||
u32 max_ctx_offset;
|
||||
u32 stack_depth;
|
||||
u32 id;
|
||||
struct latch_tree_node ksym_tnode;
|
||||
struct list_head ksym_lnode;
|
||||
const struct bpf_verifier_ops *ops;
|
||||
|
|
|
|||
|
|
@ -69,8 +69,6 @@ struct bpf_prog_aux;
|
|||
/* BPF program can access up to 512 bytes of stack space. */
|
||||
#define MAX_BPF_STACK 512
|
||||
|
||||
#define BPF_TAG_SIZE 8
|
||||
|
||||
/* Helper macros for filter block array initializers. */
|
||||
|
||||
/* ALU ops on registers, bpf_add|sub|...: dst_reg += src_reg */
|
||||
|
|
@ -432,6 +430,7 @@ struct bpf_prog {
|
|||
kmemcheck_bitfield_end(meta);
|
||||
enum bpf_prog_type type; /* Type of BPF program */
|
||||
u32 len; /* Number of filter blocks */
|
||||
u32 jited_len; /* Size of jited insns in bytes */
|
||||
u8 tag[BPF_TAG_SIZE];
|
||||
struct bpf_prog_aux *aux; /* Auxiliary fields */
|
||||
struct sock_fprog_kern *orig_prog; /* Original BPF program */
|
||||
|
|
|
|||
|
|
@ -82,6 +82,11 @@ enum bpf_cmd {
|
|||
BPF_PROG_ATTACH,
|
||||
BPF_PROG_DETACH,
|
||||
BPF_PROG_TEST_RUN,
|
||||
BPF_PROG_GET_NEXT_ID,
|
||||
BPF_MAP_GET_NEXT_ID,
|
||||
BPF_PROG_GET_FD_BY_ID,
|
||||
BPF_MAP_GET_FD_BY_ID,
|
||||
BPF_OBJ_GET_INFO_BY_FD,
|
||||
};
|
||||
|
||||
enum bpf_map_type {
|
||||
|
|
@ -209,6 +214,21 @@ union bpf_attr {
|
|||
__u32 repeat;
|
||||
__u32 duration;
|
||||
} test;
|
||||
|
||||
struct { /* anonymous struct used by BPF_*_GET_*_ID */
|
||||
union {
|
||||
__u32 start_id;
|
||||
__u32 prog_id;
|
||||
__u32 map_id;
|
||||
};
|
||||
__u32 next_id;
|
||||
};
|
||||
|
||||
struct { /* anonymous struct used by BPF_OBJ_GET_INFO_BY_FD */
|
||||
__u32 bpf_fd;
|
||||
__u32 info_len;
|
||||
__aligned_u64 info;
|
||||
} info;
|
||||
} __attribute__((aligned(8)));
|
||||
|
||||
/* BPF helper function descriptions:
|
||||
|
|
@ -673,4 +693,25 @@ struct xdp_md {
|
|||
__u32 data_end;
|
||||
};
|
||||
|
||||
#define BPF_TAG_SIZE 8
|
||||
|
||||
struct bpf_prog_info {
|
||||
__u32 type;
|
||||
__u32 id;
|
||||
__u8 tag[BPF_TAG_SIZE];
|
||||
__u32 jited_prog_len;
|
||||
__u32 xlated_prog_len;
|
||||
__aligned_u64 jited_prog_insns;
|
||||
__aligned_u64 xlated_prog_insns;
|
||||
} __attribute__((aligned(8)));
|
||||
|
||||
struct bpf_map_info {
|
||||
__u32 type;
|
||||
__u32 id;
|
||||
__u32 key_size;
|
||||
__u32 value_size;
|
||||
__u32 max_entries;
|
||||
__u32 map_flags;
|
||||
} __attribute__((aligned(8)));
|
||||
|
||||
#endif /* _UAPI__LINUX_BPF_H__ */
|
||||
|
|
|
|||
|
|
@ -22,8 +22,13 @@
|
|||
#include <linux/filter.h>
|
||||
#include <linux/version.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/idr.h>
|
||||
|
||||
DEFINE_PER_CPU(int, bpf_prog_active);
|
||||
static DEFINE_IDR(prog_idr);
|
||||
static DEFINE_SPINLOCK(prog_idr_lock);
|
||||
static DEFINE_IDR(map_idr);
|
||||
static DEFINE_SPINLOCK(map_idr_lock);
|
||||
|
||||
int sysctl_unprivileged_bpf_disabled __read_mostly;
|
||||
|
||||
|
|
@ -114,6 +119,37 @@ static void bpf_map_uncharge_memlock(struct bpf_map *map)
|
|||
free_uid(user);
|
||||
}
|
||||
|
||||
static int bpf_map_alloc_id(struct bpf_map *map)
|
||||
{
|
||||
int id;
|
||||
|
||||
spin_lock_bh(&map_idr_lock);
|
||||
id = idr_alloc_cyclic(&map_idr, map, 1, INT_MAX, GFP_ATOMIC);
|
||||
if (id > 0)
|
||||
map->id = id;
|
||||
spin_unlock_bh(&map_idr_lock);
|
||||
|
||||
if (WARN_ON_ONCE(!id))
|
||||
return -ENOSPC;
|
||||
|
||||
return id > 0 ? 0 : id;
|
||||
}
|
||||
|
||||
static void bpf_map_free_id(struct bpf_map *map, bool do_idr_lock)
|
||||
{
|
||||
if (do_idr_lock)
|
||||
spin_lock_bh(&map_idr_lock);
|
||||
else
|
||||
__acquire(&map_idr_lock);
|
||||
|
||||
idr_remove(&map_idr, map->id);
|
||||
|
||||
if (do_idr_lock)
|
||||
spin_unlock_bh(&map_idr_lock);
|
||||
else
|
||||
__release(&map_idr_lock);
|
||||
}
|
||||
|
||||
/* called from workqueue */
|
||||
static void bpf_map_free_deferred(struct work_struct *work)
|
||||
{
|
||||
|
|
@ -135,14 +171,21 @@ static void bpf_map_put_uref(struct bpf_map *map)
|
|||
/* decrement map refcnt and schedule it for freeing via workqueue
|
||||
* (unrelying map implementation ops->map_free() might sleep)
|
||||
*/
|
||||
void bpf_map_put(struct bpf_map *map)
|
||||
static void __bpf_map_put(struct bpf_map *map, bool do_idr_lock)
|
||||
{
|
||||
if (atomic_dec_and_test(&map->refcnt)) {
|
||||
/* bpf_map_free_id() must be called first */
|
||||
bpf_map_free_id(map, do_idr_lock);
|
||||
INIT_WORK(&map->work, bpf_map_free_deferred);
|
||||
schedule_work(&map->work);
|
||||
}
|
||||
}
|
||||
|
||||
void bpf_map_put(struct bpf_map *map)
|
||||
{
|
||||
__bpf_map_put(map, true);
|
||||
}
|
||||
|
||||
void bpf_map_put_with_uref(struct bpf_map *map)
|
||||
{
|
||||
bpf_map_put_uref(map);
|
||||
|
|
@ -236,11 +279,22 @@ static int map_create(union bpf_attr *attr)
|
|||
if (err)
|
||||
goto free_map_nouncharge;
|
||||
|
||||
err = bpf_map_new_fd(map);
|
||||
if (err < 0)
|
||||
/* failed to allocate fd */
|
||||
err = bpf_map_alloc_id(map);
|
||||
if (err)
|
||||
goto free_map;
|
||||
|
||||
err = bpf_map_new_fd(map);
|
||||
if (err < 0) {
|
||||
/* failed to allocate fd.
|
||||
* bpf_map_put() is needed because the above
|
||||
* bpf_map_alloc_id() has published the map
|
||||
* to the userspace and the userspace may
|
||||
* have refcnt-ed it through BPF_MAP_GET_FD_BY_ID.
|
||||
*/
|
||||
bpf_map_put(map);
|
||||
return err;
|
||||
}
|
||||
|
||||
trace_bpf_map_create(map, err);
|
||||
return err;
|
||||
|
||||
|
|
@ -295,6 +349,28 @@ struct bpf_map *bpf_map_get_with_uref(u32 ufd)
|
|||
return map;
|
||||
}
|
||||
|
||||
/* map_idr_lock should have been held */
|
||||
static struct bpf_map *bpf_map_inc_not_zero(struct bpf_map *map,
|
||||
bool uref)
|
||||
{
|
||||
int refold;
|
||||
|
||||
refold = __atomic_add_unless(&map->refcnt, 1, 0);
|
||||
|
||||
if (refold >= BPF_MAX_REFCNT) {
|
||||
__bpf_map_put(map, false);
|
||||
return ERR_PTR(-EBUSY);
|
||||
}
|
||||
|
||||
if (!refold)
|
||||
return ERR_PTR(-ENOENT);
|
||||
|
||||
if (uref)
|
||||
atomic_inc(&map->usercnt);
|
||||
|
||||
return map;
|
||||
}
|
||||
|
||||
int __weak bpf_stackmap_copy(struct bpf_map *map, void *key, void *value)
|
||||
{
|
||||
return -ENOTSUPP;
|
||||
|
|
@ -650,6 +726,42 @@ static void bpf_prog_uncharge_memlock(struct bpf_prog *prog)
|
|||
free_uid(user);
|
||||
}
|
||||
|
||||
static int bpf_prog_alloc_id(struct bpf_prog *prog)
|
||||
{
|
||||
int id;
|
||||
|
||||
spin_lock_bh(&prog_idr_lock);
|
||||
id = idr_alloc_cyclic(&prog_idr, prog, 1, INT_MAX, GFP_ATOMIC);
|
||||
if (id > 0)
|
||||
prog->aux->id = id;
|
||||
spin_unlock_bh(&prog_idr_lock);
|
||||
|
||||
/* id is in [1, INT_MAX) */
|
||||
if (WARN_ON_ONCE(!id))
|
||||
return -ENOSPC;
|
||||
|
||||
return id > 0 ? 0 : id;
|
||||
}
|
||||
|
||||
static void bpf_prog_free_id(struct bpf_prog *prog, bool do_idr_lock)
|
||||
{
|
||||
/* cBPF to eBPF migrations are currently not in the idr store. */
|
||||
if (!prog->aux->id)
|
||||
return;
|
||||
|
||||
if (do_idr_lock)
|
||||
spin_lock_bh(&prog_idr_lock);
|
||||
else
|
||||
__acquire(&prog_idr_lock);
|
||||
|
||||
idr_remove(&prog_idr, prog->aux->id);
|
||||
|
||||
if (do_idr_lock)
|
||||
spin_unlock_bh(&prog_idr_lock);
|
||||
else
|
||||
__release(&prog_idr_lock);
|
||||
}
|
||||
|
||||
static void __bpf_prog_put_rcu(struct rcu_head *rcu)
|
||||
{
|
||||
struct bpf_prog_aux *aux = container_of(rcu, struct bpf_prog_aux, rcu);
|
||||
|
|
@ -659,14 +771,21 @@ static void __bpf_prog_put_rcu(struct rcu_head *rcu)
|
|||
bpf_prog_free(aux->prog);
|
||||
}
|
||||
|
||||
void bpf_prog_put(struct bpf_prog *prog)
|
||||
static void __bpf_prog_put(struct bpf_prog *prog, bool do_idr_lock)
|
||||
{
|
||||
if (atomic_dec_and_test(&prog->aux->refcnt)) {
|
||||
trace_bpf_prog_put_rcu(prog);
|
||||
/* bpf_prog_free_id() must be called first */
|
||||
bpf_prog_free_id(prog, do_idr_lock);
|
||||
bpf_prog_kallsyms_del(prog);
|
||||
call_rcu(&prog->aux->rcu, __bpf_prog_put_rcu);
|
||||
}
|
||||
}
|
||||
|
||||
void bpf_prog_put(struct bpf_prog *prog)
|
||||
{
|
||||
__bpf_prog_put(prog, true);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(bpf_prog_put);
|
||||
|
||||
static int bpf_prog_release(struct inode *inode, struct file *filp)
|
||||
|
|
@ -748,6 +867,24 @@ struct bpf_prog *bpf_prog_inc(struct bpf_prog *prog)
|
|||
}
|
||||
EXPORT_SYMBOL_GPL(bpf_prog_inc);
|
||||
|
||||
/* prog_idr_lock should have been held */
|
||||
static struct bpf_prog *bpf_prog_inc_not_zero(struct bpf_prog *prog)
|
||||
{
|
||||
int refold;
|
||||
|
||||
refold = __atomic_add_unless(&prog->aux->refcnt, 1, 0);
|
||||
|
||||
if (refold >= BPF_MAX_REFCNT) {
|
||||
__bpf_prog_put(prog, false);
|
||||
return ERR_PTR(-EBUSY);
|
||||
}
|
||||
|
||||
if (!refold)
|
||||
return ERR_PTR(-ENOENT);
|
||||
|
||||
return prog;
|
||||
}
|
||||
|
||||
static struct bpf_prog *__bpf_prog_get(u32 ufd, enum bpf_prog_type *type)
|
||||
{
|
||||
struct fd f = fdget(ufd);
|
||||
|
|
@ -857,11 +994,22 @@ static int bpf_prog_load(union bpf_attr *attr)
|
|||
if (err < 0)
|
||||
goto free_used_maps;
|
||||
|
||||
err = bpf_prog_new_fd(prog);
|
||||
if (err < 0)
|
||||
/* failed to allocate fd */
|
||||
err = bpf_prog_alloc_id(prog);
|
||||
if (err)
|
||||
goto free_used_maps;
|
||||
|
||||
err = bpf_prog_new_fd(prog);
|
||||
if (err < 0) {
|
||||
/* failed to allocate fd.
|
||||
* bpf_prog_put() is needed because the above
|
||||
* bpf_prog_alloc_id() has published the prog
|
||||
* to the userspace and the userspace may
|
||||
* have refcnt-ed it through BPF_PROG_GET_FD_BY_ID.
|
||||
*/
|
||||
bpf_prog_put(prog);
|
||||
return err;
|
||||
}
|
||||
|
||||
bpf_prog_kallsyms_add(prog);
|
||||
trace_bpf_prog_load(prog, err);
|
||||
return err;
|
||||
|
|
@ -999,6 +1147,237 @@ static int bpf_prog_test_run(const union bpf_attr *attr,
|
|||
return ret;
|
||||
}
|
||||
|
||||
#define BPF_OBJ_GET_NEXT_ID_LAST_FIELD next_id
|
||||
|
||||
static int bpf_obj_get_next_id(const union bpf_attr *attr,
|
||||
union bpf_attr __user *uattr,
|
||||
struct idr *idr,
|
||||
spinlock_t *lock)
|
||||
{
|
||||
u32 next_id = attr->start_id;
|
||||
int err = 0;
|
||||
|
||||
if (CHECK_ATTR(BPF_OBJ_GET_NEXT_ID) || next_id >= INT_MAX)
|
||||
return -EINVAL;
|
||||
|
||||
if (!capable(CAP_SYS_ADMIN))
|
||||
return -EPERM;
|
||||
|
||||
next_id++;
|
||||
spin_lock_bh(lock);
|
||||
if (!idr_get_next(idr, &next_id))
|
||||
err = -ENOENT;
|
||||
spin_unlock_bh(lock);
|
||||
|
||||
if (!err)
|
||||
err = put_user(next_id, &uattr->next_id);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
#define BPF_PROG_GET_FD_BY_ID_LAST_FIELD prog_id
|
||||
|
||||
static int bpf_prog_get_fd_by_id(const union bpf_attr *attr)
|
||||
{
|
||||
struct bpf_prog *prog;
|
||||
u32 id = attr->prog_id;
|
||||
int fd;
|
||||
|
||||
if (CHECK_ATTR(BPF_PROG_GET_FD_BY_ID))
|
||||
return -EINVAL;
|
||||
|
||||
if (!capable(CAP_SYS_ADMIN))
|
||||
return -EPERM;
|
||||
|
||||
spin_lock_bh(&prog_idr_lock);
|
||||
prog = idr_find(&prog_idr, id);
|
||||
if (prog)
|
||||
prog = bpf_prog_inc_not_zero(prog);
|
||||
else
|
||||
prog = ERR_PTR(-ENOENT);
|
||||
spin_unlock_bh(&prog_idr_lock);
|
||||
|
||||
if (IS_ERR(prog))
|
||||
return PTR_ERR(prog);
|
||||
|
||||
fd = bpf_prog_new_fd(prog);
|
||||
if (fd < 0)
|
||||
bpf_prog_put(prog);
|
||||
|
||||
return fd;
|
||||
}
|
||||
|
||||
#define BPF_MAP_GET_FD_BY_ID_LAST_FIELD map_id
|
||||
|
||||
static int bpf_map_get_fd_by_id(const union bpf_attr *attr)
|
||||
{
|
||||
struct bpf_map *map;
|
||||
u32 id = attr->map_id;
|
||||
int fd;
|
||||
|
||||
if (CHECK_ATTR(BPF_MAP_GET_FD_BY_ID))
|
||||
return -EINVAL;
|
||||
|
||||
if (!capable(CAP_SYS_ADMIN))
|
||||
return -EPERM;
|
||||
|
||||
spin_lock_bh(&map_idr_lock);
|
||||
map = idr_find(&map_idr, id);
|
||||
if (map)
|
||||
map = bpf_map_inc_not_zero(map, true);
|
||||
else
|
||||
map = ERR_PTR(-ENOENT);
|
||||
spin_unlock_bh(&map_idr_lock);
|
||||
|
||||
if (IS_ERR(map))
|
||||
return PTR_ERR(map);
|
||||
|
||||
fd = bpf_map_new_fd(map);
|
||||
if (fd < 0)
|
||||
bpf_map_put(map);
|
||||
|
||||
return fd;
|
||||
}
|
||||
|
||||
static int check_uarg_tail_zero(void __user *uaddr,
|
||||
size_t expected_size,
|
||||
size_t actual_size)
|
||||
{
|
||||
unsigned char __user *addr;
|
||||
unsigned char __user *end;
|
||||
unsigned char val;
|
||||
int err;
|
||||
|
||||
if (actual_size <= expected_size)
|
||||
return 0;
|
||||
|
||||
addr = uaddr + expected_size;
|
||||
end = uaddr + actual_size;
|
||||
|
||||
for (; addr < end; addr++) {
|
||||
err = get_user(val, addr);
|
||||
if (err)
|
||||
return err;
|
||||
if (val)
|
||||
return -E2BIG;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int bpf_prog_get_info_by_fd(struct bpf_prog *prog,
|
||||
const union bpf_attr *attr,
|
||||
union bpf_attr __user *uattr)
|
||||
{
|
||||
struct bpf_prog_info __user *uinfo = u64_to_user_ptr(attr->info.info);
|
||||
struct bpf_prog_info info = {};
|
||||
u32 info_len = attr->info.info_len;
|
||||
char __user *uinsns;
|
||||
u32 ulen;
|
||||
int err;
|
||||
|
||||
err = check_uarg_tail_zero(uinfo, sizeof(info), info_len);
|
||||
if (err)
|
||||
return err;
|
||||
info_len = min_t(u32, sizeof(info), info_len);
|
||||
|
||||
if (copy_from_user(&info, uinfo, info_len))
|
||||
return err;
|
||||
|
||||
info.type = prog->type;
|
||||
info.id = prog->aux->id;
|
||||
|
||||
memcpy(info.tag, prog->tag, sizeof(prog->tag));
|
||||
|
||||
if (!capable(CAP_SYS_ADMIN)) {
|
||||
info.jited_prog_len = 0;
|
||||
info.xlated_prog_len = 0;
|
||||
goto done;
|
||||
}
|
||||
|
||||
ulen = info.jited_prog_len;
|
||||
info.jited_prog_len = prog->jited_len;
|
||||
if (info.jited_prog_len && ulen) {
|
||||
uinsns = u64_to_user_ptr(info.jited_prog_insns);
|
||||
ulen = min_t(u32, info.jited_prog_len, ulen);
|
||||
if (copy_to_user(uinsns, prog->bpf_func, ulen))
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
ulen = info.xlated_prog_len;
|
||||
info.xlated_prog_len = bpf_prog_size(prog->len);
|
||||
if (info.xlated_prog_len && ulen) {
|
||||
uinsns = u64_to_user_ptr(info.xlated_prog_insns);
|
||||
ulen = min_t(u32, info.xlated_prog_len, ulen);
|
||||
if (copy_to_user(uinsns, prog->insnsi, ulen))
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
done:
|
||||
if (copy_to_user(uinfo, &info, info_len) ||
|
||||
put_user(info_len, &uattr->info.info_len))
|
||||
return -EFAULT;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int bpf_map_get_info_by_fd(struct bpf_map *map,
|
||||
const union bpf_attr *attr,
|
||||
union bpf_attr __user *uattr)
|
||||
{
|
||||
struct bpf_map_info __user *uinfo = u64_to_user_ptr(attr->info.info);
|
||||
struct bpf_map_info info = {};
|
||||
u32 info_len = attr->info.info_len;
|
||||
int err;
|
||||
|
||||
err = check_uarg_tail_zero(uinfo, sizeof(info), info_len);
|
||||
if (err)
|
||||
return err;
|
||||
info_len = min_t(u32, sizeof(info), info_len);
|
||||
|
||||
info.type = map->map_type;
|
||||
info.id = map->id;
|
||||
info.key_size = map->key_size;
|
||||
info.value_size = map->value_size;
|
||||
info.max_entries = map->max_entries;
|
||||
info.map_flags = map->map_flags;
|
||||
|
||||
if (copy_to_user(uinfo, &info, info_len) ||
|
||||
put_user(info_len, &uattr->info.info_len))
|
||||
return -EFAULT;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define BPF_OBJ_GET_INFO_BY_FD_LAST_FIELD info.info
|
||||
|
||||
static int bpf_obj_get_info_by_fd(const union bpf_attr *attr,
|
||||
union bpf_attr __user *uattr)
|
||||
{
|
||||
int ufd = attr->info.bpf_fd;
|
||||
struct fd f;
|
||||
int err;
|
||||
|
||||
if (CHECK_ATTR(BPF_OBJ_GET_INFO_BY_FD))
|
||||
return -EINVAL;
|
||||
|
||||
f = fdget(ufd);
|
||||
if (!f.file)
|
||||
return -EBADFD;
|
||||
|
||||
if (f.file->f_op == &bpf_prog_fops)
|
||||
err = bpf_prog_get_info_by_fd(f.file->private_data, attr,
|
||||
uattr);
|
||||
else if (f.file->f_op == &bpf_map_fops)
|
||||
err = bpf_map_get_info_by_fd(f.file->private_data, attr,
|
||||
uattr);
|
||||
else
|
||||
err = -EINVAL;
|
||||
|
||||
fdput(f);
|
||||
return err;
|
||||
}
|
||||
|
||||
SYSCALL_DEFINE3(bpf, int, cmd, union bpf_attr __user *, uattr, unsigned int, size)
|
||||
{
|
||||
union bpf_attr attr = {};
|
||||
|
|
@ -1018,23 +1397,10 @@ SYSCALL_DEFINE3(bpf, int, cmd, union bpf_attr __user *, uattr, unsigned int, siz
|
|||
* user-space does not rely on any kernel feature
|
||||
* extensions we dont know about yet.
|
||||
*/
|
||||
if (size > sizeof(attr)) {
|
||||
unsigned char __user *addr;
|
||||
unsigned char __user *end;
|
||||
unsigned char val;
|
||||
|
||||
addr = (void __user *)uattr + sizeof(attr);
|
||||
end = (void __user *)uattr + size;
|
||||
|
||||
for (; addr < end; addr++) {
|
||||
err = get_user(val, addr);
|
||||
if (err)
|
||||
return err;
|
||||
if (val)
|
||||
return -E2BIG;
|
||||
}
|
||||
size = sizeof(attr);
|
||||
}
|
||||
err = check_uarg_tail_zero(uattr, sizeof(attr), size);
|
||||
if (err)
|
||||
return err;
|
||||
size = min_t(u32, size, sizeof(attr));
|
||||
|
||||
/* copy attributes from user space, may be less than sizeof(bpf_attr) */
|
||||
if (copy_from_user(&attr, uattr, size) != 0)
|
||||
|
|
@ -1076,6 +1442,23 @@ SYSCALL_DEFINE3(bpf, int, cmd, union bpf_attr __user *, uattr, unsigned int, siz
|
|||
case BPF_PROG_TEST_RUN:
|
||||
err = bpf_prog_test_run(&attr, uattr);
|
||||
break;
|
||||
case BPF_PROG_GET_NEXT_ID:
|
||||
err = bpf_obj_get_next_id(&attr, uattr,
|
||||
&prog_idr, &prog_idr_lock);
|
||||
break;
|
||||
case BPF_MAP_GET_NEXT_ID:
|
||||
err = bpf_obj_get_next_id(&attr, uattr,
|
||||
&map_idr, &map_idr_lock);
|
||||
break;
|
||||
case BPF_PROG_GET_FD_BY_ID:
|
||||
err = bpf_prog_get_fd_by_id(&attr);
|
||||
break;
|
||||
case BPF_MAP_GET_FD_BY_ID:
|
||||
err = bpf_map_get_fd_by_id(&attr);
|
||||
break;
|
||||
case BPF_OBJ_GET_INFO_BY_FD:
|
||||
err = bpf_obj_get_info_by_fd(&attr, uattr);
|
||||
break;
|
||||
default:
|
||||
err = -EINVAL;
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -82,6 +82,11 @@ enum bpf_cmd {
|
|||
BPF_PROG_ATTACH,
|
||||
BPF_PROG_DETACH,
|
||||
BPF_PROG_TEST_RUN,
|
||||
BPF_PROG_GET_NEXT_ID,
|
||||
BPF_MAP_GET_NEXT_ID,
|
||||
BPF_PROG_GET_FD_BY_ID,
|
||||
BPF_MAP_GET_FD_BY_ID,
|
||||
BPF_OBJ_GET_INFO_BY_FD,
|
||||
};
|
||||
|
||||
enum bpf_map_type {
|
||||
|
|
@ -209,6 +214,21 @@ union bpf_attr {
|
|||
__u32 repeat;
|
||||
__u32 duration;
|
||||
} test;
|
||||
|
||||
struct { /* anonymous struct used by BPF_*_GET_*_ID */
|
||||
union {
|
||||
__u32 start_id;
|
||||
__u32 prog_id;
|
||||
__u32 map_id;
|
||||
};
|
||||
__u32 next_id;
|
||||
};
|
||||
|
||||
struct { /* anonymous struct used by BPF_OBJ_GET_INFO_BY_FD */
|
||||
__u32 bpf_fd;
|
||||
__u32 info_len;
|
||||
__aligned_u64 info;
|
||||
} info;
|
||||
} __attribute__((aligned(8)));
|
||||
|
||||
/* BPF helper function descriptions:
|
||||
|
|
@ -673,4 +693,25 @@ struct xdp_md {
|
|||
__u32 data_end;
|
||||
};
|
||||
|
||||
#define BPF_TAG_SIZE 8
|
||||
|
||||
struct bpf_prog_info {
|
||||
__u32 type;
|
||||
__u32 id;
|
||||
__u8 tag[BPF_TAG_SIZE];
|
||||
__u32 jited_prog_len;
|
||||
__u32 xlated_prog_len;
|
||||
__aligned_u64 jited_prog_insns;
|
||||
__aligned_u64 xlated_prog_insns;
|
||||
} __attribute__((aligned(8)));
|
||||
|
||||
struct bpf_map_info {
|
||||
__u32 type;
|
||||
__u32 id;
|
||||
__u32 key_size;
|
||||
__u32 value_size;
|
||||
__u32 max_entries;
|
||||
__u32 map_flags;
|
||||
} __attribute__((aligned(8)));
|
||||
|
||||
#endif /* _UAPI__LINUX_BPF_H__ */
|
||||
|
|
|
|||
|
|
@ -257,3 +257,71 @@ int bpf_prog_test_run(int prog_fd, int repeat, void *data, __u32 size,
|
|||
*duration = attr.test.duration;
|
||||
return ret;
|
||||
}
|
||||
|
||||
int bpf_prog_get_next_id(__u32 start_id, __u32 *next_id)
|
||||
{
|
||||
union bpf_attr attr;
|
||||
int err;
|
||||
|
||||
bzero(&attr, sizeof(attr));
|
||||
attr.start_id = start_id;
|
||||
|
||||
err = sys_bpf(BPF_PROG_GET_NEXT_ID, &attr, sizeof(attr));
|
||||
if (!err)
|
||||
*next_id = attr.next_id;
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
int bpf_map_get_next_id(__u32 start_id, __u32 *next_id)
|
||||
{
|
||||
union bpf_attr attr;
|
||||
int err;
|
||||
|
||||
bzero(&attr, sizeof(attr));
|
||||
attr.start_id = start_id;
|
||||
|
||||
err = sys_bpf(BPF_MAP_GET_NEXT_ID, &attr, sizeof(attr));
|
||||
if (!err)
|
||||
*next_id = attr.next_id;
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
int bpf_prog_get_fd_by_id(__u32 id)
|
||||
{
|
||||
union bpf_attr attr;
|
||||
|
||||
bzero(&attr, sizeof(attr));
|
||||
attr.prog_id = id;
|
||||
|
||||
return sys_bpf(BPF_PROG_GET_FD_BY_ID, &attr, sizeof(attr));
|
||||
}
|
||||
|
||||
int bpf_map_get_fd_by_id(__u32 id)
|
||||
{
|
||||
union bpf_attr attr;
|
||||
|
||||
bzero(&attr, sizeof(attr));
|
||||
attr.map_id = id;
|
||||
|
||||
return sys_bpf(BPF_MAP_GET_FD_BY_ID, &attr, sizeof(attr));
|
||||
}
|
||||
|
||||
int bpf_obj_get_info_by_fd(int prog_fd, void *info, __u32 *info_len)
|
||||
{
|
||||
union bpf_attr attr;
|
||||
int err;
|
||||
|
||||
bzero(&attr, sizeof(attr));
|
||||
bzero(info, *info_len);
|
||||
attr.info.bpf_fd = prog_fd;
|
||||
attr.info.info_len = *info_len;
|
||||
attr.info.info = ptr_to_u64(info);
|
||||
|
||||
err = sys_bpf(BPF_OBJ_GET_INFO_BY_FD, &attr, sizeof(attr));
|
||||
if (!err)
|
||||
*info_len = attr.info.info_len;
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -54,5 +54,10 @@ int bpf_prog_detach(int attachable_fd, enum bpf_attach_type type);
|
|||
int bpf_prog_test_run(int prog_fd, int repeat, void *data, __u32 size,
|
||||
void *data_out, __u32 *size_out, __u32 *retval,
|
||||
__u32 *duration);
|
||||
int bpf_prog_get_next_id(__u32 start_id, __u32 *next_id);
|
||||
int bpf_map_get_next_id(__u32 start_id, __u32 *next_id);
|
||||
int bpf_prog_get_fd_by_id(__u32 id);
|
||||
int bpf_map_get_fd_by_id(__u32 id);
|
||||
int bpf_obj_get_info_by_fd(int prog_fd, void *info, __u32 *info_len);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ LDLIBS += -lcap -lelf
|
|||
TEST_GEN_PROGS = test_verifier test_tag test_maps test_lru_map test_lpm_map test_progs \
|
||||
test_align
|
||||
|
||||
TEST_GEN_FILES = test_pkt_access.o test_xdp.o test_l4lb.o test_tcp_estats.o
|
||||
TEST_GEN_FILES = test_pkt_access.o test_xdp.o test_l4lb.o test_tcp_estats.o test_obj_id.o
|
||||
|
||||
TEST_PROGS := test_kmod.sh
|
||||
|
||||
|
|
|
|||
35
tools/testing/selftests/bpf/test_obj_id.c
Normal file
35
tools/testing/selftests/bpf/test_obj_id.c
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
/* Copyright (c) 2017 Facebook
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of version 2 of the GNU General Public
|
||||
* License as published by the Free Software Foundation.
|
||||
*/
|
||||
#include <stddef.h>
|
||||
#include <linux/bpf.h>
|
||||
#include <linux/pkt_cls.h>
|
||||
#include "bpf_helpers.h"
|
||||
|
||||
/* It is a dumb bpf program such that it must have no
|
||||
* issue to be loaded since testing the verifier is
|
||||
* not the focus here.
|
||||
*/
|
||||
|
||||
int _version SEC("version") = 1;
|
||||
|
||||
struct bpf_map_def SEC("maps") test_map_id = {
|
||||
.type = BPF_MAP_TYPE_ARRAY,
|
||||
.key_size = sizeof(__u32),
|
||||
.value_size = sizeof(__u64),
|
||||
.max_entries = 1,
|
||||
};
|
||||
|
||||
SEC("test_prog_id")
|
||||
int test_prog_id(struct __sk_buff *skb)
|
||||
{
|
||||
__u32 key = 0;
|
||||
__u64 *value;
|
||||
|
||||
value = bpf_map_lookup_elem(&test_map_id, &key);
|
||||
|
||||
return TC_ACT_OK;
|
||||
}
|
||||
|
|
@ -22,6 +22,8 @@ typedef __u16 __sum16;
|
|||
|
||||
#include <sys/wait.h>
|
||||
#include <sys/resource.h>
|
||||
#include <sys/types.h>
|
||||
#include <pwd.h>
|
||||
|
||||
#include <linux/bpf.h>
|
||||
#include <linux/err.h>
|
||||
|
|
@ -70,6 +72,7 @@ static struct {
|
|||
pass_cnt++; \
|
||||
printf("%s:PASS:%s %d nsec\n", __func__, tag, duration);\
|
||||
} \
|
||||
__ret; \
|
||||
})
|
||||
|
||||
static int bpf_prog_load(const char *file, enum bpf_prog_type type,
|
||||
|
|
@ -283,6 +286,193 @@ static void test_tcp_estats(void)
|
|||
bpf_object__close(obj);
|
||||
}
|
||||
|
||||
static inline __u64 ptr_to_u64(const void *ptr)
|
||||
{
|
||||
return (__u64) (unsigned long) ptr;
|
||||
}
|
||||
|
||||
static void test_bpf_obj_id(void)
|
||||
{
|
||||
const __u64 array_magic_value = 0xfaceb00c;
|
||||
const __u32 array_key = 0;
|
||||
const int nr_iters = 2;
|
||||
const char *file = "./test_obj_id.o";
|
||||
|
||||
struct bpf_object *objs[nr_iters];
|
||||
int prog_fds[nr_iters], map_fds[nr_iters];
|
||||
/* +1 to test for the info_len returned by kernel */
|
||||
struct bpf_prog_info prog_infos[nr_iters + 1];
|
||||
struct bpf_map_info map_infos[nr_iters + 1];
|
||||
char jited_insns[128], xlated_insns[128];
|
||||
__u32 i, next_id, info_len, nr_id_found, duration = 0;
|
||||
int err = 0;
|
||||
__u64 array_value;
|
||||
|
||||
err = bpf_prog_get_fd_by_id(0);
|
||||
CHECK(err >= 0 || errno != ENOENT,
|
||||
"get-fd-by-notexist-prog-id", "err %d errno %d\n", err, errno);
|
||||
|
||||
err = bpf_map_get_fd_by_id(0);
|
||||
CHECK(err >= 0 || errno != ENOENT,
|
||||
"get-fd-by-notexist-map-id", "err %d errno %d\n", err, errno);
|
||||
|
||||
for (i = 0; i < nr_iters; i++)
|
||||
objs[i] = NULL;
|
||||
|
||||
/* Check bpf_obj_get_info_by_fd() */
|
||||
for (i = 0; i < nr_iters; i++) {
|
||||
err = bpf_prog_load(file, BPF_PROG_TYPE_SOCKET_FILTER,
|
||||
&objs[i], &prog_fds[i]);
|
||||
/* test_obj_id.o is a dumb prog. It should never fail
|
||||
* to load.
|
||||
*/
|
||||
assert(!err);
|
||||
|
||||
/* Check getting prog info */
|
||||
info_len = sizeof(struct bpf_prog_info) * 2;
|
||||
prog_infos[i].jited_prog_insns = ptr_to_u64(jited_insns);
|
||||
prog_infos[i].jited_prog_len = sizeof(jited_insns);
|
||||
prog_infos[i].xlated_prog_insns = ptr_to_u64(xlated_insns);
|
||||
prog_infos[i].xlated_prog_len = sizeof(xlated_insns);
|
||||
err = bpf_obj_get_info_by_fd(prog_fds[i], &prog_infos[i],
|
||||
&info_len);
|
||||
if (CHECK(err ||
|
||||
prog_infos[i].type != BPF_PROG_TYPE_SOCKET_FILTER ||
|
||||
info_len != sizeof(struct bpf_prog_info) ||
|
||||
!prog_infos[i].jited_prog_len ||
|
||||
!prog_infos[i].xlated_prog_len,
|
||||
"get-prog-info(fd)",
|
||||
"err %d errno %d i %d type %d(%d) info_len %u(%lu) jited_prog_len %u xlated_prog_len %u\n",
|
||||
err, errno, i,
|
||||
prog_infos[i].type, BPF_PROG_TYPE_SOCKET_FILTER,
|
||||
info_len, sizeof(struct bpf_prog_info),
|
||||
prog_infos[i].jited_prog_len,
|
||||
prog_infos[i].xlated_prog_len))
|
||||
goto done;
|
||||
|
||||
map_fds[i] = bpf_find_map(__func__, objs[i], "test_map_id");
|
||||
assert(map_fds[i] >= 0);
|
||||
err = bpf_map_update_elem(map_fds[i], &array_key,
|
||||
&array_magic_value, 0);
|
||||
assert(!err);
|
||||
|
||||
/* Check getting map info */
|
||||
info_len = sizeof(struct bpf_map_info) * 2;
|
||||
err = bpf_obj_get_info_by_fd(map_fds[i], &map_infos[i],
|
||||
&info_len);
|
||||
if (CHECK(err ||
|
||||
map_infos[i].type != BPF_MAP_TYPE_ARRAY ||
|
||||
map_infos[i].key_size != sizeof(__u32) ||
|
||||
map_infos[i].value_size != sizeof(__u64) ||
|
||||
map_infos[i].max_entries != 1 ||
|
||||
map_infos[i].map_flags != 0 ||
|
||||
info_len != sizeof(struct bpf_map_info),
|
||||
"get-map-info(fd)",
|
||||
"err %d errno %d type %d(%d) info_len %u(%lu) key_size %u value_size %u max_entries %u map_flags %X\n",
|
||||
err, errno,
|
||||
map_infos[i].type, BPF_MAP_TYPE_ARRAY,
|
||||
info_len, sizeof(struct bpf_map_info),
|
||||
map_infos[i].key_size,
|
||||
map_infos[i].value_size,
|
||||
map_infos[i].max_entries,
|
||||
map_infos[i].map_flags))
|
||||
goto done;
|
||||
}
|
||||
|
||||
/* Check bpf_prog_get_next_id() */
|
||||
nr_id_found = 0;
|
||||
next_id = 0;
|
||||
while (!bpf_prog_get_next_id(next_id, &next_id)) {
|
||||
struct bpf_prog_info prog_info;
|
||||
int prog_fd;
|
||||
|
||||
info_len = sizeof(prog_info);
|
||||
|
||||
prog_fd = bpf_prog_get_fd_by_id(next_id);
|
||||
if (prog_fd < 0 && errno == ENOENT)
|
||||
/* The bpf_prog is in the dead row */
|
||||
continue;
|
||||
if (CHECK(prog_fd < 0, "get-prog-fd(next_id)",
|
||||
"prog_fd %d next_id %d errno %d\n",
|
||||
prog_fd, next_id, errno))
|
||||
break;
|
||||
|
||||
for (i = 0; i < nr_iters; i++)
|
||||
if (prog_infos[i].id == next_id)
|
||||
break;
|
||||
|
||||
if (i == nr_iters)
|
||||
continue;
|
||||
|
||||
nr_id_found++;
|
||||
|
||||
err = bpf_obj_get_info_by_fd(prog_fd, &prog_info, &info_len);
|
||||
CHECK(err || info_len != sizeof(struct bpf_prog_info) ||
|
||||
memcmp(&prog_info, &prog_infos[i], info_len),
|
||||
"get-prog-info(next_id->fd)",
|
||||
"err %d errno %d info_len %u(%lu) memcmp %d\n",
|
||||
err, errno, info_len, sizeof(struct bpf_prog_info),
|
||||
memcmp(&prog_info, &prog_infos[i], info_len));
|
||||
|
||||
close(prog_fd);
|
||||
}
|
||||
CHECK(nr_id_found != nr_iters,
|
||||
"check total prog id found by get_next_id",
|
||||
"nr_id_found %u(%u)\n",
|
||||
nr_id_found, nr_iters);
|
||||
|
||||
/* Check bpf_map_get_next_id() */
|
||||
nr_id_found = 0;
|
||||
next_id = 0;
|
||||
while (!bpf_map_get_next_id(next_id, &next_id)) {
|
||||
struct bpf_map_info map_info;
|
||||
int map_fd;
|
||||
|
||||
info_len = sizeof(map_info);
|
||||
|
||||
map_fd = bpf_map_get_fd_by_id(next_id);
|
||||
if (map_fd < 0 && errno == ENOENT)
|
||||
/* The bpf_map is in the dead row */
|
||||
continue;
|
||||
if (CHECK(map_fd < 0, "get-map-fd(next_id)",
|
||||
"map_fd %d next_id %u errno %d\n",
|
||||
map_fd, next_id, errno))
|
||||
break;
|
||||
|
||||
for (i = 0; i < nr_iters; i++)
|
||||
if (map_infos[i].id == next_id)
|
||||
break;
|
||||
|
||||
if (i == nr_iters)
|
||||
continue;
|
||||
|
||||
nr_id_found++;
|
||||
|
||||
err = bpf_map_lookup_elem(map_fd, &array_key, &array_value);
|
||||
assert(!err);
|
||||
|
||||
err = bpf_obj_get_info_by_fd(map_fd, &map_info, &info_len);
|
||||
CHECK(err || info_len != sizeof(struct bpf_map_info) ||
|
||||
memcmp(&map_info, &map_infos[i], info_len) ||
|
||||
array_value != array_magic_value,
|
||||
"check get-map-info(next_id->fd)",
|
||||
"err %d errno %d info_len %u(%lu) memcmp %d array_value %llu(%llu)\n",
|
||||
err, errno, info_len, sizeof(struct bpf_map_info),
|
||||
memcmp(&map_info, &map_infos[i], info_len),
|
||||
array_value, array_magic_value);
|
||||
|
||||
close(map_fd);
|
||||
}
|
||||
CHECK(nr_id_found != nr_iters,
|
||||
"check total map id found by get_next_id",
|
||||
"nr_id_found %u(%u)\n",
|
||||
nr_id_found, nr_iters);
|
||||
|
||||
done:
|
||||
for (i = 0; i < nr_iters; i++)
|
||||
bpf_object__close(objs[i]);
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
struct rlimit rinf = { RLIM_INFINITY, RLIM_INFINITY };
|
||||
|
|
@ -293,6 +483,7 @@ int main(void)
|
|||
test_xdp();
|
||||
test_l4lb();
|
||||
test_tcp_estats();
|
||||
test_bpf_obj_id();
|
||||
|
||||
printf("Summary: %d PASSED, %d FAILED\n", pass_cnt, error_cnt);
|
||||
return 0;
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user