lttng-filter-specialize.c

   1 /*
   2  * lttng-filter-specialize.c
   3  *
   4  * LTTng modules filter code specializer.
   5  *
   6  * Copyright (C) 2010-2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a copy
   9  * of this software and associated documentation files (the "Software"), to deal
  10  * in the Software without restriction, including without limitation the rights
  11  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  12  * copies of the Software, and to permit persons to whom the Software is
  13  * furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included in
  16  * all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  21  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  23  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  24  * SOFTWARE.
  25  */
  26
  27 #include <linux/slab.h>
  28 #include <lttng-filter.h>
  29 #include "lib/align.h"
  30
  31 static ssize_t bytecode_reserve_data(struct bytecode_runtime *runtime,
  32                 size_t align, size_t len)
  33 {
  34         ssize_t ret;
  35         size_t padding = offset_align(runtime->data_len, align);
  36         size_t new_len = runtime->data_len + padding + len;
  37         size_t new_alloc_len = new_len;
  38         size_t old_alloc_len = runtime->data_alloc_len;
  39
  40         if (new_len > FILTER_MAX_DATA_LEN)
  41                 return -EINVAL;
  42
  43         if (new_alloc_len > old_alloc_len) {
  44                 char *newptr;
  45
  46                 new_alloc_len =
  47                         max_t(size_t, 1U << get_count_order(new_alloc_len), old_alloc_len << 1);
  48                 newptr = krealloc(runtime->data, new_alloc_len, GFP_KERNEL);
  49                 if (!newptr)
  50                         return -ENOMEM;
  51                 runtime->data = newptr;
  52                 /* We zero directly the memory from start of allocation. */
  53                 memset(&runtime->data[old_alloc_len], 0, new_alloc_len - old_alloc_len);
  54                 runtime->data_alloc_len = new_alloc_len;
  55         }
  56         runtime->data_len += padding;
  57         ret = runtime->data_len;
  58         runtime->data_len += len;
  59         return ret;
  60 }
  61
  62 static ssize_t bytecode_push_data(struct bytecode_runtime *runtime,
  63                 const void *p, size_t align, size_t len)
  64 {
  65         ssize_t offset;
  66
  67         offset = bytecode_reserve_data(runtime, align, len);
  68         if (offset < 0)
  69                 return -ENOMEM;
  70         memcpy(&runtime->data[offset], p, len);
  71         return offset;
  72 }
  73
  74 static int specialize_load_field(struct vstack_entry *stack_top,
  75                 struct load_op *insn)
  76 {
  77         int ret;
  78
  79         switch (stack_top->load.type) {
  80         case LOAD_OBJECT:
  81                 break;
  82         case LOAD_ROOT_CONTEXT:
  83         case LOAD_ROOT_APP_CONTEXT:
  84         case LOAD_ROOT_PAYLOAD:
  85         default:
  86                 dbg_printk("Filter warning: cannot load root, missing field name.\n");
  87                 ret = -EINVAL;
  88                 goto end;
  89         }
  90         switch (stack_top->load.object_type) {
  91         case OBJECT_TYPE_S8:
  92                 dbg_printk("op load field s8\n");
  93                 stack_top->type = REG_S64;
  94                 if (!stack_top->load.rev_bo)
  95                         insn->op = FILTER_OP_LOAD_FIELD_S8;
  96                 break;
  97         case OBJECT_TYPE_S16:
  98                 dbg_printk("op load field s16\n");
  99                 stack_top->type = REG_S64;
 100                 if (!stack_top->load.rev_bo)
 101                         insn->op = FILTER_OP_LOAD_FIELD_S16;
 102                 break;
 103         case OBJECT_TYPE_S32:
 104                 dbg_printk("op load field s32\n");
 105                 stack_top->type = REG_S64;
 106                 if (!stack_top->load.rev_bo)
 107                         insn->op = FILTER_OP_LOAD_FIELD_S32;
 108                 break;
 109         case OBJECT_TYPE_S64:
 110                 dbg_printk("op load field s64\n");
 111                 stack_top->type = REG_S64;
 112                 if (!stack_top->load.rev_bo)
 113                         insn->op = FILTER_OP_LOAD_FIELD_S64;
 114                 break;
 115         case OBJECT_TYPE_U8:
 116                 dbg_printk("op load field u8\n");
 117                 stack_top->type = REG_S64;
 118                 insn->op = FILTER_OP_LOAD_FIELD_U8;
 119                 break;
 120         case OBJECT_TYPE_U16:
 121                 dbg_printk("op load field u16\n");
 122                 stack_top->type = REG_S64;
 123                 if (!stack_top->load.rev_bo)
 124                         insn->op = FILTER_OP_LOAD_FIELD_U16;
 125                 break;
 126         case OBJECT_TYPE_U32:
 127                 dbg_printk("op load field u32\n");
 128                 stack_top->type = REG_S64;
 129                 if (!stack_top->load.rev_bo)
 130                         insn->op = FILTER_OP_LOAD_FIELD_U32;
 131                 break;
 132         case OBJECT_TYPE_U64:
 133                 dbg_printk("op load field u64\n");
 134                 stack_top->type = REG_S64;
 135                 if (!stack_top->load.rev_bo)
 136                         insn->op = FILTER_OP_LOAD_FIELD_U64;
 137                 break;
 138         case OBJECT_TYPE_DOUBLE:
 139                 printk(KERN_WARNING "Double type unsupported\n\n");
 140                 ret = -EINVAL;
 141                 goto end;
 142         case OBJECT_TYPE_STRING:
 143                 dbg_printk("op load field string\n");
 144                 stack_top->type = REG_STRING;
 145                 insn->op = FILTER_OP_LOAD_FIELD_STRING;
 146                 break;
 147         case OBJECT_TYPE_STRING_SEQUENCE:
 148                 dbg_printk("op load field string sequence\n");
 149                 stack_top->type = REG_STRING;
 150                 insn->op = FILTER_OP_LOAD_FIELD_SEQUENCE;
 151                 break;
 152         case OBJECT_TYPE_DYNAMIC:
 153                 ret = -EINVAL;
 154                 goto end;
 155         case OBJECT_TYPE_SEQUENCE:
 156         case OBJECT_TYPE_ARRAY:
 157         case OBJECT_TYPE_STRUCT:
 158         case OBJECT_TYPE_VARIANT:
 159                 printk(KERN_WARNING "Sequences, arrays, struct and variant cannot be loaded (nested types).\n");
 160                 ret = -EINVAL;
 161                 goto end;
 162         }
 163         return 0;
 164
 165 end:
 166         return ret;
 167 }
 168
 169 static int specialize_get_index_object_type(enum object_type *otype,
 170                 int signedness, uint32_t elem_len)
 171 {
 172         switch (elem_len) {
 173         case 8:
 174                 if (signedness)
 175                         *otype = OBJECT_TYPE_S8;
 176                 else
 177                         *otype = OBJECT_TYPE_U8;
 178                 break;
 179         case 16:
 180                 if (signedness)
 181                         *otype = OBJECT_TYPE_S16;
 182                 else
 183                         *otype = OBJECT_TYPE_U16;
 184                 break;
 185         case 32:
 186                 if (signedness)
 187                         *otype = OBJECT_TYPE_S32;
 188                 else
 189                         *otype = OBJECT_TYPE_U32;
 190                 break;
 191         case 64:
 192                 if (signedness)
 193                         *otype = OBJECT_TYPE_S64;
 194                 else
 195                         *otype = OBJECT_TYPE_U64;
 196                 break;
 197         default:
 198                 return -EINVAL;
 199         }
 200         return 0;
 201 }
 202
 203 static int specialize_get_index(struct bytecode_runtime *runtime,
 204                 struct load_op *insn, uint64_t index,
 205                 struct vstack_entry *stack_top,
 206                 int idx_len)
 207 {
 208         int ret;
 209         struct filter_get_index_data gid;
 210         ssize_t data_offset;
 211
 212         memset(&gid, 0, sizeof(gid));
 213         switch (stack_top->load.type) {
 214         case LOAD_OBJECT:
 215                 switch (stack_top->load.object_type) {
 216                 case OBJECT_TYPE_ARRAY:
 217                 {
 218                         const struct lttng_event_field *field;
 219                         uint32_t elem_len, num_elems;
 220                         int signedness;
 221
 222                         field = stack_top->load.field;
 223                         elem_len = field->type.u.array.elem_type.u.basic.integer.size;
 224                         signedness = field->type.u.array.elem_type.u.basic.integer.signedness;
 225                         num_elems = field->type.u.array.length;
 226                         if (index >= num_elems) {
 227                                 ret = -EINVAL;
 228                                 goto end;
 229                         }
 230                         ret = specialize_get_index_object_type(&stack_top->load.object_type,
 231                                         signedness, elem_len);
 232                         if (ret)
 233                                 goto end;
 234                         gid.offset = index * (elem_len / CHAR_BIT);
 235                         gid.array_len = num_elems * (elem_len / CHAR_BIT);
 236                         gid.elem.type = stack_top->load.object_type;
 237                         gid.elem.len = elem_len;
 238                         if (field->type.u.array.elem_type.u.basic.integer.reverse_byte_order)
 239                                 gid.elem.rev_bo = true;
 240                         stack_top->load.rev_bo = gid.elem.rev_bo;
 241                         break;
 242                 }
 243                 case OBJECT_TYPE_SEQUENCE:
 244                 {
 245                         const struct lttng_event_field *field;
 246                         uint32_t elem_len;
 247                         int signedness;
 248
 249                         field = stack_top->load.field;
 250                         elem_len = field->type.u.sequence.elem_type.u.basic.integer.size;
 251                         signedness = field->type.u.sequence.elem_type.u.basic.integer.signedness;
 252                         ret = specialize_get_index_object_type(&stack_top->load.object_type,
 253                                         signedness, elem_len);
 254                         if (ret)
 255                                 goto end;
 256                         gid.offset = index * (elem_len / CHAR_BIT);
 257                         gid.elem.type = stack_top->load.object_type;
 258                         gid.elem.len = elem_len;
 259                         if (field->type.u.sequence.elem_type.u.basic.integer.reverse_byte_order)
 260                                 gid.elem.rev_bo = true;
 261                         stack_top->load.rev_bo = gid.elem.rev_bo;
 262                         break;
 263                 }
 264                 case OBJECT_TYPE_STRUCT:
 265                         /* Only generated by the specialize phase. */
 266                 case OBJECT_TYPE_VARIANT:       /* Fall-through */
 267                 default:
 268                         printk(KERN_WARNING "Unexpected get index type %d",
 269                                 (int) stack_top->load.object_type);
 270                         ret = -EINVAL;
 271                         goto end;
 272                 }
 273                 break;
 274         case LOAD_ROOT_CONTEXT:
 275         case LOAD_ROOT_APP_CONTEXT:
 276         case LOAD_ROOT_PAYLOAD:
 277                 printk(KERN_WARNING "Index lookup for root field not implemented yet.\n");
 278                 ret = -EINVAL;
 279                 goto end;
 280         }
 281         data_offset = bytecode_push_data(runtime, &gid,
 282                 __alignof__(gid), sizeof(gid));
 283         if (data_offset < 0) {
 284                 ret = -EINVAL;
 285                 goto end;
 286         }
 287         switch (idx_len) {
 288         case 2:
 289                 ((struct get_index_u16 *) insn->data)->index = data_offset;
 290                 break;
 291         case 8:
 292                 ((struct get_index_u64 *) insn->data)->index = data_offset;
 293                 break;
 294         default:
 295                 ret = -EINVAL;
 296                 goto end;
 297         }
 298
 299         return 0;
 300
 301 end:
 302         return ret;
 303 }
 304
 305 static int specialize_context_lookup_name(struct bytecode_runtime *bytecode,
 306                 struct load_op *insn)
 307 {
 308         uint16_t offset;
 309         const char *name;
 310
 311         offset = ((struct get_symbol *) insn->data)->offset;
 312         name = bytecode->p.bc->bc.data + bytecode->p.bc->bc.reloc_offset + offset;
 313         return lttng_get_context_index(lttng_static_ctx, name);
 314 }
 315
 316 static int specialize_load_object(const struct lttng_event_field *field,
 317                 struct vstack_load *load, bool is_context)
 318 {
 319         load->type = LOAD_OBJECT;
 320         /*
 321          * LTTng-UST layout all integer fields as s64 on the stack for the filter.
 322          */
 323         switch (field->type.atype) {
 324         case atype_integer:
 325                 if (field->type.u.basic.integer.signedness)
 326                         load->object_type = OBJECT_TYPE_S64;
 327                 else
 328                         load->object_type = OBJECT_TYPE_U64;
 329                 load->rev_bo = false;
 330                 break;
 331         case atype_enum:
 332         {
 333                 const struct lttng_integer_type *itype =
 334                         &field->type.u.basic.enumeration.container_type;
 335
 336                 if (itype->signedness)
 337                         load->object_type = OBJECT_TYPE_S64;
 338                 else
 339                         load->object_type = OBJECT_TYPE_U64;
 340                 load->rev_bo = false;
 341                 break;
 342         }
 343         case atype_array:
 344                 if (field->type.u.array.elem_type.atype != atype_integer) {
 345                         printk(KERN_WARNING "Array nesting only supports integer types.\n");
 346                         return -EINVAL;
 347                 }
 348                 if (is_context) {
 349                         load->object_type = OBJECT_TYPE_STRING;
 350                 } else {
 351                         if (field->type.u.array.elem_type.u.basic.integer.encoding == lttng_encode_none) {
 352                                 load->object_type = OBJECT_TYPE_ARRAY;
 353                                 load->field = field;
 354                         } else {
 355                                 load->object_type = OBJECT_TYPE_STRING_SEQUENCE;
 356                         }
 357                 }
 358                 break;
 359         case atype_sequence:
 360                 if (field->type.u.sequence.elem_type.atype != atype_integer) {
 361                         printk(KERN_WARNING "Sequence nesting only supports integer types.\n");
 362                         return -EINVAL;
 363                 }
 364                 if (is_context) {
 365                         load->object_type = OBJECT_TYPE_STRING;
 366                 } else {
 367                         if (field->type.u.sequence.elem_type.u.basic.integer.encoding == lttng_encode_none) {
 368                                 load->object_type = OBJECT_TYPE_SEQUENCE;
 369                                 load->field = field;
 370                         } else {
 371                                 load->object_type = OBJECT_TYPE_STRING_SEQUENCE;
 372                         }
 373                 }
 374                 break;
 375         case atype_array_bitfield:
 376                 printk(KERN_WARNING "Bitfield array type is not supported.\n");
 377                 return -EINVAL;
 378         case atype_sequence_bitfield:
 379                 printk(KERN_WARNING "Bitfield sequence type is not supported.\n");
 380                 return -EINVAL;
 381         case atype_string:
 382                 load->object_type = OBJECT_TYPE_STRING;
 383                 break;
 384         case atype_struct:
 385                 printk(KERN_WARNING "Structure type cannot be loaded.\n");
 386                 return -EINVAL;
 387         default:
 388                 printk(KERN_WARNING "Unknown type: %d", (int) field->type.atype);
 389                 return -EINVAL;
 390         }
 391         return 0;
 392 }
 393
 394 static int specialize_context_lookup(struct bytecode_runtime *runtime,
 395                 struct load_op *insn,
 396                 struct vstack_load *load)
 397 {
 398         int idx, ret;
 399         struct lttng_ctx_field *ctx_field;
 400         struct lttng_event_field *field;
 401         struct filter_get_index_data gid;
 402         ssize_t data_offset;
 403
 404         idx = specialize_context_lookup_name(runtime, insn);
 405         if (idx < 0) {
 406                 return -ENOENT;
 407         }
 408         ctx_field = &lttng_static_ctx->fields[idx];
 409         field = &ctx_field->event_field;
 410         ret = specialize_load_object(field, load, true);
 411         if (ret)
 412                 return ret;
 413         /* Specialize each get_symbol into a get_index. */
 414         insn->op = FILTER_OP_GET_INDEX_U16;
 415         memset(&gid, 0, sizeof(gid));
 416         gid.ctx_index = idx;
 417         gid.elem.type = load->object_type;
 418         data_offset = bytecode_push_data(runtime, &gid,
 419                 __alignof__(gid), sizeof(gid));
 420         if (data_offset < 0) {
 421                 return -EINVAL;
 422         }
 423         ((struct get_index_u16 *) insn->data)->index = data_offset;
 424         return 0;
 425 }
 426
 427 static int specialize_event_payload_lookup(struct lttng_event *event,
 428                 struct bytecode_runtime *runtime,
 429                 struct load_op *insn,
 430                 struct vstack_load *load)
 431 {
 432         const char *name;
 433         uint16_t offset;
 434         const struct lttng_event_desc *desc = event->desc;
 435         unsigned int i, nr_fields;
 436         bool found = false;
 437         uint32_t field_offset = 0;
 438         const struct lttng_event_field *field;
 439         int ret;
 440         struct filter_get_index_data gid;
 441         ssize_t data_offset;
 442
 443         nr_fields = desc->nr_fields;
 444         offset = ((struct get_symbol *) insn->data)->offset;
 445         name = runtime->p.bc->bc.data + runtime->p.bc->bc.reloc_offset + offset;
 446         for (i = 0; i < nr_fields; i++) {
 447                 field = &desc->fields[i];
 448                 if (!strcmp(field->name, name)) {
 449                         found = true;
 450                         break;
 451                 }
 452                 /* compute field offset on stack */
 453                 switch (field->type.atype) {
 454                 case atype_integer:
 455                 case atype_enum:
 456                         field_offset += sizeof(int64_t);
 457                         break;
 458                 case atype_array:
 459                 case atype_sequence:
 460                 case atype_array_bitfield:
 461                 case atype_sequence_bitfield:
 462                         field_offset += sizeof(unsigned long);
 463                         field_offset += sizeof(void *);
 464                         break;
 465                 case atype_string:
 466                         field_offset += sizeof(void *);
 467                         break;
 468                 default:
 469                         ret = -EINVAL;
 470                         goto end;
 471                 }
 472         }
 473         if (!found) {
 474                 ret = -EINVAL;
 475                 goto end;
 476         }
 477
 478         ret = specialize_load_object(field, load, false);
 479         if (ret)
 480                 goto end;
 481
 482         /* Specialize each get_symbol into a get_index. */
 483         insn->op = FILTER_OP_GET_INDEX_U16;
 484         memset(&gid, 0, sizeof(gid));
 485         gid.offset = field_offset;
 486         gid.elem.type = load->object_type;
 487         data_offset = bytecode_push_data(runtime, &gid,
 488                 __alignof__(gid), sizeof(gid));
 489         if (data_offset < 0) {
 490                 ret = -EINVAL;
 491                 goto end;
 492         }
 493         ((struct get_index_u16 *) insn->data)->index = data_offset;
 494         ret = 0;
 495 end:
 496         return ret;
 497 }
 498
 499 int lttng_filter_specialize_bytecode(struct lttng_event *event,
 500                 struct bytecode_runtime *bytecode)
 501 {
 502         void *pc, *next_pc, *start_pc;
 503         int ret = -EINVAL;
 504         struct vstack _stack;
 505         struct vstack *stack = &_stack;
 506
 507         vstack_init(stack);
 508
 509         start_pc = &bytecode->code[0];
 510         for (pc = next_pc = start_pc; pc - start_pc < bytecode->len;
 511                         pc = next_pc) {
 512                 switch (*(filter_opcode_t *) pc) {
 513                 case FILTER_OP_UNKNOWN:
 514                 default:
 515                         printk(KERN_WARNING "unknown bytecode op %u\n",
 516                                 (unsigned int) *(filter_opcode_t *) pc);
 517                         ret = -EINVAL;
 518                         goto end;
 519
 520                 case FILTER_OP_RETURN:
 521                         ret = 0;
 522                         goto end;
 523
 524                 /* binary */
 525                 case FILTER_OP_MUL:
 526                 case FILTER_OP_DIV:
 527                 case FILTER_OP_MOD:
 528                 case FILTER_OP_PLUS:
 529                 case FILTER_OP_MINUS:
 530                         printk(KERN_WARNING "unsupported bytecode op %u\n",
 531                                 (unsigned int) *(filter_opcode_t *) pc);
 532                         ret = -EINVAL;
 533                         goto end;
 534
 535                 case FILTER_OP_EQ:
 536                 {
 537                         struct binary_op *insn = (struct binary_op *) pc;
 538
 539                         switch(vstack_ax(stack)->type) {
 540                         default:
 541                                 printk(KERN_WARNING "unknown register type\n");
 542                                 ret = -EINVAL;
 543                                 goto end;
 544
 545                         case REG_STRING:
 546                                 if (vstack_bx(stack)->type == REG_STAR_GLOB_STRING)
 547                                         insn->op = FILTER_OP_EQ_STAR_GLOB_STRING;
 548                                 else
 549                                         insn->op = FILTER_OP_EQ_STRING;
 550                                 break;
 551                         case REG_STAR_GLOB_STRING:
 552                                 insn->op = FILTER_OP_EQ_STAR_GLOB_STRING;
 553                                 break;
 554                         case REG_S64:
 555                                 if (vstack_bx(stack)->type == REG_S64)
 556                                         insn->op = FILTER_OP_EQ_S64;
 557                                 else
 558                                         insn->op = FILTER_OP_EQ_DOUBLE_S64;
 559                                 break;
 560                         case REG_DOUBLE:
 561                                 if (vstack_bx(stack)->type == REG_S64)
 562                                         insn->op = FILTER_OP_EQ_S64_DOUBLE;
 563                                 else
 564                                         insn->op = FILTER_OP_EQ_DOUBLE;
 565                                 break;
 566                         }
 567                         /* Pop 2, push 1 */
 568                         if (vstack_pop(stack)) {
 569                                 ret = -EINVAL;
 570                                 goto end;
 571                         }
 572                         vstack_ax(stack)->type = REG_S64;
 573                         next_pc += sizeof(struct binary_op);
 574                         break;
 575                 }
 576
 577                 case FILTER_OP_NE:
 578                 {
 579                         struct binary_op *insn = (struct binary_op *) pc;
 580
 581                         switch(vstack_ax(stack)->type) {
 582                         default:
 583                                 printk(KERN_WARNING "unknown register type\n");
 584                                 ret = -EINVAL;
 585                                 goto end;
 586
 587                         case REG_STRING:
 588                                 if (vstack_bx(stack)->type == REG_STAR_GLOB_STRING)
 589                                         insn->op = FILTER_OP_NE_STAR_GLOB_STRING;
 590                                 else
 591                                         insn->op = FILTER_OP_NE_STRING;
 592                                 break;
 593                         case REG_STAR_GLOB_STRING:
 594                                 insn->op = FILTER_OP_NE_STAR_GLOB_STRING;
 595                                 break;
 596                         case REG_S64:
 597                                 if (vstack_bx(stack)->type == REG_S64)
 598                                         insn->op = FILTER_OP_NE_S64;
 599                                 else
 600                                         insn->op = FILTER_OP_NE_DOUBLE_S64;
 601                                 break;
 602                         case REG_DOUBLE:
 603                                 if (vstack_bx(stack)->type == REG_S64)
 604                                         insn->op = FILTER_OP_NE_S64_DOUBLE;
 605                                 else
 606                                         insn->op = FILTER_OP_NE_DOUBLE;
 607                                 break;
 608                         }
 609                         /* Pop 2, push 1 */
 610                         if (vstack_pop(stack)) {
 611                                 ret = -EINVAL;
 612                                 goto end;
 613                         }
 614                         vstack_ax(stack)->type = REG_S64;
 615                         next_pc += sizeof(struct binary_op);
 616                         break;
 617                 }
 618
 619                 case FILTER_OP_GT:
 620                 {
 621                         struct binary_op *insn = (struct binary_op *) pc;
 622
 623                         switch(vstack_ax(stack)->type) {
 624                         default:
 625                                 printk(KERN_WARNING "unknown register type\n");
 626                                 ret = -EINVAL;
 627                                 goto end;
 628
 629                         case REG_STAR_GLOB_STRING:
 630                                 printk(KERN_WARNING "invalid register type for > binary operator\n");
 631                                 ret = -EINVAL;
 632                                 goto end;
 633                         case REG_STRING:
 634                                 insn->op = FILTER_OP_GT_STRING;
 635                                 break;
 636                         case REG_S64:
 637                                 if (vstack_bx(stack)->type == REG_S64)
 638                                         insn->op = FILTER_OP_GT_S64;
 639                                 else
 640                                         insn->op = FILTER_OP_GT_DOUBLE_S64;
 641                                 break;
 642                         case REG_DOUBLE:
 643                                 if (vstack_bx(stack)->type == REG_S64)
 644                                         insn->op = FILTER_OP_GT_S64_DOUBLE;
 645                                 else
 646                                         insn->op = FILTER_OP_GT_DOUBLE;
 647                                 break;
 648                         }
 649                         /* Pop 2, push 1 */
 650                         if (vstack_pop(stack)) {
 651                                 ret = -EINVAL;
 652                                 goto end;
 653                         }
 654                         vstack_ax(stack)->type = REG_S64;
 655                         next_pc += sizeof(struct binary_op);
 656                         break;
 657                 }
 658
 659                 case FILTER_OP_LT:
 660                 {
 661                         struct binary_op *insn = (struct binary_op *) pc;
 662
 663                         switch(vstack_ax(stack)->type) {
 664                         default:
 665                                 printk(KERN_WARNING "unknown register type\n");
 666                                 ret = -EINVAL;
 667                                 goto end;
 668
 669                         case REG_STAR_GLOB_STRING:
 670                                 printk(KERN_WARNING "invalid register type for < binary operator\n");
 671                                 ret = -EINVAL;
 672                                 goto end;
 673                         case REG_STRING:
 674                                 insn->op = FILTER_OP_LT_STRING;
 675                                 break;
 676                         case REG_S64:
 677                                 if (vstack_bx(stack)->type == REG_S64)
 678                                         insn->op = FILTER_OP_LT_S64;
 679                                 else
 680                                         insn->op = FILTER_OP_LT_DOUBLE_S64;
 681                                 break;
 682                         case REG_DOUBLE:
 683                                 if (vstack_bx(stack)->type == REG_S64)
 684                                         insn->op = FILTER_OP_LT_S64_DOUBLE;
 685                                 else
 686                                         insn->op = FILTER_OP_LT_DOUBLE;
 687                                 break;
 688                         }
 689                         /* Pop 2, push 1 */
 690                         if (vstack_pop(stack)) {
 691                                 ret = -EINVAL;
 692                                 goto end;
 693                         }
 694                         vstack_ax(stack)->type = REG_S64;
 695                         next_pc += sizeof(struct binary_op);
 696                         break;
 697                 }
 698
 699                 case FILTER_OP_GE:
 700                 {
 701                         struct binary_op *insn = (struct binary_op *) pc;
 702
 703                         switch(vstack_ax(stack)->type) {
 704                         default:
 705                                 printk(KERN_WARNING "unknown register type\n");
 706                                 ret = -EINVAL;
 707                                 goto end;
 708
 709                         case REG_STAR_GLOB_STRING:
 710                                 printk(KERN_WARNING "invalid register type for >= binary operator\n");
 711                                 ret = -EINVAL;
 712                                 goto end;
 713                         case REG_STRING:
 714                                 insn->op = FILTER_OP_GE_STRING;
 715                                 break;
 716                         case REG_S64:
 717                                 if (vstack_bx(stack)->type == REG_S64)
 718                                         insn->op = FILTER_OP_GE_S64;
 719                                 else
 720                                         insn->op = FILTER_OP_GE_DOUBLE_S64;
 721                                 break;
 722                         case REG_DOUBLE:
 723                                 if (vstack_bx(stack)->type == REG_S64)
 724                                         insn->op = FILTER_OP_GE_S64_DOUBLE;
 725                                 else
 726                                         insn->op = FILTER_OP_GE_DOUBLE;
 727                                 break;
 728                         }
 729                         /* Pop 2, push 1 */
 730                         if (vstack_pop(stack)) {
 731                                 ret = -EINVAL;
 732                                 goto end;
 733                         }
 734                         vstack_ax(stack)->type = REG_S64;
 735                         next_pc += sizeof(struct binary_op);
 736                         break;
 737                 }
 738                 case FILTER_OP_LE:
 739                 {
 740                         struct binary_op *insn = (struct binary_op *) pc;
 741
 742                         switch(vstack_ax(stack)->type) {
 743                         default:
 744                                 printk(KERN_WARNING "unknown register type\n");
 745                                 ret = -EINVAL;
 746                                 goto end;
 747
 748                         case REG_STAR_GLOB_STRING:
 749                                 printk(KERN_WARNING "invalid register type for <= binary operator\n");
 750                                 ret = -EINVAL;
 751                                 goto end;
 752                         case REG_STRING:
 753                                 insn->op = FILTER_OP_LE_STRING;
 754                                 break;
 755                         case REG_S64:
 756                                 if (vstack_bx(stack)->type == REG_S64)
 757                                         insn->op = FILTER_OP_LE_S64;
 758                                 else
 759                                         insn->op = FILTER_OP_LE_DOUBLE_S64;
 760                                 break;
 761                         case REG_DOUBLE:
 762                                 if (vstack_bx(stack)->type == REG_S64)
 763                                         insn->op = FILTER_OP_LE_S64_DOUBLE;
 764                                 else
 765                                         insn->op = FILTER_OP_LE_DOUBLE;
 766                                 break;
 767                         }
 768                         vstack_ax(stack)->type = REG_S64;
 769                         next_pc += sizeof(struct binary_op);
 770                         break;
 771                 }
 772
 773                 case FILTER_OP_EQ_STRING:
 774                 case FILTER_OP_NE_STRING:
 775                 case FILTER_OP_GT_STRING:
 776                 case FILTER_OP_LT_STRING:
 777                 case FILTER_OP_GE_STRING:
 778                 case FILTER_OP_LE_STRING:
 779                 case FILTER_OP_EQ_STAR_GLOB_STRING:
 780                 case FILTER_OP_NE_STAR_GLOB_STRING:
 781                 case FILTER_OP_EQ_S64:
 782                 case FILTER_OP_NE_S64:
 783                 case FILTER_OP_GT_S64:
 784                 case FILTER_OP_LT_S64:
 785                 case FILTER_OP_GE_S64:
 786                 case FILTER_OP_LE_S64:
 787                 case FILTER_OP_EQ_DOUBLE:
 788                 case FILTER_OP_NE_DOUBLE:
 789                 case FILTER_OP_GT_DOUBLE:
 790                 case FILTER_OP_LT_DOUBLE:
 791                 case FILTER_OP_GE_DOUBLE:
 792                 case FILTER_OP_LE_DOUBLE:
 793                 case FILTER_OP_EQ_DOUBLE_S64:
 794                 case FILTER_OP_NE_DOUBLE_S64:
 795                 case FILTER_OP_GT_DOUBLE_S64:
 796                 case FILTER_OP_LT_DOUBLE_S64:
 797                 case FILTER_OP_GE_DOUBLE_S64:
 798                 case FILTER_OP_LE_DOUBLE_S64:
 799                 case FILTER_OP_EQ_S64_DOUBLE:
 800                 case FILTER_OP_NE_S64_DOUBLE:
 801                 case FILTER_OP_GT_S64_DOUBLE:
 802                 case FILTER_OP_LT_S64_DOUBLE:
 803                 case FILTER_OP_GE_S64_DOUBLE:
 804                 case FILTER_OP_LE_S64_DOUBLE:
 805                 case FILTER_OP_BIT_RSHIFT:
 806                 case FILTER_OP_BIT_LSHIFT:
 807                 case FILTER_OP_BIT_AND:
 808                 case FILTER_OP_BIT_OR:
 809                 case FILTER_OP_BIT_XOR:
 810                 {
 811                         /* Pop 2, push 1 */
 812                         if (vstack_pop(stack)) {
 813                                 ret = -EINVAL;
 814                                 goto end;
 815                         }
 816                         vstack_ax(stack)->type = REG_S64;
 817                         next_pc += sizeof(struct binary_op);
 818                         break;
 819                 }
 820
 821                 /* unary */
 822                 case FILTER_OP_UNARY_PLUS:
 823                 {
 824                         struct unary_op *insn = (struct unary_op *) pc;
 825
 826                         switch(vstack_ax(stack)->type) {
 827                         default:
 828                                 printk(KERN_WARNING "unknown register type\n");
 829                                 ret = -EINVAL;
 830                                 goto end;
 831
 832                         case REG_S64:
 833                                 insn->op = FILTER_OP_UNARY_PLUS_S64;
 834                                 break;
 835                         case REG_DOUBLE:
 836                                 insn->op = FILTER_OP_UNARY_PLUS_DOUBLE;
 837                                 break;
 838                         }
 839                         /* Pop 1, push 1 */
 840                         next_pc += sizeof(struct unary_op);
 841                         break;
 842                 }
 843
 844                 case FILTER_OP_UNARY_MINUS:
 845                 {
 846                         struct unary_op *insn = (struct unary_op *) pc;
 847
 848                         switch(vstack_ax(stack)->type) {
 849                         default:
 850                                 printk(KERN_WARNING "unknown register type\n");
 851                                 ret = -EINVAL;
 852                                 goto end;
 853
 854                         case REG_S64:
 855                                 insn->op = FILTER_OP_UNARY_MINUS_S64;
 856                                 break;
 857                         case REG_DOUBLE:
 858                                 insn->op = FILTER_OP_UNARY_MINUS_DOUBLE;
 859                                 break;
 860                         }
 861                         /* Pop 1, push 1 */
 862                         next_pc += sizeof(struct unary_op);
 863                         break;
 864                 }
 865
 866                 case FILTER_OP_UNARY_NOT:
 867                 {
 868                         struct unary_op *insn = (struct unary_op *) pc;
 869
 870                         switch(vstack_ax(stack)->type) {
 871                         default:
 872                                 printk(KERN_WARNING "unknown register type\n");
 873                                 ret = -EINVAL;
 874                                 goto end;
 875
 876                         case REG_S64:
 877                                 insn->op = FILTER_OP_UNARY_NOT_S64;
 878                                 break;
 879                         case REG_DOUBLE:
 880                                 insn->op = FILTER_OP_UNARY_NOT_DOUBLE;
 881                                 break;
 882                         }
 883                         /* Pop 1, push 1 */
 884                         next_pc += sizeof(struct unary_op);
 885                         break;
 886                 }
 887
 888                 case FILTER_OP_UNARY_BIT_NOT:
 889                 {
 890                         /* Pop 1, push 1 */
 891                         next_pc += sizeof(struct unary_op);
 892                         break;
 893                 }
 894
 895                 case FILTER_OP_UNARY_PLUS_S64:
 896                 case FILTER_OP_UNARY_MINUS_S64:
 897                 case FILTER_OP_UNARY_NOT_S64:
 898                 case FILTER_OP_UNARY_PLUS_DOUBLE:
 899                 case FILTER_OP_UNARY_MINUS_DOUBLE:
 900                 case FILTER_OP_UNARY_NOT_DOUBLE:
 901                 {
 902                         /* Pop 1, push 1 */
 903                         next_pc += sizeof(struct unary_op);
 904                         break;
 905                 }
 906
 907                 /* logical */
 908                 case FILTER_OP_AND:
 909                 case FILTER_OP_OR:
 910                 {
 911                         /* Continue to next instruction */
 912                         /* Pop 1 when jump not taken */
 913                         if (vstack_pop(stack)) {
 914                                 ret = -EINVAL;
 915                                 goto end;
 916                         }
 917                         next_pc += sizeof(struct logical_op);
 918                         break;
 919                 }
 920
 921                 /* load field ref */
 922                 case FILTER_OP_LOAD_FIELD_REF:
 923                 {
 924                         printk(KERN_WARNING "Unknown field ref type\n");
 925                         ret = -EINVAL;
 926                         goto end;
 927                 }
 928                 /* get context ref */
 929                 case FILTER_OP_GET_CONTEXT_REF:
 930                 {
 931                         printk(KERN_WARNING "Unknown get context ref type\n");
 932                         ret = -EINVAL;
 933                         goto end;
 934                 }
 935                 case FILTER_OP_LOAD_FIELD_REF_STRING:
 936                 case FILTER_OP_LOAD_FIELD_REF_SEQUENCE:
 937                 case FILTER_OP_GET_CONTEXT_REF_STRING:
 938                 case FILTER_OP_LOAD_FIELD_REF_USER_STRING:
 939                 case FILTER_OP_LOAD_FIELD_REF_USER_SEQUENCE:
 940                 {
 941                         if (vstack_push(stack)) {
 942                                 ret = -EINVAL;
 943                                 goto end;
 944                         }
 945                         vstack_ax(stack)->type = REG_STRING;
 946                         next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
 947                         break;
 948                 }
 949                 case FILTER_OP_LOAD_FIELD_REF_S64:
 950                 case FILTER_OP_GET_CONTEXT_REF_S64:
 951                 {
 952                         if (vstack_push(stack)) {
 953                                 ret = -EINVAL;
 954                                 goto end;
 955                         }
 956                         vstack_ax(stack)->type = REG_S64;
 957                         next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
 958                         break;
 959                 }
 960                 case FILTER_OP_LOAD_FIELD_REF_DOUBLE:
 961                 case FILTER_OP_GET_CONTEXT_REF_DOUBLE:
 962                 {
 963                         if (vstack_push(stack)) {
 964                                 ret = -EINVAL;
 965                                 goto end;
 966                         }
 967                         vstack_ax(stack)->type = REG_DOUBLE;
 968                         next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
 969                         break;
 970                 }
 971
 972                 /* load from immediate operand */
 973                 case FILTER_OP_LOAD_STRING:
 974                 {
 975                         struct load_op *insn = (struct load_op *) pc;
 976
 977                         if (vstack_push(stack)) {
 978                                 ret = -EINVAL;
 979                                 goto end;
 980                         }
 981                         vstack_ax(stack)->type = REG_STRING;
 982                         next_pc += sizeof(struct load_op) + strlen(insn->data) + 1;
 983                         break;
 984                 }
 985
 986                 case FILTER_OP_LOAD_STAR_GLOB_STRING:
 987                 {
 988                         struct load_op *insn = (struct load_op *) pc;
 989
 990                         if (vstack_push(stack)) {
 991                                 ret = -EINVAL;
 992                                 goto end;
 993                         }
 994                         vstack_ax(stack)->type = REG_STAR_GLOB_STRING;
 995                         next_pc += sizeof(struct load_op) + strlen(insn->data) + 1;
 996                         break;
 997                 }
 998
 999                 case FILTER_OP_LOAD_S64:
1000                 {
1001                         if (vstack_push(stack)) {
1002                                 ret = -EINVAL;
1003                                 goto end;
1004                         }
1005                         vstack_ax(stack)->type = REG_S64;
1006                         next_pc += sizeof(struct load_op)
1007                                         + sizeof(struct literal_numeric);
1008                         break;
1009                 }
1010
1011                 case FILTER_OP_LOAD_DOUBLE:
1012                 {
1013                         if (vstack_push(stack)) {
1014                                 ret = -EINVAL;
1015                                 goto end;
1016                         }
1017                         vstack_ax(stack)->type = REG_DOUBLE;
1018                         next_pc += sizeof(struct load_op)
1019                                         + sizeof(struct literal_double);
1020                         break;
1021                 }
1022
1023                 /* cast */
1024                 case FILTER_OP_CAST_TO_S64:
1025                 {
1026                         struct cast_op *insn = (struct cast_op *) pc;
1027
1028                         switch (vstack_ax(stack)->type) {
1029                         default:
1030                                 printk(KERN_WARNING "unknown register type\n");
1031                                 ret = -EINVAL;
1032                                 goto end;
1033
1034                         case REG_STRING:
1035                         case REG_STAR_GLOB_STRING:
1036                                 printk(KERN_WARNING "Cast op can only be applied to numeric or floating point registers\n");
1037                                 ret = -EINVAL;
1038                                 goto end;
1039                         case REG_S64:
1040                                 insn->op = FILTER_OP_CAST_NOP;
1041                                 break;
1042                         case REG_DOUBLE:
1043                                 insn->op = FILTER_OP_CAST_DOUBLE_TO_S64;
1044                                 break;
1045                         }
1046                         /* Pop 1, push 1 */
1047                         vstack_ax(stack)->type = REG_S64;
1048                         next_pc += sizeof(struct cast_op);
1049                         break;
1050                 }
1051                 case FILTER_OP_CAST_DOUBLE_TO_S64:
1052                 {
1053                         /* Pop 1, push 1 */
1054                         vstack_ax(stack)->type = REG_S64;
1055                         next_pc += sizeof(struct cast_op);
1056                         break;
1057                 }
1058                 case FILTER_OP_CAST_NOP:
1059                 {
1060                         next_pc += sizeof(struct cast_op);
1061                         break;
1062                 }
1063
1064                 /*
1065                  * Instructions for recursive traversal through composed types.
1066                  */
1067                 case FILTER_OP_GET_CONTEXT_ROOT:
1068                 {
1069                         if (vstack_push(stack)) {
1070                                 ret = -EINVAL;
1071                                 goto end;
1072                         }
1073                         vstack_ax(stack)->type = REG_PTR;
1074                         vstack_ax(stack)->load.type = LOAD_ROOT_CONTEXT;
1075                         next_pc += sizeof(struct load_op);
1076                         break;
1077                 }
1078                 case FILTER_OP_GET_APP_CONTEXT_ROOT:
1079                 {
1080                         if (vstack_push(stack)) {
1081                                 ret = -EINVAL;
1082                                 goto end;
1083                         }
1084                         vstack_ax(stack)->type = REG_PTR;
1085                         vstack_ax(stack)->load.type = LOAD_ROOT_APP_CONTEXT;
1086                         next_pc += sizeof(struct load_op);
1087                         break;
1088                 }
1089                 case FILTER_OP_GET_PAYLOAD_ROOT:
1090                 {
1091                         if (vstack_push(stack)) {
1092                                 ret = -EINVAL;
1093                                 goto end;
1094                         }
1095                         vstack_ax(stack)->type = REG_PTR;
1096                         vstack_ax(stack)->load.type = LOAD_ROOT_PAYLOAD;
1097                         next_pc += sizeof(struct load_op);
1098                         break;
1099                 }
1100
1101                 case FILTER_OP_LOAD_FIELD:
1102                 {
1103                         struct load_op *insn = (struct load_op *) pc;
1104
1105                         WARN_ON_ONCE(vstack_ax(stack)->type != REG_PTR);
1106                         /* Pop 1, push 1 */
1107                         ret = specialize_load_field(vstack_ax(stack), insn);
1108                         if (ret)
1109                                 goto end;
1110
1111                         next_pc += sizeof(struct load_op);
1112                         break;
1113                 }
1114
1115                 case FILTER_OP_LOAD_FIELD_S8:
1116                 case FILTER_OP_LOAD_FIELD_S16:
1117                 case FILTER_OP_LOAD_FIELD_S32:
1118                 case FILTER_OP_LOAD_FIELD_S64:
1119                 case FILTER_OP_LOAD_FIELD_U8:
1120                 case FILTER_OP_LOAD_FIELD_U16:
1121                 case FILTER_OP_LOAD_FIELD_U32:
1122                 case FILTER_OP_LOAD_FIELD_U64:
1123                 {
1124                         /* Pop 1, push 1 */
1125                         vstack_ax(stack)->type = REG_S64;
1126                         next_pc += sizeof(struct load_op);
1127                         break;
1128                 }
1129
1130                 case FILTER_OP_LOAD_FIELD_STRING:
1131                 case FILTER_OP_LOAD_FIELD_SEQUENCE:
1132                 {
1133                         /* Pop 1, push 1 */
1134                         vstack_ax(stack)->type = REG_STRING;
1135                         next_pc += sizeof(struct load_op);
1136                         break;
1137                 }
1138
1139                 case FILTER_OP_LOAD_FIELD_DOUBLE:
1140                 {
1141                         /* Pop 1, push 1 */
1142                         vstack_ax(stack)->type = REG_DOUBLE;
1143                         next_pc += sizeof(struct load_op);
1144                         break;
1145                 }
1146
1147                 case FILTER_OP_GET_SYMBOL:
1148                 {
1149                         struct load_op *insn = (struct load_op *) pc;
1150
1151                         dbg_printk("op get symbol\n");
1152                         switch (vstack_ax(stack)->load.type) {
1153                         case LOAD_OBJECT:
1154                                 printk(KERN_WARNING "Nested fields not implemented yet.\n");
1155                                 ret = -EINVAL;
1156                                 goto end;
1157                         case LOAD_ROOT_CONTEXT:
1158                                 /* Lookup context field. */
1159                                 ret = specialize_context_lookup(bytecode, insn,
1160                                         &vstack_ax(stack)->load);
1161                                 if (ret)
1162                                         goto end;
1163                                 break;
1164                         case LOAD_ROOT_APP_CONTEXT:
1165                                 ret = -EINVAL;
1166                                 goto end;
1167                         case LOAD_ROOT_PAYLOAD:
1168                                 /* Lookup event payload field. */
1169                                 ret = specialize_event_payload_lookup(event,
1170                                         bytecode, insn,
1171                                         &vstack_ax(stack)->load);
1172                                 if (ret)
1173                                         goto end;
1174                                 break;
1175                         }
1176                         next_pc += sizeof(struct load_op) + sizeof(struct get_symbol);
1177                         break;
1178                 }
1179
1180                 case FILTER_OP_GET_SYMBOL_FIELD:
1181                 {
1182                         /* Always generated by specialize phase. */
1183                         ret = -EINVAL;
1184                         goto end;
1185                 }
1186
1187                 case FILTER_OP_GET_INDEX_U16:
1188                 {
1189                         struct load_op *insn = (struct load_op *) pc;
1190                         struct get_index_u16 *index = (struct get_index_u16 *) insn->data;
1191
1192                         dbg_printk("op get index u16\n");
1193                         /* Pop 1, push 1 */
1194                         ret = specialize_get_index(bytecode, insn, index->index,
1195                                         vstack_ax(stack), sizeof(*index));
1196                         if (ret)
1197                                 goto end;
1198                         next_pc += sizeof(struct load_op) + sizeof(struct get_index_u16);
1199                         break;
1200                 }
1201
1202                 case FILTER_OP_GET_INDEX_U64:
1203                 {
1204                         struct load_op *insn = (struct load_op *) pc;
1205                         struct get_index_u64 *index = (struct get_index_u64 *) insn->data;
1206
1207                         dbg_printk("op get index u64\n");
1208                         /* Pop 1, push 1 */
1209                         ret = specialize_get_index(bytecode, insn, index->index,
1210                                         vstack_ax(stack), sizeof(*index));
1211                         if (ret)
1212                                 goto end;
1213                         next_pc += sizeof(struct load_op) + sizeof(struct get_index_u64);
1214                         break;
1215                 }
1216
1217                 }
1218         }
1219 end:
1220         return ret;
1221 }