2 * SPDX-License-Identifier: GPL-2.0-or-later
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * cfdisk.c - Display or manipulate a disk partition table.
11 * Copyright (C) 2014-2023 Karel Zak <kzak@redhat.com>
12 * Copyright (C) 1994 Kevin E. Martin (martin@cs.unc.edu)
14 * The original cfdisk was inspired by the fdisk program
15 * by A. V. Le Blanc (leblanc@mcc.ac.uk.
24 #include <libsmartcols.h>
25 #include <sys/ioctl.h>
30 # include <libmount.h> /* keep it optional for non-linux systems */
35 #elif defined(HAVE_SLANG_SLANG_H)
36 # include <slang/slang.h>
40 # define _XOPEN_SOURCE 500 /* for inclusion of get_wch */
43 #ifdef HAVE_SLCURSES_H
44 # include <slcurses.h>
45 #elif defined(HAVE_SLANG_SLCURSES_H)
46 # include <slang/slcurses.h>
47 #elif defined(HAVE_NCURSESW_NCURSES_H) && defined(HAVE_WIDECHAR)
48 # include <ncursesw/ncurses.h>
49 #elif defined(HAVE_NCURSES_H)
51 #elif defined(HAVE_NCURSES_NCURSES_H)
52 # include <ncurses/ncurses.h>
61 #include "closestream.h"
72 static const char *default_disks
[] = {
76 #elif defined(__FreeBSD__)
86 #define ARROW_CURSOR_STRING ">> "
87 #define ARROW_CURSOR_DUMMY " "
88 #define ARROW_CURSOR_WIDTH (sizeof(ARROW_CURSOR_STRING) - 1)
91 #define MENU_V_SPADDING 1 /* space around menu item string */
94 #define MENU_H_SPADDING 0 /* space around menu item string */
95 #define MENU_H_BETWEEN 2 /* space between menu items */
96 #define MENU_H_PRESTR "["
97 #define MENU_H_POSTSTR "]"
99 #define MENU_TITLE_PADDING 3
101 #define MENU_H_PRESTR_SZ (sizeof(MENU_H_PRESTR) - 1)
102 #define MENU_H_POSTSTR_SZ (sizeof(MENU_H_POSTSTR) - 1)
104 #define TABLE_START_LINE 4
105 #define MENU_START_LINE (ui_lines - 4) /* The menu maybe use two lines */
106 #define INFO_LINE (ui_lines - 2)
107 #define WARN_LINE INFO_LINE
108 #define HINT_LINE (ui_lines - 1)
110 #define CFDISK_ERR_ESC 5000
113 # define KEY_ESC '\033'
116 # define KEY_DELETE '\177'
130 #ifdef HAVE_USE_DEFAULT_COLORS
131 static const int color_pairs
[][2] = {
132 /* color foreground, background */
133 [CFDISK_CL_WARNING
] = { COLOR_RED
, -1 },
134 [CFDISK_CL_FREESPACE
] = { COLOR_GREEN
, -1 },
135 [CFDISK_CL_INFO
] = { COLOR_BLUE
, -1 }
141 static struct cfdisk_menuitem
*menu_get_menuitem(struct cfdisk
*cf
, size_t idx
);
142 static struct cfdisk_menuitem
*menu_get_menuitem_by_key(struct cfdisk
*cf
, int key
, size_t *idx
);
143 static struct cfdisk_menu
*menu_push(struct cfdisk
*cf
, struct cfdisk_menuitem
*item
);
144 static struct cfdisk_menu
*menu_pop(struct cfdisk
*cf
);
145 static void menu_refresh_size(struct cfdisk
*cf
);
147 static int ui_end(void);
148 static int ui_refresh(struct cfdisk
*cf
);
150 static void ui_warnx(const char *fmt
, ...)
151 __attribute__((__format__ (__printf__
, 1, 2)));
152 static void ui_warn(const char *fmt
, ...)
153 __attribute__((__format__ (__printf__
, 1, 2)));
154 static void ui_info(const char *fmt
, ...)
155 __attribute__((__format__ (__printf__
, 1, 2)));
157 static void ui_draw_menu(struct cfdisk
*cf
);
158 static int ui_menu_move(struct cfdisk
*cf
, int key
);
159 static void ui_menu_resize(struct cfdisk
*cf
);
161 static int ui_get_size(struct cfdisk
*cf
, const char *prompt
, uint64_t *res
,
162 uint64_t low
, uint64_t up
, int *expsize
);
164 static int ui_enabled
;
165 static volatile sig_atomic_t sig_resize
;
166 static volatile sig_atomic_t sig_die
;
168 /* ncurses LINES and COLS may be actual variables or *macros*, but we need
169 * something portable and writable */
170 static size_t ui_lines
;
171 static size_t ui_cols
;
174 struct cfdisk_menuitem
{
175 int key
; /* keyboard shortcut */
176 const char *name
; /* item name */
177 const char *desc
; /* item description (hint) */
183 char *title
; /* optional menu title */
184 struct cfdisk_menuitem
*items
; /* array with menu items */
185 char *ignore
;/* string with keys to ignore */
186 size_t width
; /* maximal width of the menu item */
187 size_t nitems
; /* number of the active menu items */
188 size_t page_sz
;/* when menu longer than screen */
189 size_t idx
; /* the current menu item */
190 int prefkey
;/* preferred menu item */
191 struct cfdisk_menu
*prev
;
193 /* @ignore keys generator */
194 int (*ignore_cb
) (struct cfdisk
*, char *, size_t);
196 unsigned int vertical
: 1; /* enable vertical mode */
200 static struct cfdisk_menuitem main_menuitems
[] = {
201 { 'b', N_("Bootable"), N_("Toggle bootable flag of the current partition") },
202 { 'd', N_("Delete"), N_("Delete the current partition") },
203 { 'r', N_("Resize"), N_("Reduce or enlarge the current partition") },
204 { 'n', N_("New"), N_("Create new partition from free space") },
205 { 'q', N_("Quit"), N_("Quit program without writing changes") },
206 { 't', N_("Type"), N_("Change the partition type") },
207 { 'h', N_("Help"), N_("Print help screen") },
208 { 's', N_("Sort"), N_("Fix partitions order") },
209 { 'W', N_("Write"), N_("Write partition table to disk (this might destroy data)") },
210 { 'u', N_("Dump"), N_("Dump partition table to sfdisk compatible script file") },
214 /* extra partinfo in name:value pairs */
215 struct cfdisk_extra
{
219 struct list_head exs
;
222 /* line and extra partinfo list_head */
224 char *data
; /* line data */
225 struct libscols_table
*extra
; /* extra info ('X') */
226 WINDOW
*w
; /* window with extra info */
229 /* top level control struct */
231 struct fdisk_context
*cxt
; /* libfdisk context */
232 struct fdisk_table
*table
; /* partition table */
233 struct fdisk_table
*original_layout
; /* original on-disk PT */
235 struct cfdisk_menu
*menu
; /* the current menu */
237 int *fields
; /* output columns IDs */
238 size_t nfields
; /* number of columns IDs */
240 char *linesbuf
; /* table as string */
241 size_t linesbufsz
; /* size of the tb_buf */
243 struct cfdisk_line
*lines
; /* list of lines */
245 size_t nlines
; /* number of lines */
246 size_t lines_idx
; /* current line <0..N>, exclude header */
249 unsigned int nwrites
; /* fdisk_write_disklabel() counter */
251 WINDOW
*act_win
; /* the window currently on the screen */
254 struct libmnt_table
*mtab
;
255 struct libmnt_table
*fstab
;
256 struct libmnt_cache
*mntcache
;
258 unsigned int wrong_order
:1, /* PT not in right order */
259 zero_start
:1, /* ignore existing partition table */
260 device_is_used
: 1, /* don't use re-read ioctl */
261 show_extra
:1; /* show extra partinfo */
266 * let's use include/debug.h stuff for cfdisk too
268 static UL_DEBUG_DEFINE_MASK(cfdisk
);
269 UL_DEBUG_DEFINE_MASKNAMES(cfdisk
) = UL_DEBUG_EMPTY_MASKNAMES
;
271 #define CFDISK_DEBUG_INIT (1 << 1)
272 #define CFDISK_DEBUG_UI (1 << 2)
273 #define CFDISK_DEBUG_MENU (1 << 3)
274 #define CFDISK_DEBUG_MISC (1 << 4)
275 #define CFDISK_DEBUG_TABLE (1 << 5)
276 #define CFDISK_DEBUG_ALL 0xFFFF
278 #define DBG(m, x) __UL_DBG(cfdisk, CFDISK_DEBUG_, m, x)
280 static void cfdisk_init_debug(void)
282 __UL_INIT_DEBUG_FROM_ENV(cfdisk
, CFDISK_DEBUG_
, 0, CFDISK_DEBUG
);
285 /* Initialize output columns -- we follow libfdisk fields (usually specific
288 static int cols_init(struct cfdisk
*cf
)
296 return fdisk_label_get_fields_ids(NULL
, cf
->cxt
, &cf
->fields
, &cf
->nfields
);
299 static void die_on_signal(void)
301 DBG(MISC
, ul_debug("die on signal."));
306 static void resize(void)
310 if (ioctl(fileno(stdout
), TIOCGWINSZ
, &ws
) != -1
311 && ws
.ws_row
&& ws
.ws_col
) {
312 ui_lines
= ws
.ws_row
;
315 resizeterm(ws
.ws_row
, ws
.ws_col
);
317 clearok(stdscr
, TRUE
);
321 DBG(UI
, ul_debug("ui: resize refresh ui_cols=%zu, ui_lines=%zu",
326 /* Reads partition in tree-like order from scols
328 static int partition_from_scols(struct fdisk_table
*tb
,
329 struct libscols_line
*ln
)
331 struct fdisk_partition
*pa
= scols_line_get_userdata(ln
);
333 fdisk_table_add_partition(tb
, pa
);
334 fdisk_unref_partition(pa
);
336 if (scols_line_has_children(ln
)) {
337 struct libscols_line
*chln
;
338 struct libscols_iter
*itr
= scols_new_iter(SCOLS_ITER_FORWARD
);
342 while (scols_line_next_child(ln
, itr
, &chln
) == 0)
343 partition_from_scols(tb
, chln
);
344 scols_free_iter(itr
);
349 static char *table_to_string(struct cfdisk
*cf
, struct fdisk_table
*tb
)
351 struct fdisk_partition
*pa
;
352 struct fdisk_label
*lb
;
353 struct fdisk_iter
*itr
;
354 struct libscols_table
*table
= NULL
;
355 struct libscols_iter
*s_itr
= NULL
;
359 struct libscols_line
*ln
, *ln_cont
= NULL
;
361 DBG(TABLE
, ul_debug("convert to string"));
368 lb
= fdisk_get_label(cf
->cxt
, NULL
);
371 itr
= fdisk_new_iter(FDISK_ITER_FORWARD
);
375 /* get container (e.g. extended partition) */
376 while (fdisk_table_next_partition(tb
, itr
, &pa
) == 0) {
377 if (fdisk_partition_is_nested(pa
)) {
378 DBG(TABLE
, ul_debug("nested detected, using tree"));
379 tree
= SCOLS_FL_TREE
;
384 table
= scols_new_table();
387 scols_table_enable_maxout(table
, 1);
388 scols_table_enable_nowrap(table
, 1);
390 #if !defined(HAVE_LIBNCURSESW) || !defined(HAVE_WIDECHAR)
391 scols_table_enable_ascii(table
, 1);
395 for (i
= 0; i
< cf
->nfields
; i
++) {
397 const struct fdisk_field
*field
=
398 fdisk_label_get_field(lb
, cf
->fields
[i
]);
402 if (fdisk_field_is_number(field
))
403 fl
|= SCOLS_FL_RIGHT
;
404 if (fdisk_field_get_id(field
) == FDISK_FIELD_TYPE
)
405 fl
|= SCOLS_FL_TRUNC
;
406 if (tree
&& fdisk_field_get_id(field
) == FDISK_FIELD_DEVICE
)
409 if (!scols_table_new_column(table
,
410 _(fdisk_field_get_name(field
)),
411 fdisk_field_get_width(field
), fl
))
416 fdisk_reset_iter(itr
, FDISK_ITER_FORWARD
);
418 while (fdisk_table_next_partition(tb
, itr
, &pa
) == 0) {
419 struct libscols_line
*parent
= fdisk_partition_is_nested(pa
) ? ln_cont
: NULL
;
421 ln
= scols_table_new_line(table
, parent
);
424 for (i
= 0; i
< cf
->nfields
; i
++) {
427 if (fdisk_partition_to_string(pa
, cf
->cxt
,
428 cf
->fields
[i
], &cdata
))
430 scols_line_refer_data(ln
, i
, cdata
);
432 if (tree
&& fdisk_partition_is_container(pa
))
435 scols_line_set_userdata(ln
, (void *) pa
);
436 fdisk_ref_partition(pa
);
439 if (scols_table_is_empty(table
))
442 scols_table_reduce_termwidth(table
, ARROW_CURSOR_WIDTH
);
443 scols_print_table_to_string(table
, &res
);
445 /* scols_* code might reorder lines, let's reorder @tb according to the
446 * final output (it's no problem because partitions are addressed by
447 * parno stored within struct fdisk_partition) */
450 fdisk_reset_table(tb
);
452 s_itr
= scols_new_iter(SCOLS_ITER_FORWARD
);
456 /* add all in the right order (don't forget the output is tree) */
457 while (scols_table_next_line(table
, s_itr
, &ln
) == 0) {
458 if (scols_line_get_parent(ln
))
460 if (partition_from_scols(tb
, ln
))
464 scols_unref_table(table
);
465 scols_free_iter(s_itr
);
466 fdisk_free_iter(itr
);
471 static void cfdisk_free_lines(struct cfdisk
*cf
)
474 while(i
< cf
->nlines
) {
475 scols_unref_table(cf
->lines
[i
].extra
);
477 DBG(UI
, ul_debug("delete window: %p",
481 delwin(cf
->lines
[i
].w
);
482 cf
->lines
[i
].w
= NULL
;
490 * Read data about partitions from libfdisk and prepare output lines.
492 static int lines_refresh(struct cfdisk
*cf
)
500 DBG(TABLE
, ul_debug("refreshing buffer"));
503 cfdisk_free_lines(cf
);
509 fdisk_unref_table(cf
->table
);
512 /* read partitions and free spaces into cf->table */
513 rc
= fdisk_get_partitions(cf
->cxt
, &cf
->table
);
515 rc
= fdisk_get_freespaces(cf
->cxt
, &cf
->table
);
519 cf
->linesbuf
= table_to_string(cf
, cf
->table
);
523 cf
->linesbufsz
= strlen(cf
->linesbuf
);
524 cf
->nlines
= fdisk_table_get_nents(cf
->table
) + 1; /* 1 for header line */
526 cf
->wrong_order
= fdisk_table_wrong_order(cf
->table
) ? 1 : 0;
528 if (MENU_START_LINE
- TABLE_START_LINE
< cf
->nlines
)
529 cf
->page_sz
= MENU_START_LINE
- TABLE_START_LINE
- 1;
531 cf
->lines
= xcalloc(cf
->nlines
, sizeof(struct cfdisk_line
));
533 for (p
= cf
->linesbuf
, i
= 0; p
&& i
< cf
->nlines
; i
++) {
534 cf
->lines
[i
].data
= p
;
540 cf
->lines
[i
].extra
= scols_new_table();
541 scols_table_enable_noheadings(cf
->lines
[i
].extra
, 1);
542 scols_table_new_column(cf
->lines
[i
].extra
, NULL
, 0, SCOLS_FL_RIGHT
);
543 scols_table_new_column(cf
->lines
[i
].extra
, NULL
, 0, SCOLS_FL_TRUNC
);
549 static struct fdisk_partition
*get_current_partition(struct cfdisk
*cf
)
554 return fdisk_table_get_partition(cf
->table
, cf
->lines_idx
);
557 static int is_freespace(struct cfdisk
*cf
, size_t i
)
559 struct fdisk_partition
*pa
;
564 pa
= fdisk_table_get_partition(cf
->table
, i
);
565 return fdisk_partition_is_freespace(pa
);
568 /* converts libfdisk FDISK_ASKTYPE_MENU to cfdisk menu and returns user's
569 * response back to libfdisk
571 static int ask_menu(struct fdisk_ask
*ask
, struct cfdisk
*cf
)
573 struct cfdisk_menuitem
*d
, *cm
;
575 size_t i
= 0, nitems
;
576 const char *name
, *desc
;
581 /* create cfdisk menu according to libfdisk ask-menu, note that the
582 * last cm[] item has to be empty -- so nitems + 1 */
583 nitems
= fdisk_ask_menu_get_nitems(ask
);
584 cm
= xcalloc(nitems
+ 1, sizeof(struct cfdisk_menuitem
));
586 for (i
= 0; i
< nitems
; i
++) {
587 if (fdisk_ask_menu_get_item(ask
, i
, &key
, &name
, &desc
))
594 /* make the new menu active */
607 if (ui_menu_move(cf
, key
) == 0)
614 d
= menu_get_menuitem(cf
, cf
->menu
->idx
);
616 fdisk_ask_menu_set_result(ask
, d
->key
);
633 static int ask_callback(struct fdisk_context
*cxt
__attribute__((__unused__
)),
634 struct fdisk_ask
*ask
,
635 void *data
__attribute__((__unused__
)))
641 switch(fdisk_ask_get_type(ask
)) {
642 case FDISK_ASKTYPE_INFO
:
643 ui_info("%s", fdisk_ask_print_get_mesg(ask
));
645 case FDISK_ASKTYPE_WARNX
:
646 ui_warnx("%s", fdisk_ask_print_get_mesg(ask
));
648 case FDISK_ASKTYPE_WARN
:
649 ui_warn("%s", fdisk_ask_print_get_mesg(ask
));
651 case FDISK_ASKTYPE_MENU
:
652 ask_menu(ask
, (struct cfdisk
*) data
);
655 ui_warnx(_("internal error: unsupported dialog type %d"),
656 fdisk_ask_get_type(ask
));
662 static int ui_end(void)
667 #if defined(HAVE_SLCURSES_H) || defined(HAVE_SLANG_SLCURSES_H)
668 SLsmg_gotorc(ui_lines
- 1, 0);
671 mvcur(0, ui_cols
- 1, ui_lines
-1, 0);
681 static void __attribute__((__format__ (__printf__
, 3, 0)))
682 ui_vprint_center(size_t line
, int attrs
, const char *fmt
, va_list ap
)
690 xvasprintf(&buf
, fmt
, ap
);
692 width
= mbs_safe_width(buf
);
693 if (width
> (size_t) ui_cols
) {
694 char *p
= strrchr(buf
+ ui_cols
, ' ');
698 if (line
+ 1 >= ui_lines
)
701 mvaddstr(line
, 0, buf
);
702 mvaddstr(line
+ 1, 0, p
+1);
706 mvaddstr(line
, (ui_cols
- width
) / 2, buf
);
712 static void __attribute__((__format__ (__printf__
, 2, 3)))
713 ui_center(size_t line
, const char *fmt
, ...)
717 ui_vprint_center(line
, 0, fmt
, ap
);
721 static void __attribute__((__format__ (__printf__
, 1, 2)))
722 ui_warnx(const char *fmt
, ...)
727 ui_vprint_center(WARN_LINE
,
728 colors_wanted() ? COLOR_PAIR(CFDISK_CL_WARNING
) : 0,
731 vfprintf(stderr
, fmt
, ap
);
737 static void __attribute__((__format__ (__printf__
, 1, 2)))
738 ui_warn(const char *fmt
, ...)
743 xasprintf(&fmt_m
, "%s: %m", fmt
);
747 ui_vprint_center(WARN_LINE
,
748 colors_wanted() ? COLOR_PAIR(CFDISK_CL_WARNING
) : 0,
751 vfprintf(stderr
, fmt_m
, ap
);
758 static void ui_clean_warn(void)
764 static int __attribute__((__noreturn__
))
765 __attribute__((__format__ (__printf__
, 2, 3)))
766 ui_err(int rc
, const char *fmt
, ...)
772 fprintf(stderr
, "%s: ", program_invocation_short_name
);
773 vfprintf(stderr
, fmt
, ap
);
774 fprintf(stderr
, ": %s\n", strerror(errno
));
780 static int __attribute__((__noreturn__
))
781 __attribute__((__format__ (__printf__
, 2, 3)))
782 ui_errx(int rc
, const char *fmt
, ...)
788 fprintf(stderr
, "%s: ", program_invocation_short_name
);
789 vfprintf(stderr
, fmt
, ap
);
796 static void __attribute__((__format__ (__printf__
, 1, 2)))
797 ui_info(const char *fmt
, ...)
802 ui_vprint_center(INFO_LINE
,
803 colors_wanted() ? COLOR_PAIR(CFDISK_CL_INFO
) : 0,
806 vfprintf(stdout
, fmt
, ap
);
812 static void ui_clean_info(void)
818 static void __attribute__((__format__ (__printf__
, 1, 2)))
819 ui_hint(const char *fmt
, ...)
824 ui_vprint_center(HINT_LINE
, A_BOLD
, fmt
, ap
);
826 vfprintf(stdout
, fmt
, ap
);
832 static void ui_clean_hint(void)
839 static void sig_handler_die(int dummy
__attribute__((__unused__
)))
844 static void sig_handler_resize(int dummy
__attribute__((__unused__
)))
849 static void menu_refresh_size(struct cfdisk
*cf
)
851 if (cf
->menu
&& cf
->menu
->nitems
)
852 cf
->menu
->page_sz
= (cf
->menu
->nitems
/ (ui_lines
- 4)) ? ui_lines
- 4 : 0;
855 static void menu_update_ignore(struct cfdisk
*cf
)
857 char ignore
[128] = { 0 };
859 struct cfdisk_menu
*m
;
860 struct cfdisk_menuitem
*d
, *org
= NULL
;
865 assert(cf
->menu
->ignore_cb
);
868 DBG(MENU
, ul_debug("update menu ignored keys"));
870 i
= m
->ignore_cb(cf
, ignore
, sizeof(ignore
));
873 /* return if no change */
874 if ((!m
->ignore
&& !*ignore
)
875 || (m
->ignore
&& *ignore
&& strcmp(m
->ignore
, ignore
) == 0)) {
880 org
= menu_get_menuitem(cf
, m
->idx
);
883 m
->ignore
= xstrdup(ignore
);
886 for (d
= m
->items
; d
->name
; d
++) {
887 if (m
->ignore
&& strchr(m
->ignore
, d
->key
))
892 DBG(MENU
, ul_debug("update menu preferred keys"));
894 /* refresh menu index to be at the same menuitem or go to the first */
895 if (org
&& menu_get_menuitem_by_key(cf
, org
->key
, &idx
))
897 else if (m
->prefkey
&& menu_get_menuitem_by_key(cf
, m
->prefkey
, &idx
))
902 menu_refresh_size(cf
);
905 static struct cfdisk_menu
*menu_push(
907 struct cfdisk_menuitem
*items
)
909 struct cfdisk_menu
*m
= xcalloc(1, sizeof(*m
));
910 struct cfdisk_menuitem
*d
;
914 DBG(MENU
, ul_debug("new menu"));
919 for (d
= m
->items
; d
->name
; d
++) {
920 const char *name
= _(d
->name
);
921 size_t len
= mbs_safe_width(name
);
929 menu_refresh_size(cf
);
933 static struct cfdisk_menu
*menu_pop(struct cfdisk
*cf
)
935 struct cfdisk_menu
*m
= NULL
;
939 DBG(MENU
, ul_debug("pop menu"));
943 free(cf
->menu
->ignore
);
944 free(cf
->menu
->title
);
951 static void menu_set_title(struct cfdisk_menu
*m
, const char *title
)
956 size_t len
= mbs_safe_width(title
);
957 if (len
+ MENU_TITLE_PADDING
> m
->width
)
958 m
->width
= len
+ MENU_TITLE_PADDING
;
959 str
= xstrdup(title
);
965 static int ui_init(struct cfdisk
*cf
__attribute__((__unused__
)))
969 DBG(UI
, ul_debug("init"));
971 /* setup SIGCHLD handler */
972 sigemptyset(&sa
.sa_mask
);
974 sa
.sa_handler
= sig_handler_die
;
975 sigaction(SIGINT
, &sa
, NULL
);
976 sigaction(SIGTERM
, &sa
, NULL
);
978 sa
.sa_handler
= sig_handler_resize
;
979 sigaction(SIGWINCH
, &sa
, NULL
);
984 #ifdef HAVE_USE_DEFAULT_COLORS
985 if (colors_wanted() && has_colors()) {
989 use_default_colors();
990 for (i
= 1; i
< ARRAY_SIZE(color_pairs
); i
++) /* yeah, start from 1! */
991 init_pair(i
, color_pairs
[i
][0], color_pairs
[i
][1]);
1001 keypad(stdscr
, TRUE
);
1007 #define MENU_H_ITEMWIDTH(m) ( MENU_H_PRESTR_SZ \
1011 + MENU_H_POSTSTR_SZ)
1013 #define MENU_V_ITEMWIDTH(m) (MENU_V_SPADDING + (m)->width + MENU_V_SPADDING)
1016 static size_t menuitem_get_line(struct cfdisk
*cf
, size_t idx
)
1018 struct cfdisk_menu
*m
= cf
->menu
;
1021 if (!m
->page_sz
) /* small menu */
1022 return (ui_lines
- (cf
->menu
->nitems
+ 1)) / 2 + idx
;
1023 return (idx
% m
->page_sz
) + 1;
1027 size_t len
= MENU_H_ITEMWIDTH(m
) + MENU_H_BETWEEN
; /** item width */
1028 size_t items
= ui_cols
/ len
; /* items per line */
1032 return MENU_START_LINE
+ ((idx
/ items
));
1036 static int menuitem_get_column(struct cfdisk
*cf
, size_t idx
)
1038 if (cf
->menu
->vertical
) {
1039 size_t nc
= MENU_V_ITEMWIDTH(cf
->menu
);
1040 if ((size_t) ui_cols
<= nc
)
1042 return (ui_cols
- nc
) / 2;
1046 size_t len
= MENU_H_ITEMWIDTH(cf
->menu
) + MENU_H_BETWEEN
; /* item width */
1047 size_t items
= ui_cols
/ len
; /* items per line */
1048 size_t extra
= items
< cf
->menu
->nitems
? /* extra space on line */
1049 ui_cols
% len
: /* - multi-line menu */
1050 ui_cols
- (cf
->menu
->nitems
* len
); /* - one line menu */
1053 return 0; /* hmm... no space */
1055 extra
+= MENU_H_BETWEEN
; /* add padding after last item to extra */
1058 return (idx
* len
) + (extra
/ 2);
1059 return ((idx
% items
) * len
) + (extra
/ 2);
1063 static int menuitem_on_page(struct cfdisk
*cf
, size_t idx
)
1065 struct cfdisk_menu
*m
= cf
->menu
;
1067 if (m
->page_sz
== 0 ||
1068 m
->idx
/ m
->page_sz
== idx
/ m
->page_sz
)
1073 static struct cfdisk_menuitem
*menu_get_menuitem(struct cfdisk
*cf
, size_t idx
)
1075 struct cfdisk_menuitem
*d
;
1078 for (i
= 0, d
= cf
->menu
->items
; d
->name
; d
++) {
1079 if (cf
->menu
->ignore
&& strchr(cf
->menu
->ignore
, d
->key
))
1088 static struct cfdisk_menuitem
*menu_get_menuitem_by_key(struct cfdisk
*cf
,
1089 int key
, size_t *idx
)
1091 struct cfdisk_menuitem
*d
;
1093 for (*idx
= 0, d
= cf
->menu
->items
; d
->name
; d
++) {
1094 if (cf
->menu
->ignore
&& strchr(cf
->menu
->ignore
, d
->key
))
1104 static void ui_draw_menuitem(struct cfdisk
*cf
,
1105 struct cfdisk_menuitem
*d
,
1111 const size_t buf_sz
= 80 * MB_CUR_MAX
;
1112 int ln
, cl
, vert
= cf
->menu
->vertical
;
1114 if (!menuitem_on_page(cf
, idx
))
1115 return; /* no visible item */
1116 ln
= menuitem_get_line(cf
, idx
);
1117 cl
= menuitem_get_column(cf
, idx
);
1119 ptr
= buf
= xmalloc(buf_sz
);
1122 width
= cf
->menu
->width
+ MENU_V_SPADDING
;
1123 memset(ptr
, ' ', MENU_V_SPADDING
);
1124 ptr
+= MENU_V_SPADDING
;
1126 width
= MENU_H_SPADDING
+ cf
->menu
->width
+ MENU_H_SPADDING
;
1129 mbsalign(name
, ptr
, buf_sz
, &width
,
1130 vert
? MBS_ALIGN_LEFT
: MBS_ALIGN_CENTER
,
1133 DBG(MENU
, ul_debug("menuitem: cl=%d, ln=%d, item='%s'",
1137 mvaddch(ln
, cl
- 1, ACS_VLINE
);
1138 mvaddch(ln
, cl
+ MENU_V_ITEMWIDTH(cf
->menu
), ACS_VLINE
);
1141 if (cf
->menu
->idx
== idx
)
1145 mvprintw(ln
, cl
, "%s", buf
);
1147 mvprintw(ln
, cl
, "%s%s%s", MENU_H_PRESTR
, buf
, MENU_H_POSTSTR
);
1150 if (cf
->menu
->idx
== idx
) {
1153 ui_hint("%s", _(d
->desc
));
1157 static void ui_clean_menu(struct cfdisk
*cf
)
1161 struct cfdisk_menu
*m
= cf
->menu
;
1162 size_t ln
= menuitem_get_line(cf
, 0);
1165 lastline
= ln
+ (m
->page_sz
? m
->page_sz
: m
->nitems
);
1167 lastline
= menuitem_get_line(cf
, m
->nitems
);
1169 for (i
= ln
; i
<= lastline
; i
++) {
1172 DBG(MENU
, ul_debug("clean_menu: line %zu", i
));
1181 static void ui_draw_menu(struct cfdisk
*cf
)
1183 struct cfdisk_menuitem
*d
;
1184 struct cfdisk_menu
*m
;
1186 size_t ln
= menuitem_get_line(cf
, 0);
1192 DBG(MENU
, ul_debug("draw start"));
1198 nlines
= m
->page_sz
? m
->page_sz
: m
->nitems
;
1200 nlines
= menuitem_get_line(cf
, m
->nitems
);
1203 menu_update_ignore(cf
);
1205 while ((d
= menu_get_menuitem(cf
, i
)))
1206 ui_draw_menuitem(cf
, d
, i
++);
1209 size_t cl
= menuitem_get_column(cf
, 0);
1210 size_t curpg
= m
->page_sz
? m
->idx
/ m
->page_sz
: 0;
1212 /* corners and horizontal lines */
1213 mvaddch(ln
- 1, cl
- 1, ACS_ULCORNER
);
1214 mvaddch(ln
+ nlines
, cl
- 1, ACS_LLCORNER
);
1216 for (i
= 0; i
< MENU_V_ITEMWIDTH(m
); i
++) {
1217 mvaddch(ln
- 1, cl
+ i
, ACS_HLINE
);
1218 mvaddch(ln
+ nlines
, cl
+ i
, ACS_HLINE
);
1221 mvaddch(ln
- 1, cl
+ i
, ACS_URCORNER
);
1222 mvaddch(ln
+ nlines
, cl
+ i
, ACS_LRCORNER
);
1224 /* draw also lines around empty lines on last page */
1226 m
->nitems
/ m
->page_sz
== m
->idx
/ m
->page_sz
) {
1227 for (i
= m
->nitems
% m
->page_sz
+ 1; i
<= m
->page_sz
; i
++) {
1228 mvaddch(i
, cl
- 1, ACS_VLINE
);
1229 mvaddch(i
, cl
+ MENU_V_ITEMWIDTH(m
), ACS_VLINE
);
1234 mvprintw(ln
- 1, cl
, " %s ", m
->title
);
1238 mvaddch(ln
- 1, cl
+ MENU_V_ITEMWIDTH(m
) - 2, ACS_UARROW
);
1239 if (m
->page_sz
&& curpg
< m
->nitems
/ m
->page_sz
)
1240 mvaddch(ln
+ nlines
, cl
+ MENU_V_ITEMWIDTH(m
) - 2, ACS_DARROW
);
1243 DBG(MENU
, ul_debug("draw end."));
1246 inline static int extra_insert_pair(struct cfdisk_line
*l
, const char *name
, const char *data
)
1248 struct libscols_line
*lsl
;
1254 if (!data
|| !*data
)
1257 lsl
= scols_table_new_line(l
->extra
, NULL
);
1261 rc
= scols_line_set_data(lsl
, 0, name
);
1263 rc
= scols_line_set_data(lsl
, 1, data
);
1268 #ifndef HAVE_LIBMOUNT
1269 static char *get_mountpoint( struct cfdisk
*cf
__attribute__((unused
)),
1270 const char *tagname
__attribute__((unused
)),
1271 const char *tagdata
__attribute__((unused
)))
1276 static char *get_mountpoint(struct cfdisk
*cf
, const char *tagname
, const char *tagdata
)
1278 struct libmnt_fs
*fs
= NULL
;
1279 char *target
= NULL
;
1285 DBG(UI
, ul_debug("asking for mountpoint [%s=%s]", tagname
, tagdata
));
1288 cf
->mntcache
= mnt_new_cache();
1290 /* 1st try between mounted filesystems */
1292 cf
->mtab
= mnt_new_table();
1294 mnt_table_set_cache(cf
->mtab
, cf
->mntcache
);
1295 mnt_table_parse_mtab(cf
->mtab
, NULL
);
1300 fs
= mnt_table_find_tag(cf
->mtab
, tagname
, tagdata
, MNT_ITER_FORWARD
);
1305 cf
->fstab
= mnt_new_table();
1307 mnt_table_set_cache(cf
->fstab
, cf
->mntcache
);
1308 if (mnt_table_parse_fstab(cf
->fstab
, NULL
) != 0) {
1309 mnt_unref_table(cf
->fstab
);
1315 fs
= mnt_table_find_tag(cf
->fstab
, tagname
, tagdata
, MNT_ITER_FORWARD
);
1321 xasprintf(&target
, _("%s (mounted)"), mnt_fs_get_target(fs
));
1323 target
= xstrdup(mnt_fs_get_target(fs
));
1328 #endif /* HAVE_LIBMOUNT */
1330 static inline int iszero(const char *str
)
1334 for (p
= str
; p
&& *p
== '0'; p
++);
1336 return !p
|| *p
== '\0';
1339 static int has_uuid(struct fdisk_table
*tb
, const char *uuid
)
1341 struct fdisk_partition
*pa
;
1342 struct fdisk_iter
*itr
;
1345 if (!tb
|| !uuid
|| fdisk_table_is_empty(tb
))
1348 itr
= fdisk_new_iter(FDISK_ITER_FORWARD
);
1349 while (rc
== 0 && fdisk_table_next_partition(tb
, itr
, &pa
) == 0) {
1350 const char *x
= fdisk_partition_get_uuid(pa
);
1352 rc
= strcmp(x
, uuid
) == 0;
1354 fdisk_free_iter(itr
);
1358 static void extra_prepare_data(struct cfdisk
*cf
)
1360 struct fdisk_partition
*pa
= get_current_partition(cf
);
1361 struct cfdisk_line
*l
= &cf
->lines
[cf
->lines_idx
];
1363 char *mountpoint
= NULL
;
1365 DBG(UI
, ul_debug("preparing extra data"));
1367 /* string data should not equal an empty string */
1368 if (!fdisk_partition_to_string(pa
, cf
->cxt
, FDISK_FIELD_NAME
, &data
) && data
) {
1369 extra_insert_pair(l
, _("Partition name:"), data
);
1371 mountpoint
= get_mountpoint(cf
, "PARTLABEL", data
);
1375 if (!fdisk_partition_to_string(pa
, cf
->cxt
, FDISK_FIELD_UUID
, &data
) && data
) {
1376 extra_insert_pair(l
, _("Partition UUID:"), data
);
1378 /* Search for mountpoint by PARTUUID= means that we need to
1379 * check fstab and convert PARTUUID to the device name. This is
1380 * unnecessary and overkill for newly created partitions. Let's
1381 * check if the UUID already exist in the old layout, otherwise
1384 if (!mountpoint
&& has_uuid(cf
->original_layout
, data
))
1385 mountpoint
= get_mountpoint(cf
, "PARTUUID", data
);
1389 if (!fdisk_partition_to_string(pa
, cf
->cxt
, FDISK_FIELD_TYPE
, &data
) && data
) {
1390 char *code
= NULL
, *type
= NULL
;
1392 fdisk_partition_to_string(pa
, cf
->cxt
, FDISK_FIELD_TYPEID
, &code
);
1393 xasprintf(&type
, "%s (%s)", data
, code
);
1395 extra_insert_pair(l
, _("Partition type:"), type
);
1401 if (!fdisk_partition_to_string(pa
, cf
->cxt
, FDISK_FIELD_ATTR
, &data
) && data
) {
1402 extra_insert_pair(l
, _("Attributes:"), data
);
1406 /* for numeric data, only show non-zero rows */
1407 if (!fdisk_partition_to_string(pa
, cf
->cxt
, FDISK_FIELD_BSIZE
, &data
) && data
) {
1409 extra_insert_pair(l
, "BSIZE:", data
);
1413 if (!fdisk_partition_to_string(pa
, cf
->cxt
, FDISK_FIELD_CPG
, &data
) && data
) {
1415 extra_insert_pair(l
, "CPG:", data
);
1419 if (!fdisk_partition_to_string(pa
, cf
->cxt
, FDISK_FIELD_FSIZE
, &data
) && data
) {
1421 extra_insert_pair(l
, "FSIZE:", data
);
1425 if (!fdisk_partition_to_string(pa
, cf
->cxt
, FDISK_FIELD_FSUUID
, &data
) && data
) {
1426 extra_insert_pair(l
, _("Filesystem UUID:"), data
);
1428 mountpoint
= get_mountpoint(cf
, "UUID", data
);
1432 if (!fdisk_partition_to_string(pa
, cf
->cxt
, FDISK_FIELD_FSLABEL
, &data
) && data
) {
1433 extra_insert_pair(l
, _("Filesystem LABEL:"), data
);
1435 mountpoint
= get_mountpoint(cf
, "LABEL", data
);
1438 if (!fdisk_partition_to_string(pa
, cf
->cxt
, FDISK_FIELD_FSTYPE
, &data
) && data
) {
1439 extra_insert_pair(l
, _("Filesystem:"), data
);
1444 extra_insert_pair(l
, _("Mountpoint:"), mountpoint
);
1449 static int ui_draw_extra(struct cfdisk
*cf
)
1453 struct cfdisk_line
*ln
= &cf
->lines
[cf
->lines_idx
];
1454 char *tbstr
= NULL
, *end
;
1455 int win_ex_start_line
, win_height
, tblen
;
1458 if (!cf
->show_extra
)
1461 DBG(UI
, ul_debug("draw extra"));
1466 wclear(cf
->act_win
);
1470 if (scols_table_is_empty(ln
->extra
)) {
1471 extra_prepare_data(cf
);
1472 if (scols_table_is_empty(ln
->extra
))
1476 ndatalines
= fdisk_table_get_nents(cf
->table
) + 1;
1478 /* nents + header + one free line */
1479 win_ex_start_line
= TABLE_START_LINE
+ ndatalines
;
1480 win_height
= MENU_START_LINE
- win_ex_start_line
;
1481 tblen
= scols_table_get_nlines(ln
->extra
);
1483 /* we can't get a single line of data under the partlist*/
1487 /* number of data lines + 2 for top/bottom lines */
1488 win_height
= win_height
< tblen
+ 2 ? win_height
: tblen
+ 2;
1490 if ((size_t) win_ex_start_line
+ win_height
+ 1 < MENU_START_LINE
)
1491 win_ex_start_line
= MENU_START_LINE
- win_height
;
1493 win_ex
= subwin(stdscr
, win_height
, ui_cols
- 2, win_ex_start_line
, 1);
1495 scols_table_reduce_termwidth(ln
->extra
, 4);
1496 scols_print_table_to_string(ln
->extra
, &tbstr
);
1499 while ((end
= strchr(end
, '\n')))
1505 while (--win_height
> 1) {
1506 mvwaddstr(win_ex
, wline
++, 1 /* window column*/, tbstr
);
1507 tbstr
+= strlen(tbstr
) + 1;
1514 DBG(UI
, ul_debug("draw window: %p", win_ex
));
1518 cf
->act_win
= ln
->w
= win_ex
;
1522 static void ui_menu_goto(struct cfdisk
*cf
, int where
)
1524 struct cfdisk_menuitem
*d
;
1527 /* stop and begin/end for vertical menus */
1528 if (cf
->menu
->vertical
) {
1531 else if (where
> (int) cf
->menu
->nitems
- 1)
1532 where
= cf
->menu
->nitems
- 1;
1534 /* continue from begin/end */
1536 where
= cf
->menu
->nitems
- 1;
1537 else if ((size_t) where
> cf
->menu
->nitems
- 1)
1540 if ((size_t) where
== cf
->menu
->idx
)
1545 old
= cf
->menu
->idx
;
1546 cf
->menu
->idx
= where
;
1548 if (!menuitem_on_page(cf
, old
)) {
1553 d
= menu_get_menuitem(cf
, old
);
1554 ui_draw_menuitem(cf
, d
, old
);
1556 d
= menu_get_menuitem(cf
, where
);
1557 ui_draw_menuitem(cf
, d
, where
);
1561 static int ui_menu_move(struct cfdisk
*cf
, int key
)
1563 struct cfdisk_menu
*m
;
1568 if (key
== (int) ERR
)
1569 return 0; /* ignore errors */
1573 DBG(MENU
, ul_debug("menu move key >%c<.", key
));
1579 case '\016': /* ^N */
1580 case 'j': /* Vi-like alternative */
1581 ui_menu_goto(cf
, m
->idx
+ 1);
1584 case '\020': /* ^P */
1585 case 'k': /* Vi-like alternative */
1586 ui_menu_goto(cf
, (int) m
->idx
- 1);
1590 ui_menu_goto(cf
, (int) m
->idx
- m
->page_sz
);
1595 ui_menu_goto(cf
, 0);
1599 ui_menu_goto(cf
, m
->idx
+ m
->page_sz
);
1604 ui_menu_goto(cf
, m
->nitems
);
1611 ui_menu_goto(cf
, m
->idx
+ 1);
1617 ui_menu_goto(cf
, (int) m
->idx
- 1);
1622 if (key
== '\014') { /* ^L refresh */
1627 DBG(MENU
, ul_debug(" no menu move key"));
1631 /* but don't call me from ui_run(), this is for pop-up menus only */
1632 static void ui_menu_resize(struct cfdisk
*cf
)
1634 DBG(MENU
, ul_debug("menu resize/refresh"));
1637 menu_refresh_size(cf
);
1642 static int partition_on_page(struct cfdisk
*cf
, size_t i
)
1644 if (cf
->page_sz
== 0 ||
1645 cf
->lines_idx
/ cf
->page_sz
== i
/ cf
->page_sz
)
1650 static void ui_draw_partition(struct cfdisk
*cf
, size_t i
)
1652 int ln
= TABLE_START_LINE
+ 1 + i
; /* skip table header */
1653 int cl
= ARROW_CURSOR_WIDTH
; /* we need extra space for cursor */
1654 int cur
= cf
->lines_idx
== i
;
1658 if (!partition_on_page(cf
, i
))
1660 ln
= TABLE_START_LINE
+ (i
% cf
->page_sz
) + 1;
1661 curpg
= cf
->lines_idx
/ cf
->page_sz
;
1665 "draw partition %zu [page_sz=%zu, "
1666 "line=%d, idx=%zu]",
1667 i
, cf
->page_sz
, ln
, cf
->lines_idx
));
1671 mvaddstr(ln
, 0, ARROW_CURSOR_STRING
);
1672 mvaddstr(ln
, cl
, cf
->lines
[i
+ 1].data
);
1677 if (colors_wanted() && is_freespace(cf
, i
)) {
1678 attron(COLOR_PAIR(CFDISK_CL_FREESPACE
));
1681 mvaddstr(ln
, 0, ARROW_CURSOR_DUMMY
);
1682 mvaddstr(ln
, cl
, cf
->lines
[i
+ 1].data
);
1684 attroff(COLOR_PAIR(CFDISK_CL_FREESPACE
));
1687 if ((size_t) ln
== MENU_START_LINE
- 1 &&
1688 cf
->page_sz
&& curpg
< cf
->nlines
/ cf
->page_sz
) {
1691 mvaddch(ln
, ui_cols
- 1, ACS_DARROW
);
1692 mvaddch(ln
, 0, ACS_DARROW
);
1699 static int ui_draw_table(struct cfdisk
*cf
)
1701 int cl
= ARROW_CURSOR_WIDTH
;
1702 size_t i
, nparts
= fdisk_table_get_nents(cf
->table
);
1703 size_t curpg
= cf
->page_sz
? cf
->lines_idx
/ cf
->page_sz
: 0;
1705 DBG(UI
, ul_debug("draw table"));
1707 for (i
= TABLE_START_LINE
; i
<= TABLE_START_LINE
+ cf
->page_sz
; i
++) {
1712 if (nparts
== 0 || (size_t) cf
->lines_idx
> nparts
- 1)
1713 cf
->lines_idx
= nparts
? nparts
- 1 : 0;
1717 mvaddstr(TABLE_START_LINE
, cl
, cf
->lines
[0].data
);
1720 /* print partitions */
1721 for (i
= 0; i
< nparts
; i
++)
1722 ui_draw_partition(cf
, i
);
1725 mvaddch(TABLE_START_LINE
, ui_cols
- 1, ACS_UARROW
);
1726 mvaddch(TABLE_START_LINE
, 0, ACS_UARROW
);
1728 if (cf
->page_sz
&& curpg
< cf
->nlines
/ cf
->page_sz
) {
1729 mvaddch(MENU_START_LINE
- 1, ui_cols
- 1, ACS_DARROW
);
1730 mvaddch(MENU_START_LINE
- 1, 0, ACS_DARROW
);
1735 static int ui_table_goto(struct cfdisk
*cf
, int where
)
1738 size_t nparts
= fdisk_table_get_nents(cf
->table
);
1740 DBG(UI
, ul_debug("goto table %d", where
));
1744 else if ((size_t) where
> nparts
- 1)
1747 if ((size_t) where
== cf
->lines_idx
)
1750 old
= cf
->lines_idx
;
1751 cf
->lines_idx
= where
;
1753 if (!partition_on_page(cf
, old
) ||!partition_on_page(cf
, where
))
1756 ui_draw_partition(cf
, old
); /* cleanup old */
1757 ui_draw_partition(cf
, where
); /* draw new */
1767 static int ui_refresh(struct cfdisk
*cf
)
1769 struct fdisk_label
*lb
;
1771 uint64_t bytes
= fdisk_get_nsectors(cf
->cxt
) * fdisk_get_sector_size(cf
->cxt
);
1777 strsz
= size_to_human_string(SIZE_DECIMAL_2DIGITS
1779 | SIZE_SUFFIX_3LETTER
, bytes
);
1781 lb
= fdisk_get_label(cf
->cxt
, NULL
);
1788 ui_center(0, _("Disk: %s"), fdisk_get_devname(cf
->cxt
));
1790 ui_center(1, _("Size: %s, %"PRIu64
" bytes, %ju sectors"),
1791 strsz
, bytes
, (uintmax_t) fdisk_get_nsectors(cf
->cxt
));
1792 if (fdisk_get_disklabel_id(cf
->cxt
, &id
) == 0 && id
)
1793 ui_center(2, _("Label: %s, identifier: %s"),
1794 fdisk_label_get_name(lb
), id
);
1796 ui_center(2, _("Label: %s"), fdisk_label_get_name(lb
));
1806 static ssize_t
ui_get_string(const char *prompt
,
1807 const char *hint
, char *buf
, size_t len
)
1809 int ln
= MENU_START_LINE
, cl
= 1;
1811 struct mbs_editor
*edit
;
1813 DBG(UI
, ul_debug("ui get string"));
1825 mvaddstr(ln
, cl
, prompt
);
1826 cl
+= mbs_safe_width(prompt
);
1829 edit
= mbs_new_edit(buf
, len
, ui_cols
- cl
);
1833 mbs_edit_goto(edit
, MBS_EDIT_END
);
1836 ui_hint("%s", hint
);
1843 wint_t c
; /* we have fallback in widechar.h */
1847 mvaddstr(ln
, cl
, edit
->buf
);
1848 move(ln
, cl
+ edit
->cursor_cells
);
1851 #if !defined(HAVE_SLCURSES_H) && !defined(HAVE_SLANG_SLCURSES_H) && \
1852 defined(HAVE_LIBNCURSESW) && defined(HAVE_WIDECHAR)
1853 if (get_wch(&c
) == ERR
) {
1855 if ((c
= getch()) == (wint_t) ERR
) {
1863 if (!isatty(STDIN_FILENO
))
1869 DBG(UI
, ul_debug("ui get string: key=%lc", c
));
1871 if (c
== '\r' || c
== '\n' || c
== KEY_ENTER
)
1878 rc
= -CFDISK_ERR_ESC
;
1881 rc
= mbs_edit_goto(edit
, MBS_EDIT_LEFT
);
1884 rc
= mbs_edit_goto(edit
, MBS_EDIT_RIGHT
);
1887 rc
= mbs_edit_goto(edit
, MBS_EDIT_END
);
1890 rc
= mbs_edit_goto(edit
, MBS_EDIT_HOME
);
1896 rc
= mbs_edit_delete(edit
);
1901 rc
= mbs_edit_backspace(edit
);
1904 rc
= mbs_edit_insert(edit
, c
);
1914 rc
= strlen(edit
->buf
); /* success */
1920 mbs_free_edit(edit
);
1925 static int ui_get_size(struct cfdisk
*cf
, /* context */
1926 const char *prompt
, /* UI dialog string */
1927 uint64_t *res
, /* result in bytes */
1928 uint64_t low
, /* minimal size */
1929 uint64_t up
, /* maximal size */
1930 int *expsize
) /* explicitly specified size */
1935 char *dflt
= size_to_human_string(0, *res
);
1937 DBG(UI
, ul_debug("get_size (default=%"PRIu64
")", *res
));
1941 snprintf(buf
, sizeof(buf
), "%s", dflt
);
1944 int pwr
= 0, insec
= 0;
1946 rc
= ui_get_string(prompt
,
1947 _("May be followed by M for MiB, G for GiB, "
1948 "T for TiB, or S for sectors."),
1953 ui_warnx(_("Please, specify size."));
1954 continue; /* nothing specified */
1955 } if (rc
== -CFDISK_ERR_ESC
)
1956 break; /* cancel dialog */
1958 if (strcmp(buf
, dflt
) == 0)
1959 user
= *res
, rc
= 0; /* no change, use default */
1961 size_t len
= strlen(buf
);
1962 if (buf
[len
- 1] == 'S' || buf
[len
- 1] == 's') {
1964 buf
[len
- 1] = '\0';
1966 rc
= parse_size(buf
, (uintmax_t *)&user
, &pwr
); /* parse */
1970 DBG(UI
, ul_debug("get_size user=%"PRIu64
", power=%d, in-sectors=%s",
1971 user
, pwr
, insec
? "yes" : "no"));
1973 user
*= fdisk_get_sector_size(cf
->cxt
);
1975 ui_warnx(_("Minimum size is %"PRIu64
" bytes."), low
);
1978 if (user
> up
&& pwr
&& user
< up
+ (1ULL << pwr
* 10))
1979 /* ignore when the user specified size overflow
1980 * with in range specified by suffix (e.g. MiB) */
1984 ui_warnx(_("Maximum size is %"PRIu64
" bytes."), up
);
1987 if (rc
== 0 && insec
&& expsize
)
1991 ui_warnx(_("Failed to parse size."));
1998 DBG(UI
, ul_debug("get_size (result=%"PRIu64
", rc=%zd)", *res
, rc
));
2002 static struct fdisk_parttype
*ui_get_parttype(struct cfdisk
*cf
,
2003 struct fdisk_parttype
*cur
)
2005 struct cfdisk_menuitem
*d
, *cm
;
2006 size_t i
= 0, nitems
, idx
= 0;
2007 struct fdisk_parttype
*t
= NULL
;
2008 struct fdisk_label
*lb
;
2011 DBG(UI
, ul_debug("asking for parttype."));
2013 lb
= fdisk_get_label(cf
->cxt
, NULL
);
2015 /* create cfdisk menu according to label types, note that the
2016 * last cm[] item has to be empty -- so nitems + 1 */
2017 nitems
= fdisk_label_get_nparttypes(lb
);
2021 cm
= xcalloc(nitems
+ 1, sizeof(struct cfdisk_menuitem
));
2025 codetypes
= fdisk_label_has_code_parttypes(lb
);
2027 for (i
= 0; i
< nitems
; i
++) {
2028 const struct fdisk_parttype
*x
= fdisk_label_get_parttype(lb
, i
);
2031 cm
[i
].userdata
= (void *) x
;
2033 xasprintf(&name
, "%2x %s",
2034 fdisk_parttype_get_code(x
),
2035 _(fdisk_parttype_get_name(x
)));
2037 name
= (char *) _(fdisk_parttype_get_name(x
));
2038 cm
[i
].desc
= fdisk_parttype_get_string(x
);
2045 /* make the new menu active */
2047 cf
->menu
->vertical
= 1;
2048 cf
->menu
->idx
= idx
;
2049 menu_set_title(cf
->menu
, _("Select partition type"));
2060 if (ui_menu_move(cf
, key
) == 0)
2067 d
= menu_get_menuitem(cf
, cf
->menu
->idx
);
2069 t
= (struct fdisk_parttype
*) d
->userdata
;
2083 for (i
= 0; i
< nitems
; i
++)
2084 free((char *) cm
[i
].name
);
2087 DBG(UI
, ul_debug("get parrtype done [type=%s] ", t
?
2088 fdisk_parttype_get_name(t
) : ""));
2092 static int ui_script_read(struct cfdisk
*cf
)
2094 struct fdisk_script
*sc
= NULL
;
2095 char buf
[PATH_MAX
] = { 0 };
2099 rc
= ui_get_string( _("Enter script file name: "),
2100 _("The script file will be applied to in-memory partition table."),
2107 sc
= fdisk_new_script_from_file(cf
->cxt
, buf
);
2109 ui_warn(_("Cannot open %s"), buf
);
2111 ui_warnx(_("Failed to parse script file %s"), buf
);
2112 else if (fdisk_apply_script(cf
->cxt
, sc
) != 0)
2113 ui_warnx(_("Failed to apply script %s"), buf
);
2118 fdisk_unref_script(sc
);
2122 static int ui_script_write(struct cfdisk
*cf
)
2124 struct fdisk_script
*sc
= NULL
;
2125 char buf
[PATH_MAX
] = { 0 };
2129 rc
= ui_get_string( _("Enter script file name: "),
2130 _("The current in-memory partition table will be dumped to the file."),
2136 sc
= fdisk_new_script(cf
->cxt
);
2138 ui_warn(_("Failed to allocate script handler"));
2142 rc
= fdisk_script_read_context(sc
, NULL
);
2144 ui_warnx(_("Failed to read disk layout into script."));
2148 DBG(UI
, ul_debug("writing dump into: '%s'", buf
));
2149 f
= fopen(buf
, "w");
2151 ui_warn(_("Cannot open %s"), buf
);
2156 rc
= fdisk_script_write_file(sc
, f
);
2158 ui_info(_("Disk layout successfully dumped."));
2161 ui_warn(_("Failed to write script %s"), buf
);
2164 fdisk_unref_script(sc
);
2168 /* prints menu with libfdisk labels and waits for users response */
2169 static int ui_create_label(struct cfdisk
*cf
)
2171 struct cfdisk_menuitem
*d
, *cm
;
2172 int rc
= 1, refresh_menu
= 1;
2173 size_t i
= 0, nitems
;
2174 struct fdisk_label
*lb
= NULL
;
2178 DBG(UI
, ul_debug("asking for new disklabe."));
2180 /* create cfdisk menu according to libfdisk labels, note that the
2181 * last cm[] item has to be empty -- so nitems + 1 */
2182 nitems
= fdisk_get_nlabels(cf
->cxt
);
2183 cm
= xcalloc(nitems
+ 1, sizeof(struct cfdisk_menuitem
));
2185 while (fdisk_next_label(cf
->cxt
, &lb
) == 0) {
2186 if (fdisk_label_is_disabled(lb
) ||
2187 fdisk_label_get_type(lb
) == FDISK_DISKLABEL_BSD
)
2189 cm
[i
++].name
= fdisk_label_get_name(lb
);
2194 /* make the new menu active */
2196 cf
->menu
->vertical
= 1;
2197 menu_set_title(cf
->menu
, _("Select label type"));
2199 if (!cf
->zero_start
)
2200 ui_info(_("Device does not contain a recognized partition table."));
2208 ui_hint(_("Select a type to create a new label, press 'L' to load script file, 'Q' quits."));
2219 if (ui_menu_move(cf
, key
) == 0)
2225 d
= menu_get_menuitem(cf
, cf
->menu
->idx
);
2227 rc
= fdisk_create_disklabel(cf
->cxt
, d
->name
);
2235 rc
= ui_script_read(cf
);
2248 DBG(UI
, ul_debug("create label done [rc=%d] ", rc
));
2253 static int ui_help(void)
2256 static const char *help
[] = {
2257 N_("This is cfdisk, a curses-based disk partitioning program."),
2258 N_("It lets you create, delete, and modify partitions on a block device."),
2260 N_("Command Meaning"),
2261 N_("------- -------"),
2262 N_(" b Toggle bootable flag of the current partition;"),
2263 N_(" implemented for DOS (MBR) and SGI labels only"),
2264 N_(" d Delete the current partition"),
2265 N_(" h Print this screen"),
2266 N_(" n Create new partition from free space"),
2267 N_(" q Quit program without writing partition table"),
2268 N_(" r Reduce or enlarge the current partition"),
2269 N_(" s Fix partitions order (only when in disarray)"),
2270 N_(" t Change the partition type"),
2271 N_(" u Dump disk layout to sfdisk compatible script file"),
2272 N_(" W Write partition table to disk (you must enter uppercase W);"),
2273 N_(" since this might destroy data on the disk, you must either"),
2274 N_(" confirm or deny the write by entering 'yes' or 'no'"),
2275 N_(" x Display/hide extra information about a partition"),
2276 N_("Up Arrow Move cursor to the previous partition"),
2277 N_("Down Arrow Move cursor to the next partition"),
2278 N_("Left Arrow Move cursor to the previous menu item"),
2279 N_("Right Arrow Move cursor to the next menu item"),
2281 N_("Note: All of the commands can be entered with either upper or lower"),
2282 N_("case letters (except for Write)."),
2284 N_("Use lsblk(8) or partx(8) to see more details about the device."),
2287 "Copyright (C) 2014-2023 Karel Zak <kzak@redhat.com>"
2291 for (i
= 0; i
< ARRAY_SIZE(help
); i
++)
2292 mvaddstr(i
, 1, _(help
[i
]));
2294 ui_info(_("Press a key to continue."));
2303 /* TODO: use @sz, now 128bytes */
2304 static int main_menu_ignore_keys(struct cfdisk
*cf
, char *ignore
,
2305 size_t sz
__attribute__((__unused__
)))
2307 struct fdisk_partition
*pa
= get_current_partition(cf
);
2312 if (fdisk_partition_is_freespace(pa
)) {
2313 ignore
[i
++] = 'd'; /* delete */
2314 ignore
[i
++] = 't'; /* set type */
2315 ignore
[i
++] = 'b'; /* set bootable */
2316 ignore
[i
++] = 'r'; /* resize */
2317 cf
->menu
->prefkey
= 'n';
2319 cf
->menu
->prefkey
= 'q';
2321 if (!fdisk_is_label(cf
->cxt
, DOS
) &&
2322 !fdisk_is_label(cf
->cxt
, SGI
))
2326 if (!cf
->wrong_order
)
2329 if (fdisk_is_readonly(cf
->cxt
))
2336 /* returns: error: < 0, success: 0, quit: 1 */
2337 static int main_menu_action(struct cfdisk
*cf
, int key
)
2340 int ref
= 0, rc
, org_order
= cf
->wrong_order
;
2341 const char *info
= NULL
, *warn
= NULL
;
2342 struct fdisk_partition
*pa
;
2349 struct cfdisk_menuitem
*d
= menu_get_menuitem(cf
, cf
->menu
->idx
);
2354 } else if (key
!= 'w' && key
!= 'W')
2355 key
= tolower(key
); /* case insensitive except 'W'rite */
2357 DBG(MENU
, ul_debug("main menu action: key=%c", key
));
2359 if (cf
->menu
->ignore
&& strchr(cf
->menu
->ignore
, key
)) {
2360 DBG(MENU
, ul_debug(" ignore '%c'", key
));
2364 pa
= get_current_partition(cf
);
2367 n
= fdisk_partition_get_partno(pa
);
2369 DBG(MENU
, ul_debug("menu action on %p", pa
));
2374 case 'b': /* Bootable flag */
2376 int fl
= fdisk_is_label(cf
->cxt
, DOS
) ? DOS_FLAG_ACTIVE
:
2377 fdisk_is_label(cf
->cxt
, SGI
) ? SGI_FLAG_BOOT
: 0;
2379 if (fl
&& fdisk_toggle_partition_flag(cf
->cxt
, n
, fl
))
2380 warn
= _("Could not toggle the flag.");
2388 case 'd': /* Delete */
2389 if (fdisk_delete_partition(cf
->cxt
, n
) != 0)
2390 warn
= _("Could not delete partition %zu.");
2392 info
= _("Partition %zu has been deleted.");
2395 case 'h': /* Help */
2402 uint64_t start
, size
, dflt_size
, secs
, max_size
;
2403 struct fdisk_partition
*npa
; /* the new partition */
2404 int expsize
= 0; /* size specified explicitly in sectors */
2406 if (!fdisk_partition_is_freespace(pa
) || !fdisk_partition_has_start(pa
))
2409 /* free space range */
2410 start
= fdisk_partition_get_start(pa
);
2411 size
= max_size
= dflt_size
= fdisk_partition_get_size(pa
) * fdisk_get_sector_size(cf
->cxt
);
2413 if (ui_get_size(cf
, _("Partition size: "), &size
,
2414 fdisk_get_sector_size(cf
->cxt
),
2415 max_size
, &expsize
) == -CFDISK_ERR_ESC
)
2418 secs
= size
/ fdisk_get_sector_size(cf
->cxt
);
2420 npa
= fdisk_new_partition();
2424 if (dflt_size
== size
) /* default is to fillin all free space */
2425 fdisk_partition_end_follow_default(npa
, 1);
2427 fdisk_partition_set_size(npa
, secs
);
2430 fdisk_partition_size_explicit(pa
, 1);
2432 fdisk_partition_set_start(npa
, start
);
2433 fdisk_partition_partno_follow_default(npa
, 1);
2434 /* add to disk label -- libfdisk will ask for missing details */
2435 rc
= fdisk_add_partition(cf
->cxt
, npa
, NULL
);
2436 fdisk_unref_partition(npa
);
2441 case 'q': /* Quit */
2443 case 't': /* Type */
2445 struct fdisk_parttype
*t
;
2447 if (fdisk_partition_is_freespace(pa
))
2449 t
= (struct fdisk_parttype
*) fdisk_partition_get_type(pa
);
2450 t
= ui_get_parttype(cf
, t
);
2453 if (t
&& fdisk_set_partition_type(cf
->cxt
, n
, t
) == 0)
2454 info
= _("Changed type of partition %zu.");
2456 info
= _("The type of partition %zu is unchanged.");
2459 case 'r': /* resize */
2461 struct fdisk_partition
*npa
, *next
;
2462 uint64_t size
, max_size
, secs
;
2464 if (fdisk_partition_is_freespace(pa
) || !fdisk_partition_has_start(pa
))
2467 size
= fdisk_partition_get_size(pa
);
2469 /* is the next freespace? */
2470 next
= fdisk_table_get_partition(cf
->table
, cf
->lines_idx
+ 1);
2471 if (next
&& fdisk_partition_is_freespace(next
))
2472 size
+= fdisk_partition_get_size(next
);
2474 size
*= fdisk_get_sector_size(cf
->cxt
);
2477 if (ui_get_size(cf
, _("New size: "), &size
,
2478 fdisk_get_sector_size(cf
->cxt
),
2479 max_size
, NULL
) == -CFDISK_ERR_ESC
)
2481 secs
= size
/ fdisk_get_sector_size(cf
->cxt
);
2482 npa
= fdisk_new_partition();
2486 fdisk_partition_set_size(npa
, secs
);
2488 rc
= fdisk_set_partition(cf
->cxt
, n
, npa
);
2489 fdisk_unref_partition(npa
);
2492 info
= _("Partition %zu resized.");
2496 case 's': /* Sort */
2497 if (cf
->wrong_order
) {
2498 fdisk_reorder_partitions(cf
->cxt
);
2502 case 'u': /* dUmp */
2503 ui_script_write(cf
);
2505 case 'W': /* Write */
2507 char buf
[64] = { 0 };
2509 if (fdisk_is_readonly(cf
->cxt
)) {
2510 warn
= _("Device is open in read-only mode.");
2515 _("Are you sure you want to write the partition "
2517 _("Type \"yes\" or \"no\", or press ESC to leave this dialog."),
2521 if (rc
<= 0 || (strcasecmp(buf
, "yes") != 0 &&
2522 strcasecmp(buf
, _("yes")) != 0)) {
2523 info
= _("Did not write partition table to disk.");
2526 rc
= fdisk_write_disklabel(cf
->cxt
);
2528 warn
= _("Failed to write disklabel.");
2532 if (cf
->device_is_used
)
2533 fdisk_reread_changes(cf
->cxt
, cf
->original_layout
);
2535 fdisk_reread_partition_table(cf
->cxt
);
2536 info
= _("The partition table has been altered.");
2537 if (menu_get_menuitem_by_key(cf
, 'q', &q_idx
))
2538 ui_menu_goto(cf
, q_idx
);
2557 ui_warnx(warn
, n
+ 1);
2559 ui_info(info
, n
+ 1);
2560 else if (key
== 'n' && cf
->wrong_order
&& org_order
== 0)
2561 ui_info(_("Note that partition table entries are not in disk order now."));
2566 static void ui_resize_refresh(struct cfdisk
*cf
)
2568 DBG(UI
, ul_debug("ui resize/refresh"));
2570 menu_refresh_size(cf
);
2576 static void toggle_show_extra(struct cfdisk
*cf
)
2578 if (cf
->show_extra
&& cf
->act_win
) {
2579 wclear(cf
->act_win
);
2582 cf
->show_extra
= cf
->show_extra
? 0 : 1;
2586 DBG(MENU
, ul_debug("extra: %s", cf
->show_extra
? "ENABLED" : "DISABLED" ));
2589 static int ui_run(struct cfdisk
*cf
)
2595 DBG(UI
, ul_debug("start cols=%zu, lines=%zu", ui_cols
, ui_lines
));
2597 if (fdisk_get_collision(cf
->cxt
)) {
2598 ui_warnx(_("Device already contains a %s signature."), fdisk_get_collision(cf
->cxt
));
2599 if (fdisk_is_readonly(cf
->cxt
)) {
2600 ui_hint(_("Press a key to continue."));
2603 char buf
[64] = { 0 };
2604 rc
= ui_get_string(_("Do you want to remove it? [Y]es/[N]o: "), NULL
,
2606 fdisk_enable_wipe(cf
->cxt
,
2607 rc
> 0 && rpmatch(buf
) == RPMATCH_YES
? 1 : 0);
2611 if (!fdisk_has_label(cf
->cxt
) || cf
->zero_start
) {
2612 rc
= ui_create_label(cf
);
2615 ui_err(EXIT_FAILURE
,
2616 _("failed to create a new disklabel"));
2623 rc
= lines_refresh(cf
);
2625 ui_errx(EXIT_FAILURE
, _("failed to read partitions"));
2627 menu_push(cf
, main_menuitems
);
2628 cf
->menu
->ignore_cb
= main_menu_ignore_keys
;
2630 rc
= ui_refresh(cf
);
2637 if (fdisk_is_readonly(cf
->cxt
))
2638 ui_warnx(_("Device is open in read-only mode. Changes will remain in memory only."));
2639 else if (cf
->device_is_used
)
2640 ui_warnx(_("Device is currently in use, repartitioning is probably a bad idea."));
2641 else if (cf
->wrong_order
)
2642 ui_info(_("Note that partition table entries are not in disk order now."));
2652 /* Note that ncurses getch() returns ERR when interrupted
2653 * by signal, but SLang does not interrupt at all. */
2654 ui_resize_refresh(cf
);
2657 if (key
== '\014') { /* ^L refresh */
2658 ui_resize_refresh(cf
);
2661 if (ui_menu_move(cf
, key
) == 0)
2664 DBG(UI
, ul_debug("main action key >%1$c< [\\0%1$o].", key
));
2668 case '\016': /* ^N */
2669 case 'j': /* Vi-like alternative */
2670 ui_table_goto(cf
, cf
->lines_idx
+ 1);
2673 case '\020': /* ^P */
2674 case 'k': /* Vi-like alternative */
2675 ui_table_goto(cf
, (int) cf
->lines_idx
- 1);
2679 ui_table_goto(cf
, (int) cf
->lines_idx
- cf
->page_sz
);
2684 ui_table_goto(cf
, 0);
2688 ui_table_goto(cf
, cf
->lines_idx
+ cf
->page_sz
);
2693 ui_table_goto(cf
, (int) cf
->nlines
- 1);
2698 rc
= main_menu_action(cf
, 0);
2701 case 'x': /* Extra */
2702 toggle_show_extra(cf
);
2705 rc
= main_menu_action(cf
, key
);
2717 DBG(UI
, ul_debug("end"));
2721 static void __attribute__((__noreturn__
)) usage(void)
2724 fputs(USAGE_HEADER
, out
);
2726 _(" %1$s [options] <disk>\n"), program_invocation_short_name
);
2728 fputs(USAGE_SEPARATOR
, out
);
2729 fputs(_("Display or manipulate a disk partition table.\n"), out
);
2731 fputs(USAGE_OPTIONS
, out
);
2733 _(" -L, --color[=<when>] colorize output (%s, %s or %s)\n"), "auto", "always", "never");
2735 " %s\n", USAGE_COLORS_DEFAULT
);
2736 fputs(_(" -z, --zero start with zeroed partition table\n"), out
);
2738 _(" --lock[=<mode>] use exclusive device lock (%s, %s or %s)\n"), "yes", "no", "nonblock");
2739 fputs(_(" -r, --read-only forced open cfdisk in read-only mode\n"), out
);
2741 fputs(USAGE_SEPARATOR
, out
);
2742 fprintf(out
, USAGE_HELP_OPTIONS(26));
2744 fprintf(out
, USAGE_MAN_TAIL("cfdisk(8)"));
2748 int main(int argc
, char *argv
[])
2750 const char *diskpath
= NULL
, *lockmode
= NULL
;
2751 int rc
, c
, colormode
= UL_COLORMODE_UNDEF
;
2753 struct cfdisk _cf
= { .lines_idx
= 0 },
2756 OPT_LOCK
= CHAR_MAX
+ 1
2758 static const struct option longopts
[] = {
2759 { "color", optional_argument
, NULL
, 'L' },
2760 { "lock", optional_argument
, NULL
, OPT_LOCK
},
2761 { "help", no_argument
, NULL
, 'h' },
2762 { "version", no_argument
, NULL
, 'V' },
2763 { "zero", no_argument
, NULL
, 'z' },
2764 { "read-only", no_argument
, NULL
, 'r' },
2765 { NULL
, 0, NULL
, 0 },
2768 setlocale(LC_ALL
, "");
2769 bindtextdomain(PACKAGE
, LOCALEDIR
);
2770 textdomain(PACKAGE
);
2771 close_stdout_atexit();
2773 while((c
= getopt_long(argc
, argv
, "L::hVzr", longopts
, NULL
)) != -1) {
2779 colormode
= UL_COLORMODE_AUTO
;
2781 colormode
= colormode_or_err(optarg
,
2782 _("unsupported color mode"));
2788 print_version(EXIT_SUCCESS
);
2801 errtryhelp(EXIT_FAILURE
);
2805 colors_init(colormode
, "cfdisk");
2807 fdisk_init_debug(0);
2808 scols_init_debug(0);
2809 cfdisk_init_debug();
2810 cf
->cxt
= fdisk_new_context();
2812 err(EXIT_FAILURE
, _("failed to allocate libfdisk context"));
2814 fdisk_set_ask(cf
->cxt
, ask_callback
, (void *) cf
);
2816 if (optind
== argc
) {
2819 for (i
= 0; i
< ARRAY_SIZE(default_disks
); i
++) {
2820 if (access(default_disks
[i
], F_OK
) == 0) {
2821 diskpath
= default_disks
[i
];
2826 diskpath
= default_disks
[0]; /* default, used for "cannot open" */
2828 diskpath
= argv
[optind
];
2830 rc
= fdisk_assign_device(cf
->cxt
, diskpath
, read_only
);
2831 if (rc
== -EACCES
&& read_only
== 0)
2832 rc
= fdisk_assign_device(cf
->cxt
, diskpath
, 1);
2834 err(EXIT_FAILURE
, _("cannot open %s"), diskpath
);
2836 if (!fdisk_is_readonly(cf
->cxt
)) {
2837 if (blkdev_lock(fdisk_get_devfd(cf
->cxt
), diskpath
, lockmode
) != 0)
2838 return EXIT_FAILURE
;
2840 cf
->device_is_used
= fdisk_device_is_used(cf
->cxt
);
2841 fdisk_get_partitions(cf
->cxt
, &cf
->original_layout
);
2844 /* Don't use err(), warn() from this point */
2849 cfdisk_free_lines(cf
);
2853 fdisk_unref_table(cf
->table
);
2854 #ifdef HAVE_LIBMOUNT
2855 mnt_unref_table(cf
->fstab
);
2856 mnt_unref_table(cf
->mtab
);
2857 mnt_unref_cache(cf
->mntcache
);
2859 rc
= fdisk_deassign_device(cf
->cxt
, cf
->nwrites
== 0);
2860 fdisk_unref_context(cf
->cxt
);
2861 DBG(MISC
, ul_debug("bye! [rc=%d]", rc
));
2862 return rc
== 0 ? EXIT_SUCCESS
: EXIT_FAILURE
;