sim/bpf/bpf-helpers.c

   1 /* Emulation of eBPF helpers.
   2    Copyright (C) 2020-2021 Free Software Foundation, Inc.
   3
   4    This file is part of GDB, the GNU debugger.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 /* BPF programs rely on the existence of several helper functions,
  20    which are provided by the kernel.  This simulator provides an
  21    implementation of the helpers, which can be customized by the
  22    user.  */
  23
  24 /* This must come before any other includes.  */
  25 #include "defs.h"
  26
  27 #define WANT_CPU_BPFBF
  28 #define WANT_CPU bpfbf
  29
  30 #include "sim-main.h"
  31 #include "cgen-mem.h"
  32 #include "cgen-ops.h"
  33 #include "cpu.h"
  34
  35 /* bpf_trace_printk is a printk-like facility for debugging.
  36
  37    In the kernel, it appends a line to the Linux's tracing debugging
  38    interface.
  39
  40    In this simulator, it uses the simulator's tracing interface
  41    instead.
  42
  43    The format tags recognized by this helper are:
  44    %d, %i, %u, %x, %ld, %li, %lu, %lx, %lld, %lli, %llu, %llx,
  45    %p, %s
  46
  47    A maximum of three tags are supported.
  48
  49    This helper returns the number of bytes written, or a negative
  50    value in case of failure.  */
  51
  52 int
  53 bpf_trace_printk (SIM_CPU *current_cpu)
  54 {
  55   va_list ap;
  56   SIM_DESC sd = CPU_STATE (current_cpu);
  57
  58   DI fmt_address;
  59   uint32_t size, tags_processed;
  60   size_t i, bytes_written = 0;
  61
  62   /* The first argument is the format string, which is passed as a
  63      pointer in %r1.  */
  64   fmt_address = GET_H_GPR (1);
  65
  66   /* The second argument is the length of the format string, as an
  67      unsigned 32-bit number in %r2.  */
  68   size = GET_H_GPR (2);
  69
  70   /* Read the format string from the memory pointed by %r2, printing
  71      out the stuff as we go.  There is a maximum of three format tags
  72      supported, which are read from %r3, %r4 and %r5 respectively.  */
  73   for (i = 0, tags_processed = 0; i < size;)
  74     {
  75       UDI value;
  76       QI c = GETMEMUQI (current_cpu, CPU_PC_GET (current_cpu),
  77                         fmt_address + i);
  78
  79       switch (c)
  80         {
  81         case '%':
  82           /* Check we are not exceeding the limit of three format
  83              tags.  */
  84           if (tags_processed > 2)
  85             return -1; /* XXX look for kernel error code.  */
  86
  87           /* Depending on the kind of tag, extract the value from the
  88              proper argument.  */
  89           if (i++ >= size)
  90             return -1; /* XXX look for kernel error code.  */
  91
  92           value = GET_H_GPR (3 + tags_processed);
  93
  94           switch ((GETMEMUQI (current_cpu, CPU_PC_GET (current_cpu),
  95                              fmt_address + i)))
  96             {
  97             case 'd':
  98               trace_printf (sd, current_cpu, "%d", value);
  99               break;
 100             case 'i':
 101               trace_printf (sd, current_cpu, "%i", value);
 102               break;
 103             case 'u':
 104               trace_printf (sd, current_cpu, "%u", value);
 105               break;
 106             case 'x':
 107               trace_printf (sd, current_cpu, "%x", value);
 108               break;
 109             case 'l':
 110               {
 111                 if (i++ >= size)
 112                   return -1;
 113                 switch (GETMEMUQI (current_cpu, CPU_PC_GET (current_cpu),
 114                              fmt_address + i))
 115                   {
 116                   case 'd':
 117                     trace_printf (sd, current_cpu, "%ld", value);
 118                     break;
 119                   case 'i':
 120                     trace_printf (sd, current_cpu, "%li", value);
 121                     break;
 122                   case 'u':
 123                     trace_printf (sd, current_cpu, "%lu", value);
 124                     break;
 125                   case 'x':
 126                     trace_printf (sd, current_cpu, "%lx", value);
 127                     break;
 128                   case 'l':
 129                     {
 130                       if (i++ >= size)
 131                         return -1;
 132                       switch (GETMEMUQI (current_cpu, CPU_PC_GET (current_cpu),
 133                                 fmt_address + i)) {
 134                         case 'd':
 135                           trace_printf (sd, current_cpu, "%lld", value);
 136                           break;
 137                         case 'i':
 138                           trace_printf (sd, current_cpu, "%lli", value);
 139                           break;
 140                         case 'u':
 141                           trace_printf (sd, current_cpu, "%llu", value);
 142                           break;
 143                         case 'x':
 144                           trace_printf (sd, current_cpu, "%llx", value);
 145                           break;
 146                         default:
 147                           assert (0);
 148                           break;
 149                       }
 150                       break;
 151                     }
 152                   default:
 153                     assert (0);
 154                     break;
 155                 }
 156                 break;
 157               }
 158             default:
 159               /* XXX completeme */
 160               assert (0);
 161               break;
 162             }
 163
 164           tags_processed++;
 165           i++;
 166           break;
 167         case '\0':
 168           i = size;
 169           break;
 170         default:
 171           trace_printf (sd, current_cpu, "%c", c);
 172           bytes_written++;
 173           i++;
 174           break;
 175         }
 176     }
 177
 178   return bytes_written;
 179 }