implement Disks; # adapted from /sys/src/libdisk on Plan 9: subject to Lucent Public License 1.02 include "sys.m";	sys: Sys; include "bufio.m";	bufio: Bufio;	Iobuf: import bufio; include "disks.m"; scsiverbose := 0; Codefile: con "/lib/scsicodes"; Code: adt {	v:	int;	# (asc<<8) | ascq	s:	string;};codes: array of Code; init(){	sys = load Sys Sys->PATH;	bufio = load Bufio Bufio->PATH;} ## Discover the disk geometry by various sleazeful means.# # First, if there is a partition table in sector 0,# see if all the partitions have the same end head# and sector; if so, we'll assume that that's the # right count.# # If that fails, we'll try looking at the geometry that the ATA# driver supplied, if any, and translate that as a# BIOS might. # # If that too fails, which should only happen on a SCSI# disk with no currently defined partitions, we'll try# various common (h, s) pairs used by BIOSes when faking# the geometries.# # table entry:	Oactive,			# active flag	Ostarth,			# starting head	Ostarts,			# starting sector	Ostartc,			# starting cylinder	Otype,			# partition type	Oendh,			# ending head	Oends,			# ending sector	Oendc: con iota;		# ending cylinder	Oxlba: con Oendc+1;	# starting LBA from start of disc or partition [4]	Oxsize: con Oxlba+4;	# size in sectors[4] # Table: entry[NTentry][TentrySize] magic[2]Omagic: con NTentry*TentrySize; partitiongeometry(d: ref Disk): int{	buf := array[512] of byte;	t := buf[Toffset:]; 	#	# look for an MBR first in the /dev/sdXX/data partition, otherwise	# attempt to fall back on the current partition.	#	rawfd := sys->open(d.prefix+"data", Sys->OREAD);	if(rawfd != nil	&& sys->seek(rawfd, big 0, 0) == big 0	&& sys->readn(rawfd, buf, 512) == 512	&& int t[Omagic] == Magic0	&& int t[Omagic+1] == Magic1) {		rawfd = nil;	}else{		rawfd = nil;		if(sys->seek(d.fd, big 0, 0) < big 0		|| sys->readn(d.fd, buf, 512) != 512		|| int t[Omagic] != Magic0		|| int t[Omagic+1] != Magic1)			return -1;	} 	h := s := -1;	for(i:=0; i<NTentry*TentrySize; i += TentrySize) {		if(t[i+Otype] == byte 0)			continue; 		t[i+Oends] &= byte 63;		if(h == -1) {			h = int t[i+Oendh];			s = int t[i+Oends];		} else {			#			# Only accept the partition info if every			# partition is consistent.			#			if(h != int t[i+Oendh] || s != int t[i+Oends])				return -1;		}	} 	if(h == -1)		return -1; 	d.h = h+1;	# heads count from 0	d.s = s;	# sectors count from 1	d.c = int (d.secs / big (d.h*d.s));	d.chssrc = "part";	return 0;} ## If there is ATA geometry, use it, perhaps massaged#drivergeometry(d: ref Disk): int{	if(d.c == 0 || d.h == 0 || d.s == 0)		return -1; 	d.chssrc = "disk";	if(d.c < 1024)		return 0; 	case d.h {	15 =>		d.h = 255;		d.c /= 17; 	* =>		for(m := 2; m*d.h < 256; m *= 2) {			if(d.c/m < 1024) {				d.c /= m;				d.h *= m;				return 0;			}		} 		# set to 255, 63 and be done with it		d.h = 255;		d.s = 63;		d.c = int (d.secs / big(d.h * d.s));	}	return 0;} ## There's no ATA geometry and no partitions.# Our guess is as good as anyone's.#Guess: adt {	h:	int;	s:	int;};guess: array of Guess = array[] of {	(64, 32),	(64, 63),	(128, 63),	(255, 63),}; guessgeometry(d: ref Disk){	d.chssrc = "guess";	c := 1024;	for(i:=0; i<len guess; i++)		if(big(c*guess[i].h*guess[i].s) >= d.secs) {			d.h = guess[i].h;			d.s = guess[i].s;			d.c = int(d.secs / big(d.h * d.s));			return;		} 	# use maximum values	d.h = 255;	d.s = 63;	d.c = int(d.secs / big(d.h * d.s));} findgeometry(disk: ref Disk){	disk.h = disk.s = disk.c = 0;	if(partitiongeometry(disk) < 0 &&	   drivergeometry(disk) < 0)		guessgeometry(disk);} openfile(d: ref Disk): ref Disk{	(ok, db) := sys->fstat(d.fd);	if(ok < 0)		return nil; 	d.secsize = 512;	d.size = db.length;	d.secs = d.size / big d.secsize;	d.offset = big 0; 	findgeometry(d);	return mkwidth(d);} opensd(d: ref Disk): ref Disk{	b := bufio->fopen(d.ctlfd, Bufio->OREAD);	while((p := b.gets('\n')) != nil){		p = p[0:len p - 1];		(nf, f) := sys->tokenize(p, " \t");	# might need str->unquote		if(nf >= 3 && hd f == "geometry") {			d.secsize = int hd tl tl f;			if(nf >= 6) {				d.c = int hd tl tl tl f;				d.h = int hd tl tl tl tl f;				d.s = int hd tl tl tl tl tl f;			}		}		if(nf >= 4 && hd f == "part" && hd tl f == d.part) {			d.offset = big hd tl tl f;			d.secs = big hd tl tl tl f - d.offset;		}	} 		d.size = d.secs * big d.secsize;	if(d.size <= big 0) {		d.part = "";		d.dtype = "file";		return openfile(d);	} 	findgeometry(d);	return mkwidth(d);} Disk.open(name: string, mode: int, noctl: int): ref Disk{	d := ref Disk;	d.rdonly = mode == Sys->OREAD;	d.fd = sys->open(name, Sys->OREAD);	if(d.fd == nil)		return nil; 	if(mode != Sys->OREAD){		d.wfd = sys->open(name, Sys->OWRITE);		if(d.wfd == nil)			d.rdonly = 1;	} 	if(noctl)		return openfile(d); 	# check for floppy(3) disk	if(len name >= 7) {		q := name[len name-7:];		if(q[0] == 'f' && q[1] == 'd' && isdigit(q[2]) && q[3:] == "disk") {			if((d.ctlfd = sys->open(name[0:len name-4]+"ctl", Sys->ORDWR)) != nil) {				d.prefix = name[0:len name-4];	# fdN (unlike Plan 9)				d.dtype = "floppy";				return openfile(d);			}		}	} 	# attempt to find sd(3) disk or partition	d.prefix = name;	for(i := len name; --i >= 0;)		if(name[i] == '/'){			d.prefix = name[0:i+1];			break;		} 	if((d.ctlfd = sys->open(d.prefix+"ctl", Sys->ORDWR)) != nil) {		d.dtype = "sd";		d.part = name[len d.prefix:];		return opensd(d);	} 	# assume we have just a normal file	d.dtype = "file";	return openfile(d);} mkwidth(d: ref Disk): ref Disk{	d.width = len sys->sprint("%bd", d.size);	return d;} isdigit(c: int): int{	return c >= '0' && c <= '9';} putchs(d: ref Disk, p: array of byte, lba: big){	s := int (lba % big d.s);	h := int (lba / big d.s % big d.h);	c := int (lba / (big d.s * big d.h)); 	if(c >= 1024) {		c = 1023;		h = d.h - 1;		s = d.s - 1;	} 	p[0] = byte h;	p[1] = byte (((s+1) & 16r3F) | ((c>>2) & 16rC0));	p[2] = byte c;} PCpart.bytes(p: self PCpart, d: ref Disk): array of byte{	a := array[TentrySize] of byte;	a[Oactive] = byte p.active;	a[Otype] = byte p.ptype;	putchs(d, a[Ostarth:], p.base+p.offset);	putchs(d, a[Oendh:], p.base+p.offset+p.size-big 1);	putle32(a[Oxlba:], p.offset);	putle32(a[Oxsize:], p.size);	return a;} PCpart.extract(a: array of byte, nil: ref Disk): PCpart{	p: PCpart;	p.active = int a[Oactive];	p.ptype = int a[Otype];	p.base = big 0;	p.offset = getle32(a[Oxlba:]);	p.size = getle32(a[Oxsize:]);	return p;} getle32(p: array of byte): big{	return (big p[3]<<24) | (big p[2]<<16) | (big p[1] << 8) | big p[0];} putle32(p: array of byte, i: big){	p[0] = byte i;	p[1] = byte (i>>8);	p[2] = byte (i>>16);	p[3] = byte (i>>24);} Disk.readn(d: self ref Disk, buf: array of byte, nb: int): int{	return sys->readn(d.fd, buf, nb);} chstext(p: array of byte): string{	h := int p[0];	c := int p[2];	c |= (int p[1]&16rC0)<<2;	s := (int p[1] & 16r3F);	return sys->sprint("%d/%d/%d", c, h, s);}