path: root/usr/src/uts/common/krtld/bootrd.c

/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright 2013 Joyent, Inc.  All rights reserved.
 */


#include <sys/param.h>
#include <sys/sunddi.h>
#include <sys/bootconf.h>
#include <sys/bootvfs.h>
#include <sys/filep.h>
#include <sys/kobj.h>
#include <sys/varargs.h>
#include <sys/reboot.h>

extern void (*_kobj_printf)(void *, const char *fmt, ...);
extern int get_weakish_int(int *);
extern struct bootops *ops;
extern struct boot_fs_ops bufs_ops, bhsfs_ops, bbootfs_ops;
extern int kmem_ready;

static uint64_t rd_start, rd_end;
struct boot_fs_ops *bfs_ops;
struct boot_fs_ops *bfs_tab[] = {&bufs_ops, &bhsfs_ops, &bbootfs_ops, NULL};

static uintptr_t scratch_max = 0;

#define	_kmem_ready	get_weakish_int(&kmem_ready)

int
BRD_MOUNTROOT(struct boot_fs_ops *ops, char *str)
{
	return (ops->fsw_mountroot(str));
}

int
BRD_UNMOUNTROOT(struct boot_fs_ops *ops)
{
	if (bfs_ops != &bbootfs_ops)
		bbootfs_ops.fsw_closeall(1);

	return (ops->fsw_unmountroot());
}

int
BRD_OPEN(struct boot_fs_ops *ops, char *file, int flags)
{
	int len = strlen(SYSTEM_BOOT_PATH);
	int fd;

	/*
	 * Our policy is that we try bootfs first.  If bootfs is the only
	 * filesystem, that's the end of it.  Otherwise we will fall back to
	 * the normal root (i.e., ramdisk) filesystem at this point and try
	 * again if the file does not exist in bootfs.
	 */
	fd = bbootfs_ops.fsw_open(file, flags);

	if (bfs_ops == &bbootfs_ops)
		return (fd);

	if (strncmp(file, SYSTEM_BOOT_PATH, len) == 0 || fd >= 0)
		return ((fd < 0) ? fd : (fd | BFD_F_SYSTEM_BOOT));

	return (ops->fsw_open(file, flags));
}

int
BRD_CLOSE(struct boot_fs_ops *ops, int fd)
{
	if (fd & BFD_F_SYSTEM_BOOT)
		return (bbootfs_ops.fsw_close(fd & ~BFD_F_SYSTEM_BOOT));

	return (ops->fsw_close(fd));
}

ssize_t
BRD_READ(struct boot_fs_ops *ops, int fd, caddr_t buf, size_t len)
{
	if (fd & BFD_F_SYSTEM_BOOT) {
		return (bbootfs_ops.fsw_read(fd & ~BFD_F_SYSTEM_BOOT,
		    buf, len));
	}

	return (ops->fsw_read(fd, buf, len));
}

off_t
BRD_SEEK(struct boot_fs_ops *ops, int fd, off_t addr, int whence)
{
	if (fd & BFD_F_SYSTEM_BOOT) {
		return (bbootfs_ops.fsw_lseek(fd & ~BFD_F_SYSTEM_BOOT,
		    addr, whence));
	}

	return (ops->fsw_lseek(fd, addr, whence));
}

int
BRD_FSTAT(struct boot_fs_ops *ops, int fd, struct bootstat *bsp)
{
	if (fd & BFD_F_SYSTEM_BOOT)
		return (bbootfs_ops.fsw_fstat(fd & ~BFD_F_SYSTEM_BOOT, bsp));

	return (ops->fsw_fstat(fd, bsp));
}

/*
 * This one reads the ramdisk. If fi_memp is set, we copy the
 * ramdisk content to the designated buffer. Otherwise, we
 * do a "cached" read (set fi_memp to the actual ramdisk buffer).
 */
int
diskread(fileid_t *filep)
{
	uint_t blocknum;
	caddr_t diskloc;

	/* add in offset of root slice */
	blocknum = filep->fi_blocknum;

	diskloc = (caddr_t)(uintptr_t)rd_start + blocknum * DEV_BSIZE;
	if (diskloc + filep->fi_count > (caddr_t)(uintptr_t)rd_end) {
		_kobj_printf(ops, "diskread: start = 0x%p, size = 0x%x\n",
		    diskloc, filep->fi_count);
		_kobj_printf(ops, "reading beyond end of ramdisk\n");
		return (-1);
	}

	if (filep->fi_memp) {
		bcopy(diskloc, filep->fi_memp, filep->fi_count);
	} else {
		/* "cached" read */
		filep->fi_memp = diskloc;
	}

	return (0);
}

int
kobj_boot_mountroot()
{
	int i;

	if (BOP_GETPROPLEN(ops, "ramdisk_start") != 8 ||
	    BOP_GETPROP(ops, "ramdisk_start", (void *)&rd_start) != 0 ||
	    BOP_GETPROPLEN(ops, "ramdisk_end") != 8 ||
	    BOP_GETPROP(ops, "ramdisk_end", (void *)&rd_end) != 0) {
		_kobj_printf(ops,
		    "failed to get ramdisk from boot\n");
		return (-1);
	}
#ifdef KOBJ_DEBUG
	_kobj_printf(ops,
	    "ramdisk range: 0x%llx-%llx\n", rd_start, rd_end);
#endif

	for (i = 0; bfs_tab[i] != NULL; i++) {
		bfs_ops = bfs_tab[i];
		if (BRD_MOUNTROOT(bfs_ops, "dummy") == 0)
			return (0);
	}
	_kobj_printf(ops, "failed to mount ramdisk from boot\n");
	return (-1);
}

void
kobj_boot_unmountroot()
{
#ifdef	DEBUG
	if (boothowto & RB_VERBOSE)
		_kobj_printf(ops, "boot scratch memory used: 0x%lx\n",
		    scratch_max);
#endif
	(void) BRD_UNMOUNTROOT(bfs_ops);
}

/*
 * Boot time wrappers for memory allocators. Called for both permanent
 * and temporary boot memory allocations. We have to track which allocator
 * (boot or kmem) was used so that we know how to free.
 */
void *
bkmem_alloc(size_t size)
{
	/* allocate from boot scratch memory */
	void *addr;

	if (_kmem_ready)
		return (kobj_alloc(size, 0));

	/*
	 * Remember the highest BOP_ALLOC allocated address and don't free
	 * anything below it.
	 */
	addr = BOP_ALLOC(ops, 0, size, 0);
	if (scratch_max < (uintptr_t)addr + size)
		scratch_max = (uintptr_t)addr + size;
	return (addr);
}

/*ARGSUSED*/
void
bkmem_free(void *p, size_t size)
{
	/*
	 * Free only if it's not boot scratch memory.
	 */
	if ((uintptr_t)p >= scratch_max)
		kobj_free(p, size);
}

/*PRINTFLIKE1*/
void
kobj_printf(char *fmt, ...)
{
	va_list adx;

	va_start(adx, fmt);
	_kobj_printf(ops, fmt, adx);
	va_end(adx);
}