/* * JIT interpreter for binary filters. * it process the filter_ops and apply the instructions * on the given packet object */ static int filter_engine(struct filter_op *fop, struct packet_object *po) { u_int32 eip = 0; u_int32 flags = 0; #define FLAG_FALSE 0 #define FLAG_TRUE 1 /* sanity check */ BUG_IF(fop == NULL); FILTERS_LOCK; /* loop until EXIT */ while (fop[eip].opcode != FOP_EXIT) { switch (fop[eip].opcode) { case FOP_TEST: if (execute_test(&fop[eip], po) == FLAG_TRUE) flags |= FLAG_TRUE; else flags &= ~(FLAG_TRUE); break; case FOP_ASSIGN: execute_assign(&fop[eip], po); /* assignment always returns true */ flags |= FLAG_TRUE; break; case FOP_INC: case FOP_DEC: execute_incdec(&fop[eip], po); /* inc/dec always return true */ flags |= FLAG_TRUE; break; case FOP_FUNC: if (execute_func(&fop[eip], po) == FLAG_TRUE) flags |= FLAG_TRUE; else flags &= ~(FLAG_TRUE); break; case FOP_JMP: /* jump the the next eip */ eip = fop[eip].op.jmp; continue; break; case FOP_JTRUE: /* jump the the next eip if the TRUE FLAG is set*/ if (flags & FLAG_TRUE) { eip = fop[eip].op.jmp; continue; } break; case FOP_JFALSE: /* jump the the next eip if the TRUE FLAG is NOT set */ if (!(flags & FLAG_TRUE)) { eip = fop[eip].op.jmp; continue; } break; default: FILTERS_UNLOCK; JIT_FAULT("unsupported opcode [%d] (execution interrupted)", fop[eip].opcode); break; } /* autoincrement the instruction pointer */ eip++; } FILTERS_UNLOCK; return 0; }
/* Check if MAGIC is valid and print the Multiboot information structure pointed by ADDR. */ void entry (unsigned long magic, unsigned long addr) { multiboot_info_t *mbi; /* Clear the screen. */ clear(); /* Am I booted by a Multiboot-compliant boot loader? */ if (magic != MULTIBOOT_BOOTLOADER_MAGIC) { printf ("Invalid magic number: 0x%#x\n", (unsigned) magic); return; } /* Set MBI to the address of the Multiboot information structure. */ mbi = (multiboot_info_t *) addr; /* Print out the flags. */ printf ("flags = 0x%#x\n", (unsigned) mbi->flags); /* Are mem_* valid? */ if (CHECK_FLAG (mbi->flags, 0)) printf ("mem_lower = %uKB, mem_upper = %uKB\n", (unsigned) mbi->mem_lower, (unsigned) mbi->mem_upper); /* Is boot_device valid? */ if (CHECK_FLAG (mbi->flags, 1)) printf ("boot_device = 0x%#x\n", (unsigned) mbi->boot_device); /* Is the command line passed? */ if (CHECK_FLAG (mbi->flags, 2)) printf ("cmdline = %s\n", (char *) mbi->cmdline); if (CHECK_FLAG (mbi->flags, 3)) { int mod_count = 0; int i; module_t* mod = (module_t*)mbi->mods_addr; while(mod_count < mbi->mods_count) { printf("Module %d loaded at address: 0x%#x\n", mod_count, (unsigned int)mod->mod_start); printf("Module %d ends at address: 0x%#x\n", mod_count, (unsigned int)mod->mod_end); printf("First few bytes of module:\n"); for(i = 0; i<16; i++) { printf("0x%x ", *((char*)(mod->mod_start+i))); } printf("\n"); mod_count++; mod++; } } /* Bits 4 and 5 are mutually exclusive! */ if (CHECK_FLAG (mbi->flags, 4) && CHECK_FLAG (mbi->flags, 5)) { printf ("Both bits 4 and 5 are set.\n"); return; } /* Is the section header table of ELF valid? */ if (CHECK_FLAG (mbi->flags, 5)) { elf_section_header_table_t *elf_sec = &(mbi->elf_sec); printf ("elf_sec: num = %u, size = 0x%#x," " addr = 0x%#x, shndx = 0x%#x\n", (unsigned) elf_sec->num, (unsigned) elf_sec->size, (unsigned) elf_sec->addr, (unsigned) elf_sec->shndx); } /* Are mmap_* valid? */ if (CHECK_FLAG (mbi->flags, 6)) { memory_map_t *mmap; printf ("mmap_addr = 0x%#x, mmap_length = 0x%x\n", (unsigned) mbi->mmap_addr, (unsigned) mbi->mmap_length); for (mmap = (memory_map_t *) mbi->mmap_addr; (unsigned long) mmap < mbi->mmap_addr + mbi->mmap_length; mmap = (memory_map_t *) ((unsigned long) mmap + mmap->size + sizeof (mmap->size))) printf (" size = 0x%x, base_addr = 0x%#x%#x\n" " type = 0x%x, length = 0x%#x%#x\n", (unsigned) mmap->size, (unsigned) mmap->base_addr_high, (unsigned) mmap->base_addr_low, (unsigned) mmap->type, (unsigned) mmap->length_high, (unsigned) mmap->length_low); } /* Construct an LDT entry in the GDT */ { seg_desc_t the_ldt_desc; the_ldt_desc.granularity = 0; the_ldt_desc.opsize = 1; the_ldt_desc.reserved = 0; the_ldt_desc.avail = 0; the_ldt_desc.present = 1; the_ldt_desc.dpl = 0x0; the_ldt_desc.sys = 0; the_ldt_desc.type = 0x2; SET_LDT_PARAMS(the_ldt_desc, &ldt, ldt_size); ldt_desc_ptr = the_ldt_desc; lldt(KERNEL_LDT); } /* Construct a TSS entry in the GDT */ { seg_desc_t the_tss_desc; the_tss_desc.granularity = 0; the_tss_desc.opsize = 0; the_tss_desc.reserved = 0; the_tss_desc.avail = 0; the_tss_desc.seg_lim_19_16 = TSS_SIZE & 0x000F0000; the_tss_desc.present = 1; the_tss_desc.dpl = 0x0; the_tss_desc.sys = 0; the_tss_desc.type = 0x9; the_tss_desc.seg_lim_15_00 = TSS_SIZE & 0x0000FFFF; SET_TSS_PARAMS(the_tss_desc, &tss, tss_size); tss_desc_ptr = the_tss_desc; tss.ldt_segment_selector = KERNEL_LDT; tss.ss0 = KERNEL_DS; tss.esp0 = 0x800000; ltr(KERNEL_TSS); } fill_idt(); lidt(idt_desc_ptr); // Load IDT Pointer //Init the PIC i8259_init(); pit_init(); init_keyboard(); rtc_init(); terminal_open((uint8_t*)1); init_paging(); /* initializing file systems */ module_t * boot_fs = (module_t*)mbi->mods_addr; init_fs(boot_fs->mod_start); /* Done initializing fs */ /* Initialize devices, memory, filesystem, enable device interrupts on the * PIC, any other initialization stuff... */ /* Enable interrupts */ // printf("Enabling Interrupts\n"); sti(); // uint32_t bmap_val = 10; // char bitmap_temp[6]; // itoa(bmap_val , bitmap_temp, 2); // // printf("BMAP VALUE - %d\n", bmap_val); // printf("%s\n", bitmap_temp); // char bitmap[6]; // uint32_t l = strlen((uint8_t*)bitmap_temp); // uint32_t temp_idx; // for (temp_idx=0; temp_idx<5; temp_idx++){ // if (temp_idx<(5-l)) // bitmap[temp_idx] = '0'; // else // bitmap[temp_idx] = bitmap_temp[temp_idx+l-5]; // } // bitmap[5] = '\0'; // printf("%s\n", bitmap); // Initialization for the process init_terminals(); execute_func((uint8_t *)"shell"); // Spin (nicely, so we don't chew up cycles) asm volatile(".1: hlt; jmp .1;"); }