/* This file contains the main program of MINIX as well as its shutdown code. * The routine main() initializes the system and starts the ball rolling by * setting up the process table, interrupt vectors, and scheduling each task * to run to initialize itself. * The routine prepare_shutdown() tries to cleanly shuts down MINIX by running * the stop_sequence() to notify all system services and allowing them some * time to finalize. In case of an exception(), the stop sequence is skipped. * * The entries into this file are: * main: MINIX main program * prepare_shutdown: prepare to take MINIX down * stop_sequence: take down all system services * * Changes: * Nov 24, 2004 simplified main() with system image (Jorrit N. Herder) * Oct 21, 2004 moved copyright to announce() (Jorrit N. Herder) * Sep 04, 2004 created stop_sequence() to cleanup (Jorrit N. Herder) * Aug 20, 2004 split wreboot() and shutdown() (Jorrit N. Herder) * Jun 15, 2004 moved wreboot() to this file (Jorrit N. Herder) */ #include "kernel.h" #include #include #include #include #include #include "proc.h" #include "sendmask.h" /* Prototype declarations for PRIVATE functions. */ FORWARD _PROTOTYPE( void announce, (void)); FORWARD _PROTOTYPE( void shutdown, (int how)); #define STOP_TICKS (5*HZ) /* time allowed to stop */ /*===========================================================================* * main * *===========================================================================*/ PUBLIC void main() { /* Start the ball rolling. */ register struct proc *rp; register int i; int hdrindex; /* index to array of a.out headers */ phys_clicks text_base, bootdev_base; vir_clicks text_clicks, bootdev_clicks; vir_clicks data_clicks; reg_t ktsb; /* kernel task stack base */ struct memory *memp; struct system_image *ttp; struct exec e_hdr; /* for a copy of an a.out header */ /* Initialize the interrupt controller. */ intr_init(1); /* Clear the process table. Anounce each slot as empty and * set up mappings for proc_addr() and proc_number() macros. */ for (rp = BEG_PROC_ADDR, i = -NR_TASKS; rp < END_PROC_ADDR; ++rp, ++i) { rp->p_type = P_NONE; /* isemptyp() tests on this */ rp->p_nr = i; /* proc number from ptr */ (pproc_addr + NR_TASKS)[i] = rp; /* proc ptr from number */ } /* Set up proc table entries for tasks and servers. The stacks of the * kernel tasks are initialized to an array in data space. The stacks * of the servers have been added to the data segment by the monitor, so * the stack pointer is set to the end of the data segment. All the * processes are in low memory on the 8086. On the 386 only the kernel * is in low memory, the rest is loaded in extended memory. */ /* Task stacks. */ ktsb = (reg_t) t_stack; for (i=0; i < IMAGE_SIZE; ++i) { ttp = &image[i]; /* t's task attributes */ rp = proc_addr(ttp->proc_nr); /* t's process slot */ kstrncpy(rp->p_name, ttp->proc_name, PROC_NAME_LEN); /* set name */ rp->p_type = ttp->type; /* type of process */ rp->p_priority = ttp->priority; /* scheduling priority */ rp->p_sendmask = ttp->sendmask; /* sendmask protection */ if (i-NR_TASKS < 0) { /* part of the kernel? */ if (ttp->stksize > 0) { /* HARDWARE stack size is 0 */ rp->p_stguard = (reg_t *) ktsb; *rp->p_stguard = STACK_GUARD; } ktsb += ttp->stksize; /* point to high end of stack */ rp->p_reg.sp = ktsb; /* this task's initial stack ptr */ text_base = kinfo.code_base >> CLICK_SHIFT; /* processes that are in the kernel */ hdrindex = 0; /* all use the first a.out header */ } else { hdrindex = 1 + i-NR_TASKS; /* drivers, servers, INIT follow */ } /* The bootstrap loader created an array of the a.out headers at * absolute address 'aout'. Get one element to e_hdr. */ phys_copy(aout + hdrindex * A_MINHDR, vir2phys(&e_hdr), (phys_bytes) A_MINHDR); /* Convert addresses to clicks and build process memory map */ text_base = e_hdr.a_syms >> CLICK_SHIFT; text_clicks = (e_hdr.a_text + CLICK_SIZE-1) >> CLICK_SHIFT; if (!(e_hdr.a_flags & A_SEP)) text_clicks = 0; /* Common I&D */ data_clicks = (e_hdr.a_total + CLICK_SIZE-1) >> CLICK_SHIFT; rp->p_memmap[T].mem_phys = text_base; rp->p_memmap[T].mem_len = text_clicks; rp->p_memmap[D].mem_phys = text_base + text_clicks; rp->p_memmap[D].mem_len = data_clicks; rp->p_memmap[S].mem_phys = text_base + text_clicks + data_clicks; rp->p_memmap[S].mem_vir = data_clicks; /* empty - stack is in data */ /* Remove server memory from the free memory list. The boot monitor * promises to put processes at the start of memory chunks. The * tasks all use same base address, so only the first task changes * the memory lists. The servers and init have their own memory * spaces and their memory will be removed from the list. */ for (memp = mem; memp < &mem[NR_MEMS]; memp++) { if (memp->base == text_base) { memp->base += text_clicks + data_clicks; memp->size -= text_clicks + data_clicks; } } /* Set initial register values. The processor status word for tasks * is different from that of other processes because tasks can * access I/O; this is not allowed to less-privileged processes */ rp->p_reg.pc = (reg_t) ttp->initial_pc; rp->p_reg.psw = (isidlep(rp)||istaskp(rp)) ? INIT_TASK_PSW : INIT_PSW; /* Initialize the server stack pointer. Take it down one word * to give crtso.s something to use as "argc". */ if (i-NR_TASKS >= 0) { rp->p_reg.sp = (rp->p_memmap[S].mem_vir + rp->p_memmap[S].mem_len) << CLICK_SHIFT; rp->p_reg.sp -= sizeof(reg_t); } /* Set ready. The HARDWARE task is never ready. */ #if ENABLE_K_DEBUGGING rp->p_ready = 0; #endif if (rp->p_nr != HARDWARE) lock_ready(rp); rp->p_flags = 0; /* Code and data segments must be allocated in protected mode. */ alloc_segments(rp); } #if ENABLE_BOOTDEV /* Expect an image of the boot device to be loaded into memory as well. * The boot device is the last module that is loaded into memory, and, * for example, can contain the root FS (useful for embedded systems). */ hdrindex ++; phys_copy(aout + hdrindex * A_MINHDR,vir2phys(&e_hdr),(phys_bytes) A_MINHDR); if (e_hdr.a_flags & A_IMG) { kinfo.bootdev_base = e_hdr.a_syms; kinfo.bootdev_size = e_hdr.a_data; /* Remove from free list, to prevent being overwritten. */ bootdev_base = e_hdr.a_syms >> CLICK_SHIFT; bootdev_clicks = (e_hdr.a_total + CLICK_SIZE-1) >> CLICK_SHIFT; for (memp = mem; memp < &mem[NR_MEMS]; memp++) { if (memp->base == bootdev_base) { memp->base += bootdev_clicks; memp->size -= bootdev_clicks; } } } #endif /* This actually is not needed, because ready() already set 'proc_ptr.' */ lock_pick_proc(); bill_ptr = proc_addr(IDLE); /* it has to point somewhere */ /* MINIX is now ready. Display the startup banner to the user and return * to the assembly code to start running the current process. */ announce(); restart(); } /*==========================================================================* * announce * *==========================================================================*/ PRIVATE void announce(void) { /* Display the MINIX startup banner. */ kprintf("MINIX %s. Copyright 2001 Prentice-Hall, Inc.\n", karg(kinfo.version)); #if (CHIP == INTEL) /* Real mode, or 16/32-bit protected mode? */ kprintf("Executing in %s mode\n\n", machine.protected ? karg("32-bit protected") : karg("real")); #endif /* Check if boot device was loaded with the kernel. */ if (kinfo.bootdev_base > 0) kprintf("Image of /dev/boot loaded. Size: %u KB.\n", kinfo.bootdev_size); } /*==========================================================================* * prepare_shutdown * *==========================================================================*/ PUBLIC void prepare_shutdown(how) int how; /* 0 = halt, 1 = reboot, 2 = panic!, ... */ { /* This function prepares to shutdown MINIX. It uses a global flag to make * sure it is only executed once. Unless a CPU exception occurred, the * stop_sequence() is started. */ message m; if (shutting_down) return; /* Show debugging dumps on panics. Make sure that the TTY task is still * available to handle them. This is done with help of a non-blocking send. * We rely on TTY to call sys_abort() when it is done with the dumps. */ if (how == RBT_PANIC) { m.m_type = PANIC_DUMPS; if (nb_send(TTY, &m) == OK) /* don't block if TTY isn't ready */ return; /* await sys_abort() from TTY */ } /* The TTY expects two HARD_STOP notifications. One to switch to the * primary console for stop sequence output, and one to actually exit. */ m.NOTIFY_TYPE = HARD_STOP; lock_notify(TTY, &m); /* Run the stop sequence. The timer argument passes the shutdown status. * The stop sequence is skipped for fatal CPU exceptions. */ shutting_down = TRUE; /* flag for sys_exit() */ tmr_arg(&shutdown_timer)->ta_int = how; /* pass how in timer */ if (skip_stop_sequence) { /* set in exception() */ kprintf("\nAn exception occured; skipping stop sequence.\n", NO_ARG); shutdown(how); /* TTY isn't scheduled */ } else { kprintf("\nNotifying system services about MINIX shutdown.\n", NO_ARG); stop_sequence(&shutdown_timer); } } /*==========================================================================* * stop_sequence * *==========================================================================*/ PUBLIC void stop_sequence(tp) timer_t *tp; { /* Try to cleanly stop all system services before shutting down. For each * process type, all processes are notified and given STOP_TICKS to cleanly * shutdown. The notification order is servers, drivers, tasks. The variable * 'shutdown_process' is set globally to indicate the process next to stop * so that the stop sequence can directly continue if it has exited. Only if * stop sequence has finished, MINIX is brought down. */ static int level = P_SERVER; /* start at the highest level */ static struct proc *p = NIL_PROC; /* next process to stop */ static char *types[] = {"task","system","driver","server","user"}; static message m; /* See if the last process' shutdown was successful. Else, force exit. */ if (p != NIL_PROC) { kprintf("[%s]\n", isalivep(p) ? karg("FAILED") : karg("OK")); if (isalivep(p)) clear_proc(p->p_nr); /* now force process to exit */ } /* Find the next process that must be stopped. Continue where last search * ended or start at begin. Possibly go to next level while searching. If * the last level is completely searched, shutdown MINIX. Processes are * stopped in the order of dependencies, that is, from the highest level to * the lowest level so that, for example, the file system can still rely on * device drivers to cleanly shutdown. */ if (p == NIL_PROC) p = BEG_PROC_ADDR; while (TRUE) { if (isalivep(p) && p->p_type == level) { /* found a process */ int w; kprintf("- Stopping %s ", karg(p->p_name)); kprintf("%s ... ", karg(types[p->p_type])); shutdown_process = p; /* directly continue if exited */ m.NOTIFY_TYPE = HARD_STOP; m.NOTIFY_ARG = tmr_arg(tp)->ta_int; /* how */ lock_notify(proc_number(p), &m); set_timer(tp, get_uptime()+STOP_TICKS, stop_sequence); return; /* allow the process to shut down */ } p++; /* proceed to next process */ if (p >= END_PROC_ADDR) { /* proceed to next level */ p = BEG_PROC_ADDR; level = level - 1; if (level == P_TASK) { /* done; tasks must remain alive */ shutdown(tmr_arg(tp)->ta_int); /* no return */ return; } } } } /*==========================================================================* * shutdown * *==========================================================================*/ PRIVATE void shutdown(int how) { /* This function is called from prepare_shutdown or stop_sequence to bring * down MINIX. How to shutdown is in the argument: RBT_REBOOT, RBT_HALT, * RBT_RESET. */ static u16_t magic = STOP_MEM_CHECK; /* Now mask all interrupts, including the clock, and stop the clock. */ outb(INT_CTLMASK, ~0); clock_stop(); if (mon_return && how != RBT_RESET) { /* Reinitialize the interrupt controllers to the BIOS defaults. */ intr_init(0); outb(INT_CTLMASK, 0); outb(INT2_CTLMASK, 0); /* Return to the boot monitor. Set the program for the boot monitor. * For RBT_MONITOR, the MM has provided the program. */ if (how == RBT_HALT) { phys_copy(vir2phys("delay;menu"), kinfo.params_base, 11); } else if (how == RBT_REBOOT) { phys_copy(vir2phys("delay;boot"), kinfo.params_base, 11); } level0(monitor); } /* Stop BIOS memory test. */ phys_copy(vir2phys(&magic), SOFT_RESET_FLAG_ADDR, SOFT_RESET_FLAG_SIZE); /* Reset the system by jumping to the reset address (real mode), or by * forcing a processor shutdown (protected mode). */ level0(reset); }