/*
 * read disk partition tables, intended for early use on systems
 * that don't use 9load.  borrowed from 9load.
 */

#include <u.h>
#include <libc.h>
#include <auth.h>
#include <fcall.h>
#include <bio.h>
#include "../boot/boot.h"

typedef struct Fs Fs;
#include "/sys/src/boot/pc/dosfs.h"

#define	GSHORT(p)	(((p)[1]<<8)|(p)[0])
#define	GLONG(p)	((GSHORT((p)+2)<<16)|GSHORT(p))

#define trace 0

enum {
	parttrace = 0,

	Npart = 64,
	SDnpart = Npart,

	Maxsec = 2048,
	Cdsec = 2048,
	Normsec = 512,			/* disks */

	NAMELEN = 256,			/* hack */
};

typedef struct SDpart SDpart;
typedef struct SDunit SDunit;

typedef struct SDpart {
	uvlong	start;
	uvlong	end;
	char	name[NAMELEN];
	int	valid;
} SDpart;

typedef struct SDunit {
	int	ctl;			/* fds */
	int	data;

	char	name[NAMELEN];

	uvlong	sectors;
	ulong	secsize;
	SDpart*	part;
	int	npart;			/* of valid partitions */
} SDunit;

static uchar *mbrbuf, *partbuf;

static void
sdaddpart(SDunit* unit, char* name, uvlong start, uvlong end)
{
	SDpart *pp;
	int i, partno;

	if(parttrace)
		print("add %d %s %s %lld %lld\n", unit->npart, unit->name, name, start, end);
	/*
	 * Check name not already used
	 * and look for a free slot.
	 */
	if(unit->part != nil){
		partno = -1;
		for(i = 0; i < SDnpart; i++){
			pp = &unit->part[i];
			if(!pp->valid){
				if(partno == -1)
					partno = i;
				break;
			}
			if(strcmp(name, pp->name) == 0){
				if(pp->start == start && pp->end == end){
					if(parttrace)
						print("already present\n");
					return;
				}
			}
		}
	}else{
		if((unit->part = malloc(sizeof(SDpart)*SDnpart)) == nil){
			if(parttrace)
				print("malloc failed\n");
			return;
		}
		partno = 0;
	}

	/*
	 * Check there is a free slot and size and extent are valid.
	 */
	if(partno == -1 || start > end || end > unit->sectors){
		print("cannot add %s!%s [%llud,%llud) to disk [0,%llud): %s\n",
			unit->name, name, start, end, unit->sectors, 
			partno==-1 ? "no free partitions" : "partition boundaries out of range");
		return;
	}
	pp = &unit->part[partno];
	pp->start = start;
	pp->end = end;
	strncpy(pp->name, name, NAMELEN);
	pp->valid = 1;
	unit->npart++;

	/* update devsd's in-memory partition table */
	if (fprint(unit->ctl, "part %s %lld %lld\n", name, start, end) < 0)
		fprint(2, "can't update %s's devsd partition table for %s: %r\n",
			unit->name, name);
	dprint("part %s %lld %lld\n", name, start, end);
}

static long
sdread(SDunit *unit, SDpart *pp, void* va, long len, vlong off)
{
	long l, secsize;
	uvlong bno, nb;

	/*
	 * Check the request is within partition bounds.
	 */
	secsize = unit->secsize;
	if (secsize == 0)
		sysfatal("sdread: zero sector size");
	bno = off/secsize + pp->start;
	nb = (off+len+secsize-1)/secsize + pp->start - bno;
	if(bno+nb > pp->end)
		nb = pp->end - bno;
	if(bno >= pp->end || nb == 0)
		return 0;

	seek(unit->data, bno * secsize, 0);
	assert(va);				/* "sdread" */
	l = read(unit->data, va, len);
	if (l < 0)
		return 0;
	return l;
}

static int
sdreadblk(SDunit *unit, SDpart *part, void *a, vlong off, int mbr)
{
	uchar *b;

	assert(a);			/* sdreadblk */
	if(sdread(unit, part, a, unit->secsize, off) != unit->secsize){
		if(trace)
			print("%s: read %lud at %lld failed\n", unit->name,
				unit->secsize, (vlong)part->start*unit->secsize+off);
		return -1;
	}
	b = a;
	if(mbr && (b[0x1FE] != 0x55 || b[0x1FF] != 0xAA)){
		if(trace)
			print("%s: bad magic %.2ux %.2ux at %lld\n",
				unit->name, b[0x1FE], b[0x1FF],
				(vlong)part->start*unit->secsize+off);
		return -1;
	}
	return 0;
}

/*
 *  read partition table.  The partition table is just ascii strings.
 */
#define MAGIC "plan9 partitions"
static void
oldp9part(SDunit *unit)
{
	SDpart *pp;
	char *field[3], *line[Npart+1];
	ulong n;
	uvlong start, end;
	int i;

	/*
	 *  We have some partitions already.
	 */
	pp = &unit->part[unit->npart];

	/*
	 * We prefer partition tables on the second to last sector,
	 * but some old disks use the last sector instead.
	 */
	strcpy(pp->name, "partition");
	pp->start = unit->sectors - 2;
	pp->end = unit->sectors - 1;

	dprint("oldp9part %s\n", unit->name);
	if(sdreadblk(unit, pp, partbuf, 0, 0) < 0)
		return;

	if(strncmp((char*)partbuf, MAGIC, sizeof(MAGIC)-1) != 0) {
		/* not found on 2nd last sector; look on last sector */
		pp->start++;
		pp->end++;
		if(sdreadblk(unit, pp, partbuf, 0, 0) < 0)
			return;
		if(strncmp((char*)partbuf, MAGIC, sizeof(MAGIC)-1) != 0)
			return;
		print("%s: using old plan9 partition table on last sector\n", unit->name);
	}else
		print("%s: using old plan9 partition table on 2nd-to-last sector\n", unit->name);

	/* we found a partition table, so add a partition partition */
	unit->npart++;
	partbuf[unit->secsize-1] = '\0';

	/*
	 * parse partition table
	 */
	n = gettokens((char*)partbuf, line, Npart+1, "\n");
	if(n && strncmp(line[0], MAGIC, sizeof(MAGIC)-1) == 0){
		for(i = 1; i < n && unit->npart < SDnpart; i++){
			if(gettokens(line[i], field, 3, " ") != 3)
				break;
			start = strtoull(field[1], 0, 0);
			end = strtoull(field[2], 0, 0);
			if(start >= end || end > unit->sectors)
				break;
			sdaddpart(unit, field[0], start, end);
		}
	}	
}

static SDpart*
sdfindpart(SDunit *unit, char *name)
{
	int i;

	if(parttrace)
		print("findpart %d %s %s: ", unit->npart, unit->name, name);
	for(i=0; i<unit->npart; i++) {
		if(parttrace)
			print("%s...", unit->part[i].name);
		if(strcmp(unit->part[i].name, name) == 0){
			if(parttrace)
				print("\n");
			return &unit->part[i];
		}
	}
	if(parttrace)
		print("not found\n");
	return nil;
}

/*
 * look for a plan 9 partition table on drive `unit' in the second
 * sector (sector 1) of partition `name'.
 * if found, add the partitions defined in the table.
 */
static void
p9part(SDunit *unit, char *name)
{
	SDpart *p;
	char *field[4], *line[Npart+1];
	uvlong start, end;
	int i, n;

	dprint("p9part %s %s\n", unit->name, name);
	p = sdfindpart(unit, name);
	if(p == nil)
		return;

	if(sdreadblk(unit, p, partbuf, unit->secsize, 0) < 0)
		return;
	partbuf[unit->secsize-1] = '\0';

	if(strncmp((char*)partbuf, "part ", 5) != 0)
		return;

	n = gettokens((char*)partbuf, line, Npart+1, "\n");
	if(n == 0)
		return;
	for(i = 0; i < n && unit->npart < SDnpart; i++){
		if(strncmp(line[i], "part ", 5) != 0)
			break;
		if(gettokens(line[i], field, 4, " ") != 4)
			break;
		start = strtoull(field[2], 0, 0);
		end   = strtoull(field[3], 0, 0);
		if(start >= end || end > unit->sectors)
			break;
		sdaddpart(unit, field[1], p->start+start, p->start+end);
	}
}

static int
isdos(int t)
{
	return t==FAT12 || t==FAT16 || t==FATHUGE || t==FAT32 || t==FAT32X;
}

static int
isextend(int t)
{
	return t==EXTEND || t==EXTHUGE || t==LEXTEND;
}

/* 
 * Fetch the first dos and all plan9 partitions out of the MBR partition table.
 * We return -1 if we did not find a plan9 partition.
 */
static int
mbrpart(SDunit *unit)
{
	Dospart *dp;
	uvlong taboffset, start, end;
	uvlong firstxpart, nxtxpart;
	int havedos, i, nplan9;
	char name[10];

	taboffset = 0;
	dp = (Dospart*)&mbrbuf[0x1BE];
	{
		/* get the MBR (allowing for DMDDO) */
		if(sdreadblk(unit, &unit->part[0], mbrbuf,
		    (vlong)taboffset * unit->secsize, 1) < 0)
			return -1;
		for(i=0; i<4; i++)
			if(dp[i].type == DMDDO) {
				if(trace)
					print("DMDDO partition found\n");
				taboffset = 63;
				if(sdreadblk(unit, &unit->part[0], mbrbuf,
				    (vlong)taboffset * unit->secsize, 1) < 0)
					return -1;
				i = -1;	/* start over */
			}
	}

	/*
	 * Read the partitions, first from the MBR and then
	 * from successive extended partition tables.
	 */
	nplan9 = 0;
	havedos = 0;
	firstxpart = 0;
	for(;;) {
		if(sdreadblk(unit, &unit->part[0], mbrbuf,
		    (vlong)taboffset * unit->secsize, 1) < 0)
			return -1;
		if(trace) {
			if(firstxpart)
				print("%s ext %llud ", unit->name, taboffset);
			else
				print("%s mbr ", unit->name);
		}
		nxtxpart = 0;
		for(i=0; i<4; i++) {
			if(trace)
				print("dp %d...", dp[i].type);
			start = taboffset+GLONG(dp[i].start);
			end = start+GLONG(dp[i].len);

			if(dp[i].type == PLAN9) {
				if(nplan9 == 0)
					strcpy(name, "plan9");
				else
					sprint(name, "plan9.%d", nplan9);
				sdaddpart(unit, name, start, end);
				p9part(unit, name);
				nplan9++;
			}

			/*
			 * We used to take the active partition (and then the first
			 * when none are active).  We have to take the first here,
			 * so that the partition we call ``dos'' agrees with the
			 * partition disk/fdisk calls ``dos''. 
			 */
			if(havedos==0 && isdos(dp[i].type)){
				havedos = 1;
				sdaddpart(unit, "dos", start, end);
			}

			/* nxtxpart is relative to firstxpart (or 0), not taboffset */
			if(isextend(dp[i].type)){
				nxtxpart = start-taboffset+firstxpart;
				if(trace)
					print("link %llud...", nxtxpart);
			}
		}
		if(trace)
			print("\n");

		if(!nxtxpart)
			break;
		if(!firstxpart)
			firstxpart = nxtxpart;
		taboffset = nxtxpart;
	}	
	return nplan9 ? 0 : -1;
}

/*
 * To facilitate booting from CDs, we create a partition for
 * the boot floppy image embedded in a bootable CD.
 */
static int
part9660(SDunit *unit)
{
	uchar buf[Maxsec];
	ulong a, n;
	uchar *p;

	if(unit->secsize != Cdsec)
		return -1;

	if(sdread(unit, &unit->part[0], buf, Cdsec, 17*Cdsec) < 0)
		return -1;

	if(buf[0] || strcmp((char*)buf+1, "CD001\x01EL TORITO SPECIFICATION") != 0)
		return -1;

	
	p = buf+0x47;
	a = p[0] | (p[1]<<8) | (p[2]<<16) | (p[3]<<24);

	if(sdread(unit, &unit->part[0], buf, Cdsec, a*Cdsec) < 0)
		return -1;

	if(memcmp(buf, "\x01\x00\x00\x00", 4) != 0
	|| memcmp(buf+30, "\x55\xAA", 2) != 0
	|| buf[0x20] != 0x88)
		return -1;

	p = buf+0x28;
	a = p[0] | (p[1]<<8) | (p[2]<<16) | (p[3]<<24);

	switch(buf[0x21]){
	case 0x01:
		n = 1200*1024;
		break;
	case 0x02:
		n = 1440*1024;
		break;
	case 0x03:
		n = 2880*1024;
		break;
	default:
		return -1;
	}
	n /= Cdsec;

	print("found partition %s!cdboot; %lud+%lud\n", unit->name, a, n);
	sdaddpart(unit, "cdboot", a, a+n);
	return 0;
}

enum {
	NEW = 1<<0,
	OLD = 1<<1
};

/*
 * read unit->data to look for partition tables.
 * if found, stash partitions in environment and write them to ctl too.
 */
static void
partition(SDunit *unit)
{
	int type;
	char *p;

	if(unit->part == 0)
		return;

	if(part9660(unit) == 0)
		return;

	p = getenv("partition");
	if(p != nil && strncmp(p, "new", 3) == 0)
		type = NEW;
	else if(p != nil && strncmp(p, "old", 3) == 0)
		type = OLD;
	else
		type = NEW|OLD;

	if(mbrbuf == nil) {
		mbrbuf = malloc(Maxsec);
		partbuf = malloc(Maxsec);
		if(mbrbuf==nil || partbuf==nil) {
			free(mbrbuf);
			free(partbuf);
			partbuf = mbrbuf = nil;
			return;
		}
	}

	/*
	 * there might be no mbr (e.g. on a very large device), so look for
	 * a bare plan 9 partition table if mbrpart fails.
	 */
	if((type & NEW) && mbrpart(unit) >= 0){
		/* nothing to do */
	}
	else if (type & NEW)
		p9part(unit, "data");
	else if(type & OLD)
		oldp9part(unit);
}

static void
rdgeom(SDunit *unit)
{
	char *line;
	char *flds[5];
	Biobuf bb;
	Biobuf *bp;
	static char geom[] = "geometry ";

	bp = &bb;
	seek(unit->ctl, 0, 0);
	Binit(bp, unit->ctl, OREAD);
	while((line = Brdline(bp, '\n')) != nil){
		line[Blinelen(bp) - 1] = '\0';
		if (strncmp(line, geom, sizeof geom - 1) == 0)
			break;
	}
	if (line != nil && tokenize(line, flds, nelem(flds)) >= 3) {
		unit->sectors = atoll(flds[1]);
		unit->secsize = atoll(flds[2]);
	}
	Bterm(bp);
	seek(unit->ctl, 0, 0);
}

static void
setpartitions(char *name, int ctl, int data)
{
	SDunit sdunit;
	SDunit *unit;
	SDpart *part0;

	unit = &sdunit;
	memset(unit, 0, sizeof *unit);
	unit->ctl = ctl;
	unit->data = data;

	unit->secsize = Normsec;	/* default: won't work for CDs */
	unit->sectors = ~0ull;
	rdgeom(unit);
	strncpy(unit->name, name, sizeof unit->name);
	unit->part = mallocz(sizeof(SDpart) * SDnpart, 1);

	part0 = &unit->part[0];
	part0->end = unit->sectors - 1;
	strcpy(part0->name, "data");
	part0->valid = 1;
	unit->npart++;

	mbrbuf = malloc(Maxsec);
	partbuf = malloc(Maxsec);
	partition(unit);
	free(unit->part);
}

/*
 * read disk partition tables so that readnvram via factotum
 * can see them.
 */
int
readparts(void)
{
	int i, n, ctl, data, fd;
	char *name, *ctlname, *dataname;
	Dir *dir;

	fd = open("/dev", OREAD);
	if(fd < 0)
		return -1;
	n = dirreadall(fd, &dir);
	close(fd);

	for(i = 0; i < n; i++) {
		name = dir[i].name;
		if (strncmp(name, "sd", 2) != 0)
			continue;

		ctlname  = smprint("/dev/%s/ctl", name);
		dataname = smprint("/dev/%s/data", name);
		if (ctlname == nil || dataname == nil) {
			free(ctlname);
			free(dataname);
			continue;
		}

		ctl  = open(ctlname, ORDWR);
		data = open(dataname, OREAD);
		free(ctlname);
		free(dataname);

		if (ctl >= 0 && data >= 0)
			setpartitions(dataname, ctl, data);
		close(ctl);
		close(data);
	}
	free(dir);
	return 0;
}