1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2011 Nathan Whitehorn
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 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 *
28 * $FreeBSD$
29 */
30
31 #include <sys/param.h>
32 #include <sys/stat.h>
33 #include <errno.h>
34 #include <fcntl.h>
35 #include <libutil.h>
36 #include <inttypes.h>
37
38 #include <libgeom.h>
39 #include <dialog.h>
40 #include <dlg_keys.h>
41
42 #include "partedit.h"
43
44 #define GPART_FLAGS "x" /* Do not commit changes by default */
45
46 static void
gpart_show_error(const char * title,const char * explanation,const char * errstr)47 gpart_show_error(const char *title, const char *explanation, const char *errstr)
48 {
49 char *errmsg;
50 char message[512];
51 int error;
52
53 if (explanation == NULL)
54 explanation = "";
55
56 error = strtol(errstr, &errmsg, 0);
57 if (errmsg != errstr) {
58 while (errmsg[0] == ' ')
59 errmsg++;
60 if (errmsg[0] != '\0')
61 sprintf(message, "%s%s. %s", explanation,
62 strerror(error), errmsg);
63 else
64 sprintf(message, "%s%s", explanation, strerror(error));
65 } else {
66 sprintf(message, "%s%s", explanation, errmsg);
67 }
68
69 dialog_msgbox(title, message, 0, 0, TRUE);
70 }
71
72 static int
scheme_supports_labels(const char * scheme)73 scheme_supports_labels(const char *scheme)
74 {
75 if (strcmp(scheme, "APM") == 0)
76 return (1);
77 if (strcmp(scheme, "GPT") == 0)
78 return (1);
79
80 return (0);
81 }
82
83 static void
newfs_command(const char * fstype,char * command,int use_default)84 newfs_command(const char *fstype, char *command, int use_default)
85 {
86 if (strcmp(fstype, "freebsd-ufs") == 0) {
87 int i;
88 DIALOG_LISTITEM items[] = {
89 {"UFS1", "UFS Version 1",
90 "Use version 1 of the UFS file system instead "
91 "of version 2 (not recommended)", 0 },
92 {"SU", "Softupdates",
93 "Enable softupdates (default)", 1 },
94 {"SUJ", "Softupdates journaling",
95 "Enable file system journaling (default - "
96 "turn off for SSDs)", 1 },
97 {"TRIM", "Enable SSD TRIM support",
98 "Enable TRIM support, useful on solid-state drives",
99 0 },
100 };
101
102 if (!use_default) {
103 int choice;
104 choice = dlg_checklist("UFS Options", "", 0, 0, 0,
105 nitems(items), items, NULL,
106 FLAG_CHECK, &i);
107 if (choice == 1) /* Cancel */
108 return;
109 }
110
111 strcpy(command, "newfs ");
112 for (i = 0; i < (int)nitems(items); i++) {
113 if (items[i].state == 0)
114 continue;
115 if (strcmp(items[i].name, "UFS1") == 0)
116 strcat(command, "-O1 ");
117 else if (strcmp(items[i].name, "SU") == 0)
118 strcat(command, "-U ");
119 else if (strcmp(items[i].name, "SUJ") == 0)
120 strcat(command, "-j ");
121 else if (strcmp(items[i].name, "TRIM") == 0)
122 strcat(command, "-t ");
123 }
124 } else if (strcmp(fstype, "freebsd-zfs") == 0) {
125 int i;
126 DIALOG_LISTITEM items[] = {
127 {"fletcher4", "checksum algorithm: fletcher4",
128 "Use fletcher4 for data integrity checking. "
129 "(default)", 1 },
130 {"fletcher2", "checksum algorithm: fletcher2",
131 "Use fletcher2 for data integrity checking. "
132 "(not recommended)", 0 },
133 {"sha256", "checksum algorithm: sha256",
134 "Use sha256 for data integrity checking. "
135 "(not recommended)", 0 },
136 {"atime", "Update atimes for files",
137 "Disable atime update", 0 },
138 };
139
140 if (!use_default) {
141 int choice;
142 choice = dlg_checklist("ZFS Options", "", 0, 0, 0,
143 nitems(items), items, NULL,
144 FLAG_CHECK, &i);
145 if (choice == 1) /* Cancel */
146 return;
147 }
148
149 strcpy(command, "zpool create -f -m none ");
150 if (getenv("BSDINSTALL_TMPBOOT") != NULL) {
151 char zfsboot_path[MAXPATHLEN];
152 snprintf(zfsboot_path, sizeof(zfsboot_path), "%s/zfs",
153 getenv("BSDINSTALL_TMPBOOT"));
154 mkdir(zfsboot_path, S_IRWXU | S_IRGRP | S_IXGRP |
155 S_IROTH | S_IXOTH);
156 sprintf(command, "%s -o cachefile=%s/zpool.cache ",
157 command, zfsboot_path);
158 }
159 for (i = 0; i < (int)nitems(items); i++) {
160 if (items[i].state == 0)
161 continue;
162 if (strcmp(items[i].name, "fletcher4") == 0)
163 strcat(command, "-O checksum=fletcher4 ");
164 else if (strcmp(items[i].name, "fletcher2") == 0)
165 strcat(command, "-O checksum=fletcher2 ");
166 else if (strcmp(items[i].name, "sha256") == 0)
167 strcat(command, "-O checksum=sha256 ");
168 else if (strcmp(items[i].name, "atime") == 0)
169 strcat(command, "-O atime=off ");
170 }
171 } else if (strcmp(fstype, "fat32") == 0 || strcmp(fstype, "efi") == 0 ||
172 strcmp(fstype, "ms-basic-data") == 0) {
173 int i;
174 DIALOG_LISTITEM items[] = {
175 {"FAT32", "FAT Type 32",
176 "Create a FAT32 filesystem (default)", 1 },
177 {"FAT16", "FAT Type 16",
178 "Create a FAT16 filesystem", 0 },
179 {"FAT12", "FAT Type 12",
180 "Create a FAT12 filesystem", 0 },
181 };
182
183 if (!use_default) {
184 int choice;
185 choice = dlg_checklist("FAT Options", "", 0, 0, 0,
186 nitems(items), items, NULL,
187 FLAG_RADIO, &i);
188 if (choice == 1) /* Cancel */
189 return;
190 }
191
192 strcpy(command, "newfs_msdos ");
193 for (i = 0; i < (int)nitems(items); i++) {
194 if (items[i].state == 0)
195 continue;
196 if (strcmp(items[i].name, "FAT32") == 0)
197 strcat(command, "-F 32 -c 1");
198 else if (strcmp(items[i].name, "FAT16") == 0)
199 strcat(command, "-F 16 ");
200 else if (strcmp(items[i].name, "FAT12") == 0)
201 strcat(command, "-F 12 ");
202 }
203 } else {
204 if (!use_default)
205 dialog_msgbox("Error", "No configurable options exist "
206 "for this filesystem.", 0, 0, TRUE);
207 command[0] = '\0';
208 }
209 }
210
211 const char *
choose_part_type(const char * def_scheme)212 choose_part_type(const char *def_scheme)
213 {
214 int cancel, choice;
215 const char *scheme = NULL;
216
217 DIALOG_LISTITEM items[] = {
218 {"APM", "Apple Partition Map",
219 "Bootable on PowerPC Apple Hardware", 0 },
220 {"BSD", "BSD Labels",
221 "Bootable on most x86 systems", 0 },
222 {"GPT", "GUID Partition Table",
223 "Bootable on most x86 systems and EFI aware ARM64", 0 },
224 {"MBR", "DOS Partitions",
225 "Bootable on most x86 systems", 0 },
226 };
227
228 parttypemenu:
229 dialog_vars.default_item = __DECONST(char *, def_scheme);
230 cancel = dlg_menu("Partition Scheme",
231 "Select a partition scheme for this volume:", 0, 0, 0,
232 nitems(items), items, &choice, NULL);
233 dialog_vars.default_item = NULL;
234
235 if (cancel)
236 return NULL;
237
238 if (!is_scheme_bootable(items[choice].name)) {
239 char message[512];
240 sprintf(message, "This partition scheme (%s) is not "
241 "bootable on this platform. Are you sure you want "
242 "to proceed?", items[choice].name);
243 dialog_vars.defaultno = TRUE;
244 cancel = dialog_yesno("Warning", message, 0, 0);
245 dialog_vars.defaultno = FALSE;
246 if (cancel) /* cancel */
247 goto parttypemenu;
248 }
249
250 scheme = items[choice].name;
251
252 return scheme;
253 }
254
255 int
gpart_partition(const char * lg_name,const char * scheme)256 gpart_partition(const char *lg_name, const char *scheme)
257 {
258 int cancel;
259 struct gctl_req *r;
260 const char *errstr;
261
262 schememenu:
263 if (scheme == NULL) {
264 scheme = choose_part_type(default_scheme());
265
266 if (scheme == NULL)
267 return (-1);
268
269 if (!is_scheme_bootable(scheme)) {
270 char message[512];
271 sprintf(message, "This partition scheme (%s) is not "
272 "bootable on this platform. Are you sure you want "
273 "to proceed?", scheme);
274 dialog_vars.defaultno = TRUE;
275 cancel = dialog_yesno("Warning", message, 0, 0);
276 dialog_vars.defaultno = FALSE;
277 if (cancel) { /* cancel */
278 /* Reset scheme so user can choose another */
279 scheme = NULL;
280 goto schememenu;
281 }
282 }
283 }
284
285 r = gctl_get_handle();
286 gctl_ro_param(r, "class", -1, "PART");
287 gctl_ro_param(r, "arg0", -1, lg_name);
288 gctl_ro_param(r, "flags", -1, GPART_FLAGS);
289 gctl_ro_param(r, "scheme", -1, scheme);
290 gctl_ro_param(r, "verb", -1, "create");
291
292 errstr = gctl_issue(r);
293 if (errstr != NULL && errstr[0] != '\0') {
294 gpart_show_error("Error", NULL, errstr);
295 gctl_free(r);
296 scheme = NULL;
297 goto schememenu;
298 }
299 gctl_free(r);
300
301 if (bootcode_path(scheme) != NULL)
302 get_part_metadata(lg_name, 1)->bootcode = 1;
303 return (0);
304 }
305
306 static void
gpart_activate(struct gprovider * pp)307 gpart_activate(struct gprovider *pp)
308 {
309 struct gconfig *gc;
310 struct gctl_req *r;
311 const char *errstr, *scheme;
312 const char *attribute = NULL;
313 intmax_t idx;
314
315 /*
316 * Some partition schemes need this partition to be marked 'active'
317 * for it to be bootable.
318 */
319 LIST_FOREACH(gc, &pp->lg_geom->lg_config, lg_config) {
320 if (strcmp(gc->lg_name, "scheme") == 0) {
321 scheme = gc->lg_val;
322 break;
323 }
324 }
325
326 if (strcmp(scheme, "MBR") == 0 || strcmp(scheme, "EBR") == 0)
327 attribute = "active";
328 else
329 return;
330
331 LIST_FOREACH(gc, &pp->lg_config, lg_config) {
332 if (strcmp(gc->lg_name, "index") == 0) {
333 idx = atoi(gc->lg_val);
334 break;
335 }
336 }
337
338 r = gctl_get_handle();
339 gctl_ro_param(r, "class", -1, "PART");
340 gctl_ro_param(r, "arg0", -1, pp->lg_geom->lg_name);
341 gctl_ro_param(r, "verb", -1, "set");
342 gctl_ro_param(r, "attrib", -1, attribute);
343 gctl_ro_param(r, "index", sizeof(idx), &idx);
344
345 errstr = gctl_issue(r);
346 if (errstr != NULL && errstr[0] != '\0')
347 gpart_show_error("Error", "Error marking partition active:",
348 errstr);
349 gctl_free(r);
350 }
351
352 void
gpart_set_root(const char * lg_name,const char * attribute)353 gpart_set_root(const char *lg_name, const char *attribute)
354 {
355 struct gctl_req *r;
356 const char *errstr;
357
358 r = gctl_get_handle();
359 gctl_ro_param(r, "class", -1, "PART");
360 gctl_ro_param(r, "arg0", -1, lg_name);
361 gctl_ro_param(r, "flags", -1, "C");
362 gctl_ro_param(r, "verb", -1, "set");
363 gctl_ro_param(r, "attrib", -1, attribute);
364
365 errstr = gctl_issue(r);
366 if (errstr != NULL && errstr[0] != '\0')
367 gpart_show_error("Error", "Error setting parameter on disk:",
368 errstr);
369 gctl_free(r);
370 }
371
372 static void
gpart_bootcode(struct ggeom * gp)373 gpart_bootcode(struct ggeom *gp)
374 {
375 const char *bootcode;
376 struct gconfig *gc;
377 struct gctl_req *r;
378 const char *errstr, *scheme;
379 uint8_t *boot;
380 size_t bootsize, bytes;
381 int bootfd;
382
383 /*
384 * Write default bootcode to the newly partitioned disk, if that
385 * applies on this platform.
386 */
387 LIST_FOREACH(gc, &gp->lg_config, lg_config) {
388 if (strcmp(gc->lg_name, "scheme") == 0) {
389 scheme = gc->lg_val;
390 break;
391 }
392 }
393
394 bootcode = bootcode_path(scheme);
395 if (bootcode == NULL)
396 return;
397
398 bootfd = open(bootcode, O_RDONLY);
399 if (bootfd < 0) {
400 dialog_msgbox("Bootcode Error", strerror(errno), 0, 0,
401 TRUE);
402 return;
403 }
404
405 bootsize = lseek(bootfd, 0, SEEK_END);
406 boot = malloc(bootsize);
407 lseek(bootfd, 0, SEEK_SET);
408 bytes = 0;
409 while (bytes < bootsize)
410 bytes += read(bootfd, boot + bytes, bootsize - bytes);
411 close(bootfd);
412
413 r = gctl_get_handle();
414 gctl_ro_param(r, "class", -1, "PART");
415 gctl_ro_param(r, "arg0", -1, gp->lg_name);
416 gctl_ro_param(r, "verb", -1, "bootcode");
417 gctl_ro_param(r, "bootcode", bootsize, boot);
418
419 errstr = gctl_issue(r);
420 if (errstr != NULL && errstr[0] != '\0')
421 gpart_show_error("Bootcode Error", NULL, errstr);
422 gctl_free(r);
423 free(boot);
424 }
425
426 static void
gpart_partcode(struct gprovider * pp,const char * fstype)427 gpart_partcode(struct gprovider *pp, const char *fstype)
428 {
429 struct gconfig *gc;
430 const char *scheme;
431 const char *indexstr;
432 char message[255], command[255];
433
434 LIST_FOREACH(gc, &pp->lg_geom->lg_config, lg_config) {
435 if (strcmp(gc->lg_name, "scheme") == 0) {
436 scheme = gc->lg_val;
437 break;
438 }
439 }
440
441 /* Make sure this partition scheme needs partcode on this platform */
442 if (partcode_path(scheme, fstype) == NULL)
443 return;
444
445 LIST_FOREACH(gc, &pp->lg_config, lg_config) {
446 if (strcmp(gc->lg_name, "index") == 0) {
447 indexstr = gc->lg_val;
448 break;
449 }
450 }
451
452 /* Shell out to gpart for partcode for now */
453 sprintf(command, "gpart bootcode -p %s -i %s %s",
454 partcode_path(scheme, fstype), indexstr, pp->lg_geom->lg_name);
455 if (system(command) != 0) {
456 sprintf(message, "Error installing partcode on partition %s",
457 pp->lg_name);
458 dialog_msgbox("Error", message, 0, 0, TRUE);
459 }
460 }
461
462 void
gpart_destroy(struct ggeom * lg_geom)463 gpart_destroy(struct ggeom *lg_geom)
464 {
465 struct gctl_req *r;
466 struct gprovider *pp;
467 const char *errstr;
468 int force = 1;
469
470 /* Delete all child metadata */
471 LIST_FOREACH(pp, &lg_geom->lg_provider, lg_provider)
472 gpart_delete(pp);
473
474 /* Revert any local changes to get this geom into a pristine state */
475 r = gctl_get_handle();
476 gctl_ro_param(r, "class", -1, "PART");
477 gctl_ro_param(r, "arg0", -1, lg_geom->lg_name);
478 gctl_ro_param(r, "verb", -1, "undo");
479 gctl_issue(r); /* Ignore errors -- these are non-fatal */
480 gctl_free(r);
481
482 /* Now destroy the geom itself */
483 r = gctl_get_handle();
484 gctl_ro_param(r, "class", -1, "PART");
485 gctl_ro_param(r, "arg0", -1, lg_geom->lg_name);
486 gctl_ro_param(r, "flags", -1, GPART_FLAGS);
487 gctl_ro_param(r, "force", sizeof(force), &force);
488 gctl_ro_param(r, "verb", -1, "destroy");
489 errstr = gctl_issue(r);
490 if (errstr != NULL && errstr[0] != '\0') {
491 /*
492 * Check if we reverted away the existence of the geom
493 * altogether. Show all other errors to the user.
494 */
495 if (strtol(errstr, NULL, 0) != EINVAL)
496 gpart_show_error("Error", NULL, errstr);
497 }
498 gctl_free(r);
499
500 /* And any metadata associated with the partition scheme itself */
501 delete_part_metadata(lg_geom->lg_name);
502 }
503
504 void
gpart_edit(struct gprovider * pp)505 gpart_edit(struct gprovider *pp)
506 {
507 struct gctl_req *r;
508 struct gconfig *gc;
509 struct gconsumer *cp;
510 struct ggeom *geom;
511 const char *errstr, *oldtype, *scheme;
512 struct partition_metadata *md;
513 char sizestr[32];
514 char newfs[255];
515 intmax_t idx;
516 int hadlabel, choice, junk, nitems;
517 unsigned i;
518
519 DIALOG_FORMITEM items[] = {
520 {0, "Type:", 5, 0, 0, FALSE, "", 11, 0, 12, 15, 0,
521 FALSE, "Filesystem type (e.g. freebsd-ufs, freebsd-zfs, "
522 "freebsd-swap)", FALSE},
523 {0, "Size:", 5, 1, 0, FALSE, "", 11, 1, 12, 0, 0,
524 FALSE, "Partition size. Append K, M, G for kilobytes, "
525 "megabytes or gigabytes.", FALSE},
526 {0, "Mountpoint:", 11, 2, 0, FALSE, "", 11, 2, 12, 15, 0,
527 FALSE, "Path at which to mount this partition (leave blank "
528 "for swap, set to / for root filesystem)", FALSE},
529 {0, "Label:", 7, 3, 0, FALSE, "", 11, 3, 12, 15, 0, FALSE,
530 "Partition name. Not all partition schemes support this.",
531 FALSE},
532 };
533
534 /*
535 * Find the PART geom we are manipulating. This may be a consumer of
536 * this provider, or its parent. Check the consumer case first.
537 */
538 geom = NULL;
539 LIST_FOREACH(cp, &pp->lg_consumers, lg_consumers)
540 if (strcmp(cp->lg_geom->lg_class->lg_name, "PART") == 0) {
541 /* Check for zombie geoms, treating them as blank */
542 scheme = NULL;
543 LIST_FOREACH(gc, &cp->lg_geom->lg_config, lg_config) {
544 if (strcmp(gc->lg_name, "scheme") == 0) {
545 scheme = gc->lg_val;
546 break;
547 }
548 }
549 if (scheme == NULL || strcmp(scheme, "(none)") == 0) {
550 gpart_partition(cp->lg_geom->lg_name, NULL);
551 return;
552 }
553
554 /* If this is a nested partition, edit as usual */
555 if (strcmp(pp->lg_geom->lg_class->lg_name, "PART") == 0)
556 break;
557
558 /* Destroy the geom and all sub-partitions */
559 gpart_destroy(cp->lg_geom);
560
561 /* Now re-partition and return */
562 gpart_partition(cp->lg_geom->lg_name, NULL);
563 return;
564 }
565
566 if (geom == NULL && strcmp(pp->lg_geom->lg_class->lg_name, "PART") == 0)
567 geom = pp->lg_geom;
568
569 if (geom == NULL) {
570 /* Disk not partitioned, so partition it */
571 gpart_partition(pp->lg_name, NULL);
572 return;
573 }
574
575 LIST_FOREACH(gc, &geom->lg_config, lg_config) {
576 if (strcmp(gc->lg_name, "scheme") == 0) {
577 scheme = gc->lg_val;
578 break;
579 }
580 }
581
582 nitems = scheme_supports_labels(scheme) ? 4 : 3;
583
584 /* Edit editable parameters of a partition */
585 hadlabel = 0;
586 LIST_FOREACH(gc, &pp->lg_config, lg_config) {
587 if (strcmp(gc->lg_name, "type") == 0) {
588 oldtype = gc->lg_val;
589 items[0].text = gc->lg_val;
590 }
591 if (strcmp(gc->lg_name, "label") == 0 && gc->lg_val != NULL) {
592 hadlabel = 1;
593 items[3].text = gc->lg_val;
594 }
595 if (strcmp(gc->lg_name, "index") == 0)
596 idx = atoi(gc->lg_val);
597 }
598
599 TAILQ_FOREACH(md, &part_metadata, metadata) {
600 if (md->name != NULL && strcmp(md->name, pp->lg_name) == 0) {
601 if (md->fstab != NULL)
602 items[2].text = md->fstab->fs_file;
603 break;
604 }
605 }
606
607 humanize_number(sizestr, 7, pp->lg_mediasize, "B", HN_AUTOSCALE,
608 HN_NOSPACE | HN_DECIMAL);
609 items[1].text = sizestr;
610
611 editpart:
612 choice = dlg_form("Edit Partition", "", 0, 0, 0, nitems, items, &junk);
613
614 if (choice) /* Cancel pressed */
615 goto endedit;
616
617 /* If this is the root partition, check that this fs is bootable */
618 if (strcmp(items[2].text, "/") == 0 && !is_fs_bootable(scheme,
619 items[0].text)) {
620 char message[512];
621 sprintf(message, "This file system (%s) is not bootable "
622 "on this system. Are you sure you want to proceed?",
623 items[0].text);
624 dialog_vars.defaultno = TRUE;
625 choice = dialog_yesno("Warning", message, 0, 0);
626 dialog_vars.defaultno = FALSE;
627 if (choice == 1) /* cancel */
628 goto editpart;
629 }
630
631 /* Check if the label has a / in it */
632 if (strchr(items[3].text, '/') != NULL) {
633 dialog_msgbox("Error", "Label contains a /, which is not an "
634 "allowed character.", 0, 0, TRUE);
635 goto editpart;
636 }
637
638 r = gctl_get_handle();
639 gctl_ro_param(r, "class", -1, "PART");
640 gctl_ro_param(r, "arg0", -1, geom->lg_name);
641 gctl_ro_param(r, "flags", -1, GPART_FLAGS);
642 gctl_ro_param(r, "verb", -1, "modify");
643 gctl_ro_param(r, "index", sizeof(idx), &idx);
644 if (hadlabel || items[3].text[0] != '\0')
645 gctl_ro_param(r, "label", -1, items[3].text);
646 gctl_ro_param(r, "type", -1, items[0].text);
647 errstr = gctl_issue(r);
648 if (errstr != NULL && errstr[0] != '\0') {
649 gpart_show_error("Error", NULL, errstr);
650 gctl_free(r);
651 goto editpart;
652 }
653 gctl_free(r);
654
655 newfs_command(items[0].text, newfs, 1);
656 set_default_part_metadata(pp->lg_name, scheme, items[0].text,
657 items[2].text, (strcmp(oldtype, items[0].text) != 0) ?
658 newfs : NULL);
659
660 endedit:
661 if (strcmp(oldtype, items[0].text) != 0 && cp != NULL)
662 gpart_destroy(cp->lg_geom);
663 if (strcmp(oldtype, items[0].text) != 0 && strcmp(items[0].text,
664 "freebsd") == 0)
665 gpart_partition(pp->lg_name, "BSD");
666
667 for (i = 0; i < nitems(items); i++)
668 if (items[i].text_free)
669 free(items[i].text);
670 }
671
672 void
set_default_part_metadata(const char * name,const char * scheme,const char * type,const char * mountpoint,const char * newfs)673 set_default_part_metadata(const char *name, const char *scheme,
674 const char *type, const char *mountpoint, const char *newfs)
675 {
676 struct partition_metadata *md;
677 char *zpool_name = NULL;
678 const char *default_bootmount = NULL;
679 int i;
680
681 /* Set part metadata */
682 md = get_part_metadata(name, 1);
683
684 if (newfs) {
685 if (md->newfs != NULL) {
686 free(md->newfs);
687 md->newfs = NULL;
688 }
689
690 if (newfs != NULL && newfs[0] != '\0') {
691 md->newfs = malloc(strlen(newfs) + strlen(" /dev/") +
692 strlen(mountpoint) + 5 + strlen(name) + 1);
693 if (strcmp("freebsd-zfs", type) == 0) {
694 zpool_name = strdup((strlen(mountpoint) == 1) ?
695 "root" : &mountpoint[1]);
696 for (i = 0; zpool_name[i] != 0; i++)
697 if (!isalnum(zpool_name[i]))
698 zpool_name[i] = '_';
699 sprintf(md->newfs, "%s %s /dev/%s", newfs,
700 zpool_name, name);
701 } else {
702 sprintf(md->newfs, "%s /dev/%s", newfs, name);
703 }
704 }
705 }
706
707 if (strcmp(type, "freebsd-swap") == 0)
708 mountpoint = "none";
709 if (strcmp(type, bootpart_type(scheme, &default_bootmount)) == 0) {
710 if (default_bootmount == NULL)
711 md->bootcode = 1;
712 else if (mountpoint == NULL || strlen(mountpoint) == 0)
713 mountpoint = default_bootmount;
714 }
715
716 if (mountpoint == NULL || mountpoint[0] == '\0') {
717 if (md->fstab != NULL) {
718 free(md->fstab->fs_spec);
719 free(md->fstab->fs_file);
720 free(md->fstab->fs_vfstype);
721 free(md->fstab->fs_mntops);
722 free(md->fstab->fs_type);
723 free(md->fstab);
724 md->fstab = NULL;
725 }
726 } else {
727 if (md->fstab == NULL) {
728 md->fstab = malloc(sizeof(struct fstab));
729 } else {
730 free(md->fstab->fs_spec);
731 free(md->fstab->fs_file);
732 free(md->fstab->fs_vfstype);
733 free(md->fstab->fs_mntops);
734 free(md->fstab->fs_type);
735 }
736 if (strcmp("freebsd-zfs", type) == 0) {
737 md->fstab->fs_spec = strdup(zpool_name);
738 } else {
739 md->fstab->fs_spec = malloc(strlen(name) +
740 strlen("/dev/") + 1);
741 sprintf(md->fstab->fs_spec, "/dev/%s", name);
742 }
743 md->fstab->fs_file = strdup(mountpoint);
744 /* Get VFS from text after freebsd-, if possible */
745 if (strncmp("freebsd-", type, 8) == 0)
746 md->fstab->fs_vfstype = strdup(&type[8]);
747 else if (strcmp("fat32", type) == 0 || strcmp("efi", type) == 0
748 || strcmp("ms-basic-data", type) == 0)
749 md->fstab->fs_vfstype = strdup("msdosfs");
750 else
751 md->fstab->fs_vfstype = strdup(type); /* Guess */
752 if (strcmp(type, "freebsd-swap") == 0) {
753 md->fstab->fs_type = strdup(FSTAB_SW);
754 md->fstab->fs_freq = 0;
755 md->fstab->fs_passno = 0;
756 } else if (strcmp(type, "freebsd-zfs") == 0) {
757 md->fstab->fs_type = strdup(FSTAB_RW);
758 md->fstab->fs_freq = 0;
759 md->fstab->fs_passno = 0;
760 } else {
761 md->fstab->fs_type = strdup(FSTAB_RW);
762 if (strcmp(mountpoint, "/") == 0) {
763 md->fstab->fs_freq = 1;
764 md->fstab->fs_passno = 1;
765 } else {
766 md->fstab->fs_freq = 2;
767 md->fstab->fs_passno = 2;
768 }
769 }
770 md->fstab->fs_mntops = strdup(md->fstab->fs_type);
771 }
772
773 if (zpool_name != NULL)
774 free(zpool_name);
775 }
776
777 static
part_compare(const void * xa,const void * xb)778 int part_compare(const void *xa, const void *xb)
779 {
780 struct gprovider **a = (struct gprovider **)xa;
781 struct gprovider **b = (struct gprovider **)xb;
782 intmax_t astart, bstart;
783 struct gconfig *gc;
784
785 astart = bstart = 0;
786 LIST_FOREACH(gc, &(*a)->lg_config, lg_config)
787 if (strcmp(gc->lg_name, "start") == 0) {
788 astart = strtoimax(gc->lg_val, NULL, 0);
789 break;
790 }
791 LIST_FOREACH(gc, &(*b)->lg_config, lg_config)
792 if (strcmp(gc->lg_name, "start") == 0) {
793 bstart = strtoimax(gc->lg_val, NULL, 0);
794 break;
795 }
796
797 if (astart < bstart)
798 return -1;
799 else if (astart > bstart)
800 return 1;
801 else
802 return 0;
803 }
804
805 intmax_t
gpart_max_free(struct ggeom * geom,intmax_t * npartstart)806 gpart_max_free(struct ggeom *geom, intmax_t *npartstart)
807 {
808 struct gconfig *gc;
809 struct gprovider *pp, **providers;
810 intmax_t sectorsize, stripesize, offset;
811 intmax_t lastend;
812 intmax_t start, end;
813 intmax_t maxsize, maxstart;
814 intmax_t partstart, partend;
815 int i, nparts;
816
817 /* Now get the maximum free size and free start */
818 start = end = 0;
819 LIST_FOREACH(gc, &geom->lg_config, lg_config) {
820 if (strcmp(gc->lg_name, "first") == 0)
821 start = strtoimax(gc->lg_val, NULL, 0);
822 if (strcmp(gc->lg_name, "last") == 0)
823 end = strtoimax(gc->lg_val, NULL, 0);
824 }
825
826 i = nparts = 0;
827 LIST_FOREACH(pp, &geom->lg_provider, lg_provider)
828 nparts++;
829 providers = calloc(nparts, sizeof(providers[0]));
830 LIST_FOREACH(pp, &geom->lg_provider, lg_provider)
831 providers[i++] = pp;
832 qsort(providers, nparts, sizeof(providers[0]), part_compare);
833
834 lastend = start - 1;
835 maxsize = 0;
836 for (i = 0; i < nparts; i++) {
837 pp = providers[i];
838
839 LIST_FOREACH(gc, &pp->lg_config, lg_config) {
840 if (strcmp(gc->lg_name, "start") == 0)
841 partstart = strtoimax(gc->lg_val, NULL, 0);
842 if (strcmp(gc->lg_name, "end") == 0)
843 partend = strtoimax(gc->lg_val, NULL, 0);
844 }
845
846 if (partstart - lastend > maxsize) {
847 maxsize = partstart - lastend - 1;
848 maxstart = lastend + 1;
849 }
850
851 lastend = partend;
852 }
853
854 if (end - lastend > maxsize) {
855 maxsize = end - lastend;
856 maxstart = lastend + 1;
857 }
858
859 pp = LIST_FIRST(&geom->lg_consumer)->lg_provider;
860
861 /*
862 * Round the start and size of the largest available space up to
863 * the nearest multiple of the adjusted stripe size.
864 *
865 * The adjusted stripe size is the least common multiple of the
866 * actual stripe size, or the sector size if no stripe size was
867 * reported, and 4096. The reason for this is that contemporary
868 * disks often have 4096-byte physical sectors but report 512
869 * bytes instead for compatibility with older / broken operating
870 * systems and BIOSes. For the same reasons, virtualized storage
871 * may also report a 512-byte stripe size, or none at all.
872 */
873 sectorsize = pp->lg_sectorsize;
874 if ((stripesize = pp->lg_stripesize) == 0)
875 stripesize = sectorsize;
876 while (stripesize % 4096 != 0)
877 stripesize *= 2;
878 if ((offset = maxstart * sectorsize % stripesize) != 0) {
879 offset = (stripesize - offset) / sectorsize;
880 maxstart += offset;
881 maxsize -= offset;
882 }
883
884 if (npartstart != NULL)
885 *npartstart = maxstart;
886
887 return (maxsize);
888 }
889
890 static size_t
add_boot_partition(struct ggeom * geom,struct gprovider * pp,const char * scheme,int interactive)891 add_boot_partition(struct ggeom *geom, struct gprovider *pp,
892 const char *scheme, int interactive)
893 {
894 struct gconfig *gc;
895 struct gprovider *ppi;
896 int choice;
897
898 /* Check for existing freebsd-boot partition */
899 LIST_FOREACH(ppi, &geom->lg_provider, lg_provider) {
900 struct partition_metadata *md;
901 const char *bootmount = NULL;
902
903 LIST_FOREACH(gc, &ppi->lg_config, lg_config)
904 if (strcmp(gc->lg_name, "type") == 0)
905 break;
906 if (gc == NULL)
907 continue;
908 if (strcmp(gc->lg_val, bootpart_type(scheme, &bootmount)) != 0)
909 continue;
910
911 /*
912 * If the boot partition is not mountable and needs partcode,
913 * but doesn't have it, it doesn't satisfy our requirements.
914 */
915 md = get_part_metadata(ppi->lg_name, 0);
916 if (bootmount == NULL && (md == NULL || !md->bootcode))
917 continue;
918
919 /* If it is mountable, but mounted somewhere else, remount */
920 if (bootmount != NULL && md != NULL && md->fstab != NULL
921 && strlen(md->fstab->fs_file) > 0
922 && strcmp(md->fstab->fs_file, bootmount) != 0)
923 continue;
924
925 /* If it is mountable, but mountpoint is not set, mount it */
926 if (bootmount != NULL && md == NULL)
927 set_default_part_metadata(ppi->lg_name, scheme,
928 gc->lg_val, bootmount, NULL);
929
930 /* Looks good at this point, no added data needed */
931 return (0);
932 }
933
934 if (interactive)
935 choice = dialog_yesno("Boot Partition",
936 "This partition scheme requires a boot partition "
937 "for the disk to be bootable. Would you like to "
938 "make one now?", 0, 0);
939 else
940 choice = 0;
941
942 if (choice == 0) { /* yes */
943 struct partition_metadata *md;
944 const char *bootmount = NULL;
945 char *bootpartname = NULL;
946 char sizestr[7];
947
948 humanize_number(sizestr, 7,
949 bootpart_size(scheme), "B", HN_AUTOSCALE,
950 HN_NOSPACE | HN_DECIMAL);
951
952 gpart_create(pp, bootpart_type(scheme, &bootmount),
953 sizestr, bootmount, &bootpartname, 0);
954
955 if (bootpartname == NULL) /* Error reported to user already */
956 return 0;
957
958 /* If the part is not mountable, make sure newfs isn't set */
959 if (bootmount == NULL) {
960 md = get_part_metadata(bootpartname, 0);
961 if (md != NULL && md->newfs != NULL) {
962 free(md->newfs);
963 md->newfs = NULL;
964 }
965 }
966
967 free(bootpartname);
968
969 return (bootpart_size(scheme));
970 }
971
972 return (0);
973 }
974
975 void
gpart_create(struct gprovider * pp,const char * default_type,const char * default_size,const char * default_mountpoint,char ** partname,int interactive)976 gpart_create(struct gprovider *pp, const char *default_type,
977 const char *default_size, const char *default_mountpoint,
978 char **partname, int interactive)
979 {
980 struct gctl_req *r;
981 struct gconfig *gc;
982 struct gconsumer *cp;
983 struct ggeom *geom;
984 const char *errstr, *scheme;
985 char sizestr[32], startstr[32], output[64], *newpartname;
986 char newfs[255], options_fstype[64];
987 intmax_t maxsize, size, sector, firstfree, stripe;
988 uint64_t bytes;
989 int nitems, choice, junk;
990 unsigned i;
991
992 DIALOG_FORMITEM items[] = {
993 {0, "Type:", 5, 0, 0, FALSE, "freebsd-ufs", 11, 0, 12, 15, 0,
994 FALSE, "Filesystem type (e.g. freebsd-ufs, freebsd-zfs, "
995 "freebsd-swap)", FALSE},
996 {0, "Size:", 5, 1, 0, FALSE, "", 11, 1, 12, 15, 0,
997 FALSE, "Partition size. Append K, M, G for kilobytes, "
998 "megabytes or gigabytes.", FALSE},
999 {0, "Mountpoint:", 11, 2, 0, FALSE, "", 11, 2, 12, 15, 0,
1000 FALSE, "Path at which to mount partition (blank for "
1001 "swap, / for root filesystem)", FALSE},
1002 {0, "Label:", 7, 3, 0, FALSE, "", 11, 3, 12, 15, 0, FALSE,
1003 "Partition name. Not all partition schemes support this.",
1004 FALSE},
1005 };
1006
1007 if (partname != NULL)
1008 *partname = NULL;
1009
1010 /* Record sector and stripe sizes */
1011 sector = pp->lg_sectorsize;
1012 stripe = pp->lg_stripesize;
1013
1014 /*
1015 * Find the PART geom we are manipulating. This may be a consumer of
1016 * this provider, or its parent. Check the consumer case first.
1017 */
1018 geom = NULL;
1019 LIST_FOREACH(cp, &pp->lg_consumers, lg_consumers)
1020 if (strcmp(cp->lg_geom->lg_class->lg_name, "PART") == 0) {
1021 geom = cp->lg_geom;
1022 break;
1023 }
1024
1025 if (geom == NULL && strcmp(pp->lg_geom->lg_class->lg_name, "PART") == 0)
1026 geom = pp->lg_geom;
1027
1028 /* Now get the partition scheme */
1029 scheme = NULL;
1030 if (geom != NULL) {
1031 LIST_FOREACH(gc, &geom->lg_config, lg_config)
1032 if (strcmp(gc->lg_name, "scheme") == 0)
1033 scheme = gc->lg_val;
1034 }
1035
1036 if (geom == NULL || scheme == NULL || strcmp(scheme, "(none)") == 0) {
1037 if (gpart_partition(pp->lg_name, NULL) == 0)
1038 dialog_msgbox("",
1039 "The partition table has been successfully created."
1040 " Please press Create again to create partitions.",
1041 0, 0, TRUE);
1042
1043 return;
1044 }
1045
1046 /*
1047 * If we still don't have a geom, either the user has
1048 * canceled partitioning or there has been an error which has already
1049 * been displayed, so bail.
1050 */
1051 if (geom == NULL)
1052 return;
1053
1054 maxsize = size = gpart_max_free(geom, &firstfree);
1055 if (size <= 0) {
1056 dialog_msgbox("Error", "No free space left on device.", 0, 0,
1057 TRUE);
1058 return;
1059 }
1060
1061 humanize_number(sizestr, 7, size*sector, "B", HN_AUTOSCALE,
1062 HN_NOSPACE | HN_DECIMAL);
1063 items[1].text = sizestr;
1064
1065 /* Special-case the MBR default type for nested partitions */
1066 if (strcmp(scheme, "MBR") == 0) {
1067 items[0].text = "freebsd";
1068 items[0].help = "Filesystem type (e.g. freebsd, fat32)";
1069 }
1070
1071 nitems = scheme_supports_labels(scheme) ? 4 : 3;
1072
1073 if (default_type != NULL)
1074 items[0].text = (char *)default_type;
1075 if (default_size != NULL)
1076 items[1].text = (char *)default_size;
1077 if (default_mountpoint != NULL)
1078 items[2].text = (char *)default_mountpoint;
1079
1080 /* Default options */
1081 strncpy(options_fstype, items[0].text,
1082 sizeof(options_fstype));
1083 newfs_command(options_fstype, newfs, 1);
1084 addpartform:
1085 if (interactive) {
1086 dialog_vars.extra_label = "Options";
1087 dialog_vars.extra_button = TRUE;
1088 choice = dlg_form("Add Partition", "", 0, 0, 0, nitems,
1089 items, &junk);
1090 dialog_vars.extra_button = FALSE;
1091 switch (choice) {
1092 case 0: /* OK */
1093 break;
1094 case 1: /* Cancel */
1095 return;
1096 case 3: /* Options */
1097 strncpy(options_fstype, items[0].text,
1098 sizeof(options_fstype));
1099 newfs_command(options_fstype, newfs, 0);
1100 goto addpartform;
1101 }
1102 }
1103
1104 /*
1105 * If the user changed the fs type after specifying options, undo
1106 * their choices in favor of the new filesystem's defaults.
1107 */
1108 if (strcmp(options_fstype, items[0].text) != 0) {
1109 strncpy(options_fstype, items[0].text, sizeof(options_fstype));
1110 newfs_command(options_fstype, newfs, 1);
1111 }
1112
1113 size = maxsize;
1114 if (strlen(items[1].text) > 0) {
1115 if (expand_number(items[1].text, &bytes) != 0) {
1116 char error[512];
1117
1118 sprintf(error, "Invalid size: %s\n", strerror(errno));
1119 dialog_msgbox("Error", error, 0, 0, TRUE);
1120 goto addpartform;
1121 }
1122 size = MIN((intmax_t)(bytes/sector), maxsize);
1123 }
1124
1125 /* Check if the label has a / in it */
1126 if (strchr(items[3].text, '/') != NULL) {
1127 dialog_msgbox("Error", "Label contains a /, which is not an "
1128 "allowed character.", 0, 0, TRUE);
1129 goto addpartform;
1130 }
1131
1132 /* Warn if no mountpoint set */
1133 if (strcmp(items[0].text, "freebsd-ufs") == 0 &&
1134 items[2].text[0] != '/') {
1135 choice = 0;
1136 if (interactive) {
1137 dialog_vars.defaultno = TRUE;
1138 choice = dialog_yesno("Warning",
1139 "This partition does not have a valid mountpoint "
1140 "(for the partition from which you intend to boot the "
1141 "operating system, the mountpoint should be /). Are you "
1142 "sure you want to continue?"
1143 , 0, 0);
1144 dialog_vars.defaultno = FALSE;
1145 }
1146 if (choice == 1) /* cancel */
1147 goto addpartform;
1148 }
1149
1150 /*
1151 * Error if this scheme needs nested partitions, this is one, and
1152 * a mountpoint was set.
1153 */
1154 if (strcmp(items[0].text, "freebsd") == 0 &&
1155 strlen(items[2].text) > 0) {
1156 dialog_msgbox("Error", "Partitions of type \"freebsd\" are "
1157 "nested BSD-type partition schemes and cannot have "
1158 "mountpoints. After creating one, select it and press "
1159 "Create again to add the actual file systems.", 0, 0, TRUE);
1160 goto addpartform;
1161 }
1162
1163 /* If this is the root partition, check that this scheme is bootable */
1164 if (strcmp(items[2].text, "/") == 0 && !is_scheme_bootable(scheme)) {
1165 char message[512];
1166 sprintf(message, "This partition scheme (%s) is not bootable "
1167 "on this platform. Are you sure you want to proceed?",
1168 scheme);
1169 dialog_vars.defaultno = TRUE;
1170 choice = dialog_yesno("Warning", message, 0, 0);
1171 dialog_vars.defaultno = FALSE;
1172 if (choice == 1) /* cancel */
1173 goto addpartform;
1174 }
1175
1176 /* If this is the root partition, check that this fs is bootable */
1177 if (strcmp(items[2].text, "/") == 0 && !is_fs_bootable(scheme,
1178 items[0].text)) {
1179 char message[512];
1180 sprintf(message, "This file system (%s) is not bootable "
1181 "on this system. Are you sure you want to proceed?",
1182 items[0].text);
1183 dialog_vars.defaultno = TRUE;
1184 choice = dialog_yesno("Warning", message, 0, 0);
1185 dialog_vars.defaultno = FALSE;
1186 if (choice == 1) /* cancel */
1187 goto addpartform;
1188 }
1189
1190 /*
1191 * If this is the root partition, and we need a boot partition, ask
1192 * the user to add one.
1193 */
1194
1195 if ((strcmp(items[0].text, "freebsd") == 0 ||
1196 strcmp(items[2].text, "/") == 0) && bootpart_size(scheme) > 0) {
1197 size_t bytes = add_boot_partition(geom, pp, scheme,
1198 interactive);
1199
1200 /* Now adjust the part we are really adding forward */
1201 if (bytes > 0) {
1202 firstfree += bytes / sector;
1203 size -= (bytes + stripe)/sector;
1204 if (stripe > 0 && (firstfree*sector % stripe) != 0)
1205 firstfree += (stripe - ((firstfree*sector) %
1206 stripe)) / sector;
1207 }
1208 }
1209
1210 r = gctl_get_handle();
1211 gctl_ro_param(r, "class", -1, "PART");
1212 gctl_ro_param(r, "arg0", -1, geom->lg_name);
1213 gctl_ro_param(r, "flags", -1, GPART_FLAGS);
1214 gctl_ro_param(r, "verb", -1, "add");
1215
1216 gctl_ro_param(r, "type", -1, items[0].text);
1217 snprintf(sizestr, sizeof(sizestr), "%jd", size);
1218 gctl_ro_param(r, "size", -1, sizestr);
1219 snprintf(startstr, sizeof(startstr), "%jd", firstfree);
1220 gctl_ro_param(r, "start", -1, startstr);
1221 if (items[3].text[0] != '\0')
1222 gctl_ro_param(r, "label", -1, items[3].text);
1223 gctl_rw_param(r, "output", sizeof(output), output);
1224 errstr = gctl_issue(r);
1225 if (errstr != NULL && errstr[0] != '\0') {
1226 gpart_show_error("Error", NULL, errstr);
1227 gctl_free(r);
1228 goto addpartform;
1229 }
1230 newpartname = strtok(output, " ");
1231 gctl_free(r);
1232
1233 /*
1234 * Try to destroy any geom that gpart picked up already here from
1235 * dirty blocks.
1236 */
1237 r = gctl_get_handle();
1238 gctl_ro_param(r, "class", -1, "PART");
1239 gctl_ro_param(r, "arg0", -1, newpartname);
1240 gctl_ro_param(r, "flags", -1, GPART_FLAGS);
1241 junk = 1;
1242 gctl_ro_param(r, "force", sizeof(junk), &junk);
1243 gctl_ro_param(r, "verb", -1, "destroy");
1244 gctl_issue(r); /* Error usually expected and non-fatal */
1245 gctl_free(r);
1246
1247
1248 if (strcmp(items[0].text, "freebsd") == 0)
1249 gpart_partition(newpartname, "BSD");
1250 else
1251 set_default_part_metadata(newpartname, scheme,
1252 items[0].text, items[2].text, newfs);
1253
1254 for (i = 0; i < nitems(items); i++)
1255 if (items[i].text_free)
1256 free(items[i].text);
1257
1258 if (partname != NULL)
1259 *partname = strdup(newpartname);
1260 }
1261
1262 void
gpart_delete(struct gprovider * pp)1263 gpart_delete(struct gprovider *pp)
1264 {
1265 struct gconfig *gc;
1266 struct ggeom *geom;
1267 struct gconsumer *cp;
1268 struct gctl_req *r;
1269 const char *errstr;
1270 intmax_t idx;
1271 int is_partition;
1272
1273 /* Is it a partition? */
1274 is_partition = (strcmp(pp->lg_geom->lg_class->lg_name, "PART") == 0);
1275
1276 /* Find out if this is the root of a gpart geom */
1277 geom = NULL;
1278 LIST_FOREACH(cp, &pp->lg_consumers, lg_consumers)
1279 if (strcmp(cp->lg_geom->lg_class->lg_name, "PART") == 0) {
1280 geom = cp->lg_geom;
1281 break;
1282 }
1283
1284 /* If so, destroy all children */
1285 if (geom != NULL) {
1286 gpart_destroy(geom);
1287
1288 /* If this is a partition, revert it, so it can be deleted */
1289 if (is_partition) {
1290 r = gctl_get_handle();
1291 gctl_ro_param(r, "class", -1, "PART");
1292 gctl_ro_param(r, "arg0", -1, geom->lg_name);
1293 gctl_ro_param(r, "verb", -1, "undo");
1294 gctl_issue(r); /* Ignore non-fatal errors */
1295 gctl_free(r);
1296 }
1297 }
1298
1299 /*
1300 * If this is not a partition, see if that is a problem, complain if
1301 * necessary, and return always, since we need not do anything further,
1302 * error or no.
1303 */
1304 if (!is_partition) {
1305 if (geom == NULL)
1306 dialog_msgbox("Error",
1307 "Only partitions can be deleted.", 0, 0, TRUE);
1308 return;
1309 }
1310
1311 r = gctl_get_handle();
1312 gctl_ro_param(r, "class", -1, pp->lg_geom->lg_class->lg_name);
1313 gctl_ro_param(r, "arg0", -1, pp->lg_geom->lg_name);
1314 gctl_ro_param(r, "flags", -1, GPART_FLAGS);
1315 gctl_ro_param(r, "verb", -1, "delete");
1316
1317 LIST_FOREACH(gc, &pp->lg_config, lg_config) {
1318 if (strcmp(gc->lg_name, "index") == 0) {
1319 idx = atoi(gc->lg_val);
1320 gctl_ro_param(r, "index", sizeof(idx), &idx);
1321 break;
1322 }
1323 }
1324
1325 errstr = gctl_issue(r);
1326 if (errstr != NULL && errstr[0] != '\0') {
1327 gpart_show_error("Error", NULL, errstr);
1328 gctl_free(r);
1329 return;
1330 }
1331
1332 gctl_free(r);
1333
1334 delete_part_metadata(pp->lg_name);
1335 }
1336
1337 void
gpart_revert_all(struct gmesh * mesh)1338 gpart_revert_all(struct gmesh *mesh)
1339 {
1340 struct gclass *classp;
1341 struct gconfig *gc;
1342 struct ggeom *gp;
1343 struct gctl_req *r;
1344 const char *modified;
1345
1346 LIST_FOREACH(classp, &mesh->lg_class, lg_class) {
1347 if (strcmp(classp->lg_name, "PART") == 0)
1348 break;
1349 }
1350
1351 if (strcmp(classp->lg_name, "PART") != 0) {
1352 dialog_msgbox("Error", "gpart not found!", 0, 0, TRUE);
1353 return;
1354 }
1355
1356 LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
1357 modified = "true"; /* XXX: If we don't know (kernel too old),
1358 * assume there are modifications. */
1359 LIST_FOREACH(gc, &gp->lg_config, lg_config) {
1360 if (strcmp(gc->lg_name, "modified") == 0) {
1361 modified = gc->lg_val;
1362 break;
1363 }
1364 }
1365
1366 if (strcmp(modified, "false") == 0)
1367 continue;
1368
1369 r = gctl_get_handle();
1370 gctl_ro_param(r, "class", -1, "PART");
1371 gctl_ro_param(r, "arg0", -1, gp->lg_name);
1372 gctl_ro_param(r, "verb", -1, "undo");
1373
1374 gctl_issue(r);
1375 gctl_free(r);
1376 }
1377 }
1378
1379 void
gpart_commit(struct gmesh * mesh)1380 gpart_commit(struct gmesh *mesh)
1381 {
1382 struct partition_metadata *md;
1383 struct gclass *classp;
1384 struct ggeom *gp;
1385 struct gconfig *gc;
1386 struct gconsumer *cp;
1387 struct gprovider *pp;
1388 struct gctl_req *r;
1389 const char *errstr;
1390 const char *modified;
1391 const char *rootfs;
1392
1393 LIST_FOREACH(classp, &mesh->lg_class, lg_class) {
1394 if (strcmp(classp->lg_name, "PART") == 0)
1395 break;
1396 }
1397
1398 /* Figure out what filesystem / uses */
1399 rootfs = "ufs"; /* Assume ufs if nothing else present */
1400 TAILQ_FOREACH(md, &part_metadata, metadata) {
1401 if (md->fstab != NULL && strcmp(md->fstab->fs_file, "/") == 0) {
1402 rootfs = md->fstab->fs_vfstype;
1403 break;
1404 }
1405 }
1406
1407 if (strcmp(classp->lg_name, "PART") != 0) {
1408 dialog_msgbox("Error", "gpart not found!", 0, 0, TRUE);
1409 return;
1410 }
1411
1412 LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
1413 modified = "true"; /* XXX: If we don't know (kernel too old),
1414 * assume there are modifications. */
1415 LIST_FOREACH(gc, &gp->lg_config, lg_config) {
1416 if (strcmp(gc->lg_name, "modified") == 0) {
1417 modified = gc->lg_val;
1418 break;
1419 }
1420 }
1421
1422 if (strcmp(modified, "false") == 0)
1423 continue;
1424
1425 /* Add bootcode if necessary, before the commit */
1426 md = get_part_metadata(gp->lg_name, 0);
1427 if (md != NULL && md->bootcode)
1428 gpart_bootcode(gp);
1429
1430 /* Now install partcode on its partitions, if necessary */
1431 LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
1432 md = get_part_metadata(pp->lg_name, 0);
1433 if (md == NULL || !md->bootcode)
1434 continue;
1435
1436 /* Mark this partition active if that's required */
1437 gpart_activate(pp);
1438
1439 /* Check if the partition has sub-partitions */
1440 LIST_FOREACH(cp, &pp->lg_consumers, lg_consumers)
1441 if (strcmp(cp->lg_geom->lg_class->lg_name,
1442 "PART") == 0)
1443 break;
1444
1445 if (cp == NULL) /* No sub-partitions */
1446 gpart_partcode(pp, rootfs);
1447 }
1448
1449 r = gctl_get_handle();
1450 gctl_ro_param(r, "class", -1, "PART");
1451 gctl_ro_param(r, "arg0", -1, gp->lg_name);
1452 gctl_ro_param(r, "verb", -1, "commit");
1453
1454 errstr = gctl_issue(r);
1455 if (errstr != NULL && errstr[0] != '\0')
1456 gpart_show_error("Error", NULL, errstr);
1457 gctl_free(r);
1458 }
1459 }
1460
1461