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
maxline(const char * p,int * count)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
err_msg_win(const char * errmsg)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
set_part_type(menudesc * m,void * arg)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
set_type_label(menudesc * m,int opt,void * arg)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
edit_part_type(menudesc * m,void * arg)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
edit_part_start(menudesc * m,void * arg)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
edit_part_size(menudesc * m,void * arg)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
edit_part_install(menudesc * m,void * arg)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
menu_opts_reload(menudesc * m,const struct disk_partitions * parts)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
delete_part(menudesc * m,void * arg)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
part_rollback(menudesc * m,void * arg)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
edit_custom_opt(menudesc * m,void * arg)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 *
fill_part_edit_menu_opts(struct disk_partitions * parts,bool with_custom_attrs,const menu_ent * suffix,size_t suffix_count,size_t * res_cnt)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
edit_part_entry(menudesc * m,void * arg)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
add_part_clone(menudesc * menu,void * arg)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
add_part_entry(menudesc * m,void * arg)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
draw_outer_ptn_line(menudesc * m,int line,void * arg)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
draw_outer_ptn_header(menudesc * m,void * arg)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
draw_outer_part_line(menudesc * m,int opt,void * arg)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
part_edit_abort(menudesc * m,void * arg)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 *
outer_fill_part_menu_opts(const struct disk_partitions * parts,size_t * cnt)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
draw_outer_part_header(menudesc * m,void * arg)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
parts_use_wholedisk(struct disk_partitions * parts,size_t add_ext_parts,const struct disk_part_info * ext_parts)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
set_keep_existing(menudesc * m,void * arg)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
set_use_only_part(menudesc * m,void * arg)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
set_use_entire_disk(menudesc * m,void * arg)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
set_switch_scheme(menudesc * m,void * arg)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
ask_fullpart(struct disk_partitions * parts)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
verify_outer_parts(struct disk_partitions * parts,bool quiet)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
ask_outer_partsizes(struct disk_partitions * parts)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
edit_outer_parts(struct disk_partitions * parts)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
set_part_scheme(menudesc * m,void * arg)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 *
select_part_scheme(struct pm_devs * dev,const struct disk_partitioning_scheme * skip,bool bootable,const char * hdr)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