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> 43cdd2d676SSascha Wildner 44cdd2d676SSascha Wildner #ifdef ENABLE_NLS 45cdd2d676SSascha Wildner #include <libintl.h> 46cdd2d676SSascha Wildner #define _(String) gettext (String) 47cdd2d676SSascha Wildner #else 48cdd2d676SSascha Wildner #define _(String) (String) 49cdd2d676SSascha Wildner #endif 50cdd2d676SSascha Wildner 51cdd2d676SSascha Wildner #include "libaura/mem.h" 52cdd2d676SSascha Wildner #include "libaura/buffer.h" 53cdd2d676SSascha Wildner #include "libaura/dict.h" 54cdd2d676SSascha Wildner #include "libaura/fspred.h" 55cdd2d676SSascha Wildner 56cdd2d676SSascha Wildner #include "libdfui/dfui.h" 57cdd2d676SSascha Wildner #include "libdfui/dump.h" 58cdd2d676SSascha Wildner #include "libdfui/system.h" 59cdd2d676SSascha Wildner 60cdd2d676SSascha Wildner #include "libinstaller/commands.h" 61cdd2d676SSascha Wildner #include "libinstaller/diskutil.h" 62cdd2d676SSascha Wildner #include "libinstaller/functions.h" 63cdd2d676SSascha Wildner #include "libinstaller/uiutil.h" 64cdd2d676SSascha Wildner 65cdd2d676SSascha Wildner #include "fn.h" 66cdd2d676SSascha Wildner #include "flow.h" 67cdd2d676SSascha Wildner #include "pathnames.h" 68cdd2d676SSascha Wildner 69f9602a12SMatthew Dillon #define MTPT_BOOT 0 70f9602a12SMatthew Dillon #define MTPT_SWAP 1 71f9602a12SMatthew Dillon #define MTPT_ROOT 2 72f9602a12SMatthew Dillon #define MTPT_BUILD 3 73f9602a12SMatthew Dillon 74cdd2d676SSascha Wildner static int create_subpartitions(struct i_fn_args *); 75f9602a12SMatthew Dillon static long default_capacity(struct storage *, const char *); 76cdd2d676SSascha Wildner static int check_capacity(struct i_fn_args *); 77cdd2d676SSascha Wildner static int check_subpartition_selections(struct dfui_response *, struct i_fn_args *); 78cdd2d676SSascha Wildner static void save_subpartition_selections(struct dfui_response *, struct i_fn_args *); 79cdd2d676SSascha Wildner static void populate_create_subpartitions_form(struct dfui_form *, struct i_fn_args *); 80cdd2d676SSascha Wildner static int warn_subpartition_selections(struct i_fn_args *); 81cdd2d676SSascha Wildner static struct dfui_form *make_create_subpartitions_form(struct i_fn_args *); 82cdd2d676SSascha Wildner static int show_create_subpartitions_form(struct dfui_form *, struct i_fn_args *); 83cdd2d676SSascha Wildner 84f9602a12SMatthew Dillon static const char *def_mountpt[] = {"/boot", "swap", "/", "/build", NULL}; 85f9602a12SMatthew Dillon static long min_capacity[] = { 128, 0, DISK_MIN - 128, BUILD_MIN }; 86cdd2d676SSascha Wildner static int expert = 0; 87cdd2d676SSascha Wildner 88cdd2d676SSascha Wildner /* 89cdd2d676SSascha Wildner * Given a set of subpartitions-to-be in the selected slice, 90cdd2d676SSascha Wildner * create them. 91cdd2d676SSascha Wildner */ 92cdd2d676SSascha Wildner static int 93cdd2d676SSascha Wildner create_subpartitions(struct i_fn_args *a) 94cdd2d676SSascha Wildner { 95cdd2d676SSascha Wildner struct subpartition *sp; 96cdd2d676SSascha Wildner struct commands *cmds; 97cdd2d676SSascha Wildner int result = 0; 98cdd2d676SSascha Wildner int num_partitions; 99cdd2d676SSascha Wildner 100cdd2d676SSascha Wildner cmds = commands_new(); 101cdd2d676SSascha Wildner if (!is_file("%sinstall.disklabel.%s", 102cdd2d676SSascha Wildner a->tmp, 103cdd2d676SSascha Wildner slice_get_device_name(storage_get_selected_slice(a->s)))) { 104cdd2d676SSascha Wildner /* 105cdd2d676SSascha Wildner * Get a copy of the 'virgin' disklabel. 106cdd2d676SSascha Wildner * XXX It might make more sense for this to 107cdd2d676SSascha Wildner * happen right after format_slice() instead. 108cdd2d676SSascha Wildner */ 109cdd2d676SSascha Wildner command_add(cmds, "%s%s -r %s >%sinstall.disklabel.%s", 110b5cb2d94SSascha Wildner a->os_root, cmd_name(a, "DISKLABEL64"), 111cdd2d676SSascha Wildner slice_get_device_name(storage_get_selected_slice(a->s)), 112cdd2d676SSascha Wildner a->tmp, 113cdd2d676SSascha Wildner slice_get_device_name(storage_get_selected_slice(a->s))); 114cdd2d676SSascha Wildner } 115cdd2d676SSascha Wildner 116cdd2d676SSascha Wildner /* 117cdd2d676SSascha Wildner * Weave together a new disklabel out the of the 'virgin' 118cdd2d676SSascha Wildner * disklabel, and the user's subpartition choices. 119cdd2d676SSascha Wildner */ 120cdd2d676SSascha Wildner 121cdd2d676SSascha Wildner /* 122cdd2d676SSascha Wildner * Take everything from the 'virgin' disklabel up until the 123cdd2d676SSascha Wildner * '16 partitions' line. 124cdd2d676SSascha Wildner */ 125cdd2d676SSascha Wildner num_partitions = 16; 126cdd2d676SSascha Wildner command_add(cmds, "%s%s '$2==\"partitions:\" || cut { cut = 1 } !cut { print $0 }' <%sinstall.disklabel.%s >%sinstall.disklabel", 127cdd2d676SSascha Wildner a->os_root, cmd_name(a, "AWK"), 128cdd2d676SSascha Wildner a->tmp, 129cdd2d676SSascha Wildner slice_get_device_name(storage_get_selected_slice(a->s)), 130cdd2d676SSascha Wildner a->tmp); 131cdd2d676SSascha Wildner 132cdd2d676SSascha Wildner /* 133cdd2d676SSascha Wildner * 16 partitions: 134cdd2d676SSascha Wildner * # size offset fstype 135cdd2d676SSascha Wildner * c: 16383969 0 unused # 7999.985MB 136cdd2d676SSascha Wildner */ 137cdd2d676SSascha Wildner 138cdd2d676SSascha Wildner command_add(cmds, "%s%s '%d partitions:' >>%sinstall.disklabel", 139cdd2d676SSascha Wildner a->os_root, cmd_name(a, "ECHO"), num_partitions ,a->tmp); 140cdd2d676SSascha Wildner command_add(cmds, "%s%s '%s' >>%sinstall.disklabel", 141cdd2d676SSascha Wildner a->os_root, cmd_name(a, "ECHO"), 142cdd2d676SSascha Wildner "# size offset fstype", 143cdd2d676SSascha Wildner a->tmp); 144cdd2d676SSascha Wildner 145cdd2d676SSascha Wildner #ifdef DEBUG 146cdd2d676SSascha Wildner for (sp = slice_subpartition_first(storage_get_selected_slice(a->s)); 147cdd2d676SSascha Wildner sp != NULL; sp = subpartition_next(sp)) { 148cdd2d676SSascha Wildner command_add(cmds, "%s%s 'mountpoint: %s device: %s'", 149cdd2d676SSascha Wildner a->os_root, cmd_name(a, "ECHO"), 150cdd2d676SSascha Wildner subpartition_get_mountpoint(sp), 151cdd2d676SSascha Wildner subpartition_get_device_name(sp)); 152cdd2d676SSascha Wildner } 153cdd2d676SSascha Wildner #endif 154cdd2d676SSascha Wildner 155cdd2d676SSascha Wildner /* 156cdd2d676SSascha Wildner * Write a line for each subpartition the user wants. 157cdd2d676SSascha Wildner */ 158cdd2d676SSascha Wildner for (sp = slice_subpartition_first(storage_get_selected_slice(a->s)); 159cdd2d676SSascha Wildner sp != NULL; sp = subpartition_next(sp)) { 160761cad2fSSascha Wildner if (subpartition_is_tmpfsbacked(sp)) { 161cdd2d676SSascha Wildner continue; 162cdd2d676SSascha Wildner } 163cdd2d676SSascha Wildner if (subpartition_is_swap(sp)) { 164cdd2d676SSascha Wildner command_add(cmds, "%s%s ' %c:\t%s\t*\tswap' >>%sinstall.disklabel", 165cdd2d676SSascha Wildner a->os_root, cmd_name(a, "ECHO"), 166cdd2d676SSascha Wildner subpartition_get_letter(sp), 167cdd2d676SSascha Wildner capacity_to_string(subpartition_get_capacity(sp)), 168cdd2d676SSascha Wildner a->tmp); 169cdd2d676SSascha Wildner } else { 170cdd2d676SSascha Wildner command_add(cmds, "%s%s ' %c:\t%s\t%s\t4.2BSD' >>%sinstall.disklabel", 171cdd2d676SSascha Wildner a->os_root, cmd_name(a, "ECHO"), 172cdd2d676SSascha Wildner subpartition_get_letter(sp), 173cdd2d676SSascha Wildner capacity_to_string(subpartition_get_capacity(sp)), 174cdd2d676SSascha Wildner subpartition_get_letter(sp) == 'a' ? "0" : "*", 175cdd2d676SSascha Wildner a->tmp); 176cdd2d676SSascha Wildner } 177cdd2d676SSascha Wildner } 178cdd2d676SSascha Wildner temp_file_add(a, "install.disklabel"); 179cdd2d676SSascha Wildner 180cdd2d676SSascha Wildner /* 181cdd2d676SSascha Wildner * Label the slice from the disklabel we just wove together. 182cdd2d676SSascha Wildner */ 183cdd2d676SSascha Wildner command_add(cmds, "%s%s -R -B -r %s %sinstall.disklabel", 184b5cb2d94SSascha Wildner a->os_root, cmd_name(a, "DISKLABEL64"), 185cdd2d676SSascha Wildner slice_get_device_name(storage_get_selected_slice(a->s)), 186cdd2d676SSascha Wildner a->tmp); 187cdd2d676SSascha Wildner 188cdd2d676SSascha Wildner /* 189cdd2d676SSascha Wildner * Create a snapshot of the disklabel we just created 190cdd2d676SSascha Wildner * for debugging inspection in the log. 191cdd2d676SSascha Wildner */ 192cdd2d676SSascha Wildner command_add(cmds, "%s%s %s", 193b5cb2d94SSascha Wildner a->os_root, cmd_name(a, "DISKLABEL64"), 194cdd2d676SSascha Wildner slice_get_device_name(storage_get_selected_slice(a->s))); 195cdd2d676SSascha Wildner 196cdd2d676SSascha Wildner /* 197242084fdSAaron LI * If encryption was specified, read the passphrase. 19888cfb1f7SSascha Wildner */ 19988cfb1f7SSascha Wildner for (sp = slice_subpartition_first(storage_get_selected_slice(a->s)); 20088cfb1f7SSascha Wildner sp != NULL; sp = subpartition_next(sp)) { 20188cfb1f7SSascha Wildner if (subpartition_is_encrypted(sp)) { 202242084fdSAaron LI fn_get_passphrase(a, 1); 20388cfb1f7SSascha Wildner break; 20488cfb1f7SSascha Wildner } 20588cfb1f7SSascha Wildner } 20688cfb1f7SSascha Wildner 20788cfb1f7SSascha Wildner /* 208cdd2d676SSascha Wildner * Create filesystems on the newly-created subpartitions. 209cdd2d676SSascha Wildner */ 210cdd2d676SSascha Wildner for (sp = slice_subpartition_first(storage_get_selected_slice(a->s)); 211cdd2d676SSascha Wildner sp != NULL; sp = subpartition_next(sp)) { 21288cfb1f7SSascha Wildner if (subpartition_is_swap(sp) || subpartition_is_tmpfsbacked(sp)) { 21388cfb1f7SSascha Wildner if (subpartition_is_swap(sp) && 21488cfb1f7SSascha Wildner subpartition_is_encrypted(sp)) { 21588cfb1f7SSascha Wildner command_add(cmds, 21651871435SSascha Wildner "%s%s -d /tmp/t1 luksFormat /dev/%s", 21788cfb1f7SSascha Wildner a->os_root, cmd_name(a, "CRYPTSETUP"), 21888cfb1f7SSascha Wildner subpartition_get_device_name(sp)); 21988cfb1f7SSascha Wildner command_add(cmds, 22051871435SSascha Wildner "%s%s -d /tmp/t1 luksOpen /dev/%s swap", 22188cfb1f7SSascha Wildner a->os_root, cmd_name(a, "CRYPTSETUP"), 22288cfb1f7SSascha Wildner subpartition_get_device_name(sp)); 22388cfb1f7SSascha Wildner } 224cdd2d676SSascha Wildner continue; 22588cfb1f7SSascha Wildner } 226cdd2d676SSascha Wildner 227f9602a12SMatthew Dillon if (subpartition_is_encrypted(sp)) { 22888cfb1f7SSascha Wildner command_add(cmds, 22951871435SSascha Wildner "%s%s -d /tmp/t1 luksFormat /dev/%s", 23088cfb1f7SSascha Wildner a->os_root, cmd_name(a, "CRYPTSETUP"), 23188cfb1f7SSascha Wildner subpartition_get_device_name(sp)); 23288cfb1f7SSascha Wildner command_add(cmds, 23351871435SSascha Wildner "%s%s -d /tmp/t1 luksOpen /dev/%s %s", 23488cfb1f7SSascha Wildner a->os_root, cmd_name(a, "CRYPTSETUP"), 23588cfb1f7SSascha Wildner subpartition_get_device_name(sp), 2360c941bc8SSascha Wildner subpartition_get_mapper_name(sp, -1)); 23751871435SSascha Wildner command_add(cmds, "%s%s%s -b %ld -f %ld /dev/mapper/%s", 23888cfb1f7SSascha Wildner a->os_root, cmd_name(a, "NEWFS"), 23988cfb1f7SSascha Wildner subpartition_is_softupdated(sp) ? " -U" : "", 24088cfb1f7SSascha Wildner subpartition_get_bsize(sp), 24188cfb1f7SSascha Wildner subpartition_get_fsize(sp), 2420c941bc8SSascha Wildner subpartition_get_mapper_name(sp, -1)); 24388cfb1f7SSascha Wildner } else { 24451871435SSascha Wildner command_add(cmds, "%s%s%s -b %ld -f %ld /dev/%s", 245cdd2d676SSascha Wildner a->os_root, cmd_name(a, "NEWFS"), 246cdd2d676SSascha Wildner subpartition_is_softupdated(sp) ? " -U" : "", 247cdd2d676SSascha Wildner subpartition_get_bsize(sp), 248cdd2d676SSascha Wildner subpartition_get_fsize(sp), 249cdd2d676SSascha Wildner subpartition_get_device_name(sp)); 250cdd2d676SSascha Wildner } 25188cfb1f7SSascha Wildner } 252cdd2d676SSascha Wildner 253cdd2d676SSascha Wildner result = commands_execute(a, cmds); 254cdd2d676SSascha Wildner commands_free(cmds); 255*f8608e0dSAaron LI unlink("/tmp/t1"); 256*f8608e0dSAaron LI 257cdd2d676SSascha Wildner return(result); 258cdd2d676SSascha Wildner } 259cdd2d676SSascha Wildner 260f9602a12SMatthew Dillon /* 261f9602a12SMatthew Dillon * Return default capacity field filler. Return 0 for /build if drive 262f9602a12SMatthew Dillon * space minus swap is < 40GB (causes installer to use PFS's on the root 263f9602a12SMatthew Dillon * partition instead). 264f9602a12SMatthew Dillon */ 265cdd2d676SSascha Wildner static long 266f9602a12SMatthew Dillon default_capacity(struct storage *s, const char *mtpt) 267cdd2d676SSascha Wildner { 268f9602a12SMatthew Dillon unsigned long boot, root, swap, build; 269cdd2d676SSascha Wildner unsigned long capacity; 2706cd7259eSSascha Wildner unsigned long mem; 271cdd2d676SSascha Wildner 272f9602a12SMatthew Dillon capacity = slice_get_capacity(storage_get_selected_slice(s)); /* MB */ 2736cd7259eSSascha Wildner mem = storage_get_memsize(s); 274f9602a12SMatthew Dillon 275f9602a12SMatthew Dillon /* 276f9602a12SMatthew Dillon * Slice capacity is at least 10G at this point. Calculate basic 277f9602a12SMatthew Dillon * defaults. 278f9602a12SMatthew Dillon */ 2796cd7259eSSascha Wildner swap = 2 * mem; 280f9602a12SMatthew Dillon if (swap > capacity / 10) /* max 1/10 capacity */ 281f9602a12SMatthew Dillon swap = capacity / 10; 282f9602a12SMatthew Dillon if (swap < SWAP_MIN) /* having a little is nice */ 283f9602a12SMatthew Dillon swap = SWAP_MIN; 284f9602a12SMatthew Dillon if (swap > SWAP_MAX) /* installer cap */ 285f76463ceSSascha Wildner swap = SWAP_MAX; 286cdd2d676SSascha Wildner 287f9602a12SMatthew Dillon boot = 1024; 288f9602a12SMatthew Dillon 28934ca1b1cSMatthew Dillon build = (capacity - swap - boot) / 4; 29034ca1b1cSMatthew Dillon #if 0 29134ca1b1cSMatthew Dillon /* 29234ca1b1cSMatthew Dillon * No longer cap the size of /build, the assumption didn't hold 29334ca1b1cSMatthew Dillon * well particularly with /var/crash being placed on /build now. 29434ca1b1cSMatthew Dillon */ 295f9602a12SMatthew Dillon if (build > BUILD_MAX) 296f9602a12SMatthew Dillon build = BUILD_MAX; 29734ca1b1cSMatthew Dillon #endif 298f9602a12SMatthew Dillon 299f9602a12SMatthew Dillon for (;;) { 300f9602a12SMatthew Dillon root = (capacity - swap - boot - build); 301f9602a12SMatthew Dillon 302f9602a12SMatthew Dillon /* 303f9602a12SMatthew Dillon * Adjust until the defaults look sane 304f9602a12SMatthew Dillon * 305f9602a12SMatthew Dillon * root should be at least twice as large as build 306f9602a12SMatthew Dillon */ 307f9602a12SMatthew Dillon if (build && root < build * 2) { 308f9602a12SMatthew Dillon --build; 309f9602a12SMatthew Dillon continue; 310cdd2d676SSascha Wildner } 311f9602a12SMatthew Dillon 312f9602a12SMatthew Dillon /* 313f9602a12SMatthew Dillon * root should be at least 1/2 capacity 314f9602a12SMatthew Dillon */ 315f9602a12SMatthew Dillon if (build && root < capacity / 2) { 316f9602a12SMatthew Dillon --build; 317f9602a12SMatthew Dillon continue; 318cdd2d676SSascha Wildner } 319f9602a12SMatthew Dillon break; 320cdd2d676SSascha Wildner } 321f9602a12SMatthew Dillon 322f9602a12SMatthew Dillon /* 323f9602a12SMatthew Dillon * Finalize. If build is too small do not supply a /build, 32434ca1b1cSMatthew Dillon * and if swap is too small do not supply swap. Cascade the 32534ca1b1cSMatthew Dillon * released space to swap and root. 326f9602a12SMatthew Dillon */ 32734ca1b1cSMatthew Dillon if (build < BUILD_MIN) { 32834ca1b1cSMatthew Dillon if (swap < SWAP_MIN && build >= SWAP_MIN - swap) { 32934ca1b1cSMatthew Dillon build -= SWAP_MIN - swap; 33034ca1b1cSMatthew Dillon swap = SWAP_MIN; 33134ca1b1cSMatthew Dillon } 33234ca1b1cSMatthew Dillon if (swap < 2 * mem && build >= 2 * mem - swap) { 33334ca1b1cSMatthew Dillon build -= 2 * mem - swap; 33434ca1b1cSMatthew Dillon swap = 2 * mem; 33534ca1b1cSMatthew Dillon } 33634ca1b1cSMatthew Dillon root += build; 337f9602a12SMatthew Dillon build = 0; 33834ca1b1cSMatthew Dillon } 33934ca1b1cSMatthew Dillon if (swap < SWAP_MIN) { 34034ca1b1cSMatthew Dillon root += swap; 341f9602a12SMatthew Dillon swap = 0; 34234ca1b1cSMatthew Dillon } 34334ca1b1cSMatthew Dillon 344f9602a12SMatthew Dillon if (build == 0) 345f9602a12SMatthew Dillon root = -1; /* no /build, root is the last part */ 346f9602a12SMatthew Dillon else 347f9602a12SMatthew Dillon build = -1; /* last partition just use remaining space */ 348f9602a12SMatthew Dillon 349f9602a12SMatthew Dillon if (strcmp(mtpt, "/boot") == 0) 350f9602a12SMatthew Dillon return(boot); 351f9602a12SMatthew Dillon else if (strcmp(mtpt, "/build") == 0) 352f9602a12SMatthew Dillon return(build); 353f9602a12SMatthew Dillon else if (strcmp(mtpt, "swap") == 0) 354f9602a12SMatthew Dillon return(swap); 355f9602a12SMatthew Dillon else if (strcmp(mtpt, "/") == 0) 356f9602a12SMatthew Dillon return(root); 357f9602a12SMatthew Dillon 358cdd2d676SSascha Wildner /* shouldn't ever happen */ 359cdd2d676SSascha Wildner return(-1); 360cdd2d676SSascha Wildner } 361cdd2d676SSascha Wildner 362cdd2d676SSascha Wildner static int 363cdd2d676SSascha Wildner check_capacity(struct i_fn_args *a) 364cdd2d676SSascha Wildner { 365cdd2d676SSascha Wildner struct subpartition *sp; 366cdd2d676SSascha Wildner unsigned long total_capacity = 0; 367cdd2d676SSascha Wildner int mtpt; 368cdd2d676SSascha Wildner 369cdd2d676SSascha Wildner for (sp = slice_subpartition_first(storage_get_selected_slice(a->s)); 370cdd2d676SSascha Wildner sp != NULL; sp = subpartition_next(sp)) { 37170f67d72SSascha Wildner long subpart_capacity = subpartition_get_capacity(sp); 37270f67d72SSascha Wildner const char *mountpt = subpartition_get_mountpoint(sp); 37370f67d72SSascha Wildner 37470f67d72SSascha Wildner if (subpart_capacity == -1) 375cdd2d676SSascha Wildner total_capacity++; 376cdd2d676SSascha Wildner else 37770f67d72SSascha Wildner total_capacity += subpart_capacity; 378cdd2d676SSascha Wildner for (mtpt = 0; def_mountpt[mtpt] != NULL; mtpt++) { 37970f67d72SSascha Wildner if (strcmp(mountpt, def_mountpt[mtpt]) == 0 && 380b680ec87SSascha Wildner subpart_capacity < min_capacity[mtpt] && 381b680ec87SSascha Wildner subpart_capacity != -1) { 38270f67d72SSascha Wildner inform(a->c, _("WARNING: The size (%ldM) specified for " 38370f67d72SSascha Wildner "the %s subpartition is too small. It " 38470f67d72SSascha Wildner "should be at least %ldM or you will " 385cdd2d676SSascha Wildner "risk running out of space during " 386cdd2d676SSascha Wildner "the installation."), 38770f67d72SSascha Wildner subpart_capacity, mountpt, 38870f67d72SSascha Wildner min_capacity[mtpt]); 389cdd2d676SSascha Wildner } 390cdd2d676SSascha Wildner } 391cdd2d676SSascha Wildner } 392cdd2d676SSascha Wildner 393cdd2d676SSascha Wildner if (total_capacity > slice_get_capacity(storage_get_selected_slice(a->s))) { 394cdd2d676SSascha Wildner inform(a->c, _("The space allocated to all of your selected " 39559b733d3SSascha Wildner "subpartitions (%luM) exceeds the total " 396cdd2d676SSascha Wildner "capacity of the selected primary partition " 39759b733d3SSascha Wildner "(%luM). Remove some subpartitions or choose " 398cdd2d676SSascha Wildner "a smaller size for them and try again."), 399cdd2d676SSascha Wildner total_capacity, slice_get_capacity(storage_get_selected_slice(a->s))); 400cdd2d676SSascha Wildner return(0); 401cdd2d676SSascha Wildner } 402cdd2d676SSascha Wildner 403cdd2d676SSascha Wildner return(1); 404cdd2d676SSascha Wildner } 405cdd2d676SSascha Wildner 406cdd2d676SSascha Wildner static int 407cdd2d676SSascha Wildner check_subpartition_selections(struct dfui_response *r, struct i_fn_args *a) 408cdd2d676SSascha Wildner { 409cdd2d676SSascha Wildner struct dfui_dataset *ds; 410cdd2d676SSascha Wildner struct dfui_dataset *star_ds = NULL; 411cdd2d676SSascha Wildner struct aura_dict *d; 412cdd2d676SSascha Wildner const char *mountpoint, *capstring; 413cdd2d676SSascha Wildner long capacity = 0; 414cdd2d676SSascha Wildner int found_root = 0; 415cdd2d676SSascha Wildner int valid = 1; 416cdd2d676SSascha Wildner 417cdd2d676SSascha Wildner d = aura_dict_new(1, AURA_DICT_LIST); 418cdd2d676SSascha Wildner 419cdd2d676SSascha Wildner if ((ds = dfui_response_dataset_get_first(r)) == NULL) { 420cdd2d676SSascha Wildner inform(a->c, _("Please set up at least one subpartition.")); 421cdd2d676SSascha Wildner valid = 0; 422cdd2d676SSascha Wildner } 423cdd2d676SSascha Wildner 424cdd2d676SSascha Wildner for (ds = dfui_response_dataset_get_first(r); valid && ds != NULL; 425cdd2d676SSascha Wildner ds = dfui_dataset_get_next(ds)) { 426cdd2d676SSascha Wildner #ifdef DEBUG 427cdd2d676SSascha Wildner dfui_dataset_dump(ds); 428cdd2d676SSascha Wildner #endif 429cdd2d676SSascha Wildner mountpoint = dfui_dataset_get_value(ds, "mountpoint"); 430cdd2d676SSascha Wildner capstring = dfui_dataset_get_value(ds, "capacity"); 431cdd2d676SSascha Wildner 432cdd2d676SSascha Wildner if (expert) { 433491a8d95SSascha Wildner int tmpfsbacked; 434491a8d95SSascha Wildner 435761cad2fSSascha Wildner tmpfsbacked = (strcmp(dfui_dataset_get_value(ds, "tmpfsbacked"), "Y") == 0); 436491a8d95SSascha Wildner if (tmpfsbacked && strcmp(mountpoint, "/") == 0) { 437491a8d95SSascha Wildner inform(a->c, _("/ cannot be TMPFS backed.")); 438491a8d95SSascha Wildner valid = 0; 439491a8d95SSascha Wildner } 440cdd2d676SSascha Wildner } 441cdd2d676SSascha Wildner 442cdd2d676SSascha Wildner if (aura_dict_exists(d, mountpoint, strlen(mountpoint) + 1)) { 443cdd2d676SSascha Wildner inform(a->c, _("The same mount point cannot be specified " 444cdd2d676SSascha Wildner "for two different subpartitions.")); 445cdd2d676SSascha Wildner valid = 0; 446cdd2d676SSascha Wildner } 447cdd2d676SSascha Wildner 448cdd2d676SSascha Wildner if (strcmp(mountpoint, "/") == 0) 449cdd2d676SSascha Wildner found_root = 1; 450cdd2d676SSascha Wildner 451cdd2d676SSascha Wildner if (strcmp(capstring, "*") == 0) { 452cdd2d676SSascha Wildner if (star_ds != NULL) { 453cdd2d676SSascha Wildner inform(a->c, _("You cannot have more than one subpartition " 454cdd2d676SSascha Wildner "with a '*' capacity (meaning 'use the remainder " 455cdd2d676SSascha Wildner "of the primary partition'.)")); 456cdd2d676SSascha Wildner valid = 0; 457cdd2d676SSascha Wildner } else { 458cdd2d676SSascha Wildner star_ds = ds; 459cdd2d676SSascha Wildner } 460cdd2d676SSascha Wildner } 461cdd2d676SSascha Wildner 462cdd2d676SSascha Wildner if (!(!strcasecmp(mountpoint, "swap") || mountpoint[0] == '/')) { 463cdd2d676SSascha Wildner inform(a->c, _("Mount point must be either 'swap', or it must " 464cdd2d676SSascha Wildner "start with a '/'.")); 465cdd2d676SSascha Wildner valid = 0; 466cdd2d676SSascha Wildner } 467cdd2d676SSascha Wildner 468cdd2d676SSascha Wildner if (strpbrk(mountpoint, " \\\"'`") != NULL) { 469cdd2d676SSascha Wildner inform(a->c, _("Mount point may not contain the following " 470cdd2d676SSascha Wildner "characters: blank space, backslash, or " 471cdd2d676SSascha Wildner "single, double, or back quotes.")); 472cdd2d676SSascha Wildner valid = 0; 473cdd2d676SSascha Wildner } 474cdd2d676SSascha Wildner 475cdd2d676SSascha Wildner if (strlen(capstring) == 0) { 476cdd2d676SSascha Wildner inform(a->c, _("A capacity must be specified.")); 477cdd2d676SSascha Wildner valid = 0; 478cdd2d676SSascha Wildner } 479cdd2d676SSascha Wildner 480cdd2d676SSascha Wildner if (!string_to_capacity(capstring, &capacity)) { 4811f2824e8SSascha Wildner inform(a->c, _("Capacity must be either a '*' symbol " 4821f2824e8SSascha Wildner "to indicate 'use the rest of the primary " 4831f2824e8SSascha Wildner "partition', or it must be a series of decimal " 4841f2824e8SSascha Wildner "digits ending with an 'M' (indicating " 4851f2824e8SSascha Wildner "megabytes), a 'G' (indicating gigabytes) and " 4861f2824e8SSascha Wildner "so on (up to 'E'.)")); 487cdd2d676SSascha Wildner valid = 0; 488cdd2d676SSascha Wildner } 489cdd2d676SSascha Wildner 490268b6264SMatthew Dillon /* 491268b6264SMatthew Dillon * Maybe remove this limit entirely? 492268b6264SMatthew Dillon */ 493268b6264SMatthew Dillon if ((strcasecmp(mountpoint, "swap") == 0) && 494ef48e483SSascha Wildner (capacity > SWAP_MAX)) { 495ef48e483SSascha Wildner inform(a->c, _("Swap capacity is limited to %dG."), 496ef48e483SSascha Wildner SWAP_MAX / 1024); 497cdd2d676SSascha Wildner valid = 0; 498cdd2d676SSascha Wildner } 499cdd2d676SSascha Wildner 500cdd2d676SSascha Wildner /* 501cdd2d676SSascha Wildner * If we made it through that obstacle course, all is well. 502cdd2d676SSascha Wildner */ 503cdd2d676SSascha Wildner 504cdd2d676SSascha Wildner if (valid) 505cdd2d676SSascha Wildner aura_dict_store(d, mountpoint, strlen(mountpoint) + 1, "", 1); 506cdd2d676SSascha Wildner } 507cdd2d676SSascha Wildner 508cdd2d676SSascha Wildner if (!found_root) { 509cdd2d676SSascha Wildner inform(a->c, _("You must include a / (root) subpartition.")); 510cdd2d676SSascha Wildner valid = 0; 511cdd2d676SSascha Wildner } 512cdd2d676SSascha Wildner 513cdd2d676SSascha Wildner if (aura_dict_size(d) > 16) { 514cdd2d676SSascha Wildner inform(a->c, _("You cannot have more than 16 subpartitions " 515cdd2d676SSascha Wildner "on a single primary partition. Remove some " 516cdd2d676SSascha Wildner "and try again.")); 517cdd2d676SSascha Wildner valid = 0; 518cdd2d676SSascha Wildner } 519cdd2d676SSascha Wildner 520cdd2d676SSascha Wildner aura_dict_free(d); 521cdd2d676SSascha Wildner 522cdd2d676SSascha Wildner return(valid); 523cdd2d676SSascha Wildner } 524cdd2d676SSascha Wildner 525cdd2d676SSascha Wildner static void 526cdd2d676SSascha Wildner save_subpartition_selections(struct dfui_response *r, struct i_fn_args *a) 527cdd2d676SSascha Wildner { 528cdd2d676SSascha Wildner struct dfui_dataset *ds; 529761cad2fSSascha Wildner char tmpfsbacked; 530cdd2d676SSascha Wildner const char *mountpoint, *capstring; 531cdd2d676SSascha Wildner long capacity; 532cdd2d676SSascha Wildner long bsize, fsize; 533cdd2d676SSascha Wildner int softupdates; 534cdd2d676SSascha Wildner int valid = 1; 535cdd2d676SSascha Wildner 536cdd2d676SSascha Wildner subpartitions_free(storage_get_selected_slice(a->s)); 537cdd2d676SSascha Wildner 538cdd2d676SSascha Wildner for (ds = dfui_response_dataset_get_first(r); valid && ds != NULL; 539cdd2d676SSascha Wildner ds = dfui_dataset_get_next(ds)) { 540cdd2d676SSascha Wildner mountpoint = dfui_dataset_get_value(ds, "mountpoint"); 541cdd2d676SSascha Wildner capstring = dfui_dataset_get_value(ds, "capacity"); 542cdd2d676SSascha Wildner 543cdd2d676SSascha Wildner if (expert) { 544cdd2d676SSascha Wildner softupdates = 545cdd2d676SSascha Wildner (strcmp(dfui_dataset_get_value(ds, "softupdates"), "Y") == 0); 546cdd2d676SSascha Wildner fsize = atol(dfui_dataset_get_value(ds, "fsize")); 547cdd2d676SSascha Wildner bsize = atol(dfui_dataset_get_value(ds, "bsize")); 548761cad2fSSascha Wildner tmpfsbacked = (strcmp(dfui_dataset_get_value(ds, "tmpfsbacked"), "Y") == 0); 549cdd2d676SSascha Wildner } else { 5501b9a5070SSascha Wildner softupdates = (strcmp(mountpoint, "/boot") == 0 ? 0 : 1); 551761cad2fSSascha Wildner tmpfsbacked = 0; 552cdd2d676SSascha Wildner fsize = -1; 553cdd2d676SSascha Wildner bsize = -1; 554cdd2d676SSascha Wildner } 555cdd2d676SSascha Wildner 556cdd2d676SSascha Wildner if (string_to_capacity(capstring, &capacity)) { 55788cfb1f7SSascha Wildner subpartition_new_ufs(storage_get_selected_slice(a->s), 55888cfb1f7SSascha Wildner mountpoint, capacity, 55988cfb1f7SSascha Wildner strcasecmp(dfui_dataset_get_value(ds, "encrypted"), "Y") == 0, 560761cad2fSSascha Wildner softupdates, fsize, bsize, tmpfsbacked); 561cdd2d676SSascha Wildner } 562cdd2d676SSascha Wildner } 563cdd2d676SSascha Wildner } 564cdd2d676SSascha Wildner 565cdd2d676SSascha Wildner static void 566cdd2d676SSascha Wildner populate_create_subpartitions_form(struct dfui_form *f, struct i_fn_args *a) 567cdd2d676SSascha Wildner { 568cdd2d676SSascha Wildner struct subpartition *sp; 569cdd2d676SSascha Wildner struct dfui_dataset *ds; 570cdd2d676SSascha Wildner char temp[32]; 571cdd2d676SSascha Wildner int mtpt; 572cdd2d676SSascha Wildner long capacity; 573cdd2d676SSascha Wildner 574cdd2d676SSascha Wildner if (slice_subpartition_first(storage_get_selected_slice(a->s)) != NULL) { 575cdd2d676SSascha Wildner /* 576cdd2d676SSascha Wildner * The user has already given us their subpartition 577cdd2d676SSascha Wildner * preferences, so use them here. 578cdd2d676SSascha Wildner */ 579cdd2d676SSascha Wildner for (sp = slice_subpartition_first(storage_get_selected_slice(a->s)); 580cdd2d676SSascha Wildner sp != NULL; sp = subpartition_next(sp)) { 581cdd2d676SSascha Wildner ds = dfui_dataset_new(); 582cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "mountpoint", 583cdd2d676SSascha Wildner subpartition_get_mountpoint(sp)); 584cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "capacity", 585cdd2d676SSascha Wildner capacity_to_string(subpartition_get_capacity(sp))); 58688cfb1f7SSascha Wildner dfui_dataset_celldata_add(ds, "encrypted", 58788cfb1f7SSascha Wildner subpartition_is_encrypted(sp) ? "Y" : "N"); 588cdd2d676SSascha Wildner if (expert) { 589cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "softupdates", 590cdd2d676SSascha Wildner subpartition_is_softupdated(sp) ? "Y" : "N"); 591761cad2fSSascha Wildner dfui_dataset_celldata_add(ds, "tmpfsbacked", 592761cad2fSSascha Wildner subpartition_is_tmpfsbacked(sp) ? "Y" : "N"); 593cdd2d676SSascha Wildner snprintf(temp, 32, "%ld", subpartition_get_fsize(sp)); 594cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "fsize", 595cdd2d676SSascha Wildner temp); 596cdd2d676SSascha Wildner snprintf(temp, 32, "%ld", subpartition_get_bsize(sp)); 597cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "bsize", 598cdd2d676SSascha Wildner temp); 599cdd2d676SSascha Wildner } 600cdd2d676SSascha Wildner dfui_form_dataset_add(f, ds); 601cdd2d676SSascha Wildner } 602cdd2d676SSascha Wildner } else { 603cdd2d676SSascha Wildner /* 604cdd2d676SSascha Wildner * Otherwise, populate the form with datasets representing 605cdd2d676SSascha Wildner * reasonably-calculated defaults. The defaults are chosen 606cdd2d676SSascha Wildner * based on the slice's total capacity and the machine's 607cdd2d676SSascha Wildner * total physical memory (for swap.) 608cdd2d676SSascha Wildner */ 609cdd2d676SSascha Wildner for (mtpt = 0; def_mountpt[mtpt] != NULL; mtpt++) { 610f9602a12SMatthew Dillon capacity = default_capacity(a->s, def_mountpt[mtpt]); 611f9602a12SMatthew Dillon if (capacity == 0) 612f9602a12SMatthew Dillon continue; 613cdd2d676SSascha Wildner ds = dfui_dataset_new(); 614cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "mountpoint", 615cdd2d676SSascha Wildner def_mountpt[mtpt]); 616cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "capacity", 617cdd2d676SSascha Wildner capacity_to_string(capacity)); 61888cfb1f7SSascha Wildner dfui_dataset_celldata_add(ds, "encrypted", "N"); 619cdd2d676SSascha Wildner if (expert) { 620cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "softupdates", 6211b9a5070SSascha Wildner strcmp(def_mountpt[mtpt], "/boot") != 0 ? "Y" : "N"); 622761cad2fSSascha Wildner dfui_dataset_celldata_add(ds, "tmpfsbacked", 623cdd2d676SSascha Wildner "N"); 624cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "fsize", 625cdd2d676SSascha Wildner capacity < 1024 ? "1024" : "2048"); 626cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "bsize", 627cdd2d676SSascha Wildner capacity < 1024 ? "8192" : "16384"); 628cdd2d676SSascha Wildner } 629cdd2d676SSascha Wildner dfui_form_dataset_add(f, ds); 630cdd2d676SSascha Wildner } 631cdd2d676SSascha Wildner } 632cdd2d676SSascha Wildner } 633cdd2d676SSascha Wildner 634cdd2d676SSascha Wildner static int 635cdd2d676SSascha Wildner warn_subpartition_selections(struct i_fn_args *a) 636cdd2d676SSascha Wildner { 637cdd2d676SSascha Wildner int valid = 0; 638cdd2d676SSascha Wildner 639344b24adSSascha Wildner /* Skip this check for disks <= 8GB */ 640344b24adSSascha Wildner if (slice_get_capacity(storage_get_selected_slice(a->s)) <= 8192) 641344b24adSSascha Wildner return 0; 642344b24adSSascha Wildner 643cdd2d676SSascha Wildner valid = check_capacity(a); 64488cfb1f7SSascha Wildner 64588cfb1f7SSascha Wildner return(!valid); 64688cfb1f7SSascha Wildner } 64788cfb1f7SSascha Wildner 648cdd2d676SSascha Wildner static struct dfui_form * 649cdd2d676SSascha Wildner make_create_subpartitions_form(struct i_fn_args *a) 650cdd2d676SSascha Wildner { 651cdd2d676SSascha Wildner struct dfui_field *fi; 652cdd2d676SSascha Wildner struct dfui_form *f; 653cdd2d676SSascha Wildner char msg_buf[1][1024]; 654cdd2d676SSascha Wildner 655cdd2d676SSascha Wildner snprintf(msg_buf[0], sizeof(msg_buf[0]), 656cdd2d676SSascha Wildner _("Subpartitions further divide a primary partition for " 657cdd2d676SSascha Wildner "use with %s. Some reasons you may want " 658cdd2d676SSascha Wildner "a set of subpartitions are:\n\n" 659cdd2d676SSascha Wildner "- you want to restrict how much data can be written " 660cdd2d676SSascha Wildner "to certain parts of the primary partition, to quell " 661cdd2d676SSascha Wildner "denial-of-service attacks; and\n" 662cdd2d676SSascha Wildner "- you want to speed up access to data on the disk." 663cdd2d676SSascha Wildner ""), OPERATING_SYSTEM_NAME); 664cdd2d676SSascha Wildner 665cdd2d676SSascha Wildner f = dfui_form_create( 666cdd2d676SSascha Wildner "create_subpartitions", 667cdd2d676SSascha Wildner _("Create Subpartitions"), 668cdd2d676SSascha Wildner _("Set up the subpartitions (also known as just `partitions' " 669cdd2d676SSascha Wildner "in BSD tradition) you want to have on this primary " 670cdd2d676SSascha Wildner "partition.\n\n" 671cdd2d676SSascha Wildner "For Capacity, use 'M' to indicate megabytes, 'G' to " 6721f2824e8SSascha Wildner "indicate gigabytes, and so on (up to 'E'.) A single '*' " 6731f2824e8SSascha Wildner "indicates 'use the remaining space on the primary partition'."), 674cdd2d676SSascha Wildner 675cdd2d676SSascha Wildner msg_buf[0], 676cdd2d676SSascha Wildner 677cdd2d676SSascha Wildner "p", "special", "dfinstaller_create_subpartitions", 678cdd2d676SSascha Wildner "p", "minimum_width","64", 679cdd2d676SSascha Wildner 680cdd2d676SSascha Wildner "f", "mountpoint", _("Mountpoint"), "", "", 681cdd2d676SSascha Wildner "f", "capacity", _("Capacity"), "", "", 682cdd2d676SSascha Wildner 68388cfb1f7SSascha Wildner "f", "encrypted", _("Encrypted"), "", "", 68488cfb1f7SSascha Wildner "p", "control", "checkbox", 68588cfb1f7SSascha Wildner 686cdd2d676SSascha Wildner "a", "ok", _("Accept and Create"), "", "", 687cdd2d676SSascha Wildner "a", "cancel", 688cdd2d676SSascha Wildner (disk_get_formatted(storage_get_selected_disk(a->s)) ? 689cdd2d676SSascha Wildner _("Return to Select Disk") : 690cdd2d676SSascha Wildner _("Return to Select Primary Partition")), "", "", 691cdd2d676SSascha Wildner "p", "accelerator", "ESC", 692cdd2d676SSascha Wildner 693cdd2d676SSascha Wildner NULL 694cdd2d676SSascha Wildner ); 695cdd2d676SSascha Wildner 696cdd2d676SSascha Wildner dfui_form_set_multiple(f, 1); 697cdd2d676SSascha Wildner dfui_form_set_extensible(f, 1); 698cdd2d676SSascha Wildner 699cdd2d676SSascha Wildner if (expert) { 700cdd2d676SSascha Wildner fi = dfui_form_field_add(f, "softupdates", 701cdd2d676SSascha Wildner dfui_info_new(_("Softupdates"), "", "")); 702cdd2d676SSascha Wildner dfui_field_property_set(fi, "control", "checkbox"); 703cdd2d676SSascha Wildner 704761cad2fSSascha Wildner fi = dfui_form_field_add(f, "tmpfsbacked", 705761cad2fSSascha Wildner dfui_info_new(_("TMPFS"), "", "")); 706cdd2d676SSascha Wildner dfui_field_property_set(fi, "control", "checkbox"); 707cdd2d676SSascha Wildner 708cdd2d676SSascha Wildner fi = dfui_form_field_add(f, "fsize", 709cdd2d676SSascha Wildner dfui_info_new(_("Frag Sz"), "", "")); 710cdd2d676SSascha Wildner 711cdd2d676SSascha Wildner fi = dfui_form_field_add(f, "bsize", 712cdd2d676SSascha Wildner dfui_info_new(_("Block Sz"), "", "")); 713cdd2d676SSascha Wildner 714cdd2d676SSascha Wildner dfui_form_action_add(f, "switch", 715cdd2d676SSascha Wildner dfui_info_new(_("Switch to Normal Mode"), "", "")); 716cdd2d676SSascha Wildner } else { 717cdd2d676SSascha Wildner dfui_form_action_add(f, "switch", 718cdd2d676SSascha Wildner dfui_info_new(_("Switch to Expert Mode"), "", "")); 719cdd2d676SSascha Wildner } 720cdd2d676SSascha Wildner 721cdd2d676SSascha Wildner return(f); 722cdd2d676SSascha Wildner } 723cdd2d676SSascha Wildner 724cdd2d676SSascha Wildner /* 725cdd2d676SSascha Wildner * Returns: 726cdd2d676SSascha Wildner * -1 = the form should be redisplayed 727cdd2d676SSascha Wildner * 0 = failure, function is over 728cdd2d676SSascha Wildner * 1 = success, function is over 729cdd2d676SSascha Wildner */ 730cdd2d676SSascha Wildner static int 731cdd2d676SSascha Wildner show_create_subpartitions_form(struct dfui_form *f, struct i_fn_args *a) 732cdd2d676SSascha Wildner { 733cdd2d676SSascha Wildner struct dfui_dataset *ds; 734cdd2d676SSascha Wildner struct dfui_response *r; 735cdd2d676SSascha Wildner 736cdd2d676SSascha Wildner for (;;) { 737cdd2d676SSascha Wildner if (dfui_form_dataset_get_first(f) == NULL) 738cdd2d676SSascha Wildner populate_create_subpartitions_form(f, a); 739cdd2d676SSascha Wildner 740cdd2d676SSascha Wildner if (!dfui_be_present(a->c, f, &r)) 741cdd2d676SSascha Wildner abort_backend(); 742cdd2d676SSascha Wildner 743cdd2d676SSascha Wildner if (strcmp(dfui_response_get_action_id(r), "cancel") == 0) { 744cdd2d676SSascha Wildner dfui_response_free(r); 745cdd2d676SSascha Wildner return(0); 746cdd2d676SSascha Wildner } else if (strcmp(dfui_response_get_action_id(r), "switch") == 0) { 747cdd2d676SSascha Wildner if (check_subpartition_selections(r, a)) { 748cdd2d676SSascha Wildner save_subpartition_selections(r, a); 749cdd2d676SSascha Wildner expert = expert ? 0 : 1; 750cdd2d676SSascha Wildner dfui_response_free(r); 751cdd2d676SSascha Wildner return(-1); 752cdd2d676SSascha Wildner } 753cdd2d676SSascha Wildner } else { 754cdd2d676SSascha Wildner if (check_subpartition_selections(r, a)) { 755cdd2d676SSascha Wildner save_subpartition_selections(r, a); 756f9602a12SMatthew Dillon if (!warn_subpartition_selections(a)) { 757cdd2d676SSascha Wildner if (!create_subpartitions(a)) { 758cdd2d676SSascha Wildner inform(a->c, _("The subpartitions you chose were " 759cdd2d676SSascha Wildner "not correctly created, and the " 760cdd2d676SSascha Wildner "primary partition may " 761cdd2d676SSascha Wildner "now be in an inconsistent state. " 762cdd2d676SSascha Wildner "We recommend re-formatting it " 763cdd2d676SSascha Wildner "before proceeding.")); 764cdd2d676SSascha Wildner dfui_response_free(r); 765cdd2d676SSascha Wildner return(0); 766cdd2d676SSascha Wildner } else { 767cdd2d676SSascha Wildner dfui_response_free(r); 768cdd2d676SSascha Wildner return(1); 769cdd2d676SSascha Wildner } 770cdd2d676SSascha Wildner } 771cdd2d676SSascha Wildner } 772cdd2d676SSascha Wildner } 773cdd2d676SSascha Wildner 774cdd2d676SSascha Wildner dfui_form_datasets_free(f); 775cdd2d676SSascha Wildner /* dfui_form_datasets_add_from_response(f, r); */ 776cdd2d676SSascha Wildner for (ds = dfui_response_dataset_get_first(r); ds != NULL; 777cdd2d676SSascha Wildner ds = dfui_dataset_get_next(ds)) { 778cdd2d676SSascha Wildner dfui_form_dataset_add(f, dfui_dataset_dup(ds)); 779cdd2d676SSascha Wildner } 780cdd2d676SSascha Wildner } 781cdd2d676SSascha Wildner } 782cdd2d676SSascha Wildner 783cdd2d676SSascha Wildner void 784cdd2d676SSascha Wildner fn_create_subpartitions_ufs(struct i_fn_args *a) 785cdd2d676SSascha Wildner { 786cdd2d676SSascha Wildner struct dfui_form *f; 787344b24adSSascha Wildner unsigned long capacity; 788cdd2d676SSascha Wildner int done = 0; 789cdd2d676SSascha Wildner 790cdd2d676SSascha Wildner a->result = 0; 791344b24adSSascha Wildner capacity = slice_get_capacity(storage_get_selected_slice(a->s)); 792344b24adSSascha Wildner if (capacity < DISK_MIN) { 793344b24adSSascha Wildner inform(a->c, _("The selected disk is smaller than the " 794344b24adSSascha Wildner "required %dM for the UFS filesystem."), DISK_MIN); 795344b24adSSascha Wildner return; 796344b24adSSascha Wildner } 797f9602a12SMatthew Dillon #if 0 798344b24adSSascha Wildner if (capacity <= 8192) 799344b24adSSascha Wildner def_mountpt[2] = NULL; /* XXX adjust each time in a session */ 800f9602a12SMatthew Dillon #endif 801cdd2d676SSascha Wildner while (!done) { 802cdd2d676SSascha Wildner f = make_create_subpartitions_form(a); 803cdd2d676SSascha Wildner switch (show_create_subpartitions_form(f, a)) { 804cdd2d676SSascha Wildner case -1: 805cdd2d676SSascha Wildner done = 0; 806cdd2d676SSascha Wildner break; 807cdd2d676SSascha Wildner case 0: 808cdd2d676SSascha Wildner done = 1; 809cdd2d676SSascha Wildner a->result = 0; 810cdd2d676SSascha Wildner break; 811cdd2d676SSascha Wildner case 1: 812cdd2d676SSascha Wildner done = 1; 813cdd2d676SSascha Wildner a->result = 1; 814cdd2d676SSascha Wildner break; 815cdd2d676SSascha Wildner } 816cdd2d676SSascha Wildner dfui_form_free(f); 817cdd2d676SSascha Wildner } 818cdd2d676SSascha Wildner } 819