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