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);
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);
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 }
Cache object: 852b0ecc0bf00421491b6af137270b96
|