2 * Copyright (c) 2007, 2008 Marcel Moolenaar
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 THE AUTHORS 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 THE AUTHORS 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
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
51 #include "core/geom.h"
52 #include "misc/subr.h"
54 #ifdef STATIC_GEOM_CLASSES
55 #define PUBSYM(x) gpart_##x
60 uint32_t PUBSYM(lib_version) = G_LIB_VERSION;
61 uint32_t PUBSYM(version) = 0;
63 static char sstart[32];
64 static char ssize[32];
65 volatile sig_atomic_t undo_restore;
67 #define GPART_AUTOFILL "*"
68 #define GPART_FLAGS "C"
70 #define GPART_PARAM_BOOTCODE "bootcode"
71 #define GPART_PARAM_INDEX "index"
72 #define GPART_PARAM_PARTCODE "partcode"
74 static struct gclass *find_class(struct gmesh *, const char *);
75 static struct ggeom * find_geom(struct gclass *, const char *);
76 static const char *find_geomcfg(struct ggeom *, const char *);
77 static const char *find_provcfg(struct gprovider *, const char *);
78 static struct gprovider *find_provider(struct ggeom *, off_t);
79 static const char *fmtsize(int64_t);
80 static int gpart_autofill(struct gctl_req *);
81 static int gpart_autofill_resize(struct gctl_req *);
82 static void gpart_bootcode(struct gctl_req *, unsigned int);
83 static void *gpart_bootfile_read(const char *, ssize_t *);
84 static void gpart_issue(struct gctl_req *, unsigned int);
85 static void gpart_show(struct gctl_req *, unsigned int);
86 static void gpart_show_geom(struct ggeom *, const char *, int);
87 static int gpart_show_hasopt(struct gctl_req *, const char *, const char *);
88 static void gpart_write_partcode(struct ggeom *, int, void *, ssize_t);
89 static void gpart_write_partcode_vtoc8(struct ggeom *, int, void *);
90 static void gpart_print_error(const char *);
91 static void gpart_backup(struct gctl_req *, unsigned int);
92 static void gpart_restore(struct gctl_req *, unsigned int);
94 struct g_command PUBSYM(class_commands)[] = {
95 { "add", 0, gpart_issue, {
96 { 'a', "alignment", GPART_AUTOFILL, G_TYPE_STRING },
97 { 'b', "start", GPART_AUTOFILL, G_TYPE_STRING },
98 { 's', "size", GPART_AUTOFILL, G_TYPE_STRING },
99 { 't', "type", NULL, G_TYPE_STRING },
100 { 'i', GPART_PARAM_INDEX, G_VAL_OPTIONAL, G_TYPE_NUMBER },
101 { 'l', "label", G_VAL_OPTIONAL, G_TYPE_STRING },
102 { 'f', "flags", GPART_FLAGS, G_TYPE_STRING },
104 "-t type [-a alignment] [-b start] [-s size] [-i index] "
105 "[-l label] [-f flags] geom"
107 { "backup", 0, gpart_backup, G_NULL_OPTS,
110 { "bootcode", 0, gpart_bootcode, {
111 { 'b', GPART_PARAM_BOOTCODE, G_VAL_OPTIONAL, G_TYPE_STRING },
112 { 'p', GPART_PARAM_PARTCODE, G_VAL_OPTIONAL, G_TYPE_STRING },
113 { 'i', GPART_PARAM_INDEX, G_VAL_OPTIONAL, G_TYPE_NUMBER },
114 { 'f', "flags", GPART_FLAGS, G_TYPE_STRING },
116 "[-b bootcode] [-p partcode -i index] [-f flags] geom"
118 { "commit", 0, gpart_issue, G_NULL_OPTS,
121 { "create", 0, gpart_issue, {
122 { 's', "scheme", NULL, G_TYPE_STRING },
123 { 'n', "entries", G_VAL_OPTIONAL, G_TYPE_NUMBER },
124 { 'f', "flags", GPART_FLAGS, G_TYPE_STRING },
126 "-s scheme [-n entries] [-f flags] provider"
128 { "delete", 0, gpart_issue, {
129 { 'i', GPART_PARAM_INDEX, NULL, G_TYPE_NUMBER },
130 { 'f', "flags", GPART_FLAGS, G_TYPE_STRING },
132 "-i index [-f flags] geom"
134 { "destroy", 0, gpart_issue, {
135 { 'F', "force", NULL, G_TYPE_BOOL },
136 { 'f', "flags", GPART_FLAGS, G_TYPE_STRING },
138 "[-F] [-f flags] geom"
140 { "modify", 0, gpart_issue, {
141 { 'i', GPART_PARAM_INDEX, NULL, G_TYPE_NUMBER },
142 { 'l', "label", G_VAL_OPTIONAL, G_TYPE_STRING },
143 { 't', "type", G_VAL_OPTIONAL, G_TYPE_STRING },
144 { 'f', "flags", GPART_FLAGS, G_TYPE_STRING },
146 "-i index [-l label] [-t type] [-f flags] geom"
148 { "set", 0, gpart_issue, {
149 { 'a', "attrib", NULL, G_TYPE_STRING },
150 { 'i', GPART_PARAM_INDEX, G_VAL_OPTIONAL, G_TYPE_NUMBER },
151 { 'f', "flags", GPART_FLAGS, G_TYPE_STRING },
153 "-a attrib [-i index] [-f flags] geom"
155 { "show", 0, gpart_show, {
156 { 'l', "show_label", NULL, G_TYPE_BOOL },
157 { 'r', "show_rawtype", NULL, G_TYPE_BOOL },
158 { 'p', "show_providers", NULL, G_TYPE_BOOL },
160 "[-l | -r] [-p] [geom ...]"
162 { "undo", 0, gpart_issue, G_NULL_OPTS,
165 { "unset", 0, gpart_issue, {
166 { 'a', "attrib", NULL, G_TYPE_STRING },
167 { 'i', GPART_PARAM_INDEX, G_VAL_OPTIONAL, G_TYPE_NUMBER },
168 { 'f', "flags", GPART_FLAGS, G_TYPE_STRING },
170 "-a attrib [-i index] [-f flags] geom"
172 { "resize", 0, gpart_issue, {
173 { 'a', "alignment", GPART_AUTOFILL, G_TYPE_STRING },
174 { 's', "size", GPART_AUTOFILL, G_TYPE_STRING },
175 { 'i', GPART_PARAM_INDEX, NULL, G_TYPE_NUMBER },
176 { 'f', "flags", GPART_FLAGS, G_TYPE_STRING },
178 "-i index [-a alignment] [-s size] [-f flags] geom"
180 { "restore", 0, gpart_restore, {
181 { 'F', "force", NULL, G_TYPE_BOOL },
182 { 'l', "restore_labels", NULL, G_TYPE_BOOL },
183 { 'f', "flags", GPART_FLAGS, G_TYPE_STRING },
185 "[-lF] [-f flags] provider [...]"
187 { "recover", 0, gpart_issue, {
188 { 'f', "flags", GPART_FLAGS, G_TYPE_STRING },
195 static struct gclass *
196 find_class(struct gmesh *mesh, const char *name)
198 struct gclass *classp;
200 LIST_FOREACH(classp, &mesh->lg_class, lg_class) {
201 if (strcmp(classp->lg_name, name) == 0)
207 static struct ggeom *
208 find_geom(struct gclass *classp, const char *name)
210 struct ggeom *gp, *wgp;
212 if (strncmp(name, _PATH_DEV, sizeof(_PATH_DEV) - 1) == 0)
213 name += sizeof(_PATH_DEV) - 1;
215 LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
216 if (strcmp(gp->lg_name, name) != 0)
218 if (find_geomcfg(gp, "wither") == NULL)
227 find_geomcfg(struct ggeom *gp, const char *cfg)
231 LIST_FOREACH(gc, &gp->lg_config, lg_config) {
232 if (!strcmp(gc->lg_name, cfg))
239 find_provcfg(struct gprovider *pp, const char *cfg)
243 LIST_FOREACH(gc, &pp->lg_config, lg_config) {
244 if (!strcmp(gc->lg_name, cfg))
250 static struct gprovider *
251 find_provider(struct ggeom *gp, off_t minsector)
253 struct gprovider *pp, *bestpp;
255 off_t sector, bestsector;
259 LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
260 s = find_provcfg(pp, "start");
261 sector = (off_t)strtoimax(s, NULL, 0);
262 if (sector < minsector)
264 if (bestpp != NULL && sector >= bestsector)
274 fmtsize(int64_t rawsz)
278 humanize_number(buf, sizeof(buf), rawsz, "", HN_AUTOSCALE,
279 HN_B | HN_NOSPACE | HN_DECIMAL);
284 fmtattrib(struct gprovider *pp)
286 static char buf[128];
292 LIST_FOREACH(gc, &pp->lg_config, lg_config) {
293 if (strcmp(gc->lg_name, "attrib") != 0)
295 idx += snprintf(buf + idx, sizeof(buf) - idx, "%s%s",
296 (idx == 0) ? " [" : ",", gc->lg_val);
299 snprintf(buf + idx, sizeof(buf) - idx, "] ");
303 #define ALIGNDOWN(d, a) ((d) - (d) % (a))
304 #define ALIGNUP(d, a) ((d) % (a) ? (d) - (d) % (a) + (a): (d))
307 gpart_autofill_resize(struct gctl_req *req)
312 struct gprovider *pp;
313 off_t last, size, start, new_size;
314 off_t lba, new_lba, alignment, offset;
316 int error, idx, has_alignment;
318 idx = (int)gctl_get_intmax(req, GPART_PARAM_INDEX);
320 errx(EXIT_FAILURE, "invalid partition index");
322 error = geom_gettree(&mesh);
325 s = gctl_get_ascii(req, "class");
328 cp = find_class(&mesh, s);
330 errx(EXIT_FAILURE, "Class %s not found.", s);
331 s = gctl_get_ascii(req, "arg0");
334 gp = find_geom(cp, s);
336 errx(EXIT_FAILURE, "No such geom: %s.", s);
337 pp = LIST_FIRST(&gp->lg_consumer)->lg_provider;
339 errx(EXIT_FAILURE, "Provider for geom %s not found.", s);
341 s = gctl_get_ascii(req, "alignment");
342 has_alignment = (*s == '*') ? 0 : 1;
345 error = g_parse_lba(s, pp->lg_sectorsize, &alignment);
347 errc(EXIT_FAILURE, error, "Invalid alignment param");
349 errx(EXIT_FAILURE, "Invalid alignment param");
351 lba = pp->lg_stripesize / pp->lg_sectorsize;
355 error = gctl_delete_param(req, "alignment");
357 errc(EXIT_FAILURE, error, "internal error");
359 s = gctl_get_ascii(req, "size");
363 error = g_parse_lba(s, pp->lg_sectorsize, &new_size);
365 errc(EXIT_FAILURE, error, "Invalid size param");
366 /* no autofill necessary. */
367 if (has_alignment == 0)
371 offset = (pp->lg_stripeoffset / pp->lg_sectorsize) % alignment;
372 s = find_geomcfg(gp, "last");
374 errx(EXIT_FAILURE, "Final block not found for geom %s",
376 last = (off_t)strtoimax(s, NULL, 0);
377 LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
378 s = find_provcfg(pp, "index");
385 errx(EXIT_FAILURE, "invalid partition index");
387 s = find_provcfg(pp, "start");
388 start = (off_t)strtoimax(s, NULL, 0);
389 s = find_provcfg(pp, "end");
390 lba = (off_t)strtoimax(s, NULL, 0);
391 size = lba - start + 1;
393 pp = find_provider(gp, lba + 1);
394 if (new_size > 0 && (new_size <= size || pp == NULL)) {
395 /* The start offset may be not aligned, so we align the end
396 * offset and then calculate the size.
398 new_size = ALIGNDOWN(start + offset + new_size,
399 alignment) - start - offset;
403 new_size = ALIGNDOWN(last + offset + 1, alignment) -
408 s = find_provcfg(pp, "start");
409 new_lba = (off_t)strtoimax(s, NULL, 0);
411 * Is there any free space between current and
414 new_lba = ALIGNDOWN(new_lba + offset, alignment) - offset;
416 new_size = new_lba - start;
418 geom_deletetree(&mesh);
423 snprintf(ssize, sizeof(ssize), "%jd", (intmax_t)new_size);
424 gctl_change_param(req, "size", -1, ssize);
425 geom_deletetree(&mesh);
430 gpart_autofill(struct gctl_req *req)
435 struct gprovider *pp;
436 off_t first, last, a_first;
437 off_t size, start, a_lba;
438 off_t lba, len, alignment, offset;
441 int error, has_size, has_start, has_alignment;
443 s = gctl_get_ascii(req, "verb");
444 if (strcmp(s, "resize") == 0)
445 return gpart_autofill_resize(req);
446 if (strcmp(s, "add") != 0)
449 error = geom_gettree(&mesh);
452 s = gctl_get_ascii(req, "class");
455 cp = find_class(&mesh, s);
457 errx(EXIT_FAILURE, "Class %s not found.", s);
458 s = gctl_get_ascii(req, "arg0");
461 gp = find_geom(cp, s);
463 errx(EXIT_FAILURE, "No such geom: %s.", s);
464 pp = LIST_FIRST(&gp->lg_consumer)->lg_provider;
466 errx(EXIT_FAILURE, "Provider for geom %s not found.", s);
468 s = gctl_get_ascii(req, "alignment");
469 has_alignment = (*s == '*') ? 0 : 1;
472 error = g_parse_lba(s, pp->lg_sectorsize, &alignment);
474 errc(EXIT_FAILURE, error, "Invalid alignment param");
476 errx(EXIT_FAILURE, "Invalid alignment param");
478 error = gctl_delete_param(req, "alignment");
480 errc(EXIT_FAILURE, error, "internal error");
482 s = gctl_get_ascii(req, "size");
483 has_size = (*s == '*') ? 0 : 1;
486 error = g_parse_lba(s, pp->lg_sectorsize, &size);
488 errc(EXIT_FAILURE, error, "Invalid size param");
491 s = gctl_get_ascii(req, "start");
492 has_start = (*s == '*') ? 0 : 1;
495 error = g_parse_lba(s, pp->lg_sectorsize, &start);
497 errc(EXIT_FAILURE, error, "Invalid start param");
500 /* No autofill necessary. */
501 if (has_size && has_start && !has_alignment)
504 len = pp->lg_stripesize / pp->lg_sectorsize;
505 if (len > 0 && !has_alignment)
508 /* Adjust parameters to stripeoffset */
509 offset = (pp->lg_stripeoffset / pp->lg_sectorsize) % alignment;
510 start = ALIGNUP(start + offset, alignment);
511 if (size > alignment)
512 size = ALIGNDOWN(size, alignment);
514 s = find_geomcfg(gp, "first");
516 errx(EXIT_FAILURE, "Starting block not found for geom %s",
518 first = (off_t)strtoimax(s, NULL, 0);
519 s = find_geomcfg(gp, "last");
521 errx(EXIT_FAILURE, "Final block not found for geom %s",
523 last = (off_t)strtoimax(s, NULL, 0);
525 a_first = ALIGNUP(first + offset, alignment);
526 last = ALIGNDOWN(last + offset, alignment);
529 while ((pp = find_provider(gp, first)) != NULL) {
530 s = find_provcfg(pp, "start");
531 lba = (off_t)strtoimax(s, NULL, 0);
532 a_lba = ALIGNDOWN(lba + offset, alignment);
533 if (first < a_lba && a_first < a_lba) {
534 /* Free space [first, lba> */
535 len = a_lba - a_first;
538 (uintmax_t)(len - size) < grade) {
542 } else if (has_start) {
543 if (start >= a_first && start < a_lba) {
544 size = a_lba - start;
545 grade = start - a_first;
548 if (grade == ~0ULL || len > size) {
556 s = find_provcfg(pp, "end");
557 first = (off_t)strtoimax(s, NULL, 0) + 1;
558 if (first + offset > a_first)
559 a_first = ALIGNUP(first + offset, alignment);
561 if (a_first <= last) {
562 /* Free space [first-last] */
563 len = ALIGNDOWN(last - a_first + 1, alignment);
566 (uintmax_t)(len - size) < grade) {
570 } else if (has_start) {
571 if (start >= a_first && start <= last) {
572 size = ALIGNDOWN(last - start + 1, alignment);
573 grade = start - a_first;
576 if (grade == ~0ULL || len > size) {
583 if (grade == ~0ULL) {
584 geom_deletetree(&mesh);
587 start -= offset; /* Return back to real offset */
589 snprintf(ssize, sizeof(ssize), "%jd", (intmax_t)size);
590 gctl_change_param(req, "size", -1, ssize);
591 snprintf(sstart, sizeof(sstart), "%jd", (intmax_t)start);
592 gctl_change_param(req, "start", -1, sstart);
593 geom_deletetree(&mesh);
598 gpart_show_geom(struct ggeom *gp, const char *element, int show_providers)
600 struct gprovider *pp;
601 const char *s, *scheme;
602 off_t first, last, sector, end;
604 int idx, wblocks, wname, wmax;
606 if (find_geomcfg(gp, "wither"))
608 scheme = find_geomcfg(gp, "scheme");
610 errx(EXIT_FAILURE, "Scheme not found for geom %s", gp->lg_name);
611 s = find_geomcfg(gp, "first");
613 errx(EXIT_FAILURE, "Starting block not found for geom %s",
615 first = (off_t)strtoimax(s, NULL, 0);
616 s = find_geomcfg(gp, "last");
618 errx(EXIT_FAILURE, "Final block not found for geom %s",
620 last = (off_t)strtoimax(s, NULL, 0);
622 s = find_geomcfg(gp, "state");
624 errx(EXIT_FAILURE, "State not found for geom %s", gp->lg_name);
625 if (s != NULL && *s != 'C')
627 wmax = strlen(gp->lg_name);
628 if (show_providers) {
629 LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
630 wname = strlen(pp->lg_name);
636 pp = LIST_FIRST(&gp->lg_consumer)->lg_provider;
637 secsz = pp->lg_sectorsize;
638 printf("=>%*jd %*jd %*s %s (%s)%s\n",
639 wblocks, (intmax_t)first, wblocks, (intmax_t)(last - first + 1),
641 scheme, fmtsize(pp->lg_mediasize),
642 s ? " [CORRUPT]": "");
644 while ((pp = find_provider(gp, first)) != NULL) {
645 s = find_provcfg(pp, "start");
646 sector = (off_t)strtoimax(s, NULL, 0);
648 s = find_provcfg(pp, "end");
649 end = (off_t)strtoimax(s, NULL, 0);
650 length = end - sector + 1;
652 s = find_provcfg(pp, "index");
654 if (first < sector) {
655 printf(" %*jd %*jd %*s - free - (%s)\n",
656 wblocks, (intmax_t)first, wblocks,
657 (intmax_t)(sector - first), wname, "",
658 fmtsize((sector - first) * secsz));
660 if (show_providers) {
661 printf(" %*jd %*jd %*s %s %s (%s)\n",
662 wblocks, (intmax_t)sector, wblocks,
663 (intmax_t)length, wname, pp->lg_name,
664 find_provcfg(pp, element), fmtattrib(pp),
665 fmtsize(pp->lg_mediasize));
667 printf(" %*jd %*jd %*d %s %s (%s)\n",
668 wblocks, (intmax_t)sector, wblocks,
669 (intmax_t)length, wname, idx,
670 find_provcfg(pp, element), fmtattrib(pp),
671 fmtsize(pp->lg_mediasize));
675 length = last - first + 1;
676 printf(" %*jd %*jd %*s - free - (%s)\n",
677 wblocks, (intmax_t)first, wblocks, (intmax_t)length,
679 fmtsize(length * secsz));
685 gpart_show_hasopt(struct gctl_req *req, const char *opt, const char *elt)
688 if (!gctl_get_int(req, "%s", opt))
692 errx(EXIT_FAILURE, "-l and -r are mutually exclusive");
698 gpart_show(struct gctl_req *req, unsigned int fl __unused)
701 struct gclass *classp;
703 const char *element, *name;
704 int error, i, nargs, show_providers;
707 if (gpart_show_hasopt(req, "show_label", element))
709 if (gpart_show_hasopt(req, "show_rawtype", element))
714 name = gctl_get_ascii(req, "class");
717 error = geom_gettree(&mesh);
719 errc(EXIT_FAILURE, error, "Cannot get GEOM tree");
720 classp = find_class(&mesh, name);
721 if (classp == NULL) {
722 geom_deletetree(&mesh);
723 errx(EXIT_FAILURE, "Class %s not found.", name);
725 show_providers = gctl_get_int(req, "show_providers");
726 nargs = gctl_get_int(req, "nargs");
728 for (i = 0; i < nargs; i++) {
729 name = gctl_get_ascii(req, "arg%d", i);
730 gp = find_geom(classp, name);
732 gpart_show_geom(gp, element, show_providers);
734 errx(EXIT_FAILURE, "No such geom: %s.", name);
737 LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
738 gpart_show_geom(gp, element, show_providers);
741 geom_deletetree(&mesh);
745 gpart_backup(struct gctl_req *req, unsigned int fl __unused)
748 struct gclass *classp;
749 struct gprovider *pp;
751 const char *s, *scheme;
754 int error, i, windex, wblocks, wtype;
756 if (gctl_get_int(req, "nargs") != 1)
757 errx(EXIT_FAILURE, "Invalid number of arguments.");
758 error = geom_gettree(&mesh);
760 errc(EXIT_FAILURE, error, "Cannot get GEOM tree");
761 s = gctl_get_ascii(req, "class");
764 classp = find_class(&mesh, s);
765 if (classp == NULL) {
766 geom_deletetree(&mesh);
767 errx(EXIT_FAILURE, "Class %s not found.", s);
769 s = gctl_get_ascii(req, "arg0");
772 gp = find_geom(classp, s);
774 errx(EXIT_FAILURE, "No such geom: %s.", s);
775 scheme = find_geomcfg(gp, "scheme");
778 pp = LIST_FIRST(&gp->lg_consumer)->lg_provider;
779 s = find_geomcfg(gp, "last");
784 LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
785 s = find_provcfg(pp, "type");
790 s = find_geomcfg(gp, "entries");
794 printf("%s %s\n", scheme, s);
795 LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
796 s = find_provcfg(pp, "start");
797 sector = (off_t)strtoimax(s, NULL, 0);
799 s = find_provcfg(pp, "end");
800 end = (off_t)strtoimax(s, NULL, 0);
801 length = end - sector + 1;
803 s = find_provcfg(pp, "label");
804 printf("%-*s %*s %*jd %*jd %s %s\n",
805 windex, find_provcfg(pp, "index"),
806 wtype, find_provcfg(pp, "type"),
807 wblocks, (intmax_t)sector,
808 wblocks, (intmax_t)length,
809 (s != NULL) ? s: "", fmtattrib(pp));
811 geom_deletetree(&mesh);
815 skip_line(const char *p)
821 if (isspace(*p) == 0)
829 gpart_sighndl(int sig __unused)
835 gpart_restore(struct gctl_req *req, unsigned int fl __unused)
838 struct gclass *classp;
841 struct sigaction si_sa;
842 const char *s, *flags, *errstr, *label;
843 char **ap, *argv[6], line[BUFSIZ], *pline;
844 int error, forced, i, l, nargs, created, rl;
847 nargs = gctl_get_int(req, "nargs");
849 errx(EXIT_FAILURE, "Invalid number of arguments.");
851 forced = gctl_get_int(req, "force");
852 flags = gctl_get_ascii(req, "flags");
853 rl = gctl_get_int(req, "restore_labels");
854 s = gctl_get_ascii(req, "class");
857 error = geom_gettree(&mesh);
859 errc(EXIT_FAILURE, error, "Cannot get GEOM tree");
860 classp = find_class(&mesh, s);
861 if (classp == NULL) {
862 geom_deletetree(&mesh);
863 errx(EXIT_FAILURE, "Class %s not found.", s);
866 sigemptyset(&si_sa.sa_mask);
868 si_sa.sa_handler = gpart_sighndl;
869 if (sigaction(SIGINT, &si_sa, 0) == -1)
870 err(EXIT_FAILURE, "sigaction SIGINT");
873 /* destroy existent partition table before restore */
874 for (i = 0; i < nargs; i++) {
875 s = gctl_get_ascii(req, "arg%d", i);
876 gp = find_geom(classp, s);
878 r = gctl_get_handle();
879 gctl_ro_param(r, "class", -1,
881 gctl_ro_param(r, "verb", -1, "destroy");
882 gctl_ro_param(r, "flags", -1, "restore");
883 gctl_ro_param(r, "force", sizeof(forced),
885 gctl_ro_param(r, "arg0", -1, s);
886 errstr = gctl_issue(r);
887 if (errstr != NULL && errstr[0] != '\0') {
888 gpart_print_error(errstr);
897 while (undo_restore == 0 &&
898 fgets(line, sizeof(line) - 1, stdin) != NULL) {
899 /* Format of backup entries:
900 * <scheme name> <number of entries>
901 * <index> <type> <start> <size> [label] ['['attrib[,attrib]']']
903 pline = (char *)line;
904 pline[strlen(line) - 1] = 0;
905 if (skip_line(pline))
908 (*ap = strsep(&pline, " \t")) != NULL;)
909 if (**ap != '\0' && ++ap >= &argv[6])
912 label = pline = NULL;
913 if (l == 1 || l == 2) { /* create table */
915 errx(EXIT_FAILURE, "Incorrect backup format.");
917 n = strtoimax(argv[1], NULL, 0);
918 for (i = 0; i < nargs; i++) {
919 s = gctl_get_ascii(req, "arg%d", i);
920 r = gctl_get_handle();
921 gctl_ro_param(r, "class", -1,
923 gctl_ro_param(r, "verb", -1, "create");
924 gctl_ro_param(r, "scheme", -1, argv[0]);
926 gctl_ro_param(r, "entries",
928 gctl_ro_param(r, "flags", -1, "restore");
929 gctl_ro_param(r, "arg0", -1, s);
930 errstr = gctl_issue(r);
931 if (errstr != NULL && errstr[0] != '\0') {
932 gpart_print_error(errstr);
940 } else if (l < 4 || created == 0)
941 errx(EXIT_FAILURE, "Incorrect backup format.");
943 if (strchr(argv[4], '[') == NULL)
951 /* Add partitions to each table */
952 for (i = 0; i < nargs; i++) {
953 s = gctl_get_ascii(req, "arg%d", i);
954 r = gctl_get_handle();
955 n = strtoimax(argv[0], NULL, 0);
956 gctl_ro_param(r, "class", -1, classp->lg_name);
957 gctl_ro_param(r, "verb", -1, "add");
958 gctl_ro_param(r, "flags", -1, "restore");
959 gctl_ro_param(r, GPART_PARAM_INDEX, sizeof(n), &n);
960 gctl_ro_param(r, "type", -1, argv[1]);
961 gctl_ro_param(r, "start", -1, argv[2]);
962 gctl_ro_param(r, "size", -1, argv[3]);
963 if (rl != 0 && label != NULL)
964 gctl_ro_param(r, "label", -1, argv[4]);
965 gctl_ro_param(r, "alignment", -1, GPART_AUTOFILL);
966 gctl_ro_param(r, "arg0", -1, s);
967 error = gpart_autofill(r);
969 errc(EXIT_FAILURE, error, "autofill");
970 errstr = gctl_issue(r);
971 if (errstr != NULL && errstr[0] != '\0') {
972 gpart_print_error(errstr);
978 if (pline == NULL || *pline != '[')
983 (*ap = strsep(&pline, ",]")) != NULL;)
984 if (**ap != '\0' && ++ap >= &argv[6])
986 for (i = 0; i < nargs; i++) {
988 s = gctl_get_ascii(req, "arg%d", i);
990 r = gctl_get_handle();
991 gctl_ro_param(r, "class", -1, classp->lg_name);
992 gctl_ro_param(r, "verb", -1, "set");
993 gctl_ro_param(r, "flags", -1, "restore");
994 gctl_ro_param(r, GPART_PARAM_INDEX,
996 gctl_ro_param(r, "attrib", -1, argv[--l]);
997 gctl_ro_param(r, "arg0", -1, s);
998 errstr = gctl_issue(r);
999 if (errstr != NULL && errstr[0] != '\0') {
1000 gpart_print_error(errstr);
1010 /* commit changes if needed */
1011 if (strchr(flags, 'C') != NULL) {
1012 for (i = 0; i < nargs; i++) {
1013 s = gctl_get_ascii(req, "arg%d", i);
1014 r = gctl_get_handle();
1015 gctl_ro_param(r, "class", -1, classp->lg_name);
1016 gctl_ro_param(r, "verb", -1, "commit");
1017 gctl_ro_param(r, "arg0", -1, s);
1018 errstr = gctl_issue(r);
1019 if (errstr != NULL && errstr[0] != '\0') {
1020 gpart_print_error(errstr);
1028 geom_deletetree(&mesh);
1032 for (i = 0; i < nargs; i++) {
1033 s = gctl_get_ascii(req, "arg%d", i);
1034 r = gctl_get_handle();
1035 gctl_ro_param(r, "class", -1, classp->lg_name);
1036 gctl_ro_param(r, "verb", -1, "undo");
1037 gctl_ro_param(r, "arg0", -1, s);
1042 geom_deletetree(&mesh);
1047 gpart_bootfile_read(const char *bootfile, ssize_t *size)
1053 if (stat(bootfile, &sb) == -1)
1054 err(EXIT_FAILURE, "%s", bootfile);
1055 if (!S_ISREG(sb.st_mode))
1056 errx(EXIT_FAILURE, "%s: not a regular file", bootfile);
1057 if (sb.st_size == 0)
1058 errx(EXIT_FAILURE, "%s: empty file", bootfile);
1059 if (*size > 0 && sb.st_size > *size)
1060 errx(EXIT_FAILURE, "%s: file too big (%zu limit)", bootfile,
1065 fd = open(bootfile, O_RDONLY);
1067 err(EXIT_FAILURE, "%s", bootfile);
1068 code = malloc(*size);
1070 err(EXIT_FAILURE, NULL);
1071 if (read(fd, code, *size) != *size)
1072 err(EXIT_FAILURE, "%s", bootfile);
1079 gpart_write_partcode(struct ggeom *gp, int idx, void *code, ssize_t size)
1082 struct gprovider *pp;
1088 LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
1089 s = find_provcfg(pp, "index");
1097 snprintf(dsf, sizeof(dsf), "/dev/%s", pp->lg_name);
1098 fd = open(dsf, O_WRONLY);
1100 err(EXIT_FAILURE, "%s", dsf);
1101 if (lseek(fd, size, SEEK_SET) != size)
1102 errx(EXIT_FAILURE, "%s: not enough space", dsf);
1103 if (lseek(fd, 0, SEEK_SET) != 0)
1104 err(EXIT_FAILURE, "%s", dsf);
1107 * When writing to a disk device, the write must be
1108 * sector aligned and not write to any partial sectors,
1109 * so round up the buffer size to the next sector and zero it.
1111 bsize = (size + pp->lg_sectorsize - 1) /
1112 pp->lg_sectorsize * pp->lg_sectorsize;
1113 buf = calloc(1, bsize);
1115 err(EXIT_FAILURE, "%s", dsf);
1116 bcopy(code, buf, size);
1117 if (write(fd, buf, bsize) != bsize)
1118 err(EXIT_FAILURE, "%s", dsf);
1122 errx(EXIT_FAILURE, "invalid partition index");
1126 gpart_write_partcode_vtoc8(struct ggeom *gp, int idx, void *code)
1129 struct gprovider *pp;
1134 LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
1135 s = find_provcfg(pp, "index");
1138 if (idx != 0 && atoi(s) != idx)
1140 snprintf(dsf, sizeof(dsf), "/dev/%s", pp->lg_name);
1141 if (pp->lg_sectorsize != sizeof(struct vtoc8))
1142 errx(EXIT_FAILURE, "%s: unexpected sector "
1143 "size (%d)\n", dsf, pp->lg_sectorsize);
1144 fd = open(dsf, O_WRONLY);
1146 err(EXIT_FAILURE, "%s", dsf);
1147 if (lseek(fd, VTOC_BOOTSIZE, SEEK_SET) != VTOC_BOOTSIZE)
1150 * We ignore the first VTOC_BOOTSIZE bytes of boot code in
1151 * order to avoid overwriting the label.
1153 if (lseek(fd, sizeof(struct vtoc8), SEEK_SET) !=
1154 sizeof(struct vtoc8))
1155 err(EXIT_FAILURE, "%s", dsf);
1156 if (write(fd, (caddr_t)code + sizeof(struct vtoc8),
1157 VTOC_BOOTSIZE - sizeof(struct vtoc8)) != VTOC_BOOTSIZE -
1158 sizeof(struct vtoc8))
1159 err(EXIT_FAILURE, "%s", dsf);
1162 if (idx != 0 && atoi(s) == idx)
1166 errx(EXIT_FAILURE, "%s: no partitions", gp->lg_name);
1170 gpart_bootcode(struct gctl_req *req, unsigned int fl)
1173 struct gclass *classp;
1176 void *bootcode, *partcode;
1177 size_t bootsize, partsize;
1178 int error, idx, vtoc8;
1180 if (gctl_has_param(req, GPART_PARAM_BOOTCODE)) {
1181 s = gctl_get_ascii(req, GPART_PARAM_BOOTCODE);
1182 bootsize = 800 * 1024; /* Arbitrary limit. */
1183 bootcode = gpart_bootfile_read(s, &bootsize);
1184 error = gctl_change_param(req, GPART_PARAM_BOOTCODE, bootsize,
1187 errc(EXIT_FAILURE, error, "internal error");
1193 s = gctl_get_ascii(req, "class");
1196 error = geom_gettree(&mesh);
1198 errc(EXIT_FAILURE, error, "Cannot get GEOM tree");
1199 classp = find_class(&mesh, s);
1200 if (classp == NULL) {
1201 geom_deletetree(&mesh);
1202 errx(EXIT_FAILURE, "Class %s not found.", s);
1204 if (gctl_get_int(req, "nargs") != 1)
1205 errx(EXIT_FAILURE, "Invalid number of arguments.");
1206 s = gctl_get_ascii(req, "arg0");
1209 gp = find_geom(classp, s);
1211 errx(EXIT_FAILURE, "No such geom: %s.", s);
1212 s = find_geomcfg(gp, "scheme");
1214 errx(EXIT_FAILURE, "Scheme not found for geom %s", gp->lg_name);
1216 if (strcmp(s, "VTOC8") == 0)
1219 if (gctl_has_param(req, GPART_PARAM_PARTCODE)) {
1220 s = gctl_get_ascii(req, GPART_PARAM_PARTCODE);
1221 partsize = vtoc8 != 0 ? VTOC_BOOTSIZE : bootsize * 1024;
1222 partcode = gpart_bootfile_read(s, &partsize);
1223 error = gctl_delete_param(req, GPART_PARAM_PARTCODE);
1225 errc(EXIT_FAILURE, error, "internal error");
1231 if (gctl_has_param(req, GPART_PARAM_INDEX)) {
1232 if (partcode == NULL)
1233 errx(EXIT_FAILURE, "-i is only valid with -p");
1234 idx = (int)gctl_get_intmax(req, GPART_PARAM_INDEX);
1236 errx(EXIT_FAILURE, "invalid partition index");
1237 error = gctl_delete_param(req, GPART_PARAM_INDEX);
1239 errc(EXIT_FAILURE, error, "internal error");
1243 if (partcode != NULL) {
1246 errx(EXIT_FAILURE, "missing -i option");
1247 gpart_write_partcode(gp, idx, partcode, partsize);
1249 if (partsize != VTOC_BOOTSIZE)
1250 errx(EXIT_FAILURE, "invalid bootcode");
1251 gpart_write_partcode_vtoc8(gp, idx, partcode);
1254 if (bootcode == NULL)
1255 errx(EXIT_FAILURE, "no -b nor -p");
1257 if (bootcode != NULL)
1258 gpart_issue(req, fl);
1260 geom_deletetree(&mesh);
1264 gpart_print_error(const char *errstr)
1269 error = strtol(errstr, &errmsg, 0);
1270 if (errmsg != errstr) {
1271 while (errmsg[0] == ' ')
1273 if (errmsg[0] != '\0')
1274 warnc(error, "%s", errmsg);
1278 warnx("%s", errmsg);
1282 gpart_issue(struct gctl_req *req, unsigned int fl __unused)
1288 if (gctl_get_int(req, "nargs") != 1)
1289 errx(EXIT_FAILURE, "Invalid number of arguments.");
1290 (void)gctl_delete_param(req, "nargs");
1292 /* autofill parameters (if applicable). */
1293 error = gpart_autofill(req);
1295 warnc(error, "autofill");
1296 status = EXIT_FAILURE;
1300 bzero(buf, sizeof(buf));
1301 gctl_rw_param(req, "output", sizeof(buf), buf);
1302 errstr = gctl_issue(req);
1303 if (errstr == NULL || errstr[0] == '\0') {
1306 status = EXIT_SUCCESS;
1310 gpart_print_error(errstr);
1311 status = EXIT_FAILURE;