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