1 /* 2 * To do: 3 * 4 * Don't store drive configuration on the config DB: read each drive's header 5 * to decide where it is. 6 * 7 * Accept any old crap in the config_<foo> functions, and complain when 8 * we try to bring it up. 9 * 10 * When trying to bring volumes up, check that the complete address range 11 * is covered. 12 */ 13 /*- 14 * Copyright (c) 1997, 1998 15 * Nan Yang Computer Services Limited. All rights reserved. 16 * 17 * This software is distributed under the so-called ``Berkeley 18 * License'': 19 * 20 * Redistribution and use in source and binary forms, with or without 21 * modification, are permitted provided that the following conditions 22 * are met: 23 * 1. Redistributions of source code must retain the above copyright 24 * notice, this list of conditions and the following disclaimer. 25 * 2. Redistributions in binary form must reproduce the above copyright 26 * notice, this list of conditions and the following disclaimer in the 27 * documentation and/or other materials provided with the distribution. 28 * 3. All advertising materials mentioning features or use of this software 29 * must display the following acknowledgement: 30 * This product includes software developed by Nan Yang Computer 31 * Services Limited. 32 * 4. Neither the name of the Company nor the names of its contributors 33 * may be used to endorse or promote products derived from this software 34 * without specific prior written permission. 35 * 36 * This software is provided ``as is'', and any express or implied 37 * warranties, including, but not limited to, the implied warranties of 38 * merchantability and fitness for a particular purpose are disclaimed. 39 * In no event shall the company or contributors be liable for any 40 * direct, indirect, incidental, special, exemplary, or consequential 41 * damages (including, but not limited to, procurement of substitute 42 * goods or services; loss of use, data, or profits; or business 43 * interruption) however caused and on any theory of liability, whether 44 * in contract, strict liability, or tort (including negligence or 45 * otherwise) arising in any way out of the use of this software, even if 46 * advised of the possibility of such damage. 47 * 48 * $Id: vinumconfig.c,v 1.30 2000/05/01 09:45:50 grog Exp grog $ 49 * $FreeBSD: src/sys/dev/vinum/vinumconfig.c,v 1.32.2.6 2002/02/03 00:43:35 grog Exp $ 50 * $DragonFly: src/sys/dev/raid/vinum/vinumconfig.c,v 1.12 2007/06/07 22:58:00 corecode Exp $ 51 */ 52 53 #define STATIC static 54 55 #include <sys/udev.h> 56 #include "vinumhdr.h" 57 #include "request.h" 58 59 #define MAXTOKEN 64 /* maximum number of tokens in a line */ 60 61 /* 62 * We can afford the luxury of global variables here, 63 * since start_config ensures that these functions 64 * are single-threaded. 65 */ 66 67 /* These are indices in vinum_conf of the last-mentioned of each kind of object */ 68 static int current_drive; /* note the last drive we mention, for 69 * some defaults */ 70 static int current_plex; /* and the same for the last plex */ 71 static int current_volume; /* and the last volme */ 72 static struct _ioctl_reply *ioctl_reply; /* struct to return via ioctl */ 73 74 static void made_sd(struct sd *sd); 75 static void made_vol(struct volume *vol); 76 static void made_plex(struct plex *plex); 77 78 /* These values are used by most of these routines, so set them as globals */ 79 static char *token[MAXTOKEN]; /* pointers to individual tokens */ 80 static int tokens; /* number of tokens */ 81 82 #define TOCONS 0x01 83 #define TOTTY 0x02 84 #define TOLOG 0x04 85 86 struct putchar_arg { 87 int flags; 88 struct tty *tty; 89 }; 90 91 #define MSG_MAX 1024 /* maximum length of a formatted message */ 92 /* 93 * Format an error message and return to the user in the reply. 94 * CARE: This routine is designed to be called only from the 95 * configuration routines, so it assumes it's the owner of 96 * the configuration lock, and unlocks it on exit 97 */ 98 void 99 throw_rude_remark(int error, char *msg,...) 100 { 101 __va_list ap; 102 char *text; 103 static int finishing; /* don't recurse */ 104 int was_finishing; 105 106 if ((vinum_conf.flags & VF_LOCKED) == 0) /* bug catcher */ 107 panic ("throw_rude_remark: called without config lock"); 108 __va_start(ap, msg); 109 if ((ioctl_reply != NULL) /* we're called from the user */ 110 &&(!(vinum_conf.flags & VF_READING_CONFIG))) { /* and not reading from disk: return msg */ 111 /* 112 * We can't just format to ioctl_reply, since it 113 * may contain our input parameters 114 */ 115 kvasnrprintf(&text, MSG_MAX, 10, msg, ap); 116 strcpy(ioctl_reply->msg, text); 117 ioctl_reply->error = error; /* first byte is the error number */ 118 kvasfree(&text); 119 } else { 120 kprintf("vinum: "); 121 kvprintf(msg, ap); /* print to the console */ 122 kprintf("\n"); 123 } 124 __va_end(ap); 125 126 if (vinum_conf.flags & VF_READING_CONFIG) { /* go through to the bitter end, */ 127 if ((vinum_conf.flags & VF_READING_CONFIG) /* we're reading from disk, */ 128 &&((daemon_options & daemon_noupdate) == 0)) { 129 log(LOG_NOTICE, "Disabling configuration updates\n"); 130 daemon_options |= daemon_noupdate; 131 } 132 return; 133 } 134 /* 135 * We have a problem here: we want to unlock the 136 * configuration, which implies tidying up, but 137 * if we find an error while tidying up, we could 138 * recurse for ever. Use this kludge to only try 139 * once 140 */ 141 was_finishing = finishing; 142 finishing = 1; 143 finish_config(was_finishing); /* unlock anything we may be holding */ 144 finishing = was_finishing; 145 longjmp(command_fail, error); 146 } 147 148 /* 149 * Check a volume to see if the plex is already assigned to it. 150 * Return index in volume->plex, or -1 if not assigned 151 */ 152 int 153 my_plex(int volno, int plexno) 154 { 155 int i; 156 struct volume *vol; 157 158 vol = &VOL[volno]; /* point to volno */ 159 for (i = 0; i < vol->plexes; i++) 160 if (vol->plex[i] == plexno) 161 return i; 162 return -1; /* not found */ 163 } 164 165 /* 166 * Check a plex to see if the subdisk is already assigned to it. 167 * Return index in plex->sd, or -1 if not assigned 168 */ 169 int 170 my_sd(int plexno, int sdno) 171 { 172 int i; 173 struct plex *plex; 174 175 plex = &PLEX[plexno]; 176 for (i = 0; i < plex->subdisks; i++) 177 if (plex->sdnos[i] == sdno) 178 return i; 179 return -1; /* not found */ 180 } 181 182 /* Add plex to the volume if possible */ 183 int 184 give_plex_to_volume(int volno, int plexno) 185 { 186 struct volume *vol; 187 int i; 188 189 /* 190 * It's not an error for the plex to already 191 * belong to the volume, but we need to check a 192 * number of things to make sure it's done right. 193 * Some day. 194 */ 195 if (my_plex(volno, plexno) >= 0) 196 return plexno; /* that's it */ 197 198 vol = &VOL[volno]; /* point to volume */ 199 if (vol->plexes == MAXPLEX) /* all plexes allocated */ 200 throw_rude_remark(ENOSPC, 201 "Too many plexes for volume %s", 202 vol->name); 203 else if ((vol->plexes > 0) /* we have other plexes */ 204 &&((vol->flags & VF_CONFIG_SETUPSTATE) == 0)) /* and we're not setting up state */ 205 invalidate_subdisks(&PLEX[plexno], sd_stale); /* make the subdisks invalid */ 206 vol->plex[vol->plexes] = plexno; /* this one */ 207 vol->plexes++; /* add another plex */ 208 PLEX[plexno].volno = volno; /* note the number of our volume */ 209 210 /* Find out how big our volume is */ 211 for (i = 0; i < vol->plexes; i++) 212 vol->size = u64max(vol->size, PLEX[vol->plex[i]].length); 213 return vol->plexes - 1; /* and return its index */ 214 } 215 216 /* 217 * Add subdisk to a plex if possible 218 */ 219 int 220 give_sd_to_plex(int plexno, int sdno) 221 { 222 int i; 223 struct plex *plex; 224 struct sd *sd; 225 226 /* 227 * It's not an error for the sd to already 228 * belong to the plex, but we need to check a 229 * number of things to make sure it's done right. 230 * Some day. 231 */ 232 i = my_sd(plexno, sdno); 233 if (i >= 0) /* does it already belong to us? */ 234 return i; /* that's it */ 235 236 plex = &PLEX[plexno]; /* point to the plex */ 237 sd = &SD[sdno]; /* and the subdisk */ 238 239 /* Do we have an offset? Otherwise put it after the last one */ 240 if (sd->plexoffset < 0) { /* no offset specified */ 241 if (plex->subdisks > 0) { 242 struct sd *lastsd = &SD[plex->sdnos[plex->subdisks - 1]]; /* last subdisk */ 243 244 if (plex->organization == plex_concat) /* concat, */ 245 sd->plexoffset = lastsd->sectors + lastsd->plexoffset; /* starts here */ 246 else /* striped, RAID-4 or RAID-5 */ 247 sd->plexoffset = plex->stripesize * plex->subdisks; /* starts here */ 248 } else /* first subdisk */ 249 sd->plexoffset = 0; /* start at the beginning */ 250 } 251 if (plex->subdisks == MAXSD) /* we already have our maximum */ 252 throw_rude_remark(ENOSPC, /* crap out */ 253 "Can't add %s to %s: plex full", 254 sd->name, 255 plex->name); 256 257 plex->subdisks++; /* another entry */ 258 if (plex->subdisks >= plex->subdisks_allocated) /* need more space */ 259 EXPAND(plex->sdnos, int, plex->subdisks_allocated, INITIAL_SUBDISKS_IN_PLEX); 260 261 /* Adjust size of plex and volume. */ 262 if (isparity(plex)) /* RAID-4 or RAID-5 */ 263 plex->length = (plex->subdisks - 1) * sd->sectors; /* size is one disk short */ 264 else 265 plex->length += sd->sectors; /* plex gets this much bigger */ 266 if (plex->volno >= 0) /* we have a volume */ 267 VOL[plex->volno].size = u64max(VOL[plex->volno].size, plex->length); /* adjust its size */ 268 269 /* 270 * We need to check that the subdisks don't overlap, 271 * but we can't do that until a point where we *must* 272 * know the size of all the subdisks. That's not 273 * here. But we need to sort them by offset 274 */ 275 for (i = 0; i < plex->subdisks - 1; i++) { 276 if (sd->plexoffset < SD[plex->sdnos[i]].plexoffset) { /* it fits before this one */ 277 /* First move any remaining subdisks by one */ 278 int j; 279 280 for (j = plex->subdisks - 1; j > i; j--) /* move up one at a time */ 281 plex->sdnos[j] = plex->sdnos[j - 1]; 282 plex->sdnos[i] = sdno; 283 sd->plexsdno = i; /* note where we are in the subdisk */ 284 return i; 285 } 286 } 287 288 /* 289 * The plex doesn't have any subdisk with a 290 * larger offset. Insert it here. 291 */ 292 plex->sdnos[i] = sdno; 293 sd->plexsdno = i; /* note where we are in the subdisk */ 294 sd->plexno = plex->plexno; /* and who we belong to */ 295 return i; 296 } 297 298 /* 299 * Add a subdisk to drive if possible. The 300 * pointer to the drive must already be stored in 301 * the sd structure, but the drive doesn't know 302 * about the subdisk yet. 303 */ 304 void 305 give_sd_to_drive(int sdno) 306 { 307 struct sd *sd; /* pointer to subdisk */ 308 struct drive *drive; /* and drive */ 309 int fe; /* index in free list */ 310 int sfe; /* and index of subdisk when assigning max */ 311 312 sd = &SD[sdno]; /* point to sd */ 313 drive = &DRIVE[sd->driveno]; /* and drive */ 314 315 if (drive->state != drive_up) { 316 update_sd_state(sdno); /* that crashes the subdisk */ 317 return; 318 } 319 if (drive->flags & VF_HOTSPARE) /* the drive is a hot spare, */ 320 throw_rude_remark(ENOSPC, 321 "Can't place %s on hot spare drive %s", 322 sd->name, 323 drive->label.name); 324 if ((drive->sectors_available == 0) /* no space left */ 325 ||(sd->sectors > drive->sectors_available)) { /* or too big, */ 326 sd->driveoffset = -1; /* don't be confusing */ 327 free_sd(sd->sdno); 328 throw_rude_remark(ENOSPC, "No space for %s on %s", sd->name, drive->label.name); 329 return; /* in case we come back here */ 330 } 331 drive->subdisks_used++; /* one more subdisk */ 332 333 if (sd->sectors == 0) { /* take the largest chunk */ 334 sfe = 0; /* to keep the compiler happy */ 335 for (fe = 0; fe < drive->freelist_entries; fe++) { 336 if (drive->freelist[fe].sectors >= sd->sectors) { /* more space here */ 337 sd->sectors = drive->freelist[fe].sectors; /* take it */ 338 sd->driveoffset = drive->freelist[fe].offset; 339 sfe = fe; /* and note the index for later */ 340 } 341 } 342 if (sd->sectors == 0) { /* no luck, */ 343 sd->driveoffset = -1; /* don't be confusing */ 344 free_sd(sd->sdno); 345 throw_rude_remark(ENOSPC, /* give up */ 346 "No space for %s on %s", 347 sd->name, 348 drive->label.name); 349 } 350 if (sfe < (drive->freelist_entries - 1)) /* not the last one, */ 351 bcopy(&drive->freelist[sfe + 1], 352 &drive->freelist[sfe], 353 (drive->freelist_entries - sfe) * sizeof(struct drive_freelist)); 354 drive->freelist_entries--; /* one less entry */ 355 drive->sectors_available -= sd->sectors; /* and note how much less space we have */ 356 } else if (sd->driveoffset < 0) { /* no offset specified, find one */ 357 for (fe = 0; fe < drive->freelist_entries; fe++) { 358 if (drive->freelist[fe].sectors >= sd->sectors) { /* it'll fit here */ 359 sd->driveoffset = drive->freelist[fe].offset; 360 if (sd->sectors == drive->freelist[fe].sectors) { /* used up the entire entry */ 361 if (fe < (drive->freelist_entries - 1)) /* not the last one, */ 362 bcopy(&drive->freelist[fe + 1], 363 &drive->freelist[fe], 364 (drive->freelist_entries - fe) * sizeof(struct drive_freelist)); 365 drive->freelist_entries--; /* one less entry */ 366 } else { 367 drive->freelist[fe].sectors -= sd->sectors; /* this much less space */ 368 drive->freelist[fe].offset += sd->sectors; /* this much further on */ 369 } 370 drive->sectors_available -= sd->sectors; /* and note how much less space we have */ 371 break; 372 } 373 } 374 if (sd->driveoffset < 0) 375 /* 376 * Didn't find anything. Although the drive has 377 * enough space, it's too fragmented 378 */ 379 { 380 free_sd(sd->sdno); 381 throw_rude_remark(ENOSPC, "No space for %s on %s", sd->name, drive->label.name); 382 } 383 } else { /* specific offset */ 384 /* 385 * For a specific offset to work, the space must be 386 * entirely in a single freelist entry. Look for it. 387 */ 388 u_int64_t sdend = sd->driveoffset + sd->sectors; /* end of our subdisk */ 389 for (fe = 0; fe < drive->freelist_entries; fe++) { 390 u_int64_t dend = drive->freelist[fe].offset + drive->freelist[fe].sectors; /* end of entry */ 391 if (dend >= sdend) { /* fits before here */ 392 if (drive->freelist[fe].offset > sd->driveoffset) { /* starts after the beginning of sd area */ 393 sd->driveoffset = -1; /* don't be confusing */ 394 set_sd_state(sd->sdno, sd_down, setstate_force); 395 throw_rude_remark(ENOSPC, 396 "No space for %s on drive %s at offset %jd", 397 sd->name, 398 drive->label.name, 399 (intmax_t)sd->driveoffset); 400 return; 401 } 402 /* 403 * We've found the space, and we can allocate it. 404 * We don't need to say that to the subdisk, which 405 * already knows about it. We need to tell it to 406 * the free list, though. We have four possibilities: 407 * 408 * 1. The subdisk exactly eats up the entry. That's the 409 * same as above. 410 * 2. The subdisk starts at the beginning and leaves space 411 * at the end. 412 * 3. The subdisk starts after the beginning and leaves 413 * space at the end as well: we end up with another 414 * fragment. 415 * 4. The subdisk leaves space at the beginning and finishes 416 * at the end. 417 */ 418 drive->sectors_available -= sd->sectors; /* note how much less space we have */ 419 if (sd->driveoffset == drive->freelist[fe].offset) { /* 1 or 2 */ 420 if (sd->sectors == drive->freelist[fe].sectors) { /* 1: used up the entire entry */ 421 if (fe < (drive->freelist_entries - 1)) /* not the last one, */ 422 bcopy(&drive->freelist[fe + 1], 423 &drive->freelist[fe], 424 (drive->freelist_entries - fe) * sizeof(struct drive_freelist)); 425 drive->freelist_entries--; /* one less entry */ 426 } else { /* 2: space at the end */ 427 drive->freelist[fe].sectors -= sd->sectors; /* this much less space */ 428 drive->freelist[fe].offset += sd->sectors; /* this much further on */ 429 } 430 } else { /* 3 or 4 */ 431 drive->freelist[fe].sectors = sd->driveoffset - drive->freelist[fe].offset; 432 if (dend > sdend) { /* 3: space at the end as well */ 433 if (fe < (drive->freelist_entries - 1)) /* not the last one */ 434 bcopy(&drive->freelist[fe], /* move the rest down */ 435 &drive->freelist[fe + 1], 436 (drive->freelist_entries - fe) * sizeof(struct drive_freelist)); 437 drive->freelist_entries++; /* one less entry */ 438 drive->freelist[fe + 1].offset = sdend; /* second entry starts after sd */ 439 drive->freelist[fe + 1].sectors = dend - sdend; /* and is this long */ 440 } 441 } 442 break; 443 } 444 } 445 } 446 drive->opencount++; /* one more subdisk attached */ 447 } 448 449 /* Get an empty drive entry from the drive table */ 450 int 451 get_empty_drive(void) 452 { 453 int driveno; 454 struct drive *drive; 455 456 /* first see if we have one which has been deallocated */ 457 for (driveno = 0; driveno < vinum_conf.drives_allocated; driveno++) { 458 if (DRIVE[driveno].state == drive_unallocated) /* bingo */ 459 break; 460 } 461 462 if (driveno >= vinum_conf.drives_allocated) /* we've used all our allocation */ 463 EXPAND(DRIVE, struct drive, vinum_conf.drives_allocated, INITIAL_DRIVES); 464 465 /* got a drive entry. Make it pretty */ 466 drive = &DRIVE[driveno]; 467 bzero(drive, sizeof(struct drive)); 468 drive->driveno = driveno; /* put number in structure */ 469 drive->flags |= VF_NEWBORN; /* newly born drive */ 470 strcpy(drive->devicename, "unknown"); /* and make the name ``unknown'' */ 471 return driveno; /* return the index */ 472 } 473 474 /* 475 * Find the named drive in vinum_conf.drive, return a pointer 476 * return the index in vinum_conf.drive. 477 * Don't mark the drive as allocated (XXX SMP) 478 * If create != 0, create an entry if it doesn't exist 479 */ 480 /* XXX check if we have it open from attach */ 481 int 482 find_drive(const char *name, int create) 483 { 484 int driveno; 485 struct drive *drive; 486 487 if (name != NULL) { 488 for (driveno = 0; driveno < vinum_conf.drives_allocated; driveno++) { 489 drive = &DRIVE[driveno]; /* point to drive */ 490 if ((drive->label.name[0] != '\0') /* it has a name */ 491 &&(strcmp(drive->label.name, name) == 0) /* and it's this one */ 492 &&(drive->state > drive_unallocated)) /* and it's a real one: found */ 493 return driveno; 494 } 495 } 496 /* the drive isn't in the list. Add it if he wants */ 497 if (create == 0) /* don't want to create */ 498 return -1; /* give up */ 499 500 driveno = get_empty_drive(); 501 drive = &DRIVE[driveno]; 502 if (name != NULL) 503 ksnprintf(drive->label.name, sizeof(drive->label.name), "%s", name); 504 drive->state = drive_referenced; /* in use, nothing worthwhile there */ 505 return driveno; /* return the index */ 506 } 507 508 /* 509 * Find a drive given its device name. 510 * devname must be valid. 511 * Otherwise the same as find_drive above 512 */ 513 int 514 find_drive_by_dev(const char *devname, int create) 515 { 516 int driveno; 517 struct drive *drive; 518 519 for (driveno = 0; driveno < vinum_conf.drives_allocated; driveno++) { 520 drive = &DRIVE[driveno]; 521 if (strcmp(drive->devicename, devname) == 0 && 522 drive->state > drive_unallocated 523 ) { 524 return driveno; 525 } 526 } 527 528 if (create == 0) 529 return -1; 530 531 driveno = get_empty_drive(); 532 drive = &DRIVE[driveno]; 533 ksnprintf(drive->devicename, sizeof(drive->devicename), "%s", devname); 534 /* in use, nothing worthwhile there */ 535 drive->state = drive_referenced; 536 return driveno; 537 } 538 539 /* Find an empty subdisk in the subdisk table */ 540 int 541 get_empty_sd(void) 542 { 543 int sdno; 544 struct sd *sd; 545 546 /* first see if we have one which has been deallocated */ 547 for (sdno = 0; sdno < vinum_conf.subdisks_allocated; sdno++) { 548 if (SD[sdno].state == sd_unallocated) /* bingo */ 549 break; 550 } 551 if (sdno >= vinum_conf.subdisks_allocated) 552 /* 553 * We've run out of space. sdno is pointing 554 * where we want it, but at the moment we 555 * don't have the space. Get it. 556 */ 557 EXPAND(SD, struct sd, vinum_conf.subdisks_allocated, INITIAL_SUBDISKS); 558 559 /* initialize some things */ 560 sd = &SD[sdno]; /* point to it */ 561 bzero(sd, sizeof(struct sd)); /* initialize */ 562 sd->flags |= VF_NEWBORN; /* newly born subdisk */ 563 sd->plexno = -1; /* no plex */ 564 sd->sectors = -1; /* no space */ 565 sd->driveno = -1; /* no drive */ 566 sd->plexoffset = -1; /* and no offsets */ 567 sd->driveoffset = -1; 568 return sdno; /* return the index */ 569 } 570 571 /* return a drive to the free pool */ 572 void 573 free_drive(struct drive *drive) 574 { 575 if ((drive->state > drive_referenced) /* real drive */ 576 ||(drive->flags & VF_OPEN)) { /* how can it be open without a state? */ 577 LOCKDRIVE(drive); 578 if (drive->flags & VF_OPEN) { /* it's open, */ 579 close_locked_drive(drive); /* close it */ 580 drive->state = drive_down; /* and note the fact */ 581 } 582 if (drive->freelist) 583 Free(drive->freelist); 584 bzero(drive, sizeof(struct drive)); /* this also sets drive_unallocated */ 585 unlockdrive(drive); 586 } 587 } 588 589 /* 590 * Find the named subdisk in vinum_conf.sd. 591 * 592 * If create != 0, create an entry if it doesn't exist 593 * 594 * Return index in vinum_conf.sd 595 */ 596 int 597 find_subdisk(const char *name, int create) 598 { 599 int sdno; 600 struct sd *sd; 601 602 for (sdno = 0; sdno < vinum_conf.subdisks_allocated; sdno++) { 603 if (strcmp(SD[sdno].name, name) == 0) /* found it */ 604 return sdno; 605 } 606 607 /* the subdisk isn't in the list. Add it if he wants */ 608 if (create == 0) /* don't want to create */ 609 return -1; /* give up */ 610 611 /* Allocate one and insert the name */ 612 sdno = get_empty_sd(); 613 sd = &SD[sdno]; 614 ksnprintf(sd->name, sizeof(sd->name), "%s", name); 615 return sdno; /* return the pointer */ 616 } 617 618 /* Return space to a drive */ 619 void 620 return_drive_space(int driveno, int64_t offset, int length) 621 { 622 struct drive *drive; 623 int fe; /* free list entry */ 624 u_int64_t sdend; /* end of our subdisk */ 625 u_int64_t dend; /* end of our freelist entry */ 626 627 drive = &DRIVE[driveno]; 628 if (drive->state == drive_up) { 629 sdend = offset + length; /* end of our subdisk */ 630 631 /* Look for where to return the sd address space */ 632 for (fe = 0; 633 (fe < drive->freelist_entries) && (drive->freelist[fe].offset < offset); 634 fe++); 635 /* 636 * Now we are pointing to the last entry, the first 637 * with a higher offset than the subdisk, or both. 638 */ 639 if ((fe > 1) /* not the first entry */ 640 &&((fe == drive->freelist_entries) /* gone past the end */ 641 ||(drive->freelist[fe].offset > offset))) /* or past the block were looking for */ 642 fe--; /* point to the block before */ 643 dend = drive->freelist[fe].offset + drive->freelist[fe].sectors; /* end of the entry */ 644 645 /* 646 * At this point, we are pointing to the correct 647 * place in the free list. A number of possibilities 648 * exist: 649 * 650 * 1. The block to be freed starts at the end of the 651 * block to which we are pointing. This has two 652 * subcases: 653 * 654 * a. The block to be freed ends at the beginning 655 * of the following block. Merge the three 656 * areas into a single block. 657 * 658 * b. The block is shorter than the space between 659 * the current block and the next one. Enlarge 660 * the current block. 661 * 662 * 2. The block to be freed starts after the end 663 * of the block. Again, we have two cases: 664 * 665 * a. It ends before the start of the following block. 666 * Create a new free block. 667 * 668 * b. It ends at the start of the following block. 669 * Enlarge the following block downwards. 670 * 671 * When there is only one free space block, and the 672 * space to be returned is before it, the pointer is 673 * to a non-existent zeroth block. XXX check this 674 */ 675 if (offset == dend) { /* Case 1: it starts at the end of this block */ 676 if ((fe < drive->freelist_entries - 1) /* we're not the last block in the free list */ 677 /* and the subdisk ends at the start of the next block */ 678 &&(sdend == drive->freelist[fe + 1].offset)) { 679 drive->freelist[fe].sectors /* 1a: merge all three blocks */ 680 = drive->freelist[fe + 1].sectors; 681 if (fe < drive->freelist_entries - 2) /* still more blocks after next */ 682 bcopy(&drive->freelist[fe + 2], /* move down one */ 683 &drive->freelist[fe + 1], 684 (drive->freelist_entries - 2 - fe) 685 * sizeof(struct drive_freelist)); 686 drive->freelist_entries--; /* one less entry in the free list */ 687 } else /* 1b: just enlarge this block */ 688 drive->freelist[fe].sectors += length; 689 } else { /* Case 2 */ 690 if (offset > dend) /* it starts after this block */ 691 fe++; /* so look at the next block */ 692 if ((fe < drive->freelist_entries) /* we're not the last block in the free list */ 693 /* and the subdisk ends at the start of this block: case 4 */ 694 &&(sdend == drive->freelist[fe].offset)) { 695 drive->freelist[fe].offset = offset; /* it starts where the sd was */ 696 drive->freelist[fe].sectors += length; /* and it's this much bigger */ 697 } else { /* case 3: non-contiguous */ 698 if (fe < drive->freelist_entries) /* not after the last block, */ 699 bcopy(&drive->freelist[fe], /* move the rest up one entry */ 700 &drive->freelist[fe + 1], 701 (drive->freelist_entries - fe) 702 * sizeof(struct drive_freelist)); 703 drive->freelist_entries++; /* one less entry */ 704 drive->freelist[fe].offset = offset; /* this entry represents the sd */ 705 drive->freelist[fe].sectors = length; 706 } 707 } 708 drive->sectors_available += length; /* the sectors are now available */ 709 } 710 } 711 712 /* 713 * Free an allocated sd entry. 714 * This performs memory management only. remove() 715 * is responsible for checking relationships. 716 */ 717 void 718 free_sd(int sdno) 719 { 720 struct sd *sd; 721 722 sd = &SD[sdno]; 723 if ((sd->driveno >= 0) /* we have a drive, */ 724 &&(sd->sectors > 0)) /* and some space on it */ 725 return_drive_space(sd->driveno, /* return the space */ 726 sd->driveoffset, 727 sd->sectors); 728 if (sd->plexno >= 0) 729 PLEX[sd->plexno].subdisks--; /* one less subdisk */ 730 sd->state = sd_unallocated; 731 made_sd(sd); 732 bzero(sd, sizeof(struct sd)); /* and clear it out */ 733 sd->state = sd_unallocated; 734 vinum_conf.subdisks_used--; /* one less sd */ 735 } 736 737 static void 738 made_sd(struct sd *sd) 739 { 740 if (sd->sd_dev == NULL && sd->state != sd_unallocated) { 741 sd->sd_dev = make_dev(&vinum_ops, VINUM_SD(sd->sdno), 742 UID_ROOT, GID_OPERATOR, 0640, 743 VINUM_BASE "sd/%s", sd->name); 744 udev_dict_set_cstr(sd->sd_dev, "subsystem", "raid"); 745 udev_dict_set_cstr(sd->sd_dev, "disk-type", "raid"); 746 #if 0 747 if (sd->plexno >= 0 && PLEX[sd->plexno].volno >= 0) { 748 make_dev_alias(sd->sd_dev, "vol/%s.plex/%s", 749 VOL[PLEX[sd->plexno].volno].name, 750 plex->name, VOL[plex->volno].name); 751 } 752 #endif 753 } 754 if (sd->sd_dev && sd->state == sd_unallocated) { 755 destroy_dev(sd->sd_dev); 756 sd->sd_dev = NULL; 757 } 758 } 759 760 static void 761 made_vol(struct volume *vol) 762 { 763 if (vol->vol_dev == NULL && vol->state != volume_unallocated) { 764 vol->vol_dev = make_dev(&vinum_ops, 765 VINUMDEV(vol->volno, 0, 0, VINUM_VOLUME_TYPE), 766 UID_ROOT, GID_OPERATOR, 0640, 767 VINUM_BASE "vol/%s", vol->name); 768 udev_dict_set_cstr(vol->vol_dev, "subsystem", "raid"); 769 udev_dict_set_cstr(vol->vol_dev, "disk-type", "raid"); 770 } 771 if (vol->vol_dev && vol->state == volume_unallocated) { 772 destroy_dev(vol->vol_dev); 773 vol->vol_dev = NULL; 774 } 775 } 776 777 static void 778 made_plex(struct plex *plex) 779 { 780 if (plex->plex_dev == NULL && plex->state != plex_unallocated) { 781 plex->plex_dev = make_dev(&vinum_ops, VINUM_PLEX(plex->plexno), 782 UID_ROOT, GID_OPERATOR, 0640, 783 VINUM_BASE "plex/%s", plex->name); 784 udev_dict_set_cstr(plex->plex_dev, "subsystem", "raid"); 785 udev_dict_set_cstr(plex->plex_dev, "disk-type", "raid"); 786 if (plex->volno >= 0) { 787 make_dev_alias(plex->plex_dev, "vol/%s.plex/%s", 788 plex->name, VOL[plex->volno].name); 789 } 790 } 791 if (plex->plex_dev && plex->state == plex_unallocated) { 792 destroy_dev(plex->plex_dev); 793 plex->plex_dev = NULL; 794 } 795 } 796 797 /* Find an empty plex in the plex table */ 798 int 799 get_empty_plex(void) 800 { 801 int plexno; 802 struct plex *plex; /* if we allocate one */ 803 804 /* first see if we have one which has been deallocated */ 805 for (plexno = 0; plexno < vinum_conf.plexes_allocated; plexno++) { 806 if (PLEX[plexno].state == plex_unallocated) /* bingo */ 807 break; /* and get out of here */ 808 } 809 810 if (plexno >= vinum_conf.plexes_allocated) 811 EXPAND(PLEX, struct plex, vinum_conf.plexes_allocated, INITIAL_PLEXES); 812 813 /* Found a plex. Give it an sd structure */ 814 plex = &PLEX[plexno]; /* this one is ours */ 815 bzero(plex, sizeof(struct plex)); /* polish it up */ 816 plex->sdnos = (int *) Malloc(sizeof(int) * INITIAL_SUBDISKS_IN_PLEX); /* allocate sd table */ 817 CHECKALLOC(plex->sdnos, "vinum: Can't allocate plex subdisk table"); 818 bzero(plex->sdnos, (sizeof(int) * INITIAL_SUBDISKS_IN_PLEX)); /* do we need this? */ 819 plex->flags |= VF_NEWBORN; /* newly born plex */ 820 plex->subdisks = 0; /* no subdisks in use */ 821 plex->subdisks_allocated = INITIAL_SUBDISKS_IN_PLEX; /* and we have space for this many */ 822 plex->organization = plex_disorg; /* and it's not organized */ 823 plex->volno = -1; /* no volume yet */ 824 return plexno; /* return the index */ 825 } 826 827 /* 828 * Find the named plex in vinum_conf.plex 829 * 830 * If create != 0, create an entry if it doesn't exist 831 * return index in vinum_conf.plex 832 */ 833 int 834 find_plex(const char *name, int create) 835 { 836 int plexno; 837 struct plex *plex; 838 839 for (plexno = 0; plexno < vinum_conf.plexes_allocated; plexno++) { 840 if (strcmp(PLEX[plexno].name, name) == 0) /* found it */ 841 return plexno; 842 } 843 844 /* the plex isn't in the list. Add it if he wants */ 845 if (create == 0) /* don't want to create */ 846 return -1; /* give up */ 847 848 /* Allocate one and insert the name */ 849 plexno = get_empty_plex(); 850 plex = &PLEX[plexno]; /* point to it */ 851 ksnprintf(plex->name, sizeof(plex->name), "%s", name); 852 return plexno; /* return the pointer */ 853 } 854 855 /* 856 * Free an allocated plex entry 857 * and its associated memory areas 858 */ 859 void 860 free_plex(int plexno) 861 { 862 struct plex *plex; 863 864 plex = &PLEX[plexno]; 865 if (plex->sdnos) 866 Free(plex->sdnos); 867 if (plex->lock) 868 Free(plex->lock); 869 plex->state = plex_unallocated; 870 made_plex(plex); 871 bzero(plex, sizeof(struct plex)); /* and clear it out */ 872 plex->state = plex_unallocated; 873 } 874 875 /* Find an empty volume in the volume table */ 876 int 877 get_empty_volume(void) 878 { 879 int volno; 880 struct volume *vol; 881 int i; 882 883 /* first see if we have one which has been deallocated */ 884 for (volno = 0; volno < vinum_conf.volumes_allocated; volno++) { 885 if (VOL[volno].state == volume_unallocated) /* bingo */ 886 break; 887 } 888 889 if (volno >= vinum_conf.volumes_allocated) 890 EXPAND(VOL, struct volume, vinum_conf.volumes_allocated, INITIAL_VOLUMES); 891 892 /* Now initialize fields */ 893 vol = &VOL[volno]; 894 bzero(vol, sizeof(struct volume)); 895 vol->flags |= VF_NEWBORN | VF_CREATED; /* newly born volume */ 896 vol->preferred_plex = ROUND_ROBIN_READPOL; /* round robin */ 897 for (i = 0; i < MAXPLEX; i++) /* mark the plexes missing */ 898 vol->plex[i] = -1; 899 return volno; /* return the index */ 900 } 901 902 /* 903 * Find the named volume in vinum_conf.volume. 904 * 905 * If create != 0, create an entry if it doesn't exist 906 * return the index in vinum_conf 907 */ 908 int 909 find_volume(const char *name, int create) 910 { 911 int volno; 912 struct volume *vol; 913 914 for (volno = 0; volno < vinum_conf.volumes_allocated; volno++) { 915 if (strcmp(VOL[volno].name, name) == 0) /* found it */ 916 return volno; 917 } 918 919 /* the volume isn't in the list. Add it if he wants */ 920 if (create == 0) /* don't want to create */ 921 return -1; /* give up */ 922 923 /* Allocate one and insert the name */ 924 volno = get_empty_volume(); 925 vol = &VOL[volno]; 926 ksnprintf(vol->name, sizeof(vol->name), "%s", name); 927 vol->blocksize = DEV_BSIZE; /* block size of this volume */ 928 return volno; /* return the pointer */ 929 } 930 931 /* 932 * Free an allocated volume entry 933 * and its associated memory areas 934 */ 935 void 936 free_volume(int volno) 937 { 938 struct volume *vol; 939 940 vol = &VOL[volno]; 941 vol->state = volume_unallocated; 942 made_vol(vol); 943 bzero(vol, sizeof(struct volume)); /* and clear it out */ 944 vol->state = volume_unallocated; 945 } 946 947 /* 948 * Handle a drive definition. We store the information in the global variable 949 * drive, so we don't need to allocate. 950 * 951 * If we find an error, print a message and return 952 */ 953 void 954 config_drive(int update) 955 { 956 enum drive_label_info partition_status; /* info about the partition */ 957 int parameter; 958 int driveno; /* index of drive in vinum_conf */ 959 struct drive *drive; /* and pointer to it */ 960 int otherdriveno; /* index of possible second drive */ 961 int sdno; 962 963 if (tokens < 2) /* not enough tokens */ 964 throw_rude_remark(EINVAL, "Drive has no name\n"); 965 driveno = find_drive(token[1], 1); /* allocate a drive to initialize */ 966 drive = &DRIVE[driveno]; /* and get a pointer */ 967 if (update && ((drive->flags & VF_NEWBORN) == 0)) /* this drive exists already */ 968 return; /* don't do anything */ 969 drive->flags &= ~VF_NEWBORN; /* no longer newly born */ 970 971 if (drive->state != drive_referenced) { /* we already know this drive */ 972 /* 973 * XXX Check which definition is more up-to-date. Give 974 * preference for the definition on its own drive. 975 */ 976 return; /* XXX */ 977 } 978 for (parameter = 2; parameter < tokens; parameter++) { /* look at the other tokens */ 979 switch (get_keyword(token[parameter], &keyword_set)) { 980 case kw_device: 981 parameter++; 982 otherdriveno = find_drive_by_dev(token[parameter], 0); /* see if it exists already */ 983 if (otherdriveno >= 0) { /* yup, */ 984 drive->state = drive_unallocated; /* deallocate the drive */ 985 throw_rude_remark(EEXIST, /* and complain */ 986 "Drive %s would have same device as drive %s", 987 token[1], 988 DRIVE[otherdriveno].label.name); 989 } 990 if (drive->devicename[0] == '/') { /* we know this drive... */ 991 if (strcmp(drive->devicename, token[parameter])) /* different name */ 992 close_drive(drive); /* close it if it's open */ 993 else /* no change */ 994 break; 995 } 996 997 /* 998 * open the device and get the configuration 999 */ 1000 ksnprintf(drive->devicename, sizeof(drive->devicename), 1001 "%s", token[parameter]); 1002 partition_status = read_drive_label(drive, 1); 1003 1004 switch (partition_status) { 1005 case DL_CANT_OPEN: /* not our kind */ 1006 close_drive(drive); 1007 if (drive->lasterror == EFTYPE) /* wrong kind of partition */ 1008 throw_rude_remark(drive->lasterror, 1009 "Drive %s has invalid partition type", 1010 drive->label.name); 1011 else /* I/O error of some kind */ 1012 throw_rude_remark(drive->lasterror, 1013 "Can't initialize drive %s", 1014 drive->label.name); 1015 break; 1016 1017 case DL_WRONG_DRIVE: /* valid drive, not the name we expected */ 1018 if (vinum_conf.flags & VF_FORCECONFIG) { /* but we'll accept that */ 1019 bcopy(token[1], drive->label.name, sizeof(drive->label.name)); 1020 break; 1021 } 1022 close_drive(drive); 1023 /* 1024 * There's a potential race condition here: 1025 * the rude remark refers to a field in an 1026 * unallocated drive, which potentially could 1027 * be reused. This works because we're the only 1028 * thread accessing the config at the moment. 1029 */ 1030 drive->state = drive_unallocated; /* throw it away completely */ 1031 throw_rude_remark(drive->lasterror, 1032 "Incorrect drive name %s specified for drive %s", 1033 token[1], 1034 drive->label.name); 1035 break; 1036 1037 case DL_DELETED_LABEL: /* it was a drive, but we deleted it */ 1038 case DL_NOT_OURS: /* nothing to do with the rest */ 1039 case DL_OURS: 1040 break; 1041 } 1042 /* 1043 * read_drive_label overwrites the device name. 1044 * If we get here, we can have the drive, 1045 * so put it back again 1046 */ 1047 ksnprintf(drive->devicename, sizeof(drive->devicename), 1048 "%s", token[parameter]); 1049 break; 1050 1051 case kw_state: 1052 parameter++; /* skip the keyword */ 1053 if (vinum_conf.flags & VF_READING_CONFIG) 1054 drive->state = DriveState(token[parameter]); /* set the state */ 1055 break; 1056 1057 case kw_hotspare: /* this drive is a hot spare */ 1058 drive->flags |= VF_HOTSPARE; 1059 break; 1060 1061 default: 1062 close_drive(drive); 1063 throw_rude_remark(EINVAL, 1064 "Drive %s, invalid keyword: %s", 1065 token[1], 1066 token[parameter]); 1067 } 1068 } 1069 1070 if (drive->devicename[0] != '/') { 1071 drive->state = drive_unallocated; /* deallocate the drive */ 1072 throw_rude_remark(EINVAL, "No device name for %s", drive->label.name); 1073 } 1074 vinum_conf.drives_used++; /* passed all hurdles: one more in use */ 1075 /* 1076 * If we're replacing a drive, it could be that 1077 * we already have subdisks referencing this 1078 * drive. Note where they should be and change 1079 * their state to obsolete. 1080 */ 1081 for (sdno = 0; sdno < vinum_conf.subdisks_allocated; sdno++) { 1082 if ((SD[sdno].state > sd_referenced) 1083 && (SD[sdno].driveno == driveno)) { 1084 give_sd_to_drive(sdno); 1085 if (SD[sdno].state > sd_stale) 1086 SD[sdno].state = sd_stale; 1087 } 1088 } 1089 } 1090 1091 /* 1092 * Handle a subdisk definition. We store the information in the global variable 1093 * sd, so we don't need to allocate. 1094 * 1095 * If we find an error, print a message and return 1096 */ 1097 void 1098 config_subdisk(int update) 1099 { 1100 int parameter; 1101 int sdno; /* index of sd in vinum_conf */ 1102 struct sd *sd; /* and pointer to it */ 1103 u_int64_t size; 1104 int detached = 0; /* set to 1 if this is a detached subdisk */ 1105 int sdindex = -1; /* index in plexes subdisk table */ 1106 enum sdstate state = sd_unallocated; /* state to set, if specified */ 1107 int autosize = 0; /* set if we autosize in give_sd_to_drive */ 1108 int namedsdno; /* index of another with this name */ 1109 char partition = 0; /* partition of external subdisk */ 1110 1111 sdno = get_empty_sd(); /* allocate an SD to initialize */ 1112 sd = &SD[sdno]; /* and get a pointer */ 1113 1114 for (parameter = 1; parameter < tokens; parameter++) { /* look at the other tokens */ 1115 switch (get_keyword(token[parameter], &keyword_set)) { 1116 /* 1117 * If we have a 'name' parameter, it must 1118 * come first, because we're too lazy to tidy 1119 * up dangling refs if it comes later. 1120 */ 1121 case kw_name: 1122 namedsdno = find_subdisk(token[++parameter], 0); /* find an existing sd with this name */ 1123 if (namedsdno >= 0) { /* got one */ 1124 if (SD[namedsdno].state == sd_referenced) { /* we've been told about this one */ 1125 if (parameter > 2) 1126 throw_rude_remark(EINVAL, 1127 "sd %s: name parameter must come first\n", /* no go */ 1128 token[parameter]); 1129 else { 1130 int i; 1131 struct plex *plex; /* for tidying up dangling references */ 1132 1133 *sd = SD[namedsdno]; /* copy from the referenced one */ 1134 sd->sd_dev = NULL; 1135 made_sd(sd); 1136 SD[namedsdno].state = sd_unallocated; /* and deallocate the referenced one */ 1137 made_sd(&SD[namedsdno]); 1138 plex = &PLEX[sd->plexno]; /* now take a look at our plex */ 1139 for (i = 0; i < plex->subdisks; i++) { /* look for the pointer */ 1140 if (plex->sdnos[i] == namedsdno) /* pointing to the old subdisk */ 1141 plex->sdnos[i] = sdno; /* bend it to point here */ 1142 } 1143 } 1144 } 1145 if (update) /* are we updating? */ 1146 return; /* that's OK, nothing more to do */ 1147 else 1148 throw_rude_remark(EINVAL, "Duplicate subdisk %s", token[parameter]); 1149 } else { 1150 ksnprintf(sd->name, sizeof(sd->name), 1151 "%s", token[parameter]); 1152 } 1153 break; 1154 1155 case kw_detached: 1156 detached = 1; 1157 break; 1158 1159 case kw_plexoffset: 1160 size = sizespec(token[++parameter]); 1161 if ((size == -1) /* unallocated */ 1162 &&(vinum_conf.flags & VF_READING_CONFIG)) /* reading from disk */ 1163 break; /* invalid sd; just ignore it */ 1164 if ((size % DEV_BSIZE) != 0) 1165 throw_rude_remark(EINVAL, 1166 "sd %s, bad plex offset alignment: %lld", 1167 sd->name, 1168 (long long) size); 1169 else 1170 sd->plexoffset = size / DEV_BSIZE; 1171 break; 1172 1173 case kw_driveoffset: 1174 size = sizespec(token[++parameter]); 1175 if ((size == -1) /* unallocated */ 1176 &&(vinum_conf.flags & VF_READING_CONFIG)) /* reading from disk */ 1177 break; /* invalid sd; just ignore it */ 1178 if ((size % DEV_BSIZE) != 0) 1179 throw_rude_remark(EINVAL, 1180 "sd %s, bad drive offset alignment: %lld", 1181 sd->name, 1182 (long long) size); 1183 else 1184 sd->driveoffset = size / DEV_BSIZE; 1185 break; 1186 1187 case kw_len: 1188 if (get_keyword(token[++parameter], &keyword_set) == kw_max) /* select maximum size from drive */ 1189 size = 0; /* this is how we say it :-) */ 1190 else 1191 size = sizespec(token[parameter]); 1192 if ((size % DEV_BSIZE) != 0) 1193 throw_rude_remark(EINVAL, "sd %s, length %jd not multiple of sector size", sd->name, (intmax_t)size); 1194 else 1195 sd->sectors = size / DEV_BSIZE; 1196 /* 1197 * We have a problem with autosizing: we need to 1198 * give the drive to the plex before we give it 1199 * to the drive, in order to be clean if we give 1200 * up in the middle, but at this time the size hasn't 1201 * been set. Note that we have to fix up after 1202 * giving the subdisk to the drive. 1203 */ 1204 if (size == 0) 1205 autosize = 1; /* note that we're autosizing */ 1206 break; 1207 1208 case kw_drive: 1209 sd->driveno = find_drive(token[++parameter], 1); /* insert drive information */ 1210 break; 1211 1212 case kw_plex: 1213 sd->plexno = find_plex(token[++parameter], 1); /* insert plex information */ 1214 break; 1215 1216 /* 1217 * Set the state. We can't do this directly, 1218 * because give_sd_to_plex may change it 1219 */ 1220 case kw_state: 1221 parameter++; /* skip the keyword */ 1222 if (vinum_conf.flags & VF_READING_CONFIG) 1223 state = SdState(token[parameter]); /* set the state */ 1224 break; 1225 1226 case kw_partition: 1227 parameter++; /* skip the keyword */ 1228 if ((strlen(token[parameter]) != 1) 1229 || (token[parameter][0] < 'a') 1230 || (token[parameter][0] > 'p')) 1231 throw_rude_remark(EINVAL, 1232 "%s: invalid partition %c", 1233 sd->name, 1234 token[parameter][0]); 1235 else 1236 partition = token[parameter][0]; 1237 break; 1238 1239 case kw_retryerrors: 1240 sd->flags |= VF_RETRYERRORS; 1241 break; 1242 1243 default: 1244 throw_rude_remark(EINVAL, "%s: invalid keyword: %s", sd->name, token[parameter]); 1245 } 1246 } 1247 1248 /* Check we have a drive name */ 1249 if (sd->driveno < 0) { /* didn't specify a drive */ 1250 sd->driveno = current_drive; /* set to the current drive */ 1251 if (sd->driveno < 0) /* no current drive? */ 1252 throw_rude_remark(EINVAL, "Subdisk %s is not associated with a drive", sd->name); 1253 } 1254 /* 1255 * This is tacky. If something goes wrong 1256 * with the checks, we may end up losing drive 1257 * space. FIXME. 1258 */ 1259 if (autosize != 0) /* need to find a size, */ 1260 give_sd_to_drive(sdno); /* do it before the plex */ 1261 1262 /* Check for a plex name */ 1263 if ((sd->plexno < 0) /* didn't specify a plex */ 1264 &&(!detached)) /* and didn't say not to, */ 1265 sd->plexno = current_plex; /* set to the current plex */ 1266 1267 if (sd->plexno >= 0) 1268 sdindex = give_sd_to_plex(sd->plexno, sdno); /* now tell the plex that it has this sd */ 1269 1270 sd->sdno = sdno; /* point to our entry in the table */ 1271 1272 /* Does the subdisk have a name? If not, give it one */ 1273 if (sd->name[0] == '\0') { /* no name */ 1274 char sdsuffix[8]; /* form sd name suffix here */ 1275 1276 /* Do we have a plex name? */ 1277 if (sdindex >= 0) /* we have a plex */ 1278 strcpy(sd->name, PLEX[sd->plexno].name); /* take it from there */ 1279 else /* no way */ 1280 throw_rude_remark(EINVAL, "Unnamed sd is not associated with a plex"); 1281 ksprintf(sdsuffix, ".s%d", sdindex); /* form the suffix */ 1282 strcat(sd->name, sdsuffix); /* and add it to the name */ 1283 } 1284 /* do we have complete info for this subdisk? */ 1285 if (sd->sectors < 0) 1286 throw_rude_remark(EINVAL, "sd %s has no length spec", sd->name); 1287 1288 if (state != sd_unallocated) { /* we had a specific state to set */ 1289 sd->state = state; /* do it now */ 1290 made_sd(sd); 1291 } else if (sd->state == sd_unallocated) { /* no, nothing set yet, */ 1292 sd->state = sd_empty; /* must be empty */ 1293 made_sd(sd); 1294 } 1295 if (autosize == 0) /* no autoconfig, do the drive now */ 1296 give_sd_to_drive(sdno); 1297 vinum_conf.subdisks_used++; /* one more in use */ 1298 } 1299 1300 /* 1301 * Handle a plex definition. 1302 */ 1303 void 1304 config_plex(int update) 1305 { 1306 int parameter; 1307 int plexno; /* index of plex in vinum_conf */ 1308 struct plex *plex; /* and pointer to it */ 1309 int pindex = MAXPLEX; /* index in volume's plex list */ 1310 int detached = 0; /* don't give it to a volume */ 1311 int namedplexno; 1312 enum plexstate state = plex_init; /* state to set at end */ 1313 1314 current_plex = -1; /* forget the previous plex */ 1315 plexno = get_empty_plex(); /* allocate a plex */ 1316 plex = &PLEX[plexno]; /* and point to it */ 1317 plex->plexno = plexno; /* and back to the config */ 1318 1319 for (parameter = 1; parameter < tokens; parameter++) { /* look at the other tokens */ 1320 switch (get_keyword(token[parameter], &keyword_set)) { 1321 /* 1322 * If we have a 'name' parameter, it must 1323 * come first, because we're too lazy to tidy 1324 * up dangling refs if it comes later. 1325 */ 1326 case kw_name: 1327 namedplexno = find_plex(token[++parameter], 0); /* find an existing plex with this name */ 1328 if (namedplexno >= 0) { /* plex exists already, */ 1329 if (PLEX[namedplexno].state == plex_referenced) { /* we've been told about this one */ 1330 if (parameter > 2) /* we've done other things first, */ 1331 throw_rude_remark(EINVAL, 1332 "plex %s: name parameter must come first\n", /* no go */ 1333 token[parameter]); 1334 else { 1335 int i; 1336 struct volume *vol; /* for tidying up dangling references */ 1337 1338 *plex = PLEX[namedplexno]; /* get the info */ 1339 plex->plex_dev = NULL; 1340 made_plex(plex); 1341 PLEX[namedplexno].state = plex_unallocated; /* and deallocate the other one */ 1342 made_plex(&PLEX[namedplexno]); 1343 vol = &VOL[plex->volno]; /* point to the volume */ 1344 for (i = 0; i < MAXPLEX; i++) { /* for each plex */ 1345 if (vol->plex[i] == namedplexno) 1346 vol->plex[i] = plexno; /* bend the pointer */ 1347 } 1348 } 1349 break; /* use this one */ 1350 } 1351 if (update) /* are we updating? */ 1352 return; /* yes: that's OK, just return */ 1353 else 1354 throw_rude_remark(EINVAL, "Duplicate plex %s", token[parameter]); 1355 } else { 1356 ksnprintf(plex->name, sizeof(plex->name), 1357 "%s", token[parameter]); 1358 } 1359 break; 1360 1361 case kw_detached: 1362 detached = 1; 1363 break; 1364 1365 case kw_org: /* plex organization */ 1366 switch (get_keyword(token[++parameter], &keyword_set)) { 1367 case kw_concat: 1368 plex->organization = plex_concat; 1369 break; 1370 1371 case kw_striped: 1372 { 1373 int stripesize = sizespec(token[++parameter]); 1374 1375 plex->organization = plex_striped; 1376 if (stripesize % DEV_BSIZE != 0) /* not a multiple of block size, */ 1377 throw_rude_remark(EINVAL, "plex %s: stripe size %d not a multiple of sector size", 1378 plex->name, 1379 stripesize); 1380 else 1381 plex->stripesize = stripesize / DEV_BSIZE; 1382 break; 1383 } 1384 1385 case kw_raid4: 1386 { 1387 int stripesize = sizespec(token[++parameter]); 1388 1389 plex->organization = plex_raid4; 1390 if (stripesize % DEV_BSIZE != 0) /* not a multiple of block size, */ 1391 throw_rude_remark(EINVAL, "plex %s: stripe size %d not a multiple of sector size", 1392 plex->name, 1393 stripesize); 1394 else 1395 plex->stripesize = stripesize / DEV_BSIZE; 1396 break; 1397 } 1398 1399 case kw_raid5: 1400 { 1401 int stripesize = sizespec(token[++parameter]); 1402 1403 plex->organization = plex_raid5; 1404 if (stripesize % DEV_BSIZE != 0) /* not a multiple of block size, */ 1405 throw_rude_remark(EINVAL, "plex %s: stripe size %d not a multiple of sector size", 1406 plex->name, 1407 stripesize); 1408 else 1409 plex->stripesize = stripesize / DEV_BSIZE; 1410 break; 1411 } 1412 1413 default: 1414 throw_rude_remark(EINVAL, "Invalid plex organization"); 1415 } 1416 if (isstriped(plex) 1417 && (plex->stripesize == 0)) /* didn't specify a valid stripe size */ 1418 throw_rude_remark(EINVAL, "Need a stripe size parameter"); 1419 break; 1420 1421 case kw_volume: 1422 plex->volno = find_volume(token[++parameter], 1); /* insert a pointer to the volume */ 1423 break; 1424 1425 case kw_sd: /* add a subdisk */ 1426 { 1427 int sdno; 1428 1429 sdno = find_subdisk(token[++parameter], 1); /* find a subdisk */ 1430 SD[sdno].plexoffset = sizespec(token[++parameter]); /* get the offset */ 1431 give_sd_to_plex(plexno, sdno); /* and insert it there */ 1432 break; 1433 } 1434 1435 case kw_state: 1436 parameter++; /* skip the keyword */ 1437 if (vinum_conf.flags & VF_READING_CONFIG) 1438 state = PlexState(token[parameter]); /* set the state */ 1439 break; 1440 1441 default: 1442 throw_rude_remark(EINVAL, "plex %s, invalid keyword: %s", 1443 plex->name, 1444 token[parameter]); 1445 } 1446 } 1447 1448 if (plex->organization == plex_disorg) 1449 throw_rude_remark(EINVAL, "No plex organization specified"); 1450 1451 if ((plex->volno < 0) /* we don't have a volume */ 1452 &&(!detached)) /* and we wouldn't object */ 1453 plex->volno = current_volume; 1454 1455 if (plex->volno >= 0) 1456 pindex = give_plex_to_volume(plex->volno, plexno); /* Now tell the volume that it has this plex */ 1457 1458 /* Does the plex have a name? If not, give it one */ 1459 if (plex->name[0] == '\0') { /* no name */ 1460 char plexsuffix[8]; /* form plex name suffix here */ 1461 /* Do we have a volume name? */ 1462 if (plex->volno >= 0) /* we have a volume */ 1463 strcpy(plex->name, /* take it from there */ 1464 VOL[plex->volno].name); 1465 else /* no way */ 1466 throw_rude_remark(EINVAL, "Unnamed plex is not associated with a volume"); 1467 ksprintf(plexsuffix, ".p%d", pindex); /* form the suffix */ 1468 strcat(plex->name, plexsuffix); /* and add it to the name */ 1469 } 1470 if (isstriped(plex)) { 1471 plex->lock = (struct rangelock *) 1472 Malloc(PLEX_LOCKS * sizeof(struct rangelock)); 1473 CHECKALLOC(plex->lock, "vinum: Can't allocate lock table\n"); 1474 bzero((char *) plex->lock, PLEX_LOCKS * sizeof(struct rangelock)); 1475 } 1476 /* Note the last plex we configured */ 1477 current_plex = plexno; 1478 plex->state = state; /* set whatever state we chose */ 1479 made_plex(plex); 1480 vinum_conf.plexes_used++; /* one more in use */ 1481 } 1482 1483 /* 1484 * Handle a volume definition. 1485 * If we find an error, print a message, deallocate the nascent volume, and return 1486 */ 1487 void 1488 config_volume(int update) 1489 { 1490 int parameter; 1491 int volno; 1492 struct volume *vol; /* collect volume info here */ 1493 int i; 1494 1495 if (tokens < 2) /* not enough tokens */ 1496 throw_rude_remark(EINVAL, "Volume has no name"); 1497 current_volume = -1; /* forget the previous volume */ 1498 volno = find_volume(token[1], 1); /* allocate a volume to initialize */ 1499 vol = &VOL[volno]; /* and get a pointer */ 1500 if (update && ((vol->flags & VF_CREATED) == 0)) /* this volume exists already */ 1501 return; /* don't do anything */ 1502 vol->flags &= ~VF_CREATED; /* it exists now */ 1503 1504 for (parameter = 2; parameter < tokens; parameter++) { /* look at all tokens */ 1505 switch (get_keyword(token[parameter], &keyword_set)) { 1506 case kw_plex: 1507 { 1508 int plexno; /* index of this plex */ 1509 int myplexno; /* and index if it's already ours */ 1510 1511 plexno = find_plex(token[++parameter], 1); /* find a plex */ 1512 if (plexno < 0) /* couldn't */ 1513 break; /* we've already had an error message */ 1514 myplexno = my_plex(volno, plexno); /* does it already belong to us? */ 1515 if (myplexno > 0) /* yes, shouldn't get it again */ 1516 throw_rude_remark(EINVAL, 1517 "Plex %s already belongs to volume %s", 1518 token[parameter], 1519 vol->name); 1520 else if (vol->plexes + 1 > 8) /* another entry */ 1521 throw_rude_remark(EINVAL, 1522 "Too many plexes for volume %s", 1523 vol->name); 1524 vol->plex[vol->plexes] = plexno; 1525 vol->plexes++; 1526 PLEX[plexno].state = plex_referenced; /* we know something about it */ 1527 PLEX[plexno].volno = volno; /* and this volume references it */ 1528 } 1529 break; 1530 1531 case kw_readpol: 1532 switch (get_keyword(token[++parameter], &keyword_set)) { /* decide what to do */ 1533 case kw_round: 1534 vol->preferred_plex = ROUND_ROBIN_READPOL; /* default */ 1535 break; 1536 1537 case kw_prefer: 1538 { 1539 int myplexno; /* index of this plex */ 1540 1541 myplexno = find_plex(token[++parameter], 1); /* find a plex */ 1542 if (myplexno < 0) /* couldn't */ 1543 break; /* we've already had an error message */ 1544 myplexno = my_plex(volno, myplexno); /* does it already belong to us? */ 1545 if (myplexno > 0) /* yes */ 1546 vol->preferred_plex = myplexno; /* just note the index */ 1547 else if (++vol->plexes > 8) /* another entry */ 1548 throw_rude_remark(EINVAL, "Too many plexes"); 1549 else { /* space for the new plex */ 1550 vol->plex[vol->plexes - 1] = myplexno; /* add it to our list */ 1551 vol->preferred_plex = vol->plexes - 1; /* and note the index */ 1552 } 1553 } 1554 break; 1555 1556 default: 1557 throw_rude_remark(EINVAL, "Invalid read policy"); 1558 } 1559 1560 case kw_setupstate: 1561 vol->flags |= VF_CONFIG_SETUPSTATE; /* set the volume up later on */ 1562 break; 1563 1564 case kw_state: 1565 parameter++; /* skip the keyword */ 1566 if (vinum_conf.flags & VF_READING_CONFIG) { 1567 vol->state = VolState(token[parameter]); /* set the state */ 1568 vol->volno = volno; /* needs correct volno to make devs */ 1569 made_vol(vol); 1570 } 1571 break; 1572 1573 /* 1574 * XXX experimental ideas. These are not 1575 * documented, and will not be until I 1576 * decide they're worth keeping 1577 */ 1578 case kw_writethrough: /* set writethrough mode */ 1579 vol->flags |= VF_WRITETHROUGH; 1580 break; 1581 1582 case kw_writeback: /* set writeback mode */ 1583 vol->flags &= ~VF_WRITETHROUGH; 1584 break; 1585 1586 case kw_raw: 1587 vol->flags |= VF_RAW; /* raw volume (no label) */ 1588 break; 1589 1590 default: 1591 throw_rude_remark(EINVAL, "volume %s, invalid keyword: %s", 1592 vol->name, 1593 token[parameter]); 1594 } 1595 } 1596 current_volume = volno; /* note last referred volume */ 1597 vol->volno = volno; /* also note in volume */ 1598 1599 /* 1600 * Before we can actually use the volume, we need 1601 * a volume label. We could start to fake one here, 1602 * but it will be a lot easier when we have some 1603 * to copy from the drives, so defer it until we 1604 * set up the configuration. XXX 1605 */ 1606 if (vol->state == volume_unallocated) { 1607 vol->state = volume_down; /* now ready to bring up at the end */ 1608 made_vol(vol); 1609 } 1610 1611 /* Find out how big our volume is */ 1612 for (i = 0; i < vol->plexes; i++) 1613 vol->size = u64max(vol->size, PLEX[vol->plex[i]].length); 1614 vinum_conf.volumes_used++; /* one more in use */ 1615 } 1616 1617 /* 1618 * Parse a config entry. CARE! This destroys the original contents of the 1619 * config entry, which we don't really need after this. More specifically, it 1620 * places \0 characters at the end of each token. 1621 * 1622 * Return 0 if all is well, otherwise EINVAL for invalid keyword, 1623 * or ENOENT if 'read' command doesn't find any drives. 1624 */ 1625 int 1626 parse_config(char *cptr, struct keywordset *keyset, int update) 1627 { 1628 int status; 1629 1630 status = 0; /* until proven otherwise */ 1631 tokens = tokenize(cptr, token); /* chop up into tokens */ 1632 1633 if (tokens <= 0) /* screwed up or empty line */ 1634 return tokens; /* give up */ 1635 1636 if (token[0][0] == '#') /* comment line */ 1637 return 0; 1638 1639 switch (get_keyword(token[0], keyset)) { /* decide what to do */ 1640 case kw_read: /* read config from a specified drive */ 1641 status = vinum_scandisk(&token[1], tokens - 1); /* read the config from disk */ 1642 break; 1643 1644 case kw_drive: 1645 config_drive(update); 1646 break; 1647 1648 case kw_subdisk: 1649 config_subdisk(update); 1650 break; 1651 1652 case kw_plex: 1653 config_plex(update); 1654 break; 1655 1656 case kw_volume: 1657 config_volume(update); 1658 break; 1659 1660 /* Anything else is invalid in this context */ 1661 default: 1662 throw_rude_remark(EINVAL, /* should we die? */ 1663 "Invalid configuration information: %s", 1664 token[0]); 1665 } 1666 return status; 1667 } 1668 1669 /* 1670 * parse a line handed in from userland via ioctl. 1671 * This differs only by the error reporting mechanism: 1672 * we return the error indication in the reply to the 1673 * ioctl, so we need to set a global static pointer in 1674 * this file. This technique works because we have 1675 * ensured that configuration is performed in a single- 1676 * threaded manner 1677 */ 1678 int 1679 parse_user_config(char *cptr, struct keywordset *keyset) 1680 { 1681 int status; 1682 1683 ioctl_reply = (struct _ioctl_reply *) cptr; 1684 status = parse_config(cptr, keyset, 0); 1685 if (status == ENOENT) /* from scandisk, but it can't tell us */ 1686 strcpy(ioctl_reply->msg, "no drives found"); 1687 ioctl_reply = NULL; /* don't do this again */ 1688 return status; 1689 } 1690 1691 /* Remove an object */ 1692 void 1693 remove(struct vinum_ioctl_msg *msg) 1694 { 1695 struct vinum_ioctl_msg message = *msg; /* make a copy to hand on */ 1696 1697 ioctl_reply = (struct _ioctl_reply *) msg; /* reinstate the address to reply to */ 1698 ioctl_reply->error = 0; /* no error, */ 1699 ioctl_reply->msg[0] = '\0'; /* no message */ 1700 1701 switch (message.type) { 1702 case drive_object: 1703 remove_drive_entry(message.index, message.force); 1704 updateconfig(0); 1705 return; 1706 1707 case sd_object: 1708 remove_sd_entry(message.index, message.force, message.recurse); 1709 updateconfig(0); 1710 return; 1711 1712 case plex_object: 1713 remove_plex_entry(message.index, message.force, message.recurse); 1714 updateconfig(0); 1715 return; 1716 1717 case volume_object: 1718 remove_volume_entry(message.index, message.force, message.recurse); 1719 updateconfig(0); 1720 return; 1721 1722 default: 1723 ioctl_reply->error = EINVAL; 1724 strcpy(ioctl_reply->msg, "Invalid object type"); 1725 } 1726 } 1727 1728 /* Remove a drive. */ 1729 void 1730 remove_drive_entry(int driveno, int force) 1731 { 1732 struct drive *drive = &DRIVE[driveno]; 1733 int sdno; 1734 1735 if ((driveno > vinum_conf.drives_allocated) /* not a valid drive */ 1736 ||(drive->state == drive_unallocated)) { /* or nothing there */ 1737 ioctl_reply->error = EINVAL; 1738 strcpy(ioctl_reply->msg, "No such drive"); 1739 } else if (drive->opencount > 0) { /* we have subdisks */ 1740 if (force) { /* do it at any cost */ 1741 for (sdno = 0; sdno < vinum_conf.subdisks_allocated; sdno++) { 1742 if ((SD[sdno].state != sd_unallocated) /* subdisk is allocated */ 1743 &&(SD[sdno].driveno == driveno)) /* and it belongs to this drive */ 1744 remove_sd_entry(sdno, force, 0); 1745 } 1746 remove_drive(driveno); /* now remove it */ 1747 vinum_conf.drives_used--; /* one less drive */ 1748 } else 1749 ioctl_reply->error = EBUSY; /* can't do that */ 1750 } else { 1751 remove_drive(driveno); /* just remove it */ 1752 vinum_conf.drives_used--; /* one less drive */ 1753 } 1754 } 1755 1756 /* remove a subdisk */ 1757 void 1758 remove_sd_entry(int sdno, int force, int recurse) 1759 { 1760 struct sd *sd = &SD[sdno]; 1761 1762 if ((sdno > vinum_conf.subdisks_allocated) /* not a valid sd */ 1763 ||(sd->state == sd_unallocated)) { /* or nothing there */ 1764 ioctl_reply->error = EINVAL; 1765 strcpy(ioctl_reply->msg, "No such subdisk"); 1766 } else if (sd->flags & VF_OPEN) { /* we're open */ 1767 ioctl_reply->error = EBUSY; /* no getting around that */ 1768 return; 1769 } else if (sd->plexno >= 0) { /* we have a plex */ 1770 if (force) { /* do it at any cost */ 1771 struct plex *plex = &PLEX[sd->plexno]; /* point to our plex */ 1772 int mysdno; 1773 1774 for (mysdno = 0; /* look for ourselves */ 1775 mysdno < plex->subdisks && &SD[plex->sdnos[mysdno]] != sd; 1776 mysdno++); 1777 if (mysdno == plex->subdisks) /* didn't find it */ 1778 log(LOG_ERR, 1779 "Error removing subdisk %s: not found in plex %s\n", 1780 SD[mysdno].name, 1781 plex->name); 1782 else { /* remove the subdisk from plex */ 1783 if (mysdno < (plex->subdisks - 1)) /* not the last subdisk */ 1784 bcopy(&plex->sdnos[mysdno + 1], 1785 &plex->sdnos[mysdno], 1786 (plex->subdisks - 1 - mysdno) * sizeof(int)); 1787 plex->subdisks--; 1788 sd->plexno = -1; /* disown the subdisk */ 1789 } 1790 1791 /* 1792 * Removing a subdisk from a striped or 1793 * RAID-4 or RAID-5 plex really tears the 1794 * hell out of the structure, and it needs 1795 * to be reinitialized. 1796 */ 1797 if (plex->organization != plex_concat) /* not concatenated, */ 1798 set_plex_state(plex->plexno, plex_faulty, setstate_force); /* need to reinitialize */ 1799 log(LOG_INFO, "vinum: removing %s\n", sd->name); 1800 free_sd(sdno); 1801 } else 1802 ioctl_reply->error = EBUSY; /* can't do that */ 1803 } else { 1804 log(LOG_INFO, "vinum: removing %s\n", sd->name); 1805 free_sd(sdno); 1806 } 1807 } 1808 1809 /* remove a plex */ 1810 void 1811 remove_plex_entry(int plexno, int force, int recurse) 1812 { 1813 struct plex *plex = &PLEX[plexno]; 1814 int sdno; 1815 1816 if ((plexno > vinum_conf.plexes_allocated) /* not a valid plex */ 1817 ||(plex->state == plex_unallocated)) { /* or nothing there */ 1818 ioctl_reply->error = EINVAL; 1819 strcpy(ioctl_reply->msg, "No such plex"); 1820 } else if (plex->flags & VF_OPEN) { /* we're open */ 1821 ioctl_reply->error = EBUSY; /* no getting around that */ 1822 return; 1823 } 1824 if (plex->subdisks) { 1825 if (force) { /* do it anyway */ 1826 if (recurse) { /* remove all below */ 1827 int sds = plex->subdisks; 1828 for (sdno = 0; sdno < sds; sdno++) 1829 free_sd(plex->sdnos[sdno]); /* free all subdisks */ 1830 } else { /* just tear them out */ 1831 int sds = plex->subdisks; 1832 for (sdno = 0; sdno < sds; sdno++) 1833 SD[plex->sdnos[sdno]].plexno = -1; /* no plex any more */ 1834 } 1835 } else { /* can't do it without force */ 1836 ioctl_reply->error = EBUSY; /* can't do that */ 1837 return; 1838 } 1839 } 1840 if (plex->volno >= 0) { /* we are part of a volume */ 1841 if (force) { /* do it at any cost */ 1842 struct volume *vol = &VOL[plex->volno]; 1843 int myplexno; 1844 1845 for (myplexno = 0; myplexno < vol->plexes; myplexno++) 1846 if (vol->plex[myplexno] == plexno) /* found it */ 1847 break; 1848 if (myplexno == vol->plexes) /* didn't find it. Huh? */ 1849 log(LOG_ERR, 1850 "Error removing plex %s: not found in volume %s\n", 1851 plex->name, 1852 vol->name); 1853 if (myplexno < (vol->plexes - 1)) /* not the last plex in the list */ 1854 bcopy(&vol->plex[myplexno + 1], 1855 &vol->plex[myplexno], 1856 vol->plexes - 1 - myplexno); 1857 vol->plexes--; 1858 } else { 1859 ioctl_reply->error = EBUSY; /* can't do that */ 1860 return; 1861 } 1862 } 1863 log(LOG_INFO, "vinum: removing %s\n", plex->name); 1864 free_plex(plexno); 1865 vinum_conf.plexes_used--; /* one less plex */ 1866 } 1867 1868 /* remove a volume */ 1869 void 1870 remove_volume_entry(int volno, int force, int recurse) 1871 { 1872 struct volume *vol = &VOL[volno]; 1873 int plexno; 1874 1875 if ((volno > vinum_conf.volumes_allocated) /* not a valid volume */ 1876 ||(vol->state == volume_unallocated)) { /* or nothing there */ 1877 ioctl_reply->error = EINVAL; 1878 strcpy(ioctl_reply->msg, "No such volume"); 1879 } else if (vol->flags & VF_OPEN) /* we're open */ 1880 ioctl_reply->error = EBUSY; /* no getting around that */ 1881 else if (vol->plexes) { 1882 if (recurse && force) { /* remove all below */ 1883 int plexes = vol->plexes; 1884 1885 /* for (plexno = plexes - 1; plexno >= 0; plexno--) */ 1886 for (plexno = 0; plexno < plexes; plexno++) 1887 remove_plex_entry(vol->plex[plexno], force, recurse); 1888 log(LOG_INFO, "vinum: removing %s\n", vol->name); 1889 free_volume(volno); 1890 vinum_conf.volumes_used--; /* one less volume */ 1891 } else 1892 ioctl_reply->error = EBUSY; /* can't do that */ 1893 } else { 1894 log(LOG_INFO, "vinum: removing %s\n", vol->name); 1895 free_volume(volno); 1896 vinum_conf.volumes_used--; /* one less volume */ 1897 } 1898 } 1899 1900 /* Currently called only from ioctl */ 1901 void 1902 update_sd_config(int sdno, int diskconfig) 1903 { 1904 if (!diskconfig) 1905 set_sd_state(sdno, sd_up, setstate_configuring); 1906 SD[sdno].flags &= ~VF_NEWBORN; 1907 } 1908 1909 void 1910 update_plex_config(int plexno, int diskconfig) 1911 { 1912 u_int64_t size; 1913 int sdno; 1914 struct plex *plex = &PLEX[plexno]; 1915 enum plexstate state = plex_up; /* state we want the plex in */ 1916 int remainder; /* size of fractional stripe at end */ 1917 int added_plex; /* set if we add a plex to a volume */ 1918 int required_sds; /* number of subdisks we need */ 1919 struct sd *sd; 1920 struct volume *vol; 1921 int data_sds = 0; /* number of sds carrying data */ 1922 1923 if (plex->state < plex_init) /* not a real plex, */ 1924 return; 1925 added_plex = 0; 1926 if (plex->volno >= 0) { /* we have a volume */ 1927 vol = &VOL[plex->volno]; 1928 1929 /* 1930 * If we're newly born, 1931 * and the volume isn't, 1932 * and it has other plexes, 1933 * and we didn't read this mess from disk, 1934 * we were added later. 1935 */ 1936 if ((plex->flags & VF_NEWBORN) 1937 && ((vol->flags & VF_NEWBORN) == 0) 1938 && (vol->plexes > 0) 1939 && (diskconfig == 0)) { 1940 added_plex = 1; 1941 state = plex_down; /* so take ourselves down */ 1942 } 1943 } 1944 /* 1945 * Check that our subdisks make sense. For 1946 * striped, RAID-4 and RAID-5 plexes, we need at 1947 * least two subdisks, and they must all be the 1948 * same size. 1949 */ 1950 if (plex->organization == plex_striped) { 1951 data_sds = plex->subdisks; 1952 required_sds = 2; 1953 } else if (isparity(plex)) { /* RAID 4 or 5 */ 1954 data_sds = plex->subdisks - 1; 1955 required_sds = 3; 1956 } else 1957 required_sds = 0; 1958 if (required_sds > 0) { /* striped, RAID-4 or RAID-5 */ 1959 if (plex->subdisks < required_sds) { 1960 log(LOG_ERR, 1961 "vinum: plex %s does not have at least %d subdisks\n", 1962 plex->name, 1963 required_sds); 1964 state = plex_faulty; 1965 } 1966 /* 1967 * Now see if the plex size is a multiple of 1968 * the stripe size. If not, trim off the end 1969 * of each subdisk and return it to the drive. 1970 */ 1971 if (plex->length > 0) { 1972 if (data_sds > 0) { 1973 if (plex->stripesize > 0) { 1974 remainder = (int) (plex->length /* are we exact? */ 1975 % ((u_int64_t) plex->stripesize * data_sds)); 1976 if (remainder) { /* no */ 1977 log(LOG_INFO, "vinum: removing %d blocks of partial stripe at the end of %s\n", 1978 remainder, 1979 plex->name); 1980 plex->length -= remainder; /* shorten the plex */ 1981 remainder /= data_sds; /* spread the remainder amongst the sds */ 1982 for (sdno = 0; sdno < plex->subdisks; sdno++) { 1983 sd = &SD[plex->sdnos[sdno]]; /* point to the subdisk */ 1984 return_drive_space(sd->driveno, /* return the space */ 1985 sd->driveoffset + sd->sectors - remainder, 1986 remainder); 1987 sd->sectors -= remainder; /* and shorten it */ 1988 } 1989 } 1990 } else /* no data sds, */ 1991 plex->length = 0; /* reset length */ 1992 } 1993 } 1994 } 1995 size = 0; 1996 for (sdno = 0; sdno < plex->subdisks; sdno++) { 1997 sd = &SD[plex->sdnos[sdno]]; 1998 if (isstriped(plex) 1999 && (sdno > 0) 2000 && (sd->sectors != SD[plex->sdnos[sdno - 1]].sectors)) { 2001 log(LOG_ERR, "vinum: %s must have equal sized subdisks\n", plex->name); 2002 state = plex_down; 2003 } 2004 size += sd->sectors; 2005 if (added_plex) { /* we were added later */ 2006 sd->state = sd_stale; /* stale until proven otherwise */ 2007 made_sd(sd); 2008 } 2009 } 2010 2011 if (plex->subdisks) { /* plex has subdisks, calculate size */ 2012 /* 2013 * XXX We shouldn't need to calculate the size any 2014 * more. Check this some time 2015 */ 2016 if (isparity(plex)) 2017 size = size / plex->subdisks * (plex->subdisks - 1); /* less space for RAID-4 and RAID-5 */ 2018 if (plex->length != size) 2019 log(LOG_INFO, 2020 "Correcting length of %s: was %lld, is %lld\n", 2021 plex->name, 2022 (long long) plex->length, 2023 (long long) size); 2024 plex->length = size; 2025 } else { /* no subdisks, */ 2026 plex->length = 0; /* no size */ 2027 state = plex_down; /* take it down */ 2028 } 2029 update_plex_state(plexno); /* set the state */ 2030 plex->flags &= ~VF_NEWBORN; 2031 } 2032 2033 void 2034 update_volume_config(int volno, int diskconfig) 2035 { 2036 struct volume *vol = &VOL[volno]; 2037 struct plex *plex; 2038 int plexno; 2039 2040 if (vol->state != volume_unallocated) 2041 /* 2042 * Recalculate the size of the volume, 2043 * which might change if the original 2044 * plexes were not a multiple of the 2045 * stripe size. 2046 */ 2047 { 2048 vol->size = 0; 2049 for (plexno = 0; plexno < vol->plexes; plexno++) { 2050 plex = &PLEX[vol->plex[plexno]]; 2051 vol->size = u64max(plex->length, vol->size); 2052 plex->volplexno = plexno; /* note it in the plex */ 2053 } 2054 } 2055 vol->flags &= ~VF_NEWBORN; /* no longer newly born */ 2056 } 2057 2058 /* 2059 * Update the global configuration. 2060 * diskconfig is != 0 if we're reading in a config 2061 * from disk. In this case, we don't try to 2062 * bring the devices up, though we will bring 2063 * them down if there's some error which got 2064 * missed when writing to disk. 2065 */ 2066 void 2067 updateconfig(int diskconfig) 2068 { 2069 int plexno; 2070 int volno; 2071 2072 for (plexno = 0; plexno < vinum_conf.plexes_allocated; plexno++) 2073 update_plex_config(plexno, diskconfig); 2074 2075 for (volno = 0; volno < vinum_conf.volumes_allocated; volno++) { 2076 if (VOL[volno].state > volume_uninit) { 2077 VOL[volno].flags &= ~VF_CONFIG_SETUPSTATE; /* no more setupstate */ 2078 update_volume_state(volno); 2079 update_volume_config(volno, diskconfig); 2080 } 2081 } 2082 save_config(); 2083 } 2084 2085 /* 2086 * Start manual changes to the configuration and lock out 2087 * others who may wish to do so. 2088 * XXX why do we need this and lock_config too? 2089 */ 2090 int 2091 start_config(int force) 2092 { 2093 int error; 2094 2095 current_drive = -1; /* note the last drive we mention, for 2096 * some defaults */ 2097 current_plex = -1; /* and the same for the last plex */ 2098 current_volume = -1; /* and the last volume */ 2099 while ((vinum_conf.flags & VF_CONFIGURING) != 0) { 2100 vinum_conf.flags |= VF_WILL_CONFIGURE; 2101 if ((error = tsleep(&vinum_conf, PCATCH, "vincfg", 0)) != 0) 2102 return error; 2103 } 2104 /* 2105 * We need two flags here: VF_CONFIGURING 2106 * tells other processes to hold off (this 2107 * function), and VF_CONFIG_INCOMPLETE 2108 * tells the state change routines not to 2109 * propagate incrememntal state changes 2110 */ 2111 vinum_conf.flags |= VF_CONFIGURING | VF_CONFIG_INCOMPLETE; 2112 if (force) 2113 vinum_conf.flags |= VF_FORCECONFIG; /* overwrite differently named drives */ 2114 current_drive = -1; /* reset the defaults */ 2115 current_plex = -1; /* and the same for the last plex */ 2116 current_volume = -1; /* and the last volme */ 2117 return 0; 2118 } 2119 2120 /* 2121 * Update the config if update is 1, and unlock 2122 * it. We won't update the configuration if we 2123 * are called in a recursive loop via throw_rude_remark. 2124 */ 2125 void 2126 finish_config(int update) 2127 { 2128 /* we've finished our config */ 2129 vinum_conf.flags &= ~(VF_CONFIG_INCOMPLETE | VF_READING_CONFIG | VF_FORCECONFIG); 2130 if (update) 2131 updateconfig(0); /* so update things */ 2132 else 2133 updateconfig(1); /* do some updates only */ 2134 vinum_conf.flags &= ~VF_CONFIGURING; /* and now other people can take a turn */ 2135 if ((vinum_conf.flags & VF_WILL_CONFIGURE) != 0) { 2136 vinum_conf.flags &= ~VF_WILL_CONFIGURE; 2137 wakeup_one(&vinum_conf); 2138 } 2139 } 2140 /* Local Variables: */ 2141 /* fill-column: 50 */ 2142 /* End: */ 2143