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 * 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 * 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 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 * 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 * 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 * 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 * 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 * 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 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 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 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 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 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 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 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 856 gpart_sighndl(int sig __unused) 857 { 858 undo_restore = 1; 859 } 860 861 static void 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 * 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 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 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 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 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