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$ 10 * 11 */ 12 13 /* 14 * The following functions are based in the vn(4) driver: mdstart_swap(), 15 * mdstart_vnode(), mdcreate_swap(), mdcreate_vnode() and mddestroy(), 16 * and as such under the following copyright: 17 * 18 * Copyright (c) 1988 University of Utah. 19 * Copyright (c) 1990, 1993 20 * The Regents of the University of California. All rights reserved. 21 * 22 * This code is derived from software contributed to Berkeley by 23 * the Systems Programming Group of the University of Utah Computer 24 * Science Department. 25 * 26 * Redistribution and use in source and binary forms, with or without 27 * modification, are permitted provided that the following conditions 28 * are met: 29 * 1. Redistributions of source code must retain the above copyright 30 * notice, this list of conditions and the following disclaimer. 31 * 2. Redistributions in binary form must reproduce the above copyright 32 * notice, this list of conditions and the following disclaimer in the 33 * documentation and/or other materials provided with the distribution. 34 * 3. All advertising materials mentioning features or use of this software 35 * must display the following acknowledgement: 36 * This product includes software developed by the University of 37 * California, Berkeley and its contributors. 38 * 4. Neither the name of the University nor the names of its contributors 39 * may be used to endorse or promote products derived from this software 40 * without specific prior written permission. 41 * 42 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 43 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 44 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 45 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 46 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 47 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 48 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 49 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 50 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 51 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 52 * SUCH DAMAGE. 53 * 54 * from: Utah Hdr: vn.c 1.13 94/04/02 55 * 56 * from: @(#)vn.c 8.6 (Berkeley) 4/1/94 57 * From: src/sys/dev/vn/vn.c,v 1.122 2000/12/16 16:06:03 58 */ 59 60 #include "opt_md.h" 61 62 #include <sys/param.h> 63 #include <sys/systm.h> 64 #include <sys/bio.h> 65 #include <sys/conf.h> 66 #include <sys/devicestat.h> 67 #include <sys/disk.h> 68 #include <sys/fcntl.h> 69 #include <sys/kernel.h> 70 #include <sys/linker.h> 71 #include <sys/lock.h> 72 #include <sys/malloc.h> 73 #include <sys/mdioctl.h> 74 #include <sys/mutex.h> 75 #include <sys/namei.h> 76 #include <sys/proc.h> 77 #include <sys/queue.h> 78 #include <sys/sysctl.h> 79 #include <sys/vnode.h> 80 81 #include <machine/atomic.h> 82 83 #include <vm/vm.h> 84 #include <vm/vm_object.h> 85 #include <vm/vm_page.h> 86 #include <vm/vm_pager.h> 87 #include <vm/vm_zone.h> 88 #include <vm/swap_pager.h> 89 90 #define MD_MODVER 1 91 92 #ifndef MD_NSECT 93 #define MD_NSECT (10000 * 2) 94 #endif 95 96 MALLOC_DEFINE(M_MD, "MD disk", "Memory Disk"); 97 MALLOC_DEFINE(M_MDSECT, "MD sectors", "Memory Disk Sectors"); 98 99 static int md_debug; 100 SYSCTL_INT(_debug, OID_AUTO, mddebug, CTLFLAG_RW, &md_debug, 0, ""); 101 102 #if defined(MD_ROOT) && defined(MD_ROOT_SIZE) 103 /* Image gets put here: */ 104 static u_char mfs_root[MD_ROOT_SIZE*1024] = "MFS Filesystem goes here"; 105 static u_char end_mfs_root[] __unused = "MFS Filesystem had better STOP here"; 106 #endif 107 108 static int mdrootready; 109 static int mdunits; 110 static dev_t status_dev = 0; 111 112 113 #define CDEV_MAJOR 95 114 115 static d_strategy_t mdstrategy; 116 static d_open_t mdopen; 117 static d_ioctl_t mdioctl, mdctlioctl; 118 119 static struct cdevsw md_cdevsw = { 120 /* open */ mdopen, 121 /* close */ nullclose, 122 /* read */ physread, 123 /* write */ physwrite, 124 /* ioctl */ mdioctl, 125 /* poll */ nopoll, 126 /* mmap */ nommap, 127 /* strategy */ mdstrategy, 128 /* name */ MD_NAME, 129 /* maj */ CDEV_MAJOR, 130 /* dump */ nodump, 131 /* psize */ nopsize, 132 /* flags */ D_DISK | D_CANFREE | D_MEMDISK, 133 }; 134 135 static struct cdevsw mdctl_cdevsw = { 136 /* open */ nullopen, 137 /* close */ nullclose, 138 /* read */ noread, 139 /* write */ nowrite, 140 /* ioctl */ mdctlioctl, 141 /* poll */ nopoll, 142 /* mmap */ nommap, 143 /* strategy */ nostrategy, 144 /* name */ MD_NAME, 145 /* maj */ CDEV_MAJOR 146 }; 147 148 static struct cdevsw mddisk_cdevsw; 149 150 static LIST_HEAD(, md_s) md_softc_list = LIST_HEAD_INITIALIZER(&md_softc_list); 151 152 struct md_s { 153 int unit; 154 LIST_ENTRY(md_s) list; 155 struct devstat stats; 156 struct bio_queue_head bio_queue; 157 struct disk disk; 158 dev_t dev; 159 int busy; 160 enum md_types type; 161 unsigned nsect; 162 unsigned secsize; 163 unsigned flags; 164 165 /* MD_MALLOC related fields */ 166 u_char **secp; 167 168 /* MD_PRELOAD related fields */ 169 u_char *pl_ptr; 170 unsigned pl_len; 171 172 /* MD_VNODE related fields */ 173 struct vnode *vnode; 174 struct ucred *cred; 175 176 /* MD_OBJET related fields */ 177 vm_object_t object; 178 }; 179 180 static int 181 mdopen(dev_t dev, int flag, int fmt, struct proc *p) 182 { 183 struct md_s *sc; 184 struct disklabel *dl; 185 186 if (md_debug) 187 printf("mdopen(%s %x %x %p)\n", 188 devtoname(dev), flag, fmt, p); 189 190 sc = dev->si_drv1; 191 192 dl = &sc->disk.d_label; 193 bzero(dl, sizeof(*dl)); 194 dl->d_secsize = sc->secsize; 195 dl->d_nsectors = sc->nsect > 63 ? 63 : sc->nsect; 196 dl->d_ntracks = 1; 197 dl->d_secpercyl = dl->d_nsectors * dl->d_ntracks; 198 dl->d_secperunit = sc->nsect; 199 dl->d_ncylinders = dl->d_secperunit / dl->d_secpercyl; 200 return (0); 201 } 202 203 static int 204 mdioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct proc *p) 205 { 206 207 if (md_debug) 208 printf("mdioctl(%s %lx %p %x %p)\n", 209 devtoname(dev), cmd, addr, flags, p); 210 211 return (ENOIOCTL); 212 } 213 214 static void 215 mdstart_malloc(struct md_s *sc) 216 { 217 int i; 218 struct bio *bp; 219 devstat_trans_flags dop; 220 u_char *secp, **secpp, *dst; 221 unsigned secno, nsec, secval, uc; 222 223 for (;;) { 224 /* XXX: LOCK(unique unit numbers) */ 225 bp = bioq_first(&sc->bio_queue); 226 if (bp) 227 bioq_remove(&sc->bio_queue, bp); 228 /* XXX: UNLOCK(unique unit numbers) */ 229 if (!bp) 230 break; 231 232 devstat_start_transaction(&sc->stats); 233 234 if (bp->bio_cmd == BIO_DELETE) 235 dop = DEVSTAT_NO_DATA; 236 else if (bp->bio_cmd == BIO_READ) 237 dop = DEVSTAT_READ; 238 else 239 dop = DEVSTAT_WRITE; 240 241 nsec = bp->bio_bcount / sc->secsize; 242 secno = bp->bio_pblkno; 243 dst = bp->bio_data; 244 while (nsec--) { 245 secpp = &sc->secp[secno]; 246 if ((uintptr_t)*secpp > 255) { 247 secp = *secpp; 248 secval = 0; 249 } else { 250 secp = NULL; 251 secval = (uintptr_t) *secpp; 252 } 253 254 if (md_debug > 2) 255 printf("%x %p %p %d\n", 256 bp->bio_flags, secpp, secp, secval); 257 258 if (bp->bio_cmd == BIO_DELETE) { 259 if (!(sc->flags & MD_RESERVE) && secp != NULL) { 260 FREE(secp, M_MDSECT); 261 *secpp = 0; 262 } 263 } else if (bp->bio_cmd == BIO_READ) { 264 if (secp != NULL) { 265 bcopy(secp, dst, sc->secsize); 266 } else if (secval) { 267 for (i = 0; i < sc->secsize; i++) 268 dst[i] = secval; 269 } else { 270 bzero(dst, sc->secsize); 271 } 272 } else { 273 if (sc->flags & MD_COMPRESS) { 274 uc = dst[0]; 275 for (i = 1; i < sc->secsize; i++) 276 if (dst[i] != uc) 277 break; 278 } else { 279 i = 0; 280 uc = 0; 281 } 282 if (i == sc->secsize) { 283 if (secp) 284 FREE(secp, M_MDSECT); 285 *secpp = (u_char *)(uintptr_t)uc; 286 } else { 287 if (secp == NULL) 288 MALLOC(secp, u_char *, sc->secsize, M_MDSECT, M_WAITOK); 289 bcopy(dst, secp, sc->secsize); 290 *secpp = secp; 291 } 292 } 293 secno++; 294 dst += sc->secsize; 295 } 296 bp->bio_resid = 0; 297 biofinish(bp, &sc->stats, 0); 298 } 299 return; 300 } 301 302 303 static void 304 mdstart_preload(struct md_s *sc) 305 { 306 struct bio *bp; 307 devstat_trans_flags dop; 308 309 for (;;) { 310 /* XXX: LOCK(unique unit numbers) */ 311 bp = bioq_first(&sc->bio_queue); 312 if (bp) 313 bioq_remove(&sc->bio_queue, bp); 314 /* XXX: UNLOCK(unique unit numbers) */ 315 if (!bp) 316 break; 317 318 devstat_start_transaction(&sc->stats); 319 320 if (bp->bio_cmd == BIO_DELETE) { 321 dop = DEVSTAT_NO_DATA; 322 } else if (bp->bio_cmd == BIO_READ) { 323 dop = DEVSTAT_READ; 324 bcopy(sc->pl_ptr + (bp->bio_pblkno << DEV_BSHIFT), bp->bio_data, bp->bio_bcount); 325 } else { 326 dop = DEVSTAT_WRITE; 327 bcopy(bp->bio_data, sc->pl_ptr + (bp->bio_pblkno << DEV_BSHIFT), bp->bio_bcount); 328 } 329 bp->bio_resid = 0; 330 biofinish(bp, &sc->stats, 0); 331 } 332 return; 333 } 334 335 static void 336 mdstart_vnode(struct md_s *sc) 337 { 338 int error; 339 struct bio *bp; 340 struct uio auio; 341 struct iovec aiov; 342 struct mount *mp; 343 344 /* 345 * VNODE I/O 346 * 347 * If an error occurs, we set BIO_ERROR but we do not set 348 * B_INVAL because (for a write anyway), the buffer is 349 * still valid. 350 */ 351 352 for (;;) { 353 /* XXX: LOCK(unique unit numbers) */ 354 bp = bioq_first(&sc->bio_queue); 355 if (bp) 356 bioq_remove(&sc->bio_queue, bp); 357 /* XXX: UNLOCK(unique unit numbers) */ 358 if (!bp) 359 break; 360 361 devstat_start_transaction(&sc->stats); 362 363 bzero(&auio, sizeof(auio)); 364 365 aiov.iov_base = bp->bio_data; 366 aiov.iov_len = bp->bio_bcount; 367 auio.uio_iov = &aiov; 368 auio.uio_iovcnt = 1; 369 auio.uio_offset = (vm_ooffset_t)bp->bio_pblkno * sc->secsize; 370 auio.uio_segflg = UIO_SYSSPACE; 371 if(bp->bio_cmd == BIO_READ) 372 auio.uio_rw = UIO_READ; 373 else 374 auio.uio_rw = UIO_WRITE; 375 auio.uio_resid = bp->bio_bcount; 376 auio.uio_procp = curproc; 377 if (VOP_ISLOCKED(sc->vnode, NULL)) 378 vprint("unexpected md driver lock", sc->vnode); 379 if (bp->bio_cmd == BIO_READ) { 380 vn_lock(sc->vnode, LK_EXCLUSIVE | LK_RETRY, curproc); 381 error = VOP_READ(sc->vnode, &auio, 0, sc->cred); 382 } else { 383 (void) vn_start_write(sc->vnode, &mp, V_WAIT); 384 vn_lock(sc->vnode, LK_EXCLUSIVE | LK_RETRY, curproc); 385 error = VOP_WRITE(sc->vnode, &auio, 0, sc->cred); 386 vn_finished_write(mp); 387 } 388 VOP_UNLOCK(sc->vnode, 0, curproc); 389 bp->bio_resid = auio.uio_resid; 390 biofinish(bp, &sc->stats, error); 391 } 392 return; 393 } 394 395 static void 396 mdstart_swap(struct md_s *sc) 397 { 398 struct bio *bp; 399 400 for (;;) { 401 /* XXX: LOCK(unique unit numbers) */ 402 bp = bioq_first(&sc->bio_queue); 403 if (bp) 404 bioq_remove(&sc->bio_queue, bp); 405 /* XXX: UNLOCK(unique unit numbers) */ 406 if (!bp) 407 break; 408 409 #if 0 410 devstat_start_transaction(&sc->stats); 411 #endif 412 413 if ((bp->bio_cmd == BIO_DELETE) && (sc->flags & MD_RESERVE)) 414 biodone(bp); 415 else 416 vm_pager_strategy(sc->object, bp); 417 418 #if 0 419 devstat_end_transaction_bio(&sc->stats, bp); 420 #endif 421 } 422 return; 423 } 424 425 static void 426 mdstrategy(struct bio *bp) 427 { 428 struct md_s *sc; 429 430 if (md_debug > 1) 431 printf("mdstrategy(%p) %s %x, %d, %ld, %p)\n", 432 bp, devtoname(bp->bio_dev), bp->bio_flags, bp->bio_blkno, 433 bp->bio_bcount / DEV_BSIZE, bp->bio_data); 434 435 sc = bp->bio_dev->si_drv1; 436 437 /* XXX: LOCK(sc->lock) */ 438 bioqdisksort(&sc->bio_queue, bp); 439 /* XXX: UNLOCK(sc->lock) */ 440 441 if (atomic_cmpset_int(&sc->busy, 0, 1) == 0) 442 return; 443 444 switch (sc->type) { 445 case MD_MALLOC: 446 mdstart_malloc(sc); 447 break; 448 case MD_PRELOAD: 449 mdstart_preload(sc); 450 break; 451 case MD_VNODE: 452 mdstart_vnode(sc); 453 break; 454 case MD_SWAP: 455 mdstart_swap(sc); 456 break; 457 default: 458 panic("Impossible md(type)"); 459 break; 460 } 461 sc->busy = 0; 462 } 463 464 static struct md_s * 465 mdfind(int unit) 466 { 467 struct md_s *sc; 468 469 /* XXX: LOCK(unique unit numbers) */ 470 LIST_FOREACH(sc, &md_softc_list, list) { 471 if (sc->unit == unit) 472 break; 473 } 474 /* XXX: UNLOCK(unique unit numbers) */ 475 return (sc); 476 } 477 478 static struct md_s * 479 mdnew(int unit) 480 { 481 struct md_s *sc; 482 int max = -1; 483 484 /* XXX: LOCK(unique unit numbers) */ 485 LIST_FOREACH(sc, &md_softc_list, list) { 486 if (sc->unit == unit) { 487 /* XXX: UNLOCK(unique unit numbers) */ 488 return (NULL); 489 } 490 if (sc->unit > max) 491 max = sc->unit; 492 } 493 if (unit == -1) 494 unit = max + 1; 495 if (unit > DKMAXUNIT) 496 return (NULL); 497 MALLOC(sc, struct md_s *,sizeof(*sc), M_MD, M_WAITOK | M_ZERO); 498 sc->unit = unit; 499 LIST_INSERT_HEAD(&md_softc_list, sc, list); 500 /* XXX: UNLOCK(unique unit numbers) */ 501 return (sc); 502 } 503 504 static void 505 mdinit(struct md_s *sc) 506 { 507 508 bioq_init(&sc->bio_queue); 509 devstat_add_entry(&sc->stats, MD_NAME, sc->unit, sc->secsize, 510 DEVSTAT_NO_ORDERED_TAGS, 511 DEVSTAT_TYPE_DIRECT | DEVSTAT_TYPE_IF_OTHER, 512 DEVSTAT_PRIORITY_OTHER); 513 sc->dev = disk_create(sc->unit, &sc->disk, 0, &md_cdevsw, &mddisk_cdevsw); 514 sc->dev->si_drv1 = sc; 515 } 516 517 /* 518 * XXX: we should check that the range they feed us is mapped. 519 * XXX: we should implement read-only. 520 */ 521 522 static int 523 mdcreate_preload(struct md_ioctl *mdio) 524 { 525 struct md_s *sc; 526 527 if (mdio->md_size == 0) 528 return(EINVAL); 529 if (mdio->md_options & ~(MD_AUTOUNIT)) 530 return(EINVAL); 531 if (mdio->md_options & MD_AUTOUNIT) { 532 sc = mdnew(-1); 533 if (sc == NULL) 534 return (ENOMEM); 535 mdio->md_unit = sc->unit; 536 } else { 537 sc = mdnew(mdio->md_unit); 538 if (sc == NULL) 539 return (EBUSY); 540 } 541 sc->type = MD_PRELOAD; 542 sc->secsize = DEV_BSIZE; 543 sc->nsect = mdio->md_size; 544 /* Cast to pointer size, then to pointer to avoid warning */ 545 sc->pl_ptr = (u_char *)(uintptr_t)mdio->md_base; 546 sc->pl_len = (mdio->md_size << DEV_BSHIFT); 547 mdinit(sc); 548 return (0); 549 } 550 551 552 static int 553 mdcreate_malloc(struct md_ioctl *mdio) 554 { 555 struct md_s *sc; 556 unsigned u; 557 558 if (mdio->md_size == 0) 559 return(EINVAL); 560 if (mdio->md_options & ~(MD_AUTOUNIT | MD_COMPRESS | MD_RESERVE)) 561 return(EINVAL); 562 /* Compression doesn't make sense if we have reserved space */ 563 if (mdio->md_options & MD_RESERVE) 564 mdio->md_options &= ~MD_COMPRESS; 565 if (mdio->md_options & MD_AUTOUNIT) { 566 sc = mdnew(-1); 567 if (sc == NULL) 568 return (ENOMEM); 569 mdio->md_unit = sc->unit; 570 } else { 571 sc = mdnew(mdio->md_unit); 572 if (sc == NULL) 573 return (EBUSY); 574 } 575 sc->type = MD_MALLOC; 576 sc->secsize = DEV_BSIZE; 577 sc->nsect = mdio->md_size; 578 sc->flags = mdio->md_options & MD_COMPRESS; 579 MALLOC(sc->secp, u_char **, sc->nsect * sizeof(u_char *), M_MD, M_WAITOK | M_ZERO); 580 if (mdio->md_options & MD_RESERVE) { 581 for (u = 0; u < sc->nsect; u++) 582 MALLOC(sc->secp[u], u_char *, DEV_BSIZE, M_MDSECT, M_WAITOK | M_ZERO); 583 } 584 printf("%s%d: Malloc disk\n", MD_NAME, sc->unit); 585 mdinit(sc); 586 return (0); 587 } 588 589 590 static int 591 mdsetcred(struct md_s *sc, struct ucred *cred) 592 { 593 char *tmpbuf; 594 int error = 0; 595 596 /* 597 * Set credits in our softc 598 */ 599 600 if (sc->cred) 601 crfree(sc->cred); 602 sc->cred = crdup(cred); 603 604 /* 605 * Horrible kludge to establish credentials for NFS XXX. 606 */ 607 608 if (sc->vnode) { 609 struct uio auio; 610 struct iovec aiov; 611 612 tmpbuf = malloc(sc->secsize, M_TEMP, M_WAITOK); 613 bzero(&auio, sizeof(auio)); 614 615 aiov.iov_base = tmpbuf; 616 aiov.iov_len = sc->secsize; 617 auio.uio_iov = &aiov; 618 auio.uio_iovcnt = 1; 619 auio.uio_offset = 0; 620 auio.uio_rw = UIO_READ; 621 auio.uio_segflg = UIO_SYSSPACE; 622 auio.uio_resid = aiov.iov_len; 623 vn_lock(sc->vnode, LK_EXCLUSIVE | LK_RETRY, curproc); 624 error = VOP_READ(sc->vnode, &auio, 0, sc->cred); 625 VOP_UNLOCK(sc->vnode, 0, curproc); 626 free(tmpbuf, M_TEMP); 627 } 628 return (error); 629 } 630 631 static int 632 mdcreate_vnode(struct md_ioctl *mdio, struct proc *p) 633 { 634 struct md_s *sc; 635 struct vattr vattr; 636 struct nameidata nd; 637 int error, flags; 638 639 if (mdio->md_options & MD_AUTOUNIT) { 640 sc = mdnew(-1); 641 mdio->md_unit = sc->unit; 642 } else { 643 sc = mdnew(mdio->md_unit); 644 } 645 if (sc == NULL) 646 return (EBUSY); 647 648 sc->type = MD_VNODE; 649 650 flags = FREAD|FWRITE; 651 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, mdio->md_file, p); 652 error = vn_open(&nd, &flags, 0); 653 if (error) { 654 if (error != EACCES && error != EPERM && error != EROFS) 655 return (error); 656 flags &= ~FWRITE; 657 sc->flags |= MD_READONLY; 658 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, mdio->md_file, p); 659 error = vn_open(&nd, &flags, 0); 660 if (error) 661 return (error); 662 } 663 NDFREE(&nd, NDF_ONLY_PNBUF); 664 if (nd.ni_vp->v_type != VREG || 665 (error = VOP_GETATTR(nd.ni_vp, &vattr, p->p_ucred, p))) { 666 VOP_UNLOCK(nd.ni_vp, 0, p); 667 (void) vn_close(nd.ni_vp, flags, p->p_ucred, p); 668 return (error ? error : EINVAL); 669 } 670 VOP_UNLOCK(nd.ni_vp, 0, p); 671 sc->secsize = DEV_BSIZE; 672 sc->vnode = nd.ni_vp; 673 674 /* 675 * If the size is specified, override the file attributes. 676 */ 677 if (mdio->md_size) 678 sc->nsect = mdio->md_size; 679 else 680 sc->nsect = vattr.va_size / sc->secsize; /* XXX: round up ? */ 681 error = mdsetcred(sc, p->p_ucred); 682 if (error) { 683 (void) vn_close(nd.ni_vp, flags, p->p_ucred, p); 684 return(error); 685 } 686 mdinit(sc); 687 return (0); 688 } 689 690 static int 691 mddestroy(struct md_s *sc, struct md_ioctl *mdio, struct proc *p) 692 { 693 unsigned u; 694 695 if (sc->dev != NULL) { 696 devstat_remove_entry(&sc->stats); 697 disk_destroy(sc->dev); 698 } 699 if (sc->vnode != NULL) 700 (void)vn_close(sc->vnode, sc->flags & MD_READONLY ? FREAD : (FREAD|FWRITE), sc->cred, p); 701 if (sc->cred != NULL) 702 crfree(sc->cred); 703 if (sc->object != NULL) { 704 mtx_lock(&vm_mtx); 705 vm_pager_deallocate(sc->object); 706 mtx_unlock(&vm_mtx); 707 } 708 if (sc->secp != NULL) { 709 for (u = 0; u < sc->nsect; u++) 710 if ((uintptr_t)sc->secp[u] > 255) 711 FREE(sc->secp[u], M_MDSECT); 712 FREE(sc->secp, M_MD); 713 } 714 715 /* XXX: LOCK(unique unit numbers) */ 716 LIST_REMOVE(sc, list); 717 /* XXX: UNLOCK(unique unit numbers) */ 718 FREE(sc, M_MD); 719 return (0); 720 } 721 722 static int 723 mdcreate_swap(struct md_ioctl *mdio, struct proc *p) 724 { 725 int error; 726 struct md_s *sc; 727 728 if (mdio->md_options & MD_AUTOUNIT) { 729 sc = mdnew(-1); 730 mdio->md_unit = sc->unit; 731 } else { 732 sc = mdnew(mdio->md_unit); 733 } 734 if (sc == NULL) 735 return (EBUSY); 736 737 sc->type = MD_SWAP; 738 739 /* 740 * Range check. Disallow negative sizes or any size less then the 741 * size of a page. Then round to a page. 742 */ 743 744 if (mdio->md_size == 0) { 745 mddestroy(sc, mdio, p); 746 return(EDOM); 747 } 748 749 /* 750 * Allocate an OBJT_SWAP object. 751 * 752 * sc_secsize is PAGE_SIZE'd 753 * 754 * mdio->size is in DEV_BSIZE'd chunks. 755 * Note the truncation. 756 */ 757 758 sc->secsize = PAGE_SIZE; 759 sc->nsect = mdio->md_size / (PAGE_SIZE / DEV_BSIZE); 760 mtx_lock(&vm_mtx); 761 sc->object = vm_pager_allocate(OBJT_SWAP, NULL, sc->secsize * (vm_offset_t)sc->nsect, VM_PROT_DEFAULT, 0); 762 if (mdio->md_options & MD_RESERVE) { 763 if (swap_pager_reserve(sc->object, 0, sc->nsect) < 0) { 764 vm_pager_deallocate(sc->object); 765 mtx_unlock(&vm_mtx); 766 sc->object = NULL; 767 mddestroy(sc, mdio, p); 768 return(EDOM); 769 } 770 } 771 mtx_unlock(&vm_mtx); 772 error = mdsetcred(sc, p->p_ucred); 773 if (error) 774 mddestroy(sc, mdio, p); 775 else 776 mdinit(sc); 777 return(error); 778 } 779 780 static int 781 mdctlioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct proc *p) 782 { 783 struct md_ioctl *mdio; 784 struct md_s *sc; 785 786 if (md_debug) 787 printf("mdctlioctl(%s %lx %p %x %p)\n", 788 devtoname(dev), cmd, addr, flags, p); 789 790 mdio = (struct md_ioctl *)addr; 791 switch (cmd) { 792 case MDIOCATTACH: 793 switch (mdio->md_type) { 794 case MD_MALLOC: 795 return(mdcreate_malloc(mdio)); 796 case MD_PRELOAD: 797 return(mdcreate_preload(mdio)); 798 case MD_VNODE: 799 return(mdcreate_vnode(mdio, p)); 800 case MD_SWAP: 801 return(mdcreate_swap(mdio, p)); 802 default: 803 return (EINVAL); 804 } 805 case MDIOCDETACH: 806 if (mdio->md_file != NULL) 807 return(EINVAL); 808 if (mdio->md_size != 0) 809 return(EINVAL); 810 if (mdio->md_options != 0) 811 return(EINVAL); 812 sc = mdfind(mdio->md_unit); 813 if (sc == NULL) 814 return (ENOENT); 815 switch(sc->type) { 816 case MD_VNODE: 817 case MD_SWAP: 818 case MD_MALLOC: 819 case MD_PRELOAD: 820 return(mddestroy(sc, mdio, p)); 821 default: 822 return (EOPNOTSUPP); 823 } 824 case MDIOCQUERY: 825 sc = mdfind(mdio->md_unit); 826 if (sc == NULL) 827 return (ENOENT); 828 mdio->md_type = sc->type; 829 mdio->md_options = sc->flags; 830 switch (sc->type) { 831 case MD_MALLOC: 832 mdio->md_size = sc->nsect; 833 break; 834 case MD_PRELOAD: 835 mdio->md_size = sc->nsect; 836 (u_char *)(uintptr_t)mdio->md_base = sc->pl_ptr; 837 break; 838 case MD_SWAP: 839 mdio->md_size = sc->nsect * (PAGE_SIZE / DEV_BSIZE); 840 break; 841 case MD_VNODE: 842 mdio->md_size = sc->nsect; 843 /* XXX fill this in */ 844 mdio->md_file = NULL; 845 break; 846 } 847 return (0); 848 default: 849 return (ENOIOCTL); 850 }; 851 return (ENOIOCTL); 852 } 853 854 static void 855 md_preloaded(u_char *image, unsigned length) 856 { 857 struct md_s *sc; 858 859 sc = mdnew(-1); 860 if (sc == NULL) 861 return; 862 sc->type = MD_PRELOAD; 863 sc->secsize = DEV_BSIZE; 864 sc->nsect = length / DEV_BSIZE; 865 sc->pl_ptr = image; 866 sc->pl_len = length; 867 if (sc->unit == 0) 868 mdrootready = 1; 869 mdinit(sc); 870 } 871 872 static void 873 md_drvinit(void *unused) 874 { 875 876 caddr_t mod; 877 caddr_t c; 878 u_char *ptr, *name, *type; 879 unsigned len; 880 881 #ifdef MD_ROOT_SIZE 882 md_preloaded(mfs_root, MD_ROOT_SIZE*1024); 883 #endif 884 mod = NULL; 885 while ((mod = preload_search_next_name(mod)) != NULL) { 886 name = (char *)preload_search_info(mod, MODINFO_NAME); 887 type = (char *)preload_search_info(mod, MODINFO_TYPE); 888 if (name == NULL) 889 continue; 890 if (type == NULL) 891 continue; 892 if (strcmp(type, "md_image") && strcmp(type, "mfs_root")) 893 continue; 894 c = preload_search_info(mod, MODINFO_ADDR); 895 ptr = *(u_char **)c; 896 c = preload_search_info(mod, MODINFO_SIZE); 897 len = *(unsigned *)c; 898 printf("md%d: Preloaded image <%s> %d bytes at %p\n", 899 mdunits, name, len, ptr); 900 md_preloaded(ptr, len); 901 } 902 status_dev = make_dev(&mdctl_cdevsw, 0xffff00ff, UID_ROOT, GID_WHEEL, 0600, "mdctl"); 903 } 904 905 static int 906 md_modevent(module_t mod, int type, void *data) 907 { 908 switch (type) { 909 case MOD_LOAD: 910 md_drvinit(NULL); 911 break; 912 case MOD_UNLOAD: 913 if (!LIST_EMPTY(&md_softc_list)) 914 return EBUSY; 915 if (status_dev) 916 destroy_dev(status_dev); 917 status_dev = 0; 918 break; 919 default: 920 break; 921 } 922 return 0; 923 } 924 925 static moduledata_t md_mod = { 926 "md", 927 md_modevent, 928 NULL 929 }; 930 DECLARE_MODULE(md, md_mod, SI_SUB_DRIVERS, SI_ORDER_MIDDLE+CDEV_MAJOR); 931 MODULE_VERSION(md, MD_MODVER); 932 933 934 #ifdef MD_ROOT 935 static void 936 md_takeroot(void *junk) 937 { 938 if (mdrootready) 939 rootdevnames[0] = "ufs:/dev/md0c"; 940 } 941 942 SYSINIT(md_root, SI_SUB_MOUNT_ROOT, SI_ORDER_FIRST, md_takeroot, NULL); 943 #endif 944 945