Index: md.c =================================================================== RCS file: /cvsroot/basesrc/distrib/utils/sysinst/arch/macppc/md.c,v retrieving revision 1.23 diff -u -r1.23 md.c --- md.c 2002/08/02 05:11:33 1.23 +++ md.c 2002/10/28 10:36:30 @@ -1,11 +1,10 @@ -/* $NetBSD: md.c,v 1.23 2002/08/02 05:11:33 grant Exp $ */ +/* $NetBSD$ */ /* * Copyright 1997 Piermont Information Systems Inc. * All rights reserved. * - * Based on code written by Philip A. Nelson for Piermont Information - * Systems Inc. + * 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 @@ -37,93 +36,897 @@ * */ -/* md.c -- macppc machine specific routines */ +/* md.c -- Machine specific code for macppc */ -#include -#include -#include -#include #include -#include +#include #include #include -#include - +#include #include "defs.h" #include "md.h" #include "msg_defs.h" #include "menu_defs.h" +/* + * Compare lexigraphically two strings + */ +int +stricmp(s1, s2) + const char *s1; + const char *s2; +{ + char c1, c2; + + while (1) { + c1 = tolower(*s1++); + c2 = tolower(*s2++); + if (c1 < c2) return -1; + if (c1 > c2) return 1; + if (c1 == 0) return 0; + } +} + +void +setpartition(part, in_use, slot) + struct part_map_entry *part; + char in_use[]; + int slot; +{ + EBZB *bzb; + + bzb = (EBZB *)&part->pmBootArgs[0]; + in_use[slot] = 1; + bzb->flags.used = 1; + bzb->flags.part = 'a' + slot; +} + +/* + * Find an entry in a use array that is unused and return it or + * -1 if no entry is available + */ +int +getFreeLabelEntry(slots) + char *slots; +{ + int i; + + for ( i = 0; i < MAXPARTITIONS; i++) { + if (i != RAW_PART && slots[i] == 0) + return i; + } + return -1; +} + +/* + * Figure out what type type of the given partition is and return it. + */ +int +whichType(part) + struct part_map_entry *part; +{ + MAP_TYPE *map_entry = (MAP_TYPE *)&map_types; + EBZB *bzb; + char partyp[32]; + int type, maxsiz, entry_type = MAP_OTHER; + + bzb = (EBZB *)&part->pmBootArgs[0]; + if (part->pmSig != PART_ENTRY_MAGIC) + return 0; + maxsiz = sizeof(part->pmPartType); + if (maxsiz > sizeof(partyp)) + maxsiz = sizeof(partyp); + strncpy(partyp, part->pmPartType, maxsiz); + partyp[maxsiz-1] = '\0'; + + /* + * Find out how to treat the partition type under NetBSD + */ + while (map_entry->type != MAP_EOL) { + if (stricmp(map_entry->name, partyp) == 0) { + entry_type = map_entry->type; + break; + } + map_entry++; + } + + /* + * Now classify the use for NetBSD + */ + if (entry_type == MAP_RESERVED) + type = 0; + else if (entry_type == MAP_NETBSD) { + if (bzb->magic != BZB_MAGIC) + type = 0; + else if (bzb->type == BZB_TYPEFS) { + if (bzb->flags.root) + type = ROOT_PART; + else if (bzb->flags.usr) + type = UFS_PART; + else + type = SCRATCH_PART; + } else if (bzb->type == BZB_TYPESWAP) + type = SWAP_PART; + else + type = SCRATCH_PART; + } else if (entry_type == MAP_MACOS) + type = HFS_PART; + else + type = SCRATCH_PART; + return type; +} + +char * +getFstype(part, len_type, type) + struct part_map_entry *part; + int len_type; + char *type; +{ + *type = '\0'; + switch(whichType(part)) { + case ROOT_PART: + case UFS_PART: + strncpy(type, "4.2BSD", len_type); + break; + case SWAP_PART: + strncpy(type, "swap", len_type); + break; + case HFS_PART: + strncpy(type, "HFS", len_type); + break; + case SCRATCH_PART: + default: + break; + } + return (type); +} + +char * +getUse(part, len_use, use) + struct part_map_entry *part; + int len_use; + char *use; +{ + EBZB *bzb; + char partyp[32]; + + *use = '\0'; + bzb = (EBZB *)&part->pmBootArgs[0]; + switch(whichType(part)) { + case ROOT_PART: + if (bzb->flags.usr) + strncpy(use, "Root&Usr", len_use); + else + strncpy(use, "Root", len_use); + break; + case UFS_PART: + strncpy(use, "Usr", len_use); + break; + case SWAP_PART: + break; + case HFS_PART: + strncpy(use, "MacOS", len_use); + break; + case SCRATCH_PART: + strncpy(partyp, part->pmPartType, sizeof(partyp)); + partyp[sizeof(partyp)-1] = '\0'; + if (stricmp("Apple_Free", partyp) == 0) + strncpy(use, "Free", len_use); + else if (stricmp("Apple_Scratch", partyp) == 0) + strncpy(use, "Scratch", len_use); + else if (stricmp("Apple_MFS", partyp) == 0) + strncpy(use, "MFS", len_use); + else if (stricmp("Apple_PRODOS", partyp) == 0) + strncpy(use, "PRODOS", len_use); + else + strncpy(use, "unknown", len_use); + default: + break; + } + return(use); +} + +char * +getName(part, len_name, name) + struct part_map_entry *part; + int len_name; + char *name; +{ + EBZB *bzb; + int fd; + off_t seek; + char devname[100], macosblk[512]; + + *name = '\0'; + bzb = (EBZB *)&part->pmBootArgs[0]; + switch(whichType(part)) { + case SCRATCH_PART: + case ROOT_PART: + case UFS_PART: + strncpy(name, bzb->mount_point, len_name); + break; + case SWAP_PART: + break; + case HFS_PART: + /* + * 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)part->pmPyPartStart + (off_t)2; + seek *= (off_t)bsize; + lseek(fd, seek, SEEK_SET); + read(fd, &macosblk, sizeof(macosblk)); + macosblk[37+32] = '\0'; + strncpy(name, bzb->mount_point, len_name); + strncat(name, " (", len_name-strlen(name)); + strncat(name, &macosblk[37], len_name-strlen(name)); + strncat(name, ")", len_name-strlen(name)); + } + break; + default: + break; + } + return(name); +} + +/* + * Find the first occurance of a Standard Type partition and + * mark it for use along with the default mount slot. + */ +int +findStdType(num_parts, in_use, type, count, alt) + int num_parts; + char in_use[]; + int type; + int *count; + int alt; +{ + EBZB *bzb; + int i; + + for (i = 0; i < num_parts; i++) { + bzb = (EBZB *)&map.blk[i].pmBootArgs[0]; + if (whichType(&map.blk[i]) != type || bzb->flags.used) + continue; + if (type == ROOT_PART) { + if (alt >= 0 && alt != bzb->cluster) + continue; + setpartition(&map.blk[i], in_use, 0); + strcpy (bzb->mount_point, "/"); + *count += 1; + } else if (type == UFS_PART) { + if (alt >= 0 && alt != bzb->cluster) + continue; + setpartition(&map.blk[i], in_use, 6); + if (bzb->mount_point[0] == '\0') + strcpy (bzb->mount_point, "/usr"); + *count += 1; + } else if (type == SWAP_PART) { + setpartition(&map.blk[i], in_use, 1); + *count += 1; + } + return 0; + } + return -1; +} + +/* + * 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) + struct part_map_entry *part; +{ + EBZB *bzb; + + /* + * Clear out the MacOS fields that might be used for booting just + * in case we've clobbered the boot code. + */ + part->pmLgDataStart = 0; + part->pmPartStatus = 0x77; /* make sure the partition shows up */ + part->pmLgBootStart = 0; + part->pmBootSize = 0; + part->pmBootLoad = 0; + part->pmBootLoad2 = 0; + part->pmBootEntry = 0; + part->pmBootEntry2 = 0; + 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 *)&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; + bzb->flags.used = 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 in_use[MAXPARTITIONS]; + int i, j; + EBZB *bzb; + + /* + * Step 1, squeeze out the holes that some disk formatters leave in + * the Map. Also convert any "old" Map entries to the new entry + * type. Also clear out our used flag which is used to indicte + * we've mapped the partition. + */ + map.in_use_cnt = 0; + for (i=0;iflags.used = 0; + bzb->flags.part = 0; + } + } + + /* + * 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.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;iflags.used == 0) { + if ((j = getFreeLabelEntry(in_use)) < 0) + break; + switch (whichType(&map.blk[i])) { + case ROOT_PART: + map.root_cnt += 1; + setpartition(&map.blk[i], in_use, j); + break; + case UFS_PART: + map.usr_cnt += 1; + setpartition(&map.blk[i], in_use, j); + break; + case SWAP_PART: + map.swap_cnt += 1; + setpartition(&map.blk[i], in_use, j); + break; + case HFS_PART: + map.hfs_cnt += 1; + setpartition(&map.blk[i], in_use, j); + break; + case SCRATCH_PART: + setpartition(&map.blk[i], in_use, j); + default: + break; + } + } + } +#if 0 + md_debug_dump("After sort merge"); +#endif + return; +} + +void +disp_selected_part(sel) + int sel; +{ + int i,j; + char fstyp[16], use[16], name[32]; + EBZB *bzb; + + msg_table_add(MSG_part_header); + for (i=0;iflags.part, map.blk[j].pmPyPartStart, + map.blk[j].pmPartBlkCnt, fstyp, use, name); + if (i == sel) msg_standend(); + } + return; +} + +/* + * check for any anomalies 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 dlsize) + errs++; + if ((map.blk[j].pmPyPartStart + map.blk[j].pmPartBlkCnt) > dlsize + 1) + errs++; + } + return(errs); +} + /* - * Symbolic names for disk partitions. + * check for and report anomalies on the requested setup */ -#define PART_ROOT A -#define PART_RAW C -#define PART_USR G +void +report_errors() +{ + int i, j; + int errs = 0; + EBZB *bzb; + + if (!map.root_cnt) { + msg_display_add(MSG_disksetup_no_root); + errs++; + } + if (map.root_cnt > 1) { + msg_display_add(MSG_disksetup_multiple_roots); + errs++; + } + if (!map.swap_cnt) { + msg_display_add(MSG_disksetup_no_swap); + errs++; + } + if (map.swap_cnt > 1) { + msg_display_add(MSG_disksetup_multiple_swaps); + errs++; + } + for (i=0;i dlsize) { + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + msg_display_add(MSG_disksetup_part_beginning, + diskdev, bzb->flags.part); + errs++; + } + if ((map.blk[j].pmPyPartStart + map.blk[j].pmPartBlkCnt) > dlsize) { + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + msg_display_add(MSG_disksetup_part_size, + diskdev, bzb->flags.part); + errs++; + } + } + if (!errs) + msg_display_add(MSG_disksetup_noerrors); + return; +} int +edit_diskmap(void) +{ + int i; + + /* 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 dlsize) - dlsize = disklabel.d_secperunit; - - /* Compute minimum NetBSD partition sizes (in sectors). */ - minfsdmb = (80 + 4*rammb) * (MEG / sectorsize); + dlsize = disklabel.d_secperunit; + for (i=0;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 == 0) { + new_map[i].pmPartBlkCnt = dlsize; + new_map[i].pmDataCnt = dlsize; + break; + } + dlsize -= new_map[i].pmPartBlkCnt; + } + dlsize = disklabel.d_secperunit; +#if 0 + msg_display(MSG_dldebug, bsize, dlcyl, dlhead, dlsec, dlsize); + process_menu(MENU_ok); +#endif + map.size = 0; + /* + * 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;idd_name, "sd", 2) == 0) { + disktype = "SCSI"; + doessf = "sf:"; + } + else + disktype = "IDE"; - return 1; + return edit_diskmap(); } -/* - * hook called before writing new disklabel. - */ int md_pre_disklabel() { - return 0; + int fd; + char devname[100]; + struct disklabel lp; + Block0 new_block0 = {DRIVER_MAP_MAGIC, 512, 0}; + + /* + * Danger Will Robinson! We're about to turn that nice MacOS disk + * into an expensive doorstop... + */ + 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 rewrite the Disk Map\n", devname); + exit (1); + } + /* + * 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); + } + new_block0.sbBlkCount = dlsize; /* Set disk size */ + 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 rewrite 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); + } + fsync(fd); + /* + * Well, if we get here the dirty deed has been done. + * + * Now we need to force the incore disk table to get updated. This + * should be done by disklabel -- which is normally called right after + * we return -- but may be commented out for the mac68k port. We'll + * instead update the incore table by forcing a dummy write here. This + * relies on a change in the mac68k-specific writedisklabel() routine. + * If that change doesn't exist nothing bad happens here. If disklabel + * properly updates the ondisk and incore labels everything still + * works. Only if we fail here and if disklabel fails are we in + * in a state where we've updated the disk but not the incore and + * a reboot is necessary. + * + * First, we grab a copy of the incore label as it existed before + * we did anything to it. Then we invoke the "write label" ioctl to + * rewrite it to disk. As a result, the ondisk partition map is + * re-read and the incore label is reconstructed from it. If + * disklabel() is then called to update again, either that fails + * because the mac68k port doesn't support native disklabels, or it + * succeeds and writes out a new ondisk copy. + */ + ioctl(fd, DIOCGDINFO, &lp); /* Get the current disk label */ + ioctl(fd, DIOCWDINFO, &lp); /* Write it out again */ + + close (fd); + return 0; } -/* - * hook called after writing disklabel to new target disk. - */ int md_post_disklabel(void) { - return 0; + struct disklabel updated_label; + int fd, i, no_match; + char devname[100], buf[80]; + char *fst[] = {"free", "swap", " v6 ", " v7 ", "sysv", "v71k", + " v8 ", "ffs ", "dos ", "lfs ", "othr", "hpfs", + "9660", "boot", "ados", "hfs ", "fcor", "ex2f", + "ntfs", "raid", "ccd "}; + + snprintf(devname, sizeof(devname), "/dev/r%sc", diskdev); + /* + * Open the disk as a raw device + */ + if ((fd = open(devname, O_RDONLY, 0)) < 0) + return 0; + /* + * Get the "new" label to see if we were successful. If we aren't + * we'll return an error to keep from destroying the user's disk. + */ + ioctl(fd, DIOCGDINFO, &updated_label); + close(fd); + /* + * Make sure the in-core label matches the on-disk one + */ + no_match = 0; + for (i=0;i updated_label.d_npartitions) + break; + if (bsdlabel[i].pi_size != updated_label.d_partitions[i].p_size) + no_match = 1; + if (bsdlabel[i].pi_size) { + if (bsdlabel[i].pi_offset != updated_label.d_partitions[i].p_offset) + no_match = 1; + if (bsdlabel[i].pi_fstype != updated_label.d_partitions[i].p_fstype) + no_match = 1; + } + if (no_match) + break; + } + /* + * If the labels don't match, tell the user why + */ + if (no_match) { + msg_clear(); + msg_display(MSG_label_error); + msg_table_add(MSG_dump_line, + " in-core: offset size type on-disk: offset size type"); + for (i=0;iflags.part; + if (type < 'a' || type > 'h') type = '?'; + if (j == 0) strcpy (name, "reserved for Apple"); + sprintf(buf, " %02d:%c %08x %8s %10s %s", i+1, type, + map.blk[i].pmPyPartStart, fstyp, use, name); + msg_table_add(MSG_dump_line, buf); + } + process_menu(MENU_okabort); + msg_clear(); + return(yesno); +} + /* * MD hook called after upgrade() or install() has finished setting * up the target disk but immediately before the user is given the @@ -134,7 +937,7 @@ * On the macppc, we use this opportunity to install the boot blocks. */ int -md_post_newfs() +md_post_newfs(void) { const char *bootfile = "/boot"; @@ -142,213 +945,153 @@ cp_to_target("/usr/mdec/ofwboot", bootfile); sync(); run_prog(RUN_DISPLAY, NULL, "/usr/sbin/installboot /dev/r%sa %s %s", - diskdev, "/usr/mdec/bootxx", bootfile); + diskdev, "/usr/mdec/bootxx", bootfile); return 0; } -/* - * some ports use this to copy the MD filesystem, we do not. - */ int -md_copy_filesystem() +md_copy_filesystem(void) { + if (target_already_root()) { + return 1; + } + return 0; } + + int -md_make_bsd_partitions() +md_make_bsd_partitions(void) { - int i, part; - int remain; - char isize[20]; - int maxpart = getmaxpartitions(); - - /* - * Initialize global variables that track space used on this disk. - * Standard 4.3BSD 8-partition labels always cover whole disk. - */ - ptsize = dlsize - ptstart; - fsdsize = dlsize; /* actually means `whole disk' */ - fsptsize = dlsize - ptstart; /* netbsd partition -- same as above */ - fsdmb = fsdsize / MEG; - - /* Ask for layout type -- standard or special */ - msg_display (MSG_layout, - (1.0*fsptsize*sectorsize)/MEG, - (1.0*minfsdmb*sectorsize)/MEG, - (1.0*minfsdmb*sectorsize)/MEG+rammb+XNEEDMB); - process_menu (MENU_layout); + FILE *f; + int i, j, pl; + EBZB *bzb; - if (layoutkind == 3) { - ask_sizemult(dlcylsize); - } else { - sizemult = MEG / sectorsize; - multname = msg_string(MSG_megname); + /* + * 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 reedit 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); - /* Partitions C is predefined (whole disk). */ - bsdlabel[C].pi_fstype = FS_UNUSED; - bsdlabel[C].pi_offset = 0; - bsdlabel[C].pi_size = dlsize; - - /* Standard fstypes */ - bsdlabel[A].pi_fstype = FS_BSDFFS; - bsdlabel[A].pi_bsize = 8192; - bsdlabel[A].pi_fsize = 1024; - bsdlabel[B].pi_fstype = FS_SWAP; - /* Conventionally, C is whole disk. */ - bsdlabel[D].pi_fstype = FS_UNUSED; /* fill out below */ - bsdlabel[E].pi_fstype = FS_UNUSED; - bsdlabel[F].pi_fstype = FS_UNUSED; - bsdlabel[G].pi_fstype = FS_UNUSED; - bsdlabel[H].pi_fstype = FS_UNUSED; - part = D; - - - switch (layoutkind) { - case 1: /* standard: a root, b swap, c "unused", d /usr */ - case 2: /* standard X: a root, b swap (big), c "unused", d /usr */ - partstart = ptstart; - - /* Root */ - /* By convention, NetBSD/macppc uses a 32Mbyte root */ - partsize= NUMSEC(32, MEG/sectorsize, dlcylsize); - bsdlabel[A].pi_offset = partstart; - bsdlabel[A].pi_size = partsize; - bsdlabel[A].pi_bsize = 8192; - bsdlabel[A].pi_fsize = 1024; - strcpy (fsmount[A], "/"); - partstart += partsize; - - /* swap */ - i = NUMSEC(layoutkind * 2 * (rammb < 32 ? 32 : rammb), - MEG/sectorsize, dlcylsize) + partstart; - partsize = NUMSEC (i/(MEG/sectorsize)+1, MEG/sectorsize, - dlcylsize) - partstart; - bsdlabel[B].pi_offset = partstart; - bsdlabel[B].pi_size = partsize; - partstart += partsize; - - /* /usr */ - partsize = fsdsize - partstart; - bsdlabel[PART_USR].pi_fstype = FS_BSDFFS; - bsdlabel[PART_USR].pi_offset = partstart; - bsdlabel[PART_USR].pi_size = partsize; - bsdlabel[PART_USR].pi_bsize = 8192; - bsdlabel[PART_USR].pi_fsize = 1024; - strcpy (fsmount[PART_USR], "/usr"); - - break; - - case 3: /* custom: ask user for all sizes */ - ask_sizemult(dlcylsize); - /* root */ - partstart = ptstart; - remain = fsdsize - partstart; - /* By convention, NetBSD/macppc uses a 32Mbyte root */ - partsize = NUMSEC (32, MEG/sectorsize, dlcylsize); - snprintf (isize, 20, "%d", partsize/sizemult); - msg_prompt (MSG_askfsroot, isize, isize, 20, - remain/sizemult, multname); - partsize = NUMSEC(atoi(isize),sizemult, dlcylsize); - bsdlabel[A].pi_offset = partstart; - bsdlabel[A].pi_size = partsize; - bsdlabel[A].pi_bsize = 8192; - bsdlabel[A].pi_fsize = 1024; - strcpy (fsmount[A], "/"); - partstart += partsize; - - /* swap */ - remain = fsdsize - partstart; - i = NUMSEC(2 * (rammb < 32 ? 32 : rammb), - MEG/sectorsize, dlcylsize) + partstart; - partsize = NUMSEC (i/(MEG/sectorsize)+1, MEG/sectorsize, - dlcylsize) - partstart; - snprintf (isize, 20, "%d", partsize/sizemult); - msg_prompt_add (MSG_askfsswap, isize, isize, 20, - remain/sizemult, multname); - partsize = NUMSEC(atoi(isize),sizemult, dlcylsize); - bsdlabel[B].pi_offset = partstart; - bsdlabel[B].pi_size = partsize; - partstart += partsize; - - /* /usr */ - remain = fsdsize - partstart; - if (remain > 0) { - partsize = fsdsize - partstart; - snprintf (isize, 20, "%d", partsize/sizemult); - msg_prompt_add (MSG_askfsusr, isize, isize, 20, - remain/sizemult, multname); - partsize = NUMSEC(atoi(isize),sizemult, dlcylsize); - if (remain - partsize < sizemult) - partsize = remain; - bsdlabel[PART_USR].pi_fstype = FS_BSDFFS; - bsdlabel[PART_USR].pi_offset = partstart; - bsdlabel[PART_USR].pi_size = partsize; - bsdlabel[PART_USR].pi_bsize = 8192; - bsdlabel[PART_USR].pi_fsize = 1024; - strcpy (fsmount[PART_USR], "/usr"); - partstart += partsize; - } - - /* Others ... */ - remain = fsdsize - partstart; - part = F; - if (remain > 0) - msg_display (MSG_otherparts); - while (remain > 0 && part <= H) { - partsize = fsdsize - partstart; - snprintf (isize, 20, "%d", partsize/sizemult); - msg_prompt_add (MSG_askfspart, isize, isize, 20, - diskdev, partition_name(part), - remain/sizemult, multname); - partsize = NUMSEC(atoi(isize),sizemult, dlcylsize); - if (remain - partsize < sizemult) - partsize = remain; - bsdlabel[part].pi_fstype = FS_BSDFFS; - bsdlabel[part].pi_offset = partstart; - bsdlabel[part].pi_size = partsize; - bsdlabel[part].pi_bsize = 8192; - bsdlabel[part].pi_fsize = 1024; - msg_prompt_add (MSG_mountpoint, NULL, - fsmount[part], 20); - partstart += partsize; - remain = fsdsize - partstart; - part++; - } - - break; + /* + * The macppc port has a predefined partition for "c" which + * is the size of the disk, everything else is unused. + */ + for (i=0;iflags.part) { + pl = bzb->flags.part - 'a'; + switch (whichType(&map.blk[j])) { + case HFS_PART: + bsdlabel[pl].pi_fstype = FS_HFS; + strcpy (fsmount[pl], bzb->mount_point); + break; + case ROOT_PART: + case UFS_PART: + bsdlabel[pl].pi_fstype = FS_BSDFFS; + strcpy (fsmount[pl], bzb->mount_point); + break; + case SWAP_PART: + bsdlabel[pl].pi_fstype = FS_SWAP; + break; + case SCRATCH_PART: + bsdlabel[pl].pi_fstype = FS_OTHER; + strcpy (fsmount[pl], bzb->mount_point); + 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 */ - msg_prompt (MSG_packname, "mydisk", bsddiskname, DISKNAME_SIZE); + /* Disk name - don't bother asking, just use the physical name*/ + strcpy (bsddiskname, diskdev); - /* save label to disk for MI code to update. */ - (void) savenewlabel(bsdlabel, 8); /* 8 partitions in label */ + /* Create the disktab.preinstall */ + run_prog (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() +md_update (void) { - endwin(); md_copy_filesystem (); md_post_newfs(); @@ -359,16 +1102,32 @@ return 1; } + void -md_cleanup_install() +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); + scripting_fprintf(log, "%s\n", sedcmd); + do_system(sedcmd); + + run_prog(RUN_FATAL, NULL, "mv -f %s %s", realto, realfrom); + run_prog(0, NULL, "rm -f %s", target_expand("/sysinst")); + run_prog(0, NULL, "rm -f %s", target_expand("/.termcap")); + run_prog(0, NULL, "rm -f %s", target_expand("/.profile")); } int md_pre_update() { - return 1; + return 0; } void Index: md.h =================================================================== RCS file: /cvsroot/basesrc/distrib/utils/sysinst/arch/macppc/md.h,v retrieving revision 1.7 diff -u -r1.7 md.h --- md.h 2001/11/29 23:20:59 1.7 +++ md.h 2002/10/28 10:36:32 @@ -1,17 +1,16 @@ -/* $NetBSD: md.h,v 1.7 2001/11/29 23:20:59 thorpej Exp $ */ +/* $NetBSD$ */ /* * Copyright 1997 Piermont Information Systems Inc. * All rights reserved. * - * Based on code written by Philip A. Nelson for Piermont Information - * Systems Inc. + * 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. @@ -37,21 +36,218 @@ * */ +#include + /* md.h -- Machine specific definitions for the macppc */ + +/* + * Apple Partition Map Types + * Reserved - Entry hidden by sysinst from user + * NetBSD - Entry used for NetBSD + * MacOS - Entry used for MacOS and mapped to NetBSD + * Other - Entry use unknown, mapped for scratch. This may + * include partitions used by other systems (Linux). + */ +#define MAP_EOL 0 +#define MAP_RESERVED 1 +#define MAP_NETBSD 2 +#define MAP_MACOS 3 +#define MAP_OTHER 4 + +typedef struct { + int type; /* Entry type from above */ + char *name; /* Partition Type string */ +} MAP_TYPE; + +/* + * Define Apple Partition Map types typically seen on 68k Macs + * This should match the definitions in include/machine/disklabel.h + * and must conform to the matching rules in arch/macppc/macppc/disksubr.c + */ +EXTERN MAP_TYPE map_types[] +#ifdef MAIN += { + {MAP_RESERVED, PART_TYPE_DRIVER}, + {MAP_RESERVED, PART_TYPE_DRIVER43}, + {MAP_RESERVED, PART_TYPE_DRIVERATA}, + {MAP_RESERVED, PART_TYPE_DRIVERIOKIT}, + {MAP_RESERVED, PART_TYPE_FWDRIVER}, + {MAP_RESERVED, PART_TYPE_FWB_COMPONENT}, + {MAP_OTHER, PART_TYPE_FREE}, + {MAP_MACOS, PART_TYPE_MAC}, + {MAP_MACOS, PART_TYPE_APPLEUFS}, + {MAP_NETBSD, PART_TYPE_NETBSD}, + {MAP_RESERVED, PART_TYPE_NBSD_PPCBOOT}, + {MAP_RESERVED, PART_TYPE_NBSD_68KBOOT}, + {MAP_RESERVED, PART_TYPE_PATCHES}, + {MAP_RESERVED, PART_TYPE_PARTMAP}, + {MAP_OTHER, PART_TYPE_SCRATCH}, + {MAP_OTHER, PART_TYPE_BOOT}, + {MAP_OTHER, PART_TYPE_LOADER}, + {MAP_NETBSD, PART_TYPE_UNIX}, + {MAP_OTHER, PART_TYPE_LINUX}, + {MAP_OTHER, PART_TYPE_LINUX_SWAP}, + {MAP_EOL, NULL} +} +#endif +; + +/* + * Define NetBSD partition types + */ +#define ROOT_PART 1 +#define UFS_PART 2 +#define SWAP_PART 3 +#define HFS_PART 4 +#define SCRATCH_PART 5 + +EXTERN int bcyl, bhead, bsec, bsize, bcylsize; +EXTERN int part[4][5] INIT({{0}}); +EXTERN int bsdpart; /* partition in use by NetBSD */ +EXTERN int usefull; /* on install, clobber entire disk */ -/* Constants and defines */ +typedef struct { + int size; /* number of blocks in map for I/O */ + int in_use_cnt; /* number of block in current use in map */ + int usable_cnt; /* number of partitions usable by NetBSD */ + int hfs_cnt; /* number of MacOS partitions found */ + int root_cnt; /* number of root partitions in map */ + int swap_cnt; /* number of swap partitions in map */ + int usr_cnt; /* number of usr partitions in map */ + int selected; /* current partition selection in mblk */ + int mblk[MAXPARTITIONS];/* map block number of usable partition */ + struct part_map_entry *blk; +} MAP; +/* + * Define the default size for the Disk Partition Map if we have to + * write one to the disk. It should be a power of two minus one for + * the Block0 block, i.e. 7, 15, 31, 63. + */ +#define NEW_MAP_SIZE 15 + +EXTERN MAP map +#ifdef MAIN += {0, 0, 0, 0, 0, 0, 0, 0, {0}} +#endif +; + +int edit_diskmap (void); +void disp_selected_part (int sel); +int whichType(struct part_map_entry *); +char *getFstype(struct part_map_entry *, int, char *); +char *getUse(struct part_map_entry *, int, char *); +char *getName(struct part_map_entry *, int, char *); +int stricmp(const char *c1, const char *c2); +int getFreeLabelEntry(char *); +int findStdType(int, char *, int, int *, int); +void setpartition(struct part_map_entry *, char *, int); +void sortmerge(void); +void reset_part_flags(struct part_map_entry *); +int check_for_errors(void); +void report_errors(void); +void set_fdisk_info (void); /* write incore info into disk */ +int get_diskmap_info (void); +void md_select_kernel(void); +int md_debug_dump(char *); + +/* constants and defines */ + +/* + * The Block Zero Block is stored in the Partition Map Entry in the + * pmPad (or pmBootArgs) area. The current NetBSD definition of this + * area is incomplete, so we have our own local definition here. + */ +typedef struct { + u_int32_t magic; /* magic number that identifes Block Zero Block */ + u_int8_t cluster; /* Autorecovery cluster grouping */ + u_int8_t type; /* 1=>Std FS, 2=>Autorecovery FS, 3=>SWAP FS */ + u_int16_t inode; /* bad block inode number */ + struct { + unsigned int root : 1; /* FS contains a Root FS */ + unsigned int usr : 1; /* FS contains a Usr FS */ + unsigned int crit : 1; /* FS contains a "Critical"? FS */ + unsigned int used : 1; /* FS in use */ + unsigned int : 7; + unsigned int slice : 5; /* Slice number to assocate with plus one */ + unsigned int part : 16; /* reserved, but we'll hide disk part here */ + } flags; + u_int32_t tmade; /* time FS was created */ + u_int32_t tmount; /* time of last mount */ + u_int32_t tumount; /* time of last umount */ + struct { + u_int32_t size; /* size of map in bytes */ + u_int32_t ents; /* number of used entries */ + u_int32_t start; /* start of cltblk map */ + } abm; /* altblk map */ + u_int32_t filler[7]; /* reserved for abm expansion */ + u_int8_t mount_point[64]; /* mount point for the FS */ +} EBZB; + +/* + * Also define Block 0 on the device. We only use this when we have to + * initialize the entire disk and then we really only care about the + * Signature word, but someday someone might want to fill in other + * parts. + */ +typedef struct { + unsigned short sbSig; /* unique value for SCSI block 0 */ + unsigned short sbBlkSize; /* block size of device */ + unsigned long sbBlkCount; /* number of blocks on device */ + unsigned short sbDevType; /* device type */ + unsigned short sbDevId; /* device id */ + unsigned long sbData; /* not used */ + unsigned short sbDrvrCount; /* driver descriptor count */ + unsigned long ddBlock; /* 1st driver's starting block */ + unsigned short ddSize; /* size of 1st driver (512-byte blks) */ + unsigned short ddType; /* system type (1 for Mac+) */ + unsigned short ddPad[243]; /* ARRAY[0..242] OF INTEGER; not used */ +} Block0; + +/* + * Default Disk Partition Map used for an uninitilized disk. + * Has minimal entry for an old Apple SCSI driver, a newer 43 SCSI + * driver and an IDE driver (for those Macs with IDE). + */ +EXTERN struct part_map_entry new_map[] +#ifdef MAIN += { + {PART_ENTRY_MAGIC, 0xa5a5, 6, 1, NEW_MAP_SIZE & 0x7e, "Apple", + "Apple_Partition_Map", 0,NEW_MAP_SIZE, 0x37}, + {PART_ENTRY_MAGIC, 0, 6, 64, 32, "Macintosh", "Apple_Driver", 0,0,0x37}, + {PART_ENTRY_MAGIC, 0, 6, 96, 64, "Macintosh", "Apple_Driver43", 0,0,0x37}, + {PART_ENTRY_MAGIC, 0, 6, 160, 64, "Macintosh", "Apple_Driver_ATA", 0,0,0x37}, + {PART_ENTRY_MAGIC, 0, 6, 224, 4096, "untitled", "Apple_HFS", 0,0,0x37}, + {PART_ENTRY_MAGIC, 0, 6,4320, 0, "untitled", "Apple_Free", 0,0,0x37} +} +#endif +; + /* Megs required for a full X installation. */ -#define XNEEDMB 35 /* XXXTHORPEJ */ +#define XNEEDMB 35 /* XXXTHORPEJ */ + +/* Disk names. */ +EXTERN char *disk_names[] +#ifdef MAIN += {"wd", "sd", NULL} +#endif +; +/* Legal start character for a disk for checking input. */ +#define ISDISKSTART(dn) (dn == 'w' || dn == 's') + /* - * Default filesets to fetch and install during installation - * or upgrade. + * Machine-specific command to write a new label to a disk. + * If not defined, we assume the port does not support disklabels and + * the hand-edited disklabel will NOT be written by MI code. */ +#define DISKLABEL_CMD "disklabel -w -r" + +/* Definition of files to retrieve from ftp. */ EXTERN distinfo dist_list[] #ifdef MAIN = { - {"kern-GENERIC", 1, NULL, "Kernel : "}, + {"kern-GENERIC", 0, NULL, "Kernel : "}, {"base", 1, NULL, "Base : "}, {"etc", 1, NULL, "System (/etc): "}, {"comp", 1, NULL, "Compiler : "}, @@ -71,30 +267,12 @@ #endif ; -/* - * Disk names accepted as valid targets for a from-scratch installation. - */ -EXTERN char *disk_names[] -#ifdef MAIN -= {"sd", "wd", NULL} -#endif -; - /* - * Legal start character for a disk for checking input. - * this must return 1 for a character that matches the first - * characters of each member of disk_names. + * Default fileystem type for floppy disks. */ -#define ISDISKSTART(dn) (dn == 's' || dn == 'w') +EXTERN char *fdtype INIT("msdos"); /* - * Machine-specific command to write a new label to a disk. - * If not defined, we assume the port does not support disklabels and - * the hand-edited disklabel will NOT be written by MI code. + * prototypes for MD code. */ -#define DISKLABEL_CMD "disklabel -w -r" -/* - * Default file system type for floppies. - */ -EXTERN char *fdtype INIT("msdos"); Index: menus.md.en =================================================================== RCS file: /cvsroot/basesrc/distrib/utils/sysinst/arch/macppc/menus.md.en,v retrieving revision 1.15 diff -u -r1.15 menus.md.en --- menus.md.en 2001/11/29 23:20:59 1.15 +++ menus.md.en 2002/10/28 10:36:33 @@ -1,11 +1,10 @@ -/* $NetBSD: menus.md.en,v 1.15 2001/11/29 23:20:59 thorpej Exp $ */ +/* $NetBSD$ */ /* * Copyright 1997 Piermont Information Systems Inc. * All rights reserved. * - * Based on code written by Philip A. Nelson for Piermont Information - * Systems Inc. + * 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 @@ -37,9 +36,304 @@ * */ -/* macppc machine dependent menus, english */ +/* Menu definitions for sysinst. macppc version, machine dependent. */ -menu editfsparts, y=12, exit; +menu fullpart, title "Select your choice"; + option "Use only part of the disk", exit, action {usefull = 0;}; + option "Use the entire disk", exit, action {usefull = 1;}; + +menu nodiskmap, title "Choose an option", y=16; + display action { msg_display (MSG_nodiskmap, diskdev); }; + option "Abort install", exit, action { + endwin(); exit(1); + }; + option "Initialize Disk partition Map", exit, action { + int i; + + msg_clear(); + msg_display (MSG_okwritediskmap); + process_menu (MENU_okabort); + if (!yesno) { + endwin(); + return 0; + } + map.size = NEW_MAP_SIZE; + map.in_use_cnt = new_map[0].pmMapBlkCnt; + map.blk = (struct part_map_entry *)calloc(map.size, + sizeof(struct part_map_entry)); + for (i=0;i= map.usable_cnt) + map.selected = 0; + disp_selected_part (map.selected); + }; + option "Select next partition", action { + map.selected += 1; + if (map.selected >= map.usable_cnt) + map.selected = 0; + }; + option "Change selected partition", sub menu chooseid; + option "Set mount point for partition", sub menu mount_point; + option "Split selected partition", action { + int i, j, k, size, free_size; + char buf[40]; + EBZB *bzb; + + j = map.mblk[map.selected]; + msg_display(MSG_split_part, map.blk[j].pmPartBlkCnt); + msg_prompt_add (MSG_scratch_size, NULL, buf, sizeof(buf)); + size = atoi(buf); + if (size > 0 && size < map.blk[j].pmPartBlkCnt) { + k = map.in_use_cnt+1; + if (k <= map.size) { + memcpy (&map.blk[k], &map.blk[j], + sizeof(struct part_map_entry)); + free_size = map.blk[j].pmPartBlkCnt - size; + strcpy (map.blk[j].pmPartType, "Apple_Scratch"); + map.blk[j].pmPartBlkCnt = size; + map.blk[j].pmDataCnt = size; + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + bzb->magic = 0; + bzb->mount_point[0] = '\0'; + strcpy (map.blk[k].pmPartType, "Apple_Free"); + map.blk[k].pmPyPartStart += size; + if ((map.blk[k].pmPyPartStart + free_size) > dlsize) + map.blk[k].pmPartBlkCnt = + dlsize - map.blk[k].pmPyPartStart; + else + map.blk[k].pmPartBlkCnt = free_size; + map.blk[k].pmDataCnt = map.blk[k].pmPartBlkCnt; + bzb = (EBZB *)&map.blk[k].pmBootArgs[0]; + bzb->magic = 0; + bzb->mount_point[0] = '\0'; + map.in_use_cnt += 1; /* Count new part as usable */ + sortmerge(); + } else { + msg_display (MSG_diskfull); + process_menu (MENU_okabort); + if (!yesno) { + free (map.blk); + map.size = NEW_MAP_SIZE; + map.in_use_cnt = new_map[0].pmMapBlkCnt; + map.blk = (struct part_map_entry *)calloc(map.size, + sizeof(struct part_map_entry)); + for (i=0;iflags.part, + map.blk[i].pmPyPartStart, + map.blk[i].pmPartBlkCnt); + if ((map.blk[i].pmPyPartStart + + map.blk[i].pmPartBlkCnt) > dlsize) { + msg_display_add(MSG_parttable_fix_fixing, + diskdev, bzb->flags.part); + map.blk[i].pmPartBlkCnt = + dlsize - map.blk[i].pmPyPartStart; + map.blk[i].pmDataCnt = + map.blk[i].pmPartBlkCnt; + } else { + msg_display_add(MSG_parttable_fix_fine, + diskdev, bzb->flags.part); + } + process_menu(MENU_ok); + }; + + +menu ok2, title "Abort?", y=17; + option "OK", exit, action { }; + +menu okabort, title "What do you want to do?", y=17; + option "Continue", exit, action { yesno = 1; }; + option "Abort install", exit, action { yesno = 0; }; + +menu chooseid, title "Partition Type?"; + option "NetBSD Root", exit, action { + int i, j; + EBZB *bzb; + + j = map.mblk[map.selected]; + reset_part_flags(&map.blk[j]); + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + bzb->magic = BZB_MAGIC; + strcpy (map.blk[j].pmPartName, "NetBSD Root"); + strcpy (map.blk[j].pmPartType, "Apple_Unix_SVR2"); + bzb->type = BZB_TYPEFS; + bzb->flags.root = 1; + /* + * Automatically determine root mount points. The first + * root-type filesystem is mounted on "/", all others + * will mount on "/altroot". If there are multiple + * occurances of "/altroot" they will be picked up on + * the sanity_scan in the next step of the installation. + */ + for (i=0,map.root_cnt=0;itype == BZB_TYPEFS && bzb->flags.root) { + if (map.root_cnt++ == 0) + strcpy (bzb->mount_point, "/"); + else + strcpy (bzb->mount_point, "/altroot"); + } + } + } }; + option "NetBSD SWAP", exit, action { + int j; + EBZB *bzb; + + j = map.mblk[map.selected]; + reset_part_flags(&map.blk[j]); + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + bzb->magic = BZB_MAGIC; + strcpy (map.blk[j].pmPartName, "NetBSD SWAP"); + strcpy (map.blk[j].pmPartType, "Apple_Unix_SVR2"); + bzb->type = BZB_TYPESWAP; }; + option "NetBSD Usr", exit, action { + int j; + EBZB *bzb; + + j = map.mblk[map.selected]; + reset_part_flags(&map.blk[j]); + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + bzb->magic = BZB_MAGIC; + strcpy (map.blk[j].pmPartName, "NetBSD Usr"); + strcpy (map.blk[j].pmPartType, "Apple_Unix_SVR2"); + bzb->type = BZB_TYPEFS; + bzb->flags.usr = 1; + if (map.usr_cnt++ == 0) + strcpy (bzb->mount_point, "/usr"); + }; + option "NetBSD Root&Usr", exit, action { + int j; + EBZB *bzb; + + j = map.mblk[map.selected]; + reset_part_flags(&map.blk[j]); + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + bzb->magic = BZB_MAGIC; + strcpy (map.blk[j].pmPartName, "NetBSD Root & Usr"); + strcpy (map.blk[j].pmPartType, "Apple_Unix_SVR2"); + bzb->type = BZB_TYPEFS; + bzb->flags.root = 1; + bzb->flags.usr = 1; + if (map.root_cnt++ == 0) + strcpy (bzb->mount_point, "/"); + else { + if (map.usr_cnt++ == 0) + strcpy (bzb->mount_point, "/usr"); + } }; + option "MacOS HFS", exit, action { + int j; + EBZB *bzb; + + j = map.mblk[map.selected]; + reset_part_flags(&map.blk[j]); + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + bzb->magic = 0; + bzb->mount_point[0] = '\0'; + strcpy (map.blk[j].pmPartName, "untitled (HFS)"); + strcpy (map.blk[j].pmPartType, "Apple_HFS"); }; + option "Scratch", exit, action { + int j; + EBZB *bzb; + + j = map.mblk[map.selected]; + reset_part_flags(&map.blk[j]); + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + bzb->magic = 0; + bzb->mount_point[0] = '\0'; + strcpy (map.blk[j].pmPartName, "untitled (Scratch)"); + strcpy (map.blk[j].pmPartType, "Apple_Scratch"); }; + option "Free", exit, action { + int j; + EBZB *bzb; + + j = map.mblk[map.selected]; + reset_part_flags(&map.blk[j]); + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + bzb->magic = 0; + bzb->mount_point[0] = '\0'; + strcpy (map.blk[j].pmPartName, "untitled (Free)"); + strcpy (map.blk[j].pmPartType, "Apple_Free"); }; + +menu mount_point, title "Mount Point?"; + option "/usr", exit, action { + int j; + EBZB *bzb; + + j = map.mblk[map.selected]; + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + strcpy (bzb->mount_point, "/usr"); }; + option "/home", exit, action { + int j; + EBZB *bzb; + + j = map.mblk[map.selected]; + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + strcpy (bzb->mount_point, "/home"); }; + option "/var", exit, action { + int j; + EBZB *bzb; + + j = map.mblk[map.selected]; + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + strcpy (bzb->mount_point, "/var"); }; + option "/tmp", exit, action { + int j; + EBZB *bzb; + + j = map.mblk[map.selected]; + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + strcpy (bzb->mount_point, "/tmp"); }; + option "None", exit, action { + int j; + EBZB *bzb; + + j = map.mblk[map.selected]; + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + bzb->mount_point[0] = '\0'; }; + option "other", exit, action { + int j; + char buf[60]; + EBZB *bzb; + + msg_display (MSG_custom_mount_point); + msg_prompt_add (MSG_mountpoint, NULL, buf, sizeof(buf)); + j = map.mblk[map.selected]; + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + if (buf[0] != '\0') { + bzb->mount_point[0] = '\0'; + if (buf[0] != '/') + strcpy (bzb->mount_point, "/"); + strcat(bzb->mount_point, buf); + } }; + +menu sanity, title "Choose an option"; + display action {msg_display (MSG_sanity_check); + report_errors(); }; + option "Abort installation", exit, action {yesno = -1; }; + option "Ignore warnings and continue", exit, action {yesno = 1;}; + option "Re-edit Disk Partition Map", exit, action {yesno = 0; }; + +/* + * This menu shouldn't be used in the macppc port, but it needs to be + * defined because it's referenced from the toplevel code. + */ +menu editfsparts, y=13, exit; display action { ask_sizemult(dlcylsize); msg_display(MSG_fspart, multname); @@ -47,27 +341,26 @@ }; option "Change a", action { editpart = A;}, sub menu edfspart; option "Change b", action { editpart = B;}, sub menu edfspart; - option "Whole disk - can't change", action {}; - option "Change d", action { editpart = D;}, sub menu edfspart; option "Change e", action { editpart = E;}, sub menu edfspart; option "Change f", action { editpart = F;}, sub menu edfspart; option "Change g", action { editpart = G;}, sub menu edfspart; option "Change h", action { editpart = H;}, sub menu edfspart; option "Set new allocation size", action { reask_sizemult(dlcylsize); }; - + menu md_distcustom, x=26, y=5, exit, title "Selection toggles inclusion"; display action { show_cur_distsets (); }; option "Kernel (GENERIC)", action { toggle_getit (0); }; - option "Base", action { toggle_getit (1); }; - option "System (/etc)", action { toggle_getit (2); }; - option "Compiler Tools", action { toggle_getit (3); }; - option "Games", action { toggle_getit (4); }; - option "Online Manual Pages", action { toggle_getit (5); }; - option "Miscellaneous", action { toggle_getit (6); }; - option "Text Processing Tools", action { toggle_getit (7); }; - option "X11 base and clients", action { toggle_getit (8); }; - option "X11 fonts", action { toggle_getit (9); }; - option "X11 servers", action { toggle_getit (10); }; - option "X contrib clients", action { toggle_getit (11); }; - option "X11 programming", action { toggle_getit (12); }; - option "X11 Misc.", action { toggle_getit (13); }; + option "Kernel (GENERICSBC)", action { toggle_getit (1); }; + option "Base", action { toggle_getit (2); }; + option "System (/etc)", action { toggle_getit (3); }; + option "Compiler Tools", action { toggle_getit (4); }; + option "Games", action { toggle_getit (5); }; + option "Online Manual Pages", action { toggle_getit (6); }; + option "Miscellaneous", action { toggle_getit (7); }; + option "Text Processing Tools", action { toggle_getit (8); }; + option "X11 base and clients", action { toggle_getit (9); }; + option "X11 fonts", action { toggle_getit (10); }; + option "X11 servers", action { toggle_getit (11); }; + option "X contrib clients", action { toggle_getit (12); }; + option "X11 programming", action { toggle_getit (13); }; + option "X11 Misc.", action { toggle_getit (14); }; Index: menus.md.pl =================================================================== RCS file: /cvsroot/basesrc/distrib/utils/sysinst/arch/macppc/menus.md.pl,v retrieving revision 1.2 diff -u -r1.2 menus.md.pl --- menus.md.pl 2002/04/09 19:48:09 1.2 +++ menus.md.pl 2002/10/28 10:36:36 @@ -1,13 +1,10 @@ -/* $NetBSD: menus.md.pl,v 1.2 2002/04/09 19:48:09 hubertf Exp $ */ -/* Based on english version: */ -/* NetBSD: menus.md.en,v 1.15 2001/11/29 23:20:59 thorpej Exp */ +/* $NetBSD$ */ /* * Copyright 1997 Piermont Information Systems Inc. * All rights reserved. * - * Based on code written by Philip A. Nelson for Piermont Information - * Systems Inc. + * 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 @@ -39,9 +36,294 @@ * */ -/* macppc machine dependent menus, Polish */ +/* Menu definitions for sysinst. macppc version, machine dependent. */ -menu editfsparts, y=12, exit; +menu fullpart, title "Wybierz"; + option "Uzyj tylko czesci dysku", exit, action {usefull = 0;}; + option "Uzyj calego dysku", exit, action {usefull = 1;}; + +menu nodiskmap, title "Wybierz opcje", y=16; + display action { msg_display (MSG_nodiskmap, diskdev); }; + option "Przerwij instalacje", exit, action { + endwin(); { exit(1); + }; + option "Zainicjuj Mape partycji Dysku", exit, action { + int i; + + msg_clear(); + msg_display (MSG_okwritediskmap); + process_menu (MENU_okabort); + if (!yesno) { + endwin(); + return 0; + } + map.size = NEW_MAP_SIZE; + map.in_use_cnt = new_map[0].pmMapBlkCnt; + map.blk = (struct part_map_entry *)calloc(map.size, + sizeof(struct part_map_entry)); + for (i=0;i= map.usable_cnt) + map.selected = 0; + disp_selected_part (map.selected); + }; + option "Wybierz nastepna partycje", action { + map.selected += 1; + if (map.selected >= map.usable_cnt) + map.selected = 0; + }; + option "Zmien wybrana partycje", sub menu chooseid; + option "Ustaw punkt montazu dla partycji", sub menu mount_point; + option "Podziel wybrana partycje", action { + int i, j, k, size, free_size; + char buf[40]; + + j = map.mblk[map.selected]; + msg_display(MSG_split_part, map.blk[j].pmPartBlkCnt); + msg_prompt_add (MSG_scratch_size, NULL, buf, sizeof(buf)); + size = atoi(buf); + if (size > 0 && size < map.blk[j].pmPartBlkCnt) { + k = map.in_use_cnt+1; + if (k <= map.size) { + memcpy (&map.blk[k], &map.blk[j], + sizeof(struct part_map_entry)); + free_size = map.blk[j].pmPartBlkCnt - size; + strcpy (map.blk[j].pmPartType, "Apple_Scratch"); + map.blk[j].pmPartBlkCnt = size; + map.blk[j].pmDataCnt = size; + strcpy (map.blk[k].pmPartType, "Apple_Free"); + map.blk[k].pmPyPartStart += size; + if ((map.blk[k].pmPyPartStart + free_size) > dlsize) + map.blk[k].pmPartBlkCnt = + dlsize - map.blk[k].pmPyPartStart; + else + map.blk[k].pmPartBlkCnt = free_size; + map.blk[k].pmDataCnt = map.blk[k].pmPartBlkCnt; + map.in_use_cnt += 1; + } else { + msg_display (MSG_diskfull); + process_menu (MENU_okabort); + if (!yesno) { + free (map.blk); + map.size = NEW_MAP_SIZE; + map.in_use_cnt = new_map[0].pmMapBlkCnt; + map.blk = (struct part_map_entry *)calloc(map.size, + sizeof(struct part_map_entry)); + for (i=0;iflags.part, + map.blk[i].pmPyPartStart, + map.blk[i].pmPartBlkCnt); + if ((map.blk[i].pmPyPartStart + + map.blk[i].pmPartBlkCnt) > dlsize) { + msg_display_add(MSG_parttable_fix_fixing, + diskdev, bzb->flags.part); + map.blk[i].pmPartBlkCnt = + dlsize - map.blk[i].pmPyPartStart; + map.blk[i].pmDataCnt = + map.blk[i].pmPartBlkCnt; + } else { + msg_display_add(MSG_parttable_fix_fine, + diskdev, bzb->flags.part); + } + process_menu(MENU_ok); + }; + + + + +menu okabort, title "Co chcesz zrobic?"; + option "OK", exit, action { yesno = 1; }; + option "Przerwac instalacje", exit, action { yesno = 0; }; + +menu chooseid, title "Rodzaj partycji?"; + option "NetBSD Root", exit, action { + int i, j; + char fstyp[16], use[16], name[64]; + EBZB *bzb; + + j = map.mblk[map.selected]; + reset_part_flags(j); + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + bzb->magic = BZB_MAGIC; + strcpy (map.blk[j].pmPartName, "NetBSD Root"); + strcpy (map.blk[j].pmPartType, "Apple_Unix_SVR2"); + bzb->type = BZB_TYPEFS; + bzb->flags.root = 1; + /* + * Automatically determine root mount points. The first + * root-type filesystem is mounted on "/", all others + * will mount on "/altroot". If there are multiple + * occurances of "/altroot" they will be picked up on + * the sanity_scan in the next step of the installation. + */ + for (i=0,map.root_cnt=0;itype == BZB_TYPEFS && bzb->flags.root) { + if (map.root_cnt++ == 0) + strcpy (bzb->mount_point, "/"); + else + strcpy (bzb->mount_point, "/altroot"); + } + } + } }; + option "NetBSD SWAP", exit, action { + int j; + EBZB *bzb; + + j = map.mblk[map.selected]; + reset_part_flags(j); + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + bzb->magic = BZB_MAGIC; + strcpy (map,blk[j].pmPartName, "NetBSD SWAP"); + strcpy (map.blk[j].pmPartType, "Apple_Unix_SVR2"); + bzb->type = BZB_TYPESWAP; }; + option "NetBSD Usr", exit, action { + int j; + EBZB *bzb; + + j = map.mblk[map.selected]; + reset_part_flags(j); + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + bzb->magic = BZB_MAGIC; + strcpy (map.blk[j].pmPartName, "NetBSD Usr"); + strcpy (map.blk[j].pmPartType, "Apple_Unix_SVR2"); + bzb->type = BZB_TYPEFS; + bzb->flags.usr = 1; + if (!map.usr_cnt) + strcpy (bzb->mount_point, "/usr"); + }; + option "NetBSD Root&Usr", exit, action { + int j; + EBZB *bzb; + + j = map.mblk[map.selected]; + reset_part_flags(j); + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + bzb->magic = BZB_MAGIC; + strcpy (map.blk[j].pmPartName, "NetBSD Root & Usr"); + strcpy (map.blk[j].pmPartType, "Apple_Unix_SVR2"); + bzb->type = BZB_TYPEFS; + bzb->flags.root = 1; + bzb->flags.usr = 1; + if (!map.root_cnt) + strcpy (bzb->mount_point, "/"); + else { + if (!map.usr_cnt) + strcpy (bzb->mount_point, "/usr"); + } }; + option "MacOS HFS", exit, action { + int j; + EBZB *bzb; + + j = map.mblk[map.selected]; + reset_part_flags(j); + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + bzb->mount_point[0] = '\0'; + strcpy (map.blk[j].pmPartName, "untitled (HFS)"); + strcpy (map.blk[j].pmPartType, "Apple_HFS"); }; + option "Scratch", exit, action { + int j; + EBZB *bzb; + + j = map.mblk[map.selected]; + reset_part_flags(j); + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + bzb->mount_point[0] = '\0'; + strcpy (map.blk[j].pmPartName, "untitled (Scratch)"); + strcpy (map.blk[j].pmPartType, "Apple_Scratch"); }; + option "Free", exit, action { + int j; + EBZB *bzb; + + j = map.mblk[map.selected]; + reset_part_flags(j); + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + bzb->mount_point[0] = '\0'; + strcpy (map.blk[j].pmPartName, "untitled (Free)"); + strcpy (map.blk[j].pmPartType, "Apple_Free"); }; + +menu mount_point, title "Punkt montazu?"; + option "/usr", exit, action { + int j; + EBZB *bzb; + + j = map.mblk[map.selected]; + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + strcpy (bzb->mount_point, "/usr"); }; + option "/home", exit, action { + int j; + EBZB *bzb; + + j = map.mblk[map.selected]; + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + strcpy (bzb->mount_point, "/home"); }; + option "/var", exit, action { + int j; + EBZB *bzb; + + j = map.mblk[map.selected]; + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + strcpy (bzb->mount_point, "/var"); }; + option "/tmp", exit, action { + int j; + EBZB *bzb; + + j = map.mblk[map.selected]; + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + strcpy (bzb->mount_point, "/tmp"); }; + option "Zaden", exit, action { + int j; + EBZB *bzb; + + j = map.mblk[map.selected]; + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + bzb->mount_point[0] = '\0'; }; + option "inny", exit, action { + int j; + char buf[60]; + EBZB *bzb; + + msg_display (MSG_custom_mount_point); + msg_prompt_add (MSG_mountpoint, NULL, buf, sizeof(buf)); + j = map.mblk[map.selected]; + bzb = (EBZB *)&map.blk[j].pmBootArgs[0]; + if (buf[0] != '\0') { + bzb->mount_point[0] = '\0'; + if (buf[0] != '/') + strcpy (bzb->mount_point, "/"); + strcat(bzb->mount_point, buf); + } }; + +menu sanity, title "Wybierz opcje"; + display action {msg_display (MSG_sanity_check); + report_errors(); }; + option "Przerwij instalacje", exit, action {yesno = -1; }; + option "Zignoruj ostrzezenia i kontynuuj", exit, action {yesno = 1;}; + option "Ponownie wyedytuj mape partycji dysku", exit, action {yesno = 0; }; + +/* + * This menu shouldn't be used in the macppc port, but it needs to be + * defined because it's referenced from the toplevel code. + */ + +menu editfsparts, y=13, exit; display action { ask_sizemult(dlcylsize); msg_display(MSG_fspart, multname); @@ -49,27 +331,26 @@ }; option "Zmien a", action { editpart = A;}, sub menu edfspart; option "Zmien b", action { editpart = B;}, sub menu edfspart; - option "Caly dysk - nie mozna zmienic", action {}; - option "Zmien d", action { editpart = D;}, sub menu edfspart; option "Zmien e", action { editpart = E;}, sub menu edfspart; option "Zmien f", action { editpart = F;}, sub menu edfspart; option "Zmien g", action { editpart = G;}, sub menu edfspart; option "Zmien h", action { editpart = H;}, sub menu edfspart; option "Ustaw nowy przydzial rozmiarow", action { reask_sizemult(dlcylsize); }; - + menu md_distcustom, x=26, y=5, exit, title "Wybierz"; display action { show_cur_distsets (); }; - option "Kernel (GENERIC)", action { toggle_getit (0); }; - option "Base", action { toggle_getit (1); }; - option "System (/etc)", action { toggle_getit (2); }; - option "Compiler Tools", action { toggle_getit (3); }; - option "Games", action { toggle_getit (4); }; - option "Online Manual Pages", action { toggle_getit (5); }; - option "Miscellaneous", action { toggle_getit (6); }; - option "Text Processing Tools", action { toggle_getit (7); }; - option "X11 base and clients", action { toggle_getit (8); }; - option "X11 fonts", action { toggle_getit (9); }; - option "X11 servers", action { toggle_getit (10); }; - option "X contrib clients", action { toggle_getit (11); }; - option "X11 programming", action { toggle_getit (12); }; - option "X11 Misc.", action { toggle_getit (13); }; + option "Kernel (GENERIC)", action { toggle_getit (0); }; + option "Kernel (GENERICSBC)", action { toggle_getit (1); }; + option "Base", action { toggle_getit (2); }; + option "System (/etc)", action { toggle_getit (3); }; + option "Compiler Tools", action { toggle_getit (4); }; + option "Games", action { toggle_getit (5); }; + option "Online manual pages", action { toggle_getit (6); }; + option "Miscellaneous", action { toggle_getit (7); }; + option "Text Processing Tools", action { toggle_getit (8); }; + option "X11 base and clients", action { toggle_getit (9); }; + option "X11 fonts", action { toggle_getit (10); }; + option "X11 servers", action { toggle_getit (11); }; + option "X contrib clients", action { toggle_getit (12); }; + option "X11 programming", action { toggle_getit (13); }; + option "X11 Misc.", action { toggle_getit (14); }; Index: msg.md.en =================================================================== RCS file: /cvsroot/basesrc/distrib/utils/sysinst/arch/macppc/msg.md.en,v retrieving revision 1.5 diff -u -r1.5 msg.md.en --- msg.md.en 2000/12/03 01:54:48 1.5 +++ msg.md.en 2002/10/28 10:36:37 @@ -1,11 +1,10 @@ -/* $NetBSD: msg.md.en,v 1.5 2000/12/03 01:54:48 minoura Exp $ */ +/* $NetBSD$ */ /* * Copyright 1997 Piermont Information Systems Inc. * All rights reserved. * - * Based on code written by Philip A. Nelson for Piermont Information - * Systems Inc. + * 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 @@ -37,12 +36,14 @@ * */ -/* macppc machine dependent messages, english */ +/* MD Message catalog -- english, macppc version */ - message md_hello -{If you booted from a floppy, you may now remove the disk. +{ +} +message dobootblks +{Installing boot blocks on %s.... } message fullpart @@ -51,32 +52,189 @@ Which would you like to do? } -message dobootblks -{Installing boot blocks on %s.... +message nodiskmap +{It appears that your disk, %s, has not been formatted and initialized +for use on MacOS. This program gets the disk layout of your disk by +reading the Disk Partition Map which is written by the disk formatter +when it prepared the disk for use with the Macintosh system. Your +options are: + +* Abort the install. You can format and define a preliminary +partition structure with any disk formatter. Partitions do not +have to be defined as A/UX types; the NetBSD install process will +allow you to redefine them as necessary. + +* Allow sysinst to initialize the Disk Partition Map for you. The +disk will not be MacOS bootable and may not be usable by MacOS unless +MacOS drivers are installed with a MacOS compatible disk formatter. + } -message askfsroot -{I will be asking for partition sizes and on some, mount points. +message okwritediskmap +{Sysinst will attempt to initialize your disk with a new Disk Partition +Map using values obtained from the disk driver. This default Map will +include a minimal Block0 definition, a Partition Map allowing for up to +15 disk partitions, and pre-defined partitions for the Map, disk drivers, +and a minimal MacOS HFS partition. The rest of the disk will be marked +as available for use. The disk driver partitions will not be initialized +so the volume will not be MacOS bootable. If you choose to proceed from +this point with the installation you may edit this new partition map to +suit your NetBSD needs. The Map will not be written to the disk until +you have completed your partition setups. + +Shall we continue?} + +message part_header +{Part start size fstype use mount point (name) +---- ---------- ---------- ------ --------- ------------------\n} + +message part_row +{%3s%c %10d %10d %6s %-9s %s\n} + +message ovrwrite +{Your disk currently has at least one MacOS HFS/HFS+ partition. Overwriting +the entire disk will delete the partition and may make the disk unusable +under MacOS/MacOSX. You should consider creating a single small HFS/HFS+ +partition to insure that the disk can be mounted under MacOS/MacOSX. -First the root partition. You have %d %s left on your disk. -Root partition size? } +Are you really sure you want to overwrite the MacOS HFS/HFS+ partition(s)? +} -message askfsswap -{ -Next the swap partition. You have %d %s left on your disk. -Swap partition size? } +message editparttable +{Edit Disk Partition Map: The Map on the disk has been scanned for all +user-level partitions, but only those usable by NetBSD are displayed. +The partition table currently looks like: -message askfsusr -{ -Next the /usr partition. You have %d %s left on your disk. -/usr partition size? } +} + +message split_part +{The disk partition you have selected will be split into two partitions. +One will be an Apple_Scratch type partition and the other an Apple_Free +type partition. You may then change either of the partitions into one of +another type. If the Apple_Free part is physically adjacent to another +partition which is also an Apple_Free type, the two will be automatically +merged into a single Apple_Free type partition. + +There are %d disk blocks in the selected partition. Enter the number +of disk blocks you would like allocated to the Apple_Scratch partition. +Entering a value of zero, or a value greater than the number available +will leave the selected partition unchanged. + +} + +message scratch_size +{Size of the Apple_Scratch part of the split} + +message diskfull +{You have tried to split an existing disk partition into two parts but +there is no room in the Disk Partition Map to map the second part. This +is probably because your disk formatter didn't reserve additional space +in the original Disk Partition Map for future modifications such as this. +Your options at this point are: + +* Abandon any hope of splitting this partition, with the present +Disk Partition Map, or + +* Allow sysinst to install a new Disk Map on your disk. This will +destroy all existing data on all partitions on the volume. USE WITH CARE! + +Would you like to Abandon splitting this partition?} + +message custom_mount_point +{Specify a Mount Point for the currently selected disk partition. This +should be a unique name, starting with a "/", which is not being used +for any other partition. + +} + +message sanity_check +{In setting up the disklabel for your volume the following anomalies were +found. You may choose to ignore these and continue, but doing so may result +in an installation failure. The following problems were found: + +} -message otherparts -{You still have some space remaining unallocated on your disk. Please -give sizes and mount points for the following partitions. +message dodiskmap +{Setting up the Disk Partition Map ... +} + +message label_error +{The new on-disk partition label does not match the one currently in-core. +Any attempt to proceed will most likely result in damage to any pre-existing +disk partitions. However your new Disk Partition Map has been written to +the disk and will be available the next time NetBSD is booted. Please +reboot immediately and restart the Installation Process. +} + +message mapdebug +{Partition Map: +HFS count: %d +Root count: %d +Swap count: %d +Usr count: %d +Usable count: %d +} + +message dldebug +{Disklabel: +bsize: %d +dlcyl: %d +dlhead: %d +dlsec: %d +dlsize: %d +} + +message partdebug +{Partition %s%c: +Offset: %d +Size: %d +} + +message newfsdebug +{Running newfs on partition: %s\n +} + +message geomdebug +{Calling: %s %s\n +} +message geomdebug2 +{Calling: %s %d\n" } + +message disksetup_no_root +{* No Disk Partition defined for Root!\n} + +message disksetup_multiple_roots +{* Multiple Disk Partitions defined for Root\n} + +message disksetup_no_swap +{* No Disk Partition defined for SWAP!\n} + +message disksetup_multiple_swaps +{* Multiple Disk Partitions defined for SWAP\n} + +message disksetup_part_beginning +{* Partition %s%c begins beyond end of disk\n} -message askfspart -{The next partition is /dev/%s%c. You have %d %s left on your disk. -Partition size? } +message disksetup_part_size +{* Partition %s%c extends beyond end of disk\n} + +message disksetup_noerrors +{** No errors or anomalies found in disk setup.\n} + +message parttable_fix_fixing +{Fixing partition %s%c\n} + +message parttable_fix_fine +{Partition %s%c is just fine!\n} + +message dump_line +{%s\n} + +message emulbackup +{Either the /emul/aout or /emul directory on your system was a symbolic link +pointing to an unmounted file system. It has been given a '.old' extension. +Once you bring your upgraded system back up, you may need to take care +of merging the newly created /emul/aout directory with the old one. +} Index: msg.md.pl =================================================================== RCS file: /cvsroot/basesrc/distrib/utils/sysinst/arch/macppc/msg.md.pl,v retrieving revision 1.2 diff -u -r1.2 msg.md.pl --- msg.md.pl 2002/04/09 19:48:09 1.2 +++ msg.md.pl 2002/10/28 10:36:38 @@ -1,13 +1,10 @@ -/* $NetBSD: msg.md.pl,v 1.2 2002/04/09 19:48:09 hubertf Exp $ */ -/* Based on english version: */ -/* NetBSD: msg.md.en,v 1.5 2000/12/03 01:54:48 minoura Exp */ +/* $NetBSD$ */ /* * Copyright 1997 Piermont Information Systems Inc. * All rights reserved. * - * Based on code written by Philip A. Nelson for Piermont Information - * Systems Inc. + * 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 @@ -39,46 +36,185 @@ * */ -/* macppc machine dependent messages, Polish */ +/* MD Message catalog -- Polish, i386 version */ - message md_hello -{Jesli uruchomiles komputer z dyskietki, mozesz ja teraz wyciagnac. +{ +} +message dobootblks +{Installing boot blocks on %s.... } message fullpart -{Zainstalujemy teraz NetBSD na dysku %s. Mozesz wybrac czy chcesz +{Zainstalujemy teraz NetBSD na dysku %s. Mozesz wybrac, czy chcesz zainstalowac NetBSD na calym dysku, czy tylko na jego czesci. + Ktora instalacje chcesz zrobic? } -message dobootblks -{Instalowanie bootblokow na %s.... +message nodiskmap +{Wyglada na to, ze twoj dysk %s, nie zostal sformatowany i zainicjalizowany +do uzycia z MacOS. Ten program pobiera strukture twojego dysku poprzez +czytanie Mapy Partycji Dysku ktora jest zapisana przez program, ktory +przygotowal dysk do uzycia z systemem Macintosh. Twoje mozliwosci to: + +* Przerwac instalacje. Mozesz sformatowac dysk i zdefiniowac strukture +partycji z jakimkolwiek programem. Partycje nie musza byc zdefiniowane +jako A/UX; Proces instalacji NetBSD pozwoli ci na ich zredefiniowanie +jesli bedzie to potrzebne. + +* Pozwolic aby sysinst zainicjowal Mape Partycji Dysku dla ciebie. +Spowoduje to, ze dysk nie bedzie bootowalny ani uzyteczny pod MacOS. } -message askfsroot -{Bede pytal o rozmiary partcyji, a na niektorych o punkty montazu. +message okwritediskmap +{Sysinst sprobuje zainicjalizowac twoj dysk z nowa Mapa Partycji Dysku +uzywajac wartosci pobranych ze sterownika dysku. Ta domyslna Mapa +bedzie zawierala minimalna definicje Bloku0, Mape Partycji pozwalajaca +na maskymalnie 15 partycji dyskowych, oraz pre-definiowane partycje +dla Mapy, sterownikow dysku, oraz minimalna partycje HFS MacOS. Reszta +dysku zostanie oznaczona jako dostepna do uzycia. Partycje sterownikow dysku +nie zostana zainicjowane, wiec wolumin nie bedzie bootowalny dla MacOS. +Jesli bedziesz kontynuowal, bedziesz mogl wyedytowac nowa mape partycji +aby odpowiadala ona twoim potrzebom dla NetBSD. Mapa nie zostanie zapisana +na dysk, dopoki nie ukonczysz ustawiania partycji. + +Kontynuowac?} + +message part_header +{Part przesun rozmiar FStype uzycie punk montazu (nazwa) +---- ---------- ---------- ------ --------- ------------------\n} + +message part_row +{%3s%c %-10d %-10d %-6s %-9s %s\n} + +message ovrwrite +{Twoj dysk posiada aktualnie przynajmniej jedna partycje HFS MacOS. +Nadpisywanie calego dysku spowoduje usuniecie partycji, co moze +spowodowac ze dysk stanie sie nie uzyteczny pod MacOS. Powinienes +rozwazyc utworzenie osobnej malej partycji HFS MacOS, aby upewnic +sie, ze bedziesz mogl zamontowac dysk pod MacOS. Byloby to dobre +miejsce na trzymanie kopii bootloadera NetBSD/macppc. -Najpierw partcyja glowna. Masz %d %s wolnego miejsca na dysku. -Rozmiar partycji glownej? } +Czy napewno chcesz nadpisac partycje MacOS HFS? +} -message askfsswap -{ -Nastepnie partycja wymiany. Masz %d %s wolnego miejsca na dysku. -Rozmiar partycji wymiany? } +message editparttable +{Edycja Mapy Partycji Dysku: Mapa na dysku zostala przeszukana pod katem +wszystkich partycji uzytkownika, ale tylko te uzyteczne w NetBSD, zostaly +wyswietlone. +Aktualna tablica partycji wyglada tak: -message askfsusr -{ -Nastepnie partycja /usr. Masz %d %s wolnego miejsca na dysku. -Rozmiar partycji /usr? } +} + +message split_part +{Partycje, ktore wybrales zostana podzielone na dwie partycje. +Jedna bedzie partycja Apple_Scratch, a druga Apple_Free. +Jesli czesc Apple_Free fizycznie sasiaduje z inna partycja ktora jest +take typu Apple_Free, obie zostana automatycznie polaczone w jedna +typu Apple_Free. Mozesz pozniej zmienic ja w partycje innego typu. + +Wybrana partycja ma %s blokow. Wprowadz ilosc blokow, ktore chcialbys +zaalokowac dla partycji Apple_Scratch. Jesli podasz 0 lub wartosc wieksza +niz dozwolona, partycje pozostanie bez zmian. + +} + +message scratch_size +{Rozmiar podzielonej czesci Apple_Scratch} + +message diskfull +{Probowales podzielic istniejaca partycje na dwie czesci, ale nie ma na to +miejsca w Mapie Partycji Dysku. Jest to prawdopodobnie spowodowane tym, ze +twoj program formatujacy nie zarezerwowal dodatkowej przestrzeni w +oryginalnej Mapie Partycji Dysku na przyszle modyfikacje takie jak ta. +Mozesz teraz: + +* Porzucic nadzieje na podzielenie tej partycji, z aktualna +Mapa Partycji Dysku, lub +* Pozwolic aby sysinst zainstalowal Nowa Mape na dysku. Spowoduje to +utrate wszystkich danych na wszystkich partycjach. UZYWAJ Z UWAGA! + +Czy chcesz zrezygnowac z podzialu tej partycji?} + +message custom_mount_point +{Podaj Punkt Montazu dla aktualnie wybranej partycji. Powinna byc to +unikalna nazwa, zaczynajaca sie od "/", ktora nie jest juz uzywana +przez inna partycje. + +} + +message sanity_check +{W trakcie konfigurowania twojego dysku zostaly znalezione nastepujace +anomalie. Mozesz je zignorowac i kontynuowac, ale zrobienie tego moze +spowodowac nie powodzenie instalacji. Oto problemy, ktore wystapily: + +} + +message dodiskmap +{Konfigurowanie Mapy Partycji Dysku ... +} + +message mapdebug +{Mapa partycji: +HFS count: %d +Root count: %d +Swap count: %d +Usr count: %d +Usable count: %d +} + +message dldebug +{Disklabel: +bsize: %d +dlcyl: %d +dlhead: %d +dlsec: %d +dlsize: %d +} + +message partdebug +{Partycja %s%c: +Przesuniecie: %d +Rozmiar: %d +} + +message newfsdebug +{Uruchamianie newfs na partycji: %s\n +} -message otherparts -{Nadal masz wolna przestrzen na dysku. Podaj rozmiary i punkty montazu -dla ponizszych partycji. +message geomdebug +{Wywolywanie: %s %s\n +} +message geomdebug2 +{Wywolywanie: %s %d\n" } + +message disksetup_no_root +{* Nie zdefiniowano partycji dla Root!\n} + +message disksetup_multiple_roots +{* Zdefiniowano kilka partycji dla Root\n} + +message disksetup_no_swap +{* Nie zdefiniowano partycji dla SWAP!\n} + +message disksetup_multiple_swaps +{* Zdefiniowano kilka partycji dla SWAP\n} + +message disksetup_part_beginning +{* Partycja %s%c zaczyna sie poza koncem dysku\n} + +message disksetup_part_size +{* Partycja %s%c wykracza poza koniec dysku\n} + +message disksetup_noerrors +{** Nie znaleziono bledow lub anomali na dyskach.\n} + +message parttable_fix_fixing +{Naprawianie partycji %s%c\n} -message askfspart -{Nastepna partycja jest /dev/%s%c. Masz %d %s wolnego miejsca na dysku. -Rozmiar partycji? } +message parttable_fix_fine +{Partycja %s%c jest w porzadku!\n}