dksubr.c revision 1.71
1 /* $NetBSD: dksubr.c,v 1.71 2015/08/16 18:00:03 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.71 2015/08/16 18:00:03 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 78 void 79 dk_init(struct dk_softc *dksc, device_t dev, int dtype) 80 { 81 82 memset(dksc, 0x0, sizeof(*dksc)); 83 dksc->sc_dtype = dtype; 84 dksc->sc_dev = dev; 85 86 strlcpy(dksc->sc_xname, device_xname(dev), DK_XNAME_SIZE); 87 dksc->sc_dkdev.dk_name = dksc->sc_xname; 88 } 89 90 void 91 dk_attach(struct dk_softc *dksc) 92 { 93 mutex_init(&dksc->sc_iolock, MUTEX_DEFAULT, IPL_VM); 94 dksc->sc_flags |= DKF_INITED; 95 #ifdef DIAGNOSTIC 96 dksc->sc_flags |= DKF_WARNLABEL | DKF_LABELSANITY; 97 #endif 98 } 99 100 void 101 dk_detach(struct dk_softc *dksc) 102 { 103 dksc->sc_flags &= ~DKF_INITED; 104 mutex_destroy(&dksc->sc_iolock); 105 } 106 107 /* ARGSUSED */ 108 int 109 dk_open(struct dk_softc *dksc, dev_t dev, 110 int flags, int fmt, struct lwp *l) 111 { 112 struct disklabel *lp = dksc->sc_dkdev.dk_label; 113 int part = DISKPART(dev); 114 int pmask = 1 << part; 115 int ret = 0; 116 struct disk *dk = &dksc->sc_dkdev; 117 118 DPRINTF_FOLLOW(("dk_open(%s, %p, 0x%"PRIx64", 0x%x)\n", 119 dksc->sc_xname, dksc, dev, flags)); 120 121 mutex_enter(&dk->dk_openlock); 122 123 /* 124 * If there are wedges, and this is not RAW_PART, then we 125 * need to fail. 126 */ 127 if (dk->dk_nwedges != 0 && part != RAW_PART) { 128 ret = EBUSY; 129 goto done; 130 } 131 132 /* 133 * If we're init'ed and there are no other open partitions then 134 * update the in-core disklabel. 135 */ 136 if ((dksc->sc_flags & DKF_INITED)) { 137 if ((dksc->sc_flags & DKF_VLABEL) == 0) { 138 dksc->sc_flags |= DKF_VLABEL; 139 dk_getdisklabel(dksc, dev); 140 } 141 } 142 143 /* Fail if we can't find the partition. */ 144 if (part != RAW_PART && 145 ((dksc->sc_flags & DKF_VLABEL) == 0 || 146 part >= lp->d_npartitions || 147 lp->d_partitions[part].p_fstype == FS_UNUSED)) { 148 ret = ENXIO; 149 goto done; 150 } 151 152 /* Mark our unit as open. */ 153 switch (fmt) { 154 case S_IFCHR: 155 dk->dk_copenmask |= pmask; 156 break; 157 case S_IFBLK: 158 dk->dk_bopenmask |= pmask; 159 break; 160 } 161 162 dk->dk_openmask = dk->dk_copenmask | dk->dk_bopenmask; 163 164 done: 165 mutex_exit(&dk->dk_openlock); 166 return ret; 167 } 168 169 /* ARGSUSED */ 170 int 171 dk_close(struct dk_softc *dksc, dev_t dev, 172 int flags, int fmt, struct lwp *l) 173 { 174 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver; 175 int part = DISKPART(dev); 176 int pmask = 1 << part; 177 struct disk *dk = &dksc->sc_dkdev; 178 179 DPRINTF_FOLLOW(("dk_close(%s, %p, 0x%"PRIx64", 0x%x)\n", 180 dksc->sc_xname, dksc, dev, flags)); 181 182 mutex_enter(&dk->dk_openlock); 183 184 switch (fmt) { 185 case S_IFCHR: 186 dk->dk_copenmask &= ~pmask; 187 break; 188 case S_IFBLK: 189 dk->dk_bopenmask &= ~pmask; 190 break; 191 } 192 dk->dk_openmask = dk->dk_copenmask | dk->dk_bopenmask; 193 194 if (dk->dk_openmask == 0) { 195 if (dkd->d_lastclose != NULL) 196 (*dkd->d_lastclose)(dksc->sc_dev); 197 if ((dksc->sc_flags & DKF_KLABEL) == 0) 198 dksc->sc_flags &= ~DKF_VLABEL; 199 } 200 201 mutex_exit(&dk->dk_openlock); 202 return 0; 203 } 204 205 static int 206 dk_translate(struct dk_softc *dksc, struct buf *bp) 207 { 208 int part; 209 int wlabel; 210 daddr_t blkno; 211 struct disklabel *lp; 212 struct disk *dk; 213 uint64_t numsecs; 214 unsigned secsize; 215 216 lp = dksc->sc_dkdev.dk_label; 217 dk = &dksc->sc_dkdev; 218 219 part = DISKPART(bp->b_dev); 220 numsecs = dk->dk_geom.dg_secperunit; 221 secsize = dk->dk_geom.dg_secsize; 222 223 bp->b_resid = bp->b_bcount; 224 225 /* 226 * The transfer must be a whole number of blocks and the offset must 227 * not be negative. 228 */ 229 if ((bp->b_bcount % secsize) != 0 || bp->b_blkno < 0) 230 return EINVAL; 231 232 /* If there is nothing to do, then we are done */ 233 if (bp->b_bcount == 0) 234 return 0; 235 236 wlabel = dksc->sc_flags & (DKF_WLABEL|DKF_LABELLING); 237 if (part == RAW_PART) { 238 if (bounds_check_with_mediasize(bp, DEV_BSIZE, numsecs) <= 0) 239 return bp->b_error; 240 } else { 241 if (bounds_check_with_label(&dksc->sc_dkdev, bp, wlabel) <= 0) 242 return bp->b_error; 243 } 244 245 /* 246 * Convert the block number to absolute and put it in terms 247 * of the device's logical block size. 248 */ 249 if (secsize >= DEV_BSIZE) 250 blkno = bp->b_blkno / (secsize / DEV_BSIZE); 251 else 252 blkno = bp->b_blkno * (DEV_BSIZE / secsize); 253 254 if (part != RAW_PART) 255 blkno += lp->d_partitions[DISKPART(bp->b_dev)].p_offset; 256 bp->b_rawblkno = blkno; 257 258 return -1; 259 } 260 261 void 262 dk_strategy(struct dk_softc *dksc, struct buf *bp) 263 { 264 int error; 265 266 DPRINTF_FOLLOW(("dk_strategy(%s, %p, %p)\n", 267 dksc->sc_xname, dksc, bp)); 268 269 if (!(dksc->sc_flags & DKF_INITED)) { 270 DPRINTF_FOLLOW(("dk_strategy: not inited\n")); 271 bp->b_error = ENXIO; 272 biodone(bp); 273 return; 274 } 275 276 error = dk_translate(dksc, bp); 277 if (error >= 0) { 278 biodone(bp); 279 return; 280 } 281 282 /* 283 * Queue buffer and start unit 284 */ 285 dk_start(dksc, bp); 286 } 287 288 void 289 dk_start(struct dk_softc *dksc, struct buf *bp) 290 { 291 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver; 292 int error; 293 struct buf *qbp __diagused; 294 295 mutex_enter(&dksc->sc_iolock); 296 297 if (bp != NULL) 298 bufq_put(dksc->sc_bufq, bp); 299 300 while ((bp = bufq_peek(dksc->sc_bufq)) != NULL) { 301 302 disk_busy(&dksc->sc_dkdev); 303 error = dkd->d_diskstart(dksc->sc_dev, bp); 304 if (error == EAGAIN) { 305 disk_unbusy(&dksc->sc_dkdev, 0, (bp->b_flags & B_READ)); 306 break; 307 } 308 309 #ifdef DIAGNOSTIC 310 qbp = bufq_get(dksc->sc_bufq); 311 KASSERT(bp == qbp); 312 #else 313 (void) bufq_get(dksc->sc_bufq); 314 #endif 315 316 if (error != 0) { 317 bp->b_error = error; 318 bp->b_resid = bp->b_bcount; 319 dk_done(dksc, bp); 320 } 321 } 322 323 mutex_exit(&dksc->sc_iolock); 324 } 325 326 void 327 dk_done(struct dk_softc *dksc, struct buf *bp) 328 { 329 struct disk *dk = &dksc->sc_dkdev; 330 331 if (bp->b_error != 0) { 332 struct cfdriver *cd = device_cfdriver(dksc->sc_dev); 333 334 diskerr(bp, cd->cd_name, "error", LOG_PRINTF, 0, 335 dk->dk_label); 336 printf("\n"); 337 } 338 339 mutex_enter(&dksc->sc_iolock); 340 disk_unbusy(dk, bp->b_bcount - bp->b_resid, (bp->b_flags & B_READ)); 341 mutex_exit(&dksc->sc_iolock); 342 343 #ifdef notyet 344 rnd_add_uint(&dksc->sc_rnd_source, bp->b_rawblkno); 345 #endif 346 347 biodone(bp); 348 } 349 350 int 351 dk_discard(struct dk_softc *dksc, dev_t dev, off_t pos, off_t len) 352 { 353 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver; 354 unsigned secsize = dksc->sc_dkdev.dk_geom.dg_secsize; 355 struct buf tmp, *bp = &tmp; 356 int error; 357 358 DPRINTF_FOLLOW(("dk_discard(%s, %p, 0x"PRIx64", %jd, %jd)\n", 359 dksc->sc_xname, dksc, (intmax_t)pos, (intmax_t)len)); 360 361 if (!(dksc->sc_flags & DKF_INITED)) { 362 DPRINTF_FOLLOW(("dk_discard: not inited\n")); 363 return ENXIO; 364 } 365 366 if (secsize == 0 || (pos % secsize) != 0) 367 return EINVAL; 368 369 /* enough data to please the bounds checking code */ 370 bp->b_dev = dev; 371 bp->b_blkno = (daddr_t)(pos / secsize); 372 bp->b_bcount = len; 373 bp->b_flags = B_WRITE; 374 375 error = dk_translate(dksc, bp); 376 if (error >= 0) 377 return error; 378 379 error = dkd->d_discard(dksc->sc_dev, 380 (off_t)bp->b_rawblkno * secsize, 381 (off_t)bp->b_bcount); 382 383 return error; 384 } 385 386 int 387 dk_size(struct dk_softc *dksc, dev_t dev) 388 { 389 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver; 390 struct disklabel *lp; 391 int is_open; 392 int part; 393 int size; 394 395 if ((dksc->sc_flags & DKF_INITED) == 0) 396 return -1; 397 398 part = DISKPART(dev); 399 is_open = dksc->sc_dkdev.dk_openmask & (1 << part); 400 401 if (!is_open && dkd->d_open(dev, 0, S_IFBLK, curlwp)) 402 return -1; 403 404 lp = dksc->sc_dkdev.dk_label; 405 if (lp->d_partitions[part].p_fstype != FS_SWAP) 406 size = -1; 407 else 408 size = lp->d_partitions[part].p_size * 409 (lp->d_secsize / DEV_BSIZE); 410 411 if (!is_open && dkd->d_close(dev, 0, S_IFBLK, curlwp)) 412 return -1; 413 414 return size; 415 } 416 417 int 418 dk_ioctl(struct dk_softc *dksc, dev_t dev, 419 u_long cmd, void *data, int flag, struct lwp *l) 420 { 421 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver; 422 struct disklabel *lp; 423 struct disk *dk = &dksc->sc_dkdev; 424 #ifdef __HAVE_OLD_DISKLABEL 425 struct disklabel newlabel; 426 #endif 427 int error; 428 429 DPRINTF_FOLLOW(("dk_ioctl(%s, %p, 0x%"PRIx64", 0x%lx)\n", 430 dksc->sc_xname, dksc, dev, cmd)); 431 432 /* ensure that the pseudo disk is open for writes for these commands */ 433 switch (cmd) { 434 case DIOCSDINFO: 435 case DIOCWDINFO: 436 #ifdef __HAVE_OLD_DISKLABEL 437 case ODIOCSDINFO: 438 case ODIOCWDINFO: 439 #endif 440 case DIOCKLABEL: 441 case DIOCWLABEL: 442 case DIOCAWEDGE: 443 case DIOCDWEDGE: 444 case DIOCSSTRATEGY: 445 if ((flag & FWRITE) == 0) 446 return EBADF; 447 } 448 449 /* ensure that the pseudo-disk is initialized for these */ 450 switch (cmd) { 451 case DIOCGDINFO: 452 case DIOCSDINFO: 453 case DIOCWDINFO: 454 case DIOCGPART: 455 case DIOCKLABEL: 456 case DIOCWLABEL: 457 case DIOCGDEFLABEL: 458 case DIOCAWEDGE: 459 case DIOCDWEDGE: 460 case DIOCLWEDGES: 461 case DIOCMWEDGES: 462 case DIOCCACHESYNC: 463 #ifdef __HAVE_OLD_DISKLABEL 464 case ODIOCGDINFO: 465 case ODIOCSDINFO: 466 case ODIOCWDINFO: 467 case ODIOCGDEFLABEL: 468 #endif 469 if ((dksc->sc_flags & DKF_INITED) == 0) 470 return ENXIO; 471 } 472 473 error = disk_ioctl(dk, dev, cmd, data, flag, l); 474 if (error != EPASSTHROUGH) 475 return error; 476 else 477 error = 0; 478 479 switch (cmd) { 480 case DIOCWDINFO: 481 case DIOCSDINFO: 482 #ifdef __HAVE_OLD_DISKLABEL 483 case ODIOCWDINFO: 484 case ODIOCSDINFO: 485 #endif 486 #ifdef __HAVE_OLD_DISKLABEL 487 if (cmd == ODIOCSDINFO || cmd == ODIOCWDINFO) { 488 memset(&newlabel, 0, sizeof newlabel); 489 memcpy(&newlabel, data, sizeof (struct olddisklabel)); 490 lp = &newlabel; 491 } else 492 #endif 493 lp = (struct disklabel *)data; 494 495 mutex_enter(&dk->dk_openlock); 496 dksc->sc_flags |= DKF_LABELLING; 497 498 error = setdisklabel(dksc->sc_dkdev.dk_label, 499 lp, 0, dksc->sc_dkdev.dk_cpulabel); 500 if (error == 0) { 501 if (cmd == DIOCWDINFO 502 #ifdef __HAVE_OLD_DISKLABEL 503 || cmd == ODIOCWDINFO 504 #endif 505 ) 506 error = writedisklabel(DKLABELDEV(dev), 507 dkd->d_strategy, dksc->sc_dkdev.dk_label, 508 dksc->sc_dkdev.dk_cpulabel); 509 } 510 511 dksc->sc_flags &= ~DKF_LABELLING; 512 mutex_exit(&dk->dk_openlock); 513 break; 514 515 case DIOCKLABEL: 516 if (*(int *)data != 0) 517 dksc->sc_flags |= DKF_KLABEL; 518 else 519 dksc->sc_flags &= ~DKF_KLABEL; 520 break; 521 522 case DIOCWLABEL: 523 if (*(int *)data != 0) 524 dksc->sc_flags |= DKF_WLABEL; 525 else 526 dksc->sc_flags &= ~DKF_WLABEL; 527 break; 528 529 case DIOCGDEFLABEL: 530 dk_getdefaultlabel(dksc, (struct disklabel *)data); 531 break; 532 533 #ifdef __HAVE_OLD_DISKLABEL 534 case ODIOCGDEFLABEL: 535 dk_getdefaultlabel(dksc, &newlabel); 536 if (newlabel.d_npartitions > OLDMAXPARTITIONS) 537 return ENOTTY; 538 memcpy(data, &newlabel, sizeof (struct olddisklabel)); 539 break; 540 #endif 541 542 case DIOCGSTRATEGY: 543 { 544 struct disk_strategy *dks = (void *)data; 545 546 mutex_enter(&dksc->sc_iolock); 547 strlcpy(dks->dks_name, bufq_getstrategyname(dksc->sc_bufq), 548 sizeof(dks->dks_name)); 549 mutex_exit(&dksc->sc_iolock); 550 dks->dks_paramlen = 0; 551 552 return 0; 553 } 554 555 case DIOCSSTRATEGY: 556 { 557 struct disk_strategy *dks = (void *)data; 558 struct bufq_state *new; 559 struct bufq_state *old; 560 561 if (dks->dks_param != NULL) { 562 return EINVAL; 563 } 564 dks->dks_name[sizeof(dks->dks_name) - 1] = 0; /* ensure term */ 565 error = bufq_alloc(&new, dks->dks_name, 566 BUFQ_EXACT|BUFQ_SORT_RAWBLOCK); 567 if (error) { 568 return error; 569 } 570 mutex_enter(&dksc->sc_iolock); 571 old = dksc->sc_bufq; 572 bufq_move(new, old); 573 dksc->sc_bufq = new; 574 mutex_exit(&dksc->sc_iolock); 575 bufq_free(old); 576 577 return 0; 578 } 579 580 default: 581 error = ENOTTY; 582 } 583 584 return error; 585 } 586 587 /* 588 * dk_dump dumps all of physical memory into the partition specified. 589 * This requires substantially more framework than {s,w}ddump, and hence 590 * is probably much more fragile. 591 * 592 */ 593 594 #define DKF_READYFORDUMP (DKF_INITED|DKF_TAKEDUMP) 595 #define DKFF_READYFORDUMP(x) (((x) & DKF_READYFORDUMP) == DKF_READYFORDUMP) 596 static volatile int dk_dumping = 0; 597 598 /* ARGSUSED */ 599 int 600 dk_dump(struct dk_softc *dksc, dev_t dev, 601 daddr_t blkno, void *vav, size_t size) 602 { 603 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver; 604 char *va = vav; 605 struct disklabel *lp; 606 int part, towrt, nsects, sectoff, maxblkcnt, nblk; 607 int maxxfer, rv = 0; 608 609 /* 610 * ensure that we consider this device to be safe for dumping, 611 * and that the device is configured. 612 */ 613 if (!DKFF_READYFORDUMP(dksc->sc_flags)) 614 return ENXIO; 615 616 /* ensure that we are not already dumping */ 617 if (dk_dumping) 618 return EFAULT; 619 dk_dumping = 1; 620 621 if (dkd->d_dumpblocks == NULL) 622 return ENXIO; 623 624 /* device specific max transfer size */ 625 maxxfer = MAXPHYS; 626 if (dkd->d_iosize != NULL) 627 (*dkd->d_iosize)(dksc->sc_dev, &maxxfer); 628 629 /* Convert to disk sectors. Request must be a multiple of size. */ 630 part = DISKPART(dev); 631 lp = dksc->sc_dkdev.dk_label; 632 if ((size % lp->d_secsize) != 0) 633 return (EFAULT); 634 towrt = size / lp->d_secsize; 635 blkno = dbtob(blkno) / lp->d_secsize; /* blkno in secsize units */ 636 637 nsects = lp->d_partitions[part].p_size; 638 sectoff = lp->d_partitions[part].p_offset; 639 640 /* Check transfer bounds against partition size. */ 641 if ((blkno < 0) || ((blkno + towrt) > nsects)) 642 return (EINVAL); 643 644 /* Offset block number to start of partition. */ 645 blkno += sectoff; 646 647 /* Start dumping and return when done. */ 648 maxblkcnt = howmany(maxxfer, lp->d_secsize); 649 while (towrt > 0) { 650 nblk = min(maxblkcnt, towrt); 651 652 if ((rv = (*dkd->d_dumpblocks)(dksc->sc_dev, va, blkno, nblk)) != 0) 653 return (rv); 654 655 towrt -= nblk; 656 blkno += nblk; 657 va += nblk * lp->d_secsize; 658 } 659 660 dk_dumping = 0; 661 662 return 0; 663 } 664 665 /* ARGSUSED */ 666 void 667 dk_getdefaultlabel(struct dk_softc *dksc, struct disklabel *lp) 668 { 669 struct disk_geom *dg = &dksc->sc_dkdev.dk_geom; 670 671 memset(lp, 0, sizeof(*lp)); 672 673 if (dg->dg_secperunit > UINT32_MAX) 674 lp->d_secperunit = UINT32_MAX; 675 else 676 lp->d_secperunit = dg->dg_secperunit; 677 lp->d_secsize = dg->dg_secsize; 678 lp->d_nsectors = dg->dg_nsectors; 679 lp->d_ntracks = dg->dg_ntracks; 680 lp->d_ncylinders = dg->dg_ncylinders; 681 lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors; 682 683 strlcpy(lp->d_typename, dksc->sc_xname, sizeof(lp->d_typename)); 684 lp->d_type = dksc->sc_dtype; 685 strlcpy(lp->d_packname, "fictitious", sizeof(lp->d_packname)); 686 lp->d_rpm = 3600; 687 lp->d_interleave = 1; 688 lp->d_flags = 0; 689 690 lp->d_partitions[RAW_PART].p_offset = 0; 691 lp->d_partitions[RAW_PART].p_size = lp->d_secperunit; 692 lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED; 693 lp->d_npartitions = RAW_PART + 1; 694 695 lp->d_magic = DISKMAGIC; 696 lp->d_magic2 = DISKMAGIC; 697 lp->d_checksum = dkcksum(dksc->sc_dkdev.dk_label); 698 } 699 700 /* ARGSUSED */ 701 void 702 dk_getdisklabel(struct dk_softc *dksc, dev_t dev) 703 { 704 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver; 705 struct disklabel *lp = dksc->sc_dkdev.dk_label; 706 struct cpu_disklabel *clp = dksc->sc_dkdev.dk_cpulabel; 707 struct disk_geom *dg = &dksc->sc_dkdev.dk_geom; 708 struct partition *pp; 709 int i; 710 const char *errstring; 711 712 memset(clp, 0x0, sizeof(*clp)); 713 dk_getdefaultlabel(dksc, lp); 714 errstring = readdisklabel(DKLABELDEV(dev), dkd->d_strategy, 715 dksc->sc_dkdev.dk_label, dksc->sc_dkdev.dk_cpulabel); 716 if (errstring) { 717 dk_makedisklabel(dksc); 718 if (dksc->sc_flags & DKF_WARNLABEL) 719 printf("%s: %s\n", dksc->sc_xname, errstring); 720 return; 721 } 722 723 if ((dksc->sc_flags & DKF_LABELSANITY) == 0) 724 return; 725 726 /* Sanity check */ 727 if (lp->d_secperunit < UINT32_MAX ? 728 lp->d_secperunit != dg->dg_secperunit : 729 lp->d_secperunit > dg->dg_secperunit) 730 printf("WARNING: %s: total sector size in disklabel (%ju) " 731 "!= the size of %s (%ju)\n", dksc->sc_xname, 732 (uintmax_t)lp->d_secperunit, dksc->sc_xname, 733 (uintmax_t)dg->dg_secperunit); 734 735 for (i=0; i < lp->d_npartitions; i++) { 736 pp = &lp->d_partitions[i]; 737 if (pp->p_offset + pp->p_size > dg->dg_secperunit) 738 printf("WARNING: %s: end of partition `%c' exceeds " 739 "the size of %s (%ju)\n", dksc->sc_xname, 740 'a' + i, dksc->sc_xname, 741 (uintmax_t)dg->dg_secperunit); 742 } 743 } 744 745 /* ARGSUSED */ 746 static void 747 dk_makedisklabel(struct dk_softc *dksc) 748 { 749 struct disklabel *lp = dksc->sc_dkdev.dk_label; 750 751 lp->d_partitions[RAW_PART].p_fstype = FS_BSDFFS; 752 strlcpy(lp->d_packname, "default label", sizeof(lp->d_packname)); 753 lp->d_checksum = dkcksum(lp); 754 } 755 756 /* This function is taken from ccd.c:1.76 --rcd */ 757 758 /* 759 * XXX this function looks too generic for dksubr.c, shouldn't we 760 * put it somewhere better? 761 */ 762 763 /* 764 * Lookup the provided name in the filesystem. If the file exists, 765 * is a valid block device, and isn't being used by anyone else, 766 * set *vpp to the file's vnode. 767 */ 768 int 769 dk_lookup(struct pathbuf *pb, struct lwp *l, struct vnode **vpp) 770 { 771 struct nameidata nd; 772 struct vnode *vp; 773 int error; 774 775 if (l == NULL) 776 return ESRCH; /* Is ESRCH the best choice? */ 777 778 NDINIT(&nd, LOOKUP, FOLLOW, pb); 779 if ((error = vn_open(&nd, FREAD | FWRITE, 0)) != 0) { 780 DPRINTF((DKDB_FOLLOW|DKDB_INIT), 781 ("dk_lookup: vn_open error = %d\n", error)); 782 return error; 783 } 784 785 vp = nd.ni_vp; 786 if (vp->v_type != VBLK) { 787 error = ENOTBLK; 788 goto out; 789 } 790 791 /* Reopen as anonymous vnode to protect against forced unmount. */ 792 if ((error = bdevvp(vp->v_rdev, vpp)) != 0) 793 goto out; 794 VOP_UNLOCK(vp); 795 if ((error = vn_close(vp, FREAD | FWRITE, l->l_cred)) != 0) { 796 vrele(*vpp); 797 return error; 798 } 799 if ((error = VOP_OPEN(*vpp, FREAD | FWRITE, l->l_cred)) != 0) { 800 vrele(*vpp); 801 return error; 802 } 803 mutex_enter((*vpp)->v_interlock); 804 (*vpp)->v_writecount++; 805 mutex_exit((*vpp)->v_interlock); 806 807 IFDEBUG(DKDB_VNODE, vprint("dk_lookup: vnode info", *vpp)); 808 809 return 0; 810 out: 811 VOP_UNLOCK(vp); 812 (void) vn_close(vp, FREAD | FWRITE, l->l_cred); 813 return error; 814 } 815 816 MODULE(MODULE_CLASS_MISC, dk_subr, NULL); 817 818 static int 819 dk_subr_modcmd(modcmd_t cmd, void *arg) 820 { 821 switch (cmd) { 822 case MODULE_CMD_INIT: 823 case MODULE_CMD_FINI: 824 return 0; 825 case MODULE_CMD_STAT: 826 case MODULE_CMD_AUTOUNLOAD: 827 default: 828 return ENOTTY; 829 } 830 } 831
Indexes created Sun Oct 19 02:09:48 GMT 2025