path: root/appl/lib/disks.b

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);
}