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