2 * Copyright (c) 1997, 1998
3 * Nan Yang Computer Services Limited. All rights reserved.
5 * This software is distributed under the so-called ``Berkeley
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
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
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.
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.
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.21 2007/03/12 12:10:13 swildner Exp $
43 #include <vm/vm_zone.h>
45 static char *sappend(char *txt, char *s);
46 static int drivecmp(const void *va, const void *vb);
49 * Open the device associated with the drive, and set drive's vp.
50 * Return an error number
53 open_drive(struct drive *drive, struct proc *p, int verbose)
55 int devmajor; /* major devs for disk device */
56 int devminor; /* minor devs for disk device */
60 if (bcmp(drive->devicename, "/dev/", 5)) /* device name doesn't start with /dev */
61 return ENOENT; /* give up */
62 if (drive->flags & VF_OPEN) /* open already, */
63 return EBUSY; /* don't do it again */
66 * Yes, Bruce, I know this is horrible, but we
67 * don't have a root file system when we first
68 * try to do this. If you can come up with a
69 * better solution, I'd really like it. I'm
70 * just putting it in now to add ammuntion to
71 * moving the system to devfs.
73 dname = &drive->devicename[5];
74 drive->dev = NULL; /* no device yet */
77 if (bcmp(dname, "ad", 2) == 0) /* IDE disk */
79 else if (bcmp(dname, "wd", 2) == 0) /* IDE disk */
81 else if (bcmp(dname, "da", 2) == 0)
83 else if (bcmp(dname, "vn", 2) == 0)
85 else if (bcmp(dname, "md", 2) == 0)
87 else if (bcmp(dname, "vkd", 3) == 0) {
90 } else if (bcmp(dname, "amrd", 4) == 0) {
93 } else if (bcmp(dname, "mlxd", 4) == 0) {
96 } else if (bcmp(dname, "idad", 4) == 0) {
99 } else if (bcmp(dname, "twed", 4) == 0) { /* 3ware raid */
102 } else if (bcmp(dname, "ar", 2) == 0) {
106 dname += 2; /* point past */
109 * Found the device. We can expect one of
110 * two formats for the rest: a unit number,
111 * then either a partition letter for the
112 * compatiblity partition (e.g. h) or a
113 * slice ID and partition (e.g. s2e).
114 * Create a minor number for each of them.
117 while ((*dname >= '0') /* unit number */
119 unit = unit * 10 + *dname - '0';
123 if (*dname == 's') { /* slice */
124 if (((dname[1] < '1') || (dname[1] > '4')) /* invalid slice */
125 ||((dname[2] < 'a') || (dname[2] > 'p'))) /* or invalid partition */
127 devminor = dkmakeminor(unit, dname[1] - '0' + 1, (dname[2] - 'a'));
128 } else { /* compatibility partition */
129 if ((*dname < 'a') || (*dname > 'p')) /* or invalid partition */
131 devminor = dkmakeminor(unit, 0, (dname[0] - 'a'));
135 * Disallow partition c
137 if ((((devminor >> 17) & 0x08) | (devminor & 7)) == 2)
138 return ENOTTY; /* not buying that */
140 drive->dev = udev2dev(makeudev(devmajor, devminor), 0);
142 if (drive->dev == NOCDEV)
145 drive->dev->si_iosize_max = DFLTPHYS;
146 if (dev_is_good(drive->dev))
147 drive->lasterror = dev_dopen(drive->dev, FWRITE, 0, proc0.p_ucred);
149 drive->lasterror = ENOENT;
151 if (drive->lasterror != 0) { /* failed */
152 drive->state = drive_down; /* just force it down */
155 "vinum open_drive %s: failed with error %d\n",
156 drive->devicename, drive->lasterror);
158 drive->flags |= VF_OPEN; /* we're open now */
160 return drive->lasterror;
164 * Set some variables in the drive struct
165 * in more convenient form. Return error indication
168 set_drive_parms(struct drive *drive)
170 drive->blocksize = BLKDEV_IOSIZE; /* do we need this? */
171 drive->secsperblock = drive->blocksize /* number of sectors per block */
172 / drive->partinfo.disklab->d_secsize;
174 /* Now update the label part */
175 bcopy(hostname, drive->label.sysname, VINUMHOSTNAMELEN); /* put in host name */
176 getmicrotime(&drive->label.date_of_birth); /* and current time */
177 drive->label.drive_size = ((u_int64_t) drive->partinfo.part->p_size) /* size of the drive in bytes */
178 *((u_int64_t) drive->partinfo.disklab->d_secsize);
180 if (debug & DEBUG_BIGDRIVE) /* pretend we're 100 times as big */
181 drive->label.drive_size *= 100;
184 /* number of sectors available for subdisks */
185 drive->sectors_available = drive->label.drive_size / DEV_BSIZE - DATASTART;
188 * Bug in 3.0 as of January 1998: you can open
189 * non-existent slices. They have a length of 0.
191 if (drive->label.drive_size < MINVINUMSLICE) { /* too small to worry about */
192 set_drive_state(drive->driveno, drive_down, setstate_force);
193 drive->lasterror = ENOSPC;
196 drive->freelist_size = INITIAL_DRIVE_FREELIST; /* initial number of entries */
197 drive->freelist = (struct drive_freelist *)
198 Malloc(INITIAL_DRIVE_FREELIST * sizeof(struct drive_freelist));
199 if (drive->freelist == NULL) /* can't malloc, dammit */
201 drive->freelist_entries = 1; /* just (almost) the complete drive */
202 drive->freelist[0].offset = DATASTART; /* starts here */
203 drive->freelist[0].sectors = (drive->label.drive_size >> DEV_BSHIFT) - DATASTART; /* and it's this long */
204 if (drive->label.name[0] != '\0') /* got a name */
205 set_drive_state(drive->driveno, drive_up, setstate_force); /* our drive is accessible */
206 else /* we know about it, but that's all */
207 drive->state = drive_referenced;
212 * Initialize a drive: open the device and add device
216 init_drive(struct drive *drive, int verbose)
218 if (drive->devicename[0] != '/') {
219 drive->lasterror = EINVAL;
220 log(LOG_ERR, "vinum: Can't open drive without drive name\n");
223 drive->lasterror = open_drive(drive, curproc, verbose); /* open the drive */
224 if (drive->lasterror)
225 return drive->lasterror;
227 drive->lasterror = dev_dioctl(
230 (caddr_t) & drive->partinfo,
233 if (drive->lasterror) {
236 "vinum open_drive %s: Can't get partition information, drive->lasterror %d\n",
240 return drive->lasterror;
242 if (drive->partinfo.part->p_fstype != FS_VINUM) { /* not Vinum */
243 drive->lasterror = EFTYPE;
246 "vinum open_drive %s: Wrong partition type for vinum\n",
251 return set_drive_parms(drive); /* set various odds and ends */
254 /* Close a drive if it's open. */
256 close_drive(struct drive *drive)
258 LOCKDRIVE(drive); /* keep the daemon out */
259 if (drive->flags & VF_OPEN)
260 close_locked_drive(drive); /* and close it */
261 if (drive->state > drive_down) /* if it's up */
262 drive->state = drive_down; /* make sure it's down */
267 * Real drive close code, called with drive already locked.
268 * We have also checked that the drive is open. No errors.
271 close_locked_drive(struct drive *drive)
274 * If we can't access the drive, we can't flush
275 * the queues, which spec_close() will try to
276 * do. Get rid of them here first.
278 drive->lasterror = dev_dclose(drive->dev, 0, 0);
279 drive->flags &= ~VF_OPEN; /* no longer open */
283 * Remove drive from the configuration.
284 * Caller must ensure that it isn't active.
287 remove_drive(int driveno)
289 struct drive *drive = &vinum_conf.drive[driveno];
290 struct vinum_hdr *vhdr; /* buffer for header */
293 if (drive->state > drive_referenced) { /* real drive */
294 if (drive->state == drive_up) {
295 vhdr = (struct vinum_hdr *) Malloc(VINUMHEADERLEN); /* allocate buffer */
296 CHECKALLOC(vhdr, "Can't allocate memory");
297 error = read_drive(drive, (void *) vhdr, VINUMHEADERLEN, VINUM_LABEL_OFFSET);
299 drive->lasterror = error;
301 vhdr->magic = VINUM_NOMAGIC; /* obliterate the magic, but leave the rest */
302 write_drive(drive, (void *) vhdr, VINUMHEADERLEN, VINUM_LABEL_OFFSET);
306 free_drive(drive); /* close it and free resources */
307 save_config(); /* and save the updated configuration */
312 * Transfer drive data. Usually called from one of these defines;
313 * #define read_drive(a, b, c, d) driveio (a, b, c, d, BUF_CMD_READ)
314 * #define write_drive(a, b, c, d) driveio (a, b, c, d, BUF_CMD_WRITE)
316 * length and offset are in bytes, but must be multiples of sector
317 * size. The function *does not check* for this condition, and
318 * truncates ruthlessly.
319 * Return error number
322 driveio(struct drive *drive, char *buf, size_t length, off_t offset, buf_cmd_t cmd)
328 error = 0; /* to keep the compiler happy */
329 while (length) { /* divide into small enough blocks */
330 int len = min(length, MAXBSIZE); /* maximum block device transfer is MAXBSIZE */
332 bp = geteblk(len); /* get a buffer header */
334 bp->b_bio1.bio_offset = offset; /* disk offset */
335 saveaddr = bp->b_data;
338 dev_dstrategy(drive->dev, &bp->b_bio1);
340 bp->b_data = saveaddr;
341 bp->b_flags |= B_INVAL | B_AGE;
342 bp->b_flags &= ~B_ERROR;
346 length -= len; /* update pointers */
354 * Check a drive for a vinum header. If found,
355 * update the drive information. We come here
356 * with a partially populated drive structure
357 * which includes the device name.
359 * Return information on what we found.
361 * This function is called from two places: check_drive,
362 * which wants to find out whether the drive is a
363 * Vinum drive, and config_drive, which asserts that
364 * it is a vinum drive. In the first case, we don't
365 * print error messages (verbose==0), in the second
366 * we do (verbose==1).
368 enum drive_label_info
369 read_drive_label(struct drive *drive, int verbose)
372 int result; /* result of our search */
373 struct vinum_hdr *vhdr; /* and as header */
375 error = init_drive(drive, 0); /* find the drive */
376 if (error) /* find the drive */
377 return DL_CANT_OPEN; /* not ours */
379 vhdr = (struct vinum_hdr *) Malloc(VINUMHEADERLEN); /* allocate buffers */
380 CHECKALLOC(vhdr, "Can't allocate memory");
382 drive->state = drive_up; /* be optimistic */
383 error = read_drive(drive, (void *) vhdr, VINUMHEADERLEN, VINUM_LABEL_OFFSET);
384 if (vhdr->magic == VINUM_MAGIC) { /* ours! */
385 if (drive->label.name[0] /* we have a name for this drive */
386 &&(strcmp(drive->label.name, vhdr->label.name))) { /* but it doesn't match the real name */
387 drive->lasterror = EINVAL;
388 result = DL_WRONG_DRIVE; /* it's the wrong drive */
389 drive->state = drive_unallocated; /* put it back, it's not ours */
393 * We copy the drive anyway so that we have
394 * the correct name in the drive info. This
395 * may not be the name specified
397 drive->label = vhdr->label; /* put in the label information */
398 } else if (vhdr->magic == VINUM_NOMAGIC) /* was ours, but we gave it away */
399 result = DL_DELETED_LABEL; /* and return the info */
401 result = DL_NOT_OURS; /* we could have it, but we don't yet */
402 Free(vhdr); /* that's all. */
407 * Check a drive for a vinum header. If found,
408 * read configuration information from the drive and
409 * incorporate the data into the configuration.
411 * Return drive number.
414 check_drive(char *devicename)
420 driveno = find_drive_by_dev(devicename, 1); /* if entry doesn't exist, create it */
421 drive = &vinum_conf.drive[driveno]; /* and get a pointer */
423 if (read_drive_label(drive, 0) == DL_OURS) { /* one of ours */
424 for (i = 0; i < vinum_conf.drives_allocated; i++) { /* see if the name already exists */
425 if ((i != driveno) /* not this drive */
426 &&(DRIVE[i].state != drive_unallocated) /* and it's allocated */
427 &&(strcmp(DRIVE[i].label.name,
428 DRIVE[driveno].label.name) == 0)) { /* and it has the same name */
429 struct drive *mydrive = &DRIVE[i];
431 if (mydrive->devicename[0] == '/') { /* we know a device name for it */
433 * set an error, but don't take the
434 * drive down: that would cause unneeded
437 drive->lasterror = EEXIST;
439 } else { /* it's just a place holder, */
442 for (sdno = 0; sdno < vinum_conf.subdisks_allocated; sdno++) { /* look at each subdisk */
443 if ((SD[sdno].driveno == i) /* it's pointing to this one, */
444 &&(SD[sdno].state != sd_unallocated)) { /* and it's a real subdisk */
445 SD[sdno].driveno = drive->driveno; /* point to the one we found */
446 update_sd_state(sdno); /* and update its state */
449 bzero(mydrive, sizeof(struct drive)); /* don't deallocate it, just remove it */
454 if (drive->lasterror == 0)
455 drive->lasterror = ENODEV;
457 drive->state = drive_down;
463 sappend(char *txt, char *s)
465 while ((*s++ = *txt++) != 0);
470 format_config(char *config, int len)
475 char *configend = &config[len];
479 /* First write the volume configuration */
480 for (i = 0; i < vinum_conf.volumes_allocated; i++) {
483 vol = &vinum_conf.volume[i];
484 if ((vol->state > volume_uninit)
485 && (vol->name[0] != '\0')) { /* paranoia */
488 "volume %s state %s",
490 volume_state(vol->state));
492 s++; /* find the end */
493 if (vol->preferred_plex >= 0) /* preferences, */
496 " readpol prefer %s",
497 vinum_conf.plex[vol->preferred_plex].name);
499 s++; /* find the end */
500 s = sappend("\n", s);
504 /* Then the plex configuration */
505 for (i = 0; i < vinum_conf.plexes_allocated; i++) {
508 plex = &vinum_conf.plex[i];
509 if ((plex->state > plex_referenced)
510 && (plex->name[0] != '\0')) { /* paranoia */
513 "plex name %s state %s org %s ",
515 plex_state(plex->state),
516 plex_org(plex->organization));
518 s++; /* find the end */
519 if (isstriped(plex)) {
523 (int) plex->stripesize);
525 s++; /* find the end */
527 if (plex->volno >= 0) /* we have a volume */
531 vinum_conf.volume[plex->volno].name);
533 s++; /* find the end */
534 for (j = 0; j < plex->subdisks; j++) {
538 vinum_conf.sd[plex->sdnos[j]].name);
540 s = sappend("\n", s);
544 /* And finally the subdisk configuration */
545 for (i = 0; i < vinum_conf.subdisks_allocated; i++) {
550 if ((sd->state != sd_referenced)
551 && (sd->state != sd_unallocated)
552 && (sd->name[0] != '\0')) { /* paranoia */
553 drivename = vinum_conf.drive[sd->driveno].label.name;
555 * XXX We've seen cases of dead subdisks
556 * which don't have a drive. If we let them
557 * through here, the drive name is null, so
558 * they get the drive named 'plex'.
560 * This is a breakage limiter, not a fix.
562 if (drivename[0] == '\0')
563 drivename = "*invalid*";
566 "sd name %s drive %s plex %s len %llus driveoffset %llus state %s",
569 vinum_conf.plex[sd->plexno].name,
570 (unsigned long long) sd->sectors,
571 (unsigned long long) sd->driveoffset,
572 sd_state(sd->state));
574 s++; /* find the end */
579 (long long) sd->plexoffset);
581 ksnprintf(s, configend - s, " detached");
583 s++; /* find the end */
584 if (sd->flags & VF_RETRYERRORS) {
585 ksnprintf(s, configend - s, " retryerrors");
587 s++; /* find the end */
589 ksnprintf(s, configend - s, " \n");
591 s++; /* find the end */
594 if (s > &config[len - 2])
595 panic("vinum: configuration data overflow");
599 * issue a save config request to the dæmon. The actual work
600 * is done in process context by daemon_save_config
605 queue_daemon_request(daemonrq_saveconfig, (union daemoninfo) NULL);
609 * Write the configuration to all vinum slices. This
610 * is performed by the dæmon only
613 daemon_save_config(void)
616 int written_config; /* set when we first write the config to disk */
618 struct drive *drive; /* point to current drive info */
619 struct vinum_hdr *vhdr; /* and as header */
620 char *config; /* point to config data */
621 int wlabel_on; /* to set writing label on/off */
623 /* don't save the configuration while we're still working on it */
624 if (vinum_conf.flags & VF_CONFIGURING)
626 written_config = 0; /* no config written yet */
627 /* Build a volume header */
628 vhdr = (struct vinum_hdr *) Malloc(VINUMHEADERLEN); /* get space for the config data */
629 CHECKALLOC(vhdr, "Can't allocate config data");
630 vhdr->magic = VINUM_MAGIC; /* magic number */
631 vhdr->config_length = MAXCONFIG; /* length of following config info */
633 config = Malloc(MAXCONFIG); /* get space for the config data */
634 CHECKALLOC(config, "Can't allocate config data");
636 format_config(config, MAXCONFIG);
637 error = 0; /* no errors yet */
638 for (driveno = 0; driveno < vinum_conf.drives_allocated; driveno++) {
639 drive = &vinum_conf.drive[driveno]; /* point to drive */
640 if (drive->state > drive_referenced) {
641 LOCKDRIVE(drive); /* don't let it change */
644 * First, do some drive consistency checks. Some
645 * of these are kludges, others require a process
646 * context and couldn't be done before
648 if ((drive->devicename[0] == '\0')
649 || (drive->label.name[0] == '\0')) {
651 free_drive(drive); /* get rid of it */
654 if (((drive->flags & VF_OPEN) == 0) /* drive not open */
655 &&(drive->state > drive_down)) { /* and it thinks it's not down */
657 set_drive_state(driveno, drive_down, setstate_force); /* tell it what's what */
660 if ((drive->state == drive_down) /* it's down */
661 &&(drive->flags & VF_OPEN)) { /* but open, */
663 close_drive(drive); /* close it */
664 } else if (drive->state > drive_down) {
665 getmicrotime(&drive->label.last_update); /* time of last update is now */
666 bcopy((char *) &drive->label, /* and the label info from the drive structure */
667 (char *) &vhdr->label,
668 sizeof(vhdr->label));
669 if ((drive->state != drive_unallocated)
670 && (drive->state != drive_referenced)) { /* and it's a real drive */
671 wlabel_on = 1; /* enable writing the label */
672 error = dev_dioctl(drive->dev, /* make the label writeable */
674 (caddr_t) & wlabel_on,
678 error = write_drive(drive, (char *) vhdr, VINUMHEADERLEN, VINUM_LABEL_OFFSET);
680 error = write_drive(drive, config, MAXCONFIG, VINUM_CONFIG_OFFSET); /* first config copy */
682 error = write_drive(drive, config, MAXCONFIG, VINUM_CONFIG_OFFSET + MAXCONFIG); /* second copy */
683 wlabel_on = 0; /* enable writing the label */
685 error = dev_dioctl(drive->dev, /* make the label non-writeable again */
687 (caddr_t) & wlabel_on,
693 "vinum: Can't write config to %s, error %d\n",
696 set_drive_state(drive->driveno, drive_down, setstate_force);
698 written_config = 1; /* we've written it on at least one drive */
700 } else /* not worth looking at, */
701 unlockdrive(drive); /* just unlock it again */
709 * Disk labels are a mess. The correct way to
710 * access them is with the DIOC[GSW]DINFO ioctls,
711 * but some programs, such as newfs, access the
712 * disk directly, so we have to write things
713 * there. We do this only on request. If a user
714 * request tries to read it directly, we fake up
719 * get_volume_label returns a label structure to lp, which
720 * is allocated by the caller
723 get_volume_label(char *name, int plexes, u_int64_t size, struct disklabel *lp)
725 bzero(lp, sizeof(struct disklabel));
727 strncpy(lp->d_typename, "vinum", sizeof(lp->d_typename));
728 lp->d_type = DTYPE_VINUM;
729 strncpy(lp->d_packname, name, min(sizeof(lp->d_packname), sizeof(name)));
730 lp->d_rpm = 14400 * plexes; /* to keep them guessing */
731 lp->d_interleave = 1;
735 * A Vinum volume has a single track with all
738 lp->d_secsize = DEV_BSIZE; /* bytes per sector */
739 lp->d_nsectors = size; /* data sectors per track */
740 lp->d_ntracks = 1; /* tracks per cylinder */
741 lp->d_ncylinders = 1; /* data cylinders per unit */
742 lp->d_secpercyl = size; /* data sectors per cylinder */
743 lp->d_secperunit = size; /* data sectors per unit */
745 lp->d_bbsize = BBSIZE;
746 lp->d_sbsize = SBSIZE;
748 lp->d_magic = DISKMAGIC;
749 lp->d_magic2 = DISKMAGIC;
752 * Set up partitions a, b and c to be identical
753 * and the size of the volume. a is UFS, b is
754 * swap, c is nothing.
756 lp->d_partitions[0].p_size = size;
757 lp->d_partitions[0].p_fsize = 1024;
758 lp->d_partitions[0].p_fstype = FS_BSDFFS; /* FreeBSD File System :-) */
759 lp->d_partitions[0].p_fsize = 1024; /* FS fragment size */
760 lp->d_partitions[0].p_frag = 8; /* and fragments per block */
761 lp->d_partitions[SWAP_PART].p_size = size;
762 lp->d_partitions[SWAP_PART].p_fstype = FS_SWAP; /* swap partition */
763 lp->d_partitions[LABEL_PART].p_size = size;
764 lp->d_npartitions = LABEL_PART + 1;
765 strncpy(lp->d_packname, name, min(sizeof(lp->d_packname), sizeof(name)));
766 lp->d_checksum = dkcksum(lp);
769 /* Write a volume label. This implements the VINUM_LABEL ioctl. */
771 write_volume_label(int volno)
773 struct disklabel *lp;
775 struct disklabel *dlp;
780 lp = (struct disklabel *) Malloc((sizeof(struct disklabel) + (DEV_BSIZE - 1)) & (DEV_BSIZE - 1));
784 if ((unsigned) (volno) >= (unsigned) vinum_conf.volumes_allocated) /* invalid volume */
787 vol = &VOL[volno]; /* volume in question */
788 if (vol->state <= volume_uninit) /* nothing there */
790 else if (vol->state < volume_up) /* not accessible */
791 return EIO; /* I/O error */
793 get_volume_label(vol->name, vol->plexes, vol->size, lp); /* get the label */
796 * Now write to disk. This code is derived from the
797 * system writedisklabel (), which does silly things
798 * like reading the label and refusing to write
799 * unless it's already there.
801 bp = geteblk((int) lp->d_secsize); /* get a buffer */
802 dev = make_adhoc_dev(&vinum_ops, vol->volno);
803 bp->b_bio1.bio_offset = (off_t)LABELSECTOR * lp->d_secsize;
804 bp->b_bcount = lp->d_secsize;
805 bzero(bp->b_data, lp->d_secsize);
806 dlp = (struct disklabel *) bp->b_data;
808 bp->b_flags &= ~B_INVAL;
809 bp->b_cmd = BUF_CMD_WRITE;
814 * vinumstrategy (bp);
816 * Negotiate with phk to get it fixed.
818 dev_dstrategy(dev, &bp->b_bio1);
820 bp->b_flags |= B_INVAL | B_AGE;
821 bp->b_flags &= ~B_ERROR;
826 /* Look at all disks on the system for vinum slices */
828 vinum_scandisk(char *devicename[], int drives)
830 struct drive *volatile drive;
831 volatile int driveno;
832 int firstdrive; /* first drive in this list */
833 volatile int gooddrives; /* number of usable drives found */
834 int firsttime; /* set if we have never configured before */
836 char *config_text; /* read the config info from disk into here */
837 char *volatile cptr; /* pointer into config information */
838 char *eptr; /* end pointer into config information */
839 char *config_line; /* copy the config line to */
841 int *volatile drivelist; /* list of drive indices */
842 #define DRIVENAMELEN 64
843 #define DRIVEPARTS 35 /* max partitions per drive, excluding c */
844 char partname[DRIVENAMELEN]; /* for creating partition names */
846 status = 0; /* success indication */
847 vinum_conf.flags |= VF_READING_CONFIG; /* reading config from disk */
849 gooddrives = 0; /* number of usable drives found */
850 firstdrive = vinum_conf.drives_used; /* the first drive */
851 firsttime = vinum_conf.drives_used == 0; /* are we a virgin? */
853 /* allocate a drive pointer list */
854 drivelist = (int *) Malloc(drives * DRIVEPARTS * sizeof(int));
855 CHECKALLOC(drivelist, "Can't allocate memory");
857 /* Open all drives and find which was modified most recently */
858 for (driveno = 0; driveno < drives; driveno++) {
859 char part; /* UNIX partition */
861 int founddrive; /* flag when we find a vinum drive */
866 founddrive = 0; /* no vinum drive found yet on this spindle */
869 * If the device path contains a slice we do not try to tack on
870 * another slice. If the device path has a partition we only check
873 if ((tmp = rindex(devicename[driveno], '/')) == NULL)
874 tmp = devicename[driveno];
875 while (*tmp && (*tmp < '0' || *tmp > '9'))
877 while (*tmp && *tmp >= '0' && *tmp <= '9')
880 has_slice = strtol(tmp + 1, &tmp, 0);
881 if (*tmp >= 'a' && *tmp <= 'p')
885 * Scan slices if no slice was specified, only if no partition was
888 if (has_slice == 0 && has_part == 0)
889 for (slice = 1; slice < 5; slice++) {
890 if (has_slice && slice != has_slice)
893 for (part = 'a'; part <= 'p'; part++) {
894 if (has_part && part != has_part)
898 ksnprintf(partname, DRIVENAMELEN,
899 "%ss%d%c", devicename[driveno], slice, part);
900 drive = check_drive(partname); /* try to open it */
901 if ((drive->lasterror != 0) /* didn't work, */
902 ||(drive->state != drive_up))
903 free_drive(drive); /* get rid of it */
904 else if (drive->flags & VF_CONFIGURED) /* already read this config, */
906 "vinum: already read config from %s\n", /* say so */
909 drivelist[gooddrives] = drive->driveno; /* keep the drive index */
910 drive->flags &= ~VF_NEWBORN; /* which is no longer newly born */
916 if (founddrive == 0 && has_slice == 0) { /* didn't find anything, */
917 for (part = 'a'; part <= 'p'; part++) { /* try the compatibility partition */
918 if (has_part && has_part != part)
923 ksnprintf(partname, DRIVENAMELEN,
924 "%s", devicename[driveno]);
926 ksnprintf(partname, DRIVENAMELEN,
927 "%s%c", devicename[driveno], part);
929 drive = check_drive(partname); /* try to open it */
930 if ((drive->lasterror != 0) /* didn't work, */
931 ||(drive->state != drive_up))
932 free_drive(drive); /* get rid of it */
933 else if (drive->flags & VF_CONFIGURED) /* already read this config, */
935 "vinum: already read config from %s\n", /* say so */
938 drivelist[gooddrives] = drive->driveno; /* keep the drive index */
939 drive->flags &= ~VF_NEWBORN; /* which is no longer newly born */
946 if (gooddrives == 0) {
948 log(LOG_WARNING, "vinum: no drives found\n");
950 log(LOG_INFO, "vinum: no additional drives found\n");
954 * We now have at least one drive
955 * open. Sort them in order of config time
956 * and merge the config info with what we
959 kqsort(drivelist, gooddrives, sizeof(int), drivecmp);
960 config_text = (char *) Malloc(MAXCONFIG * 2); /* allocate buffers */
961 CHECKALLOC(config_text, "Can't allocate memory");
962 config_line = (char *) Malloc(MAXCONFIGLINE * 2); /* allocate buffers */
963 CHECKALLOC(config_line, "Can't allocate memory");
964 for (driveno = 0; driveno < gooddrives; driveno++) { /* now include the config */
965 drive = &DRIVE[drivelist[driveno]]; /* point to the drive */
967 if (firsttime && (driveno == 0)) /* we've never configured before, */
968 log(LOG_INFO, "vinum: reading configuration from %s\n", drive->devicename);
970 log(LOG_INFO, "vinum: updating configuration from %s\n", drive->devicename);
972 if (drive->state == drive_up)
973 /* Read in both copies of the configuration information */
974 error = read_drive(drive, config_text, MAXCONFIG * 2, VINUM_CONFIG_OFFSET);
977 kprintf("vinum_scandisk: %s is %s\n", drive->devicename, drive_state(drive->state));
981 log(LOG_ERR, "vinum: Can't read device %s, error %d\n", drive->devicename, error);
982 free_drive(drive); /* give it back */
986 * At this point, check that the two copies
987 * are the same, and do something useful if
988 * not. In particular, consider which is
989 * newer, and what this means for the
990 * integrity of the data on the drive.
993 vinum_conf.drives_used++; /* another drive in use */
994 /* Parse the configuration, and add it to the global configuration */
995 for (cptr = config_text; *cptr != '\0';) { /* love this style(9) */
996 volatile int parse_status; /* return value from parse_config */
998 for (eptr = config_line; (*cptr != '\n') && (*cptr != '\0');) /* until the end of the line */
1000 *eptr = '\0'; /* and delimit */
1001 if (setjmp(command_fail) == 0) { /* come back here on error and continue */
1002 parse_status = parse_config(config_line, &keyword_set, 1); /* parse the config line */
1003 if (parse_status < 0) { /* error in config */
1005 * This config should have been parsed in user
1006 * space. If we run into problems here, something
1007 * serious is afoot. Complain and let the user
1008 * snarf the config to see what's wrong.
1011 "vinum: Config error on %s, aborting integration\n",
1013 free_drive(drive); /* give it back */
1017 while (*cptr == '\n')
1018 cptr++; /* skip to next line */
1021 drive->flags |= VF_CONFIGURED; /* read this drive's configuration */
1027 vinum_conf.flags &= ~VF_READING_CONFIG; /* no longer reading from disk */
1029 kprintf("vinum: couldn't read configuration");
1031 updateconfig(VF_READING_CONFIG); /* update from disk config */
1036 * Compare the modification dates of the drives, for qsort.
1037 * Return 1 if a < b, 0 if a == b, 01 if a > b: in other
1038 * words, sort backwards.
1041 drivecmp(const void *va, const void *vb)
1043 const struct drive *a = &DRIVE[*(const int *) va];
1044 const struct drive *b = &DRIVE[*(const int *) vb];
1046 if ((a->label.last_update.tv_sec == b->label.last_update.tv_sec)
1047 && (a->label.last_update.tv_usec == b->label.last_update.tv_usec))
1049 else if ((a->label.last_update.tv_sec > b->label.last_update.tv_sec)
1050 || ((a->label.last_update.tv_sec == b->label.last_update.tv_sec)
1051 && (a->label.last_update.tv_usec > b->label.last_update.tv_usec)))
1056 /* Local Variables: */
1057 /* fill-column: 50 */