ref: 21947578303cdb0fcb4b0cdfe80aa9dab5f6b447
dir: /appl/cmd/disk/prep/fdisk.b/
implement Fdisk; # # fdisk - edit dos disk partition table # include "sys.m"; sys: Sys; include "draw.m"; include "disks.m"; disks: Disks; Disk, PCpart: import disks; NTentry, Toffset, TentrySize: import Disks; Magic0, Magic1: import Disks; include "pedit.m"; pedit: Pedit; Edit, Part: import pedit; include "arg.m"; Fdisk: module { init: fn(nil: ref Draw->Context, nil: list of string); }; Mpart: con 64; blank := 0; dowrite := 0; file := 0; rdonly := 0; doauto := 0; mbroffset := big 0; printflag := 0; printchs := 0; sec2cyl := big 0; written := 0; edit: ref Edit; stderr: ref Sys->FD; init(nil: ref Draw->Context, args: list of string) { sys = load Sys Sys->PATH; disks = load Disks Disks->PATH; pedit = load Pedit Pedit->PATH; sys->pctl(Sys->FORKFD, nil); disks->init(); pedit->init(); edit = Edit.mk("cylinder"); edit.add = cmdadd; edit.del = cmddel; edit.okname = cmdokname; edit.ext = cmdext; edit.help = cmdhelp; edit.sum = cmdsum; edit.write = cmdwrite; edit.printctl = cmdprintctl; stderr = sys->fildes(2); secsize := 0; arg := load Arg Arg->PATH; arg->init(args); arg->setusage("disk/fdisk [-abfprvw] [-s sectorsize] /dev/sdC0/data"); while((o := arg->opt()) != 0) case o { 'a' => doauto++; 'b' => blank++; 'f' => file++; 'p' => printflag++; 'r' => rdonly++; 's' => secsize = int arg->earg(); 'v' => printchs++; 'w' => dowrite++; * => arg->usage(); } args = arg->argv(); if(len args != 1) arg->usage(); arg = nil; mode := Sys->ORDWR; if(rdonly) mode = Sys->OREAD; edit.disk = Disk.open(hd args, mode, file); if(edit.disk == nil) { sys->fprint(stderr, "cannot open disk: %r\n"); exits("opendisk"); } if(secsize != 0) { edit.disk.secsize = secsize; edit.disk.secs = edit.disk.size / big secsize; } sec2cyl = big (edit.disk.h * edit.disk.s); edit.end = edit.disk.secs / sec2cyl; findmbr(edit); if(blank) blankpart(edit); else rdpart(edit, big 0, big 0); if(doauto) autopart(edit); { if(dowrite) edit.runcmd("w"); if(printflag) edit.runcmd("P"); if(dowrite || printflag) exits(nil); sys->fprint(stderr, "cylinder = %bd bytes\n", sec2cyl*big edit.disk.secsize); edit.runcmd("p"); for(;;) { sys->fprint(stderr, ">>> "); edit.runcmd(edit.getline()); } }exception e{ "*" => sys->fprint(stderr, "fdisk: exception %q\n", e); if(written) recover(edit); } } Active: con 16r80; # partition is active Primary: con 16r01; # internal flag TypeBB: con 16rFF; TypeEMPTY: con 16r00; TypeFAT12: con 16r01; TypeXENIX: con 16r02; # root TypeXENIXUSR: con 16r03; # usr TypeFAT16: con 16r04; TypeEXTENDED: con 16r05; TypeFATHUGE: con 16r06; TypeHPFS: con 16r07; TypeAIXBOOT: con 16r08; TypeAIXDATA: con 16r09; TypeOS2BOOT: con 16r0A; # OS/2 Boot Manager TypeFAT32: con 16r0B; # FAT 32 TypeFAT32LBA: con 16r0C; # FAT 32 needing LBA support TypeEXTHUGE: con 16r0F; # FAT 32 extended partition TypeUNFORMATTED: con 16r16; # unformatted primary partition (OS/2 FDISK)? TypeHPFS2: con 16r17; TypeIBMRecovery: con 16r1C; # really hidden fat TypeCPM0: con 16r52; TypeDMDDO: con 16r54; # Disk Manager Dynamic Disk Overlay TypeGB: con 16r56; # ???? TypeSPEEDSTOR: con 16r61; TypeSYSV386: con 16r63; # also HURD? TypeNETWARE: con 16r64; TypePCIX: con 16r75; TypeMINIX13: con 16r80; # Minix v1.3 and below TypeMINIX: con 16r81; # Minix v1.5+ TypeLINUXSWAP: con 16r82; TypeLINUX: con 16r83; TypeLINUXEXT: con 16r85; TypeAMOEBA: con 16r93; TypeAMOEBABB: con 16r94; TypeBSD386: con 16rA5; TypeBSDI: con 16rB7; TypeBSDISWAP: con 16rB8; TypeOTHER: con 16rDA; TypeCPM: con 16rDB; TypeDellRecovery: con 16rDE; TypeSPEEDSTOR12: con 16rE1; TypeSPEEDSTOR16: con 16rE4; TypeLANSTEP: con 16rFE; Type9: con Disks->Type9; TableSize: con TentrySize*NTentry; Omagic: con TableSize; Type: adt { desc: string; name: string; }; Dospart: adt { p: ref Part; pc: ref PCpart; primary: int; lba: big; # absolute address size: big; }; Recover: adt { table: array of byte; # [TableSize+2] copy of table and magic lba: big; # where it came from }; types: array of Type = array[256] of { TypeEMPTY => ( "EMPTY", "" ), TypeFAT12 => ( "FAT12", "dos" ), TypeFAT16 => ( "FAT16", "dos" ), TypeFAT32 => ( "FAT32", "dos" ), TypeFAT32LBA => ( "FAT32LBA", "dos" ), TypeEXTHUGE => ( "EXTHUGE", "" ), TypeIBMRecovery => ( "IBMRECOVERY", "ibm" ), TypeEXTENDED => ( "EXTENDED", "" ), TypeFATHUGE => ( "FATHUGE", "dos" ), TypeBB => ( "BB", "bb" ), TypeXENIX => ( "XENIX", "xenix" ), TypeXENIXUSR => ( "XENIX USR", "xenixusr" ), TypeHPFS => ( "HPFS", "ntfs" ), TypeAIXBOOT => ( "AIXBOOT", "aixboot" ), TypeAIXDATA => ( "AIXDATA", "aixdata" ), TypeOS2BOOT => ( "OS/2BOOT", "os2boot" ), TypeUNFORMATTED => ( "UNFORMATTED", "" ), TypeHPFS2 => ( "HPFS2", "hpfs2" ), TypeCPM0 => ( "CPM0", "cpm0" ), TypeDMDDO => ( "DMDDO", "dmdd0" ), TypeGB => ( "GB", "gb" ), TypeSPEEDSTOR => ( "SPEEDSTOR", "speedstor" ), TypeSYSV386 => ( "SYSV386", "sysv386" ), TypeNETWARE => ( "NETWARE", "netware" ), TypePCIX => ( "PCIX", "pcix" ), TypeMINIX13 => ( "MINIXV1.3", "minix13" ), TypeMINIX => ( "MINIXV1.5", "minix15" ), TypeLINUXSWAP => ( "LINUXSWAP", "linuxswap" ), TypeLINUX => ( "LINUX", "linux" ), TypeLINUXEXT => ( "LINUXEXTENDED", "" ), TypeAMOEBA => ( "AMOEBA", "amoeba" ), TypeAMOEBABB => ( "AMOEBABB", "amoebaboot" ), TypeBSD386 => ( "BSD386", "bsd386" ), TypeBSDI => ( "BSDI", "bsdi" ), TypeBSDISWAP => ( "BSDISWAP", "bsdiswap" ), TypeOTHER => ( "OTHER", "other" ), TypeCPM => ( "CPM", "cpm" ), TypeDellRecovery => ( "DELLRECOVERY", "dell" ), TypeSPEEDSTOR12 => ( "SPEEDSTOR12", "speedstor" ), TypeSPEEDSTOR16 => ( "SPEEDSTOR16", "speedstor" ), TypeLANSTEP => ( "LANSTEP", "lanstep" ), Type9 => ( "PLAN9", "plan9" ), * => (nil, nil), }; dosparts: list of ref Dospart; tag2part(p: ref Part): ref Dospart { for(l := dosparts; l != nil; l = tl l) if((hd l).p.tag == p.tag) return hd l; raise "tag2part: cannot happen"; } typestr0(ptype: int): string { if(ptype < 0 || ptype >= len types || types[ptype].desc == nil) return sys->sprint("type %d", ptype); return types[ptype].desc; } gettable(disk: ref Disk, addr: big, mbr: int): array of byte { table := array[TableSize+2] of {* => byte 0}; diskread(disk, table, len table, addr, Toffset); if(mbr){ # the informal specs say all must have this but apparently not, only mbr if(int table[Omagic] != Magic0 || int table[Omagic+1] != Magic1) sysfatal("did not find master boot record"); } return table; } diskread(disk: ref Disk, data: array of byte, ndata: int, sec: big, off: int) { a := sec*big disk.secsize + big off; if(sys->seek(disk.fd, a, 0) != a) sysfatal(sys->sprint("diskread seek %bud.%ud: %r", sec, off)); if(sys->readn(disk.fd, data, ndata) != ndata) sysfatal(sys->sprint("diskread %ud at %bud.%ud: %r", ndata, sec, off)); } puttable(disk: ref Disk, table: array of byte, sec: big): int { return diskwrite(disk, table, len table, sec, Toffset); } diskwrite(disk: ref Disk, data: array of byte, ndata: int, sec: big, off: int): int { written = 1; a := sec*big disk.secsize + big off; if(sys->seek(disk.wfd, a, 0) != a || sys->write(disk.wfd, data, ndata) != ndata){ sys->fprint(stderr, "write %d bytes at %bud.%ud failed: %r\n", ndata, sec, off); return -1; } return 0; } partgen := 0; parttag := 0; mkpart(name: string, primary: int, lba: big, size: big, pcpart: ref PCpart): ref Dospart { p := ref Dospart; if(name == nil){ if(primary) c := 'p'; else c = 's'; name = sys->sprint("%c%d", c, ++partgen); } if(pcpart != nil) p.pc = pcpart; else p.pc = ref PCpart(0, 0, big 0, big 0, big 0); p.primary = primary; p.p = ref Part; # TO DO p.p.name = name; p.p.start = lba/sec2cyl; p.p.end = (lba+size)/sec2cyl; p.p.ctlstart = lba; p.p.ctlend = lba+size; p.p.tag = ++parttag; p.lba = lba; # absolute lba p.size = size; dosparts = p :: dosparts; return p; } # # Recovery takes care of remembering what the various tables # looked like when we started, attempting to restore them when # we are finished. # rtabs: list of ref Recover; addrecover(t: array of byte, lba: big) { tc := array[TableSize+2] of byte; tc[0:] = t[0:len tc]; rtabs = ref Recover(tc, lba) :: rtabs; } recover(edit: ref Edit) { err := 0; for(rl := rtabs; rl != nil; rl = tl rl){ r := hd rl; if(puttable(edit.disk, r.table, r.lba) < 0) err = 1; } if(err) { sys->fprint(stderr, "warning: some writes failed during restoration of old partition tables\n"); exits("inconsistent"); } else sys->fprint(stderr, "restored old partition tables\n"); ctlfd := edit.disk.ctlfd; if(ctlfd != nil){ offset := edit.disk.offset; for(i:=0; i<len edit.part; i++) if(edit.part[i].ctlname != nil && sys->fprint(ctlfd, "delpart %s", edit.part[i].ctlname)<0) sys->fprint(stderr, "delpart failed: %s: %r", edit.part[i].ctlname); for(i=0; i<len edit.ctlpart; i++) if(edit.part[i].name != nil && sys->fprint(ctlfd, "delpart %s", edit.ctlpart[i].name)<0) sys->fprint(stderr, "delpart failed: %s: %r", edit.ctlpart[i].name); for(i=0; i<len edit.ctlpart; i++){ if(sys->fprint(ctlfd, "part %s %bd %bd", edit.ctlpart[i].name, edit.ctlpart[i].start+offset, edit.ctlpart[i].end+offset) < 0){ sys->fprint(stderr, "restored disk partition table but not kernel; reboot\n"); exits("inconsistent"); } } } exits("restored"); } # # Read the partition table (including extended partition tables) # from the disk into the part array. # rdpart(edit: ref Edit, lba: big, xbase: big) { if(xbase == big 0) xbase = lba; # extended partition in mbr sets the base table := gettable(edit.disk, mbroffset+lba, lba == big 0); addrecover(table, mbroffset+lba); for(tp := 0; tp<TableSize; tp += TentrySize){ dp := PCpart.extract(table[tp:], edit.disk); case dp.ptype { TypeEMPTY => ; TypeEXTENDED or TypeEXTHUGE or TypeLINUXEXT => rdpart(edit, xbase+dp.offset, xbase); * => p := mkpart(nil, lba==big 0, lba+dp.offset, dp.size, ref dp); if((err := edit.addpart(p.p)) != nil) sys->fprint(stderr, "error adding partition: %s\n", err); } } } blankpart(edit: ref Edit) { edit.changed = 1; } findmbr(edit: ref Edit) { table := gettable(edit.disk, big 0, 1); for(tp := 0; tp < TableSize; tp += TentrySize){ p := PCpart.extract(table[tp:], edit.disk); if(p.ptype == TypeDMDDO) mbroffset = big edit.disk.s; } } haveroom(edit: ref Edit, primary: int, start: big): int { if(primary) { # # must be open primary slot. # primary slots are taken by primary partitions # and runs of secondary partitions. # n := 0; lastsec := 0; for(i:=0; i<len edit.part; i++) { p := tag2part(edit.part[i]); if(p.primary){ n++; lastsec = 0; }else if(!lastsec){ n++; lastsec = 1; } } return n<4; } # # secondary partitions can be inserted between two primary # partitions only if there is an empty primary slot. # otherwise, we can put a new secondary partition next # to a secondary partition no problem. # n := 0; for(i:=0; i<len edit.part; i++){ p := tag2part(edit.part[i]); if(p.primary) n++; pend := p.p.end; q: ref Dospart; qstart: big; if(i+1<len edit.part){ q = tag2part(edit.part[i+1]); qstart = q.p.start; }else{ qstart = edit.end; q = nil; } if(start < pend || start >= qstart) continue; # we go between these two if(p.primary==0 || (q != nil && q.primary==0)) return 1; } # not next to a secondary, need a new primary return n<4; } autopart(edit: ref Edit) { for(i:=0; i<len edit.part; i++) if(tag2part(edit.part[i]).pc.ptype == Type9) return; # look for the biggest gap in which we can put a primary partition start := big 0; bigsize := big 0; bigstart := big 0; for(i=0; i<len edit.part; i++) { p := tag2part(edit.part[i]); if(p.p.start > start && p.p.start - start > bigsize && haveroom(edit, 1, start)) { bigsize = p.p.start - start; bigstart = start; } start = p.p.end; } if(edit.end - start > bigsize && haveroom(edit, 1, start)) { bigsize = edit.end - start; bigstart = start; } if(bigsize < big 1) { sys->fprint(stderr, "couldn't find space or partition slot for plan 9 partition\n"); return; } # set new partition active only if no others are active := Active; for(i=0; i<len edit.part; i++){ p := tag2part(edit.part[i]); if(p.primary && p.pc.active & Active) active = 0; } # add new plan 9 partition bigsize *= sec2cyl; bigstart *= sec2cyl; if(bigstart == big 0) { bigstart += big edit.disk.s; bigsize -= big edit.disk.s; } p := mkpart(nil, 1, bigstart, bigsize, nil); p.p.changed = 1; p.pc.active = active; p.pc.ptype = Type9; edit.changed = 1; if((err := edit.addpart(p.p)) != nil){ sys->fprint(stderr, "error adding plan9 partition: %s\n", err); return; } } namelist: list of string; plan9print(part: ref Dospart, fd: ref Sys->FD) { vname := types[part.pc.ptype].name; if(vname==nil) { part.p.ctlname = ""; return; } start := mbroffset+part.lba; end := start+part.size; # avoid names like plan90 i := len vname - 1; if(isdigit(vname[i])) sep := "."; else sep = ""; i = 0; name := sys->sprint("%s", vname); ok: int; do { ok = 1; for(nl := namelist; nl != nil; nl = tl nl) if(name == hd nl) { i++; name = sys->sprint("%s%s%d", vname, sep, i); ok = 0; } } while(ok == 0); namelist = name :: namelist; part.p.ctlname = name; if(fd != nil) sys->print("part %s %bd %bd\n", name, start, end); } cmdprintctl(edit: ref Edit, ctlfd: ref Sys->FD) { namelist = nil; for(i:=0; i<len edit.part; i++) plan9print(tag2part(edit.part[i]), nil); edit.ctldiff(ctlfd); } cmdokname(nil: ref Edit, name: string): string { if(name[0] != 'p' && name[0] != 's' || len name < 2) return "name must be pN or sN"; for(i := 1; i < len name; i++) if(!isdigit(name[i])) return "name must be pN or sN"; return nil; } KB: con big 1024; MB: con KB*KB; GB: con KB*MB; cmdsum(edit: ref Edit, vp: ref Part, a, b: big) { if(vp != nil) p := tag2part(vp); qual: string; if(p != nil && p.p.changed) qual += "'"; else qual += " "; if(p != nil && p.pc.active&Active) qual += "*"; else qual += " "; if(p != nil) name := p.p.name; else name = "empty"; if(p != nil) ty := " "+typestr0(p.pc.ptype); else ty = ""; sz := (b-a)*big edit.disk.secsize*sec2cyl; suf := "B"; div := big 1; if(sz >= big 1*GB){ suf = "GB"; div = GB; }else if(sz >= big 1*MB){ suf = "MB"; div = MB; }else if(sz >= big 1*KB){ suf = "KB"; div = KB; } if(div == big 1) sys->print("%s %-12s %*bd %-*bd (%bd cylinders, %bd %s)%s\n", qual, name, edit.disk.width, a, edit.disk.width, b, b-a, sz, suf, ty); else sys->print("%s %-12s %*bd %-*bd (%bd cylinders, %bd.%.2d %s)%s\n", qual, name, edit.disk.width, a, edit.disk.width, b, b-a, sz/div, int(((sz%div)*big 100)/div), suf, ty); } cmdadd(edit: ref Edit, name: string, start: big, end: big): string { if(!haveroom(edit, name[0]=='p', start)) return "no room for partition"; start *= sec2cyl; end *= sec2cyl; if(start == big 0 || name[0] != 'p') start += big edit.disk.s; p := mkpart(name, name[0]=='p', start, end-start, nil); p.p.changed = 1; p.pc.ptype = Type9; return edit.addpart(p.p); } cmddel(edit: ref Edit, p: ref Part): string { return edit.delpart(p); } cmdwrite(edit: ref Edit): string { wrpart(edit); return nil; } help: con "A name - set partition active\n"+ "P - sys->print table in ctl format\n"+ "R - restore disk back to initial configuration and exit\n"+ "e - show empty dos partitions\n"+ "t name [type] - set partition type\n"; cmdhelp(nil: ref Edit): string { sys->print("%s\n", help); return nil; } cmdactive(edit: ref Edit, f: array of string): string { if(len f != 2) return "args"; if(f[1][0] != 'p') return "cannot set secondary partition active"; if((p := tag2part(edit.findpart(f[1]))) == nil) return "unknown partition"; for(i:=0; i<len edit.part; i++) { ip := tag2part(edit.part[i]); if(ip.pc.active & Active) { ip.pc.active &= ~Active; ip.p.changed = 1; edit.changed = 1; } } if((p.pc.active & Active) == 0) { p.pc.active |= Active; p.p.changed = 1; edit.changed = 1; } return nil; } strupr(s: string): string { for(i := 0; i < len s; i++) if(s[i] >= 'a' && s[i] <= 'z') s[i] += 'A' - 'a'; return s; } dumplist() { n := 0; for(i:=0; i<len types; i++) { if(types[i].desc != nil) { sys->print("%-16s", types[i].desc); if(n++%4 == 3) sys->print("\n"); } } if(n%4) sys->print("\n"); } cmdtype(edit: ref Edit, f: array of string): string { if(len f < 2) return "args"; if((p := tag2part(edit.findpart(f[1]))) == nil) return "unknown partition"; q: string; if(len f == 2) { for(;;) { sys->fprint(stderr, "new partition type [? for list]: "); q = edit.getline(); if(q[0] == '?') dumplist(); else break; } } else q = f[2]; q = strupr(q); for(i:=0; i<len types; i++) if(types[i].desc != nil && types[i].desc == q) break; if(i < len types && p.pc.ptype != i) { p.pc.ptype = i; p.p.changed = 1; edit.changed = 1; } return nil; } cmdext(edit: ref Edit, f: array of string): string { case f[0][0] { 'A' => return cmdactive(edit, f); 't' => return cmdtype(edit, f); 'R' => recover(edit); return nil; * => return "unknown command"; } } wrextend(edit: ref Edit, i: int, xbase: big, startlba: big): (int, big) { if(i == len edit.part){ endlba := edit.disk.secs; if(startlba < endlba) wrzerotab(edit.disk, mbroffset+startlba); return (i, endlba); } p := tag2part(edit.part[i]); if(p.primary){ endlba := p.p.start*sec2cyl; if(startlba < endlba) wrzerotab(edit.disk, mbroffset+startlba); return (i, endlba); } disk := edit.disk; table := gettable(disk, mbroffset+startlba, 0); (ni, endlba) := wrextend(edit, i+1, xbase, p.p.end*sec2cyl); tp := wrtentry(disk, table[0:], p.pc.active, p.pc.ptype, startlba, startlba+big disk.s, p.p.end*sec2cyl); if(p.p.end*sec2cyl != endlba) tp += wrtentry(disk, table[tp:], 0, TypeEXTENDED, xbase, p.p.end*sec2cyl, endlba); for(; tp<TableSize; tp++) table[tp] = byte 0; table[Omagic] = byte Magic0; table[Omagic+1] = byte Magic1; if(puttable(edit.disk, table, mbroffset+startlba) < 0) recover(edit); return (ni, endlba); } wrzerotab(disk: ref Disk, addr: big) { table := array[TableSize+2] of {Omagic => byte Magic0, Omagic+1 => byte Magic1, * => byte 0}; if(puttable(disk, table, addr) < 0) recover(edit); } wrpart(edit: ref Edit) { disk := edit.disk; table := gettable(disk, mbroffset, 0); tp := 0; for(i:=0; i<len edit.part && tp<TableSize; ) { p := tag2part(edit.part[i]); if(p.p.start == big 0) s := big disk.s; else s = p.p.start*sec2cyl; if(p.primary) { tp += wrtentry(disk, table[tp:], p.pc.active, p.pc.ptype, big 0, s, p.p.end*sec2cyl); i++; }else{ (ni, endlba) := wrextend(edit, i, p.p.start*sec2cyl, p.p.start*sec2cyl); if(endlba >= big 1024*sec2cyl) t := TypeEXTHUGE; else t = TypeEXTENDED; tp += wrtentry(disk, table[tp:], 0, t, big 0, s, endlba); i = ni; } } for(; tp<TableSize; tp++) table[tp] = byte 0; if(i != len edit.part) raise "wrpart: cannot happen #1"; if(puttable(disk, table, mbroffset) < 0) recover(edit); # bring parts up to date namelist = nil; for(i=0; i<len edit.part; i++) plan9print(tag2part(edit.part[i]), nil); if(edit.ctldiff(disk.ctlfd) < 0) sys->fprint(stderr, "?warning: partitions could not be updated in devsd\n"); } isdigit(c: int): int { return c >= '0' && c <= '9'; } sysfatal(s: string) { sys->fprint(stderr, "fdisk: %s\n", s); raise "fail:error"; } exits(s: string) { if(s != nil) raise "fail:"+s; exit; } assert(i: int) { if(!i) raise "assertion failed"; } wrtentry(disk: ref Disk, entry: array of byte, active: int, ptype: int, xbase: big, lba: big, end: big): int { pc: PCpart; pc.active = active; pc.ptype = ptype; pc.base = xbase; pc.offset = lba-xbase; pc.size = end-lba; entry[0:] = pc.bytes(disk); return TentrySize; }