1cdd2d676SSascha Wildner /* 2cdd2d676SSascha Wildner * Copyright (c)2004 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 69cdd2d676SSascha Wildner static int create_subpartitions(struct i_fn_args *); 70cdd2d676SSascha Wildner static long default_capacity(struct storage *, int); 71cdd2d676SSascha Wildner static int check_capacity(struct i_fn_args *); 72cdd2d676SSascha Wildner static int check_subpartition_selections(struct dfui_response *, struct i_fn_args *); 73cdd2d676SSascha Wildner static void save_subpartition_selections(struct dfui_response *, struct i_fn_args *); 74cdd2d676SSascha Wildner static void populate_create_subpartitions_form(struct dfui_form *, struct i_fn_args *); 75cdd2d676SSascha Wildner static int warn_subpartition_selections(struct i_fn_args *); 7688cfb1f7SSascha Wildner static int warn_encrypted_root(struct i_fn_args *); 77cdd2d676SSascha Wildner static struct dfui_form *make_create_subpartitions_form(struct i_fn_args *); 78cdd2d676SSascha Wildner static int show_create_subpartitions_form(struct dfui_form *, struct i_fn_args *); 79cdd2d676SSascha Wildner 806cd7259eSSascha Wildner static const char *def_mountpt[] = {"/", "swap", "/var", "/tmp", "/usr", "/home", NULL}; 81cdd2d676SSascha Wildner static int expert = 0; 82cdd2d676SSascha Wildner 83cdd2d676SSascha Wildner /* 84cdd2d676SSascha Wildner * Given a set of subpartitions-to-be in the selected slice, 85cdd2d676SSascha Wildner * create them. 86cdd2d676SSascha Wildner */ 87cdd2d676SSascha Wildner static int 88cdd2d676SSascha Wildner create_subpartitions(struct i_fn_args *a) 89cdd2d676SSascha Wildner { 90cdd2d676SSascha Wildner struct subpartition *sp; 91cdd2d676SSascha Wildner struct commands *cmds; 92cdd2d676SSascha Wildner int result = 0; 93cdd2d676SSascha Wildner int num_partitions; 94cdd2d676SSascha Wildner 95cdd2d676SSascha Wildner cmds = commands_new(); 96cdd2d676SSascha Wildner if (!is_file("%sinstall.disklabel.%s", 97cdd2d676SSascha Wildner a->tmp, 98cdd2d676SSascha Wildner slice_get_device_name(storage_get_selected_slice(a->s)))) { 99cdd2d676SSascha Wildner /* 100cdd2d676SSascha Wildner * Get a copy of the 'virgin' disklabel. 101cdd2d676SSascha Wildner * XXX It might make more sense for this to 102cdd2d676SSascha Wildner * happen right after format_slice() instead. 103cdd2d676SSascha Wildner */ 104cdd2d676SSascha Wildner command_add(cmds, "%s%s -r %s >%sinstall.disklabel.%s", 105b5cb2d94SSascha Wildner a->os_root, cmd_name(a, "DISKLABEL64"), 106cdd2d676SSascha Wildner slice_get_device_name(storage_get_selected_slice(a->s)), 107cdd2d676SSascha Wildner a->tmp, 108cdd2d676SSascha Wildner slice_get_device_name(storage_get_selected_slice(a->s))); 109cdd2d676SSascha Wildner } 110cdd2d676SSascha Wildner 111cdd2d676SSascha Wildner /* 112cdd2d676SSascha Wildner * Weave together a new disklabel out the of the 'virgin' 113cdd2d676SSascha Wildner * disklabel, and the user's subpartition choices. 114cdd2d676SSascha Wildner */ 115cdd2d676SSascha Wildner 116cdd2d676SSascha Wildner /* 117cdd2d676SSascha Wildner * Take everything from the 'virgin' disklabel up until the 118cdd2d676SSascha Wildner * '16 partitions' line. 119cdd2d676SSascha Wildner */ 120cdd2d676SSascha Wildner num_partitions = 16; 121cdd2d676SSascha Wildner command_add(cmds, "%s%s '$2==\"partitions:\" || cut { cut = 1 } !cut { print $0 }' <%sinstall.disklabel.%s >%sinstall.disklabel", 122cdd2d676SSascha Wildner a->os_root, cmd_name(a, "AWK"), 123cdd2d676SSascha Wildner a->tmp, 124cdd2d676SSascha Wildner slice_get_device_name(storage_get_selected_slice(a->s)), 125cdd2d676SSascha Wildner a->tmp); 126cdd2d676SSascha Wildner 127cdd2d676SSascha Wildner /* 128cdd2d676SSascha Wildner * 16 partitions: 129cdd2d676SSascha Wildner * # size offset fstype 130cdd2d676SSascha Wildner * c: 16383969 0 unused # 7999.985MB 131cdd2d676SSascha Wildner */ 132cdd2d676SSascha Wildner 133cdd2d676SSascha Wildner command_add(cmds, "%s%s '%d partitions:' >>%sinstall.disklabel", 134cdd2d676SSascha Wildner a->os_root, cmd_name(a, "ECHO"), num_partitions ,a->tmp); 135cdd2d676SSascha Wildner command_add(cmds, "%s%s '%s' >>%sinstall.disklabel", 136cdd2d676SSascha Wildner a->os_root, cmd_name(a, "ECHO"), 137cdd2d676SSascha Wildner "# size offset fstype", 138cdd2d676SSascha Wildner a->tmp); 139cdd2d676SSascha Wildner 140cdd2d676SSascha Wildner #ifdef DEBUG 141cdd2d676SSascha Wildner for (sp = slice_subpartition_first(storage_get_selected_slice(a->s)); 142cdd2d676SSascha Wildner sp != NULL; sp = subpartition_next(sp)) { 143cdd2d676SSascha Wildner command_add(cmds, "%s%s 'mountpoint: %s device: %s'", 144cdd2d676SSascha Wildner a->os_root, cmd_name(a, "ECHO"), 145cdd2d676SSascha Wildner subpartition_get_mountpoint(sp), 146cdd2d676SSascha Wildner subpartition_get_device_name(sp)); 147cdd2d676SSascha Wildner } 148cdd2d676SSascha Wildner #endif 149cdd2d676SSascha Wildner 150cdd2d676SSascha Wildner /* 151cdd2d676SSascha Wildner * Write a line for each subpartition the user wants. 152cdd2d676SSascha Wildner */ 153cdd2d676SSascha Wildner for (sp = slice_subpartition_first(storage_get_selected_slice(a->s)); 154cdd2d676SSascha Wildner sp != NULL; sp = subpartition_next(sp)) { 155761cad2fSSascha Wildner if (subpartition_is_tmpfsbacked(sp)) { 156cdd2d676SSascha Wildner continue; 157cdd2d676SSascha Wildner } 158cdd2d676SSascha Wildner if (subpartition_is_swap(sp)) { 159cdd2d676SSascha Wildner command_add(cmds, "%s%s ' %c:\t%s\t*\tswap' >>%sinstall.disklabel", 160cdd2d676SSascha Wildner a->os_root, cmd_name(a, "ECHO"), 161cdd2d676SSascha Wildner subpartition_get_letter(sp), 162cdd2d676SSascha Wildner capacity_to_string(subpartition_get_capacity(sp)), 163cdd2d676SSascha Wildner a->tmp); 164cdd2d676SSascha Wildner } else { 165cdd2d676SSascha Wildner command_add(cmds, "%s%s ' %c:\t%s\t%s\t4.2BSD' >>%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 subpartition_get_letter(sp) == 'a' ? "0" : "*", 170cdd2d676SSascha Wildner a->tmp); 171cdd2d676SSascha Wildner } 172cdd2d676SSascha Wildner } 173cdd2d676SSascha Wildner temp_file_add(a, "install.disklabel"); 174cdd2d676SSascha Wildner 175cdd2d676SSascha Wildner /* 176cdd2d676SSascha Wildner * Label the slice from the disklabel we just wove together. 177cdd2d676SSascha Wildner */ 178cdd2d676SSascha Wildner command_add(cmds, "%s%s -R -B -r %s %sinstall.disklabel", 179b5cb2d94SSascha Wildner a->os_root, cmd_name(a, "DISKLABEL64"), 180cdd2d676SSascha Wildner slice_get_device_name(storage_get_selected_slice(a->s)), 181cdd2d676SSascha Wildner a->tmp); 182cdd2d676SSascha Wildner 183cdd2d676SSascha Wildner /* 184cdd2d676SSascha Wildner * Create a snapshot of the disklabel we just created 185cdd2d676SSascha Wildner * for debugging inspection in the log. 186cdd2d676SSascha Wildner */ 187cdd2d676SSascha Wildner command_add(cmds, "%s%s %s", 188b5cb2d94SSascha Wildner a->os_root, cmd_name(a, "DISKLABEL64"), 189cdd2d676SSascha Wildner slice_get_device_name(storage_get_selected_slice(a->s))); 190cdd2d676SSascha Wildner 191cdd2d676SSascha Wildner /* 19288cfb1f7SSascha Wildner * If encryption was specified, load dm(4). 19388cfb1f7SSascha Wildner */ 19488cfb1f7SSascha Wildner for (sp = slice_subpartition_first(storage_get_selected_slice(a->s)); 19588cfb1f7SSascha Wildner sp != NULL; sp = subpartition_next(sp)) { 19688cfb1f7SSascha Wildner if (subpartition_is_encrypted(sp)) { 19788cfb1f7SSascha Wildner fn_get_passphrase(a); 19888cfb1f7SSascha Wildner break; 19988cfb1f7SSascha Wildner } 20088cfb1f7SSascha Wildner } 20188cfb1f7SSascha Wildner 20288cfb1f7SSascha Wildner /* 203cdd2d676SSascha Wildner * Create filesystems on the newly-created subpartitions. 204cdd2d676SSascha Wildner */ 205cdd2d676SSascha Wildner for (sp = slice_subpartition_first(storage_get_selected_slice(a->s)); 206cdd2d676SSascha Wildner sp != NULL; sp = subpartition_next(sp)) { 20788cfb1f7SSascha Wildner if (subpartition_is_swap(sp) || subpartition_is_tmpfsbacked(sp)) { 20888cfb1f7SSascha Wildner if (subpartition_is_swap(sp) && 20988cfb1f7SSascha Wildner subpartition_is_encrypted(sp)) { 21088cfb1f7SSascha Wildner command_add(cmds, 21188cfb1f7SSascha Wildner "%s%s -d /tmp/t1 luksFormat %sdev/%s", 21288cfb1f7SSascha Wildner a->os_root, cmd_name(a, "CRYPTSETUP"), 21388cfb1f7SSascha Wildner a->os_root, 21488cfb1f7SSascha Wildner subpartition_get_device_name(sp)); 21588cfb1f7SSascha Wildner command_add(cmds, 21688cfb1f7SSascha Wildner "%s%s -d /tmp/t1 luksOpen %sdev/%s swap", 21788cfb1f7SSascha Wildner a->os_root, cmd_name(a, "CRYPTSETUP"), 21888cfb1f7SSascha Wildner a->os_root, 21988cfb1f7SSascha Wildner subpartition_get_device_name(sp)); 22088cfb1f7SSascha Wildner } 221cdd2d676SSascha Wildner continue; 22288cfb1f7SSascha Wildner } 223cdd2d676SSascha Wildner 22488cfb1f7SSascha Wildner if (subpartition_is_encrypted(sp) && 22588cfb1f7SSascha Wildner strcmp(subpartition_get_mountpoint(sp), "/") != 0) { 22688cfb1f7SSascha Wildner command_add(cmds, 22788cfb1f7SSascha Wildner "%s%s -d /tmp/t1 luksFormat %sdev/%s", 22888cfb1f7SSascha Wildner a->os_root, cmd_name(a, "CRYPTSETUP"), 22988cfb1f7SSascha Wildner a->os_root, 23088cfb1f7SSascha Wildner subpartition_get_device_name(sp)); 23188cfb1f7SSascha Wildner command_add(cmds, 23288cfb1f7SSascha Wildner "%s%s -d /tmp/t1 luksOpen %sdev/%s %s", 23388cfb1f7SSascha Wildner a->os_root, cmd_name(a, "CRYPTSETUP"), 23488cfb1f7SSascha Wildner a->os_root, 23588cfb1f7SSascha Wildner subpartition_get_device_name(sp), 23688cfb1f7SSascha Wildner subpartition_get_mountpoint(sp) + 1); 23788cfb1f7SSascha Wildner command_add(cmds, "%s%s%s -b %ld -f %ld %sdev/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), 24288cfb1f7SSascha Wildner a->os_root, 24388cfb1f7SSascha Wildner subpartition_get_mountpoint(sp) + 1); 24488cfb1f7SSascha Wildner } else { 245cdd2d676SSascha Wildner command_add(cmds, "%s%s%s -b %ld -f %ld %sdev/%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 a->os_root, 251cdd2d676SSascha Wildner subpartition_get_device_name(sp)); 252cdd2d676SSascha Wildner } 25388cfb1f7SSascha Wildner } 254cdd2d676SSascha Wildner 255cdd2d676SSascha Wildner result = commands_execute(a, cmds); 256cdd2d676SSascha Wildner commands_free(cmds); 257cdd2d676SSascha Wildner return(result); 258cdd2d676SSascha Wildner } 259cdd2d676SSascha Wildner 260cdd2d676SSascha Wildner static long 261cdd2d676SSascha Wildner default_capacity(struct storage *s, int mtpt) 262cdd2d676SSascha Wildner { 263cdd2d676SSascha Wildner unsigned long swap; 264cdd2d676SSascha Wildner unsigned long capacity; 2656cd7259eSSascha Wildner unsigned long mem; 266cdd2d676SSascha Wildner 267cdd2d676SSascha Wildner if (mtpt == MTPT_HOME) 268cdd2d676SSascha Wildner return(-1); 269cdd2d676SSascha Wildner 270cdd2d676SSascha Wildner capacity = slice_get_capacity(storage_get_selected_slice(s)); 2716cd7259eSSascha Wildner mem = storage_get_memsize(s); 2726cd7259eSSascha Wildner swap = 2 * mem; 2736cd7259eSSascha Wildner if (mem > (capacity / 2) || capacity < 4096) 2746cd7259eSSascha Wildner swap = mem; 2756cd7259eSSascha Wildner if (mem > capacity) 276cdd2d676SSascha Wildner swap = capacity / 2; 277f76463ceSSascha Wildner if (swap > SWAP_MAX) 278f76463ceSSascha Wildner swap = SWAP_MAX; 279cdd2d676SSascha Wildner 280cdd2d676SSascha Wildner if (capacity < DISK_MIN) { 281cdd2d676SSascha Wildner /* 282cdd2d676SSascha Wildner * For the purposes of this installer: 283cdd2d676SSascha Wildner * can't be done. Sorry. 284cdd2d676SSascha Wildner */ 285cdd2d676SSascha Wildner return(-1); 286cdd2d676SSascha Wildner } else if (capacity < 4096) { 287cdd2d676SSascha Wildner switch (mtpt) { 288167360aeSSascha Wildner case MTPT_ROOT: return(320); 289cdd2d676SSascha Wildner case MTPT_SWAP: return(swap); 290cdd2d676SSascha Wildner case MTPT_VAR: return(128); 291cdd2d676SSascha Wildner case MTPT_TMP: return(128); 292167360aeSSascha Wildner case MTPT_USR: return(1472); 293cdd2d676SSascha Wildner } 294cdd2d676SSascha Wildner } else if (capacity < 10240) { 295cdd2d676SSascha Wildner switch (mtpt) { 296167360aeSSascha Wildner case MTPT_ROOT: return(640); 297cdd2d676SSascha Wildner case MTPT_SWAP: return(swap); 298cdd2d676SSascha Wildner case MTPT_VAR: return(256); 299cdd2d676SSascha Wildner case MTPT_TMP: return(256); 300167360aeSSascha Wildner case MTPT_USR: return(2688); 301cdd2d676SSascha Wildner } 302cdd2d676SSascha Wildner } else { 303cdd2d676SSascha Wildner switch (mtpt) { 304167360aeSSascha Wildner case MTPT_ROOT: return(768); 305cdd2d676SSascha Wildner case MTPT_SWAP: return(swap); 306cdd2d676SSascha Wildner case MTPT_VAR: return(256); 307cdd2d676SSascha Wildner case MTPT_TMP: return(256); 308167360aeSSascha Wildner case MTPT_USR: return(7680); 309cdd2d676SSascha Wildner } 310cdd2d676SSascha Wildner } 311cdd2d676SSascha Wildner /* shouldn't ever happen */ 312cdd2d676SSascha Wildner return(-1); 313cdd2d676SSascha Wildner } 314cdd2d676SSascha Wildner 315cdd2d676SSascha Wildner static int 316cdd2d676SSascha Wildner check_capacity(struct i_fn_args *a) 317cdd2d676SSascha Wildner { 318cdd2d676SSascha Wildner struct subpartition *sp; 319167360aeSSascha Wildner long min_capacity[] = {320, 0, 16, 0, 1472, 0, 0}; 320cdd2d676SSascha Wildner unsigned long total_capacity = 0; 321cdd2d676SSascha Wildner int mtpt; 322cdd2d676SSascha Wildner 323cdd2d676SSascha Wildner if (subpartition_find(storage_get_selected_slice(a->s), "/usr") == NULL) 324cdd2d676SSascha Wildner min_capacity[MTPT_ROOT] += min_capacity[MTPT_USR]; 325cdd2d676SSascha Wildner 326cdd2d676SSascha Wildner for (sp = slice_subpartition_first(storage_get_selected_slice(a->s)); 327cdd2d676SSascha Wildner sp != NULL; sp = subpartition_next(sp)) { 32870f67d72SSascha Wildner long subpart_capacity = subpartition_get_capacity(sp); 32970f67d72SSascha Wildner const char *mountpt = subpartition_get_mountpoint(sp); 33070f67d72SSascha Wildner 33170f67d72SSascha Wildner if (subpart_capacity == -1) 332cdd2d676SSascha Wildner total_capacity++; 333cdd2d676SSascha Wildner else 33470f67d72SSascha Wildner total_capacity += subpart_capacity; 335cdd2d676SSascha Wildner for (mtpt = 0; def_mountpt[mtpt] != NULL; mtpt++) { 33670f67d72SSascha Wildner if (strcmp(mountpt, def_mountpt[mtpt]) == 0 && 337b680ec87SSascha Wildner subpart_capacity < min_capacity[mtpt] && 338b680ec87SSascha Wildner subpart_capacity != -1) { 33970f67d72SSascha Wildner inform(a->c, _("WARNING: The size (%ldM) specified for " 34070f67d72SSascha Wildner "the %s subpartition is too small. It " 34170f67d72SSascha Wildner "should be at least %ldM or you will " 342cdd2d676SSascha Wildner "risk running out of space during " 343cdd2d676SSascha Wildner "the installation."), 34470f67d72SSascha Wildner subpart_capacity, mountpt, 34570f67d72SSascha Wildner min_capacity[mtpt]); 346cdd2d676SSascha Wildner } 347cdd2d676SSascha Wildner } 348cdd2d676SSascha Wildner } 349cdd2d676SSascha Wildner 350cdd2d676SSascha Wildner if (total_capacity > slice_get_capacity(storage_get_selected_slice(a->s))) { 351cdd2d676SSascha Wildner inform(a->c, _("The space allocated to all of your selected " 35259b733d3SSascha Wildner "subpartitions (%luM) exceeds the total " 353cdd2d676SSascha Wildner "capacity of the selected primary partition " 35459b733d3SSascha Wildner "(%luM). Remove some subpartitions or choose " 355cdd2d676SSascha Wildner "a smaller size for them and try again."), 356cdd2d676SSascha Wildner total_capacity, slice_get_capacity(storage_get_selected_slice(a->s))); 357cdd2d676SSascha Wildner return(0); 358cdd2d676SSascha Wildner } 359cdd2d676SSascha Wildner 360cdd2d676SSascha Wildner return(1); 361cdd2d676SSascha Wildner } 362cdd2d676SSascha Wildner 363cdd2d676SSascha Wildner static int 364cdd2d676SSascha Wildner check_subpartition_selections(struct dfui_response *r, struct i_fn_args *a) 365cdd2d676SSascha Wildner { 366cdd2d676SSascha Wildner struct dfui_dataset *ds; 367cdd2d676SSascha Wildner struct dfui_dataset *star_ds = NULL; 368cdd2d676SSascha Wildner struct aura_dict *d; 369cdd2d676SSascha Wildner const char *mountpoint, *capstring; 370cdd2d676SSascha Wildner long capacity = 0; 371cdd2d676SSascha Wildner long bsize, fsize; 372cdd2d676SSascha Wildner int found_root = 0; 373761cad2fSSascha Wildner int softupdates, tmpfsbacked; 374cdd2d676SSascha Wildner int valid = 1; 375cdd2d676SSascha Wildner 376cdd2d676SSascha Wildner d = aura_dict_new(1, AURA_DICT_LIST); 377cdd2d676SSascha Wildner 378cdd2d676SSascha Wildner if ((ds = dfui_response_dataset_get_first(r)) == NULL) { 379cdd2d676SSascha Wildner inform(a->c, _("Please set up at least one subpartition.")); 380cdd2d676SSascha Wildner valid = 0; 381cdd2d676SSascha Wildner } 382cdd2d676SSascha Wildner 383cdd2d676SSascha Wildner for (ds = dfui_response_dataset_get_first(r); valid && ds != NULL; 384cdd2d676SSascha Wildner ds = dfui_dataset_get_next(ds)) { 385cdd2d676SSascha Wildner #ifdef DEBUG 386cdd2d676SSascha Wildner dfui_dataset_dump(ds); 387cdd2d676SSascha Wildner #endif 388cdd2d676SSascha Wildner mountpoint = dfui_dataset_get_value(ds, "mountpoint"); 389cdd2d676SSascha Wildner capstring = dfui_dataset_get_value(ds, "capacity"); 390cdd2d676SSascha Wildner 391cdd2d676SSascha Wildner if (expert) { 392cdd2d676SSascha Wildner softupdates = 393cdd2d676SSascha Wildner (strcmp(dfui_dataset_get_value(ds, "softupdates"), "Y") == 0); 394cdd2d676SSascha Wildner fsize = atol(dfui_dataset_get_value(ds, "fsize")); 395cdd2d676SSascha Wildner bsize = atol(dfui_dataset_get_value(ds, "bsize")); 396761cad2fSSascha Wildner tmpfsbacked = (strcmp(dfui_dataset_get_value(ds, "tmpfsbacked"), "Y") == 0); 397cdd2d676SSascha Wildner } else { 398cdd2d676SSascha Wildner softupdates = (strcmp(mountpoint, "/") == 0 ? 0 : 1); 399761cad2fSSascha Wildner tmpfsbacked = (strcmp(mountpoint, "/tmp") == 0 ? 0 : 1); 400cdd2d676SSascha Wildner fsize = -1; 401cdd2d676SSascha Wildner bsize = -1; 402cdd2d676SSascha Wildner } 403cdd2d676SSascha Wildner 404cdd2d676SSascha Wildner if (aura_dict_exists(d, mountpoint, strlen(mountpoint) + 1)) { 405cdd2d676SSascha Wildner inform(a->c, _("The same mount point cannot be specified " 406cdd2d676SSascha Wildner "for two different subpartitions.")); 407cdd2d676SSascha Wildner valid = 0; 408cdd2d676SSascha Wildner } 409cdd2d676SSascha Wildner 410cdd2d676SSascha Wildner if (strcmp(mountpoint, "/") == 0) 411cdd2d676SSascha Wildner found_root = 1; 412cdd2d676SSascha Wildner 413cdd2d676SSascha Wildner if (strcmp(capstring, "*") == 0) { 414cdd2d676SSascha Wildner if (star_ds != NULL) { 415cdd2d676SSascha Wildner inform(a->c, _("You cannot have more than one subpartition " 416cdd2d676SSascha Wildner "with a '*' capacity (meaning 'use the remainder " 417cdd2d676SSascha Wildner "of the primary partition'.)")); 418cdd2d676SSascha Wildner valid = 0; 419cdd2d676SSascha Wildner } else { 420cdd2d676SSascha Wildner star_ds = ds; 421cdd2d676SSascha Wildner } 422cdd2d676SSascha Wildner } 423cdd2d676SSascha Wildner 424cdd2d676SSascha Wildner if (!(!strcasecmp(mountpoint, "swap") || mountpoint[0] == '/')) { 425cdd2d676SSascha Wildner inform(a->c, _("Mount point must be either 'swap', or it must " 426cdd2d676SSascha Wildner "start with a '/'.")); 427cdd2d676SSascha Wildner valid = 0; 428cdd2d676SSascha Wildner } 429cdd2d676SSascha Wildner 430cdd2d676SSascha Wildner if (strpbrk(mountpoint, " \\\"'`") != NULL) { 431cdd2d676SSascha Wildner inform(a->c, _("Mount point may not contain the following " 432cdd2d676SSascha Wildner "characters: blank space, backslash, or " 433cdd2d676SSascha Wildner "single, double, or back quotes.")); 434cdd2d676SSascha Wildner valid = 0; 435cdd2d676SSascha Wildner } 436cdd2d676SSascha Wildner 437cdd2d676SSascha Wildner if (strlen(capstring) == 0) { 438cdd2d676SSascha Wildner inform(a->c, _("A capacity must be specified.")); 439cdd2d676SSascha Wildner valid = 0; 440cdd2d676SSascha Wildner } 441cdd2d676SSascha Wildner 442cdd2d676SSascha Wildner if (!string_to_capacity(capstring, &capacity)) { 443cdd2d676SSascha Wildner inform(a->c, _("Capacity must be either a '*' symbol to indicate " 444cdd2d676SSascha Wildner "'use the rest of the primary partition', or it " 445cdd2d676SSascha Wildner "must be a series of decimal digits ending with a " 446cdd2d676SSascha Wildner "'M' (indicating megabytes) or a 'G' (indicating " 447cdd2d676SSascha Wildner "gigabytes.)")); 448cdd2d676SSascha Wildner valid = 0; 449cdd2d676SSascha Wildner } 450cdd2d676SSascha Wildner 451268b6264SMatthew Dillon /* 452268b6264SMatthew Dillon * Maybe remove this limit entirely? 453268b6264SMatthew Dillon */ 454268b6264SMatthew Dillon if ((strcasecmp(mountpoint, "swap") == 0) && 455*ef48e483SSascha Wildner (capacity > SWAP_MAX)) { 456*ef48e483SSascha Wildner inform(a->c, _("Swap capacity is limited to %dG."), 457*ef48e483SSascha Wildner SWAP_MAX / 1024); 458cdd2d676SSascha Wildner valid = 0; 459cdd2d676SSascha Wildner } 460cdd2d676SSascha Wildner 461cdd2d676SSascha Wildner /* 462cdd2d676SSascha Wildner * If we made it through that obstacle course, all is well. 463cdd2d676SSascha Wildner */ 464cdd2d676SSascha Wildner 465cdd2d676SSascha Wildner if (valid) 466cdd2d676SSascha Wildner aura_dict_store(d, mountpoint, strlen(mountpoint) + 1, "", 1); 467cdd2d676SSascha Wildner } 468cdd2d676SSascha Wildner 469cdd2d676SSascha Wildner if (!found_root) { 470cdd2d676SSascha Wildner inform(a->c, _("You must include a / (root) subpartition.")); 471cdd2d676SSascha Wildner valid = 0; 472cdd2d676SSascha Wildner } 473cdd2d676SSascha Wildner 474cdd2d676SSascha Wildner if (aura_dict_size(d) > 16) { 475cdd2d676SSascha Wildner inform(a->c, _("You cannot have more than 16 subpartitions " 476cdd2d676SSascha Wildner "on a single primary partition. Remove some " 477cdd2d676SSascha Wildner "and try again.")); 478cdd2d676SSascha Wildner valid = 0; 479cdd2d676SSascha Wildner } 480cdd2d676SSascha Wildner 481cdd2d676SSascha Wildner aura_dict_free(d); 482cdd2d676SSascha Wildner 483cdd2d676SSascha Wildner return(valid); 484cdd2d676SSascha Wildner } 485cdd2d676SSascha Wildner 486cdd2d676SSascha Wildner static void 487cdd2d676SSascha Wildner save_subpartition_selections(struct dfui_response *r, struct i_fn_args *a) 488cdd2d676SSascha Wildner { 489cdd2d676SSascha Wildner struct dfui_dataset *ds; 490761cad2fSSascha Wildner char tmpfsbacked; 491cdd2d676SSascha Wildner const char *mountpoint, *capstring; 492cdd2d676SSascha Wildner long capacity; 493cdd2d676SSascha Wildner long bsize, fsize; 494cdd2d676SSascha Wildner int softupdates; 495cdd2d676SSascha Wildner int valid = 1; 496cdd2d676SSascha Wildner 497cdd2d676SSascha Wildner subpartitions_free(storage_get_selected_slice(a->s)); 498cdd2d676SSascha Wildner 499cdd2d676SSascha Wildner for (ds = dfui_response_dataset_get_first(r); valid && ds != NULL; 500cdd2d676SSascha Wildner ds = dfui_dataset_get_next(ds)) { 501cdd2d676SSascha Wildner mountpoint = dfui_dataset_get_value(ds, "mountpoint"); 502cdd2d676SSascha Wildner capstring = dfui_dataset_get_value(ds, "capacity"); 503cdd2d676SSascha Wildner 504cdd2d676SSascha Wildner if (expert) { 505cdd2d676SSascha Wildner softupdates = 506cdd2d676SSascha Wildner (strcmp(dfui_dataset_get_value(ds, "softupdates"), "Y") == 0); 507cdd2d676SSascha Wildner fsize = atol(dfui_dataset_get_value(ds, "fsize")); 508cdd2d676SSascha Wildner bsize = atol(dfui_dataset_get_value(ds, "bsize")); 509761cad2fSSascha Wildner tmpfsbacked = (strcmp(dfui_dataset_get_value(ds, "tmpfsbacked"), "Y") == 0); 510cdd2d676SSascha Wildner } else { 511cdd2d676SSascha Wildner softupdates = (strcmp(mountpoint, "/") == 0 ? 0 : 1); 512761cad2fSSascha Wildner tmpfsbacked = 0; 513cdd2d676SSascha Wildner fsize = -1; 514cdd2d676SSascha Wildner bsize = -1; 515cdd2d676SSascha Wildner } 516cdd2d676SSascha Wildner 517cdd2d676SSascha Wildner if (string_to_capacity(capstring, &capacity)) { 51888cfb1f7SSascha Wildner subpartition_new_ufs(storage_get_selected_slice(a->s), 51988cfb1f7SSascha Wildner mountpoint, capacity, 52088cfb1f7SSascha Wildner strcasecmp(dfui_dataset_get_value(ds, "encrypted"), "Y") == 0, 521761cad2fSSascha Wildner softupdates, fsize, bsize, tmpfsbacked); 522cdd2d676SSascha Wildner } 523cdd2d676SSascha Wildner } 524cdd2d676SSascha Wildner } 525cdd2d676SSascha Wildner 526cdd2d676SSascha Wildner static void 527cdd2d676SSascha Wildner populate_create_subpartitions_form(struct dfui_form *f, struct i_fn_args *a) 528cdd2d676SSascha Wildner { 529cdd2d676SSascha Wildner struct subpartition *sp; 530cdd2d676SSascha Wildner struct dfui_dataset *ds; 531cdd2d676SSascha Wildner char temp[32]; 532cdd2d676SSascha Wildner int mtpt; 533cdd2d676SSascha Wildner long capacity; 534cdd2d676SSascha Wildner 535cdd2d676SSascha Wildner if (slice_subpartition_first(storage_get_selected_slice(a->s)) != NULL) { 536cdd2d676SSascha Wildner /* 537cdd2d676SSascha Wildner * The user has already given us their subpartition 538cdd2d676SSascha Wildner * preferences, so use them here. 539cdd2d676SSascha Wildner */ 540cdd2d676SSascha Wildner for (sp = slice_subpartition_first(storage_get_selected_slice(a->s)); 541cdd2d676SSascha Wildner sp != NULL; sp = subpartition_next(sp)) { 542cdd2d676SSascha Wildner ds = dfui_dataset_new(); 543cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "mountpoint", 544cdd2d676SSascha Wildner subpartition_get_mountpoint(sp)); 545cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "capacity", 546cdd2d676SSascha Wildner capacity_to_string(subpartition_get_capacity(sp))); 54788cfb1f7SSascha Wildner dfui_dataset_celldata_add(ds, "encrypted", 54888cfb1f7SSascha Wildner subpartition_is_encrypted(sp) ? "Y" : "N"); 549cdd2d676SSascha Wildner if (expert) { 550cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "softupdates", 551cdd2d676SSascha Wildner subpartition_is_softupdated(sp) ? "Y" : "N"); 552761cad2fSSascha Wildner dfui_dataset_celldata_add(ds, "tmpfsbacked", 553761cad2fSSascha Wildner subpartition_is_tmpfsbacked(sp) ? "Y" : "N"); 554cdd2d676SSascha Wildner snprintf(temp, 32, "%ld", subpartition_get_fsize(sp)); 555cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "fsize", 556cdd2d676SSascha Wildner temp); 557cdd2d676SSascha Wildner snprintf(temp, 32, "%ld", subpartition_get_bsize(sp)); 558cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "bsize", 559cdd2d676SSascha Wildner temp); 560cdd2d676SSascha Wildner } 561cdd2d676SSascha Wildner dfui_form_dataset_add(f, ds); 562cdd2d676SSascha Wildner } 563cdd2d676SSascha Wildner } else { 564cdd2d676SSascha Wildner /* 565cdd2d676SSascha Wildner * Otherwise, populate the form with datasets representing 566cdd2d676SSascha Wildner * reasonably-calculated defaults. The defaults are chosen 567cdd2d676SSascha Wildner * based on the slice's total capacity and the machine's 568cdd2d676SSascha Wildner * total physical memory (for swap.) 569cdd2d676SSascha Wildner */ 570cdd2d676SSascha Wildner for (mtpt = 0; def_mountpt[mtpt] != NULL; mtpt++) { 571cdd2d676SSascha Wildner capacity = default_capacity(a->s, mtpt); 572cdd2d676SSascha Wildner ds = dfui_dataset_new(); 573cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "mountpoint", 574cdd2d676SSascha Wildner def_mountpt[mtpt]); 575cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "capacity", 576cdd2d676SSascha Wildner capacity_to_string(capacity)); 57788cfb1f7SSascha Wildner dfui_dataset_celldata_add(ds, "encrypted", "N"); 578cdd2d676SSascha Wildner if (expert) { 579cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "softupdates", 580cdd2d676SSascha Wildner strcmp(def_mountpt[mtpt], "/") != 0 ? "Y" : "N"); 581761cad2fSSascha Wildner dfui_dataset_celldata_add(ds, "tmpfsbacked", 582cdd2d676SSascha Wildner "N"); 583cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "fsize", 584cdd2d676SSascha Wildner capacity < 1024 ? "1024" : "2048"); 585cdd2d676SSascha Wildner dfui_dataset_celldata_add(ds, "bsize", 586cdd2d676SSascha Wildner capacity < 1024 ? "8192" : "16384"); 587cdd2d676SSascha Wildner } 588cdd2d676SSascha Wildner dfui_form_dataset_add(f, ds); 589cdd2d676SSascha Wildner } 590cdd2d676SSascha Wildner } 591cdd2d676SSascha Wildner } 592cdd2d676SSascha Wildner 593cdd2d676SSascha Wildner static int 594cdd2d676SSascha Wildner warn_subpartition_selections(struct i_fn_args *a) 595cdd2d676SSascha Wildner { 596cdd2d676SSascha Wildner int valid = 0; 597cdd2d676SSascha Wildner struct aura_buffer *omit, *consequences; 598cdd2d676SSascha Wildner 599cdd2d676SSascha Wildner omit = aura_buffer_new(2048); 600cdd2d676SSascha Wildner consequences = aura_buffer_new(2048); 601cdd2d676SSascha Wildner 602cdd2d676SSascha Wildner valid = check_capacity(a); 603cdd2d676SSascha Wildner if (subpartition_find(storage_get_selected_slice(a->s), "/var") == NULL) { 604cdd2d676SSascha Wildner aura_buffer_cat(omit, "/var "); 605cdd2d676SSascha Wildner aura_buffer_cat(consequences, _("/var will be a plain dir in /\n")); 606cdd2d676SSascha Wildner } 607cdd2d676SSascha Wildner if (subpartition_find(storage_get_selected_slice(a->s), "/usr") == NULL) { 608cdd2d676SSascha Wildner aura_buffer_cat(omit, "/usr "); 609cdd2d676SSascha Wildner aura_buffer_cat(consequences, _("/usr will be a plain dir in /\n")); 610cdd2d676SSascha Wildner } 611cdd2d676SSascha Wildner if (subpartition_find(storage_get_selected_slice(a->s), "/tmp") == NULL) { 612cdd2d676SSascha Wildner aura_buffer_cat(omit, "/tmp "); 613cdd2d676SSascha Wildner aura_buffer_cat(consequences, _("/tmp will be symlinked to /var/tmp\n")); 614cdd2d676SSascha Wildner } 615cdd2d676SSascha Wildner if (subpartition_find(storage_get_selected_slice(a->s), "/home") == NULL) { 616cdd2d676SSascha Wildner aura_buffer_cat(omit, "/home "); 617cdd2d676SSascha Wildner aura_buffer_cat(consequences, _("/home will be symlinked to /usr/home\n")); 618cdd2d676SSascha Wildner } 619cdd2d676SSascha Wildner 620cdd2d676SSascha Wildner if (valid && aura_buffer_len(omit) > 0) { 621cdd2d676SSascha Wildner switch (dfui_be_present_dialog(a->c, _("Really omit?"), 622cdd2d676SSascha Wildner _("Omit Subpartition(s)|Return to Create Subpartitions"), 623cdd2d676SSascha Wildner _("You have elected to not have the following " 624cdd2d676SSascha Wildner "subpartition(s):\n\n%s\n\n" 625cdd2d676SSascha Wildner "The ramifications of these subpartition(s) being " 626cdd2d676SSascha Wildner "missing will be:\n\n%s\n" 627cdd2d676SSascha Wildner "Is this really what you want to do?"), 628cdd2d676SSascha Wildner aura_buffer_buf(omit), aura_buffer_buf(consequences))) { 629cdd2d676SSascha Wildner case 1: 630cdd2d676SSascha Wildner valid = 1; 631cdd2d676SSascha Wildner break; 632cdd2d676SSascha Wildner case 2: 633cdd2d676SSascha Wildner valid = 0; 634cdd2d676SSascha Wildner break; 635cdd2d676SSascha Wildner default: 636cdd2d676SSascha Wildner abort_backend(); 637cdd2d676SSascha Wildner } 638cdd2d676SSascha Wildner } 639cdd2d676SSascha Wildner 640cdd2d676SSascha Wildner aura_buffer_free(omit); 641cdd2d676SSascha Wildner aura_buffer_free(consequences); 642cdd2d676SSascha Wildner 643cdd2d676SSascha Wildner return(!valid); 644cdd2d676SSascha Wildner } 645cdd2d676SSascha Wildner 64688cfb1f7SSascha Wildner static int 64788cfb1f7SSascha Wildner warn_encrypted_root(struct i_fn_args *a) 64888cfb1f7SSascha Wildner { 64988cfb1f7SSascha Wildner int valid = 1; 65088cfb1f7SSascha Wildner struct subpartition *sp; 65188cfb1f7SSascha Wildner 65288cfb1f7SSascha Wildner sp = subpartition_find(storage_get_selected_slice(a->s), "/"); 65388cfb1f7SSascha Wildner if (sp == NULL) 65488cfb1f7SSascha Wildner return(!valid); 65588cfb1f7SSascha Wildner 65688cfb1f7SSascha Wildner if (subpartition_is_encrypted(sp)) { 65788cfb1f7SSascha Wildner switch (dfui_be_present_dialog(a->c, _("root cannot be encrypted"), 65888cfb1f7SSascha Wildner _("Leave root unencrypted|Return to Create Subpartitions"), 65988cfb1f7SSascha Wildner _("You have selected encryption for the root partition which " 66088cfb1f7SSascha Wildner "is not supported."))) { 66188cfb1f7SSascha Wildner case 1: 662b8d2998cSSascha Wildner subpartition_clr_encrypted(sp); 66388cfb1f7SSascha Wildner valid = 1; 66488cfb1f7SSascha Wildner break; 66588cfb1f7SSascha Wildner case 2: 66688cfb1f7SSascha Wildner valid = 0; 66788cfb1f7SSascha Wildner break; 66888cfb1f7SSascha Wildner default: 66988cfb1f7SSascha Wildner abort_backend(); 67088cfb1f7SSascha Wildner } 67188cfb1f7SSascha Wildner } 67288cfb1f7SSascha Wildner 67388cfb1f7SSascha Wildner return(!valid); 67488cfb1f7SSascha Wildner } 67588cfb1f7SSascha Wildner 676cdd2d676SSascha Wildner static struct dfui_form * 677cdd2d676SSascha Wildner make_create_subpartitions_form(struct i_fn_args *a) 678cdd2d676SSascha Wildner { 679cdd2d676SSascha Wildner struct dfui_field *fi; 680cdd2d676SSascha Wildner struct dfui_form *f; 681cdd2d676SSascha Wildner char msg_buf[1][1024]; 682cdd2d676SSascha Wildner 683cdd2d676SSascha Wildner snprintf(msg_buf[0], sizeof(msg_buf[0]), 684cdd2d676SSascha Wildner _("Subpartitions further divide a primary partition for " 685cdd2d676SSascha Wildner "use with %s. Some reasons you may want " 686cdd2d676SSascha Wildner "a set of subpartitions are:\n\n" 687cdd2d676SSascha Wildner "- you want to restrict how much data can be written " 688cdd2d676SSascha Wildner "to certain parts of the primary partition, to quell " 689cdd2d676SSascha Wildner "denial-of-service attacks; and\n" 690cdd2d676SSascha Wildner "- you want to speed up access to data on the disk." 691cdd2d676SSascha Wildner ""), OPERATING_SYSTEM_NAME); 692cdd2d676SSascha Wildner 693cdd2d676SSascha Wildner f = dfui_form_create( 694cdd2d676SSascha Wildner "create_subpartitions", 695cdd2d676SSascha Wildner _("Create Subpartitions"), 696cdd2d676SSascha Wildner _("Set up the subpartitions (also known as just `partitions' " 697cdd2d676SSascha Wildner "in BSD tradition) you want to have on this primary " 698cdd2d676SSascha Wildner "partition.\n\n" 699cdd2d676SSascha Wildner "For Capacity, use 'M' to indicate megabytes, 'G' to " 700cdd2d676SSascha Wildner "indicate gigabytes, or a single '*' to indicate " 701cdd2d676SSascha Wildner "'use the remaining space on the primary partition'."), 702cdd2d676SSascha Wildner 703cdd2d676SSascha Wildner msg_buf[0], 704cdd2d676SSascha Wildner 705cdd2d676SSascha Wildner "p", "special", "dfinstaller_create_subpartitions", 706cdd2d676SSascha Wildner "p", "minimum_width","64", 707cdd2d676SSascha Wildner 708cdd2d676SSascha Wildner "f", "mountpoint", _("Mountpoint"), "", "", 709cdd2d676SSascha Wildner "f", "capacity", _("Capacity"), "", "", 710cdd2d676SSascha Wildner 71188cfb1f7SSascha Wildner "f", "encrypted", _("Encrypted"), "", "", 71288cfb1f7SSascha Wildner "p", "control", "checkbox", 71388cfb1f7SSascha Wildner 714cdd2d676SSascha Wildner "a", "ok", _("Accept and Create"), "", "", 715cdd2d676SSascha Wildner "a", "cancel", 716cdd2d676SSascha Wildner (disk_get_formatted(storage_get_selected_disk(a->s)) ? 717cdd2d676SSascha Wildner _("Return to Select Disk") : 718cdd2d676SSascha Wildner _("Return to Select Primary Partition")), "", "", 719cdd2d676SSascha Wildner "p", "accelerator", "ESC", 720cdd2d676SSascha Wildner 721cdd2d676SSascha Wildner NULL 722cdd2d676SSascha Wildner ); 723cdd2d676SSascha Wildner 724cdd2d676SSascha Wildner dfui_form_set_multiple(f, 1); 725cdd2d676SSascha Wildner dfui_form_set_extensible(f, 1); 726cdd2d676SSascha Wildner 727cdd2d676SSascha Wildner if (expert) { 728cdd2d676SSascha Wildner fi = dfui_form_field_add(f, "softupdates", 729cdd2d676SSascha Wildner dfui_info_new(_("Softupdates"), "", "")); 730cdd2d676SSascha Wildner dfui_field_property_set(fi, "control", "checkbox"); 731cdd2d676SSascha Wildner 732761cad2fSSascha Wildner fi = dfui_form_field_add(f, "tmpfsbacked", 733761cad2fSSascha Wildner dfui_info_new(_("TMPFS"), "", "")); 734cdd2d676SSascha Wildner dfui_field_property_set(fi, "control", "checkbox"); 735cdd2d676SSascha Wildner 736cdd2d676SSascha Wildner fi = dfui_form_field_add(f, "fsize", 737cdd2d676SSascha Wildner dfui_info_new(_("Frag Sz"), "", "")); 738cdd2d676SSascha Wildner 739cdd2d676SSascha Wildner fi = dfui_form_field_add(f, "bsize", 740cdd2d676SSascha Wildner dfui_info_new(_("Block Sz"), "", "")); 741cdd2d676SSascha Wildner 742cdd2d676SSascha Wildner dfui_form_action_add(f, "switch", 743cdd2d676SSascha Wildner dfui_info_new(_("Switch to Normal Mode"), "", "")); 744cdd2d676SSascha Wildner } else { 745cdd2d676SSascha Wildner dfui_form_action_add(f, "switch", 746cdd2d676SSascha Wildner dfui_info_new(_("Switch to Expert Mode"), "", "")); 747cdd2d676SSascha Wildner } 748cdd2d676SSascha Wildner 749cdd2d676SSascha Wildner return(f); 750cdd2d676SSascha Wildner } 751cdd2d676SSascha Wildner 752cdd2d676SSascha Wildner /* 753cdd2d676SSascha Wildner * Returns: 754cdd2d676SSascha Wildner * -1 = the form should be redisplayed 755cdd2d676SSascha Wildner * 0 = failure, function is over 756cdd2d676SSascha Wildner * 1 = success, function is over 757cdd2d676SSascha Wildner */ 758cdd2d676SSascha Wildner static int 759cdd2d676SSascha Wildner show_create_subpartitions_form(struct dfui_form *f, struct i_fn_args *a) 760cdd2d676SSascha Wildner { 761cdd2d676SSascha Wildner struct dfui_dataset *ds; 762cdd2d676SSascha Wildner struct dfui_response *r; 763cdd2d676SSascha Wildner 764cdd2d676SSascha Wildner for (;;) { 765cdd2d676SSascha Wildner if (dfui_form_dataset_get_first(f) == NULL) 766cdd2d676SSascha Wildner populate_create_subpartitions_form(f, a); 767cdd2d676SSascha Wildner 768cdd2d676SSascha Wildner if (!dfui_be_present(a->c, f, &r)) 769cdd2d676SSascha Wildner abort_backend(); 770cdd2d676SSascha Wildner 771cdd2d676SSascha Wildner if (strcmp(dfui_response_get_action_id(r), "cancel") == 0) { 772cdd2d676SSascha Wildner dfui_response_free(r); 773cdd2d676SSascha Wildner return(0); 774cdd2d676SSascha Wildner } else if (strcmp(dfui_response_get_action_id(r), "switch") == 0) { 775cdd2d676SSascha Wildner if (check_subpartition_selections(r, a)) { 776cdd2d676SSascha Wildner save_subpartition_selections(r, a); 777cdd2d676SSascha Wildner expert = expert ? 0 : 1; 778cdd2d676SSascha Wildner dfui_response_free(r); 779cdd2d676SSascha Wildner return(-1); 780cdd2d676SSascha Wildner } 781cdd2d676SSascha Wildner } else { 782cdd2d676SSascha Wildner if (check_subpartition_selections(r, a)) { 783cdd2d676SSascha Wildner save_subpartition_selections(r, a); 78488cfb1f7SSascha Wildner if (!warn_subpartition_selections(a) && 78588cfb1f7SSascha Wildner !warn_encrypted_root(a)) { 786cdd2d676SSascha Wildner if (!create_subpartitions(a)) { 787cdd2d676SSascha Wildner inform(a->c, _("The subpartitions you chose were " 788cdd2d676SSascha Wildner "not correctly created, and the " 789cdd2d676SSascha Wildner "primary partition may " 790cdd2d676SSascha Wildner "now be in an inconsistent state. " 791cdd2d676SSascha Wildner "We recommend re-formatting it " 792cdd2d676SSascha Wildner "before proceeding.")); 793cdd2d676SSascha Wildner dfui_response_free(r); 794cdd2d676SSascha Wildner return(0); 795cdd2d676SSascha Wildner } else { 796cdd2d676SSascha Wildner dfui_response_free(r); 797cdd2d676SSascha Wildner return(1); 798cdd2d676SSascha Wildner } 799cdd2d676SSascha Wildner } 800cdd2d676SSascha Wildner } 801cdd2d676SSascha Wildner } 802cdd2d676SSascha Wildner 803cdd2d676SSascha Wildner dfui_form_datasets_free(f); 804cdd2d676SSascha Wildner /* dfui_form_datasets_add_from_response(f, r); */ 805cdd2d676SSascha Wildner for (ds = dfui_response_dataset_get_first(r); ds != NULL; 806cdd2d676SSascha Wildner ds = dfui_dataset_get_next(ds)) { 807cdd2d676SSascha Wildner dfui_form_dataset_add(f, dfui_dataset_dup(ds)); 808cdd2d676SSascha Wildner } 809cdd2d676SSascha Wildner } 810cdd2d676SSascha Wildner } 811cdd2d676SSascha Wildner 812cdd2d676SSascha Wildner void 813cdd2d676SSascha Wildner fn_create_subpartitions_ufs(struct i_fn_args *a) 814cdd2d676SSascha Wildner { 815cdd2d676SSascha Wildner struct dfui_form *f; 816cdd2d676SSascha Wildner int done = 0; 817cdd2d676SSascha Wildner 818cdd2d676SSascha Wildner a->result = 0; 819cdd2d676SSascha Wildner while (!done) { 820cdd2d676SSascha Wildner f = make_create_subpartitions_form(a); 821cdd2d676SSascha Wildner switch (show_create_subpartitions_form(f, a)) { 822cdd2d676SSascha Wildner case -1: 823cdd2d676SSascha Wildner done = 0; 824cdd2d676SSascha Wildner break; 825cdd2d676SSascha Wildner case 0: 826cdd2d676SSascha Wildner done = 1; 827cdd2d676SSascha Wildner a->result = 0; 828cdd2d676SSascha Wildner break; 829cdd2d676SSascha Wildner case 1: 830cdd2d676SSascha Wildner done = 1; 831cdd2d676SSascha Wildner a->result = 1; 832cdd2d676SSascha Wildner break; 833cdd2d676SSascha Wildner } 834cdd2d676SSascha Wildner dfui_form_free(f); 835cdd2d676SSascha Wildner } 836cdd2d676SSascha Wildner } 837