~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/powerpc/net/bpf_jit_comp.c

Version: ~ [ linux-5.5-rc7 ] ~ [ linux-5.4.13 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.97 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.166 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.210 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.210 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* bpf_jit_comp.c: BPF JIT compiler for PPC64
  2  *
  3  * Copyright 2011 Matt Evans <matt@ozlabs.org>, IBM Corporation
  4  *
  5  * Based on the x86 BPF compiler, by Eric Dumazet (eric.dumazet@gmail.com)
  6  *
  7  * This program is free software; you can redistribute it and/or
  8  * modify it under the terms of the GNU General Public License
  9  * as published by the Free Software Foundation; version 2
 10  * of the License.
 11  */
 12 #include <linux/moduleloader.h>
 13 #include <asm/cacheflush.h>
 14 #include <linux/netdevice.h>
 15 #include <linux/filter.h>
 16 #include "bpf_jit.h"
 17 
 18 #ifndef __BIG_ENDIAN
 19 /* There are endianness assumptions herein. */
 20 #error "Little-endian PPC not supported in BPF compiler"
 21 #endif
 22 
 23 int bpf_jit_enable __read_mostly;
 24 
 25 
 26 static inline void bpf_flush_icache(void *start, void *end)
 27 {
 28         smp_wmb();
 29         flush_icache_range((unsigned long)start, (unsigned long)end);
 30 }
 31 
 32 static void bpf_jit_build_prologue(struct sk_filter *fp, u32 *image,
 33                                    struct codegen_context *ctx)
 34 {
 35         int i;
 36         const struct sock_filter *filter = fp->insns;
 37 
 38         if (ctx->seen & (SEEN_MEM | SEEN_DATAREF)) {
 39                 /* Make stackframe */
 40                 if (ctx->seen & SEEN_DATAREF) {
 41                         /* If we call any helpers (for loads), save LR */
 42                         EMIT(PPC_INST_MFLR | __PPC_RT(0));
 43                         PPC_STD(0, 1, 16);
 44 
 45                         /* Back up non-volatile regs. */
 46                         PPC_STD(r_D, 1, -(8*(32-r_D)));
 47                         PPC_STD(r_HL, 1, -(8*(32-r_HL)));
 48                 }
 49                 if (ctx->seen & SEEN_MEM) {
 50                         /*
 51                          * Conditionally save regs r15-r31 as some will be used
 52                          * for M[] data.
 53                          */
 54                         for (i = r_M; i < (r_M+16); i++) {
 55                                 if (ctx->seen & (1 << (i-r_M)))
 56                                         PPC_STD(i, 1, -(8*(32-i)));
 57                         }
 58                 }
 59                 EMIT(PPC_INST_STDU | __PPC_RS(1) | __PPC_RA(1) |
 60                      (-BPF_PPC_STACKFRAME & 0xfffc));
 61         }
 62 
 63         if (ctx->seen & SEEN_DATAREF) {
 64                 /*
 65                  * If this filter needs to access skb data,
 66                  * prepare r_D and r_HL:
 67                  *  r_HL = skb->len - skb->data_len
 68                  *  r_D  = skb->data
 69                  */
 70                 PPC_LWZ_OFFS(r_scratch1, r_skb, offsetof(struct sk_buff,
 71                                                          data_len));
 72                 PPC_LWZ_OFFS(r_HL, r_skb, offsetof(struct sk_buff, len));
 73                 PPC_SUB(r_HL, r_HL, r_scratch1);
 74                 PPC_LD_OFFS(r_D, r_skb, offsetof(struct sk_buff, data));
 75         }
 76 
 77         if (ctx->seen & SEEN_XREG) {
 78                 /*
 79                  * TODO: Could also detect whether first instr. sets X and
 80                  * avoid this (as below, with A).
 81                  */
 82                 PPC_LI(r_X, 0);
 83         }
 84 
 85         switch (filter[0].code) {
 86         case BPF_S_RET_K:
 87         case BPF_S_LD_W_LEN:
 88         case BPF_S_ANC_PROTOCOL:
 89         case BPF_S_ANC_IFINDEX:
 90         case BPF_S_ANC_MARK:
 91         case BPF_S_ANC_RXHASH:
 92         case BPF_S_ANC_CPU:
 93         case BPF_S_ANC_QUEUE:
 94         case BPF_S_LD_W_ABS:
 95         case BPF_S_LD_H_ABS:
 96         case BPF_S_LD_B_ABS:
 97                 /* first instruction sets A register (or is RET 'constant') */
 98                 break;
 99         default:
100                 /* make sure we dont leak kernel information to user */
101                 PPC_LI(r_A, 0);
102         }
103 }
104 
105 static void bpf_jit_build_epilogue(u32 *image, struct codegen_context *ctx)
106 {
107         int i;
108 
109         if (ctx->seen & (SEEN_MEM | SEEN_DATAREF)) {
110                 PPC_ADDI(1, 1, BPF_PPC_STACKFRAME);
111                 if (ctx->seen & SEEN_DATAREF) {
112                         PPC_LD(0, 1, 16);
113                         PPC_MTLR(0);
114                         PPC_LD(r_D, 1, -(8*(32-r_D)));
115                         PPC_LD(r_HL, 1, -(8*(32-r_HL)));
116                 }
117                 if (ctx->seen & SEEN_MEM) {
118                         /* Restore any saved non-vol registers */
119                         for (i = r_M; i < (r_M+16); i++) {
120                                 if (ctx->seen & (1 << (i-r_M)))
121                                         PPC_LD(i, 1, -(8*(32-i)));
122                         }
123                 }
124         }
125         /* The RETs have left a return value in R3. */
126 
127         PPC_BLR();
128 }
129 
130 #define CHOOSE_LOAD_FUNC(K, func) \
131         ((int)K < 0 ? ((int)K >= SKF_LL_OFF ? func##_negative_offset : func) : func##_positive_offset)
132 
133 /* Assemble the body code between the prologue & epilogue. */
134 static int bpf_jit_build_body(struct sk_filter *fp, u32 *image,
135                               struct codegen_context *ctx,
136                               unsigned int *addrs)
137 {
138         const struct sock_filter *filter = fp->insns;
139         int flen = fp->len;
140         u8 *func;
141         unsigned int true_cond;
142         int i;
143 
144         /* Start of epilogue code */
145         unsigned int exit_addr = addrs[flen];
146 
147         for (i = 0; i < flen; i++) {
148                 unsigned int K = filter[i].k;
149 
150                 /*
151                  * addrs[] maps a BPF bytecode address into a real offset from
152                  * the start of the body code.
153                  */
154                 addrs[i] = ctx->idx * 4;
155 
156                 switch (filter[i].code) {
157                         /*** ALU ops ***/
158                 case BPF_S_ALU_ADD_X: /* A += X; */
159                         ctx->seen |= SEEN_XREG;
160                         PPC_ADD(r_A, r_A, r_X);
161                         break;
162                 case BPF_S_ALU_ADD_K: /* A += K; */
163                         if (!K)
164                                 break;
165                         PPC_ADDI(r_A, r_A, IMM_L(K));
166                         if (K >= 32768)
167                                 PPC_ADDIS(r_A, r_A, IMM_HA(K));
168                         break;
169                 case BPF_S_ALU_SUB_X: /* A -= X; */
170                         ctx->seen |= SEEN_XREG;
171                         PPC_SUB(r_A, r_A, r_X);
172                         break;
173                 case BPF_S_ALU_SUB_K: /* A -= K */
174                         if (!K)
175                                 break;
176                         PPC_ADDI(r_A, r_A, IMM_L(-K));
177                         if (K >= 32768)
178                                 PPC_ADDIS(r_A, r_A, IMM_HA(-K));
179                         break;
180                 case BPF_S_ALU_MUL_X: /* A *= X; */
181                         ctx->seen |= SEEN_XREG;
182                         PPC_MUL(r_A, r_A, r_X);
183                         break;
184                 case BPF_S_ALU_MUL_K: /* A *= K */
185                         if (K < 32768)
186                                 PPC_MULI(r_A, r_A, K);
187                         else {
188                                 PPC_LI32(r_scratch1, K);
189                                 PPC_MUL(r_A, r_A, r_scratch1);
190                         }
191                         break;
192                 case BPF_S_ALU_DIV_X: /* A /= X; */
193                         ctx->seen |= SEEN_XREG;
194                         PPC_CMPWI(r_X, 0);
195                         if (ctx->pc_ret0 != -1) {
196                                 PPC_BCC(COND_EQ, addrs[ctx->pc_ret0]);
197                         } else {
198                                 /*
199                                  * Exit, returning 0; first pass hits here
200                                  * (longer worst-case code size).
201                                  */
202                                 PPC_BCC_SHORT(COND_NE, (ctx->idx*4)+12);
203                                 PPC_LI(r_ret, 0);
204                                 PPC_JMP(exit_addr);
205                         }
206                         PPC_DIVWU(r_A, r_A, r_X);
207                         break;
208                 case BPF_S_ALU_DIV_K: /* A = reciprocal_divide(A, K); */
209                         PPC_LI32(r_scratch1, K);
210                         /* Top 32 bits of 64bit result -> A */
211                         PPC_MULHWU(r_A, r_A, r_scratch1);
212                         break;
213                 case BPF_S_ALU_AND_X:
214                         ctx->seen |= SEEN_XREG;
215                         PPC_AND(r_A, r_A, r_X);
216                         break;
217                 case BPF_S_ALU_AND_K:
218                         if (!IMM_H(K))
219                                 PPC_ANDI(r_A, r_A, K);
220                         else {
221                                 PPC_LI32(r_scratch1, K);
222                                 PPC_AND(r_A, r_A, r_scratch1);
223                         }
224                         break;
225                 case BPF_S_ALU_OR_X:
226                         ctx->seen |= SEEN_XREG;
227                         PPC_OR(r_A, r_A, r_X);
228                         break;
229                 case BPF_S_ALU_OR_K:
230                         if (IMM_L(K))
231                                 PPC_ORI(r_A, r_A, IMM_L(K));
232                         if (K >= 65536)
233                                 PPC_ORIS(r_A, r_A, IMM_H(K));
234                         break;
235                 case BPF_S_ALU_LSH_X: /* A <<= X; */
236                         ctx->seen |= SEEN_XREG;
237                         PPC_SLW(r_A, r_A, r_X);
238                         break;
239                 case BPF_S_ALU_LSH_K:
240                         if (K == 0)
241                                 break;
242                         else
243                                 PPC_SLWI(r_A, r_A, K);
244                         break;
245                 case BPF_S_ALU_RSH_X: /* A >>= X; */
246                         ctx->seen |= SEEN_XREG;
247                         PPC_SRW(r_A, r_A, r_X);
248                         break;
249                 case BPF_S_ALU_RSH_K: /* A >>= K; */
250                         if (K == 0)
251                                 break;
252                         else
253                                 PPC_SRWI(r_A, r_A, K);
254                         break;
255                 case BPF_S_ALU_NEG:
256                         PPC_NEG(r_A, r_A);
257                         break;
258                 case BPF_S_RET_K:
259                         PPC_LI32(r_ret, K);
260                         if (!K) {
261                                 if (ctx->pc_ret0 == -1)
262                                         ctx->pc_ret0 = i;
263                         }
264                         /*
265                          * If this isn't the very last instruction, branch to
266                          * the epilogue if we've stuff to clean up.  Otherwise,
267                          * if there's nothing to tidy, just return.  If we /are/
268                          * the last instruction, we're about to fall through to
269                          * the epilogue to return.
270                          */
271                         if (i != flen - 1) {
272                                 /*
273                                  * Note: 'seen' is properly valid only on pass
274                                  * #2.  Both parts of this conditional are the
275                                  * same instruction size though, meaning the
276                                  * first pass will still correctly determine the
277                                  * code size/addresses.
278                                  */
279                                 if (ctx->seen)
280                                         PPC_JMP(exit_addr);
281                                 else
282                                         PPC_BLR();
283                         }
284                         break;
285                 case BPF_S_RET_A:
286                         PPC_MR(r_ret, r_A);
287                         if (i != flen - 1) {
288                                 if (ctx->seen)
289                                         PPC_JMP(exit_addr);
290                                 else
291                                         PPC_BLR();
292                         }
293                         break;
294                 case BPF_S_MISC_TAX: /* X = A */
295                         PPC_MR(r_X, r_A);
296                         break;
297                 case BPF_S_MISC_TXA: /* A = X */
298                         ctx->seen |= SEEN_XREG;
299                         PPC_MR(r_A, r_X);
300                         break;
301 
302                         /*** Constant loads/M[] access ***/
303                 case BPF_S_LD_IMM: /* A = K */
304                         PPC_LI32(r_A, K);
305                         break;
306                 case BPF_S_LDX_IMM: /* X = K */
307                         PPC_LI32(r_X, K);
308                         break;
309                 case BPF_S_LD_MEM: /* A = mem[K] */
310                         PPC_MR(r_A, r_M + (K & 0xf));
311                         ctx->seen |= SEEN_MEM | (1<<(K & 0xf));
312                         break;
313                 case BPF_S_LDX_MEM: /* X = mem[K] */
314                         PPC_MR(r_X, r_M + (K & 0xf));
315                         ctx->seen |= SEEN_MEM | (1<<(K & 0xf));
316                         break;
317                 case BPF_S_ST: /* mem[K] = A */
318                         PPC_MR(r_M + (K & 0xf), r_A);
319                         ctx->seen |= SEEN_MEM | (1<<(K & 0xf));
320                         break;
321                 case BPF_S_STX: /* mem[K] = X */
322                         PPC_MR(r_M + (K & 0xf), r_X);
323                         ctx->seen |= SEEN_XREG | SEEN_MEM | (1<<(K & 0xf));
324                         break;
325                 case BPF_S_LD_W_LEN: /* A = skb->len; */
326                         BUILD_BUG_ON(FIELD_SIZEOF(struct sk_buff, len) != 4);
327                         PPC_LWZ_OFFS(r_A, r_skb, offsetof(struct sk_buff, len));
328                         break;
329                 case BPF_S_LDX_W_LEN: /* X = skb->len; */
330                         PPC_LWZ_OFFS(r_X, r_skb, offsetof(struct sk_buff, len));
331                         break;
332 
333                         /*** Ancillary info loads ***/
334 
335                         /* None of the BPF_S_ANC* codes appear to be passed by
336                          * sk_chk_filter().  The interpreter and the x86 BPF
337                          * compiler implement them so we do too -- they may be
338                          * planted in future.
339                          */
340                 case BPF_S_ANC_PROTOCOL: /* A = ntohs(skb->protocol); */
341                         BUILD_BUG_ON(FIELD_SIZEOF(struct sk_buff,
342                                                   protocol) != 2);
343                         PPC_LHZ_OFFS(r_A, r_skb, offsetof(struct sk_buff,
344                                                           protocol));
345                         /* ntohs is a NOP with BE loads. */
346                         break;
347                 case BPF_S_ANC_IFINDEX:
348                         PPC_LD_OFFS(r_scratch1, r_skb, offsetof(struct sk_buff,
349                                                                 dev));
350                         PPC_CMPDI(r_scratch1, 0);
351                         if (ctx->pc_ret0 != -1) {
352                                 PPC_BCC(COND_EQ, addrs[ctx->pc_ret0]);
353                         } else {
354                                 /* Exit, returning 0; first pass hits here. */
355                                 PPC_BCC_SHORT(COND_NE, (ctx->idx*4)+12);
356                                 PPC_LI(r_ret, 0);
357                                 PPC_JMP(exit_addr);
358                         }
359                         BUILD_BUG_ON(FIELD_SIZEOF(struct net_device,
360                                                   ifindex) != 4);
361                         PPC_LWZ_OFFS(r_A, r_scratch1,
362                                      offsetof(struct net_device, ifindex));
363                         break;
364                 case BPF_S_ANC_MARK:
365                         BUILD_BUG_ON(FIELD_SIZEOF(struct sk_buff, mark) != 4);
366                         PPC_LWZ_OFFS(r_A, r_skb, offsetof(struct sk_buff,
367                                                           mark));
368                         break;
369                 case BPF_S_ANC_RXHASH:
370                         BUILD_BUG_ON(FIELD_SIZEOF(struct sk_buff, rxhash) != 4);
371                         PPC_LWZ_OFFS(r_A, r_skb, offsetof(struct sk_buff,
372                                                           rxhash));
373                         break;
374                 case BPF_S_ANC_QUEUE:
375                         BUILD_BUG_ON(FIELD_SIZEOF(struct sk_buff,
376                                                   queue_mapping) != 2);
377                         PPC_LHZ_OFFS(r_A, r_skb, offsetof(struct sk_buff,
378                                                           queue_mapping));
379                         break;
380                 case BPF_S_ANC_CPU:
381 #ifdef CONFIG_SMP
382                         /*
383                          * PACA ptr is r13:
384                          * raw_smp_processor_id() = local_paca->paca_index
385                          */
386                         BUILD_BUG_ON(FIELD_SIZEOF(struct paca_struct,
387                                                   paca_index) != 2);
388                         PPC_LHZ_OFFS(r_A, 13,
389                                      offsetof(struct paca_struct, paca_index));
390 #else
391                         PPC_LI(r_A, 0);
392 #endif
393                         break;
394 
395                         /*** Absolute loads from packet header/data ***/
396                 case BPF_S_LD_W_ABS:
397                         func = CHOOSE_LOAD_FUNC(K, sk_load_word);
398                         goto common_load;
399                 case BPF_S_LD_H_ABS:
400                         func = CHOOSE_LOAD_FUNC(K, sk_load_half);
401                         goto common_load;
402                 case BPF_S_LD_B_ABS:
403                         func = CHOOSE_LOAD_FUNC(K, sk_load_byte);
404                 common_load:
405                         /* Load from [K]. */
406                         ctx->seen |= SEEN_DATAREF;
407                         PPC_LI64(r_scratch1, func);
408                         PPC_MTLR(r_scratch1);
409                         PPC_LI32(r_addr, K);
410                         PPC_BLRL();
411                         /*
412                          * Helper returns 'lt' condition on error, and an
413                          * appropriate return value in r3
414                          */
415                         PPC_BCC(COND_LT, exit_addr);
416                         break;
417 
418                         /*** Indirect loads from packet header/data ***/
419                 case BPF_S_LD_W_IND:
420                         func = sk_load_word;
421                         goto common_load_ind;
422                 case BPF_S_LD_H_IND:
423                         func = sk_load_half;
424                         goto common_load_ind;
425                 case BPF_S_LD_B_IND:
426                         func = sk_load_byte;
427                 common_load_ind:
428                         /*
429                          * Load from [X + K].  Negative offsets are tested for
430                          * in the helper functions.
431                          */
432                         ctx->seen |= SEEN_DATAREF | SEEN_XREG;
433                         PPC_LI64(r_scratch1, func);
434                         PPC_MTLR(r_scratch1);
435                         PPC_ADDI(r_addr, r_X, IMM_L(K));
436                         if (K >= 32768)
437                                 PPC_ADDIS(r_addr, r_addr, IMM_HA(K));
438                         PPC_BLRL();
439                         /* If error, cr0.LT set */
440                         PPC_BCC(COND_LT, exit_addr);
441                         break;
442 
443                 case BPF_S_LDX_B_MSH:
444                         func = CHOOSE_LOAD_FUNC(K, sk_load_byte_msh);
445                         goto common_load;
446                         break;
447 
448                         /*** Jump and branches ***/
449                 case BPF_S_JMP_JA:
450                         if (K != 0)
451                                 PPC_JMP(addrs[i + 1 + K]);
452                         break;
453 
454                 case BPF_S_JMP_JGT_K:
455                 case BPF_S_JMP_JGT_X:
456                         true_cond = COND_GT;
457                         goto cond_branch;
458                 case BPF_S_JMP_JGE_K:
459                 case BPF_S_JMP_JGE_X:
460                         true_cond = COND_GE;
461                         goto cond_branch;
462                 case BPF_S_JMP_JEQ_K:
463                 case BPF_S_JMP_JEQ_X:
464                         true_cond = COND_EQ;
465                         goto cond_branch;
466                 case BPF_S_JMP_JSET_K:
467                 case BPF_S_JMP_JSET_X:
468                         true_cond = COND_NE;
469                         /* Fall through */
470                 cond_branch:
471                         /* same targets, can avoid doing the test :) */
472                         if (filter[i].jt == filter[i].jf) {
473                                 if (filter[i].jt > 0)
474                                         PPC_JMP(addrs[i + 1 + filter[i].jt]);
475                                 break;
476                         }
477 
478                         switch (filter[i].code) {
479                         case BPF_S_JMP_JGT_X:
480                         case BPF_S_JMP_JGE_X:
481                         case BPF_S_JMP_JEQ_X:
482                                 ctx->seen |= SEEN_XREG;
483                                 PPC_CMPLW(r_A, r_X);
484                                 break;
485                         case BPF_S_JMP_JSET_X:
486                                 ctx->seen |= SEEN_XREG;
487                                 PPC_AND_DOT(r_scratch1, r_A, r_X);
488                                 break;
489                         case BPF_S_JMP_JEQ_K:
490                         case BPF_S_JMP_JGT_K:
491                         case BPF_S_JMP_JGE_K:
492                                 if (K < 32768)
493                                         PPC_CMPLWI(r_A, K);
494                                 else {
495                                         PPC_LI32(r_scratch1, K);
496                                         PPC_CMPLW(r_A, r_scratch1);
497                                 }
498                                 break;
499                         case BPF_S_JMP_JSET_K:
500                                 if (K < 32768)
501                                         /* PPC_ANDI is /only/ dot-form */
502                                         PPC_ANDI(r_scratch1, r_A, K);
503                                 else {
504                                         PPC_LI32(r_scratch1, K);
505                                         PPC_AND_DOT(r_scratch1, r_A,
506                                                     r_scratch1);
507                                 }
508                                 break;
509                         }
510                         /* Sometimes branches are constructed "backward", with
511                          * the false path being the branch and true path being
512                          * a fallthrough to the next instruction.
513                          */
514                         if (filter[i].jt == 0)
515                                 /* Swap the sense of the branch */
516                                 PPC_BCC(true_cond ^ COND_CMP_TRUE,
517                                         addrs[i + 1 + filter[i].jf]);
518                         else {
519                                 PPC_BCC(true_cond, addrs[i + 1 + filter[i].jt]);
520                                 if (filter[i].jf != 0)
521                                         PPC_JMP(addrs[i + 1 + filter[i].jf]);
522                         }
523                         break;
524                 default:
525                         /* The filter contains something cruel & unusual.
526                          * We don't handle it, but also there shouldn't be
527                          * anything missing from our list.
528                          */
529                         if (printk_ratelimit())
530                                 pr_err("BPF filter opcode %04x (@%d) unsupported\n",
531                                        filter[i].code, i);
532                         return -ENOTSUPP;
533                 }
534 
535         }
536         /* Set end-of-body-code address for exit. */
537         addrs[i] = ctx->idx * 4;
538 
539         return 0;
540 }
541 
542 void bpf_jit_compile(struct sk_filter *fp)
543 {
544         unsigned int proglen;
545         unsigned int alloclen;
546         u32 *image = NULL;
547         u32 *code_base;
548         unsigned int *addrs;
549         struct codegen_context cgctx;
550         int pass;
551         int flen = fp->len;
552 
553         if (!bpf_jit_enable)
554                 return;
555 
556         addrs = kzalloc((flen+1) * sizeof(*addrs), GFP_KERNEL);
557         if (addrs == NULL)
558                 return;
559 
560         /*
561          * There are multiple assembly passes as the generated code will change
562          * size as it settles down, figuring out the max branch offsets/exit
563          * paths required.
564          *
565          * The range of standard conditional branches is +/- 32Kbytes.  Since
566          * BPF_MAXINSNS = 4096, we can only jump from (worst case) start to
567          * finish with 8 bytes/instruction.  Not feasible, so long jumps are
568          * used, distinct from short branches.
569          *
570          * Current:
571          *
572          * For now, both branch types assemble to 2 words (short branches padded
573          * with a NOP); this is less efficient, but assembly will always complete
574          * after exactly 3 passes:
575          *
576          * First pass: No code buffer; Program is "faux-generated" -- no code
577          * emitted but maximum size of output determined (and addrs[] filled
578          * in).  Also, we note whether we use M[], whether we use skb data, etc.
579          * All generation choices assumed to be 'worst-case', e.g. branches all
580          * far (2 instructions), return path code reduction not available, etc.
581          *
582          * Second pass: Code buffer allocated with size determined previously.
583          * Prologue generated to support features we have seen used.  Exit paths
584          * determined and addrs[] is filled in again, as code may be slightly
585          * smaller as a result.
586          *
587          * Third pass: Code generated 'for real', and branch destinations
588          * determined from now-accurate addrs[] map.
589          *
590          * Ideal:
591          *
592          * If we optimise this, near branches will be shorter.  On the
593          * first assembly pass, we should err on the side of caution and
594          * generate the biggest code.  On subsequent passes, branches will be
595          * generated short or long and code size will reduce.  With smaller
596          * code, more branches may fall into the short category, and code will
597          * reduce more.
598          *
599          * Finally, if we see one pass generate code the same size as the
600          * previous pass we have converged and should now generate code for
601          * real.  Allocating at the end will also save the memory that would
602          * otherwise be wasted by the (small) current code shrinkage.
603          * Preferably, we should do a small number of passes (e.g. 5) and if we
604          * haven't converged by then, get impatient and force code to generate
605          * as-is, even if the odd branch would be left long.  The chances of a
606          * long jump are tiny with all but the most enormous of BPF filter
607          * inputs, so we should usually converge on the third pass.
608          */
609 
610         cgctx.idx = 0;
611         cgctx.seen = 0;
612         cgctx.pc_ret0 = -1;
613         /* Scouting faux-generate pass 0 */
614         if (bpf_jit_build_body(fp, 0, &cgctx, addrs))
615                 /* We hit something illegal or unsupported. */
616                 goto out;
617 
618         /*
619          * Pretend to build prologue, given the features we've seen.  This will
620          * update ctgtx.idx as it pretends to output instructions, then we can
621          * calculate total size from idx.
622          */
623         bpf_jit_build_prologue(fp, 0, &cgctx);
624         bpf_jit_build_epilogue(0, &cgctx);
625 
626         proglen = cgctx.idx * 4;
627         alloclen = proglen + FUNCTION_DESCR_SIZE;
628         image = module_alloc(max_t(unsigned int, alloclen,
629                                    sizeof(struct work_struct)));
630         if (!image)
631                 goto out;
632 
633         code_base = image + (FUNCTION_DESCR_SIZE/4);
634 
635         /* Code generation passes 1-2 */
636         for (pass = 1; pass < 3; pass++) {
637                 /* Now build the prologue, body code & epilogue for real. */
638                 cgctx.idx = 0;
639                 bpf_jit_build_prologue(fp, code_base, &cgctx);
640                 bpf_jit_build_body(fp, code_base, &cgctx, addrs);
641                 bpf_jit_build_epilogue(code_base, &cgctx);
642 
643                 if (bpf_jit_enable > 1)
644                         pr_info("Pass %d: shrink = %d, seen = 0x%x\n", pass,
645                                 proglen - (cgctx.idx * 4), cgctx.seen);
646         }
647 
648         if (bpf_jit_enable > 1)
649                 pr_info("flen=%d proglen=%u pass=%d image=%p\n",
650                        flen, proglen, pass, image);
651 
652         if (image) {
653                 if (bpf_jit_enable > 1)
654                         print_hex_dump(KERN_ERR, "JIT code: ",
655                                        DUMP_PREFIX_ADDRESS,
656                                        16, 1, code_base,
657                                        proglen, false);
658 
659                 bpf_flush_icache(code_base, code_base + (proglen/4));
660                 /* Function descriptor nastiness: Address + TOC */
661                 ((u64 *)image)[0] = (u64)code_base;
662                 ((u64 *)image)[1] = local_paca->kernel_toc;
663                 fp->bpf_func = (void *)image;
664         }
665 out:
666         kfree(addrs);
667         return;
668 }
669 
670 static void jit_free_defer(struct work_struct *arg)
671 {
672         module_free(NULL, arg);
673 }
674 
675 /* run from softirq, we must use a work_struct to call
676  * module_free() from process context
677  */
678 void bpf_jit_free(struct sk_filter *fp)
679 {
680         if (fp->bpf_func != sk_run_filter) {
681                 struct work_struct *work = (struct work_struct *)fp->bpf_func;
682 
683                 INIT_WORK(work, jit_free_defer);
684                 schedule_work(work);
685         }
686 }
687 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp