/* boot.c - Load and start Minix. Author: Kees J. Bot

* 27 Dec 1991

*/

char version[]= "2.20";

#define BIOS (!UNIX) /* Either uses BIOS or UNIX syscalls. */

#define nil 0

#define _POSIX_SOURCE 1

#define _MINIX 1

#include <stddef.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <stdlib.h>

#include <stdio.h>

#include <limits.h>

#include <string.h>

#include <errno.h>

#include <machine/partition.h>

#include <machine/bios.h>

#include <minix/config.h>

#include <minix/type.h>

#include <minix/dmap.h>

#include <minix/const.h>

#include <minix/minlib.h>

#include <minix/syslib.h>

#if BIOS

#include <kernel/const.h>

#include <sys/video.h>

#endif

#if UNIX

#include <stdio.h>

#include <time.h>

#include <unistd.h>

#include <fcntl.h>

#include <signal.h>

#include <termios.h>

#endif

#include "rawfs.h"

#undef EXTERN

#define EXTERN /* Empty */

#include "boot.h"

#define arraysize(a) (sizeof(a) / sizeof((a)[0]))

#define arraylimit(a) ((a) + arraysize(a))

#define between(a, c, z) ((unsigned) ((c) - (a)) <= ((z) - (a)))

int serial_line = -1;

u16_t vid_port; /* Video i/o port. */

u32_t vid_mem_base; /* Video memory base address. */

u32_t vid_mem_size; /* Video memory size. */

int fsok= -1; /* File system state. Initially unknown. */

static int block_size;

#if BIOS

/* this data is reserved for BIOS int 0x13 to put the 'specification packet'

* in. It has a structure of course, but we don't define a struct because

* of compiler padding. We fiddle out the bytes ourselves later.

*/

unsigned char boot_spec[24];

static const char *bios_err(int err)

/* Translate BIOS error code to a readable string. (This is a rare trait

* known as error checking and reporting. Take a good look at it, you won't

* see it often.)

*/

{

static struct errlist {

int err;

char *what;

} errlist[] = {

#if !DOS

{ 0x00, "No error" },

{ 0x01, "Invalid command" },

{ 0x02, "Address mark not found" },

{ 0x03, "Disk write-protected" },

{ 0x04, "Sector not found" },

{ 0x05, "Reset failed" },

{ 0x06, "Floppy disk removed" },

{ 0x07, "Bad parameter table" },

{ 0x08, "DMA overrun" },

{ 0x09, "DMA crossed 64 KB boundary" },

{ 0x0A, "Bad sector flag" },

{ 0x0B, "Bad track flag" },

{ 0x0C, "Media type not found" },

{ 0x0D, "Invalid number of sectors on format" },

{ 0x0E, "Control data address mark detected" },

{ 0x0F, "DMA arbitration level out of range" },

{ 0x10, "Uncorrectable CRC or ECC data error" },

{ 0x11, "ECC corrected data error" },

{ 0x20, "Controller failed" },

{ 0x40, "Seek failed" },

{ 0x80, "Disk timed-out" },

{ 0xAA, "Drive not ready" },

{ 0xBB, "Undefined error" },

{ 0xCC, "Write fault" },

{ 0xE0, "Status register error" },

{ 0xFF, "Sense operation failed" }

#else /* DOS */

{ 0x00, "No error" },

{ 0x01, "Function number invalid" },

{ 0x02, "File not found" },

{ 0x03, "Path not found" },

{ 0x04, "Too many open files" },

{ 0x05, "Access denied" },

{ 0x06, "Invalid handle" },

{ 0x0C, "Access code invalid" },

#endif /* DOS */

};

struct errlist *errp;

for (errp= errlist; errp < arraylimit(errlist); errp++) {

if (errp->err == err) return errp->what;

}

return "Unknown error";

}

/* CD's are addressed in 2048-byte sectors.

* In order to be able to read CD's but maintain the same interface of 512-byte

* sector addressing, we check if the device is a CD in readsectors() and if so,

* read it into our own buffer first

*/

int readsectors(u32_t bufaddr, u32_t sector, u8_t count)

{

#define CDSECTOR_SIZE 2048

static char cdbuf[CDSECTOR_SIZE];

static i32_t cdbuf_sec = -1;

i32_t cdsec;

if(device != cddevice) {

return biosreadsectors(bufaddr, sector, count);

}

while(count > 0) {

u32_t offset;

#define FACTOR (CDSECTOR_SIZE/SECTOR_SIZE)

cdsec = sector / FACTOR;

offset = (sector % FACTOR) * SECTOR_SIZE;

if(cdsec != cdbuf_sec) {

int r;

if((r=biosreadsectors(mon2abs(cdbuf), cdsec, 1)) != 0) {

printf("error %d\n", r);

return r;

}

cdbuf_sec = cdsec;

}

raw_copy(bufaddr, mon2abs(cdbuf) + offset, SECTOR_SIZE);

bufaddr += SECTOR_SIZE;

count--;

sector++;

}

return 0;

}

char *unix_err(int err)

/* Translate the few errors rawfs can give. */

{

switch (err) {

case ENOENT: return "No such file or directory";

case ENOTDIR: return "Not a directory";

default: return "Unknown error";

}

}

static void rwerr(const char *rw, off_t sec, int err)

{

printf("\n%s error 0x%02x (%s) at sector %ld absolute\n",

rw, err, bios_err(err), sec);

}

void readerr(off_t sec, int err) { rwerr("Read", sec, err); }

void writerr(off_t sec, int err) { rwerr("Write", sec, err); }

void readblock(off_t blk, char *buf, int block_size)

/* Read blocks for the rawfs package. */

{

int r;

u32_t sec= lowsec + blk * RATIO(block_size);

if(!block_size) {

printf("block_size 0\n");

exit(1);

}

if ((r= readsectors(mon2abs(buf), sec, 1 * RATIO(block_size))) != 0) {

readerr(sec, r); exit(1);

}

}

#define istty (1)

#define alarm(n) (0)

#endif /* BIOS */

#if UNIX

/* The Minix boot block must start with these bytes: */

char boot_magic[] = { 0x31, 0xC0, 0x8E, 0xD8, 0xFA, 0x8E, 0xD0, 0xBC };

struct biosdev {

char *name; /* Name of device. */

int device; /* Device to edit parameters. */

} bootdev;

static struct termios termbuf;

static int istty;

void quit(int status)

{

if (istty) (void) tcsetattr(0, TCSANOW, &termbuf);

exit(status);

}

#define exit(s) quit(s)

void report(const char *label)

/* edparams: label: No such file or directory */

{

fprintf(stderr, "edparams: %s: %s\n", label, strerror(errno));

}

void fatal(const char *label)

{

report(label);

exit(1);

}

void *alloc(void *m, size_t n)

{

m= m == nil ? malloc(n) : realloc(m, n);

if (m == nil) fatal("");

return m;

}

#define malloc(n) alloc(nil, n)

#define realloc(m, n) alloc(m, n)

#define mon2abs(addr) ((void *) (addr))

int rwsectors(int rw, void *addr, u32_t sec, int nsec)

{

ssize_t r;

size_t len= nsec * SECTOR_SIZE;

if (lseek(bootdev.device, sec * SECTOR_SIZE, SEEK_SET) == -1)

return errno;

if (rw == 0) {

r= read(bootdev.device, (char *) addr, len);

} else {

r= write(bootdev.device, (char *) addr, len);

}

if (r == -1) return errno;

if (r != len) return EIO;

return 0;

}

#define readsectors(a, s, n) rwsectors(0, (a), (s), (n))

#define writesectors(a, s, n) rwsectors(1, (a), (s), (n))

#define readerr(sec, err) (errno= (err), report(bootdev.name))

#define writerr(sec, err) (errno= (err), report(bootdev.name))

#define putch(c) putchar(c)

#define unix_err(err) strerror(err)

void readblock(off_t blk, char *buf, int block_size)

/* Read blocks for the rawfs package. */

{

if(!block_size) fatal("block_size 0");

errno= EIO;

if (lseek(bootdev.device, blk * block_size, SEEK_SET) == -1

|| read(bootdev.device, buf, block_size) != block_size)

{

fatal(bootdev.name);

}

}

sig_atomic_t trapsig;

void trap(int sig)

{

trapsig= sig;

signal(sig, trap);

}

int escape(void)

{

if (trapsig == SIGINT) {

trapsig= 0;

return 1;

}

return 0;

}

static unsigned char unchar;

int getch(void)

{

unsigned char c;

fflush(stdout);

if (unchar != 0) {

c= unchar;

unchar= 0;

return c;

}

switch (read(0, &c, 1)) {

case -1:

if (errno != EINTR) fatal("");

return(ESC);

case 0:

if (istty) putch('\n');

exit(0);

default:

if (istty && c == termbuf.c_cc[VEOF]) {

putch('\n');

exit(0);

}

return c;

}

}

#define ungetch(c) ((void) (unchar = (c)))

#define get_tick() ((u32_t) time(nil))

#define clear_screen() printf("[clear]")

#define boot_device(device) printf("[boot %s]\n", device)

#define ctty(line) printf("[ctty %s]\n", line)

#define bootminix() (run_trailer() && printf("[boot]\n"))

#define off() printf("[off]")

#endif /* UNIX */

static char *readline(void)

/* Read a line including a newline with echoing. */

{

char *line;

size_t i, z;

int c;

i= 0;

z= 20;

line= malloc(z * sizeof(char));

do {

c= getch();

if (strchr("\b\177\25\30", c) != nil) {

/* Backspace, DEL, ctrl-U, or ctrl-X. */

do {

if (i == 0) break;

printf("\b \b");

i--;

} while (c == '\25' || c == '\30');

} else

if (c < ' ' && c != '\n') {

putch('\7');

} else {

putch(c);

line[i++]= c;

if (i == z) {

z*= 2;

line= realloc(line, z * sizeof(char));

}

}

} while (c != '\n');

line[i]= 0;

return line;

}

static int sugar(const char *tok)

/* Recognize special tokens. */

{

return strchr("=(){};\n", tok[0]) != nil;

}

static char *onetoken(char **aline)

/* Returns a string with one token for tokenize. */

{

char *line= *aline;

size_t n;

char *tok;

/* Skip spaces and runs of newlines. */

while (*line == ' ' || (*line == '\n' && line[1] == '\n')) line++;

*aline= line;

/* Don't do odd junk (nor the terminating 0!). */

if ((unsigned) *line < ' ' && *line != '\n') return nil;

if (*line == '(') {

/* Function argument, anything goes but () must match. */

int depth= 0;

while ((unsigned) *line >= ' ') {

if (*line == '(') depth++;

if (*line++ == ')' && --depth == 0) break;

}

} else

if (sugar(line)) {

/* Single character token. */

line++;

} else {

/* Multicharacter token. */

do line++; while ((unsigned) *line > ' ' && !sugar(line));

}

n= line - *aline;

tok= malloc((n + 1) * sizeof(char));

memcpy(tok, *aline, n);

tok[n]= 0;

if (tok[0] == '\n') tok[0]= ';'; /* ';' same as '\n' */

*aline= line;

return tok;

}

/* Typed commands form strings of tokens. */

typedef struct token {

struct token *next; /* Next in a command chain. */

char *token;

} token;

static token **tokenize(token **acmds, char *line)

/* Takes a line apart to form tokens. The tokens are inserted into a command

* chain at *acmds. Tokenize returns a reference to where another line could

* be added. Tokenize looks at spaces as token separators, and recognizes only

* ';', '=', '{', '}', and '\n' as single character tokens. One token is

* formed from '(' and ')' with anything in between as long as more () match.

*/

{

char *tok;

token *newcmd;

while ((tok= onetoken(&line)) != nil) {

newcmd= malloc(sizeof(*newcmd));

newcmd->token= tok;

newcmd->next= *acmds;

*acmds= newcmd;

acmds= &newcmd->next;

}

return acmds;

}

static token *cmds; /* String of commands to execute. */

static int err; /* Set on an error. */

static char *poptoken(void)

/* Pop one token off the command chain. */

{

token *cmd= cmds;

char *tok= cmd->token;

cmds= cmd->next;

free(cmd);

return tok;

}

static void voidtoken(void)

/* Remove one token from the command chain. */

{

free(poptoken());

}

void parse_code(char *code)

/* Tokenize a string of monitor code, making sure there is a delimiter. It is

* to be executed next. (Prepended to the current input.)

*/

{

if (cmds != nil && cmds->token[0] != ';') (void) tokenize(&cmds, ";");

(void) tokenize(&cmds, code);

}

static int interrupt(void)

/* Clean up after an ESC has been typed. */

{

if (escape()) {

printf("[ESC]\n");

err= 1;

return 1;

}

return 0;

}

#if BIOS

static int activate;

struct biosdev {

char name[8];

int device, primary, secondary;

} bootdev, tmpdev;

static int get_master(char *master, struct part_entry **table, u32_t pos)

/* Read a master boot sector and its partition table. */

{

int r, n;

struct part_entry *pe, **pt;

if ((r= readsectors(mon2abs(master), pos, 1)) != 0) return r;

pe= (struct part_entry *) (master + PART_TABLE_OFF);

for (pt= table; pt < table + NR_PARTITIONS; pt++) *pt= pe++;

/* DOS has the misguided idea that partition tables must be sorted. */

if (pos != 0) return 0; /* But only the primary. */

n= NR_PARTITIONS;

do {

for (pt= table; pt < table + NR_PARTITIONS-1; pt++) {

if (pt[0]->sysind == NO_PART

|| pt[0]->lowsec > pt[1]->lowsec) {

pe= pt[0]; pt[0]= pt[1]; pt[1]= pe;

}

}

} while (--n > 0);

return 0;

}

static void initialize(void)

{

char master[SECTOR_SIZE];

struct part_entry *table[NR_PARTITIONS];

int r, p;

u32_t masterpos;

char *argp;

/* Copy the boot program to the far end of low memory, this must be

* done to get out of the way of Minix, and to put the data area

* cleanly inside a 64K chunk if using BIOS I/O (no DMA problems).

*/

u32_t oldaddr= caddr;

u32_t memend= mem[0].base + mem[0].size;

u32_t newaddr= (memend - runsize) & ~0x0000FL;

#if !DOS

u32_t dma64k= (memend - 1) & ~0x0FFFFL;

/* Check if data segment crosses a 64K boundary. */

if (newaddr + (daddr - caddr) < dma64k) {

newaddr= (dma64k - runsize) & ~0x0000FL;

}

#endif

/* If we were booted from CD, remember what device it was. */

if(cdbooted)

cddevice = device;

else

cddevice = 0xff; /* Invalid. */

/* Set the new caddr for relocate. */

caddr= newaddr;

/* Copy code and data. */

raw_copy(newaddr, oldaddr, runsize);

/* Make the copy running. */

relocate();

#if !DOS

/* Take the monitor out of the memory map if we have memory to spare,

* and also keep the BIOS data area safe (1.5K), plus a bit extra for

* where we may have to put a.out headers for older kernels.

*/

if (mon_return = (mem[1].size > 512*1024L)) mem[0].size = newaddr;

mem[0].base += 2048;

mem[0].size -= 2048;

/* Find out what the boot device and partition was. */

bootdev.name[0]= 0;

bootdev.device= device;

bootdev.primary= -1;

bootdev.secondary= -1;

if (device < 0x80) {

/* Floppy. */

strcpy(bootdev.name, "fd0");

bootdev.name[2] += bootdev.device;

return;

}

/* Disk: Get the partition table from the very first sector, and

* determine the partition we booted from using the information from

* the booted partition entry as passed on by the bootstrap (rem_part).

* All we need from it is the partition offset.

*/

raw_copy(mon2abs(&lowsec),

vec2abs(&rem_part) + offsetof(struct part_entry, lowsec),

sizeof(lowsec));

masterpos= 0; /* Master bootsector position. */

for (;;) {

/* Extract the partition table from the master boot sector. */

if ((r= get_master(master, table, masterpos)) != 0) {

readerr(masterpos, r); exit(1);

}

/* If we're a CD, we know what we want. */

if(device == cddevice) {

p = 1; /* We know this is the root FS. */

lowsec = table[p]->lowsec;

bootdev.primary = p;

break; /* Found! */

}

/* See if you can find "lowsec" back. */

for (p= 0; p < NR_PARTITIONS; p++) {

if (lowsec - table[p]->lowsec < table[p]->size) break;

}

if (lowsec == table[p]->lowsec) { /* Found! */

if (bootdev.primary < 0)

bootdev.primary= p;

else

bootdev.secondary= p;

break;

}

if (p == NR_PARTITIONS || bootdev.primary >= 0

|| table[p]->sysind != MINIX_PART) {

/* The boot partition cannot be named, this only means

* that "bootdev" doesn't work.

*/

bootdev.device= -1;

return;

}

/* See if the primary partition is subpartitioned. */

bootdev.primary= p;

masterpos= table[p]->lowsec;

}

if(device == cddevice) {

strcpy(bootdev.name, CDNAME);

} else {

strcpy(bootdev.name, "d0p0");

bootdev.name[1] += (device - 0x80);

bootdev.name[3] += bootdev.primary;

if (bootdev.secondary >= 0) {

strcat(bootdev.name, "s0");

bootdev.name[5] += bootdev.secondary;

}

}

/* Find out about the video hardware. */

raw_copy(mon2abs(&vid_port), VDU_CRT_BASE_ADDR, sizeof(vid_port));

if(vid_port == C_6845) {

vid_mem_base = COLOR_BASE;

vid_mem_size = COLOR_SIZE;

} else {

vid_mem_base = MONO_BASE;

vid_mem_size = MONO_SIZE;

}

if(get_video() >= 3)

vid_mem_size = EGA_SIZE;

#else /* DOS */

/* Take the monitor out of the memory map if we have memory to spare,

* note that only half our PSP is needed at the new place, the first

* half is to be kept in its place.

*/

if (mem[1].size > 0) mem[0].size = newaddr + 0x80 - mem[0].base;

/* Parse the command line. */

argp= PSP + 0x81;

argp[PSP[0x80]]= 0;

while (between('\1', *argp, ' ')) argp++;

vdisk= argp;

while (!between('\0', *argp, ' ')) argp++;

while (between('\1', *argp, ' ')) *argp++= 0;

if (*vdisk == 0) {

printf("\nUsage: boot <vdisk> [commands ...]\n");

exit(1);

}

drun= *argp == 0 ? "main" : argp;

if ((r= dev_open()) != 0) {

printf("\n%s: Error %02x (%s)\n", vdisk, r, bios_err(r));

exit(1);

}

/* Find the active partition on the virtual disk. */

if ((r= get_master(master, table, 0)) != 0) {

readerr(0, r); exit(1);

}

strcpy(bootdev.name, "d0");

bootdev.primary= -1;

for (p= 0; p < NR_PARTITIONS; p++) {

if (table[p]->bootind != 0 && table[p]->sysind == MINIX_PART) {

bootdev.primary= p;

strcat(bootdev.name, "p0");

bootdev.name[3] += p;

lowsec= table[p]->lowsec;

break;

}

}

#endif /* DOS */

}

#endif /* BIOS */

/* Reserved names: */

enum resnames {

R_NULL, R_BOOT, R_CTTY, R_DELAY, R_ECHO, R_EXIT, R_HELP,

R_LS, R_MENU, R_OFF, R_SAVE, R_SET, R_TRAP, R_UNSET, R_RESET

};

static char resnames[][6] = {

"", "boot", "ctty", "delay", "echo", "exit", "help",

"ls", "menu", "off", "save", "set", "trap", "unset", "reset",

};

/* Using this for all null strings saves a lot of memory. */

#define null (resnames[0])

static enum resnames reserved(const char *s)

/* Recognize reserved strings. */

{

enum resnames r;

for (r= R_BOOT; r <= R_RESET; r++) {

if (strcmp(s, resnames[r]) == 0) return r;

}

return R_NULL;

}

static void sfree(char *s)

/* Free a non-null string. */

{

if (s != nil && s != null) free(s);

}

static char *copystr(const char *s)

/* Copy a non-null string using malloc. */

{

char *c;

if (*s == 0) return null;

c= malloc((strlen(s) + 1) * sizeof(char));

strcpy(c, s);

return c;

}

static int is_default(const environment *e)

{

return (e->flags & E_SPECIAL) && e->defval == nil;

}

static environment **searchenv(const char *name)

{

environment **aenv= &env;

while (*aenv != nil && strcmp((*aenv)->name, name) != 0) {

aenv= &(*aenv)->next;

}

return aenv;

}

#define b_getenv(name) (*searchenv(name))

/* Return the environment *structure* belonging to name, or nil if not found. */

char *b_value(const char *name)

/* The value of a variable. */

{

environment *e= b_getenv(name);

return e == nil || !(e->flags & E_VAR) ? nil : e->value;

}

static char *b_body(const char *name)

/* The value of a function. */

{

environment *e= b_getenv(name);

return e == nil || !(e->flags & E_FUNCTION) ? nil : e->value;

}

static int b_setenv(int flags, const char *name, const char *arg,

const char *value)

/* Change the value of an environment variable. Returns the flags of the

* variable if you are not allowed to change it, 0 otherwise.

*/

{

environment **aenv, *e;

if (*(aenv= searchenv(name)) == nil) {

if (reserved(name)) return E_RESERVED;

e= malloc(sizeof(*e));

e->name= copystr(name);

e->flags= flags;

e->defval= nil;

e->next= nil;

*aenv= e;

} else {

e= *aenv;

/* Don't change special variables to functions or vv. */

if (e->flags & E_SPECIAL

&& (e->flags & E_FUNCTION) != (flags & E_FUNCTION)

) return e->flags;

e->flags= (e->flags & E_STICKY) | flags;

if (is_default(e)) {

e->defval= e->value;

} else {

sfree(e->value);

}

sfree(e->arg);

}

e->arg= copystr(arg);

e->value= copystr(value);

return 0;

}

int b_setvar(int flags, char *name, char *value)

/* Set variable or simple function. */

{

int r;

if((r=b_setenv(flags, name, null, value))) {

return r;

}

return r;

}

void b_unset(const char *name)

/* Remove a variable from the environment. A special variable is reset to

* its default value.

*/

{

environment **aenv, *e;

if ((e= *(aenv= searchenv(name))) == nil) return;

if (e->flags & E_SPECIAL) {

if (e->defval != nil) {

sfree(e->arg);

e->arg= null;

sfree(e->value);

e->value= e->defval;

e->defval= nil;

}

} else {

sfree(e->name);

sfree(e->arg);

sfree(e->value);

*aenv= e->next;

free(e);

}

}

long a2l(const char *a)

/* Cheap atol(). */

{

int sign= 1;

long n= 0;

if (*a == '-') { sign= -1; a++; }

while (between('0', *a, '9')) n= n * 10 + (*a++ - '0');

return sign * n;

}

char *ul2a(u32_t n, unsigned b)

/* Transform a long number to ascii at base b, (b >= 8). */

{

static char num[(CHAR_BIT * sizeof(n) + 2) / 3 + 1];

char *a= arraylimit(num) - 1;

static char hex[16] = "0123456789ABCDEF";

do *--a = hex[(int) (n % b)]; while ((n/= b) > 0);

return a;

}

char *ul2a10(u32_t n)

/* Transform a long number to ascii at base 10. */

{

return ul2a(n, 10);

}

unsigned a2x(const char *a)

/* Ascii to hex. */

{

unsigned n= 0;

int c;

for (;;) {

c= *a;

if (between('0', c, '9')) c= c - '0' + 0x0;

else

if (between('A', c, 'F')) c= c - 'A' + 0xA;

else

if (between('a', c, 'f')) c= c - 'a' + 0xa;

else

break;

n= (n<<4) | c;

a++;

}

return n;

}

static void get_parameters(void)

{

char params[SECTOR_SIZE + 1];

token **acmds;

int r, processor;

memory *mp;

static char bus_type[][4] = {

"xt", "at", "mca"

};

static char vid_type[][4] = {

"mda", "cga", "ega", "ega", "vga", "vga"

};

static char vid_chrome[][6] = {

"mono", "color"

};

/* Variables that Minix needs: */

b_setvar(E_SPECIAL|E_VAR|E_DEV, "rootdev", "ram");

b_setvar(E_SPECIAL|E_VAR|E_DEV, "ramimagedev", "bootdev");

b_setvar(E_SPECIAL|E_VAR, "ramsize", "0");

#define STRINGIT2(x) #x

#define STRINGIT1(x) STRINGIT2(x)

b_setvar(E_SPECIAL|E_VAR, "hz", STRINGIT1(DEFAULT_HZ));

#if BIOS

processor = getprocessor();

if(processor == 1586) processor = 686;

b_setvar(E_SPECIAL|E_VAR, "processor", ul2a10(processor));

b_setvar(E_SPECIAL|E_VAR, "bus", bus_type[get_bus()]);

b_setvar(E_SPECIAL|E_VAR, "video", vid_type[get_video()]);

b_setvar(E_SPECIAL|E_VAR, "chrome", vid_chrome[get_video() & 1]);

params[0]= 0;

for (mp= mem; mp < arraylimit(mem); mp++) {

if (mp->size == 0) continue;

if (params[0] != 0) strcat(params, ",");

strcat(params, ul2a(mp->base, 0x10));

strcat(params, ":");

strcat(params, ul2a(mp->size, 0x10));

}

b_setvar(E_SPECIAL|E_VAR, "memory", params);

#if DOS

b_setvar(E_SPECIAL|E_VAR, "dosfile-d0", vdisk);

#endif

#endif

#if UNIX

b_setvar(E_SPECIAL|E_VAR, "processor", "?");

b_setvar(E_SPECIAL|E_VAR, "bus", "?");

b_setvar(E_SPECIAL|E_VAR, "video", "?");

b_setvar(E_SPECIAL|E_VAR, "chrome", "?");

b_setvar(E_SPECIAL|E_VAR, "memory", "?");

b_setvar(E_SPECIAL|E_VAR, "c0", "?");

#endif

/* Variables boot needs: */

b_setvar(E_SPECIAL|E_VAR, "image", "boot/image");

b_setvar(E_SPECIAL|E_FUNCTION, "leader",

"echo --- Welcome to MINIX 3. This is the boot monitor. ---\\n");

b_setvar(E_SPECIAL|E_FUNCTION, "main", "menu");

b_setvar(E_SPECIAL|E_FUNCTION, "trailer", "");

/* Default hidden menu function: */

b_setenv(E_RESERVED|E_FUNCTION, null, "=,Start MINIX", "boot");

/* Tokenize bootparams sector. */

if ((r= readsectors(mon2abs(params), lowsec+PARAMSEC, 1)) != 0) {

readerr(lowsec+PARAMSEC, r);

exit(1);

}

params[SECTOR_SIZE]= 0;

acmds= tokenize(&cmds, params);

/* Stuff the default action into the command chain. */

#if UNIX

(void) tokenize(acmds, ":;");

#elif DOS

(void) tokenize(tokenize(acmds, ":;leader;"), drun);

#else /* BIOS */

(void) tokenize(acmds, ":;leader;main");

#endif

}