geom_vinum_rm.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  *  Copyright (c) 2004, 2007 Lukas Ertl
    3  *  All rights reserved.
    4  * 
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  * 
   14  * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   17  * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
   18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   24  * SUCH DAMAGE.
   25  *
   26  */
   27 
   28 #include <sys/cdefs.h>
   29 __FBSDID("$FreeBSD: releng/8.3/sys/geom/vinum/geom_vinum_rm.c 191854 2009-05-06 19:06:28Z lulf $");
   30 
   31 #include <sys/param.h>
   32 #include <sys/libkern.h>
   33 #include <sys/malloc.h>
   34 
   35 #include <geom/geom.h>
   36 #include <geom/vinum/geom_vinum_var.h>
   37 #include <geom/vinum/geom_vinum.h>
   38 
   39 /* General 'remove' routine. */
   40 void
   41 gv_remove(struct g_geom *gp, struct gctl_req *req)
   42 {
   43         struct gv_softc *sc;
   44         struct gv_volume *v;
   45         struct gv_plex *p;
   46         struct gv_sd *s;
   47         struct gv_drive *d;
   48         int *argc, *flags;
   49         char *argv, buf[20];
   50         int i, type;
   51 
   52         argc = gctl_get_paraml(req, "argc", sizeof(*argc));
   53 
   54         if (argc == NULL || *argc == 0) {
   55                 gctl_error(req, "no arguments given");
   56                 return;
   57         }
   58 
   59         flags = gctl_get_paraml(req, "flags", sizeof(*flags));
   60         if (flags == NULL) {
   61                 gctl_error(req, "no flags given");
   62                 return;
   63         }
   64 
   65         sc = gp->softc;
   66 
   67         /* XXX config locking */
   68 
   69         for (i = 0; i < *argc; i++) {
   70                 snprintf(buf, sizeof(buf), "argv%d", i);
   71                 argv = gctl_get_param(req, buf, NULL);
   72                 if (argv == NULL)
   73                         continue;
   74                 type = gv_object_type(sc, argv);
   75                 switch (type) {
   76                 case GV_TYPE_VOL:
   77                         v = gv_find_vol(sc, argv);
   78 
   79                         /*
   80                          * If this volume has plexes, we want a recursive
   81                          * removal.
   82                          */
   83                         if (!LIST_EMPTY(&v->plexes) && !(*flags & GV_FLAG_R)) {
   84                                 gctl_error(req, "volume '%s' has attached "
   85                                     "plexes - need recursive removal", v->name);
   86                                 return;
   87                         }
   88 
   89                         gv_post_event(sc, GV_EVENT_RM_VOLUME, v, NULL, 0, 0);
   90                         break;
   91 
   92                 case GV_TYPE_PLEX:
   93                         p = gv_find_plex(sc, argv);
   94 
   95                         /*
   96                          * If this plex has subdisks, we want a recursive
   97                          * removal.
   98                          */
   99                         if (!LIST_EMPTY(&p->subdisks) &&
  100                             !(*flags & GV_FLAG_R)) {
  101                                 gctl_error(req, "plex '%s' has attached "
  102                                     "subdisks - need recursive removal",
  103                                     p->name);
  104                                 return;
  105                         }
  106 
  107                         /* Don't allow removal of the only plex of a volume. */
  108                         if (p->vol_sc != NULL && p->vol_sc->plexcount == 1) {
  109                                 gctl_error(req, "plex '%s' is still attached "
  110                                     "to volume '%s'", p->name, p->volume);
  111                                 return;
  112                         }
  113 
  114                         gv_post_event(sc, GV_EVENT_RM_PLEX, p, NULL, 0, 0);
  115                         break;
  116 
  117                 case GV_TYPE_SD:
  118                         s = gv_find_sd(sc, argv);
  119 
  120                         /* Don't allow removal if attached to a plex. */
  121                         if (s->plex_sc != NULL) {
  122                                 gctl_error(req, "subdisk '%s' is still attached"
  123                                     " to plex '%s'", s->name, s->plex_sc->name);
  124                                 return;
  125                         }
  126 
  127                         gv_post_event(sc, GV_EVENT_RM_SD, s, NULL, 0, 0);
  128                         break;
  129 
  130                 case GV_TYPE_DRIVE:
  131                         d = gv_find_drive(sc, argv);
  132                         /* We don't allow to remove open drives. */
  133                         if (gv_consumer_is_open(d->consumer) &&
  134                             !(*flags & GV_FLAG_F)) {
  135                                 gctl_error(req, "drive '%s' is open", d->name);
  136                                 return;
  137                         }
  138 
  139                         /* A drive with subdisks needs a recursive removal. */
  140 /*                      if (!LIST_EMPTY(&d->subdisks) &&
  141                             !(*flags & GV_FLAG_R)) {
  142                                 gctl_error(req, "drive '%s' still has subdisks"
  143                                     " - need recursive removal", d->name);
  144                                 return;
  145                         }*/
  146 
  147                         gv_post_event(sc, GV_EVENT_RM_DRIVE, d, NULL, *flags,
  148                             0);
  149                         break;
  150 
  151                 default:
  152                         gctl_error(req, "unknown object '%s'", argv);
  153                         return;
  154                 }
  155         }
  156 
  157         gv_post_event(sc, GV_EVENT_SAVE_CONFIG, sc, NULL, 0, 0);
  158 }
  159 
  160 /* Resets configuration */
  161 int
  162 gv_resetconfig(struct gv_softc *sc)
  163 {
  164         struct gv_drive *d, *d2;
  165         struct gv_volume *v, *v2;
  166         struct gv_plex *p, *p2;
  167         struct gv_sd *s, *s2;
  168 
  169         /* First make sure nothing is open. */
  170         LIST_FOREACH_SAFE(d, &sc->drives, drive, d2) {
  171                 if (gv_consumer_is_open(d->consumer)) {
  172                         return (GV_ERR_ISBUSY);
  173                 }
  174         }
  175 
  176         /* Make sure nothing is going on internally. */
  177         LIST_FOREACH_SAFE(p, &sc->plexes, plex, p2) {
  178                 if (p->flags & (GV_PLEX_REBUILDING | GV_PLEX_GROWING))
  179                         return (GV_ERR_ISBUSY);
  180         }
  181 
  182         /* Then if not, we remove everything. */
  183         LIST_FOREACH_SAFE(s, &sc->subdisks, sd, s2)
  184                 gv_rm_sd(sc, s);
  185         LIST_FOREACH_SAFE(d, &sc->drives, drive, d2)
  186                 gv_rm_drive(sc, d, 0);
  187         LIST_FOREACH_SAFE(p, &sc->plexes, plex, p2)
  188                 gv_rm_plex(sc, p);
  189         LIST_FOREACH_SAFE(v, &sc->volumes, volume, v2)
  190                 gv_rm_vol(sc, v);
  191 
  192         gv_post_event(sc, GV_EVENT_SAVE_CONFIG, sc, NULL, 0, 0);
  193 
  194         return (0);
  195 }
  196 
  197 /* Remove a volume. */
  198 void
  199 gv_rm_vol(struct gv_softc *sc, struct gv_volume *v)
  200 {
  201         struct g_provider *pp;
  202         struct gv_plex *p, *p2;
  203 
  204         KASSERT(v != NULL, ("gv_rm_vol: NULL v"));
  205         pp = v->provider;
  206         KASSERT(pp != NULL, ("gv_rm_vol: NULL pp"));
  207 
  208         /* Check if any of our consumers is open. */
  209         if (gv_provider_is_open(pp)) {
  210                 G_VINUM_DEBUG(0, "Unable to remove %s: volume still in use",
  211                     v->name);
  212                 return;
  213         }
  214 
  215         /* Remove the plexes our volume has. */
  216         LIST_FOREACH_SAFE(p, &v->plexes, in_volume, p2)
  217                 gv_rm_plex(sc, p);
  218 
  219         /* Clean up. */
  220         LIST_REMOVE(v, volume);
  221         g_free(v);
  222 
  223         /* Get rid of the volume's provider. */
  224         if (pp != NULL) {
  225                 g_topology_lock();
  226                 pp->flags |= G_PF_WITHER;
  227                 g_orphan_provider(pp, ENXIO);
  228                 g_topology_unlock();
  229         }
  230 }
  231 
  232 /* Remove a plex. */
  233 void
  234 gv_rm_plex(struct gv_softc *sc, struct gv_plex *p)
  235 {
  236         struct gv_volume *v;
  237         struct gv_sd *s, *s2;
  238 
  239         KASSERT(p != NULL, ("gv_rm_plex: NULL p"));
  240         v = p->vol_sc;
  241 
  242         /* Check if any of our consumers is open. */
  243         if (v != NULL && gv_provider_is_open(v->provider) && v->plexcount < 2) {
  244                 G_VINUM_DEBUG(0, "Unable to remove %s: volume still in use",
  245                     p->name);
  246                 return;
  247         }
  248 
  249         /* Remove the subdisks our plex has. */
  250         LIST_FOREACH_SAFE(s, &p->subdisks, in_plex, s2)
  251                 gv_rm_sd(sc, s);
  252 
  253         v = p->vol_sc;
  254         /* Clean up and let our geom fade away. */
  255         LIST_REMOVE(p, plex);
  256         if (p->vol_sc != NULL) {
  257                 p->vol_sc->plexcount--;
  258                 LIST_REMOVE(p, in_volume);
  259                 p->vol_sc = NULL;
  260                 /* Correctly update the volume size. */
  261                 gv_update_vol_size(v, gv_vol_size(v));
  262         }
  263 
  264         g_free(p);
  265 }
  266 
  267 /* Remove a subdisk. */
  268 void
  269 gv_rm_sd(struct gv_softc *sc, struct gv_sd *s)
  270 {
  271         struct gv_plex *p;
  272         struct gv_volume *v;
  273 
  274         KASSERT(s != NULL, ("gv_rm_sd: NULL s"));
  275 
  276         p = s->plex_sc;
  277         v = NULL;
  278 
  279         /* Clean up. */
  280         if (p != NULL) {
  281                 LIST_REMOVE(s, in_plex);
  282                 s->plex_sc = NULL;
  283                 p->sdcount--;
  284                 /* Update the plexsize. */
  285                 p->size = gv_plex_size(p);
  286                 v = p->vol_sc;
  287                 if (v != NULL) {
  288                         /* Update the size of our plex' volume. */
  289                         gv_update_vol_size(v, gv_vol_size(v));
  290                 }
  291         }
  292         if (s->drive_sc && !(s->drive_sc->flags & GV_DRIVE_REFERENCED))
  293                 LIST_REMOVE(s, from_drive);
  294         LIST_REMOVE(s, sd);
  295         gv_free_sd(s);
  296         g_free(s);
  297 }
  298 
  299 /* Remove a drive. */
  300 void
  301 gv_rm_drive(struct gv_softc *sc, struct gv_drive *d, int flags)
  302 {
  303         struct g_consumer *cp;
  304         struct gv_freelist *fl, *fl2;
  305         struct gv_plex *p;
  306         struct gv_sd *s, *s2;
  307         struct gv_volume *v;
  308         struct gv_drive *d2;
  309         int err;
  310 
  311         KASSERT(d != NULL, ("gv_rm_drive: NULL d"));
  312 
  313         cp = d->consumer;
  314 
  315         if (cp != NULL) {
  316                 g_topology_lock();
  317                 err = g_access(cp, 0, 1, 0);
  318                 g_topology_unlock();
  319 
  320                 if (err) {
  321                         G_VINUM_DEBUG(0, "%s: couldn't access '%s', "
  322                             "errno: %d", __func__, cp->provider->name, err);
  323                         return;
  324                 }
  325 
  326                 /* Clear the Vinum Magic. */
  327                 d->hdr->magic = GV_NOMAGIC;
  328                 err = gv_write_header(cp, d->hdr);
  329                 if (err)
  330                         G_VINUM_DEBUG(0, "gv_rm_drive: couldn't write header to"
  331                             " '%s', errno: %d", cp->provider->name, err);
  332 
  333                 g_topology_lock();
  334                 g_access(cp, -cp->acr, -cp->acw, -cp->ace);
  335                 g_detach(cp);
  336                 g_destroy_consumer(cp);
  337                 g_topology_unlock();
  338         }
  339 
  340         /* Remove all associated subdisks, plexes, volumes. */
  341         if (flags & GV_FLAG_R) {
  342                 if (!LIST_EMPTY(&d->subdisks)) {
  343                         LIST_FOREACH_SAFE(s, &d->subdisks, from_drive, s2) {
  344                                 p = s->plex_sc;
  345                                 if (p != NULL) {
  346                                         v = p->vol_sc;
  347                                         if (v != NULL)
  348                                                 gv_rm_vol(sc, v);
  349                                 }
  350                         }
  351                 }
  352         }
  353 
  354         /* Clean up. */
  355         LIST_FOREACH_SAFE(fl, &d->freelist, freelist, fl2) {
  356                 LIST_REMOVE(fl, freelist);
  357                 g_free(fl);
  358         }
  359 
  360         LIST_REMOVE(d, drive);
  361         g_free(d->hdr);
  362 
  363         /* Put ourself into referenced state if we have subdisks. */
  364         if (d->sdcount > 0) {
  365                 d->consumer = NULL;
  366                 d->hdr = NULL;
  367                 d->flags |= GV_DRIVE_REFERENCED;
  368                 snprintf(d->device, sizeof(d->device), "???");
  369                 d->size = 0;
  370                 d->avail = 0;
  371                 d->freelist_entries = 0;
  372                 LIST_FOREACH(s, &d->subdisks, from_drive) {
  373                         s->flags |= GV_SD_TASTED;
  374                         gv_set_sd_state(s, GV_SD_DOWN, GV_SETSTATE_FORCE);
  375                 }
  376                 /* Shuffle around so we keep gv_is_newer happy. */
  377                 LIST_REMOVE(d, drive);
  378                 d2 = LIST_FIRST(&sc->drives);
  379                 if (d2 == NULL)
  380                         LIST_INSERT_HEAD(&sc->drives, d, drive);
  381                 else
  382                         LIST_INSERT_AFTER(d2, d, drive);
  383                 return;
  384         }
  385         g_free(d);
  386 
  387         gv_save_config(sc);
  388 }
Cache object: e107e4e9182c60950e5fb05e6785f01d
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/geom/vinum/geom_vinum_rm.c

FreeBSD/Linux Kernel Cross Reference
sys/geom/vinum/geom_vinum_rm.c
