1 /* $NetBSD: bsddisklabel.c,v 1.72 2023/01/06 18:19:27 martin Exp $ */
2
3 /*
4 * Copyright 1997 Piermont Information Systems Inc.
5 * All rights reserved.
6 *
7 * Based on code written by Philip A. Nelson for Piermont Information
8 * Systems Inc.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. The name of Piermont Information Systems Inc. may not be used to endorse
19 * or promote products derived from this software without specific prior
20 * written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY PIERMONT INFORMATION SYSTEMS INC. ``AS IS''
23 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL PIERMONT INFORMATION SYSTEMS INC. BE
26 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
32 * THE POSSIBILITY OF SUCH DAMAGE.
33 */
34
35 /* bsddisklabel.c -- generate standard BSD disklabel */
36 /* Included by appropriate arch/XXXX/md.c */
37
38 #include <sys/param.h>
39 #include <sys/sysctl.h>
40 #include <sys/exec.h>
41 #include <sys/utsname.h>
42 #include <sys/types.h>
43 #include <sys/stat.h>
44 #include <machine/cpu.h>
45 #include <assert.h>
46 #include <stdio.h>
47 #include <stddef.h>
48 #include <util.h>
49 #include <dirent.h>
50 #include "defs.h"
51 #include "md.h"
52 #include "defsizes.h"
53 #include "endian.h"
54 #include "msg_defs.h"
55 #include "menu_defs.h"
56
57 static size_t fill_ptn_menu(struct partition_usage_set *pset);
58
59 /*
60 * The default partition layout.
61 */
62 static const struct part_usage_info
63 default_parts_init[] =
64 {
65 /*
66 * Pretty complex setup for boot partitions.
67 * This is copy&pasted below, please keep in sync!
68 */
69 #ifdef PART_BOOT
70 { .size = PART_BOOT/512, /* PART_BOOT is in BYTE, not MB! */
71 #ifdef PART_BOOT_MOUNT
72 .mount = PART_BOOT_MOUNT,
73 .instflags = PUIINST_MOUNT|PUIINST_BOOT,
74 #else
75 .instflags = PUIINST_BOOT,
76 #endif
77 #ifdef PART_BOOT_TYPE
78 .fs_type = PART_BOOT_TYPE,
79 #if (PART_BOOT_TYPE == FS_MSDOS) || (PART_BOOT_TYPE == FS_EX2FS)
80 .flags = PUIFLAG_ADD_OUTER,
81 #endif
82 #endif
83 #ifdef PART_BOOT_SUBT
84 .fs_version = PART_BOOT_SUBT,
85 #endif
86 },
87 #endif
88
89 /*
90 * Two more copies of above for _BOOT1 and _BOOT2, please
91 * keep in sync!
92 */
93 #ifdef PART_BOOT1
94 { .size = PART_BOOT1/512, /* PART_BOOT1 is in BYTE, not MB! */
95 #ifdef PART_BOOT1_MOUNT
96 .mount = PART_BOOT1_MOUNT,
97 .instflags = PUIINST_MOUNT|PUIINST_BOOT,
98 #else
99 .instflags = PUIINST_MOUNT|PUIINST_BOOT,
100 #endif
101 #ifdef PART_BOOT1_TYPE
102 .fs_type = PART_BOOT1_TYPE,
103 #if (PART_BOOT1_TYPE == FS_MSDOS) || (PART_BOOT1_TYPE == FS_EX2FS)
104 .flags = PUIFLAG_ADD_OUTER,
105 #endif
106 #endif
107 #ifdef PART_BOOT1_SUBT
108 .fs_version = PART_BOOT1_SUBT,
109 #endif
110 },
111 #endif
112 #ifdef PART_BOOT2
113 { .size = PART_BOOT2/512, /* PART_BOOT2 is in BYTE, not MB! */
114 #ifdef PART_BOOT2_MOUNT
115 .mount = PART_BOOT2_MOUNT,
116 .instflags = PUIINST_MOUNT|PUIINST_BOOT,
117 #else
118 .instflags = PUIINST_MOUNT|PUIINST_BOOT,
119 #endif
120 #ifdef PART_BOOT2_TYPE
121 .fs_type = PART_BOOT2_TYPE,
122 #if (PART_BOOT2_TYPE == FS_MSDOS) || (PART_BOOT2_TYPE == FS_EX2FS)
123 .flags = PUIFLAG_ADD_OUTER,
124 #endif
125 #endif
126 #ifdef PART_BOOT2_SUBT
127 .fs_version = PART_BOOT2_SUBT,
128 #endif
129 },
130 #endif
131
132 { .size = DEFROOTSIZE*(MEG/512), .mount = "/", .type = PT_root,
133 .flags = PUIFLAG_EXTEND },
134 {
135 #if DEFSWAPSIZE > 0
136 .size = DEFSWAPSIZE*(MEG/512),
137 #endif
138 .type = PT_swap, .fs_type = FS_SWAP },
139 #ifdef HAVE_TMPFS
140 { .type = PT_root, .mount = "/tmp", .fs_type = FS_TMPFS,
141 .flags = PUIFLG_JUST_MOUNTPOINT },
142 #else
143 { .type = PT_root, .mount = "/tmp", .fs_type = FS_MFS,
144 .flags = PUIFLG_JUST_MOUNTPOINT },
145 #endif
146 { .def_size = DEFUSRSIZE*(MEG/512), .mount = "/usr", .type = PT_root,
147 .fs_type = FS_BSDFFS, .fs_version = 3 },
148 { .def_size = DEFVARSIZE*(MEG/512), .mount = "/var", .type = PT_root,
149 .fs_type = FS_BSDFFS, .fs_version = 3 },
150 };
151
152 static const char size_separator[] =
153 "----------------------------------- - --------------------";
154 static char size_menu_title[STRSIZE];
155 static char size_menu_exit[MENUSTRSIZE];
156
157 static void
set_pset_exit_str(struct partition_usage_set * pset)158 set_pset_exit_str(struct partition_usage_set *pset)
159 {
160 char *str, num[25];
161 const char *args[2];
162 bool overrun;
163 daddr_t free_space = pset->cur_free_space;
164
165 /* format exit string */
166 overrun = free_space < 0;
167 if (overrun)
168 free_space = -free_space;
169
170 snprintf(num, sizeof(num), "%" PRIu64, free_space / sizemult);
171 args[0] = num;
172 args[1] = multname;
173 str = str_arg_subst(
174 msg_string(overrun ? MSG_fssizesbad : MSG_fssizesok),
175 2, args);
176 strlcpy(size_menu_exit, str, sizeof(size_menu_exit));
177 free(str);
178 }
179
180 static void
draw_size_menu_header(menudesc * m,void * arg)181 draw_size_menu_header(menudesc *m, void *arg)
182 {
183 struct partition_usage_set *pset = arg;
184 size_t i;
185 char col1[70], desc[MENUSTRSIZE];
186 bool need_ext = false, need_existing = false;
187
188 msg_display(MSG_ptnsizes);
189
190 for (i = 0; i < pset->num; i++) {
191 if (pset->infos[i].flags & PUIFLG_IS_OUTER)
192 need_ext = true;
193 else if (pset->infos[i].cur_part_id != NO_PART)
194 need_existing = true;
195 }
196 if (need_ext && need_existing)
197 snprintf(desc, sizeof desc, "%s, %s",
198 msg_string(MSG_ptnsizes_mark_existing),
199 msg_string(MSG_ptnsizes_mark_external));
200 else if (need_existing)
201 strlcpy(desc, msg_string(MSG_ptnsizes_mark_existing),
202 sizeof desc);
203 else if (need_ext)
204 strlcpy(desc, msg_string(MSG_ptnsizes_mark_external),
205 sizeof desc);
206 if (need_ext || need_existing) {
207 msg_printf("\n");
208 msg_display_add_subst(msg_string(MSG_ptnsizes_markers),
209 1, &desc);
210 }
211 msg_printf("\n\n");
212
213 /* update menu title */
214 snprintf(col1, sizeof col1, "%s (%s)", msg_string(MSG_ptnheaders_size),
215 multname);
216 snprintf(size_menu_title, sizeof size_menu_title,
217 " %-37.37s %s\n %s", col1,
218 msg_string(MSG_ptnheaders_filesystem), size_separator);
219 }
220
221 static void
draw_size_menu_line(menudesc * m,int opt,void * arg)222 draw_size_menu_line(menudesc *m, int opt, void *arg)
223 {
224 struct partition_usage_set *pset = arg;
225 daddr_t size;
226 char psize[38], inc_free[16], flag, swap[40];
227 const char *mount;
228 bool free_mount = false;
229
230 if (opt < 0 || (size_t)opt >= pset->num)
231 return;
232
233 inc_free[0] = 0;
234 if ((pset->infos[opt].flags & PUIFLAG_EXTEND) &&
235 pset->cur_free_space > 0) {
236 size = pset->infos[opt].size + pset->cur_free_space;
237 snprintf(inc_free, sizeof inc_free, " (%" PRIu64 ")",
238 size / sizemult);
239 }
240 size = pset->infos[opt].size;
241 if (pset->infos[opt].fs_type == FS_TMPFS) {
242 if (pset->infos[opt].size < 0)
243 snprintf(psize, sizeof psize, "%" PRIu64 "%%", -size);
244 else
245 snprintf(psize, sizeof psize, "%" PRIu64 " %s", size,
246 msg_string(MSG_megname));
247 } else {
248 snprintf(psize, sizeof psize, "%" PRIu64 "%s",
249 size / sizemult, inc_free);
250 }
251
252 if (pset->infos[opt].type == PT_swap) {
253 snprintf(swap, sizeof swap, "<%s>",
254 msg_string(MSG_swap_display));
255 mount = swap;
256 } else if (pset->infos[opt].flags & PUIFLG_JUST_MOUNTPOINT) {
257 snprintf(swap, sizeof swap, "%s (%s)",
258 pset->infos[opt].mount,
259 getfslabelname(pset->infos[opt].fs_type,
260 pset->infos[opt].fs_version));
261 mount = swap;
262 } else if (pset->infos[opt].mount[0]) {
263 if (pset->infos[opt].instflags & PUIINST_BOOT) {
264 snprintf(swap, sizeof swap, "%s <%s>",
265 pset->infos[opt].mount, msg_string(MSG_ptn_boot));
266 mount = swap;
267 } else {
268 mount = pset->infos[opt].mount;
269 }
270 #ifndef NO_CLONES
271 } else if (pset->infos[opt].flags & PUIFLG_CLONE_PARTS) {
272 snprintf(swap, sizeof swap, "%zu %s",
273 pset->infos[opt].clone_src->num_sel,
274 msg_string(MSG_clone_target_disp));
275 mount = swap;
276 #endif
277 } else {
278 mount = NULL;
279 if (pset->infos[opt].parts->pscheme->other_partition_identifier
280 && pset->infos[opt].cur_part_id != NO_PART)
281 mount = pset->infos[opt].parts->pscheme->
282 other_partition_identifier(pset->infos[opt].parts,
283 pset->infos[opt].cur_part_id);
284 if (mount == NULL)
285 mount = getfslabelname(pset->infos[opt].fs_type,
286 pset->infos[opt].fs_version);
287 if (pset->infos[opt].instflags & PUIINST_BOOT) {
288 snprintf(swap, sizeof swap, "%s <%s>",
289 mount, msg_string(MSG_ptn_boot));
290 mount = swap;
291 }
292 mount = str_arg_subst(msg_string(MSG_size_ptn_not_mounted),
293 1, &mount);
294 free_mount = true;
295 }
296 flag = ' ';
297 if (pset->infos[opt].flags & PUIFLAG_EXTEND)
298 flag = '+';
299 else if (pset->infos[opt].flags & PUIFLG_IS_OUTER)
300 flag = '@';
301 else if (pset->infos[opt].cur_part_id != NO_PART)
302 flag = '=';
303 wprintw(m->mw, "%-35.35s %c %s", psize, flag, mount);
304 if (free_mount)
305 free(__UNCONST(mount));
306
307 if (opt == 0)
308 set_pset_exit_str(pset);
309 }
310
311 static int
add_other_ptn_size(menudesc * menu,void * arg)312 add_other_ptn_size(menudesc *menu, void *arg)
313 {
314 struct partition_usage_set *pset = arg;
315 struct part_usage_info *p;
316 struct menu_ent *m;
317 char new_mp[MOUNTLEN], *err;
318 const char *args;
319
320 for (;;) {
321 msg_prompt_win(partman_go?MSG_askfsmountadv:MSG_askfsmount,
322 -1, 18, 0, 0, NULL, new_mp, sizeof(new_mp));
323 if (new_mp[0] == 0)
324 return 0;
325 if (new_mp[0] != '/') {
326 /* we need absolute mount paths */
327 memmove(new_mp+1, new_mp, sizeof(new_mp)-1);
328 new_mp[0] = '/';
329 }
330
331 /* duplicates? */
332 bool duplicate = false;
333 for (size_t i = 0; i < pset->num; i++) {
334 if (strcmp(pset->infos[i].mount,
335 new_mp) == 0) {
336 args = new_mp;
337 err = str_arg_subst(
338 msg_string(MSG_mp_already_exists),
339 1, &args);
340 err_msg_win(err);
341 free(err);
342 duplicate = true;
343 break;
344 }
345 }
346 if (!duplicate)
347 break;
348 }
349
350 m = realloc(pset->menu_opts, (pset->num+5)*sizeof(*pset->menu_opts));
351 if (m == NULL)
352 return 0;
353 p = realloc(pset->infos, (pset->num+1)*sizeof(*pset->infos));
354 if (p == NULL)
355 return 0;
356
357 pset->infos = p;
358 pset->menu_opts = m;
359 menu->opts = m;
360 menu->numopts = pset->num+4;
361 m += pset->num;
362 p += pset->num;
363 memset(m, 0, sizeof(*m));
364 memset(p, 0, sizeof(*p));
365 p->parts = pset->parts;
366 p->cur_part_id = NO_PART;
367 p->type = PT_root;
368 p->fs_type = FS_BSDFFS;
369 p->fs_version = 3;
370 strncpy(p->mount, new_mp, sizeof(p->mount));
371
372 menu->cursel = pset->num;
373 pset->num++;
374 fill_ptn_menu(pset);
375
376 return -1;
377 }
378
379 #ifndef NO_CLONES
380 static int
inst_ext_clone(menudesc * menu,void * arg)381 inst_ext_clone(menudesc *menu, void *arg)
382 {
383 struct selected_partitions selected;
384 struct clone_target_menu_data data;
385 struct partition_usage_set *pset = arg;
386 struct part_usage_info *p;
387 menu_ent *men;
388 int num_men, i;
389
390 if (!select_partitions(&selected, pm->parts))
391 return 0;
392
393 num_men = pset->num+1;
394 men = calloc(num_men, sizeof *men);
395 if (men == NULL)
396 return 0;
397 for (i = 0; i < num_men; i++)
398 men[i].opt_action = clone_target_select;
399 men[num_men-1].opt_name = MSG_clone_target_end;
400
401 memset(&data, 0, sizeof data);
402 data.usage = *pset;
403 data.res = -1;
404
405 data.usage.menu = new_menu(MSG_clone_target_hdr,
406 men, num_men, 3, 2, 0, 65, MC_SCROLL,
407 NULL, draw_size_menu_line, NULL, NULL, MSG_cancel);
408 process_menu(data.usage.menu, &data);
409 free_menu(data.usage.menu);
410 free(men);
411
412 if (data.res < 0)
413 goto err;
414
415 /* insert clone record */
416 men = realloc(pset->menu_opts, (pset->num+5)*sizeof(*pset->menu_opts));
417 if (men == NULL)
418 goto err;
419 pset->menu_opts = men;
420 menu->opts = men;
421 menu->numopts = pset->num+4;
422
423 p = realloc(pset->infos, (pset->num+1)*sizeof(*pset->infos));
424 if (p == NULL)
425 goto err;
426 pset->infos = p;
427
428 men += data.res;
429 p += data.res;
430 memmove(men+1, men, sizeof(*men)*((pset->num+4)-data.res));
431 memmove(p+1, p, sizeof(*p)*((pset->num)-data.res));
432 memset(men, 0, sizeof(*men));
433 memset(p, 0, sizeof(*p));
434 p->flags = PUIFLG_CLONE_PARTS;
435 p->cur_part_id = NO_PART;
436 p->clone_src = malloc(sizeof(selected));
437 if (p->clone_src != NULL) {
438 *p->clone_src = selected;
439 p->clone_ndx = ~0U;
440 p->size = selected_parts_size(&selected);
441 p->parts = pset->parts;
442 } else {
443 p->clone_ndx = 0;
444 free_selected_partitions(&selected);
445 }
446
447 menu->cursel = data.res == 0 ? 1 : 0;
448 pset->num++;
449 fill_ptn_menu(pset);
450
451 return -1;
452
453 err:
454 free_selected_partitions(&selected);
455 return 0;
456 }
457 #endif
458
459 static size_t
fill_ptn_menu(struct partition_usage_set * pset)460 fill_ptn_menu(struct partition_usage_set *pset)
461 {
462 struct part_usage_info *p;
463 struct disk_part_info info;
464 menu_ent *m;
465 size_t i;
466 daddr_t free_space;
467
468 #ifdef NO_CLONES
469 #define ADD_ITEMS 3
470 #else
471 #define ADD_ITEMS 4
472 #endif
473
474 memset(pset->menu_opts, 0, (pset->num+ADD_ITEMS)
475 *sizeof(*pset->menu_opts));
476 for (m = pset->menu_opts, p = pset->infos, i = 0; i < pset->num;
477 m++, p++, i++) {
478 if (p->flags & PUIFLG_CLONE_PARTS)
479 m->opt_flags = OPT_IGNORE|OPT_NOSHORT;
480 else
481 m->opt_action = set_ptn_size;
482 }
483
484 m->opt_name = size_separator;
485 m->opt_flags = OPT_IGNORE|OPT_NOSHORT;
486 m++;
487
488 m->opt_name = MSG_add_another_ptn;
489 m->opt_action = add_other_ptn_size;
490 m++;
491
492 #ifndef NO_CLONES
493 m->opt_name = MSG_clone_from_elsewhere;
494 m->opt_action = inst_ext_clone;
495 m++;
496 #endif
497
498 m->opt_name = MSG_askunits;
499 m->opt_menu = MENU_sizechoice;
500 m->opt_flags = OPT_SUB;
501 m++;
502
503 /* calculate free space */
504 free_space = pset->parts->free_space - pset->reserved_space;
505 for (i = 0; i < pset->parts->num_part; i++) {
506 if (!pset->parts->pscheme->get_part_info(pset->parts, i,
507 &info))
508 continue;
509 if (info.flags & (PTI_SEC_CONTAINER|PTI_WHOLE_DISK|
510 PTI_PSCHEME_INTERNAL|PTI_RAW_PART))
511 continue;
512 free_space += info.size;
513 }
514 for (i = 0; i < pset->num; i++) {
515 if (pset->infos[i].flags &
516 (PUIFLG_IS_OUTER|PUIFLG_JUST_MOUNTPOINT))
517 continue;
518 free_space -= pset->infos[i].size;
519 }
520 pset->cur_free_space = free_space;
521 set_pset_exit_str(pset);
522
523 if (pset->menu >= 0)
524 set_menu_numopts(pset->menu, m - pset->menu_opts);
525
526 return m - pset->menu_opts;
527 }
528
529 static part_id
find_part_at(struct disk_partitions * parts,daddr_t start)530 find_part_at(struct disk_partitions *parts, daddr_t start)
531 {
532 size_t i;
533 struct disk_part_info info;
534
535 for (i = 0; i < parts->num_part; i++) {
536 if (!parts->pscheme->get_part_info(parts, i, &info))
537 continue;
538 if (info.start == start)
539 return i;
540 }
541
542 return NO_PART;
543 }
544
545 static daddr_t
parse_ram_size(const char * str,bool * is_percent)546 parse_ram_size(const char *str, bool *is_percent)
547 {
548 daddr_t val;
549 char *cp;
550
551 val = strtoull(str, &cp, 10);
552 while (*cp && isspace((unsigned char)*cp))
553 cp++;
554
555 *is_percent = *cp == '%';
556 return val;
557 }
558
559 int
set_ptn_size(menudesc * m,void * arg)560 set_ptn_size(menudesc *m, void *arg)
561 {
562 struct partition_usage_set *pset = arg;
563 struct part_usage_info *p = &pset->infos[m->cursel];
564 char answer[16], dflt[16];
565 const char *err_msg;
566 size_t i, root = ~0U;
567 daddr_t size, old_size, new_size_val, mult;
568 int rv;
569 bool non_zero, extend, is_ram_size, is_percent = false;
570
571 if (pset->cur_free_space == 0 && p->size == 0 &&
572 !(p->flags & PUIFLG_JUST_MOUNTPOINT))
573 /* Don't allow 'free_parts' to go negative */
574 return 0;
575
576 if (p->cur_part_id != NO_PART) {
577 rv = 0;
578 process_menu(MENU_ptnsize_replace_existing_partition, &rv);
579 if (rv == 0)
580 return 0;
581 if (!pset->parts->pscheme->delete_partition(pset->parts,
582 p->cur_part_id, &err_msg)) {
583 if (err_msg)
584 err_msg_win(err_msg);
585 return 0;
586 }
587 p->cur_part_id = NO_PART;
588 /*
589 * All other part ids are invalid now too - update them!
590 */
591 for (i = 0; i < pset->num; i++) {
592 if (pset->infos[i].cur_part_id == NO_PART)
593 continue;
594 pset->infos[i].cur_part_id =
595 find_part_at(pset->parts, pset->infos[i].cur_start);
596 }
597 }
598
599 is_ram_size = (p->flags & PUIFLG_JUST_MOUNTPOINT)
600 && p->fs_type == FS_TMPFS;
601
602 size = p->size;
603 if (is_ram_size && size < 0) {
604 is_percent = true;
605 size = -size;
606 }
607 old_size = size;
608 if (size == 0)
609 size = p->def_size;
610 if (!is_ram_size)
611 size /= sizemult;
612
613 if (is_ram_size) {
614 snprintf(dflt, sizeof dflt, "%" PRIu64 "%s",
615 size, is_percent ? "%" : "");
616 } else {
617 snprintf(dflt, sizeof dflt, "%" PRIu64 "%s",
618 size, p->flags & PUIFLAG_EXTEND ? "+" : "");
619 }
620
621 for (;;) {
622 msg_fmt_prompt_win(MSG_askfssize, -1, 18, 0, 0,
623 dflt, answer, sizeof answer, "%s%s", p->mount,
624 is_ram_size ? msg_string(MSG_megname) : multname);
625
626 if (is_ram_size) {
627 new_size_val = parse_ram_size(answer, &is_percent);
628 if (is_percent &&
629 (new_size_val < 0 || new_size_val > 100))
630 continue;
631 if (!is_percent && new_size_val < 0)
632 continue;
633 size = new_size_val;
634 extend = false;
635 break;
636 }
637 mult = sizemult;
638 new_size_val = parse_disk_pos(answer, &mult, pm->sectorsize,
639 pm->dlcylsize, &extend);
640
641 if (strcmp(answer, dflt) == 0)
642 non_zero = p->def_size > 0;
643 else
644 non_zero = new_size_val > 0;
645
646 /* Some special cases when /usr is first given a size */
647 if (old_size == 0 && non_zero &&
648 strcmp(p->mount, "/usr") == 0) {
649 for (i = 0; i < pset->num; i++) {
650 if (strcmp(pset->infos[i].mount, "/") == 0) {
651 root = i;
652 break;
653 }
654 }
655 /* Remove space for /usr from / */
656 if (root < pset->num &&
657 pset->infos[root].cur_part_id == NO_PART &&
658 pset->infos[root].size ==
659 pset->infos[root].def_size) {
660 /*
661 * root partition does not yet exist and
662 * has default size
663 */
664 pset->infos[root].size -= p->def_size;
665 pset->cur_free_space += p->def_size;
666 }
667 /*
668 * hack to add free space to /usr if
669 * previously / got it
670 */
671 if (pset->infos[root].flags & PUIFLAG_EXTEND)
672 extend = true;
673 }
674 if (new_size_val < 0)
675 continue;
676 size = new_size_val;
677 break;
678 }
679
680 daddr_t align = pset->parts->pscheme->get_part_alignment(pset->parts);
681 if (!is_ram_size) {
682 size = NUMSEC(size, mult, align);
683 }
684 if (p->flags & PUIFLAG_EXTEND)
685 p->flags &= ~PUIFLAG_EXTEND;
686 if (extend && (p->limit == 0 || p->limit > p->size)) {
687 for (size_t k = 0; k < pset->num; k++)
688 pset->infos[k].flags &= ~PUIFLAG_EXTEND;
689 p->flags |= PUIFLAG_EXTEND;
690 if (size == 0)
691 size = align;
692 }
693 if (p->limit != 0 && size > p->limit)
694 size = p->limit;
695 if ((p->flags & (PUIFLG_IS_OUTER|PUIFLG_JUST_MOUNTPOINT)) == 0)
696 pset->cur_free_space += p->size - size;
697 p->size = is_percent ? -size : size;
698 set_pset_exit_str(pset);
699
700 return 0;
701 }
702
703 /*
704 * User interface to edit a "wanted" partition layout "pset" as first
705 * abstract phase (not concrete partitions).
706 * Make sure to have everything (at least theoretically) fit the
707 * available space.
708 * During editing we keep the part_usage_info and the menu_opts
709 * in pset in sync, that is: we always allocate just enough entries
710 * in pset->infos as we have usage infos in the list (pset->num),
711 * and two additional menu entries ("add a partition" and "select units").
712 * The menu exit string changes depending on content, and implies
713 * abort while the partition set is not valid (does not fit).
714 * Return true when the user wants to continue (by editing the concrete
715 * partitions), return false to abort.
716 */
717 bool
get_ptn_sizes(struct partition_usage_set * pset)718 get_ptn_sizes(struct partition_usage_set *pset)
719 {
720 size_t num;
721
722 wclear(stdscr);
723 wrefresh(stdscr);
724
725 if (pset->menu_opts == NULL)
726 pset->menu_opts = calloc(pset->num+4, sizeof(*pset->menu_opts));
727
728 pset->menu = -1;
729 num = fill_ptn_menu(pset);
730
731 pset->menu = new_menu(size_menu_title, pset->menu_opts, num,
732 3, -1, 12, 70,
733 MC_ALWAYS_SCROLL|MC_NOBOX|MC_NOCLEAR|MC_CONTINUOUS,
734 draw_size_menu_header, draw_size_menu_line, NULL,
735 NULL, size_menu_exit);
736
737 if (pset->menu < 0) {
738 free(pset->menu_opts);
739 pset->menu_opts = NULL;
740 return false;
741 }
742
743 pset->ok = true;
744 process_menu(pset->menu, pset);
745
746 free_menu(pset->menu);
747 free(pset->menu_opts);
748 pset->menu = -1;
749 pset->menu_opts = NULL;
750
751 return pset->ok;
752 }
753
754 static int
set_keep_existing(menudesc * m,void * arg)755 set_keep_existing(menudesc *m, void *arg)
756 {
757 ((arg_rep_int*)arg)->rv = LY_KEEPEXISTING;
758 return 0;
759 }
760
761 static int
set_switch_scheme(menudesc * m,void * arg)762 set_switch_scheme(menudesc *m, void *arg)
763 {
764 ((arg_rep_int*)arg)->rv = LY_OTHERSCHEME;
765 return 0;
766 }
767
768 static int
set_edit_part_sizes(menudesc * m,void * arg)769 set_edit_part_sizes(menudesc *m, void *arg)
770 {
771 ((arg_rep_int*)arg)->rv = LY_SETSIZES;
772 return 0;
773 }
774
775 static int
set_use_default_sizes(menudesc * m,void * arg)776 set_use_default_sizes(menudesc *m, void *arg)
777 {
778 ((arg_rep_int*)arg)->rv = LY_USEDEFAULT;
779 return 0;
780 }
781
782 static int
set_use_empty_parts(menudesc * m,void * arg)783 set_use_empty_parts(menudesc *m, void *arg)
784 {
785 ((arg_rep_int*)arg)->rv = LY_USENONE;
786 return 0;
787 }
788
789 /*
790 * Check if there is a reasonable pre-existing partition for
791 * NetBSD.
792 */
793 static bool
check_existing_netbsd(struct disk_partitions * parts)794 check_existing_netbsd(struct disk_partitions *parts)
795 {
796 size_t nbsd_parts;
797 struct disk_part_info info;
798
799 nbsd_parts = 0;
800 for (part_id p = 0; p < parts->num_part; p++) {
801 if (!parts->pscheme->get_part_info(parts, p, &info))
802 continue;
803 if (info.flags & (PTI_PSCHEME_INTERNAL|PTI_RAW_PART))
804 continue;
805 if (info.nat_type && info.nat_type->generic_ptype == PT_root)
806 nbsd_parts++;
807 }
808
809 return nbsd_parts > 0;
810 }
811
812 /*
813 * Query a partition layout type (with available options depending on
814 * pre-existing partitions).
815 */
816 static enum layout_type
ask_layout(struct disk_partitions * parts,bool have_existing)817 ask_layout(struct disk_partitions *parts, bool have_existing)
818 {
819 arg_rep_int ai;
820 const char *args[2];
821 int menu;
822 size_t num_opts;
823 menu_ent options[5], *opt;
824
825 args[0] = msg_string(parts->pscheme->name);
826 args[1] = msg_string(parts->pscheme->short_name);
827 ai.args.argv = args;
828 ai.args.argc = 2;
829 ai.rv = LY_ERROR;
830
831 memset(options, 0, sizeof(options));
832 num_opts = 0;
833 opt = &options[0];
834
835 if (have_existing) {
836 opt->opt_name = MSG_Keep_existing_partitions;
837 opt->opt_flags = OPT_EXIT;
838 opt->opt_action = set_keep_existing;
839 opt++;
840 num_opts++;
841 }
842 opt->opt_name = MSG_Set_Sizes;
843 opt->opt_flags = OPT_EXIT;
844 opt->opt_action = set_edit_part_sizes;
845 opt++;
846 num_opts++;
847
848 opt->opt_name = MSG_Use_Default_Parts;
849 opt->opt_flags = OPT_EXIT;
850 opt->opt_action = set_use_default_sizes;
851 opt++;
852 num_opts++;
853
854 opt->opt_name = MSG_Use_Empty_Parts;
855 opt->opt_flags = OPT_EXIT;
856 opt->opt_action = set_use_empty_parts;
857 opt++;
858 num_opts++;
859
860 if (num_available_part_schemes > 1 &&
861 parts->parent == NULL) {
862 opt->opt_name = MSG_Use_Different_Part_Scheme;
863 opt->opt_flags = OPT_EXIT;
864 opt->opt_action = set_switch_scheme;
865 opt++;
866 num_opts++;
867 }
868
869 menu = new_menu(MSG_Select_your_choice, options, num_opts,
870 -1, -10, 0, 0, 0, NULL, NULL, NULL, NULL, MSG_cancel);
871 if (menu != -1) {
872 get_menudesc(menu)->expand_act = expand_all_option_texts;
873 process_menu(menu, &ai);
874 free_menu(menu);
875 }
876
877 return ai.rv;
878 }
879
880 static void
merge_part_with_wanted(struct disk_partitions * parts,part_id pno,const struct disk_part_info * info,struct partition_usage_set * wanted,size_t wanted_num,bool is_outer)881 merge_part_with_wanted(struct disk_partitions *parts, part_id pno,
882 const struct disk_part_info *info, struct partition_usage_set *wanted,
883 size_t wanted_num, bool is_outer)
884 {
885 struct part_usage_info *infos;
886
887 /*
888 * does this partition match something in the wanted set?
889 */
890 for (size_t i = 0; i < wanted_num; i++) {
891 if (wanted->infos[i].type != info->nat_type->generic_ptype)
892 continue;
893 if (wanted->infos[i].type == PT_root &&
894 info->last_mounted != NULL && info->last_mounted[0] != 0 &&
895 strcmp(info->last_mounted, wanted->infos[i].mount) != 0)
896 continue;
897 if (wanted->infos[i].cur_part_id != NO_PART)
898 continue;
899 wanted->infos[i].cur_part_id = pno;
900 wanted->infos[i].parts = parts;
901 wanted->infos[i].size = info->size;
902 wanted->infos[i].cur_start = info->start;
903 wanted->infos[i].flags &= ~PUIFLAG_EXTEND;
904 if (wanted->infos[i].fs_type != FS_UNUSED &&
905 wanted->infos[i].type != PT_swap &&
906 info->last_mounted != NULL &&
907 info->last_mounted[0] != 0)
908 wanted->infos[i].instflags |= PUIINST_MOUNT;
909 if (is_outer)
910 wanted->infos[i].flags |= PUIFLG_IS_OUTER;
911 else
912 wanted->infos[i].flags &= ~PUIFLG_IS_OUTER;
913 return;
914 }
915
916 /*
917 * no match - if this is from the outer scheme, we are done.
918 * otherwise it must be inserted into the wanted set.
919 */
920 if (is_outer)
921 return;
922
923 /*
924 * create a new entry for this
925 */
926 infos = realloc(wanted->infos, sizeof(*infos)*(wanted->num+1));
927 if (infos == NULL)
928 return;
929 wanted->infos = infos;
930 infos += wanted->num;
931 wanted->num++;
932 memset(infos, 0, sizeof(*infos));
933 if (info->last_mounted != NULL && info->last_mounted[0] != 0)
934 strlcpy(infos->mount, info->last_mounted,
935 sizeof(infos->mount));
936 infos->type = info->nat_type->generic_ptype;
937 infos->cur_part_id = pno;
938 infos->parts = parts;
939 infos->size = info->size;
940 infos->cur_start = info->start;
941 infos->fs_type = info->fs_type;
942 infos->fs_version = info->fs_sub_type;
943 if (is_outer)
944 infos->flags |= PUIFLG_IS_OUTER;
945 }
946
947 static bool
have_x11_by_default(void)948 have_x11_by_default(void)
949 {
950 static const uint8_t def_sets[] = { MD_SETS_SELECTED };
951
952 for (size_t i = 0; i < __arraycount(def_sets); i++)
953 if (def_sets[i] >= SET_X11_FIRST &&
954 def_sets[i] <= SET_X11_LAST)
955 return true;
956
957 return false;
958 }
959
960 static void
fill_defaults(struct partition_usage_set * wanted,struct disk_partitions * parts,daddr_t ptstart,daddr_t ptsize)961 fill_defaults(struct partition_usage_set *wanted, struct disk_partitions *parts,
962 daddr_t ptstart, daddr_t ptsize)
963 {
964 size_t i, root = ~0U, usr = ~0U, swap = ~0U, def_usr = ~0U;
965 daddr_t free_space, dump_space, required;
966 #if defined(DEFAULT_UFS2) && !defined(HAVE_UFS2_BOOT)
967 size_t boot = ~0U;
968 #endif
969
970 memset(wanted, 0, sizeof(*wanted));
971 wanted->parts = parts;
972 if (ptstart > parts->disk_start)
973 wanted->reserved_space = ptstart - parts->disk_start;
974 if ((ptstart + ptsize) < (parts->disk_start+parts->disk_size))
975 wanted->reserved_space +=
976 (parts->disk_start+parts->disk_size) -
977 (ptstart + ptsize);
978 wanted->num = __arraycount(default_parts_init);
979 wanted->infos = calloc(wanted->num, sizeof(*wanted->infos));
980 if (wanted->infos == NULL) {
981 err_msg_win(err_outofmem);
982 return;
983 }
984
985 memcpy(wanted->infos, default_parts_init, sizeof(default_parts_init));
986
987 #ifdef HAVE_TMPFS
988 if (get_ramsize() >= SMALL_RAM_SIZE) {
989 for (i = 0; i < wanted->num; i++) {
990 if (wanted->infos[i].type != PT_root ||
991 wanted->infos[i].fs_type != FS_TMPFS)
992 continue;
993 /* default tmpfs to 1/4 RAM */
994 wanted->infos[i].size = -25;
995 wanted->infos[i].def_size = -25;
996 break;
997 }
998 }
999 #endif
1000
1001 #ifdef MD_PART_DEFAULTS
1002 MD_PART_DEFAULTS(pm, wanted->infos, wanted->num);
1003 #endif
1004
1005 for (i = 0; i < wanted->num; i++) {
1006 wanted->infos[i].parts = parts;
1007 wanted->infos[i].cur_part_id = NO_PART;
1008 if (wanted->infos[i].type == PT_undef &&
1009 wanted->infos[i].fs_type != FS_UNUSED) {
1010 const struct part_type_desc *pt =
1011 parts->pscheme->get_fs_part_type(PT_undef,
1012 wanted->infos[i].fs_type,
1013 wanted->infos[i].fs_version);
1014 if (pt != NULL)
1015 wanted->infos[i].type = pt->generic_ptype;
1016 }
1017 if (wanted->parts->parent != NULL &&
1018 (wanted->infos[i].fs_type == FS_MSDOS ||
1019 wanted->infos[i].fs_type == FS_EX2FS))
1020 wanted->infos[i].flags |=
1021 PUIFLG_ADD_INNER|PUIFLAG_ADD_OUTER;
1022
1023 #if DEFSWAPSIZE == -1
1024 if (wanted->infos[i].type == PT_swap) {
1025 #ifdef MD_MAY_SWAP_TO
1026 if (MD_MAY_SWAP_TO(wanted->parts->disk))
1027 #endif
1028 wanted->infos[i].size =
1029 get_ramsize() * (MEG / 512);
1030 }
1031 #endif
1032 if (wanted->infos[i].type == PT_swap && swap > wanted->num)
1033 swap = i;
1034 #if defined(DEFAULT_UFS2) && !defined(HAVE_UFS2_BOOT)
1035 if (wanted->infos[i].instflags & PUIINST_BOOT)
1036 boot = i;
1037 #endif
1038 if (wanted->infos[i].type == PT_root) {
1039 if (strcmp(wanted->infos[i].mount, "/") == 0) {
1040 root = i;
1041 } else if (
1042 strcmp(wanted->infos[i].mount, "/usr") == 0) {
1043 if (wanted->infos[i].size > 0)
1044 usr = i;
1045 else
1046 def_usr = i;
1047 }
1048 if (wanted->infos[i].fs_type == FS_UNUSED)
1049 wanted->infos[i].fs_type = FS_BSDFFS;
1050 if (wanted->infos[i].fs_type == FS_BSDFFS) {
1051 #ifdef DEFAULT_UFS2
1052 #ifndef HAVE_UFS2_BOOT
1053 if (boot < wanted->num || i != root)
1054 #endif
1055 wanted->infos[i].fs_version = 3;
1056 #endif
1057 }
1058 }
1059 }
1060
1061 /*
1062 * Now we have the defaults as if we were installing to an
1063 * empty disk. Merge the partitions in target range that are already
1064 * there (match with wanted) or are there additionally.
1065 * The only thing outside of target range that we care for
1066 * are FAT partitions, EXT2FS partitions, and a potential
1067 * swap partition - we assume one is enough.
1068 */
1069 size_t num = wanted->num;
1070 if (parts->parent) {
1071 for (part_id pno = 0; pno < parts->parent->num_part; pno++) {
1072 struct disk_part_info info;
1073
1074 if (!parts->parent->pscheme->get_part_info(
1075 parts->parent, pno, &info))
1076 continue;
1077 if (info.nat_type->generic_ptype != PT_swap &&
1078 info.fs_type != FS_MSDOS &&
1079 info.fs_type != FS_EX2FS)
1080 continue;
1081 merge_part_with_wanted(parts->parent, pno, &info,
1082 wanted, num, true);
1083 break;
1084 }
1085 }
1086 for (part_id pno = 0; pno < parts->num_part; pno++) {
1087 struct disk_part_info info;
1088
1089 if (!parts->pscheme->get_part_info(parts, pno, &info))
1090 continue;
1091
1092 if (info.flags & PTI_PSCHEME_INTERNAL)
1093 continue;
1094
1095 if (info.nat_type->generic_ptype != PT_swap &&
1096 (info.start < ptstart ||
1097 (info.start + info.size) > (ptstart+ptsize)))
1098 continue;
1099
1100 merge_part_with_wanted(parts, pno, &info,
1101 wanted, num, false);
1102 }
1103
1104 daddr_t align = parts->pscheme->get_part_alignment(parts);
1105
1106 if (root < wanted->num && wanted->infos[root].cur_part_id == NO_PART) {
1107 daddr_t max_root_size = parts->disk_start + parts->disk_size;
1108 if (root_limit > 0) {
1109 /* Bah - bios can not read all the disk, limit root */
1110 max_root_size = root_limit - parts->disk_start;
1111 }
1112 wanted->infos[root].limit = max_root_size;
1113 }
1114
1115 if (have_x11_by_default()) {
1116 daddr_t xsize = XNEEDMB * (MEG / 512);
1117 if (usr < wanted->num) {
1118 if (wanted->infos[usr].cur_part_id == NO_PART) {
1119 wanted->infos[usr].size += xsize;
1120 wanted->infos[usr].def_size += xsize;
1121 }
1122 } else if (root < wanted->num &&
1123 wanted->infos[root].cur_part_id == NO_PART &&
1124 (wanted->infos[root].limit == 0 ||
1125 (wanted->infos[root].size + xsize) <=
1126 wanted->infos[root].limit)) {
1127 wanted->infos[root].size += xsize;
1128 }
1129 }
1130 if (wanted->infos[root].limit > 0 &&
1131 wanted->infos[root].size > wanted->infos[root].limit) {
1132 if (usr < wanted->num) {
1133 /* move space from root to usr */
1134 daddr_t spill = wanted->infos[root].size -
1135 wanted->infos[root].limit;
1136 spill = roundup(spill, align);
1137 wanted->infos[root].size =
1138 wanted->infos[root].limit;
1139 wanted->infos[usr].size = spill;
1140 } else {
1141 wanted->infos[root].size =
1142 wanted->infos[root].limit;
1143 }
1144 }
1145
1146 /*
1147 * Preliminary calc additional space to allocate and how much
1148 * we likely will have left over. Use that to do further
1149 * adjustments, so we don't present the user inherently
1150 * impossible defaults.
1151 */
1152 free_space = parts->free_space - wanted->reserved_space;
1153 required = 0;
1154 if (root < wanted->num)
1155 required += wanted->infos[root].size;
1156 if (usr < wanted->num)
1157 required += wanted->infos[usr].size;
1158 else if (def_usr < wanted->num)
1159 required += wanted->infos[def_usr].def_size;
1160 free_space -= required;
1161 for (i = 0; i < wanted->num; i++) {
1162 if (i == root || i == usr)
1163 continue; /* already accounted above */
1164 if (wanted->infos[i].cur_part_id != NO_PART)
1165 continue;
1166 if (wanted->infos[i].size == 0)
1167 continue;
1168 if (wanted->infos[i].flags
1169 & (PUIFLG_IS_OUTER|PUIFLG_JUST_MOUNTPOINT))
1170 continue;
1171 free_space -= wanted->infos[i].size;
1172 }
1173 if (free_space < 0 && swap < wanted->num &&
1174 get_ramsize() > TINY_RAM_SIZE) {
1175 /* steel from swap partition */
1176 daddr_t d = wanted->infos[swap].size;
1177 daddr_t inc = roundup(-free_space, align);
1178 if (inc > d)
1179 inc = d;
1180 free_space += inc;
1181 wanted->infos[swap].size -= inc;
1182 }
1183 if (root < wanted->num) {
1184 /* Add space for 2 system dumps to / (traditional) */
1185 dump_space = get_ramsize() * (MEG/512);
1186 dump_space = roundup(dump_space, align);
1187 if (free_space > dump_space*2)
1188 dump_space *= 2;
1189 if (free_space > dump_space) {
1190 wanted->infos[root].size += dump_space;
1191 free_space -= dump_space;
1192 }
1193 }
1194 if (wanted->infos[root].limit > 0 &&
1195 (wanted->infos[root].cur_start + wanted->infos[root].size >
1196 wanted->infos[root].limit ||
1197 (wanted->infos[root].flags & PUIFLAG_EXTEND &&
1198 (wanted->infos[root].cur_start + wanted->infos[root].size
1199 + free_space > wanted->infos[root].limit)))) {
1200 if (usr >= wanted->num && def_usr < wanted->num) {
1201 usr = def_usr;
1202 wanted->infos[usr].size = wanted->infos[root].size
1203 - wanted->infos[root].limit;
1204 if (wanted->infos[usr].size <= 0)
1205 wanted->infos[usr].size = max(1,
1206 wanted->infos[usr].def_size);
1207 wanted->infos[root].size =
1208 wanted->infos[root].limit;
1209 if (wanted->infos[root].flags & PUIFLAG_EXTEND) {
1210 wanted->infos[root].flags &= ~PUIFLAG_EXTEND;
1211 wanted->infos[usr].flags |= PUIFLAG_EXTEND;
1212 }
1213 } else if (usr < wanted->num) {
1214 /* move space from root to usr */
1215 daddr_t spill = wanted->infos[root].size -
1216 wanted->infos[root].limit;
1217 spill = roundup(spill, align);
1218 wanted->infos[root].size =
1219 wanted->infos[root].limit;
1220 wanted->infos[usr].size = spill;
1221 } else {
1222 wanted->infos[root].size =
1223 wanted->infos[root].limit;
1224 }
1225 }
1226 wanted->infos[root].def_size = wanted->infos[root].size;
1227 }
1228
1229 /*
1230 * We sort pset->infos to sync with pset->parts and
1231 * the cur_part_id, to allow using the same index into both
1232 * "array" in later phases. This may include inserting
1233 * dummy entries (when we do not actually want the
1234 * partition, but it is forced upon us, like RAW_PART in
1235 * disklabel).
1236 */
1237 static void
sort_and_sync_parts(struct partition_usage_set * pset)1238 sort_and_sync_parts(struct partition_usage_set *pset)
1239 {
1240 struct part_usage_info *infos;
1241 size_t i, j, no;
1242 part_id pno;
1243
1244 pset->cur_free_space = pset->parts->free_space - pset->reserved_space;
1245
1246 /* count non-empty entries that are not in pset->parts */
1247 no = pset->parts->num_part;
1248 for (i = 0; i < pset->num; i++) {
1249 if (pset->infos[i].size == 0)
1250 continue;
1251 if (pset->infos[i].cur_part_id != NO_PART)
1252 continue;
1253 no++;
1254 }
1255
1256 /* allocate new infos */
1257 infos = calloc(no, sizeof *infos);
1258 if (infos == NULL)
1259 return;
1260
1261 /* pre-initialize the first entries as dummy entries */
1262 for (i = 0; i < pset->parts->num_part; i++) {
1263 infos[i].cur_part_id = NO_PART;
1264 infos[i].cur_flags = PTI_PSCHEME_INTERNAL;
1265 }
1266 /*
1267 * Now copy over everything from our old entries that points to
1268 * a real partition.
1269 */
1270 for (i = 0; i < pset->num; i++) {
1271 pno = pset->infos[i].cur_part_id;
1272 if (pno == NO_PART)
1273 continue;
1274 if (pset->parts != pset->infos[i].parts)
1275 continue;
1276 if (pset->infos[i].flags & PUIFLG_JUST_MOUNTPOINT)
1277 continue;
1278 if ((pset->infos[i].flags & (PUIFLG_IS_OUTER|PUIFLG_ADD_INNER))
1279 == PUIFLG_IS_OUTER)
1280 continue;
1281 if (pno >= pset->parts->num_part)
1282 continue;
1283 memcpy(infos+pno, pset->infos+i, sizeof(*infos));
1284 }
1285 /* Fill in the infos for real partitions where we had no data */
1286 for (pno = 0; pno < pset->parts->num_part; pno++) {
1287 struct disk_part_info info;
1288
1289 if (infos[pno].cur_part_id != NO_PART)
1290 continue;
1291
1292 if (!pset->parts->pscheme->get_part_info(pset->parts, pno,
1293 &info))
1294 continue;
1295
1296 infos[pno].parts = pset->parts;
1297 infos[pno].cur_part_id = pno;
1298 infos[pno].cur_flags = info.flags;
1299 infos[pno].size = info.size;
1300 infos[pno].type = info.nat_type->generic_ptype;
1301 infos[pno].cur_start = info.start;
1302 infos[pno].fs_type = info.fs_type;
1303 infos[pno].fs_version = info.fs_sub_type;
1304 }
1305 /* Add the non-partition entries after that */
1306 j = pset->parts->num_part;
1307 for (i = 0; i < pset->num; i++) {
1308 if (j >= no)
1309 break;
1310 if (pset->infos[i].size == 0)
1311 continue;
1312 if (pset->infos[i].cur_part_id != NO_PART)
1313 continue;
1314 memcpy(infos+j, pset->infos+i, sizeof(*infos));
1315 j++;
1316 }
1317
1318 /* done, replace infos */
1319 free(pset->infos);
1320 pset->num = no;
1321 pset->infos = infos;
1322 }
1323
1324 #ifndef NO_CLONES
1325 /*
1326 * Convert clone entries with more than one source into
1327 * several entries with a single source each.
1328 */
1329 static void
normalize_clones(struct part_usage_info ** infos,size_t * num)1330 normalize_clones(struct part_usage_info **infos, size_t *num)
1331 {
1332 size_t i, j, add_clones;
1333 struct part_usage_info *ui, *src, *target;
1334 struct disk_part_info info;
1335 struct selected_partition *clone;
1336
1337 for (add_clones = 0, i = 0; i < *num; i++) {
1338 if ((*infos)[i].clone_src != NULL &&
1339 (*infos)[i].flags & PUIFLG_CLONE_PARTS &&
1340 (*infos)[i].cur_part_id == NO_PART)
1341 add_clones += (*infos)[i].clone_src->num_sel-1;
1342 }
1343 if (add_clones == 0)
1344 return;
1345
1346 ui = calloc(*num+add_clones, sizeof(**infos));
1347 if (ui == NULL)
1348 return; /* can not handle this well here, drop some clones */
1349
1350 /* walk the list and dedup clones */
1351 for (src = *infos, target = ui, i = 0; i < *num; i++) {
1352 if (src != target)
1353 *target = *src;
1354 if (target->clone_src != NULL &&
1355 (target->flags & PUIFLG_CLONE_PARTS) &&
1356 target->cur_part_id == NO_PART) {
1357 for (j = 0; j < src->clone_src->num_sel; j++) {
1358 if (j > 0) {
1359 target++;
1360 *target = *src;
1361 }
1362 target->clone_ndx = j;
1363 clone = &target->clone_src->selection[j];
1364 clone->parts->pscheme->get_part_info(
1365 clone->parts, clone->id, &info);
1366 target->size = info.size;
1367 }
1368 }
1369 target++;
1370 src++;
1371 }
1372 *num += add_clones;
1373 assert((target-ui) >= 0 && (size_t)(target-ui) == *num);
1374 free(*infos);
1375 *infos = ui;
1376 }
1377 #endif
1378
1379 static void
apply_settings_to_partitions(struct disk_partitions * parts,struct partition_usage_set * wanted,daddr_t start,daddr_t xsize)1380 apply_settings_to_partitions(struct disk_partitions *parts,
1381 struct partition_usage_set *wanted, daddr_t start, daddr_t xsize)
1382 {
1383 size_t i, exp_ndx = ~0U;
1384 daddr_t planned_space = 0, nsp, from, align;
1385 struct disk_part_info *infos;
1386 #ifndef NO_CLONES
1387 struct disk_part_info cinfo, srcinfo;
1388 struct selected_partition *sp;
1389 #endif
1390 struct disk_part_free_space space;
1391 struct disk_partitions *ps = NULL;
1392 part_id pno, new_part_id;
1393
1394 #ifndef NO_CLONES
1395 normalize_clones(&wanted->infos, &wanted->num);
1396 #endif
1397
1398 infos = calloc(wanted->num, sizeof(*infos));
1399 if (infos == NULL) {
1400 err_msg_win(err_outofmem);
1401 return;
1402 }
1403
1404 align = wanted->parts->pscheme->get_part_alignment(wanted->parts);
1405 /*
1406 * Pass one: calculate space available for expanding
1407 * the marked partition.
1408 */
1409 if (parts->free_space != parts->disk_size)
1410 planned_space = align; /* align first part */
1411 for (i = 0; i < wanted->num; i++) {
1412 if ((wanted->infos[i].flags & PUIFLAG_EXTEND) &&
1413 exp_ndx == ~0U)
1414 exp_ndx = i;
1415 if (wanted->infos[i].flags & PUIFLG_JUST_MOUNTPOINT)
1416 continue;
1417 nsp = wanted->infos[i].size;
1418 if (wanted->infos[i].cur_part_id != NO_PART) {
1419 ps = wanted->infos[i].flags & PUIFLG_IS_OUTER ?
1420 parts->parent : parts;
1421
1422 ps->pscheme->get_part_info(ps,
1423 wanted->infos[i].cur_part_id, &infos[i]);
1424 if (!(wanted->infos[i].flags & PUIFLG_IS_OUTER))
1425 nsp -= infos[i].size;
1426 }
1427 if (nsp <= 0)
1428 continue;
1429 planned_space += roundup(nsp, align);
1430 }
1431
1432 /*
1433 * Expand the pool partition (or shrink, if we overran),
1434 * but check size limits.
1435 */
1436 if (exp_ndx < wanted->num) {
1437 daddr_t free_space = parts->free_space - planned_space -
1438 wanted->reserved_space;
1439 daddr_t new_size = wanted->infos[exp_ndx].size;
1440 if (free_space > 0)
1441 new_size += roundup(free_space,align);
1442
1443 if (wanted->infos[exp_ndx].limit > 0 &&
1444 (new_size + wanted->infos[exp_ndx].cur_start)
1445 > wanted->infos[exp_ndx].limit) {
1446 wanted->infos[exp_ndx].size =
1447 wanted->infos[exp_ndx].limit
1448 - wanted->infos[exp_ndx].cur_start;
1449 } else {
1450 wanted->infos[exp_ndx].size = new_size;
1451 }
1452 }
1453
1454 /*
1455 * Now it gets tricky: we want the wanted partitions in order
1456 * as defined, but any already existing partitions should not
1457 * be moved. We allow them to change size though.
1458 * To keep it simple, we just assign in order and skip blocked
1459 * spaces. This may shuffle the order of the resulting partitions
1460 * compared to the wanted list.
1461 */
1462
1463 /* Adjust sizes of existing partitions */
1464 for (i = 0; i < wanted->num; i++) {
1465 ps = wanted->infos[i].flags & PUIFLG_IS_OUTER ?
1466 parts->parent : parts;
1467 const struct part_usage_info *want = &wanted->infos[i];
1468
1469 if (want->cur_part_id == NO_PART)
1470 continue;
1471 if (i == exp_ndx) /* the exp. part. can not exist yet */
1472 continue;
1473 daddr_t free_size = ps->pscheme->max_free_space_at(ps,
1474 infos[i].start);
1475 if (free_size < wanted->infos[i].size)
1476 continue;
1477 if (infos[i].size != wanted->infos[i].size) {
1478 infos[i].size = wanted->infos[i].size;
1479 ps->pscheme->set_part_info(ps, want->cur_part_id,
1480 &infos[i], NULL);
1481 }
1482 }
1483
1484 from = start > 0 ? start : -1;
1485 /*
1486 * First add all outer partitions - we need to align those exactly
1487 * with the inner counterpart later.
1488 */
1489 if (parts->parent) {
1490 ps = parts->parent;
1491 daddr_t outer_align = ps->pscheme->get_part_alignment(ps);
1492
1493 for (i = 0; i < wanted->num; i++) {
1494 struct part_usage_info *want = &wanted->infos[i];
1495
1496 if (want->cur_part_id != NO_PART)
1497 continue;
1498 if (!(want->flags & PUIFLAG_ADD_OUTER))
1499 continue;
1500 if (want->size <= 0)
1501 continue;
1502
1503 size_t cnt = ps->pscheme->get_free_spaces(ps,
1504 &space, 1, want->size-2*outer_align,
1505 outer_align, from, -1);
1506
1507 if (cnt == 0) /* no free space for this partition */
1508 continue;
1509
1510 infos[i].start = space.start;
1511 infos[i].size = min(want->size, space.size);
1512 infos[i].nat_type =
1513 ps->pscheme->get_fs_part_type(
1514 want->type, want->fs_type, want->fs_version);
1515 infos[i].last_mounted = want->mount;
1516 infos[i].fs_type = want->fs_type;
1517 infos[i].fs_sub_type = want->fs_version;
1518 infos[i].fs_opt1 = want->fs_opt1;
1519 infos[i].fs_opt2 = want->fs_opt2;
1520 infos[i].fs_opt3 = want->fs_opt3;
1521 new_part_id = ps->pscheme->add_partition(ps,
1522 &infos[i], NULL);
1523 if (new_part_id == NO_PART)
1524 continue; /* failed to add, skip */
1525
1526 ps->pscheme->get_part_info(ps,
1527 new_part_id, &infos[i]);
1528 want->cur_part_id = new_part_id;
1529
1530 want->flags |= PUIFLG_ADD_INNER|PUIFLG_IS_OUTER;
1531 from = roundup(infos[i].start +
1532 infos[i].size, outer_align);
1533 }
1534 }
1535
1536 /*
1537 * Now add new inner partitions (and cloned partitions)
1538 */
1539 for (i = 0; i < wanted->num; i++) {
1540
1541 daddr_t limit = wanted->parts->disk_size + wanted->parts->disk_start;
1542 if (from >= limit)
1543 break;
1544
1545 struct part_usage_info *want = &wanted->infos[i];
1546
1547 if (want->cur_part_id != NO_PART)
1548 continue;
1549 if (want->flags & (PUIFLG_JUST_MOUNTPOINT|PUIFLG_IS_OUTER))
1550 continue;
1551 #ifndef NO_CLONES
1552 if ((want->flags & PUIFLG_CLONE_PARTS) &&
1553 want->clone_src != NULL &&
1554 want->clone_ndx < want->clone_src->num_sel) {
1555 sp = &want->clone_src->selection[want->clone_ndx];
1556 if (!sp->parts->pscheme->get_part_info(
1557 sp->parts, sp->id, &srcinfo))
1558 continue;
1559 if (!wanted->parts->pscheme->
1560 adapt_foreign_part_info(wanted->parts,
1561 &cinfo, sp->parts->pscheme, &srcinfo))
1562 continue;
1563
1564 /* find space for cinfo and add a partition */
1565 size_t cnt = wanted->parts->pscheme->get_free_spaces(
1566 wanted->parts, &space, 1, want->size-align, align,
1567 from, -1);
1568 if (cnt == 0)
1569 cnt = wanted->parts->pscheme->get_free_spaces(
1570 wanted->parts, &space, 1,
1571 want->size-5*align, align, from, -1);
1572
1573 if (cnt == 0)
1574 continue; /* no free space for this clone */
1575
1576 infos[i] = cinfo;
1577 infos[i].start = space.start;
1578 new_part_id = wanted->parts->pscheme->add_partition(
1579 wanted->parts, &infos[i], NULL);
1580 } else {
1581 #else
1582 {
1583 #endif
1584 if (want->size <= 0)
1585 continue;
1586 size_t cnt = wanted->parts->pscheme->get_free_spaces(
1587 wanted->parts, &space, 1, want->size-align, align,
1588 from, -1);
1589 if (cnt == 0)
1590 cnt = wanted->parts->pscheme->get_free_spaces(
1591 wanted->parts, &space, 1,
1592 want->size-5*align, align, from, -1);
1593
1594 if (cnt == 0)
1595 continue; /* no free space for this partition */
1596
1597 infos[i].start = space.start;
1598 infos[i].size = min(want->size, space.size);
1599 infos[i].nat_type =
1600 wanted->parts->pscheme->get_fs_part_type(
1601 want->type, want->fs_type, want->fs_version);
1602 infos[i].last_mounted = want->mount;
1603 infos[i].fs_type = want->fs_type;
1604 infos[i].fs_sub_type = want->fs_version;
1605 infos[i].fs_opt1 = want->fs_opt1;
1606 infos[i].fs_opt2 = want->fs_opt2;
1607 infos[i].fs_opt3 = want->fs_opt3;
1608 if (want->fs_type != FS_UNUSED &&
1609 want->type != PT_swap) {
1610 want->instflags |= PUIINST_NEWFS;
1611 if (want->mount[0] != 0)
1612 want->instflags |= PUIINST_MOUNT;
1613 }
1614 new_part_id = wanted->parts->pscheme->add_partition(
1615 wanted->parts, &infos[i], NULL);
1616 }
1617
1618 if (new_part_id == NO_PART)
1619 continue; /* failed to add, skip */
1620
1621 wanted->parts->pscheme->get_part_info(
1622 wanted->parts, new_part_id, &infos[i]);
1623 from = roundup(infos[i].start+infos[i].size, align);
1624 }
1625
1626
1627 /*
1628 * If there are any outer partitions that we need as inner ones
1629 * too, add them to the inner partitioning scheme.
1630 */
1631 for (i = 0; i < wanted->num; i++) {
1632 struct part_usage_info *want = &wanted->infos[i];
1633
1634 if (want->cur_part_id == NO_PART)
1635 continue;
1636 if (want->flags & PUIFLG_JUST_MOUNTPOINT)
1637 continue;
1638 if (want->size <= 0)
1639 continue;
1640
1641 if ((want->flags & (PUIFLG_ADD_INNER|PUIFLG_IS_OUTER)) !=
1642 (PUIFLG_ADD_INNER|PUIFLG_IS_OUTER))
1643 continue;
1644
1645 new_part_id = NO_PART;
1646 for (part_id j = 0; new_part_id == NO_PART &&
1647 j < wanted->parts->num_part; j++) {
1648 struct disk_part_info test;
1649
1650 if (!wanted->parts->pscheme->get_part_info(
1651 wanted->parts, j, &test))
1652 continue;
1653 if (test.start == want->cur_start &&
1654 test.size == want->size)
1655 new_part_id = j;
1656 }
1657
1658 if (new_part_id == NO_PART) {
1659 infos[i].start = want->cur_start;
1660 infos[i].size = want->size;
1661 infos[i].nat_type = wanted->parts->pscheme->
1662 get_fs_part_type(want->type, want->fs_type,
1663 want->fs_version);
1664 infos[i].last_mounted = want->mount;
1665 infos[i].fs_type = want->fs_type;
1666 infos[i].fs_sub_type = want->fs_version;
1667 infos[i].fs_opt1 = want->fs_opt1;
1668 infos[i].fs_opt2 = want->fs_opt2;
1669 infos[i].fs_opt3 = want->fs_opt3;
1670
1671 if (wanted->parts->pscheme->add_outer_partition
1672 != NULL)
1673 new_part_id = wanted->parts->pscheme->
1674 add_outer_partition(
1675 wanted->parts, &infos[i], NULL);
1676 else
1677 new_part_id = wanted->parts->pscheme->
1678 add_partition(
1679 wanted->parts, &infos[i], NULL);
1680
1681 if (new_part_id == NO_PART)
1682 continue; /* failed to add, skip */
1683 }
1684
1685 wanted->parts->pscheme->get_part_info(
1686 wanted->parts, new_part_id, &infos[i]);
1687 want->parts = wanted->parts;
1688 if (want->fs_type != FS_UNUSED &&
1689 want->type != PT_swap) {
1690 want->instflags |= PUIINST_NEWFS;
1691 if (want->mount[0] != 0)
1692 want->instflags |= PUIINST_MOUNT;
1693 }
1694 }
1695
1696 /*
1697 * Note: all part_ids are invalid now, as we have added things!
1698 */
1699 for (i = 0; i < wanted->num; i++)
1700 wanted->infos[i].cur_part_id = NO_PART;
1701 for (pno = 0; pno < parts->num_part; pno++) {
1702 struct disk_part_info t;
1703
1704 if (!parts->pscheme->get_part_info(parts, pno, &t))
1705 continue;
1706 if (t.flags & PTI_SPECIAL_PARTS)
1707 continue;
1708
1709 for (i = 0; i < wanted->num; i++) {
1710 if (wanted->infos[i].cur_part_id != NO_PART)
1711 continue;
1712 if (wanted->infos[i].size <= 0)
1713 continue;
1714 if (t.start == infos[i].start) {
1715 wanted->infos[i].cur_part_id = pno;
1716 wanted->infos[i].cur_start = infos[i].start;
1717 wanted->infos[i].cur_flags = infos[i].flags;
1718 break;
1719 }
1720 }
1721 }
1722 free(infos);
1723
1724 /* sort, and sync part ids and wanted->infos[] indices */
1725 sort_and_sync_parts(wanted);
1726 }
1727
1728 static void
1729 replace_by_default(struct disk_partitions *parts,
1730 daddr_t start, daddr_t size, struct partition_usage_set *wanted)
1731 {
1732
1733 if (start == 0 && size == parts->disk_size)
1734 parts->pscheme->delete_all_partitions(parts);
1735 else if (parts->pscheme->delete_partitions_in_range != NULL)
1736 parts->pscheme->delete_partitions_in_range(parts, start, size);
1737 else
1738 assert(parts->num_part == 0);
1739
1740 fill_defaults(wanted, parts, start, size);
1741 apply_settings_to_partitions(parts, wanted, start, size);
1742 }
1743
1744 static bool
1745 edit_with_defaults(struct disk_partitions *parts,
1746 daddr_t start, daddr_t size, struct partition_usage_set *wanted)
1747 {
1748 bool ok;
1749
1750 fill_defaults(wanted, parts, start, size);
1751 ok = get_ptn_sizes(wanted);
1752 if (ok)
1753 apply_settings_to_partitions(parts, wanted, start, size);
1754 return ok;
1755 }
1756
1757 /*
1758 * md back-end code for menu-driven BSD disklabel editor.
1759 * returns 0 on failure, 1 on success, -1 for restart.
1760 * fills the install target with a list for newfs/fstab.
1761 */
1762 int
1763 make_bsd_partitions(struct install_partition_desc *install)
1764 {
1765 struct disk_partitions *parts = pm->parts;
1766 const struct disk_partitioning_scheme *pscheme;
1767 struct partition_usage_set wanted;
1768 daddr_t p_start, p_size;
1769 enum layout_type layoutkind = LY_SETSIZES;
1770 bool have_existing;
1771
1772 if (pm && pm->no_part && parts == NULL)
1773 return 1;
1774 if (parts == NULL) {
1775 pscheme = select_part_scheme(pm, NULL, !pm->no_mbr, NULL);
1776 if (pscheme == NULL)
1777 return 0;
1778 parts = pscheme->create_new_for_disk(pm->diskdev,
1779 0, pm->dlsize, true, NULL);
1780 if (parts == NULL)
1781 return 0;
1782 pm->parts = parts;
1783 } else {
1784 pscheme = parts->pscheme;
1785 }
1786
1787 if (pscheme->secondary_partitions) {
1788 struct disk_partitions *p;
1789
1790 p = pscheme->secondary_partitions(parts, pm->ptstart, false);
1791 if (p) {
1792 parts = p;
1793 pscheme = parts->pscheme;
1794 }
1795 }
1796
1797 have_existing = check_existing_netbsd(parts);
1798
1799 /*
1800 * Make sure the cylinder size multiplier/divisor and disk size are
1801 * valid
1802 */
1803 if (pm->current_cylsize == 0)
1804 pm->current_cylsize = pm->dlcylsize;
1805 if (pm->ptsize == 0)
1806 pm->ptsize = pm->dlsize;
1807
1808 /* Ask for layout type -- standard or special */
1809 if (partman_go == 0) {
1810 char bsd_size[6], min_size[6], x_size[6];
1811
1812 humanize_number(bsd_size, sizeof(bsd_size),
1813 (uint64_t)pm->ptsize*pm->sectorsize,
1814 "", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
1815 humanize_number(min_size, sizeof(min_size),
1816 (uint64_t)(DEFROOTSIZE + DEFSWAPSIZE + DEFUSRSIZE)*MEG,
1817 "", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
1818 humanize_number(x_size, sizeof(x_size),
1819 (uint64_t)(DEFROOTSIZE + DEFSWAPSIZE + DEFUSRSIZE
1820 + XNEEDMB)*MEG,
1821 "", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
1822
1823 msg_display_subst(
1824 have_existing ? MSG_layout_prologue_existing
1825 : MSG_layout_prologue_none, 6, pm->diskdev,
1826 msg_string(parts->pscheme->name),
1827 msg_string(parts->pscheme->short_name),
1828 bsd_size, min_size, x_size);
1829 msg_display_add_subst(MSG_layout_main, 6,
1830 pm->diskdev,
1831 msg_string(parts->pscheme->name),
1832 msg_string(parts->pscheme->short_name),
1833 bsd_size, min_size, x_size);
1834 msg_display_add("\n\n");
1835 layoutkind = ask_layout(parts, have_existing);
1836 if (layoutkind == LY_ERROR)
1837 return 0;
1838 }
1839
1840 if (layoutkind == LY_USEDEFAULT || layoutkind == LY_SETSIZES) {
1841 /* calc available disk area for the NetBSD partitions */
1842 p_start = pm->ptstart;
1843 p_size = pm->ptsize;
1844 if (parts->parent != NULL &&
1845 parts->parent->pscheme->guess_install_target != NULL)
1846 parts->parent->pscheme->guess_install_target(
1847 parts->parent, &p_start, &p_size);
1848 }
1849 if (layoutkind == LY_OTHERSCHEME) {
1850 parts->pscheme->destroy_part_scheme(parts);
1851 return -1;
1852 } else if (layoutkind == LY_USENONE) {
1853 struct disk_part_free_space space;
1854 size_t cnt;
1855
1856 empty_usage_set_from_parts(&wanted, parts);
1857 cnt = parts->pscheme->get_free_spaces(parts, &space, 1,
1858 0, parts->pscheme->get_part_alignment(parts), 0, -1);
1859 p_start = p_size = 0;
1860 if (cnt == 1) {
1861 p_start = space.start;
1862 p_size = space.size;
1863 wanted.cur_free_space = space.size;
1864 }
1865 } else if (layoutkind == LY_USEDEFAULT) {
1866 replace_by_default(parts, p_start, p_size,
1867 &wanted);
1868 } else if (layoutkind == LY_SETSIZES) {
1869 if (!edit_with_defaults(parts, p_start, p_size,
1870 &wanted)) {
1871 free_usage_set(&wanted);
1872 return 0;
1873 }
1874 } else {
1875 usage_set_from_parts(&wanted, parts);
1876 }
1877
1878 /*
1879 * Make sure the target root partition is properly marked,
1880 * check for existing EFI boot partition.
1881 */
1882 bool have_inst_target = false;
1883 #ifdef HAVE_EFI_BOOT
1884 daddr_t target_start = -1;
1885 #endif
1886 for (size_t i = 0; i < wanted.num; i++) {
1887 if (wanted.infos[i].cur_flags & PTI_INSTALL_TARGET) {
1888 have_inst_target = true;
1889 #ifdef HAVE_EFI_BOOT
1890 target_start = wanted.infos[i].cur_start;
1891 #endif
1892 break;
1893 }
1894 }
1895 if (!have_inst_target) {
1896 for (size_t i = 0; i < wanted.num; i++) {
1897 struct disk_part_info info;
1898
1899 if (wanted.infos[i].type != PT_root ||
1900 strcmp(wanted.infos[i].mount, "/") != 0)
1901 continue;
1902 wanted.infos[i].cur_flags |= PTI_INSTALL_TARGET;
1903
1904 if (!wanted.parts->pscheme->get_part_info(wanted.parts,
1905 wanted.infos[i].cur_part_id, &info))
1906 break;
1907 info.flags |= PTI_INSTALL_TARGET;
1908 wanted.parts->pscheme->set_part_info(wanted.parts,
1909 wanted.infos[i].cur_part_id, &info, NULL);
1910 #ifdef HAVE_EFI_BOOT
1911 target_start = wanted.infos[i].cur_start;
1912 #endif
1913 break;
1914 }
1915 }
1916 #ifdef HAVE_EFI_BOOT
1917 size_t boot_part = ~0U;
1918 for (part_id i = 0; i < wanted.num; i++) {
1919 if ((wanted.infos[i].cur_flags & PTI_BOOT) != 0 ||
1920 wanted.infos[i].type == PT_EFI_SYSTEM) {
1921 boot_part = i;
1922 break;
1923 }
1924 }
1925 if (boot_part == ~0U) {
1926 for (part_id i = 0; i < wanted.num; i++) {
1927 /*
1928 * heuristic to recognize existing MBR FAT
1929 * partitions as EFI without looking for
1930 * details
1931 */
1932 if ((wanted.infos[i].type != PT_FAT &&
1933 wanted.infos[i].type != PT_EFI_SYSTEM) ||
1934 wanted.infos[i].fs_type != FS_MSDOS)
1935 continue;
1936 daddr_t ps = wanted.infos[i].cur_start;
1937 daddr_t pe = ps + wanted.infos[i].size;
1938 if (target_start >= 0 &&
1939 (ps >= target_start || pe >= target_start))
1940 continue;
1941 boot_part = i;
1942 break;
1943 }
1944 }
1945 if (boot_part != ~0U) {
1946 struct disk_part_info info;
1947
1948 if (wanted.parts->pscheme->get_part_info(wanted.parts,
1949 wanted.infos[boot_part].cur_part_id, &info)) {
1950 info.flags |= PTI_BOOT;
1951 wanted.parts->pscheme->set_part_info(wanted.parts,
1952 wanted.infos[boot_part].cur_part_id, &info, NULL);
1953 }
1954 wanted.infos[boot_part].instflags |= PUIINST_BOOT;
1955 }
1956 #endif
1957
1958 /*
1959 * OK, we have a partition table. Give the user the chance to
1960 * edit it and verify it's OK, or abort altogether.
1961 */
1962 for (;;) {
1963 int rv = edit_and_check_label(pm, &wanted, true);
1964 if (rv == 0) {
1965 msg_display(MSG_abort_part);
1966 free_usage_set(&wanted);
1967 return 0;
1968 }
1969 /* update install infos */
1970 install->num = wanted.num;
1971 install->infos = wanted.infos;
1972 install->write_back = wanted.write_back;
1973 install->num_write_back = wanted.num_write_back;
1974 /* and check them */
1975 if (check_partitions(install))
1976 break;
1977 }
1978
1979 /* we moved infos from wanted to install target */
1980 wanted.infos = NULL;
1981 wanted.write_back = NULL;
1982 free_usage_set(&wanted);
1983
1984 /* Everything looks OK. */
1985 return 1;
1986 }
1987
1988 #ifndef MD_NEED_BOOTBLOCK
1989 #define MD_NEED_BOOTBLOCK(A) true
1990 #endif
1991
1992 /*
1993 * check that there is at least a / somewhere.
1994 */
1995 bool
1996 check_partitions(struct install_partition_desc *install)
1997 {
1998 #ifdef HAVE_BOOTXX_xFS
1999 int rv = 1;
2000 char *bootxx;
2001 #endif
2002 #ifndef HAVE_UFS2_BOOT
2003 size_t i;
2004 #endif
2005
2006 #ifdef HAVE_BOOTXX_xFS
2007 if (MD_NEED_BOOTBLOCK(install)) {
2008 /* check if we have boot code for the root partition type */
2009 bootxx = bootxx_name(install);
2010 if (bootxx != NULL) {
2011 rv = access(bootxx, R_OK);
2012 free(bootxx);
2013 } else
2014 rv = -1;
2015 if (rv != 0) {
2016 hit_enter_to_continue(NULL, MSG_No_Bootcode);
2017 return false;
2018 }
2019 }
2020 #endif
2021 #ifndef HAVE_UFS2_BOOT
2022 if (MD_NEED_BOOTBLOCK(install)) {
2023 for (i = 0; i < install->num; i++) {
2024 if (install->infos[i].type != PT_root)
2025 continue;
2026 if (strcmp(install->infos[i].mount, "/") != 0)
2027 continue;
2028 if (install->infos[i].fs_type != FS_BSDFFS)
2029 continue;
2030 if (install->infos[i].fs_version < 2)
2031 continue;
2032 hit_enter_to_continue(NULL, MSG_cannot_ufs2_root);
2033 return false;
2034 }
2035 }
2036 #endif
2037
2038 return md_check_partitions(install);
2039 }
2040