sanchayanmaity/minix
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
minix/commands/ibm/autopart.c
Ben Gras 509394f2ba autopart now guesses the bios drive number and the setup script tells it 
to the user.

minixsize has fallback default sizes set before specifics set by input list.
2005-08-31 15:48:15 +00:00

2837 lines
69 KiB
C
Executable file
Raw Blame History

/* part 1.57 - Partition table editor Author: Kees J. Bot
* 13 Mar 1992
* Needs about 22k heap+stack.
*
* Forked july 2005 into autopart (Ben Gras), a mode which gives the user
* an easier time.
*
*/
#define nil 0
#include <sys/types.h>
#include <stdio.h>
#include <termcap.h>
#include <errno.h>
#include <unistd.h>
#include <stddef.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <fcntl.h>
#include <time.h>
#include <dirent.h>
#include <limits.h>
#include <a.out.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/ioctl.h>
#include <minix/config.h>
#include <minix/const.h>
#include <minix/partition.h>
#include <minix/u64.h>
#include <ibm/partition.h>
#include <termios.h>
#include <stdarg.h>
/* Declare prototype. */
static void printstep(int step, char *message);
/* True if a partition is an extended partition. */
#define ext_part(s) ((s) == 0x05 || (s) == 0x0F)
/* Minix master bootstrap code. */
static char MASTERBOOT[] = "/usr/mdec/masterboot";
/* Template:
----first---- --geom/last-- ------sectors-----
Device Cyl Head Sec Cyl Head Sec Base Size Kb
/dev/c0d0 977 5 17
/dev/c0d0:2 0 0 2 976 4 16 2 83043 41521
Num Sort Type
0* p0 81 MINIX 0 0 3 33 4 9 3 2880 1440
1 p1 81 MINIX 33 4 10 178 2 2 2883 12284 6142
2 p2 81 MINIX 178 2 3 976 4 16 15167 67878 33939
3 p3 00 None 0 0 0 0 0 -1 0 0 0
*/
#define MAXSIZE 999999999L
#define SECTOR_SIZE 512
#define DEV_FD0 0x200 /* Device number of /dev/fd0 */
#define DEV_C0D0 0x300 /* Device number of /dev/c0d0 */
#define MIN_REGION_MB 160
#define MIN_REGION_SECTORS (1024*1024*MIN_REGION_MB/SECTOR_SIZE)
#define MAX_REGION_MB 4095
#define MAX_REGION_SECTORS (1024*(1024/SECTOR_SIZE)*MAX_REGION_MB)
#define arraysize(a) (sizeof(a) / sizeof((a)[0]))
#define arraylimit(a) ((a) + arraysize(a))
#define SORNOT(n) ((n) == 1 ? "" : "s")
/* screen colours */
#define COL_RED 1
#define COL_GREEN 2
#define COL_ORANGE 3
#define COL_BLUE 4
#define COL_MAGENTA 5
#define COL_CYAN 6
#define SURE_SERIOUS 1
#define SURE_BACK 2
void col(int col)
{
if(!col) printf("\033[0m");
else printf("\033[3%dm", col % 10);
}
void type2col(int type)
{
switch(type) {
/* minix */
case 0x80:
case MINIX_PART: col(COL_GREEN); break;
/* dos/windows */
case 0x0B: case 0x0C: case 0x0E: case 0x0F: case 0x42:
case 0x07: col(COL_CYAN); break;
/* linux */
case 0x82: case 0x83: col(COL_ORANGE); break;
}
}
int open_ct_ok(int fd)
{
int c = -1;
if(ioctl(fd, DIOCOPENCT, &c) < 0) {
printf("Warning: couldn't verify opencount, continuing\n");
return 1;
}
if(c == 1) return 1;
if(c < 1) { printf("Error: open count %d\n", c); }
return 0;
}
void report(const char *label)
{
fprintf(stderr, "part: %s: %s\n", label, strerror(errno));
}
void fatal(const char *label)
{
report(label);
exit(1);
}
struct termios termios;
void save_ttyflags(void)
/* Save tty attributes for later restoration. */
{
if (tcgetattr(0, &termios) < 0) fatal("");
}
void restore_ttyflags(void)
/* Reset the tty flags to how we got 'em. */
{
if (tcsetattr(0, TCSANOW, &termios) < 0) fatal("");
}
void tty_raw(void)
/* Set the terminal to raw mode, no signals, no echoing. */
{
struct termios rawterm;
rawterm= termios;
rawterm.c_lflag &= ~(ICANON|ISIG|ECHO);
rawterm.c_iflag &= ~(ICRNL);
if (tcsetattr(0, TCSANOW, &rawterm) < 0) fatal("");
}
#define ctrl(c) ((c) == '?' ? '\177' : ((c) & '\37'))
char t_cd[16], t_cm[32], t_so[16], t_se[16], t_md[16], t_me[16];
int t_li, t_co;
#define STATUSROW 10
void init_tty(void)
/* Get terminal capabilities and set the tty to "editor" mode. */
{
char *term;
static char termbuf[1024];
char *tp;
if ((term= getenv("TERM")) == nil || tgetent(termbuf, term) != 1) {
fprintf(stderr, "part: Can't get terminal capabilities\n");
exit(1);
}
if (tgetstr("cd", (tp= t_cd, &tp)) == nil
|| tgetstr("cm", (tp= t_cm, &tp)) == nil) {
fprintf(stderr, "part: This terminal is too dumb\n");
exit(1);
}
t_li= tgetnum("li");
t_co= tgetnum("co");
(void) tgetstr("so", (tp= t_so, &tp));
(void) tgetstr("se", (tp= t_se, &tp));
(void) tgetstr("md", (tp= t_md, &tp));
(void) tgetstr("me", (tp= t_me, &tp));
save_ttyflags();
tty_raw();
}
void putchr(int c)
{
putchar(c);
}
void putstr(char *s)
{
int c;
while ((c= *s++) != 0) putchr(c);
}
void set_cursor(int row, int col)
{
tputs(tgoto(t_cm, col, row), 1, putchr);
}
int statusrow= STATUSROW;
int stat_ktl= 1;
int need_help= 1;
void stat_start(int serious)
/* Prepare for printing on a fresh status line, possibly highlighted. */
{
set_cursor(statusrow++, 0);
tputs(t_cd, 1, putchr);
if (serious) tputs(t_so, 1, putchr);
}
void stat_end(int ktl)
/* Closing bracket for stat_start. Sets "keystrokes to live" of message. */
{
tputs(t_se, 1, putchr);
stat_ktl= ktl;
need_help= 1;
}
void stat_reset(void)
/* Reset the statusline pointer and clear old messages if expired. */
{
if (stat_ktl > 0 && --stat_ktl == 0) {
statusrow= STATUSROW;
need_help= 1;
}
if (need_help && statusrow < (24-2)) {
if (statusrow > STATUSROW) stat_start(0);
stat_start(0);
putstr(
"Type '+' or '-' to change, 'r' to read, '?' for more help, '!' for advice");
}
statusrow= STATUSROW;
need_help= 0;
}
void clear_screen(void)
{
set_cursor(0, 0);
tputs(t_cd, 1, putchr);
stat_ktl= 1;
stat_reset();
}
void reset_tty(void)
/* Reset the tty to cooked mode. */
{
restore_ttyflags();
set_cursor(statusrow, 0);
tputs(t_cd, 1, putchr);
}
void *alloc(size_t n)
{
void *m;
if ((m= malloc(n)) == nil) { reset_tty(); fatal(""); }
return m;
}
#ifndef makedev /* Missing in sys/types.h */
#define minor(dev) (((dev) >> MINOR) & BYTE)
#define major(dev) (((dev) >> MAJOR) & BYTE)
#define makedev(major, minor) \
((dev_t) (((major) << MAJOR) | ((minor) << MINOR)))
#endif
typedef enum parttype { DUNNO, SUBPART, PRIMARY, FLOPPY } parttype_t;
typedef struct device {
struct device *next, *prev; /* Circular dequeue. */
dev_t rdev; /* Device number (sorting only). */
char *name; /* E.g. /dev/c0d0 */
char *subname; /* E.g. /dev/c0d0:2 */
parttype_t parttype;
int biosdrive;
} device_t;
typedef struct region {
/* A region is either an existing top-level partition
* entry (used_part is non-NULL) or free space (free_*
* contains data).
*/
struct part_entry used_part;
int is_used_part;
int tableno;
int free_sec_start, free_sec_last;
} region_t;
/* A disk has between 1 and 2*partitions+1 regions;
* the last case is free space before and after every partition.
*/
#define NR_REGIONS (2*NR_PARTITIONS+1)
region_t regions[NR_REGIONS];
int nr_partitions = 0, nr_regions = 0, free_regions, used_regions;
int nordonly = 0;
device_t *firstdev= nil, *curdev;
#define MAX_DEVICES 100
static struct {
device_t *dev;
int nr_partitions, free_regions, used_regions, sectors, nr_regions;
int biosdrive;
region_t regions[NR_REGIONS];
} devices[MAX_DEVICES];
void newdevice(char *name, int scanning, int disk_only)
/* Add a device to the device list. If scanning is set then we are reading
* /dev, so insert the device in device number order and make /dev/c0d0 current.
*/
{
device_t *new, *nextdev, *prevdev;
struct stat st;
st.st_rdev= 0;
if (scanning) {
if (stat(name, &st) < 0 || !S_ISBLK(st.st_mode)) return;
switch (major(st.st_rdev)) {
case 3:
/* Disk controller */
if (minor(st.st_rdev) >= 0x80
|| minor(st.st_rdev) % 5 != 0) return;
break;
default:
return;
}
/* Interesting device found. */
} else {
if(stat(name, &st) < 0) { perror(name); return; }
}
new= alloc(sizeof(*new));
new->rdev= st.st_rdev;
new->name= alloc((strlen(name) + 1) * sizeof(new->name[0]));
strcpy(new->name, name);
new->subname= new->name;
new->parttype= DUNNO;
if (major(st.st_rdev) == major(DEV_FD0) && minor(st.st_rdev) < 112) {
new->parttype= FLOPPY;
} else
if (st.st_rdev >= DEV_C0D0 && minor(st.st_rdev) < 128
&& minor(st.st_rdev) % 5 == 0) {
new->parttype= PRIMARY;
}
if (firstdev == nil) {
firstdev= new;
new->next= new->prev= new;
curdev= firstdev;
return;
}
nextdev= firstdev;
while (new->rdev >= nextdev->rdev
&& (nextdev= nextdev->next) != firstdev) {}
prevdev= nextdev->prev;
new->next= nextdev;
nextdev->prev= new;
new->prev= prevdev;
prevdev->next= new;
if (new->rdev < firstdev->rdev) firstdev= new;
if (new->rdev == DEV_C0D0) curdev= new;
if (curdev->rdev != DEV_C0D0) curdev= firstdev;
}
void getdevices(int disk_only)
/* Get all block devices from /dev that look interesting. */
{
DIR *d;
struct dirent *e;
char name[5 + NAME_MAX + 1];
if ((d= opendir("/dev")) == nil) fatal("/dev");
while ((e= readdir(d)) != nil) {
strcpy(name, "/dev/");
strcpy(name + 5, e->d_name);
newdevice(name, 1, disk_only);
}
(void) closedir(d);
}
/* One featureful master bootstrap. */
unsigned char bootstrap[] = {
0353,0001,0000,0061,0300,0216,0330,0216,0300,0372,0216,0320,0274,0000,0174,0373,
0275,0276,0007,0211,0346,0126,0277,0000,0006,0271,0000,0001,0374,0363,0245,0352,
0044,0006,0000,0000,0264,0002,0315,0026,0250,0010,0164,0033,0350,0071,0001,0174,
0007,0060,0344,0315,0026,0242,0205,0007,0054,0060,0074,0012,0163,0363,0120,0350,
0046,0001,0205,0007,0130,0353,0012,0240,0002,0006,0204,0300,0165,0003,0351,0147,
0000,0230,0262,0005,0366,0362,0262,0200,0000,0302,0210,0340,0120,0350,0234,0000,
0163,0003,0351,0147,0000,0130,0054,0001,0175,0003,0351,0141,0000,0276,0276,0175,
0211,0357,0271,0040,0000,0363,0245,0200,0301,0004,0211,0356,0215,0174,0020,0070,
0154,0004,0164,0016,0213,0135,0010,0053,0134,0010,0213,0135,0012,0033,0134,0012,
0163,0014,0212,0044,0206,0144,0020,0210,0044,0106,0071,0376,0162,0364,0211,0376,
0201,0376,0356,0007,0162,0326,0342,0322,0211,0356,0264,0020,0366,0344,0001,0306,
0200,0174,0004,0001,0162,0026,0353,0021,0204,0322,0175,0041,0211,0356,0200,0174,
0004,0000,0164,0013,0366,0004,0200,0164,0006,0350,0070,0000,0162,0053,0303,0203,
0306,0020,0201,0376,0376,0007,0162,0346,0350,0215,0000,0211,0007,0376,0302,0204,
0322,0174,0023,0315,0021,0321,0340,0321,0340,0200,0344,0003,0070,0342,0167,0355,
0350,0011,0000,0162,0350,0303,0350,0003,0000,0162,0146,0303,0211,0356,0214,0134,
0010,0214,0134,0012,0277,0003,0000,0122,0006,0127,0264,0010,0315,0023,0137,0007,
0200,0341,0077,0376,0306,0210,0310,0366,0346,0211,0303,0213,0104,0010,0213,0124,
0012,0367,0363,0222,0210,0325,0366,0361,0060,0322,0321,0352,0321,0352,0010,0342,
0210,0321,0376,0301,0132,0210,0306,0273,0000,0174,0270,0001,0002,0315,0023,0163,
0020,0200,0374,0200,0164,0011,0117,0174,0006,0060,0344,0315,0023,0163,0270,0371,
0303,0201,0076,0376,0175,0125,0252,0165,0001,0303,0350,0013,0000,0243,0007,0353,
0005,0350,0004,0000,0227,0007,0353,0376,0136,0255,0126,0211,0306,0254,0204,0300,
0164,0011,0264,0016,0273,0001,0000,0315,0020,0353,0362,0303,0057,0144,0145,0166,
0057,0150,0144,0077,0010,0000,0015,0012,0000,0116,0157,0156,0145,0040,0141,0143,
0164,0151,0166,0145,0015,0012,0000,0122,0145,0141,0144,0040,0145,0162,0162,0157,
0162,0040,0000,0116,0157,0164,0040,0142,0157,0157,0164,0141,0142,0154,0145,0040,
0000,0000,
};
int dirty= 0;
unsigned char bootblock[SECTOR_SIZE];
struct part_entry table[1 + NR_PARTITIONS];
int existing[1 + NR_PARTITIONS];
unsigned long offset= 0, extbase= 0, extsize;
int submerged= 0;
char sort_index[1 + NR_PARTITIONS], sort_order[1 + NR_PARTITIONS];
unsigned cylinders= 1, heads= 1, sectors= 1, secpcyl= 1;
unsigned alt_cyls= 1, alt_heads= 1, alt_secs= 1;
int precise= 0;
int device= -1;
unsigned long sortbase(struct part_entry *pe)
{
return pe->sysind == NO_PART ? -1 : pe->lowsec;
}
void sort(void)
/* Let the sort_index array show the order partitions are sorted in. */
{
int i, j;
for (i= 1; i <= NR_PARTITIONS; i++) sort_order[i]= i;
for (i= 1; i <= NR_PARTITIONS; i++) {
for (j= 1; j <= NR_PARTITIONS-1; j++) {
int sj= sort_order[j], sj1= sort_order[j+1];
if (sortbase(&table[sj]) > sortbase(&table[sj1])) {
sort_order[j]= sj1;
sort_order[j+1]= sj;
}
}
}
for (i= 1; i <= NR_PARTITIONS; i++) sort_index[sort_order[i]]= i;
}
void dos2chs(unsigned char *dos, unsigned *chs)
/* Extract cylinder, head and sector from the three bytes DOS uses to address
* a sector. Note that bits 8 & 9 of the cylinder number come from bit 6 & 7
* of the sector byte. The sector number is rebased to count from 0.
*/
{
chs[0]= ((dos[1] & 0xC0) << 2) | dos[2];
chs[1]= dos[0];
chs[2]= (dos[1] & 0x3F) - 1;
}
void abs2dos(unsigned char *dos, unsigned long pos)
/* Translate a sector offset to three DOS bytes. */
{
unsigned h, c, s;
c= pos / secpcyl;
h= (pos % secpcyl) / sectors;
s= pos % sectors + 1;
dos[0]= h;
dos[1]= s | ((c >> 2) & 0xC0);
dos[2]= c & 0xFF;
}
void recompute0(void)
/* Recompute the partition size for the device after a geometry change. */
{
if (device < 0) {
cylinders= heads= sectors= 1;
memset(table, 0, sizeof(table));
} else
if (!precise && offset == 0) {
table[0].lowsec= 0;
table[0].size= (unsigned long) cylinders * heads * sectors;
}
table[0].sysind= device < 0 ? NO_PART : MINIX_PART;
secpcyl= heads * sectors;
}
void guess_geometry(void)
/* With a bit of work one can deduce the disk geometry from the partition
* table. This may be necessary if the driver gets it wrong. (If partition
* tables didn't have C/H/S numbers we would not care at all...)
*/
{
int i, n;
struct part_entry *pe;
unsigned chs[3];
unsigned long sec;
unsigned h, s;
unsigned char HS[256][8]; /* Bit map off all possible H/S */
alt_cyls= alt_heads= alt_secs= 0;
/* Initially all possible H/S combinations are possible. HS[h][0]
* bit 0 is used to rule out a head value.
*/
for (h= 1; h <= 255; h++) {
for (s= 0; s < 8; s++) HS[h][s]= 0xFF;
}
for (i= 0; i < 2*NR_PARTITIONS; i++) {
pe= &(table+1)[i >> 1];
if (pe->sysind == NO_PART) continue;
/* Get the end or start sector numbers (in that order). */
if ((i & 1) == 0) {
dos2chs(&pe->last_head, chs);
sec= pe->lowsec + pe->size - 1;
} else {
dos2chs(&pe->start_head, chs);
sec= pe->lowsec;
}
if (chs[0] >= alt_cyls) alt_cyls= chs[0]+1;
/* Which H/S combinations can be ruled out? */
for (h= 1; h <= 255; h++) {
if (HS[h][0] == 0) continue;
n = 0;
for (s= 1; s <= 63; s++) {
if ((chs[0] * h + chs[1]) * s + chs[2] != sec) {
HS[h][s/8] &= ~(1 << (s%8));
}
if (HS[h][s/8] & (1 << (s%8))) n++;
}
if (n == 0) HS[h][0]= 0;
}
}
/* See if only one remains. */
i= 0;
for (h= 1; h <= 255; h++) {
if (HS[h][0] == 0) continue;
for (s= 1; s <= 63; s++) {
if (HS[h][s/8] & (1 << (s%8))) {
i++;
alt_heads= h;
alt_secs= s;
}
}
}
/* Forget it if more than one choice... */
if (i > 1) alt_cyls= alt_heads= alt_secs= 0;
}
void geometry(void)
/* Find out the geometry of the device by querying the driver, or by looking
* at the partition table. These numbers are crosschecked to make sure that
* the geometry is correct. Master bootstraps other than the Minix one use
* the CHS numbers in the partition table to load the bootstrap of the active
* partition.
*/
{
struct stat dst;
int err= 0;
struct partition geometry;
if (submerged) {
/* Geometry already known. */
sort();
return;
}
precise= 0;
cylinders= 0;
recompute0();
if (device < 0) return;
/* Try to guess the geometry from the partition table. */
guess_geometry();
/* Try to get the geometry from the driver. */
(void) fstat(device, &dst);
if (S_ISBLK(dst.st_mode) || S_ISCHR(dst.st_mode)) {
/* Try to get the drive's geometry from the driver. */
if (ioctl(device, DIOCGETP, &geometry) < 0)
err= errno;
else {
table[0].lowsec= div64u(geometry.base, SECTOR_SIZE);
table[0].size= div64u(geometry.size, SECTOR_SIZE);
cylinders= geometry.cylinders;
heads= geometry.heads;
sectors= geometry.sectors;
precise= 1;
}
} else {
err= ENODEV;
}
if (err != 0) {
/* Getting the geometry from the driver failed, so use the
* alternate geometry.
*/
if (alt_heads == 0) {
alt_cyls= table[0].size / (64 * 32);
alt_heads= 64;
alt_secs= 32;
}
cylinders= alt_cyls;
heads= alt_heads;
sectors= alt_secs;
stat_start(1);
printf("Failure to get the geometry of %s: %s", curdev->name,
errno == ENOTTY ? "No driver support" : strerror(err));
stat_end(5);
stat_start(0);
printf("The geometry has been guessed as %ux%ux%u",
cylinders, heads, sectors);
stat_end(5);
} else {
if (alt_heads == 0) {
alt_cyls= cylinders;
alt_heads= heads;
alt_secs= sectors;
}
if (heads != alt_heads || sectors != alt_secs) {
stat_start(1);
printf("WARNING:");
stat_end(10);
stat_start(0);
printf(
"The %ux%ux%u geometry obtained from the device driver does not match",
cylinders, heads, sectors);
stat_end(10);
stat_start(0);
printf(
"the %ux%ux%u geometry implied by the partition table. Hit 'X' to switch",
alt_cyls, alt_heads, alt_secs);
stat_end(10);
stat_start(0);
printf(
"between the two geometries to see what is best. Note that the geometry");
stat_end(10);
stat_start(0);
printf(
"must be correct when the table is written or the system may not boot!");
stat_end(10);
}
}
/* Show the base and size of the device instead of the whole drive.
* This makes sense for subpartitioning primary partitions.
*/
if (precise && ioctl(device, DIOCGETP, &geometry) >= 0) {
table[0].lowsec= div64u(geometry.base, SECTOR_SIZE);
table[0].size= div64u(geometry.size, SECTOR_SIZE);
} else {
precise= 0;
}
recompute0();
sort();
}
typedef struct indicators { /* Partition type to partition name. */
unsigned char ind;
char name[10];
} indicators_t;
indicators_t ind_table[]= {
{ 0x00, "None" },
{ 0x01, "FAT-12" },
{ 0x02, "XENIX /" },
{ 0x03, "XENIX usr" },
{ 0x04, "FAT-16" },
{ 0x05, "EXTENDED" },
{ 0x06, "FAT-16" },
{ 0x07, "HPFS/NTFS" },
{ 0x08, "AIX" },
{ 0x09, "COHERENT" },
{ 0x0A, "OS/2" },
{ 0x0B, "FAT-32" },
{ 0x0C, "FAT?" },
{ 0x0E, "FAT?" },
{ 0x0F, "EXTENDED" },
{ 0x10, "OPUS" },
{ 0x40, "VENIX286" },
{ 0x42, "W2000 Dyn" },
{ 0x52, "MICROPORT" },
{ 0x63, "386/IX" },
{ 0x64, "NOVELL286" },
{ 0x65, "NOVELL386" },
{ 0x75, "PC/IX" },
{ 0x80, "MINIX-OLD" },
{ 0x81, "MINIX" },
{ 0x82, "LINUXswap" },
{ 0x83, "LINUX" },
{ 0x93, "AMOEBA" },
{ 0x94, "AMOEBAbad" },
{ 0xA5, "386BSD" },
{ 0xB7, "BSDI" },
{ 0xB8, "BSDI swap" },
{ 0xC7, "SYRINX" },
{ 0xDB, "CPM" },
{ 0xFF, "BADBLOCKS" },
};
char *typ2txt(int ind)
/* Translate a numeric partition indicator for human eyes. */
{
indicators_t *pind;
for (pind= ind_table; pind < arraylimit(ind_table); pind++) {
if (pind->ind == ind) return pind->name;
}
return "unknown system";
}
int round_sysind(int ind, int delta)
/* Find the next known partition type starting with ind in direction delta. */
{
indicators_t *pind;
ind= (ind + delta) & 0xFF;
if (delta < 0) {
for (pind= arraylimit(ind_table)-1; pind->ind > ind; pind--) {}
} else {
for (pind= ind_table; pind->ind < ind; pind++) {}
}
return pind->ind;
}
/* Objects on the screen, either simple pieces of the text or the cylinder
* number of the start of partition three.
*/
typedef enum objtype {
O_INFO, O_TEXT, O_DEV, O_SUB,
O_TYPTXT, O_SORT, O_NUM, O_TYPHEX,
O_CYL, O_HEAD, O_SEC,
O_SCYL, O_SHEAD, O_SSEC, O_LCYL, O_LHEAD, O_LSEC, O_BASE, O_SIZE, O_KB
} objtype_t;
#define rjust(type) ((type) >= O_TYPHEX)
#define computed(type) ((type) >= O_TYPTXT)
typedef struct object {
struct object *next;
objtype_t type; /* Text field, cylinder number, etc. */
char flags; /* Modifiable? */
char row;
char col;
char len;
struct part_entry *entry; /* What does the object refer to? */
char *text;
char value[20]; /* Value when printed. */
} object_t;
#define OF_MOD 0x01 /* Object value is modifiable. */
#define OF_ODD 0x02 /* It has a somewhat odd value. */
#define OF_BAD 0x04 /* Its value is no good at all. */
/* Events: (Keypress events are the value of the key pressed.) */
#define E_ENTER (-1) /* Cursor moves onto object. */
#define E_LEAVE (-2) /* Cursor leaves object. */
#define E_WRITE (-3) /* Write, but not by typing 'w'. */
/* The O_SIZE objects have a dual identity. */
enum howend { SIZE, LAST } howend= SIZE;
object_t *world= nil;
object_t *curobj= nil;
object_t *newobject(objtype_t type, int flags, int row, int col, int len)
/* Make a new object given a type, flags, position and length on the screen. */
{
object_t *new;
object_t **aop= &world;
new= alloc(sizeof(*new));
new->type= type;
new->flags= flags;
new->row= row;
new->col= col;
new->len= len;
new->entry= nil;
new->text= "";
new->value[0]= 0;
new->next= *aop;
*aop= new;
return new;
}
unsigned long entry2base(struct part_entry *pe)
/* Return the base sector of the partition if defined. */
{
return pe->sysind == NO_PART ? 0 : pe->lowsec;
}
unsigned long entry2last(struct part_entry *pe)
{
return pe->sysind == NO_PART ? -1 : pe->lowsec + pe->size - 1;
}
unsigned long entry2size(struct part_entry *pe)
{
return pe->sysind == NO_PART ? 0 : pe->size;
}
int overlap(unsigned long sec)
/* See if sec is part of another partition. */
{
struct part_entry *pe;
for (pe= table + 1; pe <= table + NR_PARTITIONS; pe++) {
if (pe->sysind == NO_PART) continue;
if (pe->lowsec < sec && sec < pe->lowsec + pe->size)
return 1;
}
return 0;
}
int aligned(unsigned long sec, unsigned unit)
/* True if sec is aligned to unit or if it is no problem if it is unaligned. */
{
return (offset != 0 && extbase == 0) || (sec % unit == 0);
}
void print(object_t *op)
/* Print an object's value if it changed. */
{
struct part_entry *pe= op->entry;
int n;
unsigned long t;
char *name;
int oldflags;
char oldvalue[20];
/* Remember the old flags and value. */
oldflags= op->flags;
strcpy(oldvalue, op->value);
op->flags&= ~(OF_ODD | OF_BAD);
switch (op->type) {
case O_INFO: {
/* Current field. */
static struct field { int type; char *name; } fields[]= {
{ O_DEV, "Select device" },
{ O_NUM, "Active flag" },
{ O_TYPHEX, "Hex partition type" },
{ O_TYPTXT, "Partition type" },
{ O_SCYL, "Start cylinder" },
{ O_SHEAD, "Start head" },
{ O_SSEC, "Start sector" },
{ O_CYL, "Number of cylinders" },
{ O_HEAD, "Number of heads" },
{ O_SEC, "Sectors per track" },
{ O_LCYL, "Last cylinder" },
{ O_LHEAD, "Last head" },
{ O_LSEC, "Last sector" },
{ O_BASE, "Base sector" },
{ O_SIZE, "Size in sectors" },
{ O_KB, "Size in kilobytes" },
{ -1, "?" },
};
struct field *fp= fields;
while (fp->type >= 0 && fp->type != curobj->type) fp++;
strcpy(op->value, fp->name);
op->flags|= OF_ODD;
break; }
case O_TEXT:
/* Simple text field. */
strcpy(op->value, op->text);
break;
case O_DEV:
case O_SUB:
/* Name of currently edited device. */
name= op->type == O_DEV ? curdev->name :
offset == 0 ? "" : curdev->subname;
if ((n= strlen(name)) < op->len) n= op->len;
strcpy(op->value, name + (n - op->len));
if (device < 0 && op->type == O_DEV) op->flags|= OF_BAD;
break;
case O_NUM:
/* Position and active flag. */
sprintf(op->value, "%d%c", (int) (pe - table - 1),
pe->bootind & ACTIVE_FLAG ? '*' : ' ');
break;
case O_SORT:
/* Position if the driver sorts the table. */
sprintf(op->value, "%s%d",
curdev->parttype >= PRIMARY ? "p" :
curdev->parttype == SUBPART ? "s" : "",
(curdev->parttype == SUBPART ||
curdev->parttype == FLOPPY ? pe - table
: sort_index[pe - table]) - 1);
break;
case O_TYPHEX:
/* Hex partition type indicator. */
sprintf(op->value, "%02X", pe->sysind);
break;
case O_TYPTXT:
/* Ascii partition type indicator. */
strcpy(op->value, typ2txt(pe->sysind));
break;
case O_SCYL:
/* Partition's start cylinder. */
sprintf(op->value, "%lu", entry2base(pe) / secpcyl);
break;
case O_SHEAD:
/* Start head. */
t= entry2base(pe);
sprintf(op->value, "%lu", t % secpcyl / sectors);
if (!aligned(t, secpcyl) && t != table[0].lowsec + sectors)
op->flags|= OF_ODD;
break;
case O_SSEC:
/* Start sector. */
t= entry2base(pe);
sprintf(op->value, "%lu", t % sectors);
if (!aligned(t, sectors)) op->flags|= OF_ODD;
break;
case O_CYL:
/* Number of cylinders. */
sprintf(op->value, "%u", cylinders);
break;
case O_HEAD:
/* Number of heads. */
sprintf(op->value, "%u", heads);
break;
case O_SEC:
/* Number of sectors per track. */
sprintf(op->value, "%u", sectors);
break;
case O_LCYL:
/* Partition's last cylinder. */
t= entry2last(pe);
sprintf(op->value, "%lu", t == -1 ? 0 : t / secpcyl);
break;
case O_LHEAD:
/* Partition's last head. */
t= entry2last(pe);
sprintf(op->value, "%lu", t == -1 ? 0 : t % secpcyl / sectors);
if (!aligned(t + 1, secpcyl)) op->flags|= OF_ODD;
break;
case O_LSEC:
/* Partition's last sector. */
t= entry2last(pe);
sprintf(op->value, t == -1 ? "-1" : "%lu", t % sectors);
if (!aligned(t + 1, sectors)) op->flags|= OF_ODD;
break;
case O_BASE:
/* Partition's base sector. */
sprintf(op->value, "%lu", entry2base(pe));
if (pe->sysind != NO_PART && pe != &table[0]
&& (pe->lowsec <= table[0].lowsec || overlap(pe->lowsec)))
op->flags|= OF_BAD;
break;
case O_SIZE:
/* Size of partitition in sectors. */
t= howend == SIZE ? entry2size(pe) : entry2last(pe);
sprintf(op->value, "%lu", pe->sysind == NO_PART ? 0 : t);
if (pe->sysind != NO_PART && (pe->size == 0
|| pe->lowsec + pe->size > table[0].lowsec + table[0].size
|| overlap(pe->lowsec + pe->size)))
op->flags|= OF_BAD;
break;
case O_KB:
/* Size of partitition in kilobytes. */
sprintf(op->value, "%lu", entry2size(pe) / 2);
break;
default:
sprintf(op->value, "?? %d ??", op->type);
}
if (device < 0 && computed(op->type)) strcpy(op->value, "?");
/* If a value overflows the print field then show a blank
* reverse video field.
*/
if ((n= strlen(op->value)) > op->len) {
n= 0;
op->flags|= OF_BAD;
}
/* Right or left justified? */
if (rjust(op->type)) {
memmove(op->value + (op->len - n), op->value, n);
memset(op->value, ' ', op->len - n);
} else {
memset(op->value + n, ' ', op->len - n);
}
op->value[op->len]= 0;
if ((op->flags & (OF_ODD | OF_BAD)) == (oldflags & (OF_ODD | OF_BAD))
&& strcmp(op->value, oldvalue) == 0) {
/* The value did not change. */
return;
}
set_cursor(op->row, rjust(op->type) ? op->col - (op->len-1) : op->col);
if (op->flags & OF_BAD) tputs(t_so, 1, putchr);
else
if (op->flags & OF_ODD) tputs(t_md, 1, putchr);
putstr(op->value);
if (op->flags & OF_BAD) tputs(t_se, 1, putchr);
else
if (op->flags & OF_ODD) tputs(t_me, 1, putchr);
}
void display(void)
/* Repaint all objects that changed. */
{
object_t *op;
for (op= world; op != nil; op= op->next) print(op);
}
int typing; /* Set if a digit has been typed to set a value. */
int magic; /* Changes when using the magic key. */
void event(int ev, object_t *op);
void m_redraw(int ev, object_t *op)
/* Redraw the screen. */
{
object_t *op2;
if (ev != ctrl('L')) return;
clear_screen();
for (op2= world; op2 != nil; op2= op2->next) op2->value[0]= 0;
}
void m_toggle(int ev, object_t *op)
/* Toggle between the driver and alternate geometry. */
{
unsigned t;
if (ev != 'X') return;
if (alt_cyls == cylinders && alt_heads == heads && alt_secs == sectors)
return;
t= cylinders; cylinders= alt_cyls; alt_cyls= t;
t= heads; heads= alt_heads; alt_heads= t;
t= sectors; sectors= alt_secs; alt_secs= t;
dirty= 1;
recompute0();
}
char size_last[]= "Size";
void m_orientation(int ev, object_t *op)
{
if (ev != ' ') return;
switch (howend) {
case SIZE:
howend= LAST;
strcpy(size_last, "Last");
break;
case LAST:
howend= SIZE;
strcpy(size_last, "Size");
}
}
void m_move(int ev, object_t *op)
/* Move to the nearest modifiably object in the intended direction. Objects
* on the same row or column are really near.
*/
{
object_t *near, *op2;
unsigned dist, d2, dr, dc;
if (ev != 'h' && ev != 'j' && ev != 'k' && ev != 'l' && ev != 'H')
return;
if (device < 0) {
/* No device open? Then try to read first. */
event('r', op);
if (device < 0) return;
}
near= op;
dist= -1;
for (op2= world; op2 != nil; op2= op2->next) {
if (op2 == op || !(op2->flags & OF_MOD)) continue;
dr= abs(op2->row - op->row);
dc= abs(op2->col - op->col);
d2= 25*dr*dr + dc*dc;
if (op2->row != op->row && op2->col != op->col) d2+= 1000;
switch (ev) {
case 'h': /* Left */
if (op2->col >= op->col) d2= -1;
break;
case 'j': /* Down */
if (op2->row <= op->row) d2= -1;
break;
case 'k': /* Up */
if (op2->row >= op->row) d2= -1;
break;
case 'l': /* Right */
if (op2->col <= op->col) d2= -1;
break;
case 'H': /* Home */
if (op2->type == O_DEV) d2= 0;
}
if (d2 < dist) { near= op2; dist= d2; }
}
if (near != op) event(E_LEAVE, op);
event(E_ENTER, near);
}
void m_updown(int ev, object_t *op)
/* Move a partition table entry up or down. */
{
int i, j;
struct part_entry tmp;
int tmpx;
if (ev != ctrl('K') && ev != ctrl('J')) return;
if (op->entry == nil) return;
i= op->entry - table;
if (ev == ctrl('K')) {
if (i <= 1) return;
j= i-1;
} else {
if (i >= NR_PARTITIONS) return;
j= i+1;
}
tmp= table[i]; table[i]= table[j]; table[j]= tmp;
tmpx= existing[i]; existing[i]= existing[j]; existing[j]= tmpx;
sort();
dirty= 1;
event(ev == ctrl('K') ? 'k' : 'j', op);
}
void m_enter(int ev, object_t *op)
/* We've moved onto this object. */
{
if (ev != E_ENTER && ev != ' ' && ev != '<' && ev != '>' && ev != 'X')
return;
curobj= op;
typing= 0;
magic= 0;
}
void m_leave(int ev, object_t *op)
/* About to leave this object. */
{
if (ev != E_LEAVE) return;
}
int within(unsigned *var, unsigned low, unsigned value, unsigned high)
/* Only set *var to value if it looks reasonable. */
{
if (low <= value && value <= high) {
*var= value;
return 1;
} else
return 0;
}
int lwithin(unsigned long *var, unsigned long low, unsigned long value,
unsigned long high)
{
if (low <= value && value <= high) {
*var= value;
return 1;
} else
return 0;
}
int nextdevice(object_t *op, int delta)
/* Select the next or previous device from the device list. */
{
dev_t rdev;
if (offset != 0) return 0;
if (dirty) event(E_WRITE, op);
if (dirty) return 0;
if (device >= 0) {
(void) close(device);
device= -1;
}
recompute0();
rdev= curdev->rdev;
if (delta < 0) {
do
curdev= curdev->prev;
while (delta < -1 && major(curdev->rdev) == major(rdev)
&& curdev->rdev < rdev);
} else {
do
curdev= curdev->next;
while (delta > 1 && major(curdev->rdev) == major(rdev)
&& curdev->rdev > rdev);
}
return 1;
}
void check_ind(struct part_entry *pe)
/* If there are no other partitions then make this new one active. */
{
struct part_entry *pe2;
int i = 0;
for (pe2= table + 1; pe2 < table + 1 + NR_PARTITIONS; pe2++, i++)
if (pe2->sysind != NO_PART && (pe2->bootind & ACTIVE_FLAG))
return;
pe->bootind= ACTIVE_FLAG;
dirty = 1;
}
int check_existing(struct part_entry *pe)
/* Check and if not ask if an existing partition may be modified. */
{
static int expert= 0;
int c;
if (expert || pe == nil || !existing[pe - table]) return 1;
stat_start(1);
putstr("Do you wish to modify existing partitions? (y/n) ");
fflush(stdout);
while ((c= getchar()) != 'y' && c != 'n') {}
putchr(c);
stat_end(3);
return (expert= (c == 'y'));
}
void m_modify(int ev, object_t *op)
/* Increment, decrement, set, or toggle the value of an object, using
* arithmetic tricks the author doesn't understand either.
*/
{
object_t *op2;
struct part_entry *pe= op->entry;
int mul, delta;
unsigned level= 1;
unsigned long surplus;
int radix= op->type == O_TYPHEX ? 0x10 : 10;
unsigned long t;
if (device < 0 && op->type != O_DEV) return;
switch (ev) {
case '-':
mul= radix; delta= -1; typing= 0;
break;
case '+':
mul= radix; delta= 1; typing= 0;
break;
case '\b':
if (!typing) return;
mul= 1; delta= 0;
break;
case '\r':
typing= 0;
return;
default:
if ('0' <= ev && ev <= '9')
delta= ev - '0';
else
if (radix == 0x10 && 'a' <= ev && ev <= 'f')
delta= ev - 'a' + 10;
else
if (radix == 0x10 && 'A' <= ev && ev <= 'F')
delta= ev - 'A' + 10;
else
return;
mul= typing ? radix*radix : 0;
typing= 1;
}
magic= 0;
if (!check_existing(pe)) return;
switch (op->type) {
case O_DEV:
if (ev != '-' && ev != '+') return;
if (!nextdevice(op, delta)) return;
break;
case O_CYL:
if (!within(&cylinders, 1,
cylinders * mul / radix + delta, 1024)) return;
recompute0();
break;
case O_HEAD:
if (!within(&heads, 1, heads * mul / radix + delta, 255))
return;
recompute0();
break;
case O_SEC:
if (!within(&sectors, 1, sectors * mul / radix + delta, 63))
return;
recompute0();
break;
case O_NUM:
if (ev != '-' && ev != '+') return;
for (op2= world; op2 != nil; op2= op2->next) {
if (op2->type == O_NUM && ev == '+')
op2->entry->bootind= 0;
}
op->entry->bootind= ev == '+' ? ACTIVE_FLAG : 0;
break;
case O_TYPHEX:
check_ind(pe);
pe->sysind= pe->sysind * mul / radix + delta;
break;
case O_TYPTXT:
if (ev != '-' && ev != '+') return;
check_ind(pe);
pe->sysind= round_sysind(pe->sysind, delta);
break;
case O_SCYL:
level= heads;
case O_SHEAD:
level*= sectors;
case O_SSEC:
if (op->type != O_SCYL && ev != '-' && ev != '+') return;
case O_BASE:
if (pe->sysind == NO_PART) memset(pe, 0, sizeof(*pe));
t= pe->lowsec;
surplus= t % level;
if (!lwithin(&t, 0L,
(t / level * mul / radix + delta) * level + surplus,
MAXSIZE)) return;
if (howend == LAST || op->type != O_BASE)
pe->size-= t - pe->lowsec;
pe->lowsec= t;
check_ind(pe);
if (pe->sysind == NO_PART) pe->sysind= MINIX_PART;
break;
case O_LCYL:
level= heads;
case O_LHEAD:
level*= sectors;
case O_LSEC:
if (op->type != O_LCYL && ev != '-' && ev != '+') return;
if (pe->sysind == NO_PART) memset(pe, 0, sizeof(*pe));
t= pe->lowsec + pe->size - 1 + level;
surplus= t % level - mul / radix * level;
if (!lwithin(&t, 0L,
(t / level * mul / radix + delta) * level + surplus,
MAXSIZE)) return;
pe->size= t - pe->lowsec + 1;
check_ind(pe);
if (pe->sysind == NO_PART) pe->sysind= MINIX_PART;
break;
case O_KB:
level= 2;
if (mul == 0) pe->size= 0; /* new value, no surplus */
case O_SIZE:
if (pe->sysind == NO_PART) {
if (op->type == O_KB || howend == SIZE) {
/* First let loose magic to set the base. */
event('m', op);
magic= 0;
pe->size= 0;
event(ev, op);
return;
}
memset(pe, 0, sizeof(*pe));
}
t= (op->type == O_KB || howend == SIZE) ? pe->size
: pe->lowsec + pe->size - 1;
surplus= t % level;
if (!lwithin(&t, 0L,
(t / level * mul / radix + delta) * level + surplus,
MAXSIZE)) return;
pe->size= (op->type == O_KB || howend == SIZE) ? t :
t - pe->lowsec + 1;
check_ind(pe);
if (pe->sysind == NO_PART) pe->sysind= MINIX_PART;
break;
default:
return;
}
/* The order among the entries may have changed. */
sort();
dirty= 1;
}
unsigned long spell[3 + 4 * (1+NR_PARTITIONS)];
int nspells;
objtype_t touching;
void newspell(unsigned long charm)
/* Add a new spell, descending order for the base, ascending for the size. */
{
int i, j;
if (charm - table[0].lowsec > table[0].size) return;
for (i= 0; i < nspells; i++) {
if (charm == spell[i]) return; /* duplicate */
if (touching == O_BASE) {
if (charm == table[0].lowsec + table[0].size) return;
if ((spell[0] - charm) < (spell[0] - spell[i])) break;
} else {
if (charm == table[0].lowsec) return;
if ((charm - spell[0]) < (spell[i] - spell[0])) break;
}
}
for (j= ++nspells; j > i; j--) spell[j]= spell[j-1];
spell[i]= charm;
}
void m_magic(int ev, object_t *op)
/* Apply magic onto a base or size number. */
{
struct part_entry *pe= op->entry, *pe2;
int rough= (offset != 0 && extbase == 0);
if (ev != 'm' || device < 0) return;
typing= 0;
if (!check_existing(pe)) return;
if (magic == 0) {
/* See what magic we can let loose on this value. */
nspells= 1;
/* First spell, the current value. */
switch (op->type) {
case O_SCYL:
case O_SHEAD: /* Start of partition. */
case O_SSEC:
case O_BASE:
touching= O_BASE;
spell[0]= pe->lowsec;
break;
case O_LCYL:
case O_LHEAD:
case O_LSEC: /* End of partition. */
case O_KB:
case O_SIZE:
touching= O_SIZE;
spell[0]= pe->lowsec + pe->size;
break;
default:
return;
}
if (pe->sysind == NO_PART) {
memset(pe, 0, sizeof(*pe));
check_ind(pe);
pe->sysind= MINIX_PART;
spell[0]= 0;
if (touching == O_SIZE) {
/* First let loose magic on the base. */
object_t *op2;
for (op2= world; op2 != nil; op2= op2->next) {
if (op2->row == op->row &&
op2->type == O_BASE) {
event('m', op2);
}
}
magic= 0;
event('m', op);
return;
}
}
/* Avoid the first sector on the device. */
if (spell[0] == table[0].lowsec) newspell(spell[0] + 1);
/* Further interesting values are the the bases of other
* partitions or their ends.
*/
for (pe2= table; pe2 < table + 1 + NR_PARTITIONS; pe2++) {
if (pe2 == pe || pe2->sysind == NO_PART) continue;
if (pe2->lowsec == table[0].lowsec)
newspell(table[0].lowsec + 1);
else
newspell(pe2->lowsec);
newspell(pe2->lowsec + pe2->size);
if (touching == O_BASE && howend == SIZE) {
newspell(pe2->lowsec - pe->size);
newspell(pe2->lowsec + pe2->size - pe->size);
}
if (pe2->lowsec % sectors != 0) rough= 1;
}
/* Present values rounded up to the next cylinder unless
* the table is already a mess. Use "start + 1 track" instead
* of "start + 1 cylinder". Also add the end of the last
* cylinder.
*/
if (!rough) {
unsigned long n= spell[0];
if (n == table[0].lowsec) n++;
n= (n + sectors - 1) / sectors * sectors;
if (n != table[0].lowsec + sectors)
n= (n + secpcyl - 1) / secpcyl * secpcyl;
newspell(n);
if (touching == O_SIZE)
newspell(table[0].size / secpcyl * secpcyl);
}
}
/* Magic has been applied, a spell needs to be chosen. */
if (++magic == nspells) magic= 0;
if (touching == O_BASE) {
if (howend == LAST) pe->size-= spell[magic] - pe->lowsec;
pe->lowsec= spell[magic];
} else
pe->size= spell[magic] - pe->lowsec;
/* The order among the entries may have changed. */
sort();
dirty= 1;
}
typedef struct diving {
struct diving *up;
struct part_entry old0;
char *oldsubname;
parttype_t oldparttype;
unsigned long oldoffset;
unsigned long oldextbase;
} diving_t;
diving_t *diving= nil;
void m_in(int ev, object_t *op)
/* Go down into a primary or extended partition. */
{
diving_t *newdiv;
struct part_entry *pe= op->entry, ext;
int n;
if (ev != '>' || device < 0 || pe == nil || pe == &table[0]
|| (!(pe->sysind == MINIX_PART && offset == 0)
&& !ext_part(pe->sysind))
|| pe->size == 0) return;
ext= *pe;
if (extbase != 0) ext.size= extbase + extsize - ext.lowsec;
if (dirty) event(E_WRITE, op);
if (dirty) return;
if (device >= 0) { close(device); device= -1; }
newdiv= alloc(sizeof(*newdiv));
newdiv->old0= table[0];
newdiv->oldsubname= curdev->subname;
newdiv->oldparttype= curdev->parttype;
newdiv->oldoffset= offset;
newdiv->oldextbase= extbase;
newdiv->up= diving;
diving= newdiv;
table[0]= ext;
n= strlen(diving->oldsubname);
curdev->subname= alloc((n + 3) * sizeof(curdev->subname[0]));
strcpy(curdev->subname, diving->oldsubname);
curdev->subname[n++]= ':';
curdev->subname[n++]= '0' + (pe - table - 1);
curdev->subname[n]= 0;
curdev->parttype= curdev->parttype == PRIMARY ? SUBPART : DUNNO;
offset= ext.lowsec;
if (ext_part(ext.sysind) && extbase == 0) {
extbase= ext.lowsec;
extsize= ext.size;
curdev->parttype= DUNNO;
}
submerged= 1;
event('r', op);
}
void m_out(int ev, object_t *op)
/* Go up from an extended or subpartition table to its enclosing. */
{
diving_t *olddiv;
if (ev != '<' || diving == nil) return;
if (dirty) event(E_WRITE, op);
if (dirty) return;
if (device >= 0) { close(device); device= -1; }
olddiv= diving;
diving= olddiv->up;
table[0]= olddiv->old0;
free(curdev->subname);
curdev->subname= olddiv->oldsubname;
curdev->parttype= olddiv->oldparttype;
offset= olddiv->oldoffset;
extbase= olddiv->oldextbase;
free(olddiv);
event('r', op);
if (diving == nil) submerged= 0; /* We surfaced. */
}
void installboot(unsigned char *bootblock, char *masterboot)
/* Install code from a master bootstrap into a boot block. */
{
FILE *mfp;
struct exec hdr;
int n;
char *err;
if ((mfp= fopen(masterboot, "r")) == nil) {
err= strerror(errno);
goto m_err;
}
n= fread(&hdr, sizeof(char), A_MINHDR, mfp);
if (ferror(mfp)) {
err= strerror(errno);
fclose(mfp);
goto m_err;
}
if (n < A_MINHDR || BADMAG(hdr) || hdr.a_cpu != A_I8086) {
err= "Not an 8086 executable";
fclose(mfp);
goto m_err;
}
if (hdr.a_text + hdr.a_data > PART_TABLE_OFF) {
err= "Does not fit in a boot sector";
fclose(mfp);
goto m_err;
}
fseek(mfp, hdr.a_hdrlen, 0);
fread(bootblock, sizeof(char), (size_t) (hdr.a_text + hdr.a_data), mfp);
if (ferror(mfp)) {
err= strerror(errno);
fclose(mfp);
goto m_err;
}
fclose(mfp);
/* Bootstrap installed. */
return;
m_err:
stat_start(1);
printf("%s: %s", masterboot, err);
stat_end(5);
}
ssize_t boot_readwrite(int rw)
/* Read (0) or write (1) the boot sector. */
{
u64_t off64 = mul64u(offset, SECTOR_SIZE);
int r;
#if __minix_vmd
/* Minix-vmd has a 64 bit seek. */
if (fcntl(device, F_SEEK, off64) < 0) return -1;
#else
/* Minix has to gross things with the partition base. */
struct partition geom0, geom_seek;
if (offset >= (LONG_MAX / SECTOR_SIZE - 1)) {
/* Move partition base. */
if (ioctl(device, DIOCGETP, &geom0) < 0) return -1;
geom_seek.base = add64(geom0.base, off64);
geom_seek.size = cvu64(cmp64(add64u(off64, SECTOR_SIZE),
geom0.size) <= 0 ? STATIC_BLOCK_SIZE : 0);
sync();
if (ioctl(device, DIOCSETP, &geom_seek) < 0) return -1;
if (lseek(device, (off_t) 0, SEEK_SET) == -1) return -1;
} else {
/* Can reach this point normally. */
if (lseek(device, (off_t) offset * SECTOR_SIZE, SEEK_SET) == -1)
return -1;
}
#endif
switch (rw) {
case 0: r= read(device, bootblock, SECTOR_SIZE); break;
case 1: r= write(device, bootblock, SECTOR_SIZE); break;
}
#if !__minix_vmd
if (offset >= (LONG_MAX / SECTOR_SIZE - 1)) {
/* Restore partition base and size. */
sync();
if (ioctl(device, DIOCSETP, &geom0) < 0) return -1;
}
#endif
return r;
}
int cylinderalign(region_t *reg)
{
if(reg->is_used_part) {
if(reg->used_part.lowsec != table[0].lowsec + sectors
&& (reg->used_part.lowsec % secpcyl)) {
int extra;
extra = secpcyl - (reg->used_part.lowsec % secpcyl);
reg->used_part.lowsec += extra;
reg->used_part.size -= extra;
}
if((reg->used_part.size+1) % secpcyl) {
reg->used_part.size -= secpcyl - ((reg->used_part.size + 1) % secpcyl);
}
return reg->used_part.size > 0;
}
if(reg->free_sec_start != table[0].lowsec + sectors && (reg->free_sec_start % secpcyl)) {
/* Start is unaligned. Round up. */
reg->free_sec_start += secpcyl - (reg->free_sec_start % secpcyl);
}
if((reg->free_sec_last+1) % secpcyl) {
/* End is unaligned. Round down. */
reg->free_sec_last -= (reg->free_sec_last+1) % secpcyl;
}
/* Return nonzero if anything remains of the region after rounding. */
return reg->free_sec_last > reg->free_sec_start;
}
void regionize(void)
{
int free_sec, i, si;
sort();
free_sec = table[0].lowsec + sectors;
/* Create region data used in autopart mode. */
free_regions = used_regions = nr_regions = nr_partitions = 0;
if(table[0].lowsec > table[sort_order[1]].lowsec &&
table[sort_order[1]].sysind != NO_PART) {
printf("\nSanity check failed on %s - first partition starts before disk.\n"
"Please use expert mode to correct it.\n", curdev->name);
exit(1);
}
for(si = 1; si <= NR_PARTITIONS; si++) {
i = sort_order[si];
if(i < 1 || i > NR_PARTITIONS) {
printf("Sorry, something unexpected has happened (%d out of range).\n", i);
exit(1);
}
if(table[i].sysind == NO_PART)
break;
/* Free space before this partition? */
if(table[i].lowsec > free_sec) {
/* Free region before this partition. */
regions[nr_regions].free_sec_start = free_sec;
regions[nr_regions].free_sec_last = table[i].lowsec-1;
regions[nr_regions].is_used_part = 0;
if(cylinderalign(&regions[nr_regions])) {
nr_regions++;
free_regions++;
}
}
/* Sanity check. */
if(si > 1) {
if(table[i].lowsec < table[sort_order[si-1]].lowsec ||
table[i].lowsec < table[sort_order[si-1]].lowsec + table[sort_order[si-1]].size) {
printf("\nSanity check failed on %s - partitions overlap.\n"
"Please use expert mode to correct it.\n", curdev->name);
exit(1);
}
}
if(table[i].size > table[0].size) {
printf("\nSanity check failed on %s - partition is larger than disk.\n"
"Please use expert mode to correct it.\n", curdev->name);
exit(1);
}
if(table[i].size < 1) {
printf("\nSanity check failed on %s - zero-sized partition.\n"
"Please use expert mode to correct it.\n", curdev->name);
exit(1);
}
/* Remember used region. */
memcpy(&regions[nr_regions].used_part, &table[i], sizeof(table[i]));
free_sec = table[i].lowsec+table[i].size;
regions[nr_regions].is_used_part = 1;
regions[nr_regions].tableno = i;
nr_partitions++;
nr_regions++;
used_regions++;
}
/* Special case: space after partitions. */
if(free_sec < table[0].lowsec + table[0].size-1) {
regions[nr_regions].free_sec_start = free_sec;
regions[nr_regions].free_sec_last = table[0].lowsec + table[0].size-1;
regions[nr_regions].is_used_part = 0;
if(cylinderalign(&regions[nr_regions])) {
nr_regions++;
free_regions++;
}
}
}
void m_read(int ev, int *biosdrive)
/* Read the partition table from the current device. */
{
int si, i, mode, n, r, v;
struct part_entry *pe;
if (ev != 'r' || device >= 0) return;
/* Open() may cause kernel messages: */
stat_start(0);
fflush(stdout);
if ((device= open(curdev->name, mode= O_RDWR, 0666)) < 0) {
if (device >= 0) { close(device); device= -1; }
return;
}
v = 2*HZ;
ioctl(device, DIOCTIMEOUT, &v);
memset(bootblock, 0, sizeof(bootblock));
n= boot_readwrite(0);
if (n <= 0) stat_start(1);
if (n < 0) {
close(device);
device= -1;
} else
if (n < SECTOR_SIZE) {
close(device);
device= -1;
return;
}
if (n <= 0) stat_end(5);
if (n < SECTOR_SIZE) n= SECTOR_SIZE;
if(biosdrive) (*biosdrive)++;
if(!open_ct_ok(device)) {
printf("\n%s: device in use! skipping it.", curdev->subname);
fflush(stdout);
close(device);
device= -1;
return;
}
memcpy(table+1, bootblock+PART_TABLE_OFF,
NR_PARTITIONS * sizeof(table[1]));
if (bootblock[510] != 0x55 || bootblock[511] != 0xAA) {
/* Invalid boot block, install bootstrap, wipe partition table.
*/
memset(bootblock, 0, sizeof(bootblock));
installboot(bootblock, MASTERBOOT);
memset(table+1, 0, NR_PARTITIONS * sizeof(table[1]));
}
/* Fix an extended partition table up to something mere mortals can
* understand. Record already defined partitions.
*/
for (i= 1; i <= NR_PARTITIONS; i++) {
pe= &table[i];
if (extbase != 0 && pe->sysind != NO_PART)
pe->lowsec+= ext_part(pe->sysind) ? extbase : offset;
existing[i]= pe->sysind != NO_PART;
}
geometry();
dirty= 0;
/* Warn about grave dangers ahead. */
if (extbase != 0) {
stat_start(1);
printf("Warning: You are in an extended partition.");
stat_end(5);
}
regionize();
}
void m_write(int ev, object_t *op)
/* Write the partition table back if modified. */
{
int c;
struct part_entry new_table[NR_PARTITIONS], *pe;
if (ev != 'w' && ev != E_WRITE) return;
if (device < 0) { dirty= 0; return; }
if (!dirty) {
if (ev == 'w') {
stat_start(1);
printf("%s is not changed, or has already been written",
curdev->subname);
stat_end(2);
}
return;
}
if (extbase != 0) {
/* Will this stop him? Probably not... */
stat_start(1);
printf("You have changed an extended partition. Bad Idea.");
stat_end(5);
}
memcpy(new_table, table+1, NR_PARTITIONS * sizeof(table[1]));
for (pe= new_table; pe < new_table + NR_PARTITIONS; pe++) {
if (pe->sysind == NO_PART) {
memset(pe, 0, sizeof(*pe));
} else {
abs2dos(&pe->start_head, pe->lowsec);
abs2dos(&pe->last_head, pe->lowsec + pe->size - 1);
/* Fear and loathing time: */
if (extbase != 0)
pe->lowsec-= ext_part(pe->sysind)
? extbase : offset;
}
}
memcpy(bootblock+PART_TABLE_OFF, new_table, sizeof(new_table));
bootblock[510]= 0x55;
bootblock[511]= 0xAA;
if (boot_readwrite(1) < 0) {
stat_start(1);
printf("%s: %s", curdev->name, strerror(errno));
stat_end(5);
return;
}
dirty= 0;
}
void m_shell(int ev, object_t *op)
/* Shell escape, to do calculations for instance. */
{
int r, pid, status;
void (*sigint)(int), (*sigquit)(int), (*sigterm)(int);
if (ev != 's') return;
reset_tty();
fflush(stdout);
switch (pid= fork()) {
case -1:
stat_start(1);
printf("can't fork: %s\n", strerror(errno));
stat_end(3);
break;
case 0:
if (device >= 0) (void) close(device);
execl("/bin/sh", "sh", (char *) nil);
r= errno;
stat_start(1);
printf("/bin/sh: %s\n", strerror(errno));
stat_end(3);
exit(127);
}
sigint= signal(SIGINT, SIG_IGN);
sigquit= signal(SIGQUIT, SIG_IGN);
sigterm= signal(SIGTERM, SIG_IGN);
while (pid >= 0 && (r= wait(&status)) >= 0 && r != pid) {}
(void) signal(SIGINT, sigint);
(void) signal(SIGQUIT, sigquit);
(void) signal(SIGTERM, sigterm);
tty_raw();
if (pid < 0)
;
else
if (WIFEXITED(status) && WEXITSTATUS(status) == 127)
stat_start(0); /* Match the stat_start in the child. */
else
event(ctrl('L'), op);
}
void m_dump(struct part_entry *print_table)
/* Raw dump of the partition table. */
{
struct part_entry *pe;
int i;
unsigned chs[3];
printf(" Partition + type Cyl Head Sec Cyl Head Sec Base Size Kb\n");
for (i= 1; i <= NR_PARTITIONS; i++) {
pe= &print_table[i];
dos2chs(&pe->start_head, chs);
printf("%2d%c %02X%15d%5d%4d",
i,
pe->bootind & ACTIVE_FLAG ? '*' : ' ',
pe->sysind,
chs[0], chs[1], chs[2]);
dos2chs(&pe->last_head, chs);
printf("%6d%5d%4d%10lu%10ld%9lu\n",
chs[0], chs[1], chs[2],
pe->lowsec,
howend == SIZE ? pe->size : pe->size + pe->lowsec - 1,
pe->size / 2);
}
}
int quitting= 0;
void m_quit(int ev, object_t *op)
/* Write the partition table if modified and exit. */
{
if (ev != 'q' && ev != 'x') return;
quitting= 1;
if (dirty) event(E_WRITE, op);
if (dirty) quitting= 0;
}
void m_help(int ev, object_t *op)
/* For people without a clue; let's hope they can find the '?' key. */
{
static struct help {
char *keys;
char *what;
} help[]= {
{ "? !", "This help / more advice!" },
{ "+ - (= _ PgUp PgDn)","Select/increment/decrement/make active" },
{ "0-9 (a-f)", "Enter value" },
{ "hjkl (arrow keys)", "Move around" },
{ "CTRL-K CTRL-J", "Move entry up/down" },
{ "CTRL-L", "Redraw screen" },
{ ">", "Start a subpartition table" },
{ "<", "Back to the primary partition table" },
{ "m", "Cycle through magic values" },
{ "spacebar", "Show \"Size\" or \"Last\"" },
{ "r w", "Read/write partition table" },
{ "p s q x", "Raw dump / Shell escape / Quit / Exit" },
{ "y n DEL", "Answer \"yes\", \"no\", \"cancel\"" },
};
static char *advice[] = {
"* Choose a disk with '+' and '-', then hit 'r'.",
"* To change any value: Move to it and use '+', '-' or type the desired value.",
"* To make a new partition: Move over to the Size or Kb field of an unused",
" partition and type the size. Hit the 'm' key to pad the partition out to",
" a cylinder boundary. Hit 'm' again to pad it out to the end of the disk.",
" You can hit 'm' more than once on a base or size field to see several",
" interesting values go by. Note: Other Operating Systems can be picky about",
" partitions that are not padded to cylinder boundaries. Look for highlighted",
" head or sector numbers.",
"* To reuse a partition: Change the type to MINIX.",
"* To delete a partition: Type a zero in the hex Type field.",
"* To make a partition active: Type '+' in the Num field.",
"* To study the list of keys: Type '?'.",
};
if (ev == '?') {
struct help *hp;
for (hp= help; hp < arraylimit(help); hp++) {
stat_start(0);
printf("%-25s - %s", hp->keys, hp->what);
stat_end(0);
}
stat_start(0);
putstr("Things like ");
putstr(t_so); putstr("this"); putstr(t_se);
putstr(" must be checked, but ");
putstr(t_md); putstr("this"); putstr(t_me);
putstr(" is not really a problem");
stat_end(0);
} else
if (ev == '!') {
char **ap;
for (ap= advice; ap < arraylimit(advice); ap++) {
stat_start(0);
putstr(*ap);
stat_end(0);
}
}
}
void event(int ev, object_t *op)
/* Simply call all modifiers for an event, each one knows when to act. */
{
m_help(ev, op);
m_redraw(ev, op);
m_toggle(ev, op);
m_orientation(ev, op);
m_move(ev, op);
m_updown(ev, op);
m_enter(ev, op);
m_leave(ev, op);
m_modify(ev, op);
m_magic(ev, op);
m_in(ev, op);
m_out(ev, op);
m_read(ev, NULL);
m_write(ev, op);
m_shell(ev, op);
m_quit(ev, op);
}
int keypress(void)
/* Get a single keypress. Translate compound keypresses (arrow keys) to
* their simpler equivalents.
*/
{
char ch;
int c;
int esc= 0;
set_cursor(curobj->row, curobj->col);
fflush(stdout);
do {
if (read(0, &ch, sizeof(ch)) < 0) fatal("stdin");
c= (unsigned char) ch;
switch (esc) {
case 0:
switch (c) {
case ctrl('['): esc= 1; break;
case '_': c= '-'; break;
case '=': c= '+'; break;
}
break;
case 1:
esc= c == '[' ? 2 : 0;
break;
case 2:
switch (c) {
case 'D': c= 'h'; break;
case 'B': c= 'j'; break;
case 'A': c= 'k'; break;
case 'C': c= 'l'; break;
case 'H': c= 'H'; break;
case 'U':
case 'S': c= '-'; break;
case 'V':
case 'T': c= '+'; break;
}
/*FALL THROUGH*/
default:
esc= 0;
}
} while (esc > 0);
switch (c) {
case ctrl('B'): c= 'h'; break;
case ctrl('N'): c= 'j'; break;
case ctrl('P'): c= 'k'; break;
case ctrl('F'): c= 'l'; break;
}
return c;
}
void mainloop(void)
/* Get keypress, handle event, display results, reset screen, ad infinitum. */
{
int key;
while (!quitting) {
stat_reset();
key= keypress();
event(key, curobj);
display();
}
}
char *
prettysizeprint(int kb)
{
int toosmall = 0;
static char str[200];
char unit = 'k';
if(MIN_REGION_SECTORS > kb*2)
toosmall = 1;
if(kb >= 5*1024) {
kb /= 1024;
unit = 'M';
if(kb >= 5*1024) {
kb /= 1024;
unit = 'G';
}
}
sprintf(str, "%4d %cB%s", kb, unit,
toosmall ? ", too small for MINIX 3" : "");
return str;
}
void
printregions(region_t *theregions, int indent, int p_nr_partitions, int p_free_regions, int p_nr_regions, int numbers)
{
int r, nofree = 0;
region_t *reg;
reg = theregions;
if((p_nr_partitions >= NR_PARTITIONS || !p_free_regions) && p_free_regions)
nofree = 1;
for(r = 0; r < p_nr_regions; r++, reg++) {
unsigned long units;
if(reg->is_used_part) {
char *name;
name = typ2txt(reg->used_part.sysind);
printf("%*s", indent, ""); type2col(reg->used_part.sysind);
if(numbers) printf("[%d] ", r);
printf("In use by %-10s ", name);
units = reg->used_part.size / 2;
col(0);
printf(" (%s)\n", prettysizeprint(units));
} else {
printf("%*s", indent, "");
if(numbers) {
if(!nofree) printf("[%d] ", r);
else printf("[-] ");
}
printf("Free space ");
units = ((reg->free_sec_last - reg->free_sec_start+1))/2;
printf(" (%s)\n", prettysizeprint(units));
}
}
if(numbers && p_nr_partitions >= NR_PARTITIONS && p_free_regions) {
printf(
"\nNote: there is free space on this disk, but you can't select it,\n"
"because there isn't a free slot in the partition table to use it.\n"
"You can reclaim the free space by deleting an adjacent region.\n");
}
return;
}
#define IS_YES 3
#define IS_NO 4
#define IS_OTHER 5
int
is_sure(char *fmt, ...)
{
char yesno[10];
va_list ap;
va_start (ap, fmt);
vprintf(fmt, ap);
va_end(ap);
printf(" Please enter 'yes' or 'no': ");
fflush(stdout);
if(!fgets(yesno, sizeof(yesno)-1, stdin)) exit(1);
if (strcmp(yesno, "yes\n") == 0) return(IS_YES);
if (strcmp(yesno, "no\n") == 0) return(IS_NO);
return IS_OTHER;
}
void warn(char *message)
{
printf("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b ! %s\n",message);
}
int
may_kill_region(void)
{
int confirmation;
char line[100];
int r, i;
if(used_regions < 1) return 1;
printf("\n -- Delete in-use region? --\n\n");
printregions(regions, 3, nr_partitions, free_regions, nr_regions, 1);
printf("\nEnter the region number to delete or ENTER to continue: ");
fflush(NULL);
fgets(line, sizeof(line)-2, stdin);
if(!isdigit(line[0]))
return 1;
r=atoi(line);
if(r < 0 || r >= nr_regions) {
printf("This choice is out of range.\n");
return 0;
}
if(!regions[r].is_used_part) {
printf("This region is not in use.\n");
return 0;
}
i = regions[r].tableno;
printf("\nPlease confirm that you want to delete region %d, losing all data it", r);
printf("\ncontains. You're disk is not actually updated right away, but still.");
printf("\n\n");
do {
confirmation = is_sure("Are you sure you want to continue?");
if (confirmation == IS_NO) return 0;
} while (confirmation != IS_YES);
table[i].sysind = NO_PART;
dirty = 1;
regionize();
/* User may go again. */
return 0;
}
region_t *
select_region(void)
{
int r, rem, rn, done = 0;
static char line[100];
region_t *reg;
int nofree = 0;
printstep(2, "Select a disk region");
if(nr_regions < 1) {
printf("\nNo regions found - maybe the drive is too small.\n"
"Please try expert mode.\n");
exit(1);
}
if(nr_partitions >= NR_PARTITIONS || !free_regions) {
if(free_regions) {
nofree = 1;
}
}
printf("\nPlease select the region that you want to use for the MINIX 3 setup.");
printf("\nIf you select an in-use region it will be overwritten by MINIX. The");
printf("\nfollowing region%s were found on the selected disk:\n\n",
SORNOT(nr_regions));
printregions(regions, 3, nr_partitions, free_regions, nr_regions, 1);
printf("\n");
do {
printf("Enter the region number to use or type 'delete': ");
if(nr_regions == 1) printf(" [0] ");
fflush(NULL);
if(!fgets(line, sizeof(line)-2, stdin))
exit(1);
if (nr_regions == 1 && line[0] == '\n') {
rn = 0;
done = 1;
}
else {
if(strcmp(line,"delete\n") == 0) {
may_kill_region();
return NULL;
}
if(sscanf(line, "%d", &rn) != 1) {
warn("invalid choice");
continue;
}
if(rn < 0 || rn >= nr_regions) {
warn("out of range");
continue;
}
if(nofree && !regions[rn].is_used_part) {
warn("not available");
continue;
}
done = 1;
}
} while(! done);
return(&regions[rn]);
}
static void printstep(int step, char *str)
{
int n;
n = printf("\n --- Substep 2.%d: %s ---", step, str);
while(n++ < 73) printf("-");
printf("\n");
}
device_t *
select_disk(void)
{
int done = 0;
int i, choice, drives;
static char line[500];
int biosdrive = 0;
printstep(1, "Select a disk to install MINIX 3");
printf("\nProbing for disks. This may take a short while.");
i = 0;
curdev=firstdev;
for(; i < MAX_DEVICES;) {
printf(".");
fflush(stdout);
m_read('r', &biosdrive);
if(device >= 0) {
devices[i].dev = curdev;
devices[i].free_regions = free_regions;
devices[i].nr_regions = nr_regions;
devices[i].nr_partitions = nr_partitions;
devices[i].used_regions = used_regions;
devices[i].sectors = table[0].size;
curdev->biosdrive = biosdrive-1;
memcpy(devices[i].regions, regions, sizeof(regions));
i++;
}
nextdevice(NULL, 1);
if(curdev == firstdev)
break;
}
drives = i;
if(drives < 1) {
printf("\nFound no drives - can't partition.\n");
exit(1);
}
printf(" Probing done.\n");
printf("The following disk%s %s found on your system:\n\n", SORNOT(drives),
drives == 1 ? "was" : "were");
for(i = 0; i < drives; i++) {
printf(" ");
printf("Disk [%d]: ", i);
printf("%s, ", devices[i].dev->name);
printf("%s\n", prettysizeprint(devices[i].sectors/2));
printregions(devices[i].regions, 8,
devices[i].nr_partitions,
devices[i].free_regions,
devices[i].nr_regions, 0);
}
printf("\n");
do {
printf("Enter the disk number to use: ");
if (drives == 1) printf("[0] ");
fflush(NULL);
if(!fgets(line, sizeof(line)-2, stdin))
exit(1);
if (line[0] == '\n' && drives == 1) {
choice = 0;
done = 1;
} else {
if(sscanf(line, "%d", &choice) != 1) {
warn("choose a disk");
continue;
}
if(choice < 0 || choice >= i) {
warn("out of range");
continue;
}
done = 1;
}
} while(! done);
return devices[choice].dev;
}
int
scribble_region(region_t *reg, struct part_entry **pe)
{
int ex, trunc = 0, changed = 0, i;
struct part_entry *newpart;
if(reg->is_used_part && reg->used_part.size > MAX_REGION_SECTORS) {
reg->used_part.size = MAX_REGION_SECTORS;
trunc = 1;
changed = 1;
cylinderalign(reg);
}
if(!reg->is_used_part) {
ex = reg->free_sec_last - reg->free_sec_start + 1;
if(ex > MAX_REGION_SECTORS) {
reg->free_sec_last -= ex - MAX_REGION_SECTORS;
trunc = 1;
changed = 1;
cylinderalign(reg);
}
}
#if 0
if(trunc) {
printf("\nWill only use %dMB.\n", MAX_REGION_MB);
}
#endif
if(!reg->is_used_part) {
for(i = 1; i <= NR_PARTITIONS; i++)
if(table[i].sysind == NO_PART)
break;
if(i > NR_PARTITIONS) {
/* Bug, should've been caught earlier. */
printf("Couldn't find a free slot. Please try expert mode.\n");
exit(1);
}
newpart = &table[i];
newpart->lowsec = reg->free_sec_start;
newpart->size = reg->free_sec_last - reg->free_sec_start + 1;
changed = 1;
newpart->sysind = MINIX_PART;
} else {
newpart = &reg->used_part;
}
*pe = newpart;
changed = 1;
dirty = 1;
return changed;
}
int
sanitycheck_failed(char *dev, struct part_entry *pe)
{
struct partition part;
int fd;
unsigned long it_lowsec, it_secsize;
if((fd = open(dev, O_RDONLY)) < 0) {
perror(dev);
return 1;
}
if (ioctl(fd, DIOCGETP, &part) < 0) {
fprintf(stderr, "DIOCGETP failed\n");
perror(dev);
return 1;
}
if(!open_ct_ok(fd)) {
printf("\nAutopart error: the disk is in use. This means that although a\n"
"new table has been written, it won't be in use by the system\n"
"until it's no longer in use (or a reboot is done). Just in case,\n"
"I'm not going to continue. Please un-use the disk (or reboot) and try\n"
"again.\n\n");
return 1;
}
close(fd);
it_lowsec = div64u(part.base, SECTOR_SIZE);
it_secsize = div64u(part.size, SECTOR_SIZE);
if(it_lowsec != pe->lowsec || it_secsize != pe->size) {
fprintf(stderr, "\nReturned and set numbers don't match up!\n");
fprintf(stderr, "This can happen if the disk is still opened.\n");
return 1;
}
return 0;
}
int
do_autopart(int resultfd)
{
int confirmation;
region_t *r;
struct part_entry *pe;
char sure[50];
struct part_entry orig_table[1 + NR_PARTITIONS];
int region, disk;
nordonly = 1;
do {
curdev = select_disk();
} while(!curdev);
if(device >= 0) {
close(device);
device = -1;
}
recompute0();
m_read('r', NULL);
memcpy(orig_table, table, sizeof(table));
do {
/* Show regions. */
r = select_region();
} while(!r); /* Back to step 2. */
/* Write things. */
if(scribble_region(r, &pe)) {
char *name;
int i, found = -1;
char partbuf[100], devname[100];
struct part_entry *tpe;
printstep(3, "Confirm your choices");
region = (int)(r-regions);
/* disk = (int) (curdev-devices); */
printf("\nThis is the point of no return. You have selected to install MINIX 3\n");
printf("into region %d of disk %s. Please confirm that you want\n",
region, curdev->name);
printf("to use this selection to install MINIX 3.\n\n");
do {
confirmation = is_sure("Are you sure you want to continue?");
if (confirmation == IS_NO) return 1;
} while (confirmation != IS_YES);
/* Retrieve partition number in sorted order that we
* have scribbled in.
*/
sort();
for(i = 1; i <= NR_PARTITIONS; i++) {
int si;
si = sort_order[i];
if(si < 1 || si > NR_PARTITIONS) {
fprintf(stderr, "Autopart internal error (out of range) (nothing written).\n");
exit(1);
}
if(table[si].lowsec == pe->lowsec) {
if(found > 0) {
fprintf(stderr, "Autopart internal error (part found twice) (nothing written).\n");
exit(1);
}
check_ind(&table[si]);
table[si].sysind = MINIX_PART;
found = i;
tpe = &table[si];
}
}
if(found < 1) {
fprintf(stderr, "Autopart internal error (part not found) (nothing written).\n");
exit(1);
}
m_write('w', NULL);
if(dirty) {
fprintf(stderr, "Autopart internal error (couldn't update disk).\n");
exit(1);
}
name=strrchr(curdev->name, '/');
if(!name) name = curdev->name;
else name++;
sprintf(partbuf, "%sp%d d%dp%d\n", name, found-1,
curdev->biosdrive, found-1);
sprintf(devname, "/dev/%sp%d", name, found-1);
if(resultfd >= 0 && write(resultfd, partbuf, strlen(partbuf)) < strlen(partbuf)) {
fprintf(stderr, "Autopart internal error (couldn't write result).\n");
exit(1);
}
if(device >= 0) {
close(device);
device = -1;
}
#if 0
m_dump(orig_table);
printf("\n");
m_dump(table);
#endif
if(sanitycheck_failed(devname, tpe)) {
fprintf(stderr, "Autopart internal error (disk sanity check failed).\n");
exit(1);
}
return 0;
}
return 1;
}
int main(int argc, char **argv)
{
object_t *op;
int i, r, key;
struct part_entry *pe;
char *name;
int autopart = 0;
int resultfd = -1;
/* Autopilot mode if invoked as autopart. */
if(!(name = strrchr(argv[0], '/'))) name = argv[0];
else name++;
if(!strcmp(name, "autopart"))
autopart = 1;
if(!autopart) {
/* Define a few objects to show on the screen. First text: */
op= newobject(O_INFO, 0, 0, 2, 19);
op= newobject(O_TEXT, 0, 0, 22, 13); op->text= "----first----";
op= newobject(O_TEXT, 0, 0, 37, 13); op->text= "--geom/last--";
op= newobject(O_TEXT, 0, 0, 52, 18); op->text= "------sectors-----";
op= newobject(O_TEXT, 0, 1, 4, 6); op->text= "Device";
op= newobject(O_TEXT, 0, 1, 23, 12); op->text= "Cyl Head Sec";
op= newobject(O_TEXT, 0, 1, 38, 12); op->text= "Cyl Head Sec";
op= newobject(O_TEXT, 0, 1, 56, 4); op->text= "Base";
op= newobject(O_TEXT, 0, 1, 66, 4); op->text= size_last;
op= newobject(O_TEXT, 0, 1, 78, 2); op->text= "Kb";
op= newobject(O_TEXT, 0, 4, 0, 15); op->text= "Num Sort Type";
/* The device is the current object: */
curobj= newobject(O_DEV, OF_MOD, 2, 4, 15);
op= newobject(O_SUB, 0, 3, 4, 15);
/* Geometry: */
op= newobject(O_CYL, OF_MOD, 2, 40, 5); op->entry= &table[0];
op= newobject(O_HEAD, OF_MOD, 2, 45, 3); op->entry= &table[0];
op= newobject(O_SEC, OF_MOD, 2, 49, 2); op->entry= &table[0];
/* Objects for the device: */
op= newobject(O_SCYL, 0, 3, 25, 5); op->entry= &table[0];
op= newobject(O_SHEAD, 0, 3, 30, 3); op->entry= &table[0];
op= newobject(O_SSEC, 0, 3, 34, 2); op->entry= &table[0];
op= newobject(O_LCYL, 0, 3, 40, 5); op->entry= &table[0];
op= newobject(O_LHEAD, 0, 3, 45, 3); op->entry= &table[0];
op= newobject(O_LSEC, 0, 3, 49, 2); op->entry= &table[0];
op= newobject(O_BASE, 0, 3, 59, 9); op->entry= &table[0];
op= newobject(O_SIZE, 0, 3, 69, 9); op->entry= &table[0];
op= newobject(O_KB, 0, 3, 79, 9); op->entry= &table[0];
/* Objects for each partition: */
for (r= 5, pe= table+1; pe <= table+NR_PARTITIONS; r++, pe++) {
op= newobject(O_NUM, OF_MOD, r, 1, 2); op->entry= pe;
op= newobject(O_SORT, 0, r, 5, 2); op->entry= pe;
op= newobject(O_TYPHEX, OF_MOD, r, 10, 2); op->entry= pe;
op= newobject(O_TYPTXT, OF_MOD, r, 12, 9); op->entry= pe;
op= newobject(O_SCYL, OF_MOD, r, 25, 5); op->entry= pe;
op= newobject(O_SHEAD, OF_MOD, r, 30, 3); op->entry= pe;
op= newobject(O_SSEC, OF_MOD, r, 34, 2); op->entry= pe;
op= newobject(O_LCYL, OF_MOD, r, 40, 5); op->entry= pe;
op= newobject(O_LHEAD, OF_MOD, r, 45, 3); op->entry= pe;
op= newobject(O_LSEC, OF_MOD, r, 49, 2); op->entry= pe;
op= newobject(O_BASE, OF_MOD, r, 59, 9); op->entry= pe;
op= newobject(O_SIZE, OF_MOD, r, 69, 9); op->entry= pe;
op= newobject(O_KB, OF_MOD, r, 79, 9); op->entry= pe;
}
} else {
int c;
/* autopart uses getopt() */
while((c = getopt(argc, argv, "f:")) != EOF) {
switch(c) {
case 'f':
/* Make sure old data file is gone. */
unlink(optarg);
if((resultfd=open(optarg, O_CREAT | O_WRONLY | O_TRUNC)) < 0) {
perror(optarg);
return 1;
}
sync(); /* Make sure no old data file lingers. */
break;
default:
fprintf(stderr, "Unknown option\n");
return 1;
}
}
}
argc -= optind;
argv += optind;
for (i= 0; i < argc; i++) {
newdevice(argv[i], 0, 0);
}
if (firstdev == nil) {
getdevices(autopart);
key= ctrl('L');
} else {
key= 'r';
}
if(autopart) {
int r;
if (firstdev == nil) {
fprintf(stderr, "autopart couldn't find any devices.\n");
return 1;
}
r = do_autopart(resultfd);
if(resultfd >= 0) { close(resultfd); }
return r;
}
if (firstdev != nil) {
init_tty();
clear_screen();
event(key, curobj);
display();
mainloop();
reset_tty();
}
exit(0);
}
Reference in a new issue View git blame Copy permalink