samples/bpf: Make samples more libbpf-centric

[mirror_ubuntu-zesty-kernel.git] / samples / bpf / test_lru_dist.c

diff --git a/samples/bpf/test_lru_dist.c b/samples/bpf/test_lru_dist.c
index 316230a0ed2306271288d21c25970d505e9d0507..d96dc88d3b04067135fe80c95628fca37a29c022 100644 (file)
--- a/samples/bpf/test_lru_dist.c
+++ b/samples/bpf/test_lru_dist.c
@@ -134,7 +134,7 @@ static int pfect_lru_lookup_or_insert(struct pfect_lru *lru,
        int seen = 0;
 
        lru->total++;
-       if (!bpf_lookup_elem(lru->map_fd, &key, &node)) {
+       if (!bpf_map_lookup_elem(lru->map_fd, &key, &node)) {
                if (node) {
                        list_move(&node->list, &lru->list);
                        return 1;
@@ -151,7 +151,7 @@ static int pfect_lru_lookup_or_insert(struct pfect_lru *lru,
                node = list_last_entry(&lru->list,
                                       struct pfect_lru_node,
                                       list);
-               bpf_update_elem(lru->map_fd, &node->key, &null_node, BPF_EXIST);
+               bpf_map_update_elem(lru->map_fd, &node->key, &null_node, BPF_EXIST);
        }
 
        node->key = key;
@@ -159,10 +159,10 @@ static int pfect_lru_lookup_or_insert(struct pfect_lru *lru,
 
        lru->nr_misses++;
        if (seen) {
-               assert(!bpf_update_elem(lru->map_fd, &key, &node, BPF_EXIST));
+               assert(!bpf_map_update_elem(lru->map_fd, &key, &node, BPF_EXIST));
        } else {
                lru->nr_unique++;
-               assert(!bpf_update_elem(lru->map_fd, &key, &node, BPF_NOEXIST));
+               assert(!bpf_map_update_elem(lru->map_fd, &key, &node, BPF_NOEXIST));
        }
 
        return seen;
@@ -285,11 +285,11 @@ static void do_test_lru_dist(int task, void *data)
 
                pfect_lru_lookup_or_insert(&pfect_lru, key);
 
-               if (!bpf_lookup_elem(lru_map_fd, &key, &value))
+               if (!bpf_map_lookup_elem(lru_map_fd, &key, &value))
                        continue;
 
-               if (bpf_update_elem(lru_map_fd, &key, &value, BPF_NOEXIST)) {
-                       printf("bpf_update_elem(lru_map_fd, %llu): errno:%d\n",
+               if (bpf_map_update_elem(lru_map_fd, &key, &value, BPF_NOEXIST)) {
+                       printf("bpf_map_update_elem(lru_map_fd, %llu): errno:%d\n",
                               key, errno);
                        assert(0);
                }
@@ -358,19 +358,19 @@ static void test_lru_loss0(int map_type, int map_flags)
        for (key = 1; key <= 1000; key++) {
                int start_key, end_key;
 
-               assert(bpf_update_elem(map_fd, &key, value, BPF_NOEXIST) == 0);
+               assert(bpf_map_update_elem(map_fd, &key, value, BPF_NOEXIST) == 0);
 
                start_key = 101;
                end_key = min(key, 900);
 
                while (start_key <= end_key) {
-                       bpf_lookup_elem(map_fd, &start_key, value);
+                       bpf_map_lookup_elem(map_fd, &start_key, value);
                        start_key++;
                }
        }
 
        for (key = 1; key <= 1000; key++) {
-               if (bpf_lookup_elem(map_fd, &key, value)) {
+               if (bpf_map_lookup_elem(map_fd, &key, value)) {
                        if (key <= 100)
                                old_unused_losses++;
                        else if (key <= 900)
@@ -408,10 +408,10 @@ static void test_lru_loss1(int map_type, int map_flags)
        value[0] = 1234;
 
        for (key = 1; key <= 1000; key++)
-               assert(!bpf_update_elem(map_fd, &key, value, BPF_NOEXIST));
+               assert(!bpf_map_update_elem(map_fd, &key, value, BPF_NOEXIST));
 
        for (key = 1; key <= 1000; key++) {
-               if (bpf_lookup_elem(map_fd, &key, value))
+               if (bpf_map_lookup_elem(map_fd, &key, value))
                        nr_losses++;
        }
 
@@ -436,7 +436,7 @@ static void do_test_parallel_lru_loss(int task, void *data)
        next_ins_key = stable_base;
        value[0] = 1234;
        for (i = 0; i < nr_stable_elems; i++) {
-               assert(bpf_update_elem(map_fd, &next_ins_key, value,
+               assert(bpf_map_update_elem(map_fd, &next_ins_key, value,
                                       BPF_NOEXIST) == 0);
                next_ins_key++;
        }
@@ -448,9 +448,9 @@ static void do_test_parallel_lru_loss(int task, void *data)
 
                if (rn % 10) {
                        key = rn % nr_stable_elems + stable_base;
-                       bpf_lookup_elem(map_fd, &key, value);
+                       bpf_map_lookup_elem(map_fd, &key, value);
                } else {
-                       bpf_update_elem(map_fd, &next_ins_key, value,
+                       bpf_map_update_elem(map_fd, &next_ins_key, value,
                                        BPF_NOEXIST);
                        next_ins_key++;
                }
@@ -458,7 +458,7 @@ static void do_test_parallel_lru_loss(int task, void *data)
 
        key = stable_base;
        for (i = 0; i < nr_stable_elems; i++) {
-               if (bpf_lookup_elem(map_fd, &key, value))
+               if (bpf_map_lookup_elem(map_fd, &key, value))
                        nr_losses++;
                key++;
        }