/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License, Version 1.0 only

 * (the "License").  You may not use this file except in compliance

 * with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/* ONC_PLUS EXTRACT START */

/*

 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/* ONC_PLUS EXTRACT END */

/*

 * Configure root, swap and dump devices.

 */

#include <sys/types.h>

#include <sys/param.h>

#include <sys/sysmacros.h>

#include <sys/signal.h>

#include <sys/cred.h>

#include <sys/proc.h>

#include <sys/user.h>

#include <sys/conf.h>

#include <sys/buf.h>

#include <sys/systm.h>

#include <sys/vm.h>

#include <sys/reboot.h>

#include <sys/file.h>

#include <sys/vfs.h>

#include <sys/vnode.h>

#include <sys/errno.h>

#include <sys/kmem.h>

#include <sys/uio.h>

#include <sys/open.h>

#include <sys/mount.h>

#include <sys/kobj.h>

#include <sys/bootconf.h>

#include <sys/sysconf.h>

#include <sys/modctl.h>

#include <sys/autoconf.h>

#include <sys/debug.h>

#include <sys/fs/snode.h>

#include <fs/fs_subr.h>

#include <sys/socket.h>

#include <net/if.h>

#include <sys/mkdev.h>

#include <sys/cmn_err.h>

#include <sys/console.h>

#include <sys/conf.h>

#include <sys/ddi.h>

#include <sys/sunddi.h>

#include <sys/hwconf.h>

#include <sys/dc_ki.h>

#include <sys/promif.h>

/*

 * Local routines

 */

static int preload_module(struct sysparam *, void *);

static struct vfssw *getfstype(char *, char *, size_t);

static int getphysdev(char *, char *, size_t);

static int load_bootpath_drivers(char *bootpath);

static int load_boot_driver(char *drv);

static int load_boot_platform_modules(char *drv);

static dev_info_t *path_to_devinfo(char *path);

static boolean_t netboot_over_ib(char *bootpath);

/*

 * Module linkage information for the kernel.

 */

static struct modlmisc modlmisc = {

	&mod_miscops, "root and swap configuration %I%"

};

static struct modlinkage modlinkage = {

	MODREV_1, (void *)&modlmisc, NULL

};

int

_init(void)

{

	return (mod_install(&modlinkage));

}

int

_fini(void)

{

	return (mod_remove(&modlinkage));

}

int

_info(struct modinfo *modinfop)

{

	return (mod_info(&modlinkage, modinfop));

}

/*

 * Configure root file system.

 */

int

rootconf(void)

{

	int error;

	struct vfssw *vsw;

	extern void pm_init(void);

	BMDPRINTF(("rootconf: fstype %s\n", rootfs.bo_fstype));

	BMDPRINTF(("rootconf: name %s\n", rootfs.bo_name));

	BMDPRINTF(("rootconf: flags 0x%x\n", rootfs.bo_flags));

	BMDPRINTF(("rootconf: obp_bootpath %s\n", obp_bootpath));

	/*

	 * Install cluster modules that were only loaded during

	 * loadrootmodules().

	 */

	if (error = clboot_rootconf())

		return (error);

	if (root_is_svm) {

		(void) strncpy(rootfs.bo_name, obp_bootpath, BO_MAXOBJNAME);

		BMDPRINTF(("rootconf: svm: rootfs name %s\n", rootfs.bo_name));

		BMDPRINTF(("rootconf: svm: svm name %s\n", svm_bootpath));

	}

	/*

	 * Run _init on the root filesystem (we already loaded it

	 * but we've been waiting until now to _init it) which will

	 * have the side-effect of running vsw_init() on this vfs.

	 * Because all the nfs filesystems are lumped into one

	 * module we need to special case it.

	 */

	if (strncmp(rootfs.bo_fstype, "nfs", 3) == 0) {

		if (modload("fs", "nfs") == -1) {

			cmn_err(CE_CONT, "Cannot initialize %s filesystem\n",

			    rootfs.bo_fstype);

			return (ENXIO);

		}

	} else {

		if (modload("fs", rootfs.bo_fstype) == -1) {

			cmn_err(CE_CONT, "Cannot initialize %s filesystem\n",

			    rootfs.bo_fstype);

			return (ENXIO);

		}

	}

	RLOCK_VFSSW();

	vsw = vfs_getvfsswbyname(rootfs.bo_fstype);

	RUNLOCK_VFSSW();

	VFS_INIT(rootvfs, &vsw->vsw_vfsops, (caddr_t)0);

	VFS_HOLD(rootvfs);

	if (root_is_svm) {

		rootvfs->vfs_flag |= VFS_RDONLY;

	}

	/*

	 * This pm-releated call has to occur before root is mounted since we

	 * need to power up all devices.  It is placed after VFS_INIT() such

	 * that opening a device via ddi_lyr_ interface just before root has

	 * been mounted would work.

	 */

	pm_init();

	if (netboot) {

		if ((error = strplumb()) != 0) {

			cmn_err(CE_CONT, "Cannot plumb network device\n");

			return (error);

		}

	}

	/*

	 * ufs_mountroot() ends up calling getrootdev()

	 * (below) which actually triggers the _init, identify,

	 * probe and attach of the drivers that make up root device

	 * bush; these are also quietly waiting in memory.

	 */

	BMDPRINTF(("rootconf: calling VFS_MOUNTROOT %s\n", rootfs.bo_fstype));

	error = VFS_MOUNTROOT(rootvfs, ROOT_INIT);

	vfs_unrefvfssw(vsw);

	rootdev = rootvfs->vfs_dev;

	if (error)

		cmn_err(CE_CONT, "Cannot mount root on %s fstype %s\n",

		    rootfs.bo_name, rootfs.bo_fstype);

	else

		cmn_err(CE_CONT, "?root on %s fstype %s\n",

		    rootfs.bo_name, rootfs.bo_fstype);

	return (error);

}

/*

 * Remount root on an SVM mirror root device

 * Only supported on UFS filesystems at present

 */

int

svm_rootconf(void)

{

	int	error;

	extern int ufs_remountroot(struct vfs *vfsp);

	ASSERT(root_is_svm == 1);

	if (strcmp(rootfs.bo_fstype, "ufs") != 0) {

		cmn_err(CE_CONT, "Mounting root on %s with filesystem "

		    "type %s is not supported\n",

		    rootfs.bo_name, rootfs.bo_fstype);

		return (EINVAL);

	}

	(void) strncpy(rootfs.bo_name, svm_bootpath, BO_MAXOBJNAME);

	BMDPRINTF(("svm_rootconf: rootfs %s\n", rootfs.bo_name));

	error = ufs_remountroot(rootvfs);

	if (error) {

		cmn_err(CE_CONT, "Cannot remount root on %s fstype %s\n",

			rootfs.bo_name, rootfs.bo_fstype);

	} else {

		cmn_err(CE_CONT, "?root remounted on %s fstype %s\n",

			rootfs.bo_name, rootfs.bo_fstype);

	}

	return (error);

}

/*

 * Under the assumption that our root file system is on a

 * disk partition, get the dev_t of the partition in question.

 *

 * By now, boot has faithfully loaded all our modules into memory, and

 * we've taken over resource management.  Before we go any further, we

 * have to fire up the device drivers and stuff we need to mount the

 * root filesystem.  That's what we do here.  Fingers crossed.

 */

dev_t

getrootdev(void)

{

	dev_t	d;

	if ((d = ddi_pathname_to_dev_t(rootfs.bo_name)) == NODEV)

		cmn_err(CE_CONT, "Cannot assemble drivers for root %s\n",

		    rootfs.bo_name);

	return (d);

}

/*

 * If booted with ASKNAME, prompt on the console for a filesystem

 * name and return it.

 */

void

getfsname(char *askfor, char *name, size_t namelen)

{

	if (boothowto & RB_ASKNAME) {

		printf("%s name: ", askfor);

		console_gets(name, namelen);

	}

}

/*ARGSUSED1*/

static int

preload_module(struct sysparam *sysp, void *p)

{

	static char *wmesg = "forceload of %s failed";

	char *name;

	name = sysp->sys_ptr;

	BMDPRINTF(("preload_module: %s\n", name));

	if (modloadonly(NULL, name) < 0)

		cmn_err(CE_WARN, wmesg, name);

	return (0);

}

/* ONC_PLUS EXTRACT START */

/*

 * We want to load all the modules needed to mount the root filesystem,

 * so that when we start the ball rolling in 'getrootdev', every module

 * should already be in memory, just waiting to be init-ed.

 */

int

loadrootmodules(void)

{

	struct vfssw	*vsw;

	char		*this;

	char 		*name;

	int		err;

/* ONC_PLUS EXTRACT END */

	int		i, proplen, dhcacklen;

	extern char	*impl_module_list[];

	extern char	*platform_module_list[];

	/* Make sure that the PROM's devinfo tree has been created */

	ASSERT(ddi_root_node());

	BMDPRINTF(("loadrootmodules: fstype %s\n", rootfs.bo_fstype));

	BMDPRINTF(("loadrootmodules: name %s\n", rootfs.bo_name));

	BMDPRINTF(("loadrootmodules: flags 0x%x\n", rootfs.bo_flags));

	/*

	 * zzz We need to honor what's in rootfs if it's not null.

	 * non-null means use what's there.  This way we can

	 * change rootfs with /etc/system AND with tunetool.

	 */

	if (root_is_svm) {

		/* user replaced rootdev, record obp_bootpath */

		obp_bootpath[0] = '\0';

		(void) getphysdev("root", obp_bootpath, BO_MAXOBJNAME);

		BMDPRINTF(("loadrootmodules: obp_bootpath %s\n", obp_bootpath));

	} else {

		/*

		 * Get the root fstype and root device path from boot.

		 */

		rootfs.bo_fstype[0] = '\0';

		rootfs.bo_name[0] = '\0';

	}

	/*

	 * This lookup will result in modloadonly-ing the root

	 * filesystem module - it gets _init-ed in rootconf()

	 */

	if ((vsw = getfstype("root", rootfs.bo_fstype, BO_MAXFSNAME)) == NULL)

		return (ENXIO);	/* in case we have no file system types */

	(void) strcpy(rootfs.bo_fstype, vsw->vsw_name);

	vfs_unrefvfssw(vsw);

	/*

	 * Load the favored drivers of the implementation.

	 * e.g. 'sbus' and possibly 'zs' (even).

	 *

	 * Called whilst boot is still loaded (because boot does

	 * the i/o for us), and DDI services are unavailable.

	 */

	BMDPRINTF(("loadrootmodules: impl_module_list\n"));

	for (i = 0; (this = impl_module_list[i]) != NULL; i++) {

		if ((err = load_boot_driver(this)) != 0) {

			cmn_err(CE_WARN, "Cannot load drv/%s", this);

			return (err);

			/* NOTREACHED */

		}

	}

	/*

	 * Now load the platform modules (if any)

	 */

	BMDPRINTF(("loadrootmodules: platform_module_list\n"));

	for (i = 0; (this = platform_module_list[i]) != NULL; i++) {

		if ((err = load_boot_platform_modules(this)) != 0) {

			cmn_err(CE_WARN, "Cannot load drv/%s", this);

			return (err);

			/* NOTREACHED */

		}

	}

loop:

	(void) getphysdev("root", rootfs.bo_name, BO_MAXOBJNAME);

	/*

	 * Given a physical pathname, load the correct set of driver

	 * modules into memory, including all possible parents.

	 *

	 * NB: The code sets the variable 'name' for error reporting.

	 */

	err = 0;

	BMDPRINTF(("loadrootmodules: rootfs %s\n", rootfs.bo_name));

	if (root_is_svm == 0) {

		BMDPRINTF(("loadrootmodules: rootfs %s\n", rootfs.bo_name));

		name = rootfs.bo_name;

		err = load_bootpath_drivers(rootfs.bo_name);

	}

	/*

	 * Load driver modules in obp_bootpath, this is always

	 * required for mountroot to succeed. obp_bootpath is

	 * is set if rootdev is set via /etc/system, which is

	 * the case if booting of a SVM/VxVM mirror.

	 */

	if ((err == 0) && obp_bootpath[0] != '\0') {

		BMDPRINTF(("loadrootmodules: obp_bootpath %s\n", obp_bootpath));

		name = obp_bootpath;

		err = load_bootpath_drivers(obp_bootpath);

	}

	if (err != 0) {

		cmn_err(CE_CONT, "Cannot load drivers for %s\n", name);

		goto out;

		/* NOTREACHED */

	}

	/*

	 * Check to see if the booter performed DHCP configuration

	 * ("bootp-response" boot property exists). If so, then before

	 * bootops disappears we need to save the value of this property

	 * such that the userland dhcpagent can adopt the DHCP management

	 * of our primary network interface. We leave room at the beginning of

	 * saved property to cache the interface name we used to boot the

	 * client. This context is necessary for the user land dhcpagent

	 * to do its job properly on a multi-homed system.

	 */

	proplen = BOP_GETPROPLEN(bootops, "bootp-response");

	if (proplen > 0) {

		dhcacklen = proplen + IFNAMSIZ;

		dhcack = kmem_zalloc(dhcacklen, KM_SLEEP);

		if (BOP_GETPROP(bootops, "bootp-response",

		    (uchar_t *)&dhcack[IFNAMSIZ]) == -1) {

			cmn_err(CE_WARN, "BOP_GETPROP of  "

			    "\"bootp-response\" failed\n");

			kmem_free(dhcack, dhcacklen);

			dhcack = NULL;

			goto out;

		}

		/*

		 * Fetch the "netdev-path" boot property (if it exists), and

		 * stash it for later use by sysinfo(SI_DHCP_CACHE, ...).

		 */

		proplen = BOP_GETPROPLEN(bootops, "netdev-path");

		if (proplen > 0) {

			netdev_path = kmem_zalloc(proplen, KM_SLEEP);

			if (BOP_GETPROP(bootops, "netdev-path",

			    (uchar_t *)netdev_path) == -1) {

				cmn_err(CE_WARN, "BOP_GETPROP of  "

				    "\"netdev-path\" failed\n");

				kmem_free(netdev_path, proplen);

				goto out;

			}

		}

	}

	/*

	 * Preload (load-only, no init) all modules which

	 * were added to the /etc/system file with the

	 * FORCELOAD keyword.

	 */

	BMDPRINTF(("loadrootmodules: preload_module\n"));

	(void) mod_sysctl_type(MOD_FORCELOAD, preload_module, NULL);

/* ONC_PLUS EXTRACT START */

	/*

	 * If we booted otw then load in the plumbing

	 * routine now while we still can. If we didn't

	 * boot otw then we will load strplumb in main().

	 *

	 * NFS is actually a set of modules, the core routines,

	 * a diskless helper module, rpcmod, and the tli interface.  Load

	 * them now while we still can.

	 *

	 * Because we glomb all versions of nfs into a single module

	 * we check based on the initial string "nfs".

	 *

	 * XXX: A better test for this is to see if device_type

	 * XXX: from the PROM is "network".

	 */

	if (strncmp(rootfs.bo_fstype, "nfs", 3) == 0) {

		++netboot;

		if ((err = modload("misc", "tlimod")) < 0)  {

			cmn_err(CE_CONT, "Cannot load misc/tlimod\n");

			goto out;

			/* NOTREACHED */

		}

		if ((err = modload("strmod", "rpcmod")) < 0)  {

			cmn_err(CE_CONT, "Cannot load strmod/rpcmod\n");

			goto out;

			/* NOTREACHED */

		}

		if ((err = modload("misc", "nfs_dlboot")) < 0)  {

			cmn_err(CE_CONT, "Cannot load misc/nfs_dlboot\n");

			goto out;

			/* NOTREACHED */

		}

		if ((err = modload("misc", "strplumb")) < 0)  {

			cmn_err(CE_CONT, "Cannot load misc/strplumb\n");

			goto out;

			/* NOTREACHED */

		}

		if ((err = strplumb_load()) < 0) {

			goto out;

			/* NOTREACHED */

		}

	}

	/*

	 * Preload modules needed for booting as a cluster.

	 */

	err = clboot_loadrootmodules();

out:

	if (err != 0 && (boothowto & RB_ASKNAME))

		goto loop;

	return (err);

}

/* ONC_PLUS EXTRACT END */

/*

 * Get the name of the root or swap filesystem type, and return

 * the corresponding entry in the vfs switch.

 *

 * If we're not asking the user, and we're trying to find the

 * root filesystem type, we ask boot for the filesystem

 * type that it came from and use that.  Similarly, if we're

 * trying to find the swap filesystem, we try and derive it from