1/*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2007, 2008 Marcel Moolenaar
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 THE AUTHORS 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 THE AUTHORS 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#include <sys/cdefs.h>
30#include <sys/stat.h>
31
32#include <assert.h>
33#include <ctype.h>
34#include <err.h>
35#include <errno.h>
36#include <fcntl.h>
37#include <libgeom.h>
38#include <libutil.h>
39#include <paths.h>
40#include <signal.h>
41#include <stdint.h>
42#include <stdio.h>
43#include <stdlib.h>
44#include <limits.h>
45#include <inttypes.h>
46#include <string.h>
47#include <strings.h>
48#include <unistd.h>
49
50#include "core/geom.h"
51#include "misc/subr.h"
52
53#ifdef STATIC_GEOM_CLASSES
54#define	PUBSYM(x)	gpart_##x
55#else
56#define	PUBSYM(x)	x
57#endif
58
59uint32_t PUBSYM(lib_version) = G_LIB_VERSION;
60uint32_t PUBSYM(version) = 0;
61
62static char sstart[32];
63static char ssize[32];
64volatile sig_atomic_t undo_restore;
65
66#define	GPART_AUTOFILL	"*"
67#define	GPART_FLAGS	"C"
68
69#define	GPART_PARAM_BOOTCODE	"bootcode"
70#define	GPART_PARAM_INDEX	"index"
71#define	GPART_PARAM_PARTCODE	"partcode"
72#define	GPART_PARAM_SKIP_DSN	"skip_dsn"
73
74static struct gclass *find_class(struct gmesh *, const char *);
75static struct ggeom * find_geom(struct gclass *, const char *);
76static int geom_is_withered(struct ggeom *);
77static const char *find_geomcfg(struct ggeom *, const char *);
78static const char *find_provcfg(struct gprovider *, const char *);
79static struct gprovider *find_provider(struct ggeom *, off_t);
80static const char *fmtsize(int64_t);
81static int gpart_autofill(struct gctl_req *);
82static int gpart_autofill_resize(struct gctl_req *);
83static void gpart_bootcode(struct gctl_req *, unsigned int);
84static void *gpart_bootfile_read(const char *, ssize_t *);
85static _Noreturn void gpart_issue(struct gctl_req *, unsigned int);
86static void gpart_show(struct gctl_req *, unsigned int);
87static void gpart_show_geom(struct ggeom *, const char *, int);
88static int gpart_show_hasopt(struct gctl_req *, const char *, const char *);
89static void gpart_write_partcode(struct gctl_req *, int, void *, ssize_t);
90static void gpart_print_error(const char *);
91static void gpart_backup(struct gctl_req *, unsigned int);
92static void gpart_restore(struct gctl_req *, unsigned int);
93
94struct 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 },
103		G_OPT_SENTINEL },
104	    "-t type [-a alignment] [-b start] [-s size] [-i index] "
105		"[-l label] [-f flags] geom"
106	},
107	{ "backup", 0, gpart_backup, G_NULL_OPTS,
108	    "geom"
109	},
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 },
115		{ 'N', GPART_PARAM_SKIP_DSN, NULL, G_TYPE_BOOL },
116		G_OPT_SENTINEL },
117	    "[-N] [-b bootcode] [-p partcode -i index] [-f flags] geom"
118	},
119	{ "commit", 0, gpart_issue, G_NULL_OPTS,
120	    "geom"
121	},
122	{ "create", 0, gpart_issue, {
123		{ 's', "scheme", NULL, G_TYPE_STRING },
124		{ 'n', "entries", G_VAL_OPTIONAL, G_TYPE_NUMBER },
125		{ 'f', "flags", GPART_FLAGS, G_TYPE_STRING },
126		G_OPT_SENTINEL },
127	    "-s scheme [-n entries] [-f flags] provider"
128	},
129	{ "delete", 0, gpart_issue, {
130		{ 'i', GPART_PARAM_INDEX, NULL, G_TYPE_NUMBER },
131		{ 'f', "flags", GPART_FLAGS, G_TYPE_STRING },
132		G_OPT_SENTINEL },
133	    "-i index [-f flags] geom"
134	},
135	{ "destroy", 0, gpart_issue, {
136		{ 'F', "force", NULL, G_TYPE_BOOL },
137		{ 'f', "flags", GPART_FLAGS, G_TYPE_STRING },
138		G_OPT_SENTINEL },
139	    "[-F] [-f flags] geom"
140	},
141	{ "modify", 0, gpart_issue, {
142		{ 'i', GPART_PARAM_INDEX, NULL, G_TYPE_NUMBER },
143		{ 'l', "label", G_VAL_OPTIONAL, G_TYPE_STRING },
144		{ 't', "type", G_VAL_OPTIONAL, G_TYPE_STRING },
145		{ 'f', "flags", GPART_FLAGS, G_TYPE_STRING },
146		G_OPT_SENTINEL },
147	    "-i index [-l label] [-t type] [-f flags] geom"
148	},
149	{ "set", 0, gpart_issue, {
150		{ 'a', "attrib", NULL, G_TYPE_STRING },
151		{ 'i', GPART_PARAM_INDEX, G_VAL_OPTIONAL, G_TYPE_NUMBER },
152		{ 'f', "flags", GPART_FLAGS, G_TYPE_STRING },
153		G_OPT_SENTINEL },
154	    "-a attrib [-i index] [-f flags] geom"
155	},
156	{ "show", 0, gpart_show, {
157		{ 'l', "show_label", NULL, G_TYPE_BOOL },
158		{ 'r', "show_rawtype", NULL, G_TYPE_BOOL },
159		{ 'p', "show_providers", NULL, G_TYPE_BOOL },
160		G_OPT_SENTINEL },
161	    "[-l | -r] [-p] [geom ...]"
162	},
163	{ "undo", 0, gpart_issue, G_NULL_OPTS,
164	    "geom"
165	},
166	{ "unset", 0, gpart_issue, {
167		{ 'a', "attrib", NULL, G_TYPE_STRING },
168		{ 'i', GPART_PARAM_INDEX, G_VAL_OPTIONAL, G_TYPE_NUMBER },
169		{ 'f', "flags", GPART_FLAGS, G_TYPE_STRING },
170		G_OPT_SENTINEL },
171	    "-a attrib [-i index] [-f flags] geom"
172	},
173	{ "resize", 0, gpart_issue, {
174		{ 'a', "alignment", GPART_AUTOFILL, G_TYPE_STRING },
175		{ 's', "size", GPART_AUTOFILL, G_TYPE_STRING },
176		{ 'i', GPART_PARAM_INDEX, NULL, G_TYPE_NUMBER },
177		{ 'f', "flags", GPART_FLAGS, G_TYPE_STRING },
178		G_OPT_SENTINEL },
179	    "-i index [-a alignment] [-s size] [-f flags] geom"
180	},
181	{ "restore", 0, gpart_restore, {
182		{ 'F', "force", NULL, G_TYPE_BOOL },
183		{ 'l', "restore_labels", NULL, G_TYPE_BOOL },
184		{ 'f', "flags", GPART_FLAGS, G_TYPE_STRING },
185		G_OPT_SENTINEL },
186	    "[-lF] [-f flags] provider [...]"
187	},
188	{ "recover", 0, gpart_issue, {
189		{ 'f', "flags", GPART_FLAGS, G_TYPE_STRING },
190		G_OPT_SENTINEL },
191	    "[-f flags] geom"
192	},
193	G_CMD_SENTINEL
194};
195
196static struct gclass *
197find_class(struct gmesh *mesh, const char *name)
198{
199	struct gclass *classp;
200
201	LIST_FOREACH(classp, &mesh->lg_class, lg_class) {
202		if (strcmp(classp->lg_name, name) == 0)
203			return (classp);
204	}
205	return (NULL);
206}
207
208static struct ggeom *
209find_geom(struct gclass *classp, const char *name)
210{
211	struct ggeom *gp, *wgp;
212
213	if (strncmp(name, _PATH_DEV, sizeof(_PATH_DEV) - 1) == 0)
214		name += sizeof(_PATH_DEV) - 1;
215	wgp = NULL;
216	LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
217		if (strcmp(gp->lg_name, name) != 0)
218			continue;
219		if (!geom_is_withered(gp))
220			return (gp);
221		else
222			wgp = gp;
223	}
224	return (wgp);
225}
226
227static int
228geom_is_withered(struct ggeom *gp)
229{
230	struct gconfig *gc;
231
232	LIST_FOREACH(gc, &gp->lg_config, lg_config) {
233		if (!strcmp(gc->lg_name, "wither"))
234			return (1);
235	}
236	return (0);
237}
238
239static const char *
240find_geomcfg(struct ggeom *gp, const char *cfg)
241{
242	struct gconfig *gc;
243
244	LIST_FOREACH(gc, &gp->lg_config, lg_config) {
245		if (!strcmp(gc->lg_name, cfg))
246			return (gc->lg_val);
247	}
248	return (NULL);
249}
250
251static const char *
252find_provcfg(struct gprovider *pp, const char *cfg)
253{
254	struct gconfig *gc;
255
256	LIST_FOREACH(gc, &pp->lg_config, lg_config) {
257		if (!strcmp(gc->lg_name, cfg))
258			return (gc->lg_val);
259	}
260	return (NULL);
261}
262
263static struct gprovider *
264find_provider(struct ggeom *gp, off_t minsector)
265{
266	struct gprovider *pp, *bestpp;
267	const char *s;
268	off_t sector, bestsector;
269
270	bestpp = NULL;
271	bestsector = 0;
272	LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
273		s = find_provcfg(pp, "start");
274		sector = (off_t)strtoimax(s, NULL, 0);
275		if (sector < minsector)
276			continue;
277		if (bestpp != NULL && sector >= bestsector)
278			continue;
279
280		bestpp = pp;
281		bestsector = sector;
282	}
283	return (bestpp);
284}
285
286static const char *
287fmtsize(int64_t rawsz)
288{
289	static char buf[5];
290
291	humanize_number(buf, sizeof(buf), rawsz, "", HN_AUTOSCALE,
292	    HN_B | HN_NOSPACE | HN_DECIMAL);
293	return (buf);
294}
295
296static const char *
297fmtattrib(struct gprovider *pp)
298{
299	static char buf[128];
300	struct gconfig *gc;
301	u_int idx;
302
303	buf[0] = '\0';
304	idx = 0;
305	LIST_FOREACH(gc, &pp->lg_config, lg_config) {
306		if (strcmp(gc->lg_name, "attrib") != 0)
307			continue;
308		idx += snprintf(buf + idx, sizeof(buf) - idx, "%s%s",
309		    (idx == 0) ? " [" : ",", gc->lg_val);
310	}
311	if (idx > 0)
312		snprintf(buf + idx, sizeof(buf) - idx, "] ");
313	return (buf);
314}
315
316#define	ALIGNDOWN(d, a)	((d) - (d) % (a))
317#define	ALIGNUP(d, a)	((d) % (a) ? (d) - (d) % (a) + (a): (d))
318
319static int
320gpart_autofill_resize(struct gctl_req *req)
321{
322	struct gmesh mesh;
323	struct gclass *cp;
324	struct ggeom *gp;
325	struct gprovider *pp;
326	off_t last, size, start, new_size;
327	off_t lba, new_lba, alignment, offset;
328	const char *g, *s;
329	int error, idx, has_alignment;
330
331	idx = (int)gctl_get_intmax(req, GPART_PARAM_INDEX);
332	if (idx < 1)
333		errx(EXIT_FAILURE, "invalid partition index");
334
335	s = gctl_get_ascii(req, "class");
336	if (s == NULL)
337		abort();
338	g = gctl_get_ascii(req, "arg0");
339	if (g == NULL)
340		abort();
341	error = geom_gettree_geom(&mesh, s, g, 1);
342	if (error)
343		return (error);
344	cp = find_class(&mesh, s);
345	if (cp == NULL)
346		errx(EXIT_FAILURE, "Class %s not found.", s);
347	gp = find_geom(cp, g);
348	if (gp == NULL)
349		errx(EXIT_FAILURE, "No such geom: %s.", g);
350	pp = LIST_FIRST(&gp->lg_consumer)->lg_provider;
351	if (pp == NULL)
352		errx(EXIT_FAILURE, "Provider for geom %s not found.", g);
353
354	s = gctl_get_ascii(req, "alignment");
355	has_alignment = (*s == '*') ? 0 : 1;
356	alignment = 1;
357	if (has_alignment) {
358		error = g_parse_lba(s, pp->lg_sectorsize, &alignment);
359		if (error)
360			errc(EXIT_FAILURE, error, "Invalid alignment param");
361		if (alignment == 0)
362			errx(EXIT_FAILURE, "Invalid alignment param");
363	} else {
364		lba = pp->lg_stripesize / pp->lg_sectorsize;
365		if (lba > 0)
366			alignment = lba;
367	}
368	error = gctl_delete_param(req, "alignment");
369	if (error)
370		errc(EXIT_FAILURE, error, "internal error");
371
372	s = gctl_get_ascii(req, "size");
373	if (*s == '*')
374		new_size = 0;
375	else {
376		error = g_parse_lba(s, pp->lg_sectorsize, &new_size);
377		if (error)
378			errc(EXIT_FAILURE, error, "Invalid size param");
379		/* no autofill necessary. */
380		if (has_alignment == 0)
381			goto done;
382	}
383
384	offset = (pp->lg_stripeoffset / pp->lg_sectorsize) % alignment;
385	s = find_geomcfg(gp, "last");
386	if (s == NULL)
387		errx(EXIT_FAILURE, "Final block not found for geom %s",
388		    gp->lg_name);
389	last = (off_t)strtoimax(s, NULL, 0);
390	LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
391		s = find_provcfg(pp, "index");
392		if (s == NULL)
393			continue;
394		if (atoi(s) == idx)
395			break;
396	}
397	if (pp == NULL)
398		errx(EXIT_FAILURE, "invalid partition index");
399
400	s = find_provcfg(pp, "start");
401	start = (off_t)strtoimax(s, NULL, 0);
402	s = find_provcfg(pp, "end");
403	lba = (off_t)strtoimax(s, NULL, 0);
404	size = lba - start + 1;
405
406	pp = find_provider(gp, lba + 1);
407	if (new_size > 0 && (new_size <= size || pp == NULL)) {
408		/* The start offset may be not aligned, so we align the end
409		 * offset and then calculate the size.
410		 */
411		new_size = ALIGNDOWN(start + offset + new_size,
412		    alignment) - start - offset;
413		goto done;
414	}
415	if (pp == NULL) {
416		new_size = ALIGNDOWN(last + offset + 1, alignment) -
417		    start - offset;
418		if (new_size < size)
419			return (ENOSPC);
420	} else {
421		s = find_provcfg(pp, "start");
422		new_lba = (off_t)strtoimax(s, NULL, 0);
423		/*
424		 * Is there any free space between current and
425		 * next providers?
426		 */
427		new_lba = ALIGNDOWN(new_lba + offset, alignment) - offset;
428		if (new_lba > lba)
429			new_size = new_lba - start;
430		else {
431			geom_deletetree(&mesh);
432			return (ENOSPC);
433		}
434	}
435done:
436	snprintf(ssize, sizeof(ssize), "%jd", (intmax_t)new_size);
437	gctl_change_param(req, "size", -1, ssize);
438	geom_deletetree(&mesh);
439	return (0);
440}
441
442static int
443gpart_autofill(struct gctl_req *req)
444{
445	struct gmesh mesh;
446	struct gclass *cp;
447	struct ggeom *gp;
448	struct gprovider *pp;
449	off_t first, last, a_first;
450	off_t size, start, a_lba;
451	off_t lba, len, alignment, offset;
452	uintmax_t grade;
453	const char *g, *s;
454	int error, has_size, has_start, has_alignment;
455
456	s = gctl_get_ascii(req, "verb");
457	if (strcmp(s, "resize") == 0)
458		return gpart_autofill_resize(req);
459	if (strcmp(s, "add") != 0)
460		return (0);
461
462	s = gctl_get_ascii(req, "class");
463	if (s == NULL)
464		abort();
465	g = gctl_get_ascii(req, "arg0");
466	if (g == NULL)
467		abort();
468	error = geom_gettree_geom(&mesh, s, g, 1);
469	if (error)
470		return (error);
471	cp = find_class(&mesh, s);
472	if (cp == NULL)
473		errx(EXIT_FAILURE, "Class %s not found.", s);
474	gp = find_geom(cp, g);
475	if (gp == NULL) {
476		if (g_device_path(g) == NULL) {
477			errx(EXIT_FAILURE, "No such geom %s.", g);
478		} else {
479			/*
480			 * We don't free memory allocated by g_device_path() as
481			 * we are about to exit.
482			 */
483			errx(EXIT_FAILURE,
484			    "No partitioning scheme found on geom %s. Create one first using 'gpart create'.",
485			    g);
486		}
487	}
488	pp = LIST_FIRST(&gp->lg_consumer)->lg_provider;
489	if (pp == NULL)
490		errx(EXIT_FAILURE, "Provider for geom %s not found.", g);
491
492	s = gctl_get_ascii(req, "alignment");
493	has_alignment = (*s == '*') ? 0 : 1;
494	alignment = 1;
495	if (has_alignment) {
496		error = g_parse_lba(s, pp->lg_sectorsize, &alignment);
497		if (error)
498			errc(EXIT_FAILURE, error, "Invalid alignment param");
499		if (alignment == 0)
500			errx(EXIT_FAILURE, "Invalid alignment param");
501	}
502	error = gctl_delete_param(req, "alignment");
503	if (error)
504		errc(EXIT_FAILURE, error, "internal error");
505
506	s = gctl_get_ascii(req, "size");
507	has_size = (*s == '*') ? 0 : 1;
508	size = 0;
509	if (has_size) {
510		error = g_parse_lba(s, pp->lg_sectorsize, &size);
511		if (error)
512			errc(EXIT_FAILURE, error, "Invalid size param");
513	}
514
515	s = gctl_get_ascii(req, "start");
516	has_start = (*s == '*') ? 0 : 1;
517	start = 0ULL;
518	if (has_start) {
519		error = g_parse_lba(s, pp->lg_sectorsize, &start);
520		if (error)
521			errc(EXIT_FAILURE, error, "Invalid start param");
522	}
523
524	/* No autofill necessary. */
525	if (has_size && has_start && !has_alignment)
526		goto done;
527
528	len = pp->lg_stripesize / pp->lg_sectorsize;
529	if (len > 0 && !has_alignment)
530		alignment = len;
531
532	/* Adjust parameters to stripeoffset */
533	offset = (pp->lg_stripeoffset / pp->lg_sectorsize) % alignment;
534	start = ALIGNUP(start + offset, alignment);
535	if (size > alignment)
536		size = ALIGNDOWN(size, alignment);
537
538	s = find_geomcfg(gp, "first");
539	if (s == NULL)
540		errx(EXIT_FAILURE, "Starting block not found for geom %s",
541		    gp->lg_name);
542	first = (off_t)strtoimax(s, NULL, 0);
543	s = find_geomcfg(gp, "last");
544	if (s == NULL)
545		errx(EXIT_FAILURE, "Final block not found for geom %s",
546		    gp->lg_name);
547	last = (off_t)strtoimax(s, NULL, 0);
548	grade = ~0ULL;
549	a_first = ALIGNUP(first + offset, alignment);
550	last = ALIGNDOWN(last + offset + 1, alignment) - 1;
551	if (a_first < start)
552		a_first = start;
553	while ((pp = find_provider(gp, first)) != NULL) {
554		s = find_provcfg(pp, "start");
555		lba = (off_t)strtoimax(s, NULL, 0);
556		a_lba = ALIGNDOWN(lba + offset, alignment);
557		if (first < a_lba && a_first < a_lba) {
558			/* Free space [first, lba> */
559			len = a_lba - a_first;
560			if (has_size) {
561				if (len >= size &&
562				    (uintmax_t)(len - size) < grade) {
563					start = a_first;
564					grade = len - size;
565				}
566			} else if (has_start) {
567				if (start >= a_first && start < a_lba) {
568					size = a_lba - start;
569					grade = start - a_first;
570				}
571			} else {
572				if (grade == ~0ULL || len > size) {
573					start = a_first;
574					size = len;
575					grade = 0;
576				}
577			}
578		}
579
580		s = find_provcfg(pp, "end");
581		first = (off_t)strtoimax(s, NULL, 0) + 1;
582		if (first + offset > a_first)
583			a_first = ALIGNUP(first + offset, alignment);
584	}
585	if (a_first <= last) {
586		/* Free space [first-last] */
587		len = ALIGNDOWN(last - a_first + 1, alignment);
588		if (has_size) {
589			if (len >= size &&
590			    (uintmax_t)(len - size) < grade) {
591				start = a_first;
592				grade = len - size;
593			}
594		} else if (has_start) {
595			if (start >= a_first && start <= last) {
596				size = ALIGNDOWN(last - start + 1, alignment);
597				grade = start - a_first;
598			}
599		} else {
600			if (grade == ~0ULL || len > size) {
601				start = a_first;
602				size = len;
603				grade = 0;
604			}
605		}
606	}
607	if (grade == ~0ULL) {
608		geom_deletetree(&mesh);
609		return (ENOSPC);
610	}
611	start -= offset;	/* Return back to real offset */
612done:
613	snprintf(ssize, sizeof(ssize), "%jd", (intmax_t)size);
614	gctl_change_param(req, "size", -1, ssize);
615	snprintf(sstart, sizeof(sstart), "%jd", (intmax_t)start);
616	gctl_change_param(req, "start", -1, sstart);
617	geom_deletetree(&mesh);
618	return (0);
619}
620
621static void
622gpart_show_geom(struct ggeom *gp, const char *element, int show_providers)
623{
624	struct gprovider *pp;
625	const char *s, *scheme;
626	off_t first, last, sector, end;
627	off_t length, secsz;
628	int idx, wblocks, wname, wmax;
629
630	if (geom_is_withered(gp))
631		return;
632	scheme = find_geomcfg(gp, "scheme");
633	if (scheme == NULL)
634		errx(EXIT_FAILURE, "Scheme not found for geom %s", gp->lg_name);
635	s = find_geomcfg(gp, "first");
636	if (s == NULL)
637		errx(EXIT_FAILURE, "Starting block not found for geom %s",
638		    gp->lg_name);
639	first = (off_t)strtoimax(s, NULL, 0);
640	s = find_geomcfg(gp, "last");
641	if (s == NULL)
642		errx(EXIT_FAILURE, "Final block not found for geom %s",
643		    gp->lg_name);
644	last = (off_t)strtoimax(s, NULL, 0);
645	wblocks = strlen(s);
646	s = find_geomcfg(gp, "state");
647	if (s == NULL)
648		errx(EXIT_FAILURE, "State not found for geom %s", gp->lg_name);
649	if (s != NULL && *s != 'C')
650		s = NULL;
651	wmax = strlen(gp->lg_name);
652	if (show_providers) {
653		LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
654			wname = strlen(pp->lg_name);
655			if (wname > wmax)
656				wmax = wname;
657		}
658	}
659	wname = wmax;
660	pp = LIST_FIRST(&gp->lg_consumer)->lg_provider;
661	secsz = pp->lg_sectorsize;
662	printf("=>%*jd  %*jd  %*s  %s  (%s)%s\n",
663	    wblocks, (intmax_t)first, wblocks, (intmax_t)(last - first + 1),
664	    wname, gp->lg_name,
665	    scheme, fmtsize(pp->lg_mediasize),
666	    s ? " [CORRUPT]": "");
667
668	while ((pp = find_provider(gp, first)) != NULL) {
669		s = find_provcfg(pp, "start");
670		sector = (off_t)strtoimax(s, NULL, 0);
671
672		s = find_provcfg(pp, "end");
673		end = (off_t)strtoimax(s, NULL, 0);
674		length = end - sector + 1;
675
676		s = find_provcfg(pp, "index");
677		idx = atoi(s);
678		if (first < sector) {
679			printf("  %*jd  %*jd  %*s  - free -  (%s)\n",
680			    wblocks, (intmax_t)first, wblocks,
681			    (intmax_t)(sector - first), wname, "",
682			    fmtsize((sector - first) * secsz));
683		}
684		if (show_providers) {
685			printf("  %*jd  %*jd  %*s  %s %s (%s)\n",
686			    wblocks, (intmax_t)sector, wblocks,
687			    (intmax_t)length, wname, pp->lg_name,
688			    find_provcfg(pp, element), fmtattrib(pp),
689			    fmtsize(pp->lg_mediasize));
690		} else
691			printf("  %*jd  %*jd  %*d  %s %s (%s)\n",
692			    wblocks, (intmax_t)sector, wblocks,
693			    (intmax_t)length, wname, idx,
694			    find_provcfg(pp, element), fmtattrib(pp),
695			    fmtsize(pp->lg_mediasize));
696		first = end + 1;
697	}
698	if (first <= last) {
699		length = last - first + 1;
700		printf("  %*jd  %*jd  %*s  - free -  (%s)\n",
701		    wblocks, (intmax_t)first, wblocks, (intmax_t)length,
702		    wname, "",
703		    fmtsize(length * secsz));
704	}
705	printf("\n");
706}
707
708static int
709gpart_show_hasopt(struct gctl_req *req, const char *opt, const char *elt)
710{
711
712	if (!gctl_get_int(req, "%s", opt))
713		return (0);
714
715	if (elt != NULL)
716		errx(EXIT_FAILURE, "-l and -r are mutually exclusive");
717
718	return (1);
719}
720
721static void
722gpart_show(struct gctl_req *req, unsigned int fl __unused)
723{
724	struct gmesh mesh;
725	struct gclass *classp;
726	struct ggeom *gp;
727	const char *element, *name;
728	int error, i, nargs, show_providers;
729
730	element = NULL;
731	if (gpart_show_hasopt(req, "show_label", element))
732		element = "label";
733	if (gpart_show_hasopt(req, "show_rawtype", element))
734		element = "rawtype";
735	if (element == NULL)
736		element = "type";
737
738	name = gctl_get_ascii(req, "class");
739	if (name == NULL)
740		abort();
741	nargs = gctl_get_int(req, "nargs");
742	if (nargs == 1) {
743		error = geom_gettree_geom(&mesh, name,
744		    gctl_get_ascii(req, "arg0"), 1);
745	} else
746		error = geom_gettree(&mesh);
747	if (error != 0)
748		errc(EXIT_FAILURE, error, "Cannot get GEOM tree");
749	classp = find_class(&mesh, name);
750	if (classp == NULL) {
751		geom_deletetree(&mesh);
752		errx(EXIT_FAILURE, "Class %s not found.", name);
753	}
754	show_providers = gctl_get_int(req, "show_providers");
755	if (nargs > 0) {
756		for (i = 0; i < nargs; i++) {
757			name = gctl_get_ascii(req, "arg%d", i);
758			gp = find_geom(classp, name);
759			if (gp != NULL)
760				gpart_show_geom(gp, element, show_providers);
761			else
762				errx(EXIT_FAILURE, "No such geom: %s.", name);
763		}
764	} else {
765		LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
766			gpart_show_geom(gp, element, show_providers);
767		}
768	}
769	geom_deletetree(&mesh);
770}
771
772static void
773gpart_backup(struct gctl_req *req, unsigned int fl __unused)
774{
775	struct gmesh mesh;
776	struct gclass *classp;
777	struct gprovider *pp;
778	struct ggeom *gp;
779	const char *g, *s, *scheme;
780	off_t sector, end;
781	off_t length;
782	int error, i, windex, wblocks, wtype;
783
784	if (gctl_get_int(req, "nargs") != 1)
785		errx(EXIT_FAILURE, "Invalid number of arguments.");
786	s = gctl_get_ascii(req, "class");
787	if (s == NULL)
788		abort();
789	g = gctl_get_ascii(req, "arg0");
790	if (g == NULL)
791		abort();
792	error = geom_gettree_geom(&mesh, s, g, 0);
793	if (error != 0)
794		errc(EXIT_FAILURE, error, "Cannot get GEOM tree");
795	classp = find_class(&mesh, s);
796	if (classp == NULL) {
797		geom_deletetree(&mesh);
798		errx(EXIT_FAILURE, "Class %s not found.", s);
799	}
800	gp = find_geom(classp, g);
801	if (gp == NULL)
802		errx(EXIT_FAILURE, "No such geom: %s.", g);
803	scheme = find_geomcfg(gp, "scheme");
804	if (scheme == NULL)
805		abort();
806	s = find_geomcfg(gp, "last");
807	if (s == NULL)
808		abort();
809	wblocks = strlen(s);
810	wtype = 0;
811	LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
812		s = find_provcfg(pp, "type");
813		i = strlen(s);
814		if (i > wtype)
815			wtype = i;
816	}
817	s = find_geomcfg(gp, "entries");
818	if (s == NULL)
819		abort();
820	windex = strlen(s);
821	printf("%s %s\n", scheme, s);
822	LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
823		s = find_provcfg(pp, "start");
824		sector = (off_t)strtoimax(s, NULL, 0);
825
826		s = find_provcfg(pp, "end");
827		end = (off_t)strtoimax(s, NULL, 0);
828		length = end - sector + 1;
829
830		s = find_provcfg(pp, "label");
831		printf("%-*s %*s %*jd %*jd %s %s\n",
832		    windex, find_provcfg(pp, "index"),
833		    wtype, find_provcfg(pp, "type"),
834		    wblocks, (intmax_t)sector,
835		    wblocks, (intmax_t)length,
836		    (s != NULL) ? s: "", fmtattrib(pp));
837	}
838	geom_deletetree(&mesh);
839}
840
841static int
842skip_line(const char *p)
843{
844
845	while (*p != '\0') {
846		if (*p == '#')
847			return (1);
848		if (isspace(*p) == 0)
849			return (0);
850		p++;
851	}
852	return (1);
853}
854
855static void
856gpart_sighndl(int sig __unused)
857{
858	undo_restore = 1;
859}
860
861static void
862gpart_restore(struct gctl_req *req, unsigned int fl __unused)
863{
864	struct gmesh mesh;
865	struct gclass *classp;
866	struct gctl_req *r;
867	struct ggeom *gp;
868	struct sigaction si_sa;
869	const char *s, *flags, *errstr, *label;
870	char **ap, *argv[6], line[BUFSIZ], *pline;
871	int error, forced, i, l, nargs, created, rl;
872	intmax_t n;
873
874	nargs = gctl_get_int(req, "nargs");
875	if (nargs < 1)
876		errx(EXIT_FAILURE, "Invalid number of arguments.");
877
878	forced = gctl_get_int(req, "force");
879	flags = gctl_get_ascii(req, "flags");
880	rl = gctl_get_int(req, "restore_labels");
881	s = gctl_get_ascii(req, "class");
882	if (s == NULL)
883		abort();
884	error = geom_gettree(&mesh);
885	if (error != 0)
886		errc(EXIT_FAILURE, error, "Cannot get GEOM tree");
887	classp = find_class(&mesh, s);
888	if (classp == NULL) {
889		geom_deletetree(&mesh);
890		errx(EXIT_FAILURE, "Class %s not found.", s);
891	}
892
893	sigemptyset(&si_sa.sa_mask);
894	si_sa.sa_flags = 0;
895	si_sa.sa_handler = gpart_sighndl;
896	if (sigaction(SIGINT, &si_sa, 0) == -1)
897		err(EXIT_FAILURE, "sigaction SIGINT");
898
899	if (forced) {
900		/* destroy existent partition table before restore */
901		for (i = 0; i < nargs; i++) {
902			s = gctl_get_ascii(req, "arg%d", i);
903			gp = find_geom(classp, s);
904			if (gp != NULL) {
905				r = gctl_get_handle();
906				gctl_ro_param(r, "class", -1,
907				    classp->lg_name);
908				gctl_ro_param(r, "verb", -1, "destroy");
909				gctl_ro_param(r, "flags", -1, "restore");
910				gctl_ro_param(r, "force", sizeof(forced),
911				    &forced);
912				gctl_ro_param(r, "arg0", -1, s);
913				errstr = gctl_issue(r);
914				if (errstr != NULL && errstr[0] != '\0') {
915					gpart_print_error(errstr);
916					gctl_free(r);
917					goto backout;
918				}
919				gctl_free(r);
920			}
921		}
922	}
923	created = 0;
924	while (undo_restore == 0 &&
925	    fgets(line, sizeof(line) - 1, stdin) != NULL) {
926		/* Format of backup entries:
927		 * <scheme name> <number of entries>
928		 * <index> <type> <start> <size> [label] ['['attrib[,attrib]']']
929		 */
930		pline = (char *)line;
931		pline[strlen(line) - 1] = 0;
932		if (skip_line(pline))
933			continue;
934		for (ap = argv;
935		    (*ap = strsep(&pline, " \t")) != NULL;)
936			if (**ap != '\0' && ++ap >= &argv[6])
937				break;
938		l = ap - &argv[0];
939		label = pline = NULL;
940		if (l == 1 || l == 2) { /* create table */
941			if (created)
942				errx(EXIT_FAILURE, "Incorrect backup format.");
943			if (l == 2)
944				n = strtoimax(argv[1], NULL, 0);
945			for (i = 0; i < nargs; i++) {
946				s = gctl_get_ascii(req, "arg%d", i);
947				r = gctl_get_handle();
948				gctl_ro_param(r, "class", -1,
949				    classp->lg_name);
950				gctl_ro_param(r, "verb", -1, "create");
951				gctl_ro_param(r, "scheme", -1, argv[0]);
952				if (l == 2)
953					gctl_ro_param(r, "entries",
954					    sizeof(n), &n);
955				gctl_ro_param(r, "flags", -1, "restore");
956				gctl_ro_param(r, "arg0", -1, s);
957				errstr = gctl_issue(r);
958				if (errstr != NULL && errstr[0] != '\0') {
959					gpart_print_error(errstr);
960					gctl_free(r);
961					goto backout;
962				}
963				gctl_free(r);
964			}
965			created = 1;
966			continue;
967		} else if (l < 4 || created == 0)
968			errx(EXIT_FAILURE, "Incorrect backup format.");
969		else if (l == 5) {
970			if (strchr(argv[4], '[') == NULL)
971				label = argv[4];
972			else
973				pline = argv[4];
974		} else if (l == 6) {
975			label = argv[4];
976			pline = argv[5];
977		}
978		/* Add partitions to each table */
979		for (i = 0; i < nargs; i++) {
980			s = gctl_get_ascii(req, "arg%d", i);
981			r = gctl_get_handle();
982			n = strtoimax(argv[0], NULL, 0);
983			gctl_ro_param(r, "class", -1, classp->lg_name);
984			gctl_ro_param(r, "verb", -1, "add");
985			gctl_ro_param(r, "flags", -1, "restore");
986			gctl_ro_param(r, GPART_PARAM_INDEX, sizeof(n), &n);
987			gctl_ro_param(r, "type", -1, argv[1]);
988			gctl_ro_param(r, "start", -1, argv[2]);
989			gctl_ro_param(r, "size", -1, argv[3]);
990			if (rl != 0 && label != NULL)
991				gctl_ro_param(r, "label", -1, argv[4]);
992			gctl_ro_param(r, "alignment", -1, GPART_AUTOFILL);
993			gctl_ro_param(r, "arg0", -1, s);
994			error = gpart_autofill(r);
995			if (error != 0)
996				errc(EXIT_FAILURE, error, "autofill");
997			errstr = gctl_issue(r);
998			if (errstr != NULL && errstr[0] != '\0') {
999				gpart_print_error(errstr);
1000				gctl_free(r);
1001				goto backout;
1002			}
1003			gctl_free(r);
1004		}
1005		if (pline == NULL || *pline != '[')
1006			continue;
1007		/* set attributes */
1008		pline++;
1009		for (ap = argv;
1010		    (*ap = strsep(&pline, ",]")) != NULL;)
1011			if (**ap != '\0' && ++ap >= &argv[6])
1012				break;
1013		for (i = 0; i < nargs; i++) {
1014			l = ap - &argv[0];
1015			s = gctl_get_ascii(req, "arg%d", i);
1016			while (l > 0) {
1017				r = gctl_get_handle();
1018				gctl_ro_param(r, "class", -1, classp->lg_name);
1019				gctl_ro_param(r, "verb", -1, "set");
1020				gctl_ro_param(r, "flags", -1, "restore");
1021				gctl_ro_param(r, GPART_PARAM_INDEX,
1022				    sizeof(n), &n);
1023				gctl_ro_param(r, "attrib", -1, argv[--l]);
1024				gctl_ro_param(r, "arg0", -1, s);
1025				errstr = gctl_issue(r);
1026				if (errstr != NULL && errstr[0] != '\0') {
1027					gpart_print_error(errstr);
1028					gctl_free(r);
1029					goto backout;
1030				}
1031				gctl_free(r);
1032			}
1033		}
1034	}
1035	if (undo_restore)
1036		goto backout;
1037	/* commit changes if needed */
1038	if (strchr(flags, 'C') != NULL) {
1039		for (i = 0; i < nargs; i++) {
1040			s = gctl_get_ascii(req, "arg%d", i);
1041			r = gctl_get_handle();
1042			gctl_ro_param(r, "class", -1, classp->lg_name);
1043			gctl_ro_param(r, "verb", -1, "commit");
1044			gctl_ro_param(r, "arg0", -1, s);
1045			errstr = gctl_issue(r);
1046			if (errstr != NULL && errstr[0] != '\0') {
1047				gpart_print_error(errstr);
1048				gctl_free(r);
1049				goto backout;
1050			}
1051			gctl_free(r);
1052		}
1053	}
1054	gctl_free(req);
1055	geom_deletetree(&mesh);
1056	exit(EXIT_SUCCESS);
1057
1058backout:
1059	for (i = 0; i < nargs; i++) {
1060		s = gctl_get_ascii(req, "arg%d", i);
1061		r = gctl_get_handle();
1062		gctl_ro_param(r, "class", -1, classp->lg_name);
1063		gctl_ro_param(r, "verb", -1, "undo");
1064		gctl_ro_param(r, "arg0", -1, s);
1065		gctl_issue(r);
1066		gctl_free(r);
1067	}
1068	gctl_free(req);
1069	geom_deletetree(&mesh);
1070	exit(EXIT_FAILURE);
1071}
1072
1073static void *
1074gpart_bootfile_read(const char *bootfile, ssize_t *size)
1075{
1076	struct stat sb;
1077	void *code;
1078	int fd;
1079
1080	if (stat(bootfile, &sb) == -1)
1081		err(EXIT_FAILURE, "%s", bootfile);
1082	if (!S_ISREG(sb.st_mode))
1083		errx(EXIT_FAILURE, "%s: not a regular file", bootfile);
1084	if (sb.st_size == 0)
1085		errx(EXIT_FAILURE, "%s: empty file", bootfile);
1086	if (*size > 0 && sb.st_size > *size)
1087		errx(EXIT_FAILURE, "%s: file too big (%zu limit)", bootfile,
1088		    *size);
1089
1090	*size = sb.st_size;
1091
1092	fd = open(bootfile, O_RDONLY);
1093	if (fd == -1)
1094		err(EXIT_FAILURE, "%s", bootfile);
1095	code = malloc(*size);
1096	if (code == NULL)
1097		err(EXIT_FAILURE, NULL);
1098	if (read(fd, code, *size) != *size)
1099		err(EXIT_FAILURE, "%s", bootfile);
1100	close(fd);
1101
1102	return (code);
1103}
1104
1105static void
1106gpart_write_partcode(struct gctl_req *req, int idx, void *code, ssize_t size)
1107{
1108	char dsf[128];
1109	struct gmesh mesh;
1110	struct gclass *classp;
1111	struct ggeom *gp;
1112	struct gprovider *pp;
1113	const char *g, *s;
1114	char *buf;
1115	off_t bsize;
1116	int error, fd;
1117
1118	s = gctl_get_ascii(req, "class");
1119	if (s == NULL)
1120		abort();
1121	g = gctl_get_ascii(req, "arg0");
1122	if (g == NULL)
1123		abort();
1124	error = geom_gettree_geom(&mesh, s, g, 0);
1125	if (error != 0)
1126		errc(EXIT_FAILURE, error, "Cannot get GEOM tree");
1127	classp = find_class(&mesh, s);
1128	if (classp == NULL) {
1129		geom_deletetree(&mesh);
1130		errx(EXIT_FAILURE, "Class %s not found.", s);
1131	}
1132	gp = find_geom(classp, g);
1133	if (gp == NULL)
1134		errx(EXIT_FAILURE, "No such geom: %s.", g);
1135	s = find_geomcfg(gp, "scheme");
1136	if (s == NULL)
1137		errx(EXIT_FAILURE, "Scheme not found for geom %s", gp->lg_name);
1138
1139	LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
1140		s = find_provcfg(pp, "index");
1141		if (s == NULL)
1142			continue;
1143		if (atoi(s) == idx)
1144			break;
1145	}
1146
1147	if (pp != NULL) {
1148		snprintf(dsf, sizeof(dsf), "/dev/%s", pp->lg_name);
1149		if (pp->lg_mediasize < size)
1150			errx(EXIT_FAILURE, "%s: not enough space", dsf);
1151		fd = open(dsf, O_WRONLY);
1152		if (fd == -1)
1153			err(EXIT_FAILURE, "%s", dsf);
1154		/*
1155		 * When writing to a disk device, the write must be
1156		 * sector aligned and not write to any partial sectors,
1157		 * so round up the buffer size to the next sector and zero it.
1158		 */
1159		bsize = (size + pp->lg_sectorsize - 1) /
1160		    pp->lg_sectorsize * pp->lg_sectorsize;
1161		buf = calloc(1, bsize);
1162		if (buf == NULL)
1163			err(EXIT_FAILURE, "%s", dsf);
1164		bcopy(code, buf, size);
1165		if (write(fd, buf, bsize) != bsize)
1166			err(EXIT_FAILURE, "%s", dsf);
1167		free(buf);
1168		close(fd);
1169		printf("partcode written to %s\n", pp->lg_name);
1170	} else
1171		errx(EXIT_FAILURE, "invalid partition index");
1172
1173	geom_deletetree(&mesh);
1174}
1175
1176static void
1177gpart_bootcode(struct gctl_req *req, unsigned int fl)
1178{
1179	const char *s;
1180	void *bootcode, *partcode;
1181	size_t bootsize, partsize;
1182	int error, idx;
1183
1184	if (gctl_get_int(req, "nargs") != 1)
1185		errx(EXIT_FAILURE, "Invalid number of arguments.");
1186
1187	if (gctl_has_param(req, GPART_PARAM_BOOTCODE)) {
1188		s = gctl_get_ascii(req, GPART_PARAM_BOOTCODE);
1189		bootsize = 800 * 1024;		/* Arbitrary limit. */
1190		bootcode = gpart_bootfile_read(s, &bootsize);
1191		error = gctl_change_param(req, GPART_PARAM_BOOTCODE, bootsize,
1192		    bootcode);
1193		if (error)
1194			errc(EXIT_FAILURE, error, "internal error");
1195	} else
1196		bootcode = NULL;
1197
1198	if (!gctl_has_param(req, GPART_PARAM_PARTCODE)) {
1199		if (bootcode == NULL)
1200			errx(EXIT_FAILURE, "neither -b nor -p specified");
1201		if (gctl_has_param(req, GPART_PARAM_INDEX))
1202			errx(EXIT_FAILURE, "-i is only valid with -p");
1203		goto nopartcode;
1204	}
1205
1206	if (gctl_has_param(req, GPART_PARAM_INDEX)) {
1207		idx = (int)gctl_get_intmax(req, GPART_PARAM_INDEX);
1208		if (idx < 1)
1209			errx(EXIT_FAILURE, "invalid partition index");
1210		error = gctl_delete_param(req, GPART_PARAM_INDEX);
1211		if (error)
1212			errc(EXIT_FAILURE, error, "internal error");
1213	} else
1214		idx = 0;
1215
1216	if (gctl_has_param(req, GPART_PARAM_PARTCODE)) {
1217		s = gctl_get_ascii(req, GPART_PARAM_PARTCODE);
1218		partsize = 1024 * 1024;		/* Arbitrary limit. */
1219		partcode = gpart_bootfile_read(s, &partsize);
1220		error = gctl_delete_param(req, GPART_PARAM_PARTCODE);
1221		if (error)
1222			errc(EXIT_FAILURE, error, "internal error");
1223		if (idx == 0)
1224			errx(EXIT_FAILURE, "missing -i option");
1225		gpart_write_partcode(req, idx, partcode, partsize);
1226		free(partcode);
1227	}
1228
1229nopartcode:
1230	if (bootcode != NULL)
1231		gpart_issue(req, fl);
1232}
1233
1234static void
1235gpart_print_error(const char *errstr)
1236{
1237	char *errmsg;
1238	int error;
1239
1240	error = strtol(errstr, &errmsg, 0);
1241	if (errmsg != errstr) {
1242		while (errmsg[0] == ' ')
1243			errmsg++;
1244		if (errmsg[0] != '\0')
1245			warnc(error, "%s", errmsg);
1246		else
1247			warnc(error, NULL);
1248	} else
1249		warnx("%s", errmsg);
1250}
1251
1252static _Noreturn void
1253gpart_issue(struct gctl_req *req, unsigned int fl __unused)
1254{
1255	char buf[4096];
1256	const char *errstr;
1257	int error, status;
1258
1259	if (gctl_get_int(req, "nargs") != 1)
1260		errx(EXIT_FAILURE, "Invalid number of arguments.");
1261	(void)gctl_delete_param(req, "nargs");
1262
1263	/* autofill parameters (if applicable). */
1264	error = gpart_autofill(req);
1265	if (error) {
1266		warnc(error, "autofill");
1267		status = EXIT_FAILURE;
1268		goto done;
1269	}
1270
1271	buf[0] = '\0';
1272	gctl_add_param(req, "output", sizeof(buf), buf,
1273	    GCTL_PARAM_WR | GCTL_PARAM_ASCII);
1274	errstr = gctl_issue(req);
1275	if (errstr == NULL || errstr[0] == '\0') {
1276		if (buf[0] != '\0')
1277			printf("%s", buf);
1278		status = EXIT_SUCCESS;
1279		goto done;
1280	}
1281
1282	gpart_print_error(errstr);
1283	status = EXIT_FAILURE;
1284
1285 done:
1286	gctl_free(req);
1287	exit(status);
1288}
1289