disk-utils/fdisk.c

   1 /*
   2  * Copyright (C) 1992  A. V. Le Blanc (LeBlanc@mcc.ac.uk)
   3  * Copyright (C) 2012  Davidlohr Bueso <dave@gnu.org>
   4  *
   5  * Copyright (C) 2007-2013 Karel Zak <kzak@redhat.com>
   6  *
   7  * This program is free software.  You can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License as
   9  * published by the Free Software Foundation: either version 1 or
  10  * (at your option) any later version.
  11  */
  12 #include <unistd.h>
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <fcntl.h>
  17 #include <ctype.h>
  18 #include <errno.h>
  19 #include <getopt.h>
  20 #include <sys/stat.h>
  21 #include <sys/time.h>
  22 #include <time.h>
  23 #include <limits.h>
  24 #include <libsmartcols.h>
  25 #ifdef HAVE_LIBREADLINE
  26 # include <readline/readline.h>
  27 #endif
  28
  29 #include "c.h"
  30 #include "xalloc.h"
  31 #include "all-io.h"
  32 #include "nls.h"
  33 #include "rpmatch.h"
  34 #include "blkdev.h"
  35 #include "mbsalign.h"
  36 #include "pathnames.h"
  37 #include "canonicalize.h"
  38 #include "strutils.h"
  39 #include "closestream.h"
  40 #include "sysfs.h"
  41
  42 #include "fdisk.h"
  43
  44 #include "pt-sun.h"             /* to toggle flags */
  45
  46 #ifdef HAVE_LINUX_COMPILER_H
  47 # include <linux/compiler.h>
  48 #endif
  49 #ifdef HAVE_LINUX_BLKPG_H
  50 # include <linux/blkpg.h>
  51 #endif
  52
  53 /*
  54  * fdisk debug stuff (see fdisk.h and include/debug.h)
  55  */
  56 UL_DEBUG_DEFINE_MASK(fdisk);
  57 UL_DEBUG_DEFINE_MASKNAMES(fdisk) = UL_DEBUG_EMPTY_MASKNAMES;
  58
  59 static void fdiskprog_init_debug(void)
  60 {
  61         __UL_INIT_DEBUG(fdisk, FDISKPROG_DEBUG_, 0, FDISK_DEBUG);
  62 }
  63
  64 #ifdef HAVE_LIBREADLINE
  65 static char *rl_fgets(char *s, int n, FILE *stream, const char *prompt)
  66 {
  67         char *p;
  68
  69         rl_outstream = stream;
  70         p = readline(prompt);
  71         if (!p)
  72                 return NULL;
  73
  74         strncpy(s, p, n);
  75         s[n - 1] = '\0';
  76         free(p);
  77         return s;
  78 }
  79 #endif
  80
  81 int get_user_reply(struct fdisk_context *cxt, const char *prompt,
  82                           char *buf, size_t bufsz)
  83 {
  84         char *p;
  85         size_t sz;
  86
  87         do {
  88 #ifdef HAVE_LIBREADLINE
  89                 if (isatty(STDIN_FILENO)) {
  90                         if (!rl_fgets(buf, bufsz, stdout, prompt)) {
  91                                 if (fdisk_label_is_changed(fdisk_get_label(cxt, NULL))) {
  92                                         if (rl_fgets(buf, bufsz, stderr,
  93                                                         _("\nDo you really want to quit? "))
  94                                                         && !rpmatch(buf))
  95                                                 continue;
  96                                 }
  97                                 fdisk_unref_context(cxt);
  98                                 exit(EXIT_FAILURE);
  99                         } else
 100                                 break;
 101                 }
 102                 else
 103 #endif
 104                 {
 105                         fputs(prompt, stdout);
 106                         fflush(stdout);
 107                         if (!fgets(buf, bufsz, stdin)) {
 108                                 if (fdisk_label_is_changed(fdisk_get_label(cxt, NULL))) {
 109                                         fprintf(stderr, _("\nDo you really want to quit? "));
 110
 111                                         if (fgets(buf, bufsz, stdin) && !rpmatch(buf))
 112                                                 continue;
 113                                 }
 114                                 fdisk_unref_context(cxt);
 115                                 exit(EXIT_FAILURE);
 116                         } else
 117                                 break;
 118                 }
 119         } while (1);
 120
 121         for (p = buf; *p && !isgraph(*p); p++); /* get first non-blank */
 122
 123         if (p > buf)
 124                 memmove(buf, p, p - buf);               /* remove blank space */
 125         sz = strlen(buf);
 126         if (sz && *(buf + sz - 1) == '\n')
 127                 *(buf + sz - 1) = '\0';
 128
 129         DBG(ASK, ul_debug("user's reply: >>>%s<<<", buf));
 130         return 0;
 131 }
 132
 133 static int ask_menu(struct fdisk_context *cxt, struct fdisk_ask *ask,
 134                     char *buf, size_t bufsz)
 135
 136 {
 137         const char *q = fdisk_ask_get_query(ask);
 138         int dft = fdisk_ask_menu_get_default(ask);
 139
 140         if (q) {
 141                 fputs(q, stdout);               /* print header */
 142                 fputc('\n', stdout);
 143         }
 144
 145         do {
 146                 char prompt[128];
 147                 int key, c, rc;
 148                 const char *name, *desc;
 149                 size_t i = 0;
 150
 151                 /* print menu items */
 152                 while (fdisk_ask_menu_get_item(ask, i++, &key, &name, &desc) == 0)
 153                         fprintf(stdout, "   %c   %s (%s)\n", key, name, desc);
 154
 155                 /* ask for key */
 156                 snprintf(prompt, sizeof(prompt), _("Select (default %c): "), dft);
 157                 rc = get_user_reply(cxt, prompt, buf, bufsz);
 158                 if (rc)
 159                         return rc;
 160                 if (!*buf) {
 161                         fdisk_info(cxt, _("Using default response %c."), dft);
 162                         c = dft;
 163                 } else
 164                         c = tolower(buf[0]);
 165
 166                 /* check result */
 167                 i = 0;
 168                 while (fdisk_ask_menu_get_item(ask, i++, &key, NULL, NULL) == 0) {
 169                         if (c == key) {
 170                                 fdisk_ask_menu_set_result(ask, c);
 171                                 return 0;       /* success */
 172                         }
 173                 }
 174                 fdisk_warnx(cxt, _("Value out of range."));
 175         } while (1);
 176
 177         return -EINVAL;
 178 }
 179
 180
 181 #define tochar(num)     ((int) ('a' + num - 1))
 182 static int ask_number(struct fdisk_context *cxt,
 183                       struct fdisk_ask *ask,
 184                       char *buf, size_t bufsz)
 185 {
 186         char prompt[128] = { '\0' };
 187         const char *q = fdisk_ask_get_query(ask);
 188         const char *range = fdisk_ask_number_get_range(ask);
 189
 190         uint64_t dflt = fdisk_ask_number_get_default(ask),
 191                  low = fdisk_ask_number_get_low(ask),
 192                  high = fdisk_ask_number_get_high(ask);
 193         int inchar = fdisk_ask_number_inchars(ask);
 194
 195         assert(q);
 196
 197         DBG(ASK, ul_debug("asking for number "
 198                         "['%s', <%ju,%ju>, default=%ju, range: %s]",
 199                         q, low, high, dflt, range));
 200
 201         if (range && dflt >= low && dflt <= high) {
 202                 if (inchar)
 203                         snprintf(prompt, sizeof(prompt), _("%s (%s, default %c): "),
 204                                         q, range, tochar(dflt));
 205                 else
 206                         snprintf(prompt, sizeof(prompt), _("%s (%s, default %ju): "),
 207                                         q, range, dflt);
 208
 209         } else if (dflt >= low && dflt <= high) {
 210                 if (inchar)
 211                         snprintf(prompt, sizeof(prompt), _("%s (%c-%c, default %c): "),
 212                                         q, tochar(low), tochar(high), tochar(dflt));
 213                 else
 214                         snprintf(prompt, sizeof(prompt), _("%s (%ju-%ju, default %ju): "),
 215                                         q, low, high, dflt);
 216         } else if (inchar)
 217                 snprintf(prompt, sizeof(prompt), _("%s (%c-%c): "),
 218                                 q, tochar(low), tochar(high));
 219         else
 220                 snprintf(prompt, sizeof(prompt), _("%s (%ju-%ju): "),
 221                                 q, low, high);
 222
 223         do {
 224                 int rc = get_user_reply(cxt, prompt, buf, bufsz);
 225                 uint64_t num;
 226
 227                 if (rc)
 228                         return rc;
 229                 if (!*buf && dflt >= low && dflt <= high)
 230                         return fdisk_ask_number_set_result(ask, dflt);
 231
 232                 if (isdigit_string(buf)) {
 233                         char *end;
 234
 235                         errno = 0;
 236                         num = strtoumax(buf, &end, 10);
 237                         if (errno || buf == end || (end && *end))
 238                                 continue;
 239                 } else if (inchar && isalpha(*buf)) {
 240                         num = tolower(*buf) - 'a' + 1;
 241                 } else
 242                         rc = -EINVAL;
 243
 244                 if (rc == 0 && num >= low && num <= high)
 245                         return fdisk_ask_number_set_result(ask, num);
 246
 247                 fdisk_warnx(cxt, _("Value out of range."));
 248         } while (1);
 249
 250         return -1;
 251 }
 252
 253 static int ask_offset(struct fdisk_context *cxt,
 254                       struct fdisk_ask *ask,
 255                       char *buf, size_t bufsz)
 256 {
 257         char prompt[128] = { '\0' };
 258         const char *q = fdisk_ask_get_query(ask);
 259         const char *range = fdisk_ask_number_get_range(ask);
 260
 261         uint64_t dflt = fdisk_ask_number_get_default(ask),
 262                  low = fdisk_ask_number_get_low(ask),
 263                  high = fdisk_ask_number_get_high(ask),
 264                  base = fdisk_ask_number_get_base(ask);
 265
 266         assert(q);
 267
 268         DBG(ASK, ul_debug("asking for offset ['%s', <%ju,%ju>, base=%ju, default=%ju, range: %s]",
 269                                 q, low, high, base, dflt, range));
 270
 271         if (range && dflt >= low && dflt <= high)
 272                 snprintf(prompt, sizeof(prompt), _("%s (%s, default %ju): "), q, range, dflt);
 273         else if (dflt >= low && dflt <= high)
 274                 snprintf(prompt, sizeof(prompt), _("%s (%ju-%ju, default %ju): "), q, low, high, dflt);
 275         else
 276                 snprintf(prompt, sizeof(prompt), _("%s (%ju-%ju): "), q, low, high);
 277
 278         do {
 279                 uint64_t num = 0;
 280                 char sig = 0, *p;
 281                 int pwr = 0;
 282
 283                 int rc = get_user_reply(cxt, prompt, buf, bufsz);
 284                 if (rc)
 285                         return rc;
 286                 if (!*buf && dflt >= low && dflt <= high)
 287                         return fdisk_ask_number_set_result(ask, dflt);
 288
 289                 p = buf;
 290                 if (*p == '+' || *p == '-') {
 291                         sig = *buf;
 292                         p++;
 293                 }
 294
 295                 rc = parse_size(p, &num, &pwr);
 296                 if (rc)
 297                         continue;
 298                 DBG(ASK, ul_debug("parsed size: %ju", num));
 299                 if (sig && pwr) {
 300                         /* +{size}{K,M,...} specified, the "num" is in bytes */
 301                         uint64_t unit = fdisk_ask_number_get_unit(ask);
 302                         num += unit/2;  /* round */
 303                         num /= unit;
 304                 }
 305                 if (sig == '+')
 306                         num += base;
 307                 else if (sig == '-')
 308                         num = base - num;
 309
 310                 DBG(ASK, ul_debug("final offset: %ju [sig: %c, power: %d, %s]",
 311                                 num, sig, pwr,
 312                                 sig ? "relative" : "absolute"));
 313                 if (num >= low && num <= high) {
 314                         if (sig && pwr)
 315                                 fdisk_ask_number_set_relative(ask, 1);
 316                         return fdisk_ask_number_set_result(ask, num);
 317                 }
 318                 fdisk_warnx(cxt, _("Value out of range."));
 319         } while (1);
 320
 321         return -1;
 322 }
 323
 324 static unsigned int info_count;
 325
 326 static void fputs_info(struct fdisk_ask *ask, FILE *out)
 327 {
 328         const char *msg;
 329         assert(ask);
 330
 331         msg = fdisk_ask_print_get_mesg(ask);
 332         if (!msg)
 333                 return;
 334         if (info_count == 1)
 335                 fputc('\n', out);
 336
 337         fputs(msg, out);
 338         fputc('\n', out);
 339 }
 340
 341 int ask_callback(struct fdisk_context *cxt, struct fdisk_ask *ask,
 342                     void *data __attribute__((__unused__)))
 343 {
 344         int rc = 0;
 345         char buf[BUFSIZ];
 346
 347         assert(cxt);
 348         assert(ask);
 349
 350         if (fdisk_ask_get_type(ask) != FDISK_ASKTYPE_INFO)
 351                 info_count = 0;
 352
 353         switch(fdisk_ask_get_type(ask)) {
 354         case FDISK_ASKTYPE_MENU:
 355                 return ask_menu(cxt, ask, buf, sizeof(buf));
 356         case FDISK_ASKTYPE_NUMBER:
 357                 return ask_number(cxt, ask, buf, sizeof(buf));
 358         case FDISK_ASKTYPE_OFFSET:
 359                 return ask_offset(cxt, ask, buf, sizeof(buf));
 360         case FDISK_ASKTYPE_INFO:
 361                 if (!fdisk_is_listonly(cxt))
 362                         info_count++;
 363                 fputs_info(ask, stdout);
 364                 break;
 365         case FDISK_ASKTYPE_WARNX:
 366                 color_scheme_fenable("warn", UL_COLOR_RED, stderr);
 367                 fputs(fdisk_ask_print_get_mesg(ask), stderr);
 368                 color_fdisable(stderr);
 369                 fputc('\n', stderr);
 370                 break;
 371         case FDISK_ASKTYPE_WARN:
 372                 color_scheme_fenable("warn", UL_COLOR_RED, stderr);
 373                 fputs(fdisk_ask_print_get_mesg(ask), stderr);
 374                 errno = fdisk_ask_print_get_errno(ask);
 375                 fprintf(stderr, ": %m\n");
 376                 color_fdisable(stderr);
 377                 break;
 378         case FDISK_ASKTYPE_YESNO:
 379                 fputc('\n', stdout);
 380                 do {
 381                         int x;
 382                         fputs(fdisk_ask_get_query(ask), stdout);
 383                         rc = get_user_reply(cxt, _(" [Y]es/[N]o: "), buf, sizeof(buf));
 384                         if (rc)
 385                                 break;
 386                         x = rpmatch(buf);
 387                         if (x == RPMATCH_YES || x == RPMATCH_NO) {
 388                                 fdisk_ask_yesno_set_result(ask, x);
 389                                 break;
 390                         }
 391                 } while(1);
 392                 DBG(ASK, ul_debug("yes-no ask: reply '%s' [rc=%d]", buf, rc));
 393                 break;
 394         case FDISK_ASKTYPE_STRING:
 395         {
 396                 char prmt[BUFSIZ];
 397                 snprintf(prmt, sizeof(prmt), "%s: ", fdisk_ask_get_query(ask));
 398                 fputc('\n', stdout);
 399                 rc = get_user_reply(cxt, prmt, buf, sizeof(buf));
 400                 if (rc == 0)
 401                         fdisk_ask_string_set_result(ask, xstrdup(buf));
 402                 DBG(ASK, ul_debug("string ask: reply '%s' [rc=%d]", buf, rc));
 403                 break;
 404         }
 405         default:
 406                 warnx(_("internal error: unsupported dialog type %d"), fdisk_ask_get_type(ask));
 407                 return -EINVAL;
 408         }
 409         return rc;
 410 }
 411
 412 struct fdisk_parttype *ask_partition_type(struct fdisk_context *cxt)
 413 {
 414         const char *q;
 415         struct fdisk_label *lb;
 416
 417         assert(cxt);
 418         lb = fdisk_get_label(cxt, NULL);
 419
 420         if (!lb)
 421                 return NULL;
 422
 423         q = fdisk_label_has_code_parttypes(lb) ?
 424                 _("Partition type (type L to list all types): ") :
 425                 _("Hex code (type L to list all codes): ");
 426         do {
 427                 char buf[256];
 428                 int rc = get_user_reply(cxt, q, buf, sizeof(buf));
 429
 430                 if (rc)
 431                         break;
 432
 433                 if (buf[1] == '\0' && toupper(*buf) == 'L')
 434                         list_partition_types(cxt);
 435                 else if (*buf)
 436                         return fdisk_label_parse_parttype(lb, buf);
 437         } while (1);
 438
 439         return NULL;
 440 }
 441
 442 void list_partition_types(struct fdisk_context *cxt)
 443 {
 444         size_t ntypes = 0;
 445         struct fdisk_label *lb = fdisk_get_label(cxt, NULL);
 446
 447         assert(cxt);
 448         lb = fdisk_get_label(cxt, NULL);
 449         if (!lb)
 450                 return;
 451         ntypes = fdisk_label_get_nparttypes(lb);
 452         if (!ntypes)
 453                 return;
 454
 455         if (fdisk_label_has_code_parttypes(lb)) {
 456                 /*
 457                  * Prints in 4 columns in format <hex> <name>
 458                  */
 459                 size_t last[4], done = 0, next = 0, size;
 460                 int i;
 461
 462                 size = ntypes;
 463
 464                 for (i = 3; i >= 0; i--)
 465                         last[3 - i] = done += (size + i - done) / (i + 1);
 466                 i = done = 0;
 467
 468                 do {
 469                         #define NAME_WIDTH 15
 470                         char name[NAME_WIDTH * MB_LEN_MAX];
 471                         size_t width = NAME_WIDTH;
 472                         const struct fdisk_parttype *t = fdisk_label_get_parttype(lb, next);
 473                         size_t ret;
 474
 475                         if (fdisk_parttype_get_name(t)) {
 476                                 printf("%c%2x  ", i ? ' ' : '\n',
 477                                                 fdisk_parttype_get_code(t));
 478                                 ret = mbsalign(_(fdisk_parttype_get_name(t)),
 479                                                 name, sizeof(name),
 480                                                 &width, MBS_ALIGN_LEFT, 0);
 481
 482                                 if (ret == (size_t)-1 || ret >= sizeof(name))
 483                                         printf("%-15.15s",
 484                                                 _(fdisk_parttype_get_name(t)));
 485                                 else
 486                                         fputs(name, stdout);
 487                         }
 488
 489                         next = last[i++] + done;
 490                         if (i > 3 || next >= last[i]) {
 491                                 i = 0;
 492                                 next = ++done;
 493                         }
 494                 } while (done < last[0]);
 495
 496         } else {
 497                 /*
 498                  * Prints 1 column in format <idx> <name> <typestr>
 499                  */
 500                 size_t i;
 501
 502                 for (i = 0; i < ntypes; i++) {
 503                         const struct fdisk_parttype *t = fdisk_label_get_parttype(lb, i);
 504                         printf("%3zu %-30s %s\n", i + 1,
 505                                         fdisk_parttype_get_name(t),
 506                                         fdisk_parttype_get_string(t));
 507                 }
 508         }
 509         putchar('\n');
 510 }
 511
 512 void toggle_dos_compatibility_flag(struct fdisk_context *cxt)
 513 {
 514         struct fdisk_label *lb = fdisk_get_label(cxt, "dos");
 515         int flag;
 516
 517         if (!lb)
 518                 return;
 519
 520         flag = !fdisk_dos_is_compatible(lb);
 521         fdisk_info(cxt, flag ?
 522                         _("DOS Compatibility flag is set (DEPRECATED!)") :
 523                         _("DOS Compatibility flag is not set"));
 524
 525         fdisk_dos_enable_compatible(lb, flag);
 526
 527         if (fdisk_is_label(cxt, DOS))
 528                 fdisk_reset_alignment(cxt);     /* reset the current label */
 529 }
 530
 531 void change_partition_type(struct fdisk_context *cxt)
 532 {
 533         size_t i;
 534         struct fdisk_parttype *t = NULL;
 535         struct fdisk_partition *pa = NULL;
 536         const char *old = NULL;
 537
 538         assert(cxt);
 539
 540         if (fdisk_ask_partnum(cxt, &i, FALSE))
 541                 return;
 542
 543         if (fdisk_get_partition(cxt, i, &pa)) {
 544                 fdisk_warnx(cxt, _("Partition %zu does not exist yet!"), i + 1);
 545                 return;
 546         }
 547
 548         t = (struct fdisk_parttype *) fdisk_partition_get_type(pa);
 549         old = t ? fdisk_parttype_get_name(t) : _("Unknown");
 550
 551         do {
 552                 t = ask_partition_type(cxt);
 553         } while (!t);
 554
 555         if (fdisk_set_partition_type(cxt, i, t) == 0)
 556                 fdisk_info(cxt,
 557                         _("Changed type of partition '%s' to '%s'."),
 558                         old, t ? fdisk_parttype_get_name(t) : _("Unknown"));
 559         else
 560                 fdisk_info(cxt,
 561                         _("Type of partition %zu is unchanged: %s."),
 562                         i + 1, old);
 563
 564         fdisk_unref_partition(pa);
 565 }
 566
 567 static size_t skip_empty(const unsigned char *buf, size_t i, size_t sz)
 568 {
 569         size_t next;
 570         const unsigned char *p0 = buf + i;
 571
 572         for (next = i + 16; next < sz; next += 16) {
 573                 if (memcmp(p0, buf + next, 16) != 0)
 574                         break;
 575         }
 576
 577         return next == i + 16 ? i : next;
 578 }
 579
 580 static void dump_buffer(off_t base, unsigned char *buf, size_t sz, int all)
 581 {
 582         size_t i, l, next = 0;
 583
 584         if (!buf)
 585                 return;
 586         for (i = 0, l = 0; i < sz; i++, l++) {
 587                 if (l == 0) {
 588                         if (all == 0 && !next)
 589                                 next = skip_empty(buf, i, sz);
 590                         printf("%08jx ", base + i);
 591                 }
 592                 printf(" %02x", buf[i]);
 593                 if (l == 7)                             /* words separator */
 594                         fputs(" ", stdout);
 595                 else if (l == 15) {
 596                         fputc('\n', stdout);            /* next line */
 597                         l = -1;
 598                         if (next > i) {
 599                                 printf("*\n");
 600                                 i = next - 1;
 601                         }
 602                         next = 0;
 603                 }
 604         }
 605         if (l > 0)
 606                 printf("\n");
 607 }
 608
 609 static void dump_blkdev(struct fdisk_context *cxt, const char *name,
 610                         uint64_t offset, size_t size, int all)
 611 {
 612         int fd = fdisk_get_devfd(cxt);
 613
 614         fdisk_info(cxt, _("\n%s: offset = %ju, size = %zu bytes."),
 615                         name, offset, size);
 616
 617         assert(fd >= 0);
 618
 619         if (lseek(fd, (off_t) offset, SEEK_SET) == (off_t) -1)
 620                 fdisk_warn(cxt, _("cannot seek"));
 621         else {
 622                 unsigned char *buf = xmalloc(size);
 623
 624                 if (read_all(fd, (char *) buf, size) != (ssize_t) size)
 625                         fdisk_warn(cxt, _("cannot read"));
 626                 else
 627                         dump_buffer(offset, buf, size, all);
 628                 free(buf);
 629         }
 630 }
 631
 632 void dump_firstsector(struct fdisk_context *cxt)
 633 {
 634         int all = !isatty(STDOUT_FILENO);
 635
 636         assert(cxt);
 637
 638         dump_blkdev(cxt, _("First sector"), 0, fdisk_get_sector_size(cxt), all);
 639 }
 640
 641 void dump_disklabel(struct fdisk_context *cxt)
 642 {
 643         int all = !isatty(STDOUT_FILENO);
 644         int i = 0;
 645         const char *name = NULL;
 646         uint64_t offset = 0;
 647         size_t size = 0;
 648
 649         assert(cxt);
 650
 651         while (fdisk_locate_disklabel(cxt, i++, &name, &offset, &size) == 0 && size)
 652                 dump_blkdev(cxt, name, offset, size, all);
 653 }
 654
 655 static fdisk_sector_t get_dev_blocks(char *dev)
 656 {
 657         int fd, ret;
 658         fdisk_sector_t size;
 659
 660         if ((fd = open(dev, O_RDONLY)) < 0)
 661                 err(EXIT_FAILURE, _("cannot open %s"), dev);
 662         ret = blkdev_get_sectors(fd, (unsigned long long *) &size);
 663         close(fd);
 664         if (ret < 0)
 665                 err(EXIT_FAILURE, _("BLKGETSIZE ioctl failed on %s"), dev);
 666         return size/2;
 667 }
 668
 669 static void __attribute__ ((__noreturn__)) usage(FILE *out)
 670 {
 671         fputs(USAGE_HEADER, out);
 672
 673         fprintf(out,
 674               _(" %1$s [options] <disk>      change partition table\n"
 675                 " %1$s [options] -l [<disk>] list partition table(s)\n"),
 676                program_invocation_short_name);
 677
 678         fputs(USAGE_SEPARATOR, out);
 679         fputs(_("Display or manipulate a disk partition table.\n"), out);
 680
 681         fputs(USAGE_OPTIONS, out);
 682         fputs(_(" -b, --sector-size <size>      physical and logical sector size\n"), out);
 683         fputs(_(" -B, --protect-boot            don't erase bootbits when creat a new label\n"), out);
 684         fputs(_(" -c, --compatibility[=<mode>]  mode is 'dos' or 'nondos' (default)\n"), out);
 685         fputs(_(" -L, --color[=<when>]          colorize output (auto, always or never)\n"), out);
 686         fprintf(out,
 687                 "                                 %s\n", USAGE_COLORS_DEFAULT);
 688         fputs(_(" -l, --list                    display partitions end exit\n"), out);
 689         fputs(_(" -o, --output <list>           output columns\n"), out);
 690         fputs(_(" -t, --type <type>             recognize specified partition table type only\n"), out);
 691         fputs(_(" -u, --units[=<unit>]          display units: 'cylinders' or 'sectors' (default)\n"), out);
 692         fputs(_(" -s, --getsz                   display device size in 512-byte sectors [DEPRECATED]\n"), out);
 693         fputs(_("     --bytes                   print SIZE in bytes rather than in human readable format\n"), out);
 694
 695         fputs(USAGE_SEPARATOR, out);
 696         fputs(_(" -C, --cylinders <number>      specify the number of cylinders\n"), out);
 697         fputs(_(" -H, --heads <number>          specify the number of heads\n"), out);
 698         fputs(_(" -S, --sectors <number>        specify the number of sectors per track\n"), out);
 699
 700         fputs(USAGE_SEPARATOR, out);
 701         fputs(USAGE_HELP, out);
 702         fputs(USAGE_VERSION, out);
 703
 704         list_available_columns(out);
 705
 706         fprintf(out, USAGE_MAN_TAIL("fdisk(8)"));
 707         exit(out == stderr ? EXIT_FAILURE : EXIT_SUCCESS);
 708 }
 709
 710
 711 enum {
 712         ACT_FDISK = 0,  /* default */
 713         ACT_LIST,
 714         ACT_SHOWSIZE
 715 };
 716
 717 int main(int argc, char **argv)
 718 {
 719         int rc, i, c, act = ACT_FDISK;
 720         int colormode = UL_COLORMODE_UNDEF;
 721         struct fdisk_context *cxt;
 722         char *outarg = NULL;
 723         enum {
 724                 OPT_BYTES       = CHAR_MAX + 1
 725         };
 726         static const struct option longopts[] = {
 727                 { "bytes",          no_argument,       NULL, OPT_BYTES },
 728                 { "color",          optional_argument, NULL, 'L' },
 729                 { "compatibility",  optional_argument, NULL, 'c' },
 730                 { "cylinders",      required_argument, NULL, 'C' },
 731                 { "heads",          required_argument, NULL, 'H' },
 732                 { "sectors",        required_argument, NULL, 'S' },
 733                 { "getsz",          no_argument,       NULL, 's' },
 734                 { "help",           no_argument,       NULL, 'h' },
 735                 { "list",           no_argument,       NULL, 'l' },
 736                 { "sector-size",    required_argument, NULL, 'b' },
 737                 { "type",           required_argument, NULL, 't' },
 738                 { "units",          optional_argument, NULL, 'u' },
 739                 { "version",        no_argument,       NULL, 'V' },
 740                 { "output",         no_argument,       NULL, 'o' },
 741                 { "protect-boot",   no_argument,       NULL, 'B' },
 742                 { NULL, 0, NULL, 0 }
 743         };
 744
 745         setlocale(LC_ALL, "");
 746         bindtextdomain(PACKAGE, LOCALEDIR);
 747         textdomain(PACKAGE);
 748         atexit(close_stdout);
 749
 750         fdisk_init_debug(0);
 751         fdiskprog_init_debug();
 752
 753         cxt = fdisk_new_context();
 754         if (!cxt)
 755                 err(EXIT_FAILURE, _("failed to allocate libfdisk context"));
 756
 757         fdisk_set_ask(cxt, ask_callback, NULL);
 758
 759         while ((c = getopt_long(argc, argv, "b:Bc::C:hH:lL::o:sS:t:u::vV",
 760                                 longopts, NULL)) != -1) {
 761                 switch (c) {
 762                 case 'b':
 763                 {
 764                         size_t sz = strtou32_or_err(optarg,
 765                                         _("invalid sector size argument"));
 766                         if (sz != 512 && sz != 1024 && sz != 2048 && sz != 4096)
 767                                 usage(stderr);
 768                         fdisk_save_user_sector_size(cxt, sz, sz);
 769                         break;
 770                 }
 771                 case 'B':
 772                         fdisk_enable_bootbits_protection(cxt, 1);
 773                         break;
 774                 case 'C':
 775                         fdisk_save_user_geometry(cxt,
 776                                 strtou32_or_err(optarg,
 777                                                 _("invalid cylinders argument")),
 778                                 0, 0);
 779                         break;
 780                 case 'c':
 781                         if (optarg) {
 782                                 /* this setting is independent on the current
 783                                  * actively used label
 784                                  */
 785                                 char *p = *optarg == '=' ? optarg + 1 : optarg;
 786                                 struct fdisk_label *lb = fdisk_get_label(cxt, "dos");
 787
 788                                 if (!lb)
 789                                         err(EXIT_FAILURE, _("not found DOS label driver"));
 790                                 if (strcmp(p, "dos") == 0)
 791                                         fdisk_dos_enable_compatible(lb, TRUE);
 792                                 else if (strcmp(p, "nondos") == 0)
 793                                         fdisk_dos_enable_compatible(lb, FALSE);
 794                                 else {
 795                                         warnx(_("unknown compatibility mode '%s'"), p);
 796                                         usage(stderr);
 797                                 }
 798                         }
 799                         /* use default if no optarg specified */
 800                         break;
 801                 case 'H':
 802                         fdisk_save_user_geometry(cxt, 0,
 803                                 strtou32_or_err(optarg,
 804                                                 _("invalid heads argument")),
 805                                 0);
 806                         break;
 807                 case 'S':
 808                         fdisk_save_user_geometry(cxt, 0, 0,
 809                                 strtou32_or_err(optarg,
 810                                         _("invalid sectors argument")));
 811                         break;
 812                 case 'l':
 813                         act = ACT_LIST;
 814                         break;
 815                 case 'L':
 816                         colormode = UL_COLORMODE_AUTO;
 817                         if (optarg)
 818                                 colormode = colormode_or_err(optarg,
 819                                                 _("unsupported color mode"));
 820                         break;
 821                 case 'o':
 822                         outarg = optarg;
 823                         break;
 824                 case 's':
 825                         act = ACT_SHOWSIZE;
 826                         break;
 827                 case 't':
 828                 {
 829                         struct fdisk_label *lb = NULL;
 830
 831                         while (fdisk_next_label(cxt, &lb) == 0)
 832                                 fdisk_label_set_disabled(lb, 1);
 833
 834                         lb = fdisk_get_label(cxt, optarg);
 835                         if (!lb)
 836                                 errx(EXIT_FAILURE, _("unsupported disklabel: %s"), optarg);
 837                         fdisk_label_set_disabled(lb, 0);
 838                         break;
 839                 }
 840                 case 'u':
 841                         if (optarg && *optarg == '=')
 842                                 optarg++;
 843                         if (fdisk_set_unit(cxt, optarg) != 0)
 844                                 usage(stderr);
 845                         break;
 846                 case 'V': /* preferred for util-linux */
 847                 case 'v': /* for backward compatibility only */
 848                         printf(UTIL_LINUX_VERSION);
 849                         return EXIT_SUCCESS;
 850                 case 'h':
 851                         usage(stdout);
 852                 case OPT_BYTES:
 853                         fdisk_set_size_unit(cxt, FDISK_SIZEUNIT_BYTES);
 854                         break;
 855                 default:
 856                         usage(stderr);
 857                 }
 858         }
 859
 860         if (argc-optind != 1 && fdisk_has_user_device_properties(cxt))
 861                 warnx(_("The device properties (sector size and geometry) should"
 862                         " be used with one specified device only."));
 863
 864         colors_init(colormode, "fdisk");
 865
 866         switch (act) {
 867         case ACT_LIST:
 868                 fdisk_enable_listonly(cxt, 1);
 869                 init_fields(cxt, outarg, NULL);
 870
 871                 if (argc > optind) {
 872                         int k;
 873                         for (k = optind; k < argc; k++)
 874                                 print_device_pt(cxt, argv[k], 1, 0);
 875                 } else
 876                         print_all_devices_pt(cxt, 0);
 877                 break;
 878
 879         case ACT_SHOWSIZE:
 880                 /* deprecated */
 881                 if (argc - optind <= 0)
 882                         usage(stderr);
 883
 884                 for (i = optind; i < argc; i++) {
 885                         uintmax_t blks = get_dev_blocks(argv[i]);
 886
 887                         if (argc - optind == 1)
 888                                 printf("%ju\n", blks);
 889                         else
 890                                 printf("%s: %ju\n", argv[i], blks);
 891                 }
 892                 break;
 893
 894         case ACT_FDISK:
 895                 if (argc-optind != 1)
 896                         usage(stderr);
 897
 898                 /* Here starts interactive mode, use fdisk_{warn,info,..} functions */
 899                 color_scheme_enable("welcome", UL_COLOR_GREEN);
 900                 fdisk_info(cxt, _("Welcome to fdisk (%s)."), PACKAGE_STRING);
 901                 color_disable();
 902                 fdisk_info(cxt, _("Changes will remain in memory only, until you decide to write them.\n"
 903                                   "Be careful before using the write command.\n"));
 904
 905                 rc = fdisk_assign_device(cxt, argv[optind], 0);
 906                 if (rc == -EACCES) {
 907                         rc = fdisk_assign_device(cxt, argv[optind], 1);
 908                         if (rc == 0)
 909                                 fdisk_warnx(cxt, _("Device open in read-only mode."));
 910                 }
 911                 if (rc)
 912                         err(EXIT_FAILURE, _("cannot open %s"), argv[optind]);
 913
 914                 fflush(stdout);
 915
 916                 if (!fdisk_has_label(cxt)) {
 917                         fdisk_info(cxt, _("Device does not contain a recognized partition table."));
 918                         fdisk_create_disklabel(cxt, NULL);
 919
 920                 } else if (fdisk_is_label(cxt, GPT) && fdisk_gpt_is_hybrid(cxt))
 921                         fdisk_warnx(cxt, _(
 922                                   "A hybrid GPT was detected. You have to sync "
 923                                   "the hybrid MBR manually (expert command 'M')."));
 924
 925                 init_fields(cxt, outarg, NULL);         /* -o <columns> */
 926
 927                 while (1)
 928                         process_fdisk_menu(&cxt);
 929         }
 930
 931         fdisk_unref_context(cxt);
 932         return EXIT_SUCCESS;
 933 }