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