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

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Converted from tools/testing/selftests/bpf/verifier/meta_access.c */
   3
   4 #include <linux/bpf.h>
   5 #include <bpf/bpf_helpers.h>
   6 #include "bpf_misc.h"
   7
   8 SEC("xdp")
   9 __description("meta access, test1")
  10 __success __retval(0)
  11 __naked void meta_access_test1(void)
  12 {
  13         asm volatile ("                                 \
  14         r2 = *(u32*)(r1 + %[xdp_md_data_meta]);         \
  15         r3 = *(u32*)(r1 + %[xdp_md_data]);              \
  16         r0 = r2;                                        \
  17         r0 += 8;                                        \
  18         if r0 > r3 goto l0_%=;                          \
  19         r0 = *(u8*)(r2 + 0);                            \
  20 l0_%=:  r0 = 0;                                         \
  21         exit;                                           \
  22 "       :
  23         : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)),
  24           __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta))
  25         : __clobber_all);
  26 }
  27
  28 SEC("xdp")
  29 __description("meta access, test2")
  30 __failure __msg("invalid access to packet, off=-8")
  31 __naked void meta_access_test2(void)
  32 {
  33         asm volatile ("                                 \
  34         r2 = *(u32*)(r1 + %[xdp_md_data_meta]);         \
  35         r3 = *(u32*)(r1 + %[xdp_md_data]);              \
  36         r0 = r2;                                        \
  37         r0 -= 8;                                        \
  38         r4 = r2;                                        \
  39         r4 += 8;                                        \
  40         if r4 > r3 goto l0_%=;                          \
  41         r0 = *(u8*)(r0 + 0);                            \
  42 l0_%=:  r0 = 0;                                         \
  43         exit;                                           \
  44 "       :
  45         : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)),
  46           __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta))
  47         : __clobber_all);
  48 }
  49
  50 SEC("xdp")
  51 __description("meta access, test3")
  52 __failure __msg("invalid access to packet")
  53 __naked void meta_access_test3(void)
  54 {
  55         asm volatile ("                                 \
  56         r2 = *(u32*)(r1 + %[xdp_md_data_meta]);         \
  57         r3 = *(u32*)(r1 + %[xdp_md_data_end]);          \
  58         r0 = r2;                                        \
  59         r0 += 8;                                        \
  60         if r0 > r3 goto l0_%=;                          \
  61         r0 = *(u8*)(r2 + 0);                            \
  62 l0_%=:  r0 = 0;                                         \
  63         exit;                                           \
  64 "       :
  65         : __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)),
  66           __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta))
  67         : __clobber_all);
  68 }
  69
  70 SEC("xdp")
  71 __description("meta access, test4")
  72 __failure __msg("invalid access to packet")
  73 __naked void meta_access_test4(void)
  74 {
  75         asm volatile ("                                 \
  76         r2 = *(u32*)(r1 + %[xdp_md_data_meta]);         \
  77         r3 = *(u32*)(r1 + %[xdp_md_data_end]);          \
  78         r4 = *(u32*)(r1 + %[xdp_md_data]);              \
  79         r0 = r4;                                        \
  80         r0 += 8;                                        \
  81         if r0 > r3 goto l0_%=;                          \
  82         r0 = *(u8*)(r2 + 0);                            \
  83 l0_%=:  r0 = 0;                                         \
  84         exit;                                           \
  85 "       :
  86         : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)),
  87           __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)),
  88           __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta))
  89         : __clobber_all);
  90 }
  91
  92 SEC("xdp")
  93 __description("meta access, test5")
  94 __failure __msg("R3 !read_ok")
  95 __naked void meta_access_test5(void)
  96 {
  97         asm volatile ("                                 \
  98         r3 = *(u32*)(r1 + %[xdp_md_data_meta]);         \
  99         r4 = *(u32*)(r1 + %[xdp_md_data]);              \
 100         r0 = r3;                                        \
 101         r0 += 8;                                        \
 102         if r0 > r4 goto l0_%=;                          \
 103         r2 = -8;                                        \
 104         call %[bpf_xdp_adjust_meta];                    \
 105         r0 = *(u8*)(r3 + 0);                            \
 106 l0_%=:  r0 = 0;                                         \
 107         exit;                                           \
 108 "       :
 109         : __imm(bpf_xdp_adjust_meta),
 110           __imm_const(xdp_md_data, offsetof(struct xdp_md, data)),
 111           __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta))
 112         : __clobber_all);
 113 }
 114
 115 SEC("xdp")
 116 __description("meta access, test6")
 117 __failure __msg("invalid access to packet")
 118 __naked void meta_access_test6(void)
 119 {
 120         asm volatile ("                                 \
 121         r2 = *(u32*)(r1 + %[xdp_md_data_meta]);         \
 122         r3 = *(u32*)(r1 + %[xdp_md_data]);              \
 123         r0 = r3;                                        \
 124         r0 += 8;                                        \
 125         r4 = r2;                                        \
 126         r4 += 8;                                        \
 127         if r4 > r0 goto l0_%=;                          \
 128         r0 = *(u8*)(r2 + 0);                            \
 129 l0_%=:  r0 = 0;                                         \
 130         exit;                                           \
 131 "       :
 132         : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)),
 133           __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta))
 134         : __clobber_all);
 135 }
 136
 137 SEC("xdp")
 138 __description("meta access, test7")
 139 __success __retval(0)
 140 __naked void meta_access_test7(void)
 141 {
 142         asm volatile ("                                 \
 143         r2 = *(u32*)(r1 + %[xdp_md_data_meta]);         \
 144         r3 = *(u32*)(r1 + %[xdp_md_data]);              \
 145         r0 = r3;                                        \
 146         r0 += 8;                                        \
 147         r4 = r2;                                        \
 148         r4 += 8;                                        \
 149         if r4 > r3 goto l0_%=;                          \
 150         r0 = *(u8*)(r2 + 0);                            \
 151 l0_%=:  r0 = 0;                                         \
 152         exit;                                           \
 153 "       :
 154         : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)),
 155           __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta))
 156         : __clobber_all);
 157 }
 158
 159 SEC("xdp")
 160 __description("meta access, test8")
 161 __success __retval(0)
 162 __naked void meta_access_test8(void)
 163 {
 164         asm volatile ("                                 \
 165         r2 = *(u32*)(r1 + %[xdp_md_data_meta]);         \
 166         r3 = *(u32*)(r1 + %[xdp_md_data]);              \
 167         r4 = r2;                                        \
 168         r4 += 0xFFFF;                                   \
 169         if r4 > r3 goto l0_%=;                          \
 170         r0 = *(u8*)(r2 + 0);                            \
 171 l0_%=:  r0 = 0;                                         \
 172         exit;                                           \
 173 "       :
 174         : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)),
 175           __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta))
 176         : __clobber_all);
 177 }
 178
 179 SEC("xdp")
 180 __description("meta access, test9")
 181 __failure __msg("invalid access to packet")
 182 __naked void meta_access_test9(void)
 183 {
 184         asm volatile ("                                 \
 185         r2 = *(u32*)(r1 + %[xdp_md_data_meta]);         \
 186         r3 = *(u32*)(r1 + %[xdp_md_data]);              \
 187         r4 = r2;                                        \
 188         r4 += 0xFFFF;                                   \
 189         r4 += 1;                                        \
 190         if r4 > r3 goto l0_%=;                          \
 191         r0 = *(u8*)(r2 + 0);                            \
 192 l0_%=:  r0 = 0;                                         \
 193         exit;                                           \
 194 "       :
 195         : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)),
 196           __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta))
 197         : __clobber_all);
 198 }
 199
 200 SEC("xdp")
 201 __description("meta access, test10")
 202 __failure __msg("invalid access to packet")
 203 __naked void meta_access_test10(void)
 204 {
 205         asm volatile ("                                 \
 206         r2 = *(u32*)(r1 + %[xdp_md_data_meta]);         \
 207         r3 = *(u32*)(r1 + %[xdp_md_data]);              \
 208         r4 = *(u32*)(r1 + %[xdp_md_data_end]);          \
 209         r5 = 42;                                        \
 210         r6 = 24;                                        \
 211         *(u64*)(r10 - 8) = r5;                          \
 212         lock *(u64 *)(r10 - 8) += r6;                   \
 213         r5 = *(u64*)(r10 - 8);                          \
 214         if r5 > 100 goto l0_%=;                         \
 215         r3 += r5;                                       \
 216         r5 = r3;                                        \
 217         r6 = r2;                                        \
 218         r6 += 8;                                        \
 219         if r6 > r5 goto l0_%=;                          \
 220         r2 = *(u8*)(r2 + 0);                            \
 221 l0_%=:  r0 = 0;                                         \
 222         exit;                                           \
 223 "       :
 224         : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)),
 225           __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)),
 226           __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta))
 227         : __clobber_all);
 228 }
 229
 230 SEC("xdp")
 231 __description("meta access, test11")
 232 __success __retval(0)
 233 __naked void meta_access_test11(void)
 234 {
 235         asm volatile ("                                 \
 236         r2 = *(u32*)(r1 + %[xdp_md_data_meta]);         \
 237         r3 = *(u32*)(r1 + %[xdp_md_data]);              \
 238         r5 = 42;                                        \
 239         r6 = 24;                                        \
 240         *(u64*)(r10 - 8) = r5;                          \
 241         lock *(u64 *)(r10 - 8) += r6;                   \
 242         r5 = *(u64*)(r10 - 8);                          \
 243         if r5 > 100 goto l0_%=;                         \
 244         r2 += r5;                                       \
 245         r5 = r2;                                        \
 246         r6 = r2;                                        \
 247         r6 += 8;                                        \
 248         if r6 > r3 goto l0_%=;                          \
 249         r5 = *(u8*)(r5 + 0);                            \
 250 l0_%=:  r0 = 0;                                         \
 251         exit;                                           \
 252 "       :
 253         : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)),
 254           __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta))
 255         : __clobber_all);
 256 }
 257
 258 SEC("xdp")
 259 __description("meta access, test12")
 260 __success __retval(0)
 261 __naked void meta_access_test12(void)
 262 {
 263         asm volatile ("                                 \
 264         r2 = *(u32*)(r1 + %[xdp_md_data_meta]);         \
 265         r3 = *(u32*)(r1 + %[xdp_md_data]);              \
 266         r4 = *(u32*)(r1 + %[xdp_md_data_end]);          \
 267         r5 = r3;                                        \
 268         r5 += 16;                                       \
 269         if r5 > r4 goto l0_%=;                          \
 270         r0 = *(u8*)(r3 + 0);                            \
 271         r5 = r2;                                        \
 272         r5 += 16;                                       \
 273         if r5 > r3 goto l0_%=;                          \
 274         r0 = *(u8*)(r2 + 0);                            \
 275 l0_%=:  r0 = 0;                                         \
 276         exit;                                           \
 277 "       :
 278         : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)),
 279           __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)),
 280           __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta))
 281         : __clobber_all);
 282 }
 283
 284 char _license[] SEC("license") = "GPL";