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