1cdd2d676SSascha Wildner /*
2f9602a12SMatthew Dillon * Copyright (c)2004,2015 The DragonFly Project. All rights reserved.
3cdd2d676SSascha Wildner *
4cdd2d676SSascha Wildner * Redistribution and use in source and binary forms, with or without
5cdd2d676SSascha Wildner * modification, are permitted provided that the following conditions
6cdd2d676SSascha Wildner * are met:
7cdd2d676SSascha Wildner *
8cdd2d676SSascha Wildner * Redistributions of source code must retain the above copyright
9cdd2d676SSascha Wildner * notice, this list of conditions and the following disclaimer.
10cdd2d676SSascha Wildner *
11cdd2d676SSascha Wildner * Redistributions in binary form must reproduce the above copyright
12cdd2d676SSascha Wildner * notice, this list of conditions and the following disclaimer in
13cdd2d676SSascha Wildner * the documentation and/or other materials provided with the
14cdd2d676SSascha Wildner * distribution.
15cdd2d676SSascha Wildner *
16cdd2d676SSascha Wildner * Neither the name of the DragonFly Project nor the names of its
17cdd2d676SSascha Wildner * contributors may be used to endorse or promote products derived
18cdd2d676SSascha Wildner * from this software without specific prior written permission.
19cdd2d676SSascha Wildner *
20cdd2d676SSascha Wildner * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21cdd2d676SSascha Wildner * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22cdd2d676SSascha Wildner * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23cdd2d676SSascha Wildner * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
24cdd2d676SSascha Wildner * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
25cdd2d676SSascha Wildner * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
26cdd2d676SSascha Wildner * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
27cdd2d676SSascha Wildner * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28cdd2d676SSascha Wildner * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
29cdd2d676SSascha Wildner * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30cdd2d676SSascha Wildner * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
31cdd2d676SSascha Wildner * OF THE POSSIBILITY OF SUCH DAMAGE.
32cdd2d676SSascha Wildner */
33cdd2d676SSascha Wildner
34cdd2d676SSascha Wildner /*
35cdd2d676SSascha Wildner * fn_subpart.c
36cdd2d676SSascha Wildner * Installer Function : Create Subpartitions.
37cdd2d676SSascha Wildner * $Id: fn_subpart.c,v 1.50 2005/04/07 20:22:40 cpressey Exp $
38cdd2d676SSascha Wildner */
39cdd2d676SSascha Wildner
40cdd2d676SSascha Wildner #include <stdio.h>
41cdd2d676SSascha Wildner #include <stdlib.h>
42cdd2d676SSascha Wildner #include <string.h>
43*5950cfffSSascha Wildner #include <unistd.h>
44cdd2d676SSascha Wildner
45cdd2d676SSascha Wildner #ifdef ENABLE_NLS
46cdd2d676SSascha Wildner #include <libintl.h>
47cdd2d676SSascha Wildner #define _(String) gettext (String)
48cdd2d676SSascha Wildner #else
49cdd2d676SSascha Wildner #define _(String) (String)
50cdd2d676SSascha Wildner #endif
51cdd2d676SSascha Wildner
52cdd2d676SSascha Wildner #include "libaura/mem.h"
53cdd2d676SSascha Wildner #include "libaura/buffer.h"
54cdd2d676SSascha Wildner #include "libaura/dict.h"
55cdd2d676SSascha Wildner #include "libaura/fspred.h"
56cdd2d676SSascha Wildner
57cdd2d676SSascha Wildner #include "libdfui/dfui.h"
58cdd2d676SSascha Wildner #include "libdfui/dump.h"
59cdd2d676SSascha Wildner #include "libdfui/system.h"
60cdd2d676SSascha Wildner
61cdd2d676SSascha Wildner #include "libinstaller/commands.h"
62cdd2d676SSascha Wildner #include "libinstaller/diskutil.h"
63cdd2d676SSascha Wildner #include "libinstaller/functions.h"
64cdd2d676SSascha Wildner #include "libinstaller/uiutil.h"
65cdd2d676SSascha Wildner
66cdd2d676SSascha Wildner #include "fn.h"
67cdd2d676SSascha Wildner #include "flow.h"
68cdd2d676SSascha Wildner #include "pathnames.h"
69cdd2d676SSascha Wildner
70f9602a12SMatthew Dillon #define MTPT_BOOT 0
71f9602a12SMatthew Dillon #define MTPT_SWAP 1
72f9602a12SMatthew Dillon #define MTPT_ROOT 2
73f9602a12SMatthew Dillon #define MTPT_BUILD 3
74f9602a12SMatthew Dillon
75cdd2d676SSascha Wildner static int create_subpartitions(struct i_fn_args *);
76f9602a12SMatthew Dillon static long default_capacity(struct storage *, const char *);
77cdd2d676SSascha Wildner static int check_capacity(struct i_fn_args *);
78cdd2d676SSascha Wildner static int check_subpartition_selections(struct dfui_response *, struct i_fn_args *);
79cdd2d676SSascha Wildner static void save_subpartition_selections(struct dfui_response *, struct i_fn_args *);
80cdd2d676SSascha Wildner static void populate_create_subpartitions_form(struct dfui_form *, struct i_fn_args *);
81cdd2d676SSascha Wildner static int warn_subpartition_selections(struct i_fn_args *);
82cdd2d676SSascha Wildner static struct dfui_form *make_create_subpartitions_form(struct i_fn_args *);
83cdd2d676SSascha Wildner static int show_create_subpartitions_form(struct dfui_form *, struct i_fn_args *);
84cdd2d676SSascha Wildner
85f9602a12SMatthew Dillon static const char *def_mountpt[] = {"/boot", "swap", "/", "/build", NULL};
86f9602a12SMatthew Dillon static long min_capacity[] = { 128, 0, DISK_MIN - 128, BUILD_MIN };
87cdd2d676SSascha Wildner static int expert = 0;
88cdd2d676SSascha Wildner
89cdd2d676SSascha Wildner /*
90cdd2d676SSascha Wildner * Given a set of subpartitions-to-be in the selected slice,
91cdd2d676SSascha Wildner * create them.
92cdd2d676SSascha Wildner */
93cdd2d676SSascha Wildner static int
create_subpartitions(struct i_fn_args * a)94cdd2d676SSascha Wildner create_subpartitions(struct i_fn_args *a)
95cdd2d676SSascha Wildner {
96cdd2d676SSascha Wildner struct subpartition *sp;
97cdd2d676SSascha Wildner struct commands *cmds;
98cdd2d676SSascha Wildner int result = 0;
99cdd2d676SSascha Wildner int num_partitions;
100cdd2d676SSascha Wildner
101cdd2d676SSascha Wildner cmds = commands_new();
102cdd2d676SSascha Wildner if (!is_file("%sinstall.disklabel.%s",
103cdd2d676SSascha Wildner a->tmp,
104cdd2d676SSascha Wildner slice_get_device_name(storage_get_selected_slice(a->s)))) {
105cdd2d676SSascha Wildner /*
106cdd2d676SSascha Wildner * Get a copy of the 'virgin' disklabel.
107cdd2d676SSascha Wildner * XXX It might make more sense for this to
108cdd2d676SSascha Wildner * happen right after format_slice() instead.
109cdd2d676SSascha Wildner */
110cdd2d676SSascha Wildner command_add(cmds, "%s%s -r %s >%sinstall.disklabel.%s",
111b5cb2d94SSascha Wildner a->os_root, cmd_name(a, "DISKLABEL64"),
112cdd2d676SSascha Wildner slice_get_device_name(storage_get_selected_slice(a->s)),
113cdd2d676SSascha Wildner a->tmp,
114cdd2d676SSascha Wildner slice_get_device_name(storage_get_selected_slice(a->s)));
115cdd2d676SSascha Wildner }
116cdd2d676SSascha Wildner
117cdd2d676SSascha Wildner /*
118cdd2d676SSascha Wildner * Weave together a new disklabel out the of the 'virgin'
119cdd2d676SSascha Wildner * disklabel, and the user's subpartition choices.
120cdd2d676SSascha Wildner */
121cdd2d676SSascha Wildner
122cdd2d676SSascha Wildner /*
123cdd2d676SSascha Wildner * Take everything from the 'virgin' disklabel up until the
124cdd2d676SSascha Wildner * '16 partitions' line.
125cdd2d676SSascha Wildner */
126cdd2d676SSascha Wildner num_partitions = 16;
127cdd2d676SSascha Wildner command_add(cmds, "%s%s '$2==\"partitions:\" || cut { cut = 1 } !cut { print $0 }' <%sinstall.disklabel.%s >%sinstall.disklabel",
128cdd2d676SSascha Wildner a->os_root, cmd_name(a, "AWK"),
129cdd2d676SSascha Wildner a->tmp,
130cdd2d676SSascha Wildner slice_get_device_name(storage_get_selected_slice(a->s)),
131cdd2d676SSascha Wildner a->tmp);
132cdd2d676SSascha Wildner
133cdd2d676SSascha Wildner /*
134cdd2d676SSascha Wildner * 16 partitions:
135cdd2d676SSascha Wildner * # size offset fstype
136cdd2d676SSascha Wildner * c: 16383969 0 unused # 7999.985MB
137cdd2d676SSascha Wildner */
138cdd2d676SSascha Wildner
139cdd2d676SSascha Wildner command_add(cmds, "%s%s '%d partitions:' >>%sinstall.disklabel",
140cdd2d676SSascha Wildner a->os_root, cmd_name(a, "ECHO"), num_partitions ,a->tmp);
141cdd2d676SSascha Wildner command_add(cmds, "%s%s '%s' >>%sinstall.disklabel",
142cdd2d676SSascha Wildner a->os_root, cmd_name(a, "ECHO"),
143cdd2d676SSascha Wildner "# size offset fstype",
144cdd2d676SSascha Wildner a->tmp);
145cdd2d676SSascha Wildner
146cdd2d676SSascha Wildner #ifdef DEBUG
147cdd2d676SSascha Wildner for (sp = slice_subpartition_first(storage_get_selected_slice(a->s));
148cdd2d676SSascha Wildner sp != NULL; sp = subpartition_next(sp)) {
149cdd2d676SSascha Wildner command_add(cmds, "%s%s 'mountpoint: %s device: %s'",
150cdd2d676SSascha Wildner a->os_root, cmd_name(a, "ECHO"),
151cdd2d676SSascha Wildner subpartition_get_mountpoint(sp),
152cdd2d676SSascha Wildner subpartition_get_device_name(sp));
153cdd2d676SSascha Wildner }
154cdd2d676SSascha Wildner #endif
155cdd2d676SSascha Wildner
156cdd2d676SSascha Wildner /*
157cdd2d676SSascha Wildner * Write a line for each subpartition the user wants.
158cdd2d676SSascha Wildner */
159cdd2d676SSascha Wildner for (sp = slice_subpartition_first(storage_get_selected_slice(a->s));
160cdd2d676SSascha Wildner sp != NULL; sp = subpartition_next(sp)) {
161761cad2fSSascha Wildner if (subpartition_is_tmpfsbacked(sp)) {
162cdd2d676SSascha Wildner continue;
163cdd2d676SSascha Wildner }
164cdd2d676SSascha Wildner if (subpartition_is_swap(sp)) {
165cdd2d676SSascha Wildner command_add(cmds, "%s%s ' %c:\t%s\t*\tswap' >>%sinstall.disklabel",
166cdd2d676SSascha Wildner a->os_root, cmd_name(a, "ECHO"),
167cdd2d676SSascha Wildner subpartition_get_letter(sp),
168cdd2d676SSascha Wildner capacity_to_string(subpartition_get_capacity(sp)),
169cdd2d676SSascha Wildner a->tmp);
170cdd2d676SSascha Wildner } else {
171cdd2d676SSascha Wildner command_add(cmds, "%s%s ' %c:\t%s\t%s\t4.2BSD' >>%sinstall.disklabel",
172cdd2d676SSascha Wildner a->os_root, cmd_name(a, "ECHO"),
173cdd2d676SSascha Wildner subpartition_get_letter(sp),
174cdd2d676SSascha Wildner capacity_to_string(subpartition_get_capacity(sp)),
175cdd2d676SSascha Wildner subpartition_get_letter(sp) == 'a' ? "0" : "*",
176cdd2d676SSascha Wildner a->tmp);
177cdd2d676SSascha Wildner }
178cdd2d676SSascha Wildner }
179cdd2d676SSascha Wildner temp_file_add(a, "install.disklabel");
180cdd2d676SSascha Wildner
181cdd2d676SSascha Wildner /*
182cdd2d676SSascha Wildner * Label the slice from the disklabel we just wove together.
183cdd2d676SSascha Wildner */
184cdd2d676SSascha Wildner command_add(cmds, "%s%s -R -B -r %s %sinstall.disklabel",
185b5cb2d94SSascha Wildner a->os_root, cmd_name(a, "DISKLABEL64"),
186cdd2d676SSascha Wildner slice_get_device_name(storage_get_selected_slice(a->s)),
187cdd2d676SSascha Wildner a->tmp);
188cdd2d676SSascha Wildner
189cdd2d676SSascha Wildner /*
190cdd2d676SSascha Wildner * Create a snapshot of the disklabel we just created
191cdd2d676SSascha Wildner * for debugging inspection in the log.
192cdd2d676SSascha Wildner */
193cdd2d676SSascha Wildner command_add(cmds, "%s%s %s",
194b5cb2d94SSascha Wildner a->os_root, cmd_name(a, "DISKLABEL64"),
195cdd2d676SSascha Wildner slice_get_device_name(storage_get_selected_slice(a->s)));
196cdd2d676SSascha Wildner
197cdd2d676SSascha Wildner /*
198242084fdSAaron LI * If encryption was specified, read the passphrase.
19988cfb1f7SSascha Wildner */
20088cfb1f7SSascha Wildner for (sp = slice_subpartition_first(storage_get_selected_slice(a->s));
20188cfb1f7SSascha Wildner sp != NULL; sp = subpartition_next(sp)) {
20288cfb1f7SSascha Wildner if (subpartition_is_encrypted(sp)) {
203242084fdSAaron LI fn_get_passphrase(a, 1);
20488cfb1f7SSascha Wildner break;
20588cfb1f7SSascha Wildner }
20688cfb1f7SSascha Wildner }
20788cfb1f7SSascha Wildner
20888cfb1f7SSascha Wildner /*
209cdd2d676SSascha Wildner * Create filesystems on the newly-created subpartitions.
210cdd2d676SSascha Wildner */
211cdd2d676SSascha Wildner for (sp = slice_subpartition_first(storage_get_selected_slice(a->s));
212cdd2d676SSascha Wildner sp != NULL; sp = subpartition_next(sp)) {
21388cfb1f7SSascha Wildner if (subpartition_is_swap(sp) || subpartition_is_tmpfsbacked(sp)) {
21488cfb1f7SSascha Wildner if (subpartition_is_swap(sp) &&
21588cfb1f7SSascha Wildner subpartition_is_encrypted(sp)) {
21688cfb1f7SSascha Wildner command_add(cmds,
21751871435SSascha Wildner "%s%s -d /tmp/t1 luksFormat /dev/%s",
21888cfb1f7SSascha Wildner a->os_root, cmd_name(a, "CRYPTSETUP"),
21988cfb1f7SSascha Wildner subpartition_get_device_name(sp));
22088cfb1f7SSascha Wildner command_add(cmds,
22151871435SSascha Wildner "%s%s -d /tmp/t1 luksOpen /dev/%s swap",
22288cfb1f7SSascha Wildner a->os_root, cmd_name(a, "CRYPTSETUP"),
22388cfb1f7SSascha Wildner subpartition_get_device_name(sp));
22488cfb1f7SSascha Wildner }
225cdd2d676SSascha Wildner continue;
22688cfb1f7SSascha Wildner }
227cdd2d676SSascha Wildner
228f9602a12SMatthew Dillon if (subpartition_is_encrypted(sp)) {
22988cfb1f7SSascha Wildner command_add(cmds,
23051871435SSascha Wildner "%s%s -d /tmp/t1 luksFormat /dev/%s",
23188cfb1f7SSascha Wildner a->os_root, cmd_name(a, "CRYPTSETUP"),
23288cfb1f7SSascha Wildner subpartition_get_device_name(sp));
23388cfb1f7SSascha Wildner command_add(cmds,
23451871435SSascha Wildner "%s%s -d /tmp/t1 luksOpen /dev/%s %s",
23588cfb1f7SSascha Wildner a->os_root, cmd_name(a, "CRYPTSETUP"),
23688cfb1f7SSascha Wildner subpartition_get_device_name(sp),
2370c941bc8SSascha Wildner subpartition_get_mapper_name(sp, -1));
23851871435SSascha Wildner command_add(cmds, "%s%s%s -b %ld -f %ld /dev/mapper/%s",
23988cfb1f7SSascha Wildner a->os_root, cmd_name(a, "NEWFS"),
24088cfb1f7SSascha Wildner subpartition_is_softupdated(sp) ? " -U" : "",
24188cfb1f7SSascha Wildner subpartition_get_bsize(sp),
24288cfb1f7SSascha Wildner subpartition_get_fsize(sp),
2430c941bc8SSascha Wildner subpartition_get_mapper_name(sp, -1));
24488cfb1f7SSascha Wildner } else {
24551871435SSascha Wildner command_add(cmds, "%s%s%s -b %ld -f %ld /dev/%s",
246cdd2d676SSascha Wildner a->os_root, cmd_name(a, "NEWFS"),
247cdd2d676SSascha Wildner subpartition_is_softupdated(sp) ? " -U" : "",
248cdd2d676SSascha Wildner subpartition_get_bsize(sp),
249cdd2d676SSascha Wildner subpartition_get_fsize(sp),
250cdd2d676SSascha Wildner subpartition_get_device_name(sp));
251cdd2d676SSascha Wildner }
25288cfb1f7SSascha Wildner }
253cdd2d676SSascha Wildner
254cdd2d676SSascha Wildner result = commands_execute(a, cmds);
255cdd2d676SSascha Wildner commands_free(cmds);
256f8608e0dSAaron LI unlink("/tmp/t1");
257f8608e0dSAaron LI
258cdd2d676SSascha Wildner return(result);
259cdd2d676SSascha Wildner }
260cdd2d676SSascha Wildner
261f9602a12SMatthew Dillon /*
262f9602a12SMatthew Dillon * Return default capacity field filler. Return 0 for /build if drive
263f9602a12SMatthew Dillon * space minus swap is < 40GB (causes installer to use PFS's on the root
264f9602a12SMatthew Dillon * partition instead).
265f9602a12SMatthew Dillon */
266cdd2d676SSascha Wildner static long
default_capacity(struct storage * s,const char * mtpt)267f9602a12SMatthew Dillon default_capacity(struct storage *s, const char *mtpt)
268cdd2d676SSascha Wildner {
269f9602a12SMatthew Dillon unsigned long boot, root, swap, build;
270cdd2d676SSascha Wildner unsigned long capacity;
2716cd7259eSSascha Wildner unsigned long mem;
272cdd2d676SSascha Wildner
273f9602a12SMatthew Dillon capacity = slice_get_capacity(storage_get_selected_slice(s)); /* MB */
2746cd7259eSSascha Wildner mem = storage_get_memsize(s);
275f9602a12SMatthew Dillon
276f9602a12SMatthew Dillon /*
277f9602a12SMatthew Dillon * Slice capacity is at least 10G at this point. Calculate basic
278f9602a12SMatthew Dillon * defaults.
279f9602a12SMatthew Dillon */
2806cd7259eSSascha Wildner swap = 2 * mem;
281f9602a12SMatthew Dillon if (swap > capacity / 10) /* max 1/10 capacity */
282f9602a12SMatthew Dillon swap = capacity / 10;
283f9602a12SMatthew Dillon if (swap < SWAP_MIN) /* having a little is nice */
284f9602a12SMatthew Dillon swap = SWAP_MIN;
285f9602a12SMatthew Dillon if (swap > SWAP_MAX) /* installer cap */
286f76463ceSSascha Wildner swap = SWAP_MAX;
287cdd2d676SSascha Wildner
288f9602a12SMatthew Dillon boot = 1024;
289f9602a12SMatthew Dillon
29034ca1b1cSMatthew Dillon build = (capacity - swap - boot) / 4;
29134ca1b1cSMatthew Dillon #if 0
29234ca1b1cSMatthew Dillon /*
29334ca1b1cSMatthew Dillon * No longer cap the size of /build, the assumption didn't hold
29434ca1b1cSMatthew Dillon * well particularly with /var/crash being placed on /build now.
29534ca1b1cSMatthew Dillon */
296f9602a12SMatthew Dillon if (build > BUILD_MAX)
297f9602a12SMatthew Dillon build = BUILD_MAX;
29834ca1b1cSMatthew Dillon #endif
299f9602a12SMatthew Dillon
300f9602a12SMatthew Dillon for (;;) {
301f9602a12SMatthew Dillon root = (capacity - swap - boot - build);
302f9602a12SMatthew Dillon
303f9602a12SMatthew Dillon /*
304f9602a12SMatthew Dillon * Adjust until the defaults look sane
305f9602a12SMatthew Dillon *
306f9602a12SMatthew Dillon * root should be at least twice as large as build
307f9602a12SMatthew Dillon */
308f9602a12SMatthew Dillon if (build && root < build * 2) {
309f9602a12SMatthew Dillon --build;
310f9602a12SMatthew Dillon continue;
311cdd2d676SSascha Wildner }
312f9602a12SMatthew Dillon
313f9602a12SMatthew Dillon /*
314f9602a12SMatthew Dillon * root should be at least 1/2 capacity
315f9602a12SMatthew Dillon */
316f9602a12SMatthew Dillon if (build && root < capacity / 2) {
317f9602a12SMatthew Dillon --build;
318f9602a12SMatthew Dillon continue;
319cdd2d676SSascha Wildner }
320f9602a12SMatthew Dillon break;
321cdd2d676SSascha Wildner }
322f9602a12SMatthew Dillon
323f9602a12SMatthew Dillon /*
324f9602a12SMatthew Dillon * Finalize. If build is too small do not supply a /build,
32534ca1b1cSMatthew Dillon * and if swap is too small do not supply swap. Cascade the
32634ca1b1cSMatthew Dillon * released space to swap and root.
327f9602a12SMatthew Dillon */
32834ca1b1cSMatthew Dillon if (build < BUILD_MIN) {
32934ca1b1cSMatthew Dillon if (swap < SWAP_MIN && build >= SWAP_MIN - swap) {
33034ca1b1cSMatthew Dillon build -= SWAP_MIN - swap;
33134ca1b1cSMatthew Dillon swap = SWAP_MIN;
33234ca1b1cSMatthew Dillon }
33334ca1b1cSMatthew Dillon if (swap < 2 * mem && build >= 2 * mem - swap) {
33434ca1b1cSMatthew Dillon build -= 2 * mem - swap;
33534ca1b1cSMatthew Dillon swap = 2 * mem;
33634ca1b1cSMatthew Dillon }
33734ca1b1cSMatthew Dillon root += build;
338f9602a12SMatthew Dillon build = 0;
33934ca1b1cSMatthew Dillon }
34034ca1b1cSMatthew Dillon if (swap < SWAP_MIN) {
34134ca1b1cSMatthew Dillon root += swap;
342f9602a12SMatthew Dillon swap = 0;
34334ca1b1cSMatthew Dillon }
34434ca1b1cSMatthew Dillon
345f9602a12SMatthew Dillon if (build == 0)
346f9602a12SMatthew Dillon root = -1; /* no /build, root is the last part */
347f9602a12SMatthew Dillon else
348f9602a12SMatthew Dillon build = -1; /* last partition just use remaining space */
349f9602a12SMatthew Dillon
350f9602a12SMatthew Dillon if (strcmp(mtpt, "/boot") == 0)
351f9602a12SMatthew Dillon return(boot);
352f9602a12SMatthew Dillon else if (strcmp(mtpt, "/build") == 0)
353f9602a12SMatthew Dillon return(build);
354f9602a12SMatthew Dillon else if (strcmp(mtpt, "swap") == 0)
355f9602a12SMatthew Dillon return(swap);
356f9602a12SMatthew Dillon else if (strcmp(mtpt, "/") == 0)
357f9602a12SMatthew Dillon return(root);
358f9602a12SMatthew Dillon
359cdd2d676SSascha Wildner /* shouldn't ever happen */
360cdd2d676SSascha Wildner return(-1);
361cdd2d676SSascha Wildner }
362cdd2d676SSascha Wildner
363cdd2d676SSascha Wildner static int
check_capacity(struct i_fn_args * a)364cdd2d676SSascha Wildner check_capacity(struct i_fn_args *a)
365cdd2d676SSascha Wildner {
366cdd2d676SSascha Wildner struct subpartition *sp;
367cdd2d676SSascha Wildner unsigned long total_capacity = 0;
368cdd2d676SSascha Wildner int mtpt;
369cdd2d676SSascha Wildner
370cdd2d676SSascha Wildner for (sp = slice_subpartition_first(storage_get_selected_slice(a->s));
371cdd2d676SSascha Wildner sp != NULL; sp = subpartition_next(sp)) {
37270f67d72SSascha Wildner long subpart_capacity = subpartition_get_capacity(sp);
37370f67d72SSascha Wildner const char *mountpt = subpartition_get_mountpoint(sp);
37470f67d72SSascha Wildner
37570f67d72SSascha Wildner if (subpart_capacity == -1)
376cdd2d676SSascha Wildner total_capacity++;
377cdd2d676SSascha Wildner else
37870f67d72SSascha Wildner total_capacity += subpart_capacity;
379cdd2d676SSascha Wildner for (mtpt = 0; def_mountpt[mtpt] != NULL; mtpt++) {
38070f67d72SSascha Wildner if (strcmp(mountpt, def_mountpt[mtpt]) == 0 &&
381b680ec87SSascha Wildner subpart_capacity < min_capacity[mtpt] &&
382b680ec87SSascha Wildner subpart_capacity != -1) {
38370f67d72SSascha Wildner inform(a->c, _("WARNING: The size (%ldM) specified for "
38470f67d72SSascha Wildner "the %s subpartition is too small. It "
38570f67d72SSascha Wildner "should be at least %ldM or you will "
386cdd2d676SSascha Wildner "risk running out of space during "
387cdd2d676SSascha Wildner "the installation."),
38870f67d72SSascha Wildner subpart_capacity, mountpt,
38970f67d72SSascha Wildner min_capacity[mtpt]);
390cdd2d676SSascha Wildner }
391cdd2d676SSascha Wildner }
392cdd2d676SSascha Wildner }
393cdd2d676SSascha Wildner
394cdd2d676SSascha Wildner if (total_capacity > slice_get_capacity(storage_get_selected_slice(a->s))) {
395cdd2d676SSascha Wildner inform(a->c, _("The space allocated to all of your selected "
39659b733d3SSascha Wildner "subpartitions (%luM) exceeds the total "
397cdd2d676SSascha Wildner "capacity of the selected primary partition "
39859b733d3SSascha Wildner "(%luM). Remove some subpartitions or choose "
399cdd2d676SSascha Wildner "a smaller size for them and try again."),
400cdd2d676SSascha Wildner total_capacity, slice_get_capacity(storage_get_selected_slice(a->s)));
401cdd2d676SSascha Wildner return(0);
402cdd2d676SSascha Wildner }
403cdd2d676SSascha Wildner
404cdd2d676SSascha Wildner return(1);
405cdd2d676SSascha Wildner }
406cdd2d676SSascha Wildner
407cdd2d676SSascha Wildner static int
check_subpartition_selections(struct dfui_response * r,struct i_fn_args * a)408cdd2d676SSascha Wildner check_subpartition_selections(struct dfui_response *r, struct i_fn_args *a)
409cdd2d676SSascha Wildner {
410cdd2d676SSascha Wildner struct dfui_dataset *ds;
411cdd2d676SSascha Wildner struct dfui_dataset *star_ds = NULL;
412cdd2d676SSascha Wildner struct aura_dict *d;
413cdd2d676SSascha Wildner const char *mountpoint, *capstring;
414cdd2d676SSascha Wildner long capacity = 0;
415cdd2d676SSascha Wildner int found_root = 0;
416cdd2d676SSascha Wildner int valid = 1;
417cdd2d676SSascha Wildner
418cdd2d676SSascha Wildner d = aura_dict_new(1, AURA_DICT_LIST);
419cdd2d676SSascha Wildner
420cdd2d676SSascha Wildner if ((ds = dfui_response_dataset_get_first(r)) == NULL) {
421cdd2d676SSascha Wildner inform(a->c, _("Please set up at least one subpartition."));
422cdd2d676SSascha Wildner valid = 0;
423cdd2d676SSascha Wildner }
424cdd2d676SSascha Wildner
425cdd2d676SSascha Wildner for (ds = dfui_response_dataset_get_first(r); valid && ds != NULL;
426cdd2d676SSascha Wildner ds = dfui_dataset_get_next(ds)) {
427cdd2d676SSascha Wildner #ifdef DEBUG
428cdd2d676SSascha Wildner dfui_dataset_dump(ds);
429cdd2d676SSascha Wildner #endif
430cdd2d676SSascha Wildner mountpoint = dfui_dataset_get_value(ds, "mountpoint");
431cdd2d676SSascha Wildner capstring = dfui_dataset_get_value(ds, "capacity");
432cdd2d676SSascha Wildner
433cdd2d676SSascha Wildner if (expert) {
434491a8d95SSascha Wildner int tmpfsbacked;
435491a8d95SSascha Wildner
436761cad2fSSascha Wildner tmpfsbacked = (strcmp(dfui_dataset_get_value(ds, "tmpfsbacked"), "Y") == 0);
437491a8d95SSascha Wildner if (tmpfsbacked && strcmp(mountpoint, "/") == 0) {
438491a8d95SSascha Wildner inform(a->c, _("/ cannot be TMPFS backed."));
439491a8d95SSascha Wildner valid = 0;
440491a8d95SSascha Wildner }
441cdd2d676SSascha Wildner }
442cdd2d676SSascha Wildner
443cdd2d676SSascha Wildner if (aura_dict_exists(d, mountpoint, strlen(mountpoint) + 1)) {
444cdd2d676SSascha Wildner inform(a->c, _("The same mount point cannot be specified "
445cdd2d676SSascha Wildner "for two different subpartitions."));
446cdd2d676SSascha Wildner valid = 0;
447cdd2d676SSascha Wildner }
448cdd2d676SSascha Wildner
449cdd2d676SSascha Wildner if (strcmp(mountpoint, "/") == 0)
450cdd2d676SSascha Wildner found_root = 1;
451cdd2d676SSascha Wildner
452cdd2d676SSascha Wildner if (strcmp(capstring, "*") == 0) {
453cdd2d676SSascha Wildner if (star_ds != NULL) {
454cdd2d676SSascha Wildner inform(a->c, _("You cannot have more than one subpartition "
455cdd2d676SSascha Wildner "with a '*' capacity (meaning 'use the remainder "
456cdd2d676SSascha Wildner "of the primary partition'.)"));
457cdd2d676SSascha Wildner valid = 0;
458cdd2d676SSascha Wildner } else {
459cdd2d676SSascha Wildner star_ds = ds;
460cdd2d676SSascha Wildner }
461cdd2d676SSascha Wildner }
462cdd2d676SSascha Wildner
463cdd2d676SSascha Wildner if (!(!strcasecmp(mountpoint, "swap") || mountpoint[0] == '/')) {
464cdd2d676SSascha Wildner inform(a->c, _("Mount point must be either 'swap', or it must "
465cdd2d676SSascha Wildner "start with a '/'."));
466cdd2d676SSascha Wildner valid = 0;
467cdd2d676SSascha Wildner }
468cdd2d676SSascha Wildner
469cdd2d676SSascha Wildner if (strpbrk(mountpoint, " \\\"'`") != NULL) {
470cdd2d676SSascha Wildner inform(a->c, _("Mount point may not contain the following "
471cdd2d676SSascha Wildner "characters: blank space, backslash, or "
472cdd2d676SSascha Wildner "single, double, or back quotes."));
473cdd2d676SSascha Wildner valid = 0;
474cdd2d676SSascha Wildner }
475cdd2d676SSascha Wildner
476cdd2d676SSascha Wildner if (strlen(capstring) == 0) {
477cdd2d676SSascha Wildner inform(a->c, _("A capacity must be specified."));
478cdd2d676SSascha Wildner valid = 0;
479cdd2d676SSascha Wildner }
480cdd2d676SSascha Wildner
481cdd2d676SSascha Wildner if (!string_to_capacity(capstring, &capacity)) {
4821f2824e8SSascha Wildner inform(a->c, _("Capacity must be either a '*' symbol "
4831f2824e8SSascha Wildner "to indicate 'use the rest of the primary "
4841f2824e8SSascha Wildner "partition', or it must be a series of decimal "
4851f2824e8SSascha Wildner "digits ending with an 'M' (indicating "
4861f2824e8SSascha Wildner "megabytes), a 'G' (indicating gigabytes) and "
4871f2824e8SSascha Wildner "so on (up to 'E'.)"));
488cdd2d676SSascha Wildner valid = 0;
489cdd2d676SSascha Wildner }
490cdd2d676SSascha Wildner
491268b6264SMatthew Dillon /*
492268b6264SMatthew Dillon * Maybe remove this limit entirely?
493268b6264SMatthew Dillon */
494268b6264SMatthew Dillon if ((strcasecmp(mountpoint, "swap") == 0) &&
495ef48e483SSascha Wildner (capacity > SWAP_MAX)) {
496ef48e483SSascha Wildner inform(a->c, _("Swap capacity is limited to %dG."),
497ef48e483SSascha Wildner SWAP_MAX / 1024);
498cdd2d676SSascha Wildner valid = 0;
499cdd2d676SSascha Wildner }
500cdd2d676SSascha Wildner
501cdd2d676SSascha Wildner /*
502cdd2d676SSascha Wildner * If we made it through that obstacle course, all is well.
503cdd2d676SSascha Wildner */
504cdd2d676SSascha Wildner
505cdd2d676SSascha Wildner if (valid)
506cdd2d676SSascha Wildner aura_dict_store(d, mountpoint, strlen(mountpoint) + 1, "", 1);
507cdd2d676SSascha Wildner }
508cdd2d676SSascha Wildner
509cdd2d676SSascha Wildner if (!found_root) {
510cdd2d676SSascha Wildner inform(a->c, _("You must include a / (root) subpartition."));
511cdd2d676SSascha Wildner valid = 0;
512cdd2d676SSascha Wildner }
513cdd2d676SSascha Wildner
514cdd2d676SSascha Wildner if (aura_dict_size(d) > 16) {
515cdd2d676SSascha Wildner inform(a->c, _("You cannot have more than 16 subpartitions "
516cdd2d676SSascha Wildner "on a single primary partition. Remove some "
517cdd2d676SSascha Wildner "and try again."));
518cdd2d676SSascha Wildner valid = 0;
519cdd2d676SSascha Wildner }
520cdd2d676SSascha Wildner
521cdd2d676SSascha Wildner aura_dict_free(d);
522cdd2d676SSascha Wildner
523cdd2d676SSascha Wildner return(valid);
524cdd2d676SSascha Wildner }
525cdd2d676SSascha Wildner
526cdd2d676SSascha Wildner static void
save_subpartition_selections(struct dfui_response * r,struct i_fn_args * a)527cdd2d676SSascha Wildner save_subpartition_selections(struct dfui_response *r, struct i_fn_args *a)
528cdd2d676SSascha Wildner {
529cdd2d676SSascha Wildner struct dfui_dataset *ds;
530761cad2fSSascha Wildner char tmpfsbacked;
531cdd2d676SSascha Wildner const char *mountpoint, *capstring;
532cdd2d676SSascha Wildner long capacity;
533cdd2d676SSascha Wildner long bsize, fsize;
534cdd2d676SSascha Wildner int softupdates;
535cdd2d676SSascha Wildner int valid = 1;
536cdd2d676SSascha Wildner
537cdd2d676SSascha Wildner subpartitions_free(storage_get_selected_slice(a->s));
538cdd2d676SSascha Wildner
539cdd2d676SSascha Wildner for (ds = dfui_response_dataset_get_first(r); valid && ds != NULL;
540cdd2d676SSascha Wildner ds = dfui_dataset_get_next(ds)) {
541cdd2d676SSascha Wildner mountpoint = dfui_dataset_get_value(ds, "mountpoint");
542cdd2d676SSascha Wildner capstring = dfui_dataset_get_value(ds, "capacity");
543cdd2d676SSascha Wildner
544cdd2d676SSascha Wildner if (expert) {
545cdd2d676SSascha Wildner softupdates =
546cdd2d676SSascha Wildner (strcmp(dfui_dataset_get_value(ds, "softupdates"), "Y") == 0);
547cdd2d676SSascha Wildner fsize = atol(dfui_dataset_get_value(ds, "fsize"));
548cdd2d676SSascha Wildner bsize = atol(dfui_dataset_get_value(ds, "bsize"));
549761cad2fSSascha Wildner tmpfsbacked = (strcmp(dfui_dataset_get_value(ds, "tmpfsbacked"), "Y") == 0);
550cdd2d676SSascha Wildner } else {
5511b9a5070SSascha Wildner softupdates = (strcmp(mountpoint, "/boot") == 0 ? 0 : 1);
552761cad2fSSascha Wildner tmpfsbacked = 0;
553cdd2d676SSascha Wildner fsize = -1;
554cdd2d676SSascha Wildner bsize = -1;
555cdd2d676SSascha Wildner }
556cdd2d676SSascha Wildner
557cdd2d676SSascha Wildner if (string_to_capacity(capstring, &capacity)) {
55888cfb1f7SSascha Wildner subpartition_new_ufs(storage_get_selected_slice(a->s),
55988cfb1f7SSascha Wildner mountpoint, capacity,
56088cfb1f7SSascha Wildner strcasecmp(dfui_dataset_get_value(ds, "encrypted"), "Y") == 0,
561761cad2fSSascha Wildner softupdates, fsize, bsize, tmpfsbacked);
562cdd2d676SSascha Wildner }
563cdd2d676SSascha Wildner }
564cdd2d676SSascha Wildner }
565cdd2d676SSascha Wildner
566cdd2d676SSascha Wildner static void
populate_create_subpartitions_form(struct dfui_form * f,struct i_fn_args * a)567cdd2d676SSascha Wildner populate_create_subpartitions_form(struct dfui_form *f, struct i_fn_args *a)
568cdd2d676SSascha Wildner {
569cdd2d676SSascha Wildner struct subpartition *sp;
570cdd2d676SSascha Wildner struct dfui_dataset *ds;
571cdd2d676SSascha Wildner char temp[32];
572cdd2d676SSascha Wildner int mtpt;
573cdd2d676SSascha Wildner long capacity;
574cdd2d676SSascha Wildner
575cdd2d676SSascha Wildner if (slice_subpartition_first(storage_get_selected_slice(a->s)) != NULL) {
576cdd2d676SSascha Wildner /*
577cdd2d676SSascha Wildner * The user has already given us their subpartition
578cdd2d676SSascha Wildner * preferences, so use them here.
579cdd2d676SSascha Wildner */
580cdd2d676SSascha Wildner for (sp = slice_subpartition_first(storage_get_selected_slice(a->s));
581cdd2d676SSascha Wildner sp != NULL; sp = subpartition_next(sp)) {
582cdd2d676SSascha Wildner ds = dfui_dataset_new();
583cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "mountpoint",
584cdd2d676SSascha Wildner subpartition_get_mountpoint(sp));
585cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "capacity",
586cdd2d676SSascha Wildner capacity_to_string(subpartition_get_capacity(sp)));
58788cfb1f7SSascha Wildner dfui_dataset_celldata_add(ds, "encrypted",
58888cfb1f7SSascha Wildner subpartition_is_encrypted(sp) ? "Y" : "N");
589cdd2d676SSascha Wildner if (expert) {
590cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "softupdates",
591cdd2d676SSascha Wildner subpartition_is_softupdated(sp) ? "Y" : "N");
592761cad2fSSascha Wildner dfui_dataset_celldata_add(ds, "tmpfsbacked",
593761cad2fSSascha Wildner subpartition_is_tmpfsbacked(sp) ? "Y" : "N");
594cdd2d676SSascha Wildner snprintf(temp, 32, "%ld", subpartition_get_fsize(sp));
595cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "fsize",
596cdd2d676SSascha Wildner temp);
597cdd2d676SSascha Wildner snprintf(temp, 32, "%ld", subpartition_get_bsize(sp));
598cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "bsize",
599cdd2d676SSascha Wildner temp);
600cdd2d676SSascha Wildner }
601cdd2d676SSascha Wildner dfui_form_dataset_add(f, ds);
602cdd2d676SSascha Wildner }
603cdd2d676SSascha Wildner } else {
604cdd2d676SSascha Wildner /*
605cdd2d676SSascha Wildner * Otherwise, populate the form with datasets representing
606cdd2d676SSascha Wildner * reasonably-calculated defaults. The defaults are chosen
607cdd2d676SSascha Wildner * based on the slice's total capacity and the machine's
608cdd2d676SSascha Wildner * total physical memory (for swap.)
609cdd2d676SSascha Wildner */
610cdd2d676SSascha Wildner for (mtpt = 0; def_mountpt[mtpt] != NULL; mtpt++) {
611f9602a12SMatthew Dillon capacity = default_capacity(a->s, def_mountpt[mtpt]);
612f9602a12SMatthew Dillon if (capacity == 0)
613f9602a12SMatthew Dillon continue;
614cdd2d676SSascha Wildner ds = dfui_dataset_new();
615cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "mountpoint",
616cdd2d676SSascha Wildner def_mountpt[mtpt]);
617cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "capacity",
618cdd2d676SSascha Wildner capacity_to_string(capacity));
61988cfb1f7SSascha Wildner dfui_dataset_celldata_add(ds, "encrypted", "N");
620cdd2d676SSascha Wildner if (expert) {
621cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "softupdates",
6221b9a5070SSascha Wildner strcmp(def_mountpt[mtpt], "/boot") != 0 ? "Y" : "N");
623761cad2fSSascha Wildner dfui_dataset_celldata_add(ds, "tmpfsbacked",
624cdd2d676SSascha Wildner "N");
625cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "fsize",
626cdd2d676SSascha Wildner capacity < 1024 ? "1024" : "2048");
627cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "bsize",
628cdd2d676SSascha Wildner capacity < 1024 ? "8192" : "16384");
629cdd2d676SSascha Wildner }
630cdd2d676SSascha Wildner dfui_form_dataset_add(f, ds);
631cdd2d676SSascha Wildner }
632cdd2d676SSascha Wildner }
633cdd2d676SSascha Wildner }
634cdd2d676SSascha Wildner
635cdd2d676SSascha Wildner static int
warn_subpartition_selections(struct i_fn_args * a)636cdd2d676SSascha Wildner warn_subpartition_selections(struct i_fn_args *a)
637cdd2d676SSascha Wildner {
638cdd2d676SSascha Wildner int valid = 0;
639cdd2d676SSascha Wildner
640344b24adSSascha Wildner /* Skip this check for disks <= 8GB */
641344b24adSSascha Wildner if (slice_get_capacity(storage_get_selected_slice(a->s)) <= 8192)
642344b24adSSascha Wildner return 0;
643344b24adSSascha Wildner
644cdd2d676SSascha Wildner valid = check_capacity(a);
64588cfb1f7SSascha Wildner
64688cfb1f7SSascha Wildner return(!valid);
64788cfb1f7SSascha Wildner }
64888cfb1f7SSascha Wildner
649cdd2d676SSascha Wildner static struct dfui_form *
make_create_subpartitions_form(struct i_fn_args * a)650cdd2d676SSascha Wildner make_create_subpartitions_form(struct i_fn_args *a)
651cdd2d676SSascha Wildner {
652cdd2d676SSascha Wildner struct dfui_field *fi;
653cdd2d676SSascha Wildner struct dfui_form *f;
654cdd2d676SSascha Wildner char msg_buf[1][1024];
655cdd2d676SSascha Wildner
656cdd2d676SSascha Wildner snprintf(msg_buf[0], sizeof(msg_buf[0]),
657cdd2d676SSascha Wildner _("Subpartitions further divide a primary partition for "
658cdd2d676SSascha Wildner "use with %s. Some reasons you may want "
659cdd2d676SSascha Wildner "a set of subpartitions are:\n\n"
660cdd2d676SSascha Wildner "- you want to restrict how much data can be written "
661cdd2d676SSascha Wildner "to certain parts of the primary partition, to quell "
662cdd2d676SSascha Wildner "denial-of-service attacks; and\n"
663cdd2d676SSascha Wildner "- you want to speed up access to data on the disk."
664cdd2d676SSascha Wildner ""), OPERATING_SYSTEM_NAME);
665cdd2d676SSascha Wildner
666cdd2d676SSascha Wildner f = dfui_form_create(
667cdd2d676SSascha Wildner "create_subpartitions",
668cdd2d676SSascha Wildner _("Create Subpartitions"),
669cdd2d676SSascha Wildner _("Set up the subpartitions (also known as just `partitions' "
670cdd2d676SSascha Wildner "in BSD tradition) you want to have on this primary "
671cdd2d676SSascha Wildner "partition.\n\n"
672cdd2d676SSascha Wildner "For Capacity, use 'M' to indicate megabytes, 'G' to "
6731f2824e8SSascha Wildner "indicate gigabytes, and so on (up to 'E'.) A single '*' "
6741f2824e8SSascha Wildner "indicates 'use the remaining space on the primary partition'."),
675cdd2d676SSascha Wildner
676cdd2d676SSascha Wildner msg_buf[0],
677cdd2d676SSascha Wildner
678cdd2d676SSascha Wildner "p", "special", "dfinstaller_create_subpartitions",
679cdd2d676SSascha Wildner "p", "minimum_width","64",
680cdd2d676SSascha Wildner
681cdd2d676SSascha Wildner "f", "mountpoint", _("Mountpoint"), "", "",
682cdd2d676SSascha Wildner "f", "capacity", _("Capacity"), "", "",
683cdd2d676SSascha Wildner
68488cfb1f7SSascha Wildner "f", "encrypted", _("Encrypted"), "", "",
68588cfb1f7SSascha Wildner "p", "control", "checkbox",
68688cfb1f7SSascha Wildner
687cdd2d676SSascha Wildner "a", "ok", _("Accept and Create"), "", "",
688cdd2d676SSascha Wildner "a", "cancel",
689cdd2d676SSascha Wildner (disk_get_formatted(storage_get_selected_disk(a->s)) ?
690cdd2d676SSascha Wildner _("Return to Select Disk") :
691cdd2d676SSascha Wildner _("Return to Select Primary Partition")), "", "",
692cdd2d676SSascha Wildner "p", "accelerator", "ESC",
693cdd2d676SSascha Wildner
694cdd2d676SSascha Wildner NULL
695cdd2d676SSascha Wildner );
696cdd2d676SSascha Wildner
697cdd2d676SSascha Wildner dfui_form_set_multiple(f, 1);
698cdd2d676SSascha Wildner dfui_form_set_extensible(f, 1);
699cdd2d676SSascha Wildner
700cdd2d676SSascha Wildner if (expert) {
701cdd2d676SSascha Wildner fi = dfui_form_field_add(f, "softupdates",
702cdd2d676SSascha Wildner dfui_info_new(_("Softupdates"), "", ""));
703cdd2d676SSascha Wildner dfui_field_property_set(fi, "control", "checkbox");
704cdd2d676SSascha Wildner
705761cad2fSSascha Wildner fi = dfui_form_field_add(f, "tmpfsbacked",
706761cad2fSSascha Wildner dfui_info_new(_("TMPFS"), "", ""));
707cdd2d676SSascha Wildner dfui_field_property_set(fi, "control", "checkbox");
708cdd2d676SSascha Wildner
709cdd2d676SSascha Wildner fi = dfui_form_field_add(f, "fsize",
710cdd2d676SSascha Wildner dfui_info_new(_("Frag Sz"), "", ""));
711cdd2d676SSascha Wildner
712cdd2d676SSascha Wildner fi = dfui_form_field_add(f, "bsize",
713cdd2d676SSascha Wildner dfui_info_new(_("Block Sz"), "", ""));
714cdd2d676SSascha Wildner
715cdd2d676SSascha Wildner dfui_form_action_add(f, "switch",
716cdd2d676SSascha Wildner dfui_info_new(_("Switch to Normal Mode"), "", ""));
717cdd2d676SSascha Wildner } else {
718cdd2d676SSascha Wildner dfui_form_action_add(f, "switch",
719cdd2d676SSascha Wildner dfui_info_new(_("Switch to Expert Mode"), "", ""));
720cdd2d676SSascha Wildner }
721cdd2d676SSascha Wildner
722cdd2d676SSascha Wildner return(f);
723cdd2d676SSascha Wildner }
724cdd2d676SSascha Wildner
725cdd2d676SSascha Wildner /*
726cdd2d676SSascha Wildner * Returns:
727cdd2d676SSascha Wildner * -1 = the form should be redisplayed
728cdd2d676SSascha Wildner * 0 = failure, function is over
729cdd2d676SSascha Wildner * 1 = success, function is over
730cdd2d676SSascha Wildner */
731cdd2d676SSascha Wildner static int
show_create_subpartitions_form(struct dfui_form * f,struct i_fn_args * a)732cdd2d676SSascha Wildner show_create_subpartitions_form(struct dfui_form *f, struct i_fn_args *a)
733cdd2d676SSascha Wildner {
734cdd2d676SSascha Wildner struct dfui_dataset *ds;
735cdd2d676SSascha Wildner struct dfui_response *r;
736cdd2d676SSascha Wildner
737cdd2d676SSascha Wildner for (;;) {
738cdd2d676SSascha Wildner if (dfui_form_dataset_get_first(f) == NULL)
739cdd2d676SSascha Wildner populate_create_subpartitions_form(f, a);
740cdd2d676SSascha Wildner
741cdd2d676SSascha Wildner if (!dfui_be_present(a->c, f, &r))
742cdd2d676SSascha Wildner abort_backend();
743cdd2d676SSascha Wildner
744cdd2d676SSascha Wildner if (strcmp(dfui_response_get_action_id(r), "cancel") == 0) {
745cdd2d676SSascha Wildner dfui_response_free(r);
746cdd2d676SSascha Wildner return(0);
747cdd2d676SSascha Wildner } else if (strcmp(dfui_response_get_action_id(r), "switch") == 0) {
748cdd2d676SSascha Wildner if (check_subpartition_selections(r, a)) {
749cdd2d676SSascha Wildner save_subpartition_selections(r, a);
750cdd2d676SSascha Wildner expert = expert ? 0 : 1;
751cdd2d676SSascha Wildner dfui_response_free(r);
752cdd2d676SSascha Wildner return(-1);
753cdd2d676SSascha Wildner }
754cdd2d676SSascha Wildner } else {
755cdd2d676SSascha Wildner if (check_subpartition_selections(r, a)) {
756cdd2d676SSascha Wildner save_subpartition_selections(r, a);
757f9602a12SMatthew Dillon if (!warn_subpartition_selections(a)) {
758cdd2d676SSascha Wildner if (!create_subpartitions(a)) {
759cdd2d676SSascha Wildner inform(a->c, _("The subpartitions you chose were "
760cdd2d676SSascha Wildner "not correctly created, and the "
761cdd2d676SSascha Wildner "primary partition may "
762cdd2d676SSascha Wildner "now be in an inconsistent state. "
763cdd2d676SSascha Wildner "We recommend re-formatting it "
764cdd2d676SSascha Wildner "before proceeding."));
765cdd2d676SSascha Wildner dfui_response_free(r);
766cdd2d676SSascha Wildner return(0);
767cdd2d676SSascha Wildner } else {
768cdd2d676SSascha Wildner dfui_response_free(r);
769cdd2d676SSascha Wildner return(1);
770cdd2d676SSascha Wildner }
771cdd2d676SSascha Wildner }
772cdd2d676SSascha Wildner }
773cdd2d676SSascha Wildner }
774cdd2d676SSascha Wildner
775cdd2d676SSascha Wildner dfui_form_datasets_free(f);
776cdd2d676SSascha Wildner /* dfui_form_datasets_add_from_response(f, r); */
777cdd2d676SSascha Wildner for (ds = dfui_response_dataset_get_first(r); ds != NULL;
778cdd2d676SSascha Wildner ds = dfui_dataset_get_next(ds)) {
779cdd2d676SSascha Wildner dfui_form_dataset_add(f, dfui_dataset_dup(ds));
780cdd2d676SSascha Wildner }
781cdd2d676SSascha Wildner }
782cdd2d676SSascha Wildner }
783cdd2d676SSascha Wildner
784cdd2d676SSascha Wildner void
fn_create_subpartitions_ufs(struct i_fn_args * a)785cdd2d676SSascha Wildner fn_create_subpartitions_ufs(struct i_fn_args *a)
786cdd2d676SSascha Wildner {
787cdd2d676SSascha Wildner struct dfui_form *f;
788344b24adSSascha Wildner unsigned long capacity;
789cdd2d676SSascha Wildner int done = 0;
790cdd2d676SSascha Wildner
791cdd2d676SSascha Wildner a->result = 0;
792344b24adSSascha Wildner capacity = slice_get_capacity(storage_get_selected_slice(a->s));
793344b24adSSascha Wildner if (capacity < DISK_MIN) {
794344b24adSSascha Wildner inform(a->c, _("The selected disk is smaller than the "
795344b24adSSascha Wildner "required %dM for the UFS filesystem."), DISK_MIN);
796344b24adSSascha Wildner return;
797344b24adSSascha Wildner }
798f9602a12SMatthew Dillon #if 0
799344b24adSSascha Wildner if (capacity <= 8192)
800344b24adSSascha Wildner def_mountpt[2] = NULL; /* XXX adjust each time in a session */
801f9602a12SMatthew Dillon #endif
802cdd2d676SSascha Wildner while (!done) {
803cdd2d676SSascha Wildner f = make_create_subpartitions_form(a);
804cdd2d676SSascha Wildner switch (show_create_subpartitions_form(f, a)) {
805cdd2d676SSascha Wildner case -1:
806cdd2d676SSascha Wildner done = 0;
807cdd2d676SSascha Wildner break;
808cdd2d676SSascha Wildner case 0:
809cdd2d676SSascha Wildner done = 1;
810cdd2d676SSascha Wildner a->result = 0;
811cdd2d676SSascha Wildner break;
812cdd2d676SSascha Wildner case 1:
813cdd2d676SSascha Wildner done = 1;
814cdd2d676SSascha Wildner a->result = 1;
815cdd2d676SSascha Wildner break;
816cdd2d676SSascha Wildner }
817cdd2d676SSascha Wildner dfui_form_free(f);
818cdd2d676SSascha Wildner }
819cdd2d676SSascha Wildner }
820