partman.c revision 1.13
1 /* $NetBSD: partman.c,v 1.13 2016/05/30 17:03:21 dholland 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[MAX_RAID]; 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[MAX_VND]; 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[MAX_CGD]; 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[MAX_LVM_VG]; 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[MAX_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 strncat(buf, dev_ptr->pm_name[i], STRSIZE); 380 strncat(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, "blowfish-cbc")) 1027 dev_ptr->key_size = 128; 1028 if (! strcmp(retstring, "3des-cbc")) 1029 dev_ptr->key_size = 192; 1030 return 0; 1031 case PMC_MENU_KEYSIZE: 1032 if (! strcmp(dev_ptr->enc_type, "aes-cbc")) 1033 dev_ptr->key_size += 1034 (dev_ptr->key_size < 256)? 64 : -128; 1035 if (! strcmp(dev_ptr->enc_type, "blowfish-cbc")) 1036 dev_ptr->key_size = 128; 1037 if (! strcmp(dev_ptr->enc_type, "3des-cbc")) 1038 dev_ptr->key_size = 192; 1039 return 0; 1040 case PMC_MENU_IVTYPE: 1041 process_menu(MENU_cgd_ivtype, &retstring); 1042 dev_ptr->iv_type = retstring; 1043 return 0; 1044 case PMC_MENU_KEYGENTYPE: 1045 process_menu(MENU_cgd_keygentype, &retstring); 1046 dev_ptr->keygen_type = retstring; 1047 return 0; 1048 case PMC_MENU_VERIFYTYPE: 1049 process_menu(MENU_cgd_verifytype, &retstring); 1050 dev_ptr->verify_type = retstring; 1051 return 0; 1052 case PMC_MENU_REMOVE: 1053 dev_ptr->enabled = 0; 1054 return 0; 1055 } 1056 return -1; 1057 } 1058 1059 static void 1060 pm_cgd_init(void *arg1, void *arg2) 1061 { 1062 cgds_t *dev_ptr = arg1; 1063 part_entry_t *disk_entrie = arg2; 1064 1065 memset(dev_ptr, 0, sizeof(*dev_ptr)); 1066 *dev_ptr = (struct cgds_t) { 1067 .enabled = 1, 1068 .blocked = 0, 1069 .pm = NULL, 1070 .pm_name[0] = '\0', 1071 .pm_part = 0, 1072 .keygen_type = "pkcs5_pbkdf2/sha1", 1073 .verify_type = "disklabel", 1074 .enc_type = "aes-cbc", 1075 .iv_type = "encblkno1", 1076 .key_size = 192, 1077 }; 1078 if (disk_entrie != NULL) { 1079 pm_getdevstring(disk_entrie->fullname, SSTRSIZE, 1080 disk_entrie->dev_ptr, disk_entrie->dev_num); 1081 pm_cgd_disk_set(dev_ptr, disk_entrie); 1082 } 1083 return; 1084 } 1085 1086 static int 1087 pm_cgd_check(void *arg) 1088 { 1089 cgds_t *dev_ptr = arg; 1090 1091 if (dev_ptr->blocked) 1092 return 0; 1093 if (dev_ptr->pm == NULL) 1094 dev_ptr->enabled = 0; 1095 else 1096 pm_manage_getfreenode(&(dev_ptr->node), "cgd", &cgds_t_info); 1097 if (dev_ptr->node < 0) 1098 dev_ptr->enabled = 0; 1099 return dev_ptr->enabled; 1100 } 1101 1102 static int 1103 pm_cgd_disk_set(cgds_t *dev_ptr, part_entry_t *disk_entrie) 1104 { 1105 int alloc_disk_entrie = 0; 1106 if (disk_entrie == NULL) { 1107 alloc_disk_entrie = 1; 1108 disk_entrie = malloc (sizeof(part_entry_t)); 1109 if (disk_entrie == NULL) 1110 return -2; 1111 *disk_entrie = pm_dev_list(PM_CGD_T); 1112 if (disk_entrie->retvalue < 0) { 1113 free(disk_entrie); 1114 return -1; 1115 } 1116 } 1117 dev_ptr->pm = disk_entrie->dev_ptr; 1118 dev_ptr->pm_part = disk_entrie->dev_num; 1119 strlcpy(dev_ptr->pm_name, disk_entrie->fullname, SSTRSIZE); 1120 1121 if (alloc_disk_entrie) 1122 free(disk_entrie); 1123 return 0; 1124 } 1125 1126 int 1127 pm_cgd_edit(void *dev_ptr, part_entry_t *disk_entrie) 1128 { 1129 if (disk_entrie != NULL) 1130 dev_ptr = NULL; 1131 return pm_edit(PMC_MENU_END, pm_cgd_edit_menufmt, 1132 pm_cgd_set_value, pm_cgd_check, pm_cgd_init, 1133 disk_entrie, dev_ptr, 0, &cgds_t_info); 1134 } 1135 1136 static int 1137 pm_cgd_commit(void) 1138 { 1139 int i, error = 0; 1140 for (i = 0; i < MAX_CGD; i++) { 1141 if (! pm_cgd_check(&cgds[i])) 1142 continue; 1143 if (run_program(RUN_DISPLAY | RUN_PROGRESS, 1144 "cgdconfig -g -i %s -k %s -o /tmp/cgd.%d.conf %s %d", 1145 cgds[i].iv_type, cgds[i].keygen_type, cgds[i].node, 1146 cgds[i].enc_type, cgds[i].key_size) != 0) { 1147 error++; 1148 continue; 1149 } 1150 if (run_program(RUN_DISPLAY | RUN_PROGRESS, 1151 "cgdconfig -V re-enter cgd%d /dev/%s /tmp/cgd.%d.conf", 1152 cgds[i].node, cgds[i].pm_name, cgds[i].node) != 0) { 1153 error++; 1154 continue; 1155 } 1156 cgds[i].pm->blocked++; 1157 cgds[i].blocked = 1; 1158 } 1159 return error; 1160 } 1161 1162 /*** 1163 LVM 1164 ***/ 1165 1166 /* Add lvm logical volumes to pm list */ 1167 /* XXX: rewrite */ 1168 static int 1169 pm_lvm_find(void) 1170 { 1171 int i, ii, already_found; 1172 char dev[STRSIZE]; 1173 pm_devs_t *pm_i; 1174 1175 for (i = 0; i < MAX_LVM_VG; i++) { 1176 if (! lvms[i].blocked) 1177 continue; 1178 for (ii = 0; ii < MAX_LVM_LV; ii++) { 1179 if (! lvms[i].lv[ii].blocked || lvms[i].lv[ii].size < 1) 1180 continue; 1181 snprintf(dev, STRSIZE, "%s/%s", lvms[i].name, lvms[i].lv[ii].name); 1182 already_found = 0; 1183 SLIST_FOREACH(pm_i, &pm_head, l) 1184 if (!already_found && strcmp(pm_i->diskdev, dev) == 0) { 1185 pm_i->found = 1; 1186 already_found = 1; 1187 } 1188 if (already_found) 1189 /* We already added this device, skipping */ 1190 continue; 1191 pm_new->found = 1; 1192 pm_new->isspecial = 1; 1193 pm_new->refdev = &lvms[i].lv[ii]; 1194 pm_new->sectorsize = 1; 1195 pm_new->dlcylsize = MEG; 1196 pm_new->bsdlabel[0].pi_size = MEG * lvms[i].lv[ii].size; 1197 strlcpy(pm_new->diskdev, dev, SSTRSIZE); 1198 strlcpy(pm_new->diskdev_descr, dev, STRSIZE); 1199 1200 if (SLIST_EMPTY(&pm_head)) 1201 SLIST_INSERT_HEAD(&pm_head, pm_new, l); 1202 else 1203 SLIST_INSERT_AFTER(pm_i, pm_new, l); 1204 pm_new = malloc(sizeof (pm_devs_t)); 1205 memset(pm_new, 0, sizeof *pm_new); 1206 } 1207 } 1208 return 0; 1209 } 1210 1211 static int 1212 pm_lvm_disk_add(menudesc *m, void *arg) 1213 { 1214 int i; 1215 lvms_t *dev_ptr = arg; 1216 part_entry_t disk_entrie = pm_dev_list(PM_LVM_T); 1217 if (disk_entrie.retvalue < 0) 1218 return disk_entrie.retvalue; 1219 1220 for (i = 0; i < MAX_LVM_PV; i++) 1221 if (dev_ptr->pv[i].pm == NULL) { 1222 dev_ptr->pv[i].pm = disk_entrie.dev_ptr; 1223 dev_ptr->pv[i].pm_part = disk_entrie.dev_num; 1224 strlcpy(dev_ptr->pv[i].pm_name, disk_entrie.fullname, SSTRSIZE); 1225 break; 1226 } 1227 return 0; 1228 } 1229 1230 static int 1231 pm_lvm_disk_del(menudesc *m, void *arg) 1232 { 1233 int i, retvalue = -1, num_devs = 0; 1234 int menu_no; 1235 lvms_t *dev_ptr = arg; 1236 menu_ent menu_entries[MAX_LVM_PV]; 1237 part_entry_t submenu_args[MAX_LVM_PV]; 1238 1239 for (i = 0; i < MAX_LVM_PV; i++) { 1240 if (dev_ptr->pv[i].pm == NULL) 1241 continue; 1242 menu_entries[num_devs] = (struct menu_ent) { 1243 .opt_name = dev_ptr->pv[i].pm_name, 1244 .opt_action = set_menu_select, 1245 .opt_menu = OPT_NOMENU, 1246 .opt_flags = OPT_EXIT, 1247 }; 1248 submenu_args[num_devs].dev_num = i; 1249 num_devs++; 1250 } 1251 1252 menu_no = new_menu(MSG_lvm_disks, 1253 menu_entries, num_devs, -1, -1, (num_devs+1<3)?3:num_devs+1, 13, 1254 MC_SCROLL | MC_NOCLEAR, NULL, NULL, NULL, NULL, NULL); 1255 if (menu_no == -1) 1256 return -1; 1257 process_menu(menu_no, &retvalue); 1258 free_menu(menu_no); 1259 1260 if (retvalue < 0 || retvalue >= num_devs) 1261 return -1; 1262 1263 dev_ptr->pv[submenu_args[retvalue].dev_num].pm = NULL; 1264 1265 return 0; 1266 } 1267 1268 static void 1269 pm_lvm_menufmt(menudesc *m, int opt, void *arg) 1270 { 1271 int i, ok = 0, used_size = 0; 1272 char buf1[STRSIZE]; buf1[0] = '\0'; 1273 char buf2[STRSIZE]; buf2[0] = '\0'; 1274 lvms_t *dev_ptr = ((part_entry_t *)arg)[opt].dev_ptr; 1275 1276 if (dev_ptr->enabled == 0) 1277 return; 1278 snprintf(buf1, STRSIZE, "VG '%s' on ", dev_ptr->name); 1279 for (i = 0; i < MAX_LVM_PV; i++) 1280 if (dev_ptr->pv[i].pm != NULL) { 1281 strncat(buf1, dev_ptr->pv[i].pm_name, STRSIZE); 1282 strncat(buf1, " ", STRSIZE); 1283 ok = 1; 1284 } 1285 for (i = 0; i < MAX_LVM_LV; i++) 1286 used_size += dev_ptr->lv[i].size; 1287 if (ok) { 1288 snprintf(buf2, STRSIZE, "%d/%u", 1289 dev_ptr->total_size - used_size, dev_ptr->total_size); 1290 wprintw(m->mw, msg_string(MSG_lvm_menufmt), buf1, buf2); 1291 } else 1292 wprintw(m->mw, "%s", msg_string(MSG_lvm_err_menufmt)); 1293 return; 1294 } 1295 1296 static void 1297 pm_lvm_edit_menufmt(menudesc *m, int opt, void *arg) 1298 { 1299 int i; 1300 char buf[STRSIZE]; 1301 lvms_t *dev_ptr = arg; 1302 strlcpy(buf, msg_string(MSG_auto), STRSIZE); 1303 1304 switch (opt) { 1305 case PML_MENU_PV: 1306 buf[0] = '\0'; 1307 for (i = 0; i < MAX_LVM_PV; i++) 1308 if (dev_ptr->pv[i].pm != NULL) 1309 snprintf(buf, STRSIZE, "%s %s", buf, dev_ptr->pv[i].pm_name); 1310 wprintw(m->mw, msg_string(MSG_lvm_disks_fmt), buf); 1311 break; 1312 case PML_MENU_NAME: 1313 wprintw(m->mw, msg_string(MSG_lvm_name_fmt), dev_ptr->name); 1314 break; 1315 case PML_MENU_MAXLOGICALVOLUMES: 1316 if (dev_ptr->maxlogicalvolumes > 0) 1317 snprintf(buf, STRSIZE, "%d", dev_ptr->maxlogicalvolumes); 1318 wprintw(m->mw, msg_string(MSG_lvm_maxlv_fmt), buf); 1319 break; 1320 case PML_MENU_MAXPHYSICALVOLUMES: 1321 if (dev_ptr->maxphysicalvolumes > 0) 1322 snprintf(buf, STRSIZE, "%d", dev_ptr->maxphysicalvolumes); 1323 wprintw(m->mw, msg_string(MSG_lvm_maxpv_fmt), buf); 1324 break; 1325 case PML_MENU_PHYSICALEXTENTSIZE: 1326 if (dev_ptr->physicalextentsize > 0) 1327 snprintf(buf, STRSIZE, "%dM", dev_ptr->physicalextentsize); 1328 wprintw(m->mw, msg_string(MSG_lvm_extsiz_fmt), buf); 1329 break; 1330 } 1331 return; 1332 } 1333 1334 static int 1335 pm_lvm_set_value(menudesc *m, void *arg) 1336 { 1337 char buf[STRSIZE]; 1338 const char *msg_to_show = NULL; 1339 int *out_var = NULL; 1340 lvms_t *dev_ptr = arg; 1341 1342 static menu_ent menuent_disk_adddel[] = { 1343 {MSG_add, OPT_NOMENU, OPT_EXIT, pm_lvm_disk_add}, 1344 {MSG_remove, OPT_NOMENU, OPT_EXIT, pm_lvm_disk_del} 1345 }; 1346 static int menu_disk_adddel = -1; 1347 if (menu_disk_adddel == -1) { 1348 menu_disk_adddel = new_menu(NULL, menuent_disk_adddel, nelem(menuent_disk_adddel), 1349 -1, -1, 0, 10, MC_NOCLEAR, NULL, NULL, NULL, NULL, NULL); 1350 } 1351 1352 switch (m->cursel) { 1353 case PML_MENU_PV: 1354 process_menu(menu_disk_adddel, arg); 1355 return 0; 1356 case PML_MENU_NAME: 1357 msg_prompt_win(MSG_lvm_name_ask, -1, 18, 0, 0, dev_ptr->name, dev_ptr->name, SSTRSIZE); 1358 return 0; 1359 case PML_MENU_MAXLOGICALVOLUMES: 1360 msg_to_show = MSG_lvm_maxlv_ask; 1361 out_var = &(dev_ptr->maxlogicalvolumes); 1362 break; 1363 case PML_MENU_MAXPHYSICALVOLUMES: 1364 msg_to_show = MSG_lvm_maxpv_ask; 1365 out_var = &(dev_ptr->maxphysicalvolumes); 1366 break; 1367 case PML_MENU_PHYSICALEXTENTSIZE: 1368 msg_to_show = MSG_lvm_extsiz_ask; 1369 out_var = &(dev_ptr->physicalextentsize); 1370 break; 1371 case PML_MENU_REMOVE: 1372 dev_ptr->enabled = 0; 1373 return 0; 1374 } 1375 if (out_var == NULL || msg_to_show == NULL) 1376 return -1; 1377 snprintf(buf, SSTRSIZE, "%d", *out_var); 1378 msg_prompt_win(msg_to_show, -1, 18, 0, 0, buf, buf, SSTRSIZE); 1379 if (atoi(buf) >= 0) 1380 *out_var = atoi(buf); 1381 return 0; 1382 } 1383 1384 static void 1385 pm_lvm_init(void *arg, void* none) 1386 { 1387 lvms_t *dev_ptr = arg; 1388 1389 memset(dev_ptr, 0, sizeof *dev_ptr); 1390 *dev_ptr = (struct lvms_t) { 1391 .enabled = 1, 1392 .blocked = 0, 1393 .maxlogicalvolumes = MAX_LVM_PV, 1394 .maxphysicalvolumes = MAX_LVM_LV, 1395 .physicalextentsize = -1, 1396 }; 1397 sprintf(dev_ptr->name, "vg%.2d", rand()%100); 1398 return; 1399 } 1400 1401 static int 1402 pm_lvm_check(void *arg) 1403 { 1404 int i, ok = 0; 1405 lvms_t *dev_ptr = arg; 1406 dev_ptr->total_size = 0; 1407 1408 for (i = 0; i < MAX_LVM_PV; i++) 1409 if (dev_ptr->pv[i].pm != NULL) { 1410 ok = 1; 1411 dev_ptr->total_size += dev_ptr->pv[i].pm-> 1412 bsdlabel[dev_ptr->pv[i].pm_part].pi_size / 1413 (MEG / dev_ptr->pv[i].pm->sectorsize); 1414 } 1415 if (! ok) 1416 dev_ptr->enabled = 0; 1417 return dev_ptr->enabled; 1418 } 1419 1420 static void 1421 pm_lvmlv_menufmt(menudesc *m, int opt, void *arg) 1422 { 1423 char buf[STRSIZE]; 1424 lv_t *dev_ptr = ((part_entry_t *)arg)[opt].dev_ptr; 1425 1426 if (dev_ptr->size > 0) { 1427 snprintf(buf, STRSIZE, "'%s'", dev_ptr->name); 1428 wprintw(m->mw, msg_string(MSG_lvmlv_menufmt), buf, dev_ptr->size); 1429 } 1430 return; 1431 } 1432 1433 static void 1434 pm_lvmlv_edit_menufmt(menudesc *m, int opt, void *arg) 1435 { 1436 1437 lv_t *dev_ptr = arg; 1438 char buf[STRSIZE]; 1439 strlcpy(buf, msg_string(MSG_auto), STRSIZE); 1440 1441 switch (opt) { 1442 case PMLV_MENU_NAME: 1443 wprintw(m->mw, msg_string(MSG_lvmlv_name_fmt), dev_ptr->name); 1444 break; 1445 case PMLV_MENU_SIZE: 1446 wprintw(m->mw, msg_string(MSG_lvmlv_size_fmt), dev_ptr->size); 1447 break; 1448 case PMLV_MENU_READONLY: 1449 wprintw(m->mw, msg_string(MSG_lvmlv_ro_fmt), 1450 dev_ptr->readonly? msg_string(MSG_Yes) : msg_string(MSG_No)); 1451 break; 1452 case PMLV_MENU_CONTIGUOUS: 1453 wprintw(m->mw, msg_string(MSG_lvmlv_cont_fmt), 1454 dev_ptr->contiguous? msg_string(MSG_Yes) : msg_string(MSG_No)); 1455 break; 1456 case PMLV_MENU_EXTENTS: 1457 wprintw(m->mw, msg_string(MSG_lvmlv_extnum_fmt), 1458 (strlen(dev_ptr->extents) > 0)? dev_ptr->extents : msg_string(MSG_auto)); 1459 break; 1460 case PMLV_MENU_MINOR: 1461 if (dev_ptr->minor > 0) 1462 snprintf(buf, STRSIZE, "%dK", dev_ptr->minor); 1463 wprintw(m->mw, msg_string(MSG_lvmlv_minor_fmt), buf); 1464 break; 1465 case PMLV_MENU_MIRRORS: 1466 wprintw(m->mw, msg_string(MSG_lvmlv_mirrors_fmt), dev_ptr->mirrors); 1467 break; 1468 case PMLV_MENU_REGIONSIZE: 1469 if (dev_ptr->regionsize > 0) 1470 snprintf(buf, STRSIZE, "%dM", dev_ptr->regionsize); 1471 wprintw(m->mw, msg_string(MSG_lvmlv_regsiz_fmt), buf); 1472 break; 1473 case PMLV_MENU_PERSISTENT: 1474 wprintw(m->mw, msg_string(MSG_lvmlv_pers_fmt), 1475 dev_ptr->persistent ? msg_string(MSG_Yes) : msg_string(MSG_No)); 1476 break; 1477 case PMLV_MENU_READAHEAD: 1478 if (dev_ptr->readahead > 0) 1479 snprintf(buf, STRSIZE, "%d", dev_ptr->readahead); 1480 wprintw(m->mw, msg_string(MSG_lvmlv_readahsect_fmt), buf); 1481 break; 1482 case PMLV_MENU_STRIPES: 1483 if (dev_ptr->stripes > 0) 1484 snprintf(buf, STRSIZE, "%d", dev_ptr->stripes); 1485 wprintw(m->mw, msg_string(MSG_lvmlv_stripes_fmt), buf); 1486 break; 1487 case PMLV_MENU_STRIPESIZE: 1488 if (dev_ptr->stripesize > 0) 1489 snprintf(buf, STRSIZE, "%dK", dev_ptr->stripesize); 1490 wprintw(m->mw, msg_string(MSG_lvmlv_stripesiz_fmt), buf); 1491 break; 1492 case PMLV_MENU_ZERO: 1493 wprintw(m->mw, msg_string(MSG_lvmlv_zero_fmt), 1494 dev_ptr->zero? msg_string(MSG_Yes) : msg_string(MSG_No)); 1495 break; 1496 } 1497 return; 1498 } 1499 1500 static int 1501 pm_lvmlv_set_value(menudesc *m, void *arg) 1502 { 1503 char buf[STRSIZE]; 1504 const char *msg_to_show = NULL; 1505 int *out_var = NULL; 1506 lv_t *dev_ptr = arg; 1507 1508 switch (m->cursel) { 1509 case PMLV_MENU_NAME: 1510 msg_prompt_win(MSG_lvmlv_name_ask, -1, 18, 0, 0, dev_ptr->name, dev_ptr->name, 1511 SSTRSIZE); 1512 return 0; 1513 case PMLV_MENU_SIZE: 1514 msg_to_show = MSG_lvmlv_size_ask; 1515 out_var = &(dev_ptr->size); 1516 break; 1517 case PMLV_MENU_READONLY: 1518 dev_ptr->readonly = !dev_ptr->readonly; 1519 return 0; 1520 case PMLV_MENU_CONTIGUOUS: 1521 dev_ptr->contiguous = !dev_ptr->contiguous; 1522 return 0; 1523 case PMLV_MENU_EXTENTS: 1524 msg_prompt_win(MSG_lvmlv_extnum_ask, -1, 18, 0, 0, 1525 dev_ptr->extents, dev_ptr->extents, SSTRSIZE); 1526 return 0; 1527 case PMLV_MENU_MINOR: 1528 msg_to_show = MSG_lvmlv_minor_ask; 1529 out_var = &(dev_ptr->minor); 1530 break; 1531 case PMLV_MENU_MIRRORS: 1532 msg_to_show = MSG_lvmlv_mirrors_ask; 1533 out_var = &(dev_ptr->mirrors); 1534 break; 1535 case PMLV_MENU_REGIONSIZE: 1536 msg_to_show = MSG_lvmlv_regsiz_ask; 1537 out_var = &(dev_ptr->regionsize); 1538 break; 1539 case PMLV_MENU_PERSISTENT: 1540 dev_ptr->persistent = !dev_ptr->persistent; 1541 return 0; 1542 case PMLV_MENU_READAHEAD: 1543 msg_to_show = MSG_lvmlv_readahsect_ask; 1544 out_var = &(dev_ptr->readahead); 1545 break; 1546 case PMLV_MENU_STRIPES: 1547 msg_to_show = MSG_lvmlv_stripes_ask; 1548 out_var = &(dev_ptr->stripes); 1549 break; 1550 case PMLV_MENU_STRIPESIZE: 1551 if (dev_ptr->stripesize << 1 > 512) 1552 dev_ptr->stripesize = 4; 1553 else 1554 dev_ptr->stripesize <<= 1; 1555 return 0; 1556 case PMLV_MENU_ZERO: 1557 dev_ptr->zero = !dev_ptr->zero; 1558 return 0; 1559 case PMLV_MENU_REMOVE: 1560 dev_ptr->size = 0; 1561 return 0; 1562 } 1563 if (out_var == NULL || msg_to_show == NULL) 1564 return -1; 1565 snprintf(buf, SSTRSIZE, "%d", *out_var); 1566 msg_prompt_win(msg_to_show, -1, 18, 0, 0, buf, buf, SSTRSIZE); 1567 if (atoi(buf) >= 0) 1568 *out_var = atoi(buf); 1569 return 0; 1570 } 1571 1572 static void 1573 pm_lvmlv_init(void *arg, void *none) 1574 { 1575 lv_t *dev_ptr = arg; 1576 memset(dev_ptr, 0, sizeof *(dev_ptr)); 1577 *dev_ptr = (struct lv_t) { 1578 .blocked = 0, 1579 .size = 1024, 1580 .stripesize = 64, 1581 }; 1582 sprintf (dev_ptr->name, "lvol%.2d", rand()%100); 1583 return; 1584 } 1585 1586 static int 1587 pm_lvmlv_check(void *arg) 1588 { 1589 lv_t *dev_ptr = arg; 1590 if (dev_ptr->size > 0 && strlen(dev_ptr->name) > 0) 1591 return 1; 1592 else { 1593 dev_ptr->size = 0; 1594 return 0; 1595 } 1596 } 1597 1598 static int 1599 pm_lvm_commit(void) 1600 { 1601 int i, ii, error; 1602 uint used_size = 0; 1603 char params[STRSIZE*3]; 1604 char devs[STRSIZE*3]; 1605 1606 for (i = 0; i < MAX_LVM_VG; i++) { 1607 /* Stage 0: checks */ 1608 if (! pm_lvm_check(&lvms[i])) 1609 continue; 1610 for (ii = 0; ii < MAX_LVM_LV; ii++) 1611 used_size += lvms[i].lv[ii].size; 1612 if (used_size > lvms[i].total_size) 1613 continue; 1614 1615 params[0] = '\0'; 1616 devs[0] = '\0'; 1617 error = 0; 1618 /* Stage 1: creating Physical Volumes (PV's) */ 1619 for (ii = 0; ii < MAX_LVM_PV && ! error; ii++) 1620 if (lvms[i].pv[ii].pm != NULL) { 1621 run_program(RUN_SILENT | RUN_ERROR_OK, 1622 "lvm pvremove -ffy /dev/r%s", 1623 (char*)lvms[i].pv[ii].pm_name); 1624 error += run_program(RUN_DISPLAY | RUN_PROGRESS, 1625 "lvm pvcreate -ffy /dev/r%s", 1626 (char*)lvms[i].pv[ii].pm_name); 1627 if (error) 1628 break; 1629 snprintf(devs, STRSIZE*3, "%s /dev/r%s", devs, (char*)lvms[i].pv[ii].pm_name); 1630 } 1631 if (error) 1632 continue; 1633 /* Stage 2: creating Volume Groups (VG's) */ 1634 if (lvms[i].maxlogicalvolumes > 0) 1635 snprintf(params, STRSIZE*3, "%s -l %d", params, lvms[i].maxlogicalvolumes); 1636 if (lvms[i].maxphysicalvolumes > 0) 1637 snprintf(params, STRSIZE*3, "%s -p %d", params, lvms[i].maxphysicalvolumes); 1638 if (lvms[i].physicalextentsize > 0) 1639 snprintf(params, STRSIZE*3, "%s -s %d", params, lvms[i].physicalextentsize); 1640 error += run_program(RUN_DISPLAY | RUN_PROGRESS, "lvm vgcreate %s %s %s", 1641 params, lvms[i].name, devs); 1642 if (error) 1643 continue; 1644 /* Stage 3: creating Logical Volumes (LV's) */ 1645 for (ii = 0; ii < MAX_LVM_LV; ii++) { 1646 if (lvms[i].lv[ii].size <= 0) 1647 continue; 1648 1649 params[0] = '\0'; 1650 snprintf(params, STRSIZE*3, "%s -C %c", params, lvms[i].lv[ii].contiguous?'y':'n'); 1651 snprintf(params, STRSIZE*3, "%s -M %c", params, lvms[i].lv[ii].persistent?'y':'n'); 1652 snprintf(params, STRSIZE*3, "%s -p %s", params, lvms[i].lv[ii].readonly?"r":"rw"); 1653 snprintf(params, STRSIZE*3, "%s -Z %c", params, lvms[i].lv[ii].zero?'y':'n'); 1654 if (strlen(lvms[i].lv[ii].name) > 0) 1655 snprintf(params, STRSIZE*3, "%s -n %s", params, lvms[i].lv[ii].name); 1656 if (strlen(lvms[i].lv[ii].extents) > 0) 1657 snprintf(params, STRSIZE*3, "%s -l %s", params, lvms[i].lv[ii].extents); 1658 if (lvms[i].lv[ii].minor > 0) 1659 snprintf(params, STRSIZE*3, "%s --minor %d", params, lvms[i].lv[ii].minor); 1660 if (lvms[i].lv[ii].mirrors > 0) { 1661 snprintf(params, STRSIZE*3, "%s -m %d", params, lvms[i].lv[ii].mirrors); 1662 if (lvms[i].lv[ii].regionsize > 0) 1663 snprintf(params, STRSIZE*3, "%s -R %d", params, lvms[i].lv[ii].regionsize); 1664 } 1665 if (lvms[i].lv[ii].readahead > 0) 1666 snprintf(params, STRSIZE*3, "%s -r %d", params, lvms[i].lv[ii].readahead); 1667 if (lvms[i].lv[ii].stripes > 0) { 1668 snprintf(params, STRSIZE*3, "%s -i %d", params, lvms[i].lv[ii].stripes); 1669 if (lvms[i].lv[ii].stripesize > 0) 1670 snprintf(params, STRSIZE*3, "%s -I %d", params, lvms[i].lv[ii].stripesize); 1671 } 1672 snprintf(params, STRSIZE*3, "%s -L %uM", params, lvms[i].lv[ii].size); 1673 error += run_program(RUN_DISPLAY | RUN_PROGRESS, "lvm lvcreate %s %s", 1674 params, lvms[i].name); 1675 } 1676 if (! error) { 1677 lvms[i].blocked = 1; 1678 for (ii = 0; ii < MAX_LVM_PV; ii++) 1679 if (lvms[i].pv[ii].pm != NULL) 1680 lvms[i].pv[ii].pm->blocked++; 1681 for (ii = 0; ii < MAX_LVM_LV; ii++) 1682 if (lvms[i].lv[ii].size > 0) 1683 lvms[i].lv[ii].blocked = 1; 1684 } 1685 } 1686 1687 return 0; 1688 } 1689 1690 /*** 1691 GPT 1692 ***/ 1693 1694 int 1695 pm_gpt_convert(pm_devs_t *pm_cur) 1696 { 1697 int i, error = 0; 1698 1699 msg_display(MSG_removepartswarn); 1700 if (!ask_noyes(NULL)) 1701 return -1; 1702 1703 if (! pm_cur->gpt) 1704 error = run_program(RUN_DISPLAY | RUN_PROGRESS, "gpt create -f %s", 1705 pm_cur->diskdev); 1706 else { 1707 error = run_program(RUN_DISPLAY | RUN_PROGRESS, "gpt destroy %s", 1708 pm_cur->diskdev); 1709 for (i = 0; i < MAX_WEDGES; i++) 1710 if (wedges[i].pm == pm_cur) 1711 wedges[i].pm = NULL; 1712 } 1713 if (!error) { 1714 pm_cur->gpt = !pm_cur->gpt; 1715 pm_select(pm_cur); 1716 label_read(); 1717 } 1718 return error; 1719 } 1720 1721 static int 1722 pm_wedge_getfree(void) 1723 { 1724 int i; 1725 for (i = 0; i < MAX_WEDGES; i++) 1726 if (! wedges[i].allocated && wedges[i].pm == NULL) 1727 return i; 1728 return -1; 1729 } 1730 1731 void 1732 pm_wedges_fill(pm_devs_t *pm_cur) 1733 { 1734 int i, current; 1735 1736 for (i = 0; i < MAX_WEDGES; i++) 1737 if (wedges[i].pm == pm_cur && ! wedges[i].allocated) 1738 wedges[i].pm = NULL; 1739 1740 for (i = 0; i < min(MAXPARTITIONS,MAX_WEDGES); i++) 1741 if (pm_cur->bsdlabel[i].pi_fstype != FS_UNUSED) { 1742 current = pm_wedge_getfree(); 1743 if (current < 0) { 1744 process_menu(MENU_ok, deconst(MSG_limitcount)); 1745 return; 1746 } 1747 wedges[current].pm = pm_cur; 1748 wedges[current].ptn = i; 1749 } 1750 return; 1751 } 1752 1753 static int 1754 pm_wedge_create(int num, pm_devs_t **pm_dk) 1755 { 1756 int i, ii, hackerr, error; 1757 partinfo *p = &(wedges[num].pm->bsdlabel[wedges[num].ptn]); 1758 1759 if (num > MAX_WEDGES) 1760 return -1; 1761 1762 /* There is no ability to use required dkX device, so that's a hack */ 1763 for (i = 0; i < num; i++) 1764 if (! wedges[i].allocated) { 1765 hackerr = 1; 1766 for (ii = 0; hackerr && ii < 3; ii++) 1767 hackerr = run_program(RUN_SILENT | RUN_ERROR_OK, 1768 "dkctl %s addwedge HACK%d %d %d unused", 1769 wedges[num].pm->diskdev, 1770 rand()%33, rand()%33, 0); 1771 wedges[i].todel = 1; 1772 } 1773 1774 run_program(RUN_SILENT | RUN_ERROR_OK, 1775 "dkctl %s listwedges", wedges[num].pm->diskdev); 1776 1777 error = run_program(RUN_DISPLAY | RUN_PROGRESS, 1778 "dkctl %s addwedge dk%d %u %u %s", 1779 wedges[num].pm->diskdev, 1780 num, 1781 p->pi_offset, 1782 p->pi_size, 1783 getfstypename(p->pi_fstype)); 1784 if (!error) { 1785 wedges[num].allocated = 1; 1786 wedges[num].pm->blocked++; 1787 if (pm_dk != NULL) { 1788 *pm_dk = malloc(sizeof(pm_devs_t)); 1789 memset(*pm_dk, 0, sizeof **pm_dk); 1790 memcpy(&(*pm_dk)->bsdlabel[0], p, sizeof (*pm_dk)->bsdlabel[0]); 1791 (*pm_dk)->found = -1; 1792 (*pm_dk)->isspecial = 1; 1793 (*pm_dk)->sectorsize = 512; /* XXX: xxx */ 1794 (*pm_dk)->dlcylsize = MEG; 1795 (*pm_dk)->refdev = wedges[num].pm; 1796 snprintf((*pm_dk)->diskdev, SSTRSIZE, "dk%d", num); 1797 snprintf((*pm_dk)->diskdev_descr, STRSIZE, " %s (%s)", 1798 (*pm_dk)->diskdev, getfstypename(p->pi_fstype)); 1799 } 1800 } else 1801 if (logfp) 1802 fprintf(logfp, "Cannot create wedge dk%d for %s.\n", 1803 num, wedges[num].pm->diskdev); 1804 1805 /* Hack, see above */ 1806 for (i = 0; i < num; i ++) 1807 if (! wedges[i].allocated && wedges[i].todel) { 1808 hackerr = run_program(RUN_SILENT | RUN_ERROR_OK, 1809 "dkctl %s delwedge dk%d", wedges[num].pm->diskdev, i); 1810 (void)hackerr; /* XXX */ 1811 wedges[i].todel = 0; 1812 } 1813 1814 return error; 1815 } 1816 1817 static int 1818 pm_gpt_commit(void) 1819 { 1820 uint i, error; 1821 pm_devs_t *pm_i, *pm_dk = NULL; 1822 char fstype[STRSIZE]; fstype[0] = '\0'; 1823 partinfo *p; 1824 1825 SLIST_FOREACH(pm_i, &pm_head, l) 1826 if (pm_i->gpt && pm_i->unsaved) 1827 run_program(RUN_DISPLAY | RUN_PROGRESS, 1828 "gpt remove -a %s", 1829 pm_i->diskdev); 1830 1831 for (i = 0; i < MAX_WEDGES; i++) { 1832 if (wedges[i].pm == NULL || 1833 ! wedges[i].pm->unsaved || 1834 wedges[i].ptn < 0) 1835 continue; 1836 error = 0; 1837 p = &(wedges[i].pm->bsdlabel[wedges[i].ptn]); 1838 if (wedges[i].pm->gpt) { 1839 if (get_gptfs_by_id(p->pi_fstype) != NULL) 1840 snprintf(fstype, STRSIZE, "-t %s", get_gptfs_by_id(p->pi_fstype)); 1841 error += run_program(RUN_DISPLAY | RUN_PROGRESS, 1842 "gpt add -i %u -b %u -s %u %s %s", 1843 wedges[i].ptn + 1, 1844 p->pi_offset, p->pi_size, 1845 fstype, wedges[i].pm->diskdev); 1846 } 1847 1848 if (error || wedges[i].allocated) { 1849 if (logfp && error) 1850 fprintf(logfp, "Cannot create GPT partition #%d on %s\n", 1851 i, wedges[i].pm->diskdev); 1852 continue; 1853 } 1854 1855 error += pm_wedge_create(i, &pm_dk); 1856 if (pm_dk != NULL) { 1857 /* Create file system on wedge and add it to list */ 1858 pm_select(pm_dk); 1859 make_filesystems(); 1860 SLIST_INSERT_AFTER(wedges[i].pm, pm_dk, l); 1861 memset(p, 0, sizeof *p); 1862 if (error) 1863 return -1; 1864 } 1865 } 1866 1867 SLIST_FOREACH(pm_i, &pm_head, l) 1868 if (pm_i->gpt && pm_i->unsaved) 1869 pm_i->unsaved = 0; 1870 1871 return 0; 1872 } 1873 1874 /*** 1875 Partman generic functions 1876 ***/ 1877 1878 int 1879 pm_getrefdev(pm_devs_t *pm_cur) 1880 { 1881 int i, ii, dev_num, num_devs, num_devs_s; 1882 char dev[SSTRSIZE]; dev[0] = '\0'; 1883 1884 pm_cur->refdev = NULL; 1885 if (! strncmp(pm_cur->diskdev, "cgd", 3)) { 1886 dev_num = pm_cur->diskdev[3] - '0'; 1887 for (i = 0; i < MAX_CGD; i++) 1888 if (cgds[i].blocked && cgds[i].node == dev_num) { 1889 pm_cur->refdev = &cgds[i]; 1890 1891 snprintf(pm_cur->diskdev_descr, STRSIZE, "%s (%s, %s-%d)", 1892 pm_cur->diskdev_descr, cgds[i].pm_name, 1893 cgds[i].enc_type, cgds[i].key_size); 1894 break; 1895 } 1896 } else if (! strncmp(pm_cur->diskdev, "vnd", 3)) { 1897 dev_num = pm_cur->diskdev[3] - '0'; 1898 for (i = 0; i < MAX_VND; i++) 1899 if (vnds[i].blocked && vnds[i].node == dev_num) { 1900 pm_cur->refdev = &vnds[i]; 1901 pm_getdevstring(dev, SSTRSIZE, vnds[i].pm, vnds[i].pm_part); 1902 snprintf(pm_cur->diskdev_descr, STRSIZE, "%s (%s, %s)", 1903 pm_cur->diskdev_descr, dev, vnds[i].filepath); 1904 break; 1905 } 1906 } else if (! strncmp(pm_cur->diskdev, "raid", 4)) { 1907 dev_num = pm_cur->diskdev[4] - '0'; 1908 for (i = 0; i < MAX_RAID; i++) 1909 if (raids[i].blocked && raids[i].node == dev_num) { 1910 pm_cur->refdev = &raids[i]; 1911 num_devs = 0; num_devs_s = 0; 1912 for (ii = 0; ii < MAX_IN_RAID; ii++) 1913 if (raids[i].pm[ii] != NULL) { 1914 if(raids[i].pm_is_spare[ii]) 1915 num_devs_s++; 1916 else 1917 num_devs++; 1918 } 1919 snprintf(pm_cur->diskdev_descr, STRSIZE, 1920 "%s (lvl %d, %d disks, %d spare)", pm_cur->diskdev_descr, 1921 raids[i].raid_level, num_devs, num_devs_s); 1922 break; 1923 } 1924 } else 1925 return -1; 1926 return 0; 1927 } 1928 1929 /* Detect that partition is in use */ 1930 int 1931 pm_partusage(pm_devs_t *pm_cur, int part_num, int do_del) 1932 { 1933 int i, ii, retvalue = 0; 1934 1935 if (part_num < 0) { 1936 /* Check all partitions on device */ 1937 for (i = 0; i < MAXPARTITIONS; i++) 1938 retvalue += pm_partusage(pm_cur, i, do_del); 1939 return retvalue; 1940 } 1941 1942 for (i = 0; i < MAX_CGD; i++) 1943 if (cgds[i].enabled && 1944 cgds[i].pm == pm_cur && 1945 cgds[i].pm_part == part_num) { 1946 if (do_del) { 1947 cgds[i].pm = NULL; 1948 strcpy(cgds[i].pm_name, ""); 1949 } 1950 return 1; 1951 } 1952 for (i = 0; i < MAX_RAID; i++) 1953 for (ii = 0; ii < MAX_IN_RAID; ii++) 1954 if (raids[i].enabled && 1955 raids[i].pm[ii] == pm_cur && 1956 raids[i].pm_part[ii] == part_num) { 1957 if (do_del) 1958 raids[i].pm[ii] = NULL; 1959 return 1; 1960 } 1961 for (i = 0; i < MAX_LVM_VG; i++) 1962 for (ii = 0; ii < MAX_LVM_PV; ii++) 1963 if (lvms[i].enabled && 1964 lvms[i].pv[ii].pm == pm_cur && 1965 lvms[i].pv[ii].pm_part == part_num) { 1966 if (do_del) 1967 lvms[i].pv[ii].pm = NULL; 1968 return 1; 1969 } 1970 1971 return 0; 1972 } 1973 1974 /* Clean up removed devices */ 1975 static int 1976 pm_clean(void) 1977 { 1978 int count = 0; 1979 pm_devs_t *pm_i; 1980 1981 SLIST_FOREACH(pm_i, &pm_head, l) 1982 if (! pm_i->found) { 1983 count++; 1984 SLIST_REMOVE(&pm_head, pm_i, pm_devs_t, l); 1985 free(pm_i); 1986 } 1987 return count; 1988 } 1989 1990 void 1991 pm_make_bsd_partitions(pm_devs_t *pm_cur) 1992 { 1993 int i; 1994 partinfo baklabel[MAXPARTITIONS]; 1995 memcpy(baklabel, &pm_cur->bsdlabel, sizeof baklabel); 1996 1997 pm_cur->unsaved = 1; 1998 layoutkind = LY_SETNEW; 1999 md_make_bsd_partitions(); 2000 pm_cur->bootable = (pm_cur->bsdlabel[pm_cur->rootpart].pi_flags & PIF_MOUNT) ? 2001 1 : 0; 2002 for (i = 0; i < MAXPARTITIONS; i++) 2003 if (pm_cur->bsdlabel[i].pi_fstype != baklabel[i].pi_fstype || 2004 pm_cur->bsdlabel[i].lvmpv != baklabel[i].lvmpv) 2005 pm_partusage(pm_cur, i, 1); 2006 } 2007 2008 void 2009 pm_setfstype(pm_devs_t *pm_cur, int part_num, int fstype) 2010 { 2011 pm_cur->bsdlabel[part_num].pi_mount[0] = '\0'; 2012 pm_cur->bsdlabel[part_num].pi_flags = 0; 2013 pm_cur->bsdlabel[part_num].lvmpv = 0; 2014 pm_cur->bsdlabel[part_num].pi_fstype = fstype; 2015 return; 2016 } 2017 2018 static void 2019 pm_select(pm_devs_t *pm_devs_in) 2020 { 2021 pm = pm_devs_in; 2022 if (logfp) 2023 (void)fprintf(logfp, "Partman device: %s\n", pm->diskdev); 2024 return; 2025 } 2026 2027 void 2028 pm_rename(pm_devs_t *pm_cur) 2029 { 2030 pm_select(pm_cur); 2031 msg_prompt_win(MSG_packname, -1, 18, 0, 0, pm_cur->bsddiskname, 2032 pm_cur->bsddiskname, sizeof pm_cur->bsddiskname); 2033 #ifndef NO_DISKLABEL 2034 (void) savenewlabel(pm_cur->bsdlabel, MAXPARTITIONS); 2035 #endif 2036 return; 2037 } 2038 2039 int 2040 pm_editpart(int part_num) 2041 { 2042 partinfo backup = pm->bsdlabel[part_num]; 2043 2044 edit_ptn(&(struct menudesc){.cursel = part_num}, NULL); 2045 if (checkoverlap(pm->bsdlabel, MAXPARTITIONS, PART_D, PART_C)) { 2046 msg_display_add(MSG_cantsave); 2047 process_menu(MENU_ok, NULL); 2048 pm->bsdlabel[part_num] = backup; 2049 return -1; 2050 } 2051 pm->unsaved = 1; 2052 return 0; 2053 } 2054 2055 /* Safe erase of disk */ 2056 int 2057 pm_shred(pm_devs_t *pm_cur, int part, int shredtype) 2058 { 2059 int error = -1; 2060 char dev[SSTRSIZE]; 2061 2062 pm_getdevstring(dev, SSTRSIZE, pm_cur, part); 2063 switch(shredtype) { 2064 case SHRED_ZEROS: 2065 error += run_program(RUN_DISPLAY | RUN_PROGRESS, 2066 "dd of=/dev/%s if=/dev/zero bs=1m progress=100 msgfmt=human", 2067 dev); 2068 break; 2069 case SHRED_RANDOM: 2070 error += run_program(RUN_DISPLAY | RUN_PROGRESS, 2071 "dd of=/dev/%s if=/dev/urandom bs=1m progress=100 msgfmt=human", 2072 dev); 2073 break; 2074 case SHRED_CRYPTO: 2075 error += run_program(RUN_DISPLAY | RUN_PROGRESS, 2076 "sh -c 'cgdconfig -s cgd0 /dev/%s aes-cbc 128 < /dev/urandom'", 2077 dev); /* XXX: cgd0?! */ 2078 if (! error) { 2079 error += run_program(RUN_DISPLAY | RUN_PROGRESS, 2080 "dd of=/dev/rcgd0d if=/dev/urandom bs=1m progress=100 msgfmt=human"); 2081 error += run_program(RUN_DISPLAY | RUN_PROGRESS, 2082 "cgdconfig -u cgd0"); 2083 } 2084 break; 2085 default: 2086 return -1; 2087 } 2088 pm_partusage(pm_cur, -1, 1); 2089 memset(&pm_cur->oldlabel, 0, sizeof pm_cur->oldlabel); 2090 memset(&pm_cur->bsdlabel, 0, sizeof pm_cur->bsdlabel); 2091 return error; 2092 } 2093 2094 static int 2095 pm_mountall_sort(const void *a, const void *b) 2096 { 2097 return strcmp(mnts[*(const int *)a].on, mnts[*(const int *)b].on); 2098 } 2099 2100 /* Mount all available partitions */ 2101 static int 2102 pm_mountall(void) 2103 { 2104 int num_devs = 0; 2105 int mnts_order[MAX_MNTS]; 2106 int i, ii, error, ok; 2107 char dev[SSTRSIZE]; dev[0] = '\0'; 2108 pm_devs_t *pm_i; 2109 2110 localfs_dev[0] = '\0'; 2111 memset(&mnts, 0, sizeof mnts); 2112 2113 SLIST_FOREACH(pm_i, &pm_head, l) { 2114 ok = 0; 2115 for (i = 0; i < MAXPARTITIONS; i++) { 2116 if (!(pm_i->bsdlabel[i].pi_flags & PIF_MOUNT && 2117 pm_i->bsdlabel[i].mnt_opts != NULL)) 2118 continue; 2119 mnts[num_devs].mnt_opts = pm_i->bsdlabel[i].mnt_opts; 2120 if (strlen(pm_i->bsdlabel[i].mounted) > 0) { 2121 /* Device is already mounted. So, doing mount_null */ 2122 strlcpy(mnts[num_devs].dev, pm_i->bsdlabel[i].mounted, MOUNTLEN); 2123 mnts[num_devs].mnt_opts = "-t null"; 2124 } else { 2125 pm_getdevstring(dev, SSTRSIZE, pm_i, i); 2126 snprintf(mnts[num_devs].dev, STRSIZE, "/dev/%s", dev); 2127 } 2128 mnts[num_devs].on = pm_i->bsdlabel[i].pi_mount; 2129 if (strcmp(pm_i->bsdlabel[i].pi_mount, "/") == 0) { 2130 if (pm_i->isspecial) 2131 pm_i->bootable = 1; 2132 /* Use disk with / as a default if the user has 2133 the sets on a local disk */ 2134 strlcpy(localfs_dev, pm_i->diskdev, SSTRSIZE); 2135 } 2136 num_devs++; 2137 ok = 1; 2138 } 2139 if (ok) 2140 md_pre_mount(); 2141 } 2142 if (strlen(localfs_dev) < 1) { 2143 msg_display(MSG_noroot); 2144 process_menu(MENU_ok, NULL); 2145 return -1; 2146 } 2147 for (i = 0; i < num_devs; i++) 2148 mnts_order[i] = i; 2149 qsort(mnts_order, num_devs, sizeof mnts_order[0], pm_mountall_sort); 2150 2151 for (i = 0; i < num_devs; i++) { 2152 ii = mnts_order[i]; 2153 make_target_dir(mnts[ii].on); 2154 error = target_mount_do(mnts[ii].mnt_opts, mnts[ii].dev, mnts[ii].on); 2155 if (error) 2156 return error; 2157 } 2158 return 0; 2159 } 2160 2161 /* Mount partition bypassing ordinary order */ 2162 static int 2163 pm_mount(pm_devs_t *pm_cur, int part_num) 2164 { 2165 int error = 0; 2166 char buf[MOUNTLEN]; 2167 2168 if (strlen(pm_cur->bsdlabel[part_num].mounted) > 0) 2169 return 0; 2170 2171 snprintf(buf, MOUNTLEN, "/tmp/%s%c", pm_cur->diskdev, part_num + 'a'); 2172 if (! dir_exists_p(buf)) 2173 run_program(RUN_DISPLAY | RUN_PROGRESS, "/bin/mkdir -p %s", buf); 2174 if (pm_cur->bsdlabel[part_num].pi_flags & PIF_MOUNT && 2175 pm_cur->bsdlabel[part_num].mnt_opts != NULL && 2176 strlen(pm_cur->bsdlabel[part_num].mounted) < 1) 2177 error += run_program(RUN_DISPLAY | RUN_PROGRESS, "/sbin/mount %s /dev/%s%c %s", 2178 pm_cur->bsdlabel[part_num].mnt_opts, 2179 pm_cur->diskdev, part_num + 'a', buf); 2180 2181 if (error) 2182 pm_cur->bsdlabel[part_num].mounted[0] = '\0'; 2183 else { 2184 strlcpy(pm_cur->bsdlabel[part_num].mounted, buf, MOUNTLEN); 2185 pm_cur->blocked++; 2186 } 2187 return error; 2188 } 2189 2190 void 2191 pm_umount(pm_devs_t *pm_cur, int part_num) 2192 { 2193 char buf[SSTRSIZE]; buf[0] = '\0'; 2194 pm_getdevstring(buf, SSTRSIZE, pm_cur, part_num); 2195 2196 if (run_program(RUN_DISPLAY | RUN_PROGRESS, 2197 "umount -f /dev/%s", buf) == 0) { 2198 pm_cur->bsdlabel[part_num].mounted[0] = '\0'; 2199 if (pm_cur->blocked > 0) 2200 pm_cur->blocked--; 2201 } 2202 return; 2203 } 2204 2205 int 2206 pm_unconfigure(pm_devs_t *pm_cur) 2207 { 2208 int i, error = 0, num = 0; 2209 if (! strncmp(pm_cur->diskdev, "cgd", 3)) { 2210 error = run_program(RUN_DISPLAY | RUN_PROGRESS, "cgdconfig -u %s", pm_cur->diskdev); 2211 if (! error && pm_cur->refdev != NULL) { 2212 ((cgds_t*)pm_cur->refdev)->pm->blocked--; 2213 ((cgds_t*)pm_cur->refdev)->blocked = 0; 2214 } 2215 } else if (! strncmp(pm_cur->diskdev, "vnd", 3)) { 2216 error = run_program(RUN_DISPLAY | RUN_PROGRESS, "vnconfig -u %s", pm_cur->diskdev); 2217 if (! error && pm_cur->refdev != NULL) { 2218 ((vnds_t*)pm_cur->refdev)->pm->blocked--; 2219 ((vnds_t*)pm_cur->refdev)->blocked = 0; 2220 } 2221 } else if (! strncmp(pm_cur->diskdev, "raid", 4)) { 2222 error = run_program(RUN_DISPLAY | RUN_PROGRESS, "raidctl -u %s", pm_cur->diskdev); 2223 if (! error && pm_cur->refdev != NULL) { 2224 ((raids_t*)pm_cur->refdev)->blocked = 0; 2225 for (i = 0; i < MAX_IN_RAID; i++) 2226 if (((raids_t*)pm_cur->refdev)->pm[i] != NULL) 2227 ((raids_t*)pm_cur->refdev)->pm[i]->blocked--; 2228 } 2229 } else if (! strncmp(pm_cur->diskdev, "dk", 2)) { 2230 if (pm_cur->refdev == NULL) 2231 return -2; 2232 error = run_program(RUN_DISPLAY | RUN_PROGRESS, "dkctl %s delwedge %s", 2233 ((pm_devs_t*)pm_cur->refdev)->diskdev, pm_cur->diskdev); 2234 if (! error) { 2235 if (pm_cur->refdev != NULL && ((pm_devs_t*)pm_cur->refdev)->blocked > 0) 2236 ((pm_devs_t*)pm_cur->refdev)->blocked--; 2237 sscanf(pm_cur->diskdev, "dk%d", &num); 2238 if (num >= 0 && num < MAX_WEDGES) 2239 wedges[num].allocated = 0; 2240 } 2241 } /* XXX: lvm */ 2242 else 2243 error = run_program(RUN_DISPLAY | RUN_PROGRESS, "eject -t disk /dev/%sd", 2244 pm_cur->diskdev); 2245 if (!error) 2246 pm_cur->found = 0; 2247 return error; 2248 } 2249 2250 /* Last checks before leaving partition manager */ 2251 static int 2252 pm_lastcheck(void) 2253 { 2254 FILE *file_tmp = fopen(concat_paths(targetroot_mnt, "/etc/fstab"), "r"); 2255 if (file_tmp == NULL) 2256 return 1; 2257 fclose(file_tmp); 2258 return 0; 2259 } 2260 2261 /* Are there unsaved changes? */ 2262 static int 2263 pm_needsave(void) 2264 { 2265 pm_devs_t *pm_i; 2266 SLIST_FOREACH(pm_i, &pm_head, l) 2267 if (pm_i->unsaved) { 2268 /* Oops, we have unsaved changes */ 2269 changed = 1; 2270 msg_display(MSG_saveprompt); 2271 return ask_yesno(NULL); 2272 } 2273 return 0; 2274 } 2275 2276 /* Write all changes to disk */ 2277 static int 2278 pm_commit(menudesc *m, void *arg) 2279 { 2280 int retcode; 2281 pm_devs_t *pm_i; 2282 if (m != NULL && arg != NULL) 2283 ((part_entry_t *)arg)[0].retvalue = m->cursel + 1; 2284 2285 pm_gpt_commit(); 2286 2287 SLIST_FOREACH(pm_i, &pm_head, l) { 2288 if (! pm_i->unsaved) 2289 continue; 2290 pm_select(pm_i); 2291 2292 if (pm_i->isspecial) { 2293 if (make_filesystems() != 0) { 2294 if (logfp) 2295 fprintf(logfp, "Special disk %s preparing error\n", pm_i->diskdev); 2296 continue; 2297 } 2298 pm_i->unsaved = 0; 2299 } else if (! pm_i->gpt) { 2300 #ifndef NO_DISKLABEL 2301 savenewlabel(pm_i->bsdlabel, MAXPARTITIONS); 2302 #endif 2303 if ( 2304 write_disklabel() != 0 || /* Write slices table (disklabel) */ 2305 set_swap_if_low_ram(pm->diskdev, pm->bsdlabel) != 0 || 2306 md_post_disklabel() != 0 || /* Enable swap and check badblock */ 2307 make_filesystems() != 0 /* Create filesystems with newfs */ 2308 ) { 2309 /* Oops, something failed... */ 2310 if (logfp) 2311 fprintf(logfp, "Disk %s preparing error\n", pm_i->diskdev); 2312 continue; 2313 } 2314 pm_i->unsaved = 0; 2315 } 2316 } 2317 2318 /* Call all functions that may create new devices */ 2319 if ((retcode = pm_raid_commit()) != 0) { 2320 if (logfp) 2321 fprintf(logfp, "RAIDframe configuring error #%d\n", retcode); 2322 return -1; 2323 } 2324 if ((retcode = pm_cgd_commit()) != 0) { 2325 if (logfp) 2326 fprintf(logfp, "CGD configuring error #%d\n", retcode); 2327 return -1; 2328 } 2329 if ((retcode = pm_lvm_commit()) != 0) { 2330 if (logfp) 2331 fprintf(logfp, "LVM configuring error #%d\n", retcode); 2332 return -1; 2333 } 2334 if ((retcode = pm_vnd_commit()) != 0) { 2335 if (logfp) 2336 fprintf(logfp, "VND configuring error #%d\n", retcode); 2337 return -1; 2338 } 2339 if (m != NULL && arg != NULL) 2340 pm_upddevlist(m, arg); 2341 if (logfp) 2342 fflush (logfp); 2343 return 0; 2344 } 2345 2346 static int 2347 pm_savebootsector(void) 2348 { 2349 pm_devs_t *pm_i; 2350 SLIST_FOREACH(pm_i, &pm_head, l) 2351 if (pm_i->bootable) { 2352 if (! strncmp("raid", pm_i->diskdev, 4)) 2353 if (run_program(RUN_DISPLAY | RUN_PROGRESS, 2354 "raidctl -v -A root %s", pm_i->diskdev) != 0) { 2355 if (logfp) 2356 fprintf(logfp, "Error writting RAID bootsector to %s\n", 2357 pm_i->diskdev); 2358 continue; 2359 } 2360 if (pm_i->gpt && ! pm_i->isspecial) { 2361 if (pm_i->rootpart < 0 || 2362 run_program(RUN_DISPLAY | RUN_PROGRESS, 2363 "gpt biosboot -i %d %s", 2364 pm_i->rootpart + 1, pm_i->diskdev) != 0) { 2365 if (logfp) 2366 fprintf(logfp, "Error writting GPT bootsector to %s\n", 2367 pm_i->diskdev); 2368 continue; 2369 } 2370 } else { 2371 pm_select(pm_i); 2372 if ( 2373 #ifndef NO_DISKLABEL 2374 check_partitions() == 0 || 2375 #endif 2376 md_post_newfs() != 0) { 2377 if (logfp) 2378 fprintf(logfp, "Error writting bootsector to %s\n", 2379 pm_i->diskdev); 2380 continue; 2381 } 2382 } 2383 } 2384 return 0; 2385 } 2386 2387 /* Function for 'Enter'-menu */ 2388 static int 2389 pm_submenu(menudesc *m, void *arg) 2390 { 2391 int part_num = -1; 2392 pm_devs_t *pm_cur = NULL; 2393 ((part_entry_t *)arg)[0].retvalue = m->cursel + 1; 2394 2395 switch (((part_entry_t *)arg)[m->cursel].type) { 2396 case PM_DISK_T: 2397 case PM_WEDGE_T: 2398 case PM_PART_T: 2399 case PM_SPEC_T: 2400 if (((part_entry_t *)arg)[m->cursel].dev_ptr != NULL) { 2401 pm_cur = ((part_entry_t *)arg)[m->cursel].dev_ptr; 2402 if (pm_cur == NULL) 2403 return -1; 2404 if (pm_cur->blocked) { 2405 msg_display(MSG_wannaunblock); 2406 if (!ask_noyes(NULL)) 2407 return -2; 2408 pm_cur->blocked = 0; 2409 } 2410 pm_select(pm_cur); 2411 } 2412 default: 2413 break; 2414 } 2415 2416 switch (((part_entry_t *)arg)[m->cursel].type) { 2417 case PM_DISK_T: 2418 if (pm_cur != NULL && pm_cur->gpt) { 2419 process_menu(MENU_pmgptentry, &part_num); 2420 pm_wedges_fill(pm_cur); 2421 } else { 2422 process_menu(MENU_pmdiskentry, &part_num); 2423 } 2424 break; 2425 case PM_WEDGE_T: 2426 case PM_PART_T: 2427 part_num = ((part_entry_t *)arg)[m->cursel].dev_num; 2428 process_menu(MENU_pmpartentry, &part_num); 2429 if (pm_cur != NULL && pm_cur->gpt) 2430 pm_wedges_fill(pm_cur); 2431 break; 2432 case PM_SPEC_T: 2433 part_num = 0; 2434 process_menu(MENU_pmpartentry, &part_num); 2435 break; 2436 case PM_RAID_T: 2437 return pm_edit(PMR_MENU_END, pm_raid_edit_menufmt, 2438 pm_raid_set_value, pm_raid_check, pm_raid_init, 2439 NULL, ((part_entry_t *)arg)[m->cursel].dev_ptr, 0, &raids_t_info); 2440 case PM_VND_T: 2441 return pm_edit(PMV_MENU_END, pm_vnd_edit_menufmt, 2442 pm_vnd_set_value, pm_vnd_check, pm_vnd_init, 2443 NULL, ((part_entry_t *)arg)[m->cursel].dev_ptr, 0, &vnds_t_info); 2444 case PM_CGD_T: 2445 return pm_cgd_edit(((part_entry_t *)arg)[m->cursel].dev_ptr, 2446 NULL); 2447 case PM_LVM_T: 2448 return pm_edit(PML_MENU_END, pm_lvm_edit_menufmt, 2449 pm_lvm_set_value, pm_lvm_check, pm_lvm_init, 2450 NULL, ((part_entry_t *)arg)[m->cursel].dev_ptr, 0, &lvms_t_info); 2451 case PM_LVMLV_T: 2452 return pm_edit(PMLV_MENU_END, pm_lvmlv_edit_menufmt, 2453 pm_lvmlv_set_value, pm_lvmlv_check, pm_lvmlv_init, 2454 NULL, ((part_entry_t *)arg)[m->cursel].dev_ptr, 2455 ((part_entry_t *)arg)[m->cursel].dev_ptr_delta, &lv_t_info); 2456 } 2457 return 0; 2458 } 2459 2460 /* Functions that generate menu entries text */ 2461 static void 2462 pm_menufmt(menudesc *m, int opt, void *arg) 2463 { 2464 const char *dev_status = ""; 2465 char buf[STRSIZE]; 2466 int part_num = ((part_entry_t *)arg)[opt].dev_num; 2467 pm_devs_t *pm_cur = ((part_entry_t *)arg)[opt].dev_ptr; 2468 2469 switch (((part_entry_t *)arg)[opt].type) { 2470 case PM_DISK_T: 2471 if (pm_cur->blocked) 2472 dev_status = msg_string(MSG_pmblocked); 2473 else if (! pm_cur->unsaved) 2474 dev_status = msg_string(MSG_pmunchanged); 2475 else if (pm_cur->bootable) 2476 dev_status = msg_string(MSG_pmsetboot); 2477 else 2478 dev_status = msg_string(MSG_pmused); 2479 wprintw(m->mw, "%-33.32s %-22.21s %12.12s", 2480 pm_cur->diskdev_descr, 2481 (pm_cur->gpt) ? 2482 msg_string(MSG_pmgptdisk) : 2483 pm_cur->bsddiskname, 2484 dev_status); 2485 break; 2486 case PM_WEDGE_T: 2487 part_num = ((part_entry_t *)arg)[opt].wedge_num; 2488 snprintf(buf, STRSIZE, "dk%d: %s", 2489 part_num, 2490 wedges[part_num].pm->bsdlabel[wedges[part_num].ptn].pi_mount); 2491 wprintw(m->mw, " %-30.29s %-22.21s %11uM", 2492 buf, 2493 (wedges[part_num].pm->bsdlabel[wedges[part_num].ptn].lvmpv) ? 2494 "lvm pv" : 2495 getfslabelname(wedges[part_num].pm->bsdlabel[wedges[part_num]. 2496 ptn].pi_fstype), 2497 wedges[part_num].pm->bsdlabel[wedges[part_num].ptn].pi_size / 2498 (MEG / pm_cur->sectorsize)); 2499 break; 2500 case PM_PART_T: 2501 snprintf(buf, STRSIZE, "%s%c: %s %s", 2502 pm_cur->diskdev, 2503 'a' + part_num, 2504 pm_cur->bsdlabel[part_num].pi_mount, 2505 (strlen(pm_cur->bsdlabel[part_num].mounted) > 0) ? msg_string(MSG_pmmounted) : 2506 (part_num == PART_B || 2507 strlen (pm_cur->bsdlabel[part_num].pi_mount ) < 1 || 2508 pm_cur->bsdlabel[part_num].pi_flags & PIF_MOUNT) ? 2509 "" : msg_string(MSG_pmunused)); 2510 wprintw(m->mw, " %-30.29s %-22.21s %11uM", 2511 buf, 2512 (pm_cur->bsdlabel[part_num].lvmpv) ? 2513 "lvm pv" : 2514 getfslabelname(pm_cur->bsdlabel[part_num].pi_fstype), 2515 pm_cur->bsdlabel[part_num].pi_size / (MEG / pm_cur->sectorsize)); 2516 break; 2517 case PM_SPEC_T: 2518 snprintf(buf, STRSIZE, "%s: %s", 2519 pm_cur->diskdev_descr, pm_cur->bsdlabel[0].pi_mount); 2520 wprintw(m->mw, "%-33.32s %-22.21s %11uM", buf, 2521 getfslabelname(pm_cur->bsdlabel[0].pi_fstype), 2522 pm_cur->bsdlabel[0].pi_size / (MEG / pm_cur->sectorsize)); 2523 break; 2524 case PM_RAID_T: 2525 pm_raid_menufmt(m, opt, arg); 2526 break; 2527 case PM_VND_T: 2528 pm_vnd_menufmt(m, opt, arg); 2529 break; 2530 case PM_CGD_T: 2531 pm_cgd_menufmt(m, opt, arg); 2532 break; 2533 case PM_LVM_T: 2534 pm_lvm_menufmt(m, opt, arg); 2535 break; 2536 case PM_LVMLV_T: 2537 pm_lvmlv_menufmt(m, opt, arg); 2538 break; 2539 } 2540 return; 2541 } 2542 2543 /* Submenu for RAID/LVM/CGD/VND */ 2544 static void 2545 pm_upddevlist_adv(menudesc *m, void *arg, int *i, 2546 pm_upddevlist_adv_t *d) 2547 { 2548 int ii; 2549 if (d->create_msg != NULL) { 2550 /* We want to have menu entry that creates a new device */ 2551 ((part_entry_t *)arg)[*i].type = d->pe_type; 2552 ((part_entry_t *)arg)[*i].dev_ptr = NULL; 2553 ((part_entry_t *)arg)[*i].dev_ptr_delta = d->s->parent_size * d->sub_num; 2554 m->opts[(*i)++] = (struct menu_ent) { 2555 .opt_name = d->create_msg, 2556 .opt_action = pm_submenu, 2557 }; 2558 } 2559 for (ii = 0; ii < d->s->max; ii++) { 2560 if (d->s->entry_enabled == NULL || 2561 d->s->entry_blocked == NULL || 2562 *(int*)((char*)d->s->entry_enabled + d->s->entry_size * ii + 2563 d->s->parent_size * d->sub_num) == 0 || 2564 *(int*)((char*)d->s->entry_blocked + d->s->entry_size * ii + 2565 d->s->parent_size * d->sub_num) != 0) 2566 continue; 2567 /* We have a entry for displaying */ 2568 changed = 1; 2569 m->opts[*i] = (struct menu_ent) { 2570 .opt_name = NULL, 2571 .opt_action = pm_submenu, 2572 }; 2573 ((part_entry_t *)arg)[*i].type = d->pe_type; 2574 ((part_entry_t *)arg)[*i].dev_ptr = (char*)d->s->entry_first + 2575 d->s->entry_size * ii + d->s->parent_size * d->sub_num; 2576 (*i)++; 2577 /* We should show submenu for current entry */ 2578 if (d->sub != NULL) { 2579 d->sub->sub_num = ii; 2580 pm_upddevlist_adv(m, arg, i, d->sub); 2581 } 2582 } 2583 return; 2584 } 2585 2586 /* Update partman main menu with devices list */ 2587 static int 2588 pm_upddevlist(menudesc *m, void *arg) 2589 { 2590 int i = 0, ii; 2591 pm_devs_t *pm_i; 2592 2593 if (arg != NULL) 2594 ((part_entry_t *)arg)[0].retvalue = m->cursel + 1; 2595 2596 changed = 0; 2597 /* Mark all devices as not found */ 2598 SLIST_FOREACH(pm_i, &pm_head, l) 2599 if (pm_i->found > 0) 2600 pm_i->found = 0; 2601 /* Detect all present devices */ 2602 (void)find_disks("partman"); 2603 pm_lvm_find(); 2604 pm_clean(); 2605 2606 if (m == NULL || arg == NULL) 2607 return -1; 2608 2609 SLIST_FOREACH(pm_i, &pm_head, l) { 2610 m->opts[i].opt_name = NULL; 2611 m->opts[i].opt_action = pm_submenu; 2612 ((part_entry_t *)arg)[i].dev_ptr = pm_i; 2613 ((part_entry_t *)arg)[i].dev_num = -1; 2614 if (pm_i->isspecial) 2615 ((part_entry_t *)arg)[i].type = PM_SPEC_T; 2616 else { 2617 ((part_entry_t *)arg)[i].type = PM_DISK_T; 2618 if (pm_i->gpt) { 2619 pm_wedges_fill(pm_i); 2620 for (ii = 0; ii < MAX_WEDGES; ii++) 2621 if (wedges[ii].pm == pm_i) { 2622 i++; 2623 m->opts[i].opt_name = NULL; 2624 m->opts[i].opt_action = pm_submenu; 2625 ((part_entry_t *)arg)[i].dev_ptr = pm_i; 2626 ((part_entry_t *)arg)[i].dev_num = wedges[ii].ptn; 2627 ((part_entry_t *)arg)[i].wedge_num = ii; 2628 ((part_entry_t *)arg)[i].type = PM_WEDGE_T; 2629 } 2630 } else { 2631 for (ii = 0; ii < MAXPARTITIONS; ii++) 2632 if (pm_i->bsdlabel[ii].pi_fstype != FS_UNUSED) { 2633 i++; 2634 m->opts[i].opt_name = NULL; 2635 m->opts[i].opt_action = pm_submenu; 2636 ((part_entry_t *)arg)[i].dev_ptr = pm_i; 2637 ((part_entry_t *)arg)[i].dev_num = ii; 2638 ((part_entry_t *)arg)[i].type = PM_PART_T; 2639 } 2640 } 2641 } 2642 i++; 2643 } 2644 if (have_cgd) { 2645 pm_upddevlist_adv(m, arg, &i, 2646 &(pm_upddevlist_adv_t) {MSG_create_cgd, PM_CGD_T, &cgds_t_info, 0, NULL}); 2647 } 2648 if (have_lvm) { 2649 pm_upddevlist_adv(m, arg, &i, 2650 &(pm_upddevlist_adv_t) {MSG_create_cnd, PM_VND_T, &vnds_t_info, 0, NULL}); 2651 pm_upddevlist_adv(m, arg, &i, 2652 &(pm_upddevlist_adv_t) {MSG_create_vg, PM_LVM_T, &lvms_t_info, 0, 2653 &(pm_upddevlist_adv_t) {MSG_create_lv, PM_LVMLV_T, &lv_t_info, 0, NULL}}); 2654 } 2655 if (have_raid) { 2656 pm_upddevlist_adv(m, arg, &i, 2657 &(pm_upddevlist_adv_t) {MSG_create_raid, PM_RAID_T, &raids_t_info, 0, NULL}); 2658 } 2659 2660 m->opts[i++] = (struct menu_ent) { 2661 .opt_name = MSG_updpmlist, 2662 .opt_action = pm_upddevlist, 2663 }; 2664 m->opts[i ] = (struct menu_ent) { 2665 .opt_name = MSG_savepm, 2666 .opt_action = pm_commit, 2667 }; 2668 for (ii = 0; ii <= i; ii++) { 2669 m->opts[ii].opt_menu = OPT_NOMENU; 2670 m->opts[ii].opt_flags = OPT_EXIT; 2671 } 2672 2673 if (((part_entry_t *)arg)[0].retvalue >= 0) 2674 m->cursel = ((part_entry_t *)arg)[0].retvalue - 1; 2675 return i; 2676 } 2677 2678 static void 2679 pm_menuin(menudesc *m, void *arg) 2680 { 2681 if (cursel > m->numopts) 2682 m->cursel = m->numopts; 2683 else if (cursel < 0) 2684 m->cursel = 0; 2685 else 2686 m->cursel = cursel; 2687 } 2688 2689 static void 2690 pm_menuout(menudesc *m, void *arg) 2691 { 2692 cursel = m->cursel; 2693 } 2694 2695 /* initialize have_* variables */ 2696 void 2697 check_available_binaries() 2698 { 2699 static int did_test = false; 2700 2701 if (did_test) return; 2702 did_test = 1; 2703 2704 have_raid = binary_available("raidctl"); 2705 have_vnd = binary_available("vnconfig"); 2706 have_cgd = binary_available("cgdconfig"); 2707 have_lvm = binary_available("lvm"); 2708 have_gpt = binary_available("gpt"); 2709 have_dk = binary_available("dkctl"); 2710 } 2711 2712 /* Main partman function */ 2713 int 2714 partman(void) 2715 { 2716 int menu_no, menu_num_entries; 2717 static int firstrun = 1; 2718 menu_ent menu_entries[MAX_ENTRIES+6]; 2719 part_entry_t args[MAX_ENTRIES]; 2720 2721 if (firstrun) { 2722 check_available_binaries(); 2723 2724 if (!have_raid) 2725 remove_raid_options(); 2726 if (!have_lvm) 2727 remove_lvm_options(); 2728 if (!have_gpt) 2729 remove_gpt_options(); 2730 if (!have_cgd) 2731 remove_cgd_options(); 2732 2733 raids_t_info = (structinfo_t) { 2734 .max = MAX_RAID, 2735 .entry_size = sizeof raids[0], 2736 .entry_first = &raids[0], 2737 .entry_enabled = &(raids[0].enabled), 2738 .entry_blocked = &(raids[0].blocked), 2739 .entry_node = &(raids[0].node), 2740 }; 2741 vnds_t_info = (structinfo_t) { 2742 .max = MAX_VND, 2743 .entry_size = sizeof vnds[0], 2744 .entry_first = &vnds[0], 2745 .entry_enabled = &(vnds[0].enabled), 2746 .entry_blocked = &(vnds[0].blocked), 2747 .entry_node = &(vnds[0].node), 2748 }; 2749 cgds_t_info = (structinfo_t) { 2750 .max = MAX_CGD, 2751 .entry_size = sizeof cgds[0], 2752 .entry_first = &cgds[0], 2753 .entry_enabled = &(cgds[0].enabled), 2754 .entry_blocked = &(cgds[0].blocked), 2755 .entry_node = &(cgds[0].node), 2756 }; 2757 lvms_t_info = (structinfo_t) { 2758 .max = MAX_LVM_VG, 2759 .entry_size = sizeof lvms[0], 2760 .entry_first = &lvms[0], 2761 .entry_enabled = &(lvms[0].enabled), 2762 .entry_blocked = &(lvms[0].blocked), 2763 .entry_node = NULL, 2764 }; 2765 lv_t_info = (structinfo_t) { 2766 .max = MAX_LVM_LV, 2767 .entry_size = sizeof lvms[0].lv[0], 2768 .entry_first = &lvms[0].lv[0], 2769 .entry_enabled = &(lvms[0].lv[0].size), 2770 .entry_blocked = &(lvms[0].lv[0].blocked), 2771 .parent_size = sizeof lvms[0], 2772 }; 2773 2774 memset(&raids, 0, sizeof raids); 2775 memset(&cgds, 0, sizeof cgds); 2776 memset(&vnds, 0, sizeof vnds); 2777 memset(&lvms, 0, sizeof lvms); 2778 cursel = 0; 2779 changed = 0; 2780 firstrun = 0; 2781 } 2782 2783 do { 2784 menu_num_entries = pm_upddevlist(&(menudesc){.opts = menu_entries}, args); 2785 menu_no = new_menu(MSG_partman_header, 2786 menu_entries, menu_num_entries+1, 1, 1, 0, 75, /* Fixed width */ 2787 MC_ALWAYS_SCROLL | MC_NOBOX | MC_NOCLEAR, 2788 pm_menuin, pm_menufmt, pm_menuout, NULL, MSG_finishpm); 2789 if (menu_no == -1) 2790 args[0].retvalue = -1; 2791 else { 2792 args[0].retvalue = 0; 2793 clear(); 2794 refresh(); 2795 process_menu(menu_no, &args); 2796 free_menu(menu_no); 2797 } 2798 2799 if (args[0].retvalue == 0) { 2800 if (pm_needsave()) 2801 pm_commit(NULL, NULL); 2802 if (pm_mountall() != 0 || 2803 make_fstab() != 0 || 2804 pm_lastcheck() != 0 || 2805 pm_savebootsector() != 0) { 2806 msg_display(MSG_wannatry); 2807 args[0].retvalue = (ask_yesno(NULL)) ? 1:-1; 2808 } 2809 } 2810 } while (args[0].retvalue > 0); 2811 2812 /* retvalue <0 - error, retvalue ==0 - user quits, retvalue >0 - all ok */ 2813 return (args[0].retvalue >= 0)?0:-1; 2814 } 2815 2816 void 2817 update_wedges(const char *disk) 2818 { 2819 check_available_binaries(); 2820 2821 if (!have_dk) 2822 return; 2823 2824 run_program(RUN_SILENT | RUN_ERROR_OK, 2825 "dkctl %s makewedges", disk); 2826 } 2827
Indexes created Wed Sep 24 15:09:51 GMT 2025