kernel/trace/trace_probe_tmpl.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * Traceprobe fetch helper inlines
   4  */
   5
   6 static nokprobe_inline void
   7 fetch_store_raw(unsigned long val, struct fetch_insn *code, void *buf)
   8 {
   9         switch (code->size) {
  10         case 1:
  11                 *(u8 *)buf = (u8)val;
  12                 break;
  13         case 2:
  14                 *(u16 *)buf = (u16)val;
  15                 break;
  16         case 4:
  17                 *(u32 *)buf = (u32)val;
  18                 break;
  19         case 8:
  20                 //TBD: 32bit signed
  21                 *(u64 *)buf = (u64)val;
  22                 break;
  23         default:
  24                 *(unsigned long *)buf = val;
  25         }
  26 }
  27
  28 static nokprobe_inline void
  29 fetch_apply_bitfield(struct fetch_insn *code, void *buf)
  30 {
  31         switch (code->basesize) {
  32         case 1:
  33                 *(u8 *)buf <<= code->lshift;
  34                 *(u8 *)buf >>= code->rshift;
  35                 break;
  36         case 2:
  37                 *(u16 *)buf <<= code->lshift;
  38                 *(u16 *)buf >>= code->rshift;
  39                 break;
  40         case 4:
  41                 *(u32 *)buf <<= code->lshift;
  42                 *(u32 *)buf >>= code->rshift;
  43                 break;
  44         case 8:
  45                 *(u64 *)buf <<= code->lshift;
  46                 *(u64 *)buf >>= code->rshift;
  47                 break;
  48         }
  49 }
  50
  51 /*
  52  * These functions must be defined for each callsite.
  53  * Return consumed dynamic data size (>= 0), or error (< 0).
  54  * If dest is NULL, don't store result and return required dynamic data size.
  55  */
  56 static int
  57 process_fetch_insn(struct fetch_insn *code, struct pt_regs *regs,
  58                    void *dest, void *base);
  59 static nokprobe_inline int fetch_store_strlen(unsigned long addr);
  60 static nokprobe_inline int
  61 fetch_store_string(unsigned long addr, void *dest, void *base);
  62 static nokprobe_inline int
  63 probe_mem_read(void *dest, void *src, size_t size);
  64
  65 /* From the 2nd stage, routine is same */
  66 static nokprobe_inline int
  67 process_fetch_insn_bottom(struct fetch_insn *code, unsigned long val,
  68                            void *dest, void *base)
  69 {
  70         struct fetch_insn *s3 = NULL;
  71         int total = 0, ret = 0, i = 0;
  72         u32 loc = 0;
  73         unsigned long lval = val;
  74
  75 stage2:
  76         /* 2nd stage: dereference memory if needed */
  77         while (code->op == FETCH_OP_DEREF) {
  78                 lval = val;
  79                 ret = probe_mem_read(&val, (void *)val + code->offset,
  80                                         sizeof(val));
  81                 if (ret)
  82                         return ret;
  83                 code++;
  84         }
  85
  86         s3 = code;
  87 stage3:
  88         /* 3rd stage: store value to buffer */
  89         if (unlikely(!dest)) {
  90                 if (code->op == FETCH_OP_ST_STRING) {
  91                         ret = fetch_store_strlen(val + code->offset);
  92                         code++;
  93                         goto array;
  94                 } else
  95                         return -EILSEQ;
  96         }
  97
  98         switch (code->op) {
  99         case FETCH_OP_ST_RAW:
 100                 fetch_store_raw(val, code, dest);
 101                 break;
 102         case FETCH_OP_ST_MEM:
 103                 probe_mem_read(dest, (void *)val + code->offset, code->size);
 104                 break;
 105         case FETCH_OP_ST_STRING:
 106                 loc = *(u32 *)dest;
 107                 ret = fetch_store_string(val + code->offset, dest, base);
 108                 break;
 109         default:
 110                 return -EILSEQ;
 111         }
 112         code++;
 113
 114         /* 4th stage: modify stored value if needed */
 115         if (code->op == FETCH_OP_MOD_BF) {
 116                 fetch_apply_bitfield(code, dest);
 117                 code++;
 118         }
 119
 120 array:
 121         /* the last stage: Loop on array */
 122         if (code->op == FETCH_OP_LP_ARRAY) {
 123                 total += ret;
 124                 if (++i < code->param) {
 125                         code = s3;
 126                         if (s3->op != FETCH_OP_ST_STRING) {
 127                                 dest += s3->size;
 128                                 val += s3->size;
 129                                 goto stage3;
 130                         }
 131                         code--;
 132                         val = lval + sizeof(char *);
 133                         if (dest) {
 134                                 dest += sizeof(u32);
 135                                 *(u32 *)dest = update_data_loc(loc, ret);
 136                         }
 137                         goto stage2;
 138                 }
 139                 code++;
 140                 ret = total;
 141         }
 142
 143         return code->op == FETCH_OP_END ? ret : -EILSEQ;
 144 }
 145
 146 /* Sum up total data length for dynamic arraies (strings) */
 147 static nokprobe_inline int
 148 __get_data_size(struct trace_probe *tp, struct pt_regs *regs)
 149 {
 150         struct probe_arg *arg;
 151         int i, len, ret = 0;
 152
 153         for (i = 0; i < tp->nr_args; i++) {
 154                 arg = tp->args + i;
 155                 if (unlikely(arg->dynamic)) {
 156                         len = process_fetch_insn(arg->code, regs, NULL, NULL);
 157                         if (len > 0)
 158                                 ret += len;
 159                 }
 160         }
 161
 162         return ret;
 163 }
 164
 165 /* Store the value of each argument */
 166 static nokprobe_inline void
 167 store_trace_args(void *data, struct trace_probe *tp, struct pt_regs *regs,
 168                  int header_size, int maxlen)
 169 {
 170         struct probe_arg *arg;
 171         void *base = data - header_size;
 172         void *dyndata = data + tp->size;
 173         u32 *dl;        /* Data location */
 174         int ret, i;
 175
 176         for (i = 0; i < tp->nr_args; i++) {
 177                 arg = tp->args + i;
 178                 dl = data + arg->offset;
 179                 /* Point the dynamic data area if needed */
 180                 if (unlikely(arg->dynamic))
 181                         *dl = make_data_loc(maxlen, dyndata - base);
 182                 ret = process_fetch_insn(arg->code, regs, dl, base);
 183                 if (unlikely(ret < 0 && arg->dynamic)) {
 184                         *dl = make_data_loc(0, dyndata - base);
 185                 } else {
 186                         dyndata += ret;
 187                         maxlen -= ret;
 188                 }
 189         }
 190 }
 191
 192 static inline int
 193 print_probe_args(struct trace_seq *s, struct probe_arg *args, int nr_args,
 194                  u8 *data, void *field)
 195 {
 196         void *p;
 197         int i, j;
 198
 199         for (i = 0; i < nr_args; i++) {
 200                 struct probe_arg *a = args + i;
 201
 202                 trace_seq_printf(s, " %s=", a->name);
 203                 if (likely(!a->count)) {
 204                         if (!a->type->print(s, data + a->offset, field))
 205                                 return -ENOMEM;
 206                         continue;
 207                 }
 208                 trace_seq_putc(s, '{');
 209                 p = data + a->offset;
 210                 for (j = 0; j < a->count; j++) {
 211                         if (!a->type->print(s, p, field))
 212                                 return -ENOMEM;
 213                         trace_seq_putc(s, j == a->count - 1 ? '}' : ',');
 214                         p += a->type->size;
 215                 }
 216         }
 217         return 0;
 218 }