sys/boot/common/md.c

   1 /*-
   2  * Copyright (c) 2009 Marcel Moolenaar
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31 #include <sys/endian.h>
  32 #include <sys/queue.h>
  33 #include <machine/stdarg.h>
  34 #include <stand.h>
  35
  36 #include "bootstrap.h"
  37
  38 #define MD_BLOCK_SIZE   512
  39
  40 #ifndef MD_IMAGE_SIZE
  41 #error Must be compiled with MD_IMAGE_SIZE defined
  42 #endif
  43 #if (MD_IMAGE_SIZE == 0 || MD_IMAGE_SIZE % MD_BLOCK_SIZE)
  44 #error Image size must be a multiple of 512.
  45 #endif
  46
  47 /*
  48  * Preloaded image gets put here.
  49  * Applications that patch the object with the image can determine
  50  * the size looking at the start and end markers (strings),
  51  * so we want them contiguous.
  52  */
  53 static struct {
  54         u_char start[MD_IMAGE_SIZE];
  55         u_char end[128];
  56 } md_image = {
  57         .start = "MFS Filesystem goes here",
  58         .end = "MFS Filesystem had better STOP here",
  59 };
  60
  61 /* devsw I/F */
  62 static int md_init(void);
  63 static int md_strategy(void *, int, daddr_t, size_t, char *, size_t *);
  64 static int md_open(struct open_file *, ...);
  65 static int md_close(struct open_file *);
  66 static void md_print(int);
  67
  68 struct devsw md_dev = {
  69         "md",
  70         DEVT_DISK,
  71         md_init,
  72         md_strategy,
  73         md_open,
  74         md_close,
  75         noioctl,
  76         md_print
  77 };
  78
  79 static int
  80 md_init(void)
  81 {
  82
  83         return (0);
  84 }
  85
  86 static int
  87 md_strategy(void *devdata, int rw, daddr_t blk, size_t size, char *buf,
  88     size_t *rsize)
  89 {
  90         struct devdesc *dev = (struct devdesc *)devdata;
  91         size_t ofs;
  92
  93         if (dev->d_unit != 0)
  94                 return (ENXIO);
  95
  96         if (blk < 0 || blk >= (MD_IMAGE_SIZE / MD_BLOCK_SIZE))
  97                 return (EIO);
  98
  99         if (size % MD_BLOCK_SIZE)
 100                 return (EIO);
 101
 102         ofs = blk * MD_BLOCK_SIZE;
 103         if ((ofs + size) > MD_IMAGE_SIZE)
 104                 size = MD_IMAGE_SIZE - ofs;
 105
 106         if (rsize != 0)
 107                 *rsize = size;
 108
 109         switch (rw) {
 110         case F_READ:
 111                 bcopy(md_image.start + ofs, buf, size);
 112                 return (0);
 113         case F_WRITE:
 114                 bcopy(buf, md_image.start + ofs, size);
 115                 return (0);
 116         }
 117
 118         return (ENODEV);
 119 }
 120
 121 static int
 122 md_open(struct open_file *f, ...)
 123 {
 124         va_list ap;
 125         struct devdesc *dev;
 126
 127         va_start(ap, f);
 128         dev = va_arg(ap, struct devdesc *);
 129         va_end(ap);
 130
 131         if (dev->d_unit != 0)
 132                 return (ENXIO);
 133
 134         return (0);
 135 }
 136
 137 static int
 138 md_close(struct open_file *f)
 139 {
 140         struct devdesc *dev;
 141
 142         dev = (struct devdesc *)(f->f_devdata);
 143         return ((dev->d_unit != 0) ? ENXIO : 0);
 144 }
 145
 146 static void
 147 md_print(int verbose)
 148 {
 149
 150         printf("MD (%u bytes)\n", MD_IMAGE_SIZE);
 151 }