samples/bpf/map_perf_test_kern.c

   1 /* Copyright (c) 2016 Facebook
   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 #include <linux/skbuff.h>
   8 #include <linux/netdevice.h>
   9 #include <linux/version.h>
  10 #include <uapi/linux/bpf.h>
  11 #include "bpf_helpers.h"
  12
  13 #define MAX_ENTRIES 1000
  14 #define MAX_NR_CPUS 1024
  15
  16 struct bpf_map_def SEC("maps") hash_map = {
  17         .type = BPF_MAP_TYPE_HASH,
  18         .key_size = sizeof(u32),
  19         .value_size = sizeof(long),
  20         .max_entries = MAX_ENTRIES,
  21 };
  22
  23 struct bpf_map_def SEC("maps") lru_hash_map = {
  24         .type = BPF_MAP_TYPE_LRU_HASH,
  25         .key_size = sizeof(u32),
  26         .value_size = sizeof(long),
  27         .max_entries = 10000,
  28 };
  29
  30 struct bpf_map_def SEC("maps") nocommon_lru_hash_map = {
  31         .type = BPF_MAP_TYPE_LRU_HASH,
  32         .key_size = sizeof(u32),
  33         .value_size = sizeof(long),
  34         .max_entries = 10000,
  35         .map_flags = BPF_F_NO_COMMON_LRU,
  36 };
  37
  38 struct bpf_map_def SEC("maps") inner_lru_hash_map = {
  39         .type = BPF_MAP_TYPE_LRU_HASH,
  40         .key_size = sizeof(u32),
  41         .value_size = sizeof(long),
  42         .max_entries = MAX_ENTRIES,
  43         .map_flags = BPF_F_NUMA_NODE,
  44         .numa_node = 0,
  45 };
  46
  47 struct bpf_map_def SEC("maps") array_of_lru_hashs = {
  48         .type = BPF_MAP_TYPE_ARRAY_OF_MAPS,
  49         .key_size = sizeof(u32),
  50         .max_entries = MAX_NR_CPUS,
  51 };
  52
  53 struct bpf_map_def SEC("maps") percpu_hash_map = {
  54         .type = BPF_MAP_TYPE_PERCPU_HASH,
  55         .key_size = sizeof(u32),
  56         .value_size = sizeof(long),
  57         .max_entries = MAX_ENTRIES,
  58 };
  59
  60 struct bpf_map_def SEC("maps") hash_map_alloc = {
  61         .type = BPF_MAP_TYPE_HASH,
  62         .key_size = sizeof(u32),
  63         .value_size = sizeof(long),
  64         .max_entries = MAX_ENTRIES,
  65         .map_flags = BPF_F_NO_PREALLOC,
  66 };
  67
  68 struct bpf_map_def SEC("maps") percpu_hash_map_alloc = {
  69         .type = BPF_MAP_TYPE_PERCPU_HASH,
  70         .key_size = sizeof(u32),
  71         .value_size = sizeof(long),
  72         .max_entries = MAX_ENTRIES,
  73         .map_flags = BPF_F_NO_PREALLOC,
  74 };
  75
  76 struct bpf_map_def SEC("maps") lpm_trie_map_alloc = {
  77         .type = BPF_MAP_TYPE_LPM_TRIE,
  78         .key_size = 8,
  79         .value_size = sizeof(long),
  80         .max_entries = 10000,
  81         .map_flags = BPF_F_NO_PREALLOC,
  82 };
  83
  84 struct bpf_map_def SEC("maps") array_map = {
  85         .type = BPF_MAP_TYPE_ARRAY,
  86         .key_size = sizeof(u32),
  87         .value_size = sizeof(long),
  88         .max_entries = MAX_ENTRIES,
  89 };
  90
  91 struct bpf_map_def SEC("maps") lru_hash_lookup_map = {
  92         .type = BPF_MAP_TYPE_LRU_HASH,
  93         .key_size = sizeof(u32),
  94         .value_size = sizeof(long),
  95         .max_entries = MAX_ENTRIES,
  96 };
  97
  98 SEC("kprobe/sys_getuid")
  99 int stress_hmap(struct pt_regs *ctx)
 100 {
 101         u32 key = bpf_get_current_pid_tgid();
 102         long init_val = 1;
 103         long *value;
 104
 105         bpf_map_update_elem(&hash_map, &key, &init_val, BPF_ANY);
 106         value = bpf_map_lookup_elem(&hash_map, &key);
 107         if (value)
 108                 bpf_map_delete_elem(&hash_map, &key);
 109
 110         return 0;
 111 }
 112
 113 SEC("kprobe/sys_geteuid")
 114 int stress_percpu_hmap(struct pt_regs *ctx)
 115 {
 116         u32 key = bpf_get_current_pid_tgid();
 117         long init_val = 1;
 118         long *value;
 119
 120         bpf_map_update_elem(&percpu_hash_map, &key, &init_val, BPF_ANY);
 121         value = bpf_map_lookup_elem(&percpu_hash_map, &key);
 122         if (value)
 123                 bpf_map_delete_elem(&percpu_hash_map, &key);
 124         return 0;
 125 }
 126
 127 SEC("kprobe/sys_getgid")
 128 int stress_hmap_alloc(struct pt_regs *ctx)
 129 {
 130         u32 key = bpf_get_current_pid_tgid();
 131         long init_val = 1;
 132         long *value;
 133
 134         bpf_map_update_elem(&hash_map_alloc, &key, &init_val, BPF_ANY);
 135         value = bpf_map_lookup_elem(&hash_map_alloc, &key);
 136         if (value)
 137                 bpf_map_delete_elem(&hash_map_alloc, &key);
 138         return 0;
 139 }
 140
 141 SEC("kprobe/sys_getegid")
 142 int stress_percpu_hmap_alloc(struct pt_regs *ctx)
 143 {
 144         u32 key = bpf_get_current_pid_tgid();
 145         long init_val = 1;
 146         long *value;
 147
 148         bpf_map_update_elem(&percpu_hash_map_alloc, &key, &init_val, BPF_ANY);
 149         value = bpf_map_lookup_elem(&percpu_hash_map_alloc, &key);
 150         if (value)
 151                 bpf_map_delete_elem(&percpu_hash_map_alloc, &key);
 152         return 0;
 153 }
 154
 155 SEC("kprobe/sys_connect")
 156 int stress_lru_hmap_alloc(struct pt_regs *ctx)
 157 {
 158         char fmt[] = "Failed at stress_lru_hmap_alloc. ret:%dn";
 159         union {
 160                 u16 dst6[8];
 161                 struct {
 162                         u16 magic0;
 163                         u16 magic1;
 164                         u16 tcase;
 165                         u16 unused16;
 166                         u32 unused32;
 167                         u32 key;
 168                 };
 169         } test_params;
 170         struct sockaddr_in6 *in6;
 171         u16 test_case;
 172         int addrlen, ret;
 173         long val = 1;
 174         u32 key = 0;
 175
 176         in6 = (struct sockaddr_in6 *)PT_REGS_PARM2(ctx);
 177         addrlen = (int)PT_REGS_PARM3(ctx);
 178
 179         if (addrlen != sizeof(*in6))
 180                 return 0;
 181
 182         ret = bpf_probe_read(test_params.dst6, sizeof(test_params.dst6),
 183                              &in6->sin6_addr);
 184         if (ret)
 185                 goto done;
 186
 187         if (test_params.magic0 != 0xdead ||
 188             test_params.magic1 != 0xbeef)
 189                 return 0;
 190
 191         test_case = test_params.tcase;
 192         if (test_case != 3)
 193                 key = bpf_get_prandom_u32();
 194
 195         if (test_case == 0) {
 196                 ret = bpf_map_update_elem(&lru_hash_map, &key, &val, BPF_ANY);
 197         } else if (test_case == 1) {
 198                 ret = bpf_map_update_elem(&nocommon_lru_hash_map, &key, &val,
 199                                           BPF_ANY);
 200         } else if (test_case == 2) {
 201                 void *nolocal_lru_map;
 202                 int cpu = bpf_get_smp_processor_id();
 203
 204                 nolocal_lru_map = bpf_map_lookup_elem(&array_of_lru_hashs,
 205                                                       &cpu);
 206                 if (!nolocal_lru_map) {
 207                         ret = -ENOENT;
 208                         goto done;
 209                 }
 210
 211                 ret = bpf_map_update_elem(nolocal_lru_map, &key, &val,
 212                                           BPF_ANY);
 213         } else if (test_case == 3) {
 214                 u32 i;
 215
 216                 key = test_params.key;
 217
 218 #pragma clang loop unroll(full)
 219                 for (i = 0; i < 32; i++) {
 220                         bpf_map_lookup_elem(&lru_hash_lookup_map, &key);
 221                         key++;
 222                 }
 223         } else {
 224                 ret = -EINVAL;
 225         }
 226
 227 done:
 228         if (ret)
 229                 bpf_trace_printk(fmt, sizeof(fmt), ret);
 230
 231         return 0;
 232 }
 233
 234 SEC("kprobe/sys_gettid")
 235 int stress_lpm_trie_map_alloc(struct pt_regs *ctx)
 236 {
 237         union {
 238                 u32 b32[2];
 239                 u8 b8[8];
 240         } key;
 241         unsigned int i;
 242
 243         key.b32[0] = 32;
 244         key.b8[4] = 192;
 245         key.b8[5] = 168;
 246         key.b8[6] = 0;
 247         key.b8[7] = 1;
 248
 249 #pragma clang loop unroll(full)
 250         for (i = 0; i < 32; ++i)
 251                 bpf_map_lookup_elem(&lpm_trie_map_alloc, &key);
 252
 253         return 0;
 254 }
 255
 256 SEC("kprobe/sys_getpgid")
 257 int stress_hash_map_lookup(struct pt_regs *ctx)
 258 {
 259         u32 key = 1, i;
 260         long *value;
 261
 262 #pragma clang loop unroll(full)
 263         for (i = 0; i < 64; ++i)
 264                 value = bpf_map_lookup_elem(&hash_map, &key);
 265
 266         return 0;
 267 }
 268
 269 SEC("kprobe/sys_getpgrp")
 270 int stress_array_map_lookup(struct pt_regs *ctx)
 271 {
 272         u32 key = 1, i;
 273         long *value;
 274
 275 #pragma clang loop unroll(full)
 276         for (i = 0; i < 64; ++i)
 277                 value = bpf_map_lookup_elem(&array_map, &key);
 278
 279         return 0;
 280 }
 281
 282 char _license[] SEC("license") = "GPL";
 283 u32 _version SEC("version") = LINUX_VERSION_CODE;