fdisk: (bsd) rewrite list disklabel function

Signed-off-by: Karel Zak <kzak@redhat.com>

diff --git a/fdisks/fdisk-menu.c b/fdisks/fdisk-menu.c
index f78dfe762fec948cbbed4ffc53c5b84c53dd135e..59289ec9697e85db826f7c74bd90a15b579fdc30 100644 (file)
--- a/fdisks/fdisk-menu.c
+++ b/fdisks/fdisk-menu.c
@@ -558,7 +558,7 @@ static int bsd_menu_cb(struct fdisk_context **cxt0,
                       const struct menu_entry *ent)
 {
        struct fdisk_context *cxt = *cxt0;
-       int rc = 0;
+       int rc = 0, org;
 
        assert(cxt);
        assert(ent);
@@ -574,7 +574,11 @@ static int bsd_menu_cb(struct fdisk_context **cxt0,
                rc = fdisk_bsd_write_bootstrap(cxt);
                break;
        case 's':
-               xbsd_print_disklabel(cxt, 1);
+               org = fdisk_context_display_details(cxt);
+
+               fdisk_context_enable_details(cxt, 1);
+               fdisk_list_disklabel(cxt);
+               fdisk_context_enable_details(cxt, org);
                break;
        case 'x':
                rc = fdisk_bsd_link_partition(cxt);

diff --git a/fdisks/fdisk.c b/fdisks/fdisk.c
index 36f4361919e99ea4b83b7bbc60814a573c51882d..a27d64ee2c783d22d0e1a20daf4d98a3d5dd96c6 100644 (file)
--- a/fdisks/fdisk.c
+++ b/fdisks/fdisk.c
@@ -256,15 +256,10 @@ static void list_disk_geometry(struct fdisk_context *cxt)
        printf("\n");
 }
 
-static void list_table(struct fdisk_context *cxt, int xtra)
+static void list_table(struct fdisk_context *cxt)
 {
        list_disk_geometry(cxt);
-
-       if (fdisk_is_disklabel(cxt, BSD))
-               xbsd_print_disklabel(cxt, xtra);
-       else
-               fdisk_list_disklabel(cxt);
-
+       fdisk_list_disklabel(cxt);
 }
 
 static void verify(struct fdisk_context *cxt)
@@ -401,7 +396,7 @@ expert_command_prompt(struct fdisk_context *cxt)
                        fdisk_create_disklabel(cxt, "sgi");
                        break;
                case 'p':
-                       list_table(cxt, 1);
+                       list_table(cxt);
                        break;
                case 'q':
                        handle_quit(cxt);
@@ -439,7 +434,7 @@ static void print_partition_table_from_option(
                err(EXIT_FAILURE, _("cannot open %s"), device);
 
        if (fdisk_dev_has_disklabel(cxt))
-               list_table(cxt, 0);
+               list_table(cxt);
        else
                list_disk_geometry(cxt);
 }
@@ -557,7 +552,7 @@ static void command_prompt(struct fdisk_context *cxt)
                        fdisk_create_disklabel(cxt, "dos");
                        break;
                case 'p':
-                       list_table(cxt, 0);
+                       list_table(cxt);
                        break;
                case 'q':
                        handle_quit(cxt);

diff --git a/fdisks/fdiskbsdlabel.c b/fdisks/fdiskbsdlabel.c
index ab9642fb2f5f8701bafb1ddacd3ac5ac8a755d47..8792c507030597b75667b9cce3844b5f7c22c3d2 100644 (file)
--- a/fdisks/fdiskbsdlabel.c
+++ b/fdisks/fdiskbsdlabel.c
@@ -119,6 +119,7 @@ struct fdisk_bsd_label {
 #endif
 };
 
+static int bsd_list_disklabel(struct fdisk_context *cxt);
 
 static int xbsd_delete_part (struct fdisk_context *cxt, size_t partnum);
 static unsigned short xbsd_dkcksum (struct bsd_disklabel *lp);
@@ -343,9 +344,14 @@ static int xbsd_create_disklabel(struct fdisk_context *cxt)
 
        rc = xbsd_initlabel(cxt);
        if (!rc) {
-               xbsd_print_disklabel (cxt, 1);
+               int org = fdisk_context_display_details(cxt);
+
                cxt->label->nparts_cur = d->d_npartitions;
                cxt->label->nparts_max = BSD_MAXPARTITIONS;
+
+               fdisk_context_enable_details(cxt, 1);
+               bsd_list_disklabel(cxt);
+               fdisk_context_enable_details(cxt, org);
        }
 
        return rc;
@@ -370,101 +376,138 @@ static int xbsd_delete_part(
        return 0;
 }
 
-void
-xbsd_print_disklabel (struct fdisk_context *cxt, int show_all)
+static int bsd_list_disklabel(struct fdisk_context *cxt)
 {
-  struct bsd_disklabel *lp = self_disklabel(cxt);
-  struct bsd_partition *pp;
-  FILE *f = stdout;
-  int i, j;
-
-  if (show_all) {
-    fprintf(f, "# %s:\n", cxt->dev_path);
-    if ((unsigned) lp->d_type < BSD_DKMAXTYPES)
-      fprintf(f, _("type: %s\n"), xbsd_dktypenames[lp->d_type]);
-    else
-      fprintf(f, _("type: %d\n"), lp->d_type);
-    fprintf(f, _("disk: %.*s\n"), (int) sizeof(lp->d_typename), lp->d_typename);
-    fprintf(f, _("label: %.*s\n"), (int) sizeof(lp->d_packname), lp->d_packname);
-    fprintf(f, _("flags:"));
-    if (lp->d_flags & BSD_D_REMOVABLE)
-      fprintf(f, _(" removable"));
-    if (lp->d_flags & BSD_D_ECC)
-      fprintf(f, _(" ecc"));
-    if (lp->d_flags & BSD_D_BADSECT)
-      fprintf(f, _(" badsect"));
-    fprintf(f, "\n");
-    /* On various machines the fields of *lp are short/int/long */
-    /* In order to avoid problems, we cast them all to long. */
-    fprintf(f, _("bytes/sector: %ld\n"), (long) lp->d_secsize);
-    fprintf(f, _("sectors/track: %ld\n"), (long) lp->d_nsectors);
-    fprintf(f, _("tracks/cylinder: %ld\n"), (long) lp->d_ntracks);
-    fprintf(f, _("sectors/cylinder: %ld\n"), (long) lp->d_secpercyl);
-    fprintf(f, _("cylinders: %ld\n"), (long) lp->d_ncylinders);
-    fprintf(f, _("rpm: %d\n"), lp->d_rpm);
-    fprintf(f, _("interleave: %d\n"), lp->d_interleave);
-    fprintf(f, _("trackskew: %d\n"), lp->d_trackskew);
-    fprintf(f, _("cylinderskew: %d\n"), lp->d_cylskew);
-    fprintf(f, _("headswitch: %ld\t\t# milliseconds\n"),
-           (long) lp->d_headswitch);
-    fprintf(f, _("track-to-track seek: %ld\t# milliseconds\n"),
-           (long) lp->d_trkseek);
-    fprintf(f, _("drivedata: "));
-    for (i = ARRAY_SIZE(lp->d_drivedata)- 1; i >= 0; i--)
-      if (lp->d_drivedata[i])
-       break;
-    if (i < 0)
-      i = 0;
-    for (j = 0; j <= i; j++)
-      fprintf(f, "%ld ", (long) lp->d_drivedata[j]);
-  }
-  fprintf (f, _("\n%d partitions:\n"), lp->d_npartitions);
-  fprintf (f, _("#       start       end      size     fstype   [fsize bsize   cpg]\n"));
-  pp = lp->d_partitions;
-  for (i = 0; i < lp->d_npartitions; i++, pp++) {
-    if (pp->p_size) {
-      if (fdisk_context_use_cylinders(cxt) && lp->d_secpercyl) {
-       fprintf(f, "  %c: %8ld%c %8ld%c %8ld%c  ",
-               'a' + i,
-               (long) pp->p_offset / lp->d_secpercyl + 1,
-               (pp->p_offset % lp->d_secpercyl) ? '*' : ' ',
-               (long) (pp->p_offset + pp->p_size + lp->d_secpercyl - 1)
-                       / lp->d_secpercyl,
-               ((pp->p_offset + pp->p_size) % lp->d_secpercyl) ? '*' : ' ',
-               (long) pp->p_size / lp->d_secpercyl,
-               (pp->p_size % lp->d_secpercyl) ? '*' : ' ');
-      } else {
-       fprintf(f, "  %c: %8ld  %8ld  %8ld   ",
-               'a' + i,
-               (long) pp->p_offset,
-               (long) pp->p_offset + pp->p_size - 1,
-               (long) pp->p_size);
-      }
-      if ((unsigned) pp->p_fstype < BSD_FSMAXTYPES)
-       fprintf(f, "%8.8s", xbsd_fstypes[pp->p_fstype].name);
-      else
-       fprintf(f, "%8x", pp->p_fstype);
-      switch (pp->p_fstype) {
-       case BSD_FS_UNUSED:
-         fprintf(f, "    %5ld %5ld %5.5s ",
-                 (long) pp->p_fsize, (long) pp->p_fsize * pp->p_frag, "");
-         break;
-
-       case BSD_FS_BSDFFS:
-         fprintf(f, "    %5ld %5ld %5d ",
-                 (long) pp->p_fsize, (long) pp->p_fsize * pp->p_frag,
-                 pp->p_cpg);
-         break;
+       struct bsd_disklabel *d = self_disklabel(cxt);
+       struct bsd_partition *p;
+       struct tt *tb = NULL;
+       int i, rc, trunc = TT_FL_TRUNC;
 
-       default:
-         fprintf(f, "%22.22s", "");
-         break;
-      }
-      fprintf(f, "\n");
-    }
-  }
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, BSD));
+
+       if (fdisk_context_display_details(cxt)) {
+               fdisk_info(cxt, "# %s:", cxt->dev_path);
+
+               if ((unsigned) d->d_type < BSD_DKMAXTYPES)
+                       fdisk_info(cxt, _("type: %s"), xbsd_dktypenames[d->d_type]);
+               else
+                       fdisk_info(cxt, _("type: %d"), d->d_type);
+
+               fdisk_info(cxt, _("disk: %.*s"), (int) sizeof(d->d_typename), d->d_typename);
+               fdisk_info(cxt, _("label: %.*s"), (int) sizeof(d->d_packname), d->d_packname);
+
+               fdisk_info(cxt, _("flags: %s"),
+                       d->d_flags & BSD_D_REMOVABLE ? _(" removable") :
+                       d->d_flags & BSD_D_ECC ? _(" ecc") :
+                       d->d_flags & BSD_D_BADSECT ? _(" badsect") : "");
+
+               /* On various machines the fields of *lp are short/int/long */
+               /* In order to avoid problems, we cast them all to long. */
+               fdisk_info(cxt, _("bytes/sector: %ld"), (long) d->d_secsize);
+               fdisk_info(cxt, _("sectors/track: %ld"), (long) d->d_nsectors);
+               fdisk_info(cxt, _("tracks/cylinder: %ld"), (long) d->d_ntracks);
+               fdisk_info(cxt, _("sectors/cylinder: %ld"), (long) d->d_secpercyl);
+               fdisk_info(cxt, _("cylinders: %ld"), (long) d->d_ncylinders);
+               fdisk_info(cxt, _("rpm: %d"), d->d_rpm);
+               fdisk_info(cxt, _("interleave: %d"), d->d_interleave);
+               fdisk_info(cxt, _("trackskew: %d"), d->d_trackskew);
+               fdisk_info(cxt, _("cylinderskew: %d"), d->d_cylskew);
+               fdisk_info(cxt, _("headswitch: %ld (milliseconds)"), (long) d->d_headswitch);
+               fdisk_info(cxt, _("track-to-track seek: %ld (milliseconds)"), (long) d->d_trkseek);
+               /*
+               fdisk_info(cxt, _("drivedata: "));
+               for (i = ARRAY_SIZE(d->d_drivedata)- 1; i >= 0; i--)
+                       if (d->d_drivedata[i])
+                               break;
+               if (i < 0)
+                       i = 0;
+               for (j = 0; j <= i; j++)
+                       fdisk_info(cxt, "%ld ", (long) d->d_drivedata[j]);
+               */
+       }
+
+       fdisk_info(cxt, _("partitions: %d"), d->d_npartitions);
+
+       tb = tt_new_table(TT_FL_FREEDATA);
+       if (!tb)
+               return -ENOMEM;
+
+       /* don't trunc anything in expert mode */
+       if (fdisk_context_display_details(cxt))
+               trunc = 0;
+
+       tt_define_column(tb, _("#"),        1, 0);
+       tt_define_column(tb, _("Start"),    9, TT_FL_RIGHT);
+       tt_define_column(tb, _("End"),      9, TT_FL_RIGHT);
+       tt_define_column(tb, _("Size"),     9, TT_FL_RIGHT);
+       tt_define_column(tb, _("Type"),     8, 0);
+       tt_define_column(tb, _("fsize"),    5, trunc);
+       tt_define_column(tb, _("bsize"),    5, trunc);
+       tt_define_column(tb, _("cpg"),      5, trunc);
+
+       for (i = 0, p = d->d_partitions; i < d->d_npartitions; i++, p++) {
+               char *s;
+               struct tt_line *ln;
+
+               if (!p->p_size)
+                       continue;
+               ln = tt_add_line(tb, NULL);
+               if (!ln)
+                       continue;
+
+               if (asprintf(&s, "%c", i + 'a') > 0)
+                       tt_line_set_data(ln, 0, s);
+
+               if (fdisk_context_use_cylinders(cxt) && d->d_secpercyl) {
+                       if (asprintf(&s, "%u%c",
+                                       p->p_offset / d->d_secpercyl + 1,
+                                       p->p_offset % d->d_secpercyl ? '*' : ' ') > 0)
+                               tt_line_set_data(ln, 1, s);
+                       if (asprintf(&s, "%u%c",
+                                       (p->p_offset + p->p_size + d->d_secpercyl - 1) / d->d_secpercyl,
+                                       (p->p_offset + p->p_size) % d->d_secpercyl ? '*' : ' ') > 0)
+                               tt_line_set_data(ln, 2, s);
+                       if (asprintf(&s, "%u%c",
+                                       p->p_size / d->d_secpercyl,
+                                       p->p_size % d->d_secpercyl ? '*' : ' ') > 0)
+                               tt_line_set_data(ln, 3, s);
+               } else {
+                       if (asprintf(&s, "%u", p->p_offset) > 0)
+                               tt_line_set_data(ln, 1, s);
+                       if (asprintf(&s, "%u", p->p_offset + p->p_size - 1) > 0)
+                               tt_line_set_data(ln, 2, s);
+                       if (asprintf(&s, "%u", p->p_size) > 0)
+                               tt_line_set_data(ln, 3, s);
+               }
+
+               if ((unsigned) p->p_fstype < BSD_FSMAXTYPES)
+                       rc = asprintf(&s, "%s", xbsd_fstypes[p->p_fstype].name);
+               else
+                       rc = asprintf(&s, "%x", p->p_fstype);
+               if (rc > 0)
+                       tt_line_set_data(ln, 4, s);
+
+               if (p->p_fstype == BSD_FS_UNUSED
+                   || p->p_fstype == BSD_FS_BSDFFS) {
+                       if (asprintf(&s, "%u", p->p_fsize) > 0)
+                               tt_line_set_data(ln, 5, s);
+                       if (asprintf(&s, "%u", p->p_fsize * p->p_frag) > 0)
+                               tt_line_set_data(ln, 6, s);
+               }
+               if (p->p_fstype == BSD_FS_BSDFFS
+                   && asprintf(&s, "%u", p->p_cpg) > 0)
+                       tt_line_set_data(ln, 7, s);
+       }
+
+       rc = fdisk_print_table(cxt, tb);
+       tt_free_table(tb);
+
+       return rc;
 }
 
+
 static uint32_t ask_uint32(struct fdisk_context *cxt,
                uint32_t dflt, char *mesg)
 {
@@ -923,6 +966,7 @@ static int bsd_get_partition_status(
 static const struct fdisk_label_operations bsd_operations =
 {
        .probe          = bsd_probe_label,
+       .list           = bsd_list_disklabel,
        .write          = xbsd_write_disklabel,
        .create         = xbsd_create_disklabel,
        .part_add       = xbsd_add_part,

diff --git a/fdisks/fdiskbsdlabel.h b/fdisks/fdiskbsdlabel.h
index b7274fdba202c209238d9487ec1c141c5230aa71..e06e5e938561e460cb9f327c0d01dde75a391641 100644 (file)
--- a/fdisks/fdiskbsdlabel.h
+++ b/fdisks/fdiskbsdlabel.h
@@ -38,7 +38,6 @@
 #include "pt-bsd.h"
 
 extern int btrydev(struct fdisk_context *cxt);
-extern void xbsd_print_disklabel(struct fdisk_context *cxt, int);
 
 /* public bsd specific functions */
 extern int fdisk_bsd_edit_disklabel(struct fdisk_context *cxt);