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