dksubr.c revision 1.75
1 /* $NetBSD: dksubr.c,v 1.75 2015/08/28 05:49:31 mlelstv Exp $ */ 2 3 /*- 4 * Copyright (c) 1996, 1997, 1998, 1999, 2002, 2008 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jason R. Thorpe and Roland C. Dowdeswell. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 __KERNEL_RCSID(0, "$NetBSD: dksubr.c,v 1.75 2015/08/28 05:49:31 mlelstv Exp $"); 34 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/stat.h> 38 #include <sys/proc.h> 39 #include <sys/ioctl.h> 40 #include <sys/device.h> 41 #include <sys/disk.h> 42 #include <sys/disklabel.h> 43 #include <sys/buf.h> 44 #include <sys/bufq.h> 45 #include <sys/vnode.h> 46 #include <sys/fcntl.h> 47 #include <sys/namei.h> 48 #include <sys/module.h> 49 #include <sys/syslog.h> 50 51 #include <dev/dkvar.h> 52 #include <miscfs/specfs/specdev.h> /* for v_rdev */ 53 54 int dkdebug = 0; 55 56 #ifdef DEBUG 57 #define DKDB_FOLLOW 0x1 58 #define DKDB_INIT 0x2 59 #define DKDB_VNODE 0x4 60 61 #define IFDEBUG(x,y) if (dkdebug & (x)) y 62 #define DPRINTF(x,y) IFDEBUG(x, printf y) 63 #define DPRINTF_FOLLOW(y) DPRINTF(DKDB_FOLLOW, y) 64 #else 65 #define IFDEBUG(x,y) 66 #define DPRINTF(x,y) 67 #define DPRINTF_FOLLOW(y) 68 #endif 69 70 static int dk_subr_modcmd(modcmd_t, void *); 71 72 #define DKLABELDEV(dev) \ 73 (MAKEDISKDEV(major((dev)), DISKUNIT((dev)), RAW_PART)) 74 75 static void dk_makedisklabel(struct dk_softc *); 76 static int dk_translate(struct dk_softc *, struct buf *); 77 static void dk_done1(struct dk_softc *, struct buf *, bool); 78 79 void 80 dk_init(struct dk_softc *dksc, device_t dev, int dtype) 81 { 82 83 memset(dksc, 0x0, sizeof(*dksc)); 84 dksc->sc_dtype = dtype; 85 dksc->sc_dev = dev; 86 87 strlcpy(dksc->sc_xname, device_xname(dev), DK_XNAME_SIZE); 88 dksc->sc_dkdev.dk_name = dksc->sc_xname; 89 } 90 91 void 92 dk_attach(struct dk_softc *dksc) 93 { 94 mutex_init(&dksc->sc_iolock, MUTEX_DEFAULT, IPL_VM); 95 dksc->sc_flags |= DKF_INITED; 96 #ifdef DIAGNOSTIC 97 dksc->sc_flags |= DKF_WARNLABEL | DKF_LABELSANITY; 98 #endif 99 } 100 101 void 102 dk_detach(struct dk_softc *dksc) 103 { 104 dksc->sc_flags &= ~DKF_INITED; 105 mutex_destroy(&dksc->sc_iolock); 106 } 107 108 /* ARGSUSED */ 109 int 110 dk_open(struct dk_softc *dksc, dev_t dev, 111 int flags, int fmt, struct lwp *l) 112 { 113 struct disklabel *lp = dksc->sc_dkdev.dk_label; 114 int part = DISKPART(dev); 115 int pmask = 1 << part; 116 int ret = 0; 117 struct disk *dk = &dksc->sc_dkdev; 118 119 DPRINTF_FOLLOW(("dk_open(%s, %p, 0x%"PRIx64", 0x%x)\n", 120 dksc->sc_xname, dksc, dev, flags)); 121 122 mutex_enter(&dk->dk_openlock); 123 124 /* 125 * If there are wedges, and this is not RAW_PART, then we 126 * need to fail. 127 */ 128 if (dk->dk_nwedges != 0 && part != RAW_PART) { 129 ret = EBUSY; 130 goto done; 131 } 132 133 /* 134 * If we're init'ed and there are no other open partitions then 135 * update the in-core disklabel. 136 */ 137 if ((dksc->sc_flags & DKF_INITED)) { 138 if ((dksc->sc_flags & DKF_VLABEL) == 0) { 139 dksc->sc_flags |= DKF_VLABEL; 140 dk_getdisklabel(dksc, dev); 141 } 142 } 143 144 /* Fail if we can't find the partition. */ 145 if (part != RAW_PART && 146 ((dksc->sc_flags & DKF_VLABEL) == 0 || 147 part >= lp->d_npartitions || 148 lp->d_partitions[part].p_fstype == FS_UNUSED)) { 149 ret = ENXIO; 150 goto done; 151 } 152 153 /* Mark our unit as open. */ 154 switch (fmt) { 155 case S_IFCHR: 156 dk->dk_copenmask |= pmask; 157 break; 158 case S_IFBLK: 159 dk->dk_bopenmask |= pmask; 160 break; 161 } 162 163 dk->dk_openmask = dk->dk_copenmask | dk->dk_bopenmask; 164 165 done: 166 mutex_exit(&dk->dk_openlock); 167 return ret; 168 } 169 170 /* ARGSUSED */ 171 int 172 dk_close(struct dk_softc *dksc, dev_t dev, 173 int flags, int fmt, struct lwp *l) 174 { 175 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver; 176 int part = DISKPART(dev); 177 int pmask = 1 << part; 178 struct disk *dk = &dksc->sc_dkdev; 179 180 DPRINTF_FOLLOW(("dk_close(%s, %p, 0x%"PRIx64", 0x%x)\n", 181 dksc->sc_xname, dksc, dev, flags)); 182 183 mutex_enter(&dk->dk_openlock); 184 185 switch (fmt) { 186 case S_IFCHR: 187 dk->dk_copenmask &= ~pmask; 188 break; 189 case S_IFBLK: 190 dk->dk_bopenmask &= ~pmask; 191 break; 192 } 193 dk->dk_openmask = dk->dk_copenmask | dk->dk_bopenmask; 194 195 if (dk->dk_openmask == 0) { 196 if (dkd->d_lastclose != NULL) 197 (*dkd->d_lastclose)(dksc->sc_dev); 198 if ((dksc->sc_flags & DKF_KLABEL) == 0) 199 dksc->sc_flags &= ~DKF_VLABEL; 200 } 201 202 mutex_exit(&dk->dk_openlock); 203 return 0; 204 } 205 206 static int 207 dk_translate(struct dk_softc *dksc, struct buf *bp) 208 { 209 int part; 210 int wlabel; 211 daddr_t blkno; 212 struct disklabel *lp; 213 struct disk *dk; 214 uint64_t numsecs; 215 unsigned secsize; 216 217 lp = dksc->sc_dkdev.dk_label; 218 dk = &dksc->sc_dkdev; 219 220 part = DISKPART(bp->b_dev); 221 numsecs = dk->dk_geom.dg_secperunit; 222 secsize = dk->dk_geom.dg_secsize; 223 224 /* 225 * The transfer must be a whole number of blocks and the offset must 226 * not be negative. 227 */ 228 if ((bp->b_bcount % secsize) != 0 || bp->b_blkno < 0) { 229 bp->b_error = EINVAL; 230 goto done; 231 } 232 233 /* If there is nothing to do, then we are done */ 234 if (bp->b_bcount == 0) 235 goto done; 236 237 wlabel = dksc->sc_flags & (DKF_WLABEL|DKF_LABELLING); 238 if (part == RAW_PART) { 239 if (bounds_check_with_mediasize(bp, DEV_BSIZE, numsecs) <= 0) 240 goto done; 241 } else { 242 if (bounds_check_with_label(&dksc->sc_dkdev, bp, wlabel) <= 0) 243 goto done; 244 } 245 246 /* 247 * Convert the block number to absolute and put it in terms 248 * of the device's logical block size. 249 */ 250 if (secsize >= DEV_BSIZE) 251 blkno = bp->b_blkno / (secsize / DEV_BSIZE); 252 else 253 blkno = bp->b_blkno * (DEV_BSIZE / secsize); 254 255 if (part != RAW_PART) 256 blkno += lp->d_partitions[DISKPART(bp->b_dev)].p_offset; 257 bp->b_rawblkno = blkno; 258 259 return -1; 260 261 done: 262 bp->b_resid = bp->b_bcount; 263 return bp->b_error; 264 } 265 266 void 267 dk_strategy(struct dk_softc *dksc, struct buf *bp) 268 { 269 int error; 270 271 DPRINTF_FOLLOW(("dk_strategy(%s, %p, %p)\n", 272 dksc->sc_xname, dksc, bp)); 273 274 if (!(dksc->sc_flags & DKF_INITED)) { 275 DPRINTF_FOLLOW(("dk_strategy: not inited\n")); 276 bp->b_error = ENXIO; 277 biodone(bp); 278 return; 279 } 280 281 error = dk_translate(dksc, bp); 282 if (error >= 0) { 283 biodone(bp); 284 return; 285 } 286 287 /* 288 * Queue buffer and start unit 289 */ 290 dk_start(dksc, bp); 291 } 292 293 void 294 dk_start(struct dk_softc *dksc, struct buf *bp) 295 { 296 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver; 297 int error; 298 299 mutex_enter(&dksc->sc_iolock); 300 301 if (bp != NULL) 302 bufq_put(dksc->sc_bufq, bp); 303 304 if (dksc->sc_busy) 305 goto done; 306 dksc->sc_busy = true; 307 308 /* 309 * Peeking at the buffer queue and committing the operation 310 * only after success isn't atomic. 311 * 312 * So when a diskstart fails, the buffer is saved 313 * and tried again before the next buffer is fetched. 314 * dk_drain() handles flushing of a saved buffer. 315 * 316 * This keeps order of I/O operations, unlike bufq_put. 317 */ 318 319 bp = dksc->sc_deferred; 320 dksc->sc_deferred = NULL; 321 322 if (bp == NULL) 323 bp = bufq_get(dksc->sc_bufq); 324 325 while (bp != NULL) { 326 327 disk_busy(&dksc->sc_dkdev); 328 mutex_exit(&dksc->sc_iolock); 329 error = dkd->d_diskstart(dksc->sc_dev, bp); 330 mutex_enter(&dksc->sc_iolock); 331 if (error == EAGAIN) { 332 dksc->sc_deferred = bp; 333 disk_unbusy(&dksc->sc_dkdev, 0, (bp->b_flags & B_READ)); 334 break; 335 } 336 337 if (error != 0) { 338 bp->b_error = error; 339 bp->b_resid = bp->b_bcount; 340 dk_done1(dksc, bp, false); 341 } 342 343 bp = bufq_get(dksc->sc_bufq); 344 } 345 346 dksc->sc_busy = false; 347 done: 348 mutex_exit(&dksc->sc_iolock); 349 } 350 351 static void 352 dk_done1(struct dk_softc *dksc, struct buf *bp, bool lock) 353 { 354 struct disk *dk = &dksc->sc_dkdev; 355 356 if (bp->b_error != 0) { 357 struct cfdriver *cd = device_cfdriver(dksc->sc_dev); 358 359 diskerr(bp, cd->cd_name, "error", LOG_PRINTF, 0, 360 dk->dk_label); 361 printf("\n"); 362 } 363 364 if (lock) 365 mutex_enter(&dksc->sc_iolock); 366 disk_unbusy(dk, bp->b_bcount - bp->b_resid, (bp->b_flags & B_READ)); 367 if (lock) 368 mutex_exit(&dksc->sc_iolock); 369 370 #ifdef notyet 371 rnd_add_uint(&dksc->sc_rnd_source, bp->b_rawblkno); 372 #endif 373 374 biodone(bp); 375 } 376 377 void 378 dk_done(struct dk_softc *dksc, struct buf *bp) 379 { 380 dk_done1(dksc, bp, true); 381 } 382 383 void 384 dk_drain(struct dk_softc *dksc) 385 { 386 struct buf *bp; 387 388 mutex_enter(&dksc->sc_iolock); 389 bp = dksc->sc_deferred; 390 if (bp != NULL) { 391 bp->b_error = EIO; 392 bp->b_resid = bp->b_bcount; 393 biodone(bp); 394 } 395 bufq_drain(dksc->sc_bufq); 396 mutex_exit(&dksc->sc_iolock); 397 } 398 399 int 400 dk_discard(struct dk_softc *dksc, dev_t dev, off_t pos, off_t len) 401 { 402 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver; 403 unsigned secsize = dksc->sc_dkdev.dk_geom.dg_secsize; 404 struct buf tmp, *bp = &tmp; 405 int error; 406 407 DPRINTF_FOLLOW(("dk_discard(%s, %p, 0x"PRIx64", %jd, %jd)\n", 408 dksc->sc_xname, dksc, (intmax_t)pos, (intmax_t)len)); 409 410 if (!(dksc->sc_flags & DKF_INITED)) { 411 DPRINTF_FOLLOW(("dk_discard: not inited\n")); 412 return ENXIO; 413 } 414 415 if (secsize == 0 || (pos % secsize) != 0) 416 return EINVAL; 417 418 /* enough data to please the bounds checking code */ 419 bp->b_dev = dev; 420 bp->b_blkno = (daddr_t)(pos / secsize); 421 bp->b_bcount = len; 422 bp->b_flags = B_WRITE; 423 424 error = dk_translate(dksc, bp); 425 if (error >= 0) 426 return error; 427 428 error = dkd->d_discard(dksc->sc_dev, 429 (off_t)bp->b_rawblkno * secsize, 430 (off_t)bp->b_bcount); 431 432 return error; 433 } 434 435 int 436 dk_size(struct dk_softc *dksc, dev_t dev) 437 { 438 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver; 439 struct disklabel *lp; 440 int is_open; 441 int part; 442 int size; 443 444 if ((dksc->sc_flags & DKF_INITED) == 0) 445 return -1; 446 447 part = DISKPART(dev); 448 is_open = dksc->sc_dkdev.dk_openmask & (1 << part); 449 450 if (!is_open && dkd->d_open(dev, 0, S_IFBLK, curlwp)) 451 return -1; 452 453 lp = dksc->sc_dkdev.dk_label; 454 if (lp->d_partitions[part].p_fstype != FS_SWAP) 455 size = -1; 456 else 457 size = lp->d_partitions[part].p_size * 458 (lp->d_secsize / DEV_BSIZE); 459 460 if (!is_open && dkd->d_close(dev, 0, S_IFBLK, curlwp)) 461 return -1; 462 463 return size; 464 } 465 466 int 467 dk_ioctl(struct dk_softc *dksc, dev_t dev, 468 u_long cmd, void *data, int flag, struct lwp *l) 469 { 470 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver; 471 struct disklabel *lp; 472 struct disk *dk = &dksc->sc_dkdev; 473 #ifdef __HAVE_OLD_DISKLABEL 474 struct disklabel newlabel; 475 #endif 476 int error; 477 478 DPRINTF_FOLLOW(("dk_ioctl(%s, %p, 0x%"PRIx64", 0x%lx)\n", 479 dksc->sc_xname, dksc, dev, cmd)); 480 481 /* ensure that the pseudo disk is open for writes for these commands */ 482 switch (cmd) { 483 case DIOCSDINFO: 484 case DIOCWDINFO: 485 #ifdef __HAVE_OLD_DISKLABEL 486 case ODIOCSDINFO: 487 case ODIOCWDINFO: 488 #endif 489 case DIOCKLABEL: 490 case DIOCWLABEL: 491 case DIOCAWEDGE: 492 case DIOCDWEDGE: 493 case DIOCSSTRATEGY: 494 if ((flag & FWRITE) == 0) 495 return EBADF; 496 } 497 498 /* ensure that the pseudo-disk is initialized for these */ 499 switch (cmd) { 500 case DIOCGDINFO: 501 case DIOCSDINFO: 502 case DIOCWDINFO: 503 case DIOCGPART: 504 case DIOCKLABEL: 505 case DIOCWLABEL: 506 case DIOCGDEFLABEL: 507 case DIOCAWEDGE: 508 case DIOCDWEDGE: 509 case DIOCLWEDGES: 510 case DIOCMWEDGES: 511 case DIOCCACHESYNC: 512 #ifdef __HAVE_OLD_DISKLABEL 513 case ODIOCGDINFO: 514 case ODIOCSDINFO: 515 case ODIOCWDINFO: 516 case ODIOCGDEFLABEL: 517 #endif 518 if ((dksc->sc_flags & DKF_INITED) == 0) 519 return ENXIO; 520 } 521 522 error = disk_ioctl(dk, dev, cmd, data, flag, l); 523 if (error != EPASSTHROUGH) 524 return error; 525 else 526 error = 0; 527 528 switch (cmd) { 529 case DIOCWDINFO: 530 case DIOCSDINFO: 531 #ifdef __HAVE_OLD_DISKLABEL 532 case ODIOCWDINFO: 533 case ODIOCSDINFO: 534 #endif 535 #ifdef __HAVE_OLD_DISKLABEL 536 if (cmd == ODIOCSDINFO || cmd == ODIOCWDINFO) { 537 memset(&newlabel, 0, sizeof newlabel); 538 memcpy(&newlabel, data, sizeof (struct olddisklabel)); 539 lp = &newlabel; 540 } else 541 #endif 542 lp = (struct disklabel *)data; 543 544 mutex_enter(&dk->dk_openlock); 545 dksc->sc_flags |= DKF_LABELLING; 546 547 error = setdisklabel(dksc->sc_dkdev.dk_label, 548 lp, 0, dksc->sc_dkdev.dk_cpulabel); 549 if (error == 0) { 550 if (cmd == DIOCWDINFO 551 #ifdef __HAVE_OLD_DISKLABEL 552 || cmd == ODIOCWDINFO 553 #endif 554 ) 555 error = writedisklabel(DKLABELDEV(dev), 556 dkd->d_strategy, dksc->sc_dkdev.dk_label, 557 dksc->sc_dkdev.dk_cpulabel); 558 } 559 560 dksc->sc_flags &= ~DKF_LABELLING; 561 mutex_exit(&dk->dk_openlock); 562 break; 563 564 case DIOCKLABEL: 565 if (*(int *)data != 0) 566 dksc->sc_flags |= DKF_KLABEL; 567 else 568 dksc->sc_flags &= ~DKF_KLABEL; 569 break; 570 571 case DIOCWLABEL: 572 if (*(int *)data != 0) 573 dksc->sc_flags |= DKF_WLABEL; 574 else 575 dksc->sc_flags &= ~DKF_WLABEL; 576 break; 577 578 case DIOCGDEFLABEL: 579 dk_getdefaultlabel(dksc, (struct disklabel *)data); 580 break; 581 582 #ifdef __HAVE_OLD_DISKLABEL 583 case ODIOCGDEFLABEL: 584 dk_getdefaultlabel(dksc, &newlabel); 585 if (newlabel.d_npartitions > OLDMAXPARTITIONS) 586 return ENOTTY; 587 memcpy(data, &newlabel, sizeof (struct olddisklabel)); 588 break; 589 #endif 590 591 case DIOCGSTRATEGY: 592 { 593 struct disk_strategy *dks = (void *)data; 594 595 mutex_enter(&dksc->sc_iolock); 596 strlcpy(dks->dks_name, bufq_getstrategyname(dksc->sc_bufq), 597 sizeof(dks->dks_name)); 598 mutex_exit(&dksc->sc_iolock); 599 dks->dks_paramlen = 0; 600 601 return 0; 602 } 603 604 case DIOCSSTRATEGY: 605 { 606 struct disk_strategy *dks = (void *)data; 607 struct bufq_state *new; 608 struct bufq_state *old; 609 610 if (dks->dks_param != NULL) { 611 return EINVAL; 612 } 613 dks->dks_name[sizeof(dks->dks_name) - 1] = 0; /* ensure term */ 614 error = bufq_alloc(&new, dks->dks_name, 615 BUFQ_EXACT|BUFQ_SORT_RAWBLOCK); 616 if (error) { 617 return error; 618 } 619 mutex_enter(&dksc->sc_iolock); 620 old = dksc->sc_bufq; 621 bufq_move(new, old); 622 dksc->sc_bufq = new; 623 mutex_exit(&dksc->sc_iolock); 624 bufq_free(old); 625 626 return 0; 627 } 628 629 default: 630 error = ENOTTY; 631 } 632 633 return error; 634 } 635 636 /* 637 * dk_dump dumps all of physical memory into the partition specified. 638 * This requires substantially more framework than {s,w}ddump, and hence 639 * is probably much more fragile. 640 * 641 */ 642 643 #define DKF_READYFORDUMP (DKF_INITED|DKF_TAKEDUMP) 644 #define DKFF_READYFORDUMP(x) (((x) & DKF_READYFORDUMP) == DKF_READYFORDUMP) 645 static volatile int dk_dumping = 0; 646 647 /* ARGSUSED */ 648 int 649 dk_dump(struct dk_softc *dksc, dev_t dev, 650 daddr_t blkno, void *vav, size_t size) 651 { 652 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver; 653 char *va = vav; 654 struct disklabel *lp; 655 int part, towrt, nsects, sectoff, maxblkcnt, nblk; 656 int maxxfer, rv = 0; 657 658 /* 659 * ensure that we consider this device to be safe for dumping, 660 * and that the device is configured. 661 */ 662 if (!DKFF_READYFORDUMP(dksc->sc_flags)) 663 return ENXIO; 664 665 /* ensure that we are not already dumping */ 666 if (dk_dumping) 667 return EFAULT; 668 dk_dumping = 1; 669 670 if (dkd->d_dumpblocks == NULL) 671 return ENXIO; 672 673 /* device specific max transfer size */ 674 maxxfer = MAXPHYS; 675 if (dkd->d_iosize != NULL) 676 (*dkd->d_iosize)(dksc->sc_dev, &maxxfer); 677 678 /* Convert to disk sectors. Request must be a multiple of size. */ 679 part = DISKPART(dev); 680 lp = dksc->sc_dkdev.dk_label; 681 if ((size % lp->d_secsize) != 0) 682 return (EFAULT); 683 towrt = size / lp->d_secsize; 684 blkno = dbtob(blkno) / lp->d_secsize; /* blkno in secsize units */ 685 686 nsects = lp->d_partitions[part].p_size; 687 sectoff = lp->d_partitions[part].p_offset; 688 689 /* Check transfer bounds against partition size. */ 690 if ((blkno < 0) || ((blkno + towrt) > nsects)) 691 return (EINVAL); 692 693 /* Offset block number to start of partition. */ 694 blkno += sectoff; 695 696 /* Start dumping and return when done. */ 697 maxblkcnt = howmany(maxxfer, lp->d_secsize); 698 while (towrt > 0) { 699 nblk = min(maxblkcnt, towrt); 700 701 if ((rv = (*dkd->d_dumpblocks)(dksc->sc_dev, va, blkno, nblk)) != 0) 702 return (rv); 703 704 towrt -= nblk; 705 blkno += nblk; 706 va += nblk * lp->d_secsize; 707 } 708 709 dk_dumping = 0; 710 711 return 0; 712 } 713 714 /* ARGSUSED */ 715 void 716 dk_getdefaultlabel(struct dk_softc *dksc, struct disklabel *lp) 717 { 718 struct disk_geom *dg = &dksc->sc_dkdev.dk_geom; 719 720 memset(lp, 0, sizeof(*lp)); 721 722 if (dg->dg_secperunit > UINT32_MAX) 723 lp->d_secperunit = UINT32_MAX; 724 else 725 lp->d_secperunit = dg->dg_secperunit; 726 lp->d_secsize = dg->dg_secsize; 727 lp->d_nsectors = dg->dg_nsectors; 728 lp->d_ntracks = dg->dg_ntracks; 729 lp->d_ncylinders = dg->dg_ncylinders; 730 lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors; 731 732 strlcpy(lp->d_typename, dksc->sc_xname, sizeof(lp->d_typename)); 733 lp->d_type = dksc->sc_dtype; 734 strlcpy(lp->d_packname, "fictitious", sizeof(lp->d_packname)); 735 lp->d_rpm = 3600; 736 lp->d_interleave = 1; 737 lp->d_flags = 0; 738 739 lp->d_partitions[RAW_PART].p_offset = 0; 740 lp->d_partitions[RAW_PART].p_size = lp->d_secperunit; 741 lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED; 742 lp->d_npartitions = RAW_PART + 1; 743 744 lp->d_magic = DISKMAGIC; 745 lp->d_magic2 = DISKMAGIC; 746 lp->d_checksum = dkcksum(dksc->sc_dkdev.dk_label); 747 } 748 749 /* ARGSUSED */ 750 void 751 dk_getdisklabel(struct dk_softc *dksc, dev_t dev) 752 { 753 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver; 754 struct disklabel *lp = dksc->sc_dkdev.dk_label; 755 struct cpu_disklabel *clp = dksc->sc_dkdev.dk_cpulabel; 756 struct disk_geom *dg = &dksc->sc_dkdev.dk_geom; 757 struct partition *pp; 758 int i; 759 const char *errstring; 760 761 memset(clp, 0x0, sizeof(*clp)); 762 dk_getdefaultlabel(dksc, lp); 763 errstring = readdisklabel(DKLABELDEV(dev), dkd->d_strategy, 764 dksc->sc_dkdev.dk_label, dksc->sc_dkdev.dk_cpulabel); 765 if (errstring) { 766 dk_makedisklabel(dksc); 767 if (dksc->sc_flags & DKF_WARNLABEL) 768 printf("%s: %s\n", dksc->sc_xname, errstring); 769 return; 770 } 771 772 if ((dksc->sc_flags & DKF_LABELSANITY) == 0) 773 return; 774 775 /* Sanity check */ 776 if (lp->d_secperunit < UINT32_MAX ? 777 lp->d_secperunit != dg->dg_secperunit : 778 lp->d_secperunit > dg->dg_secperunit) 779 printf("WARNING: %s: total sector size in disklabel (%ju) " 780 "!= the size of %s (%ju)\n", dksc->sc_xname, 781 (uintmax_t)lp->d_secperunit, dksc->sc_xname, 782 (uintmax_t)dg->dg_secperunit); 783 784 for (i=0; i < lp->d_npartitions; i++) { 785 pp = &lp->d_partitions[i]; 786 if (pp->p_offset + pp->p_size > dg->dg_secperunit) 787 printf("WARNING: %s: end of partition `%c' exceeds " 788 "the size of %s (%ju)\n", dksc->sc_xname, 789 'a' + i, dksc->sc_xname, 790 (uintmax_t)dg->dg_secperunit); 791 } 792 } 793 794 /* ARGSUSED */ 795 static void 796 dk_makedisklabel(struct dk_softc *dksc) 797 { 798 struct disklabel *lp = dksc->sc_dkdev.dk_label; 799 800 lp->d_partitions[RAW_PART].p_fstype = FS_BSDFFS; 801 strlcpy(lp->d_packname, "default label", sizeof(lp->d_packname)); 802 lp->d_checksum = dkcksum(lp); 803 } 804 805 /* This function is taken from ccd.c:1.76 --rcd */ 806 807 /* 808 * XXX this function looks too generic for dksubr.c, shouldn't we 809 * put it somewhere better? 810 */ 811 812 /* 813 * Lookup the provided name in the filesystem. If the file exists, 814 * is a valid block device, and isn't being used by anyone else, 815 * set *vpp to the file's vnode. 816 */ 817 int 818 dk_lookup(struct pathbuf *pb, struct lwp *l, struct vnode **vpp) 819 { 820 struct nameidata nd; 821 struct vnode *vp; 822 int error; 823 824 if (l == NULL) 825 return ESRCH; /* Is ESRCH the best choice? */ 826 827 NDINIT(&nd, LOOKUP, FOLLOW, pb); 828 if ((error = vn_open(&nd, FREAD | FWRITE, 0)) != 0) { 829 DPRINTF((DKDB_FOLLOW|DKDB_INIT), 830 ("dk_lookup: vn_open error = %d\n", error)); 831 return error; 832 } 833 834 vp = nd.ni_vp; 835 if (vp->v_type != VBLK) { 836 error = ENOTBLK; 837 goto out; 838 } 839 840 /* Reopen as anonymous vnode to protect against forced unmount. */ 841 if ((error = bdevvp(vp->v_rdev, vpp)) != 0) 842 goto out; 843 VOP_UNLOCK(vp); 844 if ((error = vn_close(vp, FREAD | FWRITE, l->l_cred)) != 0) { 845 vrele(*vpp); 846 return error; 847 } 848 if ((error = VOP_OPEN(*vpp, FREAD | FWRITE, l->l_cred)) != 0) { 849 vrele(*vpp); 850 return error; 851 } 852 mutex_enter((*vpp)->v_interlock); 853 (*vpp)->v_writecount++; 854 mutex_exit((*vpp)->v_interlock); 855 856 IFDEBUG(DKDB_VNODE, vprint("dk_lookup: vnode info", *vpp)); 857 858 return 0; 859 out: 860 VOP_UNLOCK(vp); 861 (void) vn_close(vp, FREAD | FWRITE, l->l_cred); 862 return error; 863 } 864 865 MODULE(MODULE_CLASS_MISC, dk_subr, NULL); 866 867 static int 868 dk_subr_modcmd(modcmd_t cmd, void *arg) 869 { 870 switch (cmd) { 871 case MODULE_CMD_INIT: 872 case MODULE_CMD_FINI: 873 return 0; 874 case MODULE_CMD_STAT: 875 case MODULE_CMD_AUTOUNLOAD: 876 default: 877 return ENOTTY; 878 } 879 } 880
Indexes created Sat Oct 18 08:10:09 GMT 2025