int
edit(struct disklabel *lp, int f)
{
int first, ch, fd, error = 0;
struct disklabel label;
FILE *fp;
u_int64_t total_sectors, starting_sector, ending_sector;
if ((fd = mkstemp(tmpfil)) == -1 || (fp = fdopen(fd, "w")) == NULL) {
if (fd != -1)
close(fd);
warn("%s", tmpfil);
return (1);
}
display(fp, lp, 0, 1);
fprintf(fp, "\n# Notes:\n");
fprintf(fp,
"# Up to 16 partitions are valid, named from 'a' to 'p'. Partition 'a' is\n"
"# your root filesystem, 'b' is your swap, and 'c' should cover your whole\n"
"# disk. Any other partition is free for any use. 'size' and 'offset' are\n"
"# in 512-byte blocks. fstype should be '4.2BSD', 'swap', or 'none' or some\n"
"# other values. fsize/bsize/cpg should typically be '2048 16384 16' for a\n"
"# 4.2BSD filesystem (or '512 4096 16' except on alpha, sun4, ...)\n");
fclose(fp);
for (;;) {
if (editit(tmpfil) == -1)
break;
fp = fopen(tmpfil, "r");
if (fp == NULL) {
warn("%s", tmpfil);
break;
}
/* Get values set by OS and not the label. */
if (ioctl(f, DIOCGPDINFO, &label) < 0)
err(4, "ioctl DIOCGPDINFO");
ending_sector = DL_GETBEND(&label);
starting_sector = DL_GETBSTART(&label);
total_sectors = DL_GETDSIZE(&label);
memset(&label, 0, sizeof(label));
error = getasciilabel(fp, &label);
DL_SETBEND(&label, ending_sector);
DL_SETBSTART(&label, starting_sector);
DL_SETDSIZE(&label, total_sectors);
if (error == 0) {
if (cmplabel(lp, &label) == 0) {
puts("No changes.");
fclose(fp);
(void) unlink(tmpfil);
return (0);
}
*lp = label;
if (writelabel(f, bootarea, lp) == 0) {
fclose(fp);
(void) unlink(tmpfil);
return (0);
}
}
fclose(fp);
printf("re-edit the label? [y]: ");
fflush(stdout);
first = ch = getchar();
while (ch != '\n' && ch != EOF)
ch = getchar();
if (first == 'n' || first == 'N')
break;
}
(void)unlink(tmpfil);
return (1);
}
int
readdpmelabel(struct buf *bp, void (*strat)(struct buf *),
struct disklabel *lp, daddr_t *partoffp, int spoofonly)
{
int i, part_cnt, n, hfspartoff = -1;
long long hfspartend = DL_GETDSIZE(lp);
struct part_map_entry *part;
/* First check for a DPME (HFS) disklabel */
bp->b_blkno = LABELSECTOR;
bp->b_bcount = lp->d_secsize;
CLR(bp->b_flags, B_READ | B_WRITE | B_DONE);
SET(bp->b_flags, B_BUSY | B_READ | B_RAW);
(*strat)(bp);
if (biowait(bp))
return (bp->b_error);
/* if successful, wander through DPME partition table */
part = (struct part_map_entry *)bp->b_data;
/* if first partition is not valid, assume not HFS/DPME partitioned */
if (part->pmSig != PART_ENTRY_MAGIC)
return (EINVAL); /* not a DPME partition */
part_cnt = part->pmMapBlkCnt;
n = 8;
for (i = 0; i < part_cnt; i++) {
struct partition *pp;
char *s;
bp->b_blkno = LABELSECTOR + i;
bp->b_bcount = lp->d_secsize;
CLR(bp->b_flags, B_READ | B_WRITE | B_DONE);
SET(bp->b_flags, B_BUSY | B_READ | B_RAW);
(*strat)(bp);
if (biowait(bp))
return (bp->b_error);
part = (struct part_map_entry *)bp->b_data;
/* toupper the string, in case caps are different... */
for (s = part->pmPartType; *s; s++)
if ((*s >= 'a') && (*s <= 'z'))
*s = (*s - 'a' + 'A');
if (strcmp(part->pmPartType, PART_TYPE_OPENBSD) == 0) {
hfspartoff = part->pmPyPartStart;
hfspartend = hfspartoff + part->pmPartBlkCnt;
if (partoffp) {
*partoffp = hfspartoff;
return (0);
} else {
DL_SETBSTART(lp, hfspartoff);
DL_SETBEND(lp,
hfspartend < DL_GETDSIZE(lp) ? hfspartend :
DL_GETDSIZE(lp));
}
continue;
}
if (n >= MAXPARTITIONS || partoffp)
continue;
/* Currently we spoof HFS partitions only. */
if (strcmp(part->pmPartType, PART_TYPE_MAC) == 0) {
pp = &lp->d_partitions[n];
DL_SETPOFFSET(pp, part->pmPyPartStart);
DL_SETPSIZE(pp, part->pmPartBlkCnt);
pp->p_fstype = FS_HFS;
n++;
}
}
if (hfspartoff == -1)
return (EINVAL); /* no OpenBSD partition inside DPME label */
if (spoofonly)
return (0);
/* next, dig out disk label */
bp->b_blkno = hfspartoff;
bp->b_bcount = lp->d_secsize;
CLR(bp->b_flags, B_READ | B_WRITE | B_DONE);
SET(bp->b_flags, B_BUSY | B_READ | B_RAW);
(*strat)(bp);
if (biowait(bp))
return(bp->b_error);
/*
* Do OpenBSD disklabel validation/adjustment.
*
* N.B: No matter what the bits are on the disk, we now have the
* disklabel for this dpme disk. DO NOT proceed to readdoslabel(),
* iso_spooflabel(), * etc.
*/
checkdisklabel(bp->b_data + LABELOFFSET, lp, hfspartoff, hfspartend);
return (0);
}
int
readliflabel(struct buf *bp, void (*strat)(struct buf *),
struct disklabel *lp, int *partoffp, int spoofonly)
{
struct buf *dbp = NULL;
struct lifdir *p;
struct lifvol *lvp;
int error = 0;
int fsoff = 0, openbsdstart = MAXLIFSPACE, i;
/* read LIF volume header */
bp->b_blkno = btodb(LIF_VOLSTART);
bp->b_bcount = lp->d_secsize;
CLR(bp->b_flags, B_READ | B_WRITE | B_DONE);
SET(bp->b_flags, B_BUSY | B_READ | B_RAW);
(*strat)(bp);
if (biowait(bp))
return (bp->b_error);
lvp = (struct lifvol *)bp->b_data;
if (lvp->vol_id != LIF_VOL_ID) {
error = EINVAL; /* no LIF volume header */
goto done;
}
dbp = geteblk(LIF_DIRSIZE);
dbp->b_dev = bp->b_dev;
/* read LIF directory */
dbp->b_blkno = lifstodb(lvp->vol_addr);
dbp->b_bcount = lp->d_secsize;
CLR(dbp->b_flags, B_READ | B_WRITE | B_DONE);
SET(dbp->b_flags, B_BUSY | B_READ | B_RAW);
(*strat)(dbp);
if (biowait(dbp)) {
error = dbp->b_error;
goto done;
}
/* scan for LIF_DIR_FS dir entry */
for (i=0, p=(struct lifdir *)dbp->b_data; i < LIF_NUMDIR; p++, i++) {
if (p->dir_type == LIF_DIR_FS || p->dir_type == LIF_DIR_HPLBL)
break;
}
if (p->dir_type == LIF_DIR_FS) {
fsoff = lifstodb(p->dir_addr);
openbsdstart = 0;
goto finished;
}
/* Only came here to find the offset... */
if (partoffp)
goto finished;
if (p->dir_type == LIF_DIR_HPLBL) {
struct hpux_label *hl;
struct partition *pp;
u_int8_t fstype;
int i;
/* read LIF directory */
dbp->b_blkno = lifstodb(p->dir_addr);
dbp->b_bcount = lp->d_secsize;
CLR(dbp->b_flags, B_READ | B_WRITE | B_DONE);
SET(dbp->b_flags, B_BUSY | B_READ | B_RAW);
(*strat)(dbp);
if (biowait(dbp)) {
error = dbp->b_error;
goto done;
}
hl = (struct hpux_label *)dbp->b_data;
if (hl->hl_magic1 != hl->hl_magic2 ||
hl->hl_magic != HPUX_MAGIC || hl->hl_version != 1) {
error = EINVAL; /* HPUX label magic mismatch */
goto done;
}
lp->d_bbsize = 8192;
lp->d_sbsize = 8192;
for (i = 0; i < MAXPARTITIONS; i++) {
DL_SETPSIZE(&lp->d_partitions[i], 0);
DL_SETPOFFSET(&lp->d_partitions[i], 0);
lp->d_partitions[i].p_fstype = 0;
}
for (i = 0; i < HPUX_MAXPART; i++) {
if (!hl->hl_flags[i])
continue;
if (hl->hl_flags[i] == HPUX_PART_ROOT) {
pp = &lp->d_partitions[0];
fstype = FS_BSDFFS;
} else if (hl->hl_flags[i] == HPUX_PART_SWAP) {
pp = &lp->d_partitions[1];
fstype = FS_SWAP;
} else if (hl->hl_flags[i] == HPUX_PART_BOOT) {
pp = &lp->d_partitions[RAW_PART + 1];
fstype = FS_BSDFFS;
} else
continue;
DL_SETPSIZE(pp, hl->hl_parts[i].hlp_length * 2);
DL_SETPOFFSET(pp, hl->hl_parts[i].hlp_start * 2);
pp->p_fstype = fstype;
}
DL_SETPSIZE(&lp->d_partitions[RAW_PART], DL_GETDSIZE(lp));
DL_SETPOFFSET(&lp->d_partitions[RAW_PART], 0);
lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED;
lp->d_npartitions = MAXPARTITIONS;
lp->d_magic = DISKMAGIC;
lp->d_magic2 = DISKMAGIC;
lp->d_version = 1;
lp->d_checksum = 0;
lp->d_checksum = dkcksum(lp);
/* drop through */
}
finished:
/* record the OpenBSD partition's placement for the caller */
if (partoffp)
*partoffp = fsoff;
else {
DL_SETBSTART(lp, openbsdstart);
DL_SETBEND(lp, DL_GETDSIZE(lp)); /* XXX */
}
/* don't read the on-disk label if we are in spoofed-only mode */
if (spoofonly)
goto done;
bp->b_blkno = fsoff + LABELSECTOR;
bp->b_bcount = lp->d_secsize;
CLR(bp->b_flags, B_READ | B_WRITE | B_DONE);
SET(bp->b_flags, B_BUSY | B_READ | B_RAW);
(*strat)(bp);
if (biowait(bp)) {
error = bp->b_error;
goto done;
}
/*
* Do OpenBSD disklabel validation/adjustment.
*
* N.B: No matter what the bits are on the disk, we now have the
* OpenBSD disklabel for this lif disk. DO NOT proceed to
* readdoslabel(), iso_spooflabel(), etc.
*/
checkdisklabel(bp->b_data, lp, openbsdstart, DL_GETDSIZE(lp));
error = 0;
done:
if (dbp) {
dbp->b_flags |= B_INVAL;
brelse(dbp);
}
return (error);
}
/*
* Search for a VDIT volume information. If one is found, search for a
* vdmpart instance of name "OpenBSD". If one is found, set the disklabel
* bounds to the area it spans, and attempt to read a native label within
* it.
*/
int
readvditlabel(struct buf *bp, void (*strat)(struct buf *), struct disklabel *lp,
daddr_t *partoffp, int spoofonly, struct vdm_boot_info *vbi)
{
struct buf *sbp = NULL;
struct vdit_block_header *vbh;
struct vdit_entry_header *veh;
char *vdit_storage = NULL, *vdit_end;
size_t vdit_size;
unsigned int largest_chunk, vdit_blkno;
int expected_kind;
daddr_t blkno;
int error = 0;
vdit_id_t *vdmpart_id;
struct vdit_vdmpart_instance *bsd_vdmpart;
/*
* Figure out the size of the first VDIT.
*/
vdit_size = largest_chunk = 0;
expected_kind = VDIT_BLOCK_HEAD_BE;
blkno = VDIT_SECTOR;
for (;;) {
error = readdisksector(bp, strat, lp, DL_BLKTOSEC(lp, blkno));
if (error)
return (error);
vbh = (struct vdit_block_header *)bp->b_data;
if (VDM_ID_KIND(&vbh->id) != expected_kind ||
VDM_ID_BLKNO(&vbh->id) != vdit_size ||
vbh->id.node_number != VDM_NO_NODE_NUMBER)
return EINVAL;
if (vbi != NULL) {
if ((blkno >= vbi->boot_start &&
blkno < vbi->boot_start + vbi->boot_size) ||
(blkno + vbh->chunksz - 1 >= vbi->boot_start &&
blkno + vbh->chunksz - 1 <
vbi->boot_start + vbi->boot_size))
return EINVAL;
}
if (vbh->chunksz > largest_chunk)
largest_chunk = vbh->chunksz;
vdit_size += vbh->chunksz;
if (vbh->nextblk == VDM_NO_BLK_NUMBER)
break;
blkno = vbh->nextblk;
if (blkno >= DL_GETDSIZE(lp))
return EINVAL;
expected_kind = VDIT_PORTION_HEADER_BLOCK;
}
/*
* Now read the first VDIT.
*/
vdit_size *= dbtob(1) - sizeof(struct vdit_block_header);
vdit_storage = malloc(vdit_size, M_DEVBUF, M_WAITOK);
largest_chunk = dbtob(largest_chunk);
sbp = geteblk(largest_chunk);
sbp->b_dev = bp->b_dev;
vdit_end = vdit_storage;
expected_kind = VDIT_BLOCK_HEAD_BE;
blkno = VDIT_SECTOR;
vdit_blkno = 0;
for (;;) {
sbp->b_blkno = blkno;
sbp->b_bcount = largest_chunk;
CLR(sbp->b_flags, B_READ | B_WRITE | B_DONE);
SET(sbp->b_flags, B_BUSY | B_READ | B_RAW);
(*strat)(sbp);
if ((error = biowait(sbp)) != 0)
goto done;
vbh = (struct vdit_block_header *)sbp->b_data;
if (VDM_ID_KIND(&vbh->id) != expected_kind) {
error = EINVAL;
goto done;
}
vdit_end = extract_vdit_portion(vdit_end, sbp->b_data,
vbh->chunksz, vdit_blkno, expected_kind);
if (vdit_end == NULL) {
error = EINVAL;
goto done;
}
if (vbh->nextblk == VDM_NO_BLK_NUMBER)
break;
vdit_blkno += vbh->chunksz;
blkno = vbh->nextblk;
expected_kind = VDIT_PORTION_HEADER_BLOCK;
}
/*
* Walk the VDIT entries.
*
* If we find an OpenBSD vdmpart, we'll set our disk area bounds to
* its area, and will read a label from there.
*/
vdmpart_id = NULL;
bsd_vdmpart = NULL;
veh = (struct vdit_entry_header *)vdit_storage;
while ((caddr_t)veh < vdit_end) {
switch (veh->type) {
case VDIT_ENTRY_SUBDRIVER_INFO:
{
struct vdit_subdriver_entry *vse;
vse = (struct vdit_subdriver_entry *)(veh + 1);
if (strcmp(vse->name, VDM_SUBDRIVER_VDMPART) == 0)
vdmpart_id = &vse->subdriver_id;
}
break;
case VDIT_ENTRY_INSTANCE:
{
struct vdit_instance_entry *vie;
vie = (struct vdit_instance_entry *)(veh + 1);
if (strcmp(vie->name, VDM_INSTANCE_OPENBSD) == 0) {
if (vdmpart_id != NULL &&
memcmp(vdmpart_id, &vie->subdriver_id,
sizeof(vdit_id_t)) == 0) {
/* found it! */
if (bsd_vdmpart != NULL) {
bsd_vdmpart = NULL;
veh->type = VDIT_ENTRY_SENTINEL;
} else
bsd_vdmpart = (struct
vdit_vdmpart_instance *)vie;
}
}
}
break;
}
if (veh->type == VDIT_ENTRY_SENTINEL)
break;
veh = (struct vdit_entry_header *)((char *)veh + veh->size);
}
if (bsd_vdmpart != NULL) {
uint32_t start, size;
memcpy(&start, &bsd_vdmpart->start_blkno, sizeof(uint32_t));
memcpy(&size, &bsd_vdmpart->size, sizeof(uint32_t));
if (start >= DL_GETDSIZE(lp) ||
start + size > DL_GETDSIZE(lp)) {
error = EINVAL;
goto done;
}
if (partoffp != NULL) {
*partoffp = start;
goto done;
} else {
DL_SETBSTART(lp, start);
DL_SETBEND(lp, start + size);
}
/*
* Now read the native label.
*/
if (spoofonly == 0) {
error = readdisksector(bp, strat, lp,
DL_BLKTOSEC(lp, start + LABELSECTOR));
if (error)
goto done;
error = checkdisklabel(bp->b_data + LABELOFFSET, lp,
start, start + size);
}
} else {
/*
* VDM label, but no OpenBSD vdmpart partition found.
* XXX is it worth registering the whole disk as a
* XXX `don't touch' vendor partition in that case?
*/
error = ENOENT;
goto done;
}
done:
free(vdit_storage, M_DEVBUF, vdit_size);
if (sbp != NULL) {
sbp->b_flags |= B_INVAL;
brelse(sbp);
}
return error;
}
/*
* Search for a VDM "label" (which does not describe any partition).
* If one is found, search for either a VDIT label, or a native OpenBSD
* label in the first sector.
*/
int
readvdmlabel(struct buf *bp, void (*strat)(struct buf *), struct disklabel *lp,
daddr_t *partoffp, int spoofonly)
{
struct vdm_label *vdl;
struct vdm_boot_info *vbi;
int error = 0;
/*
* Read first sector and check for a VDM label.
* Note that a VDM label is only required for bootable disks, and
* may not be followed by a VDIT.
*/
error = readdisksector(bp, strat, lp, DL_BLKTOSEC(lp,
VDM_LABEL_SECTOR));
if (error)
return (error);
vdl = (struct vdm_label *)(bp->b_data + VDM_LABEL_OFFSET);
if (vdl->signature != VDM_LABEL_SIGNATURE)
vdl = (struct vdm_label *)(bp->b_data + VDM_LABEL_OFFSET_ALT);
if (vdl->signature != VDM_LABEL_SIGNATURE)
return EINVAL;
/*
* If the disk is a bootable disk, remember the boot block area, to
* be able to check that the VDIT does not overwrite it.
*/
vbi = (struct vdm_boot_info *)(bp->b_data + dbtob(1) - sizeof *vbi);
if (vbi->signature != VDM_LABEL_SIGNATURE || vbi->boot_start == 0)
vbi = NULL;
if (vbi != NULL && vbi->boot_start == VDIT_SECTOR)
return EINVAL;
if (vbi != NULL && vbi->boot_start + vbi->boot_size > DL_GETBSTART(lp))
DL_SETBSTART(lp, vbi->boot_start + vbi->boot_size);
error = readvditlabel(bp, strat, lp, partoffp, spoofonly, vbi);
if (error == 0)
return 0;
/*
* Valid VDIT information, but no OpenBSD vdmpart found.
* Do not try to read a native label.
*/
if (error == ENOENT)
return error;
if (partoffp != NULL)
*partoffp = 0;
/* don't read the on-disk label if we are in spoofed-only mode */
if (spoofonly != 0)
return 0;
error = readdisksector(bp, strat, lp, DL_BLKTOSEC(lp, LABELSECTOR));
if (error)
return (error);
return checkdisklabel(bp->b_data + LABELOFFSET, lp,
DL_GETBSTART(lp), DL_GETBEND(lp));
}
int
readsgilabel(struct buf *bp, void (*strat)(struct buf *),
struct disklabel *lp, daddr_t *partoffp, int spoofonly)
{
struct sgilabel *dlp;
int i, *p, cs = 0;
daddr_t fsoffs, fsend;
int error, offset;
/* if successful, locate disk label within block and validate */
error = readdisksector(bp, strat, lp, 0);
if (error)
return (error);
fsoffs = DL_SECTOBLK(lp, DL_GETBSTART(lp));
fsend = DL_SECTOBLK(lp, DL_GETBEND(lp));
dlp = (struct sgilabel *)(bp->b_data + LABELOFFSET);
if (dlp->magic != htobe32(SGILABEL_MAGIC))
goto finished;
if (dlp->partitions[0].blocks == 0)
return (EINVAL);
fsoffs = (long long)dlp->partitions[0].first;
fsend = fsoffs + dlp->partitions[0].blocks;
/* Only came here to find the offset... */
if (partoffp) {
*partoffp = fsoffs;
goto finished;
}
p = (int *)dlp;
i = sizeof(struct sgilabel) / sizeof(int);
while (i--)
cs += *p++;
if (cs != 0)
return (EINVAL); /* sgilabel checksum error */
/* Spoof info from sgi label, in case there is no OpenBSD label. */
lp->d_npartitions = MAXPARTITIONS;
for (i = 0; i < 16; i++) {
int bsd = maptab[i].m;
int type = maptab[i].b;
if (spoofonly && type != FS_UNUSED && type != FS_OTHER)
continue;
DL_SETPOFFSET(&lp->d_partitions[bsd],
dlp->partitions[i].first);
DL_SETPSIZE(&lp->d_partitions[bsd],
dlp->partitions[i].blocks);
lp->d_partitions[bsd].p_fstype = type;
if (type == FS_BSDFFS) {
lp->d_partitions[bsd].p_fragblock =
DISKLABELV1_FFS_FRAGBLOCK(1024, 8);
lp->d_partitions[bsd].p_cpg = 16;
}
}
DL_SETBSTART(lp, DL_BLKTOSEC(lp, fsoffs));
DL_SETBEND(lp, DL_BLKTOSEC(lp, fsend));
lp->d_version = 1;
lp->d_flags = D_VENDOR;
lp->d_checksum = 0;
lp->d_checksum = dkcksum(lp);
finished:
/* record the OpenBSD partition's placement for the caller */
if (partoffp)
*partoffp = fsoffs;
else {
DL_SETBSTART(lp, DL_BLKTOSEC(lp, fsoffs));
DL_SETBEND(lp, DL_BLKTOSEC(lp, fsend));
}
/* don't read the on-disk label if we are in spoofed-only mode */
if (spoofonly)
return (0);
error = readdisksector(bp, strat, lp, DL_BLKTOSEC(lp, fsoffs +
LABELSECTOR));
if (error)
return (error);
offset = DL_BLKOFFSET(lp, fsoffs + LABELSECTOR) + LABELOFFSET;
/*
* Do OpenBSD disklabel validation/adjustment.
*
* N.B: No matter what the bits are on the disk, we now have the
* OpenBSD disklabel for this sgi disk. DO NOT proceed to
* readdoslabel(), iso_spooflabel(), etc.
*/
checkdisklabel(bp->b_data + offset, lp, fsoffs, fsend);
return (0);
}
