minix3/commands/partition/partition.c

/*	partition 1.13 - Make a partition table		Author: Kees J. Bot
 *								27 Apr 1992
 */
#define nil ((void*)0)
#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <string.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <limits.h>
#include <stdint.h>
#include <assert.h>

#ifdef __minix
#include <machine/partition.h>
#include <minix/config.h>
#include <minix/const.h>
#include <minix/partition.h>
#else
#include "partition.h"
#define NR_PARTITIONS 4
#endif

#define SECTOR_SIZE	512

#define arraysize(a)	(sizeof(a)/sizeof((a)[0]))
#define arraylimit(a)	((a) + arraysize(a))

char *arg0;

void report(const char *label)
{
	fprintf(stderr, "%s: %s: %s\n", arg0, label, strerror(errno));
}

void fatal(const char *label)
{
	report(label);
	exit(1);
}

int aflag;			/* Add a new partition to the current table. */
int mflag;			/* Minix rules, no need for alignment. */
int rflag;			/* Report current partitions. */
int fflag;			/* Force making a table even if too small. */
int nflag;			/* Play-act, don't really do it. */

int cylinders, heads, sectors;	/* Device's geometry */
int pad;			/* Partitions must be padded. */

/* Descriptions of the device to divide and the partitions to make, including
 * gaps between partitions.
 */
char *device;
struct part_entry primary, table[2 * NR_PARTITIONS + 1];
int npart;

/* Extra flags at construction time. */
#define EXPAND_FLAG	0x01	/* Add the remaining sectors to this one */
#define EXIST_FLAG	0x02	/* Use existing partition */

void find_exist(struct part_entry *exist, int sysind, int nr)
{
	int f;
	uint16_t signature;
	struct part_entry oldtable[NR_PARTITIONS];
	int n, i;
	uint32_t minlow, curlow;
	struct part_entry *cur;
	char *nr_s[] = { "", "second ", "third ", "fourth" };

	if ((f= open(device, O_RDONLY)) < 0

		|| lseek(f, (off_t) PART_TABLE_OFF, SEEK_SET) == -1

		|| read(f, oldtable, sizeof(oldtable)) < 0

		|| read(f, &signature, sizeof(signature)) < 0

		|| close(f) < 0
	) fatal(device);

	minlow= 0;
	n= 0;
	for (;;) {
		curlow= -1;
		cur= nil;
		for (i= 0; i < NR_PARTITIONS; i++) {
			if (signature == 0xAA55
				&& oldtable[i].sysind != NO_PART
				&& oldtable[i].lowsec >= minlow
				&& oldtable[i].lowsec < curlow
			) {
				cur= &oldtable[i];
				curlow= oldtable[i].lowsec;
			}
		}
		if (n == nr) break;
		n++;
		minlow= curlow+1;
	}

	if (cur == nil || cur->sysind != sysind) {
		fprintf(stderr,
		"%s: Can't find a %sexisting partition of type 0x%02X\n",
			arg0, nr_s[nr], sysind);
		exit(1);
	}
	*exist = *cur;
}

void write_table(void)
{
	int f;
	uint16_t signature= 0xAA55;
	struct part_entry newtable[NR_PARTITIONS];
	int i;

	if (nflag) {
		printf("(Table not written)\n");
		return;
	}

	for (i= 0; i < NR_PARTITIONS; i++) newtable[i]= table[1 + 2*i];

	/* we have a abstract struct but it must conform to a certain
	 * reality that will never change (in-MBR sizes and offsets).
	 * each partition entry is 16 bytes and there are 4 of them.
	 * this also determines the signature offset.
	 */
	assert(sizeof(struct part_entry) == 16);
	assert(sizeof(newtable) == 64);

	if ((f= open(device, O_WRONLY)) < 0

		|| lseek(f, (off_t) PART_TABLE_OFF, SEEK_SET) == -1

		|| write(f, newtable, sizeof(newtable)) < 0

		|| write(f, &signature, sizeof(signature)) < 0

		|| close(f) < 0
	) fatal(device);
}

void sec2dos(unsigned long sec, unsigned char *dos)
/* Translate a sector number into the three bytes DOS uses. */
{
	unsigned secspcyl= heads * sectors;
	unsigned cyl;

	cyl= sec / secspcyl;
	dos[2]= cyl;
	dos[1]= ((sec % sectors) + 1) | ((cyl >> 2) & 0xC0);
	dos[0]= (sec % secspcyl) / sectors;
}

void show_chs(unsigned long pos)
{
	int cyl, head, sec;

	if (pos == -1) {
		cyl= head= 0;
		sec= -1;
	} else {
		cyl= pos / (heads * sectors);
		head= (pos / sectors) - (cyl * heads);
		sec= pos % sectors;
	}
	printf("  %4d/%03d/%02d", cyl, head, sec);
}

void show_part(struct part_entry *p)
{
	static int banner= 0;
	int n;

	n= p - table;
	if ((n % 2) == 0) return;

	if (!banner) {
		printf(
	"Part     First         Last         Base      Size       Kb\n");
		banner= 1;
	}

	printf("%3d ", (n-1) / 2);
	show_chs(p->lowsec);
	show_chs(p->lowsec + p->size - 1);
	printf("  %8lu  %8lu  %7lu\n", p->lowsec, p->size, p->size / 2);
}

void usage(void)
{
	fprintf(stderr,
		"Usage: partition [-mfn] device [type:]length[+*] ...\n");
	exit(1);
}

#define between(a, c, z)	((unsigned) ((c) - (a)) <= ((z) - (a)))

void parse(char *descr)
{
	int seen= 0, sysind, flags, c;
	unsigned long lowsec, size;

	lowsec= 0;

	if (strchr(descr, ':') == nil) {
		/* A hole. */
		if ((npart % 2) != 0) {
			fprintf(stderr, "%s: Two holes can't be adjacent.\n",
				arg0);
			exit(1);
		}
		sysind= NO_PART;
		seen|= 1;
	} else {
		/* A partition. */
		if ((npart % 2) == 0) {
			/* Need a hole before this partition. */
			if (npart == 0) {
				/* First hole contains the partition table. */
				table[0].size= 1;
			}
			npart++;
		}
		sysind= 0;
		for (;;) {
			c= *descr++;
			if (between('0', c, '9'))
				c= (c - '0') + 0x0;
			else
			if (between('a', c, 'z'))
				c= (c - 'a') + 0xa;
			else
			if (between('A', c, 'Z'))
				c= (c - 'A') + 0xA;
			else
				break;
			sysind= 0x10 * sysind + c;
			seen|= 1;
		}
		if (c != ':') usage();
	}

	flags= 0;

	if (strncmp(descr, "exist", 5) == 0 && (npart % 2) == 1) {
		struct part_entry exist;

		find_exist(&exist, sysind, (npart - 1) / 2);
		sysind= exist.sysind;
		lowsec= exist.lowsec;
		size= exist.size;
		flags |= EXIST_FLAG;
		descr += 5;
		c= *descr++;
		seen|= 2;
	} else {
		size= 0;
		while (between('0', (c= *descr++), '9')) {
			size= 10 * size + (c - '0');
			seen|= 2;
		}
	}

	for (;;) {
		if (c == '*')
			flags|= ACTIVE_FLAG;
		else
		if (c == '+' && !(flags & EXIST_FLAG))
			flags|= EXPAND_FLAG;
		else
			break;
		c= *descr++;
	}

	if (seen != 3 || c != 0) usage();

	if (npart == arraysize(table)) {
		fprintf(stderr, "%s: too many partitions, only %d possible.\n",
			arg0, NR_PARTITIONS);
		exit(1);
	}
	table[npart].bootind= flags;
	table[npart].sysind= sysind;
	table[npart].lowsec= lowsec;
	table[npart].size= size;
	npart++;
}

void geometry(void)
/* Get the geometry of the drive the device lives on, and the base and size
 * of the device.
 */
{
	int fd;
	struct stat sb;

	if ((fd= open(device, O_RDONLY)) < 0) fatal(device);

#ifdef __minix
	struct part_geom geometry;


	/* Get the geometry of the drive, and the device's base and size. */
	if (ioctl(fd, DIOCGETP, &geometry) < 0)
	{
		/* Use the same fake geometry as part. */
		if (fstat(fd, &sb) < 0)
			fatal(device);
		geometry.base= ((u64_t)(0));
		geometry.size= ((u64_t)(sb.st_size));
		geometry.sectors= 32;
		geometry.heads= 64;
		geometry.cylinders= (sb.st_size-1)/SECTOR_SIZE/
			(geometry.sectors*geometry.heads) + 1;
	}
	primary.lowsec= (unsigned long)(geometry.base / SECTOR_SIZE);
	primary.size  = (unsigned long)(geometry.size / SECTOR_SIZE);
	cylinders= geometry.cylinders;
	heads= geometry.heads;
	sectors= geometry.sectors;
#else
	if (fstat(fd, &sb) < 0) fatal(device);
	primary.lowsec= 0;
	primary.size= sb.st_size / SECTOR_SIZE;
	heads= 64;
	sectors= 32;
	cylinders= (sb.st_size-1) / SECTOR_SIZE / (sectors*heads) + 1;
#endif

	close(fd);

	/* Is this a primary partition table?  If so then pad partitions. */
	pad= (!mflag && primary.lowsec == 0);
}

void boundary(struct part_entry *pe, int exp)
/* Expand or reduce a primary partition to a track or cylinder boundary to
 * avoid giving the fdisk's of simpler operating systems a fit.
 */
{
	unsigned n;

	n= !pad ? 1 : pe == &table[0] ? sectors : heads * sectors;
	if (exp) pe->size+= n - 1;
	pe->size= ((pe->lowsec + pe->size) / n * n) - pe->lowsec;
}

void distribute(void)
/* Fit the partitions onto the device.  Try to start and end them on a
 * cylinder boundary if so required.  The first partition is to start on
 * track 1, not on cylinder 1.
 */
{
	struct part_entry *pe, *exp;
	long count;
	unsigned long base, oldbase;

	do {
		exp= nil;
		base= primary.lowsec;
		count= primary.size;

		for (pe= table; pe < arraylimit(table); pe++) {
			oldbase= base;
			if (pe->bootind & EXIST_FLAG) {
				if (base > pe->lowsec) {
					fprintf(stderr,
	"%s: fixed partition %ld is preceded by too big partitions/holes\n",
						arg0, ((pe - table) - 1) / 2);
					exit(1);
				}
				exp= nil;	/* XXX - Extend before? */
			} else {
				pe->lowsec= base;
				boundary(pe, 1);
				if (pe->bootind & EXPAND_FLAG) exp= pe;
			}
			base= pe->lowsec + pe->size;
			count-= base - oldbase;
		}
		if (count < 0) {
			if (fflag) break;
			fprintf(stderr, "%s: %s is %ld sectors too small\n",
				arg0, device, -count);
			exit(1);
		}
		if (exp != nil) {
			/* Add leftover space to the partition marked for
			 * expanding.
			 */
			exp->size+= count;
			boundary(exp, 0);
			exp->bootind&= ~EXPAND_FLAG;
		}
	} while (exp != nil);

	for (pe= table; pe < arraylimit(table); pe++) {
		if (pe->sysind == NO_PART) {
			memset(pe, 0, sizeof(*pe));
		} else {
			sec2dos(pe->lowsec, &pe->start_head);
			sec2dos(pe->lowsec + pe->size - 1, &pe->last_head);
			pe->bootind&= ACTIVE_FLAG;
		}
		show_part(pe);
	}
}

int main(int argc, char **argv)
{
	int i;

	if ((arg0= strrchr(argv[0], '/')) == nil) arg0= argv[0]; else arg0++;

	i= 1;
	while (i < argc && argv[i][0] == '-') {
		char *opt= argv[i++] + 1;

		if (opt[0] == '-' && opt[1] == 0) break;

		while (*opt != 0) switch (*opt++) {
		case 'a':	aflag= 1;	break;
		case 'm':	mflag= 1;	break;
		case 'r':	rflag= 1;	break;
		case 'f':	fflag= 1;	break;
		case 'n':	nflag= 1;	break;
		default:	usage();
		}
	}

	if (rflag) {
		if (aflag) usage();
		if ((argc - i) != 1) usage();
		fprintf(stderr, "%s: -r is not yet implemented\n", __func__);
		exit(1);
	} else {
		if ((argc - i) < 1) usage();
		if (aflag) fprintf(stderr, "%s: -a is not yet implemented\n", __func__);

		device= argv[i++];
		geometry();

		while (i < argc) parse(argv[i++]);

		distribute();
		write_table();
	}
	exit(0);
}