fdisk: remove fdisk_label from API functions, add asserts, use size_t

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

diff --git a/fdisks/fdiskaixlabel.c b/fdisks/fdiskaixlabel.c
index 41547bdbe4fc460e4c1caf25175ff002afb3750f..3d95f465f8e83db795a5eb485c66bd61d898a353 100644 (file)
--- a/fdisks/fdiskaixlabel.c
+++ b/fdisks/fdiskaixlabel.c
@@ -55,11 +55,15 @@ static void aix_nolabel(struct fdisk_context *cxt)
     return;
 }
 
-static int aix_probe_label(
-               struct fdisk_context *cxt,
-               struct fdisk_label *lb __attribute__((__unused__)))
+static int aix_probe_label(struct fdisk_context *cxt)
 {
-    struct aix_partition *aixlabel = (struct aix_partition *) cxt->firstsector;
+    struct aix_partition *aixlabel;
+
+    assert(cxt);
+    assert(cxt->label);
+    assert(fdisk_is_disklabel(cxt, GPT));
+
+    aixlabel = (struct aix_partition *) cxt->firstsector;
 
     if (aixlabel->magic != AIX_LABEL_MAGIC &&
        aixlabel->magic != AIX_LABEL_MAGIC_SWAPPED) {
@@ -73,10 +77,10 @@ static int aix_probe_label(
     return 1;
 }
 
+/* TODO: remove this, libfdisk has to return ENOSYS */
 static int aix_add_partition(
                struct fdisk_context *cxt __attribute__((__unused__)),
-               struct fdisk_label *lb __attribute__((__unused__)),
-               int partnum __attribute__((__unused__)),
+               size_t partnum __attribute__((__unused__)),
                struct fdisk_parttype *t __attribute__((__unused__)))
 {
        printf(_("\tSorry - this fdisk cannot handle AIX disk labels."

diff --git a/fdisks/fdiskbsdlabel.c b/fdisks/fdiskbsdlabel.c
index b5d0b64ea24f59d05ce6747b776279d7bb3a5188..5ef49cddb8939dea23f49856bca828d06a06deea 100644 (file)
--- a/fdisks/fdiskbsdlabel.c
+++ b/fdisks/fdiskbsdlabel.c
@@ -70,11 +70,10 @@ struct fdisk_bsd_label {
 };
 
 
-static int xbsd_delete_part (struct fdisk_context *cxt,
-                            struct fdisk_label *lb, int partnum);
+static int xbsd_delete_part (struct fdisk_context *cxt, size_t partnum);
 static void xbsd_edit_disklabel (struct fdisk_context *cxt);
 static void xbsd_write_bootstrap (struct fdisk_context *cxt);
-static void xbsd_change_fstype (struct fdisk_context *cxt, struct fdisk_label *lb);
+static void xbsd_change_fstype (struct fdisk_context *cxt);
 static int xbsd_get_part_index (struct fdisk_context *cxt, int max);
 static int xbsd_check_new_partition (struct fdisk_context *cxt, int *i);
 static unsigned short xbsd_dkcksum (struct xbsd_disklabel *lp);
@@ -116,16 +115,20 @@ static struct xbsd_disklabel xbsd_dlabel;
  * so this does not mean that there is a BSD disk label.
  */
 static int
-osf_probe_label(struct fdisk_context *cxt,
-               struct fdisk_label *lb __attribute__((__unused__)))
+osf_probe_label(struct fdisk_context *cxt)
 {
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, OSF));
+
        if (xbsd_readlabel (cxt, NULL, &xbsd_dlabel) == 0)
                return 0;
        return 1;
 }
 
 int
-btrydev (struct fdisk_context *cxt) {
+btrydev (struct fdisk_context *cxt)
+{
        if (xbsd_readlabel (cxt, NULL, &xbsd_dlabel) == 0)
                return -1;
        printf(_("\nBSD label for device: %s\n"), cxt->dev_path);
@@ -134,13 +137,13 @@ btrydev (struct fdisk_context *cxt) {
 }
 
 #if !defined (__alpha__)
-static int
-hidden(int type) {
+static int hidden(int type)
+{
        return type ^ 0x10;
 }
 
-static int
-is_bsd_partition_type(int type) {
+static int is_bsd_partition_type(int type)
+{
        return (type == FREEBSD_PARTITION ||
                type == hidden(FREEBSD_PARTITION) ||
                type == NETBSD_PARTITION ||
@@ -148,8 +151,7 @@ is_bsd_partition_type(int type) {
 }
 #endif
 
-static int xbsd_write_disklabel (struct fdisk_context *cxt,
-               struct fdisk_label *lb __attribute__((__unused__)))
+static int xbsd_write_disklabel (struct fdisk_context *cxt)
 {
 #if defined (__alpha__)
        printf (_("Writing disklabel to %s.\n"), cxt->dev_path);
@@ -165,14 +167,17 @@ static int xbsd_write_disklabel (struct fdisk_context *cxt,
 }
 
 static int xbsd_add_part (struct fdisk_context *cxt,
-               struct fdisk_label *lb,
-               int partnum __attribute__((__unused__)),
+               size_t partnum __attribute__((__unused__)),
                struct fdisk_parttype *t __attribute__((__unused__)))
 {
        unsigned int begin, end;
        char mesg[256];
        int i, rc;
 
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, OSF));
+
        rc = xbsd_check_new_partition(cxt, &i);
        if (rc)
                return rc;
@@ -204,17 +209,20 @@ static int xbsd_add_part (struct fdisk_context *cxt,
        xbsd_dlabel.d_partitions[i].p_offset = begin;
        xbsd_dlabel.d_partitions[i].p_fstype = BSD_FS_UNUSED;
 
-       lb->nparts_cur = xbsd_dlabel.d_npartitions;
-       fdisk_label_set_changed(lb, 1);
+       cxt->label->nparts_cur = xbsd_dlabel.d_npartitions;
+       fdisk_label_set_changed(cxt->label, 1);
 
        return 0;
 }
 
-static int xbsd_create_disklabel(struct fdisk_context *cxt,
-                                struct fdisk_label *lb)
+static int xbsd_create_disklabel(struct fdisk_context *cxt)
 {
        char c;
 
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, OSF));
+
 #if defined (__alpha__)
        fprintf (stderr, _("%s contains no disklabel.\n"), cxt->dev_path);
 #else
@@ -234,8 +242,8 @@ static int xbsd_create_disklabel(struct fdisk_context *cxt,
 #endif
                                ) == 1) {
                                xbsd_print_disklabel (cxt, 1);
-                               lb->nparts_cur = xbsd_dlabel.d_npartitions;
-                               lb->nparts_max = BSD_MAXPARTITIONS;
+                               cxt->label->nparts_cur = xbsd_dlabel.d_npartitions;
+                               cxt->label->nparts_max = BSD_MAXPARTITIONS;
                                return 1;
                        } else
                                return 0;
@@ -265,7 +273,7 @@ bsd_command_prompt (struct fdisk_context *cxt)
       printf (_("Reading disklabel of %s at sector %d.\n"),
              partname(cxt->dev_path, t+1, 0), ss + BSD_LABELSECTOR);
       if (xbsd_readlabel (cxt, xbsd_part, &xbsd_dlabel) == 0)
-       if (xbsd_create_disklabel (cxt, cxt->label) == 0)
+       if (xbsd_create_disklabel (cxt) == 0)
          return;
       break;
     }
@@ -288,8 +296,7 @@ bsd_command_prompt (struct fdisk_context *cxt)
     putchar ('\n');
     switch (tolower (read_char(cxt, _("BSD disklabel command (m for help): ")))) {
       case 'd':
-             xbsd_delete_part(cxt, cxt->label,
-                             xbsd_get_part_index(cxt, xbsd_dlabel.d_npartitions));
+             xbsd_delete_part(cxt, xbsd_get_part_index(cxt, xbsd_dlabel.d_npartitions));
              break;
       case 'e':
        xbsd_edit_disklabel (cxt);
@@ -301,7 +308,7 @@ bsd_command_prompt (struct fdisk_context *cxt)
        list_partition_types (cxt);
        break;
       case 'n':
-             xbsd_add_part (cxt, cxt->label, 0, 0);
+             xbsd_add_part (cxt, 0, 0);
              break;
       case 'p':
              xbsd_print_disklabel (cxt, 0);
@@ -315,13 +322,13 @@ bsd_command_prompt (struct fdisk_context *cxt)
              xbsd_print_disklabel (cxt, 1);
        break;
       case 't':
-       xbsd_change_fstype (cxt, cxt->label);
+       xbsd_change_fstype (cxt);
        break;
       case 'u':
        change_units(cxt);
        break;
       case 'w':
-       xbsd_write_disklabel (cxt, cxt->label);
+       xbsd_write_disklabel (cxt);
        break;
 #if !defined (__alpha__)
       case 'x':
@@ -336,10 +343,13 @@ bsd_command_prompt (struct fdisk_context *cxt)
 }
 
 static int xbsd_delete_part(
-               struct fdisk_context *cxt __attribute__((__unused__)),
-               struct fdisk_label *lb,
-               int partnum)
+               struct fdisk_context *cxt,
+               size_t partnum)
 {
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, OSF));
+
        xbsd_dlabel.d_partitions[partnum].p_size   = 0;
        xbsd_dlabel.d_partitions[partnum].p_offset = 0;
        xbsd_dlabel.d_partitions[partnum].p_fstype = BSD_FS_UNUSED;
@@ -347,13 +357,14 @@ static int xbsd_delete_part(
                while (!xbsd_dlabel.d_partitions[xbsd_dlabel.d_npartitions-1].p_size)
                        xbsd_dlabel.d_npartitions--;
 
-       lb->nparts_cur = xbsd_dlabel.d_npartitions;
-       fdisk_label_set_changed(lb, 1);
+       cxt->label->nparts_cur = xbsd_dlabel.d_npartitions;
+       fdisk_label_set_changed(cxt->label, 1);
        return 0;
 }
 
 void
-xbsd_print_disklabel (struct fdisk_context *cxt, int show_all) {
+xbsd_print_disklabel (struct fdisk_context *cxt, int show_all)
+{
   struct xbsd_disklabel *lp = &xbsd_dlabel;
   struct xbsd_partition *pp;
   FILE *f = stdout;
@@ -589,21 +600,22 @@ xbsd_write_bootstrap (struct fdisk_context *cxt)
 }
 
 /* TODO: remove this, use regular change_partition_type() in fdisk.c */
-static void
-xbsd_change_fstype (
-               struct fdisk_context *cxt,
-               struct fdisk_label *lb)
+static void xbsd_change_fstype (struct fdisk_context *cxt)
 {
   int i;
   struct fdisk_parttype *t;
 
+  assert(cxt);
+  assert(cxt->label);
+  assert(fdisk_is_disklabel(cxt, OSF));
+
   i = xbsd_get_part_index (cxt, xbsd_dlabel.d_npartitions);
   t = read_partition_type(cxt);
 
   if (t) {
     xbsd_dlabel.d_partitions[i].p_fstype = t->type;
     fdisk_free_parttype(t);
-    fdisk_label_set_changed(lb, 1);
+    fdisk_label_set_changed(cxt->label, 1);
   }
 }
 
@@ -621,8 +633,8 @@ xbsd_get_part_index(struct fdisk_context *cxt, int max)
 }
 
 static int
-xbsd_check_new_partition(struct fdisk_context *cxt, int *i) {
-
+xbsd_check_new_partition(struct fdisk_context *cxt, int *i)
+{
        /* room for more? various BSD flavours have different maxima */
        if (xbsd_dlabel.d_npartitions == BSD_MAXPARTITIONS) {
                int t;
@@ -886,11 +898,14 @@ alpha_bootblock_checksum (char *boot)
 
 static struct fdisk_parttype *xbsd_get_parttype(
                struct fdisk_context *cxt,
-               struct fdisk_label *lb __attribute__((__unused__)),
-               int n)
+               size_t n)
 {
        struct fdisk_parttype *t;
 
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, OSF));
+
        if (n >= xbsd_dlabel.d_npartitions)
                return NULL;
 
@@ -901,13 +916,16 @@ static struct fdisk_parttype *xbsd_get_parttype(
 }
 
 static int xbsd_set_parttype(
-               struct fdisk_context *cxt __attribute__((__unused__)),
-               struct fdisk_label *lb,
-               int partnum,
+               struct fdisk_context *cxt,
+               size_t partnum,
                struct fdisk_parttype *t)
 {
        struct xbsd_partition *p;
 
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, OSF));
+
        if (partnum >= xbsd_dlabel.d_npartitions || !t || t->type > UINT8_MAX)
                return -EINVAL;
 
@@ -916,7 +934,7 @@ static int xbsd_set_parttype(
                return 0;
 
        p->p_fstype = t->type;
-       fdisk_label_set_changed(lb, 1);
+       fdisk_label_set_changed(cxt->label, 1);
        return 0;
 }
 

diff --git a/fdisks/fdiskdoslabel.c b/fdisks/fdiskdoslabel.c
index acdbc86a5989d3e58063daa3a1c7d200a8ce4f9e..e622ac51769a70b496cd06a40fbda7bb7ee2ed91 100644 (file)
--- a/fdisks/fdiskdoslabel.c
+++ b/fdisks/fdiskdoslabel.c
@@ -204,12 +204,8 @@ void dos_init(struct fdisk_context *cxt)
        warn_alignment(cxt);
 }
 
-static int dos_delete_partition(
-               struct fdisk_context *cxt __attribute__ ((__unused__)),
-               struct fdisk_label *lb,
-               int n)
+static int dos_delete_partition(struct fdisk_context *cxt, size_t partnum)
 {
-       size_t partnum = (size_t) n;                    /* TODO: use size_t in API */
        struct pte *pe = &ptes[partnum];
        struct partition *p = pe->part_table;
        struct partition *q = pe->ext_pointer;
@@ -262,7 +258,7 @@ static int dos_delete_partition(
                        clear_partition(ptes[partnum].part_table);
        }
 
-       fdisk_label_set_changed(lb, 1);
+       fdisk_label_set_changed(cxt->label, 1);
        return 0;
 }
 
@@ -354,7 +350,7 @@ static void read_extended(struct fdisk_context *cxt, int ext)
                if (!get_nr_sects(pe->part_table) &&
                    (cxt->label->nparts_max > 5 || ptes[4].part_table->sys_ind)) {
                        printf(_("omitting empty partition (%zd)\n"), i+1);
-                       dos_delete_partition(cxt, cxt->label, i);
+                       dos_delete_partition(cxt, i);
                        goto remove;    /* numbering changed */
                }
        }
@@ -365,11 +361,14 @@ void dos_print_mbr_id(struct fdisk_context *cxt)
        printf(_("Disk identifier: 0x%08x\n"), mbr_get_id(cxt->firstsector));
 }
 
-static int dos_create_disklabel(struct fdisk_context *cxt,
-               struct fdisk_label *lb __attribute__((__unused__)))
+static int dos_create_disklabel(struct fdisk_context *cxt)
 {
        unsigned int id;
 
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, DOS));
+
        /* random disk signature */
        random_get_bytes(&id, sizeof(id));
 
@@ -441,9 +440,12 @@ static void get_partition_table_geometry(struct fdisk_context *cxt,
        DBG(CONTEXT, dbgprint("DOS PT geometry: heads=%u, sectors=%u", *ph, *ps));
 }
 
-static int dos_reset_alignment(struct fdisk_context *cxt,
-               struct fdisk_label *lb __attribute__((__unused__)))
+static int dos_reset_alignment(struct fdisk_context *cxt)
 {
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, DOS));
+
        /* overwrite necessary stuff by DOS deprecated stuff */
        if (is_dos_compatible(cxt)) {
                if (cxt->geom.sectors)
@@ -457,13 +459,14 @@ static int dos_reset_alignment(struct fdisk_context *cxt,
        return 0;
 }
 
-static int dos_probe_label(struct fdisk_context *cxt, struct fdisk_label *lb)
+static int dos_probe_label(struct fdisk_context *cxt)
 {
        size_t i;
        unsigned int h = 0, s = 0;
 
        assert(cxt);
        assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, DOS));
 
        if (!mbr_is_valid_magic(cxt->firstsector))
                return 0;
@@ -500,7 +503,7 @@ static int dos_probe_label(struct fdisk_context *cxt, struct fdisk_label *lb)
                                "table %zd will be corrected by w(rite)\n"),
                                part_table_flag(pe->sectorbuffer), i + 1);
                        pe->changed = 1;
-                       fdisk_label_set_changed(lb, 1);
+                       fdisk_label_set_changed(cxt->label, 1);
                }
        }
 
@@ -859,8 +862,7 @@ static void check_consistency(struct fdisk_context *cxt, struct partition *p,
        }
 }
 
-static int dos_verify_disklabel(struct fdisk_context *cxt,
-               struct fdisk_label *lb __attribute__((__unused__)))
+static int dos_verify_disklabel(struct fdisk_context *cxt)
 {
        size_t i, j;
        sector_t total = 1, n_sectors = cxt->total_sectors;
@@ -868,6 +870,10 @@ static int dos_verify_disklabel(struct fdisk_context *cxt,
                           last[cxt->label->nparts_max];
        struct partition *p;
 
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, DOS));
+
        fill_bounds(cxt, first, last);
        for (i = 0; i < cxt->label->nparts_max; i++) {
                struct pte *pe = &ptes[i];
@@ -933,13 +939,16 @@ static int dos_verify_disklabel(struct fdisk_context *cxt,
  */
 static int dos_add_partition(
                        struct fdisk_context *cxt,
-                       struct fdisk_label *lb __attribute__((__unused__)),
-                       int partnum __attribute__ ((__unused__)),
+                       size_t partnum __attribute__ ((__unused__)),
                        struct fdisk_parttype *t)
 {
        size_t i, free_primary = 0;
        int rc = 0;
 
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, DOS));
+
        for (i = 0; i < 4; i++)
                free_primary += !ptes[i].part_table->sys_ind;
 
@@ -1019,12 +1028,15 @@ static int write_sector(struct fdisk_context *cxt, sector_t secno,
        return 0;
 }
 
-static int dos_write_disklabel(struct fdisk_context *cxt,
-               struct fdisk_label *lb __attribute__((__unused__)))
+static int dos_write_disklabel(struct fdisk_context *cxt)
 {
        size_t i;
        int rc = 0;
 
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, DOS));
+
        /* MBR (primary partitions) */
        if (!MBRbuffer_changed) {
                for (i = 0; i < 4; i++)
@@ -1055,13 +1067,16 @@ done:
 
 static struct fdisk_parttype *dos_get_parttype(
                struct fdisk_context *cxt,
-               struct fdisk_label *lb __attribute__((__unused__)),
-               int partnum)
+               size_t partnum)
 {
        struct fdisk_parttype *t;
        struct partition *p;
 
-       if (partnum < 0 || (size_t) partnum >= cxt->label->nparts_max)
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, OSF));
+
+       if (partnum >= cxt->label->nparts_max)
                return NULL;
 
        p = ptes[partnum].part_table;
@@ -1073,14 +1088,16 @@ static struct fdisk_parttype *dos_get_parttype(
 
 static int dos_set_parttype(
                struct fdisk_context *cxt,
-               struct fdisk_label *lb,
-               int partnum,
+               size_t partnum,
                struct fdisk_parttype *t)
 {
        struct partition *p;
 
-       if (partnum < 0 || (size_t) partnum >= cxt->label->nparts_max
-           || !t || t->type > UINT8_MAX)
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, OSF));
+
+       if (partnum >= cxt->label->nparts_max || !t || t->type > UINT8_MAX)
                return -EINVAL;
 
        p = ptes[partnum].part_table;
@@ -1100,7 +1117,7 @@ static int dos_set_parttype(
                "information.\n\n"));
 
        p->sys_ind = t->type;
-       fdisk_label_set_changed(lb, 1);
+       fdisk_label_set_changed(cxt->label, 1);
        return 0;
 }
 
@@ -1159,6 +1176,7 @@ int dos_list_table(struct fdisk_context *cxt,
        size_t i, w;
 
        assert(cxt);
+       assert(cxt->label);
        assert(fdisk_is_disklabel(cxt, DOS));
 
        if (is_garbage_table()) {
@@ -1422,17 +1440,17 @@ void dos_toggle_active(struct fdisk_context *cxt, int i)
 
 static int dos_get_partition_status(
                struct fdisk_context *cxt,
-               struct fdisk_label *lb __attribute__((__unused__)),
-               int i,
+               size_t i,
                int *status)
 {
        struct pte *pe;
        struct partition *p;
 
        assert(cxt);
+       assert(cxt->label);
        assert(fdisk_is_disklabel(cxt, DOS));
 
-       if (!status || i < 0 || (size_t) i >= cxt->label->nparts_max)
+       if (!status || i >= cxt->label->nparts_max)
                return -EINVAL;
 
        *status = FDISK_PARTSTAT_NONE;

diff --git a/fdisks/fdiskmaclabel.c b/fdisks/fdiskmaclabel.c
index 14307fab02e2e94e6cad3a83738098965a3ae605..a91cabc0947f4390421ef6fd5b01b188b07f8710 100644 (file)
--- a/fdisks/fdiskmaclabel.c
+++ b/fdisks/fdiskmaclabel.c
@@ -56,8 +56,7 @@ mac_nolabel(struct fdisk_context *cxt)
 }
 
 static int
-mac_probe_label(struct fdisk_context *cxt,
-               struct fdisk_label *lb __attribute__((__unused__)))
+mac_probe_label(struct fdisk_context *cxt)
 {
        struct mac_partition *maclabel = (struct mac_partition *) cxt->firstsector;
 
@@ -91,8 +90,7 @@ IS_MAC:
 
 static int mac_add_partition(
                struct fdisk_context *cxt __attribute__ ((__unused__)),
-               struct fdisk_label *lb __attribute__((__unused__)),
-               int partnum __attribute__ ((__unused__)),
+               size_t partnum __attribute__ ((__unused__)),
                struct fdisk_parttype *t __attribute__ ((__unused__)))
 {
        printf(_("\tSorry - this fdisk cannot handle Mac disk labels."

diff --git a/fdisks/fdisksgilabel.c b/fdisks/fdisksgilabel.c
index 486a3f618b9f3dc0bc28a4fdc9d77a205c366e78..904c016b9b21b5f5daa2a7d367e3e603864901e3 100644 (file)
--- a/fdisks/fdisksgilabel.c
+++ b/fdisks/fdisksgilabel.c
@@ -150,9 +150,12 @@ static size_t count_used_partitions(struct fdisk_context *cxt)
 }
 
 static int
-sgi_probe_label(struct fdisk_context *cxt,
-               struct fdisk_label *lb __attribute__((__unused__)))
+sgi_probe_label(struct fdisk_context *cxt)
 {
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, SGI));
+
        if (sizeof(sgilabel) > 512) {
                fprintf(stderr,
                        _("According to MIPS Computer Systems, Inc the "
@@ -293,7 +296,8 @@ sgi_set_swappartition(struct fdisk_context *cxt, int i) {
 }
 
 static int
-sgi_check_bootfile(struct fdisk_context *cxt, const char* aFile) {
+sgi_check_bootfile(struct fdisk_context *cxt, const char* aFile)
+{
        if (strlen(aFile) < 3) /* "/a\n" is minimum */ {
                printf(_("\nInvalid Bootfile!\n"
                         "\tThe bootfile must be an absolute non-zero pathname,\n"
@@ -354,11 +358,15 @@ create_sgiinfo(struct fdisk_context *cxt) {
 }
 
 
-static int sgi_write_disklabel(struct fdisk_context *cxt,
-               struct fdisk_label *lb __attribute__((__unused__)))
+static int sgi_write_disklabel(struct fdisk_context *cxt)
 {
+
        sgiinfo *info = NULL;
 
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, SGI));
+
        sgilabel->csum = 0;
        sgilabel->csum = SSWAP32(two_s_complement_32bit_sum(
                (unsigned int*)sgilabel,
@@ -464,8 +472,7 @@ static void sort(void *base0, size_t num, size_t size, struct fdisk_context *cxt
        }
 }
 
-static int sgi_verify_disklabel(struct fdisk_context *cxt,
-               struct fdisk_label *lb __attribute__((__unused__)))
+static int sgi_verify_disklabel(struct fdisk_context *cxt)
 {
        int Index[16];          /* list of valid partitions */
        int sortcount = 0;      /* number of used partitions, i.e. non-zero lengths */
@@ -474,6 +481,10 @@ static int sgi_verify_disklabel(struct fdisk_context *cxt,
        long long gap = 0;      /* count unused blocks */
        unsigned int lastblock = sgi_get_lastblock(cxt);
 
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, SGI));
+
        clearfreelist();
        for (i=0; i<16; i++) {
                if (sgi_get_num_sectors(cxt, i) != 0) {
@@ -597,7 +608,7 @@ sgi_gaps(struct fdisk_context *cxt) {
         *  < 0 : there is an overlap
         *  > 0 : there is still some vacant space
         */
-       return sgi_verify_disklabel(cxt, cxt->label);
+       return sgi_verify_disklabel(cxt);
 }
 
 
@@ -612,9 +623,13 @@ sgi_entire(struct fdisk_context *cxt) {
        return -1;
 }
 
-static int sgi_set_partition(struct fdisk_context *cxt, int i,
+static int sgi_set_partition(struct fdisk_context *cxt, size_t i,
                             unsigned int start, unsigned int length, int sys)
 {
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, SGI));
+
        sgilabel->partitions[i].id = SSWAP32(sys);
        sgilabel->partitions[i].num_sectors = SSWAP32(length);
        sgilabel->partitions[i].start_sector = SSWAP32(start);
@@ -660,16 +675,14 @@ sgi_set_volhdr(struct fdisk_context *cxt)
        }
 }
 
-static int sgi_delete_partition(struct fdisk_context *cxt,
-               struct fdisk_label *lb __attribute__((__unused__)),
-               int partnum)
+static int sgi_delete_partition(struct fdisk_context *cxt, size_t partnum)
 {
        int rc;
 
        assert(cxt);
        assert(cxt->label);
 
-       if (partnum < 0 || (size_t) partnum > cxt->label->nparts_max)
+       if (partnum > cxt->label->nparts_max)
                return -EINVAL;
 
        rc = sgi_set_partition(cxt, partnum, 0, 0, 0);
@@ -680,21 +693,24 @@ static int sgi_delete_partition(struct fdisk_context *cxt,
 }
 
 static int sgi_add_partition(struct fdisk_context *cxt,
-               struct fdisk_label *lb __attribute__((__unused__)),
-               int n,
+               size_t n,
                struct fdisk_parttype *t)
 {
        char mesg[256];
        unsigned int first=0, last=0;
        int sys = t ? t->type : SGI_XFS;
 
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, SGI));
+
        if (n == 10)
                sys = SGI_VOLUME;
        else if (n == 8)
                sys = 0;
 
        if (sgi_get_num_sectors(cxt, n)) {
-               printf(_("Partition %d is already defined.  Delete "
+               printf(_("Partition %zd is already defined.  Delete "
                         "it before re-adding it.\n"), n + 1);
                return -EINVAL;
        }
@@ -756,8 +772,7 @@ static int sgi_add_partition(struct fdisk_context *cxt,
        return 0;
 }
 
-static int sgi_create_disklabel(struct fdisk_context *cxt,
-               struct fdisk_label *lb __attribute__((__unused__)))
+static int sgi_create_disklabel(struct fdisk_context *cxt)
 {
        struct hd_geometry geometry;
        struct {
@@ -770,6 +785,10 @@ static int sgi_create_disklabel(struct fdisk_context *cxt,
        int res;                /* the result from the ioctl */
        int sec_fac;            /* the sector factor */
 
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, SGI));
+
        sec_fac = cxt->sector_size / 512;       /* determine the sector factor */
 
        fprintf(stderr,
@@ -929,13 +948,11 @@ static sgiinfo *fill_sgiinfo(void)
        return info;
 }
 
-static struct fdisk_parttype *sgi_get_parttype(struct fdisk_context *cxt,
-               struct fdisk_label *lb __attribute__((__unused__)),
-               int n)
+static struct fdisk_parttype *sgi_get_parttype(struct fdisk_context *cxt, size_t n)
 {
        struct fdisk_parttype *t;
 
-       if (n < 0 || (size_t) n >= cxt->label->nparts_max)
+       if (n >= cxt->label->nparts_max)
                return NULL;
 
        t = fdisk_get_parttype_from_code(cxt, sgi_get_sysid(cxt, n));
@@ -945,12 +962,10 @@ static struct fdisk_parttype *sgi_get_parttype(struct fdisk_context *cxt,
 }
 
 static int sgi_set_parttype(struct fdisk_context *cxt,
-               struct fdisk_label *lb __attribute__((__unused__)),
-               int i,
+               size_t i,
                struct fdisk_parttype *t)
 {
-       if (i < 0 || (size_t) i >= cxt->label->nparts_max
-           || !t || t->type > UINT32_MAX)
+       if (i >= cxt->label->nparts_max || !t || t->type > UINT32_MAX)
                return -EINVAL;
 
        if (sgi_get_num_sectors(cxt, i) == 0)   /* caught already before, ... */ {
@@ -981,15 +996,14 @@ static int sgi_set_parttype(struct fdisk_context *cxt,
 
 static int sgi_get_partition_status(
                struct fdisk_context *cxt,
-               struct fdisk_label *lb __attribute__((__unused__)),
-               int i,
+               size_t i,
                int *status)
 {
 
        assert(cxt);
        assert(fdisk_is_disklabel(cxt, SGI));
 
-       if (!status || i < 0 || (size_t) i >= cxt->label->nparts_max)
+       if (!status || i >= cxt->label->nparts_max)
                return -EINVAL;
 
        *status = FDISK_PARTSTAT_NONE;

diff --git a/fdisks/fdisksunlabel.c b/fdisks/fdisksunlabel.c
index a5fa11edeed8b61886552d43c5955f5b20c8098c..ecb6c1c55ca94b6539976e18793d1cf78356fdd4 100644 (file)
--- a/fdisks/fdisksunlabel.c
+++ b/fdisks/fdisksunlabel.c
@@ -36,8 +36,6 @@ struct fdisk_sun_label {
        struct sun_disk_label   *header;        /* on-disk data (pointer to cxt->firstsector) */
 };
 
-#define is_sun_label(_l)       ((_l)->id == FDISK_DISKLABEL_SUN)
-
 static struct fdisk_parttype sun_parttypes[] = {
        {SUN_TAG_UNASSIGNED, N_("Unassigned")},
        {SUN_TAG_BOOT, N_("Boot")},
@@ -70,29 +68,38 @@ static inline uint32_t __swap32(uint32_t x) {
 #define SSWAP32(x) (other_endian ? __swap32(x) \
                                 : (uint32_t)(x))
 
-static inline struct sun_disk_label *
-label_get_sun_disklabel(struct fdisk_label *lb)
+/* return poiter buffer with on-disk data */
+static inline struct sun_disk_label *self_disklabel(struct fdisk_context *cxt)
 {
-       assert(lb);
-       assert(is_sun_label(lb));
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, SUN));
 
-       return ((struct fdisk_sun_label *) lb)->header;
+       return ((struct fdisk_sun_label *) cxt->label)->header;
 }
 
-#define context_get_sun_disklabel(_c)  label_get_sun_disklabel((_c)->label)
+/* return in-memory sun fdisk data */
+static inline struct fdisk_sun_label *self_label(struct fdisk_context *cxt)
+{
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, SUN));
+
+       return (struct fdisk_sun_label *) cxt->label;
+}
 
-int sun_is_empty_type(struct fdisk_context *cxt, int i)
+int sun_is_empty_type(struct fdisk_context *cxt, size_t i)
 {
-       struct sun_disk_label *sunlabel = context_get_sun_disklabel(cxt);
+       struct sun_disk_label *sunlabel = self_disklabel(cxt);
 
        return (!sunlabel->partitions[i].num_sectors ||
                !sunlabel->part_tags[i].tag);
 }
 
-static void set_sun_partition(struct fdisk_context *cxt,
-                             int i, uint32_t start, uint32_t stop, uint16_t sysid)
+static void set_sun_partition(struct fdisk_context *cxt, size_t i,
+               uint32_t start,uint32_t stop, uint16_t sysid)
 {
-       struct sun_disk_label *sunlabel = context_get_sun_disklabel(cxt);
+       struct sun_disk_label *sunlabel = self_disklabel(cxt);
 
        sunlabel->part_tags[i].tag = SSWAP16(sysid);
        sunlabel->part_tags[i].flag = SSWAP16(0);
@@ -104,21 +111,21 @@ static void set_sun_partition(struct fdisk_context *cxt,
        print_partition_size(cxt, i + 1, start, stop, sysid);
 }
 
-static size_t partitions_in_use(struct fdisk_label *lb)
+static size_t count_used_partitions(struct fdisk_context *cxt)
 {
-       struct sun_disk_label *sunlabel = label_get_sun_disklabel(lb);
+       struct sun_disk_label *sunlabel = self_disklabel(cxt);
        size_t ct = 0, i;
 
        assert(sunlabel);
 
-       for (i = 0; i < lb->nparts_max; i++) {
+       for (i = 0; i < cxt->label->nparts_max; i++) {
                if (sunlabel->partitions[i].num_sectors)
                        ct++;
        }
        return ct;
 }
 
-static int sun_probe_label(struct fdisk_context *cxt, struct fdisk_label *lb)
+static int sun_probe_label(struct fdisk_context *cxt)
 {
        struct fdisk_sun_label *sun;
        struct sun_disk_label *sunlabel;
@@ -127,10 +134,10 @@ static int sun_probe_label(struct fdisk_context *cxt, struct fdisk_label *lb)
        int need_fixing = 0;
 
        assert(cxt);
-       assert(lb);
-       assert(is_sun_label(lb));
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, SUN));
 
-       sunlabel = (struct sun_disk_label *) cxt->firstsector;
+       sunlabel = self_disklabel(cxt);
 
        if (sunlabel->magic != SUN_LABEL_MAGIC &&
            sunlabel->magic != SUN_LABEL_MAGIC_SWAPPED) {
@@ -153,10 +160,10 @@ static int sun_probe_label(struct fdisk_context *cxt, struct fdisk_label *lb)
        }
 
        /* map first sector buffer to sun header */
-       sun = (struct fdisk_sun_label *) lb;
+       sun = (struct fdisk_sun_label *) cxt->label;
        sun->header = (struct sun_disk_label *) cxt->firstsector;
 
-       lb->nparts_max = SUN_NUM_PARTITIONS;
+       cxt->label->nparts_max = SUN_NUM_PARTITIONS;
        cxt->geom.heads = SSWAP16(sunlabel->nhead);
        cxt->geom.cylinders = SSWAP16(sunlabel->ncyl);
        cxt->geom.sectors = SSWAP16(sunlabel->nsect);
@@ -190,15 +197,15 @@ static int sun_probe_label(struct fdisk_context *cxt, struct fdisk_label *lb)
                        csum ^= *ush++;
                sunlabel->cksum = csum;
 
-               fdisk_label_set_changed(lb, 1);
+               fdisk_label_set_changed(cxt->label, 1);
        }
 
-       lb->nparts_cur = partitions_in_use(lb);
+       cxt->label->nparts_cur = count_used_partitions(cxt);
 
        return 1;
 }
 
-static int sun_create_disklabel(struct fdisk_context *cxt, struct fdisk_label *lb)
+static int sun_create_disklabel(struct fdisk_context *cxt)
 {
        struct hd_geometry geometry;
        sector_t llsectors, llcyls;
@@ -209,14 +216,14 @@ static int sun_create_disklabel(struct fdisk_context *cxt, struct fdisk_label *l
        struct sun_disk_label *sunlabel;        /* on disk data */
 
        assert(cxt);
-       assert(lb);
-       assert(is_sun_label(lb));
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, SUN));
 
        fprintf(stderr, _("Building a new Sun disklabel.\n"));
 
        /* map first sector to header */
        fdisk_zeroize_firstsector(cxt);
-       sun = (struct fdisk_sun_label *) lb;
+       sun = (struct fdisk_sun_label *) cxt->label;
        sun->header = (struct sun_disk_label *) cxt->firstsector;
 
        sunlabel = sun->header;
@@ -226,7 +233,7 @@ static int sun_create_disklabel(struct fdisk_context *cxt, struct fdisk_label *l
 #else
        other_endian = 0;
 #endif
-       lb->nparts_max = SUN_NUM_PARTITIONS;
+       cxt->label->nparts_max = SUN_NUM_PARTITIONS;
        fdisk_zeroize_firstsector(cxt);
 
        sunlabel->magic = SSWAP16(SUN_LABEL_MAGIC);
@@ -301,15 +308,15 @@ static int sun_create_disklabel(struct fdisk_context *cxt, struct fdisk_label *l
                sunlabel->cksum = csum;
        }
 
-       fdisk_label_set_changed(lb, 1);
-       lb->nparts_cur = partitions_in_use(lb);
+       fdisk_label_set_changed(cxt->label, 1);
+       cxt->label->nparts_cur = count_used_partitions(cxt);
 
        return 0;
 }
 
-void toggle_sunflags(struct fdisk_context *cxt, int i, uint16_t mask)
+void toggle_sunflags(struct fdisk_context *cxt, size_t i, uint16_t mask)
 {
-       struct sun_disk_label *sunlabel = context_get_sun_disklabel(cxt);
+       struct sun_disk_label *sunlabel = self_disklabel(cxt);
        struct sun_tag_flag *p = &sunlabel->part_tags[i];
 
        p->flag ^= SSWAP16(mask);
@@ -318,7 +325,6 @@ void toggle_sunflags(struct fdisk_context *cxt, int i, uint16_t mask)
 }
 
 static void fetch_sun(struct fdisk_context *cxt,
-                     struct fdisk_label *lb,
                      uint32_t *starts,
                      uint32_t *lens,
                      uint32_t *start,
@@ -329,15 +335,16 @@ static void fetch_sun(struct fdisk_context *cxt,
        size_t i;
 
        assert(cxt);
-       assert(lb);
-       assert(is_sun_label(lb));
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, SUN));
 
-       sunlabel = label_get_sun_disklabel(lb);
+       sunlabel = self_disklabel(cxt);
 
        *start = 0;
        *stop = cxt->geom.cylinders * cxt->geom.heads * cxt->geom.sectors;
 
-       for (i = 0; i < lb->nparts_max; i++) {
+       for (i = 0; i < cxt->label->nparts_max; i++) {
                struct sun_partition *part = &sunlabel->partitions[i];
                struct sun_tag_flag *tag = &sunlabel->part_tags[i];
 
@@ -377,20 +384,19 @@ static int verify_sun_cmp(int *a, int *b)
     return -1;
 }
 
-static int sun_verify_disklabel(struct fdisk_context *cxt,
-                               struct fdisk_label *lb)
+static int sun_verify_disklabel(struct fdisk_context *cxt)
 {
     uint32_t starts[SUN_NUM_PARTITIONS], lens[SUN_NUM_PARTITIONS], start, stop;
     uint32_t i,j,k,starto,endo;
     int array[SUN_NUM_PARTITIONS];
 
     assert(cxt);
-    assert(lb);
-    assert(is_sun_label(lb));
+    assert(cxt->label);
+    assert(fdisk_is_disklabel(cxt, SUN));
 
     verify_sun_starts = starts;
 
-    fetch_sun(cxt, lb, starts, lens, &start, &stop);
+    fetch_sun(cxt, starts, lens, &start, &stop);
 
     for (k = 0; k < 7; k++) {
        for (i = 0; i < SUN_NUM_PARTITIONS; i++) {
@@ -453,11 +459,10 @@ static int sun_verify_disklabel(struct fdisk_context *cxt,
 
 static int sun_add_partition(
                struct fdisk_context *cxt,
-               struct fdisk_label *lb,
-               int n,
+               size_t n,
                struct fdisk_parttype *t)
 {
-       struct sun_disk_label *sunlabel = label_get_sun_disklabel(lb);
+       struct sun_disk_label *sunlabel = self_disklabel(cxt);
        uint32_t starts[SUN_NUM_PARTITIONS], lens[SUN_NUM_PARTITIONS];
        struct sun_partition *part = &sunlabel->partitions[n];
        struct sun_tag_flag *tag = &sunlabel->part_tags[n];
@@ -469,12 +474,12 @@ static int sun_add_partition(
        unsigned int first, last;
 
        if (part->num_sectors && tag->tag != SSWAP16(SUN_TAG_UNASSIGNED)) {
-               printf(_("Partition %d is already defined.  Delete "
+               printf(_("Partition %zd is already defined.  Delete "
                        "it before re-adding it.\n"), n + 1);
                return -EINVAL;
        }
 
-       fetch_sun(cxt, lb, starts, lens, &start, &stop);
+       fetch_sun(cxt, starts, lens, &start, &stop);
 
        if (stop <= start) {
                if (n == 2)
@@ -522,11 +527,11 @@ and is of type `Whole disk'\n"));
                /* On the other hand, one should not use partitions
                   starting at block 0 in an md, or the label will
                   be trashed. */
-               for (i = 0; i < lb->nparts_max; i++)
+               for (i = 0; i < cxt->label->nparts_max; i++)
                        if (lens[i] && starts[i] <= first
                                    && starts[i] + lens[i] > first)
                                break;
-               if (i < lb->nparts_max && !whole_disk) {
+               if (i < cxt->label->nparts_max && !whole_disk) {
                        if (n == 2 && !first) {
                            whole_disk = 1;
                            break;
@@ -537,7 +542,7 @@ and is of type `Whole disk'\n"));
        }
        stop = cxt->geom.cylinders * cxt->geom.heads * cxt->geom.sectors;       /* ancient */
        stop2 = stop;
-       for (i = 0; i < lb->nparts_max; i++) {
+       for (i = 0; i < cxt->label->nparts_max; i++) {
                if (starts[i] > first && starts[i] < stop)
                        stop = starts[i];
        }
@@ -575,13 +580,12 @@ and is of type `Whole disk'\n"));
                sys = SUN_TAG_BACKUP;
 
        set_sun_partition(cxt, n, first, last, sys);
-       lb->nparts_cur = partitions_in_use(lb);
+       cxt->label->nparts_cur = count_used_partitions(cxt);
        return 0;
 }
 
 static int sun_delete_partition(struct fdisk_context *cxt,
-               struct fdisk_label *lb,
-               int partnum)
+               size_t partnum)
 {
        struct sun_disk_label *sunlabel;
        struct sun_partition *part;
@@ -589,10 +593,10 @@ static int sun_delete_partition(struct fdisk_context *cxt,
        unsigned int nsec;
 
        assert(cxt);
-       assert(lb);
-       assert(is_sun_label(lb));
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, SUN));
 
-       sunlabel = label_get_sun_disklabel(lb);
+       sunlabel = self_disklabel(cxt);
        part = &sunlabel->partitions[partnum];
        tag = &sunlabel->part_tags[partnum];
 
@@ -607,8 +611,8 @@ static int sun_delete_partition(struct fdisk_context *cxt,
                         "sectors\n"), nsec);
        tag->tag = SSWAP16(SUN_TAG_UNASSIGNED);
        part->num_sectors = 0;
-       lb->nparts_cur = partitions_in_use(lb);
-       fdisk_label_set_changed(lb, 1);
+       cxt->label->nparts_cur = count_used_partitions(cxt);
+       fdisk_label_set_changed(cxt->label, 1);
        return 0;
 }
 
@@ -623,7 +627,7 @@ void sun_list_table(struct fdisk_context *cxt, int xtra)
        assert(cxt->label);
        assert(fdisk_is_disklabel(cxt, SUN));
 
-       sunlabel = context_get_sun_disklabel(cxt);
+       sunlabel = self_disklabel(cxt);
 
        w = strlen(cxt->dev_path);
        if (xtra)
@@ -678,7 +682,7 @@ void sun_list_table(struct fdisk_context *cxt, int xtra)
 
 void sun_set_alt_cyl(struct fdisk_context *cxt)
 {
-       struct sun_disk_label *sunlabel = context_get_sun_disklabel(cxt);
+       struct sun_disk_label *sunlabel = self_disklabel(cxt);
        sunlabel->acyl =
                SSWAP16(read_int(cxt, 0,SSWAP16(sunlabel->acyl), 65535, 0,
                                 _("Number of alternate cylinders")));
@@ -686,13 +690,13 @@ void sun_set_alt_cyl(struct fdisk_context *cxt)
 
 void sun_set_ncyl(struct fdisk_context *cxt, int cyl)
 {
-       struct sun_disk_label *sunlabel = context_get_sun_disklabel(cxt);
+       struct sun_disk_label *sunlabel = self_disklabel(cxt);
        sunlabel->ncyl = SSWAP16(cyl);
 }
 
 void sun_set_xcyl(struct fdisk_context *cxt)
 {
-       struct sun_disk_label *sunlabel = context_get_sun_disklabel(cxt);
+       struct sun_disk_label *sunlabel = self_disklabel(cxt);
        sunlabel->apc =
                SSWAP16(read_int(cxt, 0, SSWAP16(sunlabel->apc), cxt->geom.sectors, 0,
                                 _("Extra sectors per cylinder")));
@@ -700,7 +704,7 @@ void sun_set_xcyl(struct fdisk_context *cxt)
 
 void sun_set_ilfact(struct fdisk_context *cxt)
 {
-       struct sun_disk_label *sunlabel = context_get_sun_disklabel(cxt);
+       struct sun_disk_label *sunlabel = self_disklabel(cxt);
        sunlabel->intrlv =
                SSWAP16(read_int(cxt, 1, SSWAP16(sunlabel->intrlv), 32, 0,
                                 _("Interleave factor")));
@@ -708,7 +712,7 @@ void sun_set_ilfact(struct fdisk_context *cxt)
 
 void sun_set_rspeed(struct fdisk_context *cxt)
 {
-       struct sun_disk_label *sunlabel = context_get_sun_disklabel(cxt);
+       struct sun_disk_label *sunlabel = self_disklabel(cxt);
        sunlabel->rpm =
                SSWAP16(read_int(cxt, 1, SSWAP16(sunlabel->rpm), 100000, 0,
                                 _("Rotation speed (rpm)")));
@@ -716,23 +720,23 @@ void sun_set_rspeed(struct fdisk_context *cxt)
 
 void sun_set_pcylcount(struct fdisk_context *cxt)
 {
-       struct sun_disk_label *sunlabel = context_get_sun_disklabel(cxt);
+       struct sun_disk_label *sunlabel = self_disklabel(cxt);
        sunlabel->pcyl =
                SSWAP16(read_int(cxt, 0, SSWAP16(sunlabel->pcyl), 65535, 0,
                                 _("Number of physical cylinders")));
 }
 
-static int sun_write_disklabel(struct fdisk_context *cxt,
-               struct fdisk_label *lb __attribute__((__unused__)))
+static int sun_write_disklabel(struct fdisk_context *cxt)
 {
        struct sun_disk_label *sunlabel;
        unsigned short *ush;
        unsigned short csum = 0;
 
        assert(cxt);
-       assert(lb);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, SUN));
 
-       sunlabel = label_get_sun_disklabel(lb);
+       sunlabel = self_disklabel(cxt);
        ush = (unsigned short *) sunlabel;
 
        while(ush < (unsigned short *)(&sunlabel->cksum))
@@ -748,17 +752,16 @@ static int sun_write_disklabel(struct fdisk_context *cxt,
 
 static struct fdisk_parttype *sun_get_parttype(
                struct fdisk_context *cxt,
-               struct fdisk_label *lb,
-               int n)
+               size_t n)
 {
-       struct sun_disk_label *sunlabel = context_get_sun_disklabel(cxt);
+       struct sun_disk_label *sunlabel = self_disklabel(cxt);
        struct fdisk_parttype *t;
 
        assert(cxt);
-       assert(lb);
-       assert(is_sun_label(lb));
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, SUN));
 
-       if (n < 0 || (size_t) n >= lb->nparts_max)
+       if (n >= cxt->label->nparts_max)
                return NULL;
 
        t = fdisk_get_parttype_from_code(cxt, SSWAP16(sunlabel->part_tags[n].tag));
@@ -769,8 +772,7 @@ static struct fdisk_parttype *sun_get_parttype(
 
 static int sun_set_parttype(
                struct fdisk_context *cxt,
-               struct fdisk_label *lb,
-               int i,
+               size_t i,
                struct fdisk_parttype *t)
 {
        struct sun_disk_label *sunlabel;
@@ -778,12 +780,12 @@ static int sun_set_parttype(
        struct sun_tag_flag *tag;
 
        assert(cxt);
-       assert(lb);
-       assert(is_sun_label(lb));
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, SUN));
 
-       sunlabel = label_get_sun_disklabel(lb);
+       sunlabel = self_disklabel(cxt);
 
-       if (i < 0 || (size_t) i >= lb->nparts_max || !t || t->type > UINT16_MAX)
+       if (i >= cxt->label->nparts_max || !t || t->type > UINT16_MAX)
                return -EINVAL;
 
        if (i == 2 && t->type != SUN_TAG_BACKUP)
@@ -821,8 +823,7 @@ static int sun_set_parttype(
 }
 
 
-static int sun_reset_alignment(struct fdisk_context *cxt,
-               struct fdisk_label *lb __attribute__((__unused__)))
+static int sun_reset_alignment(struct fdisk_context *cxt)
 {
        /* this is shared with DOS ... */
        update_units(cxt);
@@ -832,15 +833,19 @@ static int sun_reset_alignment(struct fdisk_context *cxt,
 
 static int sun_get_partition_status(
                struct fdisk_context *cxt,
-               struct fdisk_label *lb __attribute__((__unused__)),
-               int i,
+               size_t i,
                int *status)
 {
-       struct sun_disk_label *sunlabel = context_get_sun_disklabel(cxt);
+       struct sun_disk_label *sunlabel;
+
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, SUN));
 
-       if (!status || i < 0 || (size_t) i >= lb->nparts_max)
+       if (!status || i >= cxt->label->nparts_max)
                return -EINVAL;
 
+       sunlabel = self_disklabel(cxt);
        *status = FDISK_PARTSTAT_NONE;
 
        if (sunlabel->partitions[i].num_sectors)

diff --git a/fdisks/fdisksunlabel.h b/fdisks/fdisksunlabel.h
index e70171e8ab96d25dbc0029c95bb34b7277a2c066..e8291a242aad831fd878e060945b00ec55a1947f 100644 (file)
--- a/fdisks/fdisksunlabel.h
+++ b/fdisks/fdisksunlabel.h
@@ -75,7 +75,7 @@ struct sun_disk_label {
 #define SUN_LABEL_MAGIC_SWAPPED        0xBEDA
 
 /* fdisksunlabel.c */
-extern int sun_change_sysid(struct fdisk_context *cxt, int i, uint16_t sys);
+extern int sun_change_sysid(struct fdisk_context *cxt, size_t i, uint16_t sys);
 extern void sun_list_table(struct fdisk_context *cxt, int xtra);
 extern void sun_set_alt_cyl(struct fdisk_context *cxt);
 extern void sun_set_ncyl(struct fdisk_context *cxt, int cyl);
@@ -83,8 +83,9 @@ extern void sun_set_xcyl(struct fdisk_context *cxt);
 extern void sun_set_ilfact(struct fdisk_context *cxt);
 extern void sun_set_rspeed(struct fdisk_context *cxt);
 extern void sun_set_pcylcount(struct fdisk_context *cxt);
-extern void toggle_sunflags(struct fdisk_context *cxt, int i, uint16_t mask);
 
-extern int sun_is_empty_type(struct fdisk_context *cxt, int i);
+extern void toggle_sunflags(struct fdisk_context *cxt, size_t i, uint16_t mask);
+
+extern int sun_is_empty_type(struct fdisk_context *cxt, size_t i);
 
 #endif /* FDISK_SUN_LABEL_H */

diff --git a/libfdisk/src/alignment.c b/libfdisk/src/alignment.c
index a89182172ad05b667f41a1b14d77c30e3dffe09b..25323d1b54e252c2dc77b1d39b6ee4416007a179 100644 (file)
--- a/libfdisk/src/alignment.c
+++ b/libfdisk/src/alignment.c
@@ -369,7 +369,7 @@ int fdisk_reset_alignment(struct fdisk_context *cxt)
 
        /* overwrite default by label stuff */
        if (cxt->label && cxt->label->op->reset_alignment)
-               rc = cxt->label->op->reset_alignment(cxt, cxt->label);
+               rc = cxt->label->op->reset_alignment(cxt);
 
        DBG(LABEL, dbgprint("%s alignment reseted to: "
                            "first LBA=%ju, grain=%lu [rc=%d]",

diff --git a/libfdisk/src/fdiskP.h b/libfdisk/src/fdiskP.h
index bf392118223cc6cf8cc8a421a4f19f5662a56a57..1301695a6bdb306450a6f8889db80e17449e8761 100644 (file)
--- a/libfdisk/src/fdiskP.h
+++ b/libfdisk/src/fdiskP.h
@@ -123,39 +123,39 @@ struct fdisk_geometry {
  */
 struct fdisk_label_operations {
        /* probe disk label */
-       int (*probe)(struct fdisk_context *cxt, struct fdisk_label *lb);
+       int (*probe)(struct fdisk_context *cxt);
        /* write in-memory changes to disk */
-       int (*write)(struct fdisk_context *cxt, struct fdisk_label *lb);
+       int (*write)(struct fdisk_context *cxt);
        /* verify the partition table */
-       int (*verify)(struct fdisk_context *cxt, struct fdisk_label *lb);
+       int (*verify)(struct fdisk_context *cxt);
        /* create new disk label */
-       int (*create)(struct fdisk_context *cxt, struct fdisk_label *lb);
+       int (*create)(struct fdisk_context *cxt);
        /* new partition */
-       int (*part_add)(struct fdisk_context *cxt, struct fdisk_label *lb,
-                                               int partnum,
+       int (*part_add)(struct fdisk_context *cxt,
+                                               size_t partnum,
                                                struct fdisk_parttype *t);
        /* delete partition */
-       int (*part_delete)(struct fdisk_context *cxt, struct fdisk_label *lb,
-                                               int partnum);
+       int (*part_delete)(struct fdisk_context *cxt,
+                                               size_t partnum);
        /* get partition type */
        struct fdisk_parttype *(*part_get_type)(struct fdisk_context *cxt,
-                                               struct fdisk_label *lb,
-                                               int partnum);
+                                               size_t partnum);
        /* set partition type */
-       int (*part_set_type)(struct fdisk_context *cxt, struct fdisk_label *lb,
-                                               int partnum,
+       int (*part_set_type)(struct fdisk_context *cxt,
+                                               size_t partnum,
                                                struct fdisk_parttype *t);
 
        /* returns FDISK_PARTSTAT_* flags */
-       int (*part_get_status)(struct fdisk_context *cxt, struct fdisk_label *lb,
-                                               int partnum, int *status);
+       int (*part_get_status)(struct fdisk_context *cxt,
+                                               size_t partnum,
+                                               int *status);
 
        /* refresh alignment setting */
-       int (*reset_alignment)(struct fdisk_context *cxt,
-                                               struct fdisk_label *lb);
+       int (*reset_alignment)(struct fdisk_context *cxt);
 
        /* free in-memory label stuff */
        void (*free)(struct fdisk_label *lb);
+
        /* deinit in-memory label stuff */
        void (*deinit)(struct fdisk_label *lb);
 };

diff --git a/libfdisk/src/gpt.c b/libfdisk/src/gpt.c
index 03fad41efca265eee79894a16024104f12b419f5..2472935dc98b910650fbd4000dc87c3a384a01dc 100644 (file)
--- a/libfdisk/src/gpt.c
+++ b/libfdisk/src/gpt.c
@@ -268,12 +268,8 @@ struct fdisk_gpt_label {
 
 static void gpt_deinit(struct fdisk_label *lb);
 
-static inline struct fdisk_gpt_label *gpt_label(struct fdisk_context *cxt)
+static inline struct fdisk_gpt_label *self_label(struct fdisk_context *cxt)
 {
-       assert(cxt);
-       assert(cxt->label);
-       assert(fdisk_is_disklabel(cxt, GPT));
-
        return (struct fdisk_gpt_label *) cxt->label;
 }
 
@@ -1034,13 +1030,16 @@ done:
        return totfound;
 }
 
-static int gpt_probe_label(struct fdisk_context *cxt, struct fdisk_label *lb)
+static int gpt_probe_label(struct fdisk_context *cxt)
 {
        int mbr_type;
-       struct fdisk_gpt_label *gpt = (struct fdisk_gpt_label *) lb;
+       struct fdisk_gpt_label *gpt;
 
-       if (!cxt || !lb)
-               goto failed;
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, GPT));
+
+       gpt = self_label(cxt);
 
        mbr_type = valid_pmbr(cxt);
        if (!mbr_type)
@@ -1068,8 +1067,8 @@ static int gpt_probe_label(struct fdisk_context *cxt, struct fdisk_label *lb)
        /* OK, probing passed, now initialize backup header and fdisk variables. */
        gpt->bheader = gpt_read_header(cxt, last_lba(cxt), NULL);
 
-       lb->nparts_max = le32_to_cpu(gpt->pheader->npartition_entries);
-       lb->nparts_cur = partitions_in_use(gpt->pheader, gpt->ents);
+       cxt->label->nparts_max = le32_to_cpu(gpt->pheader->npartition_entries);
+       cxt->label->nparts_cur = partitions_in_use(gpt->pheader, gpt->ents);
 
        printf(_("\nWARNING: fdisk GPT support is currently new, and therefore "
                 "in an experimental phase. Use at your own discretion.\n\n"));
@@ -1077,7 +1076,7 @@ static int gpt_probe_label(struct fdisk_context *cxt, struct fdisk_label *lb)
        return 1;
 failed:
        DBG(LABEL, dbgprint("GPT probe failed"));
-       gpt_deinit(lb);
+       gpt_deinit(cxt->label);
        return 0;
 }
 
@@ -1131,9 +1130,17 @@ void gpt_list_table(struct fdisk_context *cxt,
                    int xtra  __attribute__ ((__unused__)))
 {
        uint32_t i;
-       struct fdisk_gpt_label *gpt = gpt_label(cxt);
-       uint64_t fu = le64_to_cpu(gpt->pheader->first_usable_lba);
-       uint64_t lu = le64_to_cpu(gpt->pheader->last_usable_lba);
+       struct fdisk_gpt_label *gpt;
+       uint64_t fu;
+       uint64_t lu;
+
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, GPT));
+
+       gpt = self_label(cxt);
+       fu = le64_to_cpu(gpt->pheader->first_usable_lba);
+       lu = le64_to_cpu(gpt->pheader->last_usable_lba);
 
        printf("\n#         Start          End    Size  Type            Name\n");
 
@@ -1226,8 +1233,8 @@ static int gpt_write_pmbr(struct fdisk_context *cxt)
        off_t offset;
        struct gpt_legacy_mbr *pmbr = NULL;
 
-       if (!cxt || !cxt->firstsector)
-               return -EINVAL;
+       assert(cxt);
+       assert(cxt->firstsector);
 
        pmbr = (struct gpt_legacy_mbr *) cxt->firstsector;
 
@@ -1269,12 +1276,15 @@ fail:
  * Returns 0 if successful write, otherwise, a corresponding error.
  * Any indication of error will abort the operation.
  */
-static int gpt_write_disklabel(struct fdisk_context *cxt, struct fdisk_label *lb)
+static int gpt_write_disklabel(struct fdisk_context *cxt)
 {
-       struct fdisk_gpt_label *gpt = (struct fdisk_gpt_label *) lb;
+       struct fdisk_gpt_label *gpt;
 
-       if (!cxt || !lb)
-               goto err0;
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, GPT));
+
+       gpt = self_label(cxt);
 
        /* we do not want to mess up hybrid MBRs by creating a valid pmbr */
        if (valid_pmbr(cxt) == GPT_MBR_HYBRID)
@@ -1329,10 +1339,16 @@ err1:
  *   - primary and backup header validations
  *   - paritition validations
  */
-static int gpt_verify_disklabel(struct fdisk_context *cxt, struct fdisk_label *lb)
+static int gpt_verify_disklabel(struct fdisk_context *cxt)
 {
        int nerror = 0, ptnum;
-       struct fdisk_gpt_label *gpt = (struct fdisk_gpt_label *) lb;
+       struct fdisk_gpt_label *gpt;
+
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, GPT));
+
+       gpt = self_label(cxt);
 
        if (!gpt || !gpt->bheader) {
                nerror++;
@@ -1428,15 +1444,18 @@ static int gpt_verify_disklabel(struct fdisk_context *cxt, struct fdisk_label *l
 
 /* Delete a single GPT partition, specified by partnum. */
 static int gpt_delete_partition(struct fdisk_context *cxt,
-                               struct fdisk_label *lb,
-                               int partnum)
+                               size_t partnum)
 {
-       struct fdisk_gpt_label *gpt = (struct fdisk_gpt_label *) lb;
+       struct fdisk_gpt_label *gpt;
 
-       if (!cxt || partnum < 0 || !gpt)
-               return -EINVAL;
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, GPT));
 
-       if (partition_unused(&gpt->ents[partnum]))
+       gpt = self_label(cxt);
+
+       if (partnum >= cxt->label->nparts_max
+           ||  partition_unused(&gpt->ents[partnum]))
                return -EINVAL;
 
        /* hasta la vista, baby! */
@@ -1446,8 +1465,8 @@ static int gpt_delete_partition(struct fdisk_context *cxt,
        else {
                gpt_recompute_crc(gpt->pheader, gpt->ents);
                gpt_recompute_crc(gpt->bheader, gpt->ents);
-               lb->nparts_cur--;
-               fdisk_label_set_changed(lb, 1);
+               cxt->label->nparts_cur--;
+               fdisk_label_set_changed(cxt->label, 1);
        }
 
        return 0;
@@ -1482,17 +1501,21 @@ static void gpt_entry_set_type(struct gpt_entry *e, struct gpt_guid *type)
  * Returns 0 on success, or negative upon failure.
  */
 static int gpt_create_new_partition(struct fdisk_context *cxt,
-                                   int partnum, uint64_t fsect, uint64_t lsect,
+                                   size_t partnum, uint64_t fsect, uint64_t lsect,
                                    struct gpt_guid *type,
                                    struct gpt_entry *entries)
 {
        struct gpt_entry *e = NULL;
        struct fdisk_gpt_label *gpt;
 
-       if (!cxt || fsect > lsect || partnum < 0)
-               return -EINVAL;
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, GPT));
 
-       gpt = gpt_label(cxt);
+       gpt = self_label(cxt);
+
+       if (fsect > lsect || partnum >= cxt->label->nparts_max)
+               return -EINVAL;
 
        e = xcalloc(1, sizeof(*e));
        e->lba_end = cpu_to_le64(lsect);
@@ -1526,20 +1549,24 @@ static int gpt_create_new_partition(struct fdisk_context *cxt,
 /* Performs logical checks to add a new partition entry */
 static int gpt_add_partition(
                struct fdisk_context *cxt,
-               struct fdisk_label *lb,
-               int partnum,
+               size_t partnum,
                struct fdisk_parttype *t)
 {
        uint64_t user_f, user_l;        /* user input ranges for first and last sectors */
        uint64_t disk_f, disk_l;        /* first and last available sector ranges on device*/
        uint64_t dflt_f, dflt_l;        /* largest segment (default) */
        struct gpt_guid uuid = GPT_DEFAULT_ENTRY_GUID;
-       struct fdisk_gpt_label *gpt = (struct fdisk_gpt_label *) lb;
+       struct fdisk_gpt_label *gpt;
        struct gpt_header *pheader;
        struct gpt_entry *ents;
 
-       /* check basic tests before even considering adding a new partition */
-       if (!cxt || partnum < 0 || !gpt)
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, GPT));
+
+       gpt = self_label(cxt);
+
+       if (partnum >= cxt->label->nparts_max)
                return -EINVAL;
 
        pheader = gpt->pheader;
@@ -1614,8 +1641,8 @@ static int gpt_add_partition(
                printf(_("Could not create partition %d\n"), partnum + 1);
        else {
                printf(_("Created partition %d\n"), partnum + 1);
-               lb->nparts_cur++;
-               fdisk_label_set_changed(lb, 1);
+               cxt->label->nparts_cur++;
+               fdisk_label_set_changed(cxt->label, 1);
        }
 
        return 0;
@@ -1624,15 +1651,20 @@ static int gpt_add_partition(
 /*
  * Create a new GPT disklabel - destroys any previous data.
  */
-static int gpt_create_disklabel(struct fdisk_context *cxt, struct fdisk_label *lb)
+static int gpt_create_disklabel(struct fdisk_context *cxt)
 {
        int rc = 0;
        ssize_t entry_sz = 0;
        struct gpt_guid *uid;
-       struct fdisk_gpt_label *gpt = (struct fdisk_gpt_label *) lb;
+       struct fdisk_gpt_label *gpt;
+
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, GPT));
+
+       gpt = self_label(cxt);
 
        /* label private stuff has to be empty, see gpt_deinit() */
-       assert(gpt);
        assert(gpt->pheader == NULL);
        assert(gpt->bheader == NULL);
 
@@ -1665,8 +1697,8 @@ static int gpt_create_disklabel(struct fdisk_context *cxt, struct fdisk_label *l
        gpt_recompute_crc(gpt->pheader, gpt->ents);
        gpt_recompute_crc(gpt->bheader, gpt->ents);
 
-       lb->nparts_max = le32_to_cpu(gpt->pheader->npartition_entries);
-       lb->nparts_cur = 0;
+       cxt->label->nparts_max = le32_to_cpu(gpt->pheader->npartition_entries);
+       cxt->label->nparts_cur = 0;
 
        uid = &gpt->pheader->disk_guid;
        fprintf(stderr, ("Building a new GPT disklabel "
@@ -1678,26 +1710,27 @@ static int gpt_create_disklabel(struct fdisk_context *cxt, struct fdisk_label *l
                            uid->node[0], uid->node[1],
                            uid->node[2], uid->node[3],
                            uid->node[4], uid->node[5]);
-       fdisk_label_set_changed(lb, 1);
+       fdisk_label_set_changed(cxt->label, 1);
 done:
        return rc;
 }
 
 static struct fdisk_parttype *gpt_get_partition_type(
                struct fdisk_context *cxt,
-               struct fdisk_label *lb,
-               int i)
+               size_t i)
 {
        struct fdisk_parttype *t;
        struct gpt_guid uuid;
        char str[37];
-       struct fdisk_gpt_label *gpt = (struct fdisk_gpt_label *) lb;
+       struct fdisk_gpt_label *gpt;
 
-       if (!cxt)
-               return NULL;
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, GPT));
 
-       if (!cxt || !gpt || i < 0
-                || (uint32_t) i >= le32_to_cpu(gpt->pheader->npartition_entries))
+       gpt = self_label(cxt);
+
+       if ((uint32_t) i >= le32_to_cpu(gpt->pheader->npartition_entries))
                return NULL;
 
        uuid = gpt->ents[i].partition_type_guid;
@@ -1714,16 +1747,18 @@ static struct fdisk_parttype *gpt_get_partition_type(
 
 static int gpt_set_partition_type(
                struct fdisk_context *cxt,
-               struct fdisk_label *lb,
-               int i,
+               size_t i,
                struct fdisk_parttype *t)
 {
        struct gpt_guid uuid;
-       struct fdisk_gpt_label *gpt = (struct fdisk_gpt_label *) lb;
+       struct fdisk_gpt_label *gpt;
 
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, GPT));
 
-       if (!cxt || !gpt || i < 0
-            || (uint32_t) i >= le32_to_cpu(gpt->pheader->npartition_entries)
+       gpt = self_label(cxt);
+       if ((uint32_t) i >= le32_to_cpu(gpt->pheader->npartition_entries)
             || !t || !t->typestr || string_to_uuid(t->typestr, &uuid) != 0)
                return -EINVAL;
 
@@ -1731,27 +1766,31 @@ static int gpt_set_partition_type(
        gpt_recompute_crc(gpt->pheader, gpt->ents);
        gpt_recompute_crc(gpt->bheader, gpt->ents);
 
-       fdisk_label_set_changed(lb, 1);
+       fdisk_label_set_changed(cxt->label, 1);
        return 0;
 }
 
 static int gpt_get_partition_status(
                struct fdisk_context *cxt,
-               struct fdisk_label *lb __attribute__((__unused__)),
-               int i,
+               size_t i,
                int *status)
 {
-       struct fdisk_gpt_label *gpt = gpt_label(cxt);
+       struct fdisk_gpt_label *gpt;
        struct gpt_entry *e;
 
-       if (!cxt || !gpt || i < 0 || !status
-            || (uint32_t) i >= le32_to_cpu(gpt->pheader->npartition_entries))
+       assert(cxt);
+       assert(cxt->label);
+       assert(fdisk_is_disklabel(cxt, GPT));
+
+       gpt = self_label(cxt);
+
+       if (!status || (uint32_t) i >= le32_to_cpu(gpt->pheader->npartition_entries))
                return -EINVAL;
 
        e = &gpt->ents[i];
        *status = FDISK_PARTSTAT_NONE;
 
-       if (!partition_unused(&gpt->ents[i]) || gpt_partition_size(e))
+       if (!partition_unused(e) || gpt_partition_size(e))
                *status = FDISK_PARTSTAT_USED;
 
        return 0;

diff --git a/libfdisk/src/label.c b/libfdisk/src/label.c
index 4716b94a65362cefa0aa8fbdb023c75f5978b15c..e631154817fd85a4eb6b70314a91495974cb2b52 100644 (file)
--- a/libfdisk/src/label.c
+++ b/libfdisk/src/label.c
@@ -21,7 +21,7 @@ int fdisk_probe_labels(struct fdisk_context *cxt)
                DBG(LABEL, dbgprint("probing for %s", lb->name));
 
                cxt->label = lb;
-               rc = lb->op->probe(cxt, lb);
+               rc = lb->op->probe(cxt);
                cxt->label = org;
 
                if (rc != 1) {
@@ -76,7 +76,7 @@ int fdisk_write_disklabel(struct fdisk_context *cxt)
        if (!cxt->label->op->write)
                return -ENOSYS;
 
-       return cxt->label->op->write(cxt, cxt->label);
+       return cxt->label->op->write(cxt);
 }
 
 /**
@@ -94,7 +94,7 @@ int fdisk_verify_disklabel(struct fdisk_context *cxt)
        if (!cxt->label->op->verify)
                return -ENOSYS;
 
-       return cxt->label->op->verify(cxt, cxt->label);
+       return cxt->label->op->verify(cxt);
 }
 
 /**
@@ -107,7 +107,7 @@ int fdisk_verify_disklabel(struct fdisk_context *cxt)
  *
  * Returns 0.
  */
-int fdisk_add_partition(struct fdisk_context *cxt, int partnum,
+int fdisk_add_partition(struct fdisk_context *cxt, size_t partnum,
                        struct fdisk_parttype *t)
 {
        if (!cxt || !cxt->label)
@@ -115,8 +115,8 @@ int fdisk_add_partition(struct fdisk_context *cxt, int partnum,
        if (!cxt->label->op->part_add)
                return -ENOSYS;
 
-       DBG(LABEL, dbgprint("adding new partition number %d", partnum));
-       cxt->label->op->part_add(cxt, cxt->label, partnum, t);
+       DBG(LABEL, dbgprint("adding new partition number %zd", partnum));
+       cxt->label->op->part_add(cxt, partnum, t);
        return 0;
 }
 
@@ -129,16 +129,16 @@ int fdisk_add_partition(struct fdisk_context *cxt, int partnum,
  *
  * Returns 0 on success, otherwise, a corresponding error.
  */
-int fdisk_delete_partition(struct fdisk_context *cxt, int partnum)
+int fdisk_delete_partition(struct fdisk_context *cxt, size_t partnum)
 {
        if (!cxt || !cxt->label)
                return -EINVAL;
        if (!cxt->label->op->part_delete)
                return -ENOSYS;
 
-       DBG(LABEL, dbgprint("deleting %s partition number %d",
+       DBG(LABEL, dbgprint("deleting %s partition number %zd",
                                cxt->label->name, partnum));
-       return cxt->label->op->part_delete(cxt, cxt->label, partnum);
+       return cxt->label->op->part_delete(cxt, partnum);
 }
 
 /**
@@ -176,7 +176,7 @@ int fdisk_create_disklabel(struct fdisk_context *cxt, const char *name)
                return -ENOSYS;
 
        fdisk_reset_alignment(cxt);
-       return cxt->label->op->create(cxt, cxt->label);
+       return cxt->label->op->create(cxt);
 }
 
 /**
@@ -186,13 +186,14 @@ int fdisk_create_disklabel(struct fdisk_context *cxt, const char *name)
  *
  * Returns partition type or NULL upon failure.
  */
-struct fdisk_parttype *fdisk_get_partition_type(struct fdisk_context *cxt, int partnum)
+struct fdisk_parttype *fdisk_get_partition_type(struct fdisk_context *cxt,
+                                               size_t partnum)
 {
        if (!cxt || !cxt->label || !cxt->label->op->part_get_type)
                return NULL;
 
-       DBG(LABEL, dbgprint("partition: %d: get type", partnum));
-       return cxt->label->op->part_get_type(cxt, cxt->label, partnum);
+       DBG(LABEL, dbgprint("partition: %zd: get type", partnum));
+       return cxt->label->op->part_get_type(cxt, partnum);
 }
 
 /**
@@ -203,7 +204,8 @@ struct fdisk_parttype *fdisk_get_partition_type(struct fdisk_context *cxt, int p
  *
  * Returns 0 on success, < 0 on error.
  */
-int fdisk_set_partition_type(struct fdisk_context *cxt, int partnum,
+int fdisk_set_partition_type(struct fdisk_context *cxt,
+                            size_t partnum,
                             struct fdisk_parttype *t)
 {
        if (!cxt || !cxt->label)
@@ -211,8 +213,8 @@ int fdisk_set_partition_type(struct fdisk_context *cxt, int partnum,
        if (!cxt->label->op->part_set_type)
                return -ENOSYS;
 
-       DBG(LABEL, dbgprint("partition: %d: set type", partnum));
-       return cxt->label->op->part_set_type(cxt, cxt->label, partnum, t);
+       DBG(LABEL, dbgprint("partition: %zd: set type", partnum));
+       return cxt->label->op->part_set_type(cxt, partnum, t);
 }
 
 /**
@@ -237,14 +239,16 @@ size_t fdisk_get_nparttypes(struct fdisk_context *cxt)
  *
  * Returns 0 on success, otherwise, a corresponding error.
  */
-int fdisk_partition_get_status(struct fdisk_context *cxt, int partnum, int *status)
+int fdisk_partition_get_status(struct fdisk_context *cxt,
+                              size_t partnum,
+                              int *status)
 {
        if (!cxt || !cxt->label)
                return -EINVAL;
        if (!cxt->label->op->part_get_status)
                return -ENOSYS;
 
-       return cxt->label->op->part_get_status(cxt, cxt->label, partnum, status);
+       return cxt->label->op->part_get_status(cxt, partnum, status);
 }
 
 
@@ -263,7 +267,6 @@ void fdisk_deinit_label(struct fdisk_label *lb)
 void fdisk_label_set_changed(struct fdisk_label *lb, int changed)
 {
        assert(lb);
-
        lb->changed = changed ? 1 : 0;
 }
 

diff --git a/libfdisk/src/libfdisk.h b/libfdisk/src/libfdisk.h
index 967d21e9a57b217a59db321a67f054def3c025ee..18b14163ec0ca5581bd855d1609f2bb23cc8c001 100644 (file)
--- a/libfdisk/src/libfdisk.h
+++ b/libfdisk/src/libfdisk.h
@@ -85,17 +85,17 @@ extern int fdisk_write_disklabel(struct fdisk_context *cxt);
 extern int fdisk_verify_disklabel(struct fdisk_context *cxt);
 extern int fdisk_create_disklabel(struct fdisk_context *cxt, const char *name);
 
-extern int fdisk_add_partition(struct fdisk_context *cxt, int partnum, struct fdisk_parttype *t);
-extern int fdisk_delete_partition(struct fdisk_context *cxt, int partnum);
+extern int fdisk_add_partition(struct fdisk_context *cxt, size_t partnum, struct fdisk_parttype *t);
+extern int fdisk_delete_partition(struct fdisk_context *cxt, size_t partnum);
 
-extern struct fdisk_parttype *fdisk_get_partition_type(struct fdisk_context *cxt, int partnum);
-extern int fdisk_set_partition_type(struct fdisk_context *cxt, int partnum,
+extern struct fdisk_parttype *fdisk_get_partition_type(struct fdisk_context *cxt, size_t partnum);
+extern int fdisk_set_partition_type(struct fdisk_context *cxt, size_t partnum,
                             struct fdisk_parttype *t);
 
 extern void fdisk_label_set_changed(struct fdisk_label *lb, int changed);
 extern int fdisk_label_is_changed(struct fdisk_label *lb);
 
-extern int fdisk_partition_get_status(struct fdisk_context *cxt, int partnum, int *status);
+extern int fdisk_partition_get_status(struct fdisk_context *cxt, size_t partnum, int *status);
 
 /* alignment.c */
 extern int fdisk_reset_alignment(struct fdisk_context *cxt);