stand/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 <stand.h>
  31 #include <sys/param.h>
  32 #include <sys/endian.h>
  33 #include <sys/queue.h>
  34 #include <machine/stdarg.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 int 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         NULL
  78 };
  79
  80 static int
  81 md_init(void)
  82 {
  83
  84         return (0);
  85 }
  86
  87 static int
  88 md_strategy(void *devdata, int rw, daddr_t blk, size_t size,
  89     char *buf, size_t *rsize)
  90 {
  91         struct devdesc *dev = (struct devdesc *)devdata;
  92         size_t ofs;
  93
  94         if (dev->d_unit != 0)
  95                 return (ENXIO);
  96
  97         if (blk < 0 || blk >= (MD_IMAGE_SIZE / MD_BLOCK_SIZE))
  98                 return (EIO);
  99
 100         if (size % MD_BLOCK_SIZE)
 101                 return (EIO);
 102
 103         ofs = blk * MD_BLOCK_SIZE;
 104         if ((ofs + size) > MD_IMAGE_SIZE)
 105                 size = MD_IMAGE_SIZE - ofs;
 106
 107         if (rsize != NULL)
 108                 *rsize = size;
 109
 110         switch (rw & F_MASK) {
 111         case F_READ:
 112                 bcopy(md_image.start + ofs, buf, size);
 113                 return (0);
 114         case F_WRITE:
 115                 bcopy(buf, md_image.start + ofs, size);
 116                 return (0);
 117         }
 118
 119         return (ENODEV);
 120 }
 121
 122 static int
 123 md_open(struct open_file *f, ...)
 124 {
 125         va_list ap;
 126         struct devdesc *dev;
 127
 128         va_start(ap, f);
 129         dev = va_arg(ap, struct devdesc *);
 130         va_end(ap);
 131
 132         if (dev->d_unit != 0)
 133                 return (ENXIO);
 134
 135         return (0);
 136 }
 137
 138 static int
 139 md_close(struct open_file *f)
 140 {
 141         struct devdesc *dev;
 142
 143         dev = (struct devdesc *)(f->f_devdata);
 144         return ((dev->d_unit != 0) ? ENXIO : 0);
 145 }
 146
 147 static int
 148 md_print(int verbose)
 149 {
 150
 151         printf("%s devices:", md_dev.dv_name);
 152         if (pager_output("\n") != 0)
 153                 return (1);
 154
 155         printf("MD (%u bytes)", MD_IMAGE_SIZE);
 156         return (pager_output("\n"));
 157 }