2 * Copyright (c) 2004, 2007 Lukas Ertl
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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
28 #include <sys/cdefs.h>
29 __FBSDID("$FreeBSD$");
31 #include <sys/libkern.h>
32 #include <sys/malloc.h>
34 #include <geom/geom.h>
35 #include <geom/vinum/geom_vinum_var.h>
36 #include <geom/vinum/geom_vinum.h>
37 #include <geom/vinum/geom_vinum_share.h>
39 void gv_lvi(struct gv_volume *, struct sbuf *, int);
40 void gv_lpi(struct gv_plex *, struct sbuf *, int);
41 void gv_lsi(struct gv_sd *, struct sbuf *, int);
42 void gv_ldi(struct gv_drive *, struct sbuf *, int);
45 gv_list(struct g_geom *gp, struct gctl_req *req)
53 int *argc, i, *flags, type;
54 char *arg, buf[20], *cmd;
56 argc = gctl_get_paraml(req, "argc", sizeof(*argc));
59 gctl_error(req, "no arguments given");
63 flags = gctl_get_paraml(req, "flags", sizeof(*flags));
65 gctl_error(req, "no flags given");
71 sb = sbuf_new(NULL, NULL, GV_CFG_LEN, SBUF_FIXEDLEN);
73 /* Figure out which command was given. */
74 cmd = gctl_get_param(req, "cmd", NULL);
76 gctl_error(req, "no command given");
80 /* List specific objects or everything. */
81 if (!strcmp(cmd, "list") || !strcmp(cmd, "l")) {
83 for (i = 0; i < *argc; i++) {
84 snprintf(buf, sizeof(buf), "argv%d", i);
85 arg = gctl_get_param(req, buf, NULL);
88 type = gv_object_type(sc, arg);
91 v = gv_find_vol(sc, arg);
92 gv_lvi(v, sb, *flags);
95 p = gv_find_plex(sc, arg);
96 gv_lpi(p, sb, *flags);
99 s = gv_find_sd(sc, arg);
100 gv_lsi(s, sb, *flags);
103 d = gv_find_drive(sc, arg);
104 gv_ldi(d, sb, *flags);
107 gctl_error(req, "unknown object '%s'",
114 sbuf_printf(sb, "\n");
116 sbuf_printf(sb, "\n");
118 sbuf_printf(sb, "\n");
123 } else if (!strcmp(cmd, "ld")) {
125 for (i = 0; i < *argc; i++) {
126 snprintf(buf, sizeof(buf), "argv%d", i);
127 arg = gctl_get_param(req, buf, NULL);
130 type = gv_object_type(sc, arg);
131 if (type != GV_TYPE_DRIVE) {
132 gctl_error(req, "'%s' is not a drive",
136 d = gv_find_drive(sc, arg);
137 gv_ldi(d, sb, *flags);
144 } else if (!strcmp(cmd, "lv")) {
146 for (i = 0; i < *argc; i++) {
147 snprintf(buf, sizeof(buf), "argv%d", i);
148 arg = gctl_get_param(req, buf, NULL);
151 type = gv_object_type(sc, arg);
152 if (type != GV_TYPE_VOL) {
153 gctl_error(req, "'%s' is not a volume",
157 v = gv_find_vol(sc, arg);
158 gv_lvi(v, sb, *flags);
165 } else if (!strcmp(cmd, "lp")) {
167 for (i = 0; i < *argc; i++) {
168 snprintf(buf, sizeof(buf), "argv%d", i);
169 arg = gctl_get_param(req, buf, NULL);
172 type = gv_object_type(sc, arg);
173 if (type != GV_TYPE_PLEX) {
174 gctl_error(req, "'%s' is not a plex",
178 p = gv_find_plex(sc, arg);
179 gv_lpi(p, sb, *flags);
186 } else if (!strcmp(cmd, "ls")) {
188 for (i = 0; i < *argc; i++) {
189 snprintf(buf, sizeof(buf), "argv%d", i);
190 arg = gctl_get_param(req, buf, NULL);
193 type = gv_object_type(sc, arg);
194 if (type != GV_TYPE_SD) {
195 gctl_error(req, "'%s' is not a subdisk",
199 s = gv_find_sd(sc, arg);
200 gv_lsi(s, sb, *flags);
207 gctl_error(req, "unknown command '%s'", cmd);
210 gctl_set_param(req, "config", sbuf_data(sb), sbuf_len(sb) + 1);
214 /* List one or more volumes. */
216 gv_lv(struct g_geom *gp, struct gctl_req *req, struct sbuf *sb)
225 LIST_FOREACH(v, &sc->volumes, volume)
228 sbuf_printf(sb, "%d volume%s:\n", i, i == 1 ? "" : "s");
231 flags = gctl_get_paraml(req, "flags", sizeof(*flags));
232 LIST_FOREACH(v, &sc->volumes, volume)
233 gv_lvi(v, sb, *flags);
237 /* List a single volume. */
239 gv_lvi(struct gv_volume *v, struct sbuf *sb, int flags)
244 if (flags & GV_FLAG_V) {
245 sbuf_printf(sb, "Volume %s:\tSize: %jd bytes (%jd MB)\n",
246 v->name, (intmax_t)v->size, (intmax_t)v->size / MEGABYTE);
247 sbuf_printf(sb, "\t\tState: %s\n", gv_volstate(v->state));
249 sbuf_printf(sb, "V %-21s State: %s\tPlexes: %7d\tSize: %s\n",
250 v->name, gv_volstate(v->state), v->plexcount,
251 gv_roughlength(v->size, 0));
254 if (flags & GV_FLAG_VV) {
256 LIST_FOREACH(p, &v->plexes, in_volume) {
257 sbuf_printf(sb, "\t\tPlex %2d:\t%s\t(%s), %s\n", i,
258 p->name, gv_plexstate(p->state),
259 gv_roughlength(p->size, 0));
264 if (flags & GV_FLAG_R) {
265 LIST_FOREACH(p, &v->plexes, in_volume)
266 gv_lpi(p, sb, flags);
270 /* List one or more plexes. */
272 gv_lp(struct g_geom *gp, struct gctl_req *req, struct sbuf *sb)
281 LIST_FOREACH(p, &sc->plexes, plex)
284 sbuf_printf(sb, "%d plex%s:\n", i, i == 1 ? "" : "es");
287 flags = gctl_get_paraml(req, "flags", sizeof(*flags));
288 LIST_FOREACH(p, &sc->plexes, plex)
289 gv_lpi(p, sb, *flags);
293 /* List a single plex. */
295 gv_lpi(struct gv_plex *p, struct sbuf *sb, int flags)
300 if (flags & GV_FLAG_V) {
301 sbuf_printf(sb, "Plex %s:\tSize:\t%9jd bytes (%jd MB)\n",
302 p->name, (intmax_t)p->size, (intmax_t)p->size / MEGABYTE);
303 sbuf_printf(sb, "\t\tSubdisks: %8d\n", p->sdcount);
304 sbuf_printf(sb, "\t\tState: %s\n", gv_plexstate(p->state));
305 if ((p->flags & GV_PLEX_SYNCING) ||
306 (p->flags & GV_PLEX_GROWING) ||
307 (p->flags & GV_PLEX_REBUILDING)) {
308 sbuf_printf(sb, "\t\tSynced: ");
309 sbuf_printf(sb, "%16jd bytes (%d%%)\n",
311 (p->size > 0) ? (int)((p->synced * 100) / p->size) :
314 sbuf_printf(sb, "\t\tOrganization: %s", gv_plexorg(p->org));
315 if (gv_is_striped(p)) {
316 sbuf_printf(sb, "\tStripe size: %s\n",
317 gv_roughlength(p->stripesize, 1));
319 sbuf_printf(sb, "\t\tFlags: %d\n", p->flags);
320 if (p->vol_sc != NULL) {
321 sbuf_printf(sb, "\t\tPart of volume %s\n", p->volume);
324 sbuf_printf(sb, "P %-18s %2s State: ", p->name,
325 gv_plexorg_short(p->org));
326 if ((p->flags & GV_PLEX_SYNCING) ||
327 (p->flags & GV_PLEX_GROWING) ||
328 (p->flags & GV_PLEX_REBUILDING)) {
329 sbuf_printf(sb, "S %d%%\t", (int)((p->synced * 100) /
332 sbuf_printf(sb, "%s\t", gv_plexstate(p->state));
334 sbuf_printf(sb, "Subdisks: %5d\tSize: %s\n", p->sdcount,
335 gv_roughlength(p->size, 0));
338 if (flags & GV_FLAG_VV) {
340 LIST_FOREACH(s, &p->subdisks, in_plex) {
341 sbuf_printf(sb, "\t\tSubdisk %d:\t%s\n", i, s->name);
342 sbuf_printf(sb, "\t\t state: %s\tsize %11jd "
343 "(%jd MB)\n", gv_sdstate(s->state),
344 (intmax_t)s->size, (intmax_t)s->size / MEGABYTE);
345 if (p->org == GV_PLEX_CONCAT) {
346 sbuf_printf(sb, "\t\t\toffset %9jd (0x%jx)\n",
347 (intmax_t)s->plex_offset,
348 (intmax_t)s->plex_offset);
354 if (flags & GV_FLAG_R) {
355 LIST_FOREACH(s, &p->subdisks, in_plex)
356 gv_lsi(s, sb, flags);
360 /* List one or more subdisks. */
362 gv_ls(struct g_geom *gp, struct gctl_req *req, struct sbuf *sb)
371 LIST_FOREACH(s, &sc->subdisks, sd)
374 sbuf_printf(sb, "%d subdisk%s:\n", i, i == 1 ? "" : "s");
377 flags = gctl_get_paraml(req, "flags", sizeof(*flags));
378 LIST_FOREACH(s, &sc->subdisks, sd)
379 gv_lsi(s, sb, *flags);
383 /* List a single subdisk. */
385 gv_lsi(struct gv_sd *s, struct sbuf *sb, int flags)
387 if (flags & GV_FLAG_V) {
388 sbuf_printf(sb, "Subdisk %s:\n", s->name);
389 sbuf_printf(sb, "\t\tSize: %16jd bytes (%jd MB)\n",
390 (intmax_t)s->size, (intmax_t)s->size / MEGABYTE);
391 sbuf_printf(sb, "\t\tState: %s\n", gv_sdstate(s->state));
393 if (s->state == GV_SD_INITIALIZING ||
394 s->state == GV_SD_REVIVING) {
395 if (s->state == GV_SD_INITIALIZING)
396 sbuf_printf(sb, "\t\tInitialized: ");
398 sbuf_printf(sb, "\t\tRevived: ");
400 sbuf_printf(sb, "%16jd bytes (%d%%)\n",
401 (intmax_t)s->initialized,
402 (int)((s->initialized * 100) / s->size));
405 if (s->plex_sc != NULL) {
406 sbuf_printf(sb, "\t\tPlex %s at offset %jd (%s)\n",
407 s->plex, (intmax_t)s->plex_offset,
408 gv_roughlength(s->plex_offset, 1));
411 sbuf_printf(sb, "\t\tDrive %s (%s) at offset %jd (%s)\n",
413 s->drive_sc == NULL ? "*missing*" : s->drive_sc->name,
414 (intmax_t)s->drive_offset,
415 gv_roughlength(s->drive_offset, 1));
416 sbuf_printf(sb, "\t\tFlags: %d\n", s->flags);
418 sbuf_printf(sb, "S %-21s State: ", s->name);
419 if (s->state == GV_SD_INITIALIZING ||
420 s->state == GV_SD_REVIVING) {
421 if (s->state == GV_SD_INITIALIZING)
422 sbuf_printf(sb, "I ");
424 sbuf_printf(sb, "R ");
425 sbuf_printf(sb, "%d%%\t",
426 (int)((s->initialized * 100) / s->size));
428 sbuf_printf(sb, "%s\t", gv_sdstate(s->state));
430 sbuf_printf(sb, "D: %-12s Size: %s\n", s->drive,
431 gv_roughlength(s->size, 0));
435 /* List one or more drives. */
437 gv_ld(struct g_geom *gp, struct gctl_req *req, struct sbuf *sb)
446 LIST_FOREACH(d, &sc->drives, drive)
449 sbuf_printf(sb, "%d drive%s:\n", i, i == 1 ? "" : "s");
452 flags = gctl_get_paraml(req, "flags", sizeof(*flags));
453 LIST_FOREACH(d, &sc->drives, drive)
454 gv_ldi(d, sb, *flags);
458 /* List a single drive. */
460 gv_ldi(struct gv_drive *d, struct sbuf *sb, int flags)
462 struct gv_freelist *fl;
465 /* Verbose listing. */
466 if (flags & GV_FLAG_V) {
467 sbuf_printf(sb, "Drive %s:\tDevice %s\n", d->name, d->device);
468 sbuf_printf(sb, "\t\tSize: %16jd bytes (%jd MB)\n",
469 (intmax_t)d->size, (intmax_t)d->size / MEGABYTE);
470 sbuf_printf(sb, "\t\tUsed: %16jd bytes (%jd MB)\n",
471 (intmax_t)d->size - d->avail,
472 (intmax_t)(d->size - d->avail) / MEGABYTE);
473 sbuf_printf(sb, "\t\tAvailable: %11jd bytes (%jd MB)\n",
474 (intmax_t)d->avail, (intmax_t)d->avail / MEGABYTE);
475 sbuf_printf(sb, "\t\tState: %s\n", gv_drivestate(d->state));
476 sbuf_printf(sb, "\t\tFlags: %d\n", d->flags);
478 /* Be very verbose. */
479 if (flags & GV_FLAG_VV) {
480 sbuf_printf(sb, "\t\tFree list contains %d entries:\n",
481 d->freelist_entries);
482 sbuf_printf(sb, "\t\t Offset\t Size\n");
483 LIST_FOREACH(fl, &d->freelist, freelist)
484 sbuf_printf(sb, "\t\t%9jd\t%9jd\n",
485 (intmax_t)fl->offset, (intmax_t)fl->size);
488 sbuf_printf(sb, "D %-21s State: %s\t/dev/%s\tA: %jd/%jd MB "
489 "(%d%%)\n", d->name, gv_drivestate(d->state), d->device,
490 (intmax_t)d->avail / MEGABYTE, (intmax_t)d->size / MEGABYTE,
491 d->size > 0 ? (int)((d->avail * 100) / d->size) : 0);
494 /* Recursive listing. */
495 if (flags & GV_FLAG_R) {
496 LIST_FOREACH(s, &d->subdisks, from_drive)
497 gv_lsi(s, sb, flags);