ref: 5edeca01b0622463a65c126ebcc29314013fd928
dir: /os/init/bootinit.b/
# # Generalized boot Inferno # implement Init; include "sys.m"; sys: Sys; include "draw.m"; include "keyring.m"; kr: Keyring; include "security.m"; auth: Auth; random: Random; include "tftp.m"; Bootpreadlen: con 128; Init: module { init: fn(); }; ip: string; mask: string; fsip: string; bootprotocol: string; bootserver: string; bootfile: string; debug: con 0; init() { ipavailable: int; sys = load Sys Sys->PATH; kexecfd := sys->open("#B/kexec", Sys->OWRITE); if (kexecfd == nil) fatal(sys->sprint("opening #B/kexec: %r")); ipavailable = 0; if (dobind("#l", "/net", sys->MREPL) && dobind("#I", "/net", sys->MAFTER)) ipavailable = 1; dobind("#c", "/dev", sys->MAFTER); # console device if (!ipavailable) fatal("no IP stack available"); cfd := sys->open("/net/ipifc/clone", sys->ORDWR); if(cfd == nil) fatal(sys->sprint("open /net/ipifc/clone: %r")); if (sys->fprint(cfd, "bind ether ether0") < 0) fatal(sys->sprint("binding ether0: %r")); fsready := 0; fsip = ipconfig(cfd); bootstring := getenvdefault("bootpath", "tftp"); (bootprotocol, bootserver, bootfile) = parsebootstring(bootstring); if (bootprotocol == nil) fatal(bootstring + ": unrecognised syntax"); # Run dhcp if necessary if (bootprotocol == "tftp" && (bootserver == nil || bootfile == nil)) dhcp(); # determine server if (bootprotocol == "net" && bootserver == nil) bootserver = fsip; if (bootserver == nil) fatal("couldn't determine boot server"); if (bootfile == nil) fatal("couldn't determine boot file"); if (bootprotocol == nil) fatal("couldn't determine boot protocol"); sys->print("loading %s!%s!%s\n", bootprotocol, bootserver, bootfile); if (bootprotocol == "net") { sys->print("Attempting remote mount\n"); if (netfs(bootserver) == 0) sys->print("Remote mount successful\n"); else fatal(sys->sprint("Remote mount failed: %r")); fd := sys->open("/n/remote" + bootfile, Sys->OREAD); if (fd == nil) fatal(sys->sprint("%s:/n/remote%s: %r", bootserver, bootfile)); if (sys->stream(fd, kexecfd, 4096) < 0) fatal(sys->sprint("copying %s: %r", bootfile)); } else if (bootprotocol == "tftp") { tftp := load Tftp Tftp->PATH; if (tftp == nil) fatal("can't load tftp module"); tftp->init(1); errstr := tftp->receive(bootserver, bootfile, kexecfd); if (errstr != nil) fatal("tftp: " + errstr); } else fatal("protocol " + bootprotocol + " not supported"); sys->print("Launching new kernel\n"); kexecfd = nil; } parsebootstring(s: string): (string, string, string) { proto, server, file: string; (n, l) := sys->tokenize(s, "!"); if (n > 3) return (nil, nil, nil); proto = hd l; l = tl l; if (l != nil) { server = hd l; l = tl l; } if (l != nil) file = hd l; case proto { "tftp" => ; "net" => # can't have a default file, so n must be 3 if (n != 3) return (nil, nil, nil); * => return (nil, nil, nil); } return (proto, server, file); } dobind(f, t: string, flags: int): int { if(sys->bind(f, t, flags) < 0) { err(sys->sprint("can't bind %s on %s: %r", f, t)); return 0; } return 1; } err(s: string) { sys->fprint(sys->fildes(2), "bootinit: %s\n", s); } hang() { <-(chan of int); } fatal(s: string) { err(s); hang(); } envlist: list of string; getenv(name: string): string { if (envlist == nil) { fd := sys->open("/dev/sysenv", Sys->OREAD); if (fd != nil) { ntok: int; buf := array[1024] of byte; nr := sys->read(fd, buf, len buf); if(nr > 0) (ntok, envlist) = sys->tokenize(string buf, "\n"); } } ls := envlist; while(ls != nil) { (ntok2, ls2) := sys->tokenize(hd ls, "="); if(hd ls2 == name) return hd tl ls2; ls = tl ls; } return nil; } getenvdefault(name: string, default: string): string { rv := getenv(name); if (rv == nil) return default; return rv; } ipconfig(cfd: ref sys->FD): string { ip = getenv("wireip"); if (ip == nil) ip = getenv("ip"); mask = getenv("ipmask"); fsip = getenv("fsip"); if (ip != nil && mask != nil) { sys->print("ip %s %s\n", ip, mask); sys->fprint(cfd, "add %s %s", ip, mask); gwip := getenv("gwip"); if (gwip != nil) { sys->print("gwip %s\n", gwip); rfd := sys->open("/net/iproute", Sys->ORDWR); if (rfd == nil || sys->fprint(rfd, "add 0.0.0.0 0.0.0.0 %s", gwip) < 0) err(sys->sprint("failed to add default route: %r")); } } if (ip == nil || mask == nil) return bootp(cfd); return fsip; } bootpdone: int; bootp(cfd: ref sys->FD): string { if (bootpdone == 1) return fsip; bootpdone = 1; sys->print("bootp ..."); if (sys->fprint(cfd, "bootp") < 0) { sys->print("init: bootp: %r"); return nil; } fd := sys->open("/net/bootp", sys->OREAD); if(fd == nil) { err(sys->sprint("open /net/bootp: %r")); return nil; } buf := array[Bootpreadlen] of byte; nr := sys->read(fd, buf, len buf); fd = nil; if(nr <= 0) { err(sys->sprint("read /net/bootp: %r")); return nil; } (ntok, ls) := sys->tokenize(string buf, " \t\n"); while(ls != nil) { name := hd ls; ls = tl ls; if (ls == nil) break; value := hd ls; ls = tl ls; if (name == "fsip") fsip = value; else if (name == "ipaddr") ip = value; else if (name == "ipmask") mask = value; } return fsip; } netfs(server: string): int { auth = load Auth Auth->PATH; if (auth != nil) auth->init(); kr = load Keyring Keyring->PATH; sys->print("dial..."); (ok, c) := sys->dial("tcp!" + server + "!6666", nil); if(ok < 0) return -1; if(kr != nil && auth != nil){ err: string; sys->print("Authenticate ..."); ai := kr->readauthinfo("/nvfs/default"); if(ai == nil){ sys->print("readauthinfo /nvfs/default failed: %r\n"); sys->print("trying mount as `nobody'\n"); } (c.dfd, err) = auth->client("none", ai, c.dfd); if(c.dfd == nil){ sys->print("authentication failed: %s\n", err); return -1; } } sys->print("mount ..."); c.cfd = nil; n := sys->mount(c.dfd, nil, "/n/remote", sys->MREPL, ""); if(n > 0) return 0; return -1; } # # # DHCP # # Dhcp: adt { op: int; htype: int; hops: int; xid: int; secs: int; flags: int; ciaddr: int; yiaddr: int; siaddr: int; giaddr: int; chaddr: array of byte; sname: string; file: string; }; nboputl(buf: array of byte, val: int) { buf[0] = byte (val >> 24); buf[1] = byte (val >> 16); buf[2] = byte (val >> 8); buf[3] = byte val; } nboputs(buf: array of byte, val: int) { buf[0] = byte (val >> 8); buf[1] = byte val; } nbogets(buf: array of byte): int { return (int buf[0] << 8) | int buf[1]; } nbogetl(buf: array of byte): int { return (int buf[0] << 24) | (int buf[1] << 16) | (int buf[2] << 8) | int buf[3]; } stringget(buf: array of byte): string { for (x := 0; x < len buf; x++) if (buf[x] == byte 0) break; if (x == 0) return nil; return string buf[0 : x]; } memcmp(b1: array of byte, b2: array of byte): int { l := len b1; if (l < len b2) return int -b2[l]; if (l > len b2) return int b1[l]; for (i := 0; i < l; i++) { d := int b1[i] - int b2[i]; if (d != 0) return d; } return 0; } memncpy(out: array of byte, in: array of byte) { if (in == nil) return; l := len in; if (l > len out) l = len out; out[0 :] = in[0 : l]; } memset(out: array of byte, val: byte) { for (l := 0; l < len out; l++) out[l] = val; } dhcpsend(dfd: ref Sys->FD, dhcp: ref Dhcp) { buf := array[576] of byte; buf[0] = byte dhcp.op; buf[1] = byte dhcp.htype; buf[2] = byte len dhcp.chaddr; buf[3] = byte dhcp.hops; nboputl(buf[4 : 8], dhcp.xid); nboputs(buf[8 : 10], dhcp.secs); nboputs(buf[10 : 12], dhcp.flags); nboputl(buf[12 : 16], dhcp.ciaddr); nboputl(buf[16 : 20], dhcp.yiaddr); nboputl(buf[20 : 24], dhcp.siaddr); nboputl(buf[24 : 28], dhcp.giaddr); memset(buf[28 :], byte 0); memncpy(buf[28 : 44], dhcp.chaddr); memncpy(buf[44 : 108], array of byte dhcp.sname); memncpy(buf[108 : 236], array of byte dhcp.file); sys->write(dfd, buf, len buf); } kill(pid: int) { fd := sys->open("#p/" + string pid + "/ctl", sys->OWRITE); if (fd == nil) return; msg := array of byte "kill"; sys->write(fd, msg, len msg); } ipfmt(ipaddr: int): string { return sys->sprint("%ud.%ud.%ud.%ud", (ipaddr >> 24) & 16rff, (ipaddr >> 16) & 16rff, (ipaddr >> 8) & 16rff, ipaddr & 16rff); } dumpdhcp(dhcp: ref Dhcp) { sys->print("op %d htype %d hops %d xid %ud\n", dhcp.op, dhcp.htype, dhcp.hops, dhcp.xid); sys->print("secs %d flags 0x%.4ux\n", dhcp.secs, dhcp.flags); sys->print("ciaddr %s\n", ipfmt(dhcp.ciaddr)); sys->print("yiaddr %s\n", ipfmt(dhcp.yiaddr)); sys->print("siaddr %s\n", ipfmt(dhcp.siaddr)); sys->print("giaddr %s\n", ipfmt(dhcp.giaddr)); sys->print("chaddr "); for (x := 0; x < len dhcp.chaddr; x++) sys->print("%.2ux", int dhcp.chaddr[x]); sys->print("\n"); if (dhcp.sname != nil) sys->print("sname %s\n", dhcp.sname); if (dhcp.file != nil) sys->print("file %s\n", dhcp.file); } dhcplisten(pidc: chan of int, fd: ref Sys->FD, dc: chan of ref Dhcp) { pid := sys->pctl(0, nil); pidc <-= pid; buf := array [576] of byte; while (1) { n := sys->read(fd, buf, len buf); dhcp := ref Dhcp; dhcp.op = int buf[0]; dhcp.htype = int buf[1]; hlen := int buf[2]; dhcp.hops = int buf[3]; dhcp.xid = nbogetl(buf[4 : 8]); dhcp.secs = nbogets(buf[8 : 10]); dhcp.flags = nbogets(buf[10 : 12]); dhcp.ciaddr = nbogetl(buf[12 : 16]); dhcp.yiaddr = nbogetl(buf[16 : 20]); dhcp.siaddr = nbogetl(buf[20 : 24]); dhcp.giaddr = nbogetl(buf[24: 28]); dhcp.chaddr = buf[28 : 28 + hlen]; dhcp.sname = stringget(buf[44 : 108]); dhcp.file = stringget(buf[108 : 236]); dc <-= dhcp; } } timeoutproc(pid: chan of int, howlong: int, c: chan of string) { pid <-= sys->pctl(0, nil); sys->sleep(howlong); # send timeout c <-= "timed out"; } tpid := -1; tc: chan of string; timeoutcancel() { if (tpid >= 0) { kill(tpid); tpid = -1; } } timeoutstart(howlong: int): (chan of string) { timeoutcancel(); pidc := chan of int; tc = chan of string; spawn timeoutproc(pidc, howlong, tc); tpid = <- pidc; return tc; } atohn(b: byte): int { if (b >= byte '0' && b <= byte '9') return int (b - byte '0'); if (b >= byte 'A' && b <= byte 'F') return int b - 'A' + 10; if (b >= byte 'a' && b <= byte 'f') return int b - 'a' + 10; return -1; } atohb(buf: array of byte): int { tn := atohn(buf[0]); bn := atohn(buf[1]); if (tn < 0 || bn < 0) return -1; return tn * 16 + bn; } gethaddr(dhcp: ref Dhcp): int { fd := sys->open("#l/ether0/addr", Sys->OREAD); if (fd == nil) return 0; buf := array [100] of byte; n := sys->read(fd, buf, len buf); if (n < 0) return 0; dhcp.htype = 1; hlen := n / 2; dhcp.chaddr = array [hlen] of byte; for (i := 0; i < hlen; i++) dhcp.chaddr[i] = byte atohb(buf[i * 2 : i * 2 + 2]); return 1; } parsedq(dq: string): (int, int) { (c, l) := sys->tokenize(dq, "."); if (c != 4) return (0, 0); a := hd l; l = tl l; b := hd l; l = tl l; d := hd l; l = tl l; addr := (int a << 24) | (int b << 16) | (int d << 8) | int hd l; return (1, addr); } dhcp() { ok: int; conn: Sys->Connection; rdhcp: ref Dhcp; if (random == nil) random = load Random Random->PATH; (ok, conn) = sys->dial("udp!255.255.255.255!67", "68"); if (!ok) fatal(sys->sprint("failed to dial udp broadcast: %r")); pidc := chan of int; dc := chan of ref Dhcp; spawn dhcplisten(pidc, conn.dfd, dc); dhcppid := <- pidc; dhcp := ref Dhcp; dhcp.op = 1; dhcp.htype = 1; gethaddr(dhcp); dhcp.hops = 0; dhcp.xid = random->randomint(Random->NotQuiteRandom); dhcp.secs = 0; dhcp.flags = 0; (ok, dhcp.ciaddr) = parsedq(ip); dhcp.yiaddr = 0; dhcp.siaddr = 0; dhcp.giaddr = 0; if (bootfile != "bootp") dhcp.file = bootfile; else dhcp.file = nil; ok = 0; for (count := 0; !ok && count < 5; count++) { mtc := timeoutstart(3000); dhcpsend(conn.dfd, dhcp); timedout := 0; do { alt { <- mtc => timedout = 1; rdhcp = <- dc => if (debug) dumpdhcp(rdhcp); if (rdhcp.ciaddr != dhcp.ciaddr || rdhcp.xid != dhcp.xid || memcmp(rdhcp.chaddr, dhcp.chaddr) != 0) { break; } if (rdhcp.file != nil) { ok = 1; timeoutcancel(); } } } while (!timedout && !ok); dhcp.xid++; } if (ok) { if (bootfile == nil) bootfile = rdhcp.file; if (bootserver == nil) bootserver = ipfmt(rdhcp.siaddr); } else err("bootp timed out"); kill(dhcppid); }