1 /* 2 * Copyright (c)2004 The DragonFly Project. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 8 * Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 11 * Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in 13 * the documentation and/or other materials provided with the 14 * distribution. 15 * 16 * Neither the name of the DragonFly Project nor the names of its 17 * contributors may be used to endorse or promote products derived 18 * from this software without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 24 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 25 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 26 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 27 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 29 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 31 * OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 /* 35 * fn_subpart.c 36 * Installer Function : Create Subpartitions. 37 * $Id: fn_subpart.c,v 1.50 2005/04/07 20:22:40 cpressey Exp $ 38 */ 39 40 #include <stdio.h> 41 #include <stdlib.h> 42 #include <string.h> 43 44 #ifdef ENABLE_NLS 45 #include <libintl.h> 46 #define _(String) gettext (String) 47 #else 48 #define _(String) (String) 49 #endif 50 51 #include "libaura/mem.h" 52 #include "libaura/buffer.h" 53 #include "libaura/dict.h" 54 #include "libaura/fspred.h" 55 56 #include "libdfui/dfui.h" 57 #include "libdfui/dump.h" 58 #include "libdfui/system.h" 59 60 #include "libinstaller/commands.h" 61 #include "libinstaller/diskutil.h" 62 #include "libinstaller/functions.h" 63 #include "libinstaller/uiutil.h" 64 65 #include "fn.h" 66 #include "flow.h" 67 #include "pathnames.h" 68 69 static int create_subpartitions(struct i_fn_args *); 70 static long default_capacity(struct storage *, int); 71 static int check_capacity(struct i_fn_args *); 72 static int check_subpartition_selections(struct dfui_response *, struct i_fn_args *); 73 static void save_subpartition_selections(struct dfui_response *, struct i_fn_args *); 74 static void populate_create_subpartitions_form(struct dfui_form *, struct i_fn_args *); 75 static int warn_subpartition_selections(struct i_fn_args *); 76 static struct dfui_form *make_create_subpartitions_form(struct i_fn_args *); 77 static int show_create_subpartitions_form(struct dfui_form *, struct i_fn_args *); 78 79 static const char *def_mountpt[] = {"/", "swap", "/var", "/tmp", "/usr", "/home", NULL}; 80 static int expert = 0; 81 82 /* 83 * Given a set of subpartitions-to-be in the selected slice, 84 * create them. 85 */ 86 static int 87 create_subpartitions(struct i_fn_args *a) 88 { 89 struct subpartition *sp; 90 struct commands *cmds; 91 int result = 0; 92 int num_partitions; 93 94 cmds = commands_new(); 95 if (!is_file("%sinstall.disklabel.%s", 96 a->tmp, 97 slice_get_device_name(storage_get_selected_slice(a->s)))) { 98 /* 99 * Get a copy of the 'virgin' disklabel. 100 * XXX It might make more sense for this to 101 * happen right after format_slice() instead. 102 */ 103 command_add(cmds, "%s%s -r %s >%sinstall.disklabel.%s", 104 a->os_root, cmd_name(a, "DISKLABEL64"), 105 slice_get_device_name(storage_get_selected_slice(a->s)), 106 a->tmp, 107 slice_get_device_name(storage_get_selected_slice(a->s))); 108 } 109 110 /* 111 * Weave together a new disklabel out the of the 'virgin' 112 * disklabel, and the user's subpartition choices. 113 */ 114 115 /* 116 * Take everything from the 'virgin' disklabel up until the 117 * '16 partitions' line. 118 */ 119 num_partitions = 16; 120 command_add(cmds, "%s%s '$2==\"partitions:\" || cut { cut = 1 } !cut { print $0 }' <%sinstall.disklabel.%s >%sinstall.disklabel", 121 a->os_root, cmd_name(a, "AWK"), 122 a->tmp, 123 slice_get_device_name(storage_get_selected_slice(a->s)), 124 a->tmp); 125 126 /* 127 * 16 partitions: 128 * # size offset fstype 129 * c: 16383969 0 unused # 7999.985MB 130 */ 131 132 command_add(cmds, "%s%s '%d partitions:' >>%sinstall.disklabel", 133 a->os_root, cmd_name(a, "ECHO"), num_partitions ,a->tmp); 134 command_add(cmds, "%s%s '%s' >>%sinstall.disklabel", 135 a->os_root, cmd_name(a, "ECHO"), 136 "# size offset fstype", 137 a->tmp); 138 139 #ifdef DEBUG 140 for (sp = slice_subpartition_first(storage_get_selected_slice(a->s)); 141 sp != NULL; sp = subpartition_next(sp)) { 142 command_add(cmds, "%s%s 'mountpoint: %s device: %s'", 143 a->os_root, cmd_name(a, "ECHO"), 144 subpartition_get_mountpoint(sp), 145 subpartition_get_device_name(sp)); 146 } 147 #endif 148 149 /* 150 * Write a line for each subpartition the user wants. 151 */ 152 for (sp = slice_subpartition_first(storage_get_selected_slice(a->s)); 153 sp != NULL; sp = subpartition_next(sp)) { 154 if (subpartition_is_mfsbacked(sp)) { 155 continue; 156 } 157 if (subpartition_is_swap(sp)) { 158 command_add(cmds, "%s%s ' %c:\t%s\t*\tswap' >>%sinstall.disklabel", 159 a->os_root, cmd_name(a, "ECHO"), 160 subpartition_get_letter(sp), 161 capacity_to_string(subpartition_get_capacity(sp)), 162 a->tmp); 163 } else { 164 command_add(cmds, "%s%s ' %c:\t%s\t%s\t4.2BSD' >>%sinstall.disklabel", 165 a->os_root, cmd_name(a, "ECHO"), 166 subpartition_get_letter(sp), 167 capacity_to_string(subpartition_get_capacity(sp)), 168 subpartition_get_letter(sp) == 'a' ? "0" : "*", 169 a->tmp); 170 } 171 } 172 temp_file_add(a, "install.disklabel"); 173 174 /* 175 * Label the slice from the disklabel we just wove together. 176 */ 177 command_add(cmds, "%s%s -R -B -r %s %sinstall.disklabel", 178 a->os_root, cmd_name(a, "DISKLABEL64"), 179 slice_get_device_name(storage_get_selected_slice(a->s)), 180 a->tmp); 181 182 /* 183 * Create a snapshot of the disklabel we just created 184 * for debugging inspection in the log. 185 */ 186 command_add(cmds, "%s%s %s", 187 a->os_root, cmd_name(a, "DISKLABEL64"), 188 slice_get_device_name(storage_get_selected_slice(a->s))); 189 190 /* 191 * Create filesystems on the newly-created subpartitions. 192 */ 193 for (sp = slice_subpartition_first(storage_get_selected_slice(a->s)); 194 sp != NULL; sp = subpartition_next(sp)) { 195 if (subpartition_is_swap(sp) || subpartition_is_mfsbacked(sp)) 196 continue; 197 198 command_add(cmds, "%s%s%s -b %ld -f %ld %sdev/%s", 199 a->os_root, cmd_name(a, "NEWFS"), 200 subpartition_is_softupdated(sp) ? " -U" : "", 201 subpartition_get_bsize(sp), 202 subpartition_get_fsize(sp), 203 a->os_root, 204 subpartition_get_device_name(sp)); 205 } 206 207 result = commands_execute(a, cmds); 208 commands_free(cmds); 209 return(result); 210 } 211 212 static long 213 default_capacity(struct storage *s, int mtpt) 214 { 215 unsigned long swap; 216 unsigned long capacity; 217 unsigned long mem; 218 219 if (mtpt == MTPT_HOME) 220 return(-1); 221 222 capacity = slice_get_capacity(storage_get_selected_slice(s)); 223 mem = storage_get_memsize(s); 224 swap = 2 * mem; 225 if (mem > (capacity / 2) || capacity < 4096) 226 swap = mem; 227 if (mem > capacity) 228 swap = capacity / 2; 229 if (swap > 8192) 230 swap = 8192; 231 232 if (capacity < DISK_MIN) { 233 /* 234 * For the purposes of this installer: 235 * can't be done. Sorry. 236 */ 237 return(-1); 238 } else if (capacity < 4096) { 239 switch (mtpt) { 240 case MTPT_ROOT: return(256); 241 case MTPT_SWAP: return(swap); 242 case MTPT_VAR: return(128); 243 case MTPT_TMP: return(128); 244 case MTPT_USR: return(1536); 245 } 246 } else if (capacity < 10240) { 247 switch (mtpt) { 248 case MTPT_ROOT: return(256); 249 case MTPT_SWAP: return(swap); 250 case MTPT_VAR: return(256); 251 case MTPT_TMP: return(256); 252 case MTPT_USR: return(3072); 253 } 254 } else { 255 switch (mtpt) { 256 case MTPT_ROOT: return(256); 257 case MTPT_SWAP: return(swap); 258 case MTPT_VAR: return(256); 259 case MTPT_TMP: return(256); 260 case MTPT_USR: return(8192); 261 } 262 } 263 /* shouldn't ever happen */ 264 return(-1); 265 } 266 267 static int 268 check_capacity(struct i_fn_args *a) 269 { 270 struct subpartition *sp; 271 unsigned long min_capacity[] = {256, 0, 16, 0, 1536, 0, 0}; 272 unsigned long total_capacity = 0; 273 int mtpt; 274 275 if (subpartition_find(storage_get_selected_slice(a->s), "/usr") == NULL) 276 min_capacity[MTPT_ROOT] += min_capacity[MTPT_USR]; 277 278 for (sp = slice_subpartition_first(storage_get_selected_slice(a->s)); 279 sp != NULL; sp = subpartition_next(sp)) { 280 if (subpartition_get_capacity(sp) == -1) 281 total_capacity++; 282 else 283 total_capacity += subpartition_get_capacity(sp); 284 for (mtpt = 0; def_mountpt[mtpt] != NULL; mtpt++) { 285 if (strcmp(subpartition_get_mountpoint(sp), def_mountpt[mtpt]) == 0 && 286 min_capacity[mtpt] > 0 && 287 subpartition_get_capacity(sp) < min_capacity[mtpt]) { 288 inform(a->c, _("WARNING: the %s subpartition should " 289 "be at least %dM in size or you will " 290 "risk running out of space during " 291 "the installation."), 292 subpartition_get_mountpoint(sp), min_capacity[mtpt]); 293 } 294 } 295 } 296 297 if (total_capacity > slice_get_capacity(storage_get_selected_slice(a->s))) { 298 inform(a->c, _("The space allocated to all of your selected " 299 "subpartitions (%dM) exceeds the total " 300 "capacity of the selected primary partition " 301 "(%dM). Remove some subpartitions or choose " 302 "a smaller size for them and try again."), 303 total_capacity, slice_get_capacity(storage_get_selected_slice(a->s))); 304 return(0); 305 } 306 307 return(1); 308 } 309 310 static int 311 check_subpartition_selections(struct dfui_response *r, struct i_fn_args *a) 312 { 313 struct dfui_dataset *ds; 314 struct dfui_dataset *star_ds = NULL; 315 struct aura_dict *d; 316 const char *mountpoint, *capstring; 317 long capacity = 0; 318 long bsize, fsize; 319 int found_root = 0; 320 int softupdates, mfsbacked; 321 int valid = 1; 322 323 d = aura_dict_new(1, AURA_DICT_LIST); 324 325 if ((ds = dfui_response_dataset_get_first(r)) == NULL) { 326 inform(a->c, _("Please set up at least one subpartition.")); 327 valid = 0; 328 } 329 330 for (ds = dfui_response_dataset_get_first(r); valid && ds != NULL; 331 ds = dfui_dataset_get_next(ds)) { 332 #ifdef DEBUG 333 dfui_dataset_dump(ds); 334 #endif 335 mountpoint = dfui_dataset_get_value(ds, "mountpoint"); 336 capstring = dfui_dataset_get_value(ds, "capacity"); 337 338 if (expert) { 339 softupdates = 340 (strcmp(dfui_dataset_get_value(ds, "softupdates"), "Y") == 0); 341 fsize = atol(dfui_dataset_get_value(ds, "fsize")); 342 bsize = atol(dfui_dataset_get_value(ds, "bsize")); 343 mfsbacked = (strcmp(dfui_dataset_get_value(ds, "mfsbacked"), "Y") == 0); 344 } else { 345 softupdates = (strcmp(mountpoint, "/") == 0 ? 0 : 1); 346 mfsbacked = (strcmp(mountpoint, "/tmp") == 0 ? 0 : 1); 347 fsize = -1; 348 bsize = -1; 349 } 350 351 if (aura_dict_exists(d, mountpoint, strlen(mountpoint) + 1)) { 352 inform(a->c, _("The same mount point cannot be specified " 353 "for two different subpartitions.")); 354 valid = 0; 355 } 356 357 if (strcmp(mountpoint, "/") == 0) 358 found_root = 1; 359 360 if (strcmp(capstring, "*") == 0) { 361 if (star_ds != NULL) { 362 inform(a->c, _("You cannot have more than one subpartition " 363 "with a '*' capacity (meaning 'use the remainder " 364 "of the primary partition'.)")); 365 valid = 0; 366 } else { 367 star_ds = ds; 368 } 369 } 370 371 if (!(!strcasecmp(mountpoint, "swap") || mountpoint[0] == '/')) { 372 inform(a->c, _("Mount point must be either 'swap', or it must " 373 "start with a '/'.")); 374 valid = 0; 375 } 376 377 if (strpbrk(mountpoint, " \\\"'`") != NULL) { 378 inform(a->c, _("Mount point may not contain the following " 379 "characters: blank space, backslash, or " 380 "single, double, or back quotes.")); 381 valid = 0; 382 } 383 384 if (strlen(capstring) == 0) { 385 inform(a->c, _("A capacity must be specified.")); 386 valid = 0; 387 } 388 389 if (!string_to_capacity(capstring, &capacity)) { 390 inform(a->c, _("Capacity must be either a '*' symbol to indicate " 391 "'use the rest of the primary partition', or it " 392 "must be a series of decimal digits ending with a " 393 "'M' (indicating megabytes) or a 'G' (indicating " 394 "gigabytes.)")); 395 valid = 0; 396 } 397 398 if ((strcasecmp(mountpoint, "swap") == 0) && (capacity > 8192)) { 399 inform(a->c, _("Swap capacity is limited to 8G.")); 400 valid = 0; 401 } 402 403 /* 404 * If we made it through that obstacle course, all is well. 405 */ 406 407 if (valid) 408 aura_dict_store(d, mountpoint, strlen(mountpoint) + 1, "", 1); 409 } 410 411 if (!found_root) { 412 inform(a->c, _("You must include a / (root) subpartition.")); 413 valid = 0; 414 } 415 416 if (aura_dict_size(d) > 16) { 417 inform(a->c, _("You cannot have more than 16 subpartitions " 418 "on a single primary partition. Remove some " 419 "and try again.")); 420 valid = 0; 421 } 422 423 aura_dict_free(d); 424 425 return(valid); 426 } 427 428 static void 429 save_subpartition_selections(struct dfui_response *r, struct i_fn_args *a) 430 { 431 struct dfui_dataset *ds; 432 char mfsbacked; 433 const char *mountpoint, *capstring; 434 long capacity; 435 long bsize, fsize; 436 int softupdates; 437 int valid = 1; 438 439 subpartitions_free(storage_get_selected_slice(a->s)); 440 441 for (ds = dfui_response_dataset_get_first(r); valid && ds != NULL; 442 ds = dfui_dataset_get_next(ds)) { 443 mountpoint = dfui_dataset_get_value(ds, "mountpoint"); 444 capstring = dfui_dataset_get_value(ds, "capacity"); 445 446 if (expert) { 447 softupdates = 448 (strcmp(dfui_dataset_get_value(ds, "softupdates"), "Y") == 0); 449 fsize = atol(dfui_dataset_get_value(ds, "fsize")); 450 bsize = atol(dfui_dataset_get_value(ds, "bsize")); 451 mfsbacked = (strcmp(dfui_dataset_get_value(ds, "mfsbacked"), "Y") == 0); 452 } else { 453 softupdates = (strcmp(mountpoint, "/") == 0 ? 0 : 1); 454 mfsbacked = 0; 455 fsize = -1; 456 bsize = -1; 457 } 458 459 if (string_to_capacity(capstring, &capacity)) { 460 subpartition_new(storage_get_selected_slice(a->s), mountpoint, capacity, 461 softupdates, fsize, bsize, mfsbacked); 462 } 463 } 464 } 465 466 static void 467 populate_create_subpartitions_form(struct dfui_form *f, struct i_fn_args *a) 468 { 469 struct subpartition *sp; 470 struct dfui_dataset *ds; 471 char temp[32]; 472 int mtpt; 473 long capacity; 474 475 if (slice_subpartition_first(storage_get_selected_slice(a->s)) != NULL) { 476 /* 477 * The user has already given us their subpartition 478 * preferences, so use them here. 479 */ 480 for (sp = slice_subpartition_first(storage_get_selected_slice(a->s)); 481 sp != NULL; sp = subpartition_next(sp)) { 482 ds = dfui_dataset_new(); 483 dfui_dataset_celldata_add(ds, "mountpoint", 484 subpartition_get_mountpoint(sp)); 485 dfui_dataset_celldata_add(ds, "capacity", 486 capacity_to_string(subpartition_get_capacity(sp))); 487 if (expert) { 488 dfui_dataset_celldata_add(ds, "softupdates", 489 subpartition_is_softupdated(sp) ? "Y" : "N"); 490 dfui_dataset_celldata_add(ds, "mfsbacked", 491 subpartition_is_mfsbacked(sp) ? "Y" : "N"); 492 snprintf(temp, 32, "%ld", subpartition_get_fsize(sp)); 493 dfui_dataset_celldata_add(ds, "fsize", 494 temp); 495 snprintf(temp, 32, "%ld", subpartition_get_bsize(sp)); 496 dfui_dataset_celldata_add(ds, "bsize", 497 temp); 498 } 499 dfui_form_dataset_add(f, ds); 500 } 501 } else { 502 /* 503 * Otherwise, populate the form with datasets representing 504 * reasonably-calculated defaults. The defaults are chosen 505 * based on the slice's total capacity and the machine's 506 * total physical memory (for swap.) 507 */ 508 for (mtpt = 0; def_mountpt[mtpt] != NULL; mtpt++) { 509 capacity = default_capacity(a->s, mtpt); 510 ds = dfui_dataset_new(); 511 dfui_dataset_celldata_add(ds, "mountpoint", 512 def_mountpt[mtpt]); 513 dfui_dataset_celldata_add(ds, "capacity", 514 capacity_to_string(capacity)); 515 if (expert) { 516 dfui_dataset_celldata_add(ds, "softupdates", 517 strcmp(def_mountpt[mtpt], "/") != 0 ? "Y" : "N"); 518 dfui_dataset_celldata_add(ds, "mfsbacked", 519 "N"); 520 dfui_dataset_celldata_add(ds, "fsize", 521 capacity < 1024 ? "1024" : "2048"); 522 dfui_dataset_celldata_add(ds, "bsize", 523 capacity < 1024 ? "8192" : "16384"); 524 } 525 dfui_form_dataset_add(f, ds); 526 } 527 } 528 } 529 530 static int 531 warn_subpartition_selections(struct i_fn_args *a) 532 { 533 int valid = 0; 534 struct aura_buffer *omit, *consequences; 535 536 omit = aura_buffer_new(2048); 537 consequences = aura_buffer_new(2048); 538 539 valid = check_capacity(a); 540 if (subpartition_find(storage_get_selected_slice(a->s), "/var") == NULL) { 541 aura_buffer_cat(omit, "/var "); 542 aura_buffer_cat(consequences, _("/var will be a plain dir in /\n")); 543 } 544 if (subpartition_find(storage_get_selected_slice(a->s), "/usr") == NULL) { 545 aura_buffer_cat(omit, "/usr "); 546 aura_buffer_cat(consequences, _("/usr will be a plain dir in /\n")); 547 } 548 if (subpartition_find(storage_get_selected_slice(a->s), "/tmp") == NULL) { 549 aura_buffer_cat(omit, "/tmp "); 550 aura_buffer_cat(consequences, _("/tmp will be symlinked to /var/tmp\n")); 551 } 552 if (subpartition_find(storage_get_selected_slice(a->s), "/home") == NULL) { 553 aura_buffer_cat(omit, "/home "); 554 aura_buffer_cat(consequences, _("/home will be symlinked to /usr/home\n")); 555 } 556 557 if (valid && aura_buffer_len(omit) > 0) { 558 switch (dfui_be_present_dialog(a->c, _("Really omit?"), 559 _("Omit Subpartition(s)|Return to Create Subpartitions"), 560 _("You have elected to not have the following " 561 "subpartition(s):\n\n%s\n\n" 562 "The ramifications of these subpartition(s) being " 563 "missing will be:\n\n%s\n" 564 "Is this really what you want to do?"), 565 aura_buffer_buf(omit), aura_buffer_buf(consequences))) { 566 case 1: 567 valid = 1; 568 break; 569 case 2: 570 valid = 0; 571 break; 572 default: 573 abort_backend(); 574 } 575 } 576 577 aura_buffer_free(omit); 578 aura_buffer_free(consequences); 579 580 return(!valid); 581 } 582 583 static struct dfui_form * 584 make_create_subpartitions_form(struct i_fn_args *a) 585 { 586 struct dfui_field *fi; 587 struct dfui_form *f; 588 char msg_buf[1][1024]; 589 590 snprintf(msg_buf[0], sizeof(msg_buf[0]), 591 _("Subpartitions further divide a primary partition for " 592 "use with %s. Some reasons you may want " 593 "a set of subpartitions are:\n\n" 594 "- you want to restrict how much data can be written " 595 "to certain parts of the primary partition, to quell " 596 "denial-of-service attacks; and\n" 597 "- you want to speed up access to data on the disk." 598 ""), OPERATING_SYSTEM_NAME); 599 600 f = dfui_form_create( 601 "create_subpartitions", 602 _("Create Subpartitions"), 603 _("Set up the subpartitions (also known as just `partitions' " 604 "in BSD tradition) you want to have on this primary " 605 "partition.\n\n" 606 "For Capacity, use 'M' to indicate megabytes, 'G' to " 607 "indicate gigabytes, or a single '*' to indicate " 608 "'use the remaining space on the primary partition'."), 609 610 msg_buf[0], 611 612 "p", "special", "dfinstaller_create_subpartitions", 613 "p", "minimum_width","64", 614 615 "f", "mountpoint", _("Mountpoint"), "", "", 616 "f", "capacity", _("Capacity"), "", "", 617 618 "a", "ok", _("Accept and Create"), "", "", 619 "a", "cancel", 620 (disk_get_formatted(storage_get_selected_disk(a->s)) ? 621 _("Return to Select Disk") : 622 _("Return to Select Primary Partition")), "", "", 623 "p", "accelerator", "ESC", 624 625 NULL 626 ); 627 628 dfui_form_set_multiple(f, 1); 629 dfui_form_set_extensible(f, 1); 630 631 if (expert) { 632 fi = dfui_form_field_add(f, "softupdates", 633 dfui_info_new(_("Softupdates"), "", "")); 634 dfui_field_property_set(fi, "control", "checkbox"); 635 636 fi = dfui_form_field_add(f, "mfsbacked", 637 dfui_info_new(_("MFS"), "", "")); 638 dfui_field_property_set(fi, "control", "checkbox"); 639 640 fi = dfui_form_field_add(f, "fsize", 641 dfui_info_new(_("Frag Sz"), "", "")); 642 643 fi = dfui_form_field_add(f, "bsize", 644 dfui_info_new(_("Block Sz"), "", "")); 645 646 dfui_form_action_add(f, "switch", 647 dfui_info_new(_("Switch to Normal Mode"), "", "")); 648 } else { 649 dfui_form_action_add(f, "switch", 650 dfui_info_new(_("Switch to Expert Mode"), "", "")); 651 } 652 653 return(f); 654 } 655 656 /* 657 * Returns: 658 * -1 = the form should be redisplayed 659 * 0 = failure, function is over 660 * 1 = success, function is over 661 */ 662 static int 663 show_create_subpartitions_form(struct dfui_form *f, struct i_fn_args *a) 664 { 665 struct dfui_dataset *ds; 666 struct dfui_response *r; 667 668 for (;;) { 669 if (dfui_form_dataset_get_first(f) == NULL) 670 populate_create_subpartitions_form(f, a); 671 672 if (!dfui_be_present(a->c, f, &r)) 673 abort_backend(); 674 675 if (strcmp(dfui_response_get_action_id(r), "cancel") == 0) { 676 dfui_response_free(r); 677 return(0); 678 } else if (strcmp(dfui_response_get_action_id(r), "switch") == 0) { 679 if (check_subpartition_selections(r, a)) { 680 save_subpartition_selections(r, a); 681 expert = expert ? 0 : 1; 682 dfui_response_free(r); 683 return(-1); 684 } 685 } else { 686 if (check_subpartition_selections(r, a)) { 687 save_subpartition_selections(r, a); 688 if (!warn_subpartition_selections(a)) { 689 if (!create_subpartitions(a)) { 690 inform(a->c, _("The subpartitions you chose were " 691 "not correctly created, and the " 692 "primary partition may " 693 "now be in an inconsistent state. " 694 "We recommend re-formatting it " 695 "before proceeding.")); 696 dfui_response_free(r); 697 return(0); 698 } else { 699 dfui_response_free(r); 700 return(1); 701 } 702 } 703 } 704 } 705 706 dfui_form_datasets_free(f); 707 /* dfui_form_datasets_add_from_response(f, r); */ 708 for (ds = dfui_response_dataset_get_first(r); ds != NULL; 709 ds = dfui_dataset_get_next(ds)) { 710 dfui_form_dataset_add(f, dfui_dataset_dup(ds)); 711 } 712 } 713 } 714 715 void 716 fn_create_subpartitions_ufs(struct i_fn_args *a) 717 { 718 struct dfui_form *f; 719 int done = 0; 720 721 a->result = 0; 722 while (!done) { 723 f = make_create_subpartitions_form(a); 724 switch (show_create_subpartitions_form(f, a)) { 725 case -1: 726 done = 0; 727 break; 728 case 0: 729 done = 1; 730 a->result = 0; 731 break; 732 case 1: 733 done = 1; 734 a->result = 1; 735 break; 736 } 737 dfui_form_free(f); 738 } 739 } 740