1 /* $NetBSD: partman.c,v 1.18 2018/02/04 09:01:13 mrg Exp $ */ 2 3 /* 4 * Copyright 2012 Eugene Lozovoy 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. The name of Eugene Lozovoy may not be used to endorse 16 * or promote products derived from this software without specific prior 17 * written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY PIERMONT INFORMATION SYSTEMS INC. ``AS IS'' 20 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL PIERMONT INFORMATION SYSTEMS INC. BE 23 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 29 * THE POSSIBILITY OF SUCH DAMAGE. 30 * 31 */ 32 33 /* partman.c - extended partitioning */ 34 35 #include <fcntl.h> 36 #include <errno.h> 37 #include <libgen.h> 38 #include <stdio.h> 39 #include <stdlib.h> 40 #include <unistd.h> 41 #include <util.h> 42 43 #include "defs.h" 44 #include "msg_defs.h" 45 #include "menu_defs.h" 46 47 /* flags whether to offer the respective options (depending on helper 48 programs available on install media */ 49 int have_raid, have_vnd, have_cgd, have_lvm, have_gpt, have_dk; 50 51 /* XXX: replace all MAX_* defines with vars that depend on kernel settings */ 52 #define MAX_ENTRIES 96 53 54 #define MAX_RAID 8 55 #define MAX_IN_RAID 48 56 typedef struct raids_t { 57 int enabled; 58 int blocked; 59 int node; 60 char pm_name[MAX_IN_RAID][SSTRSIZE]; 61 int pm_part[MAX_IN_RAID]; 62 int pm_is_spare[MAX_IN_RAID]; 63 int numRow, numCol, numSpare; 64 int sectPerSU, SUsPerParityUnit, SUsPerReconUnit, raid_level; 65 uint total_size; 66 pm_devs_t *pm[MAX_IN_RAID]; 67 } raids_t; 68 raids_t *raids; 69 70 #define MAX_VND 4 71 typedef struct vnds_t { 72 int enabled; 73 int blocked; 74 int node; 75 char filepath[STRSIZE]; 76 int size; 77 int readonly; 78 int is_exist; 79 int manual_geom; 80 int secsize, nsectors, ntracks, ncylinders; 81 int pm_part; /* Used only for */ 82 pm_devs_t *pm; /* referring device */ 83 } vnds_t; 84 vnds_t *vnds; 85 86 #define MAX_CGD 4 87 typedef struct cgds_t { 88 int enabled; 89 int blocked; 90 int node; 91 pm_devs_t *pm; 92 char pm_name[SSTRSIZE]; 93 int pm_part; 94 const char *keygen_type; 95 const char *verify_type; 96 const char *enc_type; 97 const char *iv_type; 98 int key_size; 99 } cgds_t; 100 cgds_t *cgds; 101 102 #define MAX_LVM_VG 16 103 #define MAX_LVM_PV 255 104 #define MAX_LVM_LV 255 105 typedef struct pv_t { 106 pm_devs_t *pm; 107 char pm_name[SSTRSIZE]; 108 int pm_part; 109 int metadatasize; 110 int metadatacopies; 111 int labelsector; 112 int setphysicalvolumesize; 113 } pv_t; 114 typedef struct lv_t { 115 int blocked; 116 int size; 117 char name[SSTRSIZE]; 118 int readonly; 119 int contiguous; 120 char extents[SSTRSIZE]; 121 int minor; 122 int mirrors; 123 int regionsize; 124 int persistent; 125 int readahead; 126 int stripes; 127 int stripesize; 128 int zero; 129 } lv_t; 130 typedef struct lvms_t { 131 int enabled; 132 int blocked; 133 char name[SSTRSIZE]; 134 int maxlogicalvolumes; 135 int maxphysicalvolumes; 136 int physicalextentsize; 137 uint total_size; 138 pv_t pv[MAX_LVM_PV]; 139 lv_t lv[MAX_LVM_LV]; 140 } lvms_t; 141 lvms_t *lvms; 142 143 typedef struct structinfo_t { 144 int max; 145 uint entry_size; 146 uint parent_size; 147 void *entry_first; 148 void *entry_enabled; 149 void *entry_blocked; 150 void *entry_node; 151 } structinfo_t; 152 structinfo_t raids_t_info, vnds_t_info, cgds_t_info, lvms_t_info, lv_t_info; 153 154 typedef struct pm_upddevlist_adv_t { 155 const char *create_msg; 156 int pe_type; 157 structinfo_t *s; 158 int sub_num; 159 struct pm_upddevlist_adv_t *sub; 160 } pm_upddevlist_adv_t; 161 162 #define MAX_MNTS 48 163 struct { 164 char dev[STRSIZE]; 165 const char *mnt_opts, *on; 166 } *mnts; 167 168 int cursel; /* Number of selected entry in main menu */ 169 int changed; /* flag indicating that we have unsaved changes */ 170 int raid_curspare; /* XXX: replace by true way */ 171 172 enum { /* RAIDframe menu enum */ 173 PMR_MENU_DEVS, PMR_MENU_DEVSSPARE, PMR_MENU_RAIDLEVEL, PMR_MENU_NUMROW, 174 PMR_MENU_NUMCOL, PMR_MENU_NUMSPARE, PMR_MENU_SECTPERSU, PMR_MENU_SUSPERPARITYUNIT, 175 PMR_MENU_SUSPERRECONUNIT, PMR_MENU_REMOVE, PMR_MENU_END 176 }; 177 178 enum { /* VND menu enum */ 179 PMV_MENU_FILEPATH, PMV_MENU_EXIST, PMV_MENU_SIZE, PMV_MENU_RO, PMV_MENU_MGEOM, 180 PMV_MENU_SECSIZE, PMV_MENU_NSECTORS, PMV_MENU_NTRACKS, PMV_MENU_NCYLINDERS, 181 PMV_MENU_REMOVE, PMV_MENU_END 182 }; 183 184 enum { /* CGD menu enum */ 185 PMC_MENU_DEV, PMC_MENU_ENCTYPE, PMC_MENU_KEYSIZE, PMC_MENU_IVTYPE, 186 PMC_MENU_KEYGENTYPE, PMC_MENU_VERIFYTYPE, PMC_MENU_REMOVE, PMC_MENU_END 187 }; 188 189 enum { /* LVM menu enum */ 190 PML_MENU_PV, PML_MENU_NAME, PML_MENU_MAXLOGICALVOLUMES, 191 PML_MENU_MAXPHYSICALVOLUMES, PML_MENU_PHYSICALEXTENTSIZE, 192 PML_MENU_REMOVE, PML_MENU_END 193 }; 194 195 enum { /* LVM submenu (logical volumes) enum */ 196 PMLV_MENU_NAME, PMLV_MENU_SIZE, PMLV_MENU_READONLY, PMLV_MENU_CONTIGUOUS, 197 PMLV_MENU_EXTENTS, PMLV_MENU_MINOR, PMLV_MENU_PERSISTENT, 198 PMLV_MENU_MIRRORS, PMLV_MENU_REGIONSIZE, PMLV_MENU_READAHEAD, 199 PMLV_MENU_STRIPES, PMLV_MENU_STRIPESIZE, PMLV_MENU_ZERO, 200 PMLV_MENU_REMOVE, PMLV_MENU_END 201 }; 202 203 part_entry_t pm_dev_list(int); 204 static int pm_raid_disk_add(menudesc *, void *); 205 static int pm_raid_disk_del(menudesc *, void *); 206 static int pm_cgd_disk_set(cgds_t *, part_entry_t *); 207 static int pm_mount(pm_devs_t *, int); 208 static int pm_upddevlist(menudesc *, void *); 209 static void pm_select(pm_devs_t *); 210 211 /* Universal menu for RAID/VND/CGD/LVM entry edit */ 212 static int 213 pm_edit(int menu_entries_count, void (*menu_fmt)(menudesc *, int, void *), 214 int (*action)(menudesc *, void *), int (*check_fun)(void *), 215 void (*entry_init)(void *, void *), void *entry_init_arg, 216 void *dev_ptr, int dev_ptr_delta, structinfo_t *s) 217 { 218 int i, ok = 0; 219 220 if (dev_ptr == NULL) { 221 /* We should create new device */ 222 for (i = 0; i < s->max && !ok; i++) 223 if (*(int*)((char*)s->entry_enabled + dev_ptr_delta + s->entry_size * i) == 0) { 224 dev_ptr = (char*)s->entry_first + dev_ptr_delta + s->entry_size * i; 225 entry_init(dev_ptr, entry_init_arg); 226 ok = 1; 227 } 228 if (!ok) { 229 /* We do not have free device slots */ 230 process_menu(MENU_ok, deconst(MSG_limitcount)); 231 return -1; 232 } 233 } 234 235 menu_ent menu_entries[menu_entries_count]; 236 for (i = 0; i < menu_entries_count - 1; i++) 237 menu_entries[i] = (menu_ent) {NULL, OPT_NOMENU, 0, action}; 238 menu_entries[i] = (menu_ent) {MSG_fremove, OPT_NOMENU, OPT_EXIT, action}; 239 240 int menu_no = -1; 241 menu_no = new_menu(NULL, menu_entries, menu_entries_count, 242 -1, -1, 0, 40, MC_NOCLEAR | MC_SCROLL, 243 NULL, menu_fmt, NULL, NULL, MSG_DONE); 244 245 process_menu(menu_no, dev_ptr); 246 free_menu(menu_no); 247 248 return check_fun(dev_ptr); 249 } 250 251 static void 252 pm_getdevstring(char *buf, int len, pm_devs_t *pm_cur, int num) 253 { 254 int i; 255 256 if (pm_cur->isspecial) 257 snprintf(buf, len, "%s", pm_cur->diskdev); 258 else if (num + 'a' < 'a' || num + 'a' > 'a' + MAXPARTITIONS) 259 snprintf(buf, len, "%sd", pm_cur->diskdev); 260 else if (pm_cur->gpt) { 261 for (i = 0; i < MAX_WEDGES; i++) 262 if (wedges[i].pm == pm_cur && 263 wedges[i].ptn == num) 264 snprintf(buf, len, "dk%d", i); // XXX: xxx 265 } else 266 snprintf(buf, len, "%s%c", pm_cur->diskdev, num + 'a'); 267 268 return; 269 } 270 271 /* Show filtered partitions menu */ 272 part_entry_t 273 pm_dev_list(int type) 274 { 275 int dev_num = -1, num_devs = 0; 276 int i, ok; 277 int menu_no; 278 menu_ent menu_entries[MAX_DISKS*MAXPARTITIONS]; 279 part_entry_t disk_entries[MAX_DISKS*MAXPARTITIONS]; 280 pm_devs_t *pm_i; 281 282 SLIST_FOREACH(pm_i, &pm_head, l) 283 for (i = 0; i < MAXPARTITIONS; i++) { 284 ok = 0; 285 switch (type) { 286 case PM_RAID_T: 287 if (pm_i->bsdlabel[i].pi_fstype == FS_RAID) 288 ok = 1; 289 break; 290 case PM_CGD_T: 291 if (pm_i->bsdlabel[i].pi_fstype == FS_CGD) 292 ok = 1; 293 break; 294 case PM_LVM_T: 295 if (pm_i->bsdlabel[i].lvmpv) 296 ok = 1; 297 break; 298 } 299 if (ok && pm_partusage(pm_i, i, 0) == 0) { 300 disk_entries[num_devs].dev_ptr = pm_i; 301 disk_entries[num_devs].dev_num = i; 302 pm_getdevstring(disk_entries[num_devs].fullname, SSTRSIZE, pm_i, i); 303 304 menu_entries[num_devs] = (struct menu_ent) { 305 .opt_name = disk_entries[num_devs].fullname, 306 .opt_action = set_menu_select, 307 .opt_menu = OPT_NOMENU, 308 .opt_flags = OPT_EXIT, 309 }; 310 num_devs++; 311 } 312 } 313 314 menu_no = new_menu(MSG_avdisks, 315 menu_entries, num_devs, -1, -1, (num_devs+1<3)?3:num_devs+1, 13, 316 MC_SCROLL | MC_NOCLEAR, NULL, NULL, NULL, NULL, NULL); 317 if (menu_no == -1) 318 return (part_entry_t) { .retvalue = -1, }; 319 process_menu(menu_no, &dev_num); 320 free_menu(menu_no); 321 322 if (dev_num < 0 || dev_num >= num_devs) 323 return (part_entry_t) { .retvalue = -1, }; 324 325 disk_entries[dev_num].retvalue = dev_num; 326 return disk_entries[dev_num]; 327 } 328 329 /* Get unused raid*, cgd* or vnd* device */ 330 static int 331 pm_manage_getfreenode(void *node, const char *d, structinfo_t *s) 332 { 333 int i, ii, ok; 334 char buf[SSTRSIZE]; 335 pm_devs_t *pm_i; 336 337 *(int*)node = -1; 338 for (i = 0; i < s->max; i++) { 339 ok = 1; 340 /* Check that node is not already reserved */ 341 for (ii = 0; ii < s->max; ii++) 342 if (*(int*)((char*)s->entry_node + s->entry_size * ii) == i) { 343 ok = 0; 344 break; 345 } 346 if (! ok) 347 continue; 348 /* Check that node is not in the device list */ 349 snprintf(buf, SSTRSIZE, "%s%d", d, i); 350 SLIST_FOREACH(pm_i, &pm_head, l) 351 if (! strcmp(pm_i->diskdev, buf)) { 352 ok = 0; 353 break; 354 } 355 if (ok) { 356 *(int*)node = i; 357 return i; 358 } 359 } 360 process_menu(MENU_ok, deconst(MSG_nofreedev)); 361 return -1; 362 } 363 364 /*** 365 RAIDs 366 ***/ 367 368 static void 369 pm_raid_menufmt(menudesc *m, int opt, void *arg) 370 { 371 int i, ok = 0; 372 char buf[STRSIZE]; buf[0] = '\0'; 373 raids_t *dev_ptr = ((part_entry_t *)arg)[opt].dev_ptr; 374 375 if (dev_ptr->enabled == 0) 376 return; 377 for (i = 0; i < MAX_IN_RAID; i++) 378 if (dev_ptr->pm[i] != NULL) { 379 strlcat(buf, dev_ptr->pm_name[i], STRSIZE); 380 strlcat(buf, " ", STRSIZE); 381 ok = 1; 382 } 383 if (ok) 384 wprintw(m->mw, msg_string(MSG_raid_menufmt), dev_ptr->node, 385 dev_ptr->raid_level, buf, dev_ptr->total_size); 386 else 387 wprintw(m->mw, "%s", msg_string(MSG_raid_err_menufmt)); 388 return; 389 } 390 391 static void 392 pm_raid_edit_menufmt(menudesc *m, int opt, void *arg) 393 { 394 int i; 395 char buf[STRSIZE]; buf[0] = '\0'; 396 raids_t *dev_ptr = arg; 397 398 switch (opt) { 399 case PMR_MENU_DEVS: 400 for (i = 0; i < MAX_IN_RAID; i++) 401 if (dev_ptr->pm[i] != NULL && dev_ptr->pm_is_spare[i] == 0) 402 snprintf(buf, STRSIZE, "%s %s", buf, dev_ptr->pm_name[i]); 403 wprintw(m->mw, msg_string(MSG_raid_disks_fmt), buf); 404 break; 405 case PMR_MENU_DEVSSPARE: 406 for (i = 0; i < MAX_IN_RAID; i++) 407 if (dev_ptr->pm[i] != NULL && dev_ptr->pm_is_spare[i] != 0) 408 snprintf(buf, STRSIZE, "%s %s", buf, dev_ptr->pm_name[i]); 409 wprintw(m->mw, msg_string(MSG_raid_spares_fmt), buf); 410 break; 411 case PMR_MENU_RAIDLEVEL: 412 wprintw(m->mw, msg_string(MSG_raid_level_fmt), dev_ptr->raid_level); 413 break; 414 case PMR_MENU_NUMROW: 415 wprintw(m->mw, msg_string(MSG_raid_numrow_fmt), dev_ptr->numRow); 416 break; 417 case PMR_MENU_NUMCOL: 418 wprintw(m->mw, msg_string(MSG_raid_numcol_fmt), dev_ptr->numCol); 419 break; 420 case PMR_MENU_NUMSPARE: 421 wprintw(m->mw, msg_string(MSG_raid_numspare_fmt), dev_ptr->numSpare); 422 break; 423 case PMR_MENU_SECTPERSU: 424 wprintw(m->mw, msg_string(MSG_raid_sectpersu_fmt), dev_ptr->sectPerSU); 425 break; 426 case PMR_MENU_SUSPERPARITYUNIT: 427 wprintw(m->mw, msg_string(MSG_raid_superpar_fmt), dev_ptr->SUsPerParityUnit); 428 break; 429 case PMR_MENU_SUSPERRECONUNIT: 430 wprintw(m->mw, msg_string(MSG_raid_superrec_fmt), dev_ptr->SUsPerReconUnit); 431 break; 432 } 433 return; 434 } 435 436 static int 437 pm_raid_set_value(menudesc *m, void *arg) 438 { 439 int retvalue = -1; 440 int *out_var = NULL; 441 char buf[SSTRSIZE]; 442 const char *msg_to_show = NULL; 443 raids_t *dev_ptr = arg; 444 445 static menu_ent menuent_disk_adddel[] = { 446 {MSG_add, OPT_NOMENU, OPT_EXIT, pm_raid_disk_add}, 447 {MSG_remove, OPT_NOMENU, OPT_EXIT, pm_raid_disk_del} 448 }; 449 static int menu_disk_adddel = -1; 450 if (menu_disk_adddel == -1) { 451 menu_disk_adddel = new_menu(NULL, menuent_disk_adddel, nelem(menuent_disk_adddel), 452 -1, -1, 0, 10, MC_NOCLEAR, NULL, NULL, NULL, NULL, NULL); 453 } 454 455 switch (m->cursel) { 456 case PMR_MENU_DEVS: 457 raid_curspare = 0; 458 process_menu(menu_disk_adddel, dev_ptr); 459 return 0; 460 case PMR_MENU_DEVSSPARE: 461 raid_curspare = 1; 462 process_menu(menu_disk_adddel, dev_ptr); 463 return 0; 464 case PMR_MENU_RAIDLEVEL: 465 process_menu(MENU_raidlevel, &retvalue); 466 if (retvalue >= 0) 467 dev_ptr->raid_level = retvalue; 468 return 0; 469 case PMR_MENU_NUMROW: 470 process_menu(MENU_ok, deconst(MSG_raid_nomultidim)); 471 return 0; 472 #if 0 /* notyet */ 473 msg_to_show = MSG_raid_numrow_ask; 474 out_var = &(dev_ptr->numRow); 475 break; 476 #endif 477 case PMR_MENU_NUMCOL: 478 msg_to_show = MSG_raid_numcol_ask; 479 out_var = &(dev_ptr->numCol); 480 break; 481 case PMR_MENU_NUMSPARE: 482 msg_to_show = MSG_raid_numspare_ask; 483 out_var = &(dev_ptr->numSpare); 484 break; 485 case PMR_MENU_SECTPERSU: 486 msg_to_show = MSG_raid_sectpersu_ask; 487 out_var = &(dev_ptr->sectPerSU); 488 break; 489 case PMR_MENU_SUSPERPARITYUNIT: 490 msg_to_show = MSG_raid_superpar_ask; 491 out_var = &(dev_ptr->SUsPerParityUnit); 492 break; 493 case PMR_MENU_SUSPERRECONUNIT: 494 msg_to_show = MSG_raid_superrec_ask; 495 out_var = &(dev_ptr->SUsPerReconUnit); 496 break; 497 case PMR_MENU_REMOVE: 498 dev_ptr->enabled = 0; 499 return 0; 500 } 501 if (out_var == NULL || msg_to_show == NULL) 502 return -1; 503 snprintf(buf, SSTRSIZE, "%d", *out_var); 504 msg_prompt_win(msg_to_show, -1, 18, 0, 0, buf, buf, SSTRSIZE); 505 if (atoi(buf) >= 0) 506 *out_var = atoi(buf); 507 return 0; 508 } 509 510 static void 511 pm_raid_init(void *arg, void *none) 512 { 513 raids_t *dev_ptr = arg; 514 memset(dev_ptr, 0, sizeof(*dev_ptr)); 515 *dev_ptr = (struct raids_t) { 516 .enabled = 1, 517 .blocked = 0, 518 .sectPerSU = 32, 519 .SUsPerParityUnit = 1, 520 .SUsPerReconUnit = 1, 521 }; 522 return; 523 } 524 525 static int 526 pm_raid_check(void *arg) 527 { 528 int i, dev_num = 0, min_size = 0, cur_size = 0; 529 raids_t *dev_ptr = arg; 530 531 if (dev_ptr->blocked) 532 return 0; 533 for (i = 0; i < MAX_IN_RAID; i++) 534 if (dev_ptr->pm[i] != NULL) { 535 cur_size = dev_ptr->pm[i]->bsdlabel[dev_ptr->pm_part[i]].pi_size / 536 (MEG / dev_ptr->pm[i]->sectorsize); 537 if (cur_size < min_size || dev_num == 0) 538 min_size = cur_size; 539 if (!dev_ptr->pm_is_spare[i]) 540 dev_num++; 541 } 542 /* Calculate sum of available space */ 543 if (dev_num > 0) { 544 switch (dev_ptr->raid_level) { 545 case 0: 546 dev_ptr->total_size = min_size * dev_num; 547 break; 548 case 1: 549 dev_ptr->total_size = min_size; 550 break; 551 case 4: 552 case 5: 553 dev_ptr->total_size = min_size * (dev_num - 1); 554 break; 555 } 556 pm_manage_getfreenode(&(dev_ptr->node), "raid", &raids_t_info); 557 if (dev_ptr->node < 0) 558 dev_ptr->enabled = 0; 559 } 560 else 561 dev_ptr->enabled = 0; 562 return dev_ptr->enabled; 563 } 564 565 static int 566 pm_raid_disk_add(menudesc *m, void *arg) 567 { 568 int i; 569 raids_t *dev_ptr = arg; 570 part_entry_t disk_entrie = pm_dev_list(PM_RAID_T); 571 if (disk_entrie.retvalue < 0) 572 return disk_entrie.retvalue; 573 574 for (i = 0; i < MAX_IN_RAID; i++) 575 if (dev_ptr->pm[i] == NULL) { 576 dev_ptr->pm[i] = disk_entrie.dev_ptr; 577 dev_ptr->pm_part[i] = disk_entrie.dev_num; 578 dev_ptr->pm_is_spare[i] = raid_curspare; 579 strlcpy(dev_ptr->pm_name[i], disk_entrie.fullname, SSTRSIZE); 580 if (raid_curspare) 581 dev_ptr->numSpare++; 582 else 583 dev_ptr->numCol++; 584 dev_ptr->numRow = 1; 585 break; 586 } 587 return 0; 588 } 589 590 static int 591 pm_raid_disk_del(menudesc *m, void *arg) 592 { 593 int retvalue = -1, num_devs = 0; 594 int i, pm_cur; 595 int menu_no; 596 raids_t *dev_ptr = arg; 597 menu_ent menu_entries[MAX_IN_RAID]; 598 part_entry_t submenu_args[MAX_IN_RAID]; 599 600 for (i = 0; i < MAX_IN_RAID; i++) { 601 if (dev_ptr->pm[i] == NULL || 602 dev_ptr->pm_is_spare[i] != raid_curspare) 603 continue; 604 menu_entries[num_devs] = (struct menu_ent) { 605 .opt_name = dev_ptr->pm_name[i], 606 .opt_action = set_menu_select, 607 .opt_menu = OPT_NOMENU, 608 .opt_flags = OPT_EXIT, 609 }; 610 submenu_args[num_devs].dev_num = i; 611 num_devs++; 612 } 613 614 menu_no = new_menu(MSG_raid_disks, 615 menu_entries, num_devs, -1, -1, (num_devs+1<3)?3:num_devs+1, 13, 616 MC_SCROLL | MC_NOCLEAR, NULL, NULL, NULL, NULL, NULL); 617 if (menu_no == -1) 618 return -1; 619 process_menu(menu_no, &retvalue); 620 free_menu(menu_no); 621 622 if (retvalue < 0 || retvalue >= num_devs) 623 return -1; 624 625 pm_cur = submenu_args[retvalue].dev_num; 626 627 if (dev_ptr->pm_is_spare[pm_cur]) 628 dev_ptr->numSpare--; 629 else 630 dev_ptr->numCol--; 631 dev_ptr->numRow = (dev_ptr->numCol)?1:0; 632 dev_ptr->pm[pm_cur] = NULL; 633 634 return 0; 635 } 636 637 static int 638 pm_raid_commit(void) 639 { 640 int i, ii; 641 FILE *f; 642 char f_name[STRSIZE]; 643 644 for (i = 0; i < MAX_RAID; i++) { 645 if (! pm_raid_check(&raids[i])) 646 continue; 647 648 /* Generating configure file for our raid */ 649 snprintf(f_name, SSTRSIZE, "/tmp/raid.%d.conf", raids[i].node); 650 f = fopen(f_name, "w"); 651 if (f == NULL) { 652 endwin(); 653 (void)fprintf(stderr, "Could not open %s for writing\n", f_name); 654 if (logfp) 655 (void)fprintf(logfp, "Could not open %s for writing\n", f_name); 656 return 1; 657 } 658 scripting_fprintf(NULL, "cat <<EOF >%s\n", f_name); 659 scripting_fprintf(f, "START array\n%d %d %d\n", raids[i].numRow, 660 raids[i].numCol, raids[i].numSpare); 661 662 scripting_fprintf(f, "\nSTART disks\n"); 663 for (ii = 0; ii < MAX_IN_RAID; ii++) 664 if (raids[i].pm[ii] != NULL && raids[i].pm_is_spare[ii] == 0) { 665 scripting_fprintf(f, "/dev/%s\n", raids[i].pm_name[ii]); 666 } 667 668 scripting_fprintf(f, "\nSTART spare\n"); 669 for (ii = 0; ii < MAX_IN_RAID; ii++) 670 if (raids[i].pm[ii] != NULL && raids[i].pm_is_spare[ii] != 0) { 671 scripting_fprintf(f, "/dev/%s\n", raids[i].pm_name[ii]); 672 } 673 674 scripting_fprintf(f, "\nSTART layout\n%d %d %d %d\n", raids[i].sectPerSU, 675 raids[i].SUsPerParityUnit, raids[i].SUsPerReconUnit, 676 raids[i].raid_level); 677 678 scripting_fprintf(f, "\nSTART queue\nfifo 100\n\n"); 679 scripting_fprintf(NULL, "EOF\n"); 680 fclose (f); 681 fflush(NULL); 682 683 /* Raid initialization */ 684 if ( 685 run_program(RUN_DISPLAY | RUN_PROGRESS, "raidctl -C %s raid%d", 686 f_name, raids[i].node) == 0 && 687 run_program(RUN_DISPLAY | RUN_PROGRESS, "raidctl -I %d raid%d", 688 rand(), raids[i].node) == 0 && 689 run_program(RUN_DISPLAY | RUN_PROGRESS, "raidctl -vi raid%d", 690 raids[i].node) == 0 && 691 run_program(RUN_DISPLAY | RUN_PROGRESS, "raidctl -v -A yes raid%d", 692 raids[i].node) == 0 693 ) { 694 raids[i].blocked = 1; /* RAID creation done, remove it from list to 695 prevent its repeated reinitialization */ 696 for (ii = 0; ii < MAX_IN_RAID; ii++) 697 if (raids[i].pm[ii] != NULL) 698 raids[i].pm[ii]->blocked++; 699 } 700 } 701 return 0; 702 } 703 704 /*** 705 VND 706 ***/ 707 708 static void 709 pm_vnd_menufmt(menudesc *m, int opt, void *arg) 710 { 711 vnds_t *dev_ptr = ((part_entry_t *)arg)[opt].dev_ptr; 712 713 if (dev_ptr->enabled == 0) 714 return; 715 if (strlen(dev_ptr->filepath) < 1) 716 wprintw(m->mw, "%s", msg_string(MSG_vnd_err_menufmt)); 717 else if (dev_ptr->is_exist) 718 wprintw(m->mw, msg_string(MSG_vnd_assgn_menufmt), 719 dev_ptr->node, dev_ptr->filepath); 720 else 721 wprintw(m->mw, msg_string(MSG_vnd_menufmt), 722 dev_ptr->node, dev_ptr->filepath, dev_ptr->size); 723 return; 724 } 725 726 static void 727 pm_vnd_edit_menufmt(menudesc *m, int opt, void *arg) 728 { 729 vnds_t *dev_ptr = arg; 730 char buf[SSTRSIZE]; 731 strcpy(buf, "-"); 732 733 switch (opt) { 734 case PMV_MENU_FILEPATH: 735 wprintw(m->mw, msg_string(MSG_vnd_path_fmt), dev_ptr->filepath); 736 break; 737 case PMV_MENU_EXIST: 738 wprintw(m->mw, msg_string(MSG_vnd_assgn_fmt), 739 dev_ptr->is_exist? msg_string(MSG_No) : msg_string(MSG_Yes)); 740 break; 741 case PMV_MENU_SIZE: 742 if (!dev_ptr->is_exist) 743 snprintf(buf, SSTRSIZE, "%d", dev_ptr->size); 744 wprintw(m->mw, msg_string(MSG_vnd_size_fmt), buf); 745 break; 746 case PMV_MENU_RO: 747 wprintw(m->mw, msg_string(MSG_vnd_ro_fmt), 748 dev_ptr->readonly? msg_string(MSG_Yes) : msg_string(MSG_No)); 749 break; 750 case PMV_MENU_MGEOM: 751 if (!dev_ptr->is_exist) 752 snprintf(buf, SSTRSIZE, "%s", 753 dev_ptr->manual_geom? msg_string(MSG_Yes) : msg_string(MSG_No)); 754 wprintw(m->mw, msg_string(MSG_vnd_geom_fmt), buf); 755 break; 756 case PMV_MENU_SECSIZE: 757 if (dev_ptr->manual_geom && !dev_ptr->is_exist) 758 snprintf(buf, SSTRSIZE, "%d", dev_ptr->secsize); 759 wprintw(m->mw, msg_string(MSG_vnd_bps_fmt), buf); 760 break; 761 case PMV_MENU_NSECTORS: 762 if (dev_ptr->manual_geom && !dev_ptr->is_exist) 763 snprintf(buf, SSTRSIZE, "%d", dev_ptr->nsectors); 764 wprintw(m->mw, msg_string(MSG_vnd_spt_fmt), buf); 765 break; 766 case PMV_MENU_NTRACKS: 767 if (dev_ptr->manual_geom && !dev_ptr->is_exist) 768 snprintf(buf, SSTRSIZE, "%d", dev_ptr->ntracks); 769 wprintw(m->mw, msg_string(MSG_vnd_tpc_fmt), buf); 770 break; 771 case PMV_MENU_NCYLINDERS: 772 if (dev_ptr->manual_geom && !dev_ptr->is_exist) 773 snprintf(buf, SSTRSIZE, "%d", dev_ptr->ncylinders); 774 wprintw(m->mw, msg_string(MSG_vnd_cyl_fmt), buf); 775 break; 776 } 777 return; 778 } 779 780 static int 781 pm_vnd_set_value(menudesc *m, void *arg) 782 { 783 vnds_t *dev_ptr = arg; 784 char buf[STRSIZE]; 785 const char *msg_to_show = NULL; 786 int *out_var = NULL; 787 788 switch (m->cursel) { 789 case PMV_MENU_FILEPATH: 790 msg_prompt_win(MSG_vnd_path_ask, -1, 18, 0, 0, dev_ptr->filepath, 791 dev_ptr->filepath, STRSIZE); 792 if (dev_ptr->filepath[0] != '/') { 793 strlcpy(buf, dev_ptr->filepath, MOUNTLEN); 794 snprintf(dev_ptr->filepath, MOUNTLEN, "/%s", buf); 795 } 796 if (dev_ptr->filepath[strlen(dev_ptr->filepath) - 1] == '/') 797 dev_ptr->filepath[strlen(dev_ptr->filepath) - 1] = '\0'; 798 return 0; 799 case PMV_MENU_EXIST: 800 dev_ptr->is_exist = !dev_ptr->is_exist; 801 return 0; 802 case PMV_MENU_SIZE: 803 if (dev_ptr->is_exist) 804 return 0; 805 msg_to_show = MSG_vnd_size_ask; 806 out_var = &(dev_ptr->size); 807 break; 808 case PMV_MENU_RO: 809 dev_ptr->readonly = !dev_ptr->readonly; 810 return 0; 811 case PMV_MENU_MGEOM: 812 if (dev_ptr->is_exist) 813 return 0; 814 dev_ptr->manual_geom = !dev_ptr->manual_geom; 815 return 0; 816 case PMV_MENU_SECSIZE: 817 if (!dev_ptr->manual_geom || dev_ptr->is_exist) 818 return 0; 819 msg_to_show = MSG_vnd_bps_ask; 820 out_var = &(dev_ptr->secsize); 821 break; 822 case PMV_MENU_NSECTORS: 823 if (!dev_ptr->manual_geom || dev_ptr->is_exist) 824 return 0; 825 msg_to_show = MSG_vnd_spt_ask; 826 out_var = &(dev_ptr->nsectors); 827 break; 828 case PMV_MENU_NTRACKS: 829 if (!dev_ptr->manual_geom || dev_ptr->is_exist) 830 return 0; 831 msg_to_show = MSG_vnd_tpc_ask; 832 out_var = &(dev_ptr->ntracks); 833 break; 834 case PMV_MENU_NCYLINDERS: 835 if (!dev_ptr->manual_geom || dev_ptr->is_exist) 836 return 0; 837 msg_to_show = MSG_vnd_cyl_ask; 838 out_var = &(dev_ptr->ncylinders); 839 break; 840 case PMV_MENU_REMOVE: 841 dev_ptr->enabled = 0; 842 return 0; 843 } 844 if (out_var == NULL || msg_to_show == NULL) 845 return -1; 846 snprintf(buf, SSTRSIZE, "%d", *out_var); 847 msg_prompt_win(msg_to_show, -1, 18, 0, 0, buf, buf, SSTRSIZE); 848 if (atoi(buf) >= 0) 849 *out_var = atoi(buf); 850 return 0; 851 } 852 853 static void 854 pm_vnd_init(void *arg, void *none) 855 { 856 vnds_t *dev_ptr = arg; 857 memset(dev_ptr, 0, sizeof(*dev_ptr)); 858 *dev_ptr = (struct vnds_t) { 859 .enabled = 1, 860 .blocked = 0, 861 .filepath[0] = '\0', 862 .is_exist = 0, 863 .size = 1024, 864 .readonly = 0, 865 .manual_geom = 0, 866 .secsize = 512, 867 .nsectors = 18, 868 .ntracks = 2, 869 .ncylinders = 80 870 }; 871 return; 872 } 873 874 static int 875 pm_vnd_check(void *arg) 876 { 877 vnds_t *dev_ptr = arg; 878 879 if (dev_ptr->blocked) 880 return 0; 881 if (strlen(dev_ptr->filepath) < 1 || 882 dev_ptr->size < 1) 883 dev_ptr->enabled = 0; 884 else { 885 pm_manage_getfreenode(&(dev_ptr->node), "vnd", &vnds_t_info); 886 if (dev_ptr->node < 0) 887 dev_ptr->enabled = 0; 888 } 889 return dev_ptr->enabled; 890 } 891 892 /* XXX: vnconfig always return 0? */ 893 static int 894 pm_vnd_commit(void) 895 { 896 int i, ii, error, part_suit = -1; 897 char r_o[3], buf[MOUNTLEN+3], resultpath[STRSIZE]; 898 pm_devs_t *pm_i, *pm_suit = NULL; 899 900 for (i = 0; i < MAX_VND; i++) { 901 error = 0; 902 if (! pm_vnd_check(&vnds[i])) 903 continue; 904 905 /* Trying to assign target device */ 906 SLIST_FOREACH(pm_i, &pm_head, l) 907 for (ii = 0; ii < 6; ii++) { 908 strcpy(buf, pm_i->bsdlabel[ii].pi_mount); 909 if (buf[strlen(buf)-1] != '/') 910 sprintf(buf,"%s/", buf); 911 printf("%s\n",buf); 912 if (strstr(vnds[i].filepath, buf) == vnds[i].filepath) 913 if (part_suit < 0 || pm_suit == NULL || 914 strlen(buf) > strlen(pm_suit->bsdlabel[part_suit].pi_mount)) { 915 part_suit = ii; 916 pm_suit = pm_i; 917 } 918 } 919 if (part_suit < 0 || pm_suit == NULL || 920 pm_suit->bsdlabel[part_suit].mnt_opts == NULL || 921 ! (pm_suit->bsdlabel[part_suit].pi_flags & PIF_MOUNT)) 922 continue; 923 924 /* Mounting assigned partition and try to get real file path*/ 925 if (pm_mount(pm_suit, part_suit) != 0) 926 continue; 927 snprintf(resultpath, STRSIZE, "%s/%s", 928 pm_suit->bsdlabel[part_suit].mounted, 929 &(vnds[i].filepath[strlen(pm_suit->bsdlabel[part_suit].pi_mount)])); 930 931 strcpy(r_o, vnds[i].readonly?"-r":""); 932 /* If this is a new image */ 933 if (!vnds[i].is_exist) { 934 run_program(RUN_DISPLAY | RUN_PROGRESS, "mkdir -p %s ", dirname(resultpath)); 935 error += run_program(RUN_DISPLAY | RUN_PROGRESS, 936 "dd if=/dev/zero of=%s bs=1m count=%d progress=100 msgfmt=human", 937 resultpath, vnds[i].size); 938 } 939 if (error) 940 continue; 941 /* If this is a new image with manual geometry */ 942 if (!vnds[i].is_exist && vnds[i].manual_geom) 943 error += run_program(RUN_DISPLAY | RUN_PROGRESS, 944 "vnconfig %s vnd%d %s %d %d %d %d", r_o, vnds[i].node, 945 resultpath, vnds[i].secsize, vnds[i].nsectors, 946 vnds[i].ntracks, vnds[i].ncylinders); 947 /* If this is a existing image or image without manual geometry */ 948 else 949 error += run_program(RUN_DISPLAY | RUN_PROGRESS, "vnconfig %s vnd%d %s", 950 r_o, vnds[i].node, resultpath); 951 952 if (! error) { 953 vnds[i].blocked = 1; 954 vnds[i].pm_part = part_suit; 955 vnds[i].pm = pm_suit; 956 vnds[i].pm->blocked++; 957 } 958 } 959 return 0; 960 } 961 962 /*** 963 CGD 964 ***/ 965 966 static void 967 pm_cgd_menufmt(menudesc *m, int opt, void *arg) 968 { 969 cgds_t *dev_ptr = ((part_entry_t *)arg)[opt].dev_ptr; 970 char desc[STRSIZE]; 971 972 if (dev_ptr->enabled == 0) 973 return; 974 if (dev_ptr->pm == NULL) 975 wprintw(m->mw, "%s", msg_string(MSG_cgd_err_menufmt)); 976 else { 977 snprintf(desc, STRSIZE, "(%s-%d) on %s", dev_ptr->enc_type, 978 dev_ptr->key_size, dev_ptr->pm_name); 979 wprintw(m->mw, msg_string(MSG_cgd_menufmt), dev_ptr->node, desc, 980 dev_ptr->pm->bsdlabel[dev_ptr->pm_part].pi_size / 981 (MEG / dev_ptr->pm->sectorsize)); 982 } 983 return; 984 } 985 986 static void 987 pm_cgd_edit_menufmt(menudesc *m, int opt, void *arg) 988 { 989 cgds_t *dev_ptr = arg; 990 switch (opt) { 991 case PMC_MENU_DEV: 992 wprintw(m->mw, msg_string(MSG_cgd_dev_fmt), dev_ptr->pm_name); 993 break; 994 case PMC_MENU_ENCTYPE: 995 wprintw(m->mw, msg_string(MSG_cgd_enc_fmt), dev_ptr->enc_type); 996 break; 997 case PMC_MENU_KEYSIZE: 998 wprintw(m->mw, msg_string(MSG_cgd_key_fmt), dev_ptr->key_size); 999 break; 1000 case PMC_MENU_IVTYPE: 1001 wprintw(m->mw, msg_string(MSG_cgd_iv_fmt), dev_ptr->iv_type); 1002 break; 1003 case PMC_MENU_KEYGENTYPE: 1004 wprintw(m->mw, msg_string(MSG_cgd_keygen_fmt), dev_ptr->keygen_type); 1005 break; 1006 case PMC_MENU_VERIFYTYPE: 1007 wprintw(m->mw, msg_string(MSG_cgd_verif_fmt), dev_ptr->verify_type); 1008 break; 1009 } 1010 return; 1011 } 1012 1013 static int 1014 pm_cgd_set_value(menudesc *m, void *arg) 1015 { 1016 char *retstring; 1017 cgds_t *dev_ptr = arg; 1018 1019 switch (m->cursel) { 1020 case PMC_MENU_DEV: 1021 pm_cgd_disk_set(dev_ptr, NULL); 1022 return 0; 1023 case PMC_MENU_ENCTYPE: 1024 process_menu(MENU_cgd_enctype, &retstring); 1025 dev_ptr->enc_type = retstring; 1026 if (! strcmp(retstring, "aes-xts")) 1027 dev_ptr->key_size = 256; 1028 if (! strcmp(retstring, "aes-cbc")) 1029 dev_ptr->key_size = 192; 1030 if (! strcmp(retstring, "blowfish-cbc")) 1031 dev_ptr->key_size = 128; 1032 if (! strcmp(retstring, "3des-cbc")) 1033 dev_ptr->key_size = 192; 1034 return 0; 1035 case PMC_MENU_KEYSIZE: 1036 if (! strcmp(dev_ptr->enc_type, "aes-xts")) 1037 dev_ptr->key_size += 1038 (dev_ptr->key_size < 512)? 256 : -256; 1039 if (! strcmp(dev_ptr->enc_type, "aes-cbc")) 1040 dev_ptr->key_size += 1041 (dev_ptr->key_size < 256)? 64 : -128; 1042 if (! strcmp(dev_ptr->enc_type, "blowfish-cbc")) 1043 dev_ptr->key_size = 128; 1044 if (! strcmp(dev_ptr->enc_type, "3des-cbc")) 1045 dev_ptr->key_size = 192; 1046 return 0; 1047 case PMC_MENU_IVTYPE: 1048 process_menu(MENU_cgd_ivtype, &retstring); 1049 dev_ptr->iv_type = retstring; 1050 return 0; 1051 case PMC_MENU_KEYGENTYPE: 1052 process_menu(MENU_cgd_keygentype, &retstring); 1053 dev_ptr->keygen_type = retstring; 1054 return 0; 1055 case PMC_MENU_VERIFYTYPE: 1056 process_menu(MENU_cgd_verifytype, &retstring); 1057 dev_ptr->verify_type = retstring; 1058 return 0; 1059 case PMC_MENU_REMOVE: 1060 dev_ptr->enabled = 0; 1061 return 0; 1062 } 1063 return -1; 1064 } 1065 1066 static void 1067 pm_cgd_init(void *arg1, void *arg2) 1068 { 1069 cgds_t *dev_ptr = arg1; 1070 part_entry_t *disk_entrie = arg2; 1071 1072 memset(dev_ptr, 0, sizeof(*dev_ptr)); 1073 *dev_ptr = (struct cgds_t) { 1074 .enabled = 1, 1075 .blocked = 0, 1076 .pm = NULL, 1077 .pm_name[0] = '\0', 1078 .pm_part = 0, 1079 .keygen_type = "pkcs5_pbkdf2/sha1", 1080 .verify_type = "disklabel", 1081 .enc_type = "aes-xts", 1082 .iv_type = "encblkno1", 1083 .key_size = 256, 1084 }; 1085 if (disk_entrie != NULL) { 1086 pm_getdevstring(disk_entrie->fullname, SSTRSIZE, 1087 disk_entrie->dev_ptr, disk_entrie->dev_num); 1088 pm_cgd_disk_set(dev_ptr, disk_entrie); 1089 } 1090 return; 1091 } 1092 1093 static int 1094 pm_cgd_check(void *arg) 1095 { 1096 cgds_t *dev_ptr = arg; 1097 1098 if (dev_ptr->blocked) 1099 return 0; 1100 if (dev_ptr->pm == NULL) 1101 dev_ptr->enabled = 0; 1102 else { 1103 pm_manage_getfreenode(&(dev_ptr->node), "cgd", &cgds_t_info); 1104 if (dev_ptr->node < 0) 1105 dev_ptr->enabled = 0; 1106 } 1107 return dev_ptr->enabled; 1108 } 1109 1110 static int 1111 pm_cgd_disk_set(cgds_t *dev_ptr, part_entry_t *disk_entrie) 1112 { 1113 int alloc_disk_entrie = 0; 1114 if (disk_entrie == NULL) { 1115 alloc_disk_entrie = 1; 1116 disk_entrie = malloc (sizeof(part_entry_t)); 1117 if (disk_entrie == NULL) 1118 return -2; 1119 *disk_entrie = pm_dev_list(PM_CGD_T); 1120 if (disk_entrie->retvalue < 0) { 1121 free(disk_entrie); 1122 return -1; 1123 } 1124 } 1125 dev_ptr->pm = disk_entrie->dev_ptr; 1126 dev_ptr->pm_part = disk_entrie->dev_num; 1127 strlcpy(dev_ptr->pm_name, disk_entrie->fullname, SSTRSIZE); 1128 1129 if (alloc_disk_entrie) 1130 free(disk_entrie); 1131 return 0; 1132 } 1133 1134 int 1135 pm_cgd_edit(void *dev_ptr, part_entry_t *disk_entrie) 1136 { 1137 if (disk_entrie != NULL) 1138 dev_ptr = NULL; 1139 return pm_edit(PMC_MENU_END, pm_cgd_edit_menufmt, 1140 pm_cgd_set_value, pm_cgd_check, pm_cgd_init, 1141 disk_entrie, dev_ptr, 0, &cgds_t_info); 1142 } 1143 1144 static int 1145 pm_cgd_commit(void) 1146 { 1147 int i, error = 0; 1148 for (i = 0; i < MAX_CGD; i++) { 1149 if (! pm_cgd_check(&cgds[i])) 1150 continue; 1151 if (run_program(RUN_DISPLAY | RUN_PROGRESS, 1152 "cgdconfig -g -i %s -k %s -o /tmp/cgd.%d.conf %s %d", 1153 cgds[i].iv_type, cgds[i].keygen_type, cgds[i].node, 1154 cgds[i].enc_type, cgds[i].key_size) != 0) { 1155 error++; 1156 continue; 1157 } 1158 if (run_program(RUN_DISPLAY | RUN_PROGRESS, 1159 "cgdconfig -V re-enter cgd%d /dev/%s /tmp/cgd.%d.conf", 1160 cgds[i].node, cgds[i].pm_name, cgds[i].node) != 0) { 1161 error++; 1162 continue; 1163 } 1164 cgds[i].pm->blocked++; 1165 cgds[i].blocked = 1; 1166 } 1167 return error; 1168 } 1169 1170 /*** 1171 LVM 1172 ***/ 1173 1174 /* Add lvm logical volumes to pm list */ 1175 /* XXX: rewrite */ 1176 static int 1177 pm_lvm_find(void) 1178 { 1179 int i, ii, already_found; 1180 char dev[STRSIZE]; 1181 pm_devs_t *pm_i; 1182 1183 for (i = 0; i < MAX_LVM_VG; i++) { 1184 if (! lvms[i].blocked) 1185 continue; 1186 for (ii = 0; ii < MAX_LVM_LV; ii++) { 1187 if (! lvms[i].lv[ii].blocked || lvms[i].lv[ii].size < 1) 1188 continue; 1189 snprintf(dev, STRSIZE, "%s/%s", lvms[i].name, lvms[i].lv[ii].name); 1190 already_found = 0; 1191 SLIST_FOREACH(pm_i, &pm_head, l) 1192 if (!already_found && strcmp(pm_i->diskdev, dev) == 0) { 1193 pm_i->found = 1; 1194 already_found = 1; 1195 } 1196 if (already_found) 1197 /* We already added this device, skipping */ 1198 continue; 1199 pm_new->found = 1; 1200 pm_new->isspecial = 1; 1201 pm_new->refdev = &lvms[i].lv[ii]; 1202 pm_new->sectorsize = 1; 1203 pm_new->dlcylsize = MEG; 1204 pm_new->bsdlabel[0].pi_size = MEG * lvms[i].lv[ii].size; 1205 strlcpy(pm_new->diskdev, dev, SSTRSIZE); 1206 strlcpy(pm_new->diskdev_descr, dev, STRSIZE); 1207 1208 if (SLIST_EMPTY(&pm_head)) 1209 SLIST_INSERT_HEAD(&pm_head, pm_new, l); 1210 else 1211 SLIST_INSERT_AFTER(pm_i, pm_new, l); 1212 pm_new = malloc(sizeof (pm_devs_t)); 1213 memset(pm_new, 0, sizeof *pm_new); 1214 } 1215 } 1216 return 0; 1217 } 1218 1219 static int 1220 pm_lvm_disk_add(menudesc *m, void *arg) 1221 { 1222 int i; 1223 lvms_t *dev_ptr = arg; 1224 part_entry_t disk_entrie = pm_dev_list(PM_LVM_T); 1225 if (disk_entrie.retvalue < 0) 1226 return disk_entrie.retvalue; 1227 1228 for (i = 0; i < MAX_LVM_PV; i++) 1229 if (dev_ptr->pv[i].pm == NULL) { 1230 dev_ptr->pv[i].pm = disk_entrie.dev_ptr; 1231 dev_ptr->pv[i].pm_part = disk_entrie.dev_num; 1232 strlcpy(dev_ptr->pv[i].pm_name, disk_entrie.fullname, SSTRSIZE); 1233 break; 1234 } 1235 return 0; 1236 } 1237 1238 static int 1239 pm_lvm_disk_del(menudesc *m, void *arg) 1240 { 1241 int i, retvalue = -1, num_devs = 0; 1242 int menu_no; 1243 lvms_t *dev_ptr = arg; 1244 menu_ent menu_entries[MAX_LVM_PV]; 1245 part_entry_t submenu_args[MAX_LVM_PV]; 1246 1247 for (i = 0; i < MAX_LVM_PV; i++) { 1248 if (dev_ptr->pv[i].pm == NULL) 1249 continue; 1250 menu_entries[num_devs] = (struct menu_ent) { 1251 .opt_name = dev_ptr->pv[i].pm_name, 1252 .opt_action = set_menu_select, 1253 .opt_menu = OPT_NOMENU, 1254 .opt_flags = OPT_EXIT, 1255 }; 1256 submenu_args[num_devs].dev_num = i; 1257 num_devs++; 1258 } 1259 1260 menu_no = new_menu(MSG_lvm_disks, 1261 menu_entries, num_devs, -1, -1, (num_devs+1<3)?3:num_devs+1, 13, 1262 MC_SCROLL | MC_NOCLEAR, NULL, NULL, NULL, NULL, NULL); 1263 if (menu_no == -1) 1264 return -1; 1265 process_menu(menu_no, &retvalue); 1266 free_menu(menu_no); 1267 1268 if (retvalue < 0 || retvalue >= num_devs) 1269 return -1; 1270 1271 dev_ptr->pv[submenu_args[retvalue].dev_num].pm = NULL; 1272 1273 return 0; 1274 } 1275 1276 static void 1277 pm_lvm_menufmt(menudesc *m, int opt, void *arg) 1278 { 1279 int i, ok = 0, used_size = 0; 1280 char buf1[STRSIZE]; buf1[0] = '\0'; 1281 char buf2[STRSIZE]; buf2[0] = '\0'; 1282 lvms_t *dev_ptr = ((part_entry_t *)arg)[opt].dev_ptr; 1283 1284 if (dev_ptr->enabled == 0) 1285 return; 1286 snprintf(buf1, STRSIZE, "VG '%s' on ", dev_ptr->name); 1287 for (i = 0; i < MAX_LVM_PV; i++) 1288 if (dev_ptr->pv[i].pm != NULL) { 1289 strlcat(buf1, dev_ptr->pv[i].pm_name, STRSIZE); 1290 strlcat(buf1, " ", STRSIZE); 1291 ok = 1; 1292 } 1293 for (i = 0; i < MAX_LVM_LV; i++) 1294 used_size += dev_ptr->lv[i].size; 1295 if (ok) { 1296 snprintf(buf2, STRSIZE, "%d/%u", 1297 dev_ptr->total_size - used_size, dev_ptr->total_size); 1298 wprintw(m->mw, msg_string(MSG_lvm_menufmt), buf1, buf2); 1299 } else 1300 wprintw(m->mw, "%s", msg_string(MSG_lvm_err_menufmt)); 1301 return; 1302 } 1303 1304 static void 1305 pm_lvm_edit_menufmt(menudesc *m, int opt, void *arg) 1306 { 1307 int i; 1308 char buf[STRSIZE]; 1309 lvms_t *dev_ptr = arg; 1310 strlcpy(buf, msg_string(MSG_auto), STRSIZE); 1311 1312 switch (opt) { 1313 case PML_MENU_PV: 1314 buf[0] = '\0'; 1315 for (i = 0; i < MAX_LVM_PV; i++) 1316 if (dev_ptr->pv[i].pm != NULL) 1317 snprintf(buf, STRSIZE, "%s %s", buf, dev_ptr->pv[i].pm_name); 1318 wprintw(m->mw, msg_string(MSG_lvm_disks_fmt), buf); 1319 break; 1320 case PML_MENU_NAME: 1321 wprintw(m->mw, msg_string(MSG_lvm_name_fmt), dev_ptr->name); 1322 break; 1323 case PML_MENU_MAXLOGICALVOLUMES: 1324 if (dev_ptr->maxlogicalvolumes > 0) 1325 snprintf(buf, STRSIZE, "%d", dev_ptr->maxlogicalvolumes); 1326 wprintw(m->mw, msg_string(MSG_lvm_maxlv_fmt), buf); 1327 break; 1328 case PML_MENU_MAXPHYSICALVOLUMES: 1329 if (dev_ptr->maxphysicalvolumes > 0) 1330 snprintf(buf, STRSIZE, "%d", dev_ptr->maxphysicalvolumes); 1331 wprintw(m->mw, msg_string(MSG_lvm_maxpv_fmt), buf); 1332 break; 1333 case PML_MENU_PHYSICALEXTENTSIZE: 1334 if (dev_ptr->physicalextentsize > 0) 1335 snprintf(buf, STRSIZE, "%dM", dev_ptr->physicalextentsize); 1336 wprintw(m->mw, msg_string(MSG_lvm_extsiz_fmt), buf); 1337 break; 1338 } 1339 return; 1340 } 1341 1342 static int 1343 pm_lvm_set_value(menudesc *m, void *arg) 1344 { 1345 char buf[STRSIZE]; 1346 const char *msg_to_show = NULL; 1347 int *out_var = NULL; 1348 lvms_t *dev_ptr = arg; 1349 1350 static menu_ent menuent_disk_adddel[] = { 1351 {MSG_add, OPT_NOMENU, OPT_EXIT, pm_lvm_disk_add}, 1352 {MSG_remove, OPT_NOMENU, OPT_EXIT, pm_lvm_disk_del} 1353 }; 1354 static int menu_disk_adddel = -1; 1355 if (menu_disk_adddel == -1) { 1356 menu_disk_adddel = new_menu(NULL, menuent_disk_adddel, nelem(menuent_disk_adddel), 1357 -1, -1, 0, 10, MC_NOCLEAR, NULL, NULL, NULL, NULL, NULL); 1358 } 1359 1360 switch (m->cursel) { 1361 case PML_MENU_PV: 1362 process_menu(menu_disk_adddel, arg); 1363 return 0; 1364 case PML_MENU_NAME: 1365 msg_prompt_win(MSG_lvm_name_ask, -1, 18, 0, 0, dev_ptr->name, dev_ptr->name, SSTRSIZE); 1366 return 0; 1367 case PML_MENU_MAXLOGICALVOLUMES: 1368 msg_to_show = MSG_lvm_maxlv_ask; 1369 out_var = &(dev_ptr->maxlogicalvolumes); 1370 break; 1371 case PML_MENU_MAXPHYSICALVOLUMES: 1372 msg_to_show = MSG_lvm_maxpv_ask; 1373 out_var = &(dev_ptr->maxphysicalvolumes); 1374 break; 1375 case PML_MENU_PHYSICALEXTENTSIZE: 1376 msg_to_show = MSG_lvm_extsiz_ask; 1377 out_var = &(dev_ptr->physicalextentsize); 1378 break; 1379 case PML_MENU_REMOVE: 1380 dev_ptr->enabled = 0; 1381 return 0; 1382 } 1383 if (out_var == NULL || msg_to_show == NULL) 1384 return -1; 1385 snprintf(buf, SSTRSIZE, "%d", *out_var); 1386 msg_prompt_win(msg_to_show, -1, 18, 0, 0, buf, buf, SSTRSIZE); 1387 if (atoi(buf) >= 0) 1388 *out_var = atoi(buf); 1389 return 0; 1390 } 1391 1392 static void 1393 pm_lvm_init(void *arg, void* none) 1394 { 1395 lvms_t *dev_ptr = arg; 1396 1397 memset(dev_ptr, 0, sizeof *dev_ptr); 1398 *dev_ptr = (struct lvms_t) { 1399 .enabled = 1, 1400 .blocked = 0, 1401 .maxlogicalvolumes = MAX_LVM_PV, 1402 .maxphysicalvolumes = MAX_LVM_LV, 1403 .physicalextentsize = -1, 1404 }; 1405 sprintf(dev_ptr->name, "vg%.2d", rand()%100); 1406 return; 1407 } 1408 1409 static int 1410 pm_lvm_check(void *arg) 1411 { 1412 int i, ok = 0; 1413 lvms_t *dev_ptr = arg; 1414 dev_ptr->total_size = 0; 1415 1416 for (i = 0; i < MAX_LVM_PV; i++) 1417 if (dev_ptr->pv[i].pm != NULL) { 1418 ok = 1; 1419 dev_ptr->total_size += dev_ptr->pv[i].pm-> 1420 bsdlabel[dev_ptr->pv[i].pm_part].pi_size / 1421 (MEG / dev_ptr->pv[i].pm->sectorsize); 1422 } 1423 if (! ok) 1424 dev_ptr->enabled = 0; 1425 return dev_ptr->enabled; 1426 } 1427 1428 static void 1429 pm_lvmlv_menufmt(menudesc *m, int opt, void *arg) 1430 { 1431 char buf[STRSIZE]; 1432 lv_t *dev_ptr = ((part_entry_t *)arg)[opt].dev_ptr; 1433 1434 if (dev_ptr->size > 0) { 1435 snprintf(buf, STRSIZE, "'%s'", dev_ptr->name); 1436 wprintw(m->mw, msg_string(MSG_lvmlv_menufmt), buf, dev_ptr->size); 1437 } 1438 return; 1439 } 1440 1441 static void 1442 pm_lvmlv_edit_menufmt(menudesc *m, int opt, void *arg) 1443 { 1444 1445 lv_t *dev_ptr = arg; 1446 char buf[STRSIZE]; 1447 strlcpy(buf, msg_string(MSG_auto), STRSIZE); 1448 1449 switch (opt) { 1450 case PMLV_MENU_NAME: 1451 wprintw(m->mw, msg_string(MSG_lvmlv_name_fmt), dev_ptr->name); 1452 break; 1453 case PMLV_MENU_SIZE: 1454 wprintw(m->mw, msg_string(MSG_lvmlv_size_fmt), dev_ptr->size); 1455 break; 1456 case PMLV_MENU_READONLY: 1457 wprintw(m->mw, msg_string(MSG_lvmlv_ro_fmt), 1458 dev_ptr->readonly? msg_string(MSG_Yes) : msg_string(MSG_No)); 1459 break; 1460 case PMLV_MENU_CONTIGUOUS: 1461 wprintw(m->mw, msg_string(MSG_lvmlv_cont_fmt), 1462 dev_ptr->contiguous? msg_string(MSG_Yes) : msg_string(MSG_No)); 1463 break; 1464 case PMLV_MENU_EXTENTS: 1465 wprintw(m->mw, msg_string(MSG_lvmlv_extnum_fmt), 1466 (strlen(dev_ptr->extents) > 0)? dev_ptr->extents : msg_string(MSG_auto)); 1467 break; 1468 case PMLV_MENU_MINOR: 1469 if (dev_ptr->minor > 0) 1470 snprintf(buf, STRSIZE, "%dK", dev_ptr->minor); 1471 wprintw(m->mw, msg_string(MSG_lvmlv_minor_fmt), buf); 1472 break; 1473 case PMLV_MENU_MIRRORS: 1474 wprintw(m->mw, msg_string(MSG_lvmlv_mirrors_fmt), dev_ptr->mirrors); 1475 break; 1476 case PMLV_MENU_REGIONSIZE: 1477 if (dev_ptr->regionsize > 0) 1478 snprintf(buf, STRSIZE, "%dM", dev_ptr->regionsize); 1479 wprintw(m->mw, msg_string(MSG_lvmlv_regsiz_fmt), buf); 1480 break; 1481 case PMLV_MENU_PERSISTENT: 1482 wprintw(m->mw, msg_string(MSG_lvmlv_pers_fmt), 1483 dev_ptr->persistent ? msg_string(MSG_Yes) : msg_string(MSG_No)); 1484 break; 1485 case PMLV_MENU_READAHEAD: 1486 if (dev_ptr->readahead > 0) 1487 snprintf(buf, STRSIZE, "%d", dev_ptr->readahead); 1488 wprintw(m->mw, msg_string(MSG_lvmlv_readahsect_fmt), buf); 1489 break; 1490 case PMLV_MENU_STRIPES: 1491 if (dev_ptr->stripes > 0) 1492 snprintf(buf, STRSIZE, "%d", dev_ptr->stripes); 1493 wprintw(m->mw, msg_string(MSG_lvmlv_stripes_fmt), buf); 1494 break; 1495 case PMLV_MENU_STRIPESIZE: 1496 if (dev_ptr->stripesize > 0) 1497 snprintf(buf, STRSIZE, "%dK", dev_ptr->stripesize); 1498 wprintw(m->mw, msg_string(MSG_lvmlv_stripesiz_fmt), buf); 1499 break; 1500 case PMLV_MENU_ZERO: 1501 wprintw(m->mw, msg_string(MSG_lvmlv_zero_fmt), 1502 dev_ptr->zero? msg_string(MSG_Yes) : msg_string(MSG_No)); 1503 break; 1504 } 1505 return; 1506 } 1507 1508 static int 1509 pm_lvmlv_set_value(menudesc *m, void *arg) 1510 { 1511 char buf[STRSIZE]; 1512 const char *msg_to_show = NULL; 1513 int *out_var = NULL; 1514 lv_t *dev_ptr = arg; 1515 1516 switch (m->cursel) { 1517 case PMLV_MENU_NAME: 1518 msg_prompt_win(MSG_lvmlv_name_ask, -1, 18, 0, 0, dev_ptr->name, dev_ptr->name, 1519 SSTRSIZE); 1520 return 0; 1521 case PMLV_MENU_SIZE: 1522 msg_to_show = MSG_lvmlv_size_ask; 1523 out_var = &(dev_ptr->size); 1524 break; 1525 case PMLV_MENU_READONLY: 1526 dev_ptr->readonly = !dev_ptr->readonly; 1527 return 0; 1528 case PMLV_MENU_CONTIGUOUS: 1529 dev_ptr->contiguous = !dev_ptr->contiguous; 1530 return 0; 1531 case PMLV_MENU_EXTENTS: 1532 msg_prompt_win(MSG_lvmlv_extnum_ask, -1, 18, 0, 0, 1533 dev_ptr->extents, dev_ptr->extents, SSTRSIZE); 1534 return 0; 1535 case PMLV_MENU_MINOR: 1536 msg_to_show = MSG_lvmlv_minor_ask; 1537 out_var = &(dev_ptr->minor); 1538 break; 1539 case PMLV_MENU_MIRRORS: 1540 msg_to_show = MSG_lvmlv_mirrors_ask; 1541 out_var = &(dev_ptr->mirrors); 1542 break; 1543 case PMLV_MENU_REGIONSIZE: 1544 msg_to_show = MSG_lvmlv_regsiz_ask; 1545 out_var = &(dev_ptr->regionsize); 1546 break; 1547 case PMLV_MENU_PERSISTENT: 1548 dev_ptr->persistent = !dev_ptr->persistent; 1549 return 0; 1550 case PMLV_MENU_READAHEAD: 1551 msg_to_show = MSG_lvmlv_readahsect_ask; 1552 out_var = &(dev_ptr->readahead); 1553 break; 1554 case PMLV_MENU_STRIPES: 1555 msg_to_show = MSG_lvmlv_stripes_ask; 1556 out_var = &(dev_ptr->stripes); 1557 break; 1558 case PMLV_MENU_STRIPESIZE: 1559 if (dev_ptr->stripesize << 1 > 512) 1560 dev_ptr->stripesize = 4; 1561 else 1562 dev_ptr->stripesize <<= 1; 1563 return 0; 1564 case PMLV_MENU_ZERO: 1565 dev_ptr->zero = !dev_ptr->zero; 1566 return 0; 1567 case PMLV_MENU_REMOVE: 1568 dev_ptr->size = 0; 1569 return 0; 1570 } 1571 if (out_var == NULL || msg_to_show == NULL) 1572 return -1; 1573 snprintf(buf, SSTRSIZE, "%d", *out_var); 1574 msg_prompt_win(msg_to_show, -1, 18, 0, 0, buf, buf, SSTRSIZE); 1575 if (atoi(buf) >= 0) 1576 *out_var = atoi(buf); 1577 return 0; 1578 } 1579 1580 static void 1581 pm_lvmlv_init(void *arg, void *none) 1582 { 1583 lv_t *dev_ptr = arg; 1584 memset(dev_ptr, 0, sizeof *(dev_ptr)); 1585 *dev_ptr = (struct lv_t) { 1586 .blocked = 0, 1587 .size = 1024, 1588 .stripesize = 64, 1589 }; 1590 sprintf (dev_ptr->name, "lvol%.2d", rand()%100); 1591 return; 1592 } 1593 1594 static int 1595 pm_lvmlv_check(void *arg) 1596 { 1597 lv_t *dev_ptr = arg; 1598 if (dev_ptr->size > 0 && strlen(dev_ptr->name) > 0) 1599 return 1; 1600 else { 1601 dev_ptr->size = 0; 1602 return 0; 1603 } 1604 } 1605 1606 static int 1607 pm_lvm_commit(void) 1608 { 1609 int i, ii, error; 1610 uint used_size = 0; 1611 char params[STRSIZE*3]; 1612 char devs[STRSIZE*3]; 1613 1614 for (i = 0; i < MAX_LVM_VG; i++) { 1615 /* Stage 0: checks */ 1616 if (! pm_lvm_check(&lvms[i])) 1617 continue; 1618 for (ii = 0; ii < MAX_LVM_LV; ii++) 1619 used_size += lvms[i].lv[ii].size; 1620 if (used_size > lvms[i].total_size) 1621 continue; 1622 1623 params[0] = '\0'; 1624 devs[0] = '\0'; 1625 error = 0; 1626 /* Stage 1: creating Physical Volumes (PV's) */ 1627 for (ii = 0; ii < MAX_LVM_PV && ! error; ii++) 1628 if (lvms[i].pv[ii].pm != NULL) { 1629 run_program(RUN_SILENT | RUN_ERROR_OK, 1630 "lvm pvremove -ffy /dev/r%s", 1631 (char*)lvms[i].pv[ii].pm_name); 1632 error += run_program(RUN_DISPLAY | RUN_PROGRESS, 1633 "lvm pvcreate -ffy /dev/r%s", 1634 (char*)lvms[i].pv[ii].pm_name); 1635 if (error) 1636 break; 1637 snprintf(devs, STRSIZE*3, "%s /dev/r%s", devs, (char*)lvms[i].pv[ii].pm_name); 1638 } 1639 if (error) 1640 continue; 1641 /* Stage 2: creating Volume Groups (VG's) */ 1642 if (lvms[i].maxlogicalvolumes > 0) 1643 snprintf(params, STRSIZE*3, "%s -l %d", params, lvms[i].maxlogicalvolumes); 1644 if (lvms[i].maxphysicalvolumes > 0) 1645 snprintf(params, STRSIZE*3, "%s -p %d", params, lvms[i].maxphysicalvolumes); 1646 if (lvms[i].physicalextentsize > 0) 1647 snprintf(params, STRSIZE*3, "%s -s %d", params, lvms[i].physicalextentsize); 1648 error += run_program(RUN_DISPLAY | RUN_PROGRESS, "lvm vgcreate %s %s %s", 1649 params, lvms[i].name, devs); 1650 if (error) 1651 continue; 1652 /* Stage 3: creating Logical Volumes (LV's) */ 1653 for (ii = 0; ii < MAX_LVM_LV; ii++) { 1654 if (lvms[i].lv[ii].size <= 0) 1655 continue; 1656 1657 params[0] = '\0'; 1658 snprintf(params, STRSIZE*3, "%s -C %c", params, lvms[i].lv[ii].contiguous?'y':'n'); 1659 snprintf(params, STRSIZE*3, "%s -M %c", params, lvms[i].lv[ii].persistent?'y':'n'); 1660 snprintf(params, STRSIZE*3, "%s -p %s", params, lvms[i].lv[ii].readonly?"r":"rw"); 1661 snprintf(params, STRSIZE*3, "%s -Z %c", params, lvms[i].lv[ii].zero?'y':'n'); 1662 if (strlen(lvms[i].lv[ii].name) > 0) 1663 snprintf(params, STRSIZE*3, "%s -n %s", params, lvms[i].lv[ii].name); 1664 if (strlen(lvms[i].lv[ii].extents) > 0) 1665 snprintf(params, STRSIZE*3, "%s -l %s", params, lvms[i].lv[ii].extents); 1666 if (lvms[i].lv[ii].minor > 0) 1667 snprintf(params, STRSIZE*3, "%s --minor %d", params, lvms[i].lv[ii].minor); 1668 if (lvms[i].lv[ii].mirrors > 0) { 1669 snprintf(params, STRSIZE*3, "%s -m %d", params, lvms[i].lv[ii].mirrors); 1670 if (lvms[i].lv[ii].regionsize > 0) 1671 snprintf(params, STRSIZE*3, "%s -R %d", params, lvms[i].lv[ii].regionsize); 1672 } 1673 if (lvms[i].lv[ii].readahead > 0) 1674 snprintf(params, STRSIZE*3, "%s -r %d", params, lvms[i].lv[ii].readahead); 1675 if (lvms[i].lv[ii].stripes > 0) { 1676 snprintf(params, STRSIZE*3, "%s -i %d", params, lvms[i].lv[ii].stripes); 1677 if (lvms[i].lv[ii].stripesize > 0) 1678 snprintf(params, STRSIZE*3, "%s -I %d", params, lvms[i].lv[ii].stripesize); 1679 } 1680 snprintf(params, STRSIZE*3, "%s -L %uM", params, lvms[i].lv[ii].size); 1681 error += run_program(RUN_DISPLAY | RUN_PROGRESS, "lvm lvcreate %s %s", 1682 params, lvms[i].name); 1683 } 1684 if (! error) { 1685 lvms[i].blocked = 1; 1686 for (ii = 0; ii < MAX_LVM_PV; ii++) 1687 if (lvms[i].pv[ii].pm != NULL) 1688 lvms[i].pv[ii].pm->blocked++; 1689 for (ii = 0; ii < MAX_LVM_LV; ii++) 1690 if (lvms[i].lv[ii].size > 0) 1691 lvms[i].lv[ii].blocked = 1; 1692 } 1693 } 1694 1695 return 0; 1696 } 1697 1698 /*** 1699 GPT 1700 ***/ 1701 1702 int 1703 pm_gpt_convert(pm_devs_t *pm_cur) 1704 { 1705 int i, error = 0; 1706 1707 msg_display(MSG_removepartswarn); 1708 if (!ask_noyes(NULL)) 1709 return -1; 1710 1711 if (! pm_cur->gpt) 1712 error = run_program(RUN_DISPLAY | RUN_PROGRESS, "gpt create -f %s", 1713 pm_cur->diskdev); 1714 else { 1715 error = run_program(RUN_DISPLAY | RUN_PROGRESS, "gpt destroy %s", 1716 pm_cur->diskdev); 1717 for (i = 0; i < MAX_WEDGES; i++) 1718 if (wedges[i].pm == pm_cur) 1719 wedges[i].pm = NULL; 1720 } 1721 if (!error) { 1722 pm_cur->gpt = !pm_cur->gpt; 1723 pm_select(pm_cur); 1724 label_read(); 1725 } 1726 return error; 1727 } 1728 1729 static int 1730 pm_wedge_getfree(void) 1731 { 1732 int i; 1733 for (i = 0; i < MAX_WEDGES; i++) 1734 if (! wedges[i].allocated && wedges[i].pm == NULL) 1735 return i; 1736 return -1; 1737 } 1738 1739 void 1740 pm_wedges_fill(pm_devs_t *pm_cur) 1741 { 1742 int i, current; 1743 1744 for (i = 0; i < MAX_WEDGES; i++) 1745 if (wedges[i].pm == pm_cur && ! wedges[i].allocated) 1746 wedges[i].pm = NULL; 1747 1748 for (i = 0; i < min(MAXPARTITIONS,MAX_WEDGES); i++) 1749 if (pm_cur->bsdlabel[i].pi_fstype != FS_UNUSED) { 1750 current = pm_wedge_getfree(); 1751 if (current < 0) { 1752 process_menu(MENU_ok, deconst(MSG_limitcount)); 1753 return; 1754 } 1755 wedges[current].pm = pm_cur; 1756 wedges[current].ptn = i; 1757 } 1758 return; 1759 } 1760 1761 static int 1762 pm_wedge_create(int num, pm_devs_t **pm_dk) 1763 { 1764 int i, ii, hackerr, error; 1765 partinfo *p = &(wedges[num].pm->bsdlabel[wedges[num].ptn]); 1766 1767 if (num > MAX_WEDGES) 1768 return -1; 1769 1770 /* There is no ability to use required dkX device, so that's a hack */ 1771 for (i = 0; i < num; i++) 1772 if (! wedges[i].allocated) { 1773 hackerr = 1; 1774 for (ii = 0; hackerr && ii < 3; ii++) 1775 hackerr = run_program(RUN_SILENT | RUN_ERROR_OK, 1776 "dkctl %s addwedge HACK%d %d %d unused", 1777 wedges[num].pm->diskdev, 1778 rand()%33, rand()%33, 0); 1779 wedges[i].todel = 1; 1780 } 1781 1782 run_program(RUN_SILENT | RUN_ERROR_OK, 1783 "dkctl %s listwedges", wedges[num].pm->diskdev); 1784 1785 error = run_program(RUN_DISPLAY | RUN_PROGRESS, 1786 "dkctl %s addwedge dk%d %u %u %s", 1787 wedges[num].pm->diskdev, 1788 num, 1789 p->pi_offset, 1790 p->pi_size, 1791 getfstypename(p->pi_fstype)); 1792 if (!error) { 1793 wedges[num].allocated = 1; 1794 wedges[num].pm->blocked++; 1795 if (pm_dk != NULL) { 1796 *pm_dk = malloc(sizeof(pm_devs_t)); 1797 memset(*pm_dk, 0, sizeof **pm_dk); 1798 memcpy(&(*pm_dk)->bsdlabel[0], p, sizeof (*pm_dk)->bsdlabel[0]); 1799 (*pm_dk)->found = -1; 1800 (*pm_dk)->isspecial = 1; 1801 (*pm_dk)->sectorsize = 512; /* XXX: xxx */ 1802 (*pm_dk)->dlcylsize = MEG; 1803 (*pm_dk)->refdev = wedges[num].pm; 1804 snprintf((*pm_dk)->diskdev, SSTRSIZE, "dk%d", num); 1805 snprintf((*pm_dk)->diskdev_descr, STRSIZE, " %s (%s)", 1806 (*pm_dk)->diskdev, getfstypename(p->pi_fstype)); 1807 } 1808 } else 1809 if (logfp) 1810 fprintf(logfp, "Cannot create wedge dk%d for %s.\n", 1811 num, wedges[num].pm->diskdev); 1812 1813 /* Hack, see above */ 1814 for (i = 0; i < num; i ++) 1815 if (! wedges[i].allocated && wedges[i].todel) { 1816 hackerr = run_program(RUN_SILENT | RUN_ERROR_OK, 1817 "dkctl %s delwedge dk%d", wedges[num].pm->diskdev, i); 1818 (void)hackerr; /* XXX */ 1819 wedges[i].todel = 0; 1820 } 1821 1822 return error; 1823 } 1824 1825 static int 1826 pm_gpt_commit(void) 1827 { 1828 uint i, error; 1829 pm_devs_t *pm_i, *pm_dk = NULL; 1830 char fstype[STRSIZE]; fstype[0] = '\0'; 1831 partinfo *p; 1832 1833 SLIST_FOREACH(pm_i, &pm_head, l) 1834 if (pm_i->gpt && pm_i->unsaved) 1835 run_program(RUN_DISPLAY | RUN_PROGRESS, 1836 "gpt remove -a %s", 1837 pm_i->diskdev); 1838 1839 for (i = 0; i < MAX_WEDGES; i++) { 1840 if (wedges[i].pm == NULL || 1841 ! wedges[i].pm->unsaved || 1842 wedges[i].ptn < 0) 1843 continue; 1844 error = 0; 1845 p = &(wedges[i].pm->bsdlabel[wedges[i].ptn]); 1846 if (wedges[i].pm->gpt) { 1847 if (get_gptfs_by_id(p->pi_fstype) != NULL) 1848 snprintf(fstype, STRSIZE, "-t %s", get_gptfs_by_id(p->pi_fstype)); 1849 error += run_program(RUN_DISPLAY | RUN_PROGRESS, 1850 "gpt add -i %u -b %u -s %u %s %s", 1851 wedges[i].ptn + 1, 1852 p->pi_offset, p->pi_size, 1853 fstype, wedges[i].pm->diskdev); 1854 } 1855 1856 if (error || wedges[i].allocated) { 1857 if (logfp && error) 1858 fprintf(logfp, "Cannot create GPT partition #%d on %s\n", 1859 i, wedges[i].pm->diskdev); 1860 continue; 1861 } 1862 1863 error += pm_wedge_create(i, &pm_dk); 1864 if (pm_dk != NULL) { 1865 /* Create file system on wedge and add it to list */ 1866 pm_select(pm_dk); 1867 make_filesystems(); 1868 SLIST_INSERT_AFTER(wedges[i].pm, pm_dk, l); 1869 memset(p, 0, sizeof *p); 1870 if (error) 1871 return -1; 1872 } 1873 } 1874 1875 SLIST_FOREACH(pm_i, &pm_head, l) 1876 if (pm_i->gpt && pm_i->unsaved) 1877 pm_i->unsaved = 0; 1878 1879 return 0; 1880 } 1881 1882 /*** 1883 Partman generic functions 1884 ***/ 1885 1886 int 1887 pm_getrefdev(pm_devs_t *pm_cur) 1888 { 1889 int i, ii, dev_num, num_devs, num_devs_s; 1890 char dev[SSTRSIZE]; dev[0] = '\0'; 1891 1892 pm_cur->refdev = NULL; 1893 if (! strncmp(pm_cur->diskdev, "cgd", 3)) { 1894 dev_num = pm_cur->diskdev[3] - '0'; 1895 for (i = 0; i < MAX_CGD; i++) 1896 if (cgds[i].blocked && cgds[i].node == dev_num) { 1897 pm_cur->refdev = &cgds[i]; 1898 1899 snprintf(pm_cur->diskdev_descr, STRSIZE, "%s (%s, %s-%d)", 1900 pm_cur->diskdev_descr, cgds[i].pm_name, 1901 cgds[i].enc_type, cgds[i].key_size); 1902 break; 1903 } 1904 } else if (! strncmp(pm_cur->diskdev, "vnd", 3)) { 1905 dev_num = pm_cur->diskdev[3] - '0'; 1906 for (i = 0; i < MAX_VND; i++) 1907 if (vnds[i].blocked && vnds[i].node == dev_num) { 1908 pm_cur->refdev = &vnds[i]; 1909 pm_getdevstring(dev, SSTRSIZE, vnds[i].pm, vnds[i].pm_part); 1910 snprintf(pm_cur->diskdev_descr, STRSIZE, "%s (%s, %s)", 1911 pm_cur->diskdev_descr, dev, vnds[i].filepath); 1912 break; 1913 } 1914 } else if (! strncmp(pm_cur->diskdev, "raid", 4)) { 1915 dev_num = pm_cur->diskdev[4] - '0'; 1916 for (i = 0; i < MAX_RAID; i++) 1917 if (raids[i].blocked && raids[i].node == dev_num) { 1918 pm_cur->refdev = &raids[i]; 1919 num_devs = 0; num_devs_s = 0; 1920 for (ii = 0; ii < MAX_IN_RAID; ii++) 1921 if (raids[i].pm[ii] != NULL) { 1922 if(raids[i].pm_is_spare[ii]) 1923 num_devs_s++; 1924 else 1925 num_devs++; 1926 } 1927 snprintf(pm_cur->diskdev_descr, STRSIZE, 1928 "%s (lvl %d, %d disks, %d spare)", pm_cur->diskdev_descr, 1929 raids[i].raid_level, num_devs, num_devs_s); 1930 break; 1931 } 1932 } else 1933 return -1; 1934 return 0; 1935 } 1936 1937 /* Detect that partition is in use */ 1938 int 1939 pm_partusage(pm_devs_t *pm_cur, int part_num, int do_del) 1940 { 1941 int i, ii, retvalue = 0; 1942 1943 if (part_num < 0) { 1944 /* Check all partitions on device */ 1945 for (i = 0; i < MAXPARTITIONS; i++) 1946 retvalue += pm_partusage(pm_cur, i, do_del); 1947 return retvalue; 1948 } 1949 1950 for (i = 0; i < MAX_CGD; i++) 1951 if (cgds[i].enabled && 1952 cgds[i].pm == pm_cur && 1953 cgds[i].pm_part == part_num) { 1954 if (do_del) { 1955 cgds[i].pm = NULL; 1956 strcpy(cgds[i].pm_name, ""); 1957 } 1958 return 1; 1959 } 1960 for (i = 0; i < MAX_RAID; i++) 1961 for (ii = 0; ii < MAX_IN_RAID; ii++) 1962 if (raids[i].enabled && 1963 raids[i].pm[ii] == pm_cur && 1964 raids[i].pm_part[ii] == part_num) { 1965 if (do_del) 1966 raids[i].pm[ii] = NULL; 1967 return 1; 1968 } 1969 for (i = 0; i < MAX_LVM_VG; i++) 1970 for (ii = 0; ii < MAX_LVM_PV; ii++) 1971 if (lvms[i].enabled && 1972 lvms[i].pv[ii].pm == pm_cur && 1973 lvms[i].pv[ii].pm_part == part_num) { 1974 if (do_del) 1975 lvms[i].pv[ii].pm = NULL; 1976 return 1; 1977 } 1978 1979 return 0; 1980 } 1981 1982 /* Clean up removed devices */ 1983 static int 1984 pm_clean(void) 1985 { 1986 int count = 0; 1987 pm_devs_t *pm_i; 1988 1989 SLIST_FOREACH(pm_i, &pm_head, l) 1990 if (! pm_i->found) { 1991 count++; 1992 SLIST_REMOVE(&pm_head, pm_i, pm_devs_t, l); 1993 free(pm_i); 1994 } 1995 return count; 1996 } 1997 1998 void 1999 pm_make_bsd_partitions(pm_devs_t *pm_cur) 2000 { 2001 int i; 2002 partinfo baklabel[MAXPARTITIONS]; 2003 memcpy(baklabel, &pm_cur->bsdlabel, sizeof baklabel); 2004 2005 pm_cur->unsaved = 1; 2006 layoutkind = LY_SETNEW; 2007 md_make_bsd_partitions(); 2008 pm_cur->bootable = (pm_cur->bsdlabel[pm_cur->rootpart].pi_flags & PIF_MOUNT) ? 2009 1 : 0; 2010 for (i = 0; i < MAXPARTITIONS; i++) 2011 if (pm_cur->bsdlabel[i].pi_fstype != baklabel[i].pi_fstype || 2012 pm_cur->bsdlabel[i].lvmpv != baklabel[i].lvmpv) 2013 pm_partusage(pm_cur, i, 1); 2014 } 2015 2016 void 2017 pm_setfstype(pm_devs_t *pm_cur, int part_num, int fstype) 2018 { 2019 pm_cur->bsdlabel[part_num].pi_mount[0] = '\0'; 2020 pm_cur->bsdlabel[part_num].pi_flags = 0; 2021 pm_cur->bsdlabel[part_num].lvmpv = 0; 2022 pm_cur->bsdlabel[part_num].pi_fstype = fstype; 2023 return; 2024 } 2025 2026 static void 2027 pm_select(pm_devs_t *pm_devs_in) 2028 { 2029 pm = pm_devs_in; 2030 if (logfp) 2031 (void)fprintf(logfp, "Partman device: %s\n", pm->diskdev); 2032 return; 2033 } 2034 2035 void 2036 pm_rename(pm_devs_t *pm_cur) 2037 { 2038 pm_select(pm_cur); 2039 msg_prompt_win(MSG_packname, -1, 18, 0, 0, pm_cur->bsddiskname, 2040 pm_cur->bsddiskname, sizeof pm_cur->bsddiskname); 2041 #ifndef NO_DISKLABEL 2042 (void) savenewlabel(pm_cur->bsdlabel, MAXPARTITIONS); 2043 #endif 2044 return; 2045 } 2046 2047 int 2048 pm_editpart(int part_num) 2049 { 2050 partinfo backup = pm->bsdlabel[part_num]; 2051 2052 edit_ptn(&(struct menudesc){.cursel = part_num}, NULL); 2053 if (checkoverlap(pm->bsdlabel, MAXPARTITIONS, PART_D, PART_C)) { 2054 msg_display_add(MSG_cantsave); 2055 process_menu(MENU_ok, NULL); 2056 pm->bsdlabel[part_num] = backup; 2057 return -1; 2058 } 2059 pm->unsaved = 1; 2060 return 0; 2061 } 2062 2063 /* Safe erase of disk */ 2064 int 2065 pm_shred(pm_devs_t *pm_cur, int part, int shredtype) 2066 { 2067 int error = -1; 2068 char dev[SSTRSIZE]; 2069 2070 pm_getdevstring(dev, SSTRSIZE, pm_cur, part); 2071 switch(shredtype) { 2072 case SHRED_ZEROS: 2073 error += run_program(RUN_DISPLAY | RUN_PROGRESS, 2074 "dd of=/dev/%s if=/dev/zero bs=1m progress=100 msgfmt=human", 2075 dev); 2076 break; 2077 case SHRED_RANDOM: 2078 error += run_program(RUN_DISPLAY | RUN_PROGRESS, 2079 "dd of=/dev/%s if=/dev/urandom bs=1m progress=100 msgfmt=human", 2080 dev); 2081 break; 2082 case SHRED_CRYPTO: 2083 error += run_program(RUN_DISPLAY | RUN_PROGRESS, 2084 "sh -c 'cgdconfig -s cgd0 /dev/%s aes-cbc 128 < /dev/urandom'", 2085 dev); /* XXX: cgd0?! */ 2086 if (! error) { 2087 error += run_program(RUN_DISPLAY | RUN_PROGRESS, 2088 "dd of=/dev/rcgd0d if=/dev/urandom bs=1m progress=100 msgfmt=human"); 2089 error += run_program(RUN_DISPLAY | RUN_PROGRESS, 2090 "cgdconfig -u cgd0"); 2091 } 2092 break; 2093 default: 2094 return -1; 2095 } 2096 pm_partusage(pm_cur, -1, 1); 2097 memset(&pm_cur->oldlabel, 0, sizeof pm_cur->oldlabel); 2098 memset(&pm_cur->bsdlabel, 0, sizeof pm_cur->bsdlabel); 2099 return error; 2100 } 2101 2102 static int 2103 pm_mountall_sort(const void *a, const void *b) 2104 { 2105 return strcmp(mnts[*(const int *)a].on, mnts[*(const int *)b].on); 2106 } 2107 2108 /* Mount all available partitions */ 2109 static int 2110 pm_mountall(void) 2111 { 2112 int num_devs = 0; 2113 int mnts_order[MAX_MNTS]; 2114 int i, ii, error, ok; 2115 char dev[SSTRSIZE]; dev[0] = '\0'; 2116 pm_devs_t *pm_i; 2117 2118 localfs_dev[0] = '\0'; 2119 if (mnts == NULL) 2120 mnts = calloc(MAX_MNTS, sizeof(*mnts)); 2121 2122 SLIST_FOREACH(pm_i, &pm_head, l) { 2123 ok = 0; 2124 for (i = 0; i < MAXPARTITIONS; i++) { 2125 if (!(pm_i->bsdlabel[i].pi_flags & PIF_MOUNT && 2126 pm_i->bsdlabel[i].mnt_opts != NULL)) 2127 continue; 2128 mnts[num_devs].mnt_opts = pm_i->bsdlabel[i].mnt_opts; 2129 if (strlen(pm_i->bsdlabel[i].mounted) > 0) { 2130 /* Device is already mounted. So, doing mount_null */ 2131 strlcpy(mnts[num_devs].dev, pm_i->bsdlabel[i].mounted, MOUNTLEN); 2132 mnts[num_devs].mnt_opts = "-t null"; 2133 } else { 2134 pm_getdevstring(dev, SSTRSIZE, pm_i, i); 2135 snprintf(mnts[num_devs].dev, STRSIZE, "/dev/%s", dev); 2136 } 2137 mnts[num_devs].on = pm_i->bsdlabel[i].pi_mount; 2138 if (strcmp(pm_i->bsdlabel[i].pi_mount, "/") == 0) { 2139 if (pm_i->isspecial) 2140 pm_i->bootable = 1; 2141 /* Use disk with / as a default if the user has 2142 the sets on a local disk */ 2143 strlcpy(localfs_dev, pm_i->diskdev, SSTRSIZE); 2144 } 2145 num_devs++; 2146 ok = 1; 2147 } 2148 if (ok) 2149 md_pre_mount(); 2150 } 2151 if (strlen(localfs_dev) < 1) { 2152 msg_display(MSG_noroot); 2153 process_menu(MENU_ok, NULL); 2154 return -1; 2155 } 2156 for (i = 0; i < num_devs; i++) 2157 mnts_order[i] = i; 2158 qsort(mnts_order, num_devs, sizeof mnts_order[0], pm_mountall_sort); 2159 2160 for (i = 0; i < num_devs; i++) { 2161 ii = mnts_order[i]; 2162 make_target_dir(mnts[ii].on); 2163 error = target_mount_do(mnts[ii].mnt_opts, mnts[ii].dev, mnts[ii].on); 2164 if (error) 2165 return error; 2166 } 2167 return 0; 2168 } 2169 2170 /* Mount partition bypassing ordinary order */ 2171 static int 2172 pm_mount(pm_devs_t *pm_cur, int part_num) 2173 { 2174 int error = 0; 2175 char buf[MOUNTLEN]; 2176 2177 if (strlen(pm_cur->bsdlabel[part_num].mounted) > 0) 2178 return 0; 2179 2180 snprintf(buf, MOUNTLEN, "/tmp/%s%c", pm_cur->diskdev, part_num + 'a'); 2181 if (! dir_exists_p(buf)) 2182 run_program(RUN_DISPLAY | RUN_PROGRESS, "/bin/mkdir -p %s", buf); 2183 if (pm_cur->bsdlabel[part_num].pi_flags & PIF_MOUNT && 2184 pm_cur->bsdlabel[part_num].mnt_opts != NULL && 2185 strlen(pm_cur->bsdlabel[part_num].mounted) < 1) 2186 error += run_program(RUN_DISPLAY | RUN_PROGRESS, "/sbin/mount %s /dev/%s%c %s", 2187 pm_cur->bsdlabel[part_num].mnt_opts, 2188 pm_cur->diskdev, part_num + 'a', buf); 2189 2190 if (error) 2191 pm_cur->bsdlabel[part_num].mounted[0] = '\0'; 2192 else { 2193 strlcpy(pm_cur->bsdlabel[part_num].mounted, buf, MOUNTLEN); 2194 pm_cur->blocked++; 2195 } 2196 return error; 2197 } 2198 2199 void 2200 pm_umount(pm_devs_t *pm_cur, int part_num) 2201 { 2202 char buf[SSTRSIZE]; buf[0] = '\0'; 2203 pm_getdevstring(buf, SSTRSIZE, pm_cur, part_num); 2204 2205 if (run_program(RUN_DISPLAY | RUN_PROGRESS, 2206 "umount -f /dev/%s", buf) == 0) { 2207 pm_cur->bsdlabel[part_num].mounted[0] = '\0'; 2208 if (pm_cur->blocked > 0) 2209 pm_cur->blocked--; 2210 } 2211 return; 2212 } 2213 2214 int 2215 pm_unconfigure(pm_devs_t *pm_cur) 2216 { 2217 int i, error = 0, num = 0; 2218 if (! strncmp(pm_cur->diskdev, "cgd", 3)) { 2219 error = run_program(RUN_DISPLAY | RUN_PROGRESS, "cgdconfig -u %s", pm_cur->diskdev); 2220 if (! error && pm_cur->refdev != NULL) { 2221 ((cgds_t*)pm_cur->refdev)->pm->blocked--; 2222 ((cgds_t*)pm_cur->refdev)->blocked = 0; 2223 } 2224 } else if (! strncmp(pm_cur->diskdev, "vnd", 3)) { 2225 error = run_program(RUN_DISPLAY | RUN_PROGRESS, "vnconfig -u %s", pm_cur->diskdev); 2226 if (! error && pm_cur->refdev != NULL) { 2227 ((vnds_t*)pm_cur->refdev)->pm->blocked--; 2228 ((vnds_t*)pm_cur->refdev)->blocked = 0; 2229 } 2230 } else if (! strncmp(pm_cur->diskdev, "raid", 4)) { 2231 error = run_program(RUN_DISPLAY | RUN_PROGRESS, "raidctl -u %s", pm_cur->diskdev); 2232 if (! error && pm_cur->refdev != NULL) { 2233 ((raids_t*)pm_cur->refdev)->blocked = 0; 2234 for (i = 0; i < MAX_IN_RAID; i++) 2235 if (((raids_t*)pm_cur->refdev)->pm[i] != NULL) 2236 ((raids_t*)pm_cur->refdev)->pm[i]->blocked--; 2237 } 2238 } else if (! strncmp(pm_cur->diskdev, "dk", 2)) { 2239 if (pm_cur->refdev == NULL) 2240 return -2; 2241 error = run_program(RUN_DISPLAY | RUN_PROGRESS, "dkctl %s delwedge %s", 2242 ((pm_devs_t*)pm_cur->refdev)->diskdev, pm_cur->diskdev); 2243 if (! error) { 2244 if (pm_cur->refdev != NULL && ((pm_devs_t*)pm_cur->refdev)->blocked > 0) 2245 ((pm_devs_t*)pm_cur->refdev)->blocked--; 2246 sscanf(pm_cur->diskdev, "dk%d", &num); 2247 if (num >= 0 && num < MAX_WEDGES) 2248 wedges[num].allocated = 0; 2249 } 2250 } /* XXX: lvm */ 2251 else 2252 error = run_program(RUN_DISPLAY | RUN_PROGRESS, "eject -t disk /dev/%sd", 2253 pm_cur->diskdev); 2254 if (!error) 2255 pm_cur->found = 0; 2256 return error; 2257 } 2258 2259 /* Last checks before leaving partition manager */ 2260 static int 2261 pm_lastcheck(void) 2262 { 2263 FILE *file_tmp = fopen(concat_paths(targetroot_mnt, "/etc/fstab"), "r"); 2264 if (file_tmp == NULL) 2265 return 1; 2266 fclose(file_tmp); 2267 return 0; 2268 } 2269 2270 /* Are there unsaved changes? */ 2271 static int 2272 pm_needsave(void) 2273 { 2274 pm_devs_t *pm_i; 2275 SLIST_FOREACH(pm_i, &pm_head, l) 2276 if (pm_i->unsaved) { 2277 /* Oops, we have unsaved changes */ 2278 changed = 1; 2279 msg_display(MSG_saveprompt); 2280 return ask_yesno(NULL); 2281 } 2282 return 0; 2283 } 2284 2285 /* Write all changes to disk */ 2286 static int 2287 pm_commit(menudesc *m, void *arg) 2288 { 2289 int retcode; 2290 pm_devs_t *pm_i; 2291 if (m != NULL && arg != NULL) 2292 ((part_entry_t *)arg)[0].retvalue = m->cursel + 1; 2293 2294 pm_gpt_commit(); 2295 2296 SLIST_FOREACH(pm_i, &pm_head, l) { 2297 if (! pm_i->unsaved) 2298 continue; 2299 pm_select(pm_i); 2300 2301 if (pm_i->isspecial) { 2302 if (make_filesystems() != 0) { 2303 if (logfp) 2304 fprintf(logfp, "Special disk %s preparing error\n", pm_i->diskdev); 2305 continue; 2306 } 2307 pm_i->unsaved = 0; 2308 } else if (! pm_i->gpt) { 2309 #ifndef NO_DISKLABEL 2310 savenewlabel(pm_i->bsdlabel, MAXPARTITIONS); 2311 #endif 2312 if ( 2313 write_disklabel() != 0 || /* Write slices table (disklabel) */ 2314 set_swap_if_low_ram(pm->diskdev, pm->bsdlabel) != 0 || 2315 md_post_disklabel() != 0 || /* Enable swap and check badblock */ 2316 make_filesystems() != 0 /* Create filesystems with newfs */ 2317 ) { 2318 /* Oops, something failed... */ 2319 if (logfp) 2320 fprintf(logfp, "Disk %s preparing error\n", pm_i->diskdev); 2321 continue; 2322 } 2323 pm_i->unsaved = 0; 2324 } 2325 } 2326 2327 /* Call all functions that may create new devices */ 2328 if ((retcode = pm_raid_commit()) != 0) { 2329 if (logfp) 2330 fprintf(logfp, "RAIDframe configuring error #%d\n", retcode); 2331 return -1; 2332 } 2333 if ((retcode = pm_cgd_commit()) != 0) { 2334 if (logfp) 2335 fprintf(logfp, "CGD configuring error #%d\n", retcode); 2336 return -1; 2337 } 2338 if ((retcode = pm_lvm_commit()) != 0) { 2339 if (logfp) 2340 fprintf(logfp, "LVM configuring error #%d\n", retcode); 2341 return -1; 2342 } 2343 if ((retcode = pm_vnd_commit()) != 0) { 2344 if (logfp) 2345 fprintf(logfp, "VND configuring error #%d\n", retcode); 2346 return -1; 2347 } 2348 if (m != NULL && arg != NULL) 2349 pm_upddevlist(m, arg); 2350 if (logfp) 2351 fflush (logfp); 2352 return 0; 2353 } 2354 2355 static int 2356 pm_savebootsector(void) 2357 { 2358 pm_devs_t *pm_i; 2359 SLIST_FOREACH(pm_i, &pm_head, l) 2360 if (pm_i->bootable) { 2361 if (! strncmp("raid", pm_i->diskdev, 4)) 2362 if (run_program(RUN_DISPLAY | RUN_PROGRESS, 2363 "raidctl -v -A root %s", pm_i->diskdev) != 0) { 2364 if (logfp) 2365 fprintf(logfp, "Error writting RAID bootsector to %s\n", 2366 pm_i->diskdev); 2367 continue; 2368 } 2369 if (pm_i->gpt && ! pm_i->isspecial) { 2370 if (pm_i->rootpart < 0 || 2371 run_program(RUN_DISPLAY | RUN_PROGRESS, 2372 "gpt biosboot -i %d %s", 2373 pm_i->rootpart + 1, pm_i->diskdev) != 0) { 2374 if (logfp) 2375 fprintf(logfp, "Error writting GPT bootsector to %s\n", 2376 pm_i->diskdev); 2377 continue; 2378 } 2379 } else { 2380 pm_select(pm_i); 2381 if ( 2382 #ifndef NO_DISKLABEL 2383 check_partitions() == 0 || 2384 #endif 2385 md_post_newfs() != 0) { 2386 if (logfp) 2387 fprintf(logfp, "Error writting bootsector to %s\n", 2388 pm_i->diskdev); 2389 continue; 2390 } 2391 } 2392 } 2393 return 0; 2394 } 2395 2396 /* Function for 'Enter'-menu */ 2397 static int 2398 pm_submenu(menudesc *m, void *arg) 2399 { 2400 int part_num = -1; 2401 pm_devs_t *pm_cur = NULL; 2402 ((part_entry_t *)arg)[0].retvalue = m->cursel + 1; 2403 2404 switch (((part_entry_t *)arg)[m->cursel].type) { 2405 case PM_DISK_T: 2406 case PM_WEDGE_T: 2407 case PM_PART_T: 2408 case PM_SPEC_T: 2409 if (((part_entry_t *)arg)[m->cursel].dev_ptr != NULL) { 2410 pm_cur = ((part_entry_t *)arg)[m->cursel].dev_ptr; 2411 if (pm_cur == NULL) 2412 return -1; 2413 if (pm_cur->blocked) { 2414 msg_display(MSG_wannaunblock); 2415 if (!ask_noyes(NULL)) 2416 return -2; 2417 pm_cur->blocked = 0; 2418 } 2419 pm_select(pm_cur); 2420 } 2421 default: 2422 break; 2423 } 2424 2425 switch (((part_entry_t *)arg)[m->cursel].type) { 2426 case PM_DISK_T: 2427 if (pm_cur != NULL && pm_cur->gpt) { 2428 process_menu(MENU_pmgptentry, &part_num); 2429 pm_wedges_fill(pm_cur); 2430 } else { 2431 process_menu(MENU_pmdiskentry, &part_num); 2432 } 2433 break; 2434 case PM_WEDGE_T: 2435 case PM_PART_T: 2436 part_num = ((part_entry_t *)arg)[m->cursel].dev_num; 2437 process_menu(MENU_pmpartentry, &part_num); 2438 if (pm_cur != NULL && pm_cur->gpt) 2439 pm_wedges_fill(pm_cur); 2440 break; 2441 case PM_SPEC_T: 2442 part_num = 0; 2443 process_menu(MENU_pmpartentry, &part_num); 2444 break; 2445 case PM_RAID_T: 2446 return pm_edit(PMR_MENU_END, pm_raid_edit_menufmt, 2447 pm_raid_set_value, pm_raid_check, pm_raid_init, 2448 NULL, ((part_entry_t *)arg)[m->cursel].dev_ptr, 0, &raids_t_info); 2449 case PM_VND_T: 2450 return pm_edit(PMV_MENU_END, pm_vnd_edit_menufmt, 2451 pm_vnd_set_value, pm_vnd_check, pm_vnd_init, 2452 NULL, ((part_entry_t *)arg)[m->cursel].dev_ptr, 0, &vnds_t_info); 2453 case PM_CGD_T: 2454 return pm_cgd_edit(((part_entry_t *)arg)[m->cursel].dev_ptr, 2455 NULL); 2456 case PM_LVM_T: 2457 return pm_edit(PML_MENU_END, pm_lvm_edit_menufmt, 2458 pm_lvm_set_value, pm_lvm_check, pm_lvm_init, 2459 NULL, ((part_entry_t *)arg)[m->cursel].dev_ptr, 0, &lvms_t_info); 2460 case PM_LVMLV_T: 2461 return pm_edit(PMLV_MENU_END, pm_lvmlv_edit_menufmt, 2462 pm_lvmlv_set_value, pm_lvmlv_check, pm_lvmlv_init, 2463 NULL, ((part_entry_t *)arg)[m->cursel].dev_ptr, 2464 ((part_entry_t *)arg)[m->cursel].dev_ptr_delta, &lv_t_info); 2465 } 2466 return 0; 2467 } 2468 2469 /* Functions that generate menu entries text */ 2470 static void 2471 pm_menufmt(menudesc *m, int opt, void *arg) 2472 { 2473 const char *dev_status = ""; 2474 char buf[STRSIZE]; 2475 int part_num = ((part_entry_t *)arg)[opt].dev_num; 2476 pm_devs_t *pm_cur = ((part_entry_t *)arg)[opt].dev_ptr; 2477 2478 switch (((part_entry_t *)arg)[opt].type) { 2479 case PM_DISK_T: 2480 if (pm_cur->blocked) 2481 dev_status = msg_string(MSG_pmblocked); 2482 else if (! pm_cur->unsaved) 2483 dev_status = msg_string(MSG_pmunchanged); 2484 else if (pm_cur->bootable) 2485 dev_status = msg_string(MSG_pmsetboot); 2486 else 2487 dev_status = msg_string(MSG_pmused); 2488 wprintw(m->mw, "%-33.32s %-22.21s %12.12s", 2489 pm_cur->diskdev_descr, 2490 (pm_cur->gpt) ? 2491 msg_string(MSG_pmgptdisk) : 2492 pm_cur->bsddiskname, 2493 dev_status); 2494 break; 2495 case PM_WEDGE_T: 2496 part_num = ((part_entry_t *)arg)[opt].wedge_num; 2497 snprintf(buf, STRSIZE, "dk%d: %s", 2498 part_num, 2499 wedges[part_num].pm->bsdlabel[wedges[part_num].ptn].pi_mount); 2500 wprintw(m->mw, " %-30.29s %-22.21s %11uM", 2501 buf, 2502 (wedges[part_num].pm->bsdlabel[wedges[part_num].ptn].lvmpv) ? 2503 "lvm pv" : 2504 getfslabelname(wedges[part_num].pm->bsdlabel[wedges[part_num]. 2505 ptn].pi_fstype), 2506 wedges[part_num].pm->bsdlabel[wedges[part_num].ptn].pi_size / 2507 (MEG / pm_cur->sectorsize)); 2508 break; 2509 case PM_PART_T: 2510 snprintf(buf, STRSIZE, "%s%c: %s %s", 2511 pm_cur->diskdev, 2512 'a' + part_num, 2513 pm_cur->bsdlabel[part_num].pi_mount, 2514 (strlen(pm_cur->bsdlabel[part_num].mounted) > 0) ? msg_string(MSG_pmmounted) : 2515 (part_num == PART_B || 2516 strlen (pm_cur->bsdlabel[part_num].pi_mount ) < 1 || 2517 pm_cur->bsdlabel[part_num].pi_flags & PIF_MOUNT) ? 2518 "" : msg_string(MSG_pmunused)); 2519 wprintw(m->mw, " %-30.29s %-22.21s %11uM", 2520 buf, 2521 (pm_cur->bsdlabel[part_num].lvmpv) ? 2522 "lvm pv" : 2523 getfslabelname(pm_cur->bsdlabel[part_num].pi_fstype), 2524 pm_cur->bsdlabel[part_num].pi_size / (MEG / pm_cur->sectorsize)); 2525 break; 2526 case PM_SPEC_T: 2527 snprintf(buf, STRSIZE, "%s: %s", 2528 pm_cur->diskdev_descr, pm_cur->bsdlabel[0].pi_mount); 2529 wprintw(m->mw, "%-33.32s %-22.21s %11uM", buf, 2530 getfslabelname(pm_cur->bsdlabel[0].pi_fstype), 2531 pm_cur->bsdlabel[0].pi_size / (MEG / pm_cur->sectorsize)); 2532 break; 2533 case PM_RAID_T: 2534 pm_raid_menufmt(m, opt, arg); 2535 break; 2536 case PM_VND_T: 2537 pm_vnd_menufmt(m, opt, arg); 2538 break; 2539 case PM_CGD_T: 2540 pm_cgd_menufmt(m, opt, arg); 2541 break; 2542 case PM_LVM_T: 2543 pm_lvm_menufmt(m, opt, arg); 2544 break; 2545 case PM_LVMLV_T: 2546 pm_lvmlv_menufmt(m, opt, arg); 2547 break; 2548 } 2549 return; 2550 } 2551 2552 /* Submenu for RAID/LVM/CGD/VND */ 2553 static void 2554 pm_upddevlist_adv(menudesc *m, void *arg, int *i, 2555 pm_upddevlist_adv_t *d) 2556 { 2557 int ii; 2558 if (d->create_msg != NULL) { 2559 /* We want to have menu entry that creates a new device */ 2560 ((part_entry_t *)arg)[*i].type = d->pe_type; 2561 ((part_entry_t *)arg)[*i].dev_ptr = NULL; 2562 ((part_entry_t *)arg)[*i].dev_ptr_delta = d->s->parent_size * d->sub_num; 2563 m->opts[(*i)++] = (struct menu_ent) { 2564 .opt_name = d->create_msg, 2565 .opt_action = pm_submenu, 2566 }; 2567 } 2568 for (ii = 0; ii < d->s->max; ii++) { 2569 if (d->s->entry_enabled == NULL || 2570 d->s->entry_blocked == NULL || 2571 *(int*)((char*)d->s->entry_enabled + d->s->entry_size * ii + 2572 d->s->parent_size * d->sub_num) == 0 || 2573 *(int*)((char*)d->s->entry_blocked + d->s->entry_size * ii + 2574 d->s->parent_size * d->sub_num) != 0) 2575 continue; 2576 /* We have a entry for displaying */ 2577 changed = 1; 2578 m->opts[*i] = (struct menu_ent) { 2579 .opt_name = NULL, 2580 .opt_action = pm_submenu, 2581 }; 2582 ((part_entry_t *)arg)[*i].type = d->pe_type; 2583 ((part_entry_t *)arg)[*i].dev_ptr = (char*)d->s->entry_first + 2584 d->s->entry_size * ii + d->s->parent_size * d->sub_num; 2585 (*i)++; 2586 /* We should show submenu for current entry */ 2587 if (d->sub != NULL) { 2588 d->sub->sub_num = ii; 2589 pm_upddevlist_adv(m, arg, i, d->sub); 2590 } 2591 } 2592 return; 2593 } 2594 2595 /* Update partman main menu with devices list */ 2596 static int 2597 pm_upddevlist(menudesc *m, void *arg) 2598 { 2599 int i = 0, ii; 2600 pm_devs_t *pm_i; 2601 2602 if (arg != NULL) 2603 ((part_entry_t *)arg)[0].retvalue = m->cursel + 1; 2604 2605 changed = 0; 2606 /* Mark all devices as not found */ 2607 SLIST_FOREACH(pm_i, &pm_head, l) 2608 if (pm_i->found > 0) 2609 pm_i->found = 0; 2610 /* Detect all present devices */ 2611 (void)find_disks("partman"); 2612 pm_lvm_find(); 2613 pm_clean(); 2614 2615 if (m == NULL || arg == NULL) 2616 return -1; 2617 2618 SLIST_FOREACH(pm_i, &pm_head, l) { 2619 m->opts[i].opt_name = NULL; 2620 m->opts[i].opt_action = pm_submenu; 2621 ((part_entry_t *)arg)[i].dev_ptr = pm_i; 2622 ((part_entry_t *)arg)[i].dev_num = -1; 2623 if (pm_i->isspecial) 2624 ((part_entry_t *)arg)[i].type = PM_SPEC_T; 2625 else { 2626 ((part_entry_t *)arg)[i].type = PM_DISK_T; 2627 if (pm_i->gpt) { 2628 pm_wedges_fill(pm_i); 2629 for (ii = 0; ii < MAX_WEDGES; ii++) 2630 if (wedges[ii].pm == pm_i) { 2631 i++; 2632 m->opts[i].opt_name = NULL; 2633 m->opts[i].opt_action = pm_submenu; 2634 ((part_entry_t *)arg)[i].dev_ptr = pm_i; 2635 ((part_entry_t *)arg)[i].dev_num = wedges[ii].ptn; 2636 ((part_entry_t *)arg)[i].wedge_num = ii; 2637 ((part_entry_t *)arg)[i].type = PM_WEDGE_T; 2638 } 2639 } else { 2640 for (ii = 0; ii < MAXPARTITIONS; ii++) 2641 if (pm_i->bsdlabel[ii].pi_fstype != FS_UNUSED) { 2642 i++; 2643 m->opts[i].opt_name = NULL; 2644 m->opts[i].opt_action = pm_submenu; 2645 ((part_entry_t *)arg)[i].dev_ptr = pm_i; 2646 ((part_entry_t *)arg)[i].dev_num = ii; 2647 ((part_entry_t *)arg)[i].type = PM_PART_T; 2648 } 2649 } 2650 } 2651 i++; 2652 } 2653 if (have_cgd) { 2654 pm_upddevlist_adv(m, arg, &i, 2655 &(pm_upddevlist_adv_t) {MSG_create_cgd, PM_CGD_T, &cgds_t_info, 0, NULL}); 2656 } 2657 if (have_lvm) { 2658 pm_upddevlist_adv(m, arg, &i, 2659 &(pm_upddevlist_adv_t) {MSG_create_cnd, PM_VND_T, &vnds_t_info, 0, NULL}); 2660 pm_upddevlist_adv(m, arg, &i, 2661 &(pm_upddevlist_adv_t) {MSG_create_vg, PM_LVM_T, &lvms_t_info, 0, 2662 &(pm_upddevlist_adv_t) {MSG_create_lv, PM_LVMLV_T, &lv_t_info, 0, NULL}}); 2663 } 2664 if (have_raid) { 2665 pm_upddevlist_adv(m, arg, &i, 2666 &(pm_upddevlist_adv_t) {MSG_create_raid, PM_RAID_T, &raids_t_info, 0, NULL}); 2667 } 2668 2669 m->opts[i++] = (struct menu_ent) { 2670 .opt_name = MSG_updpmlist, 2671 .opt_action = pm_upddevlist, 2672 }; 2673 m->opts[i ] = (struct menu_ent) { 2674 .opt_name = MSG_savepm, 2675 .opt_action = pm_commit, 2676 }; 2677 for (ii = 0; ii <= i; ii++) { 2678 m->opts[ii].opt_menu = OPT_NOMENU; 2679 m->opts[ii].opt_flags = OPT_EXIT; 2680 } 2681 2682 if (((part_entry_t *)arg)[0].retvalue >= 0) 2683 m->cursel = ((part_entry_t *)arg)[0].retvalue - 1; 2684 return i; 2685 } 2686 2687 static void 2688 pm_menuin(menudesc *m, void *arg) 2689 { 2690 if (cursel > m->numopts) 2691 m->cursel = m->numopts; 2692 else if (cursel < 0) 2693 m->cursel = 0; 2694 else 2695 m->cursel = cursel; 2696 } 2697 2698 static void 2699 pm_menuout(menudesc *m, void *arg) 2700 { 2701 cursel = m->cursel; 2702 } 2703 2704 /* initialize have_* variables */ 2705 void 2706 check_available_binaries() 2707 { 2708 static int did_test = false; 2709 2710 if (did_test) return; 2711 did_test = 1; 2712 2713 have_raid = binary_available("raidctl"); 2714 have_vnd = binary_available("vnconfig"); 2715 have_cgd = binary_available("cgdconfig"); 2716 have_lvm = binary_available("lvm"); 2717 have_gpt = binary_available("gpt"); 2718 have_dk = binary_available("dkctl"); 2719 } 2720 2721 /* Main partman function */ 2722 int 2723 partman(void) 2724 { 2725 int menu_no, menu_num_entries; 2726 static int firstrun = 1; 2727 menu_ent menu_entries[MAX_ENTRIES+6]; 2728 part_entry_t args[MAX_ENTRIES]; 2729 2730 if (firstrun) { 2731 check_available_binaries(); 2732 2733 if (!have_raid) 2734 remove_raid_options(); 2735 else if (!(raids = calloc(MAX_RAID, sizeof(*raids)))) 2736 have_raid = 0; 2737 2738 #define remove_vnd_options() (void)0 2739 if (!have_vnd) 2740 remove_vnd_options(); 2741 else if (!(vnds = calloc(MAX_VND, sizeof(*vnds)))) 2742 have_vnd = 0; 2743 2744 if (!have_cgd) 2745 remove_cgd_options(); 2746 else if (!(cgds = calloc(MAX_CGD, sizeof(*cgds)))) 2747 have_cgd = 0; 2748 2749 if (!have_lvm) 2750 remove_lvm_options(); 2751 else if (!(lvms = calloc(MAX_LVM_VG, sizeof(*lvms)))) 2752 have_lvm = 0; 2753 2754 if (!have_gpt) 2755 remove_gpt_options(); 2756 2757 raids_t_info = (structinfo_t) { 2758 .max = MAX_RAID, 2759 .entry_size = sizeof raids[0], 2760 .entry_first = &raids[0], 2761 .entry_enabled = &(raids[0].enabled), 2762 .entry_blocked = &(raids[0].blocked), 2763 .entry_node = &(raids[0].node), 2764 }; 2765 vnds_t_info = (structinfo_t) { 2766 .max = MAX_VND, 2767 .entry_size = sizeof vnds[0], 2768 .entry_first = &vnds[0], 2769 .entry_enabled = &(vnds[0].enabled), 2770 .entry_blocked = &(vnds[0].blocked), 2771 .entry_node = &(vnds[0].node), 2772 }; 2773 cgds_t_info = (structinfo_t) { 2774 .max = MAX_CGD, 2775 .entry_size = sizeof cgds[0], 2776 .entry_first = &cgds[0], 2777 .entry_enabled = &(cgds[0].enabled), 2778 .entry_blocked = &(cgds[0].blocked), 2779 .entry_node = &(cgds[0].node), 2780 }; 2781 lvms_t_info = (structinfo_t) { 2782 .max = MAX_LVM_VG, 2783 .entry_size = sizeof lvms[0], 2784 .entry_first = &lvms[0], 2785 .entry_enabled = &(lvms[0].enabled), 2786 .entry_blocked = &(lvms[0].blocked), 2787 .entry_node = NULL, 2788 }; 2789 lv_t_info = (structinfo_t) { 2790 .max = MAX_LVM_LV, 2791 .entry_size = sizeof lvms[0].lv[0], 2792 .entry_first = &lvms[0].lv[0], 2793 .entry_enabled = &(lvms[0].lv[0].size), 2794 .entry_blocked = &(lvms[0].lv[0].blocked), 2795 .parent_size = sizeof lvms[0], 2796 }; 2797 2798 cursel = 0; 2799 changed = 0; 2800 firstrun = 0; 2801 } 2802 2803 do { 2804 menu_num_entries = pm_upddevlist(&(menudesc){.opts = menu_entries}, args); 2805 menu_no = new_menu(MSG_partman_header, 2806 menu_entries, menu_num_entries+1, 1, 1, 0, 75, /* Fixed width */ 2807 MC_ALWAYS_SCROLL | MC_NOBOX | MC_NOCLEAR, 2808 pm_menuin, pm_menufmt, pm_menuout, NULL, MSG_finishpm); 2809 if (menu_no == -1) 2810 args[0].retvalue = -1; 2811 else { 2812 args[0].retvalue = 0; 2813 clear(); 2814 refresh(); 2815 process_menu(menu_no, &args); 2816 free_menu(menu_no); 2817 } 2818 2819 if (args[0].retvalue == 0) { 2820 if (pm_needsave()) 2821 pm_commit(NULL, NULL); 2822 if (pm_mountall() != 0 || 2823 make_fstab() != 0 || 2824 pm_lastcheck() != 0 || 2825 pm_savebootsector() != 0) { 2826 msg_display(MSG_wannatry); 2827 args[0].retvalue = (ask_yesno(NULL)) ? 1:-1; 2828 } 2829 } 2830 } while (args[0].retvalue > 0); 2831 2832 /* retvalue <0 - error, retvalue ==0 - user quits, retvalue >0 - all ok */ 2833 return (args[0].retvalue >= 0)?0:-1; 2834 } 2835 2836 void 2837 update_wedges(const char *disk) 2838 { 2839 check_available_binaries(); 2840 2841 if (!have_dk) 2842 return; 2843 2844 run_program(RUN_SILENT | RUN_ERROR_OK, 2845 "dkctl %s makewedges", disk); 2846 } 2847