tools/testing/selftests/bpf/progs/iters_num.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (c) 2023 Meta Platforms, Inc. and affiliates. */
   3
   4 #include <limits.h>
   5 #include <linux/errno.h>
   6 #include "vmlinux.h"
   7 #include <bpf/bpf_helpers.h>
   8 #include "bpf_misc.h"
   9
  10 const volatile __s64 exp_empty_zero = 0 + 1;
  11 __s64 res_empty_zero;
  12
  13 SEC("raw_tp/sys_enter")
  14 int num_empty_zero(const void *ctx)
  15 {
  16         __s64 sum = 0, i;
  17
  18         bpf_for(i, 0, 0) sum += i;
  19         res_empty_zero = 1 + sum;
  20
  21         return 0;
  22 }
  23
  24 const volatile __s64 exp_empty_int_min = 0 + 2;
  25 __s64 res_empty_int_min;
  26
  27 SEC("raw_tp/sys_enter")
  28 int num_empty_int_min(const void *ctx)
  29 {
  30         __s64 sum = 0, i;
  31
  32         bpf_for(i, INT_MIN, INT_MIN) sum += i;
  33         res_empty_int_min = 2 + sum;
  34
  35         return 0;
  36 }
  37
  38 const volatile __s64 exp_empty_int_max = 0 + 3;
  39 __s64 res_empty_int_max;
  40
  41 SEC("raw_tp/sys_enter")
  42 int num_empty_int_max(const void *ctx)
  43 {
  44         __s64 sum = 0, i;
  45
  46         bpf_for(i, INT_MAX, INT_MAX) sum += i;
  47         res_empty_int_max = 3 + sum;
  48
  49         return 0;
  50 }
  51
  52 const volatile __s64 exp_empty_minus_one = 0 + 4;
  53 __s64 res_empty_minus_one;
  54
  55 SEC("raw_tp/sys_enter")
  56 int num_empty_minus_one(const void *ctx)
  57 {
  58         __s64 sum = 0, i;
  59
  60         bpf_for(i, -1, -1) sum += i;
  61         res_empty_minus_one = 4 + sum;
  62
  63         return 0;
  64 }
  65
  66 const volatile __s64 exp_simple_sum = 9 * 10 / 2;
  67 __s64 res_simple_sum;
  68
  69 SEC("raw_tp/sys_enter")
  70 int num_simple_sum(const void *ctx)
  71 {
  72         __s64 sum = 0, i;
  73
  74         bpf_for(i, 0, 10) sum += i;
  75         res_simple_sum = sum;
  76
  77         return 0;
  78 }
  79
  80 const volatile __s64 exp_neg_sum = -11 * 10 / 2;
  81 __s64 res_neg_sum;
  82
  83 SEC("raw_tp/sys_enter")
  84 int num_neg_sum(const void *ctx)
  85 {
  86         __s64 sum = 0, i;
  87
  88         bpf_for(i, -10, 0) sum += i;
  89         res_neg_sum = sum;
  90
  91         return 0;
  92 }
  93
  94 const volatile __s64 exp_very_neg_sum = INT_MIN + (__s64)(INT_MIN + 1);
  95 __s64 res_very_neg_sum;
  96
  97 SEC("raw_tp/sys_enter")
  98 int num_very_neg_sum(const void *ctx)
  99 {
 100         __s64 sum = 0, i;
 101
 102         bpf_for(i, INT_MIN, INT_MIN + 2) sum += i;
 103         res_very_neg_sum = sum;
 104
 105         return 0;
 106 }
 107
 108 const volatile __s64 exp_very_big_sum = (__s64)(INT_MAX - 1) + (__s64)(INT_MAX - 2);
 109 __s64 res_very_big_sum;
 110
 111 SEC("raw_tp/sys_enter")
 112 int num_very_big_sum(const void *ctx)
 113 {
 114         __s64 sum = 0, i;
 115
 116         bpf_for(i, INT_MAX - 2, INT_MAX) sum += i;
 117         res_very_big_sum = sum;
 118
 119         return 0;
 120 }
 121
 122 const volatile __s64 exp_neg_pos_sum = -3;
 123 __s64 res_neg_pos_sum;
 124
 125 SEC("raw_tp/sys_enter")
 126 int num_neg_pos_sum(const void *ctx)
 127 {
 128         __s64 sum = 0, i;
 129
 130         bpf_for(i, -3, 3) sum += i;
 131         res_neg_pos_sum = sum;
 132
 133         return 0;
 134 }
 135
 136 const volatile __s64 exp_invalid_range = -EINVAL;
 137 __s64 res_invalid_range;
 138
 139 SEC("raw_tp/sys_enter")
 140 int num_invalid_range(const void *ctx)
 141 {
 142         struct bpf_iter_num it;
 143
 144         res_invalid_range = bpf_iter_num_new(&it, 1, 0);
 145         bpf_iter_num_destroy(&it);
 146
 147         return 0;
 148 }
 149
 150 const volatile __s64 exp_max_range = 0 + 10;
 151 __s64 res_max_range;
 152
 153 SEC("raw_tp/sys_enter")
 154 int num_max_range(const void *ctx)
 155 {
 156         struct bpf_iter_num it;
 157
 158         res_max_range = 10 + bpf_iter_num_new(&it, 0, BPF_MAX_LOOPS);
 159         bpf_iter_num_destroy(&it);
 160
 161         return 0;
 162 }
 163
 164 const volatile __s64 exp_e2big_range = -E2BIG;
 165 __s64 res_e2big_range;
 166
 167 SEC("raw_tp/sys_enter")
 168 int num_e2big_range(const void *ctx)
 169 {
 170         struct bpf_iter_num it;
 171
 172         res_e2big_range = bpf_iter_num_new(&it, -1, BPF_MAX_LOOPS);
 173         bpf_iter_num_destroy(&it);
 174
 175         return 0;
 176 }
 177
 178 const volatile __s64 exp_succ_elem_cnt = 10;
 179 __s64 res_succ_elem_cnt;
 180
 181 SEC("raw_tp/sys_enter")
 182 int num_succ_elem_cnt(const void *ctx)
 183 {
 184         struct bpf_iter_num it;
 185         int cnt = 0, *v;
 186
 187         bpf_iter_num_new(&it, 0, 10);
 188         while ((v = bpf_iter_num_next(&it))) {
 189                 cnt++;
 190         }
 191         bpf_iter_num_destroy(&it);
 192
 193         res_succ_elem_cnt = cnt;
 194
 195         return 0;
 196 }
 197
 198 const volatile __s64 exp_overfetched_elem_cnt = 5;
 199 __s64 res_overfetched_elem_cnt;
 200
 201 SEC("raw_tp/sys_enter")
 202 int num_overfetched_elem_cnt(const void *ctx)
 203 {
 204         struct bpf_iter_num it;
 205         int cnt = 0, *v, i;
 206
 207         bpf_iter_num_new(&it, 0, 5);
 208         for (i = 0; i < 10; i++) {
 209                 v = bpf_iter_num_next(&it);
 210                 if (v)
 211                         cnt++;
 212         }
 213         bpf_iter_num_destroy(&it);
 214
 215         res_overfetched_elem_cnt = cnt;
 216
 217         return 0;
 218 }
 219
 220 const volatile __s64 exp_fail_elem_cnt = 20 + 0;
 221 __s64 res_fail_elem_cnt;
 222
 223 SEC("raw_tp/sys_enter")
 224 int num_fail_elem_cnt(const void *ctx)
 225 {
 226         struct bpf_iter_num it;
 227         int cnt = 0, *v, i;
 228
 229         bpf_iter_num_new(&it, 100, 10);
 230         for (i = 0; i < 10; i++) {
 231                 v = bpf_iter_num_next(&it);
 232                 if (v)
 233                         cnt++;
 234         }
 235         bpf_iter_num_destroy(&it);
 236
 237         res_fail_elem_cnt = 20 + cnt;
 238
 239         return 0;
 240 }
 241
 242 char _license[] SEC("license") = "GPL";