]>
git.ipfire.org Git - thirdparty/util-linux.git/blob - disk-utils/fdisk-menu.c
15 const char key
; /* command key */
16 const char *title
; /* help string */
17 unsigned int normal
: 1, /* normal mode */
18 expert
: 1, /* expert mode */
19 hidden
: 1; /* be sensitive for this key,
20 but don't print it in help */
22 enum fdisk_labeltype label
; /* only for this label */
23 int exclude
; /* all labels except these */
24 enum fdisk_labeltype parent
; /* for nested PT */
27 #define IS_MENU_SEP(e) ((e)->key == '-')
28 #define IS_MENU_HID(e) ((e)->hidden)
31 enum fdisk_labeltype label
; /* only for this label */
32 int exclude
; /* all labels except these */
34 unsigned int nonested
: 1; /* don't make this menu active in nested PT */
36 int (*callback
)(struct fdisk_context
**,
38 const struct menu_entry
*);
40 struct menu_entry entries
[]; /* NULL terminated array */
44 size_t menu_idx
; /* the current menu */
45 size_t entry_idx
; /* index with in the current menu */
48 #define MENU_CXT_EMPTY { 0, 0 }
49 #define DECLARE_MENU_CB(x) \
50 static int x(struct fdisk_context **, \
51 const struct menu *, \
52 const struct menu_entry *)
54 DECLARE_MENU_CB(gpt_menu_cb
);
55 DECLARE_MENU_CB(sun_menu_cb
);
56 DECLARE_MENU_CB(sgi_menu_cb
);
57 DECLARE_MENU_CB(geo_menu_cb
);
58 DECLARE_MENU_CB(dos_menu_cb
);
59 DECLARE_MENU_CB(bsd_menu_cb
);
60 DECLARE_MENU_CB(createlabel_menu_cb
);
61 DECLARE_MENU_CB(generic_menu_cb
);
65 * MENU_X* expert mode only
66 * MENU_B* both -- expert + normal mode
68 * *_E exclude this label
70 * *_L only for this label
74 #define MENU_SEP(t) { .title = t, .key = '-', .normal = 1 }
75 #define MENU_XSEP(t) { .title = t, .key = '-', .expert = 1 }
76 #define MENU_BSEP(t) { .title = t, .key = '-', .expert = 1, .normal = 1 }
79 #define MENU_ENT(k, t) { .title = t, .key = k, .normal = 1 }
80 #define MENU_ENT_E(k, t, l) { .title = t, .key = k, .normal = 1, .exclude = l }
81 #define MENU_ENT_L(k, t, l) { .title = t, .key = k, .normal = 1, .label = l }
83 #define MENU_XENT(k, t) { .title = t, .key = k, .expert = 1 }
84 #define MENU_XENT_H(k, t) { .title = t, .key = k, .expert = 1, .hidden = 1 }
86 #define MENU_BENT(k, t) { .title = t, .key = k, .expert = 1, .normal = 1 }
87 #define MENU_BENT_E(k, t, l) { .title = t, .key = k, .expert = 1, .normal = 1, .exclude = l }
89 #define MENU_ENT_NEST(k, t, l, p) { .title = t, .key = k, .normal = 1, .label = l, .parent = p }
90 #define MENU_BENT_NEST_H(k, t, l, p) { .title = t, .key = k, .expert = 1, .normal = 1, .label = l, .parent = p, .hidden = 1 }
93 static const struct menu menu_generic
= {
94 .callback
= generic_menu_cb
,
96 MENU_BSEP(N_("Generic")),
97 MENU_ENT ('d', N_("delete a partition")),
98 MENU_ENT ('F', N_("list free unpartitioned space")),
99 MENU_ENT ('l', N_("list known partition types")),
100 MENU_ENT ('n', N_("add a new partition")),
101 MENU_BENT ('p', N_("print the partition table")),
102 MENU_ENT ('t', N_("change a partition type")),
103 MENU_BENT_E('v', N_("verify the partition table"), FDISK_DISKLABEL_BSD
),
104 MENU_ENT ('i', N_("print information about a partition")),
106 MENU_XENT('d', N_("print the raw data of the first sector from the device")),
107 MENU_XENT('D', N_("print the raw data of the disklabel from the device")),
108 MENU_XENT('f', N_("fix partitions order")),
110 MENU_SEP(N_("Misc")),
111 MENU_BENT ('m', N_("print this menu")),
112 MENU_ENT_E('u', N_("change display/entry units"), FDISK_DISKLABEL_GPT
),
113 MENU_ENT_E('x', N_("extra functionality (experts only)"), FDISK_DISKLABEL_BSD
),
115 MENU_SEP(N_("Script")),
116 MENU_ENT ('I', N_("load disk layout from sfdisk script file")),
117 MENU_ENT ('O', N_("dump disk layout to sfdisk script file")),
119 MENU_BSEP(N_("Save & Exit")),
120 MENU_ENT_E('w', N_("write table to disk and exit"), FDISK_DISKLABEL_BSD
),
121 MENU_ENT_L('w', N_("write table to disk"), FDISK_DISKLABEL_BSD
),
122 MENU_BENT ('q', N_("quit without saving changes")),
123 MENU_XENT ('r', N_("return to main menu")),
125 MENU_ENT_NEST('r', N_("return from BSD to DOS (MBR)"), FDISK_DISKLABEL_BSD
, FDISK_DISKLABEL_DOS
),
127 MENU_ENT_NEST('r', N_("return from protective/hybrid MBR to GPT"), FDISK_DISKLABEL_DOS
, FDISK_DISKLABEL_GPT
),
133 static const struct menu menu_createlabel
= {
134 .callback
= createlabel_menu_cb
,
135 .exclude
= FDISK_DISKLABEL_BSD
,
138 MENU_SEP(N_("Create a new label")),
139 MENU_ENT('g', N_("create a new empty GPT partition table")),
140 MENU_ENT('G', N_("create a new empty SGI (IRIX) partition table")),
141 MENU_ENT('o', N_("create a new empty MBR (DOS) partition table")),
142 MENU_ENT('s', N_("create a new empty Sun partition table")),
144 /* backward compatibility -- be sensitive to 'g', but don't
145 * print it in the expert menu */
146 MENU_XENT_H('g', N_("create an IRIX (SGI) partition table")),
151 static const struct menu menu_geo
= {
152 .callback
= geo_menu_cb
,
153 .exclude
= FDISK_DISKLABEL_GPT
| FDISK_DISKLABEL_BSD
,
155 MENU_XSEP(N_("Geometry (for the current label)")),
156 MENU_XENT('c', N_("change number of cylinders")),
157 MENU_XENT('h', N_("change number of heads")),
158 MENU_XENT('s', N_("change number of sectors/track")),
163 static const struct menu menu_gpt
= {
164 .callback
= gpt_menu_cb
,
165 .label
= FDISK_DISKLABEL_GPT
,
167 MENU_BSEP(N_("GPT")),
168 MENU_XENT('i', N_("change disk GUID")),
169 MENU_XENT('n', N_("change partition name")),
170 MENU_XENT('u', N_("change partition UUID")),
171 MENU_XENT('l', N_("change table length")),
172 MENU_BENT('M', N_("enter protective/hybrid MBR")),
175 MENU_XENT('A', N_("toggle the legacy BIOS bootable flag")),
176 MENU_XENT('B', N_("toggle the no block IO protocol flag")),
177 MENU_XENT('R', N_("toggle the required partition flag")),
178 MENU_XENT('S', N_("toggle the GUID specific bits")),
184 static const struct menu menu_sun
= {
185 .callback
= sun_menu_cb
,
186 .label
= FDISK_DISKLABEL_SUN
,
188 MENU_BSEP(N_("Sun")),
189 MENU_ENT('a', N_("toggle the read-only flag")),
190 MENU_ENT('c', N_("toggle the mountable flag")),
192 MENU_XENT('a', N_("change number of alternate cylinders")),
193 MENU_XENT('e', N_("change number of extra sectors per cylinder")),
194 MENU_XENT('i', N_("change interleave factor")),
195 MENU_XENT('o', N_("change rotation speed (rpm)")),
196 MENU_XENT('y', N_("change number of physical cylinders")),
201 static const struct menu menu_sgi
= {
202 .callback
= sgi_menu_cb
,
203 .label
= FDISK_DISKLABEL_SGI
,
206 MENU_ENT('a', N_("select bootable partition")),
207 MENU_ENT('b', N_("edit bootfile entry")),
208 MENU_ENT('c', N_("select sgi swap partition")),
209 MENU_ENT('i', N_("create SGI info")),
214 static const struct menu menu_dos
= {
215 .callback
= dos_menu_cb
,
216 .label
= FDISK_DISKLABEL_DOS
,
218 MENU_BSEP(N_("DOS (MBR)")),
219 MENU_ENT('a', N_("toggle a bootable flag")),
220 MENU_ENT('b', N_("edit nested BSD disklabel")),
221 MENU_ENT('c', N_("toggle the dos compatibility flag")),
223 MENU_XENT('b', N_("move beginning of data in a partition")),
224 MENU_XENT('F', N_("fix partitions C/H/S values")),
225 MENU_XENT('i', N_("change the disk identifier")),
227 MENU_BENT_NEST_H('M', N_("return from protective/hybrid MBR to GPT"), FDISK_DISKLABEL_DOS
, FDISK_DISKLABEL_GPT
),
233 static const struct menu menu_bsd
= {
234 .callback
= bsd_menu_cb
,
235 .label
= FDISK_DISKLABEL_BSD
,
238 MENU_ENT('e', N_("edit drive data")),
239 MENU_ENT('i', N_("install bootstrap")),
240 MENU_ENT('s', N_("show complete disklabel")),
241 MENU_ENT('x', N_("link BSD partition to non-BSD partition")),
246 static const struct menu
*menus
[] = {
257 static const struct menu_entry
*next_menu_entry(
258 struct fdisk_context
*cxt
,
259 struct menu_context
*mc
)
261 struct fdisk_label
*lb
= fdisk_get_label(cxt
, NULL
);
262 struct fdisk_context
*parent
= fdisk_get_parent(cxt
);
263 unsigned int type
= 0, pr_type
= 0;
268 type
= fdisk_label_get_type(lb
);
270 pr_type
= fdisk_label_get_type(fdisk_get_label(parent
, NULL
));
272 while (mc
->menu_idx
< ARRAY_SIZE(menus
)) {
273 const struct menu
*m
= menus
[mc
->menu_idx
];
274 const struct menu_entry
*e
= &(m
->entries
[mc
->entry_idx
]);
280 /* no more entries */
281 if (e
->title
== NULL
||
282 /* menu wanted for specified labels only */
283 (m
->label
&& (!lb
|| !(m
->label
& type
))) ||
284 /* unwanted for nested PT */
285 (m
->nonested
&& parent
) ||
286 /* menu excluded for specified labels */
287 (m
->exclude
&& lb
&& (m
->exclude
& type
))) {
297 /* excluded for the current label */
298 if ((e
->exclude
&& lb
&& e
->exclude
& type
) ||
299 /* entry wanted for specified labels only */
300 (e
->label
&& (!lb
|| !(e
->label
& type
))) ||
301 /* exclude non-expert entries in expect mode */
302 (e
->expert
== 0 && fdisk_is_details(cxt
)) ||
304 (e
->parent
&& (!parent
|| pr_type
!= e
->parent
)) ||
305 /* exclude non-normal entries in normal mode */
306 (e
->normal
== 0 && !fdisk_is_details(cxt
))) {
317 /* returns @menu and menu entry for then @key */
318 static const struct menu_entry
*get_fdisk_menu_entry(
319 struct fdisk_context
*cxt
,
321 const struct menu
**menu
)
323 struct menu_context mc
= MENU_CXT_EMPTY
;
324 const struct menu_entry
*e
;
326 while ((e
= next_menu_entry(cxt
, &mc
))) {
327 if (IS_MENU_SEP(e
) || e
->key
!= key
)
331 *menu
= menus
[mc
.menu_idx
];
338 static int menu_detect_collisions(struct fdisk_context
*cxt
)
340 struct menu_context mc
= MENU_CXT_EMPTY
;
341 const struct menu_entry
*e
, *r
;
343 while ((e
= next_menu_entry(cxt
, &mc
))) {
347 r
= get_fdisk_menu_entry(cxt
, e
->key
, NULL
);
349 DBG(MENU
, ul_debug("warning: not found "
350 "entry for %c", e
->key
));
354 DBG(MENU
, ul_debug("warning: duplicate key '%c'",
356 DBG(MENU
, ul_debug(" : %s", e
->title
));
357 DBG(MENU
, ul_debug(" : %s", r
->title
));
365 static int print_fdisk_menu(struct fdisk_context
*cxt
)
367 struct menu_context mc
= MENU_CXT_EMPTY
;
368 const struct menu_entry
*e
;
370 ON_DBG(MENU
, menu_detect_collisions(cxt
));
372 if (fdisk_is_details(cxt
))
373 printf(_("\nHelp (expert commands):\n"));
375 printf(_("\nHelp:\n"));
377 while ((e
= next_menu_entry(cxt
, &mc
))) {
379 continue; /* hidden entry */
380 if (IS_MENU_SEP(e
) && (!e
->title
|| !*e
->title
))
382 else if (IS_MENU_SEP(e
)) {
383 color_scheme_enable("help-title", UL_COLOR_BOLD
);
384 printf("\n %s\n", _(e
->title
));
387 printf(" %c %s\n", e
->key
, _(e
->title
));
391 if (fdisk_get_parent(cxt
)) {
392 struct fdisk_label
*l
= fdisk_get_label(cxt
, NULL
),
393 *p
= fdisk_get_label(fdisk_get_parent(cxt
), NULL
);
395 fdisk_info(cxt
, _("You're editing nested '%s' partition table, "
396 "primary partition table is '%s'."),
397 fdisk_label_get_name(l
),
398 fdisk_label_get_name(p
));
404 /* Asks for command, verify the key and perform the command or
405 * returns the command key if no callback for the command is
408 * Note that this function might exchange the context pointer to
409 * switch to another (nested) context.
411 * Returns: <0 on error
412 * 0 on success (the command performed)
413 * >0 if no callback (then returns the key)
415 int process_fdisk_menu(struct fdisk_context
**cxt0
)
417 struct fdisk_context
*cxt
= *cxt0
;
418 const struct menu_entry
*ent
;
419 const struct menu
*menu
;
422 char buf
[BUFSIZ
] = { '\0' };
424 if (fdisk_is_details(cxt
))
425 prompt
= _("Expert command (m for help): ");
427 prompt
= _("Command (m for help): ");
430 rc
= get_user_reply(prompt
, buf
, sizeof(buf
));
432 if (rc
== -ECANCELED
) {
433 /* Map ^C and ^D in main menu to 'q' */
435 && fdisk_label_is_changed(fdisk_get_label(cxt
, NULL
))) {
437 _("\nAll unwritten changes will be lost, do you really want to quit? "),
439 if (rc
|| !rpmatch(buf
))
448 ent
= get_fdisk_menu_entry(cxt
, key
, &menu
);
450 fdisk_warnx(cxt
, _("%c: unknown command"), key
);
454 DBG(MENU
, ul_debug("selected: key=%c, entry='%s'",
457 /* menu has implemented callback, use it */
459 rc
= menu
->callback(cxt0
, menu
, ent
);
461 DBG(MENU
, ul_debug("no callback for key '%c'", key
));
465 DBG(MENU
, ul_debug("process menu done [rc=%d]", rc
));
469 static int script_read(struct fdisk_context
*cxt
)
471 struct fdisk_script
*sc
= NULL
;
472 char *filename
= NULL
;
475 rc
= fdisk_ask_string(cxt
, _("Enter script file name"), &filename
);
480 sc
= fdisk_new_script_from_file(cxt
, filename
);
482 fdisk_warn(cxt
, _("Cannot open %s"), filename
);
484 fdisk_warnx(cxt
, _("Failed to parse script file %s"), filename
);
485 else if (fdisk_apply_script(cxt
, sc
) != 0) {
486 fdisk_warnx(cxt
, _("Failed to apply script %s"), filename
);
487 fdisk_warnx(cxt
, _("Resetting fdisk!"));
488 rc
= fdisk_reassign_device(cxt
);
489 if (rc
== 0 && !fdisk_has_label(cxt
)) {
490 fdisk_info(cxt
, _("Device does not contain a recognized partition table."));
491 rc
= fdisk_create_disklabel(cxt
, NULL
);
494 fdisk_info(cxt
, _("Script successfully applied."));
496 fdisk_unref_script(sc
);
501 static int script_write(struct fdisk_context
*cxt
)
503 struct fdisk_script
*sc
= NULL
;
504 char *filename
= NULL
;
508 rc
= fdisk_ask_string(cxt
, _("Enter script file name"), &filename
);
512 sc
= fdisk_new_script(cxt
);
514 fdisk_warn(cxt
, _("Failed to allocate script handler"));
518 rc
= fdisk_script_read_context(sc
, NULL
);
520 fdisk_warnx(cxt
, _("Failed to transform disk layout into script"));
524 f
= fopen(filename
, "w");
526 fdisk_warn(cxt
, _("Cannot open %s"), filename
);
530 rc
= fdisk_script_write_file(sc
, f
);
532 fdisk_warn(cxt
, _("Failed to write script %s"), filename
);
534 fdisk_info(cxt
, _("Script successfully saved."));
538 fdisk_unref_script(sc
);
543 static int ask_for_wipe(struct fdisk_context
*cxt
, size_t partno
)
545 struct fdisk_partition
*tmp
= NULL
;
549 rc
= fdisk_get_partition(cxt
, partno
, &tmp
);
553 rc
= fdisk_partition_to_string(tmp
, cxt
, FDISK_FIELD_FSTYPE
, &fstype
);
554 if (rc
|| fstype
== NULL
)
557 fdisk_warnx(cxt
, _("Partition #%zu contains a %s signature."), partno
+ 1, fstype
);
559 if (pwipemode
== WIPEMODE_AUTO
&& isatty(STDIN_FILENO
))
560 fdisk_ask_yesno(cxt
, _("Do you want to remove the signature?"), &yes
);
561 else if (pwipemode
== WIPEMODE_ALWAYS
)
565 fdisk_info(cxt
, _("The signature will be removed by a write command."));
566 rc
= fdisk_wipe_partition(cxt
, partno
, TRUE
);
569 fdisk_unref_partition(tmp
);
575 * Basic fdisk actions
577 static int generic_menu_cb(struct fdisk_context
**cxt0
,
578 const struct menu
*menu
__attribute__((__unused__
)),
579 const struct menu_entry
*ent
)
581 struct fdisk_context
*cxt
= *cxt0
;
585 /* actions shared between expert and normal mode */
588 list_disk_geometry(cxt
);
592 if (fdisk_is_readonly(cxt
)) {
593 fdisk_warnx(cxt
, _("Device is open in read-only mode."));
596 rc
= fdisk_write_disklabel(cxt
);
598 err(EXIT_FAILURE
, _("failed to write disklabel"));
600 fdisk_info(cxt
, _("The partition table has been altered."));
601 if (fdisk_get_parent(cxt
))
602 break; /* nested PT, don't leave */
605 rc
= fdisk_reread_changes(cxt
, original_layout
);
607 rc
= fdisk_reread_partition_table(cxt
);
609 rc
= fdisk_deassign_device(cxt
, 0);
612 fdisk_unref_context(cxt
);
614 exit(rc
== 0 ? EXIT_SUCCESS
: EXIT_FAILURE
);
616 rc
= print_fdisk_menu(cxt
);
619 rc
= fdisk_verify_disklabel(cxt
);
622 rc
= print_partition_info(cxt
);
633 dump_firstsector(cxt
);
639 rc
= fdisk_reorder_partitions(cxt
);
642 rc
= fdisk_enable_details(cxt
, 0);
651 rc
= fdisk_ask_partnum(cxt
, &n
, FALSE
);
653 break; /* no partitions yet (or ENOMEM, ...) */
655 rc
= fdisk_delete_partition(cxt
, n
);
657 fdisk_warnx(cxt
, _("Could not delete partition %zu"), n
+ 1);
659 fdisk_info(cxt
, _("Partition %zu has been deleted."), n
+ 1);
668 list_partition_types(cxt
);
673 rc
= fdisk_add_partition(cxt
, NULL
, &partno
);
675 rc
= ask_for_wipe(cxt
, partno
);
679 change_partition_type(cxt
);
683 fdisk_use_cylinders(cxt
) ? "sectors" :
685 if (fdisk_use_cylinders(cxt
))
686 fdisk_info(cxt
, _("Changing display/entry units to cylinders (DEPRECATED!)."));
688 fdisk_info(cxt
, _("Changing display/entry units to sectors."));
691 fdisk_enable_details(cxt
, 1);
694 /* return from nested BSD to DOS or MBR to GPT */
695 if (fdisk_get_parent(cxt
)) {
696 *cxt0
= fdisk_get_parent(cxt
);
698 fdisk_info(cxt
, _("Leaving nested disklabel."));
699 fdisk_unref_context(cxt
);
709 * This is fdisk frontend for GPT specific libfdisk functions that
710 * are not exported by generic libfdisk API.
712 static int gpt_menu_cb(struct fdisk_context
**cxt0
,
713 const struct menu
*menu
__attribute__((__unused__
)),
714 const struct menu_entry
*ent
)
716 struct fdisk_context
*cxt
= *cxt0
;
717 struct fdisk_context
*mbr
;
718 struct fdisk_partition
*pa
= NULL
;
721 uintmax_t length
= 0;
725 assert(fdisk_is_label(cxt
, GPT
));
727 DBG(MENU
, ul_debug("enter GPT menu"));
732 return fdisk_set_disklabel_id(cxt
);
734 rc
= fdisk_ask_number(cxt
, 1, fdisk_get_npartitions(cxt
),
735 ~(uint32_t)0, _("New maximum entries"), &length
);
738 return fdisk_gpt_set_npartitions(cxt
, (uint32_t) length
);
740 mbr
= fdisk_new_nested_context(cxt
, "dos");
744 if (fdisk_is_details(cxt
))
745 fdisk_enable_details(cxt
, 1); /* keep us in expert mode */
746 fdisk_info(cxt
, _("Entering protective/hybrid MBR disklabel."));
750 /* actions where is necessary partnum */
751 rc
= fdisk_ask_partnum(cxt
, &n
, FALSE
);
757 pa
= fdisk_new_partition(); /* new template */
762 rc
= fdisk_ask_string(cxt
, _("New UUID (in 8-4-4-4-12 format)"), &str
);
764 rc
= fdisk_partition_set_uuid(pa
, str
);
766 rc
= fdisk_set_partition(cxt
, n
, pa
);
768 fdisk_unref_partition(pa
);
772 pa
= fdisk_new_partition(); /* new template */
777 rc
= fdisk_ask_string(cxt
, _("New name"), &str
);
779 rc
= fdisk_partition_set_name(pa
, str
);
781 rc
= fdisk_set_partition(cxt
, n
, pa
);
783 fdisk_unref_partition(pa
);
787 rc
= fdisk_toggle_partition_flag(cxt
, n
, GPT_FLAG_LEGACYBOOT
);
790 rc
= fdisk_toggle_partition_flag(cxt
, n
, GPT_FLAG_NOBLOCK
);
793 rc
= fdisk_toggle_partition_flag(cxt
, n
, GPT_FLAG_REQUIRED
);
796 rc
= fdisk_toggle_partition_flag(cxt
, n
, GPT_FLAG_GUIDSPECIFIC
);
806 * This is fdisk frontend for MBR specific libfdisk functions that
807 * are not exported by generic libfdisk API.
809 static int dos_menu_cb(struct fdisk_context
**cxt0
,
810 const struct menu
*menu
__attribute__((__unused__
)),
811 const struct menu_entry
*ent
)
813 struct fdisk_context
*cxt
= *cxt0
;
816 DBG(MENU
, ul_debug("enter DOS menu"));
823 rc
= fdisk_ask_partnum(cxt
, &n
, FALSE
);
825 rc
= fdisk_toggle_partition_flag(cxt
, n
, DOS_FLAG_ACTIVE
);
830 struct fdisk_context
*bsd
831 = fdisk_new_nested_context(cxt
, "bsd");
834 if (!fdisk_has_label(bsd
))
835 rc
= fdisk_create_disklabel(bsd
, "bsd");
837 fdisk_unref_context(bsd
);
840 fdisk_info(cxt
, _("Entering nested BSD disklabel."));
845 toggle_dos_compatibility_flag(cxt
);
856 rc
= fdisk_ask_partnum(cxt
, &n
, FALSE
);
858 rc
= fdisk_dos_move_begin(cxt
, n
);
862 rc
= fdisk_set_disklabel_id(cxt
);
865 /* return from nested MBR to GPT (backward compatibility only) */
866 if (fdisk_get_parent(cxt
)) {
867 *cxt0
= fdisk_get_parent(cxt
);
869 fdisk_info(cxt
, _("Leaving nested disklabel."));
870 fdisk_unref_context(cxt
);
874 rc
= fdisk_dos_fix_chs(cxt
);
876 fdisk_info(cxt
, _("C/H/S values fixed."));
878 fdisk_info(cxt
, _("Nothing to do. C/H/S values are correct already."));
884 static int sun_menu_cb(struct fdisk_context
**cxt0
,
885 const struct menu
*menu
__attribute__((__unused__
)),
886 const struct menu_entry
*ent
)
888 struct fdisk_context
*cxt
= *cxt0
;
891 DBG(MENU
, ul_debug("enter SUN menu"));
895 assert(fdisk_is_label(cxt
, SUN
));
897 DBG(MENU
, ul_debug("enter SUN menu"));
903 rc
= fdisk_ask_partnum(cxt
, &n
, FALSE
);
908 rc
= fdisk_toggle_partition_flag(cxt
, n
, SUN_FLAG_RONLY
);
911 rc
= fdisk_toggle_partition_flag(cxt
, n
, SUN_FLAG_UNMNT
);
920 rc
= fdisk_sun_set_alt_cyl(cxt
);
923 rc
= fdisk_sun_set_xcyl(cxt
);
926 rc
= fdisk_sun_set_ilfact(cxt
);
929 rc
= fdisk_sun_set_rspeed(cxt
);
932 rc
= fdisk_sun_set_pcylcount(cxt
);
938 static int sgi_menu_cb(struct fdisk_context
**cxt0
,
939 const struct menu
*menu
__attribute__((__unused__
)),
940 const struct menu_entry
*ent
)
942 struct fdisk_context
*cxt
= *cxt0
;
946 DBG(MENU
, ul_debug("enter SGI menu"));
950 assert(fdisk_is_label(cxt
, SGI
));
957 rc
= fdisk_ask_partnum(cxt
, &n
, FALSE
);
959 rc
= fdisk_toggle_partition_flag(cxt
, n
, SGI_FLAG_BOOT
);
962 fdisk_sgi_set_bootfile(cxt
);
965 rc
= fdisk_ask_partnum(cxt
, &n
, FALSE
);
967 rc
= fdisk_toggle_partition_flag(cxt
, n
, SGI_FLAG_SWAP
);
970 rc
= fdisk_sgi_create_info(cxt
);
978 * This is fdisk frontend for BSD specific libfdisk functions that
979 * are not exported by generic libfdisk API.
981 static int bsd_menu_cb(struct fdisk_context
**cxt0
,
982 const struct menu
*menu
__attribute__((__unused__
)),
983 const struct menu_entry
*ent
)
985 struct fdisk_context
*cxt
= *cxt0
;
990 assert(fdisk_is_label(cxt
, BSD
));
992 DBG(MENU
, ul_debug("enter BSD menu"));
996 rc
= fdisk_bsd_edit_disklabel(cxt
);
999 rc
= fdisk_bsd_write_bootstrap(cxt
);
1002 org
= fdisk_is_details(cxt
);
1004 fdisk_enable_details(cxt
, 1);
1005 list_disklabel(cxt
);
1006 fdisk_enable_details(cxt
, org
);
1009 rc
= fdisk_bsd_link_partition(cxt
);
1017 * The geometry setting from this dialog is not persistent and maybe reset by
1018 * fdisk_reset_device_properties() (for example when you create a new disk
1019 * label). Note that on command line specified -C/-H/-S setting is persistent
1020 * as it's based on fdisk_save_user_geometry().
1022 static int geo_menu_cb(struct fdisk_context
**cxt0
,
1023 const struct menu
*menu
__attribute__((__unused__
)),
1024 const struct menu_entry
*ent
)
1026 struct fdisk_context
*cxt
= *cxt0
;
1027 struct fdisk_label
*lb
= fdisk_get_label(cxt
, NULL
);
1029 uintmax_t c
= 0, h
= 0, s
= 0;
1030 fdisk_sector_t mi
, ma
;
1032 DBG(MENU
, ul_debug("enter GEO menu"));
1039 lb
= fdisk_get_label(cxt
, "dos");
1043 fdisk_label_get_geomrange_cylinders(lb
, &mi
, &ma
);
1044 rc
= fdisk_ask_number(cxt
, mi
, fdisk_get_geom_cylinders(cxt
),
1045 ma
, _("Number of cylinders"), &c
);
1050 fdisk_label_get_geomrange_heads(lb
, &i
, &a
);
1051 rc
= fdisk_ask_number(cxt
, i
, fdisk_get_geom_heads(cxt
),
1052 a
, _("Number of heads"), &h
);
1056 fdisk_label_get_geomrange_sectors(lb
, &mi
, &ma
);
1057 rc
= fdisk_ask_number(cxt
, mi
, fdisk_get_geom_sectors(cxt
),
1058 ma
, _("Number of sectors"), &s
);
1063 fdisk_override_geometry(cxt
, c
, h
, s
);
1067 static int createlabel_menu_cb(struct fdisk_context
**cxt0
,
1068 const struct menu
*menu
__attribute__((__unused__
)),
1069 const struct menu_entry
*ent
)
1071 struct fdisk_context
*cxt
= *cxt0
;
1072 const char *wanted
= NULL
;
1075 DBG(MENU
, ul_debug("enter Create label menu"));
1083 /* Deprecated, use 'G' in main menu, just for backward
1084 * compatibility only. */
1106 rc
= fdisk_create_disklabel(cxt
, wanted
);
1109 fdisk_warn(cxt
, _("Failed to create '%s' disk label"), wanted
);
1112 if (rc
== 0 && fdisk_get_collision(cxt
))
1113 follow_wipe_mode(cxt
);