1 /* Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com 2 * 3 * This program is free software; you can redistribute it and/or 4 * modify it under the terms of version 2 of the GNU General Public 5 * License as published by the Free Software Foundation. 6 * 7 * This program is distributed in the hope that it will be useful, but 8 * WITHOUT ANY WARRANTY; without even the implied warranty of 9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 10 * General Public License for more details. 11 */ 12 #include <linux/bpf.h> 13 #include <linux/syscalls.h> 14 #include <linux/slab.h> 15 #include <linux/anon_inodes.h> 16 #include <linux/file.h> 17 #include <linux/license.h> 18 #include <linux/filter.h> 19 #include <linux/version.h> 20 21 int sysctl_unprivileged_bpf_disabled __read_mostly; 22 23 static LIST_HEAD(bpf_map_types); 24 25 static struct bpf_map *find_and_alloc_map(union bpf_attr *attr) 26 { 27 struct bpf_map_type_list *tl; 28 struct bpf_map *map; 29 30 list_for_each_entry(tl, &bpf_map_types, list_node) { 31 if (tl->type == attr->map_type) { 32 map = tl->ops->map_alloc(attr); 33 if (IS_ERR(map)) 34 return map; 35 map->ops = tl->ops; 36 map->map_type = attr->map_type; 37 return map; 38 } 39 } 40 return ERR_PTR(-EINVAL); 41 } 42 43 /* boot time registration of different map implementations */ 44 void bpf_register_map_type(struct bpf_map_type_list *tl) 45 { 46 list_add(&tl->list_node, &bpf_map_types); 47 } 48 49 static int bpf_map_charge_memlock(struct bpf_map *map) 50 { 51 struct user_struct *user = get_current_user(); 52 unsigned long memlock_limit; 53 54 memlock_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT; 55 56 atomic_long_add(map->pages, &user->locked_vm); 57 58 if (atomic_long_read(&user->locked_vm) > memlock_limit) { 59 atomic_long_sub(map->pages, &user->locked_vm); 60 free_uid(user); 61 return -EPERM; 62 } 63 map->user = user; 64 return 0; 65 } 66 67 static void bpf_map_uncharge_memlock(struct bpf_map *map) 68 { 69 struct user_struct *user = map->user; 70 71 atomic_long_sub(map->pages, &user->locked_vm); 72 free_uid(user); 73 } 74 75 /* called from workqueue */ 76 static void bpf_map_free_deferred(struct work_struct *work) 77 { 78 struct bpf_map *map = container_of(work, struct bpf_map, work); 79 80 bpf_map_uncharge_memlock(map); 81 /* implementation dependent freeing */ 82 map->ops->map_free(map); 83 } 84 85 static void bpf_map_put_uref(struct bpf_map *map) 86 { 87 if (atomic_dec_and_test(&map->usercnt)) { 88 if (map->map_type == BPF_MAP_TYPE_PROG_ARRAY) 89 bpf_fd_array_map_clear(map); 90 } 91 } 92 93 /* decrement map refcnt and schedule it for freeing via workqueue 94 * (unrelying map implementation ops->map_free() might sleep) 95 */ 96 void bpf_map_put(struct bpf_map *map) 97 { 98 if (atomic_dec_and_test(&map->refcnt)) { 99 INIT_WORK(&map->work, bpf_map_free_deferred); 100 schedule_work(&map->work); 101 } 102 } 103 104 void bpf_map_put_with_uref(struct bpf_map *map) 105 { 106 bpf_map_put_uref(map); 107 bpf_map_put(map); 108 } 109 110 static int bpf_map_release(struct inode *inode, struct file *filp) 111 { 112 bpf_map_put_with_uref(filp->private_data); 113 return 0; 114 } 115 116 #ifdef CONFIG_PROC_FS 117 static void bpf_map_show_fdinfo(struct seq_file *m, struct file *filp) 118 { 119 const struct bpf_map *map = filp->private_data; 120 121 seq_printf(m, 122 "map_type:\t%u\n" 123 "key_size:\t%u\n" 124 "value_size:\t%u\n" 125 "max_entries:\t%u\n", 126 map->map_type, 127 map->key_size, 128 map->value_size, 129 map->max_entries); 130 } 131 #endif 132 133 static const struct file_operations bpf_map_fops = { 134 #ifdef CONFIG_PROC_FS 135 .show_fdinfo = bpf_map_show_fdinfo, 136 #endif 137 .release = bpf_map_release, 138 }; 139 140 int bpf_map_new_fd(struct bpf_map *map) 141 { 142 return anon_inode_getfd("bpf-map", &bpf_map_fops, map, 143 O_RDWR | O_CLOEXEC); 144 } 145 146 /* helper macro to check that unused fields 'union bpf_attr' are zero */ 147 #define CHECK_ATTR(CMD) \ 148 memchr_inv((void *) &attr->CMD##_LAST_FIELD + \ 149 sizeof(attr->CMD##_LAST_FIELD), 0, \ 150 sizeof(*attr) - \ 151 offsetof(union bpf_attr, CMD##_LAST_FIELD) - \ 152 sizeof(attr->CMD##_LAST_FIELD)) != NULL 153 154 #define BPF_MAP_CREATE_LAST_FIELD max_entries 155 /* called via syscall */ 156 static int map_create(union bpf_attr *attr) 157 { 158 struct bpf_map *map; 159 int err; 160 161 err = CHECK_ATTR(BPF_MAP_CREATE); 162 if (err) 163 return -EINVAL; 164 165 /* find map type and init map: hashtable vs rbtree vs bloom vs ... */ 166 map = find_and_alloc_map(attr); 167 if (IS_ERR(map)) 168 return PTR_ERR(map); 169 170 atomic_set(&map->refcnt, 1); 171 atomic_set(&map->usercnt, 1); 172 173 err = bpf_map_charge_memlock(map); 174 if (err) 175 goto free_map; 176 177 err = bpf_map_new_fd(map); 178 if (err < 0) 179 /* failed to allocate fd */ 180 goto free_map; 181 182 return err; 183 184 free_map: 185 map->ops->map_free(map); 186 return err; 187 } 188 189 /* if error is returned, fd is released. 190 * On success caller should complete fd access with matching fdput() 191 */ 192 struct bpf_map *__bpf_map_get(struct fd f) 193 { 194 if (!f.file) 195 return ERR_PTR(-EBADF); 196 if (f.file->f_op != &bpf_map_fops) { 197 fdput(f); 198 return ERR_PTR(-EINVAL); 199 } 200 201 return f.file->private_data; 202 } 203 204 void bpf_map_inc(struct bpf_map *map, bool uref) 205 { 206 atomic_inc(&map->refcnt); 207 if (uref) 208 atomic_inc(&map->usercnt); 209 } 210 211 struct bpf_map *bpf_map_get_with_uref(u32 ufd) 212 { 213 struct fd f = fdget(ufd); 214 struct bpf_map *map; 215 216 map = __bpf_map_get(f); 217 if (IS_ERR(map)) 218 return map; 219 220 bpf_map_inc(map, true); 221 fdput(f); 222 223 return map; 224 } 225 226 /* helper to convert user pointers passed inside __aligned_u64 fields */ 227 static void __user *u64_to_ptr(__u64 val) 228 { 229 return (void __user *) (unsigned long) val; 230 } 231 232 /* last field in 'union bpf_attr' used by this command */ 233 #define BPF_MAP_LOOKUP_ELEM_LAST_FIELD value 234 235 static int map_lookup_elem(union bpf_attr *attr) 236 { 237 void __user *ukey = u64_to_ptr(attr->key); 238 void __user *uvalue = u64_to_ptr(attr->value); 239 int ufd = attr->map_fd; 240 struct bpf_map *map; 241 void *key, *value, *ptr; 242 struct fd f; 243 int err; 244 245 if (CHECK_ATTR(BPF_MAP_LOOKUP_ELEM)) 246 return -EINVAL; 247 248 f = fdget(ufd); 249 map = __bpf_map_get(f); 250 if (IS_ERR(map)) 251 return PTR_ERR(map); 252 253 err = -ENOMEM; 254 key = kmalloc(map->key_size, GFP_USER); 255 if (!key) 256 goto err_put; 257 258 err = -EFAULT; 259 if (copy_from_user(key, ukey, map->key_size) != 0) 260 goto free_key; 261 262 err = -ENOMEM; 263 value = kmalloc(map->value_size, GFP_USER | __GFP_NOWARN); 264 if (!value) 265 goto free_key; 266 267 rcu_read_lock(); 268 ptr = map->ops->map_lookup_elem(map, key); 269 if (ptr) 270 memcpy(value, ptr, map->value_size); 271 rcu_read_unlock(); 272 273 err = -ENOENT; 274 if (!ptr) 275 goto free_value; 276 277 err = -EFAULT; 278 if (copy_to_user(uvalue, value, map->value_size) != 0) 279 goto free_value; 280 281 err = 0; 282 283 free_value: 284 kfree(value); 285 free_key: 286 kfree(key); 287 err_put: 288 fdput(f); 289 return err; 290 } 291 292 #define BPF_MAP_UPDATE_ELEM_LAST_FIELD flags 293 294 static int map_update_elem(union bpf_attr *attr) 295 { 296 void __user *ukey = u64_to_ptr(attr->key); 297 void __user *uvalue = u64_to_ptr(attr->value); 298 int ufd = attr->map_fd; 299 struct bpf_map *map; 300 void *key, *value; 301 struct fd f; 302 int err; 303 304 if (CHECK_ATTR(BPF_MAP_UPDATE_ELEM)) 305 return -EINVAL; 306 307 f = fdget(ufd); 308 map = __bpf_map_get(f); 309 if (IS_ERR(map)) 310 return PTR_ERR(map); 311 312 err = -ENOMEM; 313 key = kmalloc(map->key_size, GFP_USER); 314 if (!key) 315 goto err_put; 316 317 err = -EFAULT; 318 if (copy_from_user(key, ukey, map->key_size) != 0) 319 goto free_key; 320 321 err = -ENOMEM; 322 value = kmalloc(map->value_size, GFP_USER | __GFP_NOWARN); 323 if (!value) 324 goto free_key; 325 326 err = -EFAULT; 327 if (copy_from_user(value, uvalue, map->value_size) != 0) 328 goto free_value; 329 330 /* eBPF program that use maps are running under rcu_read_lock(), 331 * therefore all map accessors rely on this fact, so do the same here 332 */ 333 rcu_read_lock(); 334 err = map->ops->map_update_elem(map, key, value, attr->flags); 335 rcu_read_unlock(); 336 337 free_value: 338 kfree(value); 339 free_key: 340 kfree(key); 341 err_put: 342 fdput(f); 343 return err; 344 } 345 346 #define BPF_MAP_DELETE_ELEM_LAST_FIELD key 347 348 static int map_delete_elem(union bpf_attr *attr) 349 { 350 void __user *ukey = u64_to_ptr(attr->key); 351 int ufd = attr->map_fd; 352 struct bpf_map *map; 353 struct fd f; 354 void *key; 355 int err; 356 357 if (CHECK_ATTR(BPF_MAP_DELETE_ELEM)) 358 return -EINVAL; 359 360 f = fdget(ufd); 361 map = __bpf_map_get(f); 362 if (IS_ERR(map)) 363 return PTR_ERR(map); 364 365 err = -ENOMEM; 366 key = kmalloc(map->key_size, GFP_USER); 367 if (!key) 368 goto err_put; 369 370 err = -EFAULT; 371 if (copy_from_user(key, ukey, map->key_size) != 0) 372 goto free_key; 373 374 rcu_read_lock(); 375 err = map->ops->map_delete_elem(map, key); 376 rcu_read_unlock(); 377 378 free_key: 379 kfree(key); 380 err_put: 381 fdput(f); 382 return err; 383 } 384 385 /* last field in 'union bpf_attr' used by this command */ 386 #define BPF_MAP_GET_NEXT_KEY_LAST_FIELD next_key 387 388 static int map_get_next_key(union bpf_attr *attr) 389 { 390 void __user *ukey = u64_to_ptr(attr->key); 391 void __user *unext_key = u64_to_ptr(attr->next_key); 392 int ufd = attr->map_fd; 393 struct bpf_map *map; 394 void *key, *next_key; 395 struct fd f; 396 int err; 397 398 if (CHECK_ATTR(BPF_MAP_GET_NEXT_KEY)) 399 return -EINVAL; 400 401 f = fdget(ufd); 402 map = __bpf_map_get(f); 403 if (IS_ERR(map)) 404 return PTR_ERR(map); 405 406 err = -ENOMEM; 407 key = kmalloc(map->key_size, GFP_USER); 408 if (!key) 409 goto err_put; 410 411 err = -EFAULT; 412 if (copy_from_user(key, ukey, map->key_size) != 0) 413 goto free_key; 414 415 err = -ENOMEM; 416 next_key = kmalloc(map->key_size, GFP_USER); 417 if (!next_key) 418 goto free_key; 419 420 rcu_read_lock(); 421 err = map->ops->map_get_next_key(map, key, next_key); 422 rcu_read_unlock(); 423 if (err) 424 goto free_next_key; 425 426 err = -EFAULT; 427 if (copy_to_user(unext_key, next_key, map->key_size) != 0) 428 goto free_next_key; 429 430 err = 0; 431 432 free_next_key: 433 kfree(next_key); 434 free_key: 435 kfree(key); 436 err_put: 437 fdput(f); 438 return err; 439 } 440 441 static LIST_HEAD(bpf_prog_types); 442 443 static int find_prog_type(enum bpf_prog_type type, struct bpf_prog *prog) 444 { 445 struct bpf_prog_type_list *tl; 446 447 list_for_each_entry(tl, &bpf_prog_types, list_node) { 448 if (tl->type == type) { 449 prog->aux->ops = tl->ops; 450 prog->type = type; 451 return 0; 452 } 453 } 454 455 return -EINVAL; 456 } 457 458 void bpf_register_prog_type(struct bpf_prog_type_list *tl) 459 { 460 list_add(&tl->list_node, &bpf_prog_types); 461 } 462 463 /* fixup insn->imm field of bpf_call instructions: 464 * if (insn->imm == BPF_FUNC_map_lookup_elem) 465 * insn->imm = bpf_map_lookup_elem - __bpf_call_base; 466 * else if (insn->imm == BPF_FUNC_map_update_elem) 467 * insn->imm = bpf_map_update_elem - __bpf_call_base; 468 * else ... 469 * 470 * this function is called after eBPF program passed verification 471 */ 472 static void fixup_bpf_calls(struct bpf_prog *prog) 473 { 474 const struct bpf_func_proto *fn; 475 int i; 476 477 for (i = 0; i < prog->len; i++) { 478 struct bpf_insn *insn = &prog->insnsi[i]; 479 480 if (insn->code == (BPF_JMP | BPF_CALL)) { 481 /* we reach here when program has bpf_call instructions 482 * and it passed bpf_check(), means that 483 * ops->get_func_proto must have been supplied, check it 484 */ 485 BUG_ON(!prog->aux->ops->get_func_proto); 486 487 if (insn->imm == BPF_FUNC_get_route_realm) 488 prog->dst_needed = 1; 489 if (insn->imm == BPF_FUNC_get_prandom_u32) 490 bpf_user_rnd_init_once(); 491 if (insn->imm == BPF_FUNC_tail_call) { 492 /* mark bpf_tail_call as different opcode 493 * to avoid conditional branch in 494 * interpeter for every normal call 495 * and to prevent accidental JITing by 496 * JIT compiler that doesn't support 497 * bpf_tail_call yet 498 */ 499 insn->imm = 0; 500 insn->code |= BPF_X; 501 continue; 502 } 503 504 fn = prog->aux->ops->get_func_proto(insn->imm); 505 /* all functions that have prototype and verifier allowed 506 * programs to call them, must be real in-kernel functions 507 */ 508 BUG_ON(!fn->func); 509 insn->imm = fn->func - __bpf_call_base; 510 } 511 } 512 } 513 514 /* drop refcnt on maps used by eBPF program and free auxilary data */ 515 static void free_used_maps(struct bpf_prog_aux *aux) 516 { 517 int i; 518 519 for (i = 0; i < aux->used_map_cnt; i++) 520 bpf_map_put(aux->used_maps[i]); 521 522 kfree(aux->used_maps); 523 } 524 525 static int bpf_prog_charge_memlock(struct bpf_prog *prog) 526 { 527 struct user_struct *user = get_current_user(); 528 unsigned long memlock_limit; 529 530 memlock_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT; 531 532 atomic_long_add(prog->pages, &user->locked_vm); 533 if (atomic_long_read(&user->locked_vm) > memlock_limit) { 534 atomic_long_sub(prog->pages, &user->locked_vm); 535 free_uid(user); 536 return -EPERM; 537 } 538 prog->aux->user = user; 539 return 0; 540 } 541 542 static void bpf_prog_uncharge_memlock(struct bpf_prog *prog) 543 { 544 struct user_struct *user = prog->aux->user; 545 546 atomic_long_sub(prog->pages, &user->locked_vm); 547 free_uid(user); 548 } 549 550 static void __prog_put_common(struct rcu_head *rcu) 551 { 552 struct bpf_prog_aux *aux = container_of(rcu, struct bpf_prog_aux, rcu); 553 554 free_used_maps(aux); 555 bpf_prog_uncharge_memlock(aux->prog); 556 bpf_prog_free(aux->prog); 557 } 558 559 /* version of bpf_prog_put() that is called after a grace period */ 560 void bpf_prog_put_rcu(struct bpf_prog *prog) 561 { 562 if (atomic_dec_and_test(&prog->aux->refcnt)) 563 call_rcu(&prog->aux->rcu, __prog_put_common); 564 } 565 566 void bpf_prog_put(struct bpf_prog *prog) 567 { 568 if (atomic_dec_and_test(&prog->aux->refcnt)) 569 __prog_put_common(&prog->aux->rcu); 570 } 571 EXPORT_SYMBOL_GPL(bpf_prog_put); 572 573 static int bpf_prog_release(struct inode *inode, struct file *filp) 574 { 575 struct bpf_prog *prog = filp->private_data; 576 577 bpf_prog_put_rcu(prog); 578 return 0; 579 } 580 581 static const struct file_operations bpf_prog_fops = { 582 .release = bpf_prog_release, 583 }; 584 585 int bpf_prog_new_fd(struct bpf_prog *prog) 586 { 587 return anon_inode_getfd("bpf-prog", &bpf_prog_fops, prog, 588 O_RDWR | O_CLOEXEC); 589 } 590 591 static struct bpf_prog *__bpf_prog_get(struct fd f) 592 { 593 if (!f.file) 594 return ERR_PTR(-EBADF); 595 if (f.file->f_op != &bpf_prog_fops) { 596 fdput(f); 597 return ERR_PTR(-EINVAL); 598 } 599 600 return f.file->private_data; 601 } 602 603 /* called by sockets/tracing/seccomp before attaching program to an event 604 * pairs with bpf_prog_put() 605 */ 606 struct bpf_prog *bpf_prog_get(u32 ufd) 607 { 608 struct fd f = fdget(ufd); 609 struct bpf_prog *prog; 610 611 prog = __bpf_prog_get(f); 612 if (IS_ERR(prog)) 613 return prog; 614 615 atomic_inc(&prog->aux->refcnt); 616 fdput(f); 617 618 return prog; 619 } 620 EXPORT_SYMBOL_GPL(bpf_prog_get); 621 622 /* last field in 'union bpf_attr' used by this command */ 623 #define BPF_PROG_LOAD_LAST_FIELD kern_version 624 625 static int bpf_prog_load(union bpf_attr *attr) 626 { 627 enum bpf_prog_type type = attr->prog_type; 628 struct bpf_prog *prog; 629 int err; 630 char license[128]; 631 bool is_gpl; 632 633 if (CHECK_ATTR(BPF_PROG_LOAD)) 634 return -EINVAL; 635 636 /* copy eBPF program license from user space */ 637 if (strncpy_from_user(license, u64_to_ptr(attr->license), 638 sizeof(license) - 1) < 0) 639 return -EFAULT; 640 license[sizeof(license) - 1] = 0; 641 642 /* eBPF programs must be GPL compatible to use GPL-ed functions */ 643 is_gpl = license_is_gpl_compatible(license); 644 645 if (attr->insn_cnt >= BPF_MAXINSNS) 646 return -EINVAL; 647 648 if (type == BPF_PROG_TYPE_KPROBE && 649 attr->kern_version != LINUX_VERSION_CODE) 650 return -EINVAL; 651 652 if (type != BPF_PROG_TYPE_SOCKET_FILTER && !capable(CAP_SYS_ADMIN)) 653 return -EPERM; 654 655 /* plain bpf_prog allocation */ 656 prog = bpf_prog_alloc(bpf_prog_size(attr->insn_cnt), GFP_USER); 657 if (!prog) 658 return -ENOMEM; 659 660 err = bpf_prog_charge_memlock(prog); 661 if (err) 662 goto free_prog_nouncharge; 663 664 prog->len = attr->insn_cnt; 665 666 err = -EFAULT; 667 if (copy_from_user(prog->insns, u64_to_ptr(attr->insns), 668 prog->len * sizeof(struct bpf_insn)) != 0) 669 goto free_prog; 670 671 prog->orig_prog = NULL; 672 prog->jited = 0; 673 674 atomic_set(&prog->aux->refcnt, 1); 675 prog->gpl_compatible = is_gpl ? 1 : 0; 676 677 /* find program type: socket_filter vs tracing_filter */ 678 err = find_prog_type(type, prog); 679 if (err < 0) 680 goto free_prog; 681 682 /* run eBPF verifier */ 683 err = bpf_check(&prog, attr); 684 if (err < 0) 685 goto free_used_maps; 686 687 /* fixup BPF_CALL->imm field */ 688 fixup_bpf_calls(prog); 689 690 /* eBPF program is ready to be JITed */ 691 err = bpf_prog_select_runtime(prog); 692 if (err < 0) 693 goto free_used_maps; 694 695 err = bpf_prog_new_fd(prog); 696 if (err < 0) 697 /* failed to allocate fd */ 698 goto free_used_maps; 699 700 return err; 701 702 free_used_maps: 703 free_used_maps(prog->aux); 704 free_prog: 705 bpf_prog_uncharge_memlock(prog); 706 free_prog_nouncharge: 707 bpf_prog_free(prog); 708 return err; 709 } 710 711 #define BPF_OBJ_LAST_FIELD bpf_fd 712 713 static int bpf_obj_pin(const union bpf_attr *attr) 714 { 715 if (CHECK_ATTR(BPF_OBJ)) 716 return -EINVAL; 717 718 return bpf_obj_pin_user(attr->bpf_fd, u64_to_ptr(attr->pathname)); 719 } 720 721 static int bpf_obj_get(const union bpf_attr *attr) 722 { 723 if (CHECK_ATTR(BPF_OBJ) || attr->bpf_fd != 0) 724 return -EINVAL; 725 726 return bpf_obj_get_user(u64_to_ptr(attr->pathname)); 727 } 728 729 SYSCALL_DEFINE3(bpf, int, cmd, union bpf_attr __user *, uattr, unsigned int, size) 730 { 731 union bpf_attr attr = {}; 732 int err; 733 734 if (!capable(CAP_SYS_ADMIN) && sysctl_unprivileged_bpf_disabled) 735 return -EPERM; 736 737 if (!access_ok(VERIFY_READ, uattr, 1)) 738 return -EFAULT; 739 740 if (size > PAGE_SIZE) /* silly large */ 741 return -E2BIG; 742 743 /* If we're handed a bigger struct than we know of, 744 * ensure all the unknown bits are 0 - i.e. new 745 * user-space does not rely on any kernel feature 746 * extensions we dont know about yet. 747 */ 748 if (size > sizeof(attr)) { 749 unsigned char __user *addr; 750 unsigned char __user *end; 751 unsigned char val; 752 753 addr = (void __user *)uattr + sizeof(attr); 754 end = (void __user *)uattr + size; 755 756 for (; addr < end; addr++) { 757 err = get_user(val, addr); 758 if (err) 759 return err; 760 if (val) 761 return -E2BIG; 762 } 763 size = sizeof(attr); 764 } 765 766 /* copy attributes from user space, may be less than sizeof(bpf_attr) */ 767 if (copy_from_user(&attr, uattr, size) != 0) 768 return -EFAULT; 769 770 switch (cmd) { 771 case BPF_MAP_CREATE: 772 err = map_create(&attr); 773 break; 774 case BPF_MAP_LOOKUP_ELEM: 775 err = map_lookup_elem(&attr); 776 break; 777 case BPF_MAP_UPDATE_ELEM: 778 err = map_update_elem(&attr); 779 break; 780 case BPF_MAP_DELETE_ELEM: 781 err = map_delete_elem(&attr); 782 break; 783 case BPF_MAP_GET_NEXT_KEY: 784 err = map_get_next_key(&attr); 785 break; 786 case BPF_PROG_LOAD: 787 err = bpf_prog_load(&attr); 788 break; 789 case BPF_OBJ_PIN: 790 err = bpf_obj_pin(&attr); 791 break; 792 case BPF_OBJ_GET: 793 err = bpf_obj_get(&attr); 794 break; 795 default: 796 err = -EINVAL; 797 break; 798 } 799 800 return err; 801 } 802