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