diff options
Diffstat (limited to 'lkm/vinum/config.c')
| -rw-r--r-- | lkm/vinum/config.c | 1723 |
1 files changed, 0 insertions, 1723 deletions
diff --git a/lkm/vinum/config.c b/lkm/vinum/config.c deleted file mode 100644 index 24df101..0000000 --- a/lkm/vinum/config.c +++ /dev/null @@ -1,1723 +0,0 @@ -/* To do: - - * Don't store drive configuration on the config DB: read each drive's header - * to decide where it is. - * - * Accept any old crap in the config_<foo> functions, and complain when - * we try to bring it up. - * - * When trying to bring volumes up, check that the complete address range - * is covered. - */ -/*- - * 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: config.c,v 1.19 1998/10/05 02:48:15 grog Exp grog $ - */ - -#define STATIC /* nothing while we're testing XXX */ - -#define REALLYKERNEL -#include "vinumhdr.h" - -extern jmp_buf command_fail; /* return on a failed command */ - -#if __FreeBSD__ >= 3 -/* Why aren't these declared anywhere? XXX */ -void longjmp(jmp_buf, int); -#endif - -#define MAXTOKEN 64 /* maximum number of tokens in a line */ - -/* We can afford the luxury of global variables here, - * since start_config ensures that these functions - * are single-threaded. */ - -/* These are indices in vinum_conf of the last-mentioned of each kind of object */ -static int current_drive = -1; /* note the last drive we mention, for - * some defaults */ -static int current_plex = -1; /* and the same for the last plex */ -static int current_volume = -1; /* and the last volme */ -static struct _ioctl_reply *ioctl_reply; /* struct to return via ioctl */ - - -/* These values are used by most of these routines, so set them as globals */ -static char *token[MAXTOKEN]; /* pointers to individual tokens */ -static int tokens; /* number of tokens */ - -#define TOCONS 0x01 -#define TOTTY 0x02 -#define TOLOG 0x04 - -struct putchar_arg { - int flags; - struct tty *tty; -}; - -#define MSG_MAX 1024 /* maximum length of a formatted message */ -/* Format an error message and return to the user in the reply. - * CARE: This routine is designed to be called only from the - * configuration routines, so it assumes it's the owner of - * the configuration lock, and unlocks it on exit */ -void -throw_rude_remark(int error, char *msg,...) -{ - BROKEN_GDB; - int retval; - va_list ap; - char *text; - static int finishing; /* don't recurse */ - int was_finishing; - - va_start(ap, msg); - if ((ioctl_reply != NULL) /* we're called from the user */ - &&(!(vinum_conf.flags & VF_KERNELOP))) { /* and we're not doing kernel things: return msg */ - /* XXX We can't just format to ioctl_reply, since it - * may contain our input parameters */ - text = Malloc(MSG_MAX); - if (text == NULL) { - printf("vinum: can't allocate error message buffer"); - printf("vinum: "); - vprintf(msg, ap); /* print to the console */ - printf("\n"); - } else { - retval = kvprintf(msg, NULL, (void *) text, 10, ap); - text[retval] = '\0'; /* delimit */ - strcpy(ioctl_reply->msg, text); - ioctl_reply->error = error; /* first byte is the error number */ - Free(text); - } - } else { - printf("vinum: "); - vprintf(msg, ap); /* print to the console */ - printf("\n"); - } - va_end(ap); - - if (vinum_conf.flags & VF_READING_CONFIG) /* go through to the bitter end, */ - return; - /* We have a problem here: we want to unlock the - * configuration, which implies tidying up, but - * if we find an error while tidying up, we could - * recurse for ever. Use this kludge to only try - * once */ - was_finishing = finishing; - finishing = 1; - finish_config(was_finishing); /* unlock anything we may be holding */ - finishing = was_finishing; - longjmp(command_fail, error); -} - -/* Function declarations */ -int atoi(char *); /* no atoi in the kernel */ - -/* Minimal version of atoi */ -int -atoi(char *s) -{ /* no atoi in the kernel */ - BROKEN_GDB; - int r = 0; - int sign = 1; - - while (((*s >= '0') && (*s <= '9')) || (*s == '-')) { - if (*s == '-') - sign = -sign; - else - r = r * 10 + (*s - '0'); - } - return r; -} - -/* Find index of volume in vinum_conf. Return the index - * if found, or -1 if not */ -int -volume_index(struct volume *vol) -{ - BROKEN_GDB; - int i; - - for (i = 0; i < vinum_conf.volumes_used; i++) - if (&VOL[i] == vol) - return i; - return -1; -} - -/* Find index of plex in vinum_conf. Return the index - * if found, or -1 if not */ -int -plex_index(struct plex *plex) -{ - BROKEN_GDB; - int i; - - for (i = 0; i < vinum_conf.plexes_used; i++) - if (&PLEX[i] == plex) - return i; - return -1; -} - -/* Find index of subdisk in vinum_conf. Return the index - * if found, or -1 if not */ -int -sd_index(struct sd *sd) -{ - BROKEN_GDB; - int i; - - for (i = 0; i < vinum_conf.subdisks_used; i++) - if (&SD[i] == sd) - return i; - return -1; -} - -/* Find index of drive in vinum_conf. Return the index - * if found, or -1 if not */ -int -drive_index(struct drive *drive) -{ - BROKEN_GDB; - int i; - - for (i = 0; i < vinum_conf.drives_used; i++) - if (&DRIVE[i] == drive) - return i; - return -1; -} - -/* Check a volume to see if the plex is already assigned to it. - * Return index in volume->plex, or -1 if not assigned */ -int -my_plex(int volno, int plexno) -{ - BROKEN_GDB; - int i; - struct volume *vol; - - vol = &VOL[volno]; /* point to volno */ - for (i = 0; i < vol->plexes; i++) - if (vol->plex[i] == plexno) - return i; - return -1; /* not found */ -} - -/* Check a plex to see if the subdisk is already assigned to it. - * Return index in plex->sd, or -1 if not assigned */ -int -my_sd(int plexno, int sdno) -{ - BROKEN_GDB; - int i; - struct plex *plex; - - plex = &PLEX[plexno]; - for (i = 0; i < plex->subdisks; i++) - if (plex->sdnos[i] == sdno) - return i; - return -1; /* not found */ -} - -/* Check that this operation is being done in the kernel. - * longjmp out if not. op the name of the operation. */ -void -checkkernel(char *op) -{ - BROKEN_GDB; - if (vinum_conf.flags & VF_KERNELOP == 0) - throw_rude_remark(EPERM, "Can't perform '%s' from user space", op); -} - -/* Add plex to the volume if possible */ -int -give_plex_to_volume(int volno, int plexno) -{ - BROKEN_GDB; - struct volume *vol; - - /* XXX It's not an error for the plex to already - * belong to the volume, but we need to check a - * number of things to make sure it's done right. - * Some day. */ - if (my_plex(volno, plexno) >= 0) - return plexno; /* that's it */ - - vol = &VOL[volno]; /* point to volume */ - if (vol->plexes == MAXPLEX) /* all plexes allocated */ - throw_rude_remark(ENOSPC, - "Too many plexes for volume %s", - vol->name); - vol->plex[vol->plexes] = plexno; /* this one */ - vol->plexes++; /* add another plex */ - PLEX[plexno].volno = volno; /* note the number of our volume */ - - return vol->plexes - 1; /* and return its index */ -} - -/* Add subdisk to a plex if possible */ -int -give_sd_to_plex(int plexno, int sdno) -{ - BROKEN_GDB; - int i; - struct plex *plex; - struct sd *sd; - - /* XXX It's not an error for the sd to already - * belong to the plex, but we need to check a - * number of things to make sure it's done right. - * Some day. */ - i = my_sd(plexno, sdno); - if (i >= 0) /* does it already belong to us? */ - return i; /* that's it */ - - plex = &PLEX[plexno]; /* point to the plex */ - sd = &SD[sdno]; /* and the subdisk */ - - /* Do we have an offset? Otherwise put it after the last one */ - if (sd->plexoffset < 0) { /* no offset specified */ - if (plex->subdisks > 0) { - struct sd *lastsd = &SD[plex->sdnos[plex->subdisks - 1]]; /* last subdisk */ - sd->plexoffset = lastsd->sectors + lastsd->plexoffset; /* take it */ - } else /* first subdisk */ - sd->plexoffset = 0; /* start at the beginning */ - } - if (plex->subdisks == MAXSD) /* we already have our maximum */ - throw_rude_remark(ENOSPC, /* crap out */ - "Can't add %s to %s: plex full\n", - sd->name, - plex->name); - - plex->subdisks++; /* another entry */ - if (plex->subdisks >= plex->subdisks_allocated) /* need more space */ - EXPAND(plex->sdnos, int, plex->subdisks_allocated, INITIAL_SUBDISKS_IN_PLEX); - - /* XXX I'm not sure this makes any sense - * for anything except concatenated plexes, - * and it comes up with the wrong answer for - * RAID-5 plexes, but it's currently needed - * for the calculations. We'll adjust for - * RAID-5 in config_plex */ - if ((sd->sectors + sd->plexoffset) > plex->length) { /* gone beyond the end of the plex */ - plex->length = sd->sectors + sd->plexoffset; /* adjust the length */ - - if ((plex->volno >= 0) /* we have a volume */ - &&(plex->length > VOL[plex->volno].size)) /* and we're now the longest plex */ - VOL[plex->volno].size = plex->length; /* increase the size of the volume */ - } - /* We need to check that the subdisks don't overlap, - * but we can't do that until a point where we *must* - * know the size of all the subdisks. That's not - * here. But we need to sort them by offset */ - for (i = 0; i < plex->subdisks - 1; i++) { - if (sd->plexoffset < SD[plex->sdnos[i]].plexoffset) { /* it fits before this one */ - /* First move any remaining subdisks by one */ - int j; - - for (j = plex->subdisks - 1; j > i; j--) /* move up one at a time */ - plex->sdnos[j] = plex->sdnos[j - 1]; - plex->sdnos[i] = sdno; - return i; - } - } - - /* The plex doesn't have any subdisk with a larger - * offset. Insert it */ - plex->sdnos[i] = sdno; - return i; -} - -/* Add a subdisk to drive if possible. The pointer to the drive - * must already be stored in the sd structure, but the drive - * doesn't know about the subdisk yet. */ -static void -give_sd_to_drive(int sdno) -{ - BROKEN_GDB; - struct sd *sd; /* pointer to subdisk */ - struct drive *drive; /* and drive */ - int fe; /* index in free list */ - - sd = &SD[sdno]; /* point to sd */ - drive = &DRIVE[sd->driveno]; /* and drive */ - - if (drive->state != drive_up) /* not up */ - throw_rude_remark(EIO, "Drive %s is not accessible", drive->label.name); - else if (sd->sectors > drive->sectors_available) { /* too big, */ - sd->driveoffset = -1; /* don't be confusing */ - throw_rude_remark(ENOSPC, "No space for %s on %s", sd->name, drive->label.name); - } - drive->subdisks_used++; /* one more subdisk */ - - /* no offset specified, find one */ - if (sd->driveoffset < 0) { - for (fe = 0; fe < drive->freelist_entries; fe++) { - if (drive->freelist[fe].sectors >= sd->sectors) { /* it'll fit here */ - sd->driveoffset = drive->freelist[fe].offset; - if (sd->sectors == drive->freelist[fe].sectors) { /* used up the entire entry */ - if (fe < (drive->freelist_entries - 1)) /* not the last one, */ - bcopy(&drive->freelist[fe + 1], - &drive->freelist[fe], - (drive->freelist_entries - fe) * sizeof(struct drive_freelist)); - drive->freelist_entries--; /* one less entry */ - } else { - drive->freelist[fe].sectors -= sd->sectors; /* this much less space */ - drive->freelist[fe].offset += sd->sectors; /* this much further on */ - } - drive->sectors_available -= sd->sectors; /* and note how much less space we have */ - break; - } - } - if (fe == drive->freelist_entries) - /* Didn't find anything. Although the drive has - * enough space, it's too fragmented */ - { - sd->driveoffset = -1; /* don't be confusing */ - throw_rude_remark(ENOSPC, "No space for %s on %s", sd->name, drive->label.name); - } - } else { /* specific offset */ - /* For a specific offset to work, the space must be - * entirely in a single freelist entry. Look for it. */ - u_int64_t sdend = sd->driveoffset + sd->sectors; /* end of our subdisk */ - for (fe = 0; fe < drive->freelist_entries; fe++) { - u_int64_t dend = drive->freelist[fe].offset + drive->freelist[fe].sectors; /* end of entry */ - if (dend >= sdend) { /* fits before here */ - if (drive->freelist[fe].offset > sd->driveoffset) /* starts after the beginning of sd area */ - throw_rude_remark(ENOSPC, - "No space for subdisk %s on drive %s at offset %qd\n", - sd->name, - drive->label.name); - - /* We've found the space, and we can allocate it. - * We don't need to say that to the subdisk, which - * already knows about it. We need to tell it to - * the free list, though. We have four possibilities: - * - * 1. The subdisk exactly eats up the entry. That's the - * same as above. - * 2. The subdisk starts at the beginning and leaves space - * at the end. - * 3. The subdisk starts after the beginning and leaves - * space at the end as well: we end up with another - * fragment. - * 4. The subdisk leaves space at the beginning and finishes - * at the end. - */ - drive->sectors_available -= sd->sectors; /* note how much less space we have */ - if (sd->driveoffset == drive->freelist[fe].offset) { /* 1 or 2 */ - if (sd->sectors == drive->freelist[fe].sectors) { /* 1: used up the entire entry */ - if (fe < (drive->freelist_entries - 1)) /* not the last one, */ - bcopy(&drive->freelist[fe + 1], - &drive->freelist[fe], - (drive->freelist_entries - fe) * sizeof(struct drive_freelist)); - drive->freelist_entries--; /* one less entry */ - } else { /* 2: space at the end */ - drive->freelist[fe].sectors -= sd->sectors; /* this much less space */ - drive->freelist[fe].offset += sd->sectors; /* this much further on */ - } - } else { /* 3 or 4 */ - drive->freelist[fe].sectors = sd->driveoffset - drive->freelist[fe].offset; - if (dend > sdend) { /* 3: space at the end as well */ - if (fe < (drive->freelist_entries - 1)) /* not the last one */ - bcopy(&drive->freelist[fe], /* move the rest down */ - &drive->freelist[fe + 1], - (drive->freelist_entries - fe) * sizeof(struct drive_freelist)); - drive->freelist_entries++; /* one less entry */ - drive->freelist[fe + 1].offset = sdend; /* second entry starts after sd */ - drive->freelist[fe + 1].sectors = dend - sdend; /* and is this long */ - } - } - break; - } - } - } - drive->opencount++; /* one more subdisk attached */ -} - -/* Get an empty drive entry from the drive table */ -int -get_empty_drive(void) -{ - BROKEN_GDB; - int driveno; - struct drive *drive; - - /* first see if we have one which has been deallocated */ - for (driveno = 0; driveno < vinum_conf.drives_used; driveno++) { - if (DRIVE[driveno].state == drive_unallocated) /* bingo */ - break; - } - - if (driveno >= vinum_conf.drives_used) - /* Couldn't find a deallocated drive. Allocate a new one */ - { - vinum_conf.drives_used++; - if (vinum_conf.drives_used > vinum_conf.drives_allocated) /* we've used all our allocation */ - EXPAND(DRIVE, struct drive, vinum_conf.drives_allocated, INITIAL_DRIVES); - } - /* got a drive entry. Make it pretty */ - drive = &DRIVE[driveno]; - bzero(drive, sizeof(struct drive)); - drive->driveno = driveno; /* put number in structure */ - return driveno; /* return the index */ -} - -/* Find the named drive in vinum_conf.drive, return a pointer - * return the index in vinum_conf.drive. - * Don't mark the drive as allocated (XXX SMP) - * If create != 0, create an entry if it doesn't exist - */ -/* XXX check if we have it open from attach */ -int -find_drive(const char *name, int create) -{ - BROKEN_GDB; - int driveno; - struct drive *drive; - - if (name != NULL) { - for (driveno = 0; driveno < vinum_conf.drives_used; driveno++) { - drive = &DRIVE[driveno]; /* point to drive */ - if ((drive->label.name[0] != '\0') /* it has a name */ - &&(strcmp(drive->label.name, name) == 0)) /* and it's this one: found */ - return driveno; - } - } - /* the drive isn't in the list. Add it if he wants */ - if (create == 0) /* don't want to create */ - return -1; /* give up */ - - driveno = get_empty_drive(); - drive = &DRIVE[driveno]; - if (name != NULL) - bcopy(name, /* put in its name */ - drive->label.name, - min(sizeof(drive->label.name), - strlen(name))); - drive->state = drive_uninit; /* in use, nothing worthwhile there */ - return driveno; /* return the index */ -} - -/* Find a drive given its device name. - * devname must be valid. - * Otherwise the same as find_drive above */ -int -find_drive_by_dev(const char *devname, int create) -{ - BROKEN_GDB; - int driveno; - struct drive *drive; - - for (driveno = 0; driveno < vinum_conf.drives_used; driveno++) { - drive = &DRIVE[driveno]; /* point to drive */ - if ((drive->label.name[0] != '\0') /* it has a name */ - &&(strcmp(drive->label.name, devname) == 0)) /* and it's this one: found */ - return driveno; - } - - /* the drive isn't in the list. Add it if he wants */ - if (create == 0) /* don't want to create */ - return -1; /* give up */ - - driveno = get_empty_drive(); - drive = &DRIVE[driveno]; - bcopy(devname, /* put in its name */ - drive->devicename, - min(sizeof(drive->devicename), - strlen(devname))); - drive->state = drive_uninit; /* in use, nothing worthwhile there */ - return driveno; /* return the index */ -} - -/* Find an empty subdisk in the subdisk table */ -int -get_empty_sd(void) -{ - BROKEN_GDB; - int sdno; - struct sd *sd; - - /* first see if we have one which has been deallocated */ - for (sdno = 0; sdno < vinum_conf.subdisks_used; sdno++) { - if (SD[sdno].state == sd_unallocated) /* bingo */ - break; - } - - if (sdno >= vinum_conf.subdisks_used) { /* No unused sd found. Allocate a new one */ - vinum_conf.subdisks_used++; - if (vinum_conf.subdisks_used > vinum_conf.subdisks_allocated) - EXPAND(SD, struct sd, vinum_conf.subdisks_allocated, INITIAL_SUBDISKS); - } - /* initialize some things */ - sd = &SD[sdno]; /* point to it */ - bzero(sd, sizeof(struct sd)); /* initialize */ - sd->plexno = -1; /* no plex */ - sd->driveno = -1; /* and no drive */ - sd->plexoffset = -1; /* and no offsets */ - sd->driveoffset = -1; - return sdno; /* return the index */ -} - -/* return a drive to the free pool */ -void -free_drive(struct drive *drive) -{ - BROKEN_GDB; - if (drive->vp != NULL) /* device open */ - vn_close(drive->vp, FREAD | FWRITE, FSCRED, drive->p); - bzero(drive, sizeof(struct drive)); /* this also sets drive_unallocated */ - vinum_conf.drives_used--; /* one less drive */ -} - -/* Find the named subdisk in vinum_conf.sd. - - * If create != 0, create an entry if it doesn't exist - * - * Return index in vinum_conf.sd - */ -int -find_subdisk(const char *name, int create) -{ - BROKEN_GDB; - int sdno; - struct sd *sd; - - for (sdno = 0; sdno < vinum_conf.subdisks_allocated; sdno++) { - if (strcmp(SD[sdno].name, name) == 0) /* found it */ - return sdno; - } - - /* the subdisk isn't in the list. Add it if he wants */ - if (create == 0) /* don't want to create */ - return -1; /* give up */ - - /* Allocate one and insert the name */ - sdno = get_empty_sd(); - sd = &SD[sdno]; - bcopy(name, sd->name, min(sizeof(sd->name), strlen(name))); /* put in its name */ - return sdno; /* return the pointer */ -} - -/* Free an allocated sd entry - * This performs memory management only. remove() - * is responsible for checking relationships. - */ -void -free_sd(int sdno) -{ - BROKEN_GDB; - struct sd *sd; - struct drive *drive; - int fe; /* free list entry */ - u_int64_t sdend; /* end of our subdisk */ - u_int64_t dend; /* end of our freelist entry */ - - sd = &SD[sdno]; - if ((sd->driveno >= 0) /* we have a drive, */ - &&(sd->sectors > 0)) { /* and some space on it */ - drive = &DRIVE[sd->driveno]; - sdend = sd->driveoffset + sd->sectors; /* end of our subdisk */ - - /* Look for where to return the sd address space */ - for (fe = 0; - (fe < drive->freelist_entries) && (drive->freelist[fe].offset < sd->driveoffset); - fe++); - /* Now we are pointing to the last entry, the first - * with a higher offset than the subdisk, or both. */ - if ((fe > 1) /* not the first entry */ - &&((fe == drive->freelist_entries) /* gone past the end */ - ||(drive->freelist[fe].offset > sd->driveoffset))) /* or past the block were looking for */ - fe--; /* point to the block before */ - dend = drive->freelist[fe].offset + drive->freelist[fe].sectors; /* end of the entry */ - - /* At this point, we are pointing to the correct - * place in the free list. A number of possibilities - * exist: - * - * 1. The block to be freed immediately follows - * the block to which we are pointing. Just - * enlarge it. - * 2. The block to be freed starts at the end of - * the current block and ends at the beginning - * of the following block. Merge the three - * areas into a single block. - * 3. The block to be freed starts after the end - * of the block and ends before the start of - * the following block. Create a new free block. - * 4. The block to be freed starts after the end - * of the block, but ends at the start of the - * following block. Enlarge the following block - * downwards. - * - */ - if (sd->driveoffset == dend) { /* it starts after the end of this block */ - if ((fe < drive->freelist_entries - 1) /* we're not the last block in the free list */ - &&(sdend == drive->freelist[fe + 1].offset)) { /* and the subdisk ends at the start of the - * next block */ - drive->freelist[fe].sectors = drive->freelist[fe + 1].sectors; /* 2: merge all three blocks */ - if (fe < drive->freelist_entries - 2) /* still more blocks after next */ - bcopy(&drive->freelist[fe + 2], /* move down one */ - &drive->freelist[fe + 1], - (drive->freelist_entries - 2 - fe) * sizeof(struct drive_freelist)); - drive->freelist_entries--; /* one less entry in the free list */ - } else /* 1: just enlarge this block */ - drive->freelist[fe].sectors += sd->sectors; - } else { - if (sd->driveoffset > dend) /* it starts after this block */ - fe++; /* so look at the next block */ - if ((fe < drive->freelist_entries) /* we're not the last block in the free list */ - &&(sdend == drive->freelist[fe].offset)) { /* and the subdisk ends at the start of - * this block: case 4 */ - drive->freelist[fe].offset = sd->driveoffset; /* it starts where the sd was */ - drive->freelist[fe].sectors += sd->sectors; /* and it's this much bigger */ - } else { /* case 3: non-contiguous */ - if (fe < drive->freelist_entries) /* not after the last block, */ - bcopy(&drive->freelist[fe], /* move the rest up one entry */ - &drive->freelist[fe + 1], - (drive->freelist_entries - fe) * sizeof(struct drive_freelist)); - drive->freelist_entries++; /* one less entry */ - drive->freelist[fe].offset = sd->driveoffset; /* this entry represents the sd */ - drive->freelist[fe].sectors = sd->sectors; - } - } - drive->opencount--; /* one less subdisk attached */ - } - bzero(sd, sizeof(struct sd)); /* and clear it out */ - sd->state = sd_unallocated; - vinum_conf.subdisks_used--; /* one less sd */ -} - -/* Find an empty plex in the plex table */ -int -get_empty_plex(void) -{ - BROKEN_GDB; - int plexno; - struct plex *plex; /* if we allocate one */ - - /* first see if we have one which has been deallocated */ - for (plexno = 0; plexno < vinum_conf.plexes_used; plexno++) { - if (PLEX[plexno].state == plex_unallocated) /* bingo */ - break; /* and get out of here */ - } - - if (plexno >= vinum_conf.plexes_used) { - /* Couldn't find a deallocated plex. Allocate a new one */ - vinum_conf.plexes_used++; - if (vinum_conf.plexes_used > vinum_conf.plexes_allocated) - EXPAND(PLEX, struct plex, vinum_conf.plexes_allocated, INITIAL_PLEXES); - } - /* Found a plex. Give it an sd structure */ - plex = &PLEX[plexno]; /* this one is ours */ - bzero(plex, sizeof(struct plex)); /* polish it up */ - plex->sdnos = (int *) Malloc(sizeof(int) * INITIAL_SUBDISKS_IN_PLEX); /* allocate sd table */ - CHECKALLOC(plex->sdnos, "vinum: Can't allocate plex subdisk table"); - bzero(plex->sdnos, (sizeof(int) * INITIAL_SUBDISKS_IN_PLEX)); /* do we need this? */ - plex->subdisks = 0; /* no subdisks in use */ - plex->subdisks_allocated = INITIAL_SUBDISKS_IN_PLEX; /* and we have space for this many */ - plex->organization = plex_disorg; /* and it's not organized */ - plex->volno = -1; /* no volume yet */ - return plexno; /* return the index */ -} - -/* Find the named plex in vinum_conf.plex - - * If create != 0, create an entry if it doesn't exist - * return index in vinum_conf.plex - */ -int -find_plex(const char *name, int create) -{ - BROKEN_GDB; - int plexno; - struct plex *plex; - - for (plexno = 0; plexno < vinum_conf.plexes_allocated; plexno++) { - if (strcmp(PLEX[plexno].name, name) == 0) /* found it */ - return plexno; - } - - /* the plex isn't in the list. Add it if he wants */ - if (create == 0) /* don't want to create */ - return -1; /* give up */ - - /* Allocate one and insert the name */ - plexno = get_empty_plex(); - plex = &PLEX[plexno]; /* point to it */ - bcopy(name, plex->name, min(sizeof(plex->name), strlen(name))); /* put in its name */ - return plexno; /* return the pointer */ -} - -/* Free an allocated plex entry - * and its associated memory areas */ -void -free_plex(int plexno) -{ - BROKEN_GDB; - struct plex *plex; - - plex = &PLEX[plexno]; - if (plex->sdnos) - Free(plex->sdnos); - if (plex->lock) - Free(plex->lock); - if (plex->defective_region) - Free(plex->defective_region); - if (plex->unmapped_region) - Free(plex->unmapped_region); - bzero(plex, sizeof(struct plex)); /* and clear it out */ - plex->state = plex_unallocated; - vinum_conf.plexes_used--; /* one less plex */ -} - -/* Find an empty volume in the volume table */ -int -get_empty_volume(void) -{ - BROKEN_GDB; - int volno; - struct volume *vol; - - /* first see if we have one which has been deallocated */ - for (volno = 0; volno < vinum_conf.volumes_used; volno++) { - if (VOL[volno].state == volume_unallocated) /* bingo */ - break; - } - - if (volno >= vinum_conf.volumes_used) - /* Couldn't find a deallocated volume. Allocate a new one */ - { - vinum_conf.volumes_used++; - if (vinum_conf.volumes_used > vinum_conf.volumes_allocated) - EXPAND(VOL, struct volume, vinum_conf.volumes_allocated, INITIAL_VOLUMES); - } - /* Now initialize fields */ - vol = &VOL[volno]; - bzero(vol, sizeof(struct volume)); - vol->preferred_plex = -1; /* default to round robin */ - vol->preferred_plex = ROUND_ROBIN_READPOL; /* round robin */ - - return volno; /* return the index */ -} - -/* Find the named volume in vinum_conf.volume. - - * If create != 0, create an entry if it doesn't exist - * return the index in vinum_conf - */ -int -find_volume(const char *name, int create) -{ - BROKEN_GDB; - int volno; - struct volume *vol; - - for (volno = 0; volno < vinum_conf.volumes_used; volno++) { - if (strcmp(VOL[volno].name, name) == 0) /* found it */ - return volno; - } - - /* the volume isn't in the list. Add it if he wants */ - if (create == 0) /* don't want to create */ - return -1; /* give up */ - - /* Allocate one and insert the name */ - volno = get_empty_volume(); - vol = &VOL[volno]; - bcopy(name, vol->name, min(sizeof(vol->name), strlen(name))); /* put in its name */ - vol->blocksize = DEV_BSIZE; /* block size of this volume */ - return volno; /* return the pointer */ -} - -/* Free an allocated volume entry - * and its associated memory areas */ -void -free_volume(int volno) -{ - BROKEN_GDB; - struct volume *vol; - - vol = &VOL[volno]; - bzero(vol, sizeof(struct volume)); /* and clear it out */ - vol->state = volume_unallocated; - vinum_conf.volumes_used--; /* one less volume */ -} - -/* Handle a drive definition. We store the information in the global variable - * drive, so we don't need to allocate. - * - * If we find an error, print a message and return - */ -void -config_drive(void) -{ - BROKEN_GDB; - enum drive_label_info partition_status; /* info about the partition */ - int parameter; - int driveno; /* index of drive in vinum_conf */ - struct drive *drive; /* and pointer to it */ - - if (tokens < 2) /* not enough tokens */ - throw_rude_remark(EINVAL, "Drive has no name"); - driveno = find_drive(token[1], 1); /* allocate a drive to initialize */ - drive = &DRIVE[driveno]; /* and get a pointer */ - - if (drive->state != drive_uninit) { /* we already know this drive */ - /* XXX Check which definition is more up-to-date. Give - * preference for the definition on its own drive */ - return; /* XXX */ - } - for (parameter = 2; parameter < tokens; parameter++) { /* look at the other tokens */ - switch (get_keyword(token[parameter], &keyword_set)) { - case kw_device: - parameter++; - if (drive->devicename[0] != '\0') { /* we know this drive... */ - if (strcmp(drive->devicename, token[parameter])) /* different name */ - close_drive(drive); /* close it if it's open */ - else /* no change */ - break; - } - bcopy(token[parameter], /* insert device information */ - drive->devicename, - min(sizeof(drive->devicename), - strlen(token[parameter]))); - /* open the device and get the configuration */ - partition_status = read_drive_label(drive); - if (partition_status == DL_CANT_OPEN) { /* not our kind */ - close_drive(drive); - if (drive->lasterror == EFTYPE) /* wrong kind of partition */ - throw_rude_remark(drive->lasterror, - "Drive %s has invalid partition type", - drive->label.name); - else /* I/O error of some kind */ - throw_rude_remark(drive->lasterror, - "Can't initialize drive %s", - drive->label.name); - } else if (partition_status == DL_WRONG_DRIVE) { /* valid drive, not ours */ - close_drive(drive); - throw_rude_remark(drive->lasterror, - "Incorrect drive name %s specified for drive %s", - token[1], - drive->label.name); - } - break; - - case kw_state: - checkkernel(token[++parameter]); /* must be a kernel user */ - drive->state = DriveState(token[parameter]); /* set the state */ - break; - - default: - close_drive(drive); - throw_rude_remark(EINVAL, - "Drive %s, invalid keyword: %s", - token[1], - token[parameter]); - } - } - - if (drive->devicename[0] == '\0') { - drive->state = drive_unallocated; /* deallocate the drive */ - throw_rude_remark(EINVAL, "No device name for %s", drive->label.name); - } -} - -/* Handle a subdisk definition. We store the information in the global variable - * sd, so we don't need to allocate. - * - * If we find an error, print a message and return - */ -void -config_subdisk(void) -{ - BROKEN_GDB; - int parameter; - int sdno; /* index of sd in vinum_conf */ - struct sd *sd; /* and pointer to it */ - u_int64_t size; - int sectors; /* sector offset value */ - int detached = 0; /* set to 1 if this is a detached subdisk */ - int sdindex = -1; /* index in plexes subdisk table */ - int namedsdno; - - sdno = get_empty_sd(); /* allocate an SD to initialize */ - sd = &SD[sdno]; /* and get a pointer */ - for (parameter = 1; parameter < tokens; parameter++) { /* look at the other tokens */ - switch (get_keyword(token[parameter], &keyword_set)) { - case kw_detached: - detached = 1; - break; - - case kw_plexoffset: - size = sizespec(token[++parameter]); - if ((size % DEV_BSIZE) != 0) - throw_rude_remark(EINVAL, "sd %s, bad plex offset alignment: %qd", sd->name, size); - else - sd->plexoffset = size / DEV_BSIZE; - break; - - case kw_driveoffset: - size = sizespec(token[++parameter]); - if ((size % DEV_BSIZE) != 0) - throw_rude_remark(EINVAL, "sd %s, bad drive offset alignment: %qd", sd->name, size); - else - sd->driveoffset = size / DEV_BSIZE; - break; - - case kw_name: - namedsdno = find_subdisk(token[++parameter], 0); /* find an existing sd with this name */ - if (namedsdno >= 0) - throw_rude_remark(EINVAL, "Duplicate subdisk %s", token[parameter]); - bcopy(token[parameter], - sd->name, - min(sizeof(sd->name), strlen(token[parameter]))); - break; - - case kw_len: - size = sizespec(token[++parameter]); - if ((size % DEV_BSIZE) != 0) - throw_rude_remark(EINVAL, "sd %s, length %d not multiple of sector size", sd->name, size); - else - sd->sectors = size / DEV_BSIZE; - break; - - case kw_drive: - sd->driveno = find_drive(token[++parameter], 1); /* insert drive information */ - break; - - case kw_plex: - sd->plexno = find_plex(token[++parameter], 1); /* insert plex information */ - break; - - case kw_state: - checkkernel(token[++parameter]); /* must be a kernel user */ - sd->state = SdState(token[parameter]); /* set the state */ - break; - - default: - throw_rude_remark(EINVAL, "sd %s, invalid keyword: %s", sd->name, token[parameter]); - } - } - - /* Check we have a drive name */ - if (sd->driveno < 0) { /* didn't specify a drive */ - sd->driveno = current_drive; /* set to the current drive */ - if (sd->driveno < 0) /* no current drive? */ - throw_rude_remark(EINVAL, "Subdisk %s is not associated with a drive", sd->name); - } - /* Check for a plex name */ - if ((sd->plexno < 0) /* didn't specify a plex */ - &&(!detached)) /* and didn't say not to, */ - sd->plexno = current_plex; /* set to the current plex */ - - if (sd->plexno >= 0) - sdindex = give_sd_to_plex(sd->plexno, sdno); /* now tell the plex that it has this sd */ - - sd->sdno = sdno; /* point to our entry in the table */ - - /* Does the subdisk have a name? If not, give it one */ - if (sd->name[0] == '\0') { /* no name */ - char sdsuffix[8]; /* form sd name suffix here */ - - /* Do we have a plex name? */ - if (sdindex >= 0) /* we have a plex */ - strcpy(sd->name, PLEX[sd->plexno].name); /* take it from there */ - else /* no way */ - throw_rude_remark(EINVAL, "Unnamed sd is not associated with a plex"); - sprintf(sdsuffix, ".s%d", sdindex); /* form the suffix */ - strcat(sd->name, sdsuffix); /* and add it to the name */ - } - /* do we have complete info for this subdisk? */ - if (sd->sectors == 0) - throw_rude_remark(EINVAL, "sd %s has no length spec", sd->name); - - if (sd->state == sd_unallocated) /* no state decided, */ - sd->state = sd_init; /* at least we're in the game */ - - /* register the subdisk with the drive. This action - * will have the side effect of setting the offset if - * we haven't specified one, and causing an error - * message if it overlaps with another subdisk. */ - give_sd_to_drive(sdno); -} - -/* Handle a plex definition. - * If we find an error, print a message, deallocate the nascent plex, and return - */ -void -config_plex(void) -{ - BROKEN_GDB; - int parameter; - int plexno; /* index of plex in vinum_conf */ - struct plex *plex; /* and pointer to it */ - int pindex = MAXPLEX; /* index in volume's plex list */ - int detached = 0; /* don't give it to a volume */ - int namedplexno; - - current_plex = -1; /* forget the previous plex */ - plexno = get_empty_plex(); /* allocate a plex */ - plex = &PLEX[plexno]; /* and point to it */ - plex->plexno = plexno; /* and back to the config */ - for (parameter = 1; parameter < tokens; parameter++) { /* look at the other tokens */ - switch (get_keyword(token[parameter], &keyword_set)) { - case kw_detached: - detached = 1; - break; - - case kw_name: - namedplexno = find_plex(token[++parameter], 0); /* find an existing plex with this name */ - if (namedplexno >= 0) - throw_rude_remark(EINVAL, "Duplicate plex %s", token[parameter]); - bcopy(token[parameter], /* put in the name */ - plex->name, - min(MAXPLEXNAME, strlen(token[parameter]))); - break; - - case kw_org: /* plex organization */ - switch (get_keyword(token[++parameter], &keyword_set)) { - case kw_concat: - plex->organization = plex_concat; - break; - - case kw_striped: - { - int stripesize = sizespec(token[++parameter]); - - plex->organization = plex_striped; - if (stripesize % DEV_BSIZE != 0) /* not a multiple of block size, */ - throw_rude_remark(EINVAL, "plex %s: stripe size %d not a multiple of sector size", - plex->name, - stripesize); - else - plex->stripesize = stripesize / DEV_BSIZE; - break; - } - - - default: - throw_rude_remark(EINVAL, "Invalid plex organization"); - } - if (((plex->organization == plex_striped) - ) - && (plex->stripesize == 0)) /* didn't specify a valid stripe size */ - throw_rude_remark(EINVAL, "Need a stripe size parameter"); - break; - - case kw_volume: - plex->volno = find_volume(token[++parameter], 1); /* insert a pointer to the volume */ - break; - - case kw_sd: /* add a subdisk */ - { - int sdno; - - sdno = find_subdisk(token[++parameter], 1); /* find a subdisk */ - SD[sdno].plexoffset = sizespec(token[++parameter]); /* get the offset */ - give_sd_to_plex(plexno, sdno); /* and insert it there */ - break; - } - - case kw_state: - checkkernel(token[++parameter]); /* only for kernel use */ - plex->state = PlexState(token[parameter]); /* set the state */ - break; - - default: - throw_rude_remark(EINVAL, "plex %s, invalid keyword: %s", - plex->name, - token[parameter]); - } - } - - if ((plex->volno < 0) /* we don't have a volume */ - &&(!detached)) /* and we wouldn't object */ - plex->volno = current_volume; - - if (plex->volno >= 0) - pindex = give_plex_to_volume(plex->volno, plexno); /* Now tell the volume that it has this plex */ - - /* Does the plex have a name? If not, give it one */ - if (plex->name[0] == '\0') { /* no name */ - char plexsuffix[8]; /* form plex name suffix here */ - /* Do we have a volume name? */ - if (plex->volno >= 0) /* we have a volume */ - strcpy(plex->name, /* take it from there */ - VOL[plex->volno].name); - else /* no way */ - throw_rude_remark(EINVAL, "Unnamed plex is not associated with a volume"); - sprintf(plexsuffix, ".p%d", pindex); /* form the suffix */ - strcat(plex->name, plexsuffix); /* and add it to the name */ - } - /* Note the last plex we configured */ - current_plex = plexno; - if (plex->state == plex_unallocated) /* we haven't changed the state, */ - plex->state = plex_init; /* we're initialized now */ -} - -/* Handle a volume definition. - * If we find an error, print a message, deallocate the nascent volume, and return - */ -void -config_volume(void) -{ - BROKEN_GDB; - int parameter; - int volno; - struct volume *vol; /* collect volume info here */ - int i; - - if (tokens < 2) /* not enough tokens */ - throw_rude_remark(EINVAL, "Volume has no name"); - current_volume = -1; /* forget the previous volume */ - volno = find_volume(token[1], 1); /* allocate a volume to initialize */ - vol = &VOL[volno]; /* and get a pointer */ - - for (parameter = 2; parameter < tokens; parameter++) { /* look at all tokens */ - switch (get_keyword(token[parameter], &keyword_set)) { - case kw_plex: - { - int plexno; /* index of this plex */ - - plexno = find_plex(token[++parameter], 1); /* find a plex */ - if (plexno < 0) /* couldn't */ - break; /* we've already had an error message */ - plexno = my_plex(volno, plexno); /* does it already belong to us? */ - if (plexno > 0) /* yes, shouldn't get it again */ - throw_rude_remark(EINVAL, - "Plex %s already belongs to volume %s", - token[parameter], - vol->name); - else if (++vol->plexes > 8) /* another entry */ - throw_rude_remark(EINVAL, - "Too many plexes for volume %s", - vol->name); - vol->plex[vol->plexes - 1] = plexno; - } - break; - - case kw_readpol: - switch (get_keyword(token[++parameter], &keyword_set)) { /* decide what to do */ - case kw_round: - vol->preferred_plex = ROUND_ROBIN_READPOL; /* default */ - break; - - case kw_prefer: - { - int myplexno; /* index of this plex */ - - myplexno = find_plex(token[++parameter], 1); /* find a plex */ - if (myplexno < 0) /* couldn't */ - break; /* we've already had an error message */ - myplexno = my_plex(volno, myplexno); /* does it already belong to us? */ - if (myplexno > 0) /* yes */ - vol->preferred_plex = myplexno; /* just note the index */ - else if (++vol->plexes > 8) /* another entry */ - throw_rude_remark(EINVAL, "Too many plexes"); - else { /* space for the new plex */ - vol->plex[vol->plexes - 1] = myplexno; /* add it to our list */ - vol->preferred_plex = vol->plexes - 1; /* and note the index */ - } - } - break; - - default: - throw_rude_remark(EINVAL, "Invalid read policy"); - } - - case kw_setupstate: - vol->flags |= VF_CONFIG_SETUPSTATE; /* set the volume up later on */ - break; - - case kw_state: - checkkernel(token[++parameter]); /* must be a kernel user */ - vol->state = VolState(token[parameter]); /* set the state */ - break; - - /* XXX experimental ideas. These are not - * documented, and will not be until I - * decide they're worth keeping */ - case kw_writethrough: /* set writethrough mode */ - vol->flags |= VF_WRITETHROUGH; - break; - - case kw_writeback: /* set writeback mode */ - vol->flags &= ~VF_WRITETHROUGH; - break; - - case kw_raw: - vol->flags |= VF_RAW; /* raw volume (no label) */ - break; - - default: - throw_rude_remark(EINVAL, "volume %s, invalid keyword: %s", - vol->name, - token[parameter]); - } - } - - current_volume = volno; /* note last referred volume */ - vol->devno = VINUMBDEV(volno, 0, 0, VINUM_VOLUME_TYPE); /* also note device number */ - - /* Before we can actually use the volume, we need - * a volume label. We could start to fake one here, - * but it will be a lot easier when we have some - * to copy from the drives, so defer it until we - * set up the configuration. XXX */ - if (vol->state == volume_unallocated) - vol->state = volume_down; /* now ready to bring up at the end */ - - /* Find out how big our volume is */ - for (i = 0; i < vol->plexes; i++) - vol->size = max(vol->size, PLEX[vol->plex[i]].length); -} - -/* Parse a config entry. CARE! This destroys the original contents of the - * config entry, which we don't really need after this. More specifically, it - * places \0 characters at the end of each token. - * - * Return 0 if all is well, otherwise EINVAL */ -int -parse_config(char *cptr, struct keywordset *keyset) -{ - BROKEN_GDB; - int status; - - status = 0; /* until proven otherwise */ - tokens = tokenize(cptr, token); /* chop up into tokens */ - - if (tokens <= 0) /* screwed up or empty line */ - return tokens; /* give up */ - - if (token[0][0] == '#') /* comment line */ - return 0; - - switch (get_keyword(token[0], keyset)) { /* decide what to do */ - case kw_read: /* read config from a specified drive */ - vinum_conf.flags |= VF_KERNELOP | VF_READING_CONFIG; /* kernel operation: reading config */ - status = check_drive(token[1]); /* check the drive info */ - vinum_conf.flags &= ~(VF_KERNELOP | VF_READING_CONFIG); - if (status != 0) { - char *msg = "Can't read configuration from %s"; - if (status == ENODEV) - msg = "No vinum configuration on %s"; - throw_rude_remark(status, msg, token[1]); - } - updateconfig(VF_KERNELOP); /* update from kernel space */ - break; - - case kw_drive: - config_drive(); - break; - - case kw_subdisk: - config_subdisk(); - break; - - case kw_plex: - config_plex(); - break; - - case kw_volume: - config_volume(); - break; - - /* Anything else is invalid in this context */ - default: - throw_rude_remark(EINVAL, /* should we die? */ - "Invalid configuration information: %s", - token[0]); - } - return status; -} - -/* parse a line handed in from userland via ioctl. - * This differs only by the error reporting mechanism: - * we return the error indication in the reply to the - * ioctl, so we need to set a global static pointer in - * this file. This technique works because we have - * ensured that configuration is performed in a single- - * threaded manner */ -int -parse_user_config(char *cptr, struct keywordset *keyset) -{ - BROKEN_GDB; - int status; - - ioctl_reply = (struct _ioctl_reply *) cptr; - status = parse_config(cptr, keyset); - ioctl_reply = NULL; /* don't do this again */ - return status; -} - -/* Remove an object */ -void -remove(struct vinum_ioctl_msg *msg) -{ - struct vinum_ioctl_msg message = *msg; /* make a copy to hand on */ - - ioctl_reply = (struct _ioctl_reply *) msg; /* reinstate the address to reply to */ - ioctl_reply->error = 0; /* no error, */ - ioctl_reply->msg[0] = '\0'; /* no message */ - - switch (message.type) { - case drive_object: - remove_drive_entry(message.index, message.force, message.recurse); - updateconfig(0); - return; - - case sd_object: - remove_sd_entry(message.index, message.force, message.recurse); - updateconfig(0); - return; - - case plex_object: - remove_plex_entry(message.index, message.force, message.recurse); - updateconfig(0); - return; - - case volume_object: - remove_volume_entry(message.index, message.force, message.recurse); - updateconfig(0); - return; - - default: - ioctl_reply->error = EINVAL; - strcpy(ioctl_reply->msg, "Invalid object type"); - } -} - -/* Remove a drive. */ -void -remove_drive_entry(int driveno, int force, int recurse) -{ - struct drive *drive = &DRIVE[driveno]; - - if ((driveno > vinum_conf.drives_used) /* not a valid drive */ - ||(drive->state == drive_unallocated)) { /* or nothing there */ - ioctl_reply->error = EINVAL; - strcpy(ioctl_reply->msg, "No such drive"); - } else if (drive->opencount > 0) { /* we have subdisks */ - if (force) { /* do it at any cost */ - int sdno; - struct vinum_ioctl_msg sdmsg; - - for (sdno = 0; sdno < vinum_conf.subdisks_used; sdno++) { - if ((SD[sdno].state != sd_unallocated) /* subdisk is allocated */ - &&(SD[sdno].driveno == driveno)) { /* and it belongs to this drive */ - sdmsg.type = sd_object; - sdmsg.recurse = 1; - sdmsg.force = force; - remove(&sdmsg); /* remove the subdisk by force */ - } - } - remove_drive(driveno); /* now remove it */ - } else - ioctl_reply->error = EBUSY; /* can't do that */ - } else - remove_drive(driveno); /* just remove it */ -} - -/* remove a subdisk */ -void -remove_sd_entry(int sdno, int force, int recurse) -{ - struct sd *sd = &SD[sdno]; - - if ((sdno > vinum_conf.subdisks_used) /* not a valid sd */ - ||(sd->state == sd_unallocated)) { /* or nothing there */ - ioctl_reply->error = EINVAL; - strcpy(ioctl_reply->msg, "No such subdisk"); - } else if (sd->plexno >= 0) { /* we have a plex */ - if (force) { /* do it at any cost */ - struct plex *plex = &PLEX[sd->plexno]; /* point to our plex */ - int mysdno; - - for (mysdno = 0; /* look for ourselves */ - mysdno < plex->subdisks && &SD[plex->sdnos[mysdno]] != sd; - mysdno++); - if (mysdno == plex->subdisks) /* didn't find it */ - throw_rude_remark(ENOENT, "plex %s does not contain subdisk %s", plex->name, sd->name); - if (mysdno < (plex->subdisks - 1)) /* not the last subdisk */ - bcopy(&plex->sdnos[mysdno + 1], - &plex->sdnos[mysdno], - (plex->subdisks - 1 - mysdno) * sizeof(int)); - plex->subdisks--; - /* removing a subdisk from a striped or - * RAID-5 plex really tears the hell out - * of the structure, and it needs to be - * reinitialized */ - if (plex->organization != plex_concat) /* not concatenated, */ - set_plex_state(plex->plexno, plex_faulty, setstate_force); /* need to reinitialize */ - rebuild_plex_unmappedlist(plex); /* and see what remains */ - free_sd(sdno); - } else - ioctl_reply->error = EBUSY; /* can't do that */ - } else - free_sd(sdno); -} - -/* remove a plex */ -void -remove_plex_entry(int plexno, int force, int recurse) -{ - struct plex *plex = &PLEX[plexno]; - int sdno; - - if ((plexno > vinum_conf.plexes_used) /* not a valid plex */ - ||(plex->state == plex_unallocated)) { /* or nothing there */ - ioctl_reply->error = EINVAL; - strcpy(ioctl_reply->msg, "No such plex"); - } else if (plex->pid) { /* we're open */ - ioctl_reply->error = EBUSY; /* no getting around that */ - return; - } - if (plex->subdisks) { - if (force) { /* do it anyway */ - if (recurse) { /* remove all below */ - for (sdno = 0; sdno < plex->subdisks; sdno++) - free_sd(plex->sdnos[sdno]); /* free all subdisks */ - } else { /* just tear them out */ - for (sdno = 0; sdno < plex->subdisks; sdno++) - SD[plex->sdnos[sdno]].plexno = -1; /* no plex any more */ - } - } else { /* can't do it without force */ - ioctl_reply->error = EBUSY; /* can't do that */ - return; - } - } - if (plex->volno >= 0) { /* we are part of a volume */ - /* XXX This should be more intelligent. We should - * be able to remove a plex as long as the volume - * does not lose any data, which is normally the - * case when it has more than one plex. To do it - * right we must compare the completeness of the - * mapping of all the plexes in the volume */ - if (force) { /* do it at any cost */ - struct volume *vol = &VOL[plex->volno]; - int myplexno; - - for (myplexno = 0; myplexno < vol->plexes; myplexno++) - if (vol->plex[myplexno] == plexno) /* found it */ - break; - if (myplexno == vol->plexes) /* didn't find it. Huh? */ - throw_rude_remark(ENOENT, "volume %s does not contain plex %s", vol->name, plex->name); - if (myplexno < (vol->plexes - 1)) /* not the last plex in the list */ - bcopy(&vol->plex[myplexno + 1], &vol->plex[myplexno], vol->plexes - 1 - myplexno); - vol->plexes--; - } else { - ioctl_reply->error = EBUSY; /* can't do that */ - return; - } - } - free_plex(plexno); -} - -/* remove a volume */ -void -remove_volume_entry(int volno, int force, int recurse) -{ - struct volume *vol = &VOL[volno]; - int plexno; - - if ((volno > vinum_conf.volumes_used) /* not a valid volume */ - ||(vol->state == volume_unallocated)) { /* or nothing there */ - ioctl_reply->error = EINVAL; - strcpy(ioctl_reply->msg, "No such volume"); - } else if (vol->opencount) /* we're open */ - ioctl_reply->error = EBUSY; /* no getting around that */ - else if (vol->plexes) { - if (recurse && force) { /* remove all below */ - struct vinum_ioctl_msg plexmsg; - - plexmsg.type = plex_object; - plexmsg.recurse = 1; - plexmsg.force = force; - for (plexno = 0; plexno < vol->plexes; plexno++) { - plexmsg.index = vol->plex[plexno]; /* plex number */ - remove(&plexmsg); - } - free_volume(volno); - } else - ioctl_reply->error = EBUSY; /* can't do that */ - } else - free_volume(volno); -} - -void -update_sd_config(int sdno, int kernelstate) -{ - if (!kernelstate) - set_sd_state(sdno, sd_up, setstate_configuring | setstate_norecurse); -} - -void -update_plex_config(int plexno, int kernelstate) -{ - int error = 0; - int size; - int sdno; - struct plex *plex = &PLEX[plexno]; - enum plexstate state = plex_up; /* state we want the plex in */ - - /* XXX Insert checks here for sparse plexes and volumes */ - - /* Check that our subdisks make sense. For - * striped and RAID5 plexes, we need at least - * two subdisks, and they must all be the same - * size */ - if (((plex->organization == plex_striped) - ) - && (plex->subdisks < 2)) { - error = 1; - printf("vinum: plex %s does not have at least 2 subdisks\n", plex->name); - if (!kernelstate) - set_plex_state(plexno, plex_down, setstate_force | setstate_configuring | setstate_norecurse); - } - size = 0; - for (sdno = 0; sdno < plex->subdisks; sdno++) { - if (((plex->organization == plex_striped) - ) - && (sdno > 0) - && (SD[plex->sdnos[sdno]].sectors != SD[plex->sdnos[sdno - 1]].sectors)) { - error = 1; - printf("vinum: plex %s must have equal sized subdisks\n", plex->name); - set_plex_state(plexno, plex_down, setstate_force | setstate_configuring | setstate_norecurse); - } - size += SD[plex->sdnos[sdno]].sectors; - } - - if (plex->subdisks) { /* plex has subdisks, calculate size */ - rebuild_plex_unmappedlist(plex); /* rebuild the unmapped list first */ - - plex->length = size; - } else { /* no subdisks, */ - plex->length = 0; /* no size */ - state = plex_down; /* take it down */ - } - if (!(kernelstate || error)) - set_plex_state(plexno, state, setstate_none | setstate_configuring | setstate_norecurse); -} - -void -update_volume_config(int volno, int kernelstate) -{ - struct volume *vol = &VOL[volno]; - struct plex *plex; - int plexno; - - if (vol->state != volume_unallocated) - /* Recalculate the size of the volume */ - { - vol->size = 0; - for (plexno = 0; plexno < vol->plexes; plexno++) { - plex = &PLEX[vol->plex[plexno]]; - vol->size = max(plex->length, vol->size); /* maximum size */ - plex->volplexno = plexno; /* note it in the plex */ - } - } - if (!kernelstate) /* try to bring it up */ - set_volume_state(volno, volume_up, setstate_configuring | setstate_norecurse); -} - -/* Update the global configuration. - * kernelstate is != 0 if we're reading in a config - * from disk. In this case, we don't try to - * bring the devices up, though we will bring - * them down if there's some error which got - * missed when writing to disk. - */ -void -updateconfig(int kernelstate) -{ - BROKEN_GDB; - int sdno; - int plexno; - int volno; - struct volume *vol; - struct plex *plex; - - for (sdno = 0; sdno < vinum_conf.subdisks_used; sdno++) - update_sd_config(sdno, kernelstate); - - for (plexno = 0; plexno < vinum_conf.plexes_used; plexno++) - update_plex_config(plexno, kernelstate); - - for (volno = 0; volno < vinum_conf.volumes_used; volno++) - update_volume_config(volno, kernelstate); - save_config(); -} - -/* Start manual changes to the configuration and lock out - * others who may wish to do so. - * XXX why do we need this and lock_config too? */ -int -start_config(void) -{ - int error; - - while ((vinum_conf.flags & VF_CONFIGURING) != 0) { - vinum_conf.flags |= VF_WILL_CONFIGURE; - if ((error = tsleep(&vinum_conf, PRIBIO | PCATCH, "vincfg", 0)) != 0) - return error; - } - /* We need two flags here: VF_CONFIGURING - * tells other processes to hold off (this - * function), and VF_CONFIG_INCOMPLETE - * tells the state change routines not to - * propagate incrememntal state changes */ - vinum_conf.flags |= VF_CONFIGURING | VF_CONFIG_INCOMPLETE; - current_drive = -1; /* reset the defaults */ - current_plex = -1; /* and the same for the last plex */ - current_volume = -1; /* and the last volme */ - return 0; -} - -/* Update the config if update is 1, and unlock - * it. We won't update the configuration if we - * are called in a recursive loop via throw_rude_remark. - */ -void -finish_config(int update) -{ - vinum_conf.flags &= ~VF_CONFIG_INCOMPLETE; /* we've finished our config */ - if (update) - updateconfig(0); /* so update things */ - else - updateconfig(1); /* do some updates only */ - vinum_conf.flags &= ~VF_CONFIGURING; /* and now other people can take a turn */ - if ((vinum_conf.flags & VF_WILL_CONFIGURE) != 0) { - vinum_conf.flags &= ~VF_WILL_CONFIGURE; - wakeup(&vinum_conf); - } -} |
