/*- * Copyright (c) 1997, 1998, 1999 * Nan Yang Computer Services Limited. All rights reserved. * * Parts copyright (c) 1997, 1998 Cybernet Corporation, NetMAX project. * * Written by Greg Lehey * * 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: vinumstate.c,v 2.18 2000/05/10 07:30:50 grog Exp grog $ * $FreeBSD: src/sys/dev/vinum/vinumstate.c,v 1.28.2.2 2000/06/08 02:00:23 grog Exp $ */ #include "vinumhdr.h" #include "request.h" /* Update drive state */ /* Return 1 if the state changes, otherwise 0 */ int set_drive_state(int driveno, enum drivestate newstate, enum setstateflags flags) { union daemoninfo di; struct drive *drive = &DRIVE[driveno]; int oldstate = drive->state; int sdno; if (drive->state == drive_unallocated) /* no drive to do anything with, */ return 0; if (newstate == oldstate) /* don't change it if it's not different */ return 1; /* all OK */ if ((newstate == drive_down) /* the drive's going down */ &&(!(flags & setstate_force)) && (drive->opencount != 0)) /* we can't do it */ return 0; /* don't do it */ drive->state = newstate; /* set the state */ if (drive->label.name[0] != '\0') /* we have a name, */ log(LOG_INFO, "vinum: drive %s is %s\n", drive->label.name, drive_state(drive->state)); if (drive->state != oldstate) { /* state has changed */ for (sdno = 0; sdno < vinum_conf.subdisks_allocated; sdno++) { /* find this drive's subdisks */ if ((SD[sdno].state >= sd_referenced) && (SD[sdno].driveno == driveno)) /* belongs to this drive */ update_sd_state(sdno); /* update the state */ } } if (newstate == drive_up) { /* want to bring it up */ if ((drive->flags & VF_OPEN) == 0) /* should be open, but we're not */ init_drive(drive, 1); /* which changes the state again */ } else { /* taking it down or worse */ di.drive = drive; queue_daemon_request(daemonrq_closedrive, di); /* get the daemon to close it */ } if ((flags & setstate_configuring) == 0) /* configuring? */ save_config(); /* no: save the updated configuration now */ return 1; } /* * Try to set the subdisk state. Return 1 if state changed to * what we wanted, -1 if it changed to something else, and 0 * if no change. * * This routine is called both from the user (up, down states only) * and internally. * * The setstate_force bit in the flags enables the state change even * if it could be dangerous to data consistency. It shouldn't allow * nonsense. */ int set_sd_state(int sdno, enum sdstate newstate, enum setstateflags flags) { struct sd *sd = &SD[sdno]; struct plex *plex; struct volume *vol; int oldstate = sd->state; int status = 1; /* status to return */ if (newstate == oldstate) /* already there, */ return 1; else if (sd->state == sd_unallocated) /* no subdisk to do anything with, */ return 0; /* can't do it */ if (sd->driveoffset < 0) { /* not allocated space */ sd->state = sd_down; if (newstate != sd_down) { if (sd->plexno >= 0) sdstatemap(&PLEX[sd->plexno]); /* count up subdisks */ return -1; } } else { /* space allocated */ switch (newstate) { case sd_down: /* take it down? */ /* * If we're attached to a plex, and we're * not reborn, we won't go down without * use of force. */ if (!(flags & setstate_force) && (sd->plexno >= 0) && (sd->state != sd_reborn)) return 0; /* don't do it */ break; case sd_initialized: if ((sd->state == sd_initializing) /* we were initializing */ ||(flags & setstate_force)) /* or we forced it */ break; return 0; /* can't do it otherwise */ case sd_up: if (DRIVE[sd->driveno].state != drive_up) /* can't bring the sd up if the drive isn't, */ return 0; /* not even by force */ if (flags & setstate_force) /* forcing it, */ break; /* just do it, and damn the consequences */ switch (sd->state) { /* * Perform the necessary tests. To allow * the state transition, just break out of * the switch. */ case sd_crashed: case sd_reborn: case sd_down: /* been down, no data lost */ /* * If we're associated with a plex, and * the plex isn't up, or we're the only * subdisk in the plex, we can do it. */ if ((sd->plexno >= 0) && (((PLEX[sd->plexno].state < plex_firstup) || (PLEX[sd->plexno].subdisks > 1)))) break; /* do it */ if (oldstate != sd_reborn) { sd->state = sd_reborn; /* here it is again */ log(LOG_INFO, "vinum: %s is %s, not %s\n", sd->name, sd_state(sd->state), sd_state(newstate)); } status = -1; break; case sd_init: /* brand new */ if (flags & setstate_configuring) /* we're doing this while configuring */ break; /* otherwise it's like being empty */ /* FALLTHROUGH */ case sd_empty: case sd_initialized: /* * If we're not part of a plex, or the * plex is not part of a volume with other * plexes which are up, we can come up * without being inconsistent. * * If we're part of a parity plex, we'll * come up if the caller uses force. This * is the way we bring them up after * initialization. */ if ((sd->plexno < 0) || ((vpstate(&PLEX[sd->plexno]) & volplex_otherup) == 0) || (isparity((&PLEX[sd->plexno])) && (flags & setstate_force))) break; /* Otherwise it's just out of date */ /* FALLTHROUGH */ case sd_stale: /* out of date info, need reviving */ case sd_obsolete: /* * 1. If the subdisk is not part of a * plex, bring it up, don't revive. * * 2. If the subdisk is part of a * one-plex volume or an unattached * plex, and it's not RAID-4 or * RAID-5, we *can't revive*. The * subdisk doesn't change its state. * * 3. If the subdisk is part of a * one-plex volume or an unattached * plex, and it's RAID-4 or RAID-5, * but more than one subdisk is down, * we *still can't revive*. The * subdisk doesn't change its state. * * 4. If the subdisk is part of a * multi-plex volume, we'll change to * reviving and let the revive * routines find out whether it will * work or not. If they don't, the * revive stops with an error message, * but the state doesn't change * (FWIW). */ if (sd->plexno < 0) /* no plex associated, */ break; /* bring it up */ plex = &PLEX[sd->plexno]; if (plex->volno >= 0) /* have a volume */ vol = &VOL[plex->volno]; else vol = NULL; /* * We can't do it if: * * 1: we don't have a volume * 2: we're the only plex in the volume * 3: we're a RAID-4 or RAID-5 plex, and * more than one subdisk is down. */ if (((vol == NULL) || (vol->plexes == 1)) && ((!isparity(plex)) || (plex->sddowncount > 1))) { if (sd->state == sd_initializing) /* it's finished initializing */ sd->state = sd_initialized; else return 0; /* can't do it */ } else { sd->state = sd_reviving; /* put in reviving state */ sd->revived = 0; /* nothing done yet */ status = EAGAIN; /* need to repeat */ } break; case sd_reviving: if (flags & setstate_force) /* insist, */ break; return EAGAIN; /* no, try again */ default: /* can't do it */ /* * There's no way to bring subdisks up directly from * other states. First they need to be initialized * or revived. */ return 0; } break; default: /* other ones, only internal with force */ if ((flags & setstate_force) == 0) /* no force? What's this? */ return 0; /* don't do it */ } } if (status == 1) { /* we can do it, */ sd->state = newstate; if (flags & setstate_force) log(LOG_INFO, "vinum: %s is %s by force\n", sd->name, sd_state(sd->state)); else log(LOG_INFO, "vinum: %s is %s\n", sd->name, sd_state(sd->state)); } else /* we don't get here with status 0 */ log(LOG_INFO, "vinum: %s is %s, not %s\n", sd->name, sd_state(sd->state), sd_state(newstate)); if (sd->plexno >= 0) /* we belong to a plex */ update_plex_state(sd->plexno); /* update plex state */ if ((flags & setstate_configuring) == 0) /* save config now */ save_config(); return status; } /* * Set the state of a plex dependent on its subdisks. * This time round, we'll let plex state just reflect * aggregate subdisk state, so this becomes an order of * magnitude less complicated. In particular, ignore * the requested state. */ int set_plex_state(int plexno, enum plexstate state, enum setstateflags flags) { struct plex *plex; /* point to our plex */ enum plexstate oldstate; enum volplexstate vps; /* how do we compare with the other plexes? */ plex = &PLEX[plexno]; /* point to our plex */ oldstate = plex->state; /* If the plex isn't allocated, we can't do it. */ if (plex->state == plex_unallocated) return 0; /* * If it's already in the the state we want, * and it's not up, just return. If it's up, * we still need to do some housekeeping. */ if ((state == oldstate) && (state != plex_up)) return 1; vps = vpstate(plex); /* how do we compare with the other plexes? */ switch (state) { /* * We can't bring the plex up, even by force, * unless it's ready. update_plex_state * checks that. */ case plex_up: /* bring the plex up */ update_plex_state(plex->plexno); /* it'll come up if it can */ break; case plex_down: /* want to take it down */ /* * If we're the only one, or the only one * which is up, we need force to do it. */ if (((vps == volplex_onlyus) || (vps == volplex_onlyusup)) && (!(flags & setstate_force))) return 0; /* can't do it */ plex->state = state; /* do it */ invalidate_subdisks(plex, sd_down); /* and down all up subdisks */ break; /* * This is only requested internally. * Trust ourselves */ case plex_faulty: plex->state = state; /* do it */ invalidate_subdisks(plex, sd_crashed); /* and crash all up subdisks */ break; case plex_initializing: /* XXX consider what safeguards we need here */ if ((flags & setstate_force) == 0) return 0; plex->state = state; /* do it */ break; /* What's this? */ default: return 0; } if (plex->state != oldstate) /* we've changed, */ log(LOG_INFO, /* tell them about it */ "vinum: %s is %s\n", plex->name, plex_state(plex->state)); /* * Now see what we have left, and whether * we're taking the volume down */ if (plex->volno >= 0) /* we have a volume */ update_volume_state(plex->volno); /* update its state */ if ((flags & setstate_configuring) == 0) /* save config now */ save_config(); /* yes: save the updated configuration */ return 1; } /* Update the state of a plex dependent on its plexes. */ int set_volume_state(int volno, enum volumestate state, enum setstateflags flags) { struct volume *vol = &VOL[volno]; /* point to our volume */ if (vol->state == volume_unallocated) /* no volume to do anything with, */ return 0; if (vol->state == state) /* we're there already */ return 1; if (state == volume_up) /* want to come up */ update_volume_state(volno); else if (state == volume_down) { /* want to go down */ if (((vol->flags & VF_OPEN) == 0) /* not open */ ||((flags & setstate_force) != 0)) { /* or we're forcing */ vol->state = volume_down; log(LOG_INFO, "vinum: volume %s is %s\n", vol->name, volume_state(vol->state)); if ((flags & setstate_configuring) == 0) /* save config now */ save_config(); /* yes: save the updated configuration */ return 1; } } return 0; /* no change */ } /* Set the state of a subdisk based on its environment */ void update_sd_state(int sdno) { struct sd *sd; struct drive *drive; enum sdstate oldstate; sd = &SD[sdno]; oldstate = sd->state; drive = &DRIVE[sd->driveno]; if (drive->state == drive_up) { switch (sd->state) { case sd_down: case sd_crashed: sd->state = sd_reborn; /* back up again with no loss */ break; default: break; } } else { /* down or worse */ switch (sd->state) { case sd_up: case sd_reborn: case sd_reviving: case sd_empty: sd->state = sd_crashed; /* lost our drive */ break; default: break; } } if (sd->state != oldstate) /* state has changed, */ log(LOG_INFO, /* say so */ "vinum: %s is %s\n", sd->name, sd_state(sd->state)); if (sd->plexno >= 0) /* we're part of a plex, */ update_plex_state(sd->plexno); /* update its state */ } /* * Force a plex and all its subdisks * into an 'up' state. This is a helper * for update_plex_state. */ void forceup(int plexno) { struct plex *plex; int sdno; plex = &PLEX[plexno]; /* point to the plex */ plex->state = plex_up; /* and bring it up */ /* change the subdisks to up state */ for (sdno = 0; sdno < plex->subdisks; sdno++) { SD[plex->sdnos[sdno]].state = sd_up; log(LOG_INFO, /* tell them about it */ "vinum: %s is up\n", SD[plex->sdnos[sdno]].name); } } /* Set the state of a plex based on its environment */ void update_plex_state(int plexno) { struct plex *plex; /* point to our plex */ enum plexstate oldstate; enum sdstates statemap; /* get a map of the subdisk states */ enum volplexstate vps; /* how do we compare with the other plexes? */ plex = &PLEX[plexno]; /* point to our plex */ oldstate = plex->state; statemap = sdstatemap(plex); /* get a map of the subdisk states */ vps = vpstate(plex); /* how do we compare with the other plexes? */ if (statemap & sd_initstate) /* something initializing? */ plex->state = plex_initializing; /* yup, that makes the plex the same */ else if (statemap == sd_upstate) /* * All the subdisks are up. This also means that * they are consistent, so we can just bring * the plex up */ plex->state = plex_up; else if (isparity(plex) /* RAID-4 or RAID-5 plex */ &&(plex->sddowncount == 1)) /* and exactly one subdisk down */ plex->state = plex_degraded; /* limping a bit */ else if (((statemap & ~sd_downstate) == sd_emptystate) /* all subdisks empty */ ||((statemap & ~sd_downstate) == (statemap & ~sd_downstate & (sd_initializedstate | sd_upstate)))) { if ((vps & volplex_otherup) == 0) { /* no other plex is up */ struct volume *vol = &VOL[plex->volno]; /* possible volume to which it points */ /* * If we're a striped or concat plex * associated with a volume, none of whose * plexes are up, and we're new and untested, * and the volume has the setupstate bit set, * we can pretend to be in a consistent state. * * We need to do this in one swell foop: on * the next call we will no longer be just * empty. * * This code assumes that all the other plexes * are also capable of coming up (i.e. all the * sds are up), but that's OK: we'll come back * to this function for the remaining plexes * in the volume. */ if ((plex->state == plex_init) && (plex->volno >= 0) && (vol->flags & VF_CONFIG_SETUPSTATE)) { for (plexno = 0; plexno < vol->plexes; plexno++) forceup(VOL[plex->volno].plex[plexno]); } else if ((statemap == sd_initializedstate) /* if it's initialized (not empty) */ ||(plex->organization == plex_concat) /* and we're not RAID-4 or RAID-5 */ ||(plex->organization == plex_striped)) forceup(plexno); /* we'll do it */ /* * This leaves a case where things don't get * done: the plex is RAID-4 or RAID-5, and * the subdisks are all empty. They need to * be initialized first. */ } else { if (statemap == sd_upstate) /* all subdisks up */ plex->state = plex_up; /* we can come up too */ else plex->state = plex_faulty; } } else if ((statemap & (sd_upstate | sd_rebornstate)) == statemap) /* all up or reborn */ plex->state = plex_flaky; else if (statemap & (sd_upstate | sd_rebornstate)) /* some up or reborn */ plex->state = plex_corrupt; /* corrupt */ else if (statemap & (sd_initstate | sd_emptystate)) /* some subdisks empty or initializing */ plex->state = plex_initializing; else /* nothing at all up */ plex->state = plex_faulty; if (plex->state != oldstate) /* state has changed, */ log(LOG_INFO, /* tell them about it */ "vinum: %s is %s\n", plex->name, plex_state(plex->state)); if (plex->volno >= 0) /* we're part of a volume, */ update_volume_state(plex->volno); /* update its state */ } /* Set volume state based on its components */ void update_volume_state(int volno) { struct volume *vol; /* our volume */ int plexno; enum volumestate oldstate; vol = &VOL[volno]; /* point to our volume */ oldstate = vol->state; for (plexno = 0; plexno < vol->plexes; plexno++) { struct plex *plex = &PLEX[vol->plex[plexno]]; /* point to the plex */ if (plex->state >= plex_corrupt) { /* something accessible, */ vol->state = volume_up; break; } } if (plexno == vol->plexes) /* didn't find an up plex */ vol->state = volume_down; if (vol->state != oldstate) { /* state changed */ log(LOG_INFO, "vinum: %s is %s\n", vol->name, volume_state(vol->state)); save_config(); /* save the updated configuration */ } } /* * Called from request routines when they find * a subdisk which is not kosher. Decide whether * it warrants changing the state. Return * REQUEST_DOWN if we can't use the subdisk, * REQUEST_OK if we can. */ /* * A prior version of this function checked the plex * state as well. At the moment, consider plex states * information for the user only. We'll ignore them * and use the subdisk state only. The last version of * this file with the old logic was 2.7. XXX */ enum requeststatus checksdstate(struct sd *sd, struct request *rq, vinum_off_t diskaddr, vinum_off_t diskend) { struct plex *plex = &PLEX[sd->plexno]; int writeop = (rq->bio->bio_buf->b_cmd != BUF_CMD_READ); /* note if we're writing */ switch (sd->state) { /* We shouldn't get called if the subdisk is up */ case sd_up: return REQUEST_OK; case sd_reviving: /* * Access to a reviving subdisk depends on the * organization of the plex: * * - If it's concatenated, access the subdisk * up to its current revive point. If we * want to write to the subdisk overlapping * the current revive block, set the * conflict flag in the request, asking the * caller to put the request on the wait * list, which will be attended to by * revive_block when it's done. * - if it's striped, we can't do it (we could * do some hairy calculations, but it's * unlikely to work). * - if it's RAID-4 or RAID-5, we can do it as * long as only one subdisk is down */ if (plex->organization == plex_striped) /* plex is striped, */ return REQUEST_DOWN; else if (isparity(plex)) { /* RAID-4 or RAID-5 plex */ if (plex->sddowncount > 1) /* with more than one sd down, */ return REQUEST_DOWN; else /* * XXX We shouldn't do this if we can find a * better way. Check the other plexes * first, and return a DOWN if another * plex will do it better */ return REQUEST_OK; /* OK, we'll find a way */ } if (diskaddr > (sd->revived + sd->plexoffset + (sd->revive_blocksize >> DEV_BSHIFT))) /* we're beyond the end */ return REQUEST_DOWN; else if (diskend > (sd->revived + sd->plexoffset)) { /* we finish beyond the end */ if (writeop) { rq->flags |= XFR_REVIVECONFLICT; /* note a potential conflict */ rq->sdno = sd->sdno; /* and which sd last caused it */ } else return REQUEST_DOWN; } return REQUEST_OK; case sd_reborn: if (writeop) return REQUEST_OK; /* always write to a reborn disk */ else /* don't allow a read */ /* * Handle the mapping. We don't want to reject * a read request to a reborn subdisk if that's * all we have. XXX */ return REQUEST_DOWN; case sd_down: if (writeop) /* writing to a consistent down disk */ set_sd_state(sd->sdno, sd_obsolete, setstate_force); /* it's not consistent now */ return REQUEST_DOWN; case sd_crashed: if (writeop) /* writing to a consistent down disk */ set_sd_state(sd->sdno, sd_stale, setstate_force); /* it's not consistent now */ return REQUEST_DOWN; default: return REQUEST_DOWN; } } /* return a state map for the subdisks of a plex */ enum sdstates sdstatemap(struct plex *plex) { int sdno; enum sdstates statemap = 0; /* note the states we find */ plex->sddowncount = 0; /* no subdisks down yet */ for (sdno = 0; sdno < plex->subdisks; sdno++) { struct sd *sd = &SD[plex->sdnos[sdno]]; /* point to the subdisk */ switch (sd->state) { case sd_empty: statemap |= sd_emptystate; (plex->sddowncount)++; /* another unusable subdisk */ break; case sd_init: statemap |= sd_initstate; (plex->sddowncount)++; /* another unusable subdisk */ break; case sd_down: statemap |= sd_downstate; (plex->sddowncount)++; /* another unusable subdisk */ break; case sd_crashed: statemap |= sd_crashedstate; (plex->sddowncount)++; /* another unusable subdisk */ break; case sd_obsolete: statemap |= sd_obsoletestate; (plex->sddowncount)++; /* another unusable subdisk */ break; case sd_stale: statemap |= sd_stalestate; (plex->sddowncount)++; /* another unusable subdisk */ break; case sd_reborn: statemap |= sd_rebornstate; break; case sd_up: statemap |= sd_upstate; break; case sd_initializing: statemap |= sd_initstate; (plex->sddowncount)++; /* another unusable subdisk */ break; case sd_initialized: statemap |= sd_initializedstate; (plex->sddowncount)++; /* another unusable subdisk */ break; case sd_unallocated: case sd_uninit: case sd_reviving: case sd_referenced: statemap |= sd_otherstate; (plex->sddowncount)++; /* another unusable subdisk */ } } return statemap; } /* determine the state of the volume relative to this plex */ enum volplexstate vpstate(struct plex *plex) { struct volume *vol; enum volplexstate state = volplex_onlyusdown; /* state to return */ int plexno; if (plex->volno < 0) { /* not associated with a volume */ if (plex->state > plex_degraded) return volplex_onlyus; /* just us */ else return volplex_onlyusdown; /* assume the worst */ } vol = &VOL[plex->volno]; /* point to our volume */ for (plexno = 0; plexno < vol->plexes; plexno++) { if (&PLEX[vol->plex[plexno]] == plex) { /* us */ if (PLEX[vol->plex[plexno]].state >= plex_degraded) /* are we up? */ state |= volplex_onlyus; /* yes */ } else { if (PLEX[vol->plex[plexno]].state >= plex_degraded) /* not us */ state |= volplex_otherup; /* and when they were up, they were up */ else state |= volplex_alldown; /* and when they were down, they were down */ } } return state; /* and when they were only halfway up */ } /* they were neither up nor down */ /* Check if all bits b are set in a */ int allset(int a, int b); int allset(int a, int b) { return (a & b) == b; } /* Invalidate the subdisks belonging to a plex */ void invalidate_subdisks(struct plex *plex, enum sdstate state) { int sdno; for (sdno = 0; sdno < plex->subdisks; sdno++) { /* for each subdisk */ struct sd *sd = &SD[plex->sdnos[sdno]]; switch (sd->state) { case sd_unallocated: case sd_uninit: case sd_init: case sd_initializing: case sd_initialized: case sd_empty: case sd_obsolete: case sd_stale: case sd_crashed: case sd_down: case sd_referenced: break; case sd_reviving: case sd_reborn: case sd_up: set_sd_state(plex->sdnos[sdno], state, setstate_force); } } } /* * Start an object, in other words do what we can to get it up. * This is called from vinumioctl (VINUMSTART). * Return error indications via ioctl_reply */ void start_object(struct vinum_ioctl_msg *data) { int status; int objindex = data->index; /* data gets overwritten */ struct _ioctl_reply *ioctl_reply = (struct _ioctl_reply *) data; /* format for returning replies */ enum setstateflags flags; if (data->force != 0) /* are we going to use force? */ flags = setstate_force; /* yes */ else flags = setstate_none; /* no */ switch (data->type) { case drive_object: status = set_drive_state(objindex, drive_up, flags); if (DRIVE[objindex].state != drive_up) /* set status on whether we really did it */ ioctl_reply->error = EBUSY; else ioctl_reply->error = 0; break; case sd_object: if (DRIVE[SD[objindex].driveno].state != drive_up) { ioctl_reply->error = EIO; strcpy(ioctl_reply->msg, "Drive is down"); return; } if (data->blocksize) SD[objindex].revive_blocksize = data->blocksize; if ((SD[objindex].state == sd_reviving) /* reviving, */ ||(SD[objindex].state == sd_stale)) { /* or stale, will revive */ SD[objindex].state = sd_reviving; /* make sure we're reviving */ ioctl_reply->error = revive_block(objindex); /* revive another block */ ioctl_reply->msg[0] = '\0'; /* no comment */ return; } else if (SD[objindex].state == sd_initializing) { /* initializing, */ if (data->blocksize) SD[objindex].init_blocksize = data->blocksize; ioctl_reply->error = initsd(objindex, data->verify); /* initialize another block */ ioctl_reply->msg[0] = '\0'; /* no comment */ return; } status = set_sd_state(objindex, sd_up, flags); /* set state */ if (status != EAGAIN) { /* not first revive or initialize, */ if (SD[objindex].state != sd_up) /* set status on whether we really did it */ ioctl_reply->error = EBUSY; else ioctl_reply->error = 0; } else ioctl_reply->error = status; break; case plex_object: status = set_plex_state(objindex, plex_up, flags); if (PLEX[objindex].state != plex_up) /* set status on whether we really did it */ ioctl_reply->error = EBUSY; else ioctl_reply->error = 0; break; case volume_object: status = set_volume_state(objindex, volume_up, flags); if (VOL[objindex].state != volume_up) /* set status on whether we really did it */ ioctl_reply->error = EBUSY; else ioctl_reply->error = 0; break; default: ioctl_reply->error = EINVAL; strcpy(ioctl_reply->msg, "Invalid object type"); return; } /* * There's no point in saying anything here: * the userland program does it better */ ioctl_reply->msg[0] = '\0'; } /* * Stop an object, in other words do what we can to get it down * This is called from vinumioctl (VINUMSTOP). * Return error indications via ioctl_reply. */ void stop_object(struct vinum_ioctl_msg *data) { int status = 1; int objindex = data->index; /* save the number from change */ struct _ioctl_reply *ioctl_reply = (struct _ioctl_reply *) data; /* format for returning replies */ switch (data->type) { case drive_object: status = set_drive_state(objindex, drive_down, data->force); break; case sd_object: status = set_sd_state(objindex, sd_down, data->force); break; case plex_object: status = set_plex_state(objindex, plex_down, data->force); break; case volume_object: status = set_volume_state(objindex, volume_down, data->force); break; default: ioctl_reply->error = EINVAL; strcpy(ioctl_reply->msg, "Invalid object type"); return; } ioctl_reply->msg[0] = '\0'; if (status == 0) /* couldn't do it */ ioctl_reply->error = EBUSY; else ioctl_reply->error = 0; } /* * VINUM_SETSTATE ioctl: set an object state. * msg is the message passed by the user. */ void setstate(struct vinum_ioctl_msg *msg) { int sdno; struct sd *sd; struct plex *plex; struct _ioctl_reply *ioctl_reply = (struct _ioctl_reply *) msg; /* format for returning replies */ switch (msg->state) { case object_down: stop_object(msg); break; case object_initializing: switch (msg->type) { case sd_object: sd = &SD[msg->index]; if ((msg->index >= vinum_conf.subdisks_allocated) || (sd->state <= sd_referenced)) { ksprintf(ioctl_reply->msg, "Invalid subdisk %d", msg->index); ioctl_reply->error = EFAULT; return; } set_sd_state(msg->index, sd_initializing, msg->force); if (sd->state != sd_initializing) { strcpy(ioctl_reply->msg, "Can't set state"); ioctl_reply->error = EBUSY; } else ioctl_reply->error = 0; break; case plex_object: plex = &PLEX[msg->index]; if ((msg->index >= vinum_conf.plexes_allocated) || (plex->state <= plex_unallocated)) { ksprintf(ioctl_reply->msg, "Invalid plex %d", msg->index); ioctl_reply->error = EFAULT; return; } set_plex_state(msg->index, plex_initializing, msg->force); if (plex->state != plex_initializing) { strcpy(ioctl_reply->msg, "Can't set state"); ioctl_reply->error = EBUSY; } else { ioctl_reply->error = 0; for (sdno = 0; sdno < plex->subdisks; sdno++) { sd = &SD[plex->sdnos[sdno]]; set_sd_state(plex->sdnos[sdno], sd_initializing, msg->force); if (sd->state != sd_initializing) { strcpy(ioctl_reply->msg, "Can't set state"); ioctl_reply->error = EBUSY; break; } } } break; default: strcpy(ioctl_reply->msg, "Invalid object"); ioctl_reply->error = EINVAL; } break; case object_initialized: if (msg->type == sd_object) { sd = &SD[msg->index]; if ((msg->index >= vinum_conf.subdisks_allocated) || (sd->state <= sd_referenced)) { ksprintf(ioctl_reply->msg, "Invalid subdisk %d", msg->index); ioctl_reply->error = EFAULT; return; } set_sd_state(msg->index, sd_initialized, msg->force); if (sd->state != sd_initializing) { strcpy(ioctl_reply->msg, "Can't set state"); ioctl_reply->error = EBUSY; } else ioctl_reply->error = 0; } else { strcpy(ioctl_reply->msg, "Invalid object"); ioctl_reply->error = EINVAL; } break; case object_up: start_object(msg); } } /* * Brute force set state function. Don't look at * any dependencies, just do it. This is mainly * intended for testing and recovery. */ void setstate_by_force(struct vinum_ioctl_msg *msg) { struct _ioctl_reply *ioctl_reply = (struct _ioctl_reply *) msg; /* format for returning replies */ switch (msg->type) { case drive_object: DRIVE[msg->index].state = msg->state; break; case sd_object: SD[msg->index].state = msg->state; break; case plex_object: PLEX[msg->index].state = msg->state; break; case volume_object: VOL[msg->index].state = msg->state; break; default: break; } ioctl_reply->error = 0; }