Lines Matching refs:attr
100 static struct bpf_map *find_and_alloc_map(union bpf_attr *attr)
103 u32 type = attr->map_type;
117 err = ops->map_alloc_check(attr);
122 if (attr->map_ifindex) {
125 map = ops->map_alloc(attr);
327 void bpf_map_init_from_attr(struct bpf_map *map, union bpf_attr *attr)
329 map->map_type = attr->map_type;
330 map->key_size = attr->key_size;
331 map->value_size = attr->value_size;
332 map->max_entries = attr->max_entries;
333 map->map_flags = bpf_map_flags_retain_permanent(attr->map_flags);
334 map->numa_node = bpf_map_attr_numa_node(attr);
712 memchr_inv((void *)&attr->CMD##_LAST_FIELD + sizeof(attr->CMD##_LAST_FIELD), 0, \
713 sizeof(*attr) - offsetof(union bpf_attr, CMD##_LAST_FIELD) - sizeof(attr->CMD##_LAST_FIELD)) != NULL
796 static int map_create(union bpf_attr *attr)
798 int numa_node = bpf_map_attr_numa_node(attr);
809 if (attr->btf_vmlinux_value_type_id) {
810 if (attr->map_type != BPF_MAP_TYPE_STRUCT_OPS || attr->btf_key_type_id || attr->btf_value_type_id) {
813 } else if (attr->btf_key_type_id && !attr->btf_value_type_id) {
817 f_flags = bpf_get_file_flag(attr->map_flags);
827 map = find_and_alloc_map(attr);
832 err = bpf_obj_name_cpy(map->name, attr->map_name, sizeof(attr->map_name));
842 if (attr->btf_key_type_id || attr->btf_value_type_id ||
846 * counter part. Thus, attr->btf_fd has
849 attr->btf_vmlinux_value_type_id) {
852 btf = btf_get_by_fd(attr->btf_fd);
859 if (attr->btf_value_type_id) {
860 err = map_check_btf(map, btf, attr->btf_key_type_id, attr->btf_value_type_id);
866 map->btf_key_type_id = attr->btf_key_type_id;
867 map->btf_value_type_id = attr->btf_value_type_id;
868 map->btf_vmlinux_value_type_id = attr->btf_vmlinux_value_type_id;
1013 static int map_lookup_elem(union bpf_attr *attr)
1015 void __user *ukey = u64_to_user_ptr(attr->key);
1016 void __user *uvalue = u64_to_user_ptr(attr->value);
1017 int ufd = attr->map_fd;
1028 if (attr->flags & ~BPF_F_LOCK) {
1042 if ((attr->flags & BPF_F_LOCK) && !map_value_has_spin_lock(map)) {
1061 err = bpf_map_copy_value(map, key, value, attr->flags);
1084 static int map_update_elem(union bpf_attr *attr)
1086 void __user *ukey = u64_to_user_ptr(attr->key);
1087 void __user *uvalue = u64_to_user_ptr(attr->value);
1088 int ufd = attr->map_fd;
1109 if ((attr->flags & BPF_F_LOCK) && !map_value_has_spin_lock(map)) {
1138 err = bpf_map_update_value(map, f, key, value, attr->flags);
1151 static int map_delete_elem(union bpf_attr *attr)
1153 void __user *ukey = u64_to_user_ptr(attr->key);
1154 int ufd = attr->map_fd;
1205 static int map_get_next_key(union bpf_attr *attr)
1207 void __user *ukey = u64_to_user_ptr(attr->key);
1208 void __user *unext_key = u64_to_user_ptr(attr->next_key);
1209 int ufd = attr->map_fd;
1274 int generic_map_delete_batch(struct bpf_map *map, const union bpf_attr *attr, union bpf_attr __user *uattr)
1276 void __user *keys = u64_to_user_ptr(attr->batch.keys);
1281 if (attr->batch.elem_flags & ~BPF_F_LOCK) {
1285 if ((attr->batch.elem_flags & BPF_F_LOCK) && !map_value_has_spin_lock(map)) {
1289 max_count = attr->batch.count;
1328 int generic_map_update_batch(struct bpf_map *map, const union bpf_attr *attr, union bpf_attr __user *uattr)
1330 void __user *values = u64_to_user_ptr(attr->batch.values);
1331 void __user *keys = u64_to_user_ptr(attr->batch.keys);
1333 int ufd = attr->batch.map_fd;
1338 if (attr->batch.elem_flags & ~BPF_F_LOCK) {
1342 if ((attr->batch.elem_flags & BPF_F_LOCK) && !map_value_has_spin_lock(map)) {
1348 max_count = attr->batch.count;
1372 err = bpf_map_update_value(map, f, key, value, attr->batch.elem_flags);
1392 int generic_map_lookup_batch(struct bpf_map *map, const union bpf_attr *attr, union bpf_attr __user *uattr)
1394 void __user *uobatch = u64_to_user_ptr(attr->batch.out_batch);
1395 void __user *ubatch = u64_to_user_ptr(attr->batch.in_batch);
1396 void __user *values = u64_to_user_ptr(attr->batch.values);
1397 void __user *keys = u64_to_user_ptr(attr->batch.keys);
1402 if (attr->batch.elem_flags & ~BPF_F_LOCK) {
1406 if ((attr->batch.elem_flags & BPF_F_LOCK) && !map_value_has_spin_lock(map)) {
1412 max_count = attr->batch.count;
1450 err = bpf_map_copy_value(map, key, value, attr->batch.elem_flags);
1501 static int map_lookup_and_delete_elem(union bpf_attr *attr)
1503 void __user *ukey = u64_to_user_ptr(attr->key);
1504 void __user *uvalue = u64_to_user_ptr(attr->value);
1505 int ufd = attr->map_fd;
1568 static int map_freeze(const union bpf_attr *attr)
1570 int err = 0, ufd = attr->map_fd;
1996 * bpf_prog_load_fixup_attach_type() sets expected_attach_type in @attr if
2000 static void bpf_prog_load_fixup_attach_type(union bpf_attr *attr)
2002 if (attr->prog_type == BPF_PROG_TYPE_CGROUP_SOCK) {
2006 if (!attr->expected_attach_type) {
2007 attr->expected_attach_type = BPF_CGROUP_INET_SOCK_CREATE;
2147 static int bpf_prog_load(union bpf_attr *attr, union bpf_attr __user *uattr)
2149 enum bpf_prog_type type = attr->prog_type;
2159 if (attr->prog_flags & ~(BPF_F_STRICT_ALIGNMENT | BPF_F_ANY_ALIGNMENT | BPF_F_TEST_STATE_FREQ | BPF_F_SLEEPABLE |
2164 if (!IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && (attr->prog_flags & BPF_F_ANY_ALIGNMENT) &&
2170 if (strncpy_from_user(license, u64_to_user_ptr(attr->license), sizeof(license) - 1) < 0) {
2178 if (attr->insn_cnt == 0 || attr->insn_cnt > (bpf_capable() ? BPF_COMPLEXITY_LIMIT_INSNS : BPF_MAXINSNS)) {
2192 bpf_prog_load_fixup_attach_type(attr);
2193 if (bpf_prog_load_check_attach(type, attr->expected_attach_type, attr->attach_btf_id, attr->attach_prog_fd)) {
2198 prog = bpf_prog_alloc(bpf_prog_size(attr->insn_cnt), GFP_USER);
2203 prog->expected_attach_type = attr->expected_attach_type;
2204 prog->aux->attach_btf_id = attr->attach_btf_id;
2205 if (attr->attach_prog_fd) {
2208 dst_prog = bpf_prog_get(attr->attach_prog_fd);
2216 prog->aux->offload_requested = !!attr->prog_ifindex;
2217 prog->aux->sleepable = attr->prog_flags & BPF_F_SLEEPABLE;
2229 prog->len = attr->insn_cnt;
2232 if (copy_from_user(prog->insns, u64_to_user_ptr(attr->insns), bpf_prog_insn_size(prog)) != 0) {
2243 err = bpf_prog_offload_init(prog, attr);
2256 err = bpf_obj_name_cpy(prog->aux->name, attr->prog_name, sizeof(attr->prog_name));
2262 err = bpf_check(&prog, attr, uattr);
2319 static int bpf_obj_pin(const union bpf_attr *attr)
2321 if (CHECK_ATTR(BPF_OBJ) || attr->file_flags != 0) {
2325 return bpf_obj_pin_user(attr->bpf_fd, u64_to_user_ptr(attr->pathname));
2328 static int bpf_obj_get(const union bpf_attr *attr)
2330 if (CHECK_ATTR(BPF_OBJ) || attr->bpf_fd != 0 || attr->file_flags & ~BPF_OBJ_FLAG_MASK) {
2334 return bpf_obj_get_user(u64_to_user_ptr(attr->pathname), attr->file_flags);
2844 static int bpf_raw_tracepoint_open(const union bpf_attr *attr)
2858 prog = bpf_prog_get(attr->raw_tracepoint.prog_fd);
2867 if (attr->raw_tracepoint.name) {
2885 if (strncpy_from_user(buf, u64_to_user_ptr(attr->raw_tracepoint.name), sizeof(buf) - 1) < 0) {
3010 static int bpf_prog_attach(const union bpf_attr *attr)
3020 if (attr->attach_flags & ~BPF_F_ATTACH_MASK) {
3024 ptype = attach_type_to_prog_type(attr->attach_type);
3029 prog = bpf_prog_get_type(attr->attach_bpf_fd, ptype);
3034 if (bpf_prog_attach_check_attach_type(prog, attr->attach_type)) {
3042 ret = sock_map_get_from_fd(attr, prog);
3045 ret = lirc_prog_attach(attr, prog);
3048 ret = netns_bpf_prog_attach(attr, prog);
3057 ret = cgroup_bpf_prog_attach(attr, ptype, prog);
3071 static int bpf_prog_detach(const union bpf_attr *attr)
3079 ptype = attach_type_to_prog_type(attr->attach_type);
3084 return sock_map_prog_detach(attr, ptype);
3086 return lirc_prog_detach(attr);
3088 return netns_bpf_prog_detach(attr, ptype);
3096 return cgroup_bpf_prog_detach(attr, ptype);
3104 static int bpf_prog_query(const union bpf_attr *attr, union bpf_attr __user *uattr)
3112 if (attr->query.query_flags & ~BPF_F_QUERY_EFFECTIVE) {
3116 switch (attr->query.attach_type) {
3140 return cgroup_bpf_prog_query(attr, uattr);
3142 return lirc_prog_query(attr, uattr);
3145 return netns_bpf_prog_query(attr, uattr);
3153 static int bpf_prog_test_run(const union bpf_attr *attr, union bpf_attr __user *uattr)
3162 if ((attr->test.ctx_size_in && !attr->test.ctx_in) || (!attr->test.ctx_size_in && attr->test.ctx_in)) {
3166 if ((attr->test.ctx_size_out && !attr->test.ctx_out) || (!attr->test.ctx_size_out && attr->test.ctx_out)) {
3170 prog = bpf_prog_get(attr->test.prog_fd);
3176 ret = prog->aux->ops->test_run(prog, attr, uattr);
3185 static int bpf_obj_get_next_id(const union bpf_attr *attr, union bpf_attr __user *uattr, struct idr *idr,
3188 u32 next_id = attr->start_id;
3277 static int bpf_prog_get_fd_by_id(const union bpf_attr *attr)
3280 u32 id = attr->prog_id;
3306 static int bpf_map_get_fd_by_id(const union bpf_attr *attr)
3309 u32 id = attr->map_id;
3313 if (CHECK_ATTR(BPF_MAP_GET_FD_BY_ID) || attr->open_flags & ~BPF_OBJ_FLAG_MASK) {
3321 f_flags = bpf_get_file_flag(attr->open_flags);
3459 static int bpf_prog_get_info_by_fd(struct file *file, struct bpf_prog *prog, const union bpf_attr *attr,
3462 struct bpf_prog_info __user *uinfo = u64_to_user_ptr(attr->info.info);
3464 u32 info_len = attr->info.info_len;
3749 static int bpf_map_get_info_by_fd(struct file *file, struct bpf_map *map, const union bpf_attr *attr,
3752 struct bpf_map_info __user *uinfo = u64_to_user_ptr(attr->info.info);
3754 u32 info_len = attr->info.info_len;
3793 static int bpf_btf_get_info_by_fd(struct file *file, struct btf *btf, const union bpf_attr *attr,
3796 struct bpf_btf_info __user *uinfo = u64_to_user_ptr(attr->info.info);
3797 u32 info_len = attr->info.info_len;
3805 return btf_get_info_by_fd(btf, attr, uattr);
3808 static int bpf_link_get_info_by_fd(struct file *file, struct bpf_link *link, const union bpf_attr *attr,
3811 struct bpf_link_info __user *uinfo = u64_to_user_ptr(attr->info.info);
3813 u32 info_len = attr->info.info_len;
3847 static int bpf_obj_get_info_by_fd(const union bpf_attr *attr, union bpf_attr __user *uattr)
3849 int ufd = attr->info.bpf_fd;
3863 err = bpf_prog_get_info_by_fd(f.file, f.file->private_data, attr, uattr);
3865 err = bpf_map_get_info_by_fd(f.file, f.file->private_data, attr, uattr);
3867 err = bpf_btf_get_info_by_fd(f.file, f.file->private_data, attr, uattr);
3869 err = bpf_link_get_info_by_fd(f.file, f.file->private_data, attr, uattr);
3880 static int bpf_btf_load(const union bpf_attr *attr)
3890 return btf_new_fd(attr);
3895 static int bpf_btf_get_fd_by_id(const union bpf_attr *attr)
3905 return btf_get_fd_by_id(attr->btf_id);
3908 static int bpf_task_fd_query_copy(const union bpf_attr *attr, union bpf_attr __user *uattr, u32 prog_id, u32 fd_type,
3911 char __user *ubuf = u64_to_user_ptr(attr->task_fd_query.buf);
3918 input_len = attr->task_fd_query.buf_len;
3959 static int bpf_task_fd_query(const union bpf_attr *attr, union bpf_attr __user *uattr)
3961 pid_t pid = attr->task_fd_query.pid;
3962 u32 fd = attr->task_fd_query.fd;
3977 if (attr->task_fd_query.flags != 0) {
4014 err = bpf_task_fd_query_copy(attr, uattr, raw_tp->link.prog->aux->id, BPF_FD_TYPE_RAW_TRACEPOINT,
4029 err = bpf_task_fd_query_copy(attr, uattr, prog_id, fd_type, buf, probe_offset, probe_addr);
4050 err = fn(map, attr, uattr); \
4053 static int bpf_map_do_batch(const union bpf_attr *attr, union bpf_attr __user *uattr, int cmd)
4063 ufd = attr->batch.map_fd;
4096 static int tracing_bpf_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)
4098 if (attr->link_create.attach_type != prog->expected_attach_type) {
4103 return bpf_iter_link_attach(attr, prog);
4105 return bpf_tracing_prog_attach(prog, attr->link_create.target_fd, attr->link_create.target_btf_id);
4111 static int link_create(union bpf_attr *attr)
4121 prog = bpf_prog_get(attr->link_create.prog_fd);
4126 ret = bpf_prog_attach_check_attach_type(prog, attr->link_create.attach_type);
4132 ret = tracing_bpf_link_attach(attr, prog);
4136 ptype = attach_type_to_prog_type(attr->link_create.attach_type);
4150 ret = cgroup_bpf_link_attach(attr, prog);
4153 ret = tracing_bpf_link_attach(attr, prog);
4157 ret = netns_bpf_link_create(attr, prog);
4161 ret = bpf_xdp_link_attach(attr, prog);
4177 static int link_update(union bpf_attr *attr)
4188 flags = attr->link_update.flags;
4193 link = bpf_link_get_from_fd(attr->link_update.link_fd);
4198 new_prog = bpf_prog_get(attr->link_update.new_prog_fd);
4205 old_prog = bpf_prog_get(attr->link_update.old_prog_fd);
4211 } else if (attr->link_update.old_prog_fd) {
4236 static int link_detach(union bpf_attr *attr)
4245 link = bpf_link_get_from_fd(attr->link_detach.link_fd);
4291 static int bpf_link_get_fd_by_id(const union bpf_attr *attr)
4294 u32 id = attr->link_id;
4355 static int bpf_enable_stats(union bpf_attr *attr)
4365 switch (attr->enable_stats.type) {
4376 static int bpf_iter_create(union bpf_attr *attr)
4385 if (attr->iter_create.flags) {
4389 link = bpf_link_get_from_fd(attr->iter_create.link_fd);
4402 static int bpf_prog_bind_map(union bpf_attr *attr)
4413 if (attr->prog_bind_map.flags) {
4417 prog = bpf_prog_get(attr->prog_bind_map.prog_fd);
4422 map = bpf_map_get(attr->prog_bind_map.map_fd);
4466 union bpf_attr attr;
4473 err = bpf_check_uarg_tail_zero(uattr, sizeof(attr), size);
4477 size = min_t(u32, size, sizeof(attr));
4480 memset(&attr, 0, sizeof(attr));
4481 if (copy_from_user(&attr, uattr, size) != 0) {
4485 err = security_bpf(cmd, &attr, size);
4492 err = map_create(&attr);
4495 err = map_lookup_elem(&attr);
4498 err = map_update_elem(&attr);
4501 err = map_delete_elem(&attr);
4504 err = map_get_next_key(&attr);
4507 err = map_freeze(&attr);
4510 err = bpf_prog_load(&attr, uattr);
4513 err = bpf_obj_pin(&attr);
4516 err = bpf_obj_get(&attr);
4519 err = bpf_prog_attach(&attr);
4522 err = bpf_prog_detach(&attr);
4525 err = bpf_prog_query(&attr, uattr);
4528 err = bpf_prog_test_run(&attr, uattr);
4531 err = bpf_obj_get_next_id(&attr, uattr, &prog_idr, &prog_idr_lock);
4534 err = bpf_obj_get_next_id(&attr, uattr, &map_idr, &map_idr_lock);
4537 err = bpf_obj_get_next_id(&attr, uattr, &btf_idr, &btf_idr_lock);
4540 err = bpf_prog_get_fd_by_id(&attr);
4543 err = bpf_map_get_fd_by_id(&attr);
4546 err = bpf_obj_get_info_by_fd(&attr, uattr);
4549 err = bpf_raw_tracepoint_open(&attr);
4552 err = bpf_btf_load(&attr);
4555 err = bpf_btf_get_fd_by_id(&attr);
4558 err = bpf_task_fd_query(&attr, uattr);
4561 err = map_lookup_and_delete_elem(&attr);
4564 err = bpf_map_do_batch(&attr, uattr, BPF_MAP_LOOKUP_BATCH);
4567 err = bpf_map_do_batch(&attr, uattr, BPF_MAP_LOOKUP_AND_DELETE_BATCH);
4570 err = bpf_map_do_batch(&attr, uattr, BPF_MAP_UPDATE_BATCH);
4573 err = bpf_map_do_batch(&attr, uattr, BPF_MAP_DELETE_BATCH);
4576 err = link_create(&attr);
4579 err = link_update(&attr);
4582 err = bpf_link_get_fd_by_id(&attr);
4585 err = bpf_obj_get_next_id(&attr, uattr, &link_idr, &link_idr_lock);
4588 err = bpf_enable_stats(&attr);
4591 err = bpf_iter_create(&attr);
4594 err = link_detach(&attr);
4597 err = bpf_prog_bind_map(&attr);