static int __init nf_nat_init(void)
{
int ret;
ret = rhltable_init(&nf_nat_bysource_table, &nf_nat_bysource_params);
if (ret)
return ret;
ret = nf_ct_extend_register(&nat_extend);
if (ret < 0) {
rhltable_destroy(&nf_nat_bysource_table);
printk(KERN_ERR "nf_nat_core: Unable to register extension\n");
return ret;
}
ret = register_pernet_subsys(&nf_nat_net_ops);
if (ret < 0)
goto cleanup_extend;
nf_ct_helper_expectfn_register(&follow_master_nat);
BUG_ON(nfnetlink_parse_nat_setup_hook != NULL);
RCU_INIT_POINTER(nfnetlink_parse_nat_setup_hook,
nfnetlink_parse_nat_setup);
#ifdef CONFIG_XFRM
BUG_ON(nf_nat_decode_session_hook != NULL);
RCU_INIT_POINTER(nf_nat_decode_session_hook, __nf_nat_decode_session);
#endif
return 0;
cleanup_extend:
rhltable_destroy(&nf_nat_bysource_table);
nf_ct_extend_unregister(&nat_extend);
return ret;
}
static s64 __init test_rhashtable(struct rhashtable *ht, struct test_obj *array,
unsigned int entries)
{
struct test_obj *obj;
int err;
unsigned int i, insert_retries = 0;
s64 start, end;
/*
* Insertion Test:
* Insert entries into table with all keys even numbers
*/
pr_info(" Adding %d keys\n", entries);
start = ktime_get_ns();
for (i = 0; i < entries; i++) {
struct test_obj *obj = &array[i];
obj->value.id = i * 2;
err = insert_retry(ht, obj, test_rht_params);
if (err > 0)
insert_retries += err;
else if (err)
return err;
}
if (insert_retries)
pr_info(" %u insertions retried due to memory pressure\n",
insert_retries);
test_bucket_stats(ht, entries);
rcu_read_lock();
test_rht_lookup(ht, array, entries);
rcu_read_unlock();
test_bucket_stats(ht, entries);
pr_info(" Deleting %d keys\n", entries);
for (i = 0; i < entries; i++) {
struct test_obj_val key = {
.id = i * 2,
};
if (array[i].value.id != TEST_INSERT_FAIL) {
obj = rhashtable_lookup_fast(ht, &key, test_rht_params);
BUG_ON(!obj);
rhashtable_remove_fast(ht, &obj->node, test_rht_params);
}
cond_resched();
}
end = ktime_get_ns();
pr_info(" Duration of test: %lld ns\n", end - start);
return end - start;
}
static struct rhashtable ht;
static struct rhltable rhlt;
static int __init test_rhltable(unsigned int entries)
{
struct test_obj_rhl *rhl_test_objects;
unsigned long *obj_in_table;
unsigned int i, j, k;
int ret, err;
if (entries == 0)
entries = 1;
rhl_test_objects = vzalloc(sizeof(*rhl_test_objects) * entries);
if (!rhl_test_objects)
return -ENOMEM;
ret = -ENOMEM;
obj_in_table = vzalloc(BITS_TO_LONGS(entries) * sizeof(unsigned long));
if (!obj_in_table)
goto out_free;
/* nulls_base not supported in rhlist interface */
test_rht_params.nulls_base = 0;
err = rhltable_init(&rhlt, &test_rht_params);
if (WARN_ON(err))
goto out_free;
k = prandom_u32();
ret = 0;
for (i = 0; i < entries; i++) {
rhl_test_objects[i].value.id = k;
err = rhltable_insert(&rhlt, &rhl_test_objects[i].list_node,
test_rht_params);
if (WARN(err, "error %d on element %d\n", err, i))
break;
if (err == 0)
set_bit(i, obj_in_table);
}
if (err)
ret = err;
pr_info("test %d add/delete pairs into rhlist\n", entries);
for (i = 0; i < entries; i++) {
struct rhlist_head *h, *pos;
struct test_obj_rhl *obj;
struct test_obj_val key = {
.id = k,
};
bool found;
rcu_read_lock();
h = rhltable_lookup(&rhlt, &key, test_rht_params);
if (WARN(!h, "key not found during iteration %d of %d", i, entries)) {
rcu_read_unlock();
break;
}
if (i) {
j = i - 1;
rhl_for_each_entry_rcu(obj, pos, h, list_node) {
if (WARN(pos == &rhl_test_objects[j].list_node, "old element found, should be gone"))
break;
}
}
cond_resched_rcu();
found = false;
rhl_for_each_entry_rcu(obj, pos, h, list_node) {
if (pos == &rhl_test_objects[i].list_node) {
found = true;
break;
}
}
rcu_read_unlock();
if (WARN(!found, "element %d not found", i))
break;
err = rhltable_remove(&rhlt, &rhl_test_objects[i].list_node, test_rht_params);
WARN(err, "rhltable_remove: err %d for iteration %d\n", err, i);
if (err == 0)
clear_bit(i, obj_in_table);
}
if (ret == 0 && err)
ret = err;
for (i = 0; i < entries; i++) {
WARN(test_bit(i, obj_in_table), "elem %d allegedly still present", i);
err = rhltable_insert(&rhlt, &rhl_test_objects[i].list_node,
test_rht_params);
if (WARN(err, "error %d on element %d\n", err, i))
break;
if (err == 0)
set_bit(i, obj_in_table);
}
pr_info("test %d random rhlist add/delete operations\n", entries);
for (j = 0; j < entries; j++) {
u32 i = prandom_u32_max(entries);
u32 prand = prandom_u32();
cond_resched();
if (prand == 0)
prand = prandom_u32();
if (prand & 1) {
prand >>= 1;
continue;
}
err = rhltable_remove(&rhlt, &rhl_test_objects[i].list_node, test_rht_params);
if (test_bit(i, obj_in_table)) {
clear_bit(i, obj_in_table);
if (WARN(err, "cannot remove element at slot %d", i))
continue;
} else {
if (WARN(err != -ENOENT, "removed non-existant element %d, error %d not %d",
i, err, -ENOENT))
continue;
}
if (prand & 1) {
prand >>= 1;
continue;
}
err = rhltable_insert(&rhlt, &rhl_test_objects[i].list_node, test_rht_params);
if (err == 0) {
if (WARN(test_and_set_bit(i, obj_in_table), "succeeded to insert same object %d", i))
continue;
} else {
if (WARN(!test_bit(i, obj_in_table), "failed to insert object %d", i))
continue;
}
if (prand & 1) {
prand >>= 1;
continue;
}
