usr/src/uts/common/krtld/bootrd.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  * Copyright 2013 Joyent, Inc.  All rights reserved.
  25  */
  26
  27
  28 #include <sys/param.h>
  29 #include <sys/sunddi.h>
  30 #include <sys/bootconf.h>
  31 #include <sys/bootvfs.h>
  32 #include <sys/filep.h>
  33 #include <sys/kobj.h>
  34 #include <sys/varargs.h>
  35 #include <sys/reboot.h>
  36
  37 extern void (*_kobj_printf)(void *, const char *fmt, ...);
  38 extern int get_weakish_int(int *);
  39 extern struct bootops *ops;
  40 extern struct boot_fs_ops bufs_ops, bhsfs_ops, bbootfs_ops, bcpio_ops;
  41 extern int kmem_ready;
  42
  43 static uint64_t rd_start, rd_end;
  44 struct boot_fs_ops *bfs_ops;
  45 struct boot_fs_ops *bfs_tab[] = {
  46         &bufs_ops, &bhsfs_ops, &bbootfs_ops, &bcpio_ops, NULL,
  47 };
  48
  49 static uintptr_t scratch_max = 0;
  50
  51 #define _kmem_ready     get_weakish_int(&kmem_ready)
  52
  53 int
  54 BRD_MOUNTROOT(struct boot_fs_ops *ops, char *str)
  55 {
  56         return (ops->fsw_mountroot(str));
  57 }
  58
  59 int
  60 BRD_UNMOUNTROOT(struct boot_fs_ops *ops)
  61 {
  62         if (bfs_ops != &bbootfs_ops)
  63                 bbootfs_ops.fsw_closeall(1);
  64
  65         return (ops->fsw_unmountroot());
  66 }
  67
  68 int
  69 BRD_OPEN(struct boot_fs_ops *ops, char *file, int flags)
  70 {
  71         int len = strlen(SYSTEM_BOOT_PATH);
  72         int fd;
  73
  74         /*
  75          * Our policy is that we try bootfs first.  If bootfs is the only
  76          * filesystem, that's the end of it.  Otherwise we will fall back to
  77          * the normal root (i.e., ramdisk) filesystem at this point and try
  78          * again if the file does not exist in bootfs.
  79          */
  80         fd = bbootfs_ops.fsw_open(file, flags);
  81
  82         if (bfs_ops == &bbootfs_ops)
  83                 return (fd);
  84
  85         if (strncmp(file, SYSTEM_BOOT_PATH, len) == 0 || fd >= 0)
  86                 return ((fd < 0) ? fd : (fd | BFD_F_SYSTEM_BOOT));
  87
  88         return (ops->fsw_open(file, flags));
  89 }
  90
  91 int
  92 BRD_CLOSE(struct boot_fs_ops *ops, int fd)
  93 {
  94         if (fd & BFD_F_SYSTEM_BOOT)
  95                 return (bbootfs_ops.fsw_close(fd & ~BFD_F_SYSTEM_BOOT));
  96
  97         return (ops->fsw_close(fd));
  98 }
  99
 100 ssize_t
 101 BRD_READ(struct boot_fs_ops *ops, int fd, caddr_t buf, size_t len)
 102 {
 103         if (fd & BFD_F_SYSTEM_BOOT) {
 104                 return (bbootfs_ops.fsw_read(fd & ~BFD_F_SYSTEM_BOOT,
 105                     buf, len));
 106         }
 107
 108         return (ops->fsw_read(fd, buf, len));
 109 }
 110
 111 off_t
 112 BRD_SEEK(struct boot_fs_ops *ops, int fd, off_t addr, int whence)
 113 {
 114         if (fd & BFD_F_SYSTEM_BOOT) {
 115                 return (bbootfs_ops.fsw_lseek(fd & ~BFD_F_SYSTEM_BOOT,
 116                     addr, whence));
 117         }
 118
 119         return (ops->fsw_lseek(fd, addr, whence));
 120 }
 121
 122 int
 123 BRD_FSTAT(struct boot_fs_ops *ops, int fd, struct bootstat *bsp)
 124 {
 125         if (fd & BFD_F_SYSTEM_BOOT)
 126                 return (bbootfs_ops.fsw_fstat(fd & ~BFD_F_SYSTEM_BOOT, bsp));
 127
 128         return (ops->fsw_fstat(fd, bsp));
 129 }
 130
 131 /*
 132  * This one reads the ramdisk. If fi_memp is set, we copy the
 133  * ramdisk content to the designated buffer. Otherwise, we
 134  * do a "cached" read (set fi_memp to the actual ramdisk buffer).
 135  */
 136 int
 137 diskread(fileid_t *filep)
 138 {
 139         uint_t blocknum;
 140         caddr_t diskloc;
 141
 142         /* add in offset of root slice */
 143         blocknum = filep->fi_blocknum;
 144
 145         diskloc = (caddr_t)(uintptr_t)rd_start + blocknum * DEV_BSIZE;
 146         if (diskloc + filep->fi_count > (caddr_t)(uintptr_t)rd_end) {
 147                 _kobj_printf(ops, "diskread: start = 0x%p, size = 0x%x\n",
 148                     diskloc, filep->fi_count);
 149                 _kobj_printf(ops, "reading beyond end of ramdisk\n");
 150                 return (-1);
 151         }
 152
 153         if (filep->fi_memp) {
 154                 bcopy(diskloc, filep->fi_memp, filep->fi_count);
 155         } else {
 156                 /* "cached" read */
 157                 filep->fi_memp = diskloc;
 158         }
 159
 160         return (0);
 161 }
 162
 163 int
 164 kobj_boot_mountroot()
 165 {
 166         int i;
 167
 168         if (BOP_GETPROPLEN(ops, "ramdisk_start") != 8 ||
 169             BOP_GETPROP(ops, "ramdisk_start", (void *)&rd_start) != 0 ||
 170             BOP_GETPROPLEN(ops, "ramdisk_end") != 8 ||
 171             BOP_GETPROP(ops, "ramdisk_end", (void *)&rd_end) != 0) {
 172                 _kobj_printf(ops,
 173                     "failed to get ramdisk from boot\n");
 174                 return (-1);
 175         }
 176 #ifdef KOBJ_DEBUG
 177         _kobj_printf(ops,
 178             "ramdisk range: 0x%llx-%llx\n", rd_start, rd_end);
 179 #endif
 180
 181         /*
 182          * We have a range of virtual addresses which are the boot archive.
 183          */
 184         for (i = 0; bfs_tab[i] != NULL; i++) {
 185                 bfs_ops = bfs_tab[i];
 186                 if (BRD_MOUNTROOT(bfs_ops, "dummy") == 0)
 187                         return (0);
 188         }
 189
 190         _kobj_printf(ops, "failed to mount ramdisk from boot\n");
 191         return (-1);
 192 }
 193
 194 void
 195 kobj_boot_unmountroot()
 196 {
 197 #ifdef  DEBUG
 198         if (boothowto & RB_VERBOSE)
 199                 _kobj_printf(ops, "boot scratch memory used: 0x%lx\n",
 200                     scratch_max);
 201 #endif
 202         (void) BRD_UNMOUNTROOT(bfs_ops);
 203 }
 204
 205 /*
 206  * Boot time wrappers for memory allocators. Called for both permanent
 207  * and temporary boot memory allocations. We have to track which allocator
 208  * (boot or kmem) was used so that we know how to free.
 209  */
 210 void *
 211 bkmem_alloc(size_t size)
 212 {
 213         /* allocate from boot scratch memory */
 214         void *addr;
 215
 216         if (_kmem_ready)
 217                 return (kobj_alloc(size, 0));
 218
 219         /*
 220          * Remember the highest BOP_ALLOC allocated address and don't free
 221          * anything below it.
 222          */
 223         addr = BOP_ALLOC(ops, 0, size, 0);
 224         if (scratch_max < (uintptr_t)addr + size)
 225                 scratch_max = (uintptr_t)addr + size;
 226         return (addr);
 227 }
 228
 229 /*ARGSUSED*/
 230 void
 231 bkmem_free(void *p, size_t size)
 232 {
 233         /*
 234          * Free only if it's not boot scratch memory.
 235          */
 236         if ((uintptr_t)p >= scratch_max)
 237                 kobj_free(p, size);
 238 }
 239
 240 /*PRINTFLIKE1*/
 241 void
 242 kobj_printf(char *fmt, ...)
 243 {
 244         va_list adx;
 245
 246         va_start(adx, fmt);
 247         _kobj_printf(ops, fmt, adx);
 248         va_end(adx);
 249 }