1995-05-04 23:36:23 +00:00
|
|
|
/*
|
|
|
|
* The new sysinstall program.
|
|
|
|
*
|
|
|
|
* This is probably the last program in the `sysinstall' line - the next
|
|
|
|
* generation being essentially a complete rewrite.
|
|
|
|
*
|
1997-05-10 17:11:24 +00:00
|
|
|
* $Id: disks.c,v 1.84 1997/05/05 05:16:00 pst Exp $
|
1995-05-04 23:36:23 +00:00
|
|
|
*
|
|
|
|
* Copyright (c) 1995
|
|
|
|
* Jordan Hubbard. All rights reserved.
|
|
|
|
*
|
|
|
|
* 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
|
1995-05-30 08:29:07 +00:00
|
|
|
* notice, this list of conditions and the following disclaimer,
|
|
|
|
* verbatim and that no modifications are made prior to this
|
1995-05-04 23:36:23 +00:00
|
|
|
* point in the file.
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY JORDAN HUBBARD ``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 JORDAN HUBBARD OR HIS PETS 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, LIFE 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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "sysinstall.h"
|
1995-05-05 23:47:47 +00:00
|
|
|
#include <ctype.h>
|
1995-05-06 09:34:24 +00:00
|
|
|
#include <sys/disklabel.h>
|
1995-05-05 23:47:47 +00:00
|
|
|
|
1995-05-16 02:53:31 +00:00
|
|
|
/* Where we start displaying chunk information on the screen */
|
|
|
|
#define CHUNK_START_ROW 5
|
1995-05-08 00:38:02 +00:00
|
|
|
|
1995-05-16 02:53:31 +00:00
|
|
|
/* Where we keep track of MBR chunks */
|
1995-12-07 10:34:59 +00:00
|
|
|
static struct chunk *chunk_info[16];
|
1995-05-05 23:47:47 +00:00
|
|
|
static int current_chunk;
|
|
|
|
|
|
|
|
static void
|
1995-05-16 02:53:31 +00:00
|
|
|
record_chunks(Disk *d)
|
1995-05-05 23:47:47 +00:00
|
|
|
{
|
1996-10-03 06:01:44 +00:00
|
|
|
struct chunk *c1 = NULL;
|
1995-05-16 02:53:31 +00:00
|
|
|
int i = 0;
|
|
|
|
int last_free = 0;
|
1996-10-03 06:01:44 +00:00
|
|
|
|
1995-05-16 02:53:31 +00:00
|
|
|
if (!d->chunks)
|
|
|
|
msgFatal("No chunk list found for %s!", d->name);
|
1996-10-03 06:01:44 +00:00
|
|
|
|
1995-12-07 10:34:59 +00:00
|
|
|
for (c1 = d->chunks->part; c1; c1 = c1->next) {
|
1995-05-16 02:53:31 +00:00
|
|
|
if (c1->type == unused && c1->size > last_free) {
|
|
|
|
last_free = c1->size;
|
|
|
|
current_chunk = i;
|
1995-05-05 23:47:47 +00:00
|
|
|
}
|
1995-05-16 02:53:31 +00:00
|
|
|
chunk_info[i++] = c1;
|
1995-05-05 23:47:47 +00:00
|
|
|
}
|
1995-05-16 02:53:31 +00:00
|
|
|
chunk_info[i] = NULL;
|
1996-10-06 11:40:31 +00:00
|
|
|
if (current_chunk >= i)
|
|
|
|
current_chunk = i - 1;
|
1995-05-07 23:37:34 +00:00
|
|
|
}
|
|
|
|
|
1996-10-06 11:40:31 +00:00
|
|
|
static int Total;
|
|
|
|
|
1995-05-05 23:47:47 +00:00
|
|
|
static void
|
1995-05-16 02:53:31 +00:00
|
|
|
print_chunks(Disk *d)
|
1995-05-05 23:47:47 +00:00
|
|
|
{
|
1995-05-16 02:53:31 +00:00
|
|
|
int row;
|
1996-10-06 11:40:31 +00:00
|
|
|
int i;
|
1995-05-05 23:47:47 +00:00
|
|
|
|
1996-10-06 11:40:31 +00:00
|
|
|
for (i = Total = 0; chunk_info[i]; i++)
|
|
|
|
Total += chunk_info[i]->size;
|
1996-11-27 22:52:34 +00:00
|
|
|
if (d->bios_cyl > 65536 || d->bios_hd > 256 || d->bios_sect >= 64) {
|
1996-08-03 10:11:56 +00:00
|
|
|
dialog_clear_norefresh();
|
1996-07-31 06:20:59 +00:00
|
|
|
msgConfirm("WARNING: A geometry of %d/%d/%d for %s is incorrect. Using\n"
|
1996-11-27 22:52:34 +00:00
|
|
|
"a more likely geometry. If this geometry is incorrect or you\n"
|
|
|
|
"are unsure as to whether or not it's correct, please consult\n"
|
|
|
|
"the Hardware Guide in the Documentation submenu or use the\n"
|
1997-03-11 16:27:25 +00:00
|
|
|
"(G)eometry command to change it now.\n\n"
|
|
|
|
"Remember: you need to enter whatever your BIOS thinks the\n"
|
1997-04-20 16:46:36 +00:00
|
|
|
"geometry is! For IDE, it's what you were told in the BIOS\n"
|
|
|
|
"setup. For SCSI, it's the translation mode your controller is\n"
|
1997-03-11 16:27:25 +00:00
|
|
|
"using. Do NOT use a ``physical geometry''.",
|
1996-11-27 22:52:34 +00:00
|
|
|
d->bios_cyl, d->bios_hd, d->bios_sect, d->name);
|
|
|
|
Sanitize_Bios_Geom(d);
|
1995-12-07 10:34:59 +00:00
|
|
|
}
|
1995-05-05 23:47:47 +00:00
|
|
|
attrset(A_NORMAL);
|
1995-05-16 02:53:31 +00:00
|
|
|
mvaddstr(0, 0, "Disk name:\t");
|
1995-05-21 04:34:12 +00:00
|
|
|
clrtobot();
|
1995-05-16 02:53:31 +00:00
|
|
|
attrset(A_REVERSE); addstr(d->name); attrset(A_NORMAL);
|
1995-06-11 19:33:05 +00:00
|
|
|
attrset(A_REVERSE); mvaddstr(0, 55, "FDISK Partition Editor"); attrset(A_NORMAL);
|
1995-05-16 02:53:31 +00:00
|
|
|
mvprintw(1, 0,
|
1996-11-27 22:52:34 +00:00
|
|
|
"DISK Geometry:\t%lu cyls/%lu heads/%lu sectors = %lu sectors",
|
|
|
|
d->bios_cyl, d->bios_hd, d->bios_sect,
|
|
|
|
d->bios_cyl * d->bios_hd * d->bios_sect);
|
1995-05-16 02:53:31 +00:00
|
|
|
mvprintw(3, 1, "%10s %10s %10s %8s %8s %8s %8s %8s",
|
|
|
|
"Offset", "Size", "End", "Name", "PType", "Desc",
|
|
|
|
"Subtype", "Flags");
|
|
|
|
for (i = 0, row = CHUNK_START_ROW; chunk_info[i]; i++, row++) {
|
1995-05-05 23:47:47 +00:00
|
|
|
if (i == current_chunk)
|
1996-06-08 09:08:51 +00:00
|
|
|
attrset(ATTR_SELECTED);
|
1995-06-11 19:33:05 +00:00
|
|
|
mvprintw(row, 2, "%10ld %10lu %10lu %8s %8d %8s %8d\t%-6s",
|
1995-05-16 02:53:31 +00:00
|
|
|
chunk_info[i]->offset, chunk_info[i]->size,
|
|
|
|
chunk_info[i]->end, chunk_info[i]->name,
|
1997-01-24 02:26:42 +00:00
|
|
|
chunk_info[i]->type,
|
|
|
|
slice_type_name(chunk_info[i]->type, chunk_info[i]->subtype),
|
1995-06-11 19:33:05 +00:00
|
|
|
chunk_info[i]->subtype, ShowChunkFlags(chunk_info[i]));
|
1995-05-05 23:47:47 +00:00
|
|
|
if (i == current_chunk)
|
|
|
|
attrset(A_NORMAL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
print_command_summary()
|
|
|
|
{
|
1995-05-16 02:53:31 +00:00
|
|
|
mvprintw(14, 0, "The following commands are supported (in upper or lower case):");
|
1997-01-24 07:47:17 +00:00
|
|
|
mvprintw(16, 0, "A = Use Entire Disk B = Bad Block Scan C = Create Slice");
|
|
|
|
mvprintw(17, 0, "D = Delete Slice G = Set Drive Geometry S = Set Bootable");
|
1996-03-18 15:28:10 +00:00
|
|
|
mvprintw(18, 0, "U = Undo All Changes Q = Finish");
|
|
|
|
if (!RunningAsInit)
|
1997-01-24 07:47:17 +00:00
|
|
|
mvprintw(18, 48, "W = Write Changes");
|
1996-05-09 09:42:17 +00:00
|
|
|
mvprintw(21, 0, "Use F1 or ? to get more help, arrow keys to select.");
|
1995-05-05 23:47:47 +00:00
|
|
|
move(0, 0);
|
|
|
|
}
|
|
|
|
|
1995-12-07 10:34:59 +00:00
|
|
|
static u_char *
|
|
|
|
getBootMgr(char *dname)
|
|
|
|
{
|
|
|
|
extern u_char mbr[], bteasy17[];
|
|
|
|
char str[80];
|
|
|
|
char *cp;
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
cp = variable_get(VAR_BOOTMGR);
|
|
|
|
if (!cp) {
|
|
|
|
/* Figure out what kind of MBR the user wants */
|
|
|
|
sprintf(str, "Install Boot Manager for drive %s?", dname);
|
|
|
|
MenuMBRType.title = str;
|
1996-07-02 01:03:55 +00:00
|
|
|
i = dmenuOpenSimple(&MenuMBRType, FALSE);
|
1995-12-07 10:34:59 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (!strncmp(cp, "boot", 4))
|
|
|
|
BootMgr = 0;
|
|
|
|
else if (!strcmp(cp, "standard"))
|
|
|
|
BootMgr = 1;
|
|
|
|
else
|
|
|
|
BootMgr = 2;
|
|
|
|
}
|
|
|
|
if (cp || i) {
|
|
|
|
switch (BootMgr) {
|
|
|
|
case 0:
|
|
|
|
return bteasy17;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
return mbr;
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
diskPartition(Device *dev, Disk *d)
|
1995-05-04 23:36:23 +00:00
|
|
|
{
|
1996-10-06 11:40:31 +00:00
|
|
|
char *cp, *p;
|
1996-10-03 06:01:44 +00:00
|
|
|
int rv, key = 0;
|
1995-05-16 02:53:31 +00:00
|
|
|
Boolean chunking;
|
1995-05-05 23:47:47 +00:00
|
|
|
char *msg = NULL;
|
1995-12-07 10:34:59 +00:00
|
|
|
u_char *mbrContents;
|
1996-10-03 06:01:44 +00:00
|
|
|
WINDOW *w = savescr();
|
1995-05-05 23:47:47 +00:00
|
|
|
|
1995-05-16 02:53:31 +00:00
|
|
|
chunking = TRUE;
|
1995-05-05 23:47:47 +00:00
|
|
|
keypad(stdscr, TRUE);
|
|
|
|
|
1996-10-03 06:01:44 +00:00
|
|
|
/* Flush both the dialog and curses library views of the screen
|
|
|
|
since we don't always know who called us */
|
|
|
|
dialog_clear_norefresh(), clear();
|
1996-11-07 16:40:10 +00:00
|
|
|
current_chunk = 0;
|
1996-10-03 06:01:44 +00:00
|
|
|
|
1996-10-04 13:33:49 +00:00
|
|
|
/* Set up the chunk array */
|
|
|
|
record_chunks(d);
|
1996-10-03 06:01:44 +00:00
|
|
|
|
1996-10-04 13:33:49 +00:00
|
|
|
while (chunking) {
|
1996-10-06 11:40:31 +00:00
|
|
|
char *val, geometry[80];
|
|
|
|
|
1996-10-03 06:01:44 +00:00
|
|
|
/* Now print our overall state */
|
1997-01-16 14:42:21 +00:00
|
|
|
if (d)
|
|
|
|
print_chunks(d);
|
1995-05-05 23:47:47 +00:00
|
|
|
print_command_summary();
|
|
|
|
if (msg) {
|
1996-05-09 09:42:17 +00:00
|
|
|
attrset(title_attr); mvprintw(23, 0, msg); attrset(A_NORMAL);
|
1995-05-05 23:47:47 +00:00
|
|
|
beep();
|
|
|
|
msg = NULL;
|
|
|
|
}
|
1996-10-03 06:01:44 +00:00
|
|
|
else {
|
|
|
|
move(23, 0);
|
|
|
|
clrtoeol();
|
|
|
|
}
|
1995-05-16 02:53:31 +00:00
|
|
|
|
1996-10-03 06:01:44 +00:00
|
|
|
/* Get command character */
|
1996-08-03 05:29:24 +00:00
|
|
|
key = getch();
|
|
|
|
switch (toupper(key)) {
|
1996-10-06 11:40:31 +00:00
|
|
|
case '\014': /* ^L (redraw) */
|
1995-05-25 18:48:33 +00:00
|
|
|
clear();
|
1996-10-03 06:01:44 +00:00
|
|
|
msg = NULL;
|
|
|
|
break;
|
1996-10-06 11:40:31 +00:00
|
|
|
|
1997-01-15 02:52:00 +00:00
|
|
|
case '\020': /* ^P */
|
1995-05-05 23:47:47 +00:00
|
|
|
case KEY_UP:
|
|
|
|
case '-':
|
|
|
|
if (current_chunk != 0)
|
|
|
|
--current_chunk;
|
|
|
|
break;
|
1996-10-06 11:40:31 +00:00
|
|
|
|
1997-01-15 02:52:00 +00:00
|
|
|
case '\016': /* ^N */
|
1995-05-05 23:47:47 +00:00
|
|
|
case KEY_DOWN:
|
|
|
|
case '+':
|
|
|
|
case '\r':
|
|
|
|
case '\n':
|
1995-05-16 02:53:31 +00:00
|
|
|
if (chunk_info[current_chunk + 1])
|
1995-05-05 23:47:47 +00:00
|
|
|
++current_chunk;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case KEY_HOME:
|
|
|
|
current_chunk = 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case KEY_END:
|
1995-05-16 02:53:31 +00:00
|
|
|
while (chunk_info[current_chunk + 1])
|
1995-05-05 23:47:47 +00:00
|
|
|
++current_chunk;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case KEY_F(1):
|
|
|
|
case '?':
|
1995-12-07 10:34:59 +00:00
|
|
|
systemDisplayHelp("slice");
|
1996-10-01 04:56:34 +00:00
|
|
|
clear();
|
1995-05-16 02:53:31 +00:00
|
|
|
break;
|
|
|
|
|
1996-10-03 06:01:44 +00:00
|
|
|
case 'A':
|
1997-05-05 05:16:03 +00:00
|
|
|
cp = variable_get(VAR_DEDICATE_DISK);
|
1997-05-10 17:11:24 +00:00
|
|
|
if (cp && !strcasecmp(cp, "always"))
|
1997-05-05 05:16:03 +00:00
|
|
|
rv = 1;
|
|
|
|
else {
|
|
|
|
rv = msgYesNo("Do you want to do this with a true partition entry\n"
|
|
|
|
"so as to remain cooperative with any future possible\n"
|
|
|
|
"operating systems on the drive(s)?");
|
1997-05-10 17:11:24 +00:00
|
|
|
if (rv != 0 && (!cp || strcasecmp(cp, "nowarn"))) {
|
1997-05-05 05:16:03 +00:00
|
|
|
rv = !msgYesNo("This is dangerous in that it will make the drive totally\n"
|
|
|
|
"uncooperative with other potential operating systems on the\n"
|
|
|
|
"same disk. It will lead instead to a totally dedicated disk,\n"
|
|
|
|
"starting at the very first sector, bypassing all BIOS geometry\n"
|
|
|
|
"considerations. This precludes the existance of any boot\n"
|
|
|
|
"manager or other stuff in sector 0, since the BSD bootstrap\n"
|
|
|
|
"will live there.\n"
|
|
|
|
"You will run into serious trouble with ST-506 and ESDI drives\n"
|
|
|
|
"and possibly some IDE drives (e.g. drives running under the\n"
|
|
|
|
"control of sort of disk manager). SCSI drives are considerably\n"
|
|
|
|
"less at risk.\n\n"
|
|
|
|
"If, on the other hand, your goal is a dedicated FreeBSD machine\n"
|
|
|
|
"and nothing else, this option is for you.\n\n"
|
|
|
|
"Do you insist on dedicating the entire disk this way?");
|
|
|
|
}
|
|
|
|
if (rv == -1)
|
|
|
|
rv = 0;
|
1995-12-07 10:34:59 +00:00
|
|
|
}
|
|
|
|
All_FreeBSD(d, rv);
|
|
|
|
variable_set2(DISK_PARTITIONED, "yes");
|
1996-10-04 13:33:49 +00:00
|
|
|
record_chunks(d);
|
1996-10-03 06:01:44 +00:00
|
|
|
clear();
|
|
|
|
break;
|
1996-10-06 11:40:31 +00:00
|
|
|
|
1995-05-16 02:53:31 +00:00
|
|
|
case 'B':
|
|
|
|
if (chunk_info[current_chunk]->type != freebsd)
|
1997-01-24 07:47:17 +00:00
|
|
|
msg = "Can only scan for bad blocks in FreeBSD slice.";
|
1995-12-07 10:34:59 +00:00
|
|
|
else if (strncmp(d->name, "sd", 2) ||
|
|
|
|
!msgYesNo("This typically makes sense only for ESDI, IDE or MFM drives.\n"
|
|
|
|
"Are you sure you want to do this on a SCSI disk?")) {
|
1995-05-18 09:02:06 +00:00
|
|
|
if (chunk_info[current_chunk]->flags & CHUNK_BAD144)
|
|
|
|
chunk_info[current_chunk]->flags &= ~CHUNK_BAD144;
|
|
|
|
else
|
|
|
|
chunk_info[current_chunk]->flags |= CHUNK_BAD144;
|
1995-12-07 10:34:59 +00:00
|
|
|
}
|
1996-10-01 04:56:34 +00:00
|
|
|
clear();
|
1995-05-05 23:47:47 +00:00
|
|
|
break;
|
1996-10-06 11:40:31 +00:00
|
|
|
|
1995-05-05 23:47:47 +00:00
|
|
|
case 'C':
|
1995-05-16 02:53:31 +00:00
|
|
|
if (chunk_info[current_chunk]->type != unused)
|
1997-01-24 07:47:17 +00:00
|
|
|
msg = "Slice in use, delete it first or move to an unused one.";
|
1995-05-05 23:47:47 +00:00
|
|
|
else {
|
1995-05-16 11:37:27 +00:00
|
|
|
char *val, tmp[20], *cp;
|
1996-06-08 08:01:52 +00:00
|
|
|
int size, subtype;
|
|
|
|
chunk_e partitiontype;
|
1996-10-06 11:40:31 +00:00
|
|
|
|
1995-05-16 02:53:31 +00:00
|
|
|
snprintf(tmp, 20, "%d", chunk_info[current_chunk]->size);
|
1997-01-24 07:47:17 +00:00
|
|
|
val = msgGetInput(tmp, "Please specify the size for new FreeBSD slice in blocks\n"
|
1996-10-06 11:40:31 +00:00
|
|
|
"or append a trailing `M' for megabytes (e.g. 20M).");
|
1995-05-16 11:37:27 +00:00
|
|
|
if (val && (size = strtol(val, &cp, 0)) > 0) {
|
|
|
|
if (*cp && toupper(*cp) == 'M')
|
1995-12-07 10:34:59 +00:00
|
|
|
size *= ONE_MEG;
|
1996-06-08 08:01:52 +00:00
|
|
|
strcpy(tmp, "165");
|
|
|
|
val = msgGetInput(tmp, "Enter type of partition to create:\n\n"
|
|
|
|
"Pressing Enter will choose the default, a native FreeBSD\n"
|
1997-01-24 07:47:17 +00:00
|
|
|
"slice (type 165). You can choose other types, 6 for a\n"
|
1996-06-08 08:01:52 +00:00
|
|
|
"DOS partition or 131 for a Linux partition, for example.\n\n"
|
|
|
|
"Note: If you choose a non-FreeBSD partition type, it will not\n"
|
|
|
|
"be formatted or otherwise prepared, it will simply reserve space\n"
|
|
|
|
"for you to use another tool, such as DOS FORMAT, to later format\n"
|
|
|
|
"and use the partition.");
|
|
|
|
if (val && (subtype = strtol(val, NULL, 0)) > 0) {
|
|
|
|
if (subtype==165)
|
1996-10-06 11:40:31 +00:00
|
|
|
partitiontype=freebsd;
|
1996-06-08 08:01:52 +00:00
|
|
|
else if (subtype==6)
|
1996-10-06 11:40:31 +00:00
|
|
|
partitiontype=fat;
|
1996-06-08 08:01:52 +00:00
|
|
|
else
|
1996-10-06 11:40:31 +00:00
|
|
|
partitiontype=unknown;
|
|
|
|
Create_Chunk(d, chunk_info[current_chunk]->offset, size, partitiontype, subtype,
|
|
|
|
(chunk_info[current_chunk]->flags & CHUNK_ALIGN));
|
|
|
|
variable_set2(DISK_PARTITIONED, "yes");
|
|
|
|
record_chunks(d);
|
1996-06-08 08:01:52 +00:00
|
|
|
}
|
1995-05-05 23:47:47 +00:00
|
|
|
}
|
1996-10-03 06:01:44 +00:00
|
|
|
clear();
|
1995-05-05 23:47:47 +00:00
|
|
|
}
|
|
|
|
break;
|
1996-10-06 11:40:31 +00:00
|
|
|
|
1996-08-03 05:29:24 +00:00
|
|
|
case KEY_DC:
|
1995-05-16 02:53:31 +00:00
|
|
|
case 'D':
|
|
|
|
if (chunk_info[current_chunk]->type == unused)
|
1997-01-24 07:47:17 +00:00
|
|
|
msg = "Slice is already unused!";
|
1995-05-16 02:53:31 +00:00
|
|
|
else {
|
|
|
|
Delete_Chunk(d, chunk_info[current_chunk]);
|
1995-12-07 10:34:59 +00:00
|
|
|
variable_set2(DISK_PARTITIONED, "yes");
|
1996-10-04 13:33:49 +00:00
|
|
|
record_chunks(d);
|
1995-05-06 09:34:24 +00:00
|
|
|
}
|
|
|
|
break;
|
1996-10-06 11:40:31 +00:00
|
|
|
|
|
|
|
case 'G':
|
1995-09-18 16:53:06 +00:00
|
|
|
snprintf(geometry, 80, "%lu/%lu/%lu", d->bios_cyl, d->bios_hd, d->bios_sect);
|
1995-12-07 10:34:59 +00:00
|
|
|
val = msgGetInput(geometry, "Please specify the new geometry in cyl/hd/sect format.\n"
|
|
|
|
"Don't forget to use the two slash (/) separator characters!\n"
|
|
|
|
"It's not possible to parse the field without them.");
|
1995-05-16 02:53:31 +00:00
|
|
|
if (val) {
|
1996-11-27 22:52:34 +00:00
|
|
|
long nc, nh, ns;
|
|
|
|
nc = strtol(val, &val, 0);
|
|
|
|
nh = strtol(val + 1, &val, 0);
|
|
|
|
ns = strtol(val + 1, 0, 0);
|
|
|
|
Set_Bios_Geom(d, nc, nh, ns);
|
1995-05-07 05:58:57 +00:00
|
|
|
}
|
1996-10-01 04:56:34 +00:00
|
|
|
clear();
|
1996-10-06 11:40:31 +00:00
|
|
|
break;
|
1995-12-07 10:34:59 +00:00
|
|
|
|
1996-10-06 11:40:31 +00:00
|
|
|
case 'S':
|
|
|
|
/* Set Bootable */
|
|
|
|
chunk_info[current_chunk]->flags |= CHUNK_ACTIVE;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'U':
|
|
|
|
if ((cp = variable_get(DISK_LABELLED)) && !strcmp(cp, "written")) {
|
|
|
|
msgConfirm("You've already written this information out - you\n"
|
|
|
|
"can't undo it.");
|
1996-10-01 04:56:34 +00:00
|
|
|
}
|
1996-10-06 11:40:31 +00:00
|
|
|
else if (!msgYesNo("Are you SURE you want to Undo everything?")) {
|
1997-01-16 14:42:21 +00:00
|
|
|
char cp[BUFSIZ];
|
|
|
|
|
|
|
|
sstrncpy(cp, d->name, sizeof cp);
|
1996-10-06 11:40:31 +00:00
|
|
|
Free_Disk(dev->private);
|
1997-01-16 14:42:21 +00:00
|
|
|
d = Open_Disk(cp);
|
|
|
|
if (!d)
|
|
|
|
msgConfirm("Can't reopen disk %s! Internal state is probably corrupted", cp);
|
1996-10-06 11:40:31 +00:00
|
|
|
dev->private = d;
|
|
|
|
variable_unset(DISK_PARTITIONED);
|
|
|
|
variable_unset(DISK_LABELLED);
|
1997-01-16 14:42:21 +00:00
|
|
|
if (d)
|
|
|
|
record_chunks(d);
|
1995-12-07 10:34:59 +00:00
|
|
|
}
|
1996-10-01 04:56:34 +00:00
|
|
|
clear();
|
1995-05-07 23:37:34 +00:00
|
|
|
break;
|
|
|
|
|
1995-05-08 00:56:28 +00:00
|
|
|
case 'W':
|
1996-10-06 11:40:31 +00:00
|
|
|
if ((cp = variable_get(DISK_LABELLED)) && !strcmp(cp, "written")) {
|
|
|
|
msgConfirm("You've already written this information out - if\n"
|
|
|
|
"you wish to overwrite it, you'll have to restart.");
|
|
|
|
}
|
|
|
|
else if (!msgYesNo("WARNING: This should only be used when modifying an EXISTING\n"
|
|
|
|
"installation. If you are installing FreeBSD for the first time\n"
|
|
|
|
"then you should simply type Q when you're finished here and your\n"
|
|
|
|
"changes will be committed in one batch automatically at the end of\n"
|
|
|
|
"these questions.\n\n"
|
|
|
|
"Are you absolutely sure you want to do this now?")) {
|
1995-12-07 10:34:59 +00:00
|
|
|
variable_set2(DISK_PARTITIONED, "yes");
|
1996-10-06 11:40:31 +00:00
|
|
|
|
1995-12-07 10:34:59 +00:00
|
|
|
/* Don't trash the MBR if the first (and therefore only) chunk is marked for a truly dedicated
|
|
|
|
* disk (i.e., the disklabel starts at sector 0), even in cases where the user has requested
|
|
|
|
* booteasy or a "standard" MBR -- both would be fatal in this case.
|
|
|
|
*/
|
1997-01-15 07:06:39 +00:00
|
|
|
if (!(d->chunks->part->flags & CHUNK_FORCE_ALL) && (mbrContents = getBootMgr(d->name)) != NULL)
|
1995-12-07 10:34:59 +00:00
|
|
|
Set_Boot_Mgr(d, mbrContents);
|
1996-10-06 11:40:31 +00:00
|
|
|
|
1996-04-28 03:27:26 +00:00
|
|
|
if (DITEM_STATUS(diskPartitionWrite(NULL)) != DITEM_SUCCESS)
|
1995-12-07 10:34:59 +00:00
|
|
|
msgConfirm("Disk partition write returned an error status!");
|
1996-04-23 01:29:35 +00:00
|
|
|
else
|
1995-12-07 10:34:59 +00:00
|
|
|
msgConfirm("Wrote FDISK partition information out successfully.");
|
|
|
|
}
|
1996-10-01 04:56:34 +00:00
|
|
|
clear();
|
1995-09-18 16:53:06 +00:00
|
|
|
break;
|
1996-10-06 11:40:31 +00:00
|
|
|
|
1995-09-18 16:53:06 +00:00
|
|
|
case '|':
|
1995-12-07 10:34:59 +00:00
|
|
|
if (!msgYesNo("Are you SURE you want to go into Wizard mode?\n"
|
|
|
|
"No seat belts whatsoever are provided!")) {
|
1996-10-03 06:01:44 +00:00
|
|
|
clear();
|
|
|
|
refresh();
|
1995-05-16 02:53:31 +00:00
|
|
|
slice_wizard(d);
|
1995-12-07 10:34:59 +00:00
|
|
|
variable_set2(DISK_PARTITIONED, "yes");
|
1996-10-04 13:33:49 +00:00
|
|
|
record_chunks(d);
|
1995-05-08 00:56:28 +00:00
|
|
|
}
|
|
|
|
else
|
1995-05-16 02:53:31 +00:00
|
|
|
msg = "Wise choice!";
|
1996-10-03 06:01:44 +00:00
|
|
|
clear();
|
1995-05-08 00:56:28 +00:00
|
|
|
break;
|
|
|
|
|
1997-01-15 02:52:00 +00:00
|
|
|
case '\033': /* ESC */
|
1995-06-11 19:33:05 +00:00
|
|
|
case 'Q':
|
1995-05-16 02:53:31 +00:00
|
|
|
chunking = FALSE;
|
1995-12-07 10:34:59 +00:00
|
|
|
/* Don't trash the MBR if the first (and therefore only) chunk is marked for a truly dedicated
|
|
|
|
* disk (i.e., the disklabel starts at sector 0), even in cases where the user has requested
|
|
|
|
* booteasy or a "standard" MBR -- both would be fatal in this case.
|
|
|
|
*/
|
|
|
|
if ((d->chunks->part->flags & CHUNK_FORCE_ALL) != CHUNK_FORCE_ALL
|
|
|
|
&& (mbrContents = getBootMgr(d->name)) != NULL)
|
|
|
|
Set_Boot_Mgr(d, mbrContents);
|
1995-05-05 23:47:47 +00:00
|
|
|
break;
|
1996-10-06 11:40:31 +00:00
|
|
|
|
1995-05-07 23:37:34 +00:00
|
|
|
default:
|
|
|
|
beep();
|
|
|
|
msg = "Type F1 or ? for help";
|
|
|
|
break;
|
1995-05-05 23:47:47 +00:00
|
|
|
}
|
|
|
|
}
|
1995-05-16 02:53:31 +00:00
|
|
|
p = CheckRules(d);
|
|
|
|
if (p) {
|
1996-04-30 05:23:49 +00:00
|
|
|
char buf[FILENAME_MAX];
|
1996-10-06 11:40:31 +00:00
|
|
|
|
1996-08-03 10:11:56 +00:00
|
|
|
dialog_clear_norefresh();
|
1997-01-24 07:47:17 +00:00
|
|
|
use_helpline("Press F1 to read more about disk slices.");
|
1996-04-30 05:23:49 +00:00
|
|
|
use_helpfile(systemHelpFile("partition", buf));
|
1997-01-24 07:47:17 +00:00
|
|
|
dialog_mesgbox("Disk slicing warning:", p, -1, -1);
|
1995-05-16 02:53:31 +00:00
|
|
|
free(p);
|
|
|
|
}
|
1996-04-23 01:29:35 +00:00
|
|
|
restorescr(w);
|
1995-05-04 23:36:23 +00:00
|
|
|
}
|
|
|
|
|
1995-05-16 02:53:31 +00:00
|
|
|
static int
|
1996-04-13 13:32:15 +00:00
|
|
|
partitionHook(dialogMenuItem *selected)
|
1995-05-04 23:36:23 +00:00
|
|
|
{
|
1995-05-16 11:37:27 +00:00
|
|
|
Device **devs = NULL;
|
1995-05-16 02:53:31 +00:00
|
|
|
|
1996-04-13 13:32:15 +00:00
|
|
|
devs = deviceFind(selected->prompt, DEVICE_TYPE_DISK);
|
|
|
|
if (!devs) {
|
|
|
|
msgConfirm("Unable to find disk %s!", selected->prompt);
|
|
|
|
return DITEM_FAILURE;
|
1995-05-16 02:53:31 +00:00
|
|
|
}
|
1996-05-09 09:42:17 +00:00
|
|
|
/* Toggle enabled status? */
|
|
|
|
if (!devs[0]->enabled) {
|
|
|
|
devs[0]->enabled = TRUE;
|
|
|
|
diskPartition(devs[0], (Disk *)devs[0]->private);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
devs[0]->enabled = FALSE;
|
|
|
|
return DITEM_SUCCESS | DITEM_REDRAW;
|
1996-04-13 13:32:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
partitionCheck(dialogMenuItem *selected)
|
|
|
|
{
|
|
|
|
Device **devs = NULL;
|
|
|
|
|
|
|
|
devs = deviceFind(selected->prompt, DEVICE_TYPE_DISK);
|
|
|
|
if (!devs || devs[0]->enabled == FALSE)
|
|
|
|
return FALSE;
|
|
|
|
return TRUE;
|
1995-05-16 02:53:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
1996-04-07 03:52:36 +00:00
|
|
|
diskPartitionEditor(dialogMenuItem *self)
|
1995-05-16 02:53:31 +00:00
|
|
|
{
|
|
|
|
DMenu *menu;
|
1995-06-11 19:33:05 +00:00
|
|
|
Device **devs;
|
1995-12-07 10:34:59 +00:00
|
|
|
int i, cnt;
|
1996-04-13 13:32:15 +00:00
|
|
|
char *cp;
|
1995-06-11 19:33:05 +00:00
|
|
|
|
1995-12-07 10:34:59 +00:00
|
|
|
cp = variable_get(VAR_DISK);
|
|
|
|
devs = deviceFind(cp, DEVICE_TYPE_DISK);
|
1995-06-11 19:33:05 +00:00
|
|
|
cnt = deviceCount(devs);
|
|
|
|
if (!cnt) {
|
1995-12-07 10:34:59 +00:00
|
|
|
msgConfirm("No disks found! Please verify that your disk controller is being\n"
|
|
|
|
"properly probed at boot time. See the Hardware Guide on the\n"
|
|
|
|
"Documentation menu for clues on diagnosing this type of problem.");
|
1996-04-13 13:32:15 +00:00
|
|
|
i = DITEM_FAILURE;
|
1995-06-11 19:33:05 +00:00
|
|
|
}
|
|
|
|
else if (cnt == 1) {
|
|
|
|
devs[0]->enabled = TRUE;
|
1996-04-07 03:52:36 +00:00
|
|
|
diskPartition(devs[0], (Disk *)devs[0]->private);
|
1996-04-13 13:32:15 +00:00
|
|
|
i = DITEM_SUCCESS;
|
1995-05-04 23:36:23 +00:00
|
|
|
}
|
1995-05-17 14:40:00 +00:00
|
|
|
else {
|
1996-04-13 13:32:15 +00:00
|
|
|
menu = deviceCreateMenu(&MenuDiskDevices, DEVICE_TYPE_DISK, partitionHook, partitionCheck);
|
1995-12-07 10:34:59 +00:00
|
|
|
if (!menu) {
|
|
|
|
msgConfirm("No devices suitable for installation found!\n\n"
|
|
|
|
"Please verify that your disk controller (and attached drives)\n"
|
|
|
|
"were detected properly. This can be done by pressing the\n"
|
|
|
|
"[Scroll Lock] key and using the Arrow keys to move back to\n"
|
|
|
|
"the boot messages. Press [Scroll Lock] again to return.");
|
1996-04-13 13:32:15 +00:00
|
|
|
i = DITEM_FAILURE;
|
1995-12-07 10:34:59 +00:00
|
|
|
}
|
1995-06-11 19:33:05 +00:00
|
|
|
else {
|
1996-07-02 01:03:55 +00:00
|
|
|
i = dmenuOpenSimple(menu, FALSE) ? DITEM_SUCCESS : DITEM_FAILURE;
|
1995-06-11 19:33:05 +00:00
|
|
|
free(menu);
|
|
|
|
}
|
1997-01-17 08:47:13 +00:00
|
|
|
i = i | DITEM_RESTORE;
|
1995-05-17 14:40:00 +00:00
|
|
|
}
|
1995-12-07 10:34:59 +00:00
|
|
|
return i;
|
1995-09-18 16:53:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
1996-04-07 03:52:36 +00:00
|
|
|
diskPartitionWrite(dialogMenuItem *self)
|
1995-09-18 16:53:06 +00:00
|
|
|
{
|
|
|
|
Device **devs;
|
1995-12-07 10:34:59 +00:00
|
|
|
char *cp;
|
1995-09-18 16:53:06 +00:00
|
|
|
int i;
|
|
|
|
|
1995-12-07 10:34:59 +00:00
|
|
|
if ((cp = variable_get(DISK_PARTITIONED)) && strcmp(cp, "yes"))
|
1996-04-13 13:32:15 +00:00
|
|
|
return DITEM_SUCCESS;
|
1995-12-07 10:34:59 +00:00
|
|
|
else if (!cp) {
|
|
|
|
msgConfirm("You must partition the disk(s) before this option can be used.");
|
1996-04-13 13:32:15 +00:00
|
|
|
return DITEM_FAILURE;
|
1995-12-07 10:34:59 +00:00
|
|
|
}
|
|
|
|
|
1995-09-18 16:53:06 +00:00
|
|
|
devs = deviceFind(NULL, DEVICE_TYPE_DISK);
|
|
|
|
if (!devs) {
|
|
|
|
msgConfirm("Unable to find any disks to write to??");
|
1996-04-13 13:32:15 +00:00
|
|
|
return DITEM_FAILURE;
|
1995-09-18 16:53:06 +00:00
|
|
|
}
|
1996-04-29 06:47:10 +00:00
|
|
|
if (isDebug())
|
|
|
|
msgDebug("diskPartitionWrite: Examining %d devices\n", deviceCount(devs));
|
1995-09-18 16:53:06 +00:00
|
|
|
|
|
|
|
for (i = 0; devs[i]; i++) {
|
|
|
|
Chunk *c1;
|
|
|
|
Disk *d = (Disk *)devs[i]->private;
|
|
|
|
|
|
|
|
if (!devs[i]->enabled)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
Set_Boot_Blocks(d, boot1, boot2);
|
|
|
|
msgNotify("Writing partition information to drive %s", d->name);
|
1996-04-28 20:54:11 +00:00
|
|
|
if (!Fake && Write_Disk(d)) {
|
1995-12-07 10:34:59 +00:00
|
|
|
msgConfirm("ERROR: Unable to write data to disk %s!", d->name);
|
1996-04-13 13:32:15 +00:00
|
|
|
return DITEM_FAILURE;
|
1995-12-07 10:34:59 +00:00
|
|
|
}
|
1995-09-18 16:53:06 +00:00
|
|
|
/* Now scan for bad blocks, if necessary */
|
|
|
|
for (c1 = d->chunks->part; c1; c1 = c1->next) {
|
|
|
|
if (c1->flags & CHUNK_BAD144) {
|
|
|
|
int ret;
|
|
|
|
|
1997-01-24 07:47:17 +00:00
|
|
|
msgNotify("Running bad block scan on slice %s", c1->name);
|
1996-06-25 18:41:10 +00:00
|
|
|
if (!Fake) {
|
|
|
|
ret = vsystem("bad144 -v /dev/r%s 1234", c1->name);
|
|
|
|
if (ret)
|
|
|
|
msgConfirm("Bad144 init on %s returned status of %d!", c1->name, ret);
|
|
|
|
ret = vsystem("bad144 -v -s /dev/r%s", c1->name);
|
|
|
|
if (ret)
|
|
|
|
msgConfirm("Bad144 scan on %s returned status of %d!", c1->name, ret);
|
|
|
|
}
|
1995-09-18 16:53:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1995-12-07 10:34:59 +00:00
|
|
|
/* Now it's not "yes", but "written" */
|
|
|
|
variable_set2(DISK_PARTITIONED, "written");
|
1996-04-13 13:32:15 +00:00
|
|
|
return DITEM_SUCCESS;
|
1995-09-18 16:53:06 +00:00
|
|
|
}
|