sys/dev/disk/md/md.c

   1 /*
   2  * ----------------------------------------------------------------------------
   3  * "THE BEER-WARE LICENSE" (Revision 42):
   4  * <phk@FreeBSD.ORG> wrote this file.  As long as you retain this notice you
   5  * can do whatever you want with this stuff. If we meet some day, and you think
   6  * this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
   7  * ----------------------------------------------------------------------------
   8  *
   9  * $FreeBSD: src/sys/dev/md/md.c,v 1.8.2.2 2002/08/19 17:43:34 jdp Exp $
  10  * $DragonFly: src/sys/dev/disk/md/md.c,v 1.2 2003/06/17 04:28:28 dillon Exp $
  11  *
  12  */
  13
  14 #include "opt_mfs.h"            /* We have adopted some tasks from MFS */
  15 #include "opt_md.h"             /* We have adopted some tasks from MFS */
  16
  17 #include <sys/param.h>
  18 #include <sys/systm.h>
  19 #include <sys/buf.h>
  20 #include <sys/conf.h>
  21 #include <sys/devicestat.h>
  22 #include <sys/disk.h>
  23 #include <sys/kernel.h>
  24 #include <sys/malloc.h>
  25 #include <sys/sysctl.h>
  26 #include <sys/linker.h>
  27
  28 #ifndef MD_NSECT
  29 #define MD_NSECT (10000 * 2)
  30 #endif
  31
  32 MALLOC_DEFINE(M_MD, "MD disk", "Memory Disk");
  33 MALLOC_DEFINE(M_MDSECT, "MD sectors", "Memory Disk Sectors");
  34
  35 static int md_debug;
  36 SYSCTL_INT(_debug, OID_AUTO, mddebug, CTLFLAG_RW, &md_debug, 0, "");
  37
  38 #if defined(MFS_ROOT) && !defined(MD_ROOT)
  39 #define MD_ROOT MFS_ROOT
  40 #warning "option MFS_ROOT has been superceeded by MD_ROOT"
  41 #endif
  42
  43 #if defined(MFS_ROOT_SIZE) && !defined(MD_ROOT_SIZE)
  44 #define MD_ROOT_SIZE MFS_ROOT_SIZE
  45 #warning "option MFS_ROOT_SIZE has been superceeded by MD_ROOT_SIZE"
  46 #endif
  47
  48 #if defined(MD_ROOT) && defined(MD_ROOT_SIZE)
  49 /* Image gets put here: */
  50 static u_char mfs_root[MD_ROOT_SIZE*1024] = "MFS Filesystem goes here";
  51 static u_char end_mfs_root[] __unused = "MFS Filesystem had better STOP here";
  52 #endif
  53
  54 static int mdrootready;
  55
  56 static void mdcreate_malloc(void);
  57
  58 #define CDEV_MAJOR      95
  59 #define BDEV_MAJOR      22
  60
  61 static d_strategy_t mdstrategy;
  62 static d_strategy_t mdstrategy_preload;
  63 static d_strategy_t mdstrategy_malloc;
  64 static d_open_t mdopen;
  65 static d_ioctl_t mdioctl;
  66
  67 static struct cdevsw md_cdevsw = {
  68         /* open */      mdopen,
  69         /* close */     nullclose,
  70         /* read */      physread,
  71         /* write */     physwrite,
  72         /* ioctl */     mdioctl,
  73         /* poll */      nopoll,
  74         /* mmap */      nommap,
  75         /* strategy */  mdstrategy,
  76         /* name */      "md",
  77         /* maj */       CDEV_MAJOR,
  78         /* dump */      nodump,
  79         /* psize */     nopsize,
  80         /* flags */     D_DISK | D_CANFREE | D_MEMDISK,
  81         /* bmaj */      BDEV_MAJOR
  82 };
  83
  84 static struct cdevsw mddisk_cdevsw;
  85
  86 struct md_s {
  87         int unit;
  88         struct devstat stats;
  89         struct buf_queue_head buf_queue;
  90         struct disk disk;
  91         dev_t dev;
  92         int busy;
  93         enum {MD_MALLOC, MD_PRELOAD} type;
  94         unsigned nsect;
  95
  96         /* MD_MALLOC related fields */
  97         unsigned nsecp;
  98         u_char **secp;
  99
 100         /* MD_PRELOAD related fields */
 101         u_char *pl_ptr;
 102         unsigned pl_len;
 103 };
 104
 105 static int mdunits;
 106
 107 static int
 108 mdopen(dev_t dev, int flag, int fmt, struct proc *p)
 109 {
 110         struct md_s *sc;
 111         struct disklabel *dl;
 112
 113         if (md_debug)
 114                 printf("mdopen(%s %x %x %p)\n",
 115                         devtoname(dev), flag, fmt, p);
 116
 117         sc = dev->si_drv1;
 118         if (sc->unit + 1 == mdunits)
 119                 mdcreate_malloc();
 120
 121         dl = &sc->disk.d_label;
 122         bzero(dl, sizeof(*dl));
 123         dl->d_secsize = DEV_BSIZE;
 124         dl->d_nsectors = 1024;
 125         dl->d_ntracks = 1;
 126         dl->d_secpercyl = dl->d_nsectors * dl->d_ntracks;
 127         dl->d_secperunit = sc->nsect;
 128         dl->d_ncylinders = dl->d_secperunit / dl->d_secpercyl;
 129         return (0);
 130 }
 131
 132 static int
 133 mdioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct proc *p)
 134 {
 135
 136         if (md_debug)
 137                 printf("mdioctl(%s %lx %p %x %p)\n",
 138                         devtoname(dev), cmd, addr, flags, p);
 139
 140         return (ENOIOCTL);
 141 }
 142
 143 static void
 144 mdstrategy(struct buf *bp)
 145 {
 146         struct md_s *sc;
 147
 148         if (md_debug > 1)
 149                 printf("mdstrategy(%p) %s %lx, %d, %ld, %p)\n",
 150                     bp, devtoname(bp->b_dev), bp->b_flags, bp->b_blkno,
 151                     bp->b_bcount / DEV_BSIZE, bp->b_data);
 152
 153         sc = bp->b_dev->si_drv1;
 154         if (sc->type == MD_MALLOC) {
 155                 mdstrategy_malloc(bp);
 156         } else {
 157                 mdstrategy_preload(bp);
 158         }
 159         return;
 160 }
 161
 162
 163 static void
 164 mdstrategy_malloc(struct buf *bp)
 165 {
 166         int s, i;
 167         struct md_s *sc;
 168         devstat_trans_flags dop;
 169         u_char *secp, **secpp, *dst;
 170         unsigned secno, nsec, secval, uc;
 171
 172         if (md_debug > 1)
 173                 printf("mdstrategy_malloc(%p) %s %lx, %d, %ld, %p)\n",
 174                     bp, devtoname(bp->b_dev), bp->b_flags, bp->b_blkno,
 175                     bp->b_bcount / DEV_BSIZE, bp->b_data);
 176
 177         sc = bp->b_dev->si_drv1;
 178
 179         s = splbio();
 180
 181         bufqdisksort(&sc->buf_queue, bp);
 182
 183         if (sc->busy) {
 184                 splx(s);
 185                 return;
 186         }
 187
 188         sc->busy++;
 189
 190         while (1) {
 191                 bp = bufq_first(&sc->buf_queue);
 192                 if (bp)
 193                         bufq_remove(&sc->buf_queue, bp);
 194                 splx(s);
 195                 if (!bp)
 196                         break;
 197
 198                 devstat_start_transaction(&sc->stats);
 199
 200                 if (bp->b_flags & B_FREEBUF)
 201                         dop = DEVSTAT_NO_DATA;
 202                 else if (bp->b_flags & B_READ)
 203                         dop = DEVSTAT_READ;
 204                 else
 205                         dop = DEVSTAT_WRITE;
 206
 207                 nsec = bp->b_bcount / DEV_BSIZE;
 208                 secno = bp->b_pblkno;
 209                 dst = bp->b_data;
 210                 while (nsec--) {
 211
 212                         if (secno < sc->nsecp) {
 213                                 secpp = &sc->secp[secno];
 214                                 if ((u_int)*secpp > 255) {
 215                                         secp = *secpp;
 216                                         secval = 0;
 217                                 } else {
 218                                         secp = 0;
 219                                         secval = (u_int) *secpp;
 220                                 }
 221                         } else {
 222                                 secpp = 0;
 223                                 secp = 0;
 224                                 secval = 0;
 225                         }
 226                         if (md_debug > 2)
 227                                 printf("%lx %p %p %d\n", bp->b_flags, secpp, secp, secval);
 228
 229                         if (bp->b_flags & B_FREEBUF) {
 230                                 if (secpp) {
 231                                         if (secp)
 232                                                 FREE(secp, M_MDSECT);
 233                                         *secpp = 0;
 234                                 }
 235                         } else if (bp->b_flags & B_READ) {
 236                                 if (secp) {
 237                                         bcopy(secp, dst, DEV_BSIZE);
 238                                 } else if (secval) {
 239                                         for (i = 0; i < DEV_BSIZE; i++)
 240                                                 dst[i] = secval;
 241                                 } else {
 242                                         bzero(dst, DEV_BSIZE);
 243                                 }
 244                         } else {
 245                                 uc = dst[0];
 246                                 for (i = 1; i < DEV_BSIZE; i++)
 247                                         if (dst[i] != uc)
 248                                                 break;
 249                                 if (i == DEV_BSIZE && !uc) {
 250                                         if (secp)
 251                                                 FREE(secp, M_MDSECT);
 252                                         if (secpp)
 253                                                 *secpp = (u_char *)uc;
 254                                 } else {
 255                                         if (!secpp) {
 256                                                 MALLOC(secpp, u_char **, (secno + nsec + 1) * sizeof(u_char *), M_MD, M_WAITOK);
 257                                                 bzero(secpp, (secno + nsec + 1) * sizeof(u_char *));
 258                                                 bcopy(sc->secp, secpp, sc->nsecp * sizeof(u_char *));
 259                                                 FREE(sc->secp, M_MD);
 260                                                 sc->secp = secpp;
 261                                                 sc->nsecp = secno + nsec + 1;
 262                                                 secpp = &sc->secp[secno];
 263                                         }
 264                                         if (i == DEV_BSIZE) {
 265                                                 if (secp)
 266                                                         FREE(secp, M_MDSECT);
 267                                                 *secpp = (u_char *)uc;
 268                                         } else {
 269                                                 if (!secp)
 270                                                         MALLOC(secp, u_char *, DEV_BSIZE, M_MDSECT, M_WAITOK);
 271                                                 bcopy(dst, secp, DEV_BSIZE);
 272
 273                                                 *secpp = secp;
 274                                         }
 275                                 }
 276                         }
 277                         secno++;
 278                         dst += DEV_BSIZE;
 279                 }
 280                 bp->b_resid = 0;
 281                 devstat_end_transaction_buf(&sc->stats, bp);
 282                 biodone(bp);
 283                 s = splbio();
 284         }
 285         sc->busy = 0;
 286         return;
 287 }
 288
 289
 290 static void
 291 mdstrategy_preload(struct buf *bp)
 292 {
 293         int s;
 294         struct md_s *sc;
 295         devstat_trans_flags dop;
 296
 297         if (md_debug > 1)
 298                 printf("mdstrategy_preload(%p) %s %lx, %d, %ld, %p)\n",
 299                     bp, devtoname(bp->b_dev), bp->b_flags, bp->b_blkno,
 300                     bp->b_bcount / DEV_BSIZE, bp->b_data);
 301
 302         sc = bp->b_dev->si_drv1;
 303
 304         s = splbio();
 305
 306         bufqdisksort(&sc->buf_queue, bp);
 307
 308         if (sc->busy) {
 309                 splx(s);
 310                 return;
 311         }
 312
 313         sc->busy++;
 314
 315         while (1) {
 316                 bp = bufq_first(&sc->buf_queue);
 317                 if (bp)
 318                         bufq_remove(&sc->buf_queue, bp);
 319                 splx(s);
 320                 if (!bp)
 321                         break;
 322
 323                 devstat_start_transaction(&sc->stats);
 324
 325                 if (bp->b_flags & B_FREEBUF) {
 326                         dop = DEVSTAT_NO_DATA;
 327                 } else if (bp->b_flags & B_READ) {
 328                         dop = DEVSTAT_READ;
 329                         bcopy(sc->pl_ptr + (bp->b_pblkno << DEV_BSHIFT), bp->b_data, bp->b_bcount);
 330                 } else {
 331                         dop = DEVSTAT_WRITE;
 332                         bcopy(bp->b_data, sc->pl_ptr + (bp->b_pblkno << DEV_BSHIFT), bp->b_bcount);
 333                 }
 334                 bp->b_resid = 0;
 335                 devstat_end_transaction_buf(&sc->stats, bp);
 336                 biodone(bp);
 337                 s = splbio();
 338         }
 339         sc->busy = 0;
 340         return;
 341 }
 342
 343 static struct md_s *
 344 mdcreate(void)
 345 {
 346         struct md_s *sc;
 347
 348         MALLOC(sc, struct md_s *,sizeof(*sc), M_MD, M_WAITOK);
 349         bzero(sc, sizeof(*sc));
 350         sc->unit = mdunits++;
 351         bufq_init(&sc->buf_queue);
 352         devstat_add_entry(&sc->stats, "md", sc->unit, DEV_BSIZE,
 353                 DEVSTAT_NO_ORDERED_TAGS,
 354                 DEVSTAT_TYPE_DIRECT | DEVSTAT_TYPE_IF_OTHER,
 355                 DEVSTAT_PRIORITY_OTHER);
 356         sc->dev = disk_create(sc->unit, &sc->disk, 0, &md_cdevsw, &mddisk_cdevsw);
 357         sc->dev->si_drv1 = sc;
 358         return (sc);
 359 }
 360
 361 static void
 362 mdcreate_preload(u_char *image, unsigned length)
 363 {
 364         struct md_s *sc;
 365
 366         sc = mdcreate();
 367         sc->type = MD_PRELOAD;
 368         sc->nsect = length / DEV_BSIZE;
 369         sc->pl_ptr = image;
 370         sc->pl_len = length;
 371
 372         if (sc->unit == 0)
 373                 mdrootready = 1;
 374 }
 375
 376 static void
 377 mdcreate_malloc(void)
 378 {
 379         struct md_s *sc;
 380
 381         sc = mdcreate();
 382         sc->type = MD_MALLOC;
 383
 384         sc->nsect = MD_NSECT;   /* for now */
 385         MALLOC(sc->secp, u_char **, sizeof(u_char *), M_MD, M_WAITOK);
 386         bzero(sc->secp, sizeof(u_char *));
 387         sc->nsecp = 1;
 388         printf("md%d: Malloc disk\n", sc->unit);
 389 }
 390
 391 static void
 392 md_drvinit(void *unused)
 393 {
 394
 395         caddr_t mod;
 396         caddr_t c;
 397         u_char *ptr, *name, *type;
 398         unsigned len;
 399
 400 #ifdef MD_ROOT_SIZE
 401         mdcreate_preload(mfs_root, MD_ROOT_SIZE*1024);
 402 #endif
 403         mod = NULL;
 404         while ((mod = preload_search_next_name(mod)) != NULL) {
 405                 name = (char *)preload_search_info(mod, MODINFO_NAME);
 406                 type = (char *)preload_search_info(mod, MODINFO_TYPE);
 407                 if (name == NULL)
 408                         continue;
 409                 if (type == NULL)
 410                         continue;
 411                 if (strcmp(type, "md_image") && strcmp(type, "mfs_root"))
 412                         continue;
 413                 c = preload_search_info(mod, MODINFO_ADDR);
 414                 ptr = *(u_char **)c;
 415                 c = preload_search_info(mod, MODINFO_SIZE);
 416                 len = *(unsigned *)c;
 417                 printf("md%d: Preloaded image <%s> %d bytes at %p\n",
 418                    mdunits, name, len, ptr);
 419                 mdcreate_preload(ptr, len);
 420         }
 421         mdcreate_malloc();
 422 }
 423
 424 SYSINIT(mddev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR, md_drvinit,NULL)
 425
 426 #ifdef MD_ROOT
 427 static void
 428 md_takeroot(void *junk)
 429 {
 430         if (mdrootready)
 431                 rootdevnames[0] = "ufs:/dev/md0c";
 432 }
 433
 434 SYSINIT(md_root, SI_SUB_MOUNT_ROOT, SI_ORDER_FIRST, md_takeroot, NULL);
 435 #endif