xref: /freebsd/sys/geom/vinum/geom_vinum_rm.c (revision 1e413cf93298b5b97441a21d9a50fdcd0ee9945e)
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 }
400