/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


#include <sys/types.h>
#include <sys/param.h>
#include <sys/fcntl.h>
#include <sys/obpdefs.h>
#include <sys/reboot.h>
#include <sys/promif.h>
#include <sys/stat.h>
#include <sys/bootvfs.h>
#include <sys/platnames.h>
#include <sys/salib.h>
#include <sys/elf.h>
#include <sys/link.h>
#include <sys/auxv.h>
#include <sys/boot_policy.h>
#include <sys/boot_redirect.h>
#include <sys/bootconf.h>
#include <sys/boot.h>
#include "boot_plat.h"
#include "ramdisk.h"

#define	SUCCESS		0
#define	FAILURE		-1

#ifdef DEBUG
extern int debug = 0;
#else
static const int debug = 0;
#endif

#define	dprintf		if (debug) printf

char		*def_boot_archive = "boot_archive";
char		*def_miniroot = "miniroot";
extern char	cmd_line_boot_archive[];

extern int	openfile(char *filename);

static int
read_and_boot_ramdisk(int fd)
{
	struct stat	st;
	caddr_t		virt;
	size_t		size;
	extern		ssize_t xread(int, char *, size_t);

	if ((fstat(fd, &st) != 0) ||
	    ((virt = create_ramdisk(RD_ROOTFS, st.st_size, NULL)) == NULL))
		return (-1);

	dprintf("reading boot archive ...\n");
	if ((size = xread(fd, (char *)virt, st.st_size)) != st.st_size) {
		(void) printf("Error reading boot archive, bytes read = %ld, "
		    "filesize = %ld\n", (long)size, (long)st.st_size);
		destroy_ramdisk(RD_ROOTFS);
		return (-1);
	}

	boot_ramdisk(RD_ROOTFS);
	/* NOT REACHED */
	return (0);	/* to make cc happy */
}


static void
post_mountroot_nfs(void)
{
	int	fd;
	char	*fn;
	char	tmpname[MAXPATHLEN];

	for (;;) {
		fn = NULL;
		if (boothowto & RB_ASKNAME) {
			char ctmpname[MAXPATHLEN];

			fn = (cmd_line_boot_archive[0] != '\0') ?
			    cmd_line_boot_archive : def_boot_archive;

			/* Avoid buffer overrun */
			(void) strncpy(tmpname, fn, strlen(fn)+1);
			fn = tmpname;

			printf("Enter filename [%s]: ", fn);
			(void) cons_gets(ctmpname, sizeof (ctmpname));
			if (ctmpname[0] != '\0') {
				(void) strncpy(tmpname, ctmpname,
				    strlen(ctmpname)+1);
				fn = tmpname;
			}
		}

		if (boothowto & RB_HALT) {
			printf("Boot halted.\n");
			prom_enter_mon();
		}


		if (fn != NULL) {
			fd = openfile(fn);
		} else if (cmd_line_boot_archive[0] != '\0') {
			(void) strncpy(tmpname, cmd_line_boot_archive,
			    strlen(cmd_line_boot_archive)+1);
			fn = tmpname;
			fd = openfile(fn);
		} else {
			(void) strncpy(tmpname, def_boot_archive,
			    strlen(def_boot_archive)+1);
			fn = tmpname;
			if ((fd = openfile(fn)) == FAILURE) {
				(void) strncpy(tmpname, def_miniroot,
				    strlen(def_miniroot)+1);
				fn = tmpname;
				fd = openfile(fn);
			}
		}

		if (fn != tmpname || tmpname[0] == '\0') {
			printf("Possible buffer overrun, "
			    "entering boot prompt\n");
			prom_enter_mon();
		}


		if (fd == FAILURE) {
			if (strncmp(fn, def_miniroot,
			    strlen(def_miniroot)+1) != 0)
				printf("cannot open %s\n", fn);
			else
				printf("cannot open neither %s nor %s\n",
				    def_boot_archive, def_miniroot);
		} else {
			/*
			 * this function does not return if successful.
			 */
			(void) read_and_boot_ramdisk(fd);

			printf("boot failed\n");
			(void) close(fd);
		}
		boothowto |= RB_ASKNAME;
	}
}


/*
 * bpath is the boot device path buffer.
 * bargs is the boot arguments buffer.
 */
/*ARGSUSED*/
int
bootprog(char *bpath, char *bargs, boolean_t user_specified_filename)
{
	systype = set_fstype(v2path, bpath);

	if (verbosemode) {
		printf("device path '%s'\n", bpath);
		if (strcmp(bpath, v2path) != 0)
			printf("client path '%s'\n", v2path);
	}

	if (mountroot(bpath) != SUCCESS)
		prom_panic("Could not mount filesystem.");

	/*
	 * kernname (default-name) might have changed if mountroot() called
	 * boot_nfs_mountroot(), and it called set_default_filename().
	 */
	if (!user_specified_filename)
		(void) strcpy(filename, kernname);

	if (verbosemode)
		printf("standalone = `%s', args = `%s'\n", filename, bargs);

	set_client_bootargs(filename, bargs);

	post_mountroot_nfs();

	return (1);
}