netfilter: nf_tables: simplify lookup functions

+6 -6

include/net/netfilter/nf_tables.h

··· 1015 1015 1016 1016 #define nft_expr_obj(expr) *((struct nft_object **)nft_expr_priv(expr)) 1017 1017 1018 - struct nft_object *nf_tables_obj_lookup(const struct nft_table *table, 1019 - const struct nlattr *nla, u32 objtype, 1020 - u8 genmask); 1018 + struct nft_object *nft_obj_lookup(const struct nft_table *table, 1019 + const struct nlattr *nla, u32 objtype, 1020 + u8 genmask); 1021 1021 1022 1022 void nft_obj_notify(struct net *net, struct nft_table *table, 1023 1023 struct nft_object *obj, u32 portid, u32 seq, ··· 1106 1106 struct nf_flowtable data; 1107 1107 }; 1108 1108 1109 - struct nft_flowtable *nf_tables_flowtable_lookup(const struct nft_table *table, 1110 - const struct nlattr *nla, 1111 - u8 genmask); 1109 + struct nft_flowtable *nft_flowtable_lookup(const struct nft_table *table, 1110 + const struct nlattr *nla, 1111 + u8 genmask); 1112 1112 1113 1113 void nft_register_flowtable_type(struct nf_flowtable_type *type); 1114 1114 void nft_unregister_flowtable_type(struct nf_flowtable_type *type);

+100 -149

net/netfilter/nf_tables_api.c

··· 386 386 { 387 387 struct nft_table *table; 388 388 389 + if (nla == NULL) 390 + return ERR_PTR(-EINVAL); 391 + 389 392 list_for_each_entry(table, &net->nft.tables, list) { 390 393 if (!nla_strcmp(nla, table->name) && 391 394 table->family == family && 392 395 nft_active_genmask(table, genmask)) 393 396 return table; 394 397 } 395 - return NULL; 398 + 399 + return ERR_PTR(-ENOENT); 396 400 } 397 401 398 402 static struct nft_table *nft_table_lookup_byhandle(const struct net *net, ··· 410 406 nft_active_genmask(table, genmask)) 411 407 return table; 412 408 } 413 - return NULL; 414 - } 415 - 416 - static struct nft_table *nf_tables_table_lookup(const struct net *net, 417 - const struct nlattr *nla, 418 - u8 family, u8 genmask) 419 - { 420 - struct nft_table *table; 421 - 422 - if (nla == NULL) 423 - return ERR_PTR(-EINVAL); 424 - 425 - table = nft_table_lookup(net, nla, family, genmask); 426 - if (table != NULL) 427 - return table; 428 - 429 - return ERR_PTR(-ENOENT); 430 - } 431 - 432 - static struct nft_table *nf_tables_table_lookup_byhandle(const struct net *net, 433 - const struct nlattr *nla, 434 - u8 genmask) 435 - { 436 - struct nft_table *table; 437 - 438 - if (nla == NULL) 439 - return ERR_PTR(-EINVAL); 440 - 441 - table = nft_table_lookup_byhandle(net, nla, genmask); 442 - if (table != NULL) 443 - return table; 444 409 445 410 return ERR_PTR(-ENOENT); 446 411 } ··· 581 608 return netlink_dump_start(nlsk, skb, nlh, &c); 582 609 } 583 610 584 - table = nf_tables_table_lookup(net, nla[NFTA_TABLE_NAME], family, 585 - genmask); 611 + table = nft_table_lookup(net, nla[NFTA_TABLE_NAME], family, genmask); 586 612 if (IS_ERR(table)) 587 613 return PTR_ERR(table); 588 614 ··· 707 735 int err; 708 736 709 737 name = nla[NFTA_TABLE_NAME]; 710 - table = nf_tables_table_lookup(net, name, family, genmask); 738 + table = nft_table_lookup(net, name, family, genmask); 711 739 if (IS_ERR(table)) { 712 740 if (PTR_ERR(table) != -ENOENT) 713 741 return PTR_ERR(table); ··· 865 893 return nft_flush(&ctx, family); 866 894 867 895 if (nla[NFTA_TABLE_HANDLE]) 868 - table = nf_tables_table_lookup_byhandle(net, 869 - nla[NFTA_TABLE_HANDLE], 870 - genmask); 896 + table = nft_table_lookup_byhandle(net, nla[NFTA_TABLE_HANDLE], 897 + genmask); 871 898 else 872 - table = nf_tables_table_lookup(net, nla[NFTA_TABLE_NAME], 873 - family, genmask); 899 + table = nft_table_lookup(net, nla[NFTA_TABLE_NAME], family, 900 + genmask); 874 901 875 902 if (IS_ERR(table)) 876 903 return PTR_ERR(table); ··· 920 949 */ 921 950 922 951 static struct nft_chain * 923 - nf_tables_chain_lookup_byhandle(const struct nft_table *table, u64 handle, 924 - u8 genmask) 952 + nft_chain_lookup_byhandle(const struct nft_table *table, u64 handle, u8 genmask) 925 953 { 926 954 struct nft_chain *chain; 927 955 ··· 933 963 return ERR_PTR(-ENOENT); 934 964 } 935 965 936 - static struct nft_chain *nf_tables_chain_lookup(const struct nft_table *table, 937 - const struct nlattr *nla, 938 - u8 genmask) 966 + static struct nft_chain *nft_chain_lookup(const struct nft_table *table, 967 + const struct nlattr *nla, u8 genmask) 939 968 { 940 969 struct nft_chain *chain; 941 970 ··· 1163 1194 return netlink_dump_start(nlsk, skb, nlh, &c); 1164 1195 } 1165 1196 1166 - table = nf_tables_table_lookup(net, nla[NFTA_CHAIN_TABLE], family, 1167 - genmask); 1197 + table = nft_table_lookup(net, nla[NFTA_CHAIN_TABLE], family, genmask); 1168 1198 if (IS_ERR(table)) 1169 1199 return PTR_ERR(table); 1170 1200 1171 - chain = nf_tables_chain_lookup(table, nla[NFTA_CHAIN_NAME], genmask); 1201 + chain = nft_chain_lookup(table, nla[NFTA_CHAIN_NAME], genmask); 1172 1202 if (IS_ERR(chain)) 1173 1203 return PTR_ERR(chain); 1174 1204 ··· 1481 1513 nla[NFTA_CHAIN_NAME]) { 1482 1514 struct nft_chain *chain2; 1483 1515 1484 - chain2 = nf_tables_chain_lookup(table, nla[NFTA_CHAIN_NAME], 1485 - genmask); 1516 + chain2 = nft_chain_lookup(table, nla[NFTA_CHAIN_NAME], genmask); 1486 1517 if (!IS_ERR(chain2)) 1487 1518 return -EEXIST; 1488 1519 } ··· 1543 1576 1544 1577 create = nlh->nlmsg_flags & NLM_F_CREATE ? true : false; 1545 1578 1546 - table = nf_tables_table_lookup(net, nla[NFTA_CHAIN_TABLE], family, 1547 - genmask); 1579 + table = nft_table_lookup(net, nla[NFTA_CHAIN_TABLE], family, genmask); 1548 1580 if (IS_ERR(table)) 1549 1581 return PTR_ERR(table); 1550 1582 ··· 1552 1586 1553 1587 if (nla[NFTA_CHAIN_HANDLE]) { 1554 1588 handle = be64_to_cpu(nla_get_be64(nla[NFTA_CHAIN_HANDLE])); 1555 - chain = nf_tables_chain_lookup_byhandle(table, handle, genmask); 1589 + chain = nft_chain_lookup_byhandle(table, handle, genmask); 1556 1590 if (IS_ERR(chain)) 1557 1591 return PTR_ERR(chain); 1558 1592 } else { 1559 - chain = nf_tables_chain_lookup(table, name, genmask); 1593 + chain = nft_chain_lookup(table, name, genmask); 1560 1594 if (IS_ERR(chain)) { 1561 1595 if (PTR_ERR(chain) != -ENOENT) 1562 1596 return PTR_ERR(chain); ··· 1613 1647 u32 use; 1614 1648 int err; 1615 1649 1616 - table = nf_tables_table_lookup(net, nla[NFTA_CHAIN_TABLE], family, 1617 - genmask); 1650 + table = nft_table_lookup(net, nla[NFTA_CHAIN_TABLE], family, genmask); 1618 1651 if (IS_ERR(table)) 1619 1652 return PTR_ERR(table); 1620 1653 1621 1654 if (nla[NFTA_CHAIN_HANDLE]) { 1622 1655 handle = be64_to_cpu(nla_get_be64(nla[NFTA_CHAIN_HANDLE])); 1623 - chain = nf_tables_chain_lookup_byhandle(table, handle, genmask); 1656 + chain = nft_chain_lookup_byhandle(table, handle, genmask); 1624 1657 } else { 1625 - chain = nf_tables_chain_lookup(table, nla[NFTA_CHAIN_NAME], genmask); 1658 + chain = nft_chain_lookup(table, nla[NFTA_CHAIN_NAME], genmask); 1626 1659 } 1627 1660 if (IS_ERR(chain)) 1628 1661 return PTR_ERR(chain); ··· 1904 1939 * Rules 1905 1940 */ 1906 1941 1907 - static struct nft_rule *__nf_tables_rule_lookup(const struct nft_chain *chain, 1908 - u64 handle) 1942 + static struct nft_rule *__nft_rule_lookup(const struct nft_chain *chain, 1943 + u64 handle) 1909 1944 { 1910 1945 struct nft_rule *rule; 1911 1946 ··· 1918 1953 return ERR_PTR(-ENOENT); 1919 1954 } 1920 1955 1921 - static struct nft_rule *nf_tables_rule_lookup(const struct nft_chain *chain, 1922 - const struct nlattr *nla) 1956 + static struct nft_rule *nft_rule_lookup(const struct nft_chain *chain, 1957 + const struct nlattr *nla) 1923 1958 { 1924 1959 if (nla == NULL) 1925 1960 return ERR_PTR(-EINVAL); 1926 1961 1927 - return __nf_tables_rule_lookup(chain, be64_to_cpu(nla_get_be64(nla))); 1962 + return __nft_rule_lookup(chain, be64_to_cpu(nla_get_be64(nla))); 1928 1963 } 1929 1964 1930 1965 static const struct nla_policy nft_rule_policy[NFTA_RULE_MAX + 1] = { ··· 2156 2191 return netlink_dump_start(nlsk, skb, nlh, &c); 2157 2192 } 2158 2193 2159 - table = nf_tables_table_lookup(net, nla[NFTA_RULE_TABLE], family, 2160 - genmask); 2194 + table = nft_table_lookup(net, nla[NFTA_RULE_TABLE], family, genmask); 2161 2195 if (IS_ERR(table)) 2162 2196 return PTR_ERR(table); 2163 2197 2164 - chain = nf_tables_chain_lookup(table, nla[NFTA_RULE_CHAIN], genmask); 2198 + chain = nft_chain_lookup(table, nla[NFTA_RULE_CHAIN], genmask); 2165 2199 if (IS_ERR(chain)) 2166 2200 return PTR_ERR(chain); 2167 2201 2168 - rule = nf_tables_rule_lookup(chain, nla[NFTA_RULE_HANDLE]); 2202 + rule = nft_rule_lookup(chain, nla[NFTA_RULE_HANDLE]); 2169 2203 if (IS_ERR(rule)) 2170 2204 return PTR_ERR(rule); 2171 2205 ··· 2229 2265 2230 2266 create = nlh->nlmsg_flags & NLM_F_CREATE ? true : false; 2231 2267 2232 - table = nf_tables_table_lookup(net, nla[NFTA_RULE_TABLE], family, 2233 - genmask); 2268 + table = nft_table_lookup(net, nla[NFTA_RULE_TABLE], family, genmask); 2234 2269 if (IS_ERR(table)) 2235 2270 return PTR_ERR(table); 2236 2271 2237 - chain = nf_tables_chain_lookup(table, nla[NFTA_RULE_CHAIN], genmask); 2272 + chain = nft_chain_lookup(table, nla[NFTA_RULE_CHAIN], genmask); 2238 2273 if (IS_ERR(chain)) 2239 2274 return PTR_ERR(chain); 2240 2275 2241 2276 if (nla[NFTA_RULE_HANDLE]) { 2242 2277 handle = be64_to_cpu(nla_get_be64(nla[NFTA_RULE_HANDLE])); 2243 - rule = __nf_tables_rule_lookup(chain, handle); 2278 + rule = __nft_rule_lookup(chain, handle); 2244 2279 if (IS_ERR(rule)) 2245 2280 return PTR_ERR(rule); 2246 2281 ··· 2263 2300 return -EOPNOTSUPP; 2264 2301 2265 2302 pos_handle = be64_to_cpu(nla_get_be64(nla[NFTA_RULE_POSITION])); 2266 - old_rule = __nf_tables_rule_lookup(chain, pos_handle); 2303 + old_rule = __nft_rule_lookup(chain, pos_handle); 2267 2304 if (IS_ERR(old_rule)) 2268 2305 return PTR_ERR(old_rule); 2269 2306 } ··· 2398 2435 int family = nfmsg->nfgen_family, err = 0; 2399 2436 struct nft_ctx ctx; 2400 2437 2401 - table = nf_tables_table_lookup(net, nla[NFTA_RULE_TABLE], family, 2402 - genmask); 2438 + table = nft_table_lookup(net, nla[NFTA_RULE_TABLE], family, genmask); 2403 2439 if (IS_ERR(table)) 2404 2440 return PTR_ERR(table); 2405 2441 2406 2442 if (nla[NFTA_RULE_CHAIN]) { 2407 - chain = nf_tables_chain_lookup(table, nla[NFTA_RULE_CHAIN], 2408 - genmask); 2443 + chain = nft_chain_lookup(table, nla[NFTA_RULE_CHAIN], genmask); 2409 2444 if (IS_ERR(chain)) 2410 2445 return PTR_ERR(chain); 2411 2446 } ··· 2412 2451 2413 2452 if (chain) { 2414 2453 if (nla[NFTA_RULE_HANDLE]) { 2415 - rule = nf_tables_rule_lookup(chain, 2416 - nla[NFTA_RULE_HANDLE]); 2454 + rule = nft_rule_lookup(chain, nla[NFTA_RULE_HANDLE]); 2417 2455 if (IS_ERR(rule)) 2418 2456 return PTR_ERR(rule); 2419 2457 ··· 2595 2635 struct nft_table *table = NULL; 2596 2636 2597 2637 if (nla[NFTA_SET_TABLE] != NULL) { 2598 - table = nf_tables_table_lookup(net, nla[NFTA_SET_TABLE], 2599 - family, genmask); 2638 + table = nft_table_lookup(net, nla[NFTA_SET_TABLE], family, 2639 + genmask); 2600 2640 if (IS_ERR(table)) 2601 2641 return PTR_ERR(table); 2602 2642 } ··· 2605 2645 return 0; 2606 2646 } 2607 2647 2608 - static struct nft_set *nf_tables_set_lookup(const struct nft_table *table, 2609 - const struct nlattr *nla, u8 genmask) 2648 + static struct nft_set *nft_set_lookup(const struct nft_table *table, 2649 + const struct nlattr *nla, u8 genmask) 2610 2650 { 2611 2651 struct nft_set *set; 2612 2652 ··· 2621 2661 return ERR_PTR(-ENOENT); 2622 2662 } 2623 2663 2624 - static struct nft_set *nf_tables_set_lookup_byhandle(const struct nft_table *table, 2625 - const struct nlattr *nla, u8 genmask) 2664 + static struct nft_set *nft_set_lookup_byhandle(const struct nft_table *table, 2665 + const struct nlattr *nla, 2666 + u8 genmask) 2626 2667 { 2627 2668 struct nft_set *set; 2628 - 2629 - if (nla == NULL) 2630 - return ERR_PTR(-EINVAL); 2631 2669 2632 2670 list_for_each_entry(set, &table->sets, list) { 2633 2671 if (be64_to_cpu(nla_get_be64(nla)) == set->handle && ··· 2635 2677 return ERR_PTR(-ENOENT); 2636 2678 } 2637 2679 2638 - static struct nft_set *nf_tables_set_lookup_byid(const struct net *net, 2639 - const struct nlattr *nla, 2640 - u8 genmask) 2680 + static struct nft_set *nft_set_lookup_byid(const struct net *net, 2681 + const struct nlattr *nla, u8 genmask) 2641 2682 { 2642 2683 struct nft_trans *trans; 2643 2684 u32 id = ntohl(nla_get_be32(nla)); ··· 2660 2703 { 2661 2704 struct nft_set *set; 2662 2705 2663 - set = nf_tables_set_lookup(table, nla_set_name, genmask); 2706 + set = nft_set_lookup(table, nla_set_name, genmask); 2664 2707 if (IS_ERR(set)) { 2665 2708 if (!nla_set_id) 2666 2709 return set; 2667 2710 2668 - set = nf_tables_set_lookup_byid(net, nla_set_id, genmask); 2711 + set = nft_set_lookup_byid(net, nla_set_id, genmask); 2669 2712 } 2670 2713 return set; 2671 2714 } ··· 2937 2980 if (!nla[NFTA_SET_TABLE]) 2938 2981 return -EINVAL; 2939 2982 2940 - set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_NAME], genmask); 2983 + set = nft_set_lookup(ctx.table, nla[NFTA_SET_NAME], genmask); 2941 2984 if (IS_ERR(set)) 2942 2985 return PTR_ERR(set); 2943 2986 ··· 3089 3132 3090 3133 create = nlh->nlmsg_flags & NLM_F_CREATE ? true : false; 3091 3134 3092 - table = nf_tables_table_lookup(net, nla[NFTA_SET_TABLE], family, 3093 - genmask); 3135 + table = nft_table_lookup(net, nla[NFTA_SET_TABLE], family, genmask); 3094 3136 if (IS_ERR(table)) 3095 3137 return PTR_ERR(table); 3096 3138 3097 3139 nft_ctx_init(&ctx, net, skb, nlh, family, table, NULL, nla); 3098 3140 3099 - set = nf_tables_set_lookup(table, nla[NFTA_SET_NAME], genmask); 3141 + set = nft_set_lookup(table, nla[NFTA_SET_NAME], genmask); 3100 3142 if (IS_ERR(set)) { 3101 3143 if (PTR_ERR(set) != -ENOENT) 3102 3144 return PTR_ERR(set); ··· 3218 3262 return err; 3219 3263 3220 3264 if (nla[NFTA_SET_HANDLE]) 3221 - set = nf_tables_set_lookup_byhandle(ctx.table, nla[NFTA_SET_HANDLE], genmask); 3265 + set = nft_set_lookup_byhandle(ctx.table, nla[NFTA_SET_HANDLE], 3266 + genmask); 3222 3267 else 3223 - set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_NAME], genmask); 3268 + set = nft_set_lookup(ctx.table, nla[NFTA_SET_NAME], genmask); 3224 3269 if (IS_ERR(set)) 3225 3270 return PTR_ERR(set); 3226 3271 ··· 3361 3404 int family = nfmsg->nfgen_family; 3362 3405 struct nft_table *table; 3363 3406 3364 - table = nf_tables_table_lookup(net, nla[NFTA_SET_ELEM_LIST_TABLE], 3365 - family, genmask); 3407 + table = nft_table_lookup(net, nla[NFTA_SET_ELEM_LIST_TABLE], family, 3408 + genmask); 3366 3409 if (IS_ERR(table)) 3367 3410 return PTR_ERR(table); 3368 3411 ··· 3698 3741 if (err < 0) 3699 3742 return err; 3700 3743 3701 - set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_ELEM_LIST_SET], 3702 - genmask); 3744 + set = nft_set_lookup(ctx.table, nla[NFTA_SET_ELEM_LIST_SET], genmask); 3703 3745 if (IS_ERR(set)) 3704 3746 return PTR_ERR(set); 3705 3747 ··· 3910 3954 err = -EINVAL; 3911 3955 goto err2; 3912 3956 } 3913 - obj = nf_tables_obj_lookup(ctx->table, nla[NFTA_SET_ELEM_OBJREF], 3914 - set->objtype, genmask); 3957 + obj = nft_obj_lookup(ctx->table, nla[NFTA_SET_ELEM_OBJREF], 3958 + set->objtype, genmask); 3915 3959 if (IS_ERR(obj)) { 3916 3960 err = PTR_ERR(obj); 3917 3961 goto err2; ··· 4240 4284 if (err < 0) 4241 4285 return err; 4242 4286 4243 - set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_ELEM_LIST_SET], 4244 - genmask); 4287 + set = nft_set_lookup(ctx.table, nla[NFTA_SET_ELEM_LIST_SET], genmask); 4245 4288 if (IS_ERR(set)) 4246 4289 return PTR_ERR(set); 4247 4290 if (!list_empty(&set->bindings) && set->flags & NFT_SET_CONSTANT) ··· 4328 4373 } 4329 4374 EXPORT_SYMBOL_GPL(nft_unregister_obj); 4330 4375 4331 - struct nft_object *nf_tables_obj_lookup(const struct nft_table *table, 4332 - const struct nlattr *nla, 4333 - u32 objtype, u8 genmask) 4376 + struct nft_object *nft_obj_lookup(const struct nft_table *table, 4377 + const struct nlattr *nla, u32 objtype, 4378 + u8 genmask) 4334 4379 { 4335 4380 struct nft_object *obj; 4336 4381 ··· 4342 4387 } 4343 4388 return ERR_PTR(-ENOENT); 4344 4389 } 4345 - EXPORT_SYMBOL_GPL(nf_tables_obj_lookup); 4390 + EXPORT_SYMBOL_GPL(nft_obj_lookup); 4346 4391 4347 - static struct nft_object *nf_tables_obj_lookup_byhandle(const struct nft_table *table, 4348 - const struct nlattr *nla, 4349 - u32 objtype, u8 genmask) 4392 + static struct nft_object *nft_obj_lookup_byhandle(const struct nft_table *table, 4393 + const struct nlattr *nla, 4394 + u32 objtype, u8 genmask) 4350 4395 { 4351 4396 struct nft_object *obj; 4352 4397 ··· 4490 4535 !nla[NFTA_OBJ_DATA]) 4491 4536 return -EINVAL; 4492 4537 4493 - table = nf_tables_table_lookup(net, nla[NFTA_OBJ_TABLE], family, 4494 - genmask); 4538 + table = nft_table_lookup(net, nla[NFTA_OBJ_TABLE], family, genmask); 4495 4539 if (IS_ERR(table)) 4496 4540 return PTR_ERR(table); 4497 4541 4498 4542 objtype = ntohl(nla_get_be32(nla[NFTA_OBJ_TYPE])); 4499 - obj = nf_tables_obj_lookup(table, nla[NFTA_OBJ_NAME], objtype, genmask); 4543 + obj = nft_obj_lookup(table, nla[NFTA_OBJ_NAME], objtype, genmask); 4500 4544 if (IS_ERR(obj)) { 4501 4545 err = PTR_ERR(obj); 4502 4546 if (err != -ENOENT) ··· 4715 4761 !nla[NFTA_OBJ_TYPE]) 4716 4762 return -EINVAL; 4717 4763 4718 - table = nf_tables_table_lookup(net, nla[NFTA_OBJ_TABLE], family, 4719 - genmask); 4764 + table = nft_table_lookup(net, nla[NFTA_OBJ_TABLE], family, genmask); 4720 4765 if (IS_ERR(table)) 4721 4766 return PTR_ERR(table); 4722 4767 4723 4768 objtype = ntohl(nla_get_be32(nla[NFTA_OBJ_TYPE])); 4724 - obj = nf_tables_obj_lookup(table, nla[NFTA_OBJ_NAME], objtype, genmask); 4769 + obj = nft_obj_lookup(table, nla[NFTA_OBJ_NAME], objtype, genmask); 4725 4770 if (IS_ERR(obj)) 4726 4771 return PTR_ERR(obj); 4727 4772 ··· 4770 4817 (!nla[NFTA_OBJ_NAME] && !nla[NFTA_OBJ_HANDLE])) 4771 4818 return -EINVAL; 4772 4819 4773 - table = nf_tables_table_lookup(net, nla[NFTA_OBJ_TABLE], family, 4774 - genmask); 4820 + table = nft_table_lookup(net, nla[NFTA_OBJ_TABLE], family, genmask); 4775 4821 if (IS_ERR(table)) 4776 4822 return PTR_ERR(table); 4777 4823 4778 4824 objtype = ntohl(nla_get_be32(nla[NFTA_OBJ_TYPE])); 4779 4825 if (nla[NFTA_OBJ_HANDLE]) 4780 - obj = nf_tables_obj_lookup_byhandle(table, nla[NFTA_OBJ_HANDLE], 4781 - objtype, genmask); 4826 + obj = nft_obj_lookup_byhandle(table, nla[NFTA_OBJ_HANDLE], 4827 + objtype, genmask); 4782 4828 else 4783 - obj = nf_tables_obj_lookup(table, nla[NFTA_OBJ_NAME], 4784 - objtype, genmask); 4829 + obj = nft_obj_lookup(table, nla[NFTA_OBJ_NAME], objtype, 4830 + genmask); 4785 4831 if (IS_ERR(obj)) 4786 4832 return PTR_ERR(obj); 4787 4833 if (obj->use > 0) ··· 4855 4903 [NFTA_FLOWTABLE_HANDLE] = { .type = NLA_U64 }, 4856 4904 }; 4857 4905 4858 - struct nft_flowtable *nf_tables_flowtable_lookup(const struct nft_table *table, 4859 - const struct nlattr *nla, 4860 - u8 genmask) 4906 + struct nft_flowtable *nft_flowtable_lookup(const struct nft_table *table, 4907 + const struct nlattr *nla, u8 genmask) 4861 4908 { 4862 4909 struct nft_flowtable *flowtable; 4863 4910 ··· 4867 4916 } 4868 4917 return ERR_PTR(-ENOENT); 4869 4918 } 4870 - EXPORT_SYMBOL_GPL(nf_tables_flowtable_lookup); 4919 + EXPORT_SYMBOL_GPL(nft_flowtable_lookup); 4871 4920 4872 4921 static struct nft_flowtable * 4873 - nf_tables_flowtable_lookup_byhandle(const struct nft_table *table, 4874 - const struct nlattr *nla, u8 genmask) 4922 + nft_flowtable_lookup_byhandle(const struct nft_table *table, 4923 + const struct nlattr *nla, u8 genmask) 4875 4924 { 4876 4925 struct nft_flowtable *flowtable; 4877 4926 ··· 5044 5093 !nla[NFTA_FLOWTABLE_HOOK]) 5045 5094 return -EINVAL; 5046 5095 5047 - table = nf_tables_table_lookup(net, nla[NFTA_FLOWTABLE_TABLE], 5048 - family, genmask); 5096 + table = nft_table_lookup(net, nla[NFTA_FLOWTABLE_TABLE], family, 5097 + genmask); 5049 5098 if (IS_ERR(table)) 5050 5099 return PTR_ERR(table); 5051 5100 5052 - flowtable = nf_tables_flowtable_lookup(table, nla[NFTA_FLOWTABLE_NAME], 5053 - genmask); 5101 + flowtable = nft_flowtable_lookup(table, nla[NFTA_FLOWTABLE_NAME], 5102 + genmask); 5054 5103 if (IS_ERR(flowtable)) { 5055 5104 err = PTR_ERR(flowtable); 5056 5105 if (err != -ENOENT) ··· 5161 5210 !nla[NFTA_FLOWTABLE_HANDLE])) 5162 5211 return -EINVAL; 5163 5212 5164 - table = nf_tables_table_lookup(net, nla[NFTA_FLOWTABLE_TABLE], 5165 - family, genmask); 5213 + table = nft_table_lookup(net, nla[NFTA_FLOWTABLE_TABLE], family, 5214 + genmask); 5166 5215 if (IS_ERR(table)) 5167 5216 return PTR_ERR(table); 5168 5217 5169 5218 if (nla[NFTA_FLOWTABLE_HANDLE]) 5170 - flowtable = nf_tables_flowtable_lookup_byhandle(table, 5171 - nla[NFTA_FLOWTABLE_HANDLE], 5172 - genmask); 5219 + flowtable = nft_flowtable_lookup_byhandle(table, 5220 + nla[NFTA_FLOWTABLE_HANDLE], 5221 + genmask); 5173 5222 else 5174 - flowtable = nf_tables_flowtable_lookup(table, 5175 - nla[NFTA_FLOWTABLE_NAME], 5176 - genmask); 5223 + flowtable = nft_flowtable_lookup(table, 5224 + nla[NFTA_FLOWTABLE_NAME], 5225 + genmask); 5177 5226 if (IS_ERR(flowtable)) 5178 5227 return PTR_ERR(flowtable); 5179 5228 if (flowtable->use > 0) ··· 5358 5407 if (!nla[NFTA_FLOWTABLE_NAME]) 5359 5408 return -EINVAL; 5360 5409 5361 - table = nf_tables_table_lookup(net, nla[NFTA_FLOWTABLE_TABLE], 5362 - family, genmask); 5410 + table = nft_table_lookup(net, nla[NFTA_FLOWTABLE_TABLE], family, 5411 + genmask); 5363 5412 if (IS_ERR(table)) 5364 5413 return PTR_ERR(table); 5365 5414 5366 - flowtable = nf_tables_flowtable_lookup(table, nla[NFTA_FLOWTABLE_NAME], 5367 - genmask); 5415 + flowtable = nft_flowtable_lookup(table, nla[NFTA_FLOWTABLE_NAME], 5416 + genmask); 5368 5417 if (IS_ERR(flowtable)) 5369 5418 return PTR_ERR(flowtable); 5370 5419 ··· 6333 6382 case NFT_GOTO: 6334 6383 if (!tb[NFTA_VERDICT_CHAIN]) 6335 6384 return -EINVAL; 6336 - chain = nf_tables_chain_lookup(ctx->table, 6337 - tb[NFTA_VERDICT_CHAIN], genmask); 6385 + chain = nft_chain_lookup(ctx->table, tb[NFTA_VERDICT_CHAIN], 6386 + genmask); 6338 6387 if (IS_ERR(chain)) 6339 6388 return PTR_ERR(chain); 6340 6389 if (nft_is_base_chain(chain))

+2 -3

net/netfilter/nft_flow_offload.c

··· 142 142 if (!tb[NFTA_FLOW_TABLE_NAME]) 143 143 return -EINVAL; 144 144 145 - flowtable = nf_tables_flowtable_lookup(ctx->table, 146 - tb[NFTA_FLOW_TABLE_NAME], 147 - genmask); 145 + flowtable = nft_flowtable_lookup(ctx->table, tb[NFTA_FLOW_TABLE_NAME], 146 + genmask); 148 147 if (IS_ERR(flowtable)) 149 148 return PTR_ERR(flowtable); 150 149

+2 -2

net/netfilter/nft_objref.c

··· 38 38 return -EINVAL; 39 39 40 40 objtype = ntohl(nla_get_be32(tb[NFTA_OBJREF_IMM_TYPE])); 41 - obj = nf_tables_obj_lookup(ctx->table, tb[NFTA_OBJREF_IMM_NAME], objtype, 42 - genmask); 41 + obj = nft_obj_lookup(ctx->table, tb[NFTA_OBJREF_IMM_NAME], objtype, 42 + genmask); 43 43 if (IS_ERR(obj)) 44 44 return -ENOENT; 45 45