void vTestKernel3(void *pvAddress) { char send_buf[BUF_SIZE]; char recv_buf[BUF_SIZE]; unsigned int rtn; char ch = 'A'; while (1) { send_buf[0] = ch; send_buf[1] = '\0'; ch = (char)((unsigned int)ch + 1); if(ch > 'Z') { ch = 'A'; } rtn = wireless_send(send_buf); if (rtn > 0) { term_printf("<<<Task 3>>> sent by wifi: %s\r\n", send_buf); vTaskDelay(500 / portTICK_RATE_MS); rtn = wireless_recv(recv_buf, 1); if(rtn > 0) { term_printf("<<<Task 3>>> received: %s\r\n", recv_buf); } else { term_printf("<<<Task 3>>> received nothing by wifi!\r\n"); } } else { term_printf("<<<Task 3>>> failed to send data by wifi!\r\n"); } } }
int mm_init(multiboot_info_t *boot_info) { if (!(boot_info->flags & MULTIBOOT_INFO_MEMORY)) { term_print("Boot info memory entries invalid, bailing out\n"); return -1; } term_printf("Upper memory %dk\n", boot_info->mem_upper); term_printf("Lower memory %dk\n", boot_info->mem_lower); if (!(boot_info->flags & MULTIBOOT_INFO_MEM_MAP)) { term_print("Boot info mem map invalid, bailing out\n"); return -1; } multiboot_memory_map_t *mmap = (void *)boot_info->mmap_addr; term_print("Memory map:\n"); while ((multiboot_uint32_t)mmap < boot_info->mmap_addr + boot_info->mmap_length) { const char *type = mmap->type == MULTIBOOT_MEMORY_AVAILABLE ? "Available" : "Reserved "; /* * These are technically 64-bit values, so we need to convert them before passing * them to printf */ uint32_t start = mmap->addr; uint32_t len = mmap->len; term_printf(" %s [0x%lx - 0x%lx]\n", type, start, start + len); mmap = (void *)((uintptr_t)mmap + mmap->size + 4); } return 0; }
void init_ata() { // First, check for a floating bus (no drives attached) uint8_t pri_status = inb(PRIMARY_BASE + COM_STAT); uint8_t sec_status = inb(SECONDARY_BASE + COM_STAT); bool primary_floating = false; bool secondary_floating = false; if (pri_status == 0xFF) primary_floating = true; if (sec_status == 0xFF) secondary_floating = true; // Both buses are floating if (primary_floating && secondary_floating) { term_puts("No drives attached! What's going on?"); return; } // Non-0xFF values are not definitive; we need to do some more checks check_drive(PRIMARY_BASE, SEL_MASTER); check_drive(PRIMARY_BASE, SEL_SLAVE); check_drive(SECONDARY_BASE, SEL_MASTER); check_drive(SECONDARY_BASE, SEL_SLAVE); if (sel_base_port == 0) // We didn't find a (PATA) drive term_puts("No drives attached! What's going on?"); else { term_printf("Found a drive!\nSelected drive is the %s on the %s bus\n", sel_master_or_slave == SEL_MASTER ? "master" : "slave", sel_base_port == PRIMARY_BASE ? "primary" : "secondary"); term_printf("Max LBA value is %d\n", max_sector); } }
/* Parse configuration file */ void check_ini(char *path_ini) { struct cnfnode *cn_root; struct cnfmodule *mod_ini; struct cnfresult *cnf_res; register_ini(NULL); mod_ini = find_cnfmodule("ini"); cn_root = cnfmodule_parse_file(mod_ini, path_ini); if (cn_root == NULL) { term_printf ("Could not find INI file: %s\n", path_ini); return; } /* Parse configuration flags */ set_bool_from_ini(cn_root, "general/trace_only_after_first_taint", &conf_trace_only_after_first_taint); set_bool_from_ini(cn_root, "general/log_external_calls", &conf_log_external_calls); set_bool_from_ini(cn_root, "general/write_ops_at_insn_end", &conf_write_ops_at_insn_end); set_bool_from_ini(cn_root, "general/save_state_at_trace_stop", &conf_save_state_at_trace_stop); set_bool_from_ini(cn_root, "tracing/tracing_table_lookup", &tracing_table_lookup); set_bool_from_ini(cn_root, "tracing/tracing_tainted_only", &conf_tainted_only); set_bool_from_ini(cn_root, "tracing/tracing_kernel", &conf_tracing_kernel_all); set_bool_from_ini(cn_root, "tracing/tracing_kernel_tainted", &conf_tracing_kernel_tainted); set_bool_from_ini(cn_root, "tracing/tracing_kernel_partial", &conf_tracing_kernel_partial); /* Parse network configuration */ set_bool_from_ini(cn_root, "network/ignore_dns", &conf_ignore_dns); check_filter_conf(cn_root); print_nic_filter(); /* Find hook configuration file */ cnf_res = cnf_find_entry(cn_root, "function hooks/plugin_ini"); if (cnf_res) strncpy(hook_plugins_filename, cnf_res->cnfnode->value, 255); hook_plugins_filename[255] = '\0'; term_printf("Loading plugin options from: %s\n", hook_plugins_filename); /* Find hooks directory */ cnf_res = cnf_find_entry(cn_root, "function hooks/plugin_directory"); if (cnf_res) { strncpy(hook_dirname, cnf_res->cnfnode->value, 255); hook_dirname[255] = '\0'; } term_printf("Loading plugins from: %s\n", hook_dirname); destroy_cnftree(cn_root); }
void print_block(Header *header, Footer *footer) { term_printf("%X <= %X => %X <= %X => %X <= %X => %X\n", header, sizeof(Header), (uintptr_t)header + sizeof(Header), header->size - sizeof(Header) - sizeof(Footer), footer, sizeof(Footer), (uintptr_t)header + header->size); term_printf("Footer says header at %p, end at %p\n", footer->header, (uintptr_t)footer + sizeof(Footer)); }
/* Print the statistics variables */ void print_trace_stats() { term_printf("Number of instructions decoded: %ld\n", tstats.insn_counter_decoded); term_printf("Number of operands decoded: %ld\n", tstats.operand_counter); term_printf("Number of instructions written to trace: %ld\n", tstats.insn_counter_traced); term_printf("Number of tainted instructions written to trace: %ld\n", tstats.insn_counter_traced_tainted); }
void set_tainted_only(int state) { if (state) { conf_tainted_only = 1; term_printf("Taint-only flag on.\n"); } else { conf_tainted_only = 0; term_printf("Taint-only flag off.\n"); } }
void set_ignore_dns(int state) { if (state) { conf_ignore_dns = 1; term_printf("Ignore DNS flag on.\n"); } else { conf_ignore_dns = 0; term_printf("Ignore DNS flag off.\n"); } }
void set_kernel_all(int state) { if (state) { conf_tracing_kernel_all = 1; term_printf("Kernel-all flag on.\n"); } else { conf_tracing_kernel_all = 0; term_printf("Kernel-all flag off.\n"); } }
void set_kernel_tainted(int state) { if (state) { conf_tracing_kernel_tainted = 1; term_printf("Kernel-tainted flag on.\n"); } else { conf_tracing_kernel_tainted = 0; term_printf("Kernel-tainted flag off.\n"); } }
/* Print configuration variables */ void print_conf_vars() { term_printf( "TABLE_LOOKUP: %d\n" "TRACE_AFTER_FIRST_TAINT: %d\n" "LOG_EXTERNAL_CALLS: %d\n" "WRITE_OPS_AT_INSN_END: %d\n" "SAVE_STATE_AT_TRACE_STOP: %d\n" "PROTOS_IGNOREDNS: %d\n" "TAINTED_ONLY: %d\n" "TRACING_KERNEL_ALL: %d\n" "TRACING_KERNEL_TAINTED: %d\n" "TRACING_KERNEL_PARTIAL: %d\n", tracing_table_lookup, conf_trace_only_after_first_taint, conf_log_external_calls, conf_write_ops_at_insn_end, conf_save_state_at_trace_stop, conf_ignore_dns, conf_tainted_only, conf_tracing_kernel_all, conf_tracing_kernel_tainted, conf_tracing_kernel_partial ); }
void set_error_tsd(errormsg_t *err, uint8_t errornum, uint8_t track, uint8_t sector, int8_t drive) { char *msg = (char *)err->error_buffer; err->errorno = errornum; err->readp = 0; rom_sprintf(msg, IN_ROM_STR("%2.2d,"), errornum); // error number rom_strcat(msg, errmsg(errornum)); // error message from flash memory if (drive < 0) { rom_sprintf(msg + strlen(msg), IN_ROM_STR(",%2.2d,%2.2d\r"), track%100, sector%100); // track & sector } else { rom_sprintf(msg + strlen(msg), IN_ROM_STR(",%2.2d,%2.2d,%1.1d\r"), track, sector, drive); // track & sector & drive } if (errornum != CBM_ERROR_OK && errornum != CBM_ERROR_DOSVERSION && errornum != CBM_ERROR_SCRATCHED) { led_set(ERROR); term_printf("Setting status to: %s\n", err->error_buffer); } else { led_set(OFF); // same as idle, but clears error } #ifdef DEBUG_ERROR debug_printf("Set status to: %s\n", err->error_buffer); #endif }
void vTestKernel2(void *pvAddress) { while (1) { term_printf("Task 2 is running.\r\n"); vTaskDelay(6000 / portTICK_RATE_MS); } }
static void term_show_prompt2(void) { term_printf("%s", term_prompt); term_flush(); term_last_cmd_buf_index = 0; term_last_cmd_buf_size = 0; term_esc_state = IS_NORM; }
void vTestKernel4(void *pvAddress) { float sen, mem1, mem2, core; int gain_ctrl = 0; int rtn; while (1) { rtn = read_pow(gain_ctrl, &sen, &mem1, &mem2, &core); if (rtn == 0) { term_printf("<<<Task 4>>> failed to read power sensors!\r\n"); } else { term_printf("<<<Task 4>>> power_sensor reading ---gain_ctrl: %d, sen: %f, mem1: %f, mem2: %f, core: %f\r\n", gain_ctrl, sen, mem1, mem2, core); } vTaskDelay(5000 / portTICK_RATE_MS); gain_ctrl = 1 - gain_ctrl; } }
static void wav_capture_info (void *opaque) { WAVState *wav = opaque; char *path = wav->path; term_printf ("Capturing audio(%d,%d,%d) to %s: %d bytes\n", wav->freq, wav->bits, wav->nchannels, path ? path : "<not available>", wav->bytes); }
/* Parse boolean from configuration file */ static void set_bool_from_ini(struct cnfnode *cn_root, char *entry, int* flag) { struct cnfresult *cnf_res; cnf_res = cnf_find_entry(cn_root, entry); if (cnf_res) { if (strcasecmp(cnf_res->cnfnode->value, "yes") == 0) { *flag = 1; term_printf("%s is enabled.\n",entry); } else if (strcasecmp(cnf_res->cnfnode->value, "no") == 0) { *flag = 0; term_printf("%s is disabled.\n",entry); } else { term_printf("%s has incorrect value. Try <yes|no>.\n",entry); } } }
int tc_address_stop_hook(void *opaque) { term_printf("tc_address_stop_hook(*) called\n"); if ((tracing_kernel_all() || (temu_plugin->monitored_cr3 == TEMU_cpu_cr[3])) && (tc_stop_counter++ == tc_stop_at)) { tracing_start_condition = 0; if (gettimeofday(&trace_stop_time, 0) == 0) { term_printf("Trace ending time: %ld.%ld\n", trace_start_time.tv_sec, trace_start_time.tv_usec); term_printf("Total elapsed time: %ld usec\n", trace_stop_time.tv_sec*1000000 + trace_stop_time.tv_usec - trace_start_time.tv_sec*1000000 - trace_start_time.tv_usec); } /* remove the hook */ hookapi_remove_hook(tc_stop_hook_handle); } return 0; }
void vTestKernel(void *pvAddress) { char line[BUF_SIZE]; long type, id; while (1) { inet_printf("Input type and id for sensor reading.\r\n"); inet_gets(line, BUF_SIZE); sscanf(line, "%d %d", &type, &id); term_printf("sensor reading is: %d\r\n", sensor_read(type, id)); } }
void fuse_info(void) { uint8_t lowfuse, hifuse, extfuse, lockfuse; cli(); lowfuse = boot_lock_fuse_bits_get(GET_LOW_FUSE_BITS); hifuse = boot_lock_fuse_bits_get(GET_HIGH_FUSE_BITS); extfuse = boot_lock_fuse_bits_get(GET_EXTENDED_FUSE_BITS); lockfuse = boot_lock_fuse_bits_get(GET_LOCK_BITS); sei(); term_printf("\r\nFuses: l=%02X h=%02X e=%02X l=%02X\r\n", lowfuse, hifuse, extfuse, lockfuse); }
void ext2_init_fs() { load_superblock(); load_bgdt(); // Read the root inode, just for fun Ext2_inode root_inode; read_inode(&root_inode, ROOT_INODE); term_printf(" / creation time = %d\n", root_inode.creation_time); term_printf(" / uid = %d\n", root_inode.uid); term_printf(" / type & perms = 0x%X\n", root_inode.type_and_permissions); term_printf(" / size = %d\n", root_inode.size); // Enumerate the files in it term_puts(" / files:"); Ext2_file file; ext2_open_inode(ROOT_INODE, &file); Ext2_dirent dirent; while (ext2_next_dirent(&file, &dirent)) { term_printf(" inode %d, name `%s'\n", dirent.inode_num, dirent.name); } kfree(file.buf); // Look for a file term_putsn(" looking for file `/bar/baz/quux'..."); uint32_t inode = ext2_look_up_path("/bar/baz/quux"); if (inode == 0) term_puts(" not found"); else term_printf(" found: inode = %d\n", inode); }
void do_info_migrate(void) { MigrationState *s = current_migration; if (s) { term_printf("Migration status: "); switch (s->get_status(s)) { case MIG_STATE_ACTIVE: term_printf("active\n"); break; case MIG_STATE_COMPLETED: term_printf("completed\n"); break; case MIG_STATE_ERROR: term_printf("failed\n"); break; case MIG_STATE_CANCELLED: term_printf("cancelled\n"); break; } } }
void do_migrate(int detach, const char *uri) { MigrationState *s = NULL; const char *p; if (strstart(uri, "tcp:", &p)) s = tcp_start_outgoing_migration(p, max_throttle, detach); #if !defined(WIN32) else if (strstart(uri, "exec:", &p)) s = exec_start_outgoing_migration(p, max_throttle, detach); #endif else term_printf("unknown migration protocol: %s\n", uri); if (s == NULL) term_printf("migration failed\n"); else { if (current_migration) current_migration->release(current_migration); current_migration = s; } }
int tc_address_start_hook(void *opaque) { term_printf("tc_address_start_hook(*) called\n"); if ((tracing_kernel_all() || (temu_plugin->monitored_cr3 == TEMU_cpu_cr[3])) && (tc_start_counter++ == tc_start_at)) { tracing_start_condition = 1; tc_stop_counter = 0; // reset the tc_stop_counter at the execution saving /* remove the hook */ hookapi_remove_hook(cond_func_hook_handle); } return 0; }
void tc_address(uint32_t address) { /* Check if there is a conflict with conf_trace_only_after_first_taint */ if (conf_trace_only_after_first_taint) { term_printf("tc_address_start conflicts with " "conf_trace_only_after_first_taint\n" "Disabling conf_trace_only_after_first_taint\n"); conf_trace_only_after_first_taint = 0; } /* add a hook at address */ tracing_start_condition = 0; cond_func_hook_handle = hookapi_hook_function(0, address, tc_address_hook, NULL, 0); cond_func_address = address; }
// initialize a runtime config block void rtconfig_init_rtc(rtconfig_t *rtc, uint8_t devaddr) { // Default values rtc->device_address = devaddr; rtc->last_used_drive = 0; rtc->advanced_wildcards = false; rtc->errmsg_with_drive = true; if(nv_restore_config(rtc)) nv_save_config(rtc); if (num_rtcs < MAX_RTCONFIG) { rtcs[num_rtcs] = rtc; num_rtcs++; } else { term_printf("too many rtconfigs!\n"); } }
/* * Read sys file-system device file * * @line address of buffer to put file contents in * @line_size size of line * @device_file path to device file (printf format string) * @device_name device being opened (inserted into device_file) * * @return 0 failed, 1 succeeded ('line' contains data) */ static int usb_host_read_file(char *line, size_t line_size, const char *device_file, const char *device_name) { FILE *f; int ret = 0; char filename[PATH_MAX]; snprintf(filename, PATH_MAX, USBSYSBUS_PATH "/devices/%s/%s", device_name, device_file); f = fopen(filename, "r"); if (f) { fgets(line, line_size, f); fclose(f); ret = 1; } else { term_printf("husb: could not open %s\n", filename); } return ret; }
USBDevice *usb_host_device_open(const char *devname) { int bus_num, addr; char product_name[PRODUCT_NAME_SZ]; if (strstr(devname, "auto:")) { usb_host_auto_add(devname); return NULL; } if (usb_host_find_device(&bus_num, &addr, product_name, sizeof(product_name), devname) < 0) return NULL; if (hostdev_find(bus_num, addr)) { term_printf("husb: host usb device %d.%d is already open\n", bus_num, addr); return NULL; } return usb_host_device_open_addr(bus_num, addr, product_name); }
static void load_superblock() { uint16_t buf[SUPERBLOCK_LENGTH / 2]; // We can't just copy into superblock directly, as it isn't long enough read_abs_sectors(SUPERBLOCK_LBA, SUPERBLOCK_SECTORS, buf); memcpy(&superblock, buf, sizeof(Ext2_superblock)); block_size = 1024 << superblock.log2_block_size; num_groups = superblock.total_blocks / superblock.blocks_per_group; // Print some interesting stuff to check it loaded correctly ASSERT(superblock.signature == EXT2_SIGNATURE); term_printf(" total inodes = 0x%X\n", superblock.total_inodes); term_printf(" total blocks = 0x%X\n", superblock.total_blocks); term_printf(" block size = %b\n", block_size); term_printf(" num blocks = %d\n", superblock.total_blocks); term_printf(" blocks/group = %d\n", superblock.blocks_per_group); term_printf(" inodes/group = %d\n", superblock.inodes_per_group); term_printf(" num groups = %d\n", num_groups); }
/* update the displayed command line */ static void term_update(void) { int i, delta, len; if (term_cmd_buf_size != term_last_cmd_buf_size || memcmp(term_cmd_buf, term_last_cmd_buf, term_cmd_buf_size) != 0) { for(i = 0; i < term_last_cmd_buf_index; i++) { term_printf("\033[D"); } term_cmd_buf[term_cmd_buf_size] = '\0'; if (term_is_password) { len = strlen(term_cmd_buf); for(i = 0; i < len; i++) term_printf("*"); } else { term_printf("%s", term_cmd_buf); } term_printf("\033[K"); memcpy(term_last_cmd_buf, term_cmd_buf, term_cmd_buf_size); term_last_cmd_buf_size = term_cmd_buf_size; term_last_cmd_buf_index = term_cmd_buf_size; } if (term_cmd_buf_index != term_last_cmd_buf_index) { delta = term_cmd_buf_index - term_last_cmd_buf_index; if (delta > 0) { for(i = 0;i < delta; i++) { term_printf("\033[C"); } } else { delta = -delta; for(i = 0;i < delta; i++) { term_printf("\033[D"); } } term_last_cmd_buf_index = term_cmd_buf_index; } term_flush(); }