1 /*- 2 * Copyright (c) 1997, 1998 3 * Nan Yang Computer Services Limited. All rights reserved. 4 * 5 * This software is distributed under the so-called ``Berkeley 6 * License'': 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. All advertising materials mentioning features or use of this software 17 * must display the following acknowledgement: 18 * This product includes software developed by Nan Yang Computer 19 * Services Limited. 20 * 4. Neither the name of the Company nor the names of its contributors 21 * may be used to endorse or promote products derived from this software 22 * without specific prior written permission. 23 * 24 * This software is provided ``as is'', and any express or implied 25 * warranties, including, but not limited to, the implied warranties of 26 * merchantability and fitness for a particular purpose are disclaimed. 27 * In no event shall the company or contributors be liable for any 28 * direct, indirect, incidental, special, exemplary, or consequential 29 * damages (including, but not limited to, procurement of substitute 30 * goods or services; loss of use, data, or profits; or business 31 * interruption) however caused and on any theory of liability, whether 32 * in contract, strict liability, or tort (including negligence or 33 * otherwise) arising in any way out of the use of this software, even if 34 * advised of the possibility of such damage. 35 * 36 * $Id: vinumio.c,v 1.30 2000/05/10 23:23:30 grog Exp grog $ 37 * $FreeBSD: src/sys/dev/vinum/vinumio.c,v 1.52.2.6 2002/05/02 08:43:44 grog Exp $ 38 */ 39 40 #include "vinumhdr.h" 41 #include "request.h" 42 #include <vm/vm_zone.h> 43 #include <sys/nlookup.h> 44 45 static char *sappend(char *txt, char *s); 46 static int drivecmp(const void *va, const void *vb); 47 48 /* 49 * Open the device associated with the drive, and set drive's vp. 50 * Return an error number 51 */ 52 int 53 open_drive(struct drive *drive, struct proc *p, int verbose) 54 { 55 struct nlookupdata nd; 56 int error; 57 58 /* 59 * Fail if already open 60 */ 61 if (drive->flags & VF_OPEN) 62 return EBUSY; 63 64 if (rootdev) { 65 /* 66 * Open via filesystem (future) 67 */ 68 error = nlookup_init(&nd, drive->devicename, UIO_SYSSPACE, NLC_FOLLOW); 69 if (error) 70 return error; 71 error = vn_open(&nd, NULL, FREAD|FWRITE, 0); 72 drive->vp = nd.nl_open_vp; 73 nd.nl_open_vp = NULL; 74 nlookup_done(&nd); 75 } else { 76 /* 77 * Open via synthesized vnode backed by disk device 78 */ 79 error = vn_opendisk(drive->devicename, FREAD|FWRITE, &drive->vp); 80 if (error) 81 return error; 82 } 83 84 if (error == 0 && drive->vp == NULL) 85 error = ENODEV; 86 87 /* 88 * A huge amount of pollution all over vinum requires that our low 89 * level drive be a device. 90 */ 91 if (error == 0 && drive->vp->v_type != VCHR) { 92 vn_close(drive->vp, FREAD|FWRITE, NULL); 93 drive->vp = NULL; 94 error = ENODEV; 95 } 96 if (error) { 97 drive->state = drive_down; 98 if (verbose) { 99 log(LOG_WARNING, 100 "vinum open_drive %s: failed with error %d\n", 101 drive->devicename, error); 102 } 103 } else { 104 drive->dev = drive->vp->v_rdev; 105 drive->flags |= VF_OPEN; 106 } 107 drive->lasterror = error; 108 return error; 109 } 110 111 /* 112 * Set some variables in the drive struct 113 * in more convenient form. Return error indication 114 */ 115 int 116 set_drive_parms(struct drive *drive) 117 { 118 drive->blocksize = BLKDEV_IOSIZE; /* do we need this? */ 119 drive->secsperblock = drive->blocksize /* number of sectors per block */ 120 / drive->partinfo.media_blksize; 121 122 /* Now update the label part */ 123 bcopy(hostname, drive->label.sysname, VINUMHOSTNAMELEN); /* put in host name */ 124 getmicrotime(&drive->label.date_of_birth); /* and current time */ 125 drive->label.drive_size = drive->partinfo.media_size; 126 #if VINUMDEBUG 127 if (debug & DEBUG_BIGDRIVE) /* pretend we're 100 times as big */ 128 drive->label.drive_size *= 100; 129 #endif 130 131 /* number of sectors available for subdisks */ 132 drive->sectors_available = drive->label.drive_size / DEV_BSIZE - DATASTART; 133 134 /* 135 * Bug in 3.0 as of January 1998: you can open 136 * non-existent slices. They have a length of 0. 137 */ 138 if (drive->label.drive_size < MINVINUMSLICE) { /* too small to worry about */ 139 set_drive_state(drive->driveno, drive_down, setstate_force); 140 drive->lasterror = ENOSPC; 141 return ENOSPC; 142 } 143 drive->freelist_size = INITIAL_DRIVE_FREELIST; /* initial number of entries */ 144 drive->freelist = (struct drive_freelist *) 145 Malloc(INITIAL_DRIVE_FREELIST * sizeof(struct drive_freelist)); 146 if (drive->freelist == NULL) /* can't malloc, dammit */ 147 return ENOSPC; 148 drive->freelist_entries = 1; /* just (almost) the complete drive */ 149 drive->freelist[0].offset = DATASTART; /* starts here */ 150 drive->freelist[0].sectors = (drive->label.drive_size >> DEV_BSHIFT) - DATASTART; /* and it's this long */ 151 if (drive->label.name[0] != '\0') /* got a name */ 152 set_drive_state(drive->driveno, drive_up, setstate_force); /* our drive is accessible */ 153 else /* we know about it, but that's all */ 154 drive->state = drive_referenced; 155 return 0; 156 } 157 158 /* 159 * Initialize a drive: open the device and add device 160 * information 161 */ 162 int 163 init_drive(struct drive *drive, int verbose) 164 { 165 if (drive->devicename[0] != '/') { 166 drive->lasterror = EINVAL; 167 log(LOG_ERR, "vinum: Can't open drive without drive name (%s)\n", 168 drive->devicename); 169 return EINVAL; 170 } 171 drive->lasterror = open_drive(drive, curproc, verbose); /* open the drive */ 172 if (drive->lasterror) 173 return drive->lasterror; 174 175 drive->lasterror = VOP_IOCTL(drive->vp, DIOCGPART, 176 (caddr_t)&drive->partinfo, FREAD|FWRITE, 177 proc0.p_ucred, NULL); 178 if (drive->lasterror) { 179 if (verbose) 180 log(LOG_WARNING, 181 "vinum open_drive %s: Can't get partition information, drive->lasterror %d\n", 182 drive->devicename, 183 drive->lasterror); 184 close_drive(drive); 185 return drive->lasterror; 186 } 187 if (drive->partinfo.fstype != FS_VINUM && 188 !kuuid_is_vinum(&drive->partinfo.fstype_uuid) 189 ) { 190 drive->lasterror = EFTYPE; 191 if (verbose) 192 log(LOG_WARNING, 193 "vinum open_drive %s: Wrong partition type for vinum\n", 194 drive->devicename); 195 close_drive(drive); 196 return EFTYPE; 197 } 198 return set_drive_parms(drive); /* set various odds and ends */ 199 } 200 201 /* Close a drive if it's open. */ 202 void 203 close_drive(struct drive *drive) 204 { 205 LOCKDRIVE(drive); /* keep the daemon out */ 206 if (drive->flags & VF_OPEN) 207 close_locked_drive(drive); /* and close it */ 208 if (drive->state > drive_down) /* if it's up */ 209 drive->state = drive_down; /* make sure it's down */ 210 unlockdrive(drive); 211 } 212 213 /* 214 * Real drive close code, called with drive already locked. 215 * We have also checked that the drive is open. No errors. 216 */ 217 void 218 close_locked_drive(struct drive *drive) 219 { 220 /* 221 * If we can't access the drive, we can't flush 222 * the queues, which spec_close() will try to 223 * do. Get rid of them here first. 224 */ 225 if (drive->vp) { 226 drive->lasterror = vn_close(drive->vp, FREAD|FWRITE, NULL); 227 drive->vp = NULL; 228 } 229 drive->flags &= ~VF_OPEN; 230 } 231 232 /* 233 * Remove drive from the configuration. 234 * Caller must ensure that it isn't active. 235 */ 236 void 237 remove_drive(int driveno) 238 { 239 struct drive *drive = &vinum_conf.drive[driveno]; 240 struct vinum_hdr *vhdr; /* buffer for header */ 241 int error; 242 243 if (drive->state > drive_referenced) { /* real drive */ 244 if (drive->state == drive_up) { 245 vhdr = (struct vinum_hdr *) Malloc(VINUMHEADERLEN); /* allocate buffer */ 246 CHECKALLOC(vhdr, "Can't allocate memory"); 247 error = read_drive(drive, (void *) vhdr, VINUMHEADERLEN, VINUM_LABEL_OFFSET); 248 if (error) 249 drive->lasterror = error; 250 else { 251 vhdr->magic = VINUM_NOMAGIC; /* obliterate the magic, but leave the rest */ 252 write_drive(drive, (void *) vhdr, VINUMHEADERLEN, VINUM_LABEL_OFFSET); 253 } 254 Free(vhdr); 255 } 256 free_drive(drive); /* close it and free resources */ 257 save_config(); /* and save the updated configuration */ 258 } 259 } 260 261 /* 262 * Transfer drive data. Usually called from one of these defines; 263 * #define read_drive(a, b, c, d) driveio (a, b, c, d, BUF_CMD_READ) 264 * #define write_drive(a, b, c, d) driveio (a, b, c, d, BUF_CMD_WRITE) 265 * 266 * length and offset are in bytes, but must be multiples of sector 267 * size. The function *does not check* for this condition, and 268 * truncates ruthlessly. 269 * Return error number 270 */ 271 int 272 driveio(struct drive *drive, char *buf, size_t length, off_t offset, buf_cmd_t cmd) 273 { 274 int error; 275 struct buf *bp; 276 caddr_t saveaddr; 277 278 error = 0; /* to keep the compiler happy */ 279 while (length) { /* divide into small enough blocks */ 280 int len = umin(length, MAXBSIZE); /* maximum block device transfer is MAXBSIZE */ 281 282 bp = geteblk(len); /* get a buffer header */ 283 bp->b_cmd = cmd; 284 bp->b_bio1.bio_offset = offset; /* disk offset */ 285 bp->b_bio1.bio_done = biodone_sync; 286 bp->b_bio1.bio_flags |= BIO_SYNC; 287 saveaddr = bp->b_data; 288 bp->b_data = buf; 289 bp->b_bcount = len; 290 vn_strategy(drive->vp, &bp->b_bio1); 291 error = biowait(&bp->b_bio1, (cmd == BUF_CMD_READ ? "drvrd" : "drvwr")); 292 bp->b_data = saveaddr; 293 bp->b_flags |= B_INVAL | B_AGE; 294 bp->b_flags &= ~B_ERROR; 295 brelse(bp); 296 if (error) 297 break; 298 length -= len; /* update pointers */ 299 buf += len; 300 offset += len; 301 } 302 return error; 303 } 304 305 /* 306 * Check a drive for a vinum header. If found, 307 * update the drive information. We come here 308 * with a partially populated drive structure 309 * which includes the device name. 310 * 311 * Return information on what we found. 312 * 313 * This function is called from two places: check_drive, 314 * which wants to find out whether the drive is a 315 * Vinum drive, and config_drive, which asserts that 316 * it is a vinum drive. In the first case, we don't 317 * print error messages (verbose==0), in the second 318 * we do (verbose==1). 319 */ 320 enum drive_label_info 321 read_drive_label(struct drive *drive, int verbose) 322 { 323 int error; 324 int result; 325 struct vinum_hdr *vhdr; 326 327 error = init_drive(drive, verbose); /* find the drive */ 328 if (error) /* find the drive */ 329 return DL_CANT_OPEN; /* not ours */ 330 331 vhdr = (struct vinum_hdr *) Malloc(VINUMHEADERLEN); /* allocate buffers */ 332 CHECKALLOC(vhdr, "Can't allocate memory"); 333 334 drive->state = drive_up; /* be optimistic */ 335 error = read_drive(drive, (void *) vhdr, VINUMHEADERLEN, VINUM_LABEL_OFFSET); 336 if (vhdr->magic == VINUM_MAGIC) { /* ours! */ 337 if (drive->label.name[0] /* we have a name for this drive */ 338 &&(strcmp(drive->label.name, vhdr->label.name))) { /* but it doesn't match the real name */ 339 drive->lasterror = EINVAL; 340 result = DL_WRONG_DRIVE; /* it's the wrong drive */ 341 drive->state = drive_unallocated; /* put it back, it's not ours */ 342 } else 343 result = DL_OURS; 344 /* 345 * We copy the drive anyway so that we have 346 * the correct name in the drive info. This 347 * may not be the name specified 348 */ 349 drive->label = vhdr->label; /* put in the label information */ 350 } else if (vhdr->magic == VINUM_NOMAGIC) /* was ours, but we gave it away */ 351 result = DL_DELETED_LABEL; /* and return the info */ 352 else 353 result = DL_NOT_OURS; /* we could have it, but we don't yet */ 354 Free(vhdr); /* that's all. */ 355 return result; 356 } 357 358 /* 359 * Check a drive for a vinum header. If found, 360 * read configuration information from the drive and 361 * incorporate the data into the configuration. 362 * 363 * Return drive number. 364 */ 365 struct drive * 366 check_drive(char *devicename) 367 { 368 int driveno; 369 int i; 370 struct drive *drive; 371 372 driveno = find_drive_by_dev(devicename, 1); /* if entry doesn't exist, create it */ 373 drive = &vinum_conf.drive[driveno]; /* and get a pointer */ 374 375 if (read_drive_label(drive, 0) == DL_OURS) { /* one of ours */ 376 for (i = 0; i < vinum_conf.drives_allocated; i++) { /* see if the name already exists */ 377 if ((i != driveno) /* not this drive */ 378 &&(DRIVE[i].state != drive_unallocated) /* and it's allocated */ 379 &&(strcmp(DRIVE[i].label.name, 380 DRIVE[driveno].label.name) == 0)) { /* and it has the same name */ 381 struct drive *mydrive = &DRIVE[i]; 382 383 if (mydrive->devicename[0] == '/') { /* we know a device name for it */ 384 /* 385 * set an error, but don't take the 386 * drive down: that would cause unneeded 387 * error messages. 388 */ 389 drive->lasterror = EEXIST; 390 break; 391 } else { /* it's just a place holder, */ 392 int sdno; 393 394 for (sdno = 0; sdno < vinum_conf.subdisks_allocated; sdno++) { /* look at each subdisk */ 395 if ((SD[sdno].driveno == i) /* it's pointing to this one, */ 396 &&(SD[sdno].state != sd_unallocated)) { /* and it's a real subdisk */ 397 SD[sdno].driveno = drive->driveno; /* point to the one we found */ 398 update_sd_state(sdno); /* and update its state */ 399 } 400 } 401 bzero(mydrive, sizeof(struct drive)); /* don't deallocate it, just remove it */ 402 } 403 } 404 } 405 } else { 406 if (drive->lasterror == 0) 407 drive->lasterror = ENODEV; 408 close_drive(drive); 409 drive->state = drive_down; 410 } 411 return drive; 412 } 413 414 static char * 415 sappend(char *txt, char *s) 416 { 417 while ((*s++ = *txt++) != 0); 418 return s - 1; 419 } 420 421 void 422 format_config(char *config, int len) 423 { 424 int i; 425 int j; 426 char *s = config; 427 char *configend = &config[len]; 428 429 bzero(config, len); 430 431 /* First write the volume configuration */ 432 for (i = 0; i < vinum_conf.volumes_allocated; i++) { 433 struct volume *vol; 434 435 vol = &vinum_conf.volume[i]; 436 if ((vol->state > volume_uninit) 437 && (vol->name[0] != '\0')) { /* paranoia */ 438 ksnprintf(s, 439 configend - s, 440 "volume %s state %s", 441 vol->name, 442 volume_state(vol->state)); 443 while (*s) 444 s++; /* find the end */ 445 if (vol->preferred_plex >= 0) /* preferences, */ 446 ksnprintf(s, 447 configend - s, 448 " readpol prefer %s", 449 vinum_conf.plex[vol->preferred_plex].name); 450 while (*s) 451 s++; /* find the end */ 452 s = sappend("\n", s); 453 } 454 } 455 456 /* Then the plex configuration */ 457 for (i = 0; i < vinum_conf.plexes_allocated; i++) { 458 struct plex *plex; 459 460 plex = &vinum_conf.plex[i]; 461 if ((plex->state > plex_referenced) 462 && (plex->name[0] != '\0')) { /* paranoia */ 463 ksnprintf(s, 464 configend - s, 465 "plex name %s state %s org %s ", 466 plex->name, 467 plex_state(plex->state), 468 plex_org(plex->organization)); 469 while (*s) 470 s++; /* find the end */ 471 if (isstriped(plex)) { 472 ksnprintf(s, 473 configend - s, 474 "%ds ", 475 (int) plex->stripesize); 476 while (*s) 477 s++; /* find the end */ 478 } 479 if (plex->volno >= 0) /* we have a volume */ 480 ksnprintf(s, 481 configend - s, 482 "vol %s ", 483 vinum_conf.volume[plex->volno].name); 484 while (*s) 485 s++; /* find the end */ 486 for (j = 0; j < plex->subdisks; j++) { 487 ksnprintf(s, 488 configend - s, 489 " sd %s", 490 vinum_conf.sd[plex->sdnos[j]].name); 491 } 492 s = sappend("\n", s); 493 } 494 } 495 496 /* And finally the subdisk configuration */ 497 for (i = 0; i < vinum_conf.subdisks_allocated; i++) { 498 struct sd *sd; 499 char *drivename; 500 501 sd = &SD[i]; 502 if ((sd->state != sd_referenced) 503 && (sd->state != sd_unallocated) 504 && (sd->name[0] != '\0')) { /* paranoia */ 505 drivename = vinum_conf.drive[sd->driveno].label.name; 506 /* 507 * XXX We've seen cases of dead subdisks 508 * which don't have a drive. If we let them 509 * through here, the drive name is null, so 510 * they get the drive named 'plex'. 511 * 512 * This is a breakage limiter, not a fix. 513 */ 514 if (drivename[0] == '\0') 515 drivename = "*invalid*"; 516 ksnprintf(s, 517 configend - s, 518 "sd name %s drive %s plex %s len %llus driveoffset %llus state %s", 519 sd->name, 520 drivename, 521 vinum_conf.plex[sd->plexno].name, 522 (unsigned long long) sd->sectors, 523 (unsigned long long) sd->driveoffset, 524 sd_state(sd->state)); 525 while (*s) 526 s++; /* find the end */ 527 if (sd->plexno >= 0) 528 ksnprintf(s, 529 configend - s, 530 " plexoffset %llds", 531 (long long) sd->plexoffset); 532 else 533 ksnprintf(s, configend - s, " detached"); 534 while (*s) 535 s++; /* find the end */ 536 if (sd->flags & VF_RETRYERRORS) { 537 ksnprintf(s, configend - s, " retryerrors"); 538 while (*s) 539 s++; /* find the end */ 540 } 541 ksnprintf(s, configend - s, " \n"); 542 while (*s) 543 s++; /* find the end */ 544 } 545 } 546 if (s > &config[len - 2]) 547 panic("vinum: configuration data overflow"); 548 } 549 550 /* 551 * issue a save config request to the d�mon. The actual work 552 * is done in process context by daemon_save_config 553 */ 554 void 555 save_config(void) 556 { 557 union daemoninfo di = { .nothing = 0 }; 558 559 queue_daemon_request(daemonrq_saveconfig, di); 560 } 561 562 /* 563 * Write the configuration to all vinum slices. This 564 * is performed by the d�mon only 565 */ 566 void 567 daemon_save_config(void) 568 { 569 int error; 570 int driveno; 571 struct drive *drive; /* point to current drive info */ 572 struct vinum_hdr *vhdr; /* and as header */ 573 char *config; /* point to config data */ 574 int wlabel_on; /* to set writing label on/off */ 575 576 /* don't save the configuration while we're still working on it */ 577 if (vinum_conf.flags & VF_CONFIGURING) 578 return; 579 /* Build a volume header */ 580 vhdr = (struct vinum_hdr *) Malloc(VINUMHEADERLEN); /* get space for the config data */ 581 CHECKALLOC(vhdr, "Can't allocate config data"); 582 vhdr->magic = VINUM_MAGIC; /* magic number */ 583 vhdr->config_length = MAXCONFIG; /* length of following config info */ 584 585 config = Malloc(MAXCONFIG); /* get space for the config data */ 586 CHECKALLOC(config, "Can't allocate config data"); 587 588 format_config(config, MAXCONFIG); 589 error = 0; /* no errors yet */ 590 for (driveno = 0; driveno < vinum_conf.drives_allocated; driveno++) { 591 drive = &vinum_conf.drive[driveno]; /* point to drive */ 592 if (drive->state > drive_referenced) { 593 LOCKDRIVE(drive); /* don't let it change */ 594 595 /* 596 * First, do some drive consistency checks. Some 597 * of these are kludges, others require a process 598 * context and couldn't be done before 599 */ 600 if ((drive->devicename[0] == '\0') 601 || (drive->label.name[0] == '\0')) { 602 unlockdrive(drive); 603 free_drive(drive); /* get rid of it */ 604 break; 605 } 606 if (((drive->flags & VF_OPEN) == 0) /* drive not open */ 607 &&(drive->state > drive_down)) { /* and it thinks it's not down */ 608 unlockdrive(drive); 609 set_drive_state(driveno, drive_down, setstate_force); /* tell it what's what */ 610 continue; 611 } 612 if ((drive->state == drive_down) /* it's down */ 613 &&(drive->flags & VF_OPEN)) { /* but open, */ 614 unlockdrive(drive); 615 close_drive(drive); /* close it */ 616 } else if (drive->state > drive_down) { 617 getmicrotime(&drive->label.last_update); /* time of last update is now */ 618 bcopy((char *) &drive->label, /* and the label info from the drive structure */ 619 (char *) &vhdr->label, 620 sizeof(vhdr->label)); 621 if ((drive->state != drive_unallocated) 622 && (drive->state != drive_referenced)) { /* and it's a real drive */ 623 wlabel_on = 1; /* enable writing the label */ 624 error = 0; 625 #if 1 626 error = VOP_IOCTL(drive->vp, DIOCWLABEL, 627 (caddr_t)&wlabel_on, FREAD|FWRITE, 628 proc0.p_ucred, NULL); 629 #endif 630 if (error == 0) 631 error = write_drive(drive, (char *) vhdr, VINUMHEADERLEN, VINUM_LABEL_OFFSET); 632 if (error == 0) 633 error = write_drive(drive, config, MAXCONFIG, VINUM_CONFIG_OFFSET); /* first config copy */ 634 if (error == 0) 635 error = write_drive(drive, config, MAXCONFIG, VINUM_CONFIG_OFFSET + MAXCONFIG); /* second copy */ 636 wlabel_on = 0; /* enable writing the label */ 637 #if 1 638 if (error == 0) { 639 error = VOP_IOCTL(drive->vp, DIOCWLABEL, 640 (caddr_t)&wlabel_on, FREAD|FWRITE, 641 proc0.p_ucred, NULL); 642 } 643 #endif 644 unlockdrive(drive); 645 if (error) { 646 log(LOG_ERR, 647 "vinum: Can't write config to %s, error %d\n", 648 drive->devicename, 649 error); 650 set_drive_state(drive->driveno, drive_down, setstate_force); 651 } 652 } 653 } else /* not worth looking at, */ 654 unlockdrive(drive); /* just unlock it again */ 655 } 656 } 657 Free(vhdr); 658 Free(config); 659 } 660 661 /* Look at all disks on the system for vinum slices */ 662 int 663 vinum_scandisk(char *devicename[], int drives) 664 { 665 struct drive *volatile drive; 666 volatile int driveno; 667 volatile int gooddrives; /* number of usable drives found */ 668 int firsttime; /* set if we have never configured before */ 669 int error; 670 char *config_text; /* read the config info from disk into here */ 671 char *volatile cptr; /* pointer into config information */ 672 char *eptr; /* end pointer into config information */ 673 char *config_line; /* copy the config line to */ 674 volatile int status; 675 int *volatile drivelist; /* list of drive indices */ 676 #define DRIVENAMELEN 64 677 #define DRIVEPARTS 35 /* max partitions per drive, excluding c */ 678 char partname[DRIVENAMELEN]; /* for creating partition names */ 679 680 status = 0; /* success indication */ 681 vinum_conf.flags |= VF_READING_CONFIG; /* reading config from disk */ 682 683 gooddrives = 0; /* number of usable drives found */ 684 firsttime = vinum_conf.drives_used == 0; /* are we a virgin? */ 685 686 /* allocate a drive pointer list */ 687 drivelist = (int *) Malloc(drives * DRIVEPARTS * sizeof(int)); 688 CHECKALLOC(drivelist, "Can't allocate memory"); 689 error = setjmp(command_fail); /* come back here on error */ 690 if (error) { /* longjmped out */ 691 return error; 692 } 693 694 /* Open all drives and find which was modified most recently */ 695 for (driveno = 0; driveno < drives; driveno++) { 696 char part, has_part = 0; /* UNIX partition */ 697 int slice; 698 int founddrive; /* flag when we find a vinum drive */ 699 int has_slice = -1; 700 char *tmp; 701 702 founddrive = 0; /* no vinum drive found yet on this spindle */ 703 704 /* 705 * If the device path contains a slice we do not try to tack on 706 * another slice. If the device path has a partition we only check 707 * that partition. 708 */ 709 if ((tmp = rindex(devicename[driveno], '/')) == NULL) 710 tmp = devicename[driveno]; 711 else 712 tmp++; 713 ksscanf(tmp, "%*[a-z]%*d%*[s]%d%c", &has_slice, &has_part); 714 715 for (slice = 0; slice < MAX_SLICES; slice++) { 716 if (has_slice >= 0 && slice != has_slice) 717 continue; 718 719 for (part = 'a'; part < 'a' + MAXPARTITIONS; part++) { 720 if (part == 'c') 721 continue; 722 if (has_part && part != has_part) 723 continue; 724 if (has_slice >= 0 && has_part) 725 strncpy(partname, devicename[driveno], DRIVENAMELEN); 726 else if (has_slice >= 0) 727 ksnprintf(partname, DRIVENAMELEN, 728 "%s%c", devicename[driveno], part); 729 else 730 ksnprintf(partname, DRIVENAMELEN, 731 "%ss%d%c", devicename[driveno], slice, part); 732 drive = check_drive(partname); /* try to open it */ 733 if ((drive->lasterror != 0) /* didn't work, */ 734 ||(drive->state != drive_up)) 735 free_drive(drive); /* get rid of it */ 736 else if (drive->flags & VF_CONFIGURED) /* already read this config, */ 737 log(LOG_WARNING, 738 "vinum: already read config from %s\n", /* say so */ 739 drive->label.name); 740 else { 741 drivelist[gooddrives] = drive->driveno; /* keep the drive index */ 742 drive->flags &= ~VF_NEWBORN; /* which is no longer newly born */ 743 gooddrives++; 744 founddrive++; 745 } 746 } 747 } 748 } 749 750 if (gooddrives == 0) { 751 if (firsttime) 752 log(LOG_WARNING, "vinum: no drives found\n"); 753 else 754 log(LOG_INFO, "vinum: no additional drives found\n"); 755 return ENOENT; 756 } 757 /* 758 * We now have at least one drive 759 * open. Sort them in order of config time 760 * and merge the config info with what we 761 * have already. 762 */ 763 kqsort(drivelist, gooddrives, sizeof(int), drivecmp); 764 config_text = (char *) Malloc(MAXCONFIG * 2); /* allocate buffers */ 765 CHECKALLOC(config_text, "Can't allocate memory"); 766 config_line = (char *) Malloc(MAXCONFIGLINE * 2); /* allocate buffers */ 767 CHECKALLOC(config_line, "Can't allocate memory"); 768 for (driveno = 0; driveno < gooddrives; driveno++) { /* now include the config */ 769 drive = &DRIVE[drivelist[driveno]]; /* point to the drive */ 770 771 if (firsttime && (driveno == 0)) /* we've never configured before, */ 772 log(LOG_INFO, "vinum: reading configuration from %s\n", drive->devicename); 773 else 774 log(LOG_INFO, "vinum: updating configuration from %s\n", drive->devicename); 775 776 if (drive->state == drive_up) 777 /* Read in both copies of the configuration information */ 778 error = read_drive(drive, config_text, MAXCONFIG * 2, VINUM_CONFIG_OFFSET); 779 else { 780 error = EIO; 781 kprintf("vinum_scandisk: %s is %s\n", drive->devicename, drive_state(drive->state)); 782 } 783 784 if (error != 0) { 785 log(LOG_ERR, "vinum: Can't read device %s, error %d\n", drive->devicename, error); 786 free_drive(drive); /* give it back */ 787 status = error; 788 } 789 /* 790 * At this point, check that the two copies 791 * are the same, and do something useful if 792 * not. In particular, consider which is 793 * newer, and what this means for the 794 * integrity of the data on the drive. 795 */ 796 else { 797 vinum_conf.drives_used++; /* another drive in use */ 798 /* Parse the configuration, and add it to the global configuration */ 799 for (cptr = config_text; *cptr != '\0';) { /* love this style(9) */ 800 volatile int parse_status; /* return value from parse_config */ 801 802 for (eptr = config_line; (*cptr != '\n') && (*cptr != '\0');) /* until the end of the line */ 803 *eptr++ = *cptr++; 804 *eptr = '\0'; /* and delimit */ 805 if (setjmp(command_fail) == 0) { /* come back here on error and continue */ 806 parse_status = parse_config(config_line, &keyword_set, 1); /* parse the config line */ 807 if (parse_status < 0) { /* error in config */ 808 /* 809 * This config should have been parsed in user 810 * space. If we run into problems here, something 811 * serious is afoot. Complain and let the user 812 * snarf the config to see what's wrong. 813 */ 814 log(LOG_ERR, 815 "vinum: Config error on %s, aborting integration\n", 816 drive->devicename); 817 free_drive(drive); /* give it back */ 818 status = EINVAL; 819 } 820 } 821 while (*cptr == '\n') 822 cptr++; /* skip to next line */ 823 } 824 } 825 drive->flags |= VF_CONFIGURED; /* read this drive's configuration */ 826 } 827 828 Free(config_line); 829 Free(config_text); 830 Free(drivelist); 831 vinum_conf.flags &= ~VF_READING_CONFIG; /* no longer reading from disk */ 832 if (status != 0) 833 kprintf("vinum: couldn't read configuration"); 834 else 835 updateconfig(VF_READING_CONFIG); /* update from disk config */ 836 return status; 837 } 838 839 /* 840 * Compare the modification dates of the drives, for qsort. 841 * Return 1 if a < b, 0 if a == b, 01 if a > b: in other 842 * words, sort backwards. 843 */ 844 int 845 drivecmp(const void *va, const void *vb) 846 { 847 const struct drive *a = &DRIVE[*(const int *) va]; 848 const struct drive *b = &DRIVE[*(const int *) vb]; 849 850 if ((a->label.last_update.tv_sec == b->label.last_update.tv_sec) 851 && (a->label.last_update.tv_usec == b->label.last_update.tv_usec)) 852 return 0; 853 else if ((a->label.last_update.tv_sec > b->label.last_update.tv_sec) 854 || ((a->label.last_update.tv_sec == b->label.last_update.tv_sec) 855 && (a->label.last_update.tv_usec > b->label.last_update.tv_usec))) 856 return -1; 857 else 858 return 1; 859 } 860