NetBSD/distrib/utils/sysinst/disks.c

/*	$NetBSD: disks.c,v 1.41 2001/01/14 23:45:17 mrg Exp $ */

/*
 * Copyright 1997 Piermont Information Systems Inc.
 * All rights reserved.
 *
 * Written by Philip A. Nelson for Piermont Information Systems Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed for the NetBSD Project by
 *      Piermont Information Systems Inc.
 * 4. The name of Piermont Information Systems Inc. may not be used to endorse
 *    or promote products derived from this software without specific prior
 *    written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY PIERMONT INFORMATION SYSTEMS INC. ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL PIERMONT INFORMATION SYSTEMS INC. BE 
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
 * THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

/* disks.c -- routines to deal with finding disks and labeling disks. */


#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <util.h>

#include <sys/param.h>
#include <ufs/ufs/dinode.h>
#include <ufs/ffs/fs.h>

#include "defs.h"
#include "md.h"
#include "msg_defs.h"
#include "menu_defs.h"
#include "txtwalk.h"



/* Local prototypes */
static void get_disks (void);
static void foundffs (struct data *list, int num);
static int do_fsck(const char *diskpart);
static int fsck_root (void);
static int 
    do_flfs_newfs(const char *partname, int part, const char *mountpoint);
static int fsck_num(const char *mp);

static int fsck_with_error_menu(const char *diskpart);
static int target_mount_with_error_menu(const char *opt, char *diskpart,
					const char *mntpt);


static void
get_disks(void)
{
	char **xd = disk_names;
	char d_name[SSTRSIZE];
	struct disklabel l;
	int i;

	while (*xd != NULL) {
		for (i=0; i< MAX_DISKS; i++) {
			snprintf(d_name, SSTRSIZE, "%s%d", *xd, i);
			if (get_geom(d_name, &l) && numdisks < MAX_DISKS) {
				strncpy (disks[numdisks].dd_name,
					 d_name, SSTRSIZE);
				strncat (disknames, d_name,
					 SSTRSIZE-1-strlen(disknames));
				strncat (disknames, " ",
					 SSTRSIZE-1-strlen(disknames));
				disks[numdisks].dd_cyl = l.d_ncylinders;
				disks[numdisks].dd_head = l.d_ntracks;
				disks[numdisks].dd_sec = l.d_nsectors;
				disks[numdisks].dd_secsize = l.d_secsize;
				disks[numdisks].dd_totsec = l.d_secperunit;
				numdisks++;
			}
		}
		xd++;
	}
}
			

int
find_disks(void)
{
	char *tp;
	char defname[STRSIZE];
	int  i;

	/* initialize */
	disknames[0] = 0;
	numdisks = 0;

	/* Find disks. */
	get_disks();

	/* need a redraw here, kernel messages hose everything */
	touchwin(stdscr);
	refresh();

	if (numdisks == 0) {
		/* No disks found! */
		msg_display(MSG_nodisk);
		process_menu(MENU_ok);
		/*endwin();*/
		return -1;
	} else if (numdisks == 1) {
		/* One disk found! */
		/* Remove that space we added. */
		disknames[strlen(disknames)-1] = 0;
		msg_display(MSG_onedisk, disknames, doingwhat);
		process_menu(MENU_ok);
		strcpy(diskdev, disknames);
	} else {
		/* Multiple disks found! */
		strcpy(defname, disknames);
		tp = defname;
		strsep(&tp, " ");
		msg_prompt(MSG_askdisk, defname,  diskdev, 10, disknames);
		tp = diskdev;
		strsep(&tp, " ");
		diskdev[strlen(diskdev)+1] = 0;
		diskdev[strlen(diskdev)] = ' ';
		while (!ISDISKSTART(*diskdev) ||
		       strstr(disknames, diskdev) == NULL) {
			msg_prompt(MSG_badname, defname,  diskdev, 10,
				    disknames);
			tp = diskdev;
			strsep(&tp, " ");
			diskdev[strlen(diskdev)+1] = 0;
			diskdev[strlen(diskdev)] = ' ';
		}

		/* Remove that space we added. */
		diskdev[strlen(diskdev)-1] = 0;
	}
	
	/* Set disk. */
	for (i = 0; i < numdisks; i++)
		if (strcmp(diskdev, disks[i].dd_name) == 0)
			disk = &disks[i];

	sectorsize = disk->dd_secsize;
	if (disk->dd_totsec == 0)
		disk->dd_totsec = disk->dd_cyl * disk->dd_head * disk->dd_sec;
	dlcyl = disk->dd_cyl;
	dlhead = disk->dd_head;
	dlsec = disk->dd_sec;
	dlsize = disk->dd_totsec;
	dlcylsize = dlhead * dlsec;

	return numdisks;
}


void
disp_cur_fspart(int disp, int showall)
{
	int i;
	int start, stop;
	int poffset, psize, pend;

	if (disp < 0) {
		start = 0;
		stop = getmaxpartitions();
	} else {
		start = disp;
		stop = disp+1;
	}

	msg_table_add (MSG_fspart_header);
	for (i = start; i < stop; i++) {
		if (showall || bsdlabel[i].pi_size > 0) {
			poffset = bsdlabel[i].pi_offset / sizemult;
			psize = bsdlabel[i].pi_size / sizemult;
			if (psize == 0)
				pend = 0;
			else
				pend = (bsdlabel[i].pi_offset +
				bsdlabel[i].pi_size) / sizemult - 1;
			msg_table_add(MSG_fspart_row_start,
					'a'+i, psize, poffset, pend,
					fstypenames[bsdlabel[i].pi_fstype]);
			if (PI_ISBSDFS(&bsdlabel[i]))
				msg_table_add(MSG_fspart_row_end_bsd,
						bsdlabel[i].pi_bsize,
						bsdlabel[i].pi_fsize,
						preservemount[i] ? "Yes" : "No",
						fsmount[i]);
			else if (bsdlabel[i].pi_fstype == FS_MSDOS)
				msg_table_add(MSG_fspart_row_end_msdos,
						fsmount[i]);
			else
				msg_table_add(MSG_fspart_row_end_other);
		}
	}
	msg_display_add(MSG_newline);
}

/*
 * Label a disk using an MD-specific string DISKLABEL_CMD for
 * to invoke  disklabel.
 * if MD code does not define DISKLABEL_CMD, this is a no-op.
 *
 * i386  port uses "/sbin/disklabel -w -r", just like i386
 * miniroot scripts, though this may leave a bogus incore label.
 *
 * Sun ports should use  DISKLABEL_CMD "/sbin/disklabel -w"	
 * to get incore  to ondisk inode translation for the Sun proms.
 */
int
write_disklabel (void)
{

#ifdef DISKLABEL_CMD
	/* disklabel the disk */
	return run_prog(RUN_DISPLAY, MSG_cmdfail,
	    "%s %s %s", DISKLABEL_CMD, diskdev, bsddiskname);
#endif
	return 0;
}

int
make_filesystems(void)
{
	int i;
	char partname[STRSIZE];
	int error;

	/* Making new file systems and mounting them*/
	for (i = 0; i < getmaxpartitions(); i++) {
		/*
		 * newfs and mount. For now, process only BSD filesystems. 
		 * but if this is the mounted-on root, has no mount
		 * point defined, or is marked preserve, don't touch it! 
		 */
	  	snprintf(partname, STRSIZE, "%s%c", diskdev, 'a'+i);
		if (PI_ISBSDFS(&bsdlabel[i]) && !is_active_rootpart(partname)) {
			error = do_flfs_newfs(partname, i, fsmount[i]);
			if (error)
				return error;
		}
	}
	return 0;
}

/* newfs and mount an ffs filesystem. */
static int 
do_flfs_newfs(const char *partname, int partno, const char *mountpoint)
{
	char devname[STRSIZE];
	int error;

	if (*mountpoint && !preservemount[partno])
		error = run_prog(RUN_DISPLAY, MSG_cmdfail, "%s /dev/r%s",
		    bsdlabel[partno].pi_fstype == FS_BSDFFS ?
		    "/sbin/newfs" : "/sbin/newfs_lfs", partname);
	else
		error = 0;
	if (*mountpoint && error == 0) { 
		snprintf(devname, STRSIZE, "/dev/%s", partname);
		if (partno > 0)	/* XXX strcmp(mountpoint, "/") ? XXX */
			make_target_dir(mountpoint);
		error = target_mount(bsdlabel[partno].pi_fstype == FS_BSDFFS ?
		    "-v -o async" : "-v", devname, mountpoint);
		if (error) {
			msg_display(MSG_mountfail, devname, mountpoint);
			process_menu (MENU_ok);
		}
	}
	return error;
}

int
make_fstab(void)
{
	FILE *f;
	int i, swapdev = -1;

	/* Create the fstab. */
	make_target_dir("/etc");
	f = target_fopen("/etc/fstab", "w");
	if (logging)
		(void)fprintf(log, "Creating %s/etc/fstab.\n", target_prefix());
	scripting_fprintf(NULL, "cat <<EOF >%s/etc/fstab\n", target_prefix());

	if (f == NULL) {
#ifndef DEBUG
		msg_display(MSG_createfstab);
		if (logging)
			(void)fprintf(log, "Failed to make /etc/fstab!\n");
		process_menu(MENU_ok);
		return 1;
#else
		f = stdout;
#endif		
	}
	for (i = 0; i < getmaxpartitions(); i++)
		if (bsdlabel[i].pi_fstype == FS_BSDFFS)
			scripting_fprintf(f, "/dev/%s%c %s ffs rw 1 %d\n",
				       diskdev, 'a'+i, fsmount[i],
				       fsck_num(fsmount[i]));
		else if (bsdlabel[i].pi_fstype == FS_BSDLFS) {
			char *s = "#";

			/* If there is no LFS, just comment it out. */
			if (!check_lfs_progs())
				s++;
			scripting_fprintf(f, "%s/dev/%s%c %s lfs rw 1 %d\n", s,
				       diskdev, 'a'+i, fsmount[i],
				       fsck_num(fsmount[i]));
		} else if (bsdlabel[i].pi_fstype == FS_MSDOS)
			scripting_fprintf(f, "/dev/%s%c %s msdos rw 0 0\n",
				       diskdev, 'a'+i, fsmount[i]);
		else if (bsdlabel[i].pi_fstype == FS_SWAP) {
			if (swapdev == -1)
				swapdev = i;
			scripting_fprintf(f, "/dev/%s%c none swap sw 0 0\n", diskdev, 'a'+i);
		}
	if (layout_tmp) {
		if (swapdev != -1)
			scripting_fprintf(f, "/dev/%s%c /tmp mfs rw\n", diskdev, 'a'+swapdev);
		else
			scripting_fprintf(f, "swap /tmp mfs rw\n");
	}
	scripting_fprintf(script, "/kern /kern kernfs rw\n");
	scripting_fprintf(NULL, "EOF\n");

#ifndef DEBUG
	fclose(f);
	fflush(NULL);
#endif
	/* We added /kern to fstab,  make mountpoint. */
	make_target_dir("/kern");
	return 0;
}

static int
fsck_num(const char *mp)
{
	static int num = 1;

	if (strcmp(mp, "/"))
		return 1;

	return (++num);
}


/* Get information on the file systems mounted from the root filesystem.
 * Offer to convert them into 4.4BSD inodes if they are not 4.4BSD
 * inodes.  Fsck them.  Mount them.
 */


static struct lookfor fstabbuf[] = {
	{"/dev/", "/dev/%s %s ffs %s", "c", NULL, 0, 0, foundffs},
	{"/dev/", "/dev/%s %s ufs %s", "c", NULL, 0, 0, foundffs},
};
static int numfstabbuf = sizeof(fstabbuf) / sizeof(struct lookfor);

#define MAXDEVS 40

static char dev[MAXDEVS][SSTRSIZE];
static char mnt[MAXDEVS][STRSIZE];
static int  devcnt = 0;

static void
foundffs(struct data *list, int num)
{
	if (strcmp(list[1].u.s_val, "/") != 0 &&
	    strstr(list[2].u.s_val, "noauto") == NULL) {
		strncpy(dev[devcnt], list[0].u.s_val, SSTRSIZE);
		strncpy(mnt[devcnt], list[1].u.s_val, STRSIZE);
		devcnt++;
	}
}

static int
inode_kind(char *dev)
{
	union {
		struct fs fs;
		char pad[SBSIZE];
	} fs;
	int fd;
	int ret;

	fd = open(dev, O_RDONLY, 0);
	if (fd < 0)
		return fd;
        if (lseek(fd, (off_t)SBOFF, SEEK_SET) == (off_t)-1) {
		close(fd);
                return -1;
	}
        if ((ret = read(fd, &fs, SBSIZE)) != SBSIZE) {
		close(fd);
                return -2;
	}
	close(fd);
	if (fs_is_lfs(&fs.fs))
		return -4;
	if (fs.fs.fs_magic != FS_MAGIC)
		return -3;
	if (fs.fs.fs_inodefmt < FS_44INODEFMT)
		return 0;
	return 1;
}

/*
 * Do an fsck. For now, assume ffs filesystems.
 * Returns zero if the fsck completed with no errors.
 * Returns a negative numbe to indicate a bad inode type,
 * and a positive  non-zero value  if exec'ing fsck returns an error.
 * If the filesystem is an out-of-date version, prompt the user
 * whether to upgrade the filesystem  level.
 * 
 */
static int
do_fsck(const char *diskpart)
{
	char raw[SSTRSIZE];
	int inodetype;
	char *upgr = "", *prog = "/sbin/fsck_ffs";
	int err;

	/* cons up raw partition name. */
	snprintf (raw, SSTRSIZE, "/dev/r%s", diskpart);
	inodetype = inode_kind (raw);

	if (inodetype == -4) {
		if (check_lfs_progs() == 0)
			return EOPNOTSUPP;	/* XXX */
		prog = "/sbin/fsck_lfs";
	} else if (inodetype < 0) {
		/* error */
		return inodetype;
	} else if (inodetype == 0) {
		/* Ask to upgrade */
		msg_display(MSG_upgrinode, raw);
		process_menu(MENU_yesno);
		if (yesno)
			upgr = "-c 3 ";
	}

	/*endwin();*/
#ifndef	DEBUG_SETS
	err = run_prog(RUN_DISPLAY, NULL, "%s %s%s", prog, upgr, raw);
#else
	err = run_prog(RUN_DISPLAY, NULL, "%s -f %s%s", prog, upgr, raw);
#endif	
	wrefresh(stdscr);
	return err;
}

/*
 * Do an fsck. On failure,  inform the user by showing a warning
 * message and doing menu_ok() before proceeding.
 * acknowledge the warning before continuing.
 * Returns 0 on success, or nonzero return code from do_fsck() on failure.
 */
int
fsck_with_error_menu(const char *diskpart)
{
	int error;

	if ((error = do_fsck(diskpart)) != 0) {
#ifdef DEBUG
		fprintf(stderr, "sysinst: do_fsck() returned err %d\n", error);
#endif
		msg_display(MSG_badfs, diskpart, "", error);
		process_menu(MENU_ok);
	}
	return error;
}


/*
 * Do target_mount, but print a message and do menu_ok() before
 * proceeding, to inform the user.
 * returns 0 if  the mount completed without indicating errors,
 *  and an nonzero error code from target_mount() otherwise.
 */
int target_mount_with_error_menu(const char *opt, 
		 char *diskpart, const char *mntpoint)
{
	int error;
	char devname[STRSIZE];

	snprintf(devname, STRSIZE, "/dev/%s", diskpart);
#ifdef DEBUG
	fprintf(stderr, "sysinst: mount_with_error_menu: %s %s %s\n",
		opt, devname, mntpoint);
#endif

	if ((error = target_mount(opt, devname, mntpoint)) != 0) {
		msg_display (MSG_badmount, devname, "");
		process_menu (MENU_ok);
		return error;
	} else {
#ifdef DEBUG
	  printf("mount %s %s %s OK\n", opt, diskpart, mntpoint);
#endif
	}

	return error;
}

/*
 * fsck and mount the root partition.
 */
int
fsck_root()
{
	int   error;
	char	rootdev[STRSIZE];

	/* cons up the root name:  partition 'a' on the target diskdev.*/
	snprintf(rootdev, STRSIZE, "%s%c", diskdev, 'a');
#ifdef DEBUG
	printf("fsck_root: rootdev is %s\n", rootdev);
#endif
	error = fsck_with_error_menu(rootdev);
	if (error != 0)
		return error;

	if (target_already_root()) {
		return (0);
	}

	/* Mount /dev/<diskdev>a on  target's "".  
	 * If we pass "" as mount-on, Prefixing will DTRT. 
	 * for now, use no options.
	 * XXX consider -o remount in case target root is
	 * current root, still  readonly from single-user? 
	 */
	error = target_mount_with_error_menu("", rootdev, "");

#ifdef DEBUG
	printf("fsck_root: mount of %s returns %d\n", rootdev, error);
#endif
	return (error);
}

int
fsck_disks(void)
{	char *fstab;
	int   fstabsize;
	int   i;
	int   error;

	/* First the root device. */
	if (!target_already_root()) {
		error = fsck_root();
		if (error != 0 && error != EBUSY) {
			return 0;
		}
	}

	/* Check the target /etc/fstab exists before trying to parse it. */
	if (target_dir_exists_p("/etc") == 0 || 
	    target_file_exists_p("/etc/fstab") == 0) {
		msg_display(MSG_noetcfstab, diskdev);
		process_menu(MENU_ok);
		return 0;
	}


	/* Get fstab entries from the target-root /etc/fstab. */
	fstabsize = target_collect_file(T_FILE, &fstab, "/etc/fstab");
	if (fstabsize < 0) {
		/* error ! */
		msg_display(MSG_badetcfstab, diskdev);
		process_menu(MENU_ok);
		return 0;
	}
	walk(fstab, fstabsize, fstabbuf, numfstabbuf);
	free(fstab);

	for (i = 0; i < devcnt; i++) {
	  	if (fsck_with_error_menu(dev[i]))
			return 0;

#ifdef DEBUG
		printf("sysinst: mount %s\n", dev[i]);
#endif
		if (target_mount_with_error_menu("", dev[i], mnt[i]) != 0) {
			return 0;
		}
	}
	
	return 1;
}

int
set_swap(dev, pp, enable)
	const char *dev;
	partinfo *pp;
{
	partinfo parts[16];
	int i, maxpart;

	if (pp == NULL) {
		emptylabel(parts);
		if (incorelabel(dev, parts) < 0)
			return -1;
		pp = parts;
	}

	maxpart = getmaxpartitions();

	for (i = 0; i < maxpart; i++) {
		if (pp[i].pi_fstype == FS_SWAP) {
			if (run_prog(0, NULL,
			    "/sbin/swapctl -%c /dev/%s%c",
			    enable ? 'a' : 'd', dev, 'a' + i) != 0)
				return -1;
			if (enable)
				strcpy(swapdev, dev);
			else
				swapdev[0] = '\0';
			break;
		}
	}

	return 0;
}

/* XXX
 * these belong in bsddisklabel.c but until that is common across all sysinst
 * ports, they need to be here.
 */

void
show_cur_filesystems()
{

	msg_display(MSG_cur_fs);
	msg_table_add(MSG_cur_fs_header);
	msg_table_add(MSG_cur_fs_row, "/    ", "[X]      (always)");
	msg_table_add(MSG_cur_fs_row, "swap ", layout_swap ? "[X]" : "");
	msg_table_add(MSG_cur_fs_row, "/usr ", layout_usr ? "[X]" : "");
	msg_table_add(MSG_cur_fs_row, "/var ", layout_var ? "[X]" : "");
	msg_table_add(MSG_cur_fs_row, "/home", layout_home ? "[X]" : "");
	msg_table_add(MSG_cur_fs_row, "/tmp ", layout_tmp ? "[X]      (mfs)" : "         (mfs)");
}

int	layout_swap, layout_usr, layout_tmp, layout_var, layout_home;