| 1 | /* This file contains the main program of MINIX as well as its shutdown code.
|
|---|
| 2 | * The routine main() initializes the system and starts the ball rolling by
|
|---|
| 3 | * setting up the process table, interrupt vectors, and scheduling each task
|
|---|
| 4 | * to run to initialize itself.
|
|---|
| 5 | * The routine shutdown() does the opposite and brings down MINIX.
|
|---|
| 6 | *
|
|---|
| 7 | * The entries into this file are:
|
|---|
| 8 | * main: MINIX main program
|
|---|
| 9 | * prepare_shutdown: prepare to take MINIX down
|
|---|
| 10 | *
|
|---|
| 11 | * Changes:
|
|---|
| 12 | * Nov 24, 2004 simplified main() with system image (Jorrit N. Herder)
|
|---|
| 13 | * Aug 20, 2004 new prepare_shutdown() and shutdown() (Jorrit N. Herder)
|
|---|
| 14 | */
|
|---|
| 15 | #include "kernel.h"
|
|---|
| 16 | #include <signal.h>
|
|---|
| 17 | #include <string.h>
|
|---|
| 18 | #include <unistd.h>
|
|---|
| 19 | #include <a.out.h>
|
|---|
| 20 | #include <minix/callnr.h>
|
|---|
| 21 | #include <minix/com.h>
|
|---|
| 22 | #include "proc.h"
|
|---|
| 23 |
|
|---|
| 24 | /* Prototype declarations for PRIVATE functions. */
|
|---|
| 25 | FORWARD _PROTOTYPE( void announce, (void));
|
|---|
| 26 | FORWARD _PROTOTYPE( void shutdown, (timer_t *tp));
|
|---|
| 27 |
|
|---|
| 28 | /*===========================================================================*
|
|---|
| 29 | * main *
|
|---|
| 30 | *===========================================================================*/
|
|---|
| 31 | PUBLIC void main()
|
|---|
| 32 | {
|
|---|
| 33 | /* Start the ball rolling. */
|
|---|
| 34 | struct boot_image *ip; /* boot image pointer */
|
|---|
| 35 | register struct proc *rp; /* process pointer */
|
|---|
| 36 | register struct priv *sp; /* privilege structure pointer */
|
|---|
| 37 | register int i, s;
|
|---|
| 38 | int hdrindex; /* index to array of a.out headers */
|
|---|
| 39 | phys_clicks text_base;
|
|---|
| 40 | vir_clicks text_clicks, data_clicks;
|
|---|
| 41 | reg_t ktsb; /* kernel task stack base */
|
|---|
| 42 | struct exec e_hdr; /* for a copy of an a.out header */
|
|---|
| 43 |
|
|---|
| 44 | /* Initialize the interrupt controller. */
|
|---|
| 45 | intr_init(1);
|
|---|
| 46 |
|
|---|
| 47 | /* Clear the process table. Anounce each slot as empty and set up mappings
|
|---|
| 48 | * for proc_addr() and proc_nr() macros. Do the same for the table with
|
|---|
| 49 | * privilege structures for the system processes.
|
|---|
| 50 | */
|
|---|
| 51 | for (rp = BEG_PROC_ADDR, i = -NR_TASKS; rp < END_PROC_ADDR; ++rp, ++i) {
|
|---|
| 52 | rp->p_rts_flags = SLOT_FREE; /* initialize free slot */
|
|---|
| 53 | rp->p_nr = i; /* proc number from ptr */
|
|---|
| 54 | (pproc_addr + NR_TASKS)[i] = rp; /* proc ptr from number */
|
|---|
| 55 | }
|
|---|
| 56 | for (sp = BEG_PRIV_ADDR, i = 0; sp < END_PRIV_ADDR; ++sp, ++i) {
|
|---|
| 57 | sp->s_proc_nr = NONE; /* initialize as free */
|
|---|
| 58 | sp->s_id = i; /* priv structure index */
|
|---|
| 59 | ppriv_addr[i] = sp; /* priv ptr from number */
|
|---|
| 60 | }
|
|---|
| 61 |
|
|---|
| 62 | /* Set up proc table entries for tasks and servers. The stacks of the
|
|---|
| 63 | * kernel tasks are initialized to an array in data space. The stacks
|
|---|
| 64 | * of the servers have been added to the data segment by the monitor, so
|
|---|
| 65 | * the stack pointer is set to the end of the data segment. All the
|
|---|
| 66 | * processes are in low memory on the 8086. On the 386 only the kernel
|
|---|
| 67 | * is in low memory, the rest is loaded in extended memory.
|
|---|
| 68 | */
|
|---|
| 69 |
|
|---|
| 70 | /* Task stacks. */
|
|---|
| 71 | ktsb = (reg_t) t_stack;
|
|---|
| 72 |
|
|---|
| 73 | for (i=0; i < NR_BOOT_PROCS; ++i) {
|
|---|
| 74 | ip = &image[i]; /* process' attributes */
|
|---|
| 75 | rp = proc_addr(ip->proc_nr); /* get process pointer */
|
|---|
| 76 | rp->p_max_priority = ip->priority; /* max scheduling priority */
|
|---|
| 77 | rp->p_priority = ip->priority; /* current priority */
|
|---|
| 78 | rp->p_quantum_size = ip->quantum; /* quantum size in ticks */
|
|---|
| 79 | rp->p_ticks_left = ip->quantum; /* current credit */
|
|---|
| 80 | strncpy(rp->p_name, ip->proc_name, P_NAME_LEN); /* set process name */
|
|---|
| 81 | (void) get_priv(rp, (ip->flags & SYS_PROC)); /* assign structure */
|
|---|
| 82 | priv(rp)->s_flags = ip->flags; /* process flags */
|
|---|
| 83 | priv(rp)->s_trap_mask = ip->trap_mask; /* allowed traps */
|
|---|
| 84 | priv(rp)->s_call_mask = ip->call_mask; /* kernel call mask */
|
|---|
| 85 | priv(rp)->s_ipc_to.chunk[0] = ip->ipc_to; /* restrict targets */
|
|---|
| 86 | if (iskerneln(proc_nr(rp))) { /* part of the kernel? */
|
|---|
| 87 | if (ip->stksize > 0) { /* HARDWARE stack size is 0 */
|
|---|
| 88 | rp->p_priv->s_stack_guard = (reg_t *) ktsb;
|
|---|
| 89 | *rp->p_priv->s_stack_guard = STACK_GUARD;
|
|---|
| 90 | }
|
|---|
| 91 | ktsb += ip->stksize; /* point to high end of stack */
|
|---|
| 92 | rp->p_reg.sp = ktsb; /* this task's initial stack ptr */
|
|---|
| 93 | text_base = kinfo.code_base >> CLICK_SHIFT;
|
|---|
| 94 | /* processes that are in the kernel */
|
|---|
| 95 | hdrindex = 0; /* all use the first a.out header */
|
|---|
| 96 | } else {
|
|---|
| 97 | hdrindex = 1 + i-NR_TASKS; /* servers, drivers, INIT */
|
|---|
| 98 | }
|
|---|
| 99 |
|
|---|
| 100 | /* The bootstrap loader created an array of the a.out headers at
|
|---|
| 101 | * absolute address 'aout'. Get one element to e_hdr.
|
|---|
| 102 | */
|
|---|
| 103 | phys_copy(aout + hdrindex * A_MINHDR, vir2phys(&e_hdr),
|
|---|
| 104 | (phys_bytes) A_MINHDR);
|
|---|
| 105 | /* Convert addresses to clicks and build process memory map */
|
|---|
| 106 | text_base = e_hdr.a_syms >> CLICK_SHIFT;
|
|---|
| 107 | text_clicks = (e_hdr.a_text + CLICK_SIZE-1) >> CLICK_SHIFT;
|
|---|
| 108 | if (!(e_hdr.a_flags & A_SEP)) text_clicks = 0; /* common I&D */
|
|---|
| 109 | data_clicks = (e_hdr.a_total + CLICK_SIZE-1) >> CLICK_SHIFT;
|
|---|
| 110 | rp->p_memmap[T].mem_phys = text_base;
|
|---|
| 111 | rp->p_memmap[T].mem_len = text_clicks;
|
|---|
| 112 | rp->p_memmap[D].mem_phys = text_base + text_clicks;
|
|---|
| 113 | rp->p_memmap[D].mem_len = data_clicks;
|
|---|
| 114 | rp->p_memmap[S].mem_phys = text_base + text_clicks + data_clicks;
|
|---|
| 115 | rp->p_memmap[S].mem_vir = data_clicks; /* empty - stack is in data */
|
|---|
| 116 |
|
|---|
| 117 | /* Set initial register values. The processor status word for tasks
|
|---|
| 118 | * is different from that of other processes because tasks can
|
|---|
| 119 | * access I/O; this is not allowed to less-privileged processes
|
|---|
| 120 | */
|
|---|
| 121 | rp->p_reg.pc = (reg_t) ip->initial_pc;
|
|---|
| 122 | rp->p_reg.psw = (iskernelp(rp)) ? INIT_TASK_PSW : INIT_PSW;
|
|---|
| 123 |
|
|---|
| 124 | /* Initialize the server stack pointer. Take it down one word
|
|---|
| 125 | * to give crtso.s something to use as "argc".
|
|---|
| 126 | */
|
|---|
| 127 | if (isusern(proc_nr(rp))) { /* user-space process? */
|
|---|
| 128 | rp->p_reg.sp = (rp->p_memmap[S].mem_vir +
|
|---|
| 129 | rp->p_memmap[S].mem_len) << CLICK_SHIFT;
|
|---|
| 130 | rp->p_reg.sp -= sizeof(reg_t);
|
|---|
| 131 | }
|
|---|
| 132 |
|
|---|
| 133 | /* Set ready. The HARDWARE task is never ready. */
|
|---|
| 134 | if (rp->p_nr != HARDWARE) {
|
|---|
| 135 | rp->p_rts_flags = 0; /* runnable if no flags */
|
|---|
| 136 | lock_enqueue(rp); /* add to scheduling queues */
|
|---|
| 137 | } else {
|
|---|
| 138 | rp->p_rts_flags = NO_MAP; /* prevent from running */
|
|---|
| 139 | }
|
|---|
| 140 |
|
|---|
| 141 | /* Code and data segments must be allocated in protected mode. */
|
|---|
| 142 | alloc_segments(rp);
|
|---|
| 143 | }
|
|---|
| 144 |
|
|---|
| 145 | /* We're definitely not shutting down. */
|
|---|
| 146 | shutdown_started = 0;
|
|---|
| 147 |
|
|---|
| 148 | /* MINIX is now ready. All boot image processes are on the ready queue.
|
|---|
| 149 | * Return to the assembly code to start running the current process.
|
|---|
| 150 | */
|
|---|
| 151 | bill_ptr = proc_addr(IDLE); /* it has to point somewhere */
|
|---|
| 152 | announce(); /* print MINIX startup banner */
|
|---|
| 153 | restart();
|
|---|
| 154 | }
|
|---|
| 155 |
|
|---|
| 156 | /*===========================================================================*
|
|---|
| 157 | * announce *
|
|---|
| 158 | *===========================================================================*/
|
|---|
| 159 | PRIVATE void announce(void)
|
|---|
| 160 | {
|
|---|
| 161 | /* Display the MINIX startup banner. */
|
|---|
| 162 | kprintf("MINIX %s.%s."
|
|---|
| 163 | "Copyright 2006, Vrije Universiteit, Amsterdam, The Netherlands\n",
|
|---|
| 164 | OS_RELEASE, OS_VERSION);
|
|---|
| 165 |
|
|---|
| 166 | /* Real mode, or 16/32-bit protected mode? */
|
|---|
| 167 | kprintf("Executing in %s mode.\n\n",
|
|---|
| 168 | machine.protected ? "32-bit protected" : "real");
|
|---|
| 169 | }
|
|---|
| 170 |
|
|---|
| 171 | /*===========================================================================*
|
|---|
| 172 | * prepare_shutdown *
|
|---|
| 173 | *===========================================================================*/
|
|---|
| 174 | PUBLIC void prepare_shutdown(how)
|
|---|
| 175 | int how;
|
|---|
| 176 | {
|
|---|
| 177 | /* This function prepares to shutdown MINIX. */
|
|---|
| 178 | static timer_t shutdown_timer;
|
|---|
| 179 | register struct proc *rp;
|
|---|
| 180 | message m;
|
|---|
| 181 |
|
|---|
| 182 | /* Show debugging dumps on panics. Make sure that the TTY task is still
|
|---|
| 183 | * available to handle them. This is done with help of a non-blocking send.
|
|---|
| 184 | * We rely on TTY to call sys_abort() when it is done with the dumps.
|
|---|
| 185 | */
|
|---|
| 186 | if (how == RBT_PANIC) {
|
|---|
| 187 | m.m_type = PANIC_DUMPS;
|
|---|
| 188 | if (nb_send(TTY_PROC_NR,&m)==OK) /* don't block if TTY isn't ready */
|
|---|
| 189 | return; /* await sys_abort() from TTY */
|
|---|
| 190 | }
|
|---|
| 191 |
|
|---|
| 192 | /* Send a signal to all system processes that are still alive to inform
|
|---|
| 193 | * them that the MINIX kernel is shutting down. A proper shutdown sequence
|
|---|
| 194 | * should be implemented by a user-space server. This mechanism is useful
|
|---|
| 195 | * as a backup in case of system panics, so that system processes can still
|
|---|
| 196 | * run their shutdown code, e.g, to synchronize the FS or to let the TTY
|
|---|
| 197 | * switch to the first console.
|
|---|
| 198 | */
|
|---|
| 199 | kprintf("Sending SIGKSTOP to system processes ...\n");
|
|---|
| 200 | for (rp=BEG_PROC_ADDR; rp<END_PROC_ADDR; rp++) {
|
|---|
| 201 | if (!isemptyp(rp) && (priv(rp)->s_flags & SYS_PROC) && !iskernelp(rp))
|
|---|
| 202 | send_sig(proc_nr(rp), SIGKSTOP);
|
|---|
| 203 | }
|
|---|
| 204 |
|
|---|
| 205 | /* We're shutting down. Diagnostics may behave differently now. */
|
|---|
| 206 | shutdown_started = 1;
|
|---|
| 207 |
|
|---|
| 208 | /* Notify system processes of the upcoming shutdown and allow them to be
|
|---|
| 209 | * scheduled by setting a watchog timer that calls shutdown(). The timer
|
|---|
| 210 | * argument passes the shutdown status.
|
|---|
| 211 | */
|
|---|
| 212 | kprintf("MINIX will now be shut down ...\n");
|
|---|
| 213 | tmr_arg(&shutdown_timer)->ta_int = how;
|
|---|
| 214 |
|
|---|
| 215 | /* Continue after 1 second, to give processes a chance to get
|
|---|
| 216 | * scheduled to do shutdown work.
|
|---|
| 217 | */
|
|---|
| 218 | set_timer(&shutdown_timer, get_uptime() + HZ, shutdown);
|
|---|
| 219 | }
|
|---|
| 220 |
|
|---|
| 221 | /*===========================================================================*
|
|---|
| 222 | * shutdown *
|
|---|
| 223 | *===========================================================================*/
|
|---|
| 224 | PRIVATE void shutdown(tp)
|
|---|
| 225 | timer_t *tp;
|
|---|
| 226 | {
|
|---|
| 227 | /* This function is called from prepare_shutdown or stop_sequence to bring
|
|---|
| 228 | * down MINIX. How to shutdown is in the argument: RBT_HALT (return to the
|
|---|
| 229 | * monitor), RBT_MONITOR (execute given code), RBT_RESET (hard reset).
|
|---|
| 230 | */
|
|---|
| 231 | int how = tmr_arg(tp)->ta_int;
|
|---|
| 232 | u16_t magic;
|
|---|
| 233 |
|
|---|
| 234 | /* Now mask all interrupts, including the clock, and stop the clock. */
|
|---|
| 235 | outb(INT_CTLMASK, ~0);
|
|---|
| 236 | clock_stop();
|
|---|
| 237 |
|
|---|
| 238 | if (mon_return && how != RBT_RESET) {
|
|---|
| 239 | /* Reinitialize the interrupt controllers to the BIOS defaults. */
|
|---|
| 240 | intr_init(0);
|
|---|
| 241 | outb(INT_CTLMASK, 0);
|
|---|
| 242 | outb(INT2_CTLMASK, 0);
|
|---|
| 243 |
|
|---|
| 244 | /* Return to the boot monitor. Set the program if not already done. */
|
|---|
| 245 | if (how != RBT_MONITOR) phys_copy(vir2phys(""), kinfo.params_base, 1);
|
|---|
| 246 | level0(monitor);
|
|---|
| 247 | }
|
|---|
| 248 |
|
|---|
| 249 | /* Reset the system by jumping to the reset address (real mode), or by
|
|---|
| 250 | * forcing a processor shutdown (protected mode). First stop the BIOS
|
|---|
| 251 | * memory test by setting a soft reset flag.
|
|---|
| 252 | */
|
|---|
| 253 | magic = STOP_MEM_CHECK;
|
|---|
| 254 | phys_copy(vir2phys(&magic), SOFT_RESET_FLAG_ADDR, SOFT_RESET_FLAG_SIZE);
|
|---|
| 255 | level0(reset);
|
|---|
| 256 | }
|
|---|
| 257 |
|
|---|
