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
59 uint32_t PUBSYM(lib_version) = G_LIB_VERSION;
60 uint32_t PUBSYM(version) = 0;
61
62 static char sstart[32];
63 static char ssize[32];
64 volatile 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
74 static struct gclass *find_class(struct gmesh *, const char *);
75 static struct ggeom * find_geom(struct gclass *, const char *);
76 static int geom_is_withered(struct ggeom *);
77 static const char *find_geomcfg(struct ggeom *, const char *);
78 static const char *find_provcfg(struct gprovider *, const char *);
79 static struct gprovider *find_provider(struct ggeom *, off_t);
80 static const char *fmtsize(int64_t);
81 static int gpart_autofill(struct gctl_req *);
82 static int gpart_autofill_resize(struct gctl_req *);
83 static void gpart_bootcode(struct gctl_req *, unsigned int);
84 static void *gpart_bootfile_read(const char *, ssize_t *);
85 static _Noreturn void gpart_issue(struct gctl_req *, unsigned int);
86 static void gpart_show(struct gctl_req *, unsigned int);
87 static void gpart_show_geom(struct ggeom *, const char *, int);
88 static int gpart_show_hasopt(struct gctl_req *, const char *, const char *);
89 static void gpart_write_partcode(struct gctl_req *, int, void *, ssize_t);
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);
93
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 },
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
196 static struct gclass *
find_class(struct gmesh * mesh,const char * name)197 find_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
208 static struct ggeom *
find_geom(struct gclass * classp,const char * name)209 find_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
227 static int
geom_is_withered(struct ggeom * gp)228 geom_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
239 static const char *
find_geomcfg(struct ggeom * gp,const char * cfg)240 find_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
251 static const char *
find_provcfg(struct gprovider * pp,const char * cfg)252 find_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
263 static struct gprovider *
find_provider(struct ggeom * gp,off_t minsector)264 find_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
286 static const char *
fmtsize(int64_t rawsz)287 fmtsize(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
296 static const char *
fmtattrib(struct gprovider * pp)297 fmtattrib(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
319 static int
gpart_autofill_resize(struct gctl_req * req)320 gpart_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 }
435 done:
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
442 static int
gpart_autofill(struct gctl_req * req)443 gpart_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 */
612 done:
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
621 static void
gpart_show_geom(struct ggeom * gp,const char * element,int show_providers)622 gpart_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
708 static int
gpart_show_hasopt(struct gctl_req * req,const char * opt,const char * elt)709 gpart_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
721 static void
gpart_show(struct gctl_req * req,unsigned int fl __unused)722 gpart_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
772 static void
gpart_backup(struct gctl_req * req,unsigned int fl __unused)773 gpart_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
841 static int
skip_line(const char * p)842 skip_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
855 static void
gpart_sighndl(int sig __unused)856 gpart_sighndl(int sig __unused)
857 {
858 undo_restore = 1;
859 }
860
861 static void
gpart_restore(struct gctl_req * req,unsigned int fl __unused)862 gpart_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
1058 backout:
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
1073 static void *
gpart_bootfile_read(const char * bootfile,ssize_t * size)1074 gpart_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
1105 static void
gpart_write_partcode(struct gctl_req * req,int idx,void * code,ssize_t size)1106 gpart_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
1176 static void
gpart_bootcode(struct gctl_req * req,unsigned int fl)1177 gpart_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
1229 nopartcode:
1230 if (bootcode != NULL)
1231 gpart_issue(req, fl);
1232 }
1233
1234 static void
gpart_print_error(const char * errstr)1235 gpart_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
1252 static _Noreturn void
gpart_issue(struct gctl_req * req,unsigned int fl __unused)1253 gpart_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