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