void start(void) { const char *s; int whichprocess; pid_t i; // Initialize process descriptors as empty memset(proc_array, 0, sizeof(proc_array)); for (i = 0; i < NPROCS; i++) { proc_array[i].p_pid = i; proc_array[i].p_state = P_EMPTY; } // The first process has process ID 1. current = &proc_array[1]; // Set up x86 hardware, and initialize the first process's // special registers. This only needs to be done once, at boot time. // All other processes' special registers can be copied from the // first process. segments_init(); special_registers_init(current); // Erase the console, and initialize the cursor-position shared // variable to point to its upper left. console_clear(); // Figure out which program to run. cursorpos = console_printf(cursorpos, 0x0700, "Type '1' to run mpos-app, or '2' to run mpos-app2."); do { whichprocess = console_read_digit(); } while (whichprocess != 1 && whichprocess != 2); console_clear(); // Load the process application code and data into memory. // Store its entry point into the first process's EIP // (instruction pointer). program_loader(whichprocess - 1, ¤t->p_registers.reg_eip); // Set the main process's stack pointer, ESP. current->p_registers.reg_esp = PROC1_STACK_ADDR + PROC_STACK_SIZE; // Mark the process as runnable! current->p_state = P_RUNNABLE; // Switch to the main process using run(). run(current); }
// returns zero if char must not be echoed on the screen static inline int _putc(char c, bool display) { switch (c) { case '\n': _line_feed(); break; case '\t': _tab(); break; case '\r': _kill(); break; case 127: console_clear(); break; case '\b': _del_ibuf(); break; default: // not a control character if (display) _putc_attr(c, _.attr); return 1; } return 0; }
void erasure_tool_run() { keyboard_register_key_down(handle_down); console_clear(); console_puts("Welcome to K-OS!\n\nCopyright (c) 2013 Keeley Hoek\nAll rights reserved.\n\n"); console_puts("THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\n"); console_puts("ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n"); console_puts("WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n"); console_puts("DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR\n"); console_puts("ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n"); console_puts("(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n"); console_puts("LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n"); console_puts("ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n"); console_puts("(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\n"); console_puts("SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n"); console_puts("\n\n\n\n\n\n\n"); console_puts("If you do not agree to the above terms TURN THE COMPUTER OFF NOW.\n"); console_puts("If you do agree to the above terms press enter to continue."); beep(); wait_for_enter(); main_menu(); }
int kern_entry() { init_debug(); console_clear(); printk_color(rc_black, rc_green, "Hello, OS kernel!\n"); //panic("test"); printk("kernel in memory start: 0x%08X\n", kern_start); printk("kernel in memory end: 0x%08X\n", kern_end); printk("kernel in memory used: %d KB\n\n", (kern_end - kern_start) / 1024); show_memory_map(); init_pmm(); printk_color(rc_black, rc_red, "\nThe Count of Physical Memory Page is: %u\n\n", phy_page_count); uint32_t allc_addr = NULL; printk_color(rc_black, rc_light_brown, "Test Physical Memory Alloc :\n"); allc_addr = pmm_alloc_page(); printk_color(rc_black, rc_light_brown, "Alloc Physical Addr: 0x%08X\n", allc_addr); allc_addr = pmm_alloc_page(); printk_color(rc_black, rc_light_brown, "Alloc Physical Addr: 0x%08X\n", allc_addr); allc_addr = pmm_alloc_page(); printk_color(rc_black, rc_light_brown, "Alloc Physical Addr: 0x%08X\n", allc_addr); allc_addr = pmm_alloc_page(); printk_color(rc_black, rc_light_brown, "Alloc Physical Addr: 0x%08X\n", allc_addr); return 0; }
// Usage: same as printf except the first two parameters specify // the (column, row) of the display where print is to begin. // Excess print to a line is truncated. void display_printf(int col, int row, const char *t, ...) { // variadic function va_list argp; // variadic argument list pointer for vsprintf int i, maxw; // maxw marks available room on row int rb6=__VBUTTONS; // row adjustment (default is 2, if there are no buttons, change to 0) char *dp, ws[256]; // pointer into display map, working string for vsprintf va_start (argp,t); // t is last named argument in display_printf's function header; // Note: system macro va_start points argp to first variadic arg for vsprintf if (get_extra_buttons_visible()) rb6=4; if (col >= _MAPx) {row = row+1; col = 0;} // bad col so wrap to next line if (row >= _MAPy) row = _MAPy - 1; // bad row so (over) print on last line console_clear(); // ready the display if (_initialize_ == 1) {display_clear(); _initialize_=0;} // clear map to spaces on first call dp = &_display_map[row][col]; // starting point for printf maxw=_MAPx - col - 1; // space remaining on line vsprintf(ws, t, argp); // same as sprintf except requires a pointer to argument list for(i=0; i<strlen(ws); i++) { // insert formatted phrase in display map if (maxw==0) break; // if no more room get out of this *dp = ws[i]; // insert next character from working string dp++; maxw--; } va_end(argp); // clean up for(i=0; i< _MAPy-rb6-1; i++) printf("%s\n",_display_map[i]); // refresh the display printf("%s",_display_map[i]); // last line printed without new line }
/* * Clear the screen, forgetting the current contents in the process. */ void scr_clear(void) { resume_normal(); console_clear(console); curscore = -1; memset(curscreen, 0, sizeof(curscreen)); }
// remote autostart void script_autostart() { kbd_blocked = 1; gui_kbd_enter(); console_clear(); script_console_add_line("***Autostart***"); //lang_str(LANG_CONSOLE_TEXT_STARTED)); script_start_gui( 1 ); }
void start(void) { int i; // Set up hardware (schedos-x86.c) segments_init(); interrupt_controller_init(0); console_clear(); // Initialize process descriptors as empty memset(proc_array, 0, sizeof(proc_array)); for (i = 0; i < NPROCS; i++) { proc_array[i].p_pid = i; proc_array[i].p_state = P_EMPTY; } // Set up process descriptors (the proc_array[]) queue_t frontground = initQueue(); queue_t background = initQueue(); for (i = 1; i < NPROCS; i++) { process_t *proc = &proc_array[i]; uint32_t stack_ptr = PROC1_START + i * PROC_SIZE; // Initialize the process descriptor special_registers_init(proc); // Set ESP proc->p_registers.reg_esp = stack_ptr; // Load process and set EIP, based on ELF image program_loader(i - 1, &proc->p_registers.reg_eip); // Mark the process as runnable! proc->p_state = P_RUNNABLE; } // Initialize the cursor-position shared variable to point to the // console's first character (the upper left). cursorpos = (uint16_t *) 0xB8000; // Initialize the scheduling algorithm. // USE THE FOLLOWING VALUES: // 0 = the initial algorithm // 2 = strict priority scheduling (exercise 2) // 41 = p_priority algorithm (exercise 4.a) // 42 = p_share algorithm (exercise 4.b) // 7 = any algorithm that you may implement for exercise 7 scheduling_algorithm = 7; // Switch to the first process. run(&proc_array[1]); // Should never get here! while (1) /* do nothing */; }
int init(uint32_t mboot_magic, multiboot_info_t *mboot_info) { // Header console_clear(); DEBUG("------------------------------------------\n"); DEBUG("Welcome to Hydrogen AMD64 Loader 0.1\n"); DEBUG("Copyright (c) 2011 by Lukas Heidemann\n"); DEBUG("------------------------------------------\n"); // Check multiboot magic if (mboot_magic != MULTIBOOT_BOOTLOADER_MAGIC) PANIC("Bad multiboot magic value supplied by bootloader.\n" "Please make sure, that your bootloader implements the Multiboot specification" " in version 1 or higher."); // Parse boot info and relocate modules boot_info_t *info = boot_info_parse(mboot_info); frame_placement = memalign(boot_modules_relocate(info, (uintptr_t) &end), 0x1000); boot_modules_map(info); DEBUG("Boot loader name: "); DEBUG((int8_t *) (uintptr_t) info->loader_name); DEBUG("\nLoader arguments: "); DEBUG((int8_t *) (uintptr_t) mboot_info->cmdline); DEBUG("\n"); // Find the kernel module boot_info_mod_t *kernel_mod = _boot_find_kernel(info); if (0 == kernel_mod) PANIC("Could not find kernel binary.\n" "The Hydrogen AMD64 loader expects an ELF64 kernel binary to be given as a " "module with the name '/boot/kernel.bin'. Please make sure that your kernel " "binary is named as such and is passed by the bootloader."); // Map system structures memory_map_system(info); // Load the kernel uint16_t pflags = PAGE_FLAG_GLOBAL; info->entry_point = binary_load_elf64((void *) (uintptr_t) kernel_mod->address, pflags); DEBUG("Kernel Entry Point: "); DEBUG_HEX(info->entry_point); DEBUG("\n"); // Set beginning of free memory info->free_mem_begin = memalign(frame_placement, 0x1000); // Prepare long mode trampoline code boot_trampoline_callback = info->entry_point; // Relocate info structure to higher half boot_info_relocate(info, MEMORY_BOOT_INFO_VADDR); return 0; }
static void print_header() { console_clear(); console_puts("Welcome to the K-OS Secure Data Erasure Tool!\n\nCopyright (c) 2013 Keeley Hoek\nAll rights reserved.\n\n"); console_color(0x0C); console_puts("WARNING: "); console_color(0x07); console_puts("This software irreversably and indescriminatley destroys data.\n\n"); }
void kernel_main(multiboot_info_t *mbd, uint32_t magic) { //********************************************************* // First things first. Parse the command line. Quick guide: // // o quiet - Don't print so much stuff to the screen during boot // o silent - Don't print anything at all during boot (implies quiet) // o eshell - (RESERVED) Will be used to enter emergency shell // if (string_contains( (char*)(mbd->cmdline) , "quiet")) KERNEL_OPTION_QUIET = TRUE; if (string_contains( (char*)(mbd->cmdline) , "silent")) { KERNEL_OPTION_QUIET = TRUE; KERNEL_OPTION_SILENT = TRUE; } if (string_contains( (char*)(mbd->cmdline) , "eshell")) KERNEL_OPTION_ESHELL = TRUE; //********************************************************* //********************************************************* // Do some important things before we forget k_tally_available_memory(mbd); // Init the text console and colours console_init(); console_set_colors(COLOR_BRIGHT_GRAY, COLOR_BLACK); console_swap_colors(); console_set_colors(COLOR_BRIGHT_GRAY, COLOR_BLACK); console_clear(); //********************************************************* if (!KERNEL_OPTION_QUIET) { // Print some stuff about the environment console_print("Here is kernel_main()\n"); console_print("Bootloader: %s\n",mbd->boot_loader_name); console_print("Kernel: %s\n",mbd->cmdline); console_print("Flags: %b\n",mbd->flags); console_print("Boot Device: %x\n",mbd->boot_device); // Dump some info about the memory blocks/regions available/reserved k_dump_memory_blocks(mbd); } if (!KERNEL_OPTION_SILENT) { console_print("Welcome to Toast v%d.%d (nickname '%s')\nMemory: %dMiB", KERNEL_VERSION_MAJ, KERNEL_VERSION_MIN, KERNEL_NICKNAME, TOTAL_MEMORY/1048576); } //panic(0x4655434B); // (TEST) testing panic }
void start(void) { int i; // Set up hardware (schedos-x86.c) segments_init(); interrupt_controller_init(1); console_clear(); // Initialize process descriptors as empty memset(proc_array, 0, sizeof(proc_array)); for (i = 0; i < NPROCS; i++) { proc_array[i].p_pid = i; proc_array[i].p_state = P_EMPTY; } // Set up process descriptors (the proc_array[]) for (i = 1; i < NPROCS; i++) { process_t *proc = &proc_array[i]; uint32_t stack_ptr = PROC1_START + i * PROC_SIZE; // Initialize proportional scheduling vars proc->p_share = 1; proc->p_run_t = 0; // Initialize the process descriptor special_registers_init(proc); // Set ESP proc->p_registers.reg_esp = stack_ptr; // Load process and set EIP, based on ELF image program_loader(i - 1, &proc->p_registers.reg_eip); // Mark the process as runnable! proc->p_state = P_RUNNABLE; } // Initialize the cursor-position shared variable to point to the // console's first character (the upper left). cursorpos = (uint16_t *) 0xB8000; // Initialize the scheduling algorithm. scheduling_algorithm = 0; // Switch to the first process. run(&proc_array[1]); // Should never get here! while (1) /* do nothing */; }
void console_setup() { /* In console mode the buffer is used like a text console. Scrolling is implemented by changing the line numbers in each packet. The whole buffer is sent repeatedly. */ tt_buffer[0][0] = 0x2; tt_buffer[0][1] = 0x15; tt_buffer[0][2] = 0x15; tt_buffer[0][3] = 0x15; tt_buffer[0][4] = 0x15; tt_buffer[0][5] = 0x15; tt_buffer[0][6] = 0x15; tt_buffer[0][7] = 0x15; tt_buffer[0][8] = 0x15; tt_buffer[0][9] = 0x15; tt_buffer[0][10] = parity('A'); tt_buffer[0][11] = parity('V'); tt_buffer[0][12] = parity('R'); tt_buffer[0][13] = parity(' '); tt_buffer[0][14] = parity('T'); tt_buffer[0][15] = parity('e'); tt_buffer[0][16] = parity('x'); tt_buffer[0][17] = parity('t'); tt_buffer[0][18] = 0x20; tt_buffer[0][19] = 0x31; tt_buffer[0][20] = 0xb0; tt_buffer[0][21] = 0xb0; tt_buffer[0][22] = 0x20; tt_buffer[0][23] = 0x54; tt_buffer[0][24] = 0x75; tt_buffer[0][25] = 0xe5; tt_buffer[0][26] = 0x20; tt_buffer[0][27] = 0x31; tt_buffer[0][28] = 0x37; tt_buffer[0][29] = 0x20; tt_buffer[0][30] = 0x4a; tt_buffer[0][31] = 0x61; tt_buffer[0][32] = 0x6e; tt_buffer[0][33] = 0x83; tt_buffer[0][34] = 0x32; tt_buffer[0][35] = 0x31; tt_buffer[0][36] = 0xba; tt_buffer[0][37] = 0xb5; tt_buffer[0][38] = 0xb0; tt_buffer[0][39] = 0x2f; tt_buffer[0][40] = 0xb3; tt_buffer[0][41] = 0xb6; console_clear(); buffer_head = NBUFFERS; // Will never be reached. }
int kern_entry() { init_debug(); console_clear(); printk_color(rc_black, rc_green, "Hello, OS kernel!\n"); panic("test"); return 0; }
void console_init(void) { mddi_init(); cmaxx = fb_width / 6; cmaxy = (fb_height-1) / 12; cx = 0; cy = 0; console_clear(); console_flush(); }
//----------------------------------------------- // Display module load/unload error message on console static void moduleload_error(const char* name, const char* text) { extern volatile int chdk_started_flag; if (chdk_started_flag) { char buf[100]; sprintf(buf, "Fail to load %s: %s", name, text); console_clear(); console_add_line(buf); msleep(1000); } }
void console_init(void *base_address, unsigned int width, unsigned int height) { frame_buffer = static_cast<unsigned int*>(base_address); fb_width = width; fb_height = height; num_cols = width / GLYPH_WIDTH; num_rows = height / (GLYPH_HEIGHT * 2); bg_color = 0; fg_color = 0xffffffff; current_col = 0; current_row = 0; console_clear(); }
/** * @brief Initialize the console * * Initialize the console system. This will initialize the video properly, so * a call to the display_init() fuction is not necessary. */ void console_init() { /* In case they initialized the display already */ display_close(); display_init( RESOLUTION_320x240, DEPTH_16_BPP, 2, GAMMA_NONE, ANTIALIAS_RESAMPLE ); render_buffer = malloc(CONSOLE_SIZE); console_clear(); console_set_render_mode(RENDER_AUTOMATIC); /* Register ourselves with newlib */ hook_stdio_calls( &console_calls ); }
static void console_init() { console_clear(); #ifdef CONSOLE_DEBUG menu_add( "Debug", script_menu, COUNT(script_menu) ); msleep(500); if (!console_log_file) { console_log_file = FIO_CreateFileEx(CARD_DRIVE "ML/LOGS/console.log"); } #endif }
static void run_script(const char *script) { extern int ml_started; while (!ml_started) msleep(100); // for startup scripts script_state = SCRIPT_RUNNING; msleep(500); console_clear(); console_show(); console_set_help_text("SET: show/hide"); console_set_status_text("Script running..."); int exit_code = tcc_compile_and_run(get_script_path(script_selected)); if (exit_code == 0) { console_puts( "Script finished.\n"); } else { console_printf( "Script error: %d.\n", exit_code); msleep(500); gui_stop_menu(); msleep(500); console_show(); } // restore some settings to normal, if script changed them //~ script_cleanup_af(); bmp_draw_to_idle(0); canon_gui_enable_front_buffer(0); beep(); script_state = SCRIPT_JUST_FINISHED; console_set_status_text("Script finished. "); msleep(500); redraw(); msleep(500); for (int i = 0; i < 100; i++) { msleep(100); if (gui_menu_shown()) break; if (get_halfshutter_pressed()) break; } console_hide(); script_state = SCRIPT_IDLE; console_set_status_text(""); }
int console_init(void) { _.attr = ATTR_GREEN_ON_BLACK; _.curs_x = _.curs_y = 0; _.line_completed = false; _.widx = 0; console_clear(); if (keyboard_init()) return 1; return 0; }
int32_t console_init(void) { uint32_t i = 0; /* reset column and line to 0 */ g_console_column = g_console_line = 0; /* init static and global variable */ console_lastline = 0; console_clear(); for (i = 1; i < CONSOLE_VIDEO_BUFFER_S; i+=2) g_console_video[i] = FG_WHITE | BG_BLACK | FG_INTENSITY; return ERR_NONE; }
int kern_entry() { init_debug(); init_gdt(); init_idt(); console_clear(); printk_color(rc_black, rc_green, "Hello, OS kernel!\n"); init_timer(200); // 开启中断 asm volatile ("sti"); return 0; }
static u08 cmd_erase(const u08 *cmd, u08 len) { if(len > 2) { return CMD_SYNTAX_ERR; } u08 col = 0; if(len == 2) { if(!parse_nybble(cmd[1],&col)) { return CMD_NO_NYBBLE; } } console_t *c = console_get_current(); console_clear(c, col); return CMD_OK; }
void load_rom(file_descr_t *entry) { file_t file; int i; DWORD size; console_clear(); console_puts("Loading "); for (i=0; i<8; i++) { console_putc(entry->name[i]); } console_putc('.'); for (i=8; i<11; i++) { console_putc(entry->name[i]); } console_puts("\n\n"); fat_open_file(&file, entry->cluster); size = 0; while (1) { UBYTE* data; if ((size&0x3fff)==0) { // switch page 1 *((UBYTE*)0xffff) = (size>>14)&0xff; } // write to page 2 data = 0x8000+(size&0x3fff); data = fat_load_file_sector(&file,data); if (data==0) { console_puts("Error while reading file\n"); } else if (data==FAT_EOF) { console_gotoxy(0,2); return; } else { // process data size += 0x200; if ((size)%16384 == 0) console_puts("."); //console_gotoxy(0,3); //console_print_dword(size); //console_puts(" bytes loaded"); } }
/* choices is null terminated. Return the index of the choosen item, or -1 if escape was pressed.*/ int select_mode(char *header, char *choices[]) { int i, key, choice = 0; while (1) { console_clear(); console_write(header); console_write("\n"); for (i = 0; choices[i]; i++) { if (choice == i) console_write("*"); else console_write(" "); console_write(choices[i]); console_write("\n"); } console_frame(); key = wait_for_key(); switch (key) { case SDLK_UP: choice--; if (choice < 0) { /* seek last item */ choice = 0; while (choices[choice + 1] != 0) choice++; } break; case SDLK_DOWN: choice++; if (choices[choice] == 0) choice = 0; break; case SDLK_ESCAPE: return -1; default: return choice; } } }
THREAD_RAC play_thread(void *arg) { void *handle; snd__(init, &handle); size_t remain, done, cur_id = 0; void *ptr; pcm *str = arg; volatile unsigned char *sync = str->update + cur_id; while (!*sync); *sync = 0; MUTEX_LOCK(str->mutex + cur_id); while(1) { remain = str->period; ptr = str->buf + cur_id * str->period * CHANNELS * BITS / 8; if (str->update[cur_id]) { console_clear(); #ifdef _WIN32 SetConsoleTitleA(str->name); #else fputs("\e]0;", stdout); fputs(str->name, stdout); fputs("\a", stdout); #endif fputs("Now playing... ", stdout); fputs(str->name, stdout); fputc('\n', stdout); free(str->name); str->name = NULL; str->update[cur_id] = 0; } while(remain > 0) { if(exit_signal) break;//TODO done = snd__(write, handle, ptr, remain); if(done < 0) continue; ptr += done * CHANNELS * BITS / 8; remain -= done; } exit_signal = 0;//TODO if(force_exit_signal) break; cur_id++; cur_id = cur_id & str->buf_max; MUTEX_LOCK(str->mutex + cur_id); MUTEX_UNLOCK(str->mutex + ((cur_id - 1) & str->buf_max)); }
void kernel_init() { init_gdt(); init_idt(); init_debug(); init_mm(); init_vmm(); init_heap(); init_sched(); console_clear(); cprintk(rc_light_brown, "Welcome to SuperSong's OS, version: %s\n\n", "v0.1"); init_timer(200); cprintk(rc_light_cyan, "kernel in memory start: 0x%x\n", __kernel_mem_start); cprintk(rc_light_cyan, "kernel in memory end: 0x%x\n", __kernel_mem_end); cprintk(rc_light_cyan, "kernel in memory_used: %d KBs\n", (__kernel_mem_end - __kernel_mem_start + 1023) / 1024); show_memory_map(); cprintk(rc_red, "\nThe count of physical memory pages is: %d\n\n", phy_page_count); kthread_create(thread, NULL); enable_intr(); while (1) { cprintk(rc_red, "Thraed1\n"); } while (1) { __asm__ volatile ("hlt"); } }
static void console_refresh (void) { if (!HEADLESS && !enable_console) { return; } static char tmp[MAXSTR]; static char cursor_char[2] = { '_', '\0' }; strlcpy(tmp, wid_text, cursor_x + 1); strlcat(tmp, cursor_char, sizeof(tmp)); strlcat(tmp, wid_text + cursor_x, sizeof(tmp)); console_clear(); term_goto(0, TERM_HEIGHT - 1); term_putf("gorynlich> "); term_putf(tmp); term_putf(" "); term_refresh(); }
static void print_tech_info() { console_clear(); print_header(); console_color(0x0E); console_puts("Technical Information\n"); console_color(0x07); console_puts("The K-OS Secure Data Erasure Tool works by repeatadly writing over the contents of attached ATA drives. "); console_puts("Normal HDD erasure involves (a maximum of) a single pass over the drive where all bits are set to zero."); console_puts("\n\nIt has been postulated by some that the \"deleted\" bits of the HDD could potentially be recovered, and so this method of deletion is not very secure. "); console_puts("This tool attempts to remedy the problem by providing a simple means of overwriting HDDs using multiple passes. "); console_puts("Simply enter the number of passes that you would like the tool to write, and it will do the rest for you."); console_puts("\n\nFor every odd pass, the tool will write zeroes to the disk, and for every even pass, the tool will write ones to the disk."); console_puts("\n\n\n\n\nPress \"ENTER\" go back."); wait_for_enter(); }