1 /* $NetBSD: part_edit.c,v 1.27 2022/05/15 15:06:59 jmcneill Exp $ */ 2 3 /* 4 * Copyright (c) 2019 The NetBSD Foundation, Inc. 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 NETBSD FOUNDATION, INC. AND CONTRIBUTORS 17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 * POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 30 /* part_edit.c -- generic partition editing code */ 31 32 #include <sys/param.h> 33 #include <sys/types.h> 34 #include <assert.h> 35 #include <stdio.h> 36 #include <unistd.h> 37 #include <fcntl.h> 38 #include <util.h> 39 #include "defs.h" 40 #include "md.h" 41 #include "msg_defs.h" 42 #include "menu_defs.h" 43 #include "defsizes.h" 44 #include "endian.h" 45 46 47 /* 48 * A structure passed to various menu functions for partition editing 49 */ 50 struct part_edit_info { 51 struct disk_partitions *parts; /* the partitions we edit */ 52 struct disk_part_info cur; /* current value (maybe incomplete) */ 53 part_id cur_id; /* which partition is it? */ 54 int first_custom_opt; /* scheme specific menu options 55 * start here */ 56 bool cancelled; /* do not apply changes */ 57 bool num_changed; /* number of partitions has changed */ 58 }; 59 60 #ifndef NO_CLONES 61 struct single_clone_data { 62 struct selected_partitions clone_src; 63 part_id *clone_ids; /* partition IDs in target */ 64 }; 65 #endif 66 struct outer_parts_data { 67 struct arg_rv av; 68 #ifndef NO_CLONES 69 struct single_clone_data *clones; 70 size_t num_clone_entries; 71 #endif 72 }; 73 74 static menu_ent *part_menu_opts; /* the currently edited partitions */ 75 static menu_ent *outer_fill_part_menu_opts(const struct disk_partitions *parts, size_t *cnt); 76 static void draw_outer_part_line(menudesc *m, int opt, void *arg); 77 78 static char outer_part_sep_line[MENUSTRSIZE], 79 outer_part_title[2*MENUSTRSIZE]; 80 81 static int 82 maxline(const char *p, int *count) 83 { 84 int m = 0, i = 0; 85 86 for (;; p++) { 87 if (*p == '\n' || *p == 0) { 88 if (i > m) 89 m = i; 90 (*count)++; 91 if (*p == 0) 92 return m; 93 i = 0; 94 } else { 95 i++; 96 } 97 } 98 } 99 100 int 101 err_msg_win(const char *errmsg) 102 { 103 const char *cont; 104 int l, l1, lines; 105 106 errmsg = msg_string(errmsg); 107 cont = msg_string(MSG_Hit_enter_to_continue); 108 109 lines = 0; 110 l = maxline(errmsg, &lines); 111 l1 = maxline(cont, &lines); 112 if (l < l1) 113 l = l1; 114 115 msg_fmt_prompt_win("%s.\n%s", -1, 18, l + 5, 2+lines, 116 NULL, NULL, 1, "%s%s", errmsg, cont); 117 return 0; 118 } 119 120 static int 121 set_part_type(menudesc *m, void *arg) 122 { 123 struct part_edit_info *info = arg; 124 const struct part_type_desc *desc; 125 char buf[STRSIZE]; 126 const char *err; 127 128 if (m->cursel == 0) 129 return 1; /* no change */ 130 131 desc = info->parts->pscheme->get_part_type(m->cursel-1); 132 if (desc == NULL) { 133 /* Create custom type */ 134 if (info->cur.nat_type != NULL) 135 strlcpy(buf, info->cur.nat_type->short_desc, 136 sizeof(buf)); 137 else 138 buf[0] = 0; 139 for (;;) { 140 msg_prompt_win(info->parts->pscheme->new_type_prompt, 141 -1, 18, 0, 0, 142 buf, buf, sizeof(buf)); 143 if (buf[0] == 0) 144 break; 145 desc = info->parts->pscheme->create_custom_part_type( 146 buf, &err); 147 if (desc != NULL) 148 break; 149 err_msg_win(err); 150 } 151 } 152 153 info->cur.nat_type = desc; 154 return 1; 155 } 156 157 static void 158 set_type_label(menudesc *m, int opt, void *arg) 159 { 160 struct part_edit_info *info = arg; 161 const struct part_type_desc *desc; 162 163 if (opt == 0) { 164 wprintw(m->mw, "%s", msg_string(MSG_Dont_change)); 165 return; 166 } 167 168 desc = info->parts->pscheme->get_part_type(opt-1); 169 if (desc == NULL) { 170 wprintw(m->mw, "%s", msg_string(MSG_Other_kind)); 171 return; 172 } 173 wprintw(m->mw, "%s", desc->description); 174 } 175 176 static int 177 edit_part_type(menudesc *m, void *arg) 178 { 179 struct part_edit_info *info = arg; 180 menu_ent *type_opts; 181 int type_menu = -1; 182 size_t popt_cnt, i; 183 184 /* 185 * We add one line at the start of the menu, and one at the 186 * bottom, see "set_type_label" above. 187 */ 188 popt_cnt = info->parts->pscheme->get_part_types_count() + 2; 189 type_opts = calloc(popt_cnt, sizeof(*type_opts)); 190 for (i = 0; i < popt_cnt; i++) { 191 type_opts[i].opt_action = set_part_type; 192 } 193 type_menu = new_menu(NULL, type_opts, popt_cnt, 194 13, 12, 0, 30, 195 MC_SUBMENU | MC_SCROLL | MC_NOEXITOPT | MC_NOCLEAR, 196 NULL, set_type_label, NULL, 197 NULL, NULL); 198 199 if (type_menu != -1) { 200 process_menu(type_menu, arg); 201 info->num_changed = true; /* force reload of menu */ 202 } 203 204 free_menu(type_menu); 205 free(type_opts); 206 207 return -1; 208 } 209 210 static int 211 edit_part_start(menudesc *m, void *arg) 212 { 213 struct part_edit_info *marg = arg; 214 struct disk_part_info pinfo; 215 daddr_t max_size; 216 217 if (marg->cur_id == NO_PART || 218 !marg->parts->pscheme->get_part_info(marg->parts, marg->cur_id, 219 &pinfo)) 220 pinfo = marg->cur; 221 marg->cur.start = getpartoff(marg->parts, marg->cur.start); 222 max_size = marg->parts->pscheme->max_free_space_at(marg->parts, 223 pinfo.start); 224 max_size += pinfo.start - marg->cur.start; 225 if (marg->cur.size > max_size) 226 marg->cur.size = max_size; 227 228 return 0; 229 } 230 231 static int 232 edit_part_size(menudesc *m, void *arg) 233 { 234 struct part_edit_info *marg = arg; 235 struct disk_part_info pinfo; 236 237 if (marg->cur_id == NO_PART || 238 !marg->parts->pscheme->get_part_info(marg->parts, marg->cur_id, 239 &pinfo)) 240 pinfo = marg->cur; 241 marg->cur.size = getpartsize(marg->parts, pinfo.start, 242 marg->cur.start, marg->cur.size); 243 244 return 0; 245 } 246 247 static int 248 edit_part_install(menudesc *m, void *arg) 249 { 250 struct part_edit_info *marg = arg; 251 252 marg->cur.flags ^= PTI_INSTALL_TARGET; 253 return 0; 254 } 255 256 static void 257 menu_opts_reload(menudesc *m, const struct disk_partitions *parts) 258 { 259 size_t new_num; 260 261 free(part_menu_opts); 262 part_menu_opts = outer_fill_part_menu_opts(parts, &new_num); 263 m->opts = part_menu_opts; 264 m->numopts = new_num; 265 } 266 267 static int 268 delete_part(menudesc *m, void *arg) 269 { 270 struct part_edit_info *marg = arg; 271 const char *err_msg = NULL; 272 273 if (marg->cur_id == NO_PART) 274 return 0; 275 276 if (!marg->parts->pscheme->delete_partition(marg->parts, marg->cur_id, 277 &err_msg)) 278 err_msg_win(err_msg); 279 280 marg->num_changed = true; /* reload list of partitions */ 281 marg->cancelled = true; /* do not write back cur data */ 282 283 return 0; 284 } 285 286 static void draw_outer_ptn_line(menudesc *m, int line, void *arg); 287 static void draw_outer_ptn_header(menudesc *m, void *arg); 288 289 static int 290 part_rollback(menudesc *m, void *arg) 291 { 292 struct part_edit_info *marg = arg; 293 294 marg->cancelled = true; 295 return 0; 296 } 297 298 static menu_ent common_ptn_edit_opts[] = { 299 #define PTN_OPT_TYPE 0 300 { .opt_action=edit_part_type }, 301 #define PTN_OPT_START 1 302 { .opt_action=edit_part_start }, 303 #define PTN_OPT_SIZE 2 304 { .opt_action=edit_part_size }, 305 #define PTN_OPT_END 3 306 { .opt_flags=OPT_IGNORE }, /* read only "end" */ 307 308 /* 309 * Only the part upto here will be used when adding a new partition 310 */ 311 312 #define PTN_OPT_INSTALL 4 313 { .opt_action=edit_part_install }, 314 315 #define PTN_OPTS_COMMON PTN_OPT_INSTALL /* cut off from here for add */ 316 }; 317 318 static int 319 edit_custom_opt(menudesc *m, void *arg) 320 { 321 struct part_edit_info *marg = arg; 322 size_t attr_no = m->cursel - marg->first_custom_opt; 323 char line[STRSIZE]; 324 325 switch (marg->parts->pscheme->custom_attributes[attr_no].type) { 326 case pet_bool: 327 marg->parts->pscheme->custom_attribute_toggle( 328 marg->parts, marg->cur_id, attr_no); 329 break; 330 case pet_cardinal: 331 case pet_str: 332 marg->parts->pscheme->format_custom_attribute( 333 marg->parts, marg->cur_id, attr_no, &marg->cur, 334 line, sizeof(line)); 335 msg_prompt_win( 336 marg->parts->pscheme->custom_attributes[attr_no].label, 337 -1, 18, 0, 0, line, line, sizeof(line)); 338 marg->parts->pscheme->custom_attribute_set_str( 339 marg->parts, marg->cur_id, attr_no, line); 340 break; 341 } 342 343 return 0; 344 } 345 346 static menu_ent ptn_edit_opts[] = { 347 { .opt_name=MSG_askunits, .opt_menu=MENU_sizechoice, 348 .opt_flags=OPT_SUB }, 349 350 { .opt_name=MSG_Delete_partition, 351 .opt_action = delete_part, .opt_flags = OPT_EXIT }, 352 353 { .opt_name=MSG_cancel, 354 .opt_action = part_rollback, .opt_flags = OPT_EXIT }, 355 }; 356 357 static menu_ent ptn_add_opts[] = { 358 { .opt_name=MSG_askunits, .opt_menu=MENU_sizechoice, 359 .opt_flags=OPT_SUB }, 360 361 { .opt_name=MSG_cancel, 362 .opt_action = part_rollback, .opt_flags = OPT_EXIT }, 363 }; 364 365 /* 366 * Concatenate common_ptn_edit_opts, the partitioning scheme specific 367 * custom options and the given suffix to a single menu options array. 368 */ 369 static menu_ent * 370 fill_part_edit_menu_opts(struct disk_partitions *parts, 371 bool with_custom_attrs, 372 const menu_ent *suffix, size_t suffix_count, size_t *res_cnt) 373 { 374 size_t i; 375 menu_ent *opts, *p; 376 size_t count, hdr_cnt; 377 378 if (with_custom_attrs) { 379 hdr_cnt = __arraycount(common_ptn_edit_opts); 380 count = hdr_cnt + parts->pscheme->custom_attribute_count 381 + suffix_count; 382 } else { 383 hdr_cnt = PTN_OPTS_COMMON; 384 count = hdr_cnt + suffix_count; 385 } 386 387 opts = calloc(count, sizeof(*opts)); 388 if (opts == NULL) { 389 *res_cnt = 0; 390 return NULL; 391 } 392 393 memcpy(opts, common_ptn_edit_opts, 394 sizeof(*opts)*hdr_cnt); 395 p = opts + hdr_cnt; 396 if (with_custom_attrs) { 397 for (i = 0; i < parts->pscheme->custom_attribute_count; i++) { 398 p->opt_action = edit_custom_opt; 399 p++; 400 } 401 } 402 memcpy(p, suffix, sizeof(*opts)*suffix_count); 403 404 *res_cnt = count; 405 return opts; 406 } 407 408 static int 409 edit_part_entry(menudesc *m, void *arg) 410 { 411 struct outer_parts_data *pdata = arg; 412 struct part_edit_info data = { .parts = pdata->av.arg, 413 .cur_id = m->cursel, 414 .first_custom_opt = __arraycount(common_ptn_edit_opts) }; 415 int ptn_menu; 416 const char *err; 417 menu_ent *opts; 418 size_t num_opts; 419 420 opts = fill_part_edit_menu_opts(data.parts, true, ptn_edit_opts, 421 __arraycount(ptn_edit_opts), &num_opts); 422 if (opts == NULL) 423 return 1; 424 425 if (data.cur_id < data.parts->num_part) 426 data.parts->pscheme->get_part_info(data.parts, data.cur_id, 427 &data.cur); 428 429 ptn_menu = new_menu(NULL, opts, num_opts, 430 15, 2, 0, 54, 431 MC_SUBMENU | MC_SCROLL | MC_NOCLEAR, 432 draw_outer_ptn_header, draw_outer_ptn_line, NULL, 433 NULL, MSG_Partition_OK); 434 if (ptn_menu == -1) { 435 free(opts); 436 return 1; 437 } 438 439 process_menu(ptn_menu, &data); 440 free_menu(ptn_menu); 441 free(opts); 442 443 if (!data.cancelled && data.cur_id < data.parts->num_part) 444 if (!data.parts->pscheme->set_part_info(data.parts, 445 data.cur_id, &data.cur, &err)) 446 err_msg_win(err); 447 448 if (data.num_changed) { 449 menu_opts_reload(m, data.parts); 450 m->cursel = data.parts->num_part > 0 ? 0 : 2; 451 return -1; 452 } 453 454 return 0; 455 } 456 457 #ifndef NO_CLONES 458 static int 459 add_part_clone(menudesc *menu, void *arg) 460 { 461 struct outer_parts_data *pdata = arg; 462 struct disk_partitions *parts = pdata->av.arg; 463 struct clone_target_menu_data data; 464 menu_ent *men; 465 int num_men, i; 466 struct disk_part_info sinfo, cinfo; 467 struct disk_partitions *csrc; 468 struct disk_part_free_space space; 469 daddr_t offset, align; 470 size_t s; 471 part_id cid; 472 struct selected_partitions selected; 473 struct single_clone_data *new_clones; 474 475 if (!select_partitions(&selected, parts)) 476 return 0; 477 478 new_clones = realloc(pdata->clones, 479 sizeof(*pdata->clones)*(pdata->num_clone_entries+1)); 480 if (new_clones == NULL) 481 return 0; 482 pdata->num_clone_entries++; 483 pdata->clones = new_clones; 484 new_clones += (pdata->num_clone_entries-1); 485 memset(new_clones, 0, sizeof *new_clones); 486 new_clones->clone_src = selected; 487 488 memset(&data, 0, sizeof data); 489 data.usage.parts = parts; 490 491 /* if we already have partitions, ask for the target position */ 492 if (parts->num_part > 0) { 493 data.res = -1; 494 num_men = parts->num_part+1; 495 men = calloc(num_men, sizeof *men); 496 if (men == NULL) 497 return 0; 498 for (i = 0; i < num_men; i++) 499 men[i].opt_action = clone_target_select; 500 men[num_men-1].opt_name = MSG_clone_target_end; 501 502 data.usage.menu = new_menu(MSG_clone_target_hdr, 503 men, num_men, 3, 2, 0, 65, MC_SCROLL, 504 NULL, draw_outer_part_line, NULL, NULL, MSG_cancel); 505 process_menu(data.usage.menu, &data); 506 free_menu(data.usage.menu); 507 free(men); 508 509 if (data.res < 0) 510 goto err; 511 } else { 512 data.res = 0; 513 } 514 515 /* find selected offset from data.res and insert clones there */ 516 align = parts->pscheme->get_part_alignment(parts); 517 offset = -1; 518 if (data.res > 0) { 519 for (cid = 0; cid < (size_t)data.res; cid++) { 520 if (!parts->pscheme->get_part_info(parts, cid, &sinfo)) 521 continue; 522 offset = sinfo.start + sinfo.size; 523 } 524 } else { 525 offset = 0; 526 } 527 528 new_clones->clone_ids = calloc(selected.num_sel, 529 sizeof(*new_clones->clone_ids)); 530 if (new_clones->clone_ids == NULL) 531 goto err; 532 for (s = 0; s < selected.num_sel; s++) { 533 csrc = selected.selection[s].parts; 534 cid = selected.selection[s].id; 535 csrc->pscheme->get_part_info(csrc, cid, &sinfo); 536 if (!parts->pscheme->adapt_foreign_part_info( 537 parts, &cinfo, csrc->pscheme, &sinfo)) 538 continue; 539 size_t cnt = parts->pscheme->get_free_spaces( 540 parts, &space, 1, cinfo.size-align, align, 541 offset, -1); 542 if (cnt == 0) 543 continue; 544 cinfo.start = space.start; 545 cid = parts->pscheme->add_partition( 546 parts, &cinfo, NULL); 547 new_clones->clone_ids[s] = cid; 548 if (cid == NO_PART) 549 continue; 550 parts->pscheme->get_part_info(parts, cid, &cinfo); 551 offset = roundup(cinfo.start+cinfo.size, align); 552 } 553 554 /* reload menu and start again */ 555 menu_opts_reload(menu, parts); 556 menu->cursel = parts->num_part+1; 557 if (parts->num_part == 0) 558 menu->cursel++; 559 return -1; 560 561 err: 562 free_selected_partitions(&selected); 563 return -1; 564 } 565 #endif 566 567 static int 568 add_part_entry(menudesc *m, void *arg) 569 { 570 struct outer_parts_data *pdata = arg; 571 struct part_edit_info data = { .parts = pdata->av.arg, 572 .first_custom_opt = PTN_OPTS_COMMON }; 573 int ptn_menu; 574 daddr_t ptn_alignment, start; 575 menu_ent *opts; 576 size_t num_opts; 577 struct disk_part_free_space space; 578 const char *err; 579 580 opts = fill_part_edit_menu_opts(data.parts, false, ptn_add_opts, 581 __arraycount(ptn_add_opts), &num_opts); 582 if (opts == NULL) 583 return 1; 584 585 ptn_alignment = data.parts->pscheme->get_part_alignment(data.parts); 586 start = pm->ptstart > 0 ? pm->ptstart : -1; 587 data.cur_id = NO_PART; 588 memset(&data.cur, 0, sizeof(data.cur)); 589 data.cur.nat_type = data.parts->pscheme-> 590 get_generic_part_type(PT_root); 591 if (data.parts->pscheme->get_free_spaces(data.parts, &space, 1, 592 max(sizemult, ptn_alignment), ptn_alignment, start, -1) > 0) { 593 data.cur.start = space.start; 594 data.cur.size = space.size; 595 } else { 596 return 0; 597 } 598 599 ptn_menu = new_menu(NULL, opts, num_opts, 600 15, -1, 0, 54, 601 MC_SUBMENU | MC_SCROLL | MC_NOCLEAR, 602 draw_outer_ptn_header, draw_outer_ptn_line, NULL, 603 NULL, MSG_Partition_OK); 604 if (ptn_menu == -1) { 605 free(opts); 606 return 1; 607 } 608 609 process_menu(ptn_menu, &data); 610 free_menu(ptn_menu); 611 free(opts); 612 613 if (!data.cancelled && 614 data.parts->pscheme->add_partition(data.parts, &data.cur, &err) 615 == NO_PART) 616 err_msg_win(err); 617 618 menu_opts_reload(m, data.parts); 619 m->cursel = data.parts->num_part+1; 620 if (data.parts->num_part == 0) 621 m->cursel++; 622 return -1; 623 } 624 625 static void 626 draw_outer_ptn_line(menudesc *m, int line, void *arg) 627 { 628 struct part_edit_info *marg = arg; 629 char value[STRSIZE]; 630 static int col_width; 631 static const char *yes, *no, *ptn_type, *ptn_start, *ptn_size, 632 *ptn_end, *ptn_install; 633 634 if (yes == NULL) { 635 int i; 636 637 #define CHECK(str) i = strlen(str); if (i > col_width) col_width = i; 638 639 col_width = 0; 640 yes = msg_string(MSG_Yes); CHECK(yes); 641 no = msg_string(MSG_No); CHECK(no); 642 ptn_type = msg_string(MSG_ptn_type); CHECK(ptn_type); 643 ptn_start = msg_string(MSG_ptn_start); CHECK(ptn_start); 644 ptn_size = msg_string(MSG_ptn_size); CHECK(ptn_size); 645 ptn_end = msg_string(MSG_ptn_end); CHECK(ptn_end); 646 ptn_install = msg_string(MSG_ptn_install); CHECK(ptn_install); 647 648 #undef CHECK 649 650 for (size_t n = 0; 651 n < marg->parts->pscheme->custom_attribute_count; n++) { 652 i = strlen(msg_string( 653 marg->parts->pscheme->custom_attributes[n].label)); 654 if (i > col_width) 655 col_width = i; 656 } 657 col_width += 3; 658 } 659 660 if (line >= marg->first_custom_opt) { 661 size_t attr_no = line-marg->first_custom_opt; 662 marg->parts->pscheme->format_custom_attribute( 663 marg->parts, marg->cur_id, attr_no, &marg->cur, 664 value, sizeof(value)); 665 wprintw(m->mw, "%*s : %s", col_width, 666 msg_string( 667 marg->parts->pscheme->custom_attributes[attr_no].label), 668 value); 669 return; 670 } 671 672 switch (line) { 673 case PTN_OPT_TYPE: 674 wprintw(m->mw, "%*s : %s", col_width, ptn_type, 675 marg->cur.nat_type != NULL 676 ? marg->cur.nat_type->description 677 : "-"); 678 break; 679 case PTN_OPT_START: 680 wprintw(m->mw, "%*s : %" PRIu64 " %s", col_width, ptn_start, 681 marg->cur.start / (daddr_t)sizemult, multname); 682 break; 683 case PTN_OPT_SIZE: 684 wprintw(m->mw, "%*s : %" PRIu64 " %s", col_width, ptn_size, 685 marg->cur.size / (daddr_t)sizemult, multname); 686 break; 687 case PTN_OPT_END: 688 wprintw(m->mw, "%*s : %" PRIu64 " %s", col_width, ptn_end, 689 (marg->cur.start + marg->cur.size - 1) / (daddr_t)sizemult, 690 multname); 691 break; 692 case PTN_OPT_INSTALL: 693 wprintw(m->mw, "%*s : %s", col_width, ptn_install, 694 (marg->cur.nat_type->generic_ptype == PT_root && 695 (marg->cur.flags & PTI_INSTALL_TARGET)) ? yes : no); 696 break; 697 } 698 699 } 700 701 static void 702 draw_outer_ptn_header(menudesc *m, void *arg) 703 { 704 struct part_edit_info *marg = arg; 705 size_t attr_no; 706 bool may_change_type; 707 708 #define DISABLE(opt,cond) \ 709 if (cond) \ 710 m->opts[opt].opt_flags |= OPT_IGNORE; \ 711 else \ 712 m->opts[opt].opt_flags &= ~OPT_IGNORE; 713 714 /* e.g. MBR extended partitions can only change if empty */ 715 may_change_type = marg->cur_id == NO_PART 716 || marg->parts->pscheme->part_type_can_change == NULL 717 || marg->parts->pscheme->part_type_can_change( 718 marg->parts, marg->cur_id); 719 720 DISABLE(PTN_OPT_TYPE, !may_change_type); 721 if (!may_change_type && m->cursel == PTN_OPT_TYPE) 722 m->cursel++; 723 if (marg->cur_id != NO_PART) { 724 for (int i = 0; i < m->numopts; i++) { 725 if (m->opts[i].opt_action == delete_part) { 726 DISABLE(i, !may_change_type); 727 } 728 } 729 } 730 731 /* Can only install into NetBSD partition */ 732 if (marg->cur_id != NO_PART) { 733 DISABLE(PTN_OPT_INSTALL, marg->cur.nat_type == NULL 734 || marg->cur.nat_type->generic_ptype != PT_root); 735 } 736 737 if (marg->cur_id == NO_PART) 738 return; 739 740 for (attr_no = 0; attr_no < 741 marg->parts->pscheme->custom_attribute_count; attr_no++) { 742 bool writable = 743 marg->parts->pscheme->custom_attribute_writable( 744 marg->parts, marg->cur_id, attr_no); 745 DISABLE(attr_no+marg->first_custom_opt, !writable); 746 } 747 } 748 749 static void 750 draw_outer_part_line(menudesc *m, int opt, void *arg) 751 { 752 struct outer_parts_data *pdata = arg; 753 struct disk_partitions *parts = pdata->av.arg; 754 int len; 755 part_id pno = opt; 756 struct disk_part_info info; 757 char buf[SSTRSIZE], *astr, colval[STRSIZE], line[STRSIZE]; 758 size_t astr_avail, x; 759 static char install_flag = 0; 760 761 #define PART_ROW_USED_FMT "%13" PRIu64 " %13" PRIu64 " %-4s" 762 763 len = snprintf(0, 0, PART_ROW_USED_FMT, (daddr_t)0, (daddr_t)0, ""); 764 765 if (pno >= parts->num_part || 766 !parts->pscheme->get_part_info(parts, pno, &info)) { 767 wprintw(m->mw, "%*s", len, ""); 768 // XXX 769 return; 770 } 771 772 if ((info.flags & PTI_INSTALL_TARGET) && 773 info.nat_type->generic_ptype == PT_root) { 774 if (install_flag == 0) 775 install_flag = msg_string(MSG_install_flag)[0]; 776 astr_avail = sizeof(buf)-1; 777 buf[0] = install_flag; 778 buf[1] = 0; 779 astr = buf+1; 780 } else { 781 buf[0] = 0; 782 astr = buf; 783 astr_avail = sizeof(buf); 784 } 785 if (parts->pscheme->get_part_attr_str != NULL) 786 parts->pscheme->get_part_attr_str(parts, pno, astr, 787 astr_avail); 788 789 daddr_t start = info.start / sizemult; 790 daddr_t size = info.size / sizemult; 791 wprintw(m->mw, PART_ROW_USED_FMT, 792 start, size, buf); 793 794 line[0] = 0; x = 0; 795 for (size_t col = 0; col < parts->pscheme->edit_columns_count; col++) { 796 if (parts->pscheme->format_partition_table_str(parts, pno, 797 col, colval, sizeof(colval)) && colval[0] != 0 798 && x < sizeof(line)-2) { 799 for (size_t i = strlen(line); i < x; i++) 800 line[i] = ' '; 801 line[x] = ' '; 802 strlcpy(line+x+1, colval, sizeof(line)-x-1); 803 } 804 x += parts->pscheme->edit_columns[col].width + 1; 805 } 806 wprintw(m->mw, "%s", line); 807 } 808 809 static int 810 part_edit_abort(menudesc *m, void *arg) 811 { 812 struct outer_parts_data *pdata = arg; 813 814 pdata->av.rv = -1; 815 return 0; 816 } 817 818 static menu_ent * 819 outer_fill_part_menu_opts(const struct disk_partitions *parts, size_t *cnt) 820 { 821 menu_ent *opts, *op; 822 size_t num_opts; 823 size_t i; 824 bool may_add; 825 826 may_add = parts->pscheme->can_add_partition(parts); 827 num_opts = 3 + parts->num_part; 828 #ifndef NO_CLONES 829 num_opts++; 830 #endif 831 if (parts->num_part == 0) 832 num_opts++; 833 if (may_add) 834 num_opts++; 835 opts = calloc(num_opts, sizeof *opts); 836 if (opts == NULL) { 837 *cnt = 0; 838 return NULL; 839 } 840 841 /* add all existing partitions */ 842 for (op = opts, i = 0; i < parts->num_part && i < (num_opts-2); 843 op++, i++) { 844 op->opt_flags = OPT_SUB; 845 op->opt_action = edit_part_entry; 846 } 847 848 /* if empty, hint that partitions are missing */ 849 if (parts->num_part == 0) { 850 op->opt_name = MSG_nopart; 851 op->opt_flags = OPT_IGNORE|OPT_NOSHORT; 852 op++; 853 } 854 855 /* separator line between partitions and actions */ 856 op->opt_name = outer_part_sep_line; 857 op->opt_flags = OPT_IGNORE|OPT_NOSHORT; 858 op++; 859 860 /* followed by new partition adder */ 861 if (may_add) { 862 op->opt_name = MSG_addpart; 863 op->opt_flags = OPT_SUB; 864 op->opt_action = add_part_entry; 865 op++; 866 } 867 868 #ifndef NO_CLONES 869 /* and a partition cloner */ 870 op->opt_name = MSG_clone_from_elsewhere; 871 op->opt_action = add_part_clone; 872 op++; 873 #endif 874 875 /* and unit changer */ 876 op->opt_name = MSG_askunits; 877 op->opt_menu = MENU_sizechoice; 878 op->opt_flags = OPT_SUB; 879 op->opt_action = NULL; 880 op++; 881 882 /* and abort option */ 883 op->opt_name = MSG_cancel; 884 op->opt_flags = OPT_EXIT; 885 op->opt_action = part_edit_abort; 886 op++; 887 888 /* counts are consistent? */ 889 assert((op - opts) >= 0 && (size_t)(op - opts) == num_opts); 890 891 *cnt = num_opts; 892 return opts; 893 } 894 895 static void 896 draw_outer_part_header(menudesc *m, void *arg) 897 { 898 struct outer_parts_data *pdata = arg; 899 struct disk_partitions *parts = pdata->av.arg; 900 char start[SSTRSIZE], size[SSTRSIZE], col[SSTRSIZE], 901 *disk_info, total[SSTRSIZE], avail[SSTRSIZE]; 902 size_t sep; 903 const char *args[3]; 904 905 msg_display_subst(MSG_editparttable, 4, 906 parts->disk, 907 msg_string(parts->pscheme->name), 908 msg_string(parts->pscheme->short_name), 909 parts->pscheme->part_flag_desc ? 910 msg_string(parts->pscheme->part_flag_desc) 911 : ""); 912 913 snprintf(total, sizeof(total), "%" PRIu64 " %s", 914 parts->disk_size / sizemult, multname); 915 snprintf(avail, sizeof(total), "%" PRIu64 " %s", 916 parts->free_space / sizemult, multname); 917 args[0] = parts->disk; 918 args[1] = total; 919 args[2] = avail; 920 disk_info = str_arg_subst(msg_string(MSG_part_header), 3, args); 921 msg_table_add(disk_info); 922 free(disk_info); 923 924 925 strcpy(outer_part_sep_line, "------------- ------------- ----"); 926 sep = strlen(outer_part_sep_line); 927 snprintf(start, sizeof(start), "%s(%s)", 928 msg_string(MSG_part_header_col_start), multname); 929 snprintf(size, sizeof(size), "%s(%s)", 930 msg_string(MSG_part_header_col_size), multname); 931 snprintf(outer_part_title, sizeof(outer_part_title), 932 " %13s %13s %-4s", start, size, 933 msg_string(MSG_part_header_col_flag)); 934 935 for (size_t i = 0; i < parts->pscheme->edit_columns_count; i++) { 936 char *np = outer_part_sep_line+sep; 937 unsigned int w = parts->pscheme->edit_columns[i].width; 938 snprintf(col, sizeof(col), " %*s", -w, 939 msg_string(parts->pscheme->edit_columns[i].title)); 940 strlcat(outer_part_title, col, sizeof(outer_part_title)); 941 if (sep < sizeof(outer_part_sep_line)-1) { 942 *np++ = ' '; 943 sep++; 944 } 945 for (unsigned int p = 0; p < w && 946 sep < sizeof(outer_part_sep_line)-1; p++) 947 *np++ = '-', sep++; 948 *np = 0; 949 } 950 951 strlcat(outer_part_title, "\n ", sizeof(outer_part_title)); 952 strlcat(outer_part_title, outer_part_sep_line, 953 sizeof(outer_part_title)); 954 955 msg_table_add("\n\n"); 956 } 957 958 /* 959 * Use the whole disk for NetBSD, but (if any) create required helper 960 * partitions (usually for booting and stuff). 961 */ 962 bool 963 parts_use_wholedisk(struct disk_partitions *parts, 964 size_t add_ext_parts, const struct disk_part_info *ext_parts) 965 { 966 part_id nbsd; 967 struct disk_part_info info; 968 struct disk_part_free_space space; 969 daddr_t align, start; 970 size_t i; 971 972 parts->pscheme->delete_all_partitions(parts); 973 align = parts->pscheme->get_part_alignment(parts); 974 start = pm->ptstart > 0 ? pm->ptstart : -1; 975 976 if (ext_parts != NULL) { 977 for (i = 0; i < add_ext_parts; i++) { 978 info = ext_parts[i]; 979 if (parts->pscheme->get_free_spaces(parts, &space, 980 1, info.size, align, start, -1) != 1) 981 return false; 982 info.start = space.start; 983 if (info.nat_type == NULL) 984 info.nat_type = parts->pscheme-> 985 get_fs_part_type(PT_undef, info.fs_type, 986 info.fs_sub_type); 987 if (parts->pscheme->add_partition(parts, &info, NULL) 988 == NO_PART) 989 return false; 990 } 991 } 992 993 if (parts->pscheme->get_free_spaces(parts, &space, 1, 3*align, 994 align, start, -1) != 1) 995 return false; 996 997 memset(&info, 0, sizeof(info)); 998 info.start = space.start; 999 info.size = space.size; 1000 info.flags = PTI_INSTALL_TARGET; 1001 if (parts->pscheme->secondary_scheme != NULL) 1002 info.flags |= PTI_SEC_CONTAINER; 1003 info.nat_type = parts->pscheme->get_generic_part_type(PT_root); 1004 nbsd = parts->pscheme->add_partition(parts, &info, NULL); 1005 1006 if (nbsd == NO_PART) 1007 return false; 1008 1009 if (!parts->pscheme->get_part_info(parts, nbsd, &info)) 1010 return false; 1011 1012 if (parts->pscheme->secondary_scheme != NULL) { 1013 /* force empty secondary partitions */ 1014 parts->pscheme->secondary_partitions(parts, info.start, true); 1015 } 1016 1017 return true; 1018 } 1019 1020 static int 1021 set_keep_existing(menudesc *m, void *arg) 1022 { 1023 ((arg_rep_int*)arg)->rv = LY_KEEPEXISTING; 1024 return 0; 1025 } 1026 1027 static int 1028 set_use_only_part(menudesc *m, void *arg) 1029 { 1030 ((arg_rep_int*)arg)->rv = LY_SETSIZES; 1031 return 0; 1032 } 1033 1034 static int 1035 set_use_entire_disk(menudesc *m, void *arg) 1036 { 1037 ((arg_rep_int*)arg)->rv = LY_USEFULL; 1038 return 0; 1039 } 1040 1041 static int 1042 set_switch_scheme(menudesc *m, void *arg) 1043 { 1044 ((arg_rep_int*)arg)->rv = LY_OTHERSCHEME; 1045 return 0; 1046 } 1047 1048 static enum layout_type 1049 ask_fullpart(struct disk_partitions *parts) 1050 { 1051 arg_rep_int ai; 1052 const char *args[2]; 1053 int menu; 1054 size_t num_opts; 1055 menu_ent options[4], *opt; 1056 daddr_t start, size; 1057 1058 args[0] = msg_string(pm->parts->pscheme->name); 1059 args[1] = msg_string(pm->parts->pscheme->short_name); 1060 ai.args.argv = args; 1061 ai.args.argc = 2; 1062 ai.rv = LY_ERROR; 1063 1064 memset(options, 0, sizeof(options)); 1065 num_opts = 0; 1066 opt = &options[0]; 1067 if (parts->pscheme->guess_install_target != NULL && 1068 parts->pscheme->guess_install_target(parts, &start, &size)) { 1069 opt->opt_name = MSG_Keep_existing_partitions; 1070 opt->opt_flags = OPT_EXIT; 1071 opt->opt_action = set_keep_existing; 1072 opt++; 1073 num_opts++; 1074 } 1075 opt->opt_name = MSG_Use_only_part_of_the_disk; 1076 opt->opt_flags = OPT_EXIT; 1077 opt->opt_action = set_use_only_part; 1078 opt++; 1079 num_opts++; 1080 1081 opt->opt_name = MSG_Use_the_entire_disk; 1082 opt->opt_flags = OPT_EXIT; 1083 opt->opt_action = set_use_entire_disk; 1084 opt++; 1085 num_opts++; 1086 1087 if (num_available_part_schemes > 1) { 1088 opt->opt_name = MSG_Use_Different_Part_Scheme; 1089 opt->opt_flags = OPT_EXIT; 1090 opt->opt_action = set_switch_scheme; 1091 opt++; 1092 num_opts++; 1093 } 1094 1095 menu = new_menu(MSG_Select_your_choice, options, num_opts, 1096 -1, -10, 0, 0, 0, NULL, NULL, NULL, NULL, MSG_cancel); 1097 if (menu != -1) { 1098 get_menudesc(menu)->expand_act = expand_all_option_texts; 1099 process_menu(menu, &ai); 1100 free_menu(menu); 1101 } 1102 1103 return ai.rv; 1104 } 1105 1106 /* 1107 * return (see post_edit_verify): 1108 * 0 -> abort 1109 * 1 -> re-edit 1110 * 2 -> continue installation 1111 */ 1112 static int 1113 verify_outer_parts(struct disk_partitions *parts, bool quiet) 1114 { 1115 part_id i; 1116 int num_bsdparts; 1117 daddr_t first_bsdstart, inst_start, inst_size; 1118 1119 first_bsdstart = inst_start = -1; 1120 inst_size = 0; 1121 num_bsdparts = 0; 1122 for (i = 0; i < parts->num_part; i++) { 1123 struct disk_part_info info; 1124 if (!parts->pscheme->get_part_info(parts, i, &info)) 1125 continue; 1126 if (!(info.flags & PTI_SEC_CONTAINER)) 1127 continue; 1128 if (info.nat_type->generic_ptype != PT_root) 1129 continue; 1130 num_bsdparts++; 1131 1132 if (first_bsdstart < 0) { 1133 first_bsdstart = info.start; 1134 } 1135 if (inst_start< 0 && (info.flags & PTI_INSTALL_TARGET)) { 1136 inst_start = info.start; 1137 inst_size = info.size; 1138 } 1139 } 1140 1141 if (num_bsdparts == 0 || 1142 (num_bsdparts > 1 && inst_start < 0)) { 1143 if (quiet && num_bsdparts == 0) 1144 return 0; 1145 if (!quiet || parts->pscheme->guess_install_target == NULL || 1146 !parts->pscheme->guess_install_target(parts, 1147 &inst_start, &inst_size)) { 1148 if (num_bsdparts == 0) 1149 msg_display_subst(MSG_nobsdpart, 2, 1150 msg_string(parts->pscheme->name), 1151 msg_string(parts->pscheme->short_name)); 1152 else 1153 msg_display_subst(MSG_multbsdpart, 2, 1154 msg_string(parts->pscheme->name), 1155 msg_string(parts->pscheme->short_name)); 1156 1157 return ask_reedit(parts); 1158 } 1159 } 1160 1161 /* 1162 * post_edit_verify returns: 1163 * 0 -> abort 1164 * 1 -> re-edit 1165 * 2 -> continue installation 1166 */ 1167 if (parts->pscheme->post_edit_verify) 1168 return parts->pscheme->post_edit_verify(parts, quiet); 1169 1170 return 2; 1171 } 1172 1173 static bool 1174 ask_outer_partsizes(struct disk_partitions *parts) 1175 { 1176 int j; 1177 int part_menu; 1178 size_t num_opts; 1179 #ifndef NO_CLONES 1180 size_t i, ci; 1181 #endif 1182 struct outer_parts_data data; 1183 1184 part_menu_opts = outer_fill_part_menu_opts(parts, &num_opts); 1185 part_menu = new_menu(outer_part_title, part_menu_opts, num_opts, 1186 0, -1, 15, 70, 1187 MC_NOBOX|MC_ALWAYS_SCROLL|MC_NOCLEAR|MC_CONTINUOUS, 1188 draw_outer_part_header, draw_outer_part_line, NULL, 1189 NULL, MSG_Partition_table_ok); 1190 if (part_menu == -1) { 1191 free(part_menu_opts); 1192 return false; 1193 } 1194 1195 /* Default to MB, and use bios geometry for cylinder size */ 1196 set_default_sizemult(parts->disk, MEG, parts->bytes_per_sector); 1197 if (pm->current_cylsize == 0) 1198 pm->current_cylsize = 16065; /* noone cares nowadays */ 1199 memset(&data, 0, sizeof data); 1200 data.av.arg = parts; 1201 1202 for (;;) { 1203 data.av.rv = 0; 1204 process_menu(part_menu, &data); 1205 if (data.av.rv < 0) 1206 break; 1207 1208 j = verify_outer_parts(parts, false); 1209 if (j == 0) { 1210 data.av.rv = -1; 1211 return false; 1212 } else if (j == 1) { 1213 continue; 1214 } 1215 break; 1216 } 1217 1218 #ifndef NO_CLONES 1219 /* handle cloned partitions content copies now */ 1220 for (i = 0; i < data.num_clone_entries; i++) { 1221 for (ci = 0; ci < data.clones[i].clone_src.num_sel; ci++) { 1222 if (data.clones[i].clone_src.with_data) 1223 clone_partition_data(parts, 1224 data.clones[i].clone_ids[ci], 1225 data.clones[i].clone_src.selection[ci]. 1226 parts, 1227 data.clones[i].clone_src.selection[ci].id); 1228 } 1229 } 1230 1231 /* free clone data */ 1232 if (data.clones) { 1233 for (i = 0; i < data.num_clone_entries; i++) 1234 free_selected_partitions(&data.clones[i].clone_src); 1235 free(data.clones); 1236 } 1237 #endif 1238 1239 free_menu(part_menu); 1240 free(part_menu_opts); 1241 1242 return data.av.rv == 0; 1243 } 1244 1245 int 1246 edit_outer_parts(struct disk_partitions *parts) 1247 { 1248 part_id i; 1249 enum layout_type layout; 1250 int num_foreign_parts; 1251 1252 /* If targeting a wedge, do not ask for further partitioning */ 1253 if (pm && (pm->no_part || pm->no_mbr)) 1254 return 1; 1255 1256 /* Make sure parts has been properly initialized */ 1257 assert(parts && parts->pscheme); 1258 1259 if (parts->pscheme->secondary_scheme == NULL) 1260 return 1; /* no outer parts */ 1261 1262 if (partman_go) { 1263 layout = LY_SETSIZES; 1264 } else { 1265 /* Ask full/part */ 1266 const struct disk_partitioning_scheme *sec = 1267 parts->pscheme->secondary_scheme; 1268 1269 uint64_t m_size = 1270 DEFROOTSIZE + DEFSWAPSIZE + DEFUSRSIZE + XNEEDMB; 1271 char min_size[5], build_size[5]; 1272 const char 1273 *prim_name = msg_string(parts->pscheme->name), 1274 *prim_short = msg_string(parts->pscheme->short_name), 1275 *sec_name = msg_string(sec->name), 1276 *sec_short = msg_string(sec->short_name); 1277 1278 humanize_number(min_size, sizeof(min_size), 1279 m_size * MEG, 1280 "", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL); 1281 humanize_number(build_size, sizeof(build_size), 1282 SYSTEM_BUILD_SIZE * MEG, "", HN_AUTOSCALE, 1283 HN_B | HN_NOSPACE | HN_DECIMAL); 1284 1285 msg_display_subst(MSG_fullpart, 7, 1286 pm->diskdev, 1287 prim_name, sec_name, 1288 prim_short, sec_short, 1289 min_size, build_size); 1290 msg_display_add("\n\n"); 1291 1292 layout = ask_fullpart(parts); 1293 if (layout == LY_ERROR) 1294 return 0; 1295 else if (layout == LY_OTHERSCHEME) 1296 return -1; 1297 } 1298 1299 if (layout == LY_USEFULL) { 1300 struct disk_part_info info; 1301 1302 /* Count nonempty, non-BSD partitions. */ 1303 num_foreign_parts = 0; 1304 for (i = 0; i < parts->num_part; i++) { 1305 if (!parts->pscheme->get_part_info(parts, i, &info)) 1306 continue; 1307 if (info.size == 0) 1308 continue; 1309 if (info.flags & (PTI_PSCHEME_INTERNAL|PTI_RAW_PART)) 1310 continue; 1311 if (info.nat_type != NULL 1312 && info.nat_type->generic_ptype != PT_root 1313 && info.nat_type->generic_ptype != PT_swap) 1314 num_foreign_parts++; 1315 } 1316 1317 /* Ask if we really want to blow away non-NetBSD stuff */ 1318 if (num_foreign_parts > 0) { 1319 msg_display(MSG_ovrwrite); 1320 if (!ask_noyes(NULL)) { 1321 if (logfp) 1322 (void)fprintf(logfp, 1323 "User answered no to destroy " 1324 "other data, aborting.\n"); 1325 return 0; 1326 } 1327 } 1328 if (!md_parts_use_wholedisk(parts)) { 1329 hit_enter_to_continue(MSG_No_free_space, NULL); 1330 return 0; 1331 } 1332 if (parts->pscheme->post_edit_verify) { 1333 return 1334 parts->pscheme->post_edit_verify(parts, true) == 2; 1335 } 1336 return 1; 1337 } else if (layout == LY_SETSIZES) { 1338 return ask_outer_partsizes(parts); 1339 } else { 1340 return verify_outer_parts(parts, true) == 2; 1341 } 1342 } 1343 1344 static int 1345 set_part_scheme(menudesc *m, void *arg) 1346 { 1347 size_t *res = arg; 1348 1349 *res = (size_t)m->cursel; 1350 return 1; 1351 } 1352 1353 const struct disk_partitioning_scheme * 1354 select_part_scheme( 1355 struct pm_devs *dev, 1356 const struct disk_partitioning_scheme *skip, 1357 bool bootable, 1358 const char *hdr) 1359 { 1360 int ps_menu = -1; 1361 menu_ent *opt; 1362 char **str, *ms = NULL; 1363 const struct disk_partitioning_scheme **options, *res; 1364 const char *title; 1365 size_t ndx, selected = ~0U, used; 1366 const struct disk_partitioning_scheme *p; 1367 bool showing_limit = false; 1368 1369 if (hdr == NULL) 1370 hdr = MSG_select_part_scheme; 1371 1372 opt = calloc(num_available_part_schemes, sizeof *opt); 1373 if (!opt) 1374 return NULL; 1375 str = calloc(num_available_part_schemes, sizeof *str); 1376 if (!str) { 1377 free(opt); 1378 return NULL; 1379 } 1380 options = calloc(num_available_part_schemes, sizeof *options); 1381 if (!options) { 1382 free(str); 1383 free(opt); 1384 return NULL; 1385 } 1386 1387 for (used = 0, ndx = 0; ndx < num_available_part_schemes; ndx++) { 1388 p = available_part_schemes[ndx]; 1389 /* 1390 * Do not match exactly, we want to skip all lookalikes 1391 * too (only_disklabel_parts vs. disklabel_parts) 1392 */ 1393 if (skip != NULL && 1394 p->create_new_for_disk == skip->create_new_for_disk) 1395 continue; 1396 if (bootable && p->have_boot_support != NULL && 1397 !p->have_boot_support(dev->diskdev)) 1398 continue; 1399 #ifdef HAVE_MBR 1400 if (dev->no_mbr && p->name == MSG_parttype_mbr) 1401 continue; 1402 #endif 1403 if (p->size_limit && dev->dlsize*(dev->sectorsize/512) > 1404 p->size_limit) { 1405 char buf[255], hum_lim[5]; 1406 1407 humanize_number(hum_lim, sizeof(hum_lim), 1408 (uint64_t)p->size_limit*512UL, 1409 "", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL); 1410 sprintf(buf, "%s [%s %s]", msg_string(p->name), 1411 msg_string(MSG_size_limit), hum_lim); 1412 str[used] = strdup(buf); 1413 showing_limit = true; 1414 } else { 1415 str[used] = strdup(msg_string(p->name)); 1416 } 1417 if (!str[used]) 1418 goto out; 1419 1420 opt[used].opt_name = str[used]; 1421 opt[used].opt_action = set_part_scheme; 1422 options[used] = p; 1423 used++; 1424 } 1425 1426 /* do not bother to ask if there are no options */ 1427 if (used <= 1) { 1428 selected = (used == 1) ? 0 : ~0U; 1429 goto out; 1430 } 1431 1432 if (showing_limit) { 1433 char hum_lim[5], *tmp; 1434 size_t total; 1435 1436 const char *p1 = msg_string(hdr); 1437 const char *p2 = msg_string(MSG_select_part_limit); 1438 1439 humanize_number(hum_lim, sizeof(hum_lim), 1440 (uint64_t)dev->dlsize*dev->sectorsize, "", 1441 HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL); 1442 1443 const char *args[] = { dev->diskdev, hum_lim }; 1444 char *p3 = str_arg_subst(msg_string(MSG_part_limit_disksize), 1445 __arraycount(args), args); 1446 1447 total = strlen(p1) + strlen(p2) + strlen(p3) 1448 + sizeof(hum_lim) + 5; 1449 ms = tmp = malloc(total); 1450 title = tmp; 1451 strcpy(tmp, p1); tmp += strlen(p1); 1452 *tmp++ = '\n'; *tmp++ = '\n'; 1453 strcpy(tmp, p2); tmp += strlen(p2); 1454 *tmp++ = '\n'; *tmp++ = '\n'; 1455 strcpy(tmp, p3); 1456 free(p3); 1457 assert(strlen(ms) < total); 1458 } else { 1459 title = msg_string(hdr); 1460 } 1461 ps_menu = new_menu(title, opt, used, 1462 -1, 5, 0, 0, 0, NULL, NULL, NULL, NULL, MSG_exit_menu_generic); 1463 if (ps_menu != -1) 1464 process_menu(ps_menu, &selected); 1465 out: 1466 res = selected >= used ? NULL : options[selected]; 1467 for (ndx = 0; ndx < used; ndx++) 1468 free(str[ndx]); 1469 if (showing_limit && ms) 1470 free(ms); 1471 free(str); 1472 free(opt); 1473 free(options); 1474 if (ps_menu != -1) 1475 free_menu(ps_menu); 1476 1477 return res; 1478 } 1479
Indexes created Sat Sep 20 22:09:52 GMT 2025