diff options
Diffstat (limited to 'sys/dev/vinum/vinumioctl.c')
| -rw-r--r-- | sys/dev/vinum/vinumioctl.c | 958 |
1 files changed, 958 insertions, 0 deletions
diff --git a/sys/dev/vinum/vinumioctl.c b/sys/dev/vinum/vinumioctl.c new file mode 100644 index 0000000..2f7b876 --- /dev/null +++ b/sys/dev/vinum/vinumioctl.c @@ -0,0 +1,958 @@ +/* + * XXX replace all the checks on object validity with + * calls to valid<object> + */ +/*- + * 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: vinumioctl.c,v 1.23 2003/05/23 01:02:22 grog Exp grog $ + * $FreeBSD$ + */ + +#include <dev/vinum/vinumhdr.h> +#include <dev/vinum/request.h> + +#ifdef VINUMDEBUG +#include <sys/reboot.h> +#endif + +void attachobject(struct vinum_ioctl_msg *); +void detachobject(struct vinum_ioctl_msg *); +void renameobject(struct vinum_rename_msg *); +void replaceobject(struct vinum_ioctl_msg *); +void moveobject(struct vinum_ioctl_msg *); +void setreadpol(struct vinum_ioctl_msg *); + +jmp_buf command_fail; /* return on a failed command */ + +/* ioctl routine */ +int +vinumioctl(dev_t dev, + u_long cmd, + caddr_t data, + int flag, + struct thread *td) +{ + unsigned int objno; + struct sd *sd; + struct plex *plex; + struct volume *vol; + + /* First, decide what we're looking at */ + if ((minor(dev) == VINUM_SUPERDEV_MINOR) + || (minor(dev) == VINUM_DAEMON_MINOR)) + return vinum_super_ioctl(dev, cmd, data); + else /* real device */ + switch (DEVTYPE(dev)) { + case VINUM_SD_TYPE: + case VINUM_SD2_TYPE: /* second half of sd namespace */ + objno = Sdno(dev); + + sd = &SD[objno]; + + switch (cmd) { + case DIOCGSECTORSIZE: + *(u_int *) data = sd->sectorsize; + return 0; + + case DIOCGMEDIASIZE: + *(u_int64_t *) data = sd->sectors * sd->sectorsize; + return 0; + + /* + * We don't have this stuff on hardware, + * so just pretend to do it so that + * utilities don't get upset. + */ + case DIOCWDINFO: /* write partition info */ + case DIOCSDINFO: /* set partition info */ + return 0; /* not a titty */ + + default: + return ENOTTY; /* not my kind of ioctl */ + } + + return 0; /* pretend we did it */ + + case VINUM_PLEX_TYPE: + objno = Plexno(dev); + + plex = &PLEX[objno]; + + switch (cmd) { + case DIOCGSECTORSIZE: + *(u_int64_t *) data = plex->sectorsize; + return 0; + + case DIOCGMEDIASIZE: + *(u_int64_t *) data = plex->length * plex->sectorsize; + return 0; + + /* + * We don't have this stuff on hardware, + * so just pretend to do it so that + * utilities don't get upset. + */ + case DIOCWDINFO: /* write partition info */ + case DIOCSDINFO: /* set partition info */ + return 0; /* not a titty */ + + default: + return ENOTTY; /* not my kind of ioctl */ + } + + return 0; /* pretend we did it */ + + case VINUM_VOLUME_TYPE: + objno = Volno(dev); + + if ((unsigned) objno >= (unsigned) vinum_conf.volumes_allocated) /* not a valid volume */ + return ENXIO; + vol = &VOL[objno]; + if (vol->state != volume_up) /* not up, */ + return EIO; /* I/O error */ + + switch (cmd) { + case DIOCGSECTORSIZE: + *(u_int *) data = vol->sectorsize; + return 0; + + case DIOCGMEDIASIZE: + *(u_int64_t *) data = vol->size * vol->sectorsize; + return 0; + + /* + * We don't have this stuff on hardware, + * so just pretend to do it so that + * utilities don't get upset. + */ + case DIOCWDINFO: /* write partition info */ + case DIOCSDINFO: /* set partition info */ + return 0; /* not a titty */ + + default: + return ENOTTY; /* not my kind of ioctl */ + } + break; + } + return 0; /* XXX */ +} + +/* Handle ioctls for the super device */ +int +vinum_super_ioctl(dev_t dev, + u_long cmd, + caddr_t data) +{ + int error = 0; + unsigned int index; /* for transferring config info */ + unsigned int sdno; /* for transferring config info */ + int fe; /* free list element number */ + struct _ioctl_reply *ioctl_reply = (struct _ioctl_reply *) data; /* struct to return */ + + ioctl_reply = (struct _ioctl_reply *) data; /* save the address to reply to */ + if (error) /* bombed out */ + return 0; /* the reply will contain meaningful info */ + switch (cmd) { +#ifdef VINUMDEBUG + case VINUM_DEBUG: + if (((struct debuginfo *) data)->changeit) /* change debug settings */ + debug = (((struct debuginfo *) data)->param); + else { + if (debug & DEBUG_REMOTEGDB) + boothowto |= RB_GDB; /* serial debug line */ + else + boothowto &= ~RB_GDB; /* local ddb */ + Debugger("vinum debug"); + } + ioctl_reply = (struct _ioctl_reply *) data; /* reinstate the address to reply to */ + ioctl_reply->error = 0; + return 0; +#endif + + case VINUM_CREATE: /* create a vinum object */ + error = lock_config(); /* get the config for us alone */ + if (error) /* can't do it, */ + return error; /* give up */ + error = setjmp(command_fail); /* come back here on error */ + if (error == 0) /* first time, */ + ioctl_reply->error = parse_user_config((char *) data, /* update the config */ + &keyword_set); + else if (ioctl_reply->error == 0) { /* longjmp, but no error status */ + ioctl_reply->error = EINVAL; /* note that something's up */ + ioctl_reply->msg[0] = '\0'; /* no message? */ + } + unlock_config(); + return 0; /* must be 0 to return the real error info */ + + case VINUM_GETCONFIG: /* get the configuration information */ + bcopy(&vinum_conf, data, sizeof(vinum_conf)); + return 0; + + /* start configuring the subsystem */ + case VINUM_STARTCONFIG: + return start_config(*(int *) data); /* just lock it. Parameter is 'force' */ + + /* + * Move the individual parts of the config to user space. + * + * Specify the index of the object in the first word of data, + * and return the object there + */ + case VINUM_DRIVECONFIG: + index = *(int *) data; /* get the index */ + if (index >= (unsigned) vinum_conf.drives_allocated) /* can't do it */ + return ENXIO; /* bang */ + bcopy(&DRIVE[index], data, sizeof(struct _drive)); /* copy the config item out */ + return 0; + + case VINUM_SDCONFIG: + index = *(int *) data; /* get the index */ + if (index >= (unsigned) vinum_conf.subdisks_allocated) /* can't do it */ + return ENXIO; /* bang */ + bcopy(&SD[index], data, sizeof(struct _sd)); /* copy the config item out */ + return 0; + + case VINUM_PLEXCONFIG: + index = *(int *) data; /* get the index */ + if (index >= (unsigned) vinum_conf.plexes_allocated) /* can't do it */ + return ENXIO; /* bang */ + bcopy(&PLEX[index], data, sizeof(struct _plex)); /* copy the config item out */ + return 0; + + case VINUM_VOLCONFIG: + index = *(int *) data; /* get the index */ + if (index >= (unsigned) vinum_conf.volumes_allocated) /* can't do it */ + return ENXIO; /* bang */ + bcopy(&VOL[index], data, sizeof(struct _volume)); /* copy the config item out */ + return 0; + + case VINUM_PLEXSDCONFIG: + index = *(int *) data; /* get the plex index */ + sdno = ((int *) data)[1]; /* and the sd index */ + if ((index >= (unsigned) vinum_conf.plexes_allocated) /* plex doesn't exist */ + ||(sdno >= PLEX[index].subdisks)) /* or it doesn't have this many subdisks */ + return ENXIO; /* bang */ + bcopy(&SD[PLEX[index].sdnos[sdno]], /* copy the config item out */ + data, + sizeof(struct _sd)); + return 0; + + /* + * We get called in two places: one from the + * userland config routines, which call us + * to complete the config and save it. This + * call supplies the value 0 as a parameter. + * + * The other place is from the user "saveconfig" + * routine, which can only work if we're *not* + * configuring. In this case, supply parameter 1. + */ + case VINUM_SAVECONFIG: + if (VFLAGS & VF_CONFIGURING) { /* must be us, the others are asleep */ + if (*(int *) data == 0) /* finish config */ + finish_config(1); /* finish the configuration and update it */ + else + return EBUSY; /* can't do it now */ + } + save_config(); /* save configuration to disk */ + return 0; + + case VINUM_RELEASECONFIG: /* release the config */ + if (VFLAGS & VF_CONFIGURING) { /* must be us, the others are asleep */ + finish_config(0); /* finish the configuration, don't change it */ + save_config(); /* save configuration to disk */ + } else + error = EINVAL; /* release what config? */ + return error; + + case VINUM_READCONFIG: + if (((char *) data)[0] == '\0') + ioctl_reply->error = vinum_scandisk(NULL); /* built your own list */ + else + ioctl_reply->error = vinum_scandisk((char *) data); + if (ioctl_reply->error == ENOENT) { + if (vinum_conf.drives_used > 0) + strcpy(ioctl_reply->msg, "no additional drives found"); + else + strcpy(ioctl_reply->msg, "no drives found"); + } else if (ioctl_reply->error) + strcpy(ioctl_reply->msg, "can't read configuration information, see log file"); + return 0; /* must be 0 to return the real error info */ + + case VINUM_INIT: + ioctl_reply = (struct _ioctl_reply *) data; /* reinstate the address to reply to */ + ioctl_reply->error = 0; + return 0; + + case VINUM_RESETCONFIG: + if (vinum_inactive(0)) { /* if the volumes are not active */ + /* + * Note the open count. We may be called from v, so we'll be open. + * Keep the count so we don't underflow + */ + free_vinum(1); /* clean up everything */ + log(LOG_NOTICE, "vinum: CONFIGURATION OBLITERATED\n"); + ioctl_reply = (struct _ioctl_reply *) data; /* reinstate the address to reply to */ + ioctl_reply->error = 0; + return 0; + } + return EBUSY; + + case VINUM_SETSTATE: + setstate((struct vinum_ioctl_msg *) data); /* set an object state */ + return 0; + + /* + * Set state by force, without changing + * anything else. + */ + case VINUM_SETSTATE_FORCE: + setstate_by_force((struct vinum_ioctl_msg *) data); /* set an object state */ + return 0; + +#ifdef VINUMDEBUG + case VINUM_MEMINFO: + vinum_meminfo(data); + return 0; + + case VINUM_MALLOCINFO: + return vinum_mallocinfo(data); + + case VINUM_RQINFO: + return vinum_rqinfo(data); +#endif + + case VINUM_REMOVE: + remove((struct vinum_ioctl_msg *) data); /* remove an object */ + return 0; + + case VINUM_GETFREELIST: /* get a drive free list element */ + index = *(int *) data; /* get the drive index */ + fe = ((int *) data)[1]; /* and the free list element */ + if ((index >= (unsigned) vinum_conf.drives_allocated) /* plex doesn't exist */ + ||(DRIVE[index].state == drive_unallocated)) + return ENODEV; + if (fe >= DRIVE[index].freelist_entries) /* no such entry */ + return ENOENT; + bcopy(&DRIVE[index].freelist[fe], + data, + sizeof(struct drive_freelist)); + return 0; + + case VINUM_RESETSTATS: + resetstats((struct vinum_ioctl_msg *) data); /* reset object stats */ + return 0; + + /* attach an object to a superordinate object */ + case VINUM_ATTACH: + attachobject((struct vinum_ioctl_msg *) data); + return 0; + + /* detach an object from a superordinate object */ + case VINUM_DETACH: + detachobject((struct vinum_ioctl_msg *) data); + return 0; + + /* rename an object */ + case VINUM_RENAME: + renameobject((struct vinum_rename_msg *) data); + return 0; + + /* replace an object */ + case VINUM_REPLACE: + replaceobject((struct vinum_ioctl_msg *) data); + return 0; + + case VINUM_DAEMON: + vinum_daemon(); /* perform the daemon */ + return 0; + + case VINUM_FINDDAEMON: /* check for presence of daemon */ + return vinum_finddaemon(); + return 0; + + case VINUM_SETDAEMON: /* set daemon flags */ + return vinum_setdaemonopts(*(int *) data); + + case VINUM_GETDAEMON: /* get daemon flags */ + *(int *) data = daemon_options; + return 0; + + case VINUM_PARITYOP: /* check/rebuild RAID-4/5 parity */ + parityops((struct vinum_ioctl_msg *) data); + return 0; + + /* move an object */ + case VINUM_MOVE: + moveobject((struct vinum_ioctl_msg *) data); + return 0; + + case VINUM_READPOL: + setreadpol((struct vinum_ioctl_msg *) data); + return 0; + + default: + /* FALLTHROUGH */ + break; + } + return 0; /* to keep the compiler happy */ +} + +/* + * The following four functions check the supplied + * object index and return a pointer to the object + * if it exists. Otherwise they longjump out via + * throw_rude_remark. + */ +struct drive * +validdrive(int driveno, struct _ioctl_reply *reply) +{ + if ((driveno < vinum_conf.drives_allocated) + && (DRIVE[driveno].state > drive_referenced)) + return &DRIVE[driveno]; + strcpy(reply->msg, "No such drive"); + reply->error = ENOENT; + return NULL; +} + +struct sd * +validsd(int sdno, struct _ioctl_reply *reply) +{ + if ((sdno < vinum_conf.subdisks_allocated) + && (SD[sdno].state > sd_referenced)) + return &SD[sdno]; + strcpy(reply->msg, "No such subdisk"); + reply->error = ENOENT; + return NULL; +} + +struct plex * +validplex(int plexno, struct _ioctl_reply *reply) +{ + if ((plexno < vinum_conf.plexes_allocated) + && (PLEX[plexno].state > plex_referenced)) + return &PLEX[plexno]; + strcpy(reply->msg, "No such plex"); + reply->error = ENOENT; + return NULL; +} + +struct volume * +validvol(int volno, struct _ioctl_reply *reply) +{ + if ((volno < vinum_conf.volumes_allocated) + && (VOL[volno].state > volume_uninit)) + return &VOL[volno]; + strcpy(reply->msg, "No such volume"); + reply->error = ENOENT; + return NULL; +} + +/* reset an object's stats */ +void +resetstats(struct vinum_ioctl_msg *msg) +{ + struct _ioctl_reply *reply = (struct _ioctl_reply *) msg; + + switch (msg->type) { + case drive_object: + if (msg->index < vinum_conf.drives_allocated) { + struct drive *drive = &DRIVE[msg->index]; + if (drive->state > drive_referenced) { + drive->reads = 0; /* number of reads on this drive */ + drive->writes = 0; /* number of writes on this drive */ + drive->bytes_read = 0; /* number of bytes read */ + drive->bytes_written = 0; /* number of bytes written */ + reply->error = 0; + return; + } + reply->error = EINVAL; + return; + } + case sd_object: + if (msg->index < vinum_conf.subdisks_allocated) { + struct sd *sd = &SD[msg->index]; + if (sd->state > sd_referenced) { + sd->reads = 0; /* number of reads on this subdisk */ + sd->writes = 0; /* number of writes on this subdisk */ + sd->bytes_read = 0; /* number of bytes read */ + sd->bytes_written = 0; /* number of bytes written */ + reply->error = 0; + return; + } + reply->error = EINVAL; + return; + } + break; + + case plex_object: + if (msg->index < vinum_conf.plexes_allocated) { + struct plex *plex = &PLEX[msg->index]; + if (plex->state > plex_referenced) { + plex->reads = 0; + plex->writes = 0; /* number of writes on this plex */ + plex->bytes_read = 0; /* number of bytes read */ + plex->bytes_written = 0; /* number of bytes written */ + plex->recovered_reads = 0; /* number of recovered read operations */ + plex->degraded_writes = 0; /* number of degraded writes */ + plex->parityless_writes = 0; /* number of parityless writes */ + plex->multiblock = 0; /* requests that needed more than one block */ + plex->multistripe = 0; /* requests that needed more than one stripe */ + reply->error = 0; + return; + } + reply->error = EINVAL; + return; + } + break; + + case volume_object: + if (msg->index < vinum_conf.volumes_allocated) { + struct volume *vol = &VOL[msg->index]; + if (vol->state > volume_uninit) { + vol->bytes_read = 0; /* number of bytes read */ + vol->bytes_written = 0; /* number of bytes written */ + vol->reads = 0; /* number of reads on this volume */ + vol->writes = 0; /* number of writes on this volume */ + vol->recovered_reads = 0; /* reads recovered from another plex */ + reply->error = 0; + return; + } + reply->error = EINVAL; + return; + } + case invalid_object: /* can't get this */ + reply->error = EINVAL; + return; + } +} + +/* attach an object to a superior object */ +void +attachobject(struct vinum_ioctl_msg *msg) +{ + struct _ioctl_reply *reply = (struct _ioctl_reply *) msg; + int sdno; + struct sd *sd; + struct plex *plex; + struct volume *vol; + + switch (msg->type) { + case drive_object: /* you can't attach a drive to anything */ + case volume_object: /* nor a volume */ + case invalid_object: /* "this can't happen" */ + reply->error = EINVAL; + reply->msg[0] = '\0'; /* vinum(8) doesn't do this */ + return; + + case sd_object: + sd = validsd(msg->index, reply); + if (sd == NULL) /* not a valid subdisk */ + return; + plex = validplex(msg->otherobject, reply); + if (plex) { + /* + * We should be more intelligent about this. + * We should be able to reattach a dead + * subdisk, but if we want to increase the total + * number of subdisks, we have a lot of reshuffling + * to do. XXX + */ + if ((plex->organization != plex_concat) /* can't attach to striped and RAID-4/5 */ + &&(!msg->force)) { /* without using force */ + reply->error = EINVAL; /* no message, the user should check */ + strcpy(reply->msg, "Can't attach to this plex organization"); + } else if (sd->plexno >= 0) { /* already belong to a plex */ + reply->error = EBUSY; /* no message, the user should check */ + sprintf(reply->msg, "%s is already attached to %s", + sd->name, + sd[sd->plexno].name); + reply->msg[0] = '\0'; + } else { + sd->plexoffset = msg->offset; /* this is where we want it */ + set_sd_state(sd->sdno, sd_stale, setstate_force); /* make sure it's stale */ + give_sd_to_plex(plex->plexno, sd->sdno); /* and give it to the plex */ + update_sd_config(sd->sdno, 0); + save_config(); + if (sd->state == sd_reviving) + reply->error = EAGAIN; /* need to revive it */ + else + reply->error = 0; + } + } + break; + + case plex_object: + plex = validplex(msg->index, reply); /* get plex */ + if (plex == NULL) + return; + vol = validvol(msg->otherobject, reply); /* and volume information */ + if (vol) { + if (vol->plexes == MAXPLEX) { /* we have too many already */ + reply->error = ENOSPC; /* nowhere to put it */ + strcpy(reply->msg, "Too many plexes"); + } else if (plex->volno >= 0) { /* the plex has an owner */ + reply->error = EBUSY; /* no message, the user should check */ + sprintf(reply->msg, "%s is already attached to %s", + plex->name, + VOL[plex->volno].name); + } else { + for (sdno = 0; sdno < plex->subdisks; sdno++) { + sd = &SD[plex->sdnos[sdno]]; + + if (sd->state > sd_down) /* real subdisk, vaguely accessible */ + set_sd_state(plex->sdnos[sdno], sd_stale, setstate_force); /* make it stale */ + } + set_plex_state(plex->plexno, plex_up, setstate_none); /* update plex state */ + give_plex_to_volume(msg->otherobject, msg->index, 0); /* and give it to the volume */ + update_plex_config(plex->plexno, 0); + save_config(); + reply->error = 0; /* all went well */ + } + } + } +} + +/* detach an object from a superior object */ +void +detachobject(struct vinum_ioctl_msg *msg) +{ + struct _ioctl_reply *reply = (struct _ioctl_reply *) msg; + struct sd *sd; + struct plex *plex; + struct volume *vol; + int sdno; + int plexno; + + switch (msg->type) { + case drive_object: /* you can't detach a drive from anything */ + case volume_object: /* nor a volume */ + case invalid_object: /* "this can't happen" */ + reply->error = EINVAL; + reply->msg[0] = '\0'; /* vinum(8) doesn't do this */ + return; + + case sd_object: + sd = validsd(msg->index, reply); + if (sd == NULL) + return; + if (sd->plexno < 0) { /* doesn't belong to a plex */ + reply->error = ENOENT; + strcpy(reply->msg, "Subdisk is not attached"); + return; + } else { /* valid plex number */ + plex = &PLEX[sd->plexno]; + if ((!msg->force) /* don't force things */ + &&((plex->state == plex_up) /* and the plex is up */ + ||((plex->state == plex_flaky) && sd->state == sd_up))) { /* or flaky with this sd up */ + reply->error = EBUSY; /* we need this sd */ + reply->msg[0] = '\0'; + return; + } + sd->plexno = -1; /* anonymous sd */ + if (plex->subdisks == 1) { /* this was the only subdisk */ + Free(plex->sdnos); /* free the subdisk array */ + plex->sdnos = NULL; /* and note the fact */ + plex->subdisks_allocated = 0; /* no subdisk space */ + } else { + for (sdno = 0; sdno < plex->subdisks; sdno++) { + if (plex->sdnos[sdno] == msg->index) /* found our subdisk */ + break; + } + if (sdno < (plex->subdisks - 1)) /* not the last one, compact */ + bcopy(&plex->sdnos[sdno + 1], + &plex->sdnos[sdno], + (plex->subdisks - 1 - sdno) * sizeof(int)); + } + plex->subdisks--; + if (!bcmp(plex->name, sd->name, strlen(plex->name) + 1)) + /* this subdisk is named after the plex */ + { + bcopy(sd->name, + &sd->name[3], + min(strlen(sd->name) + 1, MAXSDNAME - 3)); + bcopy("ex-", sd->name, 3); + sd->name[MAXSDNAME - 1] = '\0'; + } + update_plex_config(plex->plexno, 0); + if (isstriped(plex)) /* we've just mutilated our plex, */ + set_plex_state(plex->plexno, + plex_down, + setstate_force | setstate_configuring); + if (plex->volno >= 0) /* plex attached to volume, */ + update_volume_config(plex->volno); + save_config(); + reply->error = 0; + } + return; + + case plex_object: + plex = validplex(msg->index, reply); /* get plex */ + if (plex == NULL) + return; + if (plex->volno >= 0) { + int volno = plex->volno; + + vol = &VOL[volno]; + if ((!msg->force) /* don't force things */ + &&((vol->state == volume_up) /* and the volume is up */ + &&(vol->plexes == 1))) { /* and this is the last plex */ + /* + * XXX As elsewhere, check whether we will lose + * mapping by removing this plex + */ + reply->error = EBUSY; /* we need this plex */ + reply->msg[0] = '\0'; + return; + } + plex->volno = -1; /* anonymous plex */ + for (plexno = 0; plexno < vol->plexes; plexno++) { + if (vol->plex[plexno] == msg->index) /* found our plex */ + break; + } + if (plexno < (vol->plexes - 1)) /* not the last one, compact */ + bcopy(&vol->plex[plexno + 1], + &vol->plex[plexno], + (vol->plexes - 1 - plexno) * sizeof(int)); + vol->plexes--; + vol->last_plex_read = 0; /* don't go beyond the end */ + if (!bcmp(vol->name, plex->name, strlen(vol->name) + 1)) + /* this plex is named after the volume */ + { + /* First, check if the subdisks are the same */ + if (msg->recurse) { + int sdno; + + for (sdno = 0; sdno < plex->subdisks; sdno++) { + struct sd *sd = &SD[plex->sdnos[sdno]]; + + if (!bcmp(plex->name, sd->name, strlen(plex->name) + 1)) + /* subdisk is named after the plex */ + { + bcopy(sd->name, + &sd->name[3], + min(strlen(sd->name) + 1, MAXSDNAME - 3)); + bcopy("ex-", sd->name, 3); + sd->name[MAXSDNAME - 1] = '\0'; + } + } + } + bcopy(plex->name, + &plex->name[3], + min(strlen(plex->name) + 1, MAXPLEXNAME - 3)); + bcopy("ex-", plex->name, 3); + plex->name[MAXPLEXNAME - 1] = '\0'; + } + update_volume_config(volno); + save_config(); + reply->error = 0; + } else { + reply->error = ENOENT; + strcpy(reply->msg, "Plex is not attached"); + } + } +} + +void +renameobject(struct vinum_rename_msg *msg) +{ + struct _ioctl_reply *reply = (struct _ioctl_reply *) msg; + struct drive *drive; + struct sd *sd; + struct plex *plex; + struct volume *vol; + + switch (msg->type) { + case drive_object: /* you can't attach a drive to anything */ + if (find_drive(msg->newname, 0) >= 0) { /* we have that name already, */ + reply->error = EEXIST; + reply->msg[0] = '\0'; + return; + } + drive = validdrive(msg->index, reply); + if (drive) { + bcopy(msg->newname, drive->label.name, MAXDRIVENAME); + save_config(); + reply->error = 0; + } + return; + + case sd_object: /* you can't attach a subdisk to anything */ + if (find_subdisk(msg->newname, 0) >= 0) { /* we have that name already, */ + reply->error = EEXIST; + reply->msg[0] = '\0'; + return; + } + sd = validsd(msg->index, reply); + if (sd) { + bcopy(msg->newname, sd->name, MAXSDNAME); + update_sd_config(sd->sdno, 0); + save_config(); + reply->error = 0; + } + return; + + case plex_object: /* you can't attach a plex to anything */ + if (find_plex(msg->newname, 0) >= 0) { /* we have that name already, */ + reply->error = EEXIST; + reply->msg[0] = '\0'; + return; + } + plex = validplex(msg->index, reply); + if (plex) { + bcopy(msg->newname, plex->name, MAXPLEXNAME); + update_plex_config(plex->plexno, 0); + save_config(); + reply->error = 0; + } + return; + + case volume_object: /* you can't attach a volume to anything */ + if (find_volume(msg->newname, 0) >= 0) { /* we have that name already, */ + reply->error = EEXIST; + reply->msg[0] = '\0'; + return; + } + vol = validvol(msg->index, reply); + if (vol) { + bcopy(msg->newname, vol->name, MAXVOLNAME); + update_volume_config(msg->index); + save_config(); + reply->error = 0; + } + return; + + case invalid_object: + reply->error = EINVAL; + reply->msg[0] = '\0'; + } +} + +/* + * Replace one object with another. + * Currently only for drives. + * message->index is the drive number of the old drive + * message->otherobject is the drive number of the new drive + */ +void +replaceobject(struct vinum_ioctl_msg *msg) +{ + struct _ioctl_reply *reply = (struct _ioctl_reply *) msg; + + reply->error = ENODEV; /* until I know how to do this */ + strcpy(reply->msg, "replace not implemented yet"); +/* save_config (); */ +} + +void +moveobject(struct vinum_ioctl_msg *msg) +{ + struct _ioctl_reply *reply = (struct _ioctl_reply *) msg; + struct drive *drive; + struct sd *sd; + + /* Check that our objects are valid (i.e. they exist) */ + drive = validdrive(msg->index, (struct _ioctl_reply *) msg); + if (drive == NULL) + return; + sd = validsd(msg->otherobject, (struct _ioctl_reply *) msg); + if (sd == NULL) + return; + if (sd->driveno == msg->index) /* sd already belongs to drive */ + return; + + if (sd->state > sd_stale) + set_sd_state(sd->sdno, sd_stale, setstate_force); /* make the subdisk stale */ + else + sd->state = sd_empty; + if (sd->plexno >= 0) /* part of a plex, */ + update_plex_state(sd->plexno); /* update its state */ + + /* Return the space on the old drive */ + if ((sd->driveno >= 0) /* we have a drive, */ + &&(sd->sectors > 0)) /* and some space on it */ + return_drive_space(sd->driveno, /* return the space */ + sd->driveoffset, + sd->sectors); + + /* Reassign the old subdisk */ + sd->driveno = msg->index; + sd->driveoffset = -1; /* let the drive decide where to put us */ + give_sd_to_drive(sd->sdno); + reply->error = 0; +} + +void +setreadpol(struct vinum_ioctl_msg *msg) +{ + struct _ioctl_reply *reply = (struct _ioctl_reply *) msg; + struct volume *vol; + struct plex *plex; + int myplexno = -1; + + /* Check that our objects are valid (i.e. they exist) */ + vol = validvol(msg->index, reply); + if (vol == NULL) + return; + + /* If a plex was specified, check that is is valid */ + if (msg->otherobject >= 0) { + plex = validplex(msg->otherobject, reply); + if (vol == NULL) + return; + + /* Is it attached to this volume? */ + myplexno = my_plex(msg->index, msg->otherobject); + if (myplexno < 0) { + strcpy(reply->msg, "Plex is not attached to volume"); + reply->error = ENOENT; + return; + } + } + lock_config(); + vol->preferred_plex = myplexno; + save_config(); + unlock_config(); + reply->error = 0; +} + +/* Local Variables: */ +/* fill-column: 50 */ +/* End: */ |
