1 /*- 2 * SPDX-License-Identifier: (Beerware AND BSD-3-Clause) 3 * 4 * ---------------------------------------------------------------------------- 5 * "THE BEER-WARE LICENSE" (Revision 42): 6 * <phk@FreeBSD.ORG> wrote this file. As long as you retain this notice you 7 * can do whatever you want with this stuff. If we meet some day, and you think 8 * this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp 9 * ---------------------------------------------------------------------------- 10 * 11 */ 12 13 /*- 14 * The following functions are based on the historical vn(4) driver: 15 * mdstart_swap(), mdstart_vnode(), mdcreate_swap(), mdcreate_vnode() 16 * and mddestroy(), 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 * Copyright (c) 2013 The FreeBSD Foundation 22 * All rights reserved. 23 * 24 * This code is derived from software contributed to Berkeley by 25 * the Systems Programming Group of the University of Utah Computer 26 * Science Department. 27 * 28 * Portions of this software were developed by Konstantin Belousov 29 * under sponsorship from the FreeBSD Foundation. 30 * 31 * Redistribution and use in source and binary forms, with or without 32 * modification, are permitted provided that the following conditions 33 * are met: 34 * 1. Redistributions of source code must retain the above copyright 35 * notice, this list of conditions and the following disclaimer. 36 * 2. Redistributions in binary form must reproduce the above copyright 37 * notice, this list of conditions and the following disclaimer in the 38 * documentation and/or other materials provided with the distribution. 39 * 3. Neither the name of the University nor the names of its contributors 40 * may be used to endorse or promote products derived from this software 41 * without specific prior written permission. 42 * 43 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 44 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 45 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 46 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 47 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 48 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 49 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 50 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 51 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 52 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 53 * SUCH DAMAGE. 54 * 55 * from: Utah Hdr: vn.c 1.13 94/04/02 56 * From: src/sys/dev/vn/vn.c,v 1.122 2000/12/16 16:06:03 57 */ 58 59 #include "opt_rootdevname.h" 60 #include "opt_geom.h" 61 #include "opt_md.h" 62 63 #include <sys/param.h> 64 #include <sys/systm.h> 65 #include <sys/bio.h> 66 #include <sys/buf.h> 67 #include <sys/conf.h> 68 #include <sys/devicestat.h> 69 #include <sys/fcntl.h> 70 #include <sys/kernel.h> 71 #include <sys/kthread.h> 72 #include <sys/limits.h> 73 #include <sys/linker.h> 74 #include <sys/lock.h> 75 #include <sys/malloc.h> 76 #include <sys/mdioctl.h> 77 #include <sys/mount.h> 78 #include <sys/mutex.h> 79 #include <sys/sx.h> 80 #include <sys/namei.h> 81 #include <sys/proc.h> 82 #include <sys/queue.h> 83 #include <sys/rwlock.h> 84 #include <sys/sbuf.h> 85 #include <sys/sched.h> 86 #include <sys/sf_buf.h> 87 #include <sys/sysctl.h> 88 #include <sys/uio.h> 89 #include <sys/unistd.h> 90 #include <sys/vnode.h> 91 #include <sys/disk.h> 92 #include <sys/param.h> 93 #include <sys/bus.h> 94 95 #include <geom/geom.h> 96 #include <geom/geom_int.h> 97 98 #include <vm/vm.h> 99 #include <vm/vm_extern.h> 100 #include <vm/vm_param.h> 101 #include <vm/vm_object.h> 102 #include <vm/vm_page.h> 103 #include <vm/vm_pager.h> 104 #include <vm/swap_pager.h> 105 #include <vm/uma.h> 106 107 #include <machine/bus.h> 108 109 #define MD_MODVER 1 110 111 #define MD_SHUTDOWN 0x10000 /* Tell worker thread to terminate. */ 112 #define MD_EXITING 0x20000 /* Worker thread is exiting. */ 113 #define MD_PROVIDERGONE 0x40000 /* Safe to free the softc */ 114 115 #ifndef MD_NSECT 116 #define MD_NSECT (10000 * 2) 117 #endif 118 119 struct md_req { 120 unsigned md_unit; /* unit number */ 121 enum md_types md_type; /* type of disk */ 122 off_t md_mediasize; /* size of disk in bytes */ 123 unsigned md_sectorsize; /* sectorsize */ 124 unsigned md_options; /* options */ 125 int md_fwheads; /* firmware heads */ 126 int md_fwsectors; /* firmware sectors */ 127 char *md_file; /* pathname of file to mount */ 128 enum uio_seg md_file_seg; /* location of md_file */ 129 char *md_label; /* label of the device (userspace) */ 130 int *md_units; /* pointer to units array (kernel) */ 131 size_t md_units_nitems; /* items in md_units array */ 132 }; 133 134 #ifdef COMPAT_FREEBSD32 135 struct md_ioctl32 { 136 unsigned md_version; 137 unsigned md_unit; 138 enum md_types md_type; 139 uint32_t md_file; 140 off_t md_mediasize; 141 unsigned md_sectorsize; 142 unsigned md_options; 143 uint64_t md_base; 144 int md_fwheads; 145 int md_fwsectors; 146 uint32_t md_label; 147 int md_pad[MDNPAD]; 148 } 149 #ifdef __amd64__ 150 __attribute__((__packed__)) 151 #endif 152 ; 153 #ifndef __amd64__ 154 CTASSERT((sizeof(struct md_ioctl32)) == 440); 155 #else 156 CTASSERT((sizeof(struct md_ioctl32)) == 436); 157 #endif 158 159 #define MDIOCATTACH_32 _IOC_NEWTYPE(MDIOCATTACH, struct md_ioctl32) 160 #define MDIOCDETACH_32 _IOC_NEWTYPE(MDIOCDETACH, struct md_ioctl32) 161 #define MDIOCQUERY_32 _IOC_NEWTYPE(MDIOCQUERY, struct md_ioctl32) 162 #define MDIOCRESIZE_32 _IOC_NEWTYPE(MDIOCRESIZE, struct md_ioctl32) 163 #endif /* COMPAT_FREEBSD32 */ 164 165 static MALLOC_DEFINE(M_MD, "md_disk", "Memory Disk"); 166 static MALLOC_DEFINE(M_MDSECT, "md_sectors", "Memory Disk Sectors"); 167 168 static int md_debug; 169 SYSCTL_INT(_debug, OID_AUTO, mddebug, CTLFLAG_RW, &md_debug, 0, 170 "Enable md(4) debug messages"); 171 static int md_malloc_wait; 172 SYSCTL_INT(_vm, OID_AUTO, md_malloc_wait, CTLFLAG_RW, &md_malloc_wait, 0, 173 "Allow malloc to wait for memory allocations"); 174 175 #if defined(MD_ROOT) && !defined(MD_ROOT_FSTYPE) 176 #define MD_ROOT_FSTYPE "ufs" 177 #endif 178 179 #if defined(MD_ROOT) 180 /* 181 * Preloaded image gets put here. 182 */ 183 #if defined(MD_ROOT_SIZE) 184 /* 185 * We put the mfs_root symbol into the oldmfs section of the kernel object file. 186 * Applications that patch the object with the image can determine 187 * the size looking at the oldmfs section size within the kernel. 188 */ 189 u_char mfs_root[MD_ROOT_SIZE*1024] __attribute__ ((section ("oldmfs"))); 190 const int mfs_root_size = sizeof(mfs_root); 191 #elif defined(MD_ROOT_MEM) 192 /* MD region already mapped in the memory */ 193 u_char *mfs_root; 194 int mfs_root_size; 195 #else 196 extern volatile u_char __weak_symbol mfs_root; 197 extern volatile u_char __weak_symbol mfs_root_end; 198 #define mfs_root_size ((uintptr_t)(&mfs_root_end - &mfs_root)) 199 #endif 200 #endif 201 202 static g_init_t g_md_init; 203 static g_fini_t g_md_fini; 204 static g_start_t g_md_start; 205 static g_access_t g_md_access; 206 static void g_md_dumpconf(struct sbuf *sb, const char *indent, 207 struct g_geom *gp, struct g_consumer *cp __unused, struct g_provider *pp); 208 static g_provgone_t g_md_providergone; 209 210 static struct cdev *status_dev = NULL; 211 static struct sx md_sx; 212 static struct unrhdr *md_uh; 213 214 static d_ioctl_t mdctlioctl; 215 216 static struct cdevsw mdctl_cdevsw = { 217 .d_version = D_VERSION, 218 .d_ioctl = mdctlioctl, 219 .d_name = MD_NAME, 220 }; 221 222 struct g_class g_md_class = { 223 .name = "MD", 224 .version = G_VERSION, 225 .init = g_md_init, 226 .fini = g_md_fini, 227 .start = g_md_start, 228 .access = g_md_access, 229 .dumpconf = g_md_dumpconf, 230 .providergone = g_md_providergone, 231 }; 232 233 DECLARE_GEOM_CLASS(g_md_class, g_md); 234 MODULE_VERSION(geom_md, 0); 235 236 static LIST_HEAD(, md_s) md_softc_list = LIST_HEAD_INITIALIZER(md_softc_list); 237 238 #define NINDIR (PAGE_SIZE / sizeof(uintptr_t)) 239 #define NMASK (NINDIR-1) 240 static int nshift; 241 242 struct indir { 243 uintptr_t *array; 244 u_int total; 245 u_int used; 246 u_int shift; 247 }; 248 249 struct md_s { 250 int unit; 251 LIST_ENTRY(md_s) list; 252 struct bio_queue_head bio_queue; 253 struct mtx queue_mtx; 254 struct cdev *dev; 255 enum md_types type; 256 off_t mediasize; 257 unsigned sectorsize; 258 unsigned opencount; 259 unsigned fwheads; 260 unsigned fwsectors; 261 char ident[DISK_IDENT_SIZE]; 262 unsigned flags; 263 char name[20]; 264 struct proc *procp; 265 struct g_geom *gp; 266 struct g_provider *pp; 267 int (*start)(struct md_s *sc, struct bio *bp); 268 struct devstat *devstat; 269 struct ucred *cred; 270 char label[PATH_MAX]; 271 bool candelete; 272 273 union { 274 /* MD_MALLOC related fields */ 275 struct { 276 struct indir *indir; 277 uma_zone_t uma; 278 } s_malloc; 279 280 /* MD_PRELOAD related fields */ 281 struct { 282 u_char *pl_ptr; 283 size_t pl_len; 284 char name[PATH_MAX]; 285 } s_preload; 286 287 /* MD_VNODE related fields */ 288 struct { 289 struct vnode *vnode; 290 char file[PATH_MAX]; 291 vm_offset_t kva; 292 } s_vnode; 293 294 /* MD_SWAP related fields */ 295 struct { 296 vm_object_t object; 297 } s_swap; 298 299 /* MD_NULL */ 300 struct { 301 } s_null; 302 }; 303 }; 304 305 static struct indir * 306 new_indir(u_int shift) 307 { 308 struct indir *ip; 309 310 ip = malloc(sizeof *ip, M_MD, (md_malloc_wait ? M_WAITOK : M_NOWAIT) 311 | M_ZERO); 312 if (ip == NULL) 313 return (NULL); 314 ip->array = malloc(sizeof(uintptr_t) * NINDIR, 315 M_MDSECT, (md_malloc_wait ? M_WAITOK : M_NOWAIT) | M_ZERO); 316 if (ip->array == NULL) { 317 free(ip, M_MD); 318 return (NULL); 319 } 320 ip->total = NINDIR; 321 ip->shift = shift; 322 return (ip); 323 } 324 325 static void 326 del_indir(struct indir *ip) 327 { 328 329 free(ip->array, M_MDSECT); 330 free(ip, M_MD); 331 } 332 333 static void 334 destroy_indir(struct md_s *sc, struct indir *ip) 335 { 336 int i; 337 338 for (i = 0; i < NINDIR; i++) { 339 if (!ip->array[i]) 340 continue; 341 if (ip->shift) 342 destroy_indir(sc, (struct indir*)(ip->array[i])); 343 else if (ip->array[i] > 255) 344 uma_zfree(sc->s_malloc.uma, (void *)(ip->array[i])); 345 } 346 del_indir(ip); 347 } 348 349 /* 350 * This function does the math and allocates the top level "indir" structure 351 * for a device of "size" sectors. 352 */ 353 354 static struct indir * 355 dimension(off_t size) 356 { 357 off_t rcnt; 358 struct indir *ip; 359 int layer; 360 361 rcnt = size; 362 layer = 0; 363 while (rcnt > NINDIR) { 364 rcnt /= NINDIR; 365 layer++; 366 } 367 368 /* 369 * XXX: the top layer is probably not fully populated, so we allocate 370 * too much space for ip->array in here. 371 */ 372 ip = malloc(sizeof *ip, M_MD, M_WAITOK | M_ZERO); 373 ip->array = malloc(sizeof(uintptr_t) * NINDIR, 374 M_MDSECT, M_WAITOK | M_ZERO); 375 ip->total = NINDIR; 376 ip->shift = layer * nshift; 377 return (ip); 378 } 379 380 /* 381 * Read a given sector 382 */ 383 384 static uintptr_t 385 s_read(struct indir *ip, off_t offset) 386 { 387 struct indir *cip; 388 int idx; 389 uintptr_t up; 390 391 if (md_debug > 1) 392 printf("s_read(%jd)\n", (intmax_t)offset); 393 up = 0; 394 for (cip = ip; cip != NULL;) { 395 if (cip->shift) { 396 idx = (offset >> cip->shift) & NMASK; 397 up = cip->array[idx]; 398 cip = (struct indir *)up; 399 continue; 400 } 401 idx = offset & NMASK; 402 return (cip->array[idx]); 403 } 404 return (0); 405 } 406 407 /* 408 * Write a given sector, prune the tree if the value is 0 409 */ 410 411 static int 412 s_write(struct indir *ip, off_t offset, uintptr_t ptr) 413 { 414 struct indir *cip, *lip[10]; 415 int idx, li; 416 uintptr_t up; 417 418 if (md_debug > 1) 419 printf("s_write(%jd, %p)\n", (intmax_t)offset, (void *)ptr); 420 up = 0; 421 li = 0; 422 cip = ip; 423 for (;;) { 424 lip[li++] = cip; 425 if (cip->shift) { 426 idx = (offset >> cip->shift) & NMASK; 427 up = cip->array[idx]; 428 if (up != 0) { 429 cip = (struct indir *)up; 430 continue; 431 } 432 /* Allocate branch */ 433 cip->array[idx] = 434 (uintptr_t)new_indir(cip->shift - nshift); 435 if (cip->array[idx] == 0) 436 return (ENOSPC); 437 cip->used++; 438 up = cip->array[idx]; 439 cip = (struct indir *)up; 440 continue; 441 } 442 /* leafnode */ 443 idx = offset & NMASK; 444 up = cip->array[idx]; 445 if (up != 0) 446 cip->used--; 447 cip->array[idx] = ptr; 448 if (ptr != 0) 449 cip->used++; 450 break; 451 } 452 if (cip->used != 0 || li == 1) 453 return (0); 454 li--; 455 while (cip->used == 0 && cip != ip) { 456 li--; 457 idx = (offset >> lip[li]->shift) & NMASK; 458 up = lip[li]->array[idx]; 459 KASSERT(up == (uintptr_t)cip, ("md screwed up")); 460 del_indir(cip); 461 lip[li]->array[idx] = 0; 462 lip[li]->used--; 463 cip = lip[li]; 464 } 465 return (0); 466 } 467 468 static int 469 g_md_access(struct g_provider *pp, int r, int w, int e) 470 { 471 struct md_s *sc; 472 473 sc = pp->geom->softc; 474 if (sc == NULL) { 475 if (r <= 0 && w <= 0 && e <= 0) 476 return (0); 477 return (ENXIO); 478 } 479 r += pp->acr; 480 w += pp->acw; 481 e += pp->ace; 482 if ((sc->flags & MD_READONLY) != 0 && w > 0) 483 return (EROFS); 484 if ((pp->acr + pp->acw + pp->ace) == 0 && (r + w + e) > 0) { 485 sc->opencount = 1; 486 } else if ((pp->acr + pp->acw + pp->ace) > 0 && (r + w + e) == 0) { 487 sc->opencount = 0; 488 } 489 return (0); 490 } 491 492 static void 493 g_md_start(struct bio *bp) 494 { 495 struct md_s *sc; 496 497 sc = bp->bio_to->geom->softc; 498 if ((bp->bio_cmd == BIO_READ) || (bp->bio_cmd == BIO_WRITE)) { 499 devstat_start_transaction_bio(sc->devstat, bp); 500 } 501 mtx_lock(&sc->queue_mtx); 502 bioq_disksort(&sc->bio_queue, bp); 503 wakeup(sc); 504 mtx_unlock(&sc->queue_mtx); 505 } 506 507 #define MD_MALLOC_MOVE_ZERO 1 508 #define MD_MALLOC_MOVE_FILL 2 509 #define MD_MALLOC_MOVE_READ 3 510 #define MD_MALLOC_MOVE_WRITE 4 511 #define MD_MALLOC_MOVE_CMP 5 512 513 static int 514 md_malloc_move_ma(vm_page_t **mp, int *ma_offs, unsigned sectorsize, 515 void *ptr, u_char fill, int op) 516 { 517 struct sf_buf *sf; 518 vm_page_t m, *mp1; 519 char *p, first; 520 off_t *uc; 521 unsigned n; 522 int error, i, ma_offs1, sz, first_read; 523 524 m = NULL; 525 error = 0; 526 sf = NULL; 527 /* if (op == MD_MALLOC_MOVE_CMP) { gcc */ 528 first = 0; 529 first_read = 0; 530 uc = ptr; 531 mp1 = *mp; 532 ma_offs1 = *ma_offs; 533 /* } */ 534 sched_pin(); 535 for (n = sectorsize; n != 0; n -= sz) { 536 sz = imin(PAGE_SIZE - *ma_offs, n); 537 if (m != **mp) { 538 if (sf != NULL) 539 sf_buf_free(sf); 540 m = **mp; 541 sf = sf_buf_alloc(m, SFB_CPUPRIVATE | 542 (md_malloc_wait ? 0 : SFB_NOWAIT)); 543 if (sf == NULL) { 544 error = ENOMEM; 545 break; 546 } 547 } 548 p = (char *)sf_buf_kva(sf) + *ma_offs; 549 switch (op) { 550 case MD_MALLOC_MOVE_ZERO: 551 bzero(p, sz); 552 break; 553 case MD_MALLOC_MOVE_FILL: 554 memset(p, fill, sz); 555 break; 556 case MD_MALLOC_MOVE_READ: 557 bcopy(ptr, p, sz); 558 cpu_flush_dcache(p, sz); 559 break; 560 case MD_MALLOC_MOVE_WRITE: 561 bcopy(p, ptr, sz); 562 break; 563 case MD_MALLOC_MOVE_CMP: 564 for (i = 0; i < sz; i++, p++) { 565 if (!first_read) { 566 *uc = (u_char)*p; 567 first = *p; 568 first_read = 1; 569 } else if (*p != first) { 570 error = EDOOFUS; 571 break; 572 } 573 } 574 break; 575 default: 576 KASSERT(0, ("md_malloc_move_ma unknown op %d\n", op)); 577 break; 578 } 579 if (error != 0) 580 break; 581 *ma_offs += sz; 582 *ma_offs %= PAGE_SIZE; 583 if (*ma_offs == 0) 584 (*mp)++; 585 ptr = (char *)ptr + sz; 586 } 587 588 if (sf != NULL) 589 sf_buf_free(sf); 590 sched_unpin(); 591 if (op == MD_MALLOC_MOVE_CMP && error != 0) { 592 *mp = mp1; 593 *ma_offs = ma_offs1; 594 } 595 return (error); 596 } 597 598 static int 599 md_malloc_move_vlist(bus_dma_segment_t **pvlist, int *pma_offs, 600 unsigned len, void *ptr, u_char fill, int op) 601 { 602 bus_dma_segment_t *vlist; 603 uint8_t *p, *end, first; 604 off_t *uc; 605 int ma_offs, seg_len; 606 607 vlist = *pvlist; 608 ma_offs = *pma_offs; 609 uc = ptr; 610 611 for (; len != 0; len -= seg_len) { 612 seg_len = imin(vlist->ds_len - ma_offs, len); 613 p = (uint8_t *)(uintptr_t)vlist->ds_addr + ma_offs; 614 switch (op) { 615 case MD_MALLOC_MOVE_ZERO: 616 bzero(p, seg_len); 617 break; 618 case MD_MALLOC_MOVE_FILL: 619 memset(p, fill, seg_len); 620 break; 621 case MD_MALLOC_MOVE_READ: 622 bcopy(ptr, p, seg_len); 623 cpu_flush_dcache(p, seg_len); 624 break; 625 case MD_MALLOC_MOVE_WRITE: 626 bcopy(p, ptr, seg_len); 627 break; 628 case MD_MALLOC_MOVE_CMP: 629 end = p + seg_len; 630 first = *uc = *p; 631 /* Confirm all following bytes match the first */ 632 while (++p < end) { 633 if (*p != first) 634 return (EDOOFUS); 635 } 636 break; 637 default: 638 KASSERT(0, ("md_malloc_move_vlist unknown op %d\n", op)); 639 break; 640 } 641 642 ma_offs += seg_len; 643 if (ma_offs == vlist->ds_len) { 644 ma_offs = 0; 645 vlist++; 646 } 647 ptr = (uint8_t *)ptr + seg_len; 648 } 649 *pvlist = vlist; 650 *pma_offs = ma_offs; 651 652 return (0); 653 } 654 655 static int 656 mdstart_malloc(struct md_s *sc, struct bio *bp) 657 { 658 u_char *dst; 659 vm_page_t *m; 660 bus_dma_segment_t *vlist; 661 int i, error, error1, ma_offs, notmapped; 662 off_t secno, nsec, uc; 663 uintptr_t sp, osp; 664 665 switch (bp->bio_cmd) { 666 case BIO_READ: 667 case BIO_WRITE: 668 case BIO_DELETE: 669 break; 670 case BIO_FLUSH: 671 return (0); 672 default: 673 return (EOPNOTSUPP); 674 } 675 676 notmapped = (bp->bio_flags & BIO_UNMAPPED) != 0; 677 vlist = (bp->bio_flags & BIO_VLIST) != 0 ? 678 (bus_dma_segment_t *)bp->bio_data : NULL; 679 if (notmapped) { 680 m = bp->bio_ma; 681 ma_offs = bp->bio_ma_offset; 682 dst = NULL; 683 KASSERT(vlist == NULL, ("vlists cannot be unmapped")); 684 } else if (vlist != NULL) { 685 ma_offs = bp->bio_ma_offset; 686 dst = NULL; 687 } else { 688 dst = bp->bio_data; 689 } 690 691 nsec = bp->bio_length / sc->sectorsize; 692 secno = bp->bio_offset / sc->sectorsize; 693 error = 0; 694 while (nsec--) { 695 osp = s_read(sc->s_malloc.indir, secno); 696 if (bp->bio_cmd == BIO_DELETE) { 697 if (osp != 0) 698 error = s_write(sc->s_malloc.indir, secno, 0); 699 } else if (bp->bio_cmd == BIO_READ) { 700 if (osp == 0) { 701 if (notmapped) { 702 error = md_malloc_move_ma(&m, &ma_offs, 703 sc->sectorsize, NULL, 0, 704 MD_MALLOC_MOVE_ZERO); 705 } else if (vlist != NULL) { 706 error = md_malloc_move_vlist(&vlist, 707 &ma_offs, sc->sectorsize, NULL, 0, 708 MD_MALLOC_MOVE_ZERO); 709 } else 710 bzero(dst, sc->sectorsize); 711 } else if (osp <= 255) { 712 if (notmapped) { 713 error = md_malloc_move_ma(&m, &ma_offs, 714 sc->sectorsize, NULL, osp, 715 MD_MALLOC_MOVE_FILL); 716 } else if (vlist != NULL) { 717 error = md_malloc_move_vlist(&vlist, 718 &ma_offs, sc->sectorsize, NULL, osp, 719 MD_MALLOC_MOVE_FILL); 720 } else 721 memset(dst, osp, sc->sectorsize); 722 } else { 723 if (notmapped) { 724 error = md_malloc_move_ma(&m, &ma_offs, 725 sc->sectorsize, (void *)osp, 0, 726 MD_MALLOC_MOVE_READ); 727 } else if (vlist != NULL) { 728 error = md_malloc_move_vlist(&vlist, 729 &ma_offs, sc->sectorsize, 730 (void *)osp, 0, 731 MD_MALLOC_MOVE_READ); 732 } else { 733 bcopy((void *)osp, dst, sc->sectorsize); 734 cpu_flush_dcache(dst, sc->sectorsize); 735 } 736 } 737 osp = 0; 738 } else if (bp->bio_cmd == BIO_WRITE) { 739 if (sc->flags & MD_COMPRESS) { 740 if (notmapped) { 741 error1 = md_malloc_move_ma(&m, &ma_offs, 742 sc->sectorsize, &uc, 0, 743 MD_MALLOC_MOVE_CMP); 744 i = error1 == 0 ? sc->sectorsize : 0; 745 } else if (vlist != NULL) { 746 error1 = md_malloc_move_vlist(&vlist, 747 &ma_offs, sc->sectorsize, &uc, 0, 748 MD_MALLOC_MOVE_CMP); 749 i = error1 == 0 ? sc->sectorsize : 0; 750 } else { 751 uc = dst[0]; 752 for (i = 1; i < sc->sectorsize; i++) { 753 if (dst[i] != uc) 754 break; 755 } 756 } 757 } else { 758 i = 0; 759 uc = 0; 760 } 761 if (i == sc->sectorsize) { 762 if (osp != uc) 763 error = s_write(sc->s_malloc.indir, 764 secno, uc); 765 } else { 766 if (osp <= 255) { 767 sp = (uintptr_t)uma_zalloc( 768 sc->s_malloc.uma, 769 md_malloc_wait ? M_WAITOK : 770 M_NOWAIT); 771 if (sp == 0) { 772 error = ENOSPC; 773 break; 774 } 775 if (notmapped) { 776 error = md_malloc_move_ma(&m, 777 &ma_offs, sc->sectorsize, 778 (void *)sp, 0, 779 MD_MALLOC_MOVE_WRITE); 780 } else if (vlist != NULL) { 781 error = md_malloc_move_vlist( 782 &vlist, &ma_offs, 783 sc->sectorsize, (void *)sp, 784 0, MD_MALLOC_MOVE_WRITE); 785 } else { 786 bcopy(dst, (void *)sp, 787 sc->sectorsize); 788 } 789 error = s_write(sc->s_malloc.indir, 790 secno, sp); 791 } else { 792 if (notmapped) { 793 error = md_malloc_move_ma(&m, 794 &ma_offs, sc->sectorsize, 795 (void *)osp, 0, 796 MD_MALLOC_MOVE_WRITE); 797 } else if (vlist != NULL) { 798 error = md_malloc_move_vlist( 799 &vlist, &ma_offs, 800 sc->sectorsize, (void *)osp, 801 0, MD_MALLOC_MOVE_WRITE); 802 } else { 803 bcopy(dst, (void *)osp, 804 sc->sectorsize); 805 } 806 osp = 0; 807 } 808 } 809 } else { 810 error = EOPNOTSUPP; 811 } 812 if (osp > 255) 813 uma_zfree(sc->s_malloc.uma, (void*)osp); 814 if (error != 0) 815 break; 816 secno++; 817 if (!notmapped && vlist == NULL) 818 dst += sc->sectorsize; 819 } 820 bp->bio_resid = 0; 821 return (error); 822 } 823 824 static void 825 mdcopyto_vlist(void *src, bus_dma_segment_t *vlist, off_t offset, off_t len) 826 { 827 off_t seg_len; 828 829 while (offset >= vlist->ds_len) { 830 offset -= vlist->ds_len; 831 vlist++; 832 } 833 834 while (len != 0) { 835 seg_len = omin(len, vlist->ds_len - offset); 836 bcopy(src, (void *)(uintptr_t)(vlist->ds_addr + offset), 837 seg_len); 838 offset = 0; 839 src = (uint8_t *)src + seg_len; 840 len -= seg_len; 841 vlist++; 842 } 843 } 844 845 static void 846 mdcopyfrom_vlist(bus_dma_segment_t *vlist, off_t offset, void *dst, off_t len) 847 { 848 off_t seg_len; 849 850 while (offset >= vlist->ds_len) { 851 offset -= vlist->ds_len; 852 vlist++; 853 } 854 855 while (len != 0) { 856 seg_len = omin(len, vlist->ds_len - offset); 857 bcopy((void *)(uintptr_t)(vlist->ds_addr + offset), dst, 858 seg_len); 859 offset = 0; 860 dst = (uint8_t *)dst + seg_len; 861 len -= seg_len; 862 vlist++; 863 } 864 } 865 866 static int 867 mdstart_preload(struct md_s *sc, struct bio *bp) 868 { 869 uint8_t *p; 870 871 p = sc->s_preload.pl_ptr + bp->bio_offset; 872 switch (bp->bio_cmd) { 873 case BIO_READ: 874 if ((bp->bio_flags & BIO_VLIST) != 0) { 875 mdcopyto_vlist(p, (bus_dma_segment_t *)bp->bio_data, 876 bp->bio_ma_offset, bp->bio_length); 877 } else { 878 bcopy(p, bp->bio_data, bp->bio_length); 879 } 880 cpu_flush_dcache(bp->bio_data, bp->bio_length); 881 break; 882 case BIO_WRITE: 883 if ((bp->bio_flags & BIO_VLIST) != 0) { 884 mdcopyfrom_vlist((bus_dma_segment_t *)bp->bio_data, 885 bp->bio_ma_offset, p, bp->bio_length); 886 } else { 887 bcopy(bp->bio_data, p, bp->bio_length); 888 } 889 break; 890 } 891 bp->bio_resid = 0; 892 return (0); 893 } 894 895 static int 896 mdstart_vnode(struct md_s *sc, struct bio *bp) 897 { 898 int error; 899 struct uio auio; 900 struct iovec aiov; 901 struct iovec *piov; 902 struct mount *mp; 903 struct vnode *vp; 904 bus_dma_segment_t *vlist; 905 struct thread *td; 906 off_t iolen, iostart, off, len; 907 int ma_offs, npages; 908 bool mapped; 909 910 td = curthread; 911 vp = sc->s_vnode.vnode; 912 piov = NULL; 913 ma_offs = bp->bio_ma_offset; 914 off = bp->bio_offset; 915 len = bp->bio_length; 916 mapped = false; 917 918 /* 919 * VNODE I/O 920 * 921 * If an error occurs, we set BIO_ERROR but we do not set 922 * B_INVAL because (for a write anyway), the buffer is 923 * still valid. 924 */ 925 926 switch (bp->bio_cmd) { 927 case BIO_READ: 928 auio.uio_rw = UIO_READ; 929 break; 930 case BIO_WRITE: 931 auio.uio_rw = UIO_WRITE; 932 break; 933 case BIO_FLUSH: 934 do { 935 (void)vn_start_write(vp, &mp, V_WAIT); 936 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 937 error = VOP_FSYNC(vp, MNT_WAIT, td); 938 VOP_UNLOCK(vp); 939 vn_finished_write(mp); 940 } while (error == ERELOOKUP); 941 return (error); 942 case BIO_DELETE: 943 if (sc->candelete) { 944 error = vn_deallocate(vp, &off, &len, 0, 945 sc->flags & MD_ASYNC ? 0 : IO_SYNC, 946 sc->cred, NOCRED); 947 bp->bio_resid = len; 948 return (error); 949 } 950 /* FALLTHROUGH */ 951 default: 952 return (EOPNOTSUPP); 953 } 954 955 auio.uio_offset = (vm_ooffset_t)bp->bio_offset; 956 auio.uio_resid = bp->bio_length; 957 auio.uio_segflg = UIO_SYSSPACE; 958 auio.uio_td = td; 959 960 if ((bp->bio_flags & BIO_VLIST) != 0) { 961 piov = malloc(sizeof(*piov) * bp->bio_ma_n, M_MD, M_WAITOK); 962 auio.uio_iov = piov; 963 vlist = (bus_dma_segment_t *)bp->bio_data; 964 while (len > 0) { 965 piov->iov_base = (void *)(uintptr_t)(vlist->ds_addr + 966 ma_offs); 967 piov->iov_len = vlist->ds_len - ma_offs; 968 if (piov->iov_len > len) 969 piov->iov_len = len; 970 len -= piov->iov_len; 971 ma_offs = 0; 972 vlist++; 973 piov++; 974 } 975 auio.uio_iovcnt = piov - auio.uio_iov; 976 piov = auio.uio_iov; 977 } else if ((bp->bio_flags & BIO_UNMAPPED) != 0) { 978 bp->bio_resid = len; 979 unmapped_step: 980 npages = atop(min(maxphys, round_page(len + (ma_offs & 981 PAGE_MASK)))); 982 iolen = min(ptoa(npages) - (ma_offs & PAGE_MASK), len); 983 KASSERT(iolen > 0, ("zero iolen")); 984 KASSERT(npages <= atop(maxphys + PAGE_SIZE), 985 ("npages %d too large", npages)); 986 pmap_qenter(sc->s_vnode.kva, &bp->bio_ma[atop(ma_offs)], 987 npages); 988 aiov.iov_base = (void *)(sc->s_vnode.kva + (ma_offs & 989 PAGE_MASK)); 990 aiov.iov_len = iolen; 991 auio.uio_iov = &aiov; 992 auio.uio_iovcnt = 1; 993 auio.uio_resid = iolen; 994 mapped = true; 995 } else { 996 aiov.iov_base = bp->bio_data; 997 aiov.iov_len = bp->bio_length; 998 auio.uio_iov = &aiov; 999 auio.uio_iovcnt = 1; 1000 } 1001 iostart = auio.uio_offset; 1002 if (bp->bio_cmd == BIO_READ) { 1003 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 1004 error = VOP_READ(vp, &auio, 0, sc->cred); 1005 VOP_UNLOCK(vp); 1006 } else { 1007 (void) vn_start_write(vp, &mp, V_WAIT); 1008 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 1009 error = VOP_WRITE(vp, &auio, sc->flags & MD_ASYNC ? 0 : IO_SYNC, 1010 sc->cred); 1011 VOP_UNLOCK(vp); 1012 vn_finished_write(mp); 1013 if (error == 0) 1014 sc->flags &= ~MD_VERIFY; 1015 } 1016 1017 /* When MD_CACHE is set, try to avoid double-caching the data. */ 1018 if (error == 0 && (sc->flags & MD_CACHE) == 0) 1019 VOP_ADVISE(vp, iostart, auio.uio_offset - 1, 1020 POSIX_FADV_DONTNEED); 1021 1022 if (mapped) { 1023 pmap_qremove(sc->s_vnode.kva, npages); 1024 if (error == 0) { 1025 len -= iolen; 1026 bp->bio_resid -= iolen; 1027 ma_offs += iolen; 1028 if (len > 0) 1029 goto unmapped_step; 1030 } 1031 } else { 1032 bp->bio_resid = auio.uio_resid; 1033 } 1034 1035 free(piov, M_MD); 1036 return (error); 1037 } 1038 1039 static int 1040 mdstart_swap(struct md_s *sc, struct bio *bp) 1041 { 1042 vm_page_t m; 1043 u_char *p; 1044 vm_pindex_t i, lastp; 1045 bus_dma_segment_t *vlist; 1046 int rv, ma_offs, offs, len, lastend; 1047 1048 switch (bp->bio_cmd) { 1049 case BIO_READ: 1050 case BIO_WRITE: 1051 case BIO_DELETE: 1052 break; 1053 case BIO_FLUSH: 1054 return (0); 1055 default: 1056 return (EOPNOTSUPP); 1057 } 1058 1059 p = bp->bio_data; 1060 ma_offs = (bp->bio_flags & (BIO_UNMAPPED|BIO_VLIST)) != 0 ? 1061 bp->bio_ma_offset : 0; 1062 vlist = (bp->bio_flags & BIO_VLIST) != 0 ? 1063 (bus_dma_segment_t *)bp->bio_data : NULL; 1064 1065 /* 1066 * offs is the offset at which to start operating on the 1067 * next (ie, first) page. lastp is the last page on 1068 * which we're going to operate. lastend is the ending 1069 * position within that last page (ie, PAGE_SIZE if 1070 * we're operating on complete aligned pages). 1071 */ 1072 offs = bp->bio_offset % PAGE_SIZE; 1073 lastp = (bp->bio_offset + bp->bio_length - 1) / PAGE_SIZE; 1074 lastend = (bp->bio_offset + bp->bio_length - 1) % PAGE_SIZE + 1; 1075 1076 rv = VM_PAGER_OK; 1077 vm_object_pip_add(sc->s_swap.object, 1); 1078 for (i = bp->bio_offset / PAGE_SIZE; i <= lastp; i++) { 1079 len = ((i == lastp) ? lastend : PAGE_SIZE) - offs; 1080 m = vm_page_grab_unlocked(sc->s_swap.object, i, 1081 VM_ALLOC_SYSTEM); 1082 if (bp->bio_cmd == BIO_READ) { 1083 if (vm_page_all_valid(m)) 1084 rv = VM_PAGER_OK; 1085 else 1086 rv = vm_pager_get_pages(sc->s_swap.object, 1087 &m, 1, NULL, NULL); 1088 if (rv == VM_PAGER_ERROR) { 1089 VM_OBJECT_WLOCK(sc->s_swap.object); 1090 vm_page_free(m); 1091 VM_OBJECT_WUNLOCK(sc->s_swap.object); 1092 break; 1093 } else if (rv == VM_PAGER_FAIL) { 1094 /* 1095 * Pager does not have the page. Zero 1096 * the allocated page, and mark it as 1097 * valid. Do not set dirty, the page 1098 * can be recreated if thrown out. 1099 */ 1100 pmap_zero_page(m); 1101 vm_page_valid(m); 1102 } 1103 if ((bp->bio_flags & BIO_UNMAPPED) != 0) { 1104 pmap_copy_pages(&m, offs, bp->bio_ma, 1105 ma_offs, len); 1106 } else if ((bp->bio_flags & BIO_VLIST) != 0) { 1107 physcopyout_vlist(VM_PAGE_TO_PHYS(m) + offs, 1108 vlist, ma_offs, len); 1109 cpu_flush_dcache(p, len); 1110 } else { 1111 physcopyout(VM_PAGE_TO_PHYS(m) + offs, p, len); 1112 cpu_flush_dcache(p, len); 1113 } 1114 } else if (bp->bio_cmd == BIO_WRITE) { 1115 if (len == PAGE_SIZE || vm_page_all_valid(m)) 1116 rv = VM_PAGER_OK; 1117 else 1118 rv = vm_pager_get_pages(sc->s_swap.object, 1119 &m, 1, NULL, NULL); 1120 if (rv == VM_PAGER_ERROR) { 1121 VM_OBJECT_WLOCK(sc->s_swap.object); 1122 vm_page_free(m); 1123 VM_OBJECT_WUNLOCK(sc->s_swap.object); 1124 break; 1125 } else if (rv == VM_PAGER_FAIL) 1126 pmap_zero_page(m); 1127 1128 if ((bp->bio_flags & BIO_UNMAPPED) != 0) { 1129 pmap_copy_pages(bp->bio_ma, ma_offs, &m, 1130 offs, len); 1131 } else if ((bp->bio_flags & BIO_VLIST) != 0) { 1132 physcopyin_vlist(vlist, ma_offs, 1133 VM_PAGE_TO_PHYS(m) + offs, len); 1134 } else { 1135 physcopyin(p, VM_PAGE_TO_PHYS(m) + offs, len); 1136 } 1137 1138 vm_page_valid(m); 1139 vm_page_set_dirty(m); 1140 } else if (bp->bio_cmd == BIO_DELETE) { 1141 if (len == PAGE_SIZE || vm_page_all_valid(m)) 1142 rv = VM_PAGER_OK; 1143 else 1144 rv = vm_pager_get_pages(sc->s_swap.object, 1145 &m, 1, NULL, NULL); 1146 VM_OBJECT_WLOCK(sc->s_swap.object); 1147 if (rv == VM_PAGER_ERROR) { 1148 vm_page_free(m); 1149 VM_OBJECT_WUNLOCK(sc->s_swap.object); 1150 break; 1151 } else if (rv == VM_PAGER_FAIL) { 1152 vm_page_free(m); 1153 m = NULL; 1154 } else { 1155 /* Page is valid. */ 1156 if (len != PAGE_SIZE) { 1157 pmap_zero_page_area(m, offs, len); 1158 vm_page_set_dirty(m); 1159 } else { 1160 vm_pager_page_unswapped(m); 1161 vm_page_free(m); 1162 m = NULL; 1163 } 1164 } 1165 VM_OBJECT_WUNLOCK(sc->s_swap.object); 1166 } 1167 if (m != NULL) { 1168 /* 1169 * The page may be deactivated prior to setting 1170 * PGA_REFERENCED, but in this case it will be 1171 * reactivated by the page daemon. 1172 */ 1173 if (vm_page_active(m)) 1174 vm_page_reference(m); 1175 else 1176 vm_page_activate(m); 1177 vm_page_xunbusy(m); 1178 } 1179 1180 /* Actions on further pages start at offset 0 */ 1181 p += PAGE_SIZE - offs; 1182 offs = 0; 1183 ma_offs += len; 1184 } 1185 vm_object_pip_wakeup(sc->s_swap.object); 1186 return (rv != VM_PAGER_ERROR ? 0 : ENOSPC); 1187 } 1188 1189 static int 1190 mdstart_null(struct md_s *sc, struct bio *bp) 1191 { 1192 1193 switch (bp->bio_cmd) { 1194 case BIO_READ: 1195 bzero(bp->bio_data, bp->bio_length); 1196 cpu_flush_dcache(bp->bio_data, bp->bio_length); 1197 break; 1198 case BIO_WRITE: 1199 break; 1200 } 1201 bp->bio_resid = 0; 1202 return (0); 1203 } 1204 1205 static void 1206 md_handleattr(struct md_s *sc, struct bio *bp) 1207 { 1208 if (sc->fwsectors && sc->fwheads && 1209 (g_handleattr_int(bp, "GEOM::fwsectors", sc->fwsectors) != 0 || 1210 g_handleattr_int(bp, "GEOM::fwheads", sc->fwheads) != 0)) 1211 return; 1212 if (g_handleattr_int(bp, "GEOM::candelete", sc->candelete) != 0) 1213 return; 1214 if (sc->ident[0] != '\0' && 1215 g_handleattr_str(bp, "GEOM::ident", sc->ident) != 0) 1216 return; 1217 if (g_handleattr_int(bp, "MNT::verified", (sc->flags & MD_VERIFY) != 0)) 1218 return; 1219 g_io_deliver(bp, EOPNOTSUPP); 1220 } 1221 1222 static void 1223 md_kthread(void *arg) 1224 { 1225 struct md_s *sc; 1226 struct bio *bp; 1227 int error; 1228 1229 sc = arg; 1230 thread_lock(curthread); 1231 sched_prio(curthread, PRIBIO); 1232 thread_unlock(curthread); 1233 if (sc->type == MD_VNODE) 1234 curthread->td_pflags |= TDP_NORUNNINGBUF; 1235 1236 for (;;) { 1237 mtx_lock(&sc->queue_mtx); 1238 if (sc->flags & MD_SHUTDOWN) { 1239 sc->flags |= MD_EXITING; 1240 mtx_unlock(&sc->queue_mtx); 1241 kproc_exit(0); 1242 } 1243 bp = bioq_takefirst(&sc->bio_queue); 1244 if (!bp) { 1245 msleep(sc, &sc->queue_mtx, PRIBIO | PDROP, "mdwait", 0); 1246 continue; 1247 } 1248 mtx_unlock(&sc->queue_mtx); 1249 if (bp->bio_cmd == BIO_GETATTR) { 1250 md_handleattr(sc, bp); 1251 } else { 1252 error = sc->start(sc, bp); 1253 if (bp->bio_cmd == BIO_READ || bp->bio_cmd == BIO_WRITE) { 1254 /* 1255 * Devstat uses (bio_bcount, bio_resid) for 1256 * determining the length of the completed part 1257 * of the i/o. g_io_deliver() will translate 1258 * from bio_completed to that, but it also 1259 * destroys the bio so we must do our own 1260 * translation. 1261 */ 1262 bp->bio_bcount = bp->bio_length; 1263 devstat_end_transaction_bio(sc->devstat, bp); 1264 } 1265 bp->bio_completed = bp->bio_length - bp->bio_resid; 1266 g_io_deliver(bp, error); 1267 } 1268 } 1269 } 1270 1271 static struct md_s * 1272 mdfind(int unit) 1273 { 1274 struct md_s *sc; 1275 1276 LIST_FOREACH(sc, &md_softc_list, list) { 1277 if (sc->unit == unit) 1278 break; 1279 } 1280 return (sc); 1281 } 1282 1283 static struct md_s * 1284 mdnew(int unit, int *errp, enum md_types type) 1285 { 1286 struct md_s *sc; 1287 int error; 1288 1289 *errp = 0; 1290 if (unit == -1) 1291 unit = alloc_unr(md_uh); 1292 else 1293 unit = alloc_unr_specific(md_uh, unit); 1294 1295 if (unit == -1) { 1296 *errp = EBUSY; 1297 return (NULL); 1298 } 1299 1300 sc = malloc(sizeof(*sc), M_MD, M_WAITOK | M_ZERO); 1301 sc->type = type; 1302 bioq_init(&sc->bio_queue); 1303 mtx_init(&sc->queue_mtx, "md bio queue", NULL, MTX_DEF); 1304 sc->unit = unit; 1305 sprintf(sc->name, "md%d", unit); 1306 LIST_INSERT_HEAD(&md_softc_list, sc, list); 1307 error = kproc_create(md_kthread, sc, &sc->procp, 0, 0,"%s", sc->name); 1308 if (error == 0) 1309 return (sc); 1310 LIST_REMOVE(sc, list); 1311 mtx_destroy(&sc->queue_mtx); 1312 free_unr(md_uh, sc->unit); 1313 free(sc, M_MD); 1314 *errp = error; 1315 return (NULL); 1316 } 1317 1318 static void 1319 mdinit(struct md_s *sc) 1320 { 1321 struct g_geom *gp; 1322 struct g_provider *pp; 1323 unsigned remn; 1324 1325 g_topology_lock(); 1326 gp = g_new_geomf(&g_md_class, "md%d", sc->unit); 1327 gp->softc = sc; 1328 pp = g_new_providerf(gp, "md%d", sc->unit); 1329 devstat_remove_entry(pp->stat); 1330 pp->stat = NULL; 1331 pp->flags |= G_PF_DIRECT_SEND | G_PF_DIRECT_RECEIVE; 1332 /* Prune off any residual fractional sector. */ 1333 remn = sc->mediasize % sc->sectorsize; 1334 if (remn != 0) { 1335 printf("md%d: truncating fractional last sector by %u bytes\n", 1336 sc->unit, remn); 1337 sc->mediasize -= remn; 1338 } 1339 pp->mediasize = sc->mediasize; 1340 pp->sectorsize = sc->sectorsize; 1341 switch (sc->type) { 1342 case MD_MALLOC: 1343 case MD_VNODE: 1344 case MD_SWAP: 1345 pp->flags |= G_PF_ACCEPT_UNMAPPED; 1346 break; 1347 case MD_PRELOAD: 1348 case MD_NULL: 1349 break; 1350 } 1351 sc->gp = gp; 1352 sc->pp = pp; 1353 sc->devstat = devstat_new_entry("md", sc->unit, sc->sectorsize, 1354 DEVSTAT_ALL_SUPPORTED, DEVSTAT_TYPE_DIRECT, DEVSTAT_PRIORITY_MAX); 1355 sc->devstat->id = pp; 1356 g_error_provider(pp, 0); 1357 g_topology_unlock(); 1358 } 1359 1360 static int 1361 mdcreate_malloc(struct md_s *sc, struct md_req *mdr) 1362 { 1363 uintptr_t sp; 1364 int error; 1365 off_t u; 1366 1367 error = 0; 1368 if (mdr->md_options & ~(MD_AUTOUNIT | MD_COMPRESS | MD_RESERVE)) 1369 return (EINVAL); 1370 if (mdr->md_sectorsize != 0 && !powerof2(mdr->md_sectorsize)) 1371 return (EINVAL); 1372 /* Compression doesn't make sense if we have reserved space */ 1373 if (mdr->md_options & MD_RESERVE) 1374 mdr->md_options &= ~MD_COMPRESS; 1375 if (mdr->md_fwsectors != 0) 1376 sc->fwsectors = mdr->md_fwsectors; 1377 if (mdr->md_fwheads != 0) 1378 sc->fwheads = mdr->md_fwheads; 1379 sc->flags = mdr->md_options & (MD_COMPRESS | MD_FORCE | MD_RESERVE); 1380 sc->s_malloc.indir = dimension(sc->mediasize / sc->sectorsize); 1381 sc->s_malloc.uma = uma_zcreate(sc->name, sc->sectorsize, NULL, NULL, 1382 NULL, NULL, 0x1ff, 0); 1383 if (mdr->md_options & MD_RESERVE) { 1384 off_t nsectors; 1385 1386 nsectors = sc->mediasize / sc->sectorsize; 1387 for (u = 0; u < nsectors; u++) { 1388 sp = (uintptr_t)uma_zalloc(sc->s_malloc.uma, 1389 (md_malloc_wait ? M_WAITOK : M_NOWAIT) | M_ZERO); 1390 if (sp != 0) 1391 error = s_write(sc->s_malloc.indir, u, sp); 1392 else 1393 error = ENOMEM; 1394 if (error != 0) 1395 break; 1396 } 1397 } 1398 return (error); 1399 } 1400 1401 static int 1402 mdsetcred(struct md_s *sc, struct ucred *cred) 1403 { 1404 char *tmpbuf; 1405 int error = 0; 1406 1407 /* 1408 * Set credits in our softc 1409 */ 1410 1411 if (sc->cred) 1412 crfree(sc->cred); 1413 sc->cred = crhold(cred); 1414 1415 /* 1416 * Horrible kludge to establish credentials for NFS XXX. 1417 */ 1418 1419 if (sc->type == MD_VNODE && sc->s_vnode.vnode != NULL) { 1420 struct uio auio; 1421 struct iovec aiov; 1422 1423 tmpbuf = malloc(sc->sectorsize, M_TEMP, M_WAITOK); 1424 bzero(&auio, sizeof(auio)); 1425 1426 aiov.iov_base = tmpbuf; 1427 aiov.iov_len = sc->sectorsize; 1428 auio.uio_iov = &aiov; 1429 auio.uio_iovcnt = 1; 1430 auio.uio_offset = 0; 1431 auio.uio_rw = UIO_READ; 1432 auio.uio_segflg = UIO_SYSSPACE; 1433 auio.uio_resid = aiov.iov_len; 1434 vn_lock(sc->s_vnode.vnode, LK_EXCLUSIVE | LK_RETRY); 1435 error = VOP_READ(sc->s_vnode.vnode, &auio, 0, sc->cred); 1436 VOP_UNLOCK(sc->s_vnode.vnode); 1437 free(tmpbuf, M_TEMP); 1438 } 1439 return (error); 1440 } 1441 1442 static int 1443 mdcreate_vnode(struct md_s *sc, struct md_req *mdr, struct thread *td) 1444 { 1445 struct vattr vattr; 1446 struct nameidata nd; 1447 char *fname; 1448 int error, flags; 1449 long v; 1450 1451 fname = mdr->md_file; 1452 if (mdr->md_file_seg == UIO_USERSPACE) { 1453 error = copyinstr(fname, sc->s_vnode.file, 1454 sizeof(sc->s_vnode.file), NULL); 1455 if (error != 0) 1456 return (error); 1457 } else if (mdr->md_file_seg == UIO_SYSSPACE) 1458 strlcpy(sc->s_vnode.file, fname, sizeof(sc->s_vnode.file)); 1459 else 1460 return (EDOOFUS); 1461 1462 /* 1463 * If the user specified that this is a read only device, don't 1464 * set the FWRITE mask before trying to open the backing store. 1465 */ 1466 flags = FREAD | ((mdr->md_options & MD_READONLY) ? 0 : FWRITE) \ 1467 | ((mdr->md_options & MD_VERIFY) ? O_VERIFY : 0); 1468 NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, sc->s_vnode.file); 1469 error = vn_open(&nd, &flags, 0, NULL); 1470 if (error != 0) 1471 return (error); 1472 NDFREE_PNBUF(&nd); 1473 if (nd.ni_vp->v_type != VREG) { 1474 error = EINVAL; 1475 goto bad; 1476 } 1477 error = VOP_GETATTR(nd.ni_vp, &vattr, td->td_ucred); 1478 if (error != 0) 1479 goto bad; 1480 if ((mdr->md_options & MD_MUSTDEALLOC) != 0) { 1481 error = VOP_PATHCONF(nd.ni_vp, _PC_DEALLOC_PRESENT, &v); 1482 if (error != 0) 1483 goto bad; 1484 if (v == 0) 1485 sc->candelete = false; 1486 } 1487 if (VOP_ISLOCKED(nd.ni_vp) != LK_EXCLUSIVE) { 1488 vn_lock(nd.ni_vp, LK_UPGRADE | LK_RETRY); 1489 if (VN_IS_DOOMED(nd.ni_vp)) { 1490 /* Forced unmount. */ 1491 error = EBADF; 1492 goto bad; 1493 } 1494 } 1495 nd.ni_vp->v_vflag |= VV_MD; 1496 VOP_UNLOCK(nd.ni_vp); 1497 1498 if (mdr->md_fwsectors != 0) 1499 sc->fwsectors = mdr->md_fwsectors; 1500 if (mdr->md_fwheads != 0) 1501 sc->fwheads = mdr->md_fwheads; 1502 snprintf(sc->ident, sizeof(sc->ident), "MD-DEV%ju-INO%ju", 1503 (uintmax_t)vattr.va_fsid, (uintmax_t)vattr.va_fileid); 1504 sc->flags = mdr->md_options & (MD_ASYNC | MD_CACHE | MD_FORCE | 1505 MD_VERIFY | MD_MUSTDEALLOC); 1506 if (!(flags & FWRITE)) 1507 sc->flags |= MD_READONLY; 1508 sc->s_vnode.vnode = nd.ni_vp; 1509 1510 error = mdsetcred(sc, td->td_ucred); 1511 if (error != 0) { 1512 sc->s_vnode.vnode = NULL; 1513 vn_lock(nd.ni_vp, LK_EXCLUSIVE | LK_RETRY); 1514 nd.ni_vp->v_vflag &= ~VV_MD; 1515 goto bad; 1516 } 1517 1518 sc->s_vnode.kva = kva_alloc(maxphys + PAGE_SIZE); 1519 return (0); 1520 bad: 1521 VOP_UNLOCK(nd.ni_vp); 1522 (void)vn_close(nd.ni_vp, flags, td->td_ucred, td); 1523 return (error); 1524 } 1525 1526 static void 1527 g_md_providergone(struct g_provider *pp) 1528 { 1529 struct md_s *sc = pp->geom->softc; 1530 1531 mtx_lock(&sc->queue_mtx); 1532 sc->flags |= MD_PROVIDERGONE; 1533 wakeup(&sc->flags); 1534 mtx_unlock(&sc->queue_mtx); 1535 } 1536 1537 static int 1538 mddestroy(struct md_s *sc, struct thread *td) 1539 { 1540 1541 if (sc->gp) { 1542 g_topology_lock(); 1543 g_wither_geom(sc->gp, ENXIO); 1544 g_topology_unlock(); 1545 1546 mtx_lock(&sc->queue_mtx); 1547 while (!(sc->flags & MD_PROVIDERGONE)) 1548 msleep(&sc->flags, &sc->queue_mtx, PRIBIO, "mddestroy", 0); 1549 mtx_unlock(&sc->queue_mtx); 1550 } 1551 if (sc->devstat) { 1552 devstat_remove_entry(sc->devstat); 1553 sc->devstat = NULL; 1554 } 1555 mtx_lock(&sc->queue_mtx); 1556 sc->flags |= MD_SHUTDOWN; 1557 wakeup(sc); 1558 while (!(sc->flags & MD_EXITING)) 1559 msleep(sc->procp, &sc->queue_mtx, PRIBIO, "mddestroy", hz / 10); 1560 mtx_unlock(&sc->queue_mtx); 1561 mtx_destroy(&sc->queue_mtx); 1562 switch (sc->type) { 1563 case MD_VNODE: 1564 if (sc->s_vnode.vnode != NULL) { 1565 vn_lock(sc->s_vnode.vnode, LK_EXCLUSIVE | LK_RETRY); 1566 sc->s_vnode.vnode->v_vflag &= ~VV_MD; 1567 VOP_UNLOCK(sc->s_vnode.vnode); 1568 (void)vn_close(sc->s_vnode.vnode, 1569 sc->flags & MD_READONLY ? FREAD : (FREAD|FWRITE), 1570 sc->cred, td); 1571 } 1572 if (sc->s_vnode.kva != 0) 1573 kva_free(sc->s_vnode.kva, maxphys + PAGE_SIZE); 1574 break; 1575 case MD_SWAP: 1576 if (sc->s_swap.object != NULL) 1577 vm_object_deallocate(sc->s_swap.object); 1578 break; 1579 case MD_MALLOC: 1580 if (sc->s_malloc.indir != NULL) 1581 destroy_indir(sc, sc->s_malloc.indir); 1582 if (sc->s_malloc.uma != NULL) 1583 uma_zdestroy(sc->s_malloc.uma); 1584 break; 1585 case MD_PRELOAD: 1586 case MD_NULL: 1587 break; 1588 default: 1589 __assert_unreachable(); 1590 } 1591 if (sc->cred != NULL) 1592 crfree(sc->cred); 1593 1594 LIST_REMOVE(sc, list); 1595 free_unr(md_uh, sc->unit); 1596 free(sc, M_MD); 1597 return (0); 1598 } 1599 1600 static int 1601 mdresize(struct md_s *sc, struct md_req *mdr) 1602 { 1603 int error, res; 1604 vm_pindex_t oldpages, newpages; 1605 1606 switch (sc->type) { 1607 case MD_VNODE: 1608 case MD_NULL: 1609 break; 1610 case MD_SWAP: 1611 if (mdr->md_mediasize <= 0 || 1612 (mdr->md_mediasize % PAGE_SIZE) != 0) 1613 return (EDOM); 1614 oldpages = OFF_TO_IDX(sc->mediasize); 1615 newpages = OFF_TO_IDX(mdr->md_mediasize); 1616 if (newpages < oldpages) { 1617 VM_OBJECT_WLOCK(sc->s_swap.object); 1618 vm_object_page_remove(sc->s_swap.object, newpages, 1619 0, 0); 1620 swap_release_by_cred(IDX_TO_OFF(oldpages - 1621 newpages), sc->cred); 1622 sc->s_swap.object->charge = IDX_TO_OFF(newpages); 1623 sc->s_swap.object->size = newpages; 1624 VM_OBJECT_WUNLOCK(sc->s_swap.object); 1625 } else if (newpages > oldpages) { 1626 res = swap_reserve_by_cred(IDX_TO_OFF(newpages - 1627 oldpages), sc->cred); 1628 if (!res) 1629 return (ENOMEM); 1630 if ((mdr->md_options & MD_RESERVE) || 1631 (sc->flags & MD_RESERVE)) { 1632 error = swap_pager_reserve(sc->s_swap.object, 1633 oldpages, newpages - oldpages); 1634 if (error < 0) { 1635 swap_release_by_cred( 1636 IDX_TO_OFF(newpages - oldpages), 1637 sc->cred); 1638 return (EDOM); 1639 } 1640 } 1641 VM_OBJECT_WLOCK(sc->s_swap.object); 1642 sc->s_swap.object->charge = IDX_TO_OFF(newpages); 1643 sc->s_swap.object->size = newpages; 1644 VM_OBJECT_WUNLOCK(sc->s_swap.object); 1645 } 1646 break; 1647 default: 1648 return (EOPNOTSUPP); 1649 } 1650 1651 sc->mediasize = mdr->md_mediasize; 1652 1653 g_topology_lock(); 1654 g_resize_provider(sc->pp, sc->mediasize); 1655 g_topology_unlock(); 1656 return (0); 1657 } 1658 1659 static int 1660 mdcreate_swap(struct md_s *sc, struct md_req *mdr, struct thread *td) 1661 { 1662 vm_ooffset_t npage; 1663 int error; 1664 1665 /* 1666 * Range check. Disallow negative sizes and sizes not being 1667 * multiple of page size. 1668 */ 1669 if (sc->mediasize <= 0 || (sc->mediasize % PAGE_SIZE) != 0) 1670 return (EDOM); 1671 1672 /* 1673 * Allocate an OBJT_SWAP object. 1674 * 1675 * Note the truncation. 1676 */ 1677 1678 if ((mdr->md_options & MD_VERIFY) != 0) 1679 return (EINVAL); 1680 npage = mdr->md_mediasize / PAGE_SIZE; 1681 if (mdr->md_fwsectors != 0) 1682 sc->fwsectors = mdr->md_fwsectors; 1683 if (mdr->md_fwheads != 0) 1684 sc->fwheads = mdr->md_fwheads; 1685 sc->s_swap.object = vm_pager_allocate(OBJT_SWAP, NULL, 1686 PAGE_SIZE * npage, VM_PROT_DEFAULT, 0, td->td_ucred); 1687 if (sc->s_swap.object == NULL) 1688 return (ENOMEM); 1689 sc->flags = mdr->md_options & (MD_FORCE | MD_RESERVE); 1690 if (mdr->md_options & MD_RESERVE) { 1691 if (swap_pager_reserve(sc->s_swap.object, 0, npage) < 0) { 1692 error = EDOM; 1693 goto finish; 1694 } 1695 } 1696 error = mdsetcred(sc, td->td_ucred); 1697 finish: 1698 if (error != 0) { 1699 vm_object_deallocate(sc->s_swap.object); 1700 sc->s_swap.object = NULL; 1701 } 1702 return (error); 1703 } 1704 1705 static int 1706 mdcreate_null(struct md_s *sc, struct md_req *mdr, struct thread *td) 1707 { 1708 1709 /* 1710 * Range check. Disallow negative sizes and sizes not being 1711 * multiple of page size. 1712 */ 1713 if (sc->mediasize <= 0 || (sc->mediasize % PAGE_SIZE) != 0) 1714 return (EDOM); 1715 1716 return (0); 1717 } 1718 1719 static int 1720 kern_mdattach_locked(struct thread *td, struct md_req *mdr) 1721 { 1722 struct md_s *sc; 1723 unsigned sectsize; 1724 int error; 1725 1726 sx_assert(&md_sx, SA_XLOCKED); 1727 1728 switch (mdr->md_type) { 1729 case MD_MALLOC: 1730 case MD_PRELOAD: 1731 case MD_VNODE: 1732 case MD_SWAP: 1733 case MD_NULL: 1734 break; 1735 default: 1736 return (EINVAL); 1737 } 1738 if (mdr->md_sectorsize == 0) 1739 sectsize = DEV_BSIZE; 1740 else 1741 sectsize = mdr->md_sectorsize; 1742 if (sectsize > maxphys || mdr->md_mediasize < sectsize) 1743 return (EINVAL); 1744 if (mdr->md_options & MD_AUTOUNIT) 1745 sc = mdnew(-1, &error, mdr->md_type); 1746 else { 1747 if (mdr->md_unit > INT_MAX) 1748 return (EINVAL); 1749 sc = mdnew(mdr->md_unit, &error, mdr->md_type); 1750 } 1751 if (sc == NULL) 1752 return (error); 1753 if (mdr->md_label != NULL) 1754 error = copyinstr(mdr->md_label, sc->label, 1755 sizeof(sc->label), NULL); 1756 if (error != 0) 1757 goto err_after_new; 1758 if (mdr->md_options & MD_AUTOUNIT) 1759 mdr->md_unit = sc->unit; 1760 sc->mediasize = mdr->md_mediasize; 1761 sc->sectorsize = sectsize; 1762 sc->candelete = true; 1763 error = EDOOFUS; 1764 switch (sc->type) { 1765 case MD_MALLOC: 1766 sc->start = mdstart_malloc; 1767 error = mdcreate_malloc(sc, mdr); 1768 break; 1769 case MD_PRELOAD: 1770 /* 1771 * We disallow attaching preloaded memory disks via 1772 * ioctl. Preloaded memory disks are automatically 1773 * attached in g_md_init(). 1774 */ 1775 error = EOPNOTSUPP; 1776 break; 1777 case MD_VNODE: 1778 sc->start = mdstart_vnode; 1779 error = mdcreate_vnode(sc, mdr, td); 1780 break; 1781 case MD_SWAP: 1782 sc->start = mdstart_swap; 1783 error = mdcreate_swap(sc, mdr, td); 1784 break; 1785 case MD_NULL: 1786 sc->start = mdstart_null; 1787 error = mdcreate_null(sc, mdr, td); 1788 break; 1789 } 1790 err_after_new: 1791 if (error != 0) { 1792 mddestroy(sc, td); 1793 return (error); 1794 } 1795 1796 mdinit(sc); 1797 return (0); 1798 } 1799 1800 static int 1801 kern_mdattach(struct thread *td, struct md_req *mdr) 1802 { 1803 int error; 1804 1805 sx_xlock(&md_sx); 1806 error = kern_mdattach_locked(td, mdr); 1807 sx_xunlock(&md_sx); 1808 return (error); 1809 } 1810 1811 static int 1812 kern_mddetach_locked(struct thread *td, struct md_req *mdr) 1813 { 1814 struct md_s *sc; 1815 1816 sx_assert(&md_sx, SA_XLOCKED); 1817 1818 if (mdr->md_mediasize != 0 || 1819 (mdr->md_options & ~MD_FORCE) != 0) 1820 return (EINVAL); 1821 1822 sc = mdfind(mdr->md_unit); 1823 if (sc == NULL) 1824 return (ENOENT); 1825 if (sc->opencount != 0 && !(sc->flags & MD_FORCE) && 1826 !(mdr->md_options & MD_FORCE)) 1827 return (EBUSY); 1828 return (mddestroy(sc, td)); 1829 } 1830 1831 static int 1832 kern_mddetach(struct thread *td, struct md_req *mdr) 1833 { 1834 int error; 1835 1836 sx_xlock(&md_sx); 1837 error = kern_mddetach_locked(td, mdr); 1838 sx_xunlock(&md_sx); 1839 return (error); 1840 } 1841 1842 static int 1843 kern_mdresize_locked(struct md_req *mdr) 1844 { 1845 struct md_s *sc; 1846 1847 sx_assert(&md_sx, SA_XLOCKED); 1848 1849 if ((mdr->md_options & ~(MD_FORCE | MD_RESERVE)) != 0) 1850 return (EINVAL); 1851 1852 sc = mdfind(mdr->md_unit); 1853 if (sc == NULL) 1854 return (ENOENT); 1855 if (mdr->md_mediasize < sc->sectorsize) 1856 return (EINVAL); 1857 mdr->md_mediasize -= mdr->md_mediasize % sc->sectorsize; 1858 if (mdr->md_mediasize < sc->mediasize && 1859 !(sc->flags & MD_FORCE) && 1860 !(mdr->md_options & MD_FORCE)) 1861 return (EBUSY); 1862 return (mdresize(sc, mdr)); 1863 } 1864 1865 static int 1866 kern_mdresize(struct md_req *mdr) 1867 { 1868 int error; 1869 1870 sx_xlock(&md_sx); 1871 error = kern_mdresize_locked(mdr); 1872 sx_xunlock(&md_sx); 1873 return (error); 1874 } 1875 1876 static int 1877 kern_mdquery_locked(struct md_req *mdr) 1878 { 1879 struct md_s *sc; 1880 int error; 1881 1882 sx_assert(&md_sx, SA_XLOCKED); 1883 1884 sc = mdfind(mdr->md_unit); 1885 if (sc == NULL) 1886 return (ENOENT); 1887 mdr->md_type = sc->type; 1888 mdr->md_options = sc->flags; 1889 mdr->md_mediasize = sc->mediasize; 1890 mdr->md_sectorsize = sc->sectorsize; 1891 error = 0; 1892 if (mdr->md_label != NULL) { 1893 error = copyout(sc->label, mdr->md_label, 1894 strlen(sc->label) + 1); 1895 if (error != 0) 1896 return (error); 1897 } 1898 if (sc->type == MD_VNODE) { 1899 error = copyout(sc->s_vnode.file, mdr->md_file, 1900 strlen(sc->s_vnode.file) + 1); 1901 } else if (sc->type == MD_PRELOAD && mdr->md_file != NULL) { 1902 error = copyout(sc->s_preload.name, mdr->md_file, 1903 strlen(sc->s_preload.name) + 1); 1904 } 1905 return (error); 1906 } 1907 1908 static int 1909 kern_mdquery(struct md_req *mdr) 1910 { 1911 int error; 1912 1913 sx_xlock(&md_sx); 1914 error = kern_mdquery_locked(mdr); 1915 sx_xunlock(&md_sx); 1916 return (error); 1917 } 1918 1919 /* Copy members that are not userspace pointers. */ 1920 #define MD_IOCTL2REQ(mdio, mdr) do { \ 1921 (mdr)->md_unit = (mdio)->md_unit; \ 1922 (mdr)->md_type = (mdio)->md_type; \ 1923 (mdr)->md_mediasize = (mdio)->md_mediasize; \ 1924 (mdr)->md_sectorsize = (mdio)->md_sectorsize; \ 1925 (mdr)->md_options = (mdio)->md_options; \ 1926 (mdr)->md_fwheads = (mdio)->md_fwheads; \ 1927 (mdr)->md_fwsectors = (mdio)->md_fwsectors; \ 1928 (mdr)->md_units = &(mdio)->md_pad[0]; \ 1929 (mdr)->md_units_nitems = nitems((mdio)->md_pad); \ 1930 } while(0) 1931 1932 /* Copy members that might have been updated */ 1933 #define MD_REQ2IOCTL(mdr, mdio) do { \ 1934 (mdio)->md_unit = (mdr)->md_unit; \ 1935 (mdio)->md_type = (mdr)->md_type; \ 1936 (mdio)->md_mediasize = (mdr)->md_mediasize; \ 1937 (mdio)->md_sectorsize = (mdr)->md_sectorsize; \ 1938 (mdio)->md_options = (mdr)->md_options; \ 1939 (mdio)->md_fwheads = (mdr)->md_fwheads; \ 1940 (mdio)->md_fwsectors = (mdr)->md_fwsectors; \ 1941 } while(0) 1942 1943 static int 1944 mdctlioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flags, 1945 struct thread *td) 1946 { 1947 struct md_req mdr; 1948 int error; 1949 1950 if (md_debug) 1951 printf("mdctlioctl(%s %lx %p %x %p)\n", 1952 devtoname(dev), cmd, addr, flags, td); 1953 1954 bzero(&mdr, sizeof(mdr)); 1955 switch (cmd) { 1956 case MDIOCATTACH: 1957 case MDIOCDETACH: 1958 case MDIOCRESIZE: 1959 case MDIOCQUERY: { 1960 struct md_ioctl *mdio = (struct md_ioctl *)addr; 1961 if (mdio->md_version != MDIOVERSION) 1962 return (EINVAL); 1963 MD_IOCTL2REQ(mdio, &mdr); 1964 mdr.md_file = mdio->md_file; 1965 mdr.md_file_seg = UIO_USERSPACE; 1966 /* If the file is adjacent to the md_ioctl it's in kernel. */ 1967 if ((void *)mdio->md_file == (void *)(mdio + 1)) 1968 mdr.md_file_seg = UIO_SYSSPACE; 1969 mdr.md_label = mdio->md_label; 1970 break; 1971 } 1972 #ifdef COMPAT_FREEBSD32 1973 case MDIOCATTACH_32: 1974 case MDIOCDETACH_32: 1975 case MDIOCRESIZE_32: 1976 case MDIOCQUERY_32: { 1977 struct md_ioctl32 *mdio = (struct md_ioctl32 *)addr; 1978 if (mdio->md_version != MDIOVERSION) 1979 return (EINVAL); 1980 MD_IOCTL2REQ(mdio, &mdr); 1981 mdr.md_file = (void *)(uintptr_t)mdio->md_file; 1982 mdr.md_file_seg = UIO_USERSPACE; 1983 mdr.md_label = (void *)(uintptr_t)mdio->md_label; 1984 break; 1985 } 1986 #endif 1987 default: 1988 /* Fall through to handler switch. */ 1989 break; 1990 } 1991 1992 error = 0; 1993 switch (cmd) { 1994 case MDIOCATTACH: 1995 #ifdef COMPAT_FREEBSD32 1996 case MDIOCATTACH_32: 1997 #endif 1998 error = kern_mdattach(td, &mdr); 1999 break; 2000 case MDIOCDETACH: 2001 #ifdef COMPAT_FREEBSD32 2002 case MDIOCDETACH_32: 2003 #endif 2004 error = kern_mddetach(td, &mdr); 2005 break; 2006 case MDIOCRESIZE: 2007 #ifdef COMPAT_FREEBSD32 2008 case MDIOCRESIZE_32: 2009 #endif 2010 error = kern_mdresize(&mdr); 2011 break; 2012 case MDIOCQUERY: 2013 #ifdef COMPAT_FREEBSD32 2014 case MDIOCQUERY_32: 2015 #endif 2016 error = kern_mdquery(&mdr); 2017 break; 2018 default: 2019 error = ENOIOCTL; 2020 } 2021 2022 switch (cmd) { 2023 case MDIOCATTACH: 2024 case MDIOCQUERY: { 2025 struct md_ioctl *mdio = (struct md_ioctl *)addr; 2026 MD_REQ2IOCTL(&mdr, mdio); 2027 break; 2028 } 2029 #ifdef COMPAT_FREEBSD32 2030 case MDIOCATTACH_32: 2031 case MDIOCQUERY_32: { 2032 struct md_ioctl32 *mdio = (struct md_ioctl32 *)addr; 2033 MD_REQ2IOCTL(&mdr, mdio); 2034 break; 2035 } 2036 #endif 2037 default: 2038 /* Other commands to not alter mdr. */ 2039 break; 2040 } 2041 2042 return (error); 2043 } 2044 2045 static void 2046 md_preloaded(u_char *image, size_t length, const char *name) 2047 { 2048 struct md_s *sc; 2049 int error; 2050 2051 sc = mdnew(-1, &error, MD_PRELOAD); 2052 if (sc == NULL) 2053 return; 2054 sc->mediasize = length; 2055 sc->sectorsize = DEV_BSIZE; 2056 sc->s_preload.pl_ptr = image; 2057 sc->s_preload.pl_len = length; 2058 sc->start = mdstart_preload; 2059 if (name != NULL) 2060 strlcpy(sc->s_preload.name, name, 2061 sizeof(sc->s_preload.name)); 2062 #ifdef MD_ROOT 2063 if (sc->unit == 0) { 2064 #ifndef ROOTDEVNAME 2065 rootdevnames[0] = MD_ROOT_FSTYPE ":/dev/md0"; 2066 #endif 2067 #ifdef MD_ROOT_READONLY 2068 sc->flags |= MD_READONLY; 2069 #endif 2070 } 2071 #endif 2072 mdinit(sc); 2073 if (name != NULL) { 2074 printf("%s%d: Preloaded image <%s> %zd bytes at %p\n", 2075 MD_NAME, sc->unit, name, length, image); 2076 } else { 2077 printf("%s%d: Embedded image %zd bytes at %p\n", 2078 MD_NAME, sc->unit, length, image); 2079 } 2080 } 2081 2082 static void 2083 g_md_init(struct g_class *mp __unused) 2084 { 2085 caddr_t mod; 2086 u_char *ptr, *name, *type; 2087 u_char scratch[40]; 2088 unsigned len; 2089 int i; 2090 vm_offset_t paddr; 2091 2092 /* figure out log2(NINDIR) */ 2093 for (i = NINDIR, nshift = -1; i; nshift++) 2094 i >>= 1; 2095 2096 mod = NULL; 2097 sx_init(&md_sx, "MD config lock"); 2098 g_topology_unlock(); 2099 md_uh = new_unrhdr(0, INT_MAX, NULL); 2100 #ifdef MD_ROOT 2101 if (mfs_root_size != 0) { 2102 sx_xlock(&md_sx); 2103 #ifdef MD_ROOT_MEM 2104 md_preloaded(mfs_root, mfs_root_size, NULL); 2105 #else 2106 md_preloaded(__DEVOLATILE(u_char *, &mfs_root), mfs_root_size, 2107 NULL); 2108 #endif 2109 sx_xunlock(&md_sx); 2110 } 2111 #endif 2112 /* XXX: are preload_* static or do they need Giant ? */ 2113 while ((mod = preload_search_next_name(mod)) != NULL) { 2114 name = (char *)preload_search_info(mod, MODINFO_NAME); 2115 if (name == NULL) 2116 continue; 2117 type = (char *)preload_search_info(mod, MODINFO_TYPE); 2118 if (type == NULL) 2119 continue; 2120 if (strcmp(type, "md_image") && strcmp(type, "mfs_root")) 2121 continue; 2122 ptr = preload_fetch_addr(mod); 2123 len = preload_fetch_size(mod); 2124 if (ptr != NULL && len != 0) { 2125 sx_xlock(&md_sx); 2126 md_preloaded(ptr, len, name); 2127 sx_xunlock(&md_sx); 2128 } 2129 } 2130 2131 /* 2132 * Load up to 32 pre-loaded disks 2133 */ 2134 for (int i = 0; i < 32; i++) { 2135 if (resource_long_value("md", i, "physaddr", 2136 (long *) &paddr) != 0 || 2137 resource_int_value("md", i, "len", &len) != 0) 2138 break; 2139 ptr = (char *)pmap_map(NULL, paddr, paddr + len, VM_PROT_READ); 2140 if (ptr != NULL && len != 0) { 2141 sprintf(scratch, "preload%d 0x%016jx", i, 2142 (uintmax_t)paddr); 2143 sx_xlock(&md_sx); 2144 md_preloaded(ptr, len, scratch); 2145 sx_xunlock(&md_sx); 2146 } 2147 } 2148 2149 status_dev = make_dev(&mdctl_cdevsw, INT_MAX, UID_ROOT, GID_WHEEL, 2150 0600, MDCTL_NAME); 2151 g_topology_lock(); 2152 } 2153 2154 static void 2155 g_md_dumpconf(struct sbuf *sb, const char *indent, struct g_geom *gp, 2156 struct g_consumer *cp __unused, struct g_provider *pp) 2157 { 2158 struct md_s *mp; 2159 char *type; 2160 2161 mp = gp->softc; 2162 if (mp == NULL) 2163 return; 2164 2165 switch (mp->type) { 2166 case MD_MALLOC: 2167 type = "malloc"; 2168 break; 2169 case MD_PRELOAD: 2170 type = "preload"; 2171 break; 2172 case MD_VNODE: 2173 type = "vnode"; 2174 break; 2175 case MD_SWAP: 2176 type = "swap"; 2177 break; 2178 case MD_NULL: 2179 type = "null"; 2180 break; 2181 default: 2182 type = "unknown"; 2183 break; 2184 } 2185 2186 if (pp != NULL) { 2187 if (indent == NULL) { 2188 sbuf_printf(sb, " u %d", mp->unit); 2189 sbuf_printf(sb, " s %ju", (uintmax_t) mp->sectorsize); 2190 sbuf_printf(sb, " f %ju", (uintmax_t) mp->fwheads); 2191 sbuf_printf(sb, " fs %ju", (uintmax_t) mp->fwsectors); 2192 sbuf_printf(sb, " l %ju", (uintmax_t) mp->mediasize); 2193 sbuf_printf(sb, " t %s", type); 2194 if (mp->type == MD_VNODE && 2195 mp->s_vnode.vnode != NULL) 2196 sbuf_printf(sb, " file %s", mp->s_vnode.file); 2197 if (mp->type == MD_PRELOAD && 2198 mp->s_preload.name[0] != '\0') { 2199 sbuf_printf(sb, " file %s", 2200 mp->s_preload.name); 2201 } 2202 sbuf_printf(sb, " label %s", mp->label); 2203 } else { 2204 sbuf_printf(sb, "%s<unit>%d</unit>\n", indent, 2205 mp->unit); 2206 sbuf_printf(sb, "%s<sectorsize>%ju</sectorsize>\n", 2207 indent, (uintmax_t) mp->sectorsize); 2208 sbuf_printf(sb, "%s<fwheads>%ju</fwheads>\n", 2209 indent, (uintmax_t) mp->fwheads); 2210 sbuf_printf(sb, "%s<fwsectors>%ju</fwsectors>\n", 2211 indent, (uintmax_t) mp->fwsectors); 2212 if (mp->ident[0] != '\0') { 2213 sbuf_printf(sb, "%s<ident>", indent); 2214 g_conf_printf_escaped(sb, "%s", mp->ident); 2215 sbuf_printf(sb, "</ident>\n"); 2216 } 2217 sbuf_printf(sb, "%s<length>%ju</length>\n", 2218 indent, (uintmax_t) mp->mediasize); 2219 sbuf_printf(sb, "%s<compression>%s</compression>\n", indent, 2220 (mp->flags & MD_COMPRESS) == 0 ? "off": "on"); 2221 sbuf_printf(sb, "%s<access>%s</access>\n", indent, 2222 (mp->flags & MD_READONLY) == 0 ? "read-write": 2223 "read-only"); 2224 sbuf_printf(sb, "%s<type>%s</type>\n", indent, 2225 type); 2226 if (mp->type == MD_VNODE) { 2227 if (mp->s_vnode.vnode != NULL) { 2228 sbuf_printf(sb, "%s<file>", indent); 2229 g_conf_printf_escaped(sb, "%s", 2230 mp->s_vnode.file); 2231 sbuf_printf(sb, "</file>\n"); 2232 } 2233 sbuf_printf(sb, "%s<cache>%s</cache>\n", indent, 2234 (mp->flags & MD_CACHE) == 0 ? "off": "on"); 2235 } 2236 if (mp->type == MD_PRELOAD && 2237 mp->s_preload.name[0] != '\0') { 2238 sbuf_printf(sb, "%s<file>", indent); 2239 g_conf_printf_escaped(sb, "%s", 2240 mp->s_preload.name); 2241 sbuf_printf(sb, "</file>\n"); 2242 } 2243 sbuf_printf(sb, "%s<label>", indent); 2244 g_conf_printf_escaped(sb, "%s", mp->label); 2245 sbuf_printf(sb, "</label>\n"); 2246 } 2247 } 2248 } 2249 2250 static void 2251 g_md_fini(struct g_class *mp __unused) 2252 { 2253 2254 sx_destroy(&md_sx); 2255 if (status_dev != NULL) 2256 destroy_dev(status_dev); 2257 delete_unrhdr(md_uh); 2258 } 2259