void i386_init(void) { extern char edata[], end[]; // Before doing anything else, complete the ELF loading process. // Clear the uninitialized global data (BSS) section of our program. // This ensures that all static/global variables start out zero. memset(edata, 0, end - edata); // Initialize the console. // Can't call cprintf until after we do this! cons_init(); cprintf("6828 decimal is %o octal!\n", 6828); // Lab 2 memory management initialization functions i386_detect_memory(); i386_vm_init(); page_init(); page_check(); // Lab 3 user environment initialization functions env_init(); idt_init(); // Lab 4 multitasking initialization functions pic_init(); kclock_init(); // Should always have an idle process as first one. ENV_CREATE(user_idle); // Start fs. ENV_CREATE(fs_fs); ENV_CREATE(user_icode); #if defined(TEST) // Don't touch -- used by grading script! ENV_CREATE2(TEST, TESTSIZE) #else // Touch all you want. // ENV_CREATE(user_icode); // ENV_CREATE(user_pipereadeof); // ENV_CREATE(user_pipewriteeof); // ENV_CREATE(user_testpipe); // ENV_CREATE(user_primespipe); // ENV_CREATE(user_testpiperace); // ENV_CREATE(user_testpiperace2); // ENV_CREATE(user_testfdsharing); #endif // TEST* // Should not be necessary - drain keyboard because interrupt has given up. kbd_intr(); // Schedule and run the first user environment! sched_yield(); }
void uart_init(uint8_t uart, __unused uint8_t interrupts) { /* no interrupts, only polling so far */ uart_reg_write(uart, IER, 0x00); if (uart == CONS_UART_NR) { cons_init(); } else { sercomm_init(); uart_irq_enable(uart, UART_IRQ_RX_CHAR, 1); } uart_reg_write(uart, AUTOBAUD_EN, 0x00); /* disable AUTOBAUD */ uart_reg_write(uart, EFR, 0x10); /* Enhanced Features Register */ /* no XON/XOFF flow control, ENHANCED_EN, no auto-RTS/CTS */ uart_reg_write(uart, EFR, (1 << 4)); /* enable Tx/Rx FIFO, Tx trigger at 56 spaces, Rx trigger at 60 chars */ //FIXME check those FIFO settings uart_reg_write(uart, IIR, FIFO_EN | RX_FIFO_CLEAR | TX_FIFO_CLEAR | (3 << TX_FIFO_TRIG_SHIFT) | (1 << RX_FIFO_TRIG_SHIFT)); /* RBR interrupt only when TX FIFO and TX shift register are empty */ uart_reg_write(uart, SCR, (1 << 0));// | (1 << 3)); /* 8 bit, 1 stop bit, no parity, no break */ uart_reg_write(uart, LCR, 0x03); uart_set_lcr7bit(uart, 0); }
void _benmain(void) { struct FIFO32 fifo; int keybuf[128]={0}; fifo32_init(&fifo, 128, keybuf); struct TSS32 tss_a = {0}; cons_init(); env_init(); /* keyboard setting */ init_kb(&fifo, 256); tss_a.ldtr = 0; tss_a.iomap = 0x40000000; set_segmdesc(gdt + 0, 103, (int) &tss_a, AR_TSS32); task_init(memman); /* Unfortunate try the switch back to 0*8 (_benmain) with farjmp but not working. * And the reason still unknown. * So that I use another thread_kb_io() to catch the keyboard interrupt. */ load_tr(0 * 8); // record current working task to tss_a task_create((int) &thread_kb_io, memman, "bshell", 1); task_create((int) &thread_events, memman, "events", 0); /* strange issue encountered if run pci_init at the setup_hw() */ puts("pci scan bus\n"); pci_init(); farjmp(0, 4*8); puts("\nSystem Halted \n"); _syshalt(); }
void i386_init(void) { extern char edata[], end[]; extern const uint32_t sctors[], ectors[]; const uint32_t *ctorva; // Initialize the console. // Can't call cprintf until after we do this! cons_init(); // Then call any global constructors. // This relies on linker script magic to define the 'sctors' and // 'ectors' symbols; see kern/kernel.ld. // Call after cons_init() so we can cprintf() if necessary. for (ctorva = ectors; ctorva > sctors; ) ((void(*)()) *--ctorva)(); cprintf("6828 decimal is %o octal!\n", 6828); // Lab 2 memory management initialization functions mem_init(); // Lab 2 interrupt and gate descriptor initialization functions idt_init(); // Test IDT (lab 2 only) __asm__ __volatile__("int3"); cprintf("Breakpoint succeeded!\n"); // Drop into the kernel monitor. while (1) monitor(NULL); }
void i386_init(void) { extern char edata[], end[]; // Before doing anything else, complete the ELF loading process. // Clear the uninitialized global data (BSS) section of our program. // This ensures that all static/global variables start out zero. memset(edata, 0, end - edata); // Initialize the console. // Can't call cprintf until after we do this! cons_init(); cprintf("6828 decimal is %o octal!\n", 6828); // Lab 2 memory management initialization functions mem_init(); // Lab 3 user environment initialization functions env_init(); trap_init(); #if defined(TEST) // Don't touch -- used by grading script! ENV_CREATE(TEST, ENV_TYPE_USER); #else // Touch all you want. ENV_CREATE(user_hello, ENV_TYPE_USER); #endif // TEST* // We only have one user environment for now, so just run it. env_run(&envs[0]); }
void i386_init(void) { extern char edata[], end[]; // Before doing anything else, complete the ELF loading process. // Clear the uninitialized global data (BSS) section of our program. // This ensures that all static/global variables start out zero. memset(edata, 0, end - edata); // Initialize the console. // Can't call cprintf until after we do this! cons_init(); cprintf("6828 decimal is %o octal!\n", 6828); // Lab 2 memory management initialization functions i386_detect_memory(); i386_vm_init(); page_init(); page_check(); // Drop into the kernel monitor. while (1) monitor(NULL); }
int kern_init(void) { extern char edata[], end[]; memset(edata, 0, end - edata); cons_init(); // init the console const char *message = "(THU.CST) os is loading ..."; kprintf ("%s\n\n", message); /* Only to initialize lcpu_count. */ mp_init (); pmm_init(); // init physical memory management pmm_init_ap (); pic_init(); // init interrupt controller vmm_init(); // init virtual memory management sched_init(); // init scheduler proc_init(); // init process table sync_init(); // init sync struct ide_init(); // init ide devices swap_init(); // init swap fs_init(); // init fs clock_init(); // init clock interrupt intr_enable(); // enable irq interrupt cpu_idle(); // run idle process }
void i386_init(void) { extern char edata[], end[]; // Lab1 only char chnum1 = 0, chnum2 = 0, ntest[256] = {}; // Before doing anything else, complete the ELF loading process. // Clear the uninitialized global data (BSS) section of our program. // This ensures that all static/global variables start out zero. memset(edata, 0, end - edata); // Initialize the console. // Can't call cprintf until after we do this! cons_init(); cprintf("6828 decimal is %o octal!%n\n%n", 6828, &chnum1, &chnum2); cprintf("pading space in the right to number 22: %-8d.\n", 22); cprintf("chnum1: %d chnum2: %d\n", chnum1, chnum2); cprintf("%n", NULL); memset(ntest, 0xd, sizeof(ntest) - 1); cprintf("%s%n", ntest, &chnum1); cprintf("chnum1: %d\n", chnum1); cprintf("show me the sign: %+d, %+d\n", 1024, -1024); // Lab 2 memory management initialization functions mem_init(); // Drop into the kernel monitor. while (1) monitor(NULL); }
static void handle_keypress(char c) { amr_t handler = c == 'G' ? __run_mon : __cons_add_char; send_kernel_message(core_id(), handler, (long)&cons_buf, (long)c, 0, KMSG_ROUTINE); cons_init(); }
void i386_init(void) { extern char edata[], end[]; // Before doing anything else, complete the ELF loading process. // Clear the uninitialized global data (BSS) section of our program. // This ensures that all static/global variables start out zero. memset(edata, 0, end - edata); // Initialize the console. // Can't call cprintf until after we do this! cons_init(); // int x = 1, y = 3, z = 4; // cprintf("x %d, y %x, z %d\n", x, y, z); // unsigned int i = 0x00646c72; // cprintf("H%x Wo%s\n", 57616, &i); // cprintf("x=%d y=%d", 3, 4); // cprintf("x=%d y=%d", 3); cprintf("6828 decimal is %o octal!\n", 6828); // Lab 2 memory management initialization functions mem_init(); // Drop into the kernel monitor. while (1) monitor(NULL); }
int main(void){ cli(); cons_init(); mm_init(); trap_init(); god_init(); }
int main( int argc, char* argv[] ) { FILE* f = stdout; if ( argc == 2 ) { f = fopen(argv[1], "r"); if( f==NULL || ferror(f) ) { printf("File didnt open or something.\n"); return -1;} } if ( argc > 2 ) { printf("Note: anything more then first argument is ignored."); } cons_init(1024); printf( "Initiated.\n" ); printf("File %s opened.\n", argv[1]); printf("Reading file.\n"); Obj obj=// read_obj(f); Obj_Cons(read_cons(f)); printf("Printing next.\n"); Obj_print(obj, printing_print,NULL); printf("\nClean up.\n"); Obj_exit(obj); printf("\nClosing file, de-initiating.\n"); if( argc==2 ){ fclose(f); } cons_exit(); }
/** * The entry. */ int main(int argc, char *argv[], char *envp[]) { if (ginfo->status == STATUS_DEBUG) raise(SIGTRAP); cons_init(); const char *message = "(THU.CST) os is loading ..."; kprintf("%s\n\n", message); intr_init(); ide_init(); host_signal_init(); /* Only to initialize lcpu_count. */ mp_init(); pmm_init(); pmm_init_ap(); vmm_init(); sched_init(); proc_init(); swap_init(); fs_init(); sync_init(); umclock_init(); cpu_idle(); host_exit(SIGINT); return 0; }
int __noreturn kern_init(void) { extern char edata[], end[]; memset(edata, 0, end - edata); cons_init(); // init the console const char *message = "(THU.CST) os is loading ..."; cprintf("%s\n\n", message); print_kerninfo(); pmm_init(); // init physical memory management pic_init(); // init interrupt controller idt_init(); // init interrupt descriptor table vmm_init(); // init virtual memory management sched_init(); // init scheduler proc_init(); // init process table sync_init(); // init sync struct ide_init(); // init ide devices swap_init(); // init swap fs_init(); // init fs clock_init(); // init clock interrupt intr_enable(); // enable irq interrupt cpu_idle(); // run idle process }
void i386_init(void) { extern char edata[], end[]; /* before doing anything else, complete the ELF loading process; clear the uninitialized global data (BSS) section of our program; this ensures that all static/global variables start out zero */ memset(edata, 0, end - edata); /* initialize the console; can't call cprintf until after we do this */ cons_init(); cprintf("\n*** Welcome to Jake, The Java Kernel! ***"); cprintf("\nCopyright (C) 2011. Enterprise Java Systems.\n\n"); /* test the stack backtrace function */ test_backtrace(5); /* memory setup */ i386_detect_memory(); i386_vm_init(); /* drop into the kernel monitor */ while (1) monitor(NULL); }
void i386_init(void) { extern char edata[], end[]; // Before doing anything else, complete the ELF loading process. // Clear the uninitialized global data (BSS) section of our program. // This ensures that all static/global variables start out zero. memset(edata, 0, end - edata); // Initialize the console. // Can't call cprintf until after we do this! cons_init(); cprintf("6828 decimal is %o octal!\n", 6828); //check page_alloc() this is a test,not my code check_page_alloc(); // Test the stack backtrace function (lab 1 only) test_backtrace(5); // Drop into the kernel monitor. while (1) monitor(NULL); }
int kern_init(void) { extern char edata[], end[]; memset(edata, 0, end - edata); cons_init(); // init the console const char *message = "(THU.CST) os is loading ..."; cprintf("%s\n\n", message); print_kerninfo(); grade_backtrace(); pic_init(); // init interrupt controller idt_init(); // init interrupt descriptor table pmm_init(); // init physical memory management vmm_init(); // init virtual memory management sched_init(); // init scheduler proc_init(); // init process table swap_init(); // init swap fs_init(); // init fs clock_init(); // init clock interrupt intr_enable(); // enable irq interrupt //LAB1: CAHLLENGE 1 If you try to do it, uncomment lab1_switch_test() // user/kernel mode switch test //lab1_switch_test(); cpu_idle(); // run idle process }
void i386_init(void) { extern char edata[], end[]; // Before doing anything else, complete the ELF loading process. // Clear the uninitialized global data (BSS) section of our program. // This ensures that all static/global variables start out zero. memset(edata, 0, end - edata); // Initialize the console. // Can't call cprintf until after we do this! cons_init(); cprintf("6828 decimal is %o octal!\n", 6828); // Lab 2 memory management initialization functions i386_detect_memory(); i386_vm_init(); // Lab 3 user environment initialization functions env_init(); idt_init(); // Lab 4 multitasking initialization functions pic_init(); kclock_init(); time_init(); pci_init(); // Should always have an idle process as first one. ENV_CREATE(user_idle); // Start fs. ENV_CREATE(fs_fs); #if !defined(TEST_NO_NS) // Start ns. ENV_CREATE(net_ns); #endif #if defined(TEST) // Don't touch -- used by grading script! ENV_CREATE2(TEST, TESTSIZE); #else // Touch all you want. // ENV_CREATE(net_testoutput); // ENV_CREATE(user_echosrv); // ENV_CREATE(user_httpd); // ENV_CREATE(user_writemotd); // ENV_CREATE(user_testfile); ENV_CREATE(user_icode); // ENV_CREATE(user_primes); #endif // TEST* // Schedule and run the first user environment! sched_yield(); }
void i386_init(void) { extern char edata[], end[]; // Before doing anything else, complete the ELF loading process. // Clear the uninitialized global data (BSS) section of our program. // This ensures that all static/global variables start out zero. memset(edata, 0, end - edata); // Initialize the console. // Can't call cprintf until after we do this! cons_init(); cprintf("6828 decimal is %o octal!\n", 6828); // Lab 2 memory management initialization functions mem_init(); // Lab 3 user environment initialization functions env_init(); trap_init(); // Lab 4 multiprocessor initialization functions mp_init(); lapic_init(); // Lab 4 multitasking initialization functions pic_init(); // Acquire the big kernel lock before waking up APs // Your code here: lock_kernel(); // Starting non-boot CPUs boot_aps(); // Start fs. ENV_CREATE(fs_fs, ENV_TYPE_FS); #if defined(TEST) // Don't touch -- used by grading script! ENV_CREATE(TEST, ENV_TYPE_USER); #else // Touch all you want. //<<<<<<< HEAD ENV_CREATE(user_icode, ENV_TYPE_USER); //======= // ENV_CREATE(user_dumbfork, ENV_TYPE_USER); //>>>>>>> lab4 #endif // TEST* // Should not be necessary - drains keyboard because interrupt has given up. kbd_intr(); // Schedule and run the first user environment! sched_yield(); }
int main(void){ cli(); cons_init(); printk("Welcome to NONE.\nVersion : "KERNEL_VERSION"\n"); mem_init(); trap_init(); god_init(); }
/* * null console initialization. This includes allocation of a new device and * a new tty. */ void nullcninit(struct consdev *cn) { static struct consdev nullcn = cons_init(null); nullcnprobe(&nullcn); cn_tab = &nullcn; }
void i386_init(void) { extern char edata[], end[]; // Before doing anything else, complete the ELF loading process. // Clear the uninitialized global data (BSS) section of our program. // This ensures that all static/global variables start out zero. memset(edata, 0, end - edata); // Initialize the console. // Can't call cprintf until after we do this! cons_init(); //bluesea //经测试,下面的语句会输出:edata f0114300, end f0114970 //因此,edata < end, [edata, end)之间是bss段, kernel需要用的global variable. // > end之后的内存可以用于boot_alloc //cprintf("edata %x, end %x\n", edata, end); cprintf("6828 decimal is %o octal!\n", 6828); // Lab 2 memory management initialization functions mem_init(); // Lab 3 user environment initialization functions env_init(); trap_init(); // Lab 4 multiprocessor initialization functions mp_init(); lapic_init(); // Lab 4 multitasking initialization functions pic_init(); // Acquire the big kernel lock before waking up APs // Your code here: lock_kernel(); // Starting non-boot CPUs boot_aps(); #if defined(TEST) // Don't touch -- used by grading script! ENV_CREATE(TEST, ENV_TYPE_USER); #else // Touch all you want. //ENV_CREATE(user_primes, ENV_TYPE_USER); //ENV_CREATE(user_yield, ENV_TYPE_USER); //ENV_CREATE(user_yield, ENV_TYPE_USER); //ENV_CREATE(user_yield, ENV_TYPE_USER); ENV_CREATE(user_dumbfork, ENV_TYPE_USER); #endif // TEST* // Schedule and run the first user environment! sched_yield(); }
void i386_init(void) { extern char edata[], end[]; // Before doing anything else, complete the ELF loading process. // Clear the uninitialized global data (BSS) section of our program. // This ensures that all static/global variables start out zero. memset(edata, 0, end - edata); // Initialize the console. // Can't call cprintf until after we do this! cons_init(); cprintf("372 decimal is %o octal!\n", 372); // Lab 2 memory management initialization functions mem_init(); // Lab 3 user environment initialization functions env_init(); trap_init(); // Lab 4 multiprocessor initialization functions mp_init(); lapic_init(); // Lab 4 multitasking initialization functions pic_init(); // Acquire the big kernel lock before waking up APs // Your code here: lock_kernel(); // Starting non-boot CPUs boot_aps(); // Should always have idle processes at first. int i; for (i = 0; i < NCPU; i++) ENV_CREATE(user_idle, ENV_TYPE_IDLE); // ENV_CREATE(user_yield, ENV_TYPE_USER); // ENV_CREATE(user_yield, ENV_TYPE_USER); // ENV_CREATE(user_yield, ENV_TYPE_USER); #if defined(TEST) // Don't touch -- used by grading script! ENV_CREATE(TEST, ENV_TYPE_USER); #else // Touch all you want. ENV_CREATE(user_primes, ENV_TYPE_USER); #endif // TEST* // Schedule and run the first user environment! sched_yield(); }
static void fakecninit(void) { static struct consdev fakecntab = cons_init(sacom); cn_tab = &fakecntab; (*cn_tab->cn_init)(0); cn_tab->cn_pri = CN_REMOTE; }
static void handle_keypress(char c) { /* brho: not sure if this will work on riscv or not... */ #define capchar2ctl(x) ((x) - '@') amr_t handler = c == capchar2ctl('G') ? __run_mon : __cons_add_char; send_kernel_message(core_id(), handler, (long)&cons_buf, (long)c, 0, KMSG_ROUTINE); cons_init(); }
/* * driver's main function. */ int XXXmain(void) { if (cons_init()) return (-1); print_string("[teton] initialised\n"); return 0; }
// The kernel main function. Initialize everything and start the kernel // debugger. The two arguments are the physical address of the Multiboot info // structure and the bootloader magic number respectively. void init() { int r; // Initialize the console first to print messages during the initialization cons_init(); kprintf("Argentum Operating System\n"); arch_init(); kmem_cache_init(); kmem_cache_sizes_init(); vm_init(); process_init(); thread_init(); ipc_init(); scheduler_init(); sync_init(); clock_init(); if ((r = process_create_system(system_main, NULL)) < 0) kprintf("Cannot create system process: %s\n", strerror(-r)); if (module_start) { Boot_image *image = (Boot_image *) module_start; if(image->magic != 0x12345678) panic("invalid bootimage"); for (unsigned i = 0; i < image->length; i++) { uint8_t *binary = (uint8_t *) image + image->headers[i].offset; size_t size = image->headers[i].length; if (binary < module_start || binary >= module_end) panic("invalid bootimage"); if ((binary + size) <= module_start || (binary + size) > module_end) panic("invalid bootimage"); r = process_create((uint8_t *) image + image->headers[i].offset, image->headers[i].length, PROCESS_TYPE_USER, NULL); if (r < 0) panic("Cannot create process: %s", strerror(-r)); } } scheduler_start(); for (;;) { kdb_main(NULL); } }
void uart_init(uint8_t uart, uint8_t interrupts) { uint8_t irq = uart2irq[uart]; uart_reg_write(uart, IER, 0x00); if (uart == cons_get_uart()) { cons_init(); if(interrupts) { irq_register_handler(irq, &uart_irq_handler_cons); irq_config(irq, 0, 0, 0xff); irq_enable(irq); } } else if (uart == sercomm_get_uart()) { sercomm_init(); if(interrupts) { irq_register_handler(irq, &uart_irq_handler_sercomm); irq_config(irq, 0, 0, 0xff); irq_enable(irq); } uart_irq_enable(uart, UART_IRQ_RX_CHAR, 1); } else { return; } #if 0 if (uart == 1) { /* assign UART to MCU and unmask interrupts*/ writeb(UART_REG_UIR, 0x00); } #endif /* if we don't initialize these, we get strange corruptions in the received data... :-( */ uart_reg_write(uart, MDR1, 0x07); /* turn off UART */ uart_reg_write(uart, XON1, 0x00); /* Xon1/Addr Register */ uart_reg_write(uart, XON2, 0x00); /* Xon2/Addr Register */ uart_reg_write(uart, XOFF1, 0x00); /* Xoff1 Register */ uart_reg_write(uart, XOFF2, 0x00); /* Xoff2 Register */ uart_reg_write(uart, EFR, 0x00); /* Enhanced Features Register */ /* select UART mode */ uart_reg_write(uart, MDR1, 0); /* no XON/XOFF flow control, ENHANCED_EN, no auto-RTS/CTS */ uart_reg_write(uart, EFR, (1 << 4)); /* enable Tx/Rx FIFO, Tx trigger at 56 spaces, Rx trigger at 60 chars */ uart_reg_write(uart, FCR, FIFO_EN | RX_FIFO_CLEAR | TX_FIFO_CLEAR | (3 << TX_FIFO_TRIG_SHIFT) | (3 << RX_FIFO_TRIG_SHIFT)); /* THR interrupt only when TX FIFO and TX shift register are empty */ uart_reg_write(uart, SCR, (1 << 0));// | (1 << 3)); /* 8 bit, 1 stop bit, no parity, no break */ uart_reg_write(uart, LCR, 0x03); uart_set_lcr7bit(uart, 0); }
void x86_boot(struct multiboot_info *mbi) { cons_init(); bmk_printf("rump kernel bare metal bootstrap\n\n"); cpu_init(); bmk_sched_init(); multiboot(mbi); spl0(); bmk_sched_startmain(bmk_mainthread, multiboot_cmdline); }
void __noreturn kern_init(void) { //setup_exception_vector(); tlb_invalidate_all(); /* unsigned base = 0xBE000000; int i, j; for (j = 10; j < 24; ++j) { kprintf("\nj=%d\n\n\n", j); for (i = 0; i < 10; ++i) { int *addr = (int*)(base + i * 4 + (1 << j)); kprintf("0x%08x=0x%04x\n", addr, (*addr)&0xFFFF); } } */ pic_init(); // init interrupt controller cons_init(); // init the console clock_init(); // init clock interrupt // panic("init"); check_initrd(); const char *message = "(THU.CST) os is loading ...\n\n"; kprintf(message); print_kerninfo(); #if 0 kprintf("EX\n"); __asm__ volatile("syscall"); kprintf("EX RET\n"); #endif pmm_init(); // init physical memory management vmm_init(); // init virtual memory management sched_init(); proc_init(); // init process table ide_init(); fs_init(); intr_enable(); // enable irq interrupt //*(int*)(0x00124) = 0x432; //asm volatile("divu $1, $1, $1"); cpu_idle(); }