dksubr.c revision 1.74
1 /* $NetBSD: dksubr.c,v 1.74 2015/08/27 05:51:50 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.74 2015/08/27 05:51:50 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 /* 305 * Peeking at the buffer queue and committing the operation 306 * only after success isn't atomic. 307 * 308 * So when a diskstart fails, the buffer is saved 309 * and tried again before the next buffer is fetched. 310 * dk_drain() handles flushing of a saved buffer. 311 * 312 * This keeps order of I/O operations, unlike bufq_put. 313 */ 314 315 bp = dksc->sc_deferred; 316 dksc->sc_deferred = NULL; 317 318 if (bp == NULL) 319 bp = bufq_get(dksc->sc_bufq); 320 321 while (bp != NULL) { 322 323 disk_busy(&dksc->sc_dkdev); 324 mutex_exit(&dksc->sc_iolock); 325 error = dkd->d_diskstart(dksc->sc_dev, bp); 326 mutex_enter(&dksc->sc_iolock); 327 if (error == EAGAIN) { 328 dksc->sc_deferred = bp; 329 disk_unbusy(&dksc->sc_dkdev, 0, (bp->b_flags & B_READ)); 330 break; 331 } 332 333 if (error != 0) { 334 bp->b_error = error; 335 bp->b_resid = bp->b_bcount; 336 dk_done1(dksc, bp, false); 337 } 338 339 bp = bufq_get(dksc->sc_bufq); 340 } 341 342 mutex_exit(&dksc->sc_iolock); 343 } 344 345 static void 346 dk_done1(struct dk_softc *dksc, struct buf *bp, bool lock) 347 { 348 struct disk *dk = &dksc->sc_dkdev; 349 350 if (bp->b_error != 0) { 351 struct cfdriver *cd = device_cfdriver(dksc->sc_dev); 352 353 diskerr(bp, cd->cd_name, "error", LOG_PRINTF, 0, 354 dk->dk_label); 355 printf("\n"); 356 } 357 358 if (lock) 359 mutex_enter(&dksc->sc_iolock); 360 disk_unbusy(dk, bp->b_bcount - bp->b_resid, (bp->b_flags & B_READ)); 361 if (lock) 362 mutex_exit(&dksc->sc_iolock); 363 364 #ifdef notyet 365 rnd_add_uint(&dksc->sc_rnd_source, bp->b_rawblkno); 366 #endif 367 368 biodone(bp); 369 } 370 371 void 372 dk_done(struct dk_softc *dksc, struct buf *bp) 373 { 374 dk_done1(dksc, bp, true); 375 } 376 377 void 378 dk_drain(struct dk_softc *dksc) 379 { 380 struct buf *bp; 381 382 mutex_enter(&dksc->sc_iolock); 383 bp = dksc->sc_deferred; 384 if (bp != NULL) { 385 bp->b_error = EIO; 386 bp->b_resid = bp->b_bcount; 387 biodone(bp); 388 } 389 bufq_drain(dksc->sc_bufq); 390 mutex_exit(&dksc->sc_iolock); 391 } 392 393 int 394 dk_discard(struct dk_softc *dksc, dev_t dev, off_t pos, off_t len) 395 { 396 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver; 397 unsigned secsize = dksc->sc_dkdev.dk_geom.dg_secsize; 398 struct buf tmp, *bp = &tmp; 399 int error; 400 401 DPRINTF_FOLLOW(("dk_discard(%s, %p, 0x"PRIx64", %jd, %jd)\n", 402 dksc->sc_xname, dksc, (intmax_t)pos, (intmax_t)len)); 403 404 if (!(dksc->sc_flags & DKF_INITED)) { 405 DPRINTF_FOLLOW(("dk_discard: not inited\n")); 406 return ENXIO; 407 } 408 409 if (secsize == 0 || (pos % secsize) != 0) 410 return EINVAL; 411 412 /* enough data to please the bounds checking code */ 413 bp->b_dev = dev; 414 bp->b_blkno = (daddr_t)(pos / secsize); 415 bp->b_bcount = len; 416 bp->b_flags = B_WRITE; 417 418 error = dk_translate(dksc, bp); 419 if (error >= 0) 420 return error; 421 422 error = dkd->d_discard(dksc->sc_dev, 423 (off_t)bp->b_rawblkno * secsize, 424 (off_t)bp->b_bcount); 425 426 return error; 427 } 428 429 int 430 dk_size(struct dk_softc *dksc, dev_t dev) 431 { 432 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver; 433 struct disklabel *lp; 434 int is_open; 435 int part; 436 int size; 437 438 if ((dksc->sc_flags & DKF_INITED) == 0) 439 return -1; 440 441 part = DISKPART(dev); 442 is_open = dksc->sc_dkdev.dk_openmask & (1 << part); 443 444 if (!is_open && dkd->d_open(dev, 0, S_IFBLK, curlwp)) 445 return -1; 446 447 lp = dksc->sc_dkdev.dk_label; 448 if (lp->d_partitions[part].p_fstype != FS_SWAP) 449 size = -1; 450 else 451 size = lp->d_partitions[part].p_size * 452 (lp->d_secsize / DEV_BSIZE); 453 454 if (!is_open && dkd->d_close(dev, 0, S_IFBLK, curlwp)) 455 return -1; 456 457 return size; 458 } 459 460 int 461 dk_ioctl(struct dk_softc *dksc, dev_t dev, 462 u_long cmd, void *data, int flag, struct lwp *l) 463 { 464 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver; 465 struct disklabel *lp; 466 struct disk *dk = &dksc->sc_dkdev; 467 #ifdef __HAVE_OLD_DISKLABEL 468 struct disklabel newlabel; 469 #endif 470 int error; 471 472 DPRINTF_FOLLOW(("dk_ioctl(%s, %p, 0x%"PRIx64", 0x%lx)\n", 473 dksc->sc_xname, dksc, dev, cmd)); 474 475 /* ensure that the pseudo disk is open for writes for these commands */ 476 switch (cmd) { 477 case DIOCSDINFO: 478 case DIOCWDINFO: 479 #ifdef __HAVE_OLD_DISKLABEL 480 case ODIOCSDINFO: 481 case ODIOCWDINFO: 482 #endif 483 case DIOCKLABEL: 484 case DIOCWLABEL: 485 case DIOCAWEDGE: 486 case DIOCDWEDGE: 487 case DIOCSSTRATEGY: 488 if ((flag & FWRITE) == 0) 489 return EBADF; 490 } 491 492 /* ensure that the pseudo-disk is initialized for these */ 493 switch (cmd) { 494 case DIOCGDINFO: 495 case DIOCSDINFO: 496 case DIOCWDINFO: 497 case DIOCGPART: 498 case DIOCKLABEL: 499 case DIOCWLABEL: 500 case DIOCGDEFLABEL: 501 case DIOCAWEDGE: 502 case DIOCDWEDGE: 503 case DIOCLWEDGES: 504 case DIOCMWEDGES: 505 case DIOCCACHESYNC: 506 #ifdef __HAVE_OLD_DISKLABEL 507 case ODIOCGDINFO: 508 case ODIOCSDINFO: 509 case ODIOCWDINFO: 510 case ODIOCGDEFLABEL: 511 #endif 512 if ((dksc->sc_flags & DKF_INITED) == 0) 513 return ENXIO; 514 } 515 516 error = disk_ioctl(dk, dev, cmd, data, flag, l); 517 if (error != EPASSTHROUGH) 518 return error; 519 else 520 error = 0; 521 522 switch (cmd) { 523 case DIOCWDINFO: 524 case DIOCSDINFO: 525 #ifdef __HAVE_OLD_DISKLABEL 526 case ODIOCWDINFO: 527 case ODIOCSDINFO: 528 #endif 529 #ifdef __HAVE_OLD_DISKLABEL 530 if (cmd == ODIOCSDINFO || cmd == ODIOCWDINFO) { 531 memset(&newlabel, 0, sizeof newlabel); 532 memcpy(&newlabel, data, sizeof (struct olddisklabel)); 533 lp = &newlabel; 534 } else 535 #endif 536 lp = (struct disklabel *)data; 537 538 mutex_enter(&dk->dk_openlock); 539 dksc->sc_flags |= DKF_LABELLING; 540 541 error = setdisklabel(dksc->sc_dkdev.dk_label, 542 lp, 0, dksc->sc_dkdev.dk_cpulabel); 543 if (error == 0) { 544 if (cmd == DIOCWDINFO 545 #ifdef __HAVE_OLD_DISKLABEL 546 || cmd == ODIOCWDINFO 547 #endif 548 ) 549 error = writedisklabel(DKLABELDEV(dev), 550 dkd->d_strategy, dksc->sc_dkdev.dk_label, 551 dksc->sc_dkdev.dk_cpulabel); 552 } 553 554 dksc->sc_flags &= ~DKF_LABELLING; 555 mutex_exit(&dk->dk_openlock); 556 break; 557 558 case DIOCKLABEL: 559 if (*(int *)data != 0) 560 dksc->sc_flags |= DKF_KLABEL; 561 else 562 dksc->sc_flags &= ~DKF_KLABEL; 563 break; 564 565 case DIOCWLABEL: 566 if (*(int *)data != 0) 567 dksc->sc_flags |= DKF_WLABEL; 568 else 569 dksc->sc_flags &= ~DKF_WLABEL; 570 break; 571 572 case DIOCGDEFLABEL: 573 dk_getdefaultlabel(dksc, (struct disklabel *)data); 574 break; 575 576 #ifdef __HAVE_OLD_DISKLABEL 577 case ODIOCGDEFLABEL: 578 dk_getdefaultlabel(dksc, &newlabel); 579 if (newlabel.d_npartitions > OLDMAXPARTITIONS) 580 return ENOTTY; 581 memcpy(data, &newlabel, sizeof (struct olddisklabel)); 582 break; 583 #endif 584 585 case DIOCGSTRATEGY: 586 { 587 struct disk_strategy *dks = (void *)data; 588 589 mutex_enter(&dksc->sc_iolock); 590 strlcpy(dks->dks_name, bufq_getstrategyname(dksc->sc_bufq), 591 sizeof(dks->dks_name)); 592 mutex_exit(&dksc->sc_iolock); 593 dks->dks_paramlen = 0; 594 595 return 0; 596 } 597 598 case DIOCSSTRATEGY: 599 { 600 struct disk_strategy *dks = (void *)data; 601 struct bufq_state *new; 602 struct bufq_state *old; 603 604 if (dks->dks_param != NULL) { 605 return EINVAL; 606 } 607 dks->dks_name[sizeof(dks->dks_name) - 1] = 0; /* ensure term */ 608 error = bufq_alloc(&new, dks->dks_name, 609 BUFQ_EXACT|BUFQ_SORT_RAWBLOCK); 610 if (error) { 611 return error; 612 } 613 mutex_enter(&dksc->sc_iolock); 614 old = dksc->sc_bufq; 615 bufq_move(new, old); 616 dksc->sc_bufq = new; 617 mutex_exit(&dksc->sc_iolock); 618 bufq_free(old); 619 620 return 0; 621 } 622 623 default: 624 error = ENOTTY; 625 } 626 627 return error; 628 } 629 630 /* 631 * dk_dump dumps all of physical memory into the partition specified. 632 * This requires substantially more framework than {s,w}ddump, and hence 633 * is probably much more fragile. 634 * 635 */ 636 637 #define DKF_READYFORDUMP (DKF_INITED|DKF_TAKEDUMP) 638 #define DKFF_READYFORDUMP(x) (((x) & DKF_READYFORDUMP) == DKF_READYFORDUMP) 639 static volatile int dk_dumping = 0; 640 641 /* ARGSUSED */ 642 int 643 dk_dump(struct dk_softc *dksc, dev_t dev, 644 daddr_t blkno, void *vav, size_t size) 645 { 646 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver; 647 char *va = vav; 648 struct disklabel *lp; 649 int part, towrt, nsects, sectoff, maxblkcnt, nblk; 650 int maxxfer, rv = 0; 651 652 /* 653 * ensure that we consider this device to be safe for dumping, 654 * and that the device is configured. 655 */ 656 if (!DKFF_READYFORDUMP(dksc->sc_flags)) 657 return ENXIO; 658 659 /* ensure that we are not already dumping */ 660 if (dk_dumping) 661 return EFAULT; 662 dk_dumping = 1; 663 664 if (dkd->d_dumpblocks == NULL) 665 return ENXIO; 666 667 /* device specific max transfer size */ 668 maxxfer = MAXPHYS; 669 if (dkd->d_iosize != NULL) 670 (*dkd->d_iosize)(dksc->sc_dev, &maxxfer); 671 672 /* Convert to disk sectors. Request must be a multiple of size. */ 673 part = DISKPART(dev); 674 lp = dksc->sc_dkdev.dk_label; 675 if ((size % lp->d_secsize) != 0) 676 return (EFAULT); 677 towrt = size / lp->d_secsize; 678 blkno = dbtob(blkno) / lp->d_secsize; /* blkno in secsize units */ 679 680 nsects = lp->d_partitions[part].p_size; 681 sectoff = lp->d_partitions[part].p_offset; 682 683 /* Check transfer bounds against partition size. */ 684 if ((blkno < 0) || ((blkno + towrt) > nsects)) 685 return (EINVAL); 686 687 /* Offset block number to start of partition. */ 688 blkno += sectoff; 689 690 /* Start dumping and return when done. */ 691 maxblkcnt = howmany(maxxfer, lp->d_secsize); 692 while (towrt > 0) { 693 nblk = min(maxblkcnt, towrt); 694 695 if ((rv = (*dkd->d_dumpblocks)(dksc->sc_dev, va, blkno, nblk)) != 0) 696 return (rv); 697 698 towrt -= nblk; 699 blkno += nblk; 700 va += nblk * lp->d_secsize; 701 } 702 703 dk_dumping = 0; 704 705 return 0; 706 } 707 708 /* ARGSUSED */ 709 void 710 dk_getdefaultlabel(struct dk_softc *dksc, struct disklabel *lp) 711 { 712 struct disk_geom *dg = &dksc->sc_dkdev.dk_geom; 713 714 memset(lp, 0, sizeof(*lp)); 715 716 if (dg->dg_secperunit > UINT32_MAX) 717 lp->d_secperunit = UINT32_MAX; 718 else 719 lp->d_secperunit = dg->dg_secperunit; 720 lp->d_secsize = dg->dg_secsize; 721 lp->d_nsectors = dg->dg_nsectors; 722 lp->d_ntracks = dg->dg_ntracks; 723 lp->d_ncylinders = dg->dg_ncylinders; 724 lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors; 725 726 strlcpy(lp->d_typename, dksc->sc_xname, sizeof(lp->d_typename)); 727 lp->d_type = dksc->sc_dtype; 728 strlcpy(lp->d_packname, "fictitious", sizeof(lp->d_packname)); 729 lp->d_rpm = 3600; 730 lp->d_interleave = 1; 731 lp->d_flags = 0; 732 733 lp->d_partitions[RAW_PART].p_offset = 0; 734 lp->d_partitions[RAW_PART].p_size = lp->d_secperunit; 735 lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED; 736 lp->d_npartitions = RAW_PART + 1; 737 738 lp->d_magic = DISKMAGIC; 739 lp->d_magic2 = DISKMAGIC; 740 lp->d_checksum = dkcksum(dksc->sc_dkdev.dk_label); 741 } 742 743 /* ARGSUSED */ 744 void 745 dk_getdisklabel(struct dk_softc *dksc, dev_t dev) 746 { 747 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver; 748 struct disklabel *lp = dksc->sc_dkdev.dk_label; 749 struct cpu_disklabel *clp = dksc->sc_dkdev.dk_cpulabel; 750 struct disk_geom *dg = &dksc->sc_dkdev.dk_geom; 751 struct partition *pp; 752 int i; 753 const char *errstring; 754 755 memset(clp, 0x0, sizeof(*clp)); 756 dk_getdefaultlabel(dksc, lp); 757 errstring = readdisklabel(DKLABELDEV(dev), dkd->d_strategy, 758 dksc->sc_dkdev.dk_label, dksc->sc_dkdev.dk_cpulabel); 759 if (errstring) { 760 dk_makedisklabel(dksc); 761 if (dksc->sc_flags & DKF_WARNLABEL) 762 printf("%s: %s\n", dksc->sc_xname, errstring); 763 return; 764 } 765 766 if ((dksc->sc_flags & DKF_LABELSANITY) == 0) 767 return; 768 769 /* Sanity check */ 770 if (lp->d_secperunit < UINT32_MAX ? 771 lp->d_secperunit != dg->dg_secperunit : 772 lp->d_secperunit > dg->dg_secperunit) 773 printf("WARNING: %s: total sector size in disklabel (%ju) " 774 "!= the size of %s (%ju)\n", dksc->sc_xname, 775 (uintmax_t)lp->d_secperunit, dksc->sc_xname, 776 (uintmax_t)dg->dg_secperunit); 777 778 for (i=0; i < lp->d_npartitions; i++) { 779 pp = &lp->d_partitions[i]; 780 if (pp->p_offset + pp->p_size > dg->dg_secperunit) 781 printf("WARNING: %s: end of partition `%c' exceeds " 782 "the size of %s (%ju)\n", dksc->sc_xname, 783 'a' + i, dksc->sc_xname, 784 (uintmax_t)dg->dg_secperunit); 785 } 786 } 787 788 /* ARGSUSED */ 789 static void 790 dk_makedisklabel(struct dk_softc *dksc) 791 { 792 struct disklabel *lp = dksc->sc_dkdev.dk_label; 793 794 lp->d_partitions[RAW_PART].p_fstype = FS_BSDFFS; 795 strlcpy(lp->d_packname, "default label", sizeof(lp->d_packname)); 796 lp->d_checksum = dkcksum(lp); 797 } 798 799 /* This function is taken from ccd.c:1.76 --rcd */ 800 801 /* 802 * XXX this function looks too generic for dksubr.c, shouldn't we 803 * put it somewhere better? 804 */ 805 806 /* 807 * Lookup the provided name in the filesystem. If the file exists, 808 * is a valid block device, and isn't being used by anyone else, 809 * set *vpp to the file's vnode. 810 */ 811 int 812 dk_lookup(struct pathbuf *pb, struct lwp *l, struct vnode **vpp) 813 { 814 struct nameidata nd; 815 struct vnode *vp; 816 int error; 817 818 if (l == NULL) 819 return ESRCH; /* Is ESRCH the best choice? */ 820 821 NDINIT(&nd, LOOKUP, FOLLOW, pb); 822 if ((error = vn_open(&nd, FREAD | FWRITE, 0)) != 0) { 823 DPRINTF((DKDB_FOLLOW|DKDB_INIT), 824 ("dk_lookup: vn_open error = %d\n", error)); 825 return error; 826 } 827 828 vp = nd.ni_vp; 829 if (vp->v_type != VBLK) { 830 error = ENOTBLK; 831 goto out; 832 } 833 834 /* Reopen as anonymous vnode to protect against forced unmount. */ 835 if ((error = bdevvp(vp->v_rdev, vpp)) != 0) 836 goto out; 837 VOP_UNLOCK(vp); 838 if ((error = vn_close(vp, FREAD | FWRITE, l->l_cred)) != 0) { 839 vrele(*vpp); 840 return error; 841 } 842 if ((error = VOP_OPEN(*vpp, FREAD | FWRITE, l->l_cred)) != 0) { 843 vrele(*vpp); 844 return error; 845 } 846 mutex_enter((*vpp)->v_interlock); 847 (*vpp)->v_writecount++; 848 mutex_exit((*vpp)->v_interlock); 849 850 IFDEBUG(DKDB_VNODE, vprint("dk_lookup: vnode info", *vpp)); 851 852 return 0; 853 out: 854 VOP_UNLOCK(vp); 855 (void) vn_close(vp, FREAD | FWRITE, l->l_cred); 856 return error; 857 } 858 859 MODULE(MODULE_CLASS_MISC, dk_subr, NULL); 860 861 static int 862 dk_subr_modcmd(modcmd_t cmd, void *arg) 863 { 864 switch (cmd) { 865 case MODULE_CMD_INIT: 866 case MODULE_CMD_FINI: 867 return 0; 868 case MODULE_CMD_STAT: 869 case MODULE_CMD_AUTOUNLOAD: 870 default: 871 return ENOTTY; 872 } 873 } 874
Indexes created Sun Oct 19 16:10:00 GMT 2025