ixgbe: fix MAC anti-spoofing filter after VFLR
[muen/linux.git] / kernel / bpf / verifier.c
1 /* Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com
2  * Copyright (c) 2016 Facebook
3  * Copyright (c) 2018 Covalent IO, Inc. http://covalent.io
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of version 2 of the GNU General Public
7  * License as published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * General Public License for more details.
13  */
14 #include <linux/kernel.h>
15 #include <linux/types.h>
16 #include <linux/slab.h>
17 #include <linux/bpf.h>
18 #include <linux/bpf_verifier.h>
19 #include <linux/filter.h>
20 #include <net/netlink.h>
21 #include <linux/file.h>
22 #include <linux/vmalloc.h>
23 #include <linux/stringify.h>
24 #include <linux/bsearch.h>
25 #include <linux/sort.h>
26 #include <linux/perf_event.h>
27
28 #include "disasm.h"
29
30 static const struct bpf_verifier_ops * const bpf_verifier_ops[] = {
31 #define BPF_PROG_TYPE(_id, _name) \
32         [_id] = & _name ## _verifier_ops,
33 #define BPF_MAP_TYPE(_id, _ops)
34 #include <linux/bpf_types.h>
35 #undef BPF_PROG_TYPE
36 #undef BPF_MAP_TYPE
37 };
38
39 /* bpf_check() is a static code analyzer that walks eBPF program
40  * instruction by instruction and updates register/stack state.
41  * All paths of conditional branches are analyzed until 'bpf_exit' insn.
42  *
43  * The first pass is depth-first-search to check that the program is a DAG.
44  * It rejects the following programs:
45  * - larger than BPF_MAXINSNS insns
46  * - if loop is present (detected via back-edge)
47  * - unreachable insns exist (shouldn't be a forest. program = one function)
48  * - out of bounds or malformed jumps
49  * The second pass is all possible path descent from the 1st insn.
50  * Since it's analyzing all pathes through the program, the length of the
51  * analysis is limited to 64k insn, which may be hit even if total number of
52  * insn is less then 4K, but there are too many branches that change stack/regs.
53  * Number of 'branches to be analyzed' is limited to 1k
54  *
55  * On entry to each instruction, each register has a type, and the instruction
56  * changes the types of the registers depending on instruction semantics.
57  * If instruction is BPF_MOV64_REG(BPF_REG_1, BPF_REG_5), then type of R5 is
58  * copied to R1.
59  *
60  * All registers are 64-bit.
61  * R0 - return register
62  * R1-R5 argument passing registers
63  * R6-R9 callee saved registers
64  * R10 - frame pointer read-only
65  *
66  * At the start of BPF program the register R1 contains a pointer to bpf_context
67  * and has type PTR_TO_CTX.
68  *
69  * Verifier tracks arithmetic operations on pointers in case:
70  *    BPF_MOV64_REG(BPF_REG_1, BPF_REG_10),
71  *    BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -20),
72  * 1st insn copies R10 (which has FRAME_PTR) type into R1
73  * and 2nd arithmetic instruction is pattern matched to recognize
74  * that it wants to construct a pointer to some element within stack.
75  * So after 2nd insn, the register R1 has type PTR_TO_STACK
76  * (and -20 constant is saved for further stack bounds checking).
77  * Meaning that this reg is a pointer to stack plus known immediate constant.
78  *
79  * Most of the time the registers have SCALAR_VALUE type, which
80  * means the register has some value, but it's not a valid pointer.
81  * (like pointer plus pointer becomes SCALAR_VALUE type)
82  *
83  * When verifier sees load or store instructions the type of base register
84  * can be: PTR_TO_MAP_VALUE, PTR_TO_CTX, PTR_TO_STACK, PTR_TO_SOCKET. These are
85  * four pointer types recognized by check_mem_access() function.
86  *
87  * PTR_TO_MAP_VALUE means that this register is pointing to 'map element value'
88  * and the range of [ptr, ptr + map's value_size) is accessible.
89  *
90  * registers used to pass values to function calls are checked against
91  * function argument constraints.
92  *
93  * ARG_PTR_TO_MAP_KEY is one of such argument constraints.
94  * It means that the register type passed to this function must be
95  * PTR_TO_STACK and it will be used inside the function as
96  * 'pointer to map element key'
97  *
98  * For example the argument constraints for bpf_map_lookup_elem():
99  *   .ret_type = RET_PTR_TO_MAP_VALUE_OR_NULL,
100  *   .arg1_type = ARG_CONST_MAP_PTR,
101  *   .arg2_type = ARG_PTR_TO_MAP_KEY,
102  *
103  * ret_type says that this function returns 'pointer to map elem value or null'
104  * function expects 1st argument to be a const pointer to 'struct bpf_map' and
105  * 2nd argument should be a pointer to stack, which will be used inside
106  * the helper function as a pointer to map element key.
107  *
108  * On the kernel side the helper function looks like:
109  * u64 bpf_map_lookup_elem(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5)
110  * {
111  *    struct bpf_map *map = (struct bpf_map *) (unsigned long) r1;
112  *    void *key = (void *) (unsigned long) r2;
113  *    void *value;
114  *
115  *    here kernel can access 'key' and 'map' pointers safely, knowing that
116  *    [key, key + map->key_size) bytes are valid and were initialized on
117  *    the stack of eBPF program.
118  * }
119  *
120  * Corresponding eBPF program may look like:
121  *    BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),  // after this insn R2 type is FRAME_PTR
122  *    BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4), // after this insn R2 type is PTR_TO_STACK
123  *    BPF_LD_MAP_FD(BPF_REG_1, map_fd),      // after this insn R1 type is CONST_PTR_TO_MAP
124  *    BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
125  * here verifier looks at prototype of map_lookup_elem() and sees:
126  * .arg1_type == ARG_CONST_MAP_PTR and R1->type == CONST_PTR_TO_MAP, which is ok,
127  * Now verifier knows that this map has key of R1->map_ptr->key_size bytes
128  *
129  * Then .arg2_type == ARG_PTR_TO_MAP_KEY and R2->type == PTR_TO_STACK, ok so far,
130  * Now verifier checks that [R2, R2 + map's key_size) are within stack limits
131  * and were initialized prior to this call.
132  * If it's ok, then verifier allows this BPF_CALL insn and looks at
133  * .ret_type which is RET_PTR_TO_MAP_VALUE_OR_NULL, so it sets
134  * R0->type = PTR_TO_MAP_VALUE_OR_NULL which means bpf_map_lookup_elem() function
135  * returns ether pointer to map value or NULL.
136  *
137  * When type PTR_TO_MAP_VALUE_OR_NULL passes through 'if (reg != 0) goto +off'
138  * insn, the register holding that pointer in the true branch changes state to
139  * PTR_TO_MAP_VALUE and the same register changes state to CONST_IMM in the false
140  * branch. See check_cond_jmp_op().
141  *
142  * After the call R0 is set to return type of the function and registers R1-R5
143  * are set to NOT_INIT to indicate that they are no longer readable.
144  *
145  * The following reference types represent a potential reference to a kernel
146  * resource which, after first being allocated, must be checked and freed by
147  * the BPF program:
148  * - PTR_TO_SOCKET_OR_NULL, PTR_TO_SOCKET
149  *
150  * When the verifier sees a helper call return a reference type, it allocates a
151  * pointer id for the reference and stores it in the current function state.
152  * Similar to the way that PTR_TO_MAP_VALUE_OR_NULL is converted into
153  * PTR_TO_MAP_VALUE, PTR_TO_SOCKET_OR_NULL becomes PTR_TO_SOCKET when the type
154  * passes through a NULL-check conditional. For the branch wherein the state is
155  * changed to CONST_IMM, the verifier releases the reference.
156  *
157  * For each helper function that allocates a reference, such as
158  * bpf_sk_lookup_tcp(), there is a corresponding release function, such as
159  * bpf_sk_release(). When a reference type passes into the release function,
160  * the verifier also releases the reference. If any unchecked or unreleased
161  * reference remains at the end of the program, the verifier rejects it.
162  */
163
164 /* verifier_state + insn_idx are pushed to stack when branch is encountered */
165 struct bpf_verifier_stack_elem {
166         /* verifer state is 'st'
167          * before processing instruction 'insn_idx'
168          * and after processing instruction 'prev_insn_idx'
169          */
170         struct bpf_verifier_state st;
171         int insn_idx;
172         int prev_insn_idx;
173         struct bpf_verifier_stack_elem *next;
174 };
175
176 #define BPF_COMPLEXITY_LIMIT_INSNS      131072
177 #define BPF_COMPLEXITY_LIMIT_STACK      1024
178
179 #define BPF_MAP_PTR_UNPRIV      1UL
180 #define BPF_MAP_PTR_POISON      ((void *)((0xeB9FUL << 1) +     \
181                                           POISON_POINTER_DELTA))
182 #define BPF_MAP_PTR(X)          ((struct bpf_map *)((X) & ~BPF_MAP_PTR_UNPRIV))
183
184 static bool bpf_map_ptr_poisoned(const struct bpf_insn_aux_data *aux)
185 {
186         return BPF_MAP_PTR(aux->map_state) == BPF_MAP_PTR_POISON;
187 }
188
189 static bool bpf_map_ptr_unpriv(const struct bpf_insn_aux_data *aux)
190 {
191         return aux->map_state & BPF_MAP_PTR_UNPRIV;
192 }
193
194 static void bpf_map_ptr_store(struct bpf_insn_aux_data *aux,
195                               const struct bpf_map *map, bool unpriv)
196 {
197         BUILD_BUG_ON((unsigned long)BPF_MAP_PTR_POISON & BPF_MAP_PTR_UNPRIV);
198         unpriv |= bpf_map_ptr_unpriv(aux);
199         aux->map_state = (unsigned long)map |
200                          (unpriv ? BPF_MAP_PTR_UNPRIV : 0UL);
201 }
202
203 struct bpf_call_arg_meta {
204         struct bpf_map *map_ptr;
205         bool raw_mode;
206         bool pkt_access;
207         int regno;
208         int access_size;
209         s64 msize_smax_value;
210         u64 msize_umax_value;
211         int ptr_id;
212 };
213
214 static DEFINE_MUTEX(bpf_verifier_lock);
215
216 void bpf_verifier_vlog(struct bpf_verifier_log *log, const char *fmt,
217                        va_list args)
218 {
219         unsigned int n;
220
221         n = vscnprintf(log->kbuf, BPF_VERIFIER_TMP_LOG_SIZE, fmt, args);
222
223         WARN_ONCE(n >= BPF_VERIFIER_TMP_LOG_SIZE - 1,
224                   "verifier log line truncated - local buffer too short\n");
225
226         n = min(log->len_total - log->len_used - 1, n);
227         log->kbuf[n] = '\0';
228
229         if (!copy_to_user(log->ubuf + log->len_used, log->kbuf, n + 1))
230                 log->len_used += n;
231         else
232                 log->ubuf = NULL;
233 }
234
235 /* log_level controls verbosity level of eBPF verifier.
236  * bpf_verifier_log_write() is used to dump the verification trace to the log,
237  * so the user can figure out what's wrong with the program
238  */
239 __printf(2, 3) void bpf_verifier_log_write(struct bpf_verifier_env *env,
240                                            const char *fmt, ...)
241 {
242         va_list args;
243
244         if (!bpf_verifier_log_needed(&env->log))
245                 return;
246
247         va_start(args, fmt);
248         bpf_verifier_vlog(&env->log, fmt, args);
249         va_end(args);
250 }
251 EXPORT_SYMBOL_GPL(bpf_verifier_log_write);
252
253 __printf(2, 3) static void verbose(void *private_data, const char *fmt, ...)
254 {
255         struct bpf_verifier_env *env = private_data;
256         va_list args;
257
258         if (!bpf_verifier_log_needed(&env->log))
259                 return;
260
261         va_start(args, fmt);
262         bpf_verifier_vlog(&env->log, fmt, args);
263         va_end(args);
264 }
265
266 static bool type_is_pkt_pointer(enum bpf_reg_type type)
267 {
268         return type == PTR_TO_PACKET ||
269                type == PTR_TO_PACKET_META;
270 }
271
272 static bool reg_type_may_be_null(enum bpf_reg_type type)
273 {
274         return type == PTR_TO_MAP_VALUE_OR_NULL ||
275                type == PTR_TO_SOCKET_OR_NULL;
276 }
277
278 static bool type_is_refcounted(enum bpf_reg_type type)
279 {
280         return type == PTR_TO_SOCKET;
281 }
282
283 static bool type_is_refcounted_or_null(enum bpf_reg_type type)
284 {
285         return type == PTR_TO_SOCKET || type == PTR_TO_SOCKET_OR_NULL;
286 }
287
288 static bool reg_is_refcounted(const struct bpf_reg_state *reg)
289 {
290         return type_is_refcounted(reg->type);
291 }
292
293 static bool reg_is_refcounted_or_null(const struct bpf_reg_state *reg)
294 {
295         return type_is_refcounted_or_null(reg->type);
296 }
297
298 static bool arg_type_is_refcounted(enum bpf_arg_type type)
299 {
300         return type == ARG_PTR_TO_SOCKET;
301 }
302
303 /* Determine whether the function releases some resources allocated by another
304  * function call. The first reference type argument will be assumed to be
305  * released by release_reference().
306  */
307 static bool is_release_function(enum bpf_func_id func_id)
308 {
309         return func_id == BPF_FUNC_sk_release;
310 }
311
312 /* string representation of 'enum bpf_reg_type' */
313 static const char * const reg_type_str[] = {
314         [NOT_INIT]              = "?",
315         [SCALAR_VALUE]          = "inv",
316         [PTR_TO_CTX]            = "ctx",
317         [CONST_PTR_TO_MAP]      = "map_ptr",
318         [PTR_TO_MAP_VALUE]      = "map_value",
319         [PTR_TO_MAP_VALUE_OR_NULL] = "map_value_or_null",
320         [PTR_TO_STACK]          = "fp",
321         [PTR_TO_PACKET]         = "pkt",
322         [PTR_TO_PACKET_META]    = "pkt_meta",
323         [PTR_TO_PACKET_END]     = "pkt_end",
324         [PTR_TO_FLOW_KEYS]      = "flow_keys",
325         [PTR_TO_SOCKET]         = "sock",
326         [PTR_TO_SOCKET_OR_NULL] = "sock_or_null",
327 };
328
329 static char slot_type_char[] = {
330         [STACK_INVALID] = '?',
331         [STACK_SPILL]   = 'r',
332         [STACK_MISC]    = 'm',
333         [STACK_ZERO]    = '0',
334 };
335
336 static void print_liveness(struct bpf_verifier_env *env,
337                            enum bpf_reg_liveness live)
338 {
339         if (live & (REG_LIVE_READ | REG_LIVE_WRITTEN))
340             verbose(env, "_");
341         if (live & REG_LIVE_READ)
342                 verbose(env, "r");
343         if (live & REG_LIVE_WRITTEN)
344                 verbose(env, "w");
345 }
346
347 static struct bpf_func_state *func(struct bpf_verifier_env *env,
348                                    const struct bpf_reg_state *reg)
349 {
350         struct bpf_verifier_state *cur = env->cur_state;
351
352         return cur->frame[reg->frameno];
353 }
354
355 static void print_verifier_state(struct bpf_verifier_env *env,
356                                  const struct bpf_func_state *state)
357 {
358         const struct bpf_reg_state *reg;
359         enum bpf_reg_type t;
360         int i;
361
362         if (state->frameno)
363                 verbose(env, " frame%d:", state->frameno);
364         for (i = 0; i < MAX_BPF_REG; i++) {
365                 reg = &state->regs[i];
366                 t = reg->type;
367                 if (t == NOT_INIT)
368                         continue;
369                 verbose(env, " R%d", i);
370                 print_liveness(env, reg->live);
371                 verbose(env, "=%s", reg_type_str[t]);
372                 if ((t == SCALAR_VALUE || t == PTR_TO_STACK) &&
373                     tnum_is_const(reg->var_off)) {
374                         /* reg->off should be 0 for SCALAR_VALUE */
375                         verbose(env, "%lld", reg->var_off.value + reg->off);
376                         if (t == PTR_TO_STACK)
377                                 verbose(env, ",call_%d", func(env, reg)->callsite);
378                 } else {
379                         verbose(env, "(id=%d", reg->id);
380                         if (t != SCALAR_VALUE)
381                                 verbose(env, ",off=%d", reg->off);
382                         if (type_is_pkt_pointer(t))
383                                 verbose(env, ",r=%d", reg->range);
384                         else if (t == CONST_PTR_TO_MAP ||
385                                  t == PTR_TO_MAP_VALUE ||
386                                  t == PTR_TO_MAP_VALUE_OR_NULL)
387                                 verbose(env, ",ks=%d,vs=%d",
388                                         reg->map_ptr->key_size,
389                                         reg->map_ptr->value_size);
390                         if (tnum_is_const(reg->var_off)) {
391                                 /* Typically an immediate SCALAR_VALUE, but
392                                  * could be a pointer whose offset is too big
393                                  * for reg->off
394                                  */
395                                 verbose(env, ",imm=%llx", reg->var_off.value);
396                         } else {
397                                 if (reg->smin_value != reg->umin_value &&
398                                     reg->smin_value != S64_MIN)
399                                         verbose(env, ",smin_value=%lld",
400                                                 (long long)reg->smin_value);
401                                 if (reg->smax_value != reg->umax_value &&
402                                     reg->smax_value != S64_MAX)
403                                         verbose(env, ",smax_value=%lld",
404                                                 (long long)reg->smax_value);
405                                 if (reg->umin_value != 0)
406                                         verbose(env, ",umin_value=%llu",
407                                                 (unsigned long long)reg->umin_value);
408                                 if (reg->umax_value != U64_MAX)
409                                         verbose(env, ",umax_value=%llu",
410                                                 (unsigned long long)reg->umax_value);
411                                 if (!tnum_is_unknown(reg->var_off)) {
412                                         char tn_buf[48];
413
414                                         tnum_strn(tn_buf, sizeof(tn_buf), reg->var_off);
415                                         verbose(env, ",var_off=%s", tn_buf);
416                                 }
417                         }
418                         verbose(env, ")");
419                 }
420         }
421         for (i = 0; i < state->allocated_stack / BPF_REG_SIZE; i++) {
422                 char types_buf[BPF_REG_SIZE + 1];
423                 bool valid = false;
424                 int j;
425
426                 for (j = 0; j < BPF_REG_SIZE; j++) {
427                         if (state->stack[i].slot_type[j] != STACK_INVALID)
428                                 valid = true;
429                         types_buf[j] = slot_type_char[
430                                         state->stack[i].slot_type[j]];
431                 }
432                 types_buf[BPF_REG_SIZE] = 0;
433                 if (!valid)
434                         continue;
435                 verbose(env, " fp%d", (-i - 1) * BPF_REG_SIZE);
436                 print_liveness(env, state->stack[i].spilled_ptr.live);
437                 if (state->stack[i].slot_type[0] == STACK_SPILL)
438                         verbose(env, "=%s",
439                                 reg_type_str[state->stack[i].spilled_ptr.type]);
440                 else
441                         verbose(env, "=%s", types_buf);
442         }
443         if (state->acquired_refs && state->refs[0].id) {
444                 verbose(env, " refs=%d", state->refs[0].id);
445                 for (i = 1; i < state->acquired_refs; i++)
446                         if (state->refs[i].id)
447                                 verbose(env, ",%d", state->refs[i].id);
448         }
449         verbose(env, "\n");
450 }
451
452 #define COPY_STATE_FN(NAME, COUNT, FIELD, SIZE)                         \
453 static int copy_##NAME##_state(struct bpf_func_state *dst,              \
454                                const struct bpf_func_state *src)        \
455 {                                                                       \
456         if (!src->FIELD)                                                \
457                 return 0;                                               \
458         if (WARN_ON_ONCE(dst->COUNT < src->COUNT)) {                    \
459                 /* internal bug, make state invalid to reject the program */ \
460                 memset(dst, 0, sizeof(*dst));                           \
461                 return -EFAULT;                                         \
462         }                                                               \
463         memcpy(dst->FIELD, src->FIELD,                                  \
464                sizeof(*src->FIELD) * (src->COUNT / SIZE));              \
465         return 0;                                                       \
466 }
467 /* copy_reference_state() */
468 COPY_STATE_FN(reference, acquired_refs, refs, 1)
469 /* copy_stack_state() */
470 COPY_STATE_FN(stack, allocated_stack, stack, BPF_REG_SIZE)
471 #undef COPY_STATE_FN
472
473 #define REALLOC_STATE_FN(NAME, COUNT, FIELD, SIZE)                      \
474 static int realloc_##NAME##_state(struct bpf_func_state *state, int size, \
475                                   bool copy_old)                        \
476 {                                                                       \
477         u32 old_size = state->COUNT;                                    \
478         struct bpf_##NAME##_state *new_##FIELD;                         \
479         int slot = size / SIZE;                                         \
480                                                                         \
481         if (size <= old_size || !size) {                                \
482                 if (copy_old)                                           \
483                         return 0;                                       \
484                 state->COUNT = slot * SIZE;                             \
485                 if (!size && old_size) {                                \
486                         kfree(state->FIELD);                            \
487                         state->FIELD = NULL;                            \
488                 }                                                       \
489                 return 0;                                               \
490         }                                                               \
491         new_##FIELD = kmalloc_array(slot, sizeof(struct bpf_##NAME##_state), \
492                                     GFP_KERNEL);                        \
493         if (!new_##FIELD)                                               \
494                 return -ENOMEM;                                         \
495         if (copy_old) {                                                 \
496                 if (state->FIELD)                                       \
497                         memcpy(new_##FIELD, state->FIELD,               \
498                                sizeof(*new_##FIELD) * (old_size / SIZE)); \
499                 memset(new_##FIELD + old_size / SIZE, 0,                \
500                        sizeof(*new_##FIELD) * (size - old_size) / SIZE); \
501         }                                                               \
502         state->COUNT = slot * SIZE;                                     \
503         kfree(state->FIELD);                                            \
504         state->FIELD = new_##FIELD;                                     \
505         return 0;                                                       \
506 }
507 /* realloc_reference_state() */
508 REALLOC_STATE_FN(reference, acquired_refs, refs, 1)
509 /* realloc_stack_state() */
510 REALLOC_STATE_FN(stack, allocated_stack, stack, BPF_REG_SIZE)
511 #undef REALLOC_STATE_FN
512
513 /* do_check() starts with zero-sized stack in struct bpf_verifier_state to
514  * make it consume minimal amount of memory. check_stack_write() access from
515  * the program calls into realloc_func_state() to grow the stack size.
516  * Note there is a non-zero 'parent' pointer inside bpf_verifier_state
517  * which realloc_stack_state() copies over. It points to previous
518  * bpf_verifier_state which is never reallocated.
519  */
520 static int realloc_func_state(struct bpf_func_state *state, int stack_size,
521                               int refs_size, bool copy_old)
522 {
523         int err = realloc_reference_state(state, refs_size, copy_old);
524         if (err)
525                 return err;
526         return realloc_stack_state(state, stack_size, copy_old);
527 }
528
529 /* Acquire a pointer id from the env and update the state->refs to include
530  * this new pointer reference.
531  * On success, returns a valid pointer id to associate with the register
532  * On failure, returns a negative errno.
533  */
534 static int acquire_reference_state(struct bpf_verifier_env *env, int insn_idx)
535 {
536         struct bpf_func_state *state = cur_func(env);
537         int new_ofs = state->acquired_refs;
538         int id, err;
539
540         err = realloc_reference_state(state, state->acquired_refs + 1, true);
541         if (err)
542                 return err;
543         id = ++env->id_gen;
544         state->refs[new_ofs].id = id;
545         state->refs[new_ofs].insn_idx = insn_idx;
546
547         return id;
548 }
549
550 /* release function corresponding to acquire_reference_state(). Idempotent. */
551 static int __release_reference_state(struct bpf_func_state *state, int ptr_id)
552 {
553         int i, last_idx;
554
555         if (!ptr_id)
556                 return -EFAULT;
557
558         last_idx = state->acquired_refs - 1;
559         for (i = 0; i < state->acquired_refs; i++) {
560                 if (state->refs[i].id == ptr_id) {
561                         if (last_idx && i != last_idx)
562                                 memcpy(&state->refs[i], &state->refs[last_idx],
563                                        sizeof(*state->refs));
564                         memset(&state->refs[last_idx], 0, sizeof(*state->refs));
565                         state->acquired_refs--;
566                         return 0;
567                 }
568         }
569         return -EFAULT;
570 }
571
572 /* variation on the above for cases where we expect that there must be an
573  * outstanding reference for the specified ptr_id.
574  */
575 static int release_reference_state(struct bpf_verifier_env *env, int ptr_id)
576 {
577         struct bpf_func_state *state = cur_func(env);
578         int err;
579
580         err = __release_reference_state(state, ptr_id);
581         if (WARN_ON_ONCE(err != 0))
582                 verbose(env, "verifier internal error: can't release reference\n");
583         return err;
584 }
585
586 static int transfer_reference_state(struct bpf_func_state *dst,
587                                     struct bpf_func_state *src)
588 {
589         int err = realloc_reference_state(dst, src->acquired_refs, false);
590         if (err)
591                 return err;
592         err = copy_reference_state(dst, src);
593         if (err)
594                 return err;
595         return 0;
596 }
597
598 static void free_func_state(struct bpf_func_state *state)
599 {
600         if (!state)
601                 return;
602         kfree(state->refs);
603         kfree(state->stack);
604         kfree(state);
605 }
606
607 static void free_verifier_state(struct bpf_verifier_state *state,
608                                 bool free_self)
609 {
610         int i;
611
612         for (i = 0; i <= state->curframe; i++) {
613                 free_func_state(state->frame[i]);
614                 state->frame[i] = NULL;
615         }
616         if (free_self)
617                 kfree(state);
618 }
619
620 /* copy verifier state from src to dst growing dst stack space
621  * when necessary to accommodate larger src stack
622  */
623 static int copy_func_state(struct bpf_func_state *dst,
624                            const struct bpf_func_state *src)
625 {
626         int err;
627
628         err = realloc_func_state(dst, src->allocated_stack, src->acquired_refs,
629                                  false);
630         if (err)
631                 return err;
632         memcpy(dst, src, offsetof(struct bpf_func_state, acquired_refs));
633         err = copy_reference_state(dst, src);
634         if (err)
635                 return err;
636         return copy_stack_state(dst, src);
637 }
638
639 static int copy_verifier_state(struct bpf_verifier_state *dst_state,
640                                const struct bpf_verifier_state *src)
641 {
642         struct bpf_func_state *dst;
643         int i, err;
644
645         /* if dst has more stack frames then src frame, free them */
646         for (i = src->curframe + 1; i <= dst_state->curframe; i++) {
647                 free_func_state(dst_state->frame[i]);
648                 dst_state->frame[i] = NULL;
649         }
650         dst_state->curframe = src->curframe;
651         for (i = 0; i <= src->curframe; i++) {
652                 dst = dst_state->frame[i];
653                 if (!dst) {
654                         dst = kzalloc(sizeof(*dst), GFP_KERNEL);
655                         if (!dst)
656                                 return -ENOMEM;
657                         dst_state->frame[i] = dst;
658                 }
659                 err = copy_func_state(dst, src->frame[i]);
660                 if (err)
661                         return err;
662         }
663         return 0;
664 }
665
666 static int pop_stack(struct bpf_verifier_env *env, int *prev_insn_idx,
667                      int *insn_idx)
668 {
669         struct bpf_verifier_state *cur = env->cur_state;
670         struct bpf_verifier_stack_elem *elem, *head = env->head;
671         int err;
672
673         if (env->head == NULL)
674                 return -ENOENT;
675
676         if (cur) {
677                 err = copy_verifier_state(cur, &head->st);
678                 if (err)
679                         return err;
680         }
681         if (insn_idx)
682                 *insn_idx = head->insn_idx;
683         if (prev_insn_idx)
684                 *prev_insn_idx = head->prev_insn_idx;
685         elem = head->next;
686         free_verifier_state(&head->st, false);
687         kfree(head);
688         env->head = elem;
689         env->stack_size--;
690         return 0;
691 }
692
693 static struct bpf_verifier_state *push_stack(struct bpf_verifier_env *env,
694                                              int insn_idx, int prev_insn_idx)
695 {
696         struct bpf_verifier_state *cur = env->cur_state;
697         struct bpf_verifier_stack_elem *elem;
698         int err;
699
700         elem = kzalloc(sizeof(struct bpf_verifier_stack_elem), GFP_KERNEL);
701         if (!elem)
702                 goto err;
703
704         elem->insn_idx = insn_idx;
705         elem->prev_insn_idx = prev_insn_idx;
706         elem->next = env->head;
707         env->head = elem;
708         env->stack_size++;
709         err = copy_verifier_state(&elem->st, cur);
710         if (err)
711                 goto err;
712         if (env->stack_size > BPF_COMPLEXITY_LIMIT_STACK) {
713                 verbose(env, "BPF program is too complex\n");
714                 goto err;
715         }
716         return &elem->st;
717 err:
718         free_verifier_state(env->cur_state, true);
719         env->cur_state = NULL;
720         /* pop all elements and return */
721         while (!pop_stack(env, NULL, NULL));
722         return NULL;
723 }
724
725 #define CALLER_SAVED_REGS 6
726 static const int caller_saved[CALLER_SAVED_REGS] = {
727         BPF_REG_0, BPF_REG_1, BPF_REG_2, BPF_REG_3, BPF_REG_4, BPF_REG_5
728 };
729
730 static void __mark_reg_not_init(struct bpf_reg_state *reg);
731
732 /* Mark the unknown part of a register (variable offset or scalar value) as
733  * known to have the value @imm.
734  */
735 static void __mark_reg_known(struct bpf_reg_state *reg, u64 imm)
736 {
737         /* Clear id, off, and union(map_ptr, range) */
738         memset(((u8 *)reg) + sizeof(reg->type), 0,
739                offsetof(struct bpf_reg_state, var_off) - sizeof(reg->type));
740         reg->var_off = tnum_const(imm);
741         reg->smin_value = (s64)imm;
742         reg->smax_value = (s64)imm;
743         reg->umin_value = imm;
744         reg->umax_value = imm;
745 }
746
747 /* Mark the 'variable offset' part of a register as zero.  This should be
748  * used only on registers holding a pointer type.
749  */
750 static void __mark_reg_known_zero(struct bpf_reg_state *reg)
751 {
752         __mark_reg_known(reg, 0);
753 }
754
755 static void __mark_reg_const_zero(struct bpf_reg_state *reg)
756 {
757         __mark_reg_known(reg, 0);
758         reg->type = SCALAR_VALUE;
759 }
760
761 static void mark_reg_known_zero(struct bpf_verifier_env *env,
762                                 struct bpf_reg_state *regs, u32 regno)
763 {
764         if (WARN_ON(regno >= MAX_BPF_REG)) {
765                 verbose(env, "mark_reg_known_zero(regs, %u)\n", regno);
766                 /* Something bad happened, let's kill all regs */
767                 for (regno = 0; regno < MAX_BPF_REG; regno++)
768                         __mark_reg_not_init(regs + regno);
769                 return;
770         }
771         __mark_reg_known_zero(regs + regno);
772 }
773
774 static bool reg_is_pkt_pointer(const struct bpf_reg_state *reg)
775 {
776         return type_is_pkt_pointer(reg->type);
777 }
778
779 static bool reg_is_pkt_pointer_any(const struct bpf_reg_state *reg)
780 {
781         return reg_is_pkt_pointer(reg) ||
782                reg->type == PTR_TO_PACKET_END;
783 }
784
785 /* Unmodified PTR_TO_PACKET[_META,_END] register from ctx access. */
786 static bool reg_is_init_pkt_pointer(const struct bpf_reg_state *reg,
787                                     enum bpf_reg_type which)
788 {
789         /* The register can already have a range from prior markings.
790          * This is fine as long as it hasn't been advanced from its
791          * origin.
792          */
793         return reg->type == which &&
794                reg->id == 0 &&
795                reg->off == 0 &&
796                tnum_equals_const(reg->var_off, 0);
797 }
798
799 /* Attempts to improve min/max values based on var_off information */
800 static void __update_reg_bounds(struct bpf_reg_state *reg)
801 {
802         /* min signed is max(sign bit) | min(other bits) */
803         reg->smin_value = max_t(s64, reg->smin_value,
804                                 reg->var_off.value | (reg->var_off.mask & S64_MIN));
805         /* max signed is min(sign bit) | max(other bits) */
806         reg->smax_value = min_t(s64, reg->smax_value,
807                                 reg->var_off.value | (reg->var_off.mask & S64_MAX));
808         reg->umin_value = max(reg->umin_value, reg->var_off.value);
809         reg->umax_value = min(reg->umax_value,
810                               reg->var_off.value | reg->var_off.mask);
811 }
812
813 /* Uses signed min/max values to inform unsigned, and vice-versa */
814 static void __reg_deduce_bounds(struct bpf_reg_state *reg)
815 {
816         /* Learn sign from signed bounds.
817          * If we cannot cross the sign boundary, then signed and unsigned bounds
818          * are the same, so combine.  This works even in the negative case, e.g.
819          * -3 s<= x s<= -1 implies 0xf...fd u<= x u<= 0xf...ff.
820          */
821         if (reg->smin_value >= 0 || reg->smax_value < 0) {
822                 reg->smin_value = reg->umin_value = max_t(u64, reg->smin_value,
823                                                           reg->umin_value);
824                 reg->smax_value = reg->umax_value = min_t(u64, reg->smax_value,
825                                                           reg->umax_value);
826                 return;
827         }
828         /* Learn sign from unsigned bounds.  Signed bounds cross the sign
829          * boundary, so we must be careful.
830          */
831         if ((s64)reg->umax_value >= 0) {
832                 /* Positive.  We can't learn anything from the smin, but smax
833                  * is positive, hence safe.
834                  */
835                 reg->smin_value = reg->umin_value;
836                 reg->smax_value = reg->umax_value = min_t(u64, reg->smax_value,
837                                                           reg->umax_value);
838         } else if ((s64)reg->umin_value < 0) {
839                 /* Negative.  We can't learn anything from the smax, but smin
840                  * is negative, hence safe.
841                  */
842                 reg->smin_value = reg->umin_value = max_t(u64, reg->smin_value,
843                                                           reg->umin_value);
844                 reg->smax_value = reg->umax_value;
845         }
846 }
847
848 /* Attempts to improve var_off based on unsigned min/max information */
849 static void __reg_bound_offset(struct bpf_reg_state *reg)
850 {
851         reg->var_off = tnum_intersect(reg->var_off,
852                                       tnum_range(reg->umin_value,
853                                                  reg->umax_value));
854 }
855
856 /* Reset the min/max bounds of a register */
857 static void __mark_reg_unbounded(struct bpf_reg_state *reg)
858 {
859         reg->smin_value = S64_MIN;
860         reg->smax_value = S64_MAX;
861         reg->umin_value = 0;
862         reg->umax_value = U64_MAX;
863 }
864
865 /* Mark a register as having a completely unknown (scalar) value. */
866 static void __mark_reg_unknown(struct bpf_reg_state *reg)
867 {
868         /*
869          * Clear type, id, off, and union(map_ptr, range) and
870          * padding between 'type' and union
871          */
872         memset(reg, 0, offsetof(struct bpf_reg_state, var_off));
873         reg->type = SCALAR_VALUE;
874         reg->var_off = tnum_unknown;
875         reg->frameno = 0;
876         __mark_reg_unbounded(reg);
877 }
878
879 static void mark_reg_unknown(struct bpf_verifier_env *env,
880                              struct bpf_reg_state *regs, u32 regno)
881 {
882         if (WARN_ON(regno >= MAX_BPF_REG)) {
883                 verbose(env, "mark_reg_unknown(regs, %u)\n", regno);
884                 /* Something bad happened, let's kill all regs except FP */
885                 for (regno = 0; regno < BPF_REG_FP; regno++)
886                         __mark_reg_not_init(regs + regno);
887                 return;
888         }
889         __mark_reg_unknown(regs + regno);
890 }
891
892 static void __mark_reg_not_init(struct bpf_reg_state *reg)
893 {
894         __mark_reg_unknown(reg);
895         reg->type = NOT_INIT;
896 }
897
898 static void mark_reg_not_init(struct bpf_verifier_env *env,
899                               struct bpf_reg_state *regs, u32 regno)
900 {
901         if (WARN_ON(regno >= MAX_BPF_REG)) {
902                 verbose(env, "mark_reg_not_init(regs, %u)\n", regno);
903                 /* Something bad happened, let's kill all regs except FP */
904                 for (regno = 0; regno < BPF_REG_FP; regno++)
905                         __mark_reg_not_init(regs + regno);
906                 return;
907         }
908         __mark_reg_not_init(regs + regno);
909 }
910
911 static void init_reg_state(struct bpf_verifier_env *env,
912                            struct bpf_func_state *state)
913 {
914         struct bpf_reg_state *regs = state->regs;
915         int i;
916
917         for (i = 0; i < MAX_BPF_REG; i++) {
918                 mark_reg_not_init(env, regs, i);
919                 regs[i].live = REG_LIVE_NONE;
920                 regs[i].parent = NULL;
921         }
922
923         /* frame pointer */
924         regs[BPF_REG_FP].type = PTR_TO_STACK;
925         mark_reg_known_zero(env, regs, BPF_REG_FP);
926         regs[BPF_REG_FP].frameno = state->frameno;
927
928         /* 1st arg to a function */
929         regs[BPF_REG_1].type = PTR_TO_CTX;
930         mark_reg_known_zero(env, regs, BPF_REG_1);
931 }
932
933 #define BPF_MAIN_FUNC (-1)
934 static void init_func_state(struct bpf_verifier_env *env,
935                             struct bpf_func_state *state,
936                             int callsite, int frameno, int subprogno)
937 {
938         state->callsite = callsite;
939         state->frameno = frameno;
940         state->subprogno = subprogno;
941         init_reg_state(env, state);
942 }
943
944 enum reg_arg_type {
945         SRC_OP,         /* register is used as source operand */
946         DST_OP,         /* register is used as destination operand */
947         DST_OP_NO_MARK  /* same as above, check only, don't mark */
948 };
949
950 static int cmp_subprogs(const void *a, const void *b)
951 {
952         return ((struct bpf_subprog_info *)a)->start -
953                ((struct bpf_subprog_info *)b)->start;
954 }
955
956 static int find_subprog(struct bpf_verifier_env *env, int off)
957 {
958         struct bpf_subprog_info *p;
959
960         p = bsearch(&off, env->subprog_info, env->subprog_cnt,
961                     sizeof(env->subprog_info[0]), cmp_subprogs);
962         if (!p)
963                 return -ENOENT;
964         return p - env->subprog_info;
965
966 }
967
968 static int add_subprog(struct bpf_verifier_env *env, int off)
969 {
970         int insn_cnt = env->prog->len;
971         int ret;
972
973         if (off >= insn_cnt || off < 0) {
974                 verbose(env, "call to invalid destination\n");
975                 return -EINVAL;
976         }
977         ret = find_subprog(env, off);
978         if (ret >= 0)
979                 return 0;
980         if (env->subprog_cnt >= BPF_MAX_SUBPROGS) {
981                 verbose(env, "too many subprograms\n");
982                 return -E2BIG;
983         }
984         env->subprog_info[env->subprog_cnt++].start = off;
985         sort(env->subprog_info, env->subprog_cnt,
986              sizeof(env->subprog_info[0]), cmp_subprogs, NULL);
987         return 0;
988 }
989
990 static int check_subprogs(struct bpf_verifier_env *env)
991 {
992         int i, ret, subprog_start, subprog_end, off, cur_subprog = 0;
993         struct bpf_subprog_info *subprog = env->subprog_info;
994         struct bpf_insn *insn = env->prog->insnsi;
995         int insn_cnt = env->prog->len;
996
997         /* Add entry function. */
998         ret = add_subprog(env, 0);
999         if (ret < 0)
1000                 return ret;
1001
1002         /* determine subprog starts. The end is one before the next starts */
1003         for (i = 0; i < insn_cnt; i++) {
1004                 if (insn[i].code != (BPF_JMP | BPF_CALL))
1005                         continue;
1006                 if (insn[i].src_reg != BPF_PSEUDO_CALL)
1007                         continue;
1008                 if (!env->allow_ptr_leaks) {
1009                         verbose(env, "function calls to other bpf functions are allowed for root only\n");
1010                         return -EPERM;
1011                 }
1012                 ret = add_subprog(env, i + insn[i].imm + 1);
1013                 if (ret < 0)
1014                         return ret;
1015         }
1016
1017         /* Add a fake 'exit' subprog which could simplify subprog iteration
1018          * logic. 'subprog_cnt' should not be increased.
1019          */
1020         subprog[env->subprog_cnt].start = insn_cnt;
1021
1022         if (env->log.level > 1)
1023                 for (i = 0; i < env->subprog_cnt; i++)
1024                         verbose(env, "func#%d @%d\n", i, subprog[i].start);
1025
1026         /* now check that all jumps are within the same subprog */
1027         subprog_start = subprog[cur_subprog].start;
1028         subprog_end = subprog[cur_subprog + 1].start;
1029         for (i = 0; i < insn_cnt; i++) {
1030                 u8 code = insn[i].code;
1031
1032                 if (BPF_CLASS(code) != BPF_JMP)
1033                         goto next;
1034                 if (BPF_OP(code) == BPF_EXIT || BPF_OP(code) == BPF_CALL)
1035                         goto next;
1036                 off = i + insn[i].off + 1;
1037                 if (off < subprog_start || off >= subprog_end) {
1038                         verbose(env, "jump out of range from insn %d to %d\n", i, off);
1039                         return -EINVAL;
1040                 }
1041 next:
1042                 if (i == subprog_end - 1) {
1043                         /* to avoid fall-through from one subprog into another
1044                          * the last insn of the subprog should be either exit
1045                          * or unconditional jump back
1046                          */
1047                         if (code != (BPF_JMP | BPF_EXIT) &&
1048                             code != (BPF_JMP | BPF_JA)) {
1049                                 verbose(env, "last insn is not an exit or jmp\n");
1050                                 return -EINVAL;
1051                         }
1052                         subprog_start = subprog_end;
1053                         cur_subprog++;
1054                         if (cur_subprog < env->subprog_cnt)
1055                                 subprog_end = subprog[cur_subprog + 1].start;
1056                 }
1057         }
1058         return 0;
1059 }
1060
1061 /* Parentage chain of this register (or stack slot) should take care of all
1062  * issues like callee-saved registers, stack slot allocation time, etc.
1063  */
1064 static int mark_reg_read(struct bpf_verifier_env *env,
1065                          const struct bpf_reg_state *state,
1066                          struct bpf_reg_state *parent)
1067 {
1068         bool writes = parent == state->parent; /* Observe write marks */
1069
1070         while (parent) {
1071                 /* if read wasn't screened by an earlier write ... */
1072                 if (writes && state->live & REG_LIVE_WRITTEN)
1073                         break;
1074                 /* ... then we depend on parent's value */
1075                 parent->live |= REG_LIVE_READ;
1076                 state = parent;
1077                 parent = state->parent;
1078                 writes = true;
1079         }
1080         return 0;
1081 }
1082
1083 static int check_reg_arg(struct bpf_verifier_env *env, u32 regno,
1084                          enum reg_arg_type t)
1085 {
1086         struct bpf_verifier_state *vstate = env->cur_state;
1087         struct bpf_func_state *state = vstate->frame[vstate->curframe];
1088         struct bpf_reg_state *regs = state->regs;
1089
1090         if (regno >= MAX_BPF_REG) {
1091                 verbose(env, "R%d is invalid\n", regno);
1092                 return -EINVAL;
1093         }
1094
1095         if (t == SRC_OP) {
1096                 /* check whether register used as source operand can be read */
1097                 if (regs[regno].type == NOT_INIT) {
1098                         verbose(env, "R%d !read_ok\n", regno);
1099                         return -EACCES;
1100                 }
1101                 /* We don't need to worry about FP liveness because it's read-only */
1102                 if (regno != BPF_REG_FP)
1103                         return mark_reg_read(env, &regs[regno],
1104                                              regs[regno].parent);
1105         } else {
1106                 /* check whether register used as dest operand can be written to */
1107                 if (regno == BPF_REG_FP) {
1108                         verbose(env, "frame pointer is read only\n");
1109                         return -EACCES;
1110                 }
1111                 regs[regno].live |= REG_LIVE_WRITTEN;
1112                 if (t == DST_OP)
1113                         mark_reg_unknown(env, regs, regno);
1114         }
1115         return 0;
1116 }
1117
1118 static bool is_spillable_regtype(enum bpf_reg_type type)
1119 {
1120         switch (type) {
1121         case PTR_TO_MAP_VALUE:
1122         case PTR_TO_MAP_VALUE_OR_NULL:
1123         case PTR_TO_STACK:
1124         case PTR_TO_CTX:
1125         case PTR_TO_PACKET:
1126         case PTR_TO_PACKET_META:
1127         case PTR_TO_PACKET_END:
1128         case PTR_TO_FLOW_KEYS:
1129         case CONST_PTR_TO_MAP:
1130         case PTR_TO_SOCKET:
1131         case PTR_TO_SOCKET_OR_NULL:
1132                 return true;
1133         default:
1134                 return false;
1135         }
1136 }
1137
1138 /* Does this register contain a constant zero? */
1139 static bool register_is_null(struct bpf_reg_state *reg)
1140 {
1141         return reg->type == SCALAR_VALUE && tnum_equals_const(reg->var_off, 0);
1142 }
1143
1144 /* check_stack_read/write functions track spill/fill of registers,
1145  * stack boundary and alignment are checked in check_mem_access()
1146  */
1147 static int check_stack_write(struct bpf_verifier_env *env,
1148                              struct bpf_func_state *state, /* func where register points to */
1149                              int off, int size, int value_regno, int insn_idx)
1150 {
1151         struct bpf_func_state *cur; /* state of the current function */
1152         int i, slot = -off - 1, spi = slot / BPF_REG_SIZE, err;
1153         enum bpf_reg_type type;
1154
1155         err = realloc_func_state(state, round_up(slot + 1, BPF_REG_SIZE),
1156                                  state->acquired_refs, true);
1157         if (err)
1158                 return err;
1159         /* caller checked that off % size == 0 and -MAX_BPF_STACK <= off < 0,
1160          * so it's aligned access and [off, off + size) are within stack limits
1161          */
1162         if (!env->allow_ptr_leaks &&
1163             state->stack[spi].slot_type[0] == STACK_SPILL &&
1164             size != BPF_REG_SIZE) {
1165                 verbose(env, "attempt to corrupt spilled pointer on stack\n");
1166                 return -EACCES;
1167         }
1168
1169         cur = env->cur_state->frame[env->cur_state->curframe];
1170         if (value_regno >= 0 &&
1171             is_spillable_regtype((type = cur->regs[value_regno].type))) {
1172
1173                 /* register containing pointer is being spilled into stack */
1174                 if (size != BPF_REG_SIZE) {
1175                         verbose(env, "invalid size of register spill\n");
1176                         return -EACCES;
1177                 }
1178
1179                 if (state != cur && type == PTR_TO_STACK) {
1180                         verbose(env, "cannot spill pointers to stack into stack frame of the caller\n");
1181                         return -EINVAL;
1182                 }
1183
1184                 /* save register state */
1185                 state->stack[spi].spilled_ptr = cur->regs[value_regno];
1186                 state->stack[spi].spilled_ptr.live |= REG_LIVE_WRITTEN;
1187
1188                 for (i = 0; i < BPF_REG_SIZE; i++) {
1189                         if (state->stack[spi].slot_type[i] == STACK_MISC &&
1190                             !env->allow_ptr_leaks) {
1191                                 int *poff = &env->insn_aux_data[insn_idx].sanitize_stack_off;
1192                                 int soff = (-spi - 1) * BPF_REG_SIZE;
1193
1194                                 /* detected reuse of integer stack slot with a pointer
1195                                  * which means either llvm is reusing stack slot or
1196                                  * an attacker is trying to exploit CVE-2018-3639
1197                                  * (speculative store bypass)
1198                                  * Have to sanitize that slot with preemptive
1199                                  * store of zero.
1200                                  */
1201                                 if (*poff && *poff != soff) {
1202                                         /* disallow programs where single insn stores
1203                                          * into two different stack slots, since verifier
1204                                          * cannot sanitize them
1205                                          */
1206                                         verbose(env,
1207                                                 "insn %d cannot access two stack slots fp%d and fp%d",
1208                                                 insn_idx, *poff, soff);
1209                                         return -EINVAL;
1210                                 }
1211                                 *poff = soff;
1212                         }
1213                         state->stack[spi].slot_type[i] = STACK_SPILL;
1214                 }
1215         } else {
1216                 u8 type = STACK_MISC;
1217
1218                 /* regular write of data into stack destroys any spilled ptr */
1219                 state->stack[spi].spilled_ptr.type = NOT_INIT;
1220
1221                 /* only mark the slot as written if all 8 bytes were written
1222                  * otherwise read propagation may incorrectly stop too soon
1223                  * when stack slots are partially written.
1224                  * This heuristic means that read propagation will be
1225                  * conservative, since it will add reg_live_read marks
1226                  * to stack slots all the way to first state when programs
1227                  * writes+reads less than 8 bytes
1228                  */
1229                 if (size == BPF_REG_SIZE)
1230                         state->stack[spi].spilled_ptr.live |= REG_LIVE_WRITTEN;
1231
1232                 /* when we zero initialize stack slots mark them as such */
1233                 if (value_regno >= 0 &&
1234                     register_is_null(&cur->regs[value_regno]))
1235                         type = STACK_ZERO;
1236
1237                 for (i = 0; i < size; i++)
1238                         state->stack[spi].slot_type[(slot - i) % BPF_REG_SIZE] =
1239                                 type;
1240         }
1241         return 0;
1242 }
1243
1244 static int check_stack_read(struct bpf_verifier_env *env,
1245                             struct bpf_func_state *reg_state /* func where register points to */,
1246                             int off, int size, int value_regno)
1247 {
1248         struct bpf_verifier_state *vstate = env->cur_state;
1249         struct bpf_func_state *state = vstate->frame[vstate->curframe];
1250         int i, slot = -off - 1, spi = slot / BPF_REG_SIZE;
1251         u8 *stype;
1252
1253         if (reg_state->allocated_stack <= slot) {
1254                 verbose(env, "invalid read from stack off %d+0 size %d\n",
1255                         off, size);
1256                 return -EACCES;
1257         }
1258         stype = reg_state->stack[spi].slot_type;
1259
1260         if (stype[0] == STACK_SPILL) {
1261                 if (size != BPF_REG_SIZE) {
1262                         verbose(env, "invalid size of register spill\n");
1263                         return -EACCES;
1264                 }
1265                 for (i = 1; i < BPF_REG_SIZE; i++) {
1266                         if (stype[(slot - i) % BPF_REG_SIZE] != STACK_SPILL) {
1267                                 verbose(env, "corrupted spill memory\n");
1268                                 return -EACCES;
1269                         }
1270                 }
1271
1272                 if (value_regno >= 0) {
1273                         /* restore register state from stack */
1274                         state->regs[value_regno] = reg_state->stack[spi].spilled_ptr;
1275                         /* mark reg as written since spilled pointer state likely
1276                          * has its liveness marks cleared by is_state_visited()
1277                          * which resets stack/reg liveness for state transitions
1278                          */
1279                         state->regs[value_regno].live |= REG_LIVE_WRITTEN;
1280                 }
1281                 mark_reg_read(env, &reg_state->stack[spi].spilled_ptr,
1282                               reg_state->stack[spi].spilled_ptr.parent);
1283                 return 0;
1284         } else {
1285                 int zeros = 0;
1286
1287                 for (i = 0; i < size; i++) {
1288                         if (stype[(slot - i) % BPF_REG_SIZE] == STACK_MISC)
1289                                 continue;
1290                         if (stype[(slot - i) % BPF_REG_SIZE] == STACK_ZERO) {
1291                                 zeros++;
1292                                 continue;
1293                         }
1294                         verbose(env, "invalid read from stack off %d+%d size %d\n",
1295                                 off, i, size);
1296                         return -EACCES;
1297                 }
1298                 mark_reg_read(env, &reg_state->stack[spi].spilled_ptr,
1299                               reg_state->stack[spi].spilled_ptr.parent);
1300                 if (value_regno >= 0) {
1301                         if (zeros == size) {
1302                                 /* any size read into register is zero extended,
1303                                  * so the whole register == const_zero
1304                                  */
1305                                 __mark_reg_const_zero(&state->regs[value_regno]);
1306                         } else {
1307                                 /* have read misc data from the stack */
1308                                 mark_reg_unknown(env, state->regs, value_regno);
1309                         }
1310                         state->regs[value_regno].live |= REG_LIVE_WRITTEN;
1311                 }
1312                 return 0;
1313         }
1314 }
1315
1316 /* check read/write into map element returned by bpf_map_lookup_elem() */
1317 static int __check_map_access(struct bpf_verifier_env *env, u32 regno, int off,
1318                               int size, bool zero_size_allowed)
1319 {
1320         struct bpf_reg_state *regs = cur_regs(env);
1321         struct bpf_map *map = regs[regno].map_ptr;
1322
1323         if (off < 0 || size < 0 || (size == 0 && !zero_size_allowed) ||
1324             off + size > map->value_size) {
1325                 verbose(env, "invalid access to map value, value_size=%d off=%d size=%d\n",
1326                         map->value_size, off, size);
1327                 return -EACCES;
1328         }
1329         return 0;
1330 }
1331
1332 /* check read/write into a map element with possible variable offset */
1333 static int check_map_access(struct bpf_verifier_env *env, u32 regno,
1334                             int off, int size, bool zero_size_allowed)
1335 {
1336         struct bpf_verifier_state *vstate = env->cur_state;
1337         struct bpf_func_state *state = vstate->frame[vstate->curframe];
1338         struct bpf_reg_state *reg = &state->regs[regno];
1339         int err;
1340
1341         /* We may have adjusted the register to this map value, so we
1342          * need to try adding each of min_value and max_value to off
1343          * to make sure our theoretical access will be safe.
1344          */
1345         if (env->log.level)
1346                 print_verifier_state(env, state);
1347         /* The minimum value is only important with signed
1348          * comparisons where we can't assume the floor of a
1349          * value is 0.  If we are using signed variables for our
1350          * index'es we need to make sure that whatever we use
1351          * will have a set floor within our range.
1352          */
1353         if (reg->smin_value < 0) {
1354                 verbose(env, "R%d min value is negative, either use unsigned index or do a if (index >=0) check.\n",
1355                         regno);
1356                 return -EACCES;
1357         }
1358         err = __check_map_access(env, regno, reg->smin_value + off, size,
1359                                  zero_size_allowed);
1360         if (err) {
1361                 verbose(env, "R%d min value is outside of the array range\n",
1362                         regno);
1363                 return err;
1364         }
1365
1366         /* If we haven't set a max value then we need to bail since we can't be
1367          * sure we won't do bad things.
1368          * If reg->umax_value + off could overflow, treat that as unbounded too.
1369          */
1370         if (reg->umax_value >= BPF_MAX_VAR_OFF) {
1371                 verbose(env, "R%d unbounded memory access, make sure to bounds check any array access into a map\n",
1372                         regno);
1373                 return -EACCES;
1374         }
1375         err = __check_map_access(env, regno, reg->umax_value + off, size,
1376                                  zero_size_allowed);
1377         if (err)
1378                 verbose(env, "R%d max value is outside of the array range\n",
1379                         regno);
1380         return err;
1381 }
1382
1383 #define MAX_PACKET_OFF 0xffff
1384
1385 static bool may_access_direct_pkt_data(struct bpf_verifier_env *env,
1386                                        const struct bpf_call_arg_meta *meta,
1387                                        enum bpf_access_type t)
1388 {
1389         switch (env->prog->type) {
1390         /* Program types only with direct read access go here! */
1391         case BPF_PROG_TYPE_LWT_IN:
1392         case BPF_PROG_TYPE_LWT_OUT:
1393         case BPF_PROG_TYPE_LWT_SEG6LOCAL:
1394         case BPF_PROG_TYPE_SK_REUSEPORT:
1395         case BPF_PROG_TYPE_FLOW_DISSECTOR:
1396         case BPF_PROG_TYPE_CGROUP_SKB:
1397                 if (t == BPF_WRITE)
1398                         return false;
1399                 /* fallthrough */
1400
1401         /* Program types with direct read + write access go here! */
1402         case BPF_PROG_TYPE_SCHED_CLS:
1403         case BPF_PROG_TYPE_SCHED_ACT:
1404         case BPF_PROG_TYPE_XDP:
1405         case BPF_PROG_TYPE_LWT_XMIT:
1406         case BPF_PROG_TYPE_SK_SKB:
1407         case BPF_PROG_TYPE_SK_MSG:
1408                 if (meta)
1409                         return meta->pkt_access;
1410
1411                 env->seen_direct_write = true;
1412                 return true;
1413         default:
1414                 return false;
1415         }
1416 }
1417
1418 static int __check_packet_access(struct bpf_verifier_env *env, u32 regno,
1419                                  int off, int size, bool zero_size_allowed)
1420 {
1421         struct bpf_reg_state *regs = cur_regs(env);
1422         struct bpf_reg_state *reg = &regs[regno];
1423
1424         if (off < 0 || size < 0 || (size == 0 && !zero_size_allowed) ||
1425             (u64)off + size > reg->range) {
1426                 verbose(env, "invalid access to packet, off=%d size=%d, R%d(id=%d,off=%d,r=%d)\n",
1427                         off, size, regno, reg->id, reg->off, reg->range);
1428                 return -EACCES;
1429         }
1430         return 0;
1431 }
1432
1433 static int check_packet_access(struct bpf_verifier_env *env, u32 regno, int off,
1434                                int size, bool zero_size_allowed)
1435 {
1436         struct bpf_reg_state *regs = cur_regs(env);
1437         struct bpf_reg_state *reg = &regs[regno];
1438         int err;
1439
1440         /* We may have added a variable offset to the packet pointer; but any
1441          * reg->range we have comes after that.  We are only checking the fixed
1442          * offset.
1443          */
1444
1445         /* We don't allow negative numbers, because we aren't tracking enough
1446          * detail to prove they're safe.
1447          */
1448         if (reg->smin_value < 0) {
1449                 verbose(env, "R%d min value is negative, either use unsigned index or do a if (index >=0) check.\n",
1450                         regno);
1451                 return -EACCES;
1452         }
1453         err = __check_packet_access(env, regno, off, size, zero_size_allowed);
1454         if (err) {
1455                 verbose(env, "R%d offset is outside of the packet\n", regno);
1456                 return err;
1457         }
1458         return err;
1459 }
1460
1461 /* check access to 'struct bpf_context' fields.  Supports fixed offsets only */
1462 static int check_ctx_access(struct bpf_verifier_env *env, int insn_idx, int off, int size,
1463                             enum bpf_access_type t, enum bpf_reg_type *reg_type)
1464 {
1465         struct bpf_insn_access_aux info = {
1466                 .reg_type = *reg_type,
1467         };
1468
1469         if (env->ops->is_valid_access &&
1470             env->ops->is_valid_access(off, size, t, env->prog, &info)) {
1471                 /* A non zero info.ctx_field_size indicates that this field is a
1472                  * candidate for later verifier transformation to load the whole
1473                  * field and then apply a mask when accessed with a narrower
1474                  * access than actual ctx access size. A zero info.ctx_field_size
1475                  * will only allow for whole field access and rejects any other
1476                  * type of narrower access.
1477                  */
1478                 *reg_type = info.reg_type;
1479
1480                 env->insn_aux_data[insn_idx].ctx_field_size = info.ctx_field_size;
1481                 /* remember the offset of last byte accessed in ctx */
1482                 if (env->prog->aux->max_ctx_offset < off + size)
1483                         env->prog->aux->max_ctx_offset = off + size;
1484                 return 0;
1485         }
1486
1487         verbose(env, "invalid bpf_context access off=%d size=%d\n", off, size);
1488         return -EACCES;
1489 }
1490
1491 static int check_flow_keys_access(struct bpf_verifier_env *env, int off,
1492                                   int size)
1493 {
1494         if (size < 0 || off < 0 ||
1495             (u64)off + size > sizeof(struct bpf_flow_keys)) {
1496                 verbose(env, "invalid access to flow keys off=%d size=%d\n",
1497                         off, size);
1498                 return -EACCES;
1499         }
1500         return 0;
1501 }
1502
1503 static int check_sock_access(struct bpf_verifier_env *env, u32 regno, int off,
1504                              int size, enum bpf_access_type t)
1505 {
1506         struct bpf_reg_state *regs = cur_regs(env);
1507         struct bpf_reg_state *reg = &regs[regno];
1508         struct bpf_insn_access_aux info;
1509
1510         if (reg->smin_value < 0) {
1511                 verbose(env, "R%d min value is negative, either use unsigned index or do a if (index >=0) check.\n",
1512                         regno);
1513                 return -EACCES;
1514         }
1515
1516         if (!bpf_sock_is_valid_access(off, size, t, &info)) {
1517                 verbose(env, "invalid bpf_sock access off=%d size=%d\n",
1518                         off, size);
1519                 return -EACCES;
1520         }
1521
1522         return 0;
1523 }
1524
1525 static bool __is_pointer_value(bool allow_ptr_leaks,
1526                                const struct bpf_reg_state *reg)
1527 {
1528         if (allow_ptr_leaks)
1529                 return false;
1530
1531         return reg->type != SCALAR_VALUE;
1532 }
1533
1534 static struct bpf_reg_state *reg_state(struct bpf_verifier_env *env, int regno)
1535 {
1536         return cur_regs(env) + regno;
1537 }
1538
1539 static bool is_pointer_value(struct bpf_verifier_env *env, int regno)
1540 {
1541         return __is_pointer_value(env->allow_ptr_leaks, reg_state(env, regno));
1542 }
1543
1544 static bool is_ctx_reg(struct bpf_verifier_env *env, int regno)
1545 {
1546         const struct bpf_reg_state *reg = reg_state(env, regno);
1547
1548         return reg->type == PTR_TO_CTX ||
1549                reg->type == PTR_TO_SOCKET;
1550 }
1551
1552 static bool is_pkt_reg(struct bpf_verifier_env *env, int regno)
1553 {
1554         const struct bpf_reg_state *reg = reg_state(env, regno);
1555
1556         return type_is_pkt_pointer(reg->type);
1557 }
1558
1559 static bool is_flow_key_reg(struct bpf_verifier_env *env, int regno)
1560 {
1561         const struct bpf_reg_state *reg = reg_state(env, regno);
1562
1563         /* Separate to is_ctx_reg() since we still want to allow BPF_ST here. */
1564         return reg->type == PTR_TO_FLOW_KEYS;
1565 }
1566
1567 static int check_pkt_ptr_alignment(struct bpf_verifier_env *env,
1568                                    const struct bpf_reg_state *reg,
1569                                    int off, int size, bool strict)
1570 {
1571         struct tnum reg_off;
1572         int ip_align;
1573
1574         /* Byte size accesses are always allowed. */
1575         if (!strict || size == 1)
1576                 return 0;
1577
1578         /* For platforms that do not have a Kconfig enabling
1579          * CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS the value of
1580          * NET_IP_ALIGN is universally set to '2'.  And on platforms
1581          * that do set CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS, we get
1582          * to this code only in strict mode where we want to emulate
1583          * the NET_IP_ALIGN==2 checking.  Therefore use an
1584          * unconditional IP align value of '2'.
1585          */
1586         ip_align = 2;
1587
1588         reg_off = tnum_add(reg->var_off, tnum_const(ip_align + reg->off + off));
1589         if (!tnum_is_aligned(reg_off, size)) {
1590                 char tn_buf[48];
1591
1592                 tnum_strn(tn_buf, sizeof(tn_buf), reg->var_off);
1593                 verbose(env,
1594                         "misaligned packet access off %d+%s+%d+%d size %d\n",
1595                         ip_align, tn_buf, reg->off, off, size);
1596                 return -EACCES;
1597         }
1598
1599         return 0;
1600 }
1601
1602 static int check_generic_ptr_alignment(struct bpf_verifier_env *env,
1603                                        const struct bpf_reg_state *reg,
1604                                        const char *pointer_desc,
1605                                        int off, int size, bool strict)
1606 {
1607         struct tnum reg_off;
1608
1609         /* Byte size accesses are always allowed. */
1610         if (!strict || size == 1)
1611                 return 0;
1612
1613         reg_off = tnum_add(reg->var_off, tnum_const(reg->off + off));
1614         if (!tnum_is_aligned(reg_off, size)) {
1615                 char tn_buf[48];
1616
1617                 tnum_strn(tn_buf, sizeof(tn_buf), reg->var_off);
1618                 verbose(env, "misaligned %saccess off %s+%d+%d size %d\n",
1619                         pointer_desc, tn_buf, reg->off, off, size);
1620                 return -EACCES;
1621         }
1622
1623         return 0;
1624 }
1625
1626 static int check_ptr_alignment(struct bpf_verifier_env *env,
1627                                const struct bpf_reg_state *reg, int off,
1628                                int size, bool strict_alignment_once)
1629 {
1630         bool strict = env->strict_alignment || strict_alignment_once;
1631         const char *pointer_desc = "";
1632
1633         switch (reg->type) {
1634         case PTR_TO_PACKET:
1635         case PTR_TO_PACKET_META:
1636                 /* Special case, because of NET_IP_ALIGN. Given metadata sits
1637                  * right in front, treat it the very same way.
1638                  */
1639                 return check_pkt_ptr_alignment(env, reg, off, size, strict);
1640         case PTR_TO_FLOW_KEYS:
1641                 pointer_desc = "flow keys ";
1642                 break;
1643         case PTR_TO_MAP_VALUE:
1644                 pointer_desc = "value ";
1645                 break;
1646         case PTR_TO_CTX:
1647                 pointer_desc = "context ";
1648                 break;
1649         case PTR_TO_STACK:
1650                 pointer_desc = "stack ";
1651                 /* The stack spill tracking logic in check_stack_write()
1652                  * and check_stack_read() relies on stack accesses being
1653                  * aligned.
1654                  */
1655                 strict = true;
1656                 break;
1657         case PTR_TO_SOCKET:
1658                 pointer_desc = "sock ";
1659                 break;
1660         default:
1661                 break;
1662         }
1663         return check_generic_ptr_alignment(env, reg, pointer_desc, off, size,
1664                                            strict);
1665 }
1666
1667 static int update_stack_depth(struct bpf_verifier_env *env,
1668                               const struct bpf_func_state *func,
1669                               int off)
1670 {
1671         u16 stack = env->subprog_info[func->subprogno].stack_depth;
1672
1673         if (stack >= -off)
1674                 return 0;
1675
1676         /* update known max for given subprogram */
1677         env->subprog_info[func->subprogno].stack_depth = -off;
1678         return 0;
1679 }
1680
1681 /* starting from main bpf function walk all instructions of the function
1682  * and recursively walk all callees that given function can call.
1683  * Ignore jump and exit insns.
1684  * Since recursion is prevented by check_cfg() this algorithm
1685  * only needs a local stack of MAX_CALL_FRAMES to remember callsites
1686  */
1687 static int check_max_stack_depth(struct bpf_verifier_env *env)
1688 {
1689         int depth = 0, frame = 0, idx = 0, i = 0, subprog_end;
1690         struct bpf_subprog_info *subprog = env->subprog_info;
1691         struct bpf_insn *insn = env->prog->insnsi;
1692         int ret_insn[MAX_CALL_FRAMES];
1693         int ret_prog[MAX_CALL_FRAMES];
1694
1695 process_func:
1696         /* round up to 32-bytes, since this is granularity
1697          * of interpreter stack size
1698          */
1699         depth += round_up(max_t(u32, subprog[idx].stack_depth, 1), 32);
1700         if (depth > MAX_BPF_STACK) {
1701                 verbose(env, "combined stack size of %d calls is %d. Too large\n",
1702                         frame + 1, depth);
1703                 return -EACCES;
1704         }
1705 continue_func:
1706         subprog_end = subprog[idx + 1].start;
1707         for (; i < subprog_end; i++) {
1708                 if (insn[i].code != (BPF_JMP | BPF_CALL))
1709                         continue;
1710                 if (insn[i].src_reg != BPF_PSEUDO_CALL)
1711                         continue;
1712                 /* remember insn and function to return to */
1713                 ret_insn[frame] = i + 1;
1714                 ret_prog[frame] = idx;
1715
1716                 /* find the callee */
1717                 i = i + insn[i].imm + 1;
1718                 idx = find_subprog(env, i);
1719                 if (idx < 0) {
1720                         WARN_ONCE(1, "verifier bug. No program starts at insn %d\n",
1721                                   i);
1722                         return -EFAULT;
1723                 }
1724                 frame++;
1725                 if (frame >= MAX_CALL_FRAMES) {
1726                         WARN_ONCE(1, "verifier bug. Call stack is too deep\n");
1727                         return -EFAULT;
1728                 }
1729                 goto process_func;
1730         }
1731         /* end of for() loop means the last insn of the 'subprog'
1732          * was reached. Doesn't matter whether it was JA or EXIT
1733          */
1734         if (frame == 0)
1735                 return 0;
1736         depth -= round_up(max_t(u32, subprog[idx].stack_depth, 1), 32);
1737         frame--;
1738         i = ret_insn[frame];
1739         idx = ret_prog[frame];
1740         goto continue_func;
1741 }
1742
1743 #ifndef CONFIG_BPF_JIT_ALWAYS_ON
1744 static int get_callee_stack_depth(struct bpf_verifier_env *env,
1745                                   const struct bpf_insn *insn, int idx)
1746 {
1747         int start = idx + insn->imm + 1, subprog;
1748
1749         subprog = find_subprog(env, start);
1750         if (subprog < 0) {
1751                 WARN_ONCE(1, "verifier bug. No program starts at insn %d\n",
1752                           start);
1753                 return -EFAULT;
1754         }
1755         return env->subprog_info[subprog].stack_depth;
1756 }
1757 #endif
1758
1759 static int check_ctx_reg(struct bpf_verifier_env *env,
1760                          const struct bpf_reg_state *reg, int regno)
1761 {
1762         /* Access to ctx or passing it to a helper is only allowed in
1763          * its original, unmodified form.
1764          */
1765
1766         if (reg->off) {
1767                 verbose(env, "dereference of modified ctx ptr R%d off=%d disallowed\n",
1768                         regno, reg->off);
1769                 return -EACCES;
1770         }
1771
1772         if (!tnum_is_const(reg->var_off) || reg->var_off.value) {
1773                 char tn_buf[48];
1774
1775                 tnum_strn(tn_buf, sizeof(tn_buf), reg->var_off);
1776                 verbose(env, "variable ctx access var_off=%s disallowed\n", tn_buf);
1777                 return -EACCES;
1778         }
1779
1780         return 0;
1781 }
1782
1783 /* truncate register to smaller size (in bytes)
1784  * must be called with size < BPF_REG_SIZE
1785  */
1786 static void coerce_reg_to_size(struct bpf_reg_state *reg, int size)
1787 {
1788         u64 mask;
1789
1790         /* clear high bits in bit representation */
1791         reg->var_off = tnum_cast(reg->var_off, size);
1792
1793         /* fix arithmetic bounds */
1794         mask = ((u64)1 << (size * 8)) - 1;
1795         if ((reg->umin_value & ~mask) == (reg->umax_value & ~mask)) {
1796                 reg->umin_value &= mask;
1797                 reg->umax_value &= mask;
1798         } else {
1799                 reg->umin_value = 0;
1800                 reg->umax_value = mask;
1801         }
1802         reg->smin_value = reg->umin_value;
1803         reg->smax_value = reg->umax_value;
1804 }
1805
1806 /* check whether memory at (regno + off) is accessible for t = (read | write)
1807  * if t==write, value_regno is a register which value is stored into memory
1808  * if t==read, value_regno is a register which will receive the value from memory
1809  * if t==write && value_regno==-1, some unknown value is stored into memory
1810  * if t==read && value_regno==-1, don't care what we read from memory
1811  */
1812 static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regno,
1813                             int off, int bpf_size, enum bpf_access_type t,
1814                             int value_regno, bool strict_alignment_once)
1815 {
1816         struct bpf_reg_state *regs = cur_regs(env);
1817         struct bpf_reg_state *reg = regs + regno;
1818         struct bpf_func_state *state;
1819         int size, err = 0;
1820
1821         size = bpf_size_to_bytes(bpf_size);
1822         if (size < 0)
1823                 return size;
1824
1825         /* alignment checks will add in reg->off themselves */
1826         err = check_ptr_alignment(env, reg, off, size, strict_alignment_once);
1827         if (err)
1828                 return err;
1829
1830         /* for access checks, reg->off is just part of off */
1831         off += reg->off;
1832
1833         if (reg->type == PTR_TO_MAP_VALUE) {
1834                 if (t == BPF_WRITE && value_regno >= 0 &&
1835                     is_pointer_value(env, value_regno)) {
1836                         verbose(env, "R%d leaks addr into map\n", value_regno);
1837                         return -EACCES;
1838                 }
1839
1840                 err = check_map_access(env, regno, off, size, false);
1841                 if (!err && t == BPF_READ && value_regno >= 0)
1842                         mark_reg_unknown(env, regs, value_regno);
1843
1844         } else if (reg->type == PTR_TO_CTX) {
1845                 enum bpf_reg_type reg_type = SCALAR_VALUE;
1846
1847                 if (t == BPF_WRITE && value_regno >= 0 &&
1848                     is_pointer_value(env, value_regno)) {
1849                         verbose(env, "R%d leaks addr into ctx\n", value_regno);
1850                         return -EACCES;
1851                 }
1852
1853                 err = check_ctx_reg(env, reg, regno);
1854                 if (err < 0)
1855                         return err;
1856
1857                 err = check_ctx_access(env, insn_idx, off, size, t, &reg_type);
1858                 if (!err && t == BPF_READ && value_regno >= 0) {
1859                         /* ctx access returns either a scalar, or a
1860                          * PTR_TO_PACKET[_META,_END]. In the latter
1861                          * case, we know the offset is zero.
1862                          */
1863                         if (reg_type == SCALAR_VALUE)
1864                                 mark_reg_unknown(env, regs, value_regno);
1865                         else
1866                                 mark_reg_known_zero(env, regs,
1867                                                     value_regno);
1868                         regs[value_regno].type = reg_type;
1869                 }
1870
1871         } else if (reg->type == PTR_TO_STACK) {
1872                 /* stack accesses must be at a fixed offset, so that we can
1873                  * determine what type of data were returned.
1874                  * See check_stack_read().
1875                  */
1876                 if (!tnum_is_const(reg->var_off)) {
1877                         char tn_buf[48];
1878
1879                         tnum_strn(tn_buf, sizeof(tn_buf), reg->var_off);
1880                         verbose(env, "variable stack access var_off=%s off=%d size=%d",
1881                                 tn_buf, off, size);
1882                         return -EACCES;
1883                 }
1884                 off += reg->var_off.value;
1885                 if (off >= 0 || off < -MAX_BPF_STACK) {
1886                         verbose(env, "invalid stack off=%d size=%d\n", off,
1887                                 size);
1888                         return -EACCES;
1889                 }
1890
1891                 state = func(env, reg);
1892                 err = update_stack_depth(env, state, off);
1893                 if (err)
1894                         return err;
1895
1896                 if (t == BPF_WRITE)
1897                         err = check_stack_write(env, state, off, size,
1898                                                 value_regno, insn_idx);
1899                 else
1900                         err = check_stack_read(env, state, off, size,
1901                                                value_regno);
1902         } else if (reg_is_pkt_pointer(reg)) {
1903                 if (t == BPF_WRITE && !may_access_direct_pkt_data(env, NULL, t)) {
1904                         verbose(env, "cannot write into packet\n");
1905                         return -EACCES;
1906                 }
1907                 if (t == BPF_WRITE && value_regno >= 0 &&
1908                     is_pointer_value(env, value_regno)) {
1909                         verbose(env, "R%d leaks addr into packet\n",
1910                                 value_regno);
1911                         return -EACCES;
1912                 }
1913                 err = check_packet_access(env, regno, off, size, false);
1914                 if (!err && t == BPF_READ && value_regno >= 0)
1915                         mark_reg_unknown(env, regs, value_regno);
1916         } else if (reg->type == PTR_TO_FLOW_KEYS) {
1917                 if (t == BPF_WRITE && value_regno >= 0 &&
1918                     is_pointer_value(env, value_regno)) {
1919                         verbose(env, "R%d leaks addr into flow keys\n",
1920                                 value_regno);
1921                         return -EACCES;
1922                 }
1923
1924                 err = check_flow_keys_access(env, off, size);
1925                 if (!err && t == BPF_READ && value_regno >= 0)
1926                         mark_reg_unknown(env, regs, value_regno);
1927         } else if (reg->type == PTR_TO_SOCKET) {
1928                 if (t == BPF_WRITE) {
1929                         verbose(env, "cannot write into socket\n");
1930                         return -EACCES;
1931                 }
1932                 err = check_sock_access(env, regno, off, size, t);
1933                 if (!err && value_regno >= 0)
1934                         mark_reg_unknown(env, regs, value_regno);
1935         } else {
1936                 verbose(env, "R%d invalid mem access '%s'\n", regno,
1937                         reg_type_str[reg->type]);
1938                 return -EACCES;
1939         }
1940
1941         if (!err && size < BPF_REG_SIZE && value_regno >= 0 && t == BPF_READ &&
1942             regs[value_regno].type == SCALAR_VALUE) {
1943                 /* b/h/w load zero-extends, mark upper bits as known 0 */
1944                 coerce_reg_to_size(&regs[value_regno], size);
1945         }
1946         return err;
1947 }
1948
1949 static int check_xadd(struct bpf_verifier_env *env, int insn_idx, struct bpf_insn *insn)
1950 {
1951         int err;
1952
1953         if ((BPF_SIZE(insn->code) != BPF_W && BPF_SIZE(insn->code) != BPF_DW) ||
1954             insn->imm != 0) {
1955                 verbose(env, "BPF_XADD uses reserved fields\n");
1956                 return -EINVAL;
1957         }
1958
1959         /* check src1 operand */
1960         err = check_reg_arg(env, insn->src_reg, SRC_OP);
1961         if (err)
1962                 return err;
1963
1964         /* check src2 operand */
1965         err = check_reg_arg(env, insn->dst_reg, SRC_OP);
1966         if (err)
1967                 return err;
1968
1969         if (is_pointer_value(env, insn->src_reg)) {
1970                 verbose(env, "R%d leaks addr into mem\n", insn->src_reg);
1971                 return -EACCES;
1972         }
1973
1974         if (is_ctx_reg(env, insn->dst_reg) ||
1975             is_pkt_reg(env, insn->dst_reg) ||
1976             is_flow_key_reg(env, insn->dst_reg)) {
1977                 verbose(env, "BPF_XADD stores into R%d %s is not allowed\n",
1978                         insn->dst_reg,
1979                         reg_type_str[reg_state(env, insn->dst_reg)->type]);
1980                 return -EACCES;
1981         }
1982
1983         /* check whether atomic_add can read the memory */
1984         err = check_mem_access(env, insn_idx, insn->dst_reg, insn->off,
1985                                BPF_SIZE(insn->code), BPF_READ, -1, true);
1986         if (err)
1987                 return err;
1988
1989         /* check whether atomic_add can write into the same memory */
1990         return check_mem_access(env, insn_idx, insn->dst_reg, insn->off,
1991                                 BPF_SIZE(insn->code), BPF_WRITE, -1, true);
1992 }
1993
1994 /* when register 'regno' is passed into function that will read 'access_size'
1995  * bytes from that pointer, make sure that it's within stack boundary
1996  * and all elements of stack are initialized.
1997  * Unlike most pointer bounds-checking functions, this one doesn't take an
1998  * 'off' argument, so it has to add in reg->off itself.
1999  */
2000 static int check_stack_boundary(struct bpf_verifier_env *env, int regno,
2001                                 int access_size, bool zero_size_allowed,
2002                                 struct bpf_call_arg_meta *meta)
2003 {
2004         struct bpf_reg_state *reg = reg_state(env, regno);
2005         struct bpf_func_state *state = func(env, reg);
2006         int off, i, slot, spi;
2007
2008         if (reg->type != PTR_TO_STACK) {
2009                 /* Allow zero-byte read from NULL, regardless of pointer type */
2010                 if (zero_size_allowed && access_size == 0 &&
2011                     register_is_null(reg))
2012                         return 0;
2013
2014                 verbose(env, "R%d type=%s expected=%s\n", regno,
2015                         reg_type_str[reg->type],
2016                         reg_type_str[PTR_TO_STACK]);
2017                 return -EACCES;
2018         }
2019
2020         /* Only allow fixed-offset stack reads */
2021         if (!tnum_is_const(reg->var_off)) {
2022                 char tn_buf[48];
2023
2024                 tnum_strn(tn_buf, sizeof(tn_buf), reg->var_off);
2025                 verbose(env, "invalid variable stack read R%d var_off=%s\n",
2026                         regno, tn_buf);
2027                 return -EACCES;
2028         }
2029         off = reg->off + reg->var_off.value;
2030         if (off >= 0 || off < -MAX_BPF_STACK || off + access_size > 0 ||
2031             access_size < 0 || (access_size == 0 && !zero_size_allowed)) {
2032                 verbose(env, "invalid stack type R%d off=%d access_size=%d\n",
2033                         regno, off, access_size);
2034                 return -EACCES;
2035         }
2036
2037         if (meta && meta->raw_mode) {
2038                 meta->access_size = access_size;
2039                 meta->regno = regno;
2040                 return 0;
2041         }
2042
2043         for (i = 0; i < access_size; i++) {
2044                 u8 *stype;
2045
2046                 slot = -(off + i) - 1;
2047                 spi = slot / BPF_REG_SIZE;
2048                 if (state->allocated_stack <= slot)
2049                         goto err;
2050                 stype = &state->stack[spi].slot_type[slot % BPF_REG_SIZE];
2051                 if (*stype == STACK_MISC)
2052                         goto mark;
2053                 if (*stype == STACK_ZERO) {
2054                         /* helper can write anything into the stack */
2055                         *stype = STACK_MISC;
2056                         goto mark;
2057                 }
2058 err:
2059                 verbose(env, "invalid indirect read from stack off %d+%d size %d\n",
2060                         off, i, access_size);
2061                 return -EACCES;
2062 mark:
2063                 /* reading any byte out of 8-byte 'spill_slot' will cause
2064                  * the whole slot to be marked as 'read'
2065                  */
2066                 mark_reg_read(env, &state->stack[spi].spilled_ptr,
2067                               state->stack[spi].spilled_ptr.parent);
2068         }
2069         return update_stack_depth(env, state, off);
2070 }
2071
2072 static int check_helper_mem_access(struct bpf_verifier_env *env, int regno,
2073                                    int access_size, bool zero_size_allowed,
2074                                    struct bpf_call_arg_meta *meta)
2075 {
2076         struct bpf_reg_state *regs = cur_regs(env), *reg = &regs[regno];
2077
2078         switch (reg->type) {
2079         case PTR_TO_PACKET:
2080         case PTR_TO_PACKET_META:
2081                 return check_packet_access(env, regno, reg->off, access_size,
2082                                            zero_size_allowed);
2083         case PTR_TO_MAP_VALUE:
2084                 return check_map_access(env, regno, reg->off, access_size,
2085                                         zero_size_allowed);
2086         default: /* scalar_value|ptr_to_stack or invalid ptr */
2087                 return check_stack_boundary(env, regno, access_size,
2088                                             zero_size_allowed, meta);
2089         }
2090 }
2091
2092 static bool arg_type_is_mem_ptr(enum bpf_arg_type type)
2093 {
2094         return type == ARG_PTR_TO_MEM ||
2095                type == ARG_PTR_TO_MEM_OR_NULL ||
2096                type == ARG_PTR_TO_UNINIT_MEM;
2097 }
2098
2099 static bool arg_type_is_mem_size(enum bpf_arg_type type)
2100 {
2101         return type == ARG_CONST_SIZE ||
2102                type == ARG_CONST_SIZE_OR_ZERO;
2103 }
2104
2105 static int check_func_arg(struct bpf_verifier_env *env, u32 regno,
2106                           enum bpf_arg_type arg_type,
2107                           struct bpf_call_arg_meta *meta)
2108 {
2109         struct bpf_reg_state *regs = cur_regs(env), *reg = &regs[regno];
2110         enum bpf_reg_type expected_type, type = reg->type;
2111         int err = 0;
2112
2113         if (arg_type == ARG_DONTCARE)
2114                 return 0;
2115
2116         err = check_reg_arg(env, regno, SRC_OP);
2117         if (err)
2118                 return err;
2119
2120         if (arg_type == ARG_ANYTHING) {
2121                 if (is_pointer_value(env, regno)) {
2122                         verbose(env, "R%d leaks addr into helper function\n",
2123                                 regno);
2124                         return -EACCES;
2125                 }
2126                 return 0;
2127         }
2128
2129         if (type_is_pkt_pointer(type) &&
2130             !may_access_direct_pkt_data(env, meta, BPF_READ)) {
2131                 verbose(env, "helper access to the packet is not allowed\n");
2132                 return -EACCES;
2133         }
2134
2135         if (arg_type == ARG_PTR_TO_MAP_KEY ||
2136             arg_type == ARG_PTR_TO_MAP_VALUE ||
2137             arg_type == ARG_PTR_TO_UNINIT_MAP_VALUE) {
2138                 expected_type = PTR_TO_STACK;
2139                 if (!type_is_pkt_pointer(type) && type != PTR_TO_MAP_VALUE &&
2140                     type != expected_type)
2141                         goto err_type;
2142         } else if (arg_type == ARG_CONST_SIZE ||
2143                    arg_type == ARG_CONST_SIZE_OR_ZERO) {
2144                 expected_type = SCALAR_VALUE;
2145                 if (type != expected_type)
2146                         goto err_type;
2147         } else if (arg_type == ARG_CONST_MAP_PTR) {
2148                 expected_type = CONST_PTR_TO_MAP;
2149                 if (type != expected_type)
2150                         goto err_type;
2151         } else if (arg_type == ARG_PTR_TO_CTX) {
2152                 expected_type = PTR_TO_CTX;
2153                 if (type != expected_type)
2154                         goto err_type;
2155                 err = check_ctx_reg(env, reg, regno);
2156                 if (err < 0)
2157                         return err;
2158         } else if (arg_type == ARG_PTR_TO_SOCKET) {
2159                 expected_type = PTR_TO_SOCKET;
2160                 if (type != expected_type)
2161                         goto err_type;
2162                 if (meta->ptr_id || !reg->id) {
2163                         verbose(env, "verifier internal error: mismatched references meta=%d, reg=%d\n",
2164                                 meta->ptr_id, reg->id);
2165                         return -EFAULT;
2166                 }
2167                 meta->ptr_id = reg->id;
2168         } else if (arg_type_is_mem_ptr(arg_type)) {
2169                 expected_type = PTR_TO_STACK;
2170                 /* One exception here. In case function allows for NULL to be
2171                  * passed in as argument, it's a SCALAR_VALUE type. Final test
2172                  * happens during stack boundary checking.
2173                  */
2174                 if (register_is_null(reg) &&
2175                     arg_type == ARG_PTR_TO_MEM_OR_NULL)
2176                         /* final test in check_stack_boundary() */;
2177                 else if (!type_is_pkt_pointer(type) &&
2178                          type != PTR_TO_MAP_VALUE &&
2179                          type != expected_type)
2180                         goto err_type;
2181                 meta->raw_mode = arg_type == ARG_PTR_TO_UNINIT_MEM;
2182         } else {
2183                 verbose(env, "unsupported arg_type %d\n", arg_type);
2184                 return -EFAULT;
2185         }
2186
2187         if (arg_type == ARG_CONST_MAP_PTR) {
2188                 /* bpf_map_xxx(map_ptr) call: remember that map_ptr */
2189                 meta->map_ptr = reg->map_ptr;
2190         } else if (arg_type == ARG_PTR_TO_MAP_KEY) {
2191                 /* bpf_map_xxx(..., map_ptr, ..., key) call:
2192                  * check that [key, key + map->key_size) are within
2193                  * stack limits and initialized
2194                  */
2195                 if (!meta->map_ptr) {
2196                         /* in function declaration map_ptr must come before
2197                          * map_key, so that it's verified and known before
2198                          * we have to check map_key here. Otherwise it means
2199                          * that kernel subsystem misconfigured verifier
2200                          */
2201                         verbose(env, "invalid map_ptr to access map->key\n");
2202                         return -EACCES;
2203                 }
2204                 err = check_helper_mem_access(env, regno,
2205                                               meta->map_ptr->key_size, false,
2206                                               NULL);
2207         } else if (arg_type == ARG_PTR_TO_MAP_VALUE ||
2208                    arg_type == ARG_PTR_TO_UNINIT_MAP_VALUE) {
2209                 /* bpf_map_xxx(..., map_ptr, ..., value) call:
2210                  * check [value, value + map->value_size) validity
2211                  */
2212                 if (!meta->map_ptr) {
2213                         /* kernel subsystem misconfigured verifier */
2214                         verbose(env, "invalid map_ptr to access map->value\n");
2215                         return -EACCES;
2216                 }
2217                 meta->raw_mode = (arg_type == ARG_PTR_TO_UNINIT_MAP_VALUE);
2218                 err = check_helper_mem_access(env, regno,
2219                                               meta->map_ptr->value_size, false,
2220                                               meta);
2221         } else if (arg_type_is_mem_size(arg_type)) {
2222                 bool zero_size_allowed = (arg_type == ARG_CONST_SIZE_OR_ZERO);
2223
2224                 /* remember the mem_size which may be used later
2225                  * to refine return values.
2226                  */
2227                 meta->msize_smax_value = reg->smax_value;
2228                 meta->msize_umax_value = reg->umax_value;
2229
2230                 /* The register is SCALAR_VALUE; the access check
2231                  * happens using its boundaries.
2232                  */
2233                 if (!tnum_is_const(reg->var_off))
2234                         /* For unprivileged variable accesses, disable raw
2235                          * mode so that the program is required to
2236                          * initialize all the memory that the helper could
2237                          * just partially fill up.
2238                          */
2239                         meta = NULL;
2240
2241                 if (reg->smin_value < 0) {
2242                         verbose(env, "R%d min value is negative, either use unsigned or 'var &= const'\n",
2243                                 regno);
2244                         return -EACCES;
2245                 }
2246
2247                 if (reg->umin_value == 0) {
2248                         err = check_helper_mem_access(env, regno - 1, 0,
2249                                                       zero_size_allowed,
2250                                                       meta);
2251                         if (err)
2252                                 return err;
2253                 }
2254
2255                 if (reg->umax_value >= BPF_MAX_VAR_SIZ) {
2256                         verbose(env, "R%d unbounded memory access, use 'var &= const' or 'if (var < const)'\n",
2257                                 regno);
2258                         return -EACCES;
2259                 }
2260                 err = check_helper_mem_access(env, regno - 1,
2261                                               reg->umax_value,
2262                                               zero_size_allowed, meta);
2263         }
2264
2265         return err;
2266 err_type:
2267         verbose(env, "R%d type=%s expected=%s\n", regno,
2268                 reg_type_str[type], reg_type_str[expected_type]);
2269         return -EACCES;
2270 }
2271
2272 static int check_map_func_compatibility(struct bpf_verifier_env *env,
2273                                         struct bpf_map *map, int func_id)
2274 {
2275         if (!map)
2276                 return 0;
2277
2278         /* We need a two way check, first is from map perspective ... */
2279         switch (map->map_type) {
2280         case BPF_MAP_TYPE_PROG_ARRAY:
2281                 if (func_id != BPF_FUNC_tail_call)
2282                         goto error;
2283                 break;
2284         case BPF_MAP_TYPE_PERF_EVENT_ARRAY:
2285                 if (func_id != BPF_FUNC_perf_event_read &&
2286                     func_id != BPF_FUNC_perf_event_output &&
2287                     func_id != BPF_FUNC_perf_event_read_value)
2288                         goto error;
2289                 break;
2290         case BPF_MAP_TYPE_STACK_TRACE:
2291                 if (func_id != BPF_FUNC_get_stackid)
2292                         goto error;
2293                 break;
2294         case BPF_MAP_TYPE_CGROUP_ARRAY:
2295                 if (func_id != BPF_FUNC_skb_under_cgroup &&
2296                     func_id != BPF_FUNC_current_task_under_cgroup)
2297                         goto error;
2298                 break;
2299         case BPF_MAP_TYPE_CGROUP_STORAGE:
2300         case BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE:
2301                 if (func_id != BPF_FUNC_get_local_storage)
2302                         goto error;
2303                 break;
2304         /* devmap returns a pointer to a live net_device ifindex that we cannot
2305          * allow to be modified from bpf side. So do not allow lookup elements
2306          * for now.
2307          */
2308         case BPF_MAP_TYPE_DEVMAP:
2309                 if (func_id != BPF_FUNC_redirect_map)
2310                         goto error;
2311                 break;
2312         /* Restrict bpf side of cpumap and xskmap, open when use-cases
2313          * appear.
2314          */
2315         case BPF_MAP_TYPE_CPUMAP:
2316         case BPF_MAP_TYPE_XSKMAP:
2317                 if (func_id != BPF_FUNC_redirect_map)
2318                         goto error;
2319                 break;
2320         case BPF_MAP_TYPE_ARRAY_OF_MAPS:
2321         case BPF_MAP_TYPE_HASH_OF_MAPS:
2322                 if (func_id != BPF_FUNC_map_lookup_elem)
2323                         goto error;
2324                 break;
2325         case BPF_MAP_TYPE_SOCKMAP:
2326                 if (func_id != BPF_FUNC_sk_redirect_map &&
2327                     func_id != BPF_FUNC_sock_map_update &&
2328                     func_id != BPF_FUNC_map_delete_elem &&
2329                     func_id != BPF_FUNC_msg_redirect_map)
2330                         goto error;
2331                 break;
2332         case BPF_MAP_TYPE_SOCKHASH:
2333                 if (func_id != BPF_FUNC_sk_redirect_hash &&
2334                     func_id != BPF_FUNC_sock_hash_update &&
2335                     func_id != BPF_FUNC_map_delete_elem &&
2336                     func_id != BPF_FUNC_msg_redirect_hash)
2337                         goto error;
2338                 break;
2339         case BPF_MAP_TYPE_REUSEPORT_SOCKARRAY:
2340                 if (func_id != BPF_FUNC_sk_select_reuseport)
2341                         goto error;
2342                 break;
2343         case BPF_MAP_TYPE_QUEUE:
2344         case BPF_MAP_TYPE_STACK:
2345                 if (func_id != BPF_FUNC_map_peek_elem &&
2346                     func_id != BPF_FUNC_map_pop_elem &&
2347                     func_id != BPF_FUNC_map_push_elem)
2348                         goto error;
2349                 break;
2350         default:
2351                 break;
2352         }
2353
2354         /* ... and second from the function itself. */
2355         switch (func_id) {
2356         case BPF_FUNC_tail_call:
2357                 if (map->map_type != BPF_MAP_TYPE_PROG_ARRAY)
2358                         goto error;
2359                 if (env->subprog_cnt > 1) {
2360                         verbose(env, "tail_calls are not allowed in programs with bpf-to-bpf calls\n");
2361                         return -EINVAL;
2362                 }
2363                 break;
2364         case BPF_FUNC_perf_event_read:
2365         case BPF_FUNC_perf_event_output:
2366         case BPF_FUNC_perf_event_read_value:
2367                 if (map->map_type != BPF_MAP_TYPE_PERF_EVENT_ARRAY)
2368                         goto error;
2369                 break;
2370         case BPF_FUNC_get_stackid:
2371                 if (map->map_type != BPF_MAP_TYPE_STACK_TRACE)
2372                         goto error;
2373                 break;
2374         case BPF_FUNC_current_task_under_cgroup:
2375         case BPF_FUNC_skb_under_cgroup:
2376                 if (map->map_type != BPF_MAP_TYPE_CGROUP_ARRAY)
2377                         goto error;
2378                 break;
2379         case BPF_FUNC_redirect_map:
2380                 if (map->map_type != BPF_MAP_TYPE_DEVMAP &&
2381                     map->map_type != BPF_MAP_TYPE_CPUMAP &&
2382                     map->map_type != BPF_MAP_TYPE_XSKMAP)
2383                         goto error;
2384                 break;
2385         case BPF_FUNC_sk_redirect_map:
2386         case BPF_FUNC_msg_redirect_map:
2387         case BPF_FUNC_sock_map_update:
2388                 if (map->map_type != BPF_MAP_TYPE_SOCKMAP)
2389                         goto error;
2390                 break;
2391         case BPF_FUNC_sk_redirect_hash:
2392         case BPF_FUNC_msg_redirect_hash:
2393         case BPF_FUNC_sock_hash_update:
2394                 if (map->map_type != BPF_MAP_TYPE_SOCKHASH)
2395                         goto error;
2396                 break;
2397         case BPF_FUNC_get_local_storage:
2398                 if (map->map_type != BPF_MAP_TYPE_CGROUP_STORAGE &&
2399                     map->map_type != BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE)
2400                         goto error;
2401                 break;
2402         case BPF_FUNC_sk_select_reuseport:
2403                 if (map->map_type != BPF_MAP_TYPE_REUSEPORT_SOCKARRAY)
2404                         goto error;
2405                 break;
2406         case BPF_FUNC_map_peek_elem:
2407         case BPF_FUNC_map_pop_elem:
2408         case BPF_FUNC_map_push_elem:
2409                 if (map->map_type != BPF_MAP_TYPE_QUEUE &&
2410                     map->map_type != BPF_MAP_TYPE_STACK)
2411                         goto error;
2412                 break;
2413         default:
2414                 break;
2415         }
2416
2417         return 0;
2418 error:
2419         verbose(env, "cannot pass map_type %d into func %s#%d\n",
2420                 map->map_type, func_id_name(func_id), func_id);
2421         return -EINVAL;
2422 }
2423
2424 static bool check_raw_mode_ok(const struct bpf_func_proto *fn)
2425 {
2426         int count = 0;
2427
2428         if (fn->arg1_type == ARG_PTR_TO_UNINIT_MEM)
2429                 count++;
2430         if (fn->arg2_type == ARG_PTR_TO_UNINIT_MEM)
2431                 count++;
2432         if (fn->arg3_type == ARG_PTR_TO_UNINIT_MEM)
2433                 count++;
2434         if (fn->arg4_type == ARG_PTR_TO_UNINIT_MEM)
2435                 count++;
2436         if (fn->arg5_type == ARG_PTR_TO_UNINIT_MEM)
2437                 count++;
2438
2439         /* We only support one arg being in raw mode at the moment,
2440          * which is sufficient for the helper functions we have
2441          * right now.
2442          */
2443         return count <= 1;
2444 }
2445
2446 static bool check_args_pair_invalid(enum bpf_arg_type arg_curr,
2447                                     enum bpf_arg_type arg_next)
2448 {
2449         return (arg_type_is_mem_ptr(arg_curr) &&
2450                 !arg_type_is_mem_size(arg_next)) ||
2451                (!arg_type_is_mem_ptr(arg_curr) &&
2452                 arg_type_is_mem_size(arg_next));
2453 }
2454
2455 static bool check_arg_pair_ok(const struct bpf_func_proto *fn)
2456 {
2457         /* bpf_xxx(..., buf, len) call will access 'len'
2458          * bytes from memory 'buf'. Both arg types need
2459          * to be paired, so make sure there's no buggy
2460          * helper function specification.
2461          */
2462         if (arg_type_is_mem_size(fn->arg1_type) ||
2463             arg_type_is_mem_ptr(fn->arg5_type)  ||
2464             check_args_pair_invalid(fn->arg1_type, fn->arg2_type) ||
2465             check_args_pair_invalid(fn->arg2_type, fn->arg3_type) ||
2466             check_args_pair_invalid(fn->arg3_type, fn->arg4_type) ||
2467             check_args_pair_invalid(fn->arg4_type, fn->arg5_type))
2468                 return false;
2469
2470         return true;
2471 }
2472
2473 static bool check_refcount_ok(const struct bpf_func_proto *fn)
2474 {
2475         int count = 0;
2476
2477         if (arg_type_is_refcounted(fn->arg1_type))
2478                 count++;
2479         if (arg_type_is_refcounted(fn->arg2_type))
2480                 count++;
2481         if (arg_type_is_refcounted(fn->arg3_type))
2482                 count++;
2483         if (arg_type_is_refcounted(fn->arg4_type))
2484                 count++;
2485         if (arg_type_is_refcounted(fn->arg5_type))
2486                 count++;
2487
2488         /* We only support one arg being unreferenced at the moment,
2489          * which is sufficient for the helper functions we have right now.
2490          */
2491         return count <= 1;
2492 }
2493
2494 static int check_func_proto(const struct bpf_func_proto *fn)
2495 {
2496         return check_raw_mode_ok(fn) &&
2497                check_arg_pair_ok(fn) &&
2498                check_refcount_ok(fn) ? 0 : -EINVAL;
2499 }
2500
2501 /* Packet data might have moved, any old PTR_TO_PACKET[_META,_END]
2502  * are now invalid, so turn them into unknown SCALAR_VALUE.
2503  */
2504 static void __clear_all_pkt_pointers(struct bpf_verifier_env *env,
2505                                      struct bpf_func_state *state)
2506 {
2507         struct bpf_reg_state *regs = state->regs, *reg;
2508         int i;
2509
2510         for (i = 0; i < MAX_BPF_REG; i++)
2511                 if (reg_is_pkt_pointer_any(&regs[i]))
2512                         mark_reg_unknown(env, regs, i);
2513
2514         bpf_for_each_spilled_reg(i, state, reg) {
2515                 if (!reg)
2516                         continue;
2517                 if (reg_is_pkt_pointer_any(reg))
2518                         __mark_reg_unknown(reg);
2519         }
2520 }
2521
2522 static void clear_all_pkt_pointers(struct bpf_verifier_env *env)
2523 {
2524         struct bpf_verifier_state *vstate = env->cur_state;
2525         int i;
2526
2527         for (i = 0; i <= vstate->curframe; i++)
2528                 __clear_all_pkt_pointers(env, vstate->frame[i]);
2529 }
2530
2531 static void release_reg_references(struct bpf_verifier_env *env,
2532                                    struct bpf_func_state *state, int id)
2533 {
2534         struct bpf_reg_state *regs = state->regs, *reg;
2535         int i;
2536
2537         for (i = 0; i < MAX_BPF_REG; i++)
2538                 if (regs[i].id == id)
2539                         mark_reg_unknown(env, regs, i);
2540
2541         bpf_for_each_spilled_reg(i, state, reg) {
2542                 if (!reg)
2543                         continue;
2544                 if (reg_is_refcounted(reg) && reg->id == id)
2545                         __mark_reg_unknown(reg);
2546         }
2547 }
2548
2549 /* The pointer with the specified id has released its reference to kernel
2550  * resources. Identify all copies of the same pointer and clear the reference.
2551  */
2552 static int release_reference(struct bpf_verifier_env *env,
2553                              struct bpf_call_arg_meta *meta)
2554 {
2555         struct bpf_verifier_state *vstate = env->cur_state;
2556         int i;
2557
2558         for (i = 0; i <= vstate->curframe; i++)
2559                 release_reg_references(env, vstate->frame[i], meta->ptr_id);
2560
2561         return release_reference_state(env, meta->ptr_id);
2562 }
2563
2564 static int check_func_call(struct bpf_verifier_env *env, struct bpf_insn *insn,
2565                            int *insn_idx)
2566 {
2567         struct bpf_verifier_state *state = env->cur_state;
2568         struct bpf_func_state *caller, *callee;
2569         int i, err, subprog, target_insn;
2570
2571         if (state->curframe + 1 >= MAX_CALL_FRAMES) {
2572                 verbose(env, "the call stack of %d frames is too deep\n",
2573                         state->curframe + 2);
2574                 return -E2BIG;
2575         }
2576
2577         target_insn = *insn_idx + insn->imm;
2578         subprog = find_subprog(env, target_insn + 1);
2579         if (subprog < 0) {
2580                 verbose(env, "verifier bug. No program starts at insn %d\n",
2581                         target_insn + 1);
2582                 return -EFAULT;
2583         }
2584
2585         caller = state->frame[state->curframe];
2586         if (state->frame[state->curframe + 1]) {
2587                 verbose(env, "verifier bug. Frame %d already allocated\n",
2588                         state->curframe + 1);
2589                 return -EFAULT;
2590         }
2591
2592         callee = kzalloc(sizeof(*callee), GFP_KERNEL);
2593         if (!callee)
2594                 return -ENOMEM;
2595         state->frame[state->curframe + 1] = callee;
2596
2597         /* callee cannot access r0, r6 - r9 for reading and has to write
2598          * into its own stack before reading from it.
2599          * callee can read/write into caller's stack
2600          */
2601         init_func_state(env, callee,
2602                         /* remember the callsite, it will be used by bpf_exit */
2603                         *insn_idx /* callsite */,
2604                         state->curframe + 1 /* frameno within this callchain */,
2605                         subprog /* subprog number within this prog */);
2606
2607         /* Transfer references to the callee */
2608         err = transfer_reference_state(callee, caller);
2609         if (err)
2610                 return err;
2611
2612         /* copy r1 - r5 args that callee can access.  The copy includes parent
2613          * pointers, which connects us up to the liveness chain
2614          */
2615         for (i = BPF_REG_1; i <= BPF_REG_5; i++)
2616                 callee->regs[i] = caller->regs[i];
2617
2618         /* after the call registers r0 - r5 were scratched */
2619         for (i = 0; i < CALLER_SAVED_REGS; i++) {
2620                 mark_reg_not_init(env, caller->regs, caller_saved[i]);
2621                 check_reg_arg(env, caller_saved[i], DST_OP_NO_MARK);
2622         }
2623
2624         /* only increment it after check_reg_arg() finished */
2625         state->curframe++;
2626
2627         /* and go analyze first insn of the callee */
2628         *insn_idx = target_insn;
2629
2630         if (env->log.level) {
2631                 verbose(env, "caller:\n");
2632                 print_verifier_state(env, caller);
2633                 verbose(env, "callee:\n");
2634                 print_verifier_state(env, callee);
2635         }
2636         return 0;
2637 }
2638
2639 static int prepare_func_exit(struct bpf_verifier_env *env, int *insn_idx)
2640 {
2641         struct bpf_verifier_state *state = env->cur_state;
2642         struct bpf_func_state *caller, *callee;
2643         struct bpf_reg_state *r0;
2644         int err;
2645
2646         callee = state->frame[state->curframe];
2647         r0 = &callee->regs[BPF_REG_0];
2648         if (r0->type == PTR_TO_STACK) {
2649                 /* technically it's ok to return caller's stack pointer
2650                  * (or caller's caller's pointer) back to the caller,
2651                  * since these pointers are valid. Only current stack
2652                  * pointer will be invalid as soon as function exits,
2653                  * but let's be conservative
2654                  */
2655                 verbose(env, "cannot return stack pointer to the caller\n");
2656                 return -EINVAL;
2657         }
2658
2659         state->curframe--;
2660         caller = state->frame[state->curframe];
2661         /* return to the caller whatever r0 had in the callee */
2662         caller->regs[BPF_REG_0] = *r0;
2663
2664         /* Transfer references to the caller */
2665         err = transfer_reference_state(caller, callee);
2666         if (err)
2667                 return err;
2668
2669         *insn_idx = callee->callsite + 1;
2670         if (env->log.level) {
2671                 verbose(env, "returning from callee:\n");
2672                 print_verifier_state(env, callee);
2673                 verbose(env, "to caller at %d:\n", *insn_idx);
2674                 print_verifier_state(env, caller);
2675         }
2676         /* clear everything in the callee */
2677         free_func_state(callee);
2678         state->frame[state->curframe + 1] = NULL;
2679         return 0;
2680 }
2681
2682 static void do_refine_retval_range(struct bpf_reg_state *regs, int ret_type,
2683                                    int func_id,
2684                                    struct bpf_call_arg_meta *meta)
2685 {
2686         struct bpf_reg_state *ret_reg = &regs[BPF_REG_0];
2687
2688         if (ret_type != RET_INTEGER ||
2689             (func_id != BPF_FUNC_get_stack &&
2690              func_id != BPF_FUNC_probe_read_str))
2691                 return;
2692
2693         ret_reg->smax_value = meta->msize_smax_value;
2694         ret_reg->umax_value = meta->msize_umax_value;
2695         __reg_deduce_bounds(ret_reg);
2696         __reg_bound_offset(ret_reg);
2697 }
2698
2699 static int
2700 record_func_map(struct bpf_verifier_env *env, struct bpf_call_arg_meta *meta,
2701                 int func_id, int insn_idx)
2702 {
2703         struct bpf_insn_aux_data *aux = &env->insn_aux_data[insn_idx];
2704
2705         if (func_id != BPF_FUNC_tail_call &&
2706             func_id != BPF_FUNC_map_lookup_elem &&
2707             func_id != BPF_FUNC_map_update_elem &&
2708             func_id != BPF_FUNC_map_delete_elem &&
2709             func_id != BPF_FUNC_map_push_elem &&
2710             func_id != BPF_FUNC_map_pop_elem &&
2711             func_id != BPF_FUNC_map_peek_elem)
2712                 return 0;
2713
2714         if (meta->map_ptr == NULL) {
2715                 verbose(env, "kernel subsystem misconfigured verifier\n");
2716                 return -EINVAL;
2717         }
2718
2719         if (!BPF_MAP_PTR(aux->map_state))
2720                 bpf_map_ptr_store(aux, meta->map_ptr,
2721                                   meta->map_ptr->unpriv_array);
2722         else if (BPF_MAP_PTR(aux->map_state) != meta->map_ptr)
2723                 bpf_map_ptr_store(aux, BPF_MAP_PTR_POISON,
2724                                   meta->map_ptr->unpriv_array);
2725         return 0;
2726 }
2727
2728 static int check_reference_leak(struct bpf_verifier_env *env)
2729 {
2730         struct bpf_func_state *state = cur_func(env);
2731         int i;
2732
2733         for (i = 0; i < state->acquired_refs; i++) {
2734                 verbose(env, "Unreleased reference id=%d alloc_insn=%d\n",
2735                         state->refs[i].id, state->refs[i].insn_idx);
2736         }
2737         return state->acquired_refs ? -EINVAL : 0;
2738 }
2739
2740 static int check_helper_call(struct bpf_verifier_env *env, int func_id, int insn_idx)
2741 {
2742         const struct bpf_func_proto *fn = NULL;
2743         struct bpf_reg_state *regs;
2744         struct bpf_call_arg_meta meta;
2745         bool changes_data;
2746         int i, err;
2747
2748         /* find function prototype */
2749         if (func_id < 0 || func_id >= __BPF_FUNC_MAX_ID) {
2750                 verbose(env, "invalid func %s#%d\n", func_id_name(func_id),
2751                         func_id);
2752                 return -EINVAL;
2753         }
2754
2755         if (env->ops->get_func_proto)
2756                 fn = env->ops->get_func_proto(func_id, env->prog);
2757         if (!fn) {
2758                 verbose(env, "unknown func %s#%d\n", func_id_name(func_id),
2759                         func_id);
2760                 return -EINVAL;
2761         }
2762
2763         /* eBPF programs must be GPL compatible to use GPL-ed functions */
2764         if (!env->prog->gpl_compatible && fn->gpl_only) {
2765                 verbose(env, "cannot call GPL-restricted function from non-GPL compatible program\n");
2766                 return -EINVAL;
2767         }
2768
2769         /* With LD_ABS/IND some JITs save/restore skb from r1. */
2770         changes_data = bpf_helper_changes_pkt_data(fn->func);
2771         if (changes_data && fn->arg1_type != ARG_PTR_TO_CTX) {
2772                 verbose(env, "kernel subsystem misconfigured func %s#%d: r1 != ctx\n",
2773                         func_id_name(func_id), func_id);
2774                 return -EINVAL;
2775         }
2776
2777         memset(&meta, 0, sizeof(meta));
2778         meta.pkt_access = fn->pkt_access;
2779
2780         err = check_func_proto(fn);
2781         if (err) {
2782                 verbose(env, "kernel subsystem misconfigured func %s#%d\n",
2783                         func_id_name(func_id), func_id);
2784                 return err;
2785         }
2786
2787         /* check args */
2788         err = check_func_arg(env, BPF_REG_1, fn->arg1_type, &meta);
2789         if (err)
2790                 return err;
2791         err = check_func_arg(env, BPF_REG_2, fn->arg2_type, &meta);
2792         if (err)
2793                 return err;
2794         err = check_func_arg(env, BPF_REG_3, fn->arg3_type, &meta);
2795         if (err)
2796                 return err;
2797         err = check_func_arg(env, BPF_REG_4, fn->arg4_type, &meta);
2798         if (err)
2799                 return err;
2800         err = check_func_arg(env, BPF_REG_5, fn->arg5_type, &meta);
2801         if (err)
2802                 return err;
2803
2804         err = record_func_map(env, &meta, func_id, insn_idx);
2805         if (err)
2806                 return err;
2807
2808         /* Mark slots with STACK_MISC in case of raw mode, stack offset
2809          * is inferred from register state.
2810          */
2811         for (i = 0; i < meta.access_size; i++) {
2812                 err = check_mem_access(env, insn_idx, meta.regno, i, BPF_B,
2813                                        BPF_WRITE, -1, false);
2814                 if (err)
2815                         return err;
2816         }
2817
2818         if (func_id == BPF_FUNC_tail_call) {
2819                 err = check_reference_leak(env);
2820                 if (err) {
2821                         verbose(env, "tail_call would lead to reference leak\n");
2822                         return err;
2823                 }
2824         } else if (is_release_function(func_id)) {
2825                 err = release_reference(env, &meta);
2826                 if (err)
2827                         return err;
2828         }
2829
2830         regs = cur_regs(env);
2831
2832         /* check that flags argument in get_local_storage(map, flags) is 0,
2833          * this is required because get_local_storage() can't return an error.
2834          */
2835         if (func_id == BPF_FUNC_get_local_storage &&
2836             !register_is_null(&regs[BPF_REG_2])) {
2837                 verbose(env, "get_local_storage() doesn't support non-zero flags\n");
2838                 return -EINVAL;
2839         }
2840
2841         /* reset caller saved regs */
2842         for (i = 0; i < CALLER_SAVED_REGS; i++) {
2843                 mark_reg_not_init(env, regs, caller_saved[i]);
2844                 check_reg_arg(env, caller_saved[i], DST_OP_NO_MARK);
2845         }
2846
2847         /* update return register (already marked as written above) */
2848         if (fn->ret_type == RET_INTEGER) {
2849                 /* sets type to SCALAR_VALUE */
2850                 mark_reg_unknown(env, regs, BPF_REG_0);
2851         } else if (fn->ret_type == RET_VOID) {
2852                 regs[BPF_REG_0].type = NOT_INIT;
2853         } else if (fn->ret_type == RET_PTR_TO_MAP_VALUE_OR_NULL ||
2854                    fn->ret_type == RET_PTR_TO_MAP_VALUE) {
2855                 if (fn->ret_type == RET_PTR_TO_MAP_VALUE)
2856                         regs[BPF_REG_0].type = PTR_TO_MAP_VALUE;
2857                 else
2858                         regs[BPF_REG_0].type = PTR_TO_MAP_VALUE_OR_NULL;
2859                 /* There is no offset yet applied, variable or fixed */
2860                 mark_reg_known_zero(env, regs, BPF_REG_0);
2861                 /* remember map_ptr, so that check_map_access()
2862                  * can check 'value_size' boundary of memory access
2863                  * to map element returned from bpf_map_lookup_elem()
2864                  */
2865                 if (meta.map_ptr == NULL) {
2866                         verbose(env,
2867                                 "kernel subsystem misconfigured verifier\n");
2868                         return -EINVAL;
2869                 }
2870                 regs[BPF_REG_0].map_ptr = meta.map_ptr;
2871                 regs[BPF_REG_0].id = ++env->id_gen;
2872         } else if (fn->ret_type == RET_PTR_TO_SOCKET_OR_NULL) {
2873                 int id = acquire_reference_state(env, insn_idx);
2874                 if (id < 0)
2875                         return id;
2876                 mark_reg_known_zero(env, regs, BPF_REG_0);
2877                 regs[BPF_REG_0].type = PTR_TO_SOCKET_OR_NULL;
2878                 regs[BPF_REG_0].id = id;
2879         } else {
2880                 verbose(env, "unknown return type %d of func %s#%d\n",
2881                         fn->ret_type, func_id_name(func_id), func_id);
2882                 return -EINVAL;
2883         }
2884
2885         do_refine_retval_range(regs, fn->ret_type, func_id, &meta);
2886
2887         err = check_map_func_compatibility(env, meta.map_ptr, func_id);
2888         if (err)
2889                 return err;
2890
2891         if (func_id == BPF_FUNC_get_stack && !env->prog->has_callchain_buf) {
2892                 const char *err_str;
2893
2894 #ifdef CONFIG_PERF_EVENTS
2895                 err = get_callchain_buffers(sysctl_perf_event_max_stack);
2896                 err_str = "cannot get callchain buffer for func %s#%d\n";
2897 #else
2898                 err = -ENOTSUPP;
2899                 err_str = "func %s#%d not supported without CONFIG_PERF_EVENTS\n";
2900 #endif
2901                 if (err) {
2902                         verbose(env, err_str, func_id_name(func_id), func_id);
2903                         return err;
2904                 }
2905
2906                 env->prog->has_callchain_buf = true;
2907         }
2908
2909         if (changes_data)
2910                 clear_all_pkt_pointers(env);
2911         return 0;
2912 }
2913
2914 static bool signed_add_overflows(s64 a, s64 b)
2915 {
2916         /* Do the add in u64, where overflow is well-defined */
2917         s64 res = (s64)((u64)a + (u64)b);
2918
2919         if (b < 0)
2920                 return res > a;
2921         return res < a;
2922 }
2923
2924 static bool signed_sub_overflows(s64 a, s64 b)
2925 {
2926         /* Do the sub in u64, where overflow is well-defined */
2927         s64 res = (s64)((u64)a - (u64)b);
2928
2929         if (b < 0)
2930                 return res < a;
2931         return res > a;
2932 }
2933
2934 static bool check_reg_sane_offset(struct bpf_verifier_env *env,
2935                                   const struct bpf_reg_state *reg,
2936                                   enum bpf_reg_type type)
2937 {
2938         bool known = tnum_is_const(reg->var_off);
2939         s64 val = reg->var_off.value;
2940         s64 smin = reg->smin_value;
2941
2942         if (known && (val >= BPF_MAX_VAR_OFF || val <= -BPF_MAX_VAR_OFF)) {
2943                 verbose(env, "math between %s pointer and %lld is not allowed\n",
2944                         reg_type_str[type], val);
2945                 return false;
2946         }
2947
2948         if (reg->off >= BPF_MAX_VAR_OFF || reg->off <= -BPF_MAX_VAR_OFF) {
2949                 verbose(env, "%s pointer offset %d is not allowed\n",
2950                         reg_type_str[type], reg->off);
2951                 return false;
2952         }
2953
2954         if (smin == S64_MIN) {
2955                 verbose(env, "math between %s pointer and register with unbounded min value is not allowed\n",
2956                         reg_type_str[type]);
2957                 return false;
2958         }
2959
2960         if (smin >= BPF_MAX_VAR_OFF || smin <= -BPF_MAX_VAR_OFF) {
2961                 verbose(env, "value %lld makes %s pointer be out of bounds\n",
2962                         smin, reg_type_str[type]);
2963                 return false;
2964         }
2965
2966         return true;
2967 }
2968
2969 /* Handles arithmetic on a pointer and a scalar: computes new min/max and var_off.
2970  * Caller should also handle BPF_MOV case separately.
2971  * If we return -EACCES, caller may want to try again treating pointer as a
2972  * scalar.  So we only emit a diagnostic if !env->allow_ptr_leaks.
2973  */
2974 static int adjust_ptr_min_max_vals(struct bpf_verifier_env *env,
2975                                    struct bpf_insn *insn,
2976                                    const struct bpf_reg_state *ptr_reg,
2977                                    const struct bpf_reg_state *off_reg)
2978 {
2979         struct bpf_verifier_state *vstate = env->cur_state;
2980         struct bpf_func_state *state = vstate->frame[vstate->curframe];
2981         struct bpf_reg_state *regs = state->regs, *dst_reg;
2982         bool known = tnum_is_const(off_reg->var_off);
2983         s64 smin_val = off_reg->smin_value, smax_val = off_reg->smax_value,
2984             smin_ptr = ptr_reg->smin_value, smax_ptr = ptr_reg->smax_value;
2985         u64 umin_val = off_reg->umin_value, umax_val = off_reg->umax_value,
2986             umin_ptr = ptr_reg->umin_value, umax_ptr = ptr_reg->umax_value;
2987         u8 opcode = BPF_OP(insn->code);
2988         u32 dst = insn->dst_reg;
2989
2990         dst_reg = &regs[dst];
2991
2992         if ((known && (smin_val != smax_val || umin_val != umax_val)) ||
2993             smin_val > smax_val || umin_val > umax_val) {
2994                 /* Taint dst register if offset had invalid bounds derived from
2995                  * e.g. dead branches.
2996                  */
2997                 __mark_reg_unknown(dst_reg);
2998                 return 0;
2999         }
3000
3001         if (BPF_CLASS(insn->code) != BPF_ALU64) {
3002                 /* 32-bit ALU ops on pointers produce (meaningless) scalars */
3003                 verbose(env,
3004                         "R%d 32-bit pointer arithmetic prohibited\n",
3005                         dst);
3006                 return -EACCES;
3007         }
3008
3009         switch (ptr_reg->type) {
3010         case PTR_TO_MAP_VALUE_OR_NULL:
3011                 verbose(env, "R%d pointer arithmetic on %s prohibited, null-check it first\n",
3012                         dst, reg_type_str[ptr_reg->type]);
3013                 return -EACCES;
3014         case CONST_PTR_TO_MAP:
3015         case PTR_TO_PACKET_END:
3016         case PTR_TO_SOCKET:
3017         case PTR_TO_SOCKET_OR_NULL:
3018                 verbose(env, "R%d pointer arithmetic on %s prohibited\n",
3019                         dst, reg_type_str[ptr_reg->type]);
3020                 return -EACCES;
3021         default:
3022                 break;
3023         }
3024
3025         /* In case of 'scalar += pointer', dst_reg inherits pointer type and id.
3026          * The id may be overwritten later if we create a new variable offset.
3027          */
3028         dst_reg->type = ptr_reg->type;
3029         dst_reg->id = ptr_reg->id;
3030
3031         if (!check_reg_sane_offset(env, off_reg, ptr_reg->type) ||
3032             !check_reg_sane_offset(env, ptr_reg, ptr_reg->type))
3033                 return -EINVAL;
3034
3035         switch (opcode) {
3036         case BPF_ADD:
3037                 /* We can take a fixed offset as long as it doesn't overflow
3038                  * the s32 'off' field
3039                  */
3040                 if (known && (ptr_reg->off + smin_val ==
3041                               (s64)(s32)(ptr_reg->off + smin_val))) {
3042                         /* pointer += K.  Accumulate it into fixed offset */
3043                         dst_reg->smin_value = smin_ptr;
3044                         dst_reg->smax_value = smax_ptr;
3045                         dst_reg->umin_value = umin_ptr;
3046                         dst_reg->umax_value = umax_ptr;
3047                         dst_reg->var_off = ptr_reg->var_off;
3048                         dst_reg->off = ptr_reg->off + smin_val;
3049                         dst_reg->range = ptr_reg->range;
3050                         break;
3051                 }
3052                 /* A new variable offset is created.  Note that off_reg->off
3053                  * == 0, since it's a scalar.
3054                  * dst_reg gets the pointer type and since some positive
3055                  * integer value was added to the pointer, give it a new 'id'
3056                  * if it's a PTR_TO_PACKET.
3057                  * this creates a new 'base' pointer, off_reg (variable) gets
3058                  * added into the variable offset, and we copy the fixed offset
3059                  * from ptr_reg.
3060                  */
3061                 if (signed_add_overflows(smin_ptr, smin_val) ||
3062                     signed_add_overflows(smax_ptr, smax_val)) {
3063                         dst_reg->smin_value = S64_MIN;
3064                         dst_reg->smax_value = S64_MAX;
3065                 } else {
3066                         dst_reg->smin_value = smin_ptr + smin_val;
3067                         dst_reg->smax_value = smax_ptr + smax_val;
3068                 }
3069                 if (umin_ptr + umin_val < umin_ptr ||
3070                     umax_ptr + umax_val < umax_ptr) {
3071                         dst_reg->umin_value = 0;
3072                         dst_reg->umax_value = U64_MAX;
3073                 } else {
3074                         dst_reg->umin_value = umin_ptr + umin_val;
3075                         dst_reg->umax_value = umax_ptr + umax_val;
3076                 }
3077                 dst_reg->var_off = tnum_add(ptr_reg->var_off, off_reg->var_off);
3078                 dst_reg->off = ptr_reg->off;
3079                 if (reg_is_pkt_pointer(ptr_reg)) {
3080                         dst_reg->id = ++env->id_gen;
3081                         /* something was added to pkt_ptr, set range to zero */
3082                         dst_reg->range = 0;
3083                 }
3084                 break;
3085         case BPF_SUB:
3086                 if (dst_reg == off_reg) {
3087                         /* scalar -= pointer.  Creates an unknown scalar */
3088                         verbose(env, "R%d tried to subtract pointer from scalar\n",
3089                                 dst);
3090                         return -EACCES;
3091                 }
3092                 /* We don't allow subtraction from FP, because (according to
3093                  * test_verifier.c test "invalid fp arithmetic", JITs might not
3094                  * be able to deal with it.
3095                  */
3096                 if (ptr_reg->type == PTR_TO_STACK) {
3097                         verbose(env, "R%d subtraction from stack pointer prohibited\n",
3098                                 dst);
3099                         return -EACCES;
3100                 }
3101                 if (known && (ptr_reg->off - smin_val ==
3102                               (s64)(s32)(ptr_reg->off - smin_val))) {
3103                         /* pointer -= K.  Subtract it from fixed offset */
3104                         dst_reg->smin_value = smin_ptr;
3105                         dst_reg->smax_value = smax_ptr;
3106                         dst_reg->umin_value = umin_ptr;
3107                         dst_reg->umax_value = umax_ptr;
3108                         dst_reg->var_off = ptr_reg->var_off;
3109                         dst_reg->id = ptr_reg->id;
3110                         dst_reg->off = ptr_reg->off - smin_val;
3111                         dst_reg->range = ptr_reg->range;
3112                         break;
3113                 }
3114                 /* A new variable offset is created.  If the subtrahend is known
3115                  * nonnegative, then any reg->range we had before is still good.
3116                  */
3117                 if (signed_sub_overflows(smin_ptr, smax_val) ||
3118                     signed_sub_overflows(smax_ptr, smin_val)) {
3119                         /* Overflow possible, we know nothing */
3120                         dst_reg->smin_value = S64_MIN;
3121                         dst_reg->smax_value = S64_MAX;
3122                 } else {
3123                         dst_reg->smin_value = smin_ptr - smax_val;
3124                         dst_reg->smax_value = smax_ptr - smin_val;
3125                 }
3126                 if (umin_ptr < umax_val) {
3127                         /* Overflow possible, we know nothing */
3128                         dst_reg->umin_value = 0;
3129                         dst_reg->umax_value = U64_MAX;
3130                 } else {
3131                         /* Cannot overflow (as long as bounds are consistent) */
3132                         dst_reg->umin_value = umin_ptr - umax_val;
3133                         dst_reg->umax_value = umax_ptr - umin_val;
3134                 }
3135                 dst_reg->var_off = tnum_sub(ptr_reg->var_off, off_reg->var_off);
3136                 dst_reg->off = ptr_reg->off;
3137                 if (reg_is_pkt_pointer(ptr_reg)) {
3138                         dst_reg->id = ++env->id_gen;
3139                         /* something was added to pkt_ptr, set range to zero */
3140                         if (smin_val < 0)
3141                                 dst_reg->range = 0;
3142                 }
3143                 break;
3144         case BPF_AND:
3145         case BPF_OR:
3146         case BPF_XOR:
3147                 /* bitwise ops on pointers are troublesome, prohibit. */
3148                 verbose(env, "R%d bitwise operator %s on pointer prohibited\n",
3149                         dst, bpf_alu_string[opcode >> 4]);
3150                 return -EACCES;
3151         default:
3152                 /* other operators (e.g. MUL,LSH) produce non-pointer results */
3153                 verbose(env, "R%d pointer arithmetic with %s operator prohibited\n",
3154                         dst, bpf_alu_string[opcode >> 4]);
3155                 return -EACCES;
3156         }
3157
3158         if (!check_reg_sane_offset(env, dst_reg, ptr_reg->type))
3159                 return -EINVAL;
3160
3161         __update_reg_bounds(dst_reg);
3162         __reg_deduce_bounds(dst_reg);
3163         __reg_bound_offset(dst_reg);
3164         return 0;
3165 }
3166
3167 /* WARNING: This function does calculations on 64-bit values, but the actual
3168  * execution may occur on 32-bit values. Therefore, things like bitshifts
3169  * need extra checks in the 32-bit case.
3170  */
3171 static int adjust_scalar_min_max_vals(struct bpf_verifier_env *env,
3172                                       struct bpf_insn *insn,
3173                                       struct bpf_reg_state *dst_reg,
3174                                       struct bpf_reg_state src_reg)
3175 {
3176         struct bpf_reg_state *regs = cur_regs(env);
3177         u8 opcode = BPF_OP(insn->code);
3178         bool src_known, dst_known;
3179         s64 smin_val, smax_val;
3180         u64 umin_val, umax_val;
3181         u64 insn_bitness = (BPF_CLASS(insn->code) == BPF_ALU64) ? 64 : 32;
3182
3183         if (insn_bitness == 32) {
3184                 /* Relevant for 32-bit RSH: Information can propagate towards
3185                  * LSB, so it isn't sufficient to only truncate the output to
3186                  * 32 bits.
3187                  */
3188                 coerce_reg_to_size(dst_reg, 4);
3189                 coerce_reg_to_size(&src_reg, 4);
3190         }
3191
3192         smin_val = src_reg.smin_value;
3193         smax_val = src_reg.smax_value;
3194         umin_val = src_reg.umin_value;
3195         umax_val = src_reg.umax_value;
3196         src_known = tnum_is_const(src_reg.var_off);
3197         dst_known = tnum_is_const(dst_reg->var_off);
3198
3199         if ((src_known && (smin_val != smax_val || umin_val != umax_val)) ||
3200             smin_val > smax_val || umin_val > umax_val) {
3201                 /* Taint dst register if offset had invalid bounds derived from
3202                  * e.g. dead branches.
3203                  */
3204                 __mark_reg_unknown(dst_reg);
3205                 return 0;
3206         }
3207
3208         if (!src_known &&
3209             opcode != BPF_ADD && opcode != BPF_SUB && opcode != BPF_AND) {
3210                 __mark_reg_unknown(dst_reg);
3211                 return 0;
3212         }
3213
3214         switch (opcode) {
3215         case BPF_ADD:
3216                 if (signed_add_overflows(dst_reg->smin_value, smin_val) ||
3217                     signed_add_overflows(dst_reg->smax_value, smax_val)) {
3218                         dst_reg->smin_value = S64_MIN;
3219                         dst_reg->smax_value = S64_MAX;
3220                 } else {
3221                         dst_reg->smin_value += smin_val;
3222                         dst_reg->smax_value += smax_val;
3223                 }