sys/geom/vinum/geom_vinum_rm.c

   1 /*-
   2  *  Copyright (c) 2004 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$");
  30
  31 #include <sys/param.h>
  32 #include <sys/libkern.h>
  33 #include <sys/kernel.h>
  34 #include <sys/malloc.h>
  35
  36 #include <geom/geom.h>
  37 #include <geom/vinum/geom_vinum_var.h>
  38 #include <geom/vinum/geom_vinum.h>
  39 #include <geom/vinum/geom_vinum_share.h>
  40
  41 static int      gv_rm_drive(struct gv_softc *, struct gctl_req *,
  42                     struct gv_drive *, int);
  43 static int      gv_rm_plex(struct gv_softc *, struct gctl_req *,
  44                     struct gv_plex *, int);
  45 static int      gv_rm_vol(struct gv_softc *, struct gctl_req *,
  46                     struct gv_volume *, int);
  47
  48 /* General 'remove' routine. */
  49 void
  50 gv_remove(struct g_geom *gp, struct gctl_req *req)
  51 {
  52         struct gv_softc *sc;
  53         struct gv_volume *v;
  54         struct gv_plex *p;
  55         struct gv_sd *s;
  56         struct gv_drive *d;
  57         int *argc, *flags;
  58         char *argv, buf[20];
  59         int i, type, err;
  60
  61         argc = gctl_get_paraml(req, "argc", sizeof(*argc));
  62         flags = gctl_get_paraml(req, "flags", sizeof(*flags));
  63
  64         if (argc == NULL || *argc == 0) {
  65                 gctl_error(req, "no arguments given");
  66                 return;
  67         }
  68
  69         sc = gp->softc;
  70
  71         for (i = 0; i < *argc; i++) {
  72                 snprintf(buf, sizeof(buf), "argv%d", i);
  73                 argv = gctl_get_param(req, buf, NULL);
  74                 if (argv == NULL)
  75                         continue;
  76                 type = gv_object_type(sc, argv);
  77                 switch (type) {
  78                 case GV_TYPE_VOL:
  79                         v = gv_find_vol(sc, argv);
  80                         if (v == NULL) {
  81                                 gctl_error(req, "unknown volume '%s'", argv);
  82                                 return;
  83                         }
  84                         err = gv_rm_vol(sc, req, v, *flags);
  85                         if (err)
  86                                 return;
  87                         break;
  88                 case GV_TYPE_PLEX:
  89                         p = gv_find_plex(sc, argv);
  90                         if (p == NULL) {
  91                                 gctl_error(req, "unknown plex '%s'", argv);
  92                                 return;
  93                         }
  94                         err = gv_rm_plex(sc, req, p, *flags);
  95                         if (err)
  96                                 return;
  97                         break;
  98                 case GV_TYPE_SD:
  99                         s = gv_find_sd(sc, argv);
 100                         if (s == NULL) {
 101                                 gctl_error(req, "unknown subdisk '%s'", argv);
 102                                 return;
 103                         }
 104                         err = gv_rm_sd(sc, req, s, *flags);
 105                         if (err)
 106                                 return;
 107                         break;
 108                 case GV_TYPE_DRIVE:
 109                         d = gv_find_drive(sc, argv);
 110                         if (d == NULL) {
 111                                 gctl_error(req, "unknown drive '%s'", argv);
 112                                 return;
 113                         }
 114                         err = gv_rm_drive(sc, req, d, *flags);
 115                         if (err)
 116                                 return;
 117                         break;
 118                 default:
 119                         gctl_error(req, "unknown object '%s'", argv);
 120                         return;
 121                 }
 122         }
 123
 124         gv_save_config_all(sc);
 125 }
 126
 127 /* Resets configuration */
 128 int
 129 gv_resetconfig(struct g_geom *gp, struct gctl_req *req)
 130 {
 131         struct gv_softc *sc;
 132         struct gv_drive *d, *d2;
 133         struct gv_volume *v, *v2;
 134         struct gv_plex *p, *p2;
 135         struct gv_sd *s, *s2;
 136         int flags;
 137
 138         d = NULL;
 139         d2 = NULL;
 140         p = NULL;
 141         p2 = NULL;
 142         s = NULL;
 143         s2 = NULL;
 144         flags = GV_FLAG_R;
 145         sc = gp->softc;
 146         /* First loop through to make sure no volumes are up */
 147         LIST_FOREACH_SAFE(v, &sc->volumes, volume, v2) {
 148                 if (gv_is_open(v->geom)) {
 149                         gctl_error(req, "volume '%s' is busy", v->name);
 150                         return (-1);
 151                 }
 152         }
 153         /* Then if not, we remove everything. */
 154         LIST_FOREACH_SAFE(v, &sc->volumes, volume, v2)
 155                 gv_rm_vol(sc, req, v, flags);
 156         LIST_FOREACH_SAFE(p, &sc->plexes, plex, p2)
 157                 gv_rm_plex(sc, req, p, flags);
 158         LIST_FOREACH_SAFE(s, &sc->subdisks, sd, s2)
 159                 gv_rm_sd(sc, req, s, flags);
 160         LIST_FOREACH_SAFE(d, &sc->drives, drive, d2)
 161                 gv_rm_drive(sc, req, d, flags);
 162         gv_save_config_all(sc);
 163         return (0);
 164 }
 165
 166 /* Remove a volume. */
 167 static int
 168 gv_rm_vol(struct gv_softc *sc, struct gctl_req *req, struct gv_volume *v, int flags)
 169 {
 170         struct g_geom *gp;
 171         struct gv_plex *p, *p2;
 172         int err;
 173
 174         g_topology_assert();
 175         KASSERT(v != NULL, ("gv_rm_vol: NULL v"));
 176
 177         /* If this volume has plexes, we want a recursive removal. */
 178         if (!LIST_EMPTY(&v->plexes) && !(flags & GV_FLAG_R)) {
 179                 gctl_error(req, "volume '%s' has attached plexes", v->name);
 180                 return (-1);
 181         }
 182
 183         gp = v->geom;
 184
 185         /* Check if any of our consumers is open. */
 186         if (gp != NULL && gv_is_open(gp)) {
 187                 gctl_error(req, "volume '%s' is busy", v->name);
 188                 return (-1);
 189         }
 190
 191         /* Remove the plexes our volume has. */
 192         LIST_FOREACH_SAFE(p, &v->plexes, in_volume, p2) {
 193                 v->plexcount--;
 194                 LIST_REMOVE(p, in_volume);
 195                 p->vol_sc = NULL;
 196
 197                 err = gv_rm_plex(sc, req, p, flags);
 198                 if (err)
 199                         return (err);
 200         }
 201
 202         /* Clean up and let our geom fade away. */
 203         LIST_REMOVE(v, volume);
 204         gv_kill_vol_thread(v);
 205         g_free(v);
 206         if (gp != NULL) {
 207                 gp->softc = NULL;
 208                 g_wither_geom(gp, ENXIO);
 209         }
 210
 211         return (0);
 212 }
 213
 214 /* Remove a plex. */
 215 static int
 216 gv_rm_plex(struct gv_softc *sc, struct gctl_req *req, struct gv_plex *p, int flags)
 217 {
 218         struct g_geom *gp;
 219         struct gv_volume *v;
 220         struct gv_sd *s, *s2;
 221         int err;
 222
 223         g_topology_assert();
 224
 225         KASSERT(p != NULL, ("gv_rm_plex: NULL p"));
 226
 227         /* If this plex has subdisks, we want a recursive removal. */
 228         if (!LIST_EMPTY(&p->subdisks) && !(flags & GV_FLAG_R)) {
 229                 gctl_error(req, "plex '%s' has attached subdisks", p->name);
 230                 return (-1);
 231         }
 232
 233         if (p->vol_sc != NULL && p->vol_sc->plexcount == 1) {
 234                 gctl_error(req, "plex '%s' is still attached to volume '%s'",
 235                     p->name, p->volume);
 236                 return (-1);
 237         }
 238
 239         gp = p->geom;
 240
 241         /* Check if any of our consumers is open. */
 242         if (gp != NULL && gv_is_open(gp)) {
 243                 gctl_error(req, "plex '%s' is busy", p->name);
 244                 return (-1);
 245         }
 246
 247         /* Remove the subdisks our plex has. */
 248         LIST_FOREACH_SAFE(s, &p->subdisks, in_plex, s2) {
 249 #if 0
 250                 LIST_REMOVE(s, in_plex);
 251                 s->plex_sc = NULL;
 252 #endif
 253
 254                 err = gv_rm_sd(sc, req, s, flags);
 255                 if (err)
 256                         return (err);
 257         }
 258
 259         v = p->vol_sc;
 260         /* Clean up and let our geom fade away. */
 261         LIST_REMOVE(p, plex);
 262         if (p->vol_sc != NULL) {
 263                 p->vol_sc->plexcount--;
 264                 LIST_REMOVE(p, in_volume);
 265                 p->vol_sc = NULL;
 266                 /* Correctly update the volume size. */
 267                 gv_update_vol_size(v, gv_vol_size(v));
 268         }
 269
 270         gv_kill_plex_thread(p);
 271         g_free(p);
 272
 273         if (gp != NULL) {
 274                 gp->softc = NULL;
 275                 g_wither_geom(gp, ENXIO);
 276         }
 277
 278         return (0);
 279 }
 280
 281 /* Remove a subdisk. */
 282 int
 283 gv_rm_sd(struct gv_softc *sc, struct gctl_req *req, struct gv_sd *s, int flags)
 284 {
 285         struct g_provider *pp;
 286         struct gv_plex *p;
 287         struct gv_volume *v;
 288
 289         KASSERT(s != NULL, ("gv_rm_sd: NULL s"));
 290
 291         pp = s->provider;
 292         p = s->plex_sc;
 293         v = NULL;
 294
 295         /* Clean up. */
 296         if (p != NULL) {
 297                 LIST_REMOVE(s, in_plex);
 298
 299                 p->sdcount--;
 300                 /* Update the plexsize. */
 301                 p->size = gv_plex_size(p);
 302                 v = p->vol_sc;
 303                 if (v != NULL) {
 304                         /* Update the size of our plex' volume. */
 305                         gv_update_vol_size(v, gv_vol_size(v));
 306                 }
 307         }
 308         if (s->drive_sc)
 309                 LIST_REMOVE(s, from_drive);
 310         LIST_REMOVE(s, sd);
 311         gv_free_sd(s);
 312         g_free(s);
 313
 314         /* If the subdisk has a provider we need to clean up this one too. */
 315         if (pp != NULL) {
 316                 pp->flags |= G_PF_WITHER;
 317                 g_orphan_provider(pp, ENXIO);
 318         }
 319
 320         return (0);
 321 }
 322
 323 /* Remove a drive. */
 324 static int
 325 gv_rm_drive(struct gv_softc *sc, struct gctl_req *req, struct gv_drive *d, int flags)
 326 {
 327         struct g_geom *gp;
 328         struct g_consumer *cp;
 329         struct gv_freelist *fl, *fl2;
 330         struct gv_plex *p;
 331         struct gv_sd *s, *s2;
 332         struct gv_volume *v;
 333         int err;
 334
 335         KASSERT(d != NULL, ("gv_rm_drive: NULL d"));
 336         gp = d->geom;
 337         KASSERT(gp != NULL, ("gv_rm_drive: NULL gp"));
 338
 339         /* We don't allow to remove open drives. */
 340         if (gv_is_open(gp)) {
 341                 gctl_error(req, "drive '%s' is open", d->name);
 342                 return (-1);
 343         }
 344
 345         /* A drive with subdisks needs a recursive removal. */
 346         if (!LIST_EMPTY(&d->subdisks) && !(flags & GV_FLAG_R)) {
 347                 gctl_error(req, "drive '%s' still has subdisks", d->name);
 348                 return (-1);
 349         }
 350
 351         cp = LIST_FIRST(&gp->consumer);
 352         err = g_access(cp, 0, 1, 0);
 353         if (err) {
 354                 printf("GEOM_VINUM: gv_rm_drive: couldn't access '%s', errno: "
 355                     "%d\n", cp->provider->name, err);
 356                 return (err);
 357         }
 358
 359         /* Clear the Vinum Magic. */
 360         d->hdr->magic = GV_NOMAGIC;
 361         g_topology_unlock();
 362         err = g_write_data(cp, GV_HDR_OFFSET, d->hdr, GV_HDR_LEN);
 363         if (err) {
 364                 printf("GEOM_VINUM: gv_rm_drive: couldn't write header to '%s'"
 365                     ", errno: %d\n", cp->provider->name, err);
 366                 d->hdr->magic = GV_MAGIC;
 367         }
 368         g_topology_lock();
 369         g_access(cp, 0, -1, 0);
 370
 371         /* Remove all associated subdisks, plexes, volumes. */
 372         if (!LIST_EMPTY(&d->subdisks)) {
 373                 LIST_FOREACH_SAFE(s, &d->subdisks, from_drive, s2) {
 374                         p = s->plex_sc;
 375                         if (p != NULL) {
 376                                 v = p->vol_sc;
 377                                 if (v != NULL)
 378                                         gv_rm_vol(sc, req, v, flags);
 379                         }
 380                 }
 381         }
 382
 383         /* Clean up. */
 384         LIST_FOREACH_SAFE(fl, &d->freelist, freelist, fl2) {
 385                 LIST_REMOVE(fl, freelist);
 386                 g_free(fl);
 387         }
 388         LIST_REMOVE(d, drive);
 389
 390         gv_kill_drive_thread(d);
 391         gp = d->geom;
 392         d->geom = NULL;
 393         g_free(d->hdr);
 394         g_free(d);
 395         gv_save_config_all(sc);
 396         g_wither_geom(gp, ENXIO);
 397
 398         return (err);
 399 }