Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/distrib/utils/sysinst/arch/mac68k/md.c

889 lines
24 KiB
C
Raw Blame History

/* $NetBSD: md.c,v 1.5 1999/04/16 08:29:15 ender Exp $ */
/*
* Copyright 1997 Piermont Information Systems Inc.
* All rights reserved.
*
* Written by Philip A. Nelson for Piermont Information Systems Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software develooped for the NetBSD Project by
* Piermont Information Systems Inc.
* 4. The name of Piermont Information Systems Inc. may not be used to endorse
* or promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY PIERMONT INFORMATION SYSTEMS INC. ``AS IS''
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL PIERMONT INFORMATION SYSTEMS INC. BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/* md.c -- Machine specific code for mac68k */
#include <stdio.h>
#include <util.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include "defs.h"
#include "md.h"
#include "msg_defs.h"
#include "menu_defs.h"
MAP map = {0, 0, 0, 0, 0, 0, 0, 0, {0}};
/* prototypes */
/*
* Define the known partition type table that we use to
* classify what we find on disk. The ParType fields here could use
* the predefined strings that exist in the NetBSD/mac68k disklabel.h
* file, but there they are all in uppercase. Apple really defined
* these to be in mixed case, something not all 3rd party disk formatters
* honored. Just to be a purist we'll use the original Apple definitions
* here, not that it makes a lot of difference since we always do a
* case insensitive string match anyway.
*
* Note also that the "Apple_Unix_SVR2" type is initially classified as
* an unknown BSD type partition. This will change to a "4.2BSD" type
* classification if the appropiate flags are found in the BootArgs
* block. Not all 3rd party disk formatters properly set these flags
* so this could be an important tip-off that the disk is not properly
* configured for use by NetBSD.
*/
PTYPES ptypes[] = {
{ TYP_RSRVD, "Apple_partition_map", "reserved"},
{ TYP_RSRVD, "Apple_Driver", "reserved"},
{ TYP_RSRVD, "Apple_Driver43", "reserved"},
{ TYP_RSRVD, "Apple_Driver_ATA", "reserved"},
{ TYP_RSRVD, "Apple_Patches", "reserved"},
{ TYP_AVAIL, "Apple_MFS", "MFS"},
{ TYP_HFS, "Apple_HFS", "HFS"},
{ TYP_BSD, "Apple_Unix_SVR2", "?BSD?"},
{ TYP_AVAIL, "Apple_PRODOS", "PRODOS"},
{ TYP_AVAIL, "Apple_Free", "free"},
{ TYP_AVAIL, "Apple_Scratch", "scratch"},
{ TYP_AVAIL, NULL, NULL}};
/*
* Order of the BSD disk parts as they are assigned in the mac68k port
*/
char bsd_order[] = {'g', 'd', 'e', 'f', 'h'};
char macos_order[] = {'a', 'd', 'e', 'f', 'g', 'h'};
/*
* Define a default Disk Partition Map that can be used for an uninitialized
* disk.
*/
Block0 new_block0 = {0x4552, 512, 0};
/*
* Compare lexigraphically two strings up to a max length
*/
int
strnicmp(s1, s2, n)
const char *s1;
const char *s2;
int n;
{
int i;
char c1, c2;
for (i=0; i<n; i++) {
c1 = tolower(*s1++);
c2 = tolower(*s2++);
if (c1 < c2) return -1;
if (c1 > c2) return 1;
if (!c1) return 0;
}
return 0;
}
/*
* Reset the flags and reserved fields in the selected partition.
* This functions isn't called to process any of the reserved partitions
* where the boot code for MacOS is stored, so (hopefully) we won't
* do more damage that we're trying to avoid. Eventually the NetBSD
* Boot Code will need to go into a partition too, but that should go
* into a reserved partition as well. I'd suggest using a partition
* named something like "NetBSD_Boot" with a pmPartName of "Macintosh".
* The Apple Start Manager (in ROM) will then recognize the partition
* as the one containing the system bootstrip for the volume.
*/
void
reset_part_flags (part)
int part;
{
EBZB *bzb;
/*
* Clear out the MacOS fields that might be used for booting just
* in case we've clobbered the boot code.
*/
map.blk[part].pmLgDataStart = 0;
map.blk[part].pmPartStatus = 0x7f; /* make sure the partition shows up */
map.blk[part].pmLgBootStart = 0;
map.blk[part].pmBootSize = 0;
map.blk[part].pmBootLoad = 0;
map.blk[part].pmBootLoad2 = 0;
map.blk[part].pmBootEntry = 0;
map.blk[part].pmBootEntry2 = 0;
map.blk[part].pmBootCksum = 0;
/*
* Clear out all the NetBSD fields too. We only clear out the ones
* that should get reset during our processing.
*/
bzb = (EBZB *)&map.blk[part].pmBootArgs[0];
bzb->magic = 0;
bzb->cluster = 0;
bzb->inode = 0;
bzb->type = 0;
bzb->flags.root = 0;
bzb->flags.usr = 0;
bzb->flags.crit = 0;
bzb->flags.slice = 0;
return;
}
/*
* sortmerge:
* 1) Moves all the Partition Map entries to the front of the Map.
* This is required because some disk formatters leave holes.
* 2) Sorts all entries by ascending start block number.
* Needed so the NetBSD algorithm for finding partitions works
* consistently from a user perspective.
* 3) Collapse multiple adjected "free" entries into a single entry.
* 4) Identify the NetBSD mount_points.
*/
void
sortmerge(void)
{
struct part_map_entry tmp_blk;
char fstyp[16], use[16], name[64];
int i, j, k;
EBZB *bzb;
/*
* Step 1, squeeze out the holes
*/
for (i=0;i<map.size-1;i++) {
if (map.blk[i].pmSig != PART_ENTRY_MAGIC && map.blk[i].pmSig != 0x5453) {
for (j=i+1;j<map.size;j++) {
if (map.blk[j].pmSig == PART_ENTRY_MAGIC || map.blk[j].pmSig == 0x5453) {
memcpy (&map.blk[i], &map.blk[j], sizeof(struct part_map_entry));
map.blk[j].pmSig = 0;
break;
}
}
}
}
/*
* Step 2, sort by ascending starting block number. Since
* we've already removed the holes we only need to
* deal with the in_use count of blocks.
*/
for (i=0;i<map.in_use_cnt-1;i++) {
for (j=i+1;j<map.in_use_cnt;j++) {
if (map.blk[i].pmPyPartStart > map.blk[j].pmPyPartStart) {
memcpy (&tmp_blk, &map.blk[i], sizeof(struct part_map_entry));
memcpy (&map.blk[i], &map.blk[j], sizeof(struct part_map_entry));
memcpy (&map.blk[j], &tmp_blk, sizeof(struct part_map_entry));
}
}
}
/*
* Step 3, merge adjacent free space
*/
for (i=0;i<map.in_use_cnt-1;i++) {
if (strnicmp("Apple_Free", map.blk[i].pmPartType,
sizeof(map.blk[i].pmPartType)) == 0 &&
strnicmp("Apple_Free", map.blk[i+1].pmPartType,
sizeof(map.blk[i+1].pmPartType)) == 0) {
map.blk[i].pmPartBlkCnt += map.blk[i+1].pmPartBlkCnt;
map.blk[i].pmDataCnt += map.blk[i+1].pmDataCnt;
map.blk[i+1].pmSig = 0;
for (j=i+1;j<map.in_use_cnt-1;j++) {
memcpy (&map.blk[j], &map.blk[j+1], sizeof(struct part_map_entry));
map.blk[j+1].pmSig = 0;
}
map.in_use_cnt -= 1;
}
}
/*
* Step 4, try to identify the mount points for the partitions
* Also, force use of PART_ENTRY_MAGIC in place of the old
* 0x5453 pmSig value, and adjust the pmMapBlkCnt in
* each Map entry. Set up the display array for the
* non-reserved partitions, and count the number of
* NetBSD usable partitions
*/
map.hfs_cnt = 0;
map.root_cnt = 0;
map.swap_cnt = 0;
map.usr_cnt = 0;
map.usable_cnt = 0;
for (i=0,j=0;i<map.in_use_cnt;i++) {
map.blk[i].pmSig = PART_ENTRY_MAGIC;
map.blk[i].pmMapBlkCnt = map.in_use_cnt;
if ((part_type(i, fstyp, use, name) != TYP_RSRVD) &&
(j < MAXPARTITIONS)) {
map.mblk[j++] = i;
map.usable_cnt += 1;
}
if (strnicmp("Apple_Unix_SVR2", map.blk[i].pmPartType,
sizeof(map.blk[i].pmPartType)) == 0) {
bzb = (EBZB *)&map.blk[i].pmBootArgs[0];
bzb->flags.part = '?';
if (bzb->magic == BZB_MAGIC) {
switch (bzb->type) {
case BZB_TYPEFS:
if (bzb->flags.root && !map.root_cnt) {
map.root_cnt = 1;
bzb->flags.part = 'a';
strcpy (bzb->mount_point, "/");
}
else if (bzb->flags.root || bzb->flags.usr)
bzb->flags.part = bsd_order[map.usr_cnt++];
break;
case BZB_TYPESWAP:
if (!map.swap_cnt)
bzb->flags.part = 'b';
map.swap_cnt += 1;
break;
default:
break;
}
}
}
}
/*
* Map any remaining slots and partitions to any other non-reserved
* partition type on the disk. This picks up the MacOS HFS parts.
*/
if (map.root_cnt+map.usr_cnt+map.swap_cnt < MAXPARTITIONS) {
for (i=0,k=map.root_cnt;i<map.in_use_cnt;i++) {
j = part_type(i, fstyp, use, name);
if (j == TYP_AVAIL || j == TYP_HFS) {
bzb = (EBZB *)&map.blk[i].pmBootArgs[0];
bzb->flags.part = macos_order[k++];
if (j == TYP_HFS)
map.hfs_cnt += 1;
}
}
}
return;
}
/*
* Identify the Partition Map entry by Filesystem type, Use and
* assigned name. For MacOS partitions we try to pull up the
* disk partition name; for BSD type partitions we attempt to
* pull up the mount_point which will be assigned by the user.
*/
int
part_type(entry, fstyp, use, name)
int entry;
char *fstyp;
char *use;
char *name;
{
PTYPES *ptr = (PTYPES *)&ptypes;
EBZB *bzb;
int fd;
off_t seek;
char devname[100], macosblk[512];
while (ptr->partype) {
if (strnicmp(ptr->partype, map.blk[entry].pmPartType,
sizeof(map.blk[entry].pmPartType)) == 0) {
strcpy(fstyp, ptr->fstyp);
strncpy(name, map.blk[entry].pmPartType,
sizeof(map.blk[entry].pmPartType));
name[sizeof(map.blk[entry].pmPartType)] = '\0';
strcpy(use, "unknown");
switch (ptr->usable) {
case 2: /* MacOS HFS */
/*
* OK, this is stupid but it's damn nice to know!
*/
snprintf (devname, sizeof(devname), "/dev/r%sc", diskdev);
/*
* Open the disk as a raw device
*/
if ((fd = open(devname, O_RDONLY, 0)) >= 0) {
seek = (off_t)map.blk[entry].pmPyPartStart + (off_t)2;
seek *= (off_t)bsize;
lseek(fd, seek, SEEK_SET);
read(fd, &macosblk, sizeof(macosblk));
macosblk[37+32] = '\0';
bzb = (EBZB *)&map.blk[entry].pmBootArgs[0];
sprintf(name, "%s (%s)", bzb->mount_point,
&macosblk[37]);
}
strcpy (use, "MacOS");
break;
case 3: /* Unix */
bzb = (EBZB *)&map.blk[entry].pmBootArgs[0];
if (bzb->magic == BZB_MAGIC) {
switch (bzb->type) {
case BZB_TYPEFS:
strcpy (fstyp, "4.2BSD");
if (bzb->flags.root && bzb->flags.usr) {
strcpy(use, "Root&Usr");
sprintf(name, "%s", bzb->mount_point);
}
else if (bzb->flags.root) {
strcpy(use, "Root");
sprintf(name, "%s", bzb->mount_point);
}
else if (bzb->flags.usr) {
strcpy(use, "Usr");
sprintf(name, "%s", bzb->mount_point);
}
else {
strcpy (use, "unknown");
*name = '\0';
}
break;
case BZB_TYPESWAP:
strcpy (fstyp, "4.2BSD");
strcpy (use, "swap");
*name = '\0';
break;
default:
break;
}
}
else {
strcpy (use, "unknown");
*name = '\0';
}
break;
default:
break;
}
return (ptr->usable);
}
ptr++;
}
*fstyp = '\0';
*name = '\0';
*use = '\0';
return (0);
}
void
disp_selected_part(sel)
int sel;
{
int i,j;
char name[64], use[16], fstyp[16];
EBZB *bzb;
msg_display_add (MSG_part_head);
for (i=0;i<map.usable_cnt;i++) {
if (i == sel) msg_standout();
j = map.mblk[i];
part_type(j, fstyp, use, name);
bzb = (EBZB *)&map.blk[j].pmBootArgs[0];
msg_printf_add ("%s%c%12d%12d%8s%9s %s\n", diskdev,
bzb->flags.part, map.blk[j].pmPartBlkCnt,
map.blk[j].pmPyPartStart, fstyp, use, name);
if (i == sel) msg_standend();
}
return;
}
/*
* check for any anomolies on the requested setup
*/
int
check_for_errors()
{
int i, j;
int errs = 0;
errs = (!map.root_cnt) || (map.root_cnt > 1) || (!map.swap_cnt) ||
(map.swap_cnt > 1);
for (i=0;i<map.usable_cnt;i++) {
j = map.mblk[i];
if (map.blk[j].pmPyPartStart > dlsize)
errs++;
if ((map.blk[j].pmPyPartStart + map.blk[j].pmPartBlkCnt) > dlsize + 1)
errs++;
}
return(errs);
}
/*
* check for and report anomolies on the requested setup
*/
void
report_errors()
{
int i, j;
int errs = 0;
EBZB *bzb;
if (!map.root_cnt) {
msg_printf_add (" No Disk Partition defined for Root!\n");
errs++;
}
if (map.root_cnt > 1) {
msg_printf_add (" Multiple Disk Partitions defined for Root\n");
errs++;
}
if (!map.swap_cnt) {
msg_printf_add (" No Disk Partition defined for SWAP!\n");
errs++;
}
if (map.swap_cnt > 1) {
msg_printf_add (" Multiple Disk Partitions defined for SWAP\n");
errs++;
}
for (i=0;i<map.usable_cnt;i++) {
j = map.mblk[i];
if (map.blk[j].pmPyPartStart > dlsize) {
bzb = (EBZB *)&map.blk[j].pmBootArgs[0];
msg_printf_add (" Partition %s%c begins beyond end of disk\n",
diskdev, bzb->flags.part);
errs++;
}
if ((map.blk[j].pmPyPartStart + map.blk[j].pmPartBlkCnt) > dlsize) {
bzb = (EBZB *)&map.blk[j].pmBootArgs[0];
msg_printf_add (" Partition %s%c extends beyond end of disk\n",
diskdev, bzb->flags.part);
errs++;
}
}
if (!errs)
msg_printf_add ("** No errors or anomolies found in disk setup.\n");
return;
}
int
edit_diskmap(void)
{
int i;
char fstyp[16], use[16], name[64];
/* Ask full/part */
msg_display (MSG_fullpart, diskdev);
process_menu (MENU_fullpart);
map.selected = 0;
sortmerge();
/* If blowing away the whole disk, let user know if there
* are any active disk partitions */
if (usefull) {
if (map.usable_cnt > (map.root_cnt+map.swap_cnt+map.usr_cnt)) {
msg_display (MSG_ovrwrite);
process_menu (MENU_noyes);
if (!yesno) {
endwin();
return (0);
}
}
/*
* mark all non-reserved partitions as "free"
* then sort and merge the map into something sensible
*/
for (i=0;i<map.size;i++)
if (part_type(i, fstyp, use, name))
strcpy (map.blk[i].pmPartType, "Apple_Free");
sortmerge();
}
process_menu (MENU_editparttable);
return (1);
}
int
md_get_info()
{
struct disklabel disklabel;
int fd, i;
char devname[100];
struct part_map_entry block;
snprintf (devname, sizeof(devname), "/dev/r%sc", diskdev);
/*
* Open the disk as a raw device
*/
fd = open(devname, O_RDONLY, 0);
if (fd < 0) {
endwin();
fprintf (stderr, "Can't open %s\n", devname);
exit(1);
}
/*
* Try to get the default disklabel info for the device
*/
if (ioctl(fd, DIOCGDINFO, &disklabel) == -1) {
endwin();
fprintf (stderr, "Can't read disklabel on %s\n", devname);
close(fd);
exit(1);
}
/*
* Get the disk parameters from the disk driver. It should have
* obained them by querying the disk itself.
*/
bsize = disklabel.d_secsize;
dlcyl = disklabel.d_ncylinders;
dlhead = disklabel.d_ntracks;
dlsec = disklabel.d_nsectors;
/*
* Just in case, initialize the structures we'll need if we
* need to completely initialize the disk.
*/
dlsize = dlsec*dlhead*dlcyl;
new_block0.sbBlkCount = dlsize;
for (i=0;i<NEW_MAP_SIZE;i++) {
if (i > 0)
new_map[i].pmPyPartStart = new_map[i-1].pmPyPartStart +
new_map[i-1].pmPartBlkCnt;
new_map[i].pmDataCnt = new_map[i].pmPartBlkCnt;
if (new_map[i].pmPartBlkCnt) {
new_map[i].pmPartBlkCnt = dlsize;
new_map[i].pmDataCnt = dlsize;
break;
}
dlsize -= new_map[i].pmPartBlkCnt;
}
dlsize = dlsec*dlhead*dlcyl;
#if 0
msg_display(MSG_dldebug, bsize, dlcyl, dlhead, dlsec, dlsize);
process_menu(MENU_ok);
#endif
/*
* Verify the disk has been initialized for MacOS use by checking
* to see if the disk have a Boot Block
*/
if (lseek(fd, (off_t)0 * bsize, SEEK_SET) < 0 ||
read(fd, &block, sizeof(struct part_map_entry)) < sizeof(block) ||
block.pmSig != 0x4552) {
process_menu(MENU_nodiskmap);
}
else {
/*
* Scan for the Partition Map entry that describes the Partition
* Map itself. We need to know the number of blocks allocated
* to it and the number currently in use.
*/
for (i=0;i<MAXMAXPARTITIONS;i++) {
lseek(fd, (off_t)(i+1) * bsize, SEEK_SET);
read(fd, &block, sizeof(struct part_map_entry));
if (strnicmp("Apple_partition_map", block.pmPartType,
sizeof(block.pmPartType)) == 0) {
map.size = block.pmPartBlkCnt;
map.in_use_cnt = block.pmMapBlkCnt;
map.blk = (struct part_map_entry *)malloc(map.size * bsize);
break;
}
}
lseek(fd, (off_t)1 * bsize, SEEK_SET);
read(fd, map.blk, map.size * bsize);
}
close(fd);
/*
* Setup the disktype so /etc/disktab gets proper info
*/
if (strncmp (disk->dd_name, "sd", 2) == 0) {
disktype = "SCSI";
doessf = "sf:";
}
else
disktype = "IDE";
return edit_diskmap();
}
int
md_pre_disklabel()
{
int fd;
char devname[100];
/*
* Danger Will Robinson! We're about to turn that nice MacOS disk
* into an expensive doorstop...
*
* Always remember that this code was written in a town called
* Murphy, so anything that can go wrong will.
*/
printf ("%s", msg_string (MSG_dodiskmap));
snprintf (devname, sizeof(devname), "dev/r%sc", diskdev);
/*
* Open the disk as a raw device
*/
if ((fd = open(devname, O_WRONLY, 0)) < 0) {
endwin();
fprintf(stderr, "Can't open %s to re-write the Disk Map\n", devname);
exit (1);
}
/*
* OK boys and girls, here we go. First check the pmSigPad field of
* the first block in the incore Partition Map. It should be zero,
* but if it's 0xa5a5 that means we need to write out Block0 too.
*/
if (map.blk[0].pmSigPad == 0xa5a5) {
if (lseek (fd, (off_t)0 * bsize, SEEK_SET) < 0) {
endwin();
fprintf (stderr, "Can't position to write Block0\n");
close (fd);
exit (1);
}
if (write (fd, &new_block0, bsize) != bsize) {
endwin();
fprintf (stderr, "I/O error writing Block0\n");
close (fd);
exit (1);
}
map.blk[0].pmSigPad = 0;
}
if (lseek (fd, (off_t)1 * bsize, SEEK_SET) < 0) {
endwin();
fprintf (stderr, "Can't position disk to re-write Disk Map\n");
close (fd);
exit (1);
}
if (write (fd, map.blk, map.size * bsize) != (map.size * bsize)) {
endwin();
fprintf(stderr, "I/O error writing Disk Map\n");
close (fd);
exit (1);
}
/*
* Well, if we get here the dirty deed has been done.
*/
close (fd);
return 0;
}
int
md_post_disklabel(void)
{
return 0;
}
int
md_post_newfs(void)
{
return 0;
}
int
md_copy_filesystem(void)
{
if (target_already_root()) {
return 1;
}
/* Copy the instbin(s) to the disk */
msg_display(MSG_dotar);
if (run_prog (0, 0, NULL, "pax -X -r -w -pe / /mnt") != 0)
return 1;
/* Copy next-stage install profile into target /.profile. */
if (cp_to_target ("/tmp/.hdprofile", "/.profile") != 0)
return 1;
return cp_to_target ("/usr/share/misc/termcap", "/.termcap");
}
int
md_make_bsd_partitions(void)
{
FILE *f;
int i, j, pl;
char fstyp[16], use[16], name[64];
EBZB *bzb;
/*
* Scan for any problems and report them before continuing.
* The user can abort installation and we'll take them back
* to the main menu; continue ignoring the warnings, or
* ask to re-edit the Disk Partition Map.
*/
while (1) {
if (check_for_errors()) {
process_menu (MENU_sanity);
if (yesno < 0)
return (0);
else if (yesno)
break;
edit_diskmap();
} else
break;
}
/* Build standard partitions */
emptylabel(bsdlabel);
/*
* The mac68k port has no predefined partitions, so we'll
* start by setting everything to unused.
*/
for (i=0;i<MAXPARTITIONS;i++) {
bsdlabel[i].pi_size = 0;
bsdlabel[i].pi_offset = 0;
bsdlabel[i].pi_fstype = FS_UNUSED;
bsdlabel[i].pi_bsize = 0;
bsdlabel[i].pi_fsize = 0;
fsmount[i][0] = '\0';
}
/*
* Now, scan through the Disk Partition Map and transfer the
* information into the incore disklabel.
*/
for (i=0;i<map.usable_cnt;i++) {
j = map.mblk[i];
bzb = (EBZB *)&map.blk[j].pmBootArgs[0];
if (bzb->flags.part) {
pl = bzb->flags.part - 'a';
switch (part_type(j, fstyp, use, name)) {
case TYP_HFS:
bsdlabel[pl].pi_fstype = FS_HFS;
strcpy (fsmount[pl], bzb->mount_point);
break;
case TYP_BSD:
switch (bzb->type) {
case BZB_TYPEFS:
bsdlabel[pl].pi_fstype = FS_BSDFFS;
strcpy (fsmount[pl], bzb->mount_point);
break;
case BZB_TYPESWAP:
bsdlabel[pl].pi_fstype = FS_SWAP;
break;
default:
break;
}
break;
default:
break;
}
if (bsdlabel[pl].pi_fstype != FS_UNUSED) {
bsdlabel[pl].pi_size = map.blk[j].pmPartBlkCnt;
bsdlabel[pl].pi_offset = map.blk[j].pmPyPartStart;
if (bsdlabel[pl].pi_fstype != FS_SWAP) {
bsdlabel[pl].pi_bsize = 8192;
bsdlabel[pl].pi_fsize = 1024;
}
}
}
}
/* Disk name - don't bother asking, just use the physical name*/
strcpy (bsddiskname, diskdev);
/* Create the disktab.preinstall */
run_prog (0, 0, NULL, "cp /etc/disktab.preinstall /etc/disktab");
#ifdef DEBUG
f = fopen ("/tmp/disktab", "a");
#else
f = fopen ("/etc/disktab", "a");
#endif
if (f == NULL) {
endwin();
(void) fprintf (stderr, "Could not open /etc/disktab");
exit (1);
}
(void)fprintf (f, "%s|NetBSD installation generated:\\\n", bsddiskname);
(void)fprintf (f, "\t:dt=%s:ty=winchester:\\\n", disktype);
(void)fprintf (f, "\t:nc#%d:nt#%d:ns#%d:\\\n", dlcyl, dlhead, dlsec);
(void)fprintf (f, "\t:sc#%d:su#%d:\\\n", dlhead*dlsec, dlsize);
(void)fprintf (f, "\t:se#%d:%s\\\n", bsize, doessf);
for (i=0; i<8; i++) {
if (bsdlabel[i].pi_fstype == FS_HFS)
(void)fprintf (f, "\t:p%c#%d:o%c#%d:t%c=macos:",
'a'+i, bsdlabel[i].pi_size,
'a'+i, bsdlabel[i].pi_offset,
'a'+i);
else
(void)fprintf (f, "\t:p%c#%d:o%c#%d:t%c=%s:",
'a'+i, bsdlabel[i].pi_size,
'a'+i, bsdlabel[i].pi_offset,
'a'+i, fstypenames[bsdlabel[i].pi_fstype]);
if (bsdlabel[i].pi_fstype == FS_BSDFFS)
(void)fprintf (f, "b%c#%d:f%c#%d",
'a'+i, bsdlabel[i].pi_bsize,
'a'+i, bsdlabel[i].pi_fsize);
if (i < 7)
(void)fprintf (f, "\\\n");
else
(void)fprintf (f, "\n");
}
fclose (f);
/* Everything looks OK. */
return (1);
}
/* Upgrade support */
int
md_update (void)
{
endwin();
md_copy_filesystem ();
md_post_newfs();
puts (CL);
wrefresh(stdscr);
return 1;
}
void
md_cleanup_install(void)
{
char realfrom[STRSIZE];
char realto[STRSIZE];
char sedcmd[STRSIZE];
strncpy(realfrom, target_expand("/etc/rc.conf"), STRSIZE);
strncpy(realto, target_expand("/etc/rc.conf.install"), STRSIZE);
sprintf(sedcmd, "sed 's/rc_configured=NO/rc_configured=YES/' < %s > %s",
realfrom, realto);
if (logging)
(void)fprintf(log, "%s\n", sedcmd);
if (scripting)
(void)fprintf(script, "%s\n", sedcmd);
do_system(sedcmd);
run_prog(1, 0, NULL, "mv -f %s %s", realto, realfrom);
run_prog(0, 0, NULL, "rm -f %s", target_expand("/sysinst"));
run_prog(0, 0, NULL, "rm -f %s", target_expand("/.termcap"));
run_prog(0, 0, NULL, "rm -f %s", target_expand("/.profile"));
}
Reference in New Issue View Git Blame Copy Permalink