1 /* $NetBSD: partman.c,v 1.22 2018/05/18 12:23:22 joerg 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, __UNCONST(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, __UNCONST(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, __UNCONST(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: vndconfig 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 "vndconfig %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, "vndconfig %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 void 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 } 1217 1218 static int 1219 pm_lvm_disk_add(menudesc *m, void *arg) 1220 { 1221 int i; 1222 lvms_t *dev_ptr = arg; 1223 part_entry_t disk_entrie = pm_dev_list(PM_LVM_T); 1224 if (disk_entrie.retvalue < 0) 1225 return disk_entrie.retvalue; 1226 1227 for (i = 0; i < MAX_LVM_PV; i++) 1228 if (dev_ptr->pv[i].pm == NULL) { 1229 dev_ptr->pv[i].pm = disk_entrie.dev_ptr; 1230 dev_ptr->pv[i].pm_part = disk_entrie.dev_num; 1231 strlcpy(dev_ptr->pv[i].pm_name, disk_entrie.fullname, SSTRSIZE); 1232 break; 1233 } 1234 return 0; 1235 } 1236 1237 static int 1238 pm_lvm_disk_del(menudesc *m, void *arg) 1239 { 1240 int i, retvalue = -1, num_devs = 0; 1241 int menu_no; 1242 lvms_t *dev_ptr = arg; 1243 menu_ent menu_entries[MAX_LVM_PV]; 1244 part_entry_t submenu_args[MAX_LVM_PV]; 1245 1246 for (i = 0; i < MAX_LVM_PV; i++) { 1247 if (dev_ptr->pv[i].pm == NULL) 1248 continue; 1249 menu_entries[num_devs] = (struct menu_ent) { 1250 .opt_name = dev_ptr->pv[i].pm_name, 1251 .opt_action = set_menu_select, 1252 .opt_menu = OPT_NOMENU, 1253 .opt_flags = OPT_EXIT, 1254 }; 1255 submenu_args[num_devs].dev_num = i; 1256 num_devs++; 1257 } 1258 1259 menu_no = new_menu(MSG_lvm_disks, 1260 menu_entries, num_devs, -1, -1, (num_devs+1<3)?3:num_devs+1, 13, 1261 MC_SCROLL | MC_NOCLEAR, NULL, NULL, NULL, NULL, NULL); 1262 if (menu_no == -1) 1263 return -1; 1264 process_menu(menu_no, &retvalue); 1265 free_menu(menu_no); 1266 1267 if (retvalue < 0 || retvalue >= num_devs) 1268 return -1; 1269 1270 dev_ptr->pv[submenu_args[retvalue].dev_num].pm = NULL; 1271 1272 return 0; 1273 } 1274 1275 static void 1276 pm_lvm_menufmt(menudesc *m, int opt, void *arg) 1277 { 1278 int i, ok = 0, used_size = 0; 1279 char buf1[STRSIZE]; buf1[0] = '\0'; 1280 char buf2[STRSIZE]; buf2[0] = '\0'; 1281 lvms_t *dev_ptr = ((part_entry_t *)arg)[opt].dev_ptr; 1282 1283 if (dev_ptr->enabled == 0) 1284 return; 1285 snprintf(buf1, STRSIZE, "VG '%s' on ", dev_ptr->name); 1286 for (i = 0; i < MAX_LVM_PV; i++) 1287 if (dev_ptr->pv[i].pm != NULL) { 1288 strlcat(buf1, dev_ptr->pv[i].pm_name, STRSIZE); 1289 strlcat(buf1, " ", STRSIZE); 1290 ok = 1; 1291 } 1292 for (i = 0; i < MAX_LVM_LV; i++) 1293 used_size += dev_ptr->lv[i].size; 1294 if (ok) { 1295 snprintf(buf2, STRSIZE, "%d/%u", 1296 dev_ptr->total_size - used_size, dev_ptr->total_size); 1297 wprintw(m->mw, msg_string(MSG_lvm_menufmt), buf1, buf2); 1298 } else 1299 wprintw(m->mw, "%s", msg_string(MSG_lvm_err_menufmt)); 1300 return; 1301 } 1302 1303 static void 1304 pm_lvm_edit_menufmt(menudesc *m, int opt, void *arg) 1305 { 1306 int i; 1307 char buf[STRSIZE]; 1308 lvms_t *dev_ptr = arg; 1309 strlcpy(buf, msg_string(MSG_auto), STRSIZE); 1310 1311 switch (opt) { 1312 case PML_MENU_PV: 1313 buf[0] = '\0'; 1314 for (i = 0; i < MAX_LVM_PV; i++) 1315 if (dev_ptr->pv[i].pm != NULL) 1316 snprintf(buf, STRSIZE, "%s %s", buf, dev_ptr->pv[i].pm_name); 1317 wprintw(m->mw, msg_string(MSG_lvm_disks_fmt), buf); 1318 break; 1319 case PML_MENU_NAME: 1320 wprintw(m->mw, msg_string(MSG_lvm_name_fmt), dev_ptr->name); 1321 break; 1322 case PML_MENU_MAXLOGICALVOLUMES: 1323 if (dev_ptr->maxlogicalvolumes > 0) 1324 snprintf(buf, STRSIZE, "%d", dev_ptr->maxlogicalvolumes); 1325 wprintw(m->mw, msg_string(MSG_lvm_maxlv_fmt), buf); 1326 break; 1327 case PML_MENU_MAXPHYSICALVOLUMES: 1328 if (dev_ptr->maxphysicalvolumes > 0) 1329 snprintf(buf, STRSIZE, "%d", dev_ptr->maxphysicalvolumes); 1330 wprintw(m->mw, msg_string(MSG_lvm_maxpv_fmt), buf); 1331 break; 1332 case PML_MENU_PHYSICALEXTENTSIZE: 1333 if (dev_ptr->physicalextentsize > 0) 1334 snprintf(buf, STRSIZE, "%dM", dev_ptr->physicalextentsize); 1335 wprintw(m->mw, msg_string(MSG_lvm_extsiz_fmt), buf); 1336 break; 1337 } 1338 return; 1339 } 1340 1341 static int 1342 pm_lvm_set_value(menudesc *m, void *arg) 1343 { 1344 char buf[STRSIZE]; 1345 const char *msg_to_show = NULL; 1346 int *out_var = NULL; 1347 lvms_t *dev_ptr = arg; 1348 1349 static menu_ent menuent_disk_adddel[] = { 1350 {MSG_add, OPT_NOMENU, OPT_EXIT, pm_lvm_disk_add}, 1351 {MSG_remove, OPT_NOMENU, OPT_EXIT, pm_lvm_disk_del} 1352 }; 1353 static int menu_disk_adddel = -1; 1354 if (menu_disk_adddel == -1) { 1355 menu_disk_adddel = new_menu(NULL, menuent_disk_adddel, nelem(menuent_disk_adddel), 1356 -1, -1, 0, 10, MC_NOCLEAR, NULL, NULL, NULL, NULL, NULL); 1357 } 1358 1359 switch (m->cursel) { 1360 case PML_MENU_PV: 1361 process_menu(menu_disk_adddel, arg); 1362 return 0; 1363 case PML_MENU_NAME: 1364 msg_prompt_win(MSG_lvm_name_ask, -1, 18, 0, 0, dev_ptr->name, dev_ptr->name, SSTRSIZE); 1365 return 0; 1366 case PML_MENU_MAXLOGICALVOLUMES: 1367 msg_to_show = MSG_lvm_maxlv_ask; 1368 out_var = &(dev_ptr->maxlogicalvolumes); 1369 break; 1370 case PML_MENU_MAXPHYSICALVOLUMES: 1371 msg_to_show = MSG_lvm_maxpv_ask; 1372 out_var = &(dev_ptr->maxphysicalvolumes); 1373 break; 1374 case PML_MENU_PHYSICALEXTENTSIZE: 1375 msg_to_show = MSG_lvm_extsiz_ask; 1376 out_var = &(dev_ptr->physicalextentsize); 1377 break; 1378 case PML_MENU_REMOVE: 1379 dev_ptr->enabled = 0; 1380 return 0; 1381 } 1382 if (out_var == NULL || msg_to_show == NULL) 1383 return -1; 1384 snprintf(buf, SSTRSIZE, "%d", *out_var); 1385 msg_prompt_win(msg_to_show, -1, 18, 0, 0, buf, buf, SSTRSIZE); 1386 if (atoi(buf) >= 0) 1387 *out_var = atoi(buf); 1388 return 0; 1389 } 1390 1391 static void 1392 pm_lvm_init(void *arg, void* none) 1393 { 1394 lvms_t *dev_ptr = arg; 1395 1396 memset(dev_ptr, 0, sizeof *dev_ptr); 1397 *dev_ptr = (struct lvms_t) { 1398 .enabled = 1, 1399 .blocked = 0, 1400 .maxlogicalvolumes = MAX_LVM_PV, 1401 .maxphysicalvolumes = MAX_LVM_LV, 1402 .physicalextentsize = -1, 1403 }; 1404 sprintf(dev_ptr->name, "vg%.2d", rand()%100); 1405 return; 1406 } 1407 1408 static int 1409 pm_lvm_check(void *arg) 1410 { 1411 int i, ok = 0; 1412 lvms_t *dev_ptr = arg; 1413 dev_ptr->total_size = 0; 1414 1415 for (i = 0; i < MAX_LVM_PV; i++) 1416 if (dev_ptr->pv[i].pm != NULL) { 1417 ok = 1; 1418 dev_ptr->total_size += dev_ptr->pv[i].pm-> 1419 bsdlabel[dev_ptr->pv[i].pm_part].pi_size / 1420 (MEG / dev_ptr->pv[i].pm->sectorsize); 1421 } 1422 if (! ok) 1423 dev_ptr->enabled = 0; 1424 return dev_ptr->enabled; 1425 } 1426 1427 static void 1428 pm_lvmlv_menufmt(menudesc *m, int opt, void *arg) 1429 { 1430 char buf[STRSIZE]; 1431 lv_t *dev_ptr = ((part_entry_t *)arg)[opt].dev_ptr; 1432 1433 if (dev_ptr->size > 0) { 1434 snprintf(buf, STRSIZE, "'%s'", dev_ptr->name); 1435 wprintw(m->mw, msg_string(MSG_lvmlv_menufmt), buf, dev_ptr->size); 1436 } 1437 return; 1438 } 1439 1440 static void 1441 pm_lvmlv_edit_menufmt(menudesc *m, int opt, void *arg) 1442 { 1443 1444 lv_t *dev_ptr = arg; 1445 char buf[STRSIZE]; 1446 strlcpy(buf, msg_string(MSG_auto), STRSIZE); 1447 1448 switch (opt) { 1449 case PMLV_MENU_NAME: 1450 wprintw(m->mw, msg_string(MSG_lvmlv_name_fmt), dev_ptr->name); 1451 break; 1452 case PMLV_MENU_SIZE: 1453 wprintw(m->mw, msg_string(MSG_lvmlv_size_fmt), dev_ptr->size); 1454 break; 1455 case PMLV_MENU_READONLY: 1456 wprintw(m->mw, msg_string(MSG_lvmlv_ro_fmt), 1457 dev_ptr->readonly? msg_string(MSG_Yes) : msg_string(MSG_No)); 1458 break; 1459 case PMLV_MENU_CONTIGUOUS: 1460 wprintw(m->mw, msg_string(MSG_lvmlv_cont_fmt), 1461 dev_ptr->contiguous? msg_string(MSG_Yes) : msg_string(MSG_No)); 1462 break; 1463 case PMLV_MENU_EXTENTS: 1464 wprintw(m->mw, msg_string(MSG_lvmlv_extnum_fmt), 1465 (strlen(dev_ptr->extents) > 0)? dev_ptr->extents : msg_string(MSG_auto)); 1466 break; 1467 case PMLV_MENU_MINOR: 1468 if (dev_ptr->minor > 0) 1469 snprintf(buf, STRSIZE, "%dK", dev_ptr->minor); 1470 wprintw(m->mw, msg_string(MSG_lvmlv_minor_fmt), buf); 1471 break; 1472 case PMLV_MENU_MIRRORS: 1473 wprintw(m->mw, msg_string(MSG_lvmlv_mirrors_fmt), dev_ptr->mirrors); 1474 break; 1475 case PMLV_MENU_REGIONSIZE: 1476 if (dev_ptr->regionsize > 0) 1477 snprintf(buf, STRSIZE, "%dM", dev_ptr->regionsize); 1478 wprintw(m->mw, msg_string(MSG_lvmlv_regsiz_fmt), buf); 1479 break; 1480 case PMLV_MENU_PERSISTENT: 1481 wprintw(m->mw, msg_string(MSG_lvmlv_pers_fmt), 1482 dev_ptr->persistent ? msg_string(MSG_Yes) : msg_string(MSG_No)); 1483 break; 1484 case PMLV_MENU_READAHEAD: 1485 if (dev_ptr->readahead > 0) 1486 snprintf(buf, STRSIZE, "%d", dev_ptr->readahead); 1487 wprintw(m->mw, msg_string(MSG_lvmlv_readahsect_fmt), buf); 1488 break; 1489 case PMLV_MENU_STRIPES: 1490 if (dev_ptr->stripes > 0) 1491 snprintf(buf, STRSIZE, "%d", dev_ptr->stripes); 1492 wprintw(m->mw, msg_string(MSG_lvmlv_stripes_fmt), buf); 1493 break; 1494 case PMLV_MENU_STRIPESIZE: 1495 if (dev_ptr->stripesize > 0) 1496 snprintf(buf, STRSIZE, "%dK", dev_ptr->stripesize); 1497 wprintw(m->mw, msg_string(MSG_lvmlv_stripesiz_fmt), buf); 1498 break; 1499 case PMLV_MENU_ZERO: 1500 wprintw(m->mw, msg_string(MSG_lvmlv_zero_fmt), 1501 dev_ptr->zero? msg_string(MSG_Yes) : msg_string(MSG_No)); 1502 break; 1503 } 1504 return; 1505 } 1506 1507 static int 1508 pm_lvmlv_set_value(menudesc *m, void *arg) 1509 { 1510 char buf[STRSIZE]; 1511 const char *msg_to_show = NULL; 1512 int *out_var = NULL; 1513 lv_t *dev_ptr = arg; 1514 1515 switch (m->cursel) { 1516 case PMLV_MENU_NAME: 1517 msg_prompt_win(MSG_lvmlv_name_ask, -1, 18, 0, 0, dev_ptr->name, dev_ptr->name, 1518 SSTRSIZE); 1519 return 0; 1520 case PMLV_MENU_SIZE: 1521 msg_to_show = MSG_lvmlv_size_ask; 1522 out_var = &(dev_ptr->size); 1523 break; 1524 case PMLV_MENU_READONLY: 1525 dev_ptr->readonly = !dev_ptr->readonly; 1526 return 0; 1527 case PMLV_MENU_CONTIGUOUS: 1528 dev_ptr->contiguous = !dev_ptr->contiguous; 1529 return 0; 1530 case PMLV_MENU_EXTENTS: 1531 msg_prompt_win(MSG_lvmlv_extnum_ask, -1, 18, 0, 0, 1532 dev_ptr->extents, dev_ptr->extents, SSTRSIZE); 1533 return 0; 1534 case PMLV_MENU_MINOR: 1535 msg_to_show = MSG_lvmlv_minor_ask; 1536 out_var = &(dev_ptr->minor); 1537 break; 1538 case PMLV_MENU_MIRRORS: 1539 msg_to_show = MSG_lvmlv_mirrors_ask; 1540 out_var = &(dev_ptr->mirrors); 1541 break; 1542 case PMLV_MENU_REGIONSIZE: 1543 msg_to_show = MSG_lvmlv_regsiz_ask; 1544 out_var = &(dev_ptr->regionsize); 1545 break; 1546 case PMLV_MENU_PERSISTENT: 1547 dev_ptr->persistent = !dev_ptr->persistent; 1548 return 0; 1549 case PMLV_MENU_READAHEAD: 1550 msg_to_show = MSG_lvmlv_readahsect_ask; 1551 out_var = &(dev_ptr->readahead); 1552 break; 1553 case PMLV_MENU_STRIPES: 1554 msg_to_show = MSG_lvmlv_stripes_ask; 1555 out_var = &(dev_ptr->stripes); 1556 break; 1557 case PMLV_MENU_STRIPESIZE: 1558 if (dev_ptr->stripesize << 1 > 512) 1559 dev_ptr->stripesize = 4; 1560 else 1561 dev_ptr->stripesize <<= 1; 1562 return 0; 1563 case PMLV_MENU_ZERO: 1564 dev_ptr->zero = !dev_ptr->zero; 1565 return 0; 1566 case PMLV_MENU_REMOVE: 1567 dev_ptr->size = 0; 1568 return 0; 1569 } 1570 if (out_var == NULL || msg_to_show == NULL) 1571 return -1; 1572 snprintf(buf, SSTRSIZE, "%d", *out_var); 1573 msg_prompt_win(msg_to_show, -1, 18, 0, 0, buf, buf, SSTRSIZE); 1574 if (atoi(buf) >= 0) 1575 *out_var = atoi(buf); 1576 return 0; 1577 } 1578 1579 static void 1580 pm_lvmlv_init(void *arg, void *none) 1581 { 1582 lv_t *dev_ptr = arg; 1583 memset(dev_ptr, 0, sizeof *(dev_ptr)); 1584 *dev_ptr = (struct lv_t) { 1585 .blocked = 0, 1586 .size = 1024, 1587 .stripesize = 64, 1588 }; 1589 sprintf (dev_ptr->name, "lvol%.2d", rand()%100); 1590 return; 1591 } 1592 1593 static int 1594 pm_lvmlv_check(void *arg) 1595 { 1596 lv_t *dev_ptr = arg; 1597 if (dev_ptr->size > 0 && strlen(dev_ptr->name) > 0) 1598 return 1; 1599 else { 1600 dev_ptr->size = 0; 1601 return 0; 1602 } 1603 } 1604 1605 static int 1606 pm_lvm_commit(void) 1607 { 1608 int i, ii, error; 1609 uint used_size = 0; 1610 char params[STRSIZE*3]; 1611 char devs[STRSIZE*3]; 1612 1613 for (i = 0; i < MAX_LVM_VG; i++) { 1614 /* Stage 0: checks */ 1615 if (! pm_lvm_check(&lvms[i])) 1616 continue; 1617 for (ii = 0; ii < MAX_LVM_LV; ii++) 1618 used_size += lvms[i].lv[ii].size; 1619 if (used_size > lvms[i].total_size) 1620 continue; 1621 1622 params[0] = '\0'; 1623 devs[0] = '\0'; 1624 error = 0; 1625 /* Stage 1: creating Physical Volumes (PV's) */ 1626 for (ii = 0; ii < MAX_LVM_PV && ! error; ii++) 1627 if (lvms[i].pv[ii].pm != NULL) { 1628 run_program(RUN_SILENT | RUN_ERROR_OK, 1629 "lvm pvremove -ffy /dev/r%s", 1630 (char*)lvms[i].pv[ii].pm_name); 1631 error += run_program(RUN_DISPLAY | RUN_PROGRESS, 1632 "lvm pvcreate -ffy /dev/r%s", 1633 (char*)lvms[i].pv[ii].pm_name); 1634 if (error) 1635 break; 1636 snprintf(devs, STRSIZE*3, "%s /dev/r%s", devs, (char*)lvms[i].pv[ii].pm_name); 1637 } 1638 if (error) 1639 continue; 1640 /* Stage 2: creating Volume Groups (VG's) */ 1641 if (lvms[i].maxlogicalvolumes > 0) 1642 snprintf(params, STRSIZE*3, "%s -l %d", params, lvms[i].maxlogicalvolumes); 1643 if (lvms[i].maxphysicalvolumes > 0) 1644 snprintf(params, STRSIZE*3, "%s -p %d", params, lvms[i].maxphysicalvolumes); 1645 if (lvms[i].physicalextentsize > 0) 1646 snprintf(params, STRSIZE*3, "%s -s %d", params, lvms[i].physicalextentsize); 1647 error += run_program(RUN_DISPLAY | RUN_PROGRESS, "lvm vgcreate %s %s %s", 1648 params, lvms[i].name, devs); 1649 if (error) 1650 continue; 1651 /* Stage 3: creating Logical Volumes (LV's) */ 1652 for (ii = 0; ii < MAX_LVM_LV; ii++) { 1653 if (lvms[i].lv[ii].size <= 0) 1654 continue; 1655 1656 params[0] = '\0'; 1657 snprintf(params, STRSIZE*3, "%s -C %c", params, lvms[i].lv[ii].contiguous?'y':'n'); 1658 snprintf(params, STRSIZE*3, "%s -M %c", params, lvms[i].lv[ii].persistent?'y':'n'); 1659 snprintf(params, STRSIZE*3, "%s -p %s", params, lvms[i].lv[ii].readonly?"r":"rw"); 1660 snprintf(params, STRSIZE*3, "%s -Z %c", params, lvms[i].lv[ii].zero?'y':'n'); 1661 if (strlen(lvms[i].lv[ii].name) > 0) 1662 snprintf(params, STRSIZE*3, "%s -n %s", params, lvms[i].lv[ii].name); 1663 if (strlen(lvms[i].lv[ii].extents) > 0) 1664 snprintf(params, STRSIZE*3, "%s -l %s", params, lvms[i].lv[ii].extents); 1665 if (lvms[i].lv[ii].minor > 0) 1666 snprintf(params, STRSIZE*3, "%s --minor %d", params, lvms[i].lv[ii].minor); 1667 if (lvms[i].lv[ii].mirrors > 0) { 1668 snprintf(params, STRSIZE*3, "%s -m %d", params, lvms[i].lv[ii].mirrors); 1669 if (lvms[i].lv[ii].regionsize > 0) 1670 snprintf(params, STRSIZE*3, "%s -R %d", params, lvms[i].lv[ii].regionsize); 1671 } 1672 if (lvms[i].lv[ii].readahead > 0) 1673 snprintf(params, STRSIZE*3, "%s -r %d", params, lvms[i].lv[ii].readahead); 1674 if (lvms[i].lv[ii].stripes > 0) { 1675 snprintf(params, STRSIZE*3, "%s -i %d", params, lvms[i].lv[ii].stripes); 1676 if (lvms[i].lv[ii].stripesize > 0) 1677 snprintf(params, STRSIZE*3, "%s -I %d", params, lvms[i].lv[ii].stripesize); 1678 } 1679 snprintf(params, STRSIZE*3, "%s -L %uM", params, lvms[i].lv[ii].size); 1680 error += run_program(RUN_DISPLAY | RUN_PROGRESS, "lvm lvcreate %s %s", 1681 params, lvms[i].name); 1682 } 1683 if (! error) { 1684 lvms[i].blocked = 1; 1685 for (ii = 0; ii < MAX_LVM_PV; ii++) 1686 if (lvms[i].pv[ii].pm != NULL) 1687 lvms[i].pv[ii].pm->blocked++; 1688 for (ii = 0; ii < MAX_LVM_LV; ii++) 1689 if (lvms[i].lv[ii].size > 0) 1690 lvms[i].lv[ii].blocked = 1; 1691 } 1692 } 1693 1694 return 0; 1695 } 1696 1697 /*** 1698 GPT 1699 ***/ 1700 1701 int 1702 pm_gpt_convert(pm_devs_t *pm_cur) 1703 { 1704 int i, error = 0; 1705 1706 msg_display(MSG_removepartswarn); 1707 if (!ask_noyes(NULL)) 1708 return -1; 1709 1710 if (! pm_cur->gpt) 1711 error = run_program(RUN_DISPLAY | RUN_PROGRESS, "gpt create -f %s", 1712 pm_cur->diskdev); 1713 else { 1714 error = run_program(RUN_DISPLAY | RUN_PROGRESS, "gpt destroy %s", 1715 pm_cur->diskdev); 1716 for (i = 0; i < MAX_WEDGES; i++) 1717 if (wedges[i].pm == pm_cur) 1718 wedges[i].pm = NULL; 1719 } 1720 if (!error) { 1721 pm_cur->gpt = !pm_cur->gpt; 1722 pm_select(pm_cur); 1723 label_read(); 1724 } 1725 return error; 1726 } 1727 1728 static int 1729 pm_wedge_getfree(void) 1730 { 1731 int i; 1732 for (i = 0; i < MAX_WEDGES; i++) 1733 if (! wedges[i].allocated && wedges[i].pm == NULL) 1734 return i; 1735 return -1; 1736 } 1737 1738 void 1739 pm_wedges_fill(pm_devs_t *pm_cur) 1740 { 1741 int i, current; 1742 1743 for (i = 0; i < MAX_WEDGES; i++) 1744 if (wedges[i].pm == pm_cur && ! wedges[i].allocated) 1745 wedges[i].pm = NULL; 1746 1747 for (i = 0; i < min(MAXPARTITIONS,MAX_WEDGES); i++) 1748 if (pm_cur->bsdlabel[i].pi_fstype != FS_UNUSED) { 1749 current = pm_wedge_getfree(); 1750 if (current < 0) { 1751 process_menu(MENU_ok, __UNCONST(MSG_limitcount)); 1752 return; 1753 } 1754 wedges[current].pm = pm_cur; 1755 wedges[current].ptn = i; 1756 } 1757 return; 1758 } 1759 1760 static int 1761 pm_wedge_create(int num, pm_devs_t **pm_dk) 1762 { 1763 int i, ii, hackerr, error; 1764 partinfo *p = &(wedges[num].pm->bsdlabel[wedges[num].ptn]); 1765 1766 if (num > MAX_WEDGES) 1767 return -1; 1768 1769 /* There is no ability to use required dkX device, so that's a hack */ 1770 for (i = 0; i < num; i++) 1771 if (! wedges[i].allocated) { 1772 hackerr = 1; 1773 for (ii = 0; hackerr && ii < 3; ii++) 1774 hackerr = run_program(RUN_SILENT | RUN_ERROR_OK, 1775 "dkctl %s addwedge HACK%d %d %d unused", 1776 wedges[num].pm->diskdev, 1777 rand()%33, rand()%33, 0); 1778 wedges[i].todel = 1; 1779 } 1780 1781 run_program(RUN_SILENT | RUN_ERROR_OK, 1782 "dkctl %s listwedges", wedges[num].pm->diskdev); 1783 1784 error = run_program(RUN_DISPLAY | RUN_PROGRESS, 1785 "dkctl %s addwedge dk%d %u %u %s", 1786 wedges[num].pm->diskdev, 1787 num, 1788 p->pi_offset, 1789 p->pi_size, 1790 getfstypename(p->pi_fstype)); 1791 if (!error) { 1792 wedges[num].allocated = 1; 1793 wedges[num].pm->blocked++; 1794 if (pm_dk != NULL) { 1795 *pm_dk = malloc(sizeof(pm_devs_t)); 1796 memset(*pm_dk, 0, sizeof **pm_dk); 1797 memcpy(&(*pm_dk)->bsdlabel[0], p, sizeof (*pm_dk)->bsdlabel[0]); 1798 (*pm_dk)->found = -1; 1799 (*pm_dk)->isspecial = 1; 1800 (*pm_dk)->sectorsize = 512; /* XXX: xxx */ 1801 (*pm_dk)->dlcylsize = MEG; 1802 (*pm_dk)->refdev = wedges[num].pm; 1803 snprintf((*pm_dk)->diskdev, SSTRSIZE, "dk%d", num); 1804 snprintf((*pm_dk)->diskdev_descr, STRSIZE, " %s (%s)", 1805 (*pm_dk)->diskdev, getfstypename(p->pi_fstype)); 1806 } 1807 } else 1808 if (logfp) 1809 fprintf(logfp, "Cannot create wedge dk%d for %s.\n", 1810 num, wedges[num].pm->diskdev); 1811 1812 /* Hack, see above */ 1813 for (i = 0; i < num; i ++) 1814 if (! wedges[i].allocated && wedges[i].todel) { 1815 hackerr = run_program(RUN_SILENT | RUN_ERROR_OK, 1816 "dkctl %s delwedge dk%d", wedges[num].pm->diskdev, i); 1817 (void)hackerr; /* XXX */ 1818 wedges[i].todel = 0; 1819 } 1820 1821 return error; 1822 } 1823 1824 static int 1825 pm_gpt_commit(void) 1826 { 1827 uint i, error; 1828 pm_devs_t *pm_i, *pm_dk = NULL; 1829 char fstype[STRSIZE]; fstype[0] = '\0'; 1830 partinfo *p; 1831 1832 SLIST_FOREACH(pm_i, &pm_head, l) 1833 if (pm_i->gpt && pm_i->unsaved) 1834 run_program(RUN_DISPLAY | RUN_PROGRESS, 1835 "gpt remove -a %s", 1836 pm_i->diskdev); 1837 1838 for (i = 0; i < MAX_WEDGES; i++) { 1839 if (wedges[i].pm == NULL || 1840 ! wedges[i].pm->unsaved || 1841 wedges[i].ptn < 0) 1842 continue; 1843 error = 0; 1844 p = &(wedges[i].pm->bsdlabel[wedges[i].ptn]); 1845 if (wedges[i].pm->gpt) { 1846 if (get_gptfs_by_id(p->pi_fstype) != NULL) 1847 snprintf(fstype, STRSIZE, "-t %s", get_gptfs_by_id(p->pi_fstype)); 1848 error += run_program(RUN_DISPLAY | RUN_PROGRESS, 1849 "gpt add -i %u -b %u -s %u %s %s", 1850 wedges[i].ptn + 1, 1851 p->pi_offset, p->pi_size, 1852 fstype, wedges[i].pm->diskdev); 1853 } 1854 1855 if (error || wedges[i].allocated) { 1856 if (logfp && error) 1857 fprintf(logfp, "Cannot create GPT partition #%d on %s\n", 1858 i, wedges[i].pm->diskdev); 1859 continue; 1860 } 1861 1862 error += pm_wedge_create(i, &pm_dk); 1863 if (pm_dk != NULL) { 1864 /* Create file system on wedge and add it to list */ 1865 pm_select(pm_dk); 1866 make_filesystems(); 1867 SLIST_INSERT_AFTER(wedges[i].pm, pm_dk, l); 1868 memset(p, 0, sizeof *p); 1869 if (error) 1870 return -1; 1871 } 1872 } 1873 1874 SLIST_FOREACH(pm_i, &pm_head, l) 1875 if (pm_i->gpt && pm_i->unsaved) 1876 pm_i->unsaved = 0; 1877 1878 return 0; 1879 } 1880 1881 /*** 1882 Partman generic functions 1883 ***/ 1884 1885 int 1886 pm_getrefdev(pm_devs_t *pm_cur) 1887 { 1888 int i, ii, dev_num, num_devs, num_devs_s; 1889 char dev[SSTRSIZE]; dev[0] = '\0'; 1890 1891 pm_cur->refdev = NULL; 1892 if (! strncmp(pm_cur->diskdev, "cgd", 3)) { 1893 dev_num = pm_cur->diskdev[3] - '0'; 1894 for (i = 0; i < MAX_CGD; i++) 1895 if (cgds[i].blocked && cgds[i].node == dev_num) { 1896 pm_cur->refdev = &cgds[i]; 1897 1898 snprintf(pm_cur->diskdev_descr, STRSIZE, "%s (%s, %s-%d)", 1899 pm_cur->diskdev_descr, cgds[i].pm_name, 1900 cgds[i].enc_type, cgds[i].key_size); 1901 break; 1902 } 1903 } else if (! strncmp(pm_cur->diskdev, "vnd", 3)) { 1904 dev_num = pm_cur->diskdev[3] - '0'; 1905 for (i = 0; i < MAX_VND; i++) 1906 if (vnds[i].blocked && vnds[i].node == dev_num) { 1907 pm_cur->refdev = &vnds[i]; 1908 pm_getdevstring(dev, SSTRSIZE, vnds[i].pm, vnds[i].pm_part); 1909 snprintf(pm_cur->diskdev_descr, STRSIZE, "%s (%s, %s)", 1910 pm_cur->diskdev_descr, dev, vnds[i].filepath); 1911 break; 1912 } 1913 } else if (! strncmp(pm_cur->diskdev, "raid", 4)) { 1914 dev_num = pm_cur->diskdev[4] - '0'; 1915 for (i = 0; i < MAX_RAID; i++) 1916 if (raids[i].blocked && raids[i].node == dev_num) { 1917 pm_cur->refdev = &raids[i]; 1918 num_devs = 0; num_devs_s = 0; 1919 for (ii = 0; ii < MAX_IN_RAID; ii++) 1920 if (raids[i].pm[ii] != NULL) { 1921 if(raids[i].pm_is_spare[ii]) 1922 num_devs_s++; 1923 else 1924 num_devs++; 1925 } 1926 snprintf(pm_cur->diskdev_descr, STRSIZE, 1927 "%s (lvl %d, %d disks, %d spare)", pm_cur->diskdev_descr, 1928 raids[i].raid_level, num_devs, num_devs_s); 1929 break; 1930 } 1931 } else 1932 return -1; 1933 return 0; 1934 } 1935 1936 /* Detect that partition is in use */ 1937 int 1938 pm_partusage(pm_devs_t *pm_cur, int part_num, int do_del) 1939 { 1940 int i, ii, retvalue = 0; 1941 1942 if (part_num < 0) { 1943 /* Check all partitions on device */ 1944 for (i = 0; i < MAXPARTITIONS; i++) 1945 retvalue += pm_partusage(pm_cur, i, do_del); 1946 return retvalue; 1947 } 1948 1949 for (i = 0; i < MAX_CGD; i++) 1950 if (cgds[i].enabled && 1951 cgds[i].pm == pm_cur && 1952 cgds[i].pm_part == part_num) { 1953 if (do_del) { 1954 cgds[i].pm = NULL; 1955 strcpy(cgds[i].pm_name, ""); 1956 } 1957 return 1; 1958 } 1959 for (i = 0; i < MAX_RAID; i++) 1960 for (ii = 0; ii < MAX_IN_RAID; ii++) 1961 if (raids[i].enabled && 1962 raids[i].pm[ii] == pm_cur && 1963 raids[i].pm_part[ii] == part_num) { 1964 if (do_del) 1965 raids[i].pm[ii] = NULL; 1966 return 1; 1967 } 1968 for (i = 0; i < MAX_LVM_VG; i++) 1969 for (ii = 0; ii < MAX_LVM_PV; ii++) 1970 if (lvms[i].enabled && 1971 lvms[i].pv[ii].pm == pm_cur && 1972 lvms[i].pv[ii].pm_part == part_num) { 1973 if (do_del) 1974 lvms[i].pv[ii].pm = NULL; 1975 return 1; 1976 } 1977 1978 return 0; 1979 } 1980 1981 /* Clean up removed devices */ 1982 static int 1983 pm_clean(void) 1984 { 1985 int count = 0; 1986 pm_devs_t *pm_i; 1987 1988 SLIST_FOREACH(pm_i, &pm_head, l) 1989 if (! pm_i->found) { 1990 count++; 1991 SLIST_REMOVE(&pm_head, pm_i, pm_devs_t, l); 1992 free(pm_i); 1993 } 1994 return count; 1995 } 1996 1997 void 1998 pm_make_bsd_partitions(pm_devs_t *pm_cur) 1999 { 2000 int i; 2001 partinfo baklabel[MAXPARTITIONS]; 2002 memcpy(baklabel, &pm_cur->bsdlabel, sizeof baklabel); 2003 2004 pm_cur->unsaved = 1; 2005 layoutkind = LY_SETNEW; 2006 md_make_bsd_partitions(); 2007 pm_cur->bootable = (pm_cur->bsdlabel[pm_cur->rootpart].pi_flags & PIF_MOUNT) ? 2008 1 : 0; 2009 for (i = 0; i < MAXPARTITIONS; i++) 2010 if (pm_cur->bsdlabel[i].pi_fstype != baklabel[i].pi_fstype || 2011 pm_cur->bsdlabel[i].lvmpv != baklabel[i].lvmpv) 2012 pm_partusage(pm_cur, i, 1); 2013 } 2014 2015 void 2016 pm_setfstype(pm_devs_t *pm_cur, int part_num, int fstype) 2017 { 2018 pm_cur->bsdlabel[part_num].pi_mount[0] = '\0'; 2019 pm_cur->bsdlabel[part_num].pi_flags = 0; 2020 pm_cur->bsdlabel[part_num].lvmpv = 0; 2021 pm_cur->bsdlabel[part_num].pi_fstype = fstype; 2022 return; 2023 } 2024 2025 static void 2026 pm_select(pm_devs_t *pm_devs_in) 2027 { 2028 pm = pm_devs_in; 2029 if (logfp) 2030 (void)fprintf(logfp, "Partman device: %s\n", pm->diskdev); 2031 return; 2032 } 2033 2034 void 2035 pm_rename(pm_devs_t *pm_cur) 2036 { 2037 pm_select(pm_cur); 2038 msg_prompt_win(MSG_packname, -1, 18, 0, 0, pm_cur->bsddiskname, 2039 pm_cur->bsddiskname, sizeof pm_cur->bsddiskname); 2040 #ifndef NO_DISKLABEL 2041 (void) savenewlabel(pm_cur->bsdlabel, MAXPARTITIONS); 2042 #endif 2043 return; 2044 } 2045 2046 int 2047 pm_editpart(int part_num) 2048 { 2049 partinfo backup = pm->bsdlabel[part_num]; 2050 2051 edit_ptn(&(struct menudesc){.cursel = part_num}, NULL); 2052 if (checkoverlap(pm->bsdlabel, MAXPARTITIONS, PART_D, PART_C)) { 2053 msg_display_add(MSG_cantsave); 2054 process_menu(MENU_ok, NULL); 2055 pm->bsdlabel[part_num] = backup; 2056 return -1; 2057 } 2058 pm->unsaved = 1; 2059 return 0; 2060 } 2061 2062 /* Safe erase of disk */ 2063 int 2064 pm_shred(pm_devs_t *pm_cur, int part, int shredtype) 2065 { 2066 int error = -1; 2067 char dev[SSTRSIZE]; 2068 2069 pm_getdevstring(dev, SSTRSIZE, pm_cur, part); 2070 switch(shredtype) { 2071 case SHRED_ZEROS: 2072 error += run_program(RUN_DISPLAY | RUN_PROGRESS, 2073 "dd of=/dev/%s if=/dev/zero bs=1m progress=100 msgfmt=human", 2074 dev); 2075 break; 2076 case SHRED_RANDOM: 2077 error += run_program(RUN_DISPLAY | RUN_PROGRESS, 2078 "dd of=/dev/%s if=/dev/urandom bs=1m progress=100 msgfmt=human", 2079 dev); 2080 break; 2081 case SHRED_CRYPTO: 2082 error += run_program(RUN_DISPLAY | RUN_PROGRESS, 2083 "sh -c 'cgdconfig -s cgd0 /dev/%s aes-cbc 128 < /dev/urandom'", 2084 dev); /* XXX: cgd0?! */ 2085 if (! error) { 2086 error += run_program(RUN_DISPLAY | RUN_PROGRESS, 2087 "dd of=/dev/rcgd0d if=/dev/urandom bs=1m progress=100 msgfmt=human"); 2088 error += run_program(RUN_DISPLAY | RUN_PROGRESS, 2089 "cgdconfig -u cgd0"); 2090 } 2091 break; 2092 default: 2093 return -1; 2094 } 2095 pm_partusage(pm_cur, -1, 1); 2096 memset(&pm_cur->oldlabel, 0, sizeof pm_cur->oldlabel); 2097 memset(&pm_cur->bsdlabel, 0, sizeof pm_cur->bsdlabel); 2098 return error; 2099 } 2100 2101 static int 2102 pm_mountall_sort(const void *a, const void *b) 2103 { 2104 return strcmp(mnts[*(const int *)a].on, mnts[*(const int *)b].on); 2105 } 2106 2107 /* Mount all available partitions */ 2108 static int 2109 pm_mountall(void) 2110 { 2111 int num_devs = 0; 2112 int mnts_order[MAX_MNTS]; 2113 int i, ii, error, ok; 2114 char dev[SSTRSIZE]; dev[0] = '\0'; 2115 pm_devs_t *pm_i; 2116 2117 localfs_dev[0] = '\0'; 2118 if (mnts == NULL) 2119 mnts = calloc(MAX_MNTS, sizeof(*mnts)); 2120 2121 SLIST_FOREACH(pm_i, &pm_head, l) { 2122 ok = 0; 2123 for (i = 0; i < MAXPARTITIONS; i++) { 2124 if (!(pm_i->bsdlabel[i].pi_flags & PIF_MOUNT && 2125 pm_i->bsdlabel[i].mnt_opts != NULL)) 2126 continue; 2127 mnts[num_devs].mnt_opts = pm_i->bsdlabel[i].mnt_opts; 2128 if (strlen(pm_i->bsdlabel[i].mounted) > 0) { 2129 /* Device is already mounted. So, doing mount_null */ 2130 strlcpy(mnts[num_devs].dev, pm_i->bsdlabel[i].mounted, MOUNTLEN); 2131 mnts[num_devs].mnt_opts = "-t null"; 2132 } else { 2133 pm_getdevstring(dev, SSTRSIZE, pm_i, i); 2134 snprintf(mnts[num_devs].dev, STRSIZE, "/dev/%s", dev); 2135 } 2136 mnts[num_devs].on = pm_i->bsdlabel[i].pi_mount; 2137 if (strcmp(pm_i->bsdlabel[i].pi_mount, "/") == 0) { 2138 if (pm_i->isspecial) 2139 pm_i->bootable = 1; 2140 /* Use disk with / as a default if the user has 2141 the sets on a local disk */ 2142 strlcpy(localfs_dev, pm_i->diskdev, SSTRSIZE); 2143 } 2144 num_devs++; 2145 ok = 1; 2146 } 2147 if (ok) 2148 md_pre_mount(); 2149 } 2150 if (strlen(localfs_dev) < 1) { 2151 msg_display(MSG_noroot); 2152 process_menu(MENU_ok, NULL); 2153 return -1; 2154 } 2155 for (i = 0; i < num_devs; i++) 2156 mnts_order[i] = i; 2157 qsort(mnts_order, num_devs, sizeof mnts_order[0], pm_mountall_sort); 2158 2159 for (i = 0; i < num_devs; i++) { 2160 ii = mnts_order[i]; 2161 make_target_dir(mnts[ii].on); 2162 error = target_mount_do(mnts[ii].mnt_opts, mnts[ii].dev, mnts[ii].on); 2163 if (error) 2164 return error; 2165 } 2166 return 0; 2167 } 2168 2169 /* Mount partition bypassing ordinary order */ 2170 static int 2171 pm_mount(pm_devs_t *pm_cur, int part_num) 2172 { 2173 int error = 0; 2174 char buf[MOUNTLEN]; 2175 2176 if (strlen(pm_cur->bsdlabel[part_num].mounted) > 0) 2177 return 0; 2178 2179 snprintf(buf, MOUNTLEN, "/tmp/%s%c", pm_cur->diskdev, part_num + 'a'); 2180 if (! dir_exists_p(buf)) 2181 run_program(RUN_DISPLAY | RUN_PROGRESS, "/bin/mkdir -p %s", buf); 2182 if (pm_cur->bsdlabel[part_num].pi_flags & PIF_MOUNT && 2183 pm_cur->bsdlabel[part_num].mnt_opts != NULL && 2184 strlen(pm_cur->bsdlabel[part_num].mounted) < 1) 2185 error += run_program(RUN_DISPLAY | RUN_PROGRESS, "/sbin/mount %s /dev/%s%c %s", 2186 pm_cur->bsdlabel[part_num].mnt_opts, 2187 pm_cur->diskdev, part_num + 'a', buf); 2188 2189 if (error) 2190 pm_cur->bsdlabel[part_num].mounted[0] = '\0'; 2191 else { 2192 strlcpy(pm_cur->bsdlabel[part_num].mounted, buf, MOUNTLEN); 2193 pm_cur->blocked++; 2194 } 2195 return error; 2196 } 2197 2198 void 2199 pm_umount(pm_devs_t *pm_cur, int part_num) 2200 { 2201 char buf[SSTRSIZE]; buf[0] = '\0'; 2202 pm_getdevstring(buf, SSTRSIZE, pm_cur, part_num); 2203 2204 if (run_program(RUN_DISPLAY | RUN_PROGRESS, 2205 "umount -f /dev/%s", buf) == 0) { 2206 pm_cur->bsdlabel[part_num].mounted[0] = '\0'; 2207 if (pm_cur->blocked > 0) 2208 pm_cur->blocked--; 2209 } 2210 return; 2211 } 2212 2213 int 2214 pm_unconfigure(pm_devs_t *pm_cur) 2215 { 2216 int i, error = 0, num = 0; 2217 if (! strncmp(pm_cur->diskdev, "cgd", 3)) { 2218 error = run_program(RUN_DISPLAY | RUN_PROGRESS, "cgdconfig -u %s", pm_cur->diskdev); 2219 if (! error && pm_cur->refdev != NULL) { 2220 ((cgds_t*)pm_cur->refdev)->pm->blocked--; 2221 ((cgds_t*)pm_cur->refdev)->blocked = 0; 2222 } 2223 } else if (! strncmp(pm_cur->diskdev, "vnd", 3)) { 2224 error = run_program(RUN_DISPLAY | RUN_PROGRESS, "vndconfig -u %s", pm_cur->diskdev); 2225 if (! error && pm_cur->refdev != NULL) { 2226 ((vnds_t*)pm_cur->refdev)->pm->blocked--; 2227 ((vnds_t*)pm_cur->refdev)->blocked = 0; 2228 } 2229 } else if (! strncmp(pm_cur->diskdev, "raid", 4)) { 2230 error = run_program(RUN_DISPLAY | RUN_PROGRESS, "raidctl -u %s", pm_cur->diskdev); 2231 if (! error && pm_cur->refdev != NULL) { 2232 ((raids_t*)pm_cur->refdev)->blocked = 0; 2233 for (i = 0; i < MAX_IN_RAID; i++) 2234 if (((raids_t*)pm_cur->refdev)->pm[i] != NULL) 2235 ((raids_t*)pm_cur->refdev)->pm[i]->blocked--; 2236 } 2237 } else if (! strncmp(pm_cur->diskdev, "dk", 2)) { 2238 if (pm_cur->refdev == NULL) 2239 return -2; 2240 error = run_program(RUN_DISPLAY | RUN_PROGRESS, "dkctl %s delwedge %s", 2241 ((pm_devs_t*)pm_cur->refdev)->diskdev, pm_cur->diskdev); 2242 if (! error) { 2243 if (pm_cur->refdev != NULL && ((pm_devs_t*)pm_cur->refdev)->blocked > 0) 2244 ((pm_devs_t*)pm_cur->refdev)->blocked--; 2245 sscanf(pm_cur->diskdev, "dk%d", &num); 2246 if (num >= 0 && num < MAX_WEDGES) 2247 wedges[num].allocated = 0; 2248 } 2249 } /* XXX: lvm */ 2250 else 2251 error = run_program(RUN_DISPLAY | RUN_PROGRESS, "eject -t disk /dev/%sd", 2252 pm_cur->diskdev); 2253 if (!error) 2254 pm_cur->found = 0; 2255 return error; 2256 } 2257 2258 /* Last checks before leaving partition manager */ 2259 static int 2260 pm_lastcheck(void) 2261 { 2262 FILE *file_tmp = fopen(concat_paths(targetroot_mnt, "/etc/fstab"), "r"); 2263 if (file_tmp == NULL) 2264 return 1; 2265 fclose(file_tmp); 2266 return 0; 2267 } 2268 2269 /* Are there unsaved changes? */ 2270 static int 2271 pm_needsave(void) 2272 { 2273 pm_devs_t *pm_i; 2274 SLIST_FOREACH(pm_i, &pm_head, l) 2275 if (pm_i->unsaved) { 2276 /* Oops, we have unsaved changes */ 2277 changed = 1; 2278 msg_display(MSG_saveprompt); 2279 return ask_yesno(NULL); 2280 } 2281 return 0; 2282 } 2283 2284 /* Write all changes to disk */ 2285 static int 2286 pm_commit(menudesc *m, void *arg) 2287 { 2288 int retcode; 2289 pm_devs_t *pm_i; 2290 if (m != NULL && arg != NULL) 2291 ((part_entry_t *)arg)[0].retvalue = m->cursel + 1; 2292 2293 pm_gpt_commit(); 2294 2295 SLIST_FOREACH(pm_i, &pm_head, l) { 2296 if (! pm_i->unsaved) 2297 continue; 2298 pm_select(pm_i); 2299 2300 if (pm_i->isspecial) { 2301 if (make_filesystems() != 0) { 2302 if (logfp) 2303 fprintf(logfp, "Special disk %s preparing error\n", pm_i->diskdev); 2304 continue; 2305 } 2306 pm_i->unsaved = 0; 2307 } else if (! pm_i->gpt) { 2308 #ifndef NO_DISKLABEL 2309 savenewlabel(pm_i->bsdlabel, MAXPARTITIONS); 2310 #endif 2311 if ( 2312 write_disklabel() != 0 || /* Write slices table (disklabel) */ 2313 set_swap_if_low_ram(pm->diskdev, pm->bsdlabel) != 0 || 2314 md_post_disklabel() != 0 || /* Enable swap and check badblock */ 2315 make_filesystems() != 0 /* Create filesystems with newfs */ 2316 ) { 2317 /* Oops, something failed... */ 2318 if (logfp) 2319 fprintf(logfp, "Disk %s preparing error\n", pm_i->diskdev); 2320 continue; 2321 } 2322 pm_i->unsaved = 0; 2323 } 2324 } 2325 2326 /* Call all functions that may create new devices */ 2327 if ((retcode = pm_raid_commit()) != 0) { 2328 if (logfp) 2329 fprintf(logfp, "RAIDframe configuring error #%d\n", retcode); 2330 return -1; 2331 } 2332 if ((retcode = pm_cgd_commit()) != 0) { 2333 if (logfp) 2334 fprintf(logfp, "CGD configuring error #%d\n", retcode); 2335 return -1; 2336 } 2337 if ((retcode = pm_lvm_commit()) != 0) { 2338 if (logfp) 2339 fprintf(logfp, "LVM configuring error #%d\n", retcode); 2340 return -1; 2341 } 2342 if ((retcode = pm_vnd_commit()) != 0) { 2343 if (logfp) 2344 fprintf(logfp, "VND configuring error #%d\n", retcode); 2345 return -1; 2346 } 2347 if (m != NULL && arg != NULL) 2348 pm_upddevlist(m, arg); 2349 if (logfp) 2350 fflush (logfp); 2351 return 0; 2352 } 2353 2354 static int 2355 pm_savebootsector(void) 2356 { 2357 pm_devs_t *pm_i; 2358 SLIST_FOREACH(pm_i, &pm_head, l) 2359 if (pm_i->bootable) { 2360 if (! strncmp("raid", pm_i->diskdev, 4)) 2361 if (run_program(RUN_DISPLAY | RUN_PROGRESS, 2362 "raidctl -v -A root %s", pm_i->diskdev) != 0) { 2363 if (logfp) 2364 fprintf(logfp, "Error writting RAID bootsector to %s\n", 2365 pm_i->diskdev); 2366 continue; 2367 } 2368 if (pm_i->gpt && ! pm_i->isspecial) { 2369 if (pm_i->rootpart < 0 || 2370 run_program(RUN_DISPLAY | RUN_PROGRESS, 2371 "gpt biosboot -i %d %s", 2372 pm_i->rootpart + 1, pm_i->diskdev) != 0) { 2373 if (logfp) 2374 fprintf(logfp, "Error writting GPT bootsector to %s\n", 2375 pm_i->diskdev); 2376 continue; 2377 } 2378 } else { 2379 pm_select(pm_i); 2380 if ( 2381 #ifndef NO_DISKLABEL 2382 check_partitions() == 0 || 2383 #endif 2384 md_post_newfs() != 0) { 2385 if (logfp) 2386 fprintf(logfp, "Error writting bootsector to %s\n", 2387 pm_i->diskdev); 2388 continue; 2389 } 2390 } 2391 } 2392 return 0; 2393 } 2394 2395 /* Function for 'Enter'-menu */ 2396 static int 2397 pm_submenu(menudesc *m, void *arg) 2398 { 2399 int part_num = -1; 2400 pm_devs_t *pm_cur = NULL; 2401 ((part_entry_t *)arg)[0].retvalue = m->cursel + 1; 2402 2403 switch (((part_entry_t *)arg)[m->cursel].type) { 2404 case PM_DISK_T: 2405 case PM_WEDGE_T: 2406 case PM_PART_T: 2407 case PM_SPEC_T: 2408 if (((part_entry_t *)arg)[m->cursel].dev_ptr != NULL) { 2409 pm_cur = ((part_entry_t *)arg)[m->cursel].dev_ptr; 2410 if (pm_cur == NULL) 2411 return -1; 2412 if (pm_cur->blocked) { 2413 msg_display(MSG_wannaunblock); 2414 if (!ask_noyes(NULL)) 2415 return -2; 2416 pm_cur->blocked = 0; 2417 } 2418 pm_select(pm_cur); 2419 } 2420 default: 2421 break; 2422 } 2423 2424 switch (((part_entry_t *)arg)[m->cursel].type) { 2425 case PM_DISK_T: 2426 if (pm_cur != NULL && pm_cur->gpt) { 2427 process_menu(MENU_pmgptentry, &part_num); 2428 pm_wedges_fill(pm_cur); 2429 } else { 2430 process_menu(MENU_pmdiskentry, &part_num); 2431 } 2432 break; 2433 case PM_WEDGE_T: 2434 case PM_PART_T: 2435 part_num = ((part_entry_t *)arg)[m->cursel].dev_num; 2436 process_menu(MENU_pmpartentry, &part_num); 2437 if (pm_cur != NULL && pm_cur->gpt) 2438 pm_wedges_fill(pm_cur); 2439 break; 2440 case PM_SPEC_T: 2441 part_num = 0; 2442 process_menu(MENU_pmpartentry, &part_num); 2443 break; 2444 case PM_RAID_T: 2445 return pm_edit(PMR_MENU_END, pm_raid_edit_menufmt, 2446 pm_raid_set_value, pm_raid_check, pm_raid_init, 2447 NULL, ((part_entry_t *)arg)[m->cursel].dev_ptr, 0, &raids_t_info); 2448 case PM_VND_T: 2449 return pm_edit(PMV_MENU_END, pm_vnd_edit_menufmt, 2450 pm_vnd_set_value, pm_vnd_check, pm_vnd_init, 2451 NULL, ((part_entry_t *)arg)[m->cursel].dev_ptr, 0, &vnds_t_info); 2452 case PM_CGD_T: 2453 return pm_cgd_edit(((part_entry_t *)arg)[m->cursel].dev_ptr, 2454 NULL); 2455 case PM_LVM_T: 2456 return pm_edit(PML_MENU_END, pm_lvm_edit_menufmt, 2457 pm_lvm_set_value, pm_lvm_check, pm_lvm_init, 2458 NULL, ((part_entry_t *)arg)[m->cursel].dev_ptr, 0, &lvms_t_info); 2459 case PM_LVMLV_T: 2460 return pm_edit(PMLV_MENU_END, pm_lvmlv_edit_menufmt, 2461 pm_lvmlv_set_value, pm_lvmlv_check, pm_lvmlv_init, 2462 NULL, ((part_entry_t *)arg)[m->cursel].dev_ptr, 2463 ((part_entry_t *)arg)[m->cursel].dev_ptr_delta, &lv_t_info); 2464 } 2465 return 0; 2466 } 2467 2468 /* Functions that generate menu entries text */ 2469 static void 2470 pm_menufmt(menudesc *m, int opt, void *arg) 2471 { 2472 const char *dev_status = ""; 2473 char buf[STRSIZE]; 2474 int part_num = ((part_entry_t *)arg)[opt].dev_num; 2475 pm_devs_t *pm_cur = ((part_entry_t *)arg)[opt].dev_ptr; 2476 2477 switch (((part_entry_t *)arg)[opt].type) { 2478 case PM_DISK_T: 2479 if (pm_cur->blocked) 2480 dev_status = msg_string(MSG_pmblocked); 2481 else if (! pm_cur->unsaved) 2482 dev_status = msg_string(MSG_pmunchanged); 2483 else if (pm_cur->bootable) 2484 dev_status = msg_string(MSG_pmsetboot); 2485 else 2486 dev_status = msg_string(MSG_pmused); 2487 wprintw(m->mw, "%-33.32s %-22.21s %12.12s", 2488 pm_cur->diskdev_descr, 2489 (pm_cur->gpt) ? 2490 msg_string(MSG_pmgptdisk) : 2491 pm_cur->bsddiskname, 2492 dev_status); 2493 break; 2494 case PM_WEDGE_T: 2495 part_num = ((part_entry_t *)arg)[opt].wedge_num; 2496 snprintf(buf, STRSIZE, "dk%d: %s", 2497 part_num, 2498 wedges[part_num].pm->bsdlabel[wedges[part_num].ptn].pi_mount); 2499 wprintw(m->mw, " %-30.29s %-22.21s %11uM", 2500 buf, 2501 (wedges[part_num].pm->bsdlabel[wedges[part_num].ptn].lvmpv) ? 2502 "lvm pv" : 2503 getfslabelname(wedges[part_num].pm->bsdlabel[wedges[part_num]. 2504 ptn].pi_fstype), 2505 wedges[part_num].pm->bsdlabel[wedges[part_num].ptn].pi_size / 2506 (MEG / pm_cur->sectorsize)); 2507 break; 2508 case PM_PART_T: 2509 snprintf(buf, STRSIZE, "%s%c: %s %s", 2510 pm_cur->diskdev, 2511 'a' + part_num, 2512 pm_cur->bsdlabel[part_num].pi_mount, 2513 (strlen(pm_cur->bsdlabel[part_num].mounted) > 0) ? msg_string(MSG_pmmounted) : 2514 (part_num == PART_B || 2515 strlen (pm_cur->bsdlabel[part_num].pi_mount ) < 1 || 2516 pm_cur->bsdlabel[part_num].pi_flags & PIF_MOUNT) ? 2517 "" : msg_string(MSG_pmunused)); 2518 wprintw(m->mw, " %-30.29s %-22.21s %11uM", 2519 buf, 2520 (pm_cur->bsdlabel[part_num].lvmpv) ? 2521 "lvm pv" : 2522 getfslabelname(pm_cur->bsdlabel[part_num].pi_fstype), 2523 pm_cur->bsdlabel[part_num].pi_size / (MEG / pm_cur->sectorsize)); 2524 break; 2525 case PM_SPEC_T: 2526 snprintf(buf, STRSIZE, "%s: %s", 2527 pm_cur->diskdev_descr, pm_cur->bsdlabel[0].pi_mount); 2528 wprintw(m->mw, "%-33.32s %-22.21s %11uM", buf, 2529 getfslabelname(pm_cur->bsdlabel[0].pi_fstype), 2530 pm_cur->bsdlabel[0].pi_size / (MEG / pm_cur->sectorsize)); 2531 break; 2532 case PM_RAID_T: 2533 pm_raid_menufmt(m, opt, arg); 2534 break; 2535 case PM_VND_T: 2536 pm_vnd_menufmt(m, opt, arg); 2537 break; 2538 case PM_CGD_T: 2539 pm_cgd_menufmt(m, opt, arg); 2540 break; 2541 case PM_LVM_T: 2542 pm_lvm_menufmt(m, opt, arg); 2543 break; 2544 case PM_LVMLV_T: 2545 pm_lvmlv_menufmt(m, opt, arg); 2546 break; 2547 } 2548 return; 2549 } 2550 2551 /* Submenu for RAID/LVM/CGD/VND */ 2552 static void 2553 pm_upddevlist_adv(menudesc *m, void *arg, int *i, 2554 pm_upddevlist_adv_t *d) 2555 { 2556 int ii; 2557 if (d->create_msg != NULL) { 2558 /* We want to have menu entry that creates a new device */ 2559 ((part_entry_t *)arg)[*i].type = d->pe_type; 2560 ((part_entry_t *)arg)[*i].dev_ptr = NULL; 2561 ((part_entry_t *)arg)[*i].dev_ptr_delta = d->s->parent_size * d->sub_num; 2562 m->opts[(*i)++] = (struct menu_ent) { 2563 .opt_name = d->create_msg, 2564 .opt_action = pm_submenu, 2565 }; 2566 } 2567 for (ii = 0; ii < d->s->max; ii++) { 2568 if (d->s->entry_enabled == NULL || 2569 d->s->entry_blocked == NULL || 2570 *(int*)((char*)d->s->entry_enabled + d->s->entry_size * ii + 2571 d->s->parent_size * d->sub_num) == 0 || 2572 *(int*)((char*)d->s->entry_blocked + d->s->entry_size * ii + 2573 d->s->parent_size * d->sub_num) != 0) 2574 continue; 2575 /* We have a entry for displaying */ 2576 changed = 1; 2577 m->opts[*i] = (struct menu_ent) { 2578 .opt_name = NULL, 2579 .opt_action = pm_submenu, 2580 }; 2581 ((part_entry_t *)arg)[*i].type = d->pe_type; 2582 ((part_entry_t *)arg)[*i].dev_ptr = (char*)d->s->entry_first + 2583 d->s->entry_size * ii + d->s->parent_size * d->sub_num; 2584 (*i)++; 2585 /* We should show submenu for current entry */ 2586 if (d->sub != NULL) { 2587 d->sub->sub_num = ii; 2588 pm_upddevlist_adv(m, arg, i, d->sub); 2589 } 2590 } 2591 return; 2592 } 2593 2594 /* Update partman main menu with devices list */ 2595 static int 2596 pm_upddevlist(menudesc *m, void *arg) 2597 { 2598 int i = 0, ii; 2599 pm_devs_t *pm_i; 2600 2601 if (arg != NULL) 2602 ((part_entry_t *)arg)[0].retvalue = m->cursel + 1; 2603 2604 changed = 0; 2605 /* Mark all devices as not found */ 2606 SLIST_FOREACH(pm_i, &pm_head, l) 2607 if (pm_i->found > 0) 2608 pm_i->found = 0; 2609 /* Detect all present devices */ 2610 (void)find_disks("partman"); 2611 if (have_lvm) 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("vndconfig"); 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