ld.c revision 1.107
1 /* $NetBSD: ld.c,v 1.107 2019/10/06 06:10:44 mlelstv Exp $ */ 2 3 /*- 4 * Copyright (c) 1998, 2000 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Andrew Doran and Charles M. Hannum. 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 /* 33 * Disk driver for use by RAID controllers. 34 */ 35 36 #include <sys/cdefs.h> 37 __KERNEL_RCSID(0, "$NetBSD: ld.c,v 1.107 2019/10/06 06:10:44 mlelstv Exp $"); 38 39 #include <sys/param.h> 40 #include <sys/systm.h> 41 #include <sys/kernel.h> 42 #include <sys/device.h> 43 #include <sys/queue.h> 44 #include <sys/proc.h> 45 #include <sys/buf.h> 46 #include <sys/bufq.h> 47 #include <sys/endian.h> 48 #include <sys/disklabel.h> 49 #include <sys/disk.h> 50 #include <sys/dkio.h> 51 #include <sys/stat.h> 52 #include <sys/conf.h> 53 #include <sys/fcntl.h> 54 #include <sys/vnode.h> 55 #include <sys/syslog.h> 56 #include <sys/mutex.h> 57 #include <sys/module.h> 58 #include <sys/reboot.h> 59 60 #include <dev/ldvar.h> 61 62 #include "ioconf.h" 63 64 static void ldminphys(struct buf *bp); 65 static bool ld_suspend(device_t, const pmf_qual_t *); 66 static bool ld_shutdown(device_t, int); 67 static int ld_diskstart(device_t, struct buf *bp); 68 static void ld_iosize(device_t, int *); 69 static int ld_dumpblocks(device_t, void *, daddr_t, int); 70 static void ld_fake_geometry(struct ld_softc *); 71 static void ld_set_geometry(struct ld_softc *); 72 static void ld_config_interrupts (device_t); 73 static int ld_lastclose(device_t); 74 static int ld_discard(device_t, off_t, off_t); 75 static int ld_flush(device_t, bool); 76 77 static dev_type_open(ldopen); 78 static dev_type_close(ldclose); 79 static dev_type_read(ldread); 80 static dev_type_write(ldwrite); 81 static dev_type_ioctl(ldioctl); 82 static dev_type_strategy(ldstrategy); 83 static dev_type_dump(lddump); 84 static dev_type_size(ldsize); 85 static dev_type_discard(lddiscard); 86 87 const struct bdevsw ld_bdevsw = { 88 .d_open = ldopen, 89 .d_close = ldclose, 90 .d_strategy = ldstrategy, 91 .d_ioctl = ldioctl, 92 .d_dump = lddump, 93 .d_psize = ldsize, 94 .d_discard = lddiscard, 95 .d_flag = D_DISK | D_MPSAFE 96 }; 97 98 const struct cdevsw ld_cdevsw = { 99 .d_open = ldopen, 100 .d_close = ldclose, 101 .d_read = ldread, 102 .d_write = ldwrite, 103 .d_ioctl = ldioctl, 104 .d_stop = nostop, 105 .d_tty = notty, 106 .d_poll = nopoll, 107 .d_mmap = nommap, 108 .d_kqfilter = nokqfilter, 109 .d_discard = lddiscard, 110 .d_flag = D_DISK | D_MPSAFE 111 }; 112 113 static struct dkdriver lddkdriver = { 114 .d_open = ldopen, 115 .d_close = ldclose, 116 .d_strategy = ldstrategy, 117 .d_iosize = ld_iosize, 118 .d_minphys = ldminphys, 119 .d_diskstart = ld_diskstart, 120 .d_dumpblocks = ld_dumpblocks, 121 .d_lastclose = ld_lastclose, 122 .d_discard = ld_discard 123 }; 124 125 void 126 ldattach(struct ld_softc *sc, const char *default_strategy) 127 { 128 device_t self = sc->sc_dv; 129 struct dk_softc *dksc = &sc->sc_dksc; 130 131 mutex_init(&sc->sc_mutex, MUTEX_DEFAULT, IPL_VM); 132 cv_init(&sc->sc_drain, "lddrain"); 133 134 if ((sc->sc_flags & LDF_ENABLED) == 0) { 135 return; 136 } 137 138 /* don't attach a disk that we cannot handle */ 139 if (sc->sc_secsize < DEV_BSIZE) { 140 sc->sc_flags &= ~LDF_ENABLED; 141 return; 142 } 143 144 /* Initialise dk and disk structure. */ 145 dk_init(dksc, self, DKTYPE_LD); 146 disk_init(&dksc->sc_dkdev, dksc->sc_xname, &lddkdriver); 147 148 if (sc->sc_maxxfer > MAXPHYS) 149 sc->sc_maxxfer = MAXPHYS; 150 151 /* Build synthetic geometry if necessary. */ 152 if (sc->sc_nheads == 0 || sc->sc_nsectors == 0 || 153 sc->sc_ncylinders == 0) 154 ld_fake_geometry(sc); 155 156 sc->sc_disksize512 = sc->sc_secperunit * sc->sc_secsize / DEV_BSIZE; 157 158 if (sc->sc_flags & LDF_NO_RND) 159 dksc->sc_flags |= DKF_NO_RND; 160 161 /* Attach dk and disk subsystems */ 162 dk_attach(dksc); 163 disk_attach(&dksc->sc_dkdev); 164 ld_set_geometry(sc); 165 166 bufq_alloc(&dksc->sc_bufq, default_strategy, BUFQ_SORT_RAWBLOCK); 167 168 /* Register with PMF */ 169 if (!pmf_device_register1(dksc->sc_dev, ld_suspend, NULL, ld_shutdown)) 170 aprint_error_dev(dksc->sc_dev, 171 "couldn't establish power handler\n"); 172 173 /* Discover wedges on this disk. */ 174 config_interrupts(sc->sc_dv, ld_config_interrupts); 175 } 176 177 int 178 ldadjqparam(struct ld_softc *sc, int xmax) 179 { 180 181 mutex_enter(&sc->sc_mutex); 182 sc->sc_maxqueuecnt = xmax; 183 mutex_exit(&sc->sc_mutex); 184 185 return (0); 186 } 187 188 int 189 ldbegindetach(struct ld_softc *sc, int flags) 190 { 191 struct dk_softc *dksc = &sc->sc_dksc; 192 int rv = 0; 193 194 if ((sc->sc_flags & LDF_ENABLED) == 0) 195 return (0); 196 197 rv = disk_begindetach(&dksc->sc_dkdev, ld_lastclose, dksc->sc_dev, flags); 198 199 if (rv != 0) 200 return rv; 201 202 mutex_enter(&sc->sc_mutex); 203 sc->sc_maxqueuecnt = 0; 204 205 while (sc->sc_queuecnt > 0) { 206 sc->sc_flags |= LDF_DRAIN; 207 cv_wait(&sc->sc_drain, &sc->sc_mutex); 208 } 209 mutex_exit(&sc->sc_mutex); 210 211 return (rv); 212 } 213 214 void 215 ldenddetach(struct ld_softc *sc) 216 { 217 struct dk_softc *dksc = &sc->sc_dksc; 218 int bmaj, cmaj, i, mn; 219 220 if ((sc->sc_flags & LDF_ENABLED) == 0) 221 return; 222 223 mutex_enter(&sc->sc_mutex); 224 225 /* Wait for commands queued with the hardware to complete. */ 226 if (sc->sc_queuecnt != 0) { 227 if (cv_timedwait(&sc->sc_drain, &sc->sc_mutex, 30 * hz)) 228 printf("%s: not drained\n", dksc->sc_xname); 229 } 230 mutex_exit(&sc->sc_mutex); 231 232 /* Kill off any queued buffers. */ 233 dk_drain(dksc); 234 bufq_free(dksc->sc_bufq); 235 236 /* Locate the major numbers. */ 237 bmaj = bdevsw_lookup_major(&ld_bdevsw); 238 cmaj = cdevsw_lookup_major(&ld_cdevsw); 239 240 /* Nuke the vnodes for any open instances. */ 241 for (i = 0; i < MAXPARTITIONS; i++) { 242 mn = DISKMINOR(device_unit(dksc->sc_dev), i); 243 vdevgone(bmaj, mn, mn, VBLK); 244 vdevgone(cmaj, mn, mn, VCHR); 245 } 246 247 /* Delete all of our wedges. */ 248 dkwedge_delall(&dksc->sc_dkdev); 249 250 /* Detach from the disk list. */ 251 disk_detach(&dksc->sc_dkdev); 252 disk_destroy(&dksc->sc_dkdev); 253 254 dk_detach(dksc); 255 256 /* Deregister with PMF */ 257 pmf_device_deregister(dksc->sc_dev); 258 259 /* 260 * XXX We can't really flush the cache here, because the 261 * XXX device may already be non-existent from the controller's 262 * XXX perspective. 263 */ 264 #if 0 265 ld_flush(dksc->sc_dev, false); 266 #endif 267 cv_destroy(&sc->sc_drain); 268 mutex_destroy(&sc->sc_mutex); 269 } 270 271 /* ARGSUSED */ 272 static bool 273 ld_suspend(device_t dev, const pmf_qual_t *qual) 274 { 275 return ld_shutdown(dev, 0); 276 } 277 278 /* ARGSUSED */ 279 static bool 280 ld_shutdown(device_t dev, int flags) 281 { 282 if ((flags & RB_NOSYNC) == 0 && ld_flush(dev, true) != 0) 283 return false; 284 285 return true; 286 } 287 288 /* ARGSUSED */ 289 static int 290 ldopen(dev_t dev, int flags, int fmt, struct lwp *l) 291 { 292 struct ld_softc *sc; 293 struct dk_softc *dksc; 294 int unit; 295 296 unit = DISKUNIT(dev); 297 if ((sc = device_lookup_private(&ld_cd, unit)) == NULL) 298 return (ENXIO); 299 dksc = &sc->sc_dksc; 300 301 return dk_open(dksc, dev, flags, fmt, l); 302 } 303 304 static int 305 ld_lastclose(device_t self) 306 { 307 ld_flush(self, false); 308 309 return 0; 310 } 311 312 /* ARGSUSED */ 313 static int 314 ldclose(dev_t dev, int flags, int fmt, struct lwp *l) 315 { 316 struct ld_softc *sc; 317 struct dk_softc *dksc; 318 int unit; 319 320 unit = DISKUNIT(dev); 321 sc = device_lookup_private(&ld_cd, unit); 322 dksc = &sc->sc_dksc; 323 324 return dk_close(dksc, dev, flags, fmt, l); 325 } 326 327 /* ARGSUSED */ 328 static int 329 ldread(dev_t dev, struct uio *uio, int ioflag) 330 { 331 332 return (physio(ldstrategy, NULL, dev, B_READ, ldminphys, uio)); 333 } 334 335 /* ARGSUSED */ 336 static int 337 ldwrite(dev_t dev, struct uio *uio, int ioflag) 338 { 339 340 return (physio(ldstrategy, NULL, dev, B_WRITE, ldminphys, uio)); 341 } 342 343 /* ARGSUSED */ 344 static int 345 ldioctl(dev_t dev, u_long cmd, void *addr, int32_t flag, struct lwp *l) 346 { 347 struct ld_softc *sc; 348 struct dk_softc *dksc; 349 int unit, error; 350 351 unit = DISKUNIT(dev); 352 sc = device_lookup_private(&ld_cd, unit); 353 dksc = &sc->sc_dksc; 354 355 error = 0; 356 357 /* 358 * Some common checks so that individual attachments wouldn't need 359 * to duplicate them. 360 */ 361 switch (cmd) { 362 case DIOCCACHESYNC: 363 /* 364 * XXX Do we really need to care about having a writable 365 * file descriptor here? 366 */ 367 if ((flag & FWRITE) == 0) 368 error = EBADF; 369 else 370 error = 0; 371 break; 372 } 373 374 if (error != 0) 375 return (error); 376 377 if (sc->sc_ioctl) { 378 if ((sc->sc_flags & LDF_MPSAFE) == 0) 379 KERNEL_LOCK(1, curlwp); 380 error = (*sc->sc_ioctl)(sc, cmd, addr, flag, 0); 381 if ((sc->sc_flags & LDF_MPSAFE) == 0) 382 KERNEL_UNLOCK_ONE(curlwp); 383 if (error != EPASSTHROUGH) 384 return (error); 385 } 386 387 /* something not handled by the attachment */ 388 return dk_ioctl(dksc, dev, cmd, addr, flag, l); 389 } 390 391 /* 392 * Flush the device's cache. 393 */ 394 static int 395 ld_flush(device_t self, bool poll) 396 { 397 int error = 0; 398 struct ld_softc *sc = device_private(self); 399 400 if (sc->sc_ioctl) { 401 if ((sc->sc_flags & LDF_MPSAFE) == 0) 402 KERNEL_LOCK(1, curlwp); 403 error = (*sc->sc_ioctl)(sc, DIOCCACHESYNC, NULL, 0, poll); 404 if ((sc->sc_flags & LDF_MPSAFE) == 0) 405 KERNEL_UNLOCK_ONE(curlwp); 406 if (error != 0) 407 device_printf(self, "unable to flush cache\n"); 408 } 409 410 return error; 411 } 412 413 static void 414 ldstrategy(struct buf *bp) 415 { 416 struct ld_softc *sc; 417 struct dk_softc *dksc; 418 int unit; 419 420 unit = DISKUNIT(bp->b_dev); 421 sc = device_lookup_private(&ld_cd, unit); 422 dksc = &sc->sc_dksc; 423 424 dk_strategy(dksc, bp); 425 } 426 427 static int 428 ld_diskstart(device_t dev, struct buf *bp) 429 { 430 struct ld_softc *sc = device_private(dev); 431 int error; 432 433 if (sc->sc_queuecnt >= sc->sc_maxqueuecnt) 434 return EAGAIN; 435 436 if ((sc->sc_flags & LDF_MPSAFE) == 0) 437 KERNEL_LOCK(1, curlwp); 438 439 mutex_enter(&sc->sc_mutex); 440 441 if (sc->sc_queuecnt >= sc->sc_maxqueuecnt) 442 error = EAGAIN; 443 else { 444 error = (*sc->sc_start)(sc, bp); 445 if (error == 0) 446 sc->sc_queuecnt++; 447 } 448 449 mutex_exit(&sc->sc_mutex); 450 451 if ((sc->sc_flags & LDF_MPSAFE) == 0) 452 KERNEL_UNLOCK_ONE(curlwp); 453 454 return error; 455 } 456 457 void 458 lddone(struct ld_softc *sc, struct buf *bp) 459 { 460 struct dk_softc *dksc = &sc->sc_dksc; 461 462 dk_done(dksc, bp); 463 464 mutex_enter(&sc->sc_mutex); 465 if (--sc->sc_queuecnt <= sc->sc_maxqueuecnt) { 466 if ((sc->sc_flags & LDF_DRAIN) != 0) { 467 sc->sc_flags &= ~LDF_DRAIN; 468 cv_broadcast(&sc->sc_drain); 469 } 470 mutex_exit(&sc->sc_mutex); 471 dk_start(dksc, NULL); 472 } else 473 mutex_exit(&sc->sc_mutex); 474 } 475 476 static int 477 ldsize(dev_t dev) 478 { 479 struct ld_softc *sc; 480 struct dk_softc *dksc; 481 int unit; 482 483 unit = DISKUNIT(dev); 484 if ((sc = device_lookup_private(&ld_cd, unit)) == NULL) 485 return (-1); 486 dksc = &sc->sc_dksc; 487 488 if ((sc->sc_flags & LDF_ENABLED) == 0) 489 return (-1); 490 491 return dk_size(dksc, dev); 492 } 493 494 /* 495 * Take a dump. 496 */ 497 static int 498 lddump(dev_t dev, daddr_t blkno, void *va, size_t size) 499 { 500 struct ld_softc *sc; 501 struct dk_softc *dksc; 502 int unit; 503 504 unit = DISKUNIT(dev); 505 if ((sc = device_lookup_private(&ld_cd, unit)) == NULL) 506 return (ENXIO); 507 dksc = &sc->sc_dksc; 508 509 if ((sc->sc_flags & LDF_ENABLED) == 0) 510 return (ENODEV); 511 512 return dk_dump(dksc, dev, blkno, va, size); 513 } 514 515 static int 516 ld_dumpblocks(device_t dev, void *va, daddr_t blkno, int nblk) 517 { 518 struct ld_softc *sc = device_private(dev); 519 520 if (sc->sc_dump == NULL) 521 return (ENODEV); 522 523 return (*sc->sc_dump)(sc, va, blkno, nblk); 524 } 525 526 /* 527 * Adjust the size of a transfer. 528 */ 529 static void 530 ldminphys(struct buf *bp) 531 { 532 int unit; 533 struct ld_softc *sc; 534 535 unit = DISKUNIT(bp->b_dev); 536 sc = device_lookup_private(&ld_cd, unit); 537 538 ld_iosize(sc->sc_dv, &bp->b_bcount); 539 minphys(bp); 540 } 541 542 static void 543 ld_iosize(device_t d, int *countp) 544 { 545 struct ld_softc *sc = device_private(d); 546 547 if (*countp > sc->sc_maxxfer) 548 *countp = sc->sc_maxxfer; 549 } 550 551 static void 552 ld_fake_geometry(struct ld_softc *sc) 553 { 554 uint64_t ncyl; 555 556 if (sc->sc_secperunit <= 528 * 2048) /* 528MB */ 557 sc->sc_nheads = 16; 558 else if (sc->sc_secperunit <= 1024 * 2048) /* 1GB */ 559 sc->sc_nheads = 32; 560 else if (sc->sc_secperunit <= 21504 * 2048) /* 21GB */ 561 sc->sc_nheads = 64; 562 else if (sc->sc_secperunit <= 43008 * 2048) /* 42GB */ 563 sc->sc_nheads = 128; 564 else 565 sc->sc_nheads = 255; 566 567 sc->sc_nsectors = 63; 568 sc->sc_ncylinders = INT_MAX; 569 ncyl = sc->sc_secperunit / 570 (sc->sc_nheads * sc->sc_nsectors); 571 if (ncyl < INT_MAX) 572 sc->sc_ncylinders = (int)ncyl; 573 } 574 575 static void 576 ld_set_geometry(struct ld_softc *sc) 577 { 578 struct dk_softc *dksc = &sc->sc_dksc; 579 struct disk_geom *dg = &dksc->sc_dkdev.dk_geom; 580 char tbuf[9]; 581 582 format_bytes(tbuf, sizeof(tbuf), sc->sc_secperunit * 583 sc->sc_secsize); 584 aprint_normal_dev(dksc->sc_dev, "%s, %d cyl, %d head, %d sec, " 585 "%d bytes/sect x %"PRIu64" sectors\n", 586 tbuf, sc->sc_ncylinders, sc->sc_nheads, 587 sc->sc_nsectors, sc->sc_secsize, sc->sc_secperunit); 588 589 memset(dg, 0, sizeof(*dg)); 590 dg->dg_secperunit = sc->sc_secperunit; 591 dg->dg_secsize = sc->sc_secsize; 592 dg->dg_nsectors = sc->sc_nsectors; 593 dg->dg_ntracks = sc->sc_nheads; 594 dg->dg_ncylinders = sc->sc_ncylinders; 595 596 disk_set_info(dksc->sc_dev, &dksc->sc_dkdev, sc->sc_typename); 597 } 598 599 static void 600 ld_config_interrupts(device_t d) 601 { 602 struct ld_softc *sc = device_private(d); 603 struct dk_softc *dksc = &sc->sc_dksc; 604 605 dkwedge_discover(&dksc->sc_dkdev); 606 } 607 608 static int 609 ld_discard(device_t dev, off_t pos, off_t len) 610 { 611 struct ld_softc *sc = device_private(dev); 612 struct buf dbuf, *bp = &dbuf; 613 int error = 0; 614 615 KASSERT(len <= INT_MAX); 616 617 if (sc->sc_discard == NULL) 618 return (ENODEV); 619 620 if ((sc->sc_flags & LDF_MPSAFE) == 0) 621 KERNEL_LOCK(1, curlwp); 622 623 buf_init(bp); 624 bp->b_vp = NULL; 625 bp->b_data = NULL; 626 bp->b_bufsize = 0; 627 bp->b_rawblkno = pos / sc->sc_secsize; 628 bp->b_bcount = len; 629 bp->b_flags = B_WRITE; 630 bp->b_cflags = BC_BUSY; 631 632 error = (*sc->sc_discard)(sc, bp); 633 if (error == 0) 634 error = biowait(bp); 635 636 buf_destroy(bp); 637 638 if ((sc->sc_flags & LDF_MPSAFE) == 0) 639 KERNEL_UNLOCK_ONE(curlwp); 640 641 return error; 642 } 643 644 void 645 lddiscardend(struct ld_softc *sc, struct buf *bp) 646 { 647 648 if (bp->b_error) 649 bp->b_resid = bp->b_bcount; 650 biodone(bp); 651 } 652 653 static int 654 lddiscard(dev_t dev, off_t pos, off_t len) 655 { 656 struct ld_softc *sc; 657 struct dk_softc *dksc; 658 int unit; 659 660 unit = DISKUNIT(dev); 661 sc = device_lookup_private(&ld_cd, unit); 662 dksc = &sc->sc_dksc; 663 664 return dk_discard(dksc, dev, pos, len); 665 } 666 667 MODULE(MODULE_CLASS_DRIVER, ld, "dk_subr"); 668 669 #ifdef _MODULE 670 CFDRIVER_DECL(ld, DV_DISK, NULL); 671 #endif 672 673 static int 674 ld_modcmd(modcmd_t cmd, void *opaque) 675 { 676 #ifdef _MODULE 677 devmajor_t bmajor, cmajor; 678 #endif 679 int error = 0; 680 681 #ifdef _MODULE 682 switch (cmd) { 683 case MODULE_CMD_INIT: 684 bmajor = cmajor = -1; 685 error = devsw_attach(ld_cd.cd_name, &ld_bdevsw, &bmajor, 686 &ld_cdevsw, &cmajor); 687 if (error) 688 break; 689 error = config_cfdriver_attach(&ld_cd); 690 break; 691 case MODULE_CMD_FINI: 692 error = config_cfdriver_detach(&ld_cd); 693 if (error) 694 break; 695 devsw_detach(&ld_bdevsw, &ld_cdevsw); 696 break; 697 default: 698 error = ENOTTY; 699 break; 700 } 701 #endif 702 703 return error; 704 } 705
Indexes created Wed Sep 24 05:09:52 GMT 2025