1 /*- 2 * Copyright (c) 2004, 2007 Lukas Ertl 3 * Copyright (c) 2007, 2009 Ulf Lilleengen 4 * Copyright (c) 1997, 1998, 1999 5 * Nan Yang Computer Services Limited. All rights reserved. 6 * 7 * Parts written by Greg Lehey 8 * 9 * This software is distributed under the so-called ``Berkeley 10 * License'': 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions and the following disclaimer. 17 * 2. Redistributions in binary form must reproduce the above copyright 18 * notice, this list of conditions and the following disclaimer in the 19 * documentation and/or other materials provided with the distribution. 20 * 3. All advertising materials mentioning features or use of this software 21 * must display the following acknowledgement: 22 * This product includes software developed by Nan Yang Computer 23 * Services Limited. 24 * 4. Neither the name of the Company nor the names of its contributors 25 * may be used to endorse or promote products derived from this software 26 * without specific prior written permission. 27 * 28 * This software is provided ``as is'', and any express or implied 29 * warranties, including, but not limited to, the implied warranties of 30 * merchantability and fitness for a particular purpose are disclaimed. 31 * In no event shall the company or contributors be liable for any 32 * direct, indirect, incidental, special, exemplary, or consequential 33 * damages (including, but not limited to, procurement of substitute 34 * goods or services; loss of use, data, or profits; or business 35 * interruption) however caused and on any theory of liability, whether 36 * in contract, strict liability, or tort (including negligence or 37 * otherwise) arising in any way out of the use of this software, even if 38 * advised of the possibility of such damage. 39 * 40 */ 41 42 #include <sys/cdefs.h> 43 __FBSDID("$FreeBSD$"); 44 45 #include <sys/param.h> 46 #include <sys/malloc.h> 47 #include <sys/sbuf.h> 48 #include <sys/systm.h> 49 50 #include <geom/geom.h> 51 #include <geom/vinum/geom_vinum_var.h> 52 #include <geom/vinum/geom_vinum.h> 53 #include <geom/vinum/geom_vinum_share.h> 54 55 int gv_drive_is_newer(struct gv_softc *, struct gv_drive *); 56 static off_t gv_plex_smallest_sd(struct gv_plex *); 57 58 void 59 gv_parse_config(struct gv_softc *sc, char *buf, struct gv_drive *d) 60 { 61 char *aptr, *bptr, *cptr; 62 struct gv_volume *v, *v2; 63 struct gv_plex *p, *p2; 64 struct gv_sd *s, *s2; 65 int error, is_newer, tokens; 66 char *token[GV_MAXARGS]; 67 68 is_newer = gv_drive_is_newer(sc, d); 69 70 /* Until the end of the string *buf. */ 71 for (aptr = buf; *aptr != '\0'; aptr = bptr) { 72 bptr = aptr; 73 cptr = aptr; 74 75 /* Separate input lines. */ 76 while (*bptr != '\n') 77 bptr++; 78 *bptr = '\0'; 79 bptr++; 80 81 tokens = gv_tokenize(cptr, token, GV_MAXARGS); 82 83 if (tokens <= 0) 84 continue; 85 86 if (!strcmp(token[0], "volume")) { 87 v = gv_new_volume(tokens, token); 88 if (v == NULL) { 89 G_VINUM_DEBUG(0, "config parse failed volume"); 90 break; 91 } 92 93 v2 = gv_find_vol(sc, v->name); 94 if (v2 != NULL) { 95 if (is_newer) { 96 v2->state = v->state; 97 G_VINUM_DEBUG(2, "newer volume found!"); 98 } 99 g_free(v); 100 continue; 101 } 102 103 gv_create_volume(sc, v); 104 105 } else if (!strcmp(token[0], "plex")) { 106 p = gv_new_plex(tokens, token); 107 if (p == NULL) { 108 G_VINUM_DEBUG(0, "config parse failed plex"); 109 break; 110 } 111 112 p2 = gv_find_plex(sc, p->name); 113 if (p2 != NULL) { 114 /* XXX */ 115 if (is_newer) { 116 p2->state = p->state; 117 G_VINUM_DEBUG(2, "newer plex found!"); 118 } 119 g_free(p); 120 continue; 121 } 122 123 error = gv_create_plex(sc, p); 124 if (error) 125 continue; 126 /* 127 * These flags were set in gv_create_plex() and are not 128 * needed here (on-disk config parsing). 129 */ 130 p->flags &= ~GV_PLEX_ADDED; 131 132 } else if (!strcmp(token[0], "sd")) { 133 s = gv_new_sd(tokens, token); 134 135 if (s == NULL) { 136 G_VINUM_DEBUG(0, "config parse failed subdisk"); 137 break; 138 } 139 140 s2 = gv_find_sd(sc, s->name); 141 if (s2 != NULL) { 142 /* XXX */ 143 if (is_newer) { 144 s2->state = s->state; 145 G_VINUM_DEBUG(2, "newer subdisk found!"); 146 } 147 g_free(s); 148 continue; 149 } 150 151 /* 152 * Signal that this subdisk was tasted, and could 153 * possibly reference a drive that isn't in our config 154 * yet. 155 */ 156 s->flags |= GV_SD_TASTED; 157 158 if (s->state == GV_SD_UP) 159 s->flags |= GV_SD_CANGOUP; 160 161 error = gv_create_sd(sc, s); 162 if (error) 163 continue; 164 165 /* 166 * This flag was set in gv_create_sd() and is not 167 * needed here (on-disk config parsing). 168 */ 169 s->flags &= ~GV_SD_NEWBORN; 170 s->flags &= ~GV_SD_GROW; 171 } 172 } 173 } 174 175 /* 176 * Format the vinum configuration properly. If ondisk is non-zero then the 177 * configuration is intended to be written to disk later. 178 */ 179 void 180 gv_format_config(struct gv_softc *sc, struct sbuf *sb, int ondisk, char *prefix) 181 { 182 struct gv_drive *d; 183 struct gv_sd *s; 184 struct gv_plex *p; 185 struct gv_volume *v; 186 187 /* 188 * We don't need the drive configuration if we're not writing the 189 * config to disk. 190 */ 191 if (!ondisk) { 192 LIST_FOREACH(d, &sc->drives, drive) { 193 sbuf_printf(sb, "%sdrive %s device /dev/%s\n", prefix, 194 d->name, d->device); 195 } 196 } 197 198 LIST_FOREACH(v, &sc->volumes, volume) { 199 if (!ondisk) 200 sbuf_printf(sb, "%s", prefix); 201 sbuf_printf(sb, "volume %s", v->name); 202 if (ondisk) 203 sbuf_printf(sb, " state %s", gv_volstate(v->state)); 204 sbuf_printf(sb, "\n"); 205 } 206 207 LIST_FOREACH(p, &sc->plexes, plex) { 208 if (!ondisk) 209 sbuf_printf(sb, "%s", prefix); 210 sbuf_printf(sb, "plex name %s org %s ", p->name, 211 gv_plexorg(p->org)); 212 if (gv_is_striped(p)) 213 sbuf_printf(sb, "%ds ", p->stripesize / 512); 214 if (p->vol_sc != NULL) 215 sbuf_printf(sb, "vol %s", p->volume); 216 if (ondisk) 217 sbuf_printf(sb, " state %s", gv_plexstate(p->state)); 218 sbuf_printf(sb, "\n"); 219 } 220 221 LIST_FOREACH(s, &sc->subdisks, sd) { 222 if (!ondisk) 223 sbuf_printf(sb, "%s", prefix); 224 sbuf_printf(sb, "sd name %s drive %s len %jds driveoffset " 225 "%jds", s->name, s->drive, s->size / 512, 226 s->drive_offset / 512); 227 if (s->plex_sc != NULL) { 228 sbuf_printf(sb, " plex %s plexoffset %jds", s->plex, 229 s->plex_offset / 512); 230 } 231 if (ondisk) 232 sbuf_printf(sb, " state %s", gv_sdstate(s->state)); 233 sbuf_printf(sb, "\n"); 234 } 235 } 236 237 static off_t 238 gv_plex_smallest_sd(struct gv_plex *p) 239 { 240 struct gv_sd *s; 241 off_t smallest; 242 243 KASSERT(p != NULL, ("gv_plex_smallest_sd: NULL p")); 244 245 s = LIST_FIRST(&p->subdisks); 246 if (s == NULL) 247 return (-1); 248 smallest = s->size; 249 LIST_FOREACH(s, &p->subdisks, in_plex) { 250 if (s->size < smallest) 251 smallest = s->size; 252 } 253 return (smallest); 254 } 255 256 /* Walk over plexes in a volume and count how many are down. */ 257 int 258 gv_plexdown(struct gv_volume *v) 259 { 260 int plexdown; 261 struct gv_plex *p; 262 263 KASSERT(v != NULL, ("gv_plexdown: NULL v")); 264 265 plexdown = 0; 266 267 LIST_FOREACH(p, &v->plexes, plex) { 268 if (p->state == GV_PLEX_DOWN) 269 plexdown++; 270 } 271 return (plexdown); 272 } 273 274 int 275 gv_sd_to_plex(struct gv_sd *s, struct gv_plex *p) 276 { 277 struct gv_sd *s2; 278 off_t psizeorig, remainder, smallest; 279 280 /* If this subdisk was already given to this plex, do nothing. */ 281 if (s->plex_sc == p) 282 return (0); 283 284 /* Check correct size of this subdisk. */ 285 s2 = LIST_FIRST(&p->subdisks); 286 /* Adjust the subdisk-size if necessary. */ 287 if (s2 != NULL && gv_is_striped(p)) { 288 /* First adjust to the stripesize. */ 289 remainder = s->size % p->stripesize; 290 291 if (remainder) { 292 G_VINUM_DEBUG(1, "size of sd %s is not a " 293 "multiple of plex stripesize, taking off " 294 "%jd bytes", s->name, 295 (intmax_t)remainder); 296 gv_adjust_freespace(s, remainder); 297 } 298 299 smallest = gv_plex_smallest_sd(p); 300 /* Then take off extra if other subdisks are smaller. */ 301 remainder = s->size - smallest; 302 303 /* 304 * Don't allow a remainder below zero for running plexes, it's too 305 * painful, and if someone were to accidentally do this, the 306 * resulting array might be smaller than the original... not god 307 */ 308 if (remainder < 0) { 309 if (!(p->flags & GV_PLEX_NEWBORN)) { 310 G_VINUM_DEBUG(0, "sd %s too small for plex %s!", 311 s->name, p->name); 312 return (GV_ERR_BADSIZE); 313 } 314 /* Adjust other subdisks. */ 315 LIST_FOREACH(s2, &p->subdisks, in_plex) { 316 G_VINUM_DEBUG(1, "size of sd %s is to big, " 317 "taking off %jd bytes", s->name, 318 (intmax_t)remainder); 319 gv_adjust_freespace(s2, (remainder * -1)); 320 } 321 } else if (remainder > 0) { 322 G_VINUM_DEBUG(1, "size of sd %s is to big, " 323 "taking off %jd bytes", s->name, 324 (intmax_t)remainder); 325 gv_adjust_freespace(s, remainder); 326 } 327 } 328 329 /* Find the correct plex offset for this subdisk, if needed. */ 330 if (s->plex_offset == -1) { 331 /* 332 * First set it to 0 to catch the case where we had a detached 333 * subdisk that didn't get any good offset. 334 */ 335 s->plex_offset = 0; 336 if (p->sdcount) { 337 LIST_FOREACH(s2, &p->subdisks, in_plex) { 338 if (gv_is_striped(p)) 339 s->plex_offset = p->sdcount * 340 p->stripesize; 341 else 342 s->plex_offset = s2->plex_offset + 343 s2->size; 344 } 345 } 346 } 347 348 /* There are no subdisks for this plex yet, just insert it. */ 349 if (LIST_EMPTY(&p->subdisks)) { 350 LIST_INSERT_HEAD(&p->subdisks, s, in_plex); 351 352 /* Insert in correct order, depending on plex_offset. */ 353 } else { 354 LIST_FOREACH(s2, &p->subdisks, in_plex) { 355 if (s->plex_offset < s2->plex_offset) { 356 LIST_INSERT_BEFORE(s2, s, in_plex); 357 break; 358 } else if (LIST_NEXT(s2, in_plex) == NULL) { 359 LIST_INSERT_AFTER(s2, s, in_plex); 360 break; 361 } 362 } 363 } 364 365 s->plex_sc = p; 366 /* Adjust the size of our plex. We check if the plex misses a subdisk, 367 * so we don't make the plex smaller than it actually should be. 368 */ 369 psizeorig = p->size; 370 p->size = gv_plex_size(p); 371 /* Make sure the size is not changed. */ 372 if (p->sddetached > 0) { 373 if (p->size < psizeorig) { 374 p->size = psizeorig; 375 /* We make sure wee need another subdisk. */ 376 if (p->sddetached == 1) 377 p->sddetached++; 378 } 379 p->sddetached--; 380 } else { 381 if ((p->org == GV_PLEX_RAID5 || 382 p->org == GV_PLEX_STRIPED) && 383 !(p->flags & GV_PLEX_NEWBORN) && 384 p->state == GV_PLEX_UP) { 385 s->flags |= GV_SD_GROW; 386 } 387 p->sdcount++; 388 } 389 390 return (0); 391 } 392 393 void 394 gv_update_vol_size(struct gv_volume *v, off_t size) 395 { 396 if (v == NULL) 397 return; 398 if (v->provider != NULL) { 399 g_topology_lock(); 400 v->provider->mediasize = size; 401 g_topology_unlock(); 402 } 403 v->size = size; 404 } 405 406 /* Return how many subdisks that constitute the original plex. */ 407 int 408 gv_sdcount(struct gv_plex *p, int growing) 409 { 410 struct gv_sd *s; 411 int sdcount; 412 413 sdcount = p->sdcount; 414 if (growing) { 415 LIST_FOREACH(s, &p->subdisks, in_plex) { 416 if (s->flags & GV_SD_GROW) 417 sdcount--; 418 } 419 } 420 421 return (sdcount); 422 } 423 424 /* Calculates the plex size. */ 425 off_t 426 gv_plex_size(struct gv_plex *p) 427 { 428 struct gv_sd *s; 429 off_t size; 430 int sdcount; 431 432 KASSERT(p != NULL, ("gv_plex_size: NULL p")); 433 434 /* Adjust the size of our plex. */ 435 size = 0; 436 sdcount = gv_sdcount(p, 1); 437 switch (p->org) { 438 case GV_PLEX_CONCAT: 439 LIST_FOREACH(s, &p->subdisks, in_plex) 440 size += s->size; 441 break; 442 case GV_PLEX_STRIPED: 443 s = LIST_FIRST(&p->subdisks); 444 size = ((s != NULL) ? (sdcount * s->size) : 0); 445 break; 446 case GV_PLEX_RAID5: 447 s = LIST_FIRST(&p->subdisks); 448 size = ((s != NULL) ? ((sdcount - 1) * s->size) : 0); 449 break; 450 } 451 452 return (size); 453 } 454 455 /* Returns the size of a volume. */ 456 off_t 457 gv_vol_size(struct gv_volume *v) 458 { 459 struct gv_plex *p; 460 off_t minplexsize; 461 462 KASSERT(v != NULL, ("gv_vol_size: NULL v")); 463 464 p = LIST_FIRST(&v->plexes); 465 if (p == NULL) 466 return (0); 467 468 minplexsize = p->size; 469 LIST_FOREACH(p, &v->plexes, in_volume) { 470 if (p->size < minplexsize) { 471 minplexsize = p->size; 472 } 473 } 474 return (minplexsize); 475 } 476 477 void 478 gv_update_plex_config(struct gv_plex *p) 479 { 480 struct gv_sd *s, *s2; 481 off_t remainder; 482 int required_sds, state; 483 484 KASSERT(p != NULL, ("gv_update_plex_config: NULL p")); 485 486 /* The plex was added to an already running volume. */ 487 if (p->flags & GV_PLEX_ADDED) 488 gv_set_plex_state(p, GV_PLEX_DOWN, GV_SETSTATE_FORCE); 489 490 switch (p->org) { 491 case GV_PLEX_STRIPED: 492 required_sds = 2; 493 break; 494 case GV_PLEX_RAID5: 495 required_sds = 3; 496 break; 497 case GV_PLEX_CONCAT: 498 default: 499 required_sds = 0; 500 break; 501 } 502 503 if (required_sds) { 504 if (p->sdcount < required_sds) { 505 gv_set_plex_state(p, GV_PLEX_DOWN, GV_SETSTATE_FORCE); 506 } 507 508 /* 509 * The subdisks in striped plexes must all have the same size. 510 */ 511 s = LIST_FIRST(&p->subdisks); 512 LIST_FOREACH(s2, &p->subdisks, in_plex) { 513 if (s->size != s2->size) { 514 G_VINUM_DEBUG(0, "subdisk size mismatch %s" 515 "(%jd) <> %s (%jd)", s->name, s->size, 516 s2->name, s2->size); 517 gv_set_plex_state(p, GV_PLEX_DOWN, 518 GV_SETSTATE_FORCE); 519 } 520 } 521 522 LIST_FOREACH(s, &p->subdisks, in_plex) { 523 /* Trim subdisk sizes to match the stripe size. */ 524 remainder = s->size % p->stripesize; 525 if (remainder) { 526 G_VINUM_DEBUG(1, "size of sd %s is not a " 527 "multiple of plex stripesize, taking off " 528 "%jd bytes", s->name, (intmax_t)remainder); 529 gv_adjust_freespace(s, remainder); 530 } 531 } 532 } 533 534 p->size = gv_plex_size(p); 535 if (p->sdcount == 0) 536 gv_set_plex_state(p, GV_PLEX_DOWN, GV_SETSTATE_FORCE); 537 else if (p->org == GV_PLEX_RAID5 && p->flags & GV_PLEX_NEWBORN) { 538 LIST_FOREACH(s, &p->subdisks, in_plex) 539 gv_set_sd_state(s, GV_SD_UP, GV_SETSTATE_FORCE); 540 /* If added to a volume, we want the plex to be down. */ 541 state = (p->flags & GV_PLEX_ADDED) ? GV_PLEX_DOWN : GV_PLEX_UP; 542 gv_set_plex_state(p, state, GV_SETSTATE_FORCE); 543 p->flags &= ~GV_PLEX_ADDED; 544 } else if (p->flags & GV_PLEX_ADDED) { 545 LIST_FOREACH(s, &p->subdisks, in_plex) 546 gv_set_sd_state(s, GV_SD_STALE, GV_SETSTATE_FORCE); 547 gv_set_plex_state(p, GV_PLEX_DOWN, GV_SETSTATE_FORCE); 548 p->flags &= ~GV_PLEX_ADDED; 549 } else if (p->state == GV_PLEX_UP) { 550 LIST_FOREACH(s, &p->subdisks, in_plex) { 551 if (s->flags & GV_SD_GROW) { 552 gv_set_plex_state(p, GV_PLEX_GROWABLE, 553 GV_SETSTATE_FORCE); 554 break; 555 } 556 } 557 } 558 /* Our plex is grown up now. */ 559 p->flags &= ~GV_PLEX_NEWBORN; 560 } 561 562 /* 563 * Give a subdisk to a drive, check and adjust several parameters, adjust 564 * freelist. 565 */ 566 int 567 gv_sd_to_drive(struct gv_sd *s, struct gv_drive *d) 568 { 569 struct gv_sd *s2; 570 struct gv_freelist *fl, *fl2; 571 off_t tmp; 572 int i; 573 574 fl2 = NULL; 575 576 /* Shortcut for "referenced" drives. */ 577 if (d->flags & GV_DRIVE_REFERENCED) { 578 s->drive_sc = d; 579 return (0); 580 } 581 582 /* Check if this subdisk was already given to this drive. */ 583 if (s->drive_sc != NULL) { 584 if (s->drive_sc == d) { 585 if (!(s->flags & GV_SD_TASTED)) { 586 return (0); 587 } 588 } else { 589 G_VINUM_DEBUG(0, "error giving subdisk '%s' to '%s' " 590 "(already on '%s')", s->name, d->name, 591 s->drive_sc->name); 592 return (GV_ERR_ISATTACHED); 593 } 594 } 595 596 /* Preliminary checks. */ 597 if ((s->size > d->avail) || (d->freelist_entries == 0)) { 598 G_VINUM_DEBUG(0, "not enough space on '%s' for '%s'", d->name, 599 s->name); 600 return (GV_ERR_NOSPACE); 601 } 602 603 /* If no size was given for this subdisk, try to auto-size it... */ 604 if (s->size == -1) { 605 /* Find the largest available slot. */ 606 LIST_FOREACH(fl, &d->freelist, freelist) { 607 if (fl->size < s->size) 608 continue; 609 s->size = fl->size; 610 s->drive_offset = fl->offset; 611 fl2 = fl; 612 } 613 614 /* No good slot found? */ 615 if (s->size == -1) { 616 G_VINUM_DEBUG(0, "unable to autosize '%s' on '%s'", 617 s->name, d->name); 618 return (GV_ERR_BADSIZE); 619 } 620 621 /* 622 * ... or check if we have a free slot that's large enough for the 623 * given size. 624 */ 625 } else { 626 i = 0; 627 LIST_FOREACH(fl, &d->freelist, freelist) { 628 if (fl->size < s->size) 629 continue; 630 /* Assign drive offset, if not given. */ 631 if (s->drive_offset == -1) 632 s->drive_offset = fl->offset; 633 fl2 = fl; 634 i++; 635 break; 636 } 637 638 /* Couldn't find a good free slot. */ 639 if (i == 0) { 640 G_VINUM_DEBUG(0, "free slots to small for '%s' on '%s'", 641 s->name, d->name); 642 return (GV_ERR_NOSPACE); 643 } 644 } 645 646 /* No drive offset given, try to calculate it. */ 647 if (s->drive_offset == -1) { 648 649 /* Add offsets and sizes from other subdisks on this drive. */ 650 LIST_FOREACH(s2, &d->subdisks, from_drive) { 651 s->drive_offset = s2->drive_offset + s2->size; 652 } 653 654 /* 655 * If there are no other subdisks yet, then set the default 656 * offset to GV_DATA_START. 657 */ 658 if (s->drive_offset == -1) 659 s->drive_offset = GV_DATA_START; 660 661 /* Check if we have a free slot at the given drive offset. */ 662 } else { 663 i = 0; 664 LIST_FOREACH(fl, &d->freelist, freelist) { 665 /* Yes, this subdisk fits. */ 666 if ((fl->offset <= s->drive_offset) && 667 (fl->offset + fl->size >= 668 s->drive_offset + s->size)) { 669 i++; 670 fl2 = fl; 671 break; 672 } 673 } 674 675 /* Couldn't find a good free slot. */ 676 if (i == 0) { 677 G_VINUM_DEBUG(0, "given drive_offset for '%s' won't fit " 678 "on '%s'", s->name, d->name); 679 return (GV_ERR_NOSPACE); 680 } 681 } 682 683 /* 684 * Now that all parameters are checked and set up, we can give the 685 * subdisk to the drive and adjust the freelist. 686 */ 687 688 /* First, adjust the freelist. */ 689 LIST_FOREACH(fl, &d->freelist, freelist) { 690 /* Look for the free slot that we have found before. */ 691 if (fl != fl2) 692 continue; 693 694 /* The subdisk starts at the beginning of the free slot. */ 695 if (fl->offset == s->drive_offset) { 696 fl->offset += s->size; 697 fl->size -= s->size; 698 699 /* The subdisk uses the whole slot, so remove it. */ 700 if (fl->size == 0) { 701 d->freelist_entries--; 702 LIST_REMOVE(fl, freelist); 703 } 704 /* 705 * The subdisk does not start at the beginning of the free 706 * slot. 707 */ 708 } else { 709 tmp = fl->offset + fl->size; 710 fl->size = s->drive_offset - fl->offset; 711 712 /* 713 * The subdisk didn't use the complete rest of the free 714 * slot, so we need to split it. 715 */ 716 if (s->drive_offset + s->size != tmp) { 717 fl2 = g_malloc(sizeof(*fl2), M_WAITOK | M_ZERO); 718 fl2->offset = s->drive_offset + s->size; 719 fl2->size = tmp - fl2->offset; 720 LIST_INSERT_AFTER(fl, fl2, freelist); 721 d->freelist_entries++; 722 } 723 } 724 break; 725 } 726 727 /* 728 * This is the first subdisk on this drive, just insert it into the 729 * list. 730 */ 731 if (LIST_EMPTY(&d->subdisks)) { 732 LIST_INSERT_HEAD(&d->subdisks, s, from_drive); 733 734 /* There are other subdisks, so insert this one in correct order. */ 735 } else { 736 LIST_FOREACH(s2, &d->subdisks, from_drive) { 737 if (s->drive_offset < s2->drive_offset) { 738 LIST_INSERT_BEFORE(s2, s, from_drive); 739 break; 740 } else if (LIST_NEXT(s2, from_drive) == NULL) { 741 LIST_INSERT_AFTER(s2, s, from_drive); 742 break; 743 } 744 } 745 } 746 747 d->sdcount++; 748 d->avail -= s->size; 749 750 s->flags &= ~GV_SD_TASTED; 751 752 /* Link back from the subdisk to this drive. */ 753 s->drive_sc = d; 754 755 return (0); 756 } 757 758 void 759 gv_free_sd(struct gv_sd *s) 760 { 761 struct gv_drive *d; 762 struct gv_freelist *fl, *fl2; 763 764 KASSERT(s != NULL, ("gv_free_sd: NULL s")); 765 766 d = s->drive_sc; 767 if (d == NULL) 768 return; 769 770 /* 771 * First, find the free slot that's immediately before or after this 772 * subdisk. 773 */ 774 fl = NULL; 775 LIST_FOREACH(fl, &d->freelist, freelist) { 776 if (fl->offset == s->drive_offset + s->size) 777 break; 778 if (fl->offset + fl->size == s->drive_offset) 779 break; 780 } 781 782 /* If there is no free slot behind this subdisk, so create one. */ 783 if (fl == NULL) { 784 785 fl = g_malloc(sizeof(*fl), M_WAITOK | M_ZERO); 786 fl->size = s->size; 787 fl->offset = s->drive_offset; 788 789 if (d->freelist_entries == 0) { 790 LIST_INSERT_HEAD(&d->freelist, fl, freelist); 791 } else { 792 LIST_FOREACH(fl2, &d->freelist, freelist) { 793 if (fl->offset < fl2->offset) { 794 LIST_INSERT_BEFORE(fl2, fl, freelist); 795 break; 796 } else if (LIST_NEXT(fl2, freelist) == NULL) { 797 LIST_INSERT_AFTER(fl2, fl, freelist); 798 break; 799 } 800 } 801 } 802 803 d->freelist_entries++; 804 805 /* Expand the free slot we just found. */ 806 } else { 807 fl->size += s->size; 808 if (fl->offset > s->drive_offset) 809 fl->offset = s->drive_offset; 810 } 811 812 d->avail += s->size; 813 d->sdcount--; 814 } 815 816 void 817 gv_adjust_freespace(struct gv_sd *s, off_t remainder) 818 { 819 struct gv_drive *d; 820 struct gv_freelist *fl, *fl2; 821 822 KASSERT(s != NULL, ("gv_adjust_freespace: NULL s")); 823 d = s->drive_sc; 824 KASSERT(d != NULL, ("gv_adjust_freespace: NULL d")); 825 826 /* First, find the free slot that's immediately after this subdisk. */ 827 fl = NULL; 828 LIST_FOREACH(fl, &d->freelist, freelist) { 829 if (fl->offset == s->drive_offset + s->size) 830 break; 831 } 832 833 /* If there is no free slot behind this subdisk, so create one. */ 834 if (fl == NULL) { 835 836 fl = g_malloc(sizeof(*fl), M_WAITOK | M_ZERO); 837 fl->size = remainder; 838 fl->offset = s->drive_offset + s->size - remainder; 839 840 if (d->freelist_entries == 0) { 841 LIST_INSERT_HEAD(&d->freelist, fl, freelist); 842 } else { 843 LIST_FOREACH(fl2, &d->freelist, freelist) { 844 if (fl->offset < fl2->offset) { 845 LIST_INSERT_BEFORE(fl2, fl, freelist); 846 break; 847 } else if (LIST_NEXT(fl2, freelist) == NULL) { 848 LIST_INSERT_AFTER(fl2, fl, freelist); 849 break; 850 } 851 } 852 } 853 854 d->freelist_entries++; 855 856 /* Expand the free slot we just found. */ 857 } else { 858 fl->offset -= remainder; 859 fl->size += remainder; 860 } 861 862 s->size -= remainder; 863 d->avail += remainder; 864 } 865 866 /* Check if the given plex is a striped one. */ 867 int 868 gv_is_striped(struct gv_plex *p) 869 { 870 KASSERT(p != NULL, ("gv_is_striped: NULL p")); 871 switch(p->org) { 872 case GV_PLEX_STRIPED: 873 case GV_PLEX_RAID5: 874 return (1); 875 default: 876 return (0); 877 } 878 } 879 880 /* Find a volume by name. */ 881 struct gv_volume * 882 gv_find_vol(struct gv_softc *sc, char *name) 883 { 884 struct gv_volume *v; 885 886 LIST_FOREACH(v, &sc->volumes, volume) { 887 if (!strncmp(v->name, name, GV_MAXVOLNAME)) 888 return (v); 889 } 890 891 return (NULL); 892 } 893 894 /* Find a plex by name. */ 895 struct gv_plex * 896 gv_find_plex(struct gv_softc *sc, char *name) 897 { 898 struct gv_plex *p; 899 900 LIST_FOREACH(p, &sc->plexes, plex) { 901 if (!strncmp(p->name, name, GV_MAXPLEXNAME)) 902 return (p); 903 } 904 905 return (NULL); 906 } 907 908 /* Find a subdisk by name. */ 909 struct gv_sd * 910 gv_find_sd(struct gv_softc *sc, char *name) 911 { 912 struct gv_sd *s; 913 914 LIST_FOREACH(s, &sc->subdisks, sd) { 915 if (!strncmp(s->name, name, GV_MAXSDNAME)) 916 return (s); 917 } 918 919 return (NULL); 920 } 921 922 /* Find a drive by name. */ 923 struct gv_drive * 924 gv_find_drive(struct gv_softc *sc, char *name) 925 { 926 struct gv_drive *d; 927 928 LIST_FOREACH(d, &sc->drives, drive) { 929 if (!strncmp(d->name, name, GV_MAXDRIVENAME)) 930 return (d); 931 } 932 933 return (NULL); 934 } 935 936 /* Find a drive given a device. */ 937 struct gv_drive * 938 gv_find_drive_device(struct gv_softc *sc, char *device) 939 { 940 struct gv_drive *d; 941 942 LIST_FOREACH(d, &sc->drives, drive) { 943 if(!strcmp(d->device, device)) 944 return (d); 945 } 946 947 return (NULL); 948 } 949 950 /* Check if any consumer of the given geom is open. */ 951 int 952 gv_consumer_is_open(struct g_consumer *cp) 953 { 954 if (cp == NULL) 955 return (0); 956 957 if (cp->acr || cp->acw || cp->ace) 958 return (1); 959 960 return (0); 961 } 962 963 int 964 gv_provider_is_open(struct g_provider *pp) 965 { 966 if (pp == NULL) 967 return (0); 968 969 if (pp->acr || pp->acw || pp->ace) 970 return (1); 971 972 return (0); 973 } 974 975 /* 976 * Compare the modification dates of the drives. 977 * Return 1 if a > b, 0 otherwise. 978 */ 979 int 980 gv_drive_is_newer(struct gv_softc *sc, struct gv_drive *d) 981 { 982 struct gv_drive *d2; 983 struct timeval *a, *b; 984 985 KASSERT(!LIST_EMPTY(&sc->drives), 986 ("gv_is_drive_newer: empty drive list")); 987 988 a = &d->hdr->label.last_update; 989 LIST_FOREACH(d2, &sc->drives, drive) { 990 if ((d == d2) || (d2->state != GV_DRIVE_UP) || 991 (d2->hdr == NULL)) 992 continue; 993 b = &d2->hdr->label.last_update; 994 if (timevalcmp(a, b, >)) 995 return (1); 996 } 997 998 return (0); 999 } 1000 1001 /* Return the type of object identified by string 'name'. */ 1002 int 1003 gv_object_type(struct gv_softc *sc, char *name) 1004 { 1005 struct gv_drive *d; 1006 struct gv_plex *p; 1007 struct gv_sd *s; 1008 struct gv_volume *v; 1009 1010 LIST_FOREACH(v, &sc->volumes, volume) { 1011 if (!strncmp(v->name, name, GV_MAXVOLNAME)) 1012 return (GV_TYPE_VOL); 1013 } 1014 1015 LIST_FOREACH(p, &sc->plexes, plex) { 1016 if (!strncmp(p->name, name, GV_MAXPLEXNAME)) 1017 return (GV_TYPE_PLEX); 1018 } 1019 1020 LIST_FOREACH(s, &sc->subdisks, sd) { 1021 if (!strncmp(s->name, name, GV_MAXSDNAME)) 1022 return (GV_TYPE_SD); 1023 } 1024 1025 LIST_FOREACH(d, &sc->drives, drive) { 1026 if (!strncmp(d->name, name, GV_MAXDRIVENAME)) 1027 return (GV_TYPE_DRIVE); 1028 } 1029 1030 return (GV_ERR_NOTFOUND); 1031 } 1032 1033 void 1034 gv_setup_objects(struct gv_softc *sc) 1035 { 1036 struct g_provider *pp; 1037 struct gv_volume *v; 1038 struct gv_plex *p; 1039 struct gv_sd *s; 1040 struct gv_drive *d; 1041 1042 LIST_FOREACH(s, &sc->subdisks, sd) { 1043 d = gv_find_drive(sc, s->drive); 1044 if (d != NULL) 1045 gv_sd_to_drive(s, d); 1046 p = gv_find_plex(sc, s->plex); 1047 if (p != NULL) 1048 gv_sd_to_plex(s, p); 1049 gv_update_sd_state(s); 1050 } 1051 1052 LIST_FOREACH(p, &sc->plexes, plex) { 1053 gv_update_plex_config(p); 1054 v = gv_find_vol(sc, p->volume); 1055 if (v != NULL && p->vol_sc != v) { 1056 p->vol_sc = v; 1057 v->plexcount++; 1058 LIST_INSERT_HEAD(&v->plexes, p, in_volume); 1059 } 1060 gv_update_plex_config(p); 1061 } 1062 1063 LIST_FOREACH(v, &sc->volumes, volume) { 1064 v->size = gv_vol_size(v); 1065 if (v->provider == NULL) { 1066 g_topology_lock(); 1067 pp = g_new_providerf(sc->geom, "gvinum/%s", v->name); 1068 pp->mediasize = v->size; 1069 pp->sectorsize = 512; /* XXX */ 1070 g_error_provider(pp, 0); 1071 v->provider = pp; 1072 pp->private = v; 1073 g_topology_unlock(); 1074 } else if (v->provider->mediasize != v->size) { 1075 g_topology_lock(); 1076 v->provider->mediasize = v->size; 1077 g_topology_unlock(); 1078 } 1079 v->flags &= ~GV_VOL_NEWBORN; 1080 gv_update_vol_state(v); 1081 } 1082 } 1083 1084 void 1085 gv_cleanup(struct gv_softc *sc) 1086 { 1087 struct gv_volume *v, *v2; 1088 struct gv_plex *p, *p2; 1089 struct gv_sd *s, *s2; 1090 struct gv_drive *d, *d2; 1091 struct gv_freelist *fl, *fl2; 1092 1093 mtx_lock(&sc->config_mtx); 1094 LIST_FOREACH_SAFE(v, &sc->volumes, volume, v2) { 1095 LIST_REMOVE(v, volume); 1096 g_free(v->wqueue); 1097 g_free(v); 1098 } 1099 LIST_FOREACH_SAFE(p, &sc->plexes, plex, p2) { 1100 LIST_REMOVE(p, plex); 1101 g_free(p->bqueue); 1102 g_free(p->rqueue); 1103 g_free(p->wqueue); 1104 g_free(p); 1105 } 1106 LIST_FOREACH_SAFE(s, &sc->subdisks, sd, s2) { 1107 LIST_REMOVE(s, sd); 1108 g_free(s); 1109 } 1110 LIST_FOREACH_SAFE(d, &sc->drives, drive, d2) { 1111 LIST_FOREACH_SAFE(fl, &d->freelist, freelist, fl2) { 1112 LIST_REMOVE(fl, freelist); 1113 g_free(fl); 1114 } 1115 LIST_REMOVE(d, drive); 1116 g_free(d->hdr); 1117 g_free(d); 1118 } 1119 mtx_destroy(&sc->config_mtx); 1120 } 1121 1122 /* General 'attach' routine. */ 1123 int 1124 gv_attach_plex(struct gv_plex *p, struct gv_volume *v, int rename) 1125 { 1126 struct gv_sd *s; 1127 struct gv_softc *sc; 1128 1129 g_topology_assert(); 1130 1131 sc = p->vinumconf; 1132 KASSERT(sc != NULL, ("NULL sc")); 1133 1134 if (p->vol_sc != NULL) { 1135 G_VINUM_DEBUG(1, "unable to attach %s: already attached to %s", 1136 p->name, p->volume); 1137 return (GV_ERR_ISATTACHED); 1138 } 1139 1140 /* Stale all subdisks of this plex. */ 1141 LIST_FOREACH(s, &p->subdisks, in_plex) { 1142 if (s->state != GV_SD_STALE) 1143 gv_set_sd_state(s, GV_SD_STALE, GV_SETSTATE_FORCE); 1144 } 1145 /* Attach to volume. Make sure volume is not up and running. */ 1146 if (gv_provider_is_open(v->provider)) { 1147 G_VINUM_DEBUG(1, "unable to attach %s: volume %s is busy", 1148 p->name, v->name); 1149 return (GV_ERR_ISBUSY); 1150 } 1151 p->vol_sc = v; 1152 strlcpy(p->volume, v->name, sizeof(p->volume)); 1153 v->plexcount++; 1154 if (rename) { 1155 snprintf(p->name, sizeof(p->name), "%s.p%d", v->name, 1156 v->plexcount); 1157 } 1158 LIST_INSERT_HEAD(&v->plexes, p, in_volume); 1159 1160 /* Get plex up again. */ 1161 gv_update_vol_size(v, gv_vol_size(v)); 1162 gv_set_plex_state(p, GV_PLEX_UP, 0); 1163 gv_save_config(p->vinumconf); 1164 return (0); 1165 } 1166 1167 int 1168 gv_attach_sd(struct gv_sd *s, struct gv_plex *p, off_t offset, int rename) 1169 { 1170 struct gv_sd *s2; 1171 int error, sdcount; 1172 1173 g_topology_assert(); 1174 1175 /* If subdisk is attached, don't do it. */ 1176 if (s->plex_sc != NULL) { 1177 G_VINUM_DEBUG(1, "unable to attach %s: already attached to %s", 1178 s->name, s->plex); 1179 return (GV_ERR_ISATTACHED); 1180 } 1181 1182 gv_set_sd_state(s, GV_SD_STALE, GV_SETSTATE_FORCE); 1183 /* First check that this subdisk has a correct offset. If none other 1184 * starts at the same, and it's correct module stripesize, it is */ 1185 if (offset != -1 && offset % p->stripesize != 0) 1186 return (GV_ERR_BADOFFSET); 1187 LIST_FOREACH(s2, &p->subdisks, in_plex) { 1188 if (s2->plex_offset == offset) 1189 return (GV_ERR_BADOFFSET); 1190 } 1191 1192 /* Attach the subdisk to the plex at given offset. */ 1193 s->plex_offset = offset; 1194 strlcpy(s->plex, p->name, sizeof(s->plex)); 1195 1196 sdcount = p->sdcount; 1197 error = gv_sd_to_plex(s, p); 1198 if (error) 1199 return (error); 1200 gv_update_plex_config(p); 1201 1202 if (rename) { 1203 snprintf(s->name, sizeof(s->name), "%s.s%d", s->plex, 1204 p->sdcount); 1205 } 1206 if (p->vol_sc != NULL) 1207 gv_update_vol_size(p->vol_sc, gv_vol_size(p->vol_sc)); 1208 gv_save_config(p->vinumconf); 1209 /* We don't update the subdisk state since the user might have to 1210 * initiate a rebuild/sync first. */ 1211 return (0); 1212 } 1213 1214 /* Detach a plex from a volume. */ 1215 int 1216 gv_detach_plex(struct gv_plex *p, int flags) 1217 { 1218 struct gv_volume *v; 1219 1220 g_topology_assert(); 1221 v = p->vol_sc; 1222 1223 if (v == NULL) { 1224 G_VINUM_DEBUG(1, "unable to detach %s: already detached", 1225 p->name); 1226 return (0); /* Not an error. */ 1227 } 1228 1229 /* 1230 * Only proceed if forced or volume inactive. 1231 */ 1232 if (!(flags & GV_FLAG_F) && (gv_provider_is_open(v->provider) || 1233 p->state == GV_PLEX_UP)) { 1234 G_VINUM_DEBUG(1, "unable to detach %s: volume %s is busy", 1235 p->name, p->volume); 1236 return (GV_ERR_ISBUSY); 1237 } 1238 v->plexcount--; 1239 /* Make sure someone don't read us when gone. */ 1240 v->last_read_plex = NULL; 1241 LIST_REMOVE(p, in_volume); 1242 p->vol_sc = NULL; 1243 memset(p->volume, 0, GV_MAXVOLNAME); 1244 gv_update_vol_size(v, gv_vol_size(v)); 1245 gv_save_config(p->vinumconf); 1246 return (0); 1247 } 1248 1249 /* Detach a subdisk from a plex. */ 1250 int 1251 gv_detach_sd(struct gv_sd *s, int flags) 1252 { 1253 struct gv_plex *p; 1254 1255 g_topology_assert(); 1256 p = s->plex_sc; 1257 1258 if (p == NULL) { 1259 G_VINUM_DEBUG(1, "unable to detach %s: already detached", 1260 s->name); 1261 return (0); /* Not an error. */ 1262 } 1263 1264 /* 1265 * Don't proceed if we're not forcing, and the plex is up, or degraded 1266 * with this subdisk up. 1267 */ 1268 if (!(flags & GV_FLAG_F) && ((p->state > GV_PLEX_DEGRADED) || 1269 ((p->state == GV_PLEX_DEGRADED) && (s->state == GV_SD_UP)))) { 1270 G_VINUM_DEBUG(1, "unable to detach %s: plex %s is busy", 1271 s->name, s->plex); 1272 return (GV_ERR_ISBUSY); 1273 } 1274 1275 LIST_REMOVE(s, in_plex); 1276 s->plex_sc = NULL; 1277 memset(s->plex, 0, GV_MAXPLEXNAME); 1278 p->sddetached++; 1279 gv_save_config(s->vinumconf); 1280 return (0); 1281 } 1282