1 /*- 2 * SPDX-License-Identifier: (BSD-2-Clause AND BSD-3-Clause) 3 * 4 * Copyright (c) 2003 Poul-Henning Kamp. 5 * Copyright (c) 1996, 1997 The NetBSD Foundation, Inc. 6 * All rights reserved. 7 * 8 * This code is derived from software contributed to The NetBSD Foundation 9 * by Jason R. Thorpe. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30 * POSSIBILITY OF SUCH DAMAGE. 31 * 32 * $NetBSD: ccd.c,v 1.22 1995/12/08 19:13:26 thorpej Exp $ 33 */ 34 35 /*- 36 * Copyright (c) 1988 University of Utah. 37 * Copyright (c) 1990, 1993 38 * The Regents of the University of California. All rights reserved. 39 * 40 * This code is derived from software contributed to Berkeley by 41 * the Systems Programming Group of the University of Utah Computer 42 * Science Department. 43 * 44 * Redistribution and use in source and binary forms, with or without 45 * modification, are permitted provided that the following conditions 46 * are met: 47 * 1. Redistributions of source code must retain the above copyright 48 * notice, this list of conditions and the following disclaimer. 49 * 2. Redistributions in binary form must reproduce the above copyright 50 * notice, this list of conditions and the following disclaimer in the 51 * documentation and/or other materials provided with the distribution. 52 * 3. Neither the name of the University nor the names of its contributors 53 * may be used to endorse or promote products derived from this software 54 * without specific prior written permission. 55 * 56 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 57 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 58 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 59 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 60 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 61 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 62 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 63 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 64 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 65 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 66 * SUCH DAMAGE. 67 * 68 * from: Utah $Hdr: cd.c 1.6 90/11/28$ 69 */ 70 71 /* 72 * Dynamic configuration and disklabel support by: 73 * Jason R. Thorpe <thorpej@nas.nasa.gov> 74 * Numerical Aerodynamic Simulation Facility 75 * Mail Stop 258-6 76 * NASA Ames Research Center 77 * Moffett Field, CA 94035 78 */ 79 80 #include <sys/param.h> 81 #include <sys/systm.h> 82 #include <sys/kernel.h> 83 #include <sys/module.h> 84 #include <sys/bio.h> 85 #include <sys/malloc.h> 86 #include <sys/sbuf.h> 87 #include <geom/geom.h> 88 89 /* 90 * Number of blocks to untouched in front of a component partition. 91 * This is to avoid violating its disklabel area when it starts at the 92 * beginning of the slice. 93 */ 94 #if !defined(CCD_OFFSET) 95 #define CCD_OFFSET 16 96 #endif 97 98 /* sc_flags */ 99 #define CCDF_UNIFORM 0x02 /* use LCCD of sizes for uniform interleave */ 100 #define CCDF_MIRROR 0x04 /* use mirroring */ 101 #define CCDF_NO_OFFSET 0x08 /* do not leave space in front */ 102 #define CCDF_LINUX 0x10 /* use Linux compatibility mode */ 103 104 /* Mask of user-settable ccd flags. */ 105 #define CCDF_USERMASK (CCDF_UNIFORM|CCDF_MIRROR) 106 107 /* 108 * Interleave description table. 109 * Computed at boot time to speed irregular-interleave lookups. 110 * The idea is that we interleave in "groups". First we interleave 111 * evenly over all component disks up to the size of the smallest 112 * component (the first group), then we interleave evenly over all 113 * remaining disks up to the size of the next-smallest (second group), 114 * and so on. 115 * 116 * Each table entry describes the interleave characteristics of one 117 * of these groups. For example if a concatenated disk consisted of 118 * three components of 5, 3, and 7 DEV_BSIZE blocks interleaved at 119 * DEV_BSIZE (1), the table would have three entries: 120 * 121 * ndisk startblk startoff dev 122 * 3 0 0 0, 1, 2 123 * 2 9 3 0, 2 124 * 1 13 5 2 125 * 0 - - - 126 * 127 * which says that the first nine blocks (0-8) are interleaved over 128 * 3 disks (0, 1, 2) starting at block offset 0 on any component disk, 129 * the next 4 blocks (9-12) are interleaved over 2 disks (0, 2) starting 130 * at component block 3, and the remaining blocks (13-14) are on disk 131 * 2 starting at offset 5. 132 */ 133 struct ccdiinfo { 134 int ii_ndisk; /* # of disks range is interleaved over */ 135 daddr_t ii_startblk; /* starting scaled block # for range */ 136 daddr_t ii_startoff; /* starting component offset (block #) */ 137 int *ii_index; /* ordered list of components in range */ 138 }; 139 140 /* 141 * Component info table. 142 * Describes a single component of a concatenated disk. 143 */ 144 struct ccdcinfo { 145 daddr_t ci_size; /* size */ 146 struct g_provider *ci_provider; /* provider */ 147 struct g_consumer *ci_consumer; /* consumer */ 148 }; 149 150 /* 151 * A concatenated disk is described by this structure. 152 */ 153 154 struct ccd_s { 155 LIST_ENTRY(ccd_s) list; 156 157 int sc_unit; /* logical unit number */ 158 int sc_flags; /* flags */ 159 daddr_t sc_size; /* size of ccd */ 160 int sc_ileave; /* interleave */ 161 u_int sc_ndisks; /* number of components */ 162 struct ccdcinfo *sc_cinfo; /* component info */ 163 struct ccdiinfo *sc_itable; /* interleave table */ 164 uint32_t sc_secsize; /* # bytes per sector */ 165 int sc_pick; /* side of mirror picked */ 166 daddr_t sc_blk[2]; /* mirror localization */ 167 uint32_t sc_offset; /* actual offset used */ 168 }; 169 170 static g_start_t g_ccd_start; 171 static void ccdiodone(struct bio *bp); 172 static void ccdinterleave(struct ccd_s *); 173 static int ccdinit(struct gctl_req *req, struct ccd_s *); 174 static int ccdbuffer(struct bio **ret, struct ccd_s *, 175 struct bio *, daddr_t, caddr_t, long); 176 177 static void 178 g_ccd_orphan(struct g_consumer *cp) 179 { 180 /* 181 * XXX: We don't do anything here. It is not obvious 182 * XXX: what DTRT would be, so we do what the previous 183 * XXX: code did: ignore it and let the user cope. 184 */ 185 } 186 187 static int 188 g_ccd_access(struct g_provider *pp, int dr, int dw, int de) 189 { 190 struct g_geom *gp; 191 struct g_consumer *cp1, *cp2; 192 int error; 193 194 de += dr; 195 de += dw; 196 197 gp = pp->geom; 198 error = ENXIO; 199 LIST_FOREACH(cp1, &gp->consumer, consumer) { 200 error = g_access(cp1, dr, dw, de); 201 if (error) { 202 LIST_FOREACH(cp2, &gp->consumer, consumer) { 203 if (cp1 == cp2) 204 break; 205 g_access(cp2, -dr, -dw, -de); 206 } 207 break; 208 } 209 } 210 return (error); 211 } 212 213 /* 214 * Free the softc and its substructures. 215 */ 216 static void 217 g_ccd_freesc(struct ccd_s *sc) 218 { 219 struct ccdiinfo *ii; 220 221 g_free(sc->sc_cinfo); 222 if (sc->sc_itable != NULL) { 223 for (ii = sc->sc_itable; ii->ii_ndisk > 0; ii++) 224 g_free(ii->ii_index); 225 g_free(sc->sc_itable); 226 } 227 g_free(sc); 228 } 229 230 static int 231 ccdinit(struct gctl_req *req, struct ccd_s *cs) 232 { 233 struct ccdcinfo *ci; 234 daddr_t size; 235 int ix; 236 daddr_t minsize; 237 int maxsecsize; 238 off_t mediasize; 239 u_int sectorsize; 240 241 cs->sc_size = 0; 242 243 maxsecsize = 0; 244 minsize = 0; 245 246 if (cs->sc_flags & CCDF_LINUX) { 247 cs->sc_offset = 0; 248 cs->sc_ileave *= 2; 249 if (cs->sc_flags & CCDF_MIRROR && cs->sc_ndisks != 2) 250 gctl_error(req, "Mirror mode for Linux raids is " 251 "only supported with 2 devices"); 252 } else { 253 if (cs->sc_flags & CCDF_NO_OFFSET) 254 cs->sc_offset = 0; 255 else 256 cs->sc_offset = CCD_OFFSET; 257 } 258 for (ix = 0; ix < cs->sc_ndisks; ix++) { 259 ci = &cs->sc_cinfo[ix]; 260 261 mediasize = ci->ci_provider->mediasize; 262 sectorsize = ci->ci_provider->sectorsize; 263 if (sectorsize > maxsecsize) 264 maxsecsize = sectorsize; 265 size = mediasize / DEV_BSIZE - cs->sc_offset; 266 267 /* Truncate to interleave boundary */ 268 269 if (cs->sc_ileave > 1) 270 size -= size % cs->sc_ileave; 271 272 if (size == 0) { 273 gctl_error(req, "Component %s has effective size zero", 274 ci->ci_provider->name); 275 return(ENODEV); 276 } 277 278 if (minsize == 0 || size < minsize) 279 minsize = size; 280 ci->ci_size = size; 281 cs->sc_size += size; 282 } 283 284 /* 285 * Don't allow the interleave to be smaller than 286 * the biggest component sector. 287 */ 288 if ((cs->sc_ileave > 0) && 289 (cs->sc_ileave < (maxsecsize / DEV_BSIZE))) { 290 gctl_error(req, "Interleave to small for sector size"); 291 return(EINVAL); 292 } 293 294 /* 295 * If uniform interleave is desired set all sizes to that of 296 * the smallest component. This will guarantee that a single 297 * interleave table is generated. 298 * 299 * Lost space must be taken into account when calculating the 300 * overall size. Half the space is lost when CCDF_MIRROR is 301 * specified. 302 */ 303 if (cs->sc_flags & CCDF_UNIFORM) { 304 for (ix = 0; ix < cs->sc_ndisks; ix++) { 305 ci = &cs->sc_cinfo[ix]; 306 ci->ci_size = minsize; 307 } 308 cs->sc_size = cs->sc_ndisks * minsize; 309 } 310 311 if (cs->sc_flags & CCDF_MIRROR) { 312 /* 313 * Check to see if an even number of components 314 * have been specified. The interleave must also 315 * be non-zero in order for us to be able to 316 * guarantee the topology. 317 */ 318 if (cs->sc_ndisks % 2) { 319 gctl_error(req, 320 "Mirroring requires an even number of disks"); 321 return(EINVAL); 322 } 323 if (cs->sc_ileave == 0) { 324 gctl_error(req, 325 "An interleave must be specified when mirroring"); 326 return(EINVAL); 327 } 328 cs->sc_size = (cs->sc_ndisks/2) * minsize; 329 } 330 331 /* 332 * Construct the interleave table. 333 */ 334 ccdinterleave(cs); 335 336 /* 337 * Create pseudo-geometry based on 1MB cylinders. It's 338 * pretty close. 339 */ 340 cs->sc_secsize = maxsecsize; 341 342 return (0); 343 } 344 345 static void 346 ccdinterleave(struct ccd_s *cs) 347 { 348 struct ccdcinfo *ci, *smallci; 349 struct ccdiinfo *ii; 350 daddr_t bn, lbn; 351 int ix; 352 daddr_t size; 353 354 /* 355 * Allocate an interleave table. The worst case occurs when each 356 * of N disks is of a different size, resulting in N interleave 357 * tables. 358 * 359 * Chances are this is too big, but we don't care. 360 */ 361 size = (cs->sc_ndisks + 1) * sizeof(struct ccdiinfo); 362 cs->sc_itable = g_malloc(size, M_WAITOK | M_ZERO); 363 364 /* 365 * Trivial case: no interleave (actually interleave of disk size). 366 * Each table entry represents a single component in its entirety. 367 * 368 * An interleave of 0 may not be used with a mirror setup. 369 */ 370 if (cs->sc_ileave == 0) { 371 bn = 0; 372 ii = cs->sc_itable; 373 374 for (ix = 0; ix < cs->sc_ndisks; ix++) { 375 /* Allocate space for ii_index. */ 376 ii->ii_index = g_malloc(sizeof(int), M_WAITOK); 377 ii->ii_ndisk = 1; 378 ii->ii_startblk = bn; 379 ii->ii_startoff = 0; 380 ii->ii_index[0] = ix; 381 bn += cs->sc_cinfo[ix].ci_size; 382 ii++; 383 } 384 ii->ii_ndisk = 0; 385 return; 386 } 387 388 /* 389 * The following isn't fast or pretty; it doesn't have to be. 390 */ 391 size = 0; 392 bn = lbn = 0; 393 for (ii = cs->sc_itable; ; ii++) { 394 /* 395 * Allocate space for ii_index. We might allocate more then 396 * we use. 397 */ 398 ii->ii_index = g_malloc((sizeof(int) * cs->sc_ndisks), 399 M_WAITOK); 400 401 /* 402 * Locate the smallest of the remaining components 403 */ 404 smallci = NULL; 405 for (ci = cs->sc_cinfo; ci < &cs->sc_cinfo[cs->sc_ndisks]; 406 ci++) { 407 if (ci->ci_size > size && 408 (smallci == NULL || 409 ci->ci_size < smallci->ci_size)) { 410 smallci = ci; 411 } 412 } 413 414 /* 415 * Nobody left, all done 416 */ 417 if (smallci == NULL) { 418 ii->ii_ndisk = 0; 419 g_free(ii->ii_index); 420 ii->ii_index = NULL; 421 break; 422 } 423 424 /* 425 * Record starting logical block using an sc_ileave blocksize. 426 */ 427 ii->ii_startblk = bn / cs->sc_ileave; 428 429 /* 430 * Record starting component block using an sc_ileave 431 * blocksize. This value is relative to the beginning of 432 * a component disk. 433 */ 434 ii->ii_startoff = lbn; 435 436 /* 437 * Determine how many disks take part in this interleave 438 * and record their indices. 439 */ 440 ix = 0; 441 for (ci = cs->sc_cinfo; 442 ci < &cs->sc_cinfo[cs->sc_ndisks]; ci++) { 443 if (ci->ci_size >= smallci->ci_size) { 444 ii->ii_index[ix++] = ci - cs->sc_cinfo; 445 } 446 } 447 ii->ii_ndisk = ix; 448 bn += ix * (smallci->ci_size - size); 449 lbn = smallci->ci_size / cs->sc_ileave; 450 size = smallci->ci_size; 451 } 452 } 453 454 static void 455 g_ccd_start(struct bio *bp) 456 { 457 long bcount, rcount; 458 struct bio *cbp[2]; 459 caddr_t addr; 460 daddr_t bn; 461 int err; 462 struct ccd_s *cs; 463 464 cs = bp->bio_to->geom->softc; 465 466 /* 467 * Block all GETATTR requests, we wouldn't know which of our 468 * subdevices we should ship it off to. 469 * XXX: this may not be the right policy. 470 */ 471 if(bp->bio_cmd == BIO_GETATTR) { 472 g_io_deliver(bp, EINVAL); 473 return; 474 } 475 476 /* 477 * Translate the partition-relative block number to an absolute. 478 */ 479 bn = bp->bio_offset / cs->sc_secsize; 480 481 /* 482 * Allocate component buffers and fire off the requests 483 */ 484 addr = bp->bio_data; 485 for (bcount = bp->bio_length; bcount > 0; bcount -= rcount) { 486 err = ccdbuffer(cbp, cs, bp, bn, addr, bcount); 487 if (err) { 488 bp->bio_completed += bcount; 489 if (bp->bio_error == 0) 490 bp->bio_error = err; 491 if (bp->bio_completed == bp->bio_length) 492 g_io_deliver(bp, bp->bio_error); 493 return; 494 } 495 rcount = cbp[0]->bio_length; 496 497 if (cs->sc_flags & CCDF_MIRROR) { 498 /* 499 * Mirroring. Writes go to both disks, reads are 500 * taken from whichever disk seems most appropriate. 501 * 502 * We attempt to localize reads to the disk whos arm 503 * is nearest the read request. We ignore seeks due 504 * to writes when making this determination and we 505 * also try to avoid hogging. 506 */ 507 if (cbp[0]->bio_cmd != BIO_READ) { 508 g_io_request(cbp[0], cbp[0]->bio_from); 509 g_io_request(cbp[1], cbp[1]->bio_from); 510 } else { 511 int pick = cs->sc_pick; 512 daddr_t range = cs->sc_size / 16; 513 514 if (bn < cs->sc_blk[pick] - range || 515 bn > cs->sc_blk[pick] + range 516 ) { 517 cs->sc_pick = pick = 1 - pick; 518 } 519 cs->sc_blk[pick] = bn + btodb(rcount); 520 g_io_request(cbp[pick], cbp[pick]->bio_from); 521 } 522 } else { 523 /* 524 * Not mirroring 525 */ 526 g_io_request(cbp[0], cbp[0]->bio_from); 527 } 528 bn += btodb(rcount); 529 addr += rcount; 530 } 531 } 532 533 /* 534 * Build a component buffer header. 535 */ 536 static int 537 ccdbuffer(struct bio **cb, struct ccd_s *cs, struct bio *bp, daddr_t bn, caddr_t addr, long bcount) 538 { 539 struct ccdcinfo *ci, *ci2 = NULL; 540 struct bio *cbp; 541 daddr_t cbn, cboff; 542 off_t cbc; 543 544 /* 545 * Determine which component bn falls in. 546 */ 547 cbn = bn; 548 cboff = 0; 549 550 if (cs->sc_ileave == 0) { 551 /* 552 * Serially concatenated and neither a mirror nor a parity 553 * config. This is a special case. 554 */ 555 daddr_t sblk; 556 557 sblk = 0; 558 for (ci = cs->sc_cinfo; cbn >= sblk + ci->ci_size; ci++) 559 sblk += ci->ci_size; 560 cbn -= sblk; 561 } else { 562 struct ccdiinfo *ii; 563 int ccdisk, off; 564 565 /* 566 * Calculate cbn, the logical superblock (sc_ileave chunks), 567 * and cboff, a normal block offset (DEV_BSIZE chunks) relative 568 * to cbn. 569 */ 570 cboff = cbn % cs->sc_ileave; /* DEV_BSIZE gran */ 571 cbn = cbn / cs->sc_ileave; /* DEV_BSIZE * ileave gran */ 572 573 /* 574 * Figure out which interleave table to use. 575 */ 576 for (ii = cs->sc_itable; ii->ii_ndisk; ii++) { 577 if (ii->ii_startblk > cbn) 578 break; 579 } 580 ii--; 581 582 /* 583 * off is the logical superblock relative to the beginning 584 * of this interleave block. 585 */ 586 off = cbn - ii->ii_startblk; 587 588 /* 589 * We must calculate which disk component to use (ccdisk), 590 * and recalculate cbn to be the superblock relative to 591 * the beginning of the component. This is typically done by 592 * adding 'off' and ii->ii_startoff together. However, 'off' 593 * must typically be divided by the number of components in 594 * this interleave array to be properly convert it from a 595 * CCD-relative logical superblock number to a 596 * component-relative superblock number. 597 */ 598 if (ii->ii_ndisk == 1) { 599 /* 600 * When we have just one disk, it can't be a mirror 601 * or a parity config. 602 */ 603 ccdisk = ii->ii_index[0]; 604 cbn = ii->ii_startoff + off; 605 } else { 606 if (cs->sc_flags & CCDF_MIRROR) { 607 /* 608 * We have forced a uniform mapping, resulting 609 * in a single interleave array. We double 610 * up on the first half of the available 611 * components and our mirror is in the second 612 * half. This only works with a single 613 * interleave array because doubling up 614 * doubles the number of sectors, so there 615 * cannot be another interleave array because 616 * the next interleave array's calculations 617 * would be off. 618 */ 619 int ndisk2 = ii->ii_ndisk / 2; 620 ccdisk = ii->ii_index[off % ndisk2]; 621 cbn = ii->ii_startoff + off / ndisk2; 622 ci2 = &cs->sc_cinfo[ccdisk + ndisk2]; 623 } else { 624 ccdisk = ii->ii_index[off % ii->ii_ndisk]; 625 cbn = ii->ii_startoff + off / ii->ii_ndisk; 626 } 627 } 628 629 ci = &cs->sc_cinfo[ccdisk]; 630 631 /* 632 * Convert cbn from a superblock to a normal block so it 633 * can be used to calculate (along with cboff) the normal 634 * block index into this particular disk. 635 */ 636 cbn *= cs->sc_ileave; 637 } 638 639 /* 640 * Fill in the component buf structure. 641 */ 642 cbp = g_clone_bio(bp); 643 if (cbp == NULL) 644 return (ENOMEM); 645 cbp->bio_done = g_std_done; 646 cbp->bio_offset = dbtob(cbn + cboff + cs->sc_offset); 647 cbp->bio_data = addr; 648 if (cs->sc_ileave == 0) 649 cbc = dbtob((off_t)(ci->ci_size - cbn)); 650 else 651 cbc = dbtob((off_t)(cs->sc_ileave - cboff)); 652 cbp->bio_length = (cbc < bcount) ? cbc : bcount; 653 654 cbp->bio_from = ci->ci_consumer; 655 cb[0] = cbp; 656 657 if (cs->sc_flags & CCDF_MIRROR) { 658 cbp = g_clone_bio(bp); 659 if (cbp == NULL) 660 return (ENOMEM); 661 cbp->bio_done = cb[0]->bio_done = ccdiodone; 662 cbp->bio_offset = cb[0]->bio_offset; 663 cbp->bio_data = cb[0]->bio_data; 664 cbp->bio_length = cb[0]->bio_length; 665 cbp->bio_from = ci2->ci_consumer; 666 cbp->bio_caller1 = cb[0]; 667 cb[0]->bio_caller1 = cbp; 668 cb[1] = cbp; 669 } 670 return (0); 671 } 672 673 /* 674 * Called only for mirrored operations. 675 */ 676 static void 677 ccdiodone(struct bio *cbp) 678 { 679 struct bio *mbp, *pbp; 680 681 mbp = cbp->bio_caller1; 682 pbp = cbp->bio_parent; 683 684 if (pbp->bio_cmd == BIO_READ) { 685 if (cbp->bio_error == 0) { 686 /* We will not be needing the partner bio */ 687 if (mbp != NULL) { 688 pbp->bio_inbed++; 689 g_destroy_bio(mbp); 690 } 691 g_std_done(cbp); 692 return; 693 } 694 if (mbp != NULL) { 695 /* Try partner the bio instead */ 696 mbp->bio_caller1 = NULL; 697 pbp->bio_inbed++; 698 g_destroy_bio(cbp); 699 g_io_request(mbp, mbp->bio_from); 700 /* 701 * XXX: If this comes back OK, we should actually 702 * try to write the good data on the failed mirror 703 */ 704 return; 705 } 706 g_std_done(cbp); 707 return; 708 } 709 if (mbp != NULL) { 710 mbp->bio_caller1 = NULL; 711 pbp->bio_inbed++; 712 if (cbp->bio_error != 0 && pbp->bio_error == 0) 713 pbp->bio_error = cbp->bio_error; 714 g_destroy_bio(cbp); 715 return; 716 } 717 g_std_done(cbp); 718 } 719 720 static void 721 g_ccd_create(struct gctl_req *req, struct g_class *mp) 722 { 723 int *unit, *ileave, *nprovider; 724 struct g_geom *gp; 725 struct g_consumer *cp; 726 struct g_provider *pp; 727 struct ccd_s *sc; 728 struct sbuf *sb; 729 char buf[20]; 730 int i, error; 731 732 g_topology_assert(); 733 unit = gctl_get_paraml(req, "unit", sizeof (*unit)); 734 if (unit == NULL) { 735 gctl_error(req, "unit parameter not given"); 736 return; 737 } 738 ileave = gctl_get_paraml(req, "ileave", sizeof (*ileave)); 739 if (ileave == NULL) { 740 gctl_error(req, "ileave parameter not given"); 741 return; 742 } 743 nprovider = gctl_get_paraml(req, "nprovider", sizeof (*nprovider)); 744 if (nprovider == NULL) { 745 gctl_error(req, "nprovider parameter not given"); 746 return; 747 } 748 749 /* Check for duplicate unit */ 750 LIST_FOREACH(gp, &mp->geom, geom) { 751 sc = gp->softc; 752 if (sc != NULL && sc->sc_unit == *unit) { 753 gctl_error(req, "Unit %d already configured", *unit); 754 return; 755 } 756 } 757 758 if (*nprovider <= 0) { 759 gctl_error(req, "Bogus nprovider argument (= %d)", *nprovider); 760 return; 761 } 762 763 /* Check all providers are valid */ 764 for (i = 0; i < *nprovider; i++) { 765 snprintf(buf, sizeof(buf), "provider%d", i); 766 pp = gctl_get_provider(req, buf); 767 if (pp == NULL) 768 return; 769 } 770 771 gp = g_new_geomf(mp, "ccd%d", *unit); 772 sc = g_malloc(sizeof *sc, M_WAITOK | M_ZERO); 773 gp->softc = sc; 774 sc->sc_ndisks = *nprovider; 775 776 /* Allocate space for the component info. */ 777 sc->sc_cinfo = g_malloc(sc->sc_ndisks * sizeof(struct ccdcinfo), 778 M_WAITOK | M_ZERO); 779 780 /* Create consumers and attach to all providers */ 781 for (i = 0; i < *nprovider; i++) { 782 snprintf(buf, sizeof(buf), "provider%d", i); 783 pp = gctl_get_provider(req, buf); 784 cp = g_new_consumer(gp); 785 error = g_attach(cp, pp); 786 KASSERT(error == 0, ("attach to %s failed", pp->name)); 787 sc->sc_cinfo[i].ci_consumer = cp; 788 sc->sc_cinfo[i].ci_provider = pp; 789 } 790 791 sc->sc_unit = *unit; 792 sc->sc_ileave = *ileave; 793 794 if (gctl_get_param(req, "no_offset", NULL)) 795 sc->sc_flags |= CCDF_NO_OFFSET; 796 if (gctl_get_param(req, "linux", NULL)) 797 sc->sc_flags |= CCDF_LINUX; 798 799 if (gctl_get_param(req, "uniform", NULL)) 800 sc->sc_flags |= CCDF_UNIFORM; 801 if (gctl_get_param(req, "mirror", NULL)) 802 sc->sc_flags |= CCDF_MIRROR; 803 804 if (sc->sc_ileave == 0 && (sc->sc_flags & CCDF_MIRROR)) { 805 printf("%s: disabling mirror, interleave is 0\n", gp->name); 806 sc->sc_flags &= ~(CCDF_MIRROR); 807 } 808 809 if ((sc->sc_flags & CCDF_MIRROR) && !(sc->sc_flags & CCDF_UNIFORM)) { 810 printf("%s: mirror/parity forces uniform flag\n", gp->name); 811 sc->sc_flags |= CCDF_UNIFORM; 812 } 813 814 error = ccdinit(req, sc); 815 if (error != 0) { 816 g_ccd_freesc(sc); 817 gp->softc = NULL; 818 g_wither_geom(gp, ENXIO); 819 return; 820 } 821 822 pp = g_new_providerf(gp, "%s", gp->name); 823 pp->mediasize = sc->sc_size * (off_t)sc->sc_secsize; 824 pp->sectorsize = sc->sc_secsize; 825 g_error_provider(pp, 0); 826 827 sb = sbuf_new_auto(); 828 sbuf_printf(sb, "ccd%d: %d components ", sc->sc_unit, *nprovider); 829 for (i = 0; i < *nprovider; i++) { 830 sbuf_printf(sb, "%s%s", 831 i == 0 ? "(" : ", ", 832 sc->sc_cinfo[i].ci_provider->name); 833 } 834 sbuf_printf(sb, "), %jd blocks ", (off_t)pp->mediasize / DEV_BSIZE); 835 if (sc->sc_ileave != 0) 836 sbuf_printf(sb, "interleaved at %d blocks\n", 837 sc->sc_ileave); 838 else 839 sbuf_printf(sb, "concatenated\n"); 840 sbuf_finish(sb); 841 gctl_set_param_err(req, "output", sbuf_data(sb), sbuf_len(sb) + 1); 842 sbuf_delete(sb); 843 } 844 845 static int 846 g_ccd_destroy_geom(struct gctl_req *req, struct g_class *mp, struct g_geom *gp) 847 { 848 struct g_provider *pp; 849 struct ccd_s *sc; 850 851 g_topology_assert(); 852 sc = gp->softc; 853 pp = LIST_FIRST(&gp->provider); 854 if (sc == NULL || pp == NULL) 855 return (EBUSY); 856 if (pp->acr != 0 || pp->acw != 0 || pp->ace != 0) { 857 gctl_error(req, "%s is open(r%dw%de%d)", gp->name, 858 pp->acr, pp->acw, pp->ace); 859 return (EBUSY); 860 } 861 g_ccd_freesc(sc); 862 gp->softc = NULL; 863 g_wither_geom(gp, ENXIO); 864 return (0); 865 } 866 867 static void 868 g_ccd_list(struct gctl_req *req, struct g_class *mp) 869 { 870 struct sbuf *sb; 871 struct ccd_s *cs; 872 struct g_geom *gp; 873 int i, unit, *up; 874 875 up = gctl_get_paraml(req, "unit", sizeof (*up)); 876 if (up == NULL) { 877 gctl_error(req, "unit parameter not given"); 878 return; 879 } 880 unit = *up; 881 sb = sbuf_new_auto(); 882 LIST_FOREACH(gp, &mp->geom, geom) { 883 cs = gp->softc; 884 if (cs == NULL || (unit >= 0 && unit != cs->sc_unit)) 885 continue; 886 sbuf_printf(sb, "ccd%d\t\t%d\t%d\t", 887 cs->sc_unit, cs->sc_ileave, cs->sc_flags & CCDF_USERMASK); 888 889 for (i = 0; i < cs->sc_ndisks; ++i) { 890 sbuf_printf(sb, "%s/dev/%s", i == 0 ? "" : " ", 891 cs->sc_cinfo[i].ci_provider->name); 892 } 893 sbuf_printf(sb, "\n"); 894 } 895 sbuf_finish(sb); 896 gctl_set_param_err(req, "output", sbuf_data(sb), sbuf_len(sb) + 1); 897 sbuf_delete(sb); 898 } 899 900 static void 901 g_ccd_config(struct gctl_req *req, struct g_class *mp, char const *verb) 902 { 903 struct g_geom *gp; 904 905 g_topology_assert(); 906 if (!strcmp(verb, "create geom")) { 907 g_ccd_create(req, mp); 908 } else if (!strcmp(verb, "destroy geom")) { 909 gp = gctl_get_geom(req, mp, "geom"); 910 if (gp != NULL) 911 g_ccd_destroy_geom(req, mp, gp); 912 } else if (!strcmp(verb, "list")) { 913 g_ccd_list(req, mp); 914 } else { 915 gctl_error(req, "unknown verb"); 916 } 917 } 918 919 static struct g_class g_ccd_class = { 920 .name = "CCD", 921 .version = G_VERSION, 922 .ctlreq = g_ccd_config, 923 .destroy_geom = g_ccd_destroy_geom, 924 .start = g_ccd_start, 925 .orphan = g_ccd_orphan, 926 .access = g_ccd_access, 927 }; 928 929 DECLARE_GEOM_CLASS(g_ccd_class, g_ccd); 930 MODULE_VERSION(geom_ccd, 0); 931