2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Copyright (c) 2007 Lukas Ertl
5 * Copyright (c) 2007, 2009 Ulf Lilleengen
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD$");
33 #include <sys/param.h>
37 #include <sys/kernel.h>
38 #include <sys/malloc.h>
39 #include <sys/systm.h>
41 #include <geom/geom.h>
42 #include <geom/geom_dbg.h>
43 #include <geom/vinum/geom_vinum_var.h>
44 #include <geom/vinum/geom_vinum.h>
46 #define DEFAULT_STRIPESIZE 262144
49 * Create a new drive object, either by user request, during taste of the drive
50 * itself, or because it was referenced by a subdisk during taste.
53 gv_create_drive(struct gv_softc *sc, struct gv_drive *d)
56 struct g_provider *pp;
57 struct g_consumer *cp, *cp2;
60 struct gv_freelist *fl;
62 KASSERT(d != NULL, ("gv_create_drive: NULL d"));
69 /* The drive already has a consumer if it was tasted before. */
70 if (d->consumer != NULL) {
74 } else if (!(d->flags & GV_DRIVE_REFERENCED)) {
75 if (gv_find_drive(sc, d->name) != NULL) {
76 G_VINUM_DEBUG(0, "drive '%s' already exists", d->name);
78 return (GV_ERR_CREATE);
81 if (gv_find_drive_device(sc, d->device) != NULL) {
82 G_VINUM_DEBUG(0, "provider '%s' already in use by "
84 return (GV_ERR_CREATE);
87 pp = g_provider_by_name(d->device);
89 G_VINUM_DEBUG(0, "create '%s': device '%s' disappeared",
92 return (GV_ERR_CREATE);
96 cp = g_new_consumer(gp);
97 if (g_attach(cp, pp) != 0) {
98 g_destroy_consumer(cp);
100 G_VINUM_DEBUG(0, "create drive '%s': unable to attach",
103 return (GV_ERR_CREATE);
112 * If this was just a "referenced" drive, we're almost finished, but
113 * insert this drive not on the head of the drives list, as
114 * gv_drive_is_newer() expects a "real" drive from LIST_FIRST().
116 if (d->flags & GV_DRIVE_REFERENCED) {
117 snprintf(d->device, sizeof(d->device), "???");
118 d2 = LIST_FIRST(&sc->drives);
120 LIST_INSERT_HEAD(&sc->drives, d, drive);
122 LIST_INSERT_AFTER(d2, d, drive);
127 * Update access counts of the new drive to those of an already
130 LIST_FOREACH(d2, &sc->drives, drive) {
131 if ((d == d2) || (d2->consumer == NULL))
136 if ((cp2->acr || cp2->acw || cp2->ace) &&
137 (g_access(cp, cp2->acr, cp2->acw, cp2->ace) != 0)) {
139 g_destroy_consumer(cp);
141 G_VINUM_DEBUG(0, "create drive '%s': unable to update "
142 "access counts", d->name);
146 return (GV_ERR_CREATE);
152 d->size = pp->mediasize - GV_DATA_START;
155 LIST_INIT(&d->subdisks);
156 LIST_INIT(&d->freelist);
158 /* The header might have been set during taste. */
159 if (d->hdr == NULL) {
160 hdr = g_malloc(sizeof(*hdr), M_WAITOK | M_ZERO);
161 hdr->magic = GV_MAGIC;
162 hdr->config_length = GV_CFG_LEN;
163 getcredhostname(NULL, hdr->label.sysname, GV_HOSTNAME_LEN);
164 strlcpy(hdr->label.name, d->name, sizeof(hdr->label.name));
165 microtime(&hdr->label.date_of_birth);
169 /* We also need a freelist entry. */
170 fl = g_malloc(sizeof(struct gv_freelist), M_WAITOK | M_ZERO);
171 fl->offset = GV_DATA_START;
173 LIST_INSERT_HEAD(&d->freelist, fl, freelist);
174 d->freelist_entries = 1;
176 if (gv_find_drive(sc, d->name) == NULL)
177 LIST_INSERT_HEAD(&sc->drives, d, drive);
179 gv_set_drive_state(d, GV_DRIVE_UP, 0);
184 gv_create_volume(struct gv_softc *sc, struct gv_volume *v)
186 KASSERT(v != NULL, ("gv_create_volume: NULL v"));
189 v->flags |= GV_VOL_NEWBORN;
190 LIST_INIT(&v->plexes);
191 LIST_INSERT_HEAD(&sc->volumes, v, volume);
192 v->wqueue = g_malloc(sizeof(struct bio_queue_head), M_WAITOK | M_ZERO);
193 bioq_init(v->wqueue);
198 gv_create_plex(struct gv_softc *sc, struct gv_plex *p)
202 KASSERT(p != NULL, ("gv_create_plex: NULL p"));
204 /* Find the volume this plex should be attached to. */
205 v = gv_find_vol(sc, p->volume);
207 G_VINUM_DEBUG(0, "create plex '%s': volume '%s' not found",
210 return (GV_ERR_CREATE);
212 if (!(v->flags & GV_VOL_NEWBORN))
213 p->flags |= GV_PLEX_ADDED;
218 p->flags |= GV_PLEX_NEWBORN;
219 LIST_INSERT_HEAD(&v->plexes, p, in_volume);
220 LIST_INIT(&p->subdisks);
221 TAILQ_INIT(&p->packets);
222 LIST_INSERT_HEAD(&sc->plexes, p, plex);
223 p->bqueue = g_malloc(sizeof(struct bio_queue_head), M_WAITOK | M_ZERO);
224 bioq_init(p->bqueue);
225 p->wqueue = g_malloc(sizeof(struct bio_queue_head), M_WAITOK | M_ZERO);
226 bioq_init(p->wqueue);
227 p->rqueue = g_malloc(sizeof(struct bio_queue_head), M_WAITOK | M_ZERO);
228 bioq_init(p->rqueue);
233 gv_create_sd(struct gv_softc *sc, struct gv_sd *s)
238 KASSERT(s != NULL, ("gv_create_sd: NULL s"));
240 /* Find the drive where this subdisk should be put on. */
241 d = gv_find_drive(sc, s->drive);
244 * It's possible that the subdisk references a drive that
245 * doesn't exist yet (during the taste process), so create a
246 * practically empty "referenced" drive.
248 if (s->flags & GV_SD_TASTED) {
249 d = g_malloc(sizeof(struct gv_drive),
251 d->flags |= GV_DRIVE_REFERENCED;
252 strlcpy(d->name, s->drive, sizeof(d->name));
253 gv_create_drive(sc, d);
255 G_VINUM_DEBUG(0, "create sd '%s': drive '%s' not found",
258 return (GV_ERR_CREATE);
262 /* Find the plex where this subdisk belongs to. */
263 p = gv_find_plex(sc, s->plex);
265 G_VINUM_DEBUG(0, "create sd '%s': plex '%s' not found",
268 return (GV_ERR_CREATE);
272 * First we give the subdisk to the drive, to handle autosized
275 if (gv_sd_to_drive(s, d) != 0) {
277 return (GV_ERR_CREATE);
281 * Then, we give the subdisk to the plex; we check if the
282 * given values are correct and maybe adjust them.
284 if (gv_sd_to_plex(s, p) != 0) {
285 G_VINUM_DEBUG(0, "unable to give sd '%s' to plex '%s'",
287 if (s->drive_sc && !(s->drive_sc->flags & GV_DRIVE_REFERENCED))
288 LIST_REMOVE(s, from_drive);
292 * If this subdisk can't be created, we won't create
293 * the attached plex either, if it is also a new one.
295 if (!(p->flags & GV_PLEX_NEWBORN))
296 return (GV_ERR_CREATE);
298 return (GV_ERR_CREATE);
300 s->flags |= GV_SD_NEWBORN;
303 LIST_INSERT_HEAD(&sc->subdisks, s, sd);
309 * Create a concatenated volume from specified drives or drivegroups.
312 gv_concat(struct g_geom *gp, struct gctl_req *req)
319 char *drive, buf[30], *vol;
324 vol = gctl_get_param(req, "name", NULL);
326 gctl_error(req, "volume name not given");
330 drives = gctl_get_paraml(req, "drives", sizeof(*drives));
332 if (drives == NULL) {
333 gctl_error(req, "drive names not given");
337 /* First we create the volume. */
338 v = g_malloc(sizeof(*v), M_WAITOK | M_ZERO);
339 strlcpy(v->name, vol, sizeof(v->name));
340 v->state = GV_VOL_UP;
341 gv_post_event(sc, GV_EVENT_CREATE_VOLUME, v, NULL, 0, 0);
343 /* Then we create the plex. */
344 p = g_malloc(sizeof(*p), M_WAITOK | M_ZERO);
345 snprintf(p->name, sizeof(p->name), "%s.p%d", v->name, v->plexcount);
346 strlcpy(p->volume, v->name, sizeof(p->volume));
347 p->org = GV_PLEX_CONCAT;
349 gv_post_event(sc, GV_EVENT_CREATE_PLEX, p, NULL, 0, 0);
351 /* Drives are first (right now) priority */
352 for (dcount = 0; dcount < *drives; dcount++) {
353 snprintf(buf, sizeof(buf), "drive%d", dcount);
354 drive = gctl_get_param(req, buf, NULL);
355 d = gv_find_drive(sc, drive);
357 gctl_error(req, "No such drive '%s'", drive);
360 s = g_malloc(sizeof(*s), M_WAITOK | M_ZERO);
361 snprintf(s->name, sizeof(s->name), "%s.s%d", p->name, dcount);
362 strlcpy(s->plex, p->name, sizeof(s->plex));
363 strlcpy(s->drive, drive, sizeof(s->drive));
365 s->drive_offset = -1;
367 gv_post_event(sc, GV_EVENT_CREATE_SD, s, NULL, 0, 0);
369 gv_post_event(sc, GV_EVENT_SETUP_OBJECTS, sc, NULL, 0, 0);
370 gv_post_event(sc, GV_EVENT_SAVE_CONFIG, sc, NULL, 0, 0);
374 * Create a mirrored volume from specified drives or drivegroups.
377 gv_mirror(struct g_geom *gp, struct gctl_req *req)
384 char *drive, buf[30], *vol;
385 int *drives, *flags, dcount, pcount, scount;
391 vol = gctl_get_param(req, "name", NULL);
393 gctl_error(req, "volume name not given");
397 flags = gctl_get_paraml(req, "flags", sizeof(*flags));
398 drives = gctl_get_paraml(req, "drives", sizeof(*drives));
400 if (drives == NULL) {
401 gctl_error(req, "drive names not given");
405 /* We must have an even number of drives. */
406 if (*drives % 2 != 0) {
407 gctl_error(req, "mirror organization must have an even number "
411 if (*flags & GV_FLAG_S && *drives < 4) {
412 gctl_error(req, "must have at least 4 drives for striped plex");
416 /* First we create the volume. */
417 v = g_malloc(sizeof(*v), M_WAITOK | M_ZERO);
418 strlcpy(v->name, vol, sizeof(v->name));
419 v->state = GV_VOL_UP;
420 gv_post_event(sc, GV_EVENT_CREATE_VOLUME, v, NULL, 0, 0);
422 /* Then we create the plexes. */
423 for (pcount = 0; pcount < 2; pcount++) {
424 p = g_malloc(sizeof(*p), M_WAITOK | M_ZERO);
425 snprintf(p->name, sizeof(p->name), "%s.p%d", v->name,
427 strlcpy(p->volume, v->name, sizeof(p->volume));
428 if (*flags & GV_FLAG_S) {
429 p->org = GV_PLEX_STRIPED;
430 p->stripesize = DEFAULT_STRIPESIZE;
432 p->org = GV_PLEX_CONCAT;
435 gv_post_event(sc, GV_EVENT_CREATE_PLEX, p, NULL, 0, 0);
438 * We just gives each even drive to plex one, and each odd to
442 for (dcount = pcount; dcount < *drives; dcount += 2) {
443 snprintf(buf, sizeof(buf), "drive%d", dcount);
444 drive = gctl_get_param(req, buf, NULL);
445 d = gv_find_drive(sc, drive);
447 gctl_error(req, "No such drive '%s', aborting",
452 s = g_malloc(sizeof(*s), M_WAITOK | M_ZERO);
453 snprintf(s->name, sizeof(s->name), "%s.s%d", p->name,
455 strlcpy(s->plex, p->name, sizeof(s->plex));
456 strlcpy(s->drive, drive, sizeof(s->drive));
458 s->drive_offset = -1;
460 gv_post_event(sc, GV_EVENT_CREATE_SD, s, NULL, 0, 0);
464 gv_post_event(sc, GV_EVENT_SETUP_OBJECTS, sc, NULL, 0, 0);
465 gv_post_event(sc, GV_EVENT_SAVE_CONFIG, sc, NULL, 0, 0);
469 gv_raid5(struct g_geom *gp, struct gctl_req *req)
476 int *drives, *flags, dcount;
477 char *vol, *drive, buf[30];
482 vol = gctl_get_param(req, "name", NULL);
484 gctl_error(req, "volume name not given");
487 flags = gctl_get_paraml(req, "flags", sizeof(*flags));
488 drives = gctl_get_paraml(req, "drives", sizeof(*drives));
489 stripesize = gctl_get_paraml(req, "stripesize", sizeof(*stripesize));
491 if (stripesize == NULL) {
492 gctl_error(req, "no stripesize given");
496 if (drives == NULL) {
497 gctl_error(req, "drive names not given");
501 /* We must have at least three drives. */
503 gctl_error(req, "must have at least three drives for this "
504 "plex organisation");
507 /* First we create the volume. */
508 v = g_malloc(sizeof(*v), M_WAITOK | M_ZERO);
509 strlcpy(v->name, vol, sizeof(v->name));
510 v->state = GV_VOL_UP;
511 gv_post_event(sc, GV_EVENT_CREATE_VOLUME, v, NULL, 0, 0);
513 /* Then we create the plex. */
514 p = g_malloc(sizeof(*p), M_WAITOK | M_ZERO);
515 snprintf(p->name, sizeof(p->name), "%s.p%d", v->name, v->plexcount);
516 strlcpy(p->volume, v->name, sizeof(p->volume));
517 p->org = GV_PLEX_RAID5;
518 p->stripesize = *stripesize;
519 gv_post_event(sc, GV_EVENT_CREATE_PLEX, p, NULL, 0, 0);
521 /* Create subdisks on drives. */
522 for (dcount = 0; dcount < *drives; dcount++) {
523 snprintf(buf, sizeof(buf), "drive%d", dcount);
524 drive = gctl_get_param(req, buf, NULL);
525 d = gv_find_drive(sc, drive);
527 gctl_error(req, "No such drive '%s'", drive);
530 s = g_malloc(sizeof(*s), M_WAITOK | M_ZERO);
531 snprintf(s->name, sizeof(s->name), "%s.s%d", p->name, dcount);
532 strlcpy(s->plex, p->name, sizeof(s->plex));
533 strlcpy(s->drive, drive, sizeof(s->drive));
535 s->drive_offset = -1;
537 gv_post_event(sc, GV_EVENT_CREATE_SD, s, NULL, 0, 0);
539 gv_post_event(sc, GV_EVENT_SETUP_OBJECTS, sc, NULL, 0, 0);
540 gv_post_event(sc, GV_EVENT_SAVE_CONFIG, sc, NULL, 0, 0);
544 * Create a striped volume from specified drives or drivegroups.
547 gv_stripe(struct g_geom *gp, struct gctl_req *req)
554 char *drive, buf[30], *vol;
555 int *drives, *flags, dcount, pcount;
560 vol = gctl_get_param(req, "name", NULL);
562 gctl_error(req, "volume name not given");
565 flags = gctl_get_paraml(req, "flags", sizeof(*flags));
566 drives = gctl_get_paraml(req, "drives", sizeof(*drives));
568 if (drives == NULL) {
569 gctl_error(req, "drive names not given");
573 /* We must have at least two drives. */
575 gctl_error(req, "must have at least 2 drives");
579 /* First we create the volume. */
580 v = g_malloc(sizeof(*v), M_WAITOK | M_ZERO);
581 strlcpy(v->name, vol, sizeof(v->name));
582 v->state = GV_VOL_UP;
583 gv_post_event(sc, GV_EVENT_CREATE_VOLUME, v, NULL, 0, 0);
585 /* Then we create the plex. */
586 p = g_malloc(sizeof(*p), M_WAITOK | M_ZERO);
587 snprintf(p->name, sizeof(p->name), "%s.p%d", v->name, v->plexcount);
588 strlcpy(p->volume, v->name, sizeof(p->volume));
589 p->org = GV_PLEX_STRIPED;
590 p->stripesize = 262144;
591 gv_post_event(sc, GV_EVENT_CREATE_PLEX, p, NULL, 0, 0);
593 /* Create subdisks on drives. */
594 for (dcount = 0; dcount < *drives; dcount++) {
595 snprintf(buf, sizeof(buf), "drive%d", dcount);
596 drive = gctl_get_param(req, buf, NULL);
597 d = gv_find_drive(sc, drive);
599 gctl_error(req, "No such drive '%s'", drive);
602 s = g_malloc(sizeof(*s), M_WAITOK | M_ZERO);
603 snprintf(s->name, sizeof(s->name), "%s.s%d", p->name, dcount);
604 strlcpy(s->plex, p->name, sizeof(s->plex));
605 strlcpy(s->drive, drive, sizeof(s->drive));
607 s->drive_offset = -1;
609 gv_post_event(sc, GV_EVENT_CREATE_SD, s, NULL, 0, 0);
611 gv_post_event(sc, GV_EVENT_SETUP_OBJECTS, sc, NULL, 0, 0);
612 gv_post_event(sc, GV_EVENT_SAVE_CONFIG, sc, NULL, 0, 0);