freebsd-nq/sys/dev/vinum/vinumio.c

/*-
 * Copyright (c) 1997, 1998
 *	Nan Yang Computer Services Limited.  All rights reserved.
 *
 *  This software is distributed under the so-called ``Berkeley
 *  License'':
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by Nan Yang Computer
 *      Services Limited.
 * 4. Neither the name of the Company nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *  
 * This software is provided ``as is'', and any express or implied
 * warranties, including, but not limited to, the implied warranties of
 * merchantability and fitness for a particular purpose are disclaimed.
 * In no event shall the company or contributors be liable for any
 * direct, indirect, incidental, special, exemplary, or consequential
 * damages (including, but not limited to, procurement of substitute
 * goods or services; loss of use, data, or profits; or business
 * interruption) however caused and on any theory of liability, whether
 * in contract, strict liability, or tort (including negligence or
 * otherwise) arising in any way out of the use of this software, even if
 * advised of the possibility of such damage.
 *
 * $Id: vinumio.c,v 1.21 1998/12/30 06:04:31 grog Exp grog $
 */

#define STATIC						    /* nothing while we're testing XXX */

#include "opt_vinum.h"

#define REALLYKERNEL
#include "vinumhdr.h"
#include "request.h"
#include <miscfs/specfs/specdev.h>

extern jmp_buf command_fail;				    /* return on a failed command */
struct _ioctl_reply *ioctl_reply;			    /* data pointer, for returning error messages */

/* Why aren't these declared anywhere? XXX */
int setjmp(jmp_buf);
void longjmp(jmp_buf, int);

static char *sappend(char *txt, char *s);
static int drivecmp(const void *va, const void *vb);

/* Open the device associated with the drive, and set drive's vp.
 * Return an error number */
int
open_drive(struct drive *drive, struct proc *p, int verbose)
{
    struct nameidata nd;
    struct vattr va;
    int error;

    if (drive->devicename[0] == '\0')			    /* no device name */
	sprintf(drive->devicename, "/dev/%s", drive->label.name); /* get it from the drive name */
    NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, drive->devicename, p);
    error = vn_open(&nd, FREAD | FWRITE, 0);		    /* open the device */
    if (error != 0) {					    /* can't open? */
	set_drive_state(drive->driveno, drive_down, setstate_force);
	drive->lasterror = error;
	if (verbose)
	    printf("vinum open_drive %s: failed with error %d\n", drive->devicename, error); /* XXX */
	return error;
    }
    drive->vp = nd.ni_vp;
    drive->p = p;

    if (drive->vp->v_usecount > 1) {			    /* already in use? */
    if (verbose)
	printf("open_drive %s: use count %d, ignoring\n",   /* XXX where does this come from? */
		drive->devicename,
		drive->vp->v_usecount);
	drive->vp->v_usecount = 1;			    /* will this work? */
    }
    error = VOP_GETATTR(drive->vp, &va, NOCRED, drive->p);
    if (error) {
	VOP_UNLOCK(drive->vp, 0, drive->p);
	close_drive(drive);
	set_drive_state(drive->driveno, drive_down, setstate_force);
	drive->lasterror = error;
	if (verbose)
	    printf("vinum open_drive %s: GETAATTR returns error %d\n", drive->devicename, error); /* XXX */
	return error;
    }
    drive->dev = va.va_rdev;				    /* device */

    if (va.va_type != VBLK) {				    /* only consider block devices */
	VOP_UNLOCK(drive->vp, 0, drive->p);
	close_drive(drive);
	set_drive_state(drive->driveno, drive_down, setstate_force); /* this also closes the drive */
	drive->lasterror = ENOTBLK;
	if (verbose)
	    printf("vinum open_drive %s: Not a block device\n", drive->devicename); /* XXX */
	return ENOTBLK;
    }
    drive->vp->v_numoutput = 0;
    VOP_UNLOCK(drive->vp, 0, drive->p);
    return 0;
}

/* Set some variables in the drive struct
 * in more convenient form.  Return error indication */
int 
set_drive_parms(struct drive *drive)
{
    drive->blocksize = BLKDEV_IOSIZE;			    /* XXX do we need this? */
    drive->secsperblock = drive->blocksize		    /* number of sectors per block */
	/ drive->partinfo.disklab->d_secsize;

    /* Now update the label part */
    bcopy(hostname, drive->label.sysname, VINUMHOSTNAMELEN); /* put in host name */
    getmicrotime(&drive->label.date_of_birth);		    /* and current time */
    drive->label.drive_size = ((u_int64_t) drive->partinfo.part->p_size) /* size of the drive in bytes */
    *((u_int64_t) drive->partinfo.disklab->d_secsize);

    /* number of sectors available for subdisks */
    drive->sectors_available = drive->label.drive_size / DEV_BSIZE - DATASTART;

    /* XXX Bug in 3.0 as of January 1998: you can open
     * non-existent slices.  They have a length of 0 */
    if (drive->label.drive_size < MINVINUMSLICE) {	    /* too small to worry about */
	set_drive_state(drive->driveno, drive_down, setstate_force);
	drive->lasterror = ENOSPC;
	return ENOSPC;
    }
    drive->freelist_size = INITIAL_DRIVE_FREELIST;	    /* initial number of entries */
    drive->freelist = (struct drive_freelist *)
	Malloc(INITIAL_DRIVE_FREELIST * sizeof(struct drive_freelist));
    if (drive->freelist == NULL)			    /* can't malloc, dammit */
	return ENOSPC;
    drive->freelist_entries = 1;			    /* just (almost) the complete drive */
    drive->freelist[0].offset = DATASTART;		    /* starts here */
    drive->freelist[0].sectors = (drive->label.drive_size >> DEV_BSHIFT) - DATASTART; /* and it's this long */
    if (drive->label.name[0] != '\0')			    /* got a name */
	set_drive_state(drive->driveno, drive_up, setstate_force); /* our drive is accessible */
    else						    /* we know about it, but that's all */
	drive->state = drive_uninit;
    return 0;
}

/* Initialize a drive: open the device and add device
 * information */
int 
init_drive(struct drive *drive, int verbose)
{
    int error;

    if (drive->devicename[0] == '\0') {			    /* no device name yet, default to drive name */
	drive->lasterror = EINVAL;
	/* This is a bug if it happens internally,
	 * so print a message regardless */
	printf("vinum: Can't open drive without drive name\n");	/* XXX */
	return EINVAL;
    }
    error = open_drive(drive, curproc, verbose);	    /* open the drive */
    if (error)
	return error;

    error = VOP_IOCTL(drive->vp,			    /* get the partition information */
	DIOCGPART,
	(caddr_t) & drive->partinfo,
	FREAD,
	NOCRED,
	curproc);
    if (error) {
	if (verbose)
	    printf("vinum open_drive %s: Can't get partition information, error %d\n",
		drive->devicename,
		error);					    /* XXX */
	close_drive(drive);
	drive->lasterror = error;
	set_drive_state(drive->driveno, drive_down, setstate_force);
	return error;
    }
    if (drive->partinfo.part->p_fstype != 0) {		    /* not plain */
	drive->lasterror = EFTYPE;
	if (verbose)
	    printf("vinum open_drive %s: Wrong partition type for vinum\n", drive->devicename);	/* XXX */
	close_drive(drive);
	set_drive_state(drive->driveno, drive_down, setstate_force);
	return EFTYPE;
    }
    return set_drive_parms(drive);			    /* set various odds and ends */
}

/* Close a drive if it's open.  No errors */
void 
close_drive(struct drive *drive)
{
    if (drive->vp) {
	lockdrive(drive);				    /* keep the daemon out */
	vn_close(drive->vp, FREAD | FWRITE, NOCRED, drive->p);
	if (drive->vp->v_usecount) {			    /* XXX shouldn't happen */
	    printf("close_drive %s: use count still %d\n", drive->devicename, drive->vp->v_usecount);
	    drive->vp->v_usecount = 0;			    /* will this work? */
	}
	drive->vp = NULL;
	unlockdrive(drive);
    }
}

/* Remove drive from the configuration.
 * Caller must ensure that it isn't active
 */
void 
remove_drive(int driveno)
{
    struct drive *drive = &vinum_conf.drive[driveno];
    long long int nomagic = VINUM_NOMAGIC;		    /* no magic number */

    write_drive(drive,					    /* obliterate the magic, but leave a hint */
	(char *) &nomagic,
	8,
	VINUM_LABEL_OFFSET);
    free_drive(drive);					    /* close it and free resources */
    save_config();					    /* and save the updated configuration */
}

/* Transfer drive data.  Usually called from one of these defines;
 * #define read_drive(a, b, c, d) driveio (a, b, c, d, B_READ)
 * #define write_drive(a, b, c, d) driveio (a, b, c, d, B_WRITE)
 *
 * length and offset are in bytes, but must be multiples of sector
 * size.  The function *does not check* for this condition, and
 * truncates ruthlessly.
 * Return error number
 */
int
driveio(struct drive *drive, char *buf, size_t length, off_t offset, int flag)
{
    int error;
    struct buf *bp;
    char foo[40];

    error = 0;						    /* to keep the compiler happy */
    while (length) {					    /* divide into small enough blocks */
	int len = min(length, MAXBSIZE);		    /* maximum block device transfer is MAXBSIZE */

	bp = geteblk(len);				    /* get a buffer header */
	bp->b_flags = B_BUSY | flag;			    /* get busy */
	bp->b_proc = curproc;				    /* process */
	bp->b_dev = drive->vp->v_un.vu_specinfo->si_rdev;   /* device */
	bp->b_blkno = offset / drive->partinfo.disklab->d_secsize; /* block number */
	bp->b_data = buf;
	bp->b_bcount = len;
	bp->b_bufsize = len;

	(*bdevsw[major(bp->b_dev)]->d_strategy) (bp);	    /* initiate the transfer */

	error = biowait(bp);
	printf("driveio: %s dev 0x%x, block 0x%x, len 0x%lx, error %d\n", /* XXX */
	    flag ? "read" : "write",
	    bp->b_dev,
	    bp->b_blkno,
	    bp->b_bcount,
	    error);
	bcopy(buf, foo, 40);
	foo[39] = '\0';
	printf("---> %s\n", foo);			    /* XXXXXX */
	bp->b_flags |= B_INVAL | B_AGE;
	brelse(bp);
	if (error)
	    break;
	length -= len;					    /* update pointers */
	buf += len;
	offset += len;
    }
    return error;
}

/* Read data from a drive

 * Return error number
 */
int
read_drive(struct drive *drive, void *buf, size_t length, off_t offset)
{
    int error;
    struct buf *bp;
    daddr_t nextbn;
    long bscale;

    struct uio uio;
    struct iovec iov;
    daddr_t blocknum;					    /* block number */
    int blockoff;					    /* offset in block */
    int count;						    /* amount to transfer */

    iov.iov_base = buf;
    iov.iov_len = length;

    uio.uio_iov = &iov;
    uio.uio_iovcnt = length;
    uio.uio_offset = offset;
    uio.uio_resid = length;
    uio.uio_segflg = UIO_SYSSPACE;
    uio.uio_rw = UIO_READ;
    uio.uio_procp = curproc;

    bscale = btodb(drive->blocksize);			    /* mask off offset from block number */
    do {
	blocknum = btodb(uio.uio_offset) & ~(bscale - 1);   /* get the block number */
	blockoff = uio.uio_offset % drive->blocksize;	    /* offset in block */
	count = min((unsigned) (drive->blocksize - blockoff), /* amount to transfer in this block */
	    uio.uio_resid);

	/* XXX Check this.  I think the test is wrong */
	if (drive->vp->v_lastr + bscale == blocknum) {	    /* did our last read finish in this block? */
	    nextbn = blocknum + bscale;			    /* note the end of the transfer */
	    error = breadn(drive->vp,			    /* and read with read-ahead */
		blocknum,
		(int) drive->blocksize,
		&nextbn,
		(int *) &drive->blocksize,
		1,
		NOCRED,
		&bp);
	} else						    /* random read: just read this block */
	    error = bread(drive->vp, blocknum, (int) drive->blocksize, NOCRED, &bp);
	drive->vp->v_lastr = blocknum;			    /* note the last block we read */
	count = min(count, drive->blocksize - bp->b_resid);
	if (error) {
	    brelse(bp);
	    return error;
	}
	error = uiomove((char *) bp->b_data + blockoff, count, &uio); /* move the data */
	brelse(bp);
    }
    while (error == 0 && uio.uio_resid > 0 && count != 0);
    return error;
}

/* Write data to a drive

 * Return error number
 */
int 
write_drive(struct drive *drive, void *buf, size_t length, off_t offset)
{
    int error;
    struct buf *bp;
    struct uio uio;
    struct iovec iov;
    daddr_t blocknum;					    /* block number */
    int blockoff;					    /* offset in block */
    int count;						    /* amount to transfer */
    int blockshift;

    if (drive->state == drive_down)			    /* currently down */
	return 0;					    /* ignore */
    if (drive->vp == NULL) {
	drive->lasterror = ENODEV;
	return ENODEV;					    /* not configured yet */
    }
    iov.iov_base = buf;
    iov.iov_len = length;

    uio.uio_iov = &iov;
    uio.uio_iovcnt = length;
    uio.uio_offset = offset;
    uio.uio_resid = length;
    uio.uio_segflg = UIO_SYSSPACE;
    uio.uio_rw = UIO_WRITE;
    uio.uio_procp = curproc;

    error = 0;
    blockshift = btodb(drive->blocksize) - 1;		    /* amount to shift block number
							    * to get sector number */
    do {
	blocknum = btodb(uio.uio_offset) & ~blockshift;	    /* get the block number */
	blockoff = uio.uio_offset % drive->blocksize;	    /* offset in block */
	count = min((unsigned) (drive->blocksize - blockoff), /* amount to transfer in this block */
	    uio.uio_resid);
	if (count == drive->blocksize)			    /* the whole block */
	    bp = getblk(drive->vp, blocknum, drive->blocksize, 0, 0); /* just transfer it */
	else						    /* partial block: */
	    error = bread(drive->vp,			    /* read it first */
		blocknum,
		drive->blocksize,
		NOCRED,
		&bp);
	count = min(count, drive->blocksize - bp->b_resid); /* how much will we transfer now? */
	if (error == 0)
	    error = uiomove((char *) bp->b_data + blockoff, /* move the data to the block */
		count,
		&uio);
	if (error) {
	    brelse(bp);
	    drive->lasterror = error;
	    switch (error) {
	    case EIO:
		set_drive_state(drive->driveno, drive_down, setstate_force);
		break;

		/* XXX Add other possibilities here */
	    default:
	    }
	    return error;
	}
	if (count + blockoff == drive->blocksize)
	    /* The transfer goes to the end of the block.  There's
	     * no need to wait for any more data to arrive. */
	    bawrite(bp);				    /* start the write now */
	else
	    bdwrite(bp);				    /* do a delayed write */
    }
    while (error == 0 && uio.uio_resid > 0 && count != 0);
    if (error)
	drive->lasterror = error;
    return error;					    /* OK */
}

/* Wake up on completion */
void 
drive_io_done(struct buf *bp)
{
    wakeup((caddr_t) bp);				    /* Wachet auf! */
    bp->b_flags &= ~B_CALL;				    /* don't do this again */
}

/* Check a drive for a vinum header.  If found, 
 * update the drive information.  We come here
 * with a partially populated drive structure
 * which includes the device name.
 *
 * Return information on what we found.
 *
 * This function is called from two places: check_drive,
 * which wants to find out whether the drive is a
 * Vinum drive, and config_drive, which asserts that
 * it is a vinum drive.  In the first case, we don't
 * print error messages (verbose==0), in the second
 * we do (verbose==1).
 */
enum drive_label_info 
read_drive_label(struct drive *drive, int verbose)
{
    int error;
    int result;						    /* result of our search */
    struct vinum_hdr *vhdr;				    /* and as header */

    error = init_drive(drive, 0);			    /* find the drive */
    if (error)						    /* find the drive */
	return DL_CANT_OPEN;				    /* not ours */

    vhdr = (struct vinum_hdr *) Malloc(VINUMHEADERLEN);	    /* allocate buffers */
    CHECKALLOC(vhdr, "Can't allocate memory");

    error = read_drive(drive, (void *) vhdr, VINUMHEADERLEN, VINUM_LABEL_OFFSET);
    if (vhdr->magic == VINUM_MAGIC) {			    /* ours! */
	if (drive->label.name[0]			    /* we have a name for this drive */
	&&(strcmp(drive->label.name, vhdr->label.name))) {  /* but it doesn't match the real name */
	    drive->lasterror = EINVAL;
	    result = DL_WRONG_DRIVE;			    /* it's the wrong drive */
	} else {
	    drive->state = drive_up;			    /* it's OK by us */
	    result = DL_OURS;
	}
	/* We copy the drive anyway so that we have
	 * the correct name in the drive info.  This
	 * may not be the name specified */
	drive->label = vhdr->label;			    /* put in the label information */
    } else if (vhdr->magic == VINUM_NOMAGIC)		    /* was ours, but we gave it away */
	result = DL_DELETED_LABEL;
    else
	result = DL_NOT_OURS;				    /* we could have it, but we don't yet */
    Free(vhdr);						    /* that's all. */
    return result;
}

/* Check a drive for a vinum header.  If found, 
 * read configuration information from the drive and
 * incorporate the data into the configuration.
 *
 * Return 
 */
struct drive *
check_drive(char *drivename)
{
    int driveno;
    struct drive *drive;

    driveno = find_drive_by_dev(drivename, 1);		    /* entry doesn't exist, create it */
    drive = &vinum_conf.drive[driveno];			    /* and get a pointer */

    if (read_drive_label(drive, 0) != DL_OURS) {	    /* not ours */
	if (drive->lasterror == 0)
	    drive->lasterror = ENODEV;
	set_drive_state(drive->driveno, drive_down, setstate_force);
    }
    return drive;
}

static char *
sappend(char *txt, char *s)
{
    while (*s++ = *txt++);
    return s - 1;
}

/* Kludge: kernel printf doesn't handle quads */
static char *lltoa (long long l, char *s);

static char *lltoa (long long l, char *s)
{
  if (l < 0)
    {
    *s++ = '-';
    l = -l;
    }
  if (l > 9)
    {
    s = lltoa (l / 10, s);
    l %= 10;
    }
  *s++ = l + '0';
  return s;
  }
/* Format the configuration in text form into the buffer
 * at config.  Don't go beyond len bytes
 * XXX this stinks.  Fix soon. */
void format_config (char *config, int len)
{
#if __FreeBSD__ == 2
  BROKEN_GDB
#endif
  int i;
  int j;
  char *s = config;
  
  bzero (config, len);
  
#if 0							    /* XXX die, die */
  /* First write the drive configuration */
  for (i = 0; i < vinum_conf.drives_used; i++)
    {
    struct drive *drive;
    
    drive = &vinum_conf.drive [i];
    if (drive->state != drive_unallocated)
      {
      sprintf (s,
	       "drive %s state %s device %s\n",
	       drive->label.name,
	       drive_state (drive->state),
	       drive->devicename);
      while (*s)
	s++;						    /* find the end */
      if (s > &config [len - 80])
	{
	printf ("vinum: configuration data overflow\n");
	return;
	}
      }
    }
#endif
  
  /* Then the volume configuration */
  for (i = 0; i < vinum_conf.volumes_used; i++)
    {
    struct volume *vol;
    
    vol = &vinum_conf.volume [i];
    if (vol->state != volume_unallocated)
      {
      if (vol->preferred_plex >= 0)			    /* preferences, */
	sprintf (s,
		 "volume %s state %s readpol prefer %s",
		 vol->name,
		 volume_state (vol->state),
		 vinum_conf.plex [vol->preferred_plex].name);
      else						    /* default round-robin */
	sprintf (s,
		 "volume %s state %s",
		 vol->name,
		 volume_state (vol->state));
      while (*s)
	s++;						    /* find the end */
#if 0
      /* Do we need to state the plexes? */
      for (j = 0; j < vol->plexes; j++)
	{
	sprintf (s, " plex %s", vinum_conf.plex [vol->plex [j]].name);
	while (*s)
	  s++;						    /* find the end */
	}
#endif
      s = sappend ("\n", s);
      if (s > &config [len - 80])
	{
	printf ("vinum: configuration data overflow\n");
	return;
	}
      }
    }

  /* Then the plex configuration */
  for (i = 0; i < vinum_conf.plexes_used; i++)
    {
    struct plex *plex;
    
    plex = &vinum_conf.plex [i];
    if (plex->state != plex_unallocated)
      {
      sprintf (s, "plex name %s state %s org %s ",
	       plex->name,
	       plex_state (plex->state), 
	       plex_org (plex->organization) );
      while (*s)
	s++;						    /* find the end */
      if ((plex->organization == plex_striped)
#ifdef RAID5
	  || (plex->organization == plex_raid5)
#endif
	  )
	{
	sprintf (s, "%db ", (int) plex->stripesize);
	while (*s)
	  s++;						    /* find the end */
	}
      if (plex->volno >= 0)				    /* we have a volume */
	sprintf (s, "vol %s ", vinum_conf.volume [plex->volno].name);
      while (*s)
	s++;						    /* find the end */
      for (j = 0; j < plex->subdisks; j++)
	{
	sprintf (s, " sd %s", vinum_conf.sd [plex->sdnos [j]].name);
	}
      s = sappend ("\n", s);
      if (s > &config [len - 80])
	{
	printf ("vinum: configuration data overflow\n");
	return;
	}
      }
    }
  
  /* And finally the subdisk configuration */
  for (i = 0; i < vinum_conf.subdisks_used; i++)
    {
    struct sd *sd = &vinum_conf.sd [i];			    /* XXX */
    if (vinum_conf.sd [i].state != sd_unallocated)
      {
      sprintf (s,
	       "sd name %s drive %s plex %s state %s len ",
	       sd->name,
	       vinum_conf.drive [sd->driveno].label.name,
	       vinum_conf.plex [sd->plexno].name,
	       sd_state (sd->state) );
      while (*s)
	s++;						    /* find the end */
      s = lltoa (sd->sectors, s);
      s = sappend ("b driveoffset ", s);
      s = lltoa (sd->driveoffset, s);
      s = sappend ("b plexoffset ", s);
      s = lltoa (sd->plexoffset, s);
      s = sappend ("b\n", s);
      if (s > &config [len - 80])
	{
	printf ("vinum: configuration data overflow\n");
	return;
	}
      }
    }
  }

/* issue a save config request to the d<>mon.  The actual work
 * is done in process context by daemon_save_config */
void 
save_config(void)
{
    queue_daemon_request(daemonrq_saveconfig, NULL);
}

/* Write the configuration to all vinum slices.  This
 * is performed by the d<EFBFBD>mon only */
void 
daemon_save_config(void)
{
    int error;
    int written_config;					    /* set when we first write the config to disk */
    int driveno;
    struct drive *drive;				    /* point to current drive info */
    struct vinum_hdr *vhdr;				    /* and as header */
    char *config;					    /* point to config data */
    int wlabel_on;					    /* to set writing label on/off */

    /* don't save the configuration while we're still working on it */
    if (vinum_conf.flags & VF_CONFIGURING)
	return;
    written_config = 0;					    /* no config written yet */
    /* Build a volume header */
    vhdr = (struct vinum_hdr *) Malloc(VINUMHEADERLEN);	    /* get space for the config data */
    CHECKALLOC(vhdr, "Can't allocate config data");
    vhdr->magic = VINUM_MAGIC;				    /* magic number */
    vhdr->config_length = MAXCONFIG;			    /* length of following config info */

    config = Malloc(MAXCONFIG);				    /* get space for the config data */
    CHECKALLOC(config, "Can't allocate config data");

    format_config(config, MAXCONFIG);
    error = 0;						    /* no errors yet */
    for (driveno = 0; driveno < vinum_conf.drives_used; driveno++) {
	drive = &vinum_conf.drive[driveno];		    /* point to drive */
	lockdrive(drive);				    /* don't let it change */

	/* First, do some drive consistency checks.  Some
	 * of these are kludges, others require a process
	 * context and couldn't be done before */
	if ((drive->devicename[0] == '\0')		    /* XXX we keep getting these nameless drives */
	||(drive->label.name[0] == '\0')) {		    /* XXX we keep getting these nameless drives */
	    unlockdrive(drive);
	    printf("Removing incomplete drive, index %d\n", driveno);
	    if (drive->vp)				    /* how can it be open without a name? */
		close_drive(drive);
	    free_drive(drive);				    /* get rid of it */
	    break;
	}
	if ((drive->vp == NULL)				    /* drive not open */
	&&(drive->state > drive_down)) {		    /* and it thinks it's not down */
	    unlockdrive(drive);
	    set_drive_state(driveno, drive_down, setstate_force); /* tell it what's what */
	}
	if ((drive->state == drive_down)		    /* it's down */
	&&(drive->vp != NULL)) {			    /* but open, */
	    unlockdrive(drive);
	    close_drive(drive);				    /* close it */
	} else if (drive->state > drive_down) {
	    getmicrotime(&drive->label.last_update);	    /* time of last update is now */
	    bcopy((char *) &drive->label,		    /* and the label info from the drive structure */
		(char *) &vhdr->label,
		sizeof(vhdr->label));
	    if ((drive->state != drive_unallocated)
		&& (drive->state != drive_uninit)) {
		wlabel_on = 1;				    /* enable writing the label */
		error = VOP_IOCTL(drive->vp,		    /* make the label writeable */
		    DIOCWLABEL,
		    (caddr_t) & wlabel_on,
		    FWRITE,
		    NOCRED,
		    curproc);
		if (error == 0)
		    error = write_drive(drive, (char *) vhdr, VINUMHEADERLEN, VINUM_LABEL_OFFSET);
		if (error == 0)
		    error = write_drive(drive, config, MAXCONFIG, VINUM_CONFIG_OFFSET);	/* first config copy */
		if (error == 0)
		    error = write_drive(drive, config, MAXCONFIG, VINUM_CONFIG_OFFSET + MAXCONFIG); /* second copy */
		wlabel_on = 0;				    /* enable writing the label */
		if (error == 0)
		    VOP_IOCTL(drive->vp,		    /* make the label non-writeable again */
			DIOCWLABEL,
			(caddr_t) & wlabel_on,
			FWRITE,
			NOCRED,
			curproc);
		unlockdrive(drive);
		if (error) {
		    printf("vinum: Can't write config to %s, error %d\n", drive->devicename, error);
		    set_drive_state(drive->driveno, drive_down, setstate_force);
		} else
		    written_config = 1;			    /* we've written it on at least one drive */
	    }
	}
    }
    Free(vhdr);
    Free(config);
}

/* Disk labels are a mess.  The correct way to access them
 * is with the DIOC[GSW]DINFO ioctls, but some programs, such
 * as newfs, access the disk directly, so we have to write
 * things there.  We do this only on request.  If a user
 * request tries to read it directly, we fake up one on the fly.
 */

/* get_volume_label returns a label structure to lp, which
 * is allocated by the caller */
void 
get_volume_label(struct volume *vol, struct disklabel *lp)
{
    bzero(lp, sizeof(struct disklabel));

    strncpy(lp->d_typename, "vinum", sizeof(lp->d_typename));
    lp->d_type = DTYPE_VINUM;
    strncpy(lp->d_packname, vol->name, min(sizeof(lp->d_packname), sizeof(vol->name)));
    lp->d_rpm = 14400 * vol->plexes;			    /* to keep them guessing */
    lp->d_interleave = 1;
    lp->d_flags = 0;

    /* Fitting unto the vine, a vinum has a single
     *  track with all its sectors */
    lp->d_secsize = DEV_BSIZE;				    /* bytes per sector */
    lp->d_nsectors = vol->size;				    /* data sectors per track */
    lp->d_ntracks = 1;					    /* tracks per cylinder */
    lp->d_ncylinders = 1;				    /* data cylinders per unit */
    lp->d_secpercyl = vol->size;			    /* data sectors per cylinder */
    lp->d_secperunit = vol->size;			    /* data sectors per unit */

    lp->d_bbsize = BBSIZE;
    lp->d_sbsize = SBSIZE;

    lp->d_magic = DISKMAGIC;
    lp->d_magic2 = DISKMAGIC;

    /* Set up partitions a, b and c to be identical
     * and the size of the volume.  a is UFS, b is
     * swap, c is nothing */
    lp->d_partitions[0].p_size = vol->size;
    lp->d_partitions[0].p_fsize = 1024;
    lp->d_partitions[0].p_fstype = FS_BSDFFS;		    /* FreeBSD File System :-) */
    lp->d_partitions[0].p_fsize = 1024;			    /* FS fragment size */
    lp->d_partitions[0].p_frag = 8;			    /* and fragments per block */
    lp->d_partitions[SWAP_PART].p_size = vol->size;
    lp->d_partitions[SWAP_PART].p_fstype = FS_SWAP;	    /* swap partition */
    lp->d_partitions[LABEL_PART].p_size = vol->size;
    lp->d_npartitions = LABEL_PART + 1;
    strncpy(lp->d_packname, vol->name, min(sizeof(lp->d_packname), sizeof(vol->name)));
    lp->d_checksum = dkcksum(lp);
}

/* Write a volume label.  This implements the VINUM_LABEL ioctl. */
int 
write_volume_label(int volno)
{
    struct disklabel *lp;
    struct buf *bp;
    struct disklabel *dlp;
    struct volume *vol;
    int error;

    lp = (struct disklabel *) Malloc((sizeof(struct disklabel) + (DEV_BSIZE - 1)) & (DEV_BSIZE - 1));
    if (lp == 0)
	return ENOMEM;

    if ((unsigned) (volno) >= (unsigned) vinum_conf.volumes_used) /* invalid volume */
	return ENOENT;

    vol = &VOL[volno];					    /* volume in question */
    if (vol->state == volume_unallocated)		    /* nothing there */
	return ENOENT;

    get_volume_label(vol, lp);				    /* get the label */

    /* Now write to disk.  This code is derived from the
     * system writedisklabel (), which does silly things
     * like reading the label and refusing to write
     * unless it's already there. */
    bp = geteblk((int) lp->d_secsize);			    /* get a buffer */
    bp->b_dev = minor(vol->devno) | (CDEV_MAJOR << MAJORDEV_SHIFT); /* our own raw volume */
    bp->b_blkno = LABELSECTOR * ((int) lp->d_secsize / DEV_BSIZE);
    bp->b_bcount = lp->d_secsize;
    bzero(bp->b_data, lp->d_secsize);
    dlp = (struct disklabel *) bp->b_data;
    *dlp = *lp;
    bp->b_flags &= ~B_INVAL;
    bp->b_flags |= B_BUSY | B_WRITE;
    vinumstrategy(bp);					    /* write it out */
    error = biowait(bp);
    bp->b_flags |= B_INVAL | B_AGE;
    brelse(bp);
    return error;
}

/* Initialize a subdisk */
int 
initsd(int sdno)
{
    return 0;
}

/* Look at all disks on the system for vinum slices */
void 
vinum_scandisk(char *drivename[], int drives)
{
    struct drive *volatile drive;
    volatile int driveno;
    int firstdrive;					    /* first drive in this list */
    volatile int gooddrives;				    /* number of usable drives found */
    int firsttime;					    /* set if we have never configured before */
    int error;
    struct nameidata nd;				    /* mount point credentials */
    char *config_text;					    /* read the config info from disk into here */
    char *volatile cptr;				    /* pointer into config information */
    char *eptr;						    /* end pointer into config information */
    char *config_line;					    /* copy the config line to */
    volatile int status;
    struct drive **volatile drivelist;
#define DRIVENAMELEN 64
#define DRIVEPARTS   35					    /* max partitions per drive, excluding c */
    char partname[DRIVENAMELEN];			    /* for creating partition names */

    status = 0;						    /* success indication */
    vinum_conf.flags |= VF_KERNELOP | VF_READING_CONFIG;    /* kernel operation: reading config */

    gooddrives = 0;					    /* number of usable drives found */
    firstdrive = vinum_conf.drives_used;		    /* the first drive */
    firsttime = vinum_conf.drives_used == 0;		    /* are we a virgin? */


    /* allocate a drive pointer list */
    drivelist = (struct drive **) Malloc(drives * DRIVEPARTS * sizeof(struct drive *));
    CHECKALLOC(drivelist, "Can't allocate memory");

    /* Open all drives and find which was modified most recently */
    for (driveno = 0; driveno < drives; driveno++) {
	char part;					    /* UNIX partition */

	for (part = 'a'; part < 'i'; part++)
	    if (part != 'c') {				    /* don't do the c partition */
		snprintf(partname,			    /* /dev/sd0a */
		    DRIVENAMELEN,
		    "%s%c",
		    drivename[driveno],
		    part);
		drive = check_drive(partname);		    /* try to open it */
		if (drive->lasterror != 0)		    /* didn't work, */
		    free_drive(drive);			    /* get rid of it */
		else if (drive->flags & VF_CONFIGURED)	    /* already read this config, */
		    printf("vinum: already read config from %s\n", /* say so */
			drive->label.name);
		else {
		    drivelist[gooddrives] = drive;	    /* keep a pointer to the drive */
		    drive->flags &= ~VF_NEWBORN;	    /* which is no longer newly born */
		    gooddrives++;
		}
	    }
    }

    if (gooddrives == 0) {
	printf("vinum: no drives found\n");
	return;
    }
    /* We now have at least one drive
     * open.  Sort them in order of config time
     * and merge the config info with what we
     * have already */
    qsort(drivelist, gooddrives, sizeof(struct drive *), drivecmp);
    config_text = (char *) Malloc(MAXCONFIG * 2);	    /* allocate buffers */
    CHECKALLOC(config_text, "Can't allocate memory");
    config_line = (char *) Malloc(MAXCONFIGLINE * 2);	    /* allocate buffers */
    CHECKALLOC(config_line, "Can't allocate memory");
    for (driveno = 0; driveno < gooddrives; driveno++) {    /* now include the config */
	drive = drivelist[driveno];

	if (firsttime && (driveno == 0))		    /* we've never configured before, */
	    printf("vinum: reading configuration from %s\n", drive->devicename);
	else
	    printf("vinum: updating configuration from %s\n", drive->devicename);

	/* Read in both copies of the configuration information */
	error = read_drive(drive, config_text, MAXCONFIG * 2, VINUM_CONFIG_OFFSET);

	if (error != 0) {
	    printf("vinum: Can't read device %s, error %d\n", drive->devicename, error);
	    Free(config_text);
	    Free(config_line);
	    free_drive(drive);				    /* give it back */
	    status = error;
	}
	/* XXX At this point, check that the two copies are the same, and do something useful if not.
	 * In particular, consider which is newer, and what this means for the integrity of the
	 * data on the drive */

	else {
	    /* Parse the configuration, and add it to the global configuration */
	    for (cptr = config_text; *cptr != '\0';) {	    /* love this style(9) */
		volatile int parse_status;		    /* return value from parse_config */

		for (eptr = config_line; (*cptr != '\n') && (*cptr != '\0');) /* until the end of the line */
		    *eptr++ = *cptr++;
		*eptr = '\0';				    /* and delimit */
		if (setjmp(command_fail) == 0) {	    /* come back here on error and continue */
		    parse_status = parse_config(config_line, &keyword_set, 1); /* parse the config line */
		    if (parse_status < 0) {		    /* error in config */
							    /* This config should have been parsed in user
			   * space.  If we run into problems here, something
			   * serious is afoot.  Complain and let the user
			   * snarf the config to see what's wrong */
			printf("vinum: Config error on drive %s, aborting integration\n", nd.ni_dirp);
			Free(config_text);
			Free(config_line);
			free_drive(drive);		    /* give it back */
			status = EINVAL;
		    }
		}
		while (*cptr == '\n')
		    cptr++;				    /* skip to next line */
	    }
	}
	drive->flags |= VF_CONFIGURED;			    /* read this drive's configuration */
    }

    Free(config_text);
    Free(drivelist);
    vinum_conf.flags &= ~(VF_KERNELOP | VF_READING_CONFIG);
    if (status != 0)
	throw_rude_remark(status, "Couldn't read configuration");
    updateconfig(VF_KERNELOP);				    /* update from kernel space */
}

/* Compare the modification dates of the drives, for qsort.
 * Return 1 if a < b, 0 if a == b, 01 if a > b: in other
 * words, sort backwards */
int 
drivecmp(const void *va, const void *vb)
{
    struct drive *a = *(struct drive **) va;
    struct drive *b = *(struct drive **) vb;

    if ((a->label.last_update.tv_sec == b->label.last_update.tv_sec)
	&& (a->label.last_update.tv_usec == b->label.last_update.tv_usec))
	return 0;
    else if ((a->label.last_update.tv_sec > b->label.last_update.tv_sec)
	    || ((a->label.last_update.tv_sec == b->label.last_update.tv_sec)
	    && (a->label.last_update.tv_usec > b->label.last_update.tv_usec)))
	return -1;
    else
	return 1;
}