libfdisk: rename sector_t to fdisk_sector_t

.. just to avoid too generic names for public API.

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

diff --git a/disk-utils/fdisk.c b/disk-utils/fdisk.c
index 8a66caeed6c3fc1f041aac87609a6c0e65016d26..cf86281bb6b0a226bbbf5d1c5f43cc398c4a783e 100644 (file)
--- a/disk-utils/fdisk.c
+++ b/disk-utils/fdisk.c
@@ -613,14 +613,14 @@ void dump_disklabel(struct fdisk_context *cxt)
                dump_blkdev(cxt, name, offset, size, all);
 }
 
-static sector_t get_dev_blocks(char *dev)
+static fdisk_sector_t get_dev_blocks(char *dev)
 {
        int fd, ret;
-       sector_t size;
+       fdisk_sector_t size;
 
        if ((fd = open(dev, O_RDONLY)) < 0)
                err(EXIT_FAILURE, _("cannot open %s"), dev);
-       ret = blkdev_get_sectors(fd, &size);
+       ret = blkdev_get_sectors(fd, (unsigned long long *) &size);
        close(fd);
        if (ret < 0)
                err(EXIT_FAILURE, _("BLKGETSIZE ioctl failed on %s"), dev);
@@ -823,10 +823,12 @@ int main(int argc, char **argv)
                        usage(stderr);
 
                for (i = optind; i < argc; i++) {
+                       uintmax_t blks = get_dev_blocks(argv[i]);
+
                        if (argc - optind == 1)
-                               printf("%llu\n", get_dev_blocks(argv[i]));
+                               printf("%ju\n", blks);
                        else
-                               printf("%s: %llu\n", argv[i], get_dev_blocks(argv[i]));
+                               printf("%s: %ju\n", argv[i], blks);
                }
                break;
 

diff --git a/libfdisk/src/alignment.c b/libfdisk/src/alignment.c
index b1f3ee5c3d94db9c6d28a192eb0eb2a7fd6d89ef..67f1ddd08451f8822f7c4e337f71adfb60f57b15 100644 (file)
--- a/libfdisk/src/alignment.c
+++ b/libfdisk/src/alignment.c
@@ -36,7 +36,7 @@
 /*
  * Alignment according to logical granularity (usually 1MiB)
  */
-static int lba_is_aligned(struct fdisk_context *cxt, sector_t lba)
+static int lba_is_aligned(struct fdisk_context *cxt, fdisk_sector_t lba)
 {
        unsigned long granularity = max(cxt->phy_sector_size, cxt->min_io_size);
        uintmax_t offset;
@@ -51,7 +51,7 @@ static int lba_is_aligned(struct fdisk_context *cxt, sector_t lba)
 /*
  * Alignment according to physical device topology (usually minimal i/o size)
  */
-static int lba_is_phy_aligned(struct fdisk_context *cxt, sector_t lba)
+static int lba_is_phy_aligned(struct fdisk_context *cxt, fdisk_sector_t lba)
 {
        unsigned long granularity = max(cxt->phy_sector_size, cxt->min_io_size);
        uintmax_t offset = (lba * cxt->sector_size) & (granularity - 1);
@@ -71,14 +71,14 @@ static int lba_is_phy_aligned(struct fdisk_context *cxt, sector_t lba)
  *
  * Returns: alignment LBA.
  */
-sector_t fdisk_align_lba(struct fdisk_context *cxt, sector_t lba, int direction)
+fdisk_sector_t fdisk_align_lba(struct fdisk_context *cxt, fdisk_sector_t lba, int direction)
 {
-       sector_t res;
+       fdisk_sector_t res;
 
        if (lba_is_aligned(cxt, lba))
                res = lba;
        else {
-               sector_t sects_in_phy = cxt->grain / cxt->sector_size;
+               fdisk_sector_t sects_in_phy = cxt->grain / cxt->sector_size;
 
                if (lba < cxt->first_lba)
                        res = cxt->first_lba;
@@ -128,10 +128,10 @@ sector_t fdisk_align_lba(struct fdisk_context *cxt, sector_t lba, int direction)
  *
  * Returns: aligned LBA
  */
-sector_t fdisk_align_lba_in_range(struct fdisk_context *cxt,
-                                 sector_t lba, sector_t start, sector_t stop)
+fdisk_sector_t fdisk_align_lba_in_range(struct fdisk_context *cxt,
+                                 fdisk_sector_t lba, fdisk_sector_t start, fdisk_sector_t stop)
 {
-       sector_t res;
+       fdisk_sector_t res;
 
        start = fdisk_align_lba(cxt, start, FDISK_ALIGN_UP);
        stop = fdisk_align_lba(cxt, stop, FDISK_ALIGN_DOWN);
@@ -161,7 +161,7 @@ sector_t fdisk_align_lba_in_range(struct fdisk_context *cxt,
  *
  * Returns: 1 if aligned.
  */
-int fdisk_lba_is_phy_aligned(struct fdisk_context *cxt, sector_t lba)
+int fdisk_lba_is_phy_aligned(struct fdisk_context *cxt, fdisk_sector_t lba)
 {
        return lba_is_phy_aligned(cxt, lba);
 }
@@ -405,7 +405,7 @@ int fdisk_reset_device_properties(struct fdisk_context *cxt)
  */
 int fdisk_discover_geometry(struct fdisk_context *cxt)
 {
-       sector_t nsects;
+       fdisk_sector_t nsects;
 
        assert(cxt);
        assert(cxt->geom.heads == 0);
@@ -413,7 +413,7 @@ int fdisk_discover_geometry(struct fdisk_context *cxt)
        DBG(CXT, ul_debugobj(cxt, "%s: discovering geometry...", cxt->dev_path));
 
        /* get number of 512-byte sectors, and convert it the real sectors */
-       if (!blkdev_get_sectors(cxt->dev_fd, &nsects))
+       if (!blkdev_get_sectors(cxt->dev_fd, (unsigned long long *) &nsects))
                cxt->total_sectors = (nsects / (cxt->sector_size >> 9));
 
        DBG(CXT, ul_debugobj(cxt, "total sectors: %ju (ioctl=%ju)",
@@ -503,9 +503,9 @@ static int has_topology(struct fdisk_context *cxt)
  *
  * Returns: 0 on error or number of logical sectors.
  */
-static sector_t topology_get_first_lba(struct fdisk_context *cxt)
+static fdisk_sector_t topology_get_first_lba(struct fdisk_context *cxt)
 {
-       sector_t x = 0, res;
+       fdisk_sector_t x = 0, res;
 
        if (!cxt)
                return 0;
@@ -601,13 +601,13 @@ int fdisk_reset_alignment(struct fdisk_context *cxt)
 }
 
 
-sector_t fdisk_scround(struct fdisk_context *cxt, sector_t num)
+fdisk_sector_t fdisk_scround(struct fdisk_context *cxt, fdisk_sector_t num)
 {
-       sector_t un = fdisk_get_units_per_sector(cxt);
+       fdisk_sector_t un = fdisk_get_units_per_sector(cxt);
        return (num + un - 1) / un;
 }
 
-sector_t fdisk_cround(struct fdisk_context *cxt, sector_t num)
+fdisk_sector_t fdisk_cround(struct fdisk_context *cxt, fdisk_sector_t num)
 {
        return fdisk_use_cylinders(cxt) ?
                        (num / fdisk_get_units_per_sector(cxt)) + 1 : num;

diff --git a/libfdisk/src/ask.c b/libfdisk/src/ask.c
index 647687ef8e02ea0d75ef01026b625ef160912175..7e0c3c218717942c207d2faa655ef4f683b40e99 100644 (file)
--- a/libfdisk/src/ask.c
+++ b/libfdisk/src/ask.c
@@ -987,7 +987,7 @@ int fdisk_warnx(struct fdisk_context *cxt, const char *fmt, ...)
 
 int fdisk_info_new_partition(
                        struct fdisk_context *cxt,
-                       int num, sector_t start, sector_t stop,
+                       int num, fdisk_sector_t start, fdisk_sector_t stop,
                        struct fdisk_parttype *t)
 {
        int rc;

diff --git a/libfdisk/src/bsd.c b/libfdisk/src/bsd.c
index d355cc0aa1afee9815197e1ffa823bf14c229cf9..0e45f6dcab4e3a734b1eca45a0ec94f7c19c6eb7 100644 (file)
--- a/libfdisk/src/bsd.c
+++ b/libfdisk/src/bsd.c
@@ -155,7 +155,7 @@ static int bsd_assign_dos_partition(struct fdisk_context *cxt)
        size_t i;
 
        for (i = 0; i < 4; i++) {
-               sector_t ss;
+               fdisk_sector_t ss;
 
                l->dos_part = fdisk_dos_get_partition(cxt->parent, i);
 
@@ -346,10 +346,10 @@ static int bsd_set_partition(struct fdisk_context *cxt, size_t n,
        if (l->dos_part && (fdisk_partition_has_start(pa) ||
                            fdisk_partition_has_size(pa))) {
 
-               sector_t dosbegin = dos_partition_get_start(l->dos_part);
-               sector_t dosend = dosbegin + dos_partition_get_size(l->dos_part) - 1;
-               sector_t begin = fdisk_partition_has_start(pa) ? pa->start : p->p_offset;
-               sector_t end = begin + (fdisk_partition_has_size(pa) ? pa->size : p->p_size) - 1;
+               fdisk_sector_t dosbegin = dos_partition_get_start(l->dos_part);
+               fdisk_sector_t dosend = dosbegin + dos_partition_get_size(l->dos_part) - 1;
+               fdisk_sector_t begin = fdisk_partition_has_start(pa) ? pa->start : p->p_offset;
+               fdisk_sector_t end = begin + (fdisk_partition_has_size(pa) ? pa->size : p->p_size) - 1;
 
                if (begin < dosbegin || begin > dosend)
                        return -ERANGE;
@@ -609,7 +609,7 @@ int fdisk_bsd_write_bootstrap(struct fdisk_context *cxt)
        char buf[BUFSIZ];
        char *res, *dp, *p;
        int rc;
-       sector_t sector;
+       fdisk_sector_t sector;
 
        snprintf(buf, sizeof(buf),
                _("Bootstrap: %1$sboot -> boot%1$s (default %1$s)"),

diff --git a/libfdisk/src/context.c b/libfdisk/src/context.c
index 42ad9f8a92b51a246a869ea37bec12467fd4a36a..2a4d377e05a43b76235284381c7fb238a79f8eac 100644 (file)
--- a/libfdisk/src/context.c
+++ b/libfdisk/src/context.c
@@ -854,7 +854,7 @@ unsigned long fdisk_get_grain_size(struct fdisk_context *cxt)
  *
  * Returns: first possible LBA on disk for data partitions.
  */
-sector_t fdisk_get_first_lba(struct fdisk_context *cxt)
+fdisk_sector_t fdisk_get_first_lba(struct fdisk_context *cxt)
 {
        assert(cxt);
        return cxt->first_lba;
@@ -876,7 +876,7 @@ sector_t fdisk_get_first_lba(struct fdisk_context *cxt)
  *
  * Returns: 0 on success, <0 on error.
  */
-sector_t fdisk_set_first_lba(struct fdisk_context *cxt, sector_t lba)
+fdisk_sector_t fdisk_set_first_lba(struct fdisk_context *cxt, fdisk_sector_t lba)
 {
        assert(cxt);
        DBG(CXT, ul_debugobj(cxt, "setting first LBA from %ju to %ju",
@@ -893,7 +893,7 @@ sector_t fdisk_set_first_lba(struct fdisk_context *cxt, sector_t lba)
  *
  * Returns: last possible LBA on device
  */
-sector_t fdisk_get_last_lba(struct fdisk_context *cxt)
+fdisk_sector_t fdisk_get_last_lba(struct fdisk_context *cxt)
 {
        return cxt->last_lba;
 }
@@ -913,7 +913,7 @@ sector_t fdisk_get_last_lba(struct fdisk_context *cxt)
  *
  * Returns: 0 on success, <0 on error.
  */
-sector_t fdisk_set_last_lba(struct fdisk_context *cxt, sector_t lba)
+fdisk_sector_t fdisk_set_last_lba(struct fdisk_context *cxt, fdisk_sector_t lba)
 {
        assert(cxt);
 
@@ -930,7 +930,7 @@ sector_t fdisk_set_last_lba(struct fdisk_context *cxt, sector_t lba)
  *
  * Returns: size of the device in logical sectors.
  */
-sector_t fdisk_get_nsectors(struct fdisk_context *cxt)
+fdisk_sector_t fdisk_get_nsectors(struct fdisk_context *cxt)
 {
        assert(cxt);
        return cxt->total_sectors;
@@ -977,7 +977,7 @@ unsigned int fdisk_get_geom_heads(struct fdisk_context *cxt)
  *
  * Returns: number of geometry sectors.
  */
-sector_t fdisk_get_geom_sectors(struct fdisk_context *cxt)
+fdisk_sector_t fdisk_get_geom_sectors(struct fdisk_context *cxt)
 {
        assert(cxt);
        return cxt->geom.sectors;
@@ -990,7 +990,7 @@ sector_t fdisk_get_geom_sectors(struct fdisk_context *cxt)
  *
  * Returns: number of geometry cylinders
  */
-sector_t fdisk_get_geom_cylinders(struct fdisk_context *cxt)
+fdisk_sector_t fdisk_get_geom_cylinders(struct fdisk_context *cxt)
 {
        assert(cxt);
        return cxt->geom.cylinders;

diff --git a/libfdisk/src/dos.c b/libfdisk/src/dos.c
index 16391806e8dd42b0f2e859cb158836eb9944cfde..ef336f632a0303ddc5ac136f712fcc5ad1a58afc 100644 (file)
--- a/libfdisk/src/dos.c
+++ b/libfdisk/src/dos.c
@@ -44,7 +44,7 @@
 struct pte {
        struct dos_partition *pt_entry; /* on-disk MBR entry */
        struct dos_partition *ex_entry; /* on-disk EBR entry */
-       sector_t offset;                /* disk sector number */
+       fdisk_sector_t offset;          /* disk sector number */
        unsigned char *sectorbuffer;    /* disk sector contents */
 
        unsigned int changed : 1,
@@ -58,7 +58,7 @@ struct fdisk_dos_label {
        struct fdisk_label      head;           /* generic part */
 
        struct pte      ptes[MAXIMUM_PARTS];    /* partition */
-       sector_t        ext_offset;             /* start of the ext.partition */
+       fdisk_sector_t  ext_offset;             /* start of the ext.partition */
        size_t          ext_index;              /* ext.partition index (if ext_offset is set) */
        unsigned int    compatible : 1,         /* is DOS compatible? */
                        non_pt_changed : 1;     /* MBR, but no PT changed */
@@ -167,7 +167,7 @@ static void partition_set_changed(
                fdisk_label_set_changed(cxt->label, 1);
 }
 
-static sector_t get_abs_partition_start(struct pte *pe)
+static fdisk_sector_t get_abs_partition_start(struct pte *pe)
 {
        assert(pe);
        assert(pe->pt_entry);
@@ -175,9 +175,9 @@ static sector_t get_abs_partition_start(struct pte *pe)
        return pe->offset + dos_partition_get_start(pe->pt_entry);
 }
 
-static sector_t get_abs_partition_end(struct pte *pe)
+static fdisk_sector_t get_abs_partition_end(struct pte *pe)
 {
-       sector_t size;
+       fdisk_sector_t size;
 
        assert(pe);
        assert(pe->pt_entry);
@@ -218,14 +218,14 @@ static int get_partition_unused_primary(struct fdisk_context *cxt,
        return rc;
 }
 
-static int seek_sector(struct fdisk_context *cxt, sector_t secno)
+static int seek_sector(struct fdisk_context *cxt, fdisk_sector_t secno)
 {
        off_t offset = (off_t) secno * cxt->sector_size;
 
        return lseek(cxt->dev_fd, offset, SEEK_SET) == (off_t) -1 ? -errno : 0;
 }
 
-static int read_sector(struct fdisk_context *cxt, sector_t secno,
+static int read_sector(struct fdisk_context *cxt, fdisk_sector_t secno,
                        unsigned char *buf)
 {
        int rc = seek_sector(cxt, secno);
@@ -243,7 +243,7 @@ static int read_sector(struct fdisk_context *cxt, sector_t secno,
 }
 
 /* Allocate a buffer and read a partition table sector */
-static int read_pte(struct fdisk_context *cxt, size_t pno, sector_t offset)
+static int read_pte(struct fdisk_context *cxt, size_t pno, fdisk_sector_t offset)
 {
        int rc;
        unsigned char *buf;
@@ -822,12 +822,12 @@ static int dos_probe_label(struct fdisk_context *cxt)
 }
 
 static void set_partition(struct fdisk_context *cxt,
-                         int i, int doext, sector_t start,
-                         sector_t stop, int sysid, int boot)
+                         int i, int doext, fdisk_sector_t start,
+                         fdisk_sector_t stop, int sysid, int boot)
 {
        struct pte *pe = self_pte(cxt, i);
        struct dos_partition *p;
-       sector_t offset;
+       fdisk_sector_t offset;
 
        assert(!FDISK_IS_UNDEF(start));
        assert(!FDISK_IS_UNDEF(stop));
@@ -862,14 +862,14 @@ static void set_partition(struct fdisk_context *cxt,
        partition_set_changed(cxt, i, 1);
 }
 
-static sector_t get_unused_start(struct fdisk_context *cxt,
-                                int part_n, sector_t start,
-                                sector_t first[], sector_t last[])
+static fdisk_sector_t get_unused_start(struct fdisk_context *cxt,
+                                int part_n, fdisk_sector_t start,
+                                fdisk_sector_t first[], fdisk_sector_t last[])
 {
        size_t i;
 
        for (i = 0; i < cxt->label->nparts_max; i++) {
-               sector_t lastplusoff;
+               fdisk_sector_t lastplusoff;
                struct pte *pe = self_pte(cxt, i);
 
                if (start == pe->offset)
@@ -883,7 +883,7 @@ static sector_t get_unused_start(struct fdisk_context *cxt,
 }
 
 static void fill_bounds(struct fdisk_context *cxt,
-                       sector_t *first, sector_t *last)
+                       fdisk_sector_t *first, fdisk_sector_t *last)
 {
        size_t i;
        struct pte *pe = self_pte(cxt, 0);
@@ -902,10 +902,10 @@ static void fill_bounds(struct fdisk_context *cxt,
 }
 
 static int get_start_from_user(        struct fdisk_context *cxt,
-                               sector_t *start,
-                               sector_t low,
-                               sector_t dflt,
-                               sector_t limit,
+                               fdisk_sector_t *start,
+                               fdisk_sector_t low,
+                               fdisk_sector_t dflt,
+                               fdisk_sector_t limit,
                                struct fdisk_partition *pa)
 {
        assert(start);
@@ -955,9 +955,9 @@ static int get_start_from_user(     struct fdisk_context *cxt,
        return 0;
 }
 
-static sector_t get_possible_last(struct fdisk_context *cxt, size_t n)
+static fdisk_sector_t get_possible_last(struct fdisk_context *cxt, size_t n)
 {
-       sector_t limit;
+       fdisk_sector_t limit;
 
        if (n >= 4) {
                /* logical partitions */
@@ -985,12 +985,12 @@ static sector_t get_possible_last(struct fdisk_context *cxt, size_t n)
 
 /* returns last free sector for area addressed by @start, the first[] and
  * last[] are fill_bounds() results */
-static sector_t get_unused_last(struct fdisk_context *cxt, size_t n,
-                               sector_t start,
-                               sector_t first[], sector_t last[])
+static fdisk_sector_t get_unused_last(struct fdisk_context *cxt, size_t n,
+                               fdisk_sector_t start,
+                               fdisk_sector_t first[], fdisk_sector_t last[])
 {
        size_t i;
-       sector_t limit = get_possible_last(cxt, n);
+       fdisk_sector_t limit = get_possible_last(cxt, n);
 
        for (i = 0; i < cxt->label->nparts_max; i++) {
                struct pte *pe = self_pte(cxt, i);
@@ -1015,7 +1015,7 @@ static int add_partition(struct fdisk_context *cxt, size_t n,
        struct dos_partition *p = self_partition(cxt, n);
        struct pte *ext_pe = l->ext_offset ? self_pte(cxt, l->ext_index) : NULL;
 
-       sector_t start, stop = 0, limit, temp,
+       fdisk_sector_t start, stop = 0, limit, temp,
                first[cxt->label->nparts_max],
                last[cxt->label->nparts_max];
 
@@ -1070,7 +1070,7 @@ static int add_partition(struct fdisk_context *cxt, size_t n,
         * Ask for first sector
         */
        do {
-               sector_t dflt, aligned;
+               fdisk_sector_t dflt, aligned;
 
                temp = start;
                dflt = start = get_unused_start(cxt, n, start, first, last);
@@ -1389,9 +1389,9 @@ static void check_consistency(struct fdisk_context *cxt, struct dos_partition *p
 static int dos_verify_disklabel(struct fdisk_context *cxt)
 {
        size_t i, j;
-       sector_t total = 1, n_sectors = cxt->total_sectors;
-       unsigned long long first[cxt->label->nparts_max],
-                          last[cxt->label->nparts_max];
+       fdisk_sector_t total = 1, n_sectors = cxt->total_sectors;
+       fdisk_sector_t first[cxt->label->nparts_max],
+                      last[cxt->label->nparts_max];
        struct dos_partition *p;
        struct fdisk_dos_label *l = self_label(cxt);
 
@@ -1433,7 +1433,7 @@ static int dos_verify_disklabel(struct fdisk_context *cxt)
        }
 
        if (l->ext_offset) {
-               sector_t e_last;
+               fdisk_sector_t e_last;
                struct pte *ext_pe = self_pte(cxt, l->ext_index);
 
                e_last = get_abs_partition_end(ext_pe);
@@ -1478,7 +1478,7 @@ static int dos_add_partition(struct fdisk_context *cxt,
                             size_t *partno)
 {
        size_t i, free_primary = 0, free_sectors = 0;
-       sector_t last = 0, grain;
+       fdisk_sector_t last = 0, grain;
        int rc = 0;
        struct fdisk_dos_label *l;
        struct pte *ext_pe;
@@ -1541,7 +1541,7 @@ static int dos_add_partition(struct fdisk_context *cxt,
                struct dos_partition *p = self_partition(cxt, i);
 
                if (is_used_partition(p)) {
-                       sector_t start = dos_partition_get_start(p);
+                       fdisk_sector_t start = dos_partition_get_start(p);
                        if (last + grain <= start)
                                free_sectors = 1;
                        last = start + dos_partition_get_size(p);
@@ -1661,7 +1661,7 @@ done:
        return rc;
 }
 
-static int write_sector(struct fdisk_context *cxt, sector_t secno,
+static int write_sector(struct fdisk_context *cxt, fdisk_sector_t secno,
                               unsigned char *buf)
 {
        int rc;
@@ -1712,7 +1712,7 @@ static int dos_write_disklabel(struct fdisk_context *cxt)
                 * been modified and then cleanup possible remaining EBR  */
                struct pte *pe = self_pte(cxt, l->ext_index);
                unsigned char empty[512] = { 0 };
-               sector_t off = pe ? get_abs_partition_start(pe) : 0;
+               fdisk_sector_t off = pe ? get_abs_partition_start(pe) : 0;
 
                if (off && pe->changed) {
                        mbr_set_magic(empty);
@@ -1869,7 +1869,7 @@ static int dos_set_partition(struct fdisk_context *cxt, size_t n,
        struct fdisk_dos_label *l;
        struct dos_partition *p;
        struct pte *pe;
-       sector_t start, size;
+       fdisk_sector_t start, size;
 
        assert(cxt);
        assert(pa);
@@ -1901,7 +1901,7 @@ static int dos_set_partition(struct fdisk_context *cxt, size_t n,
                size = pa->size;
 
        if (pa->end_follow_default) {
-               sector_t first[cxt->label->nparts_max],
+               fdisk_sector_t first[cxt->label->nparts_max],
                         last[cxt->label->nparts_max],
                         xlast;
                struct pte *ext = l->ext_offset ? self_pte(cxt, l->ext_index) : NULL; 
@@ -2018,7 +2018,7 @@ again:
                    get_abs_partition_start(nxt)) {
 
                        struct dos_partition tmp = *cur->pt_entry;
-                       sector_t cur_start = get_abs_partition_start(cur),
+                       fdisk_sector_t cur_start = get_abs_partition_start(cur),
                                 nxt_start = get_abs_partition_start(nxt);
 
                        /* swap data partitions */
@@ -2041,7 +2041,7 @@ again:
                struct pte *cur = self_pte(cxt, i),
                           *nxt = self_pte(cxt, i + 1);
 
-               sector_t noff = nxt->offset - l->ext_offset,
+               fdisk_sector_t noff = nxt->offset - l->ext_offset,
                         ooff = dos_partition_get_start(cur->ex_entry);
 
                if (noff == ooff)

diff --git a/libfdisk/src/fdiskP.h b/libfdisk/src/fdiskP.h
index 85fd2cd8be9a7d95a12c4a26756fdac0c1ad6d21..b912e6c6bc0d9eb36f0f5213c75cc136e53ff5a4 100644 (file)
--- a/libfdisk/src/fdiskP.h
+++ b/libfdisk/src/fdiskP.h
@@ -118,9 +118,9 @@ struct fdisk_partition {
        size_t          partno;                 /* partition number */
        size_t          parent_partno;          /* for logical partitions */
 
-       uint64_t        start;                  /* first sectors */
-       uint64_t        end;                    /* last sector */
-       uint64_t        size;                   /* size in sectors */
+       fdisk_sector_t  start;                  /* first sectors */
+       fdisk_sector_t  end;                    /* last sector */
+       fdisk_sector_t  size;                   /* size in sectors */
 
        char            *name;                  /* partition name */
        char            *uuid;                  /* partition UUID */
@@ -167,8 +167,8 @@ struct fdisk_table {
  */
 struct fdisk_geometry {
        unsigned int heads;
-       sector_t sectors;
-       sector_t cylinders;
+       fdisk_sector_t sectors;
+       fdisk_sector_t cylinders;
 };
 
 /*
@@ -354,11 +354,11 @@ struct fdisk_context {
 
        /* alignment */
        unsigned long grain;            /* alignment unit */
-       sector_t first_lba;             /* recommended begin of the first partition */
-       sector_t last_lba;              /* recomennded end of last partition */
+       fdisk_sector_t first_lba;               /* recommended begin of the first partition */
+       fdisk_sector_t last_lba;                /* recomennded end of last partition */
 
        /* geometry */
-       sector_t total_sectors; /* in logical sectors */
+       fdisk_sector_t total_sectors;   /* in logical sectors */
        struct fdisk_geometry geom;
 
        /* user setting to overwrite device default */
@@ -390,8 +390,8 @@ extern int __fdisk_switch_label(struct fdisk_context *cxt,
 extern int fdisk_missing_geometry(struct fdisk_context *cxt);
 
 /* alignment.c */
-sector_t fdisk_scround(struct fdisk_context *cxt, sector_t num);
-sector_t fdisk_cround(struct fdisk_context *cxt, sector_t num);
+fdisk_sector_t fdisk_scround(struct fdisk_context *cxt, fdisk_sector_t num);
+fdisk_sector_t fdisk_cround(struct fdisk_context *cxt, fdisk_sector_t num);
 
 extern int fdisk_discover_geometry(struct fdisk_context *cxt);
 extern int fdisk_discover_topology(struct fdisk_context *cxt);
@@ -428,7 +428,7 @@ int fdisk_ask_print_set_errno(struct fdisk_ask *ask, int errnum);
 int fdisk_ask_print_set_mesg(struct fdisk_ask *ask, const char *mesg);
 int fdisk_info_new_partition(
                        struct fdisk_context *cxt,
-                       int num, sector_t start, sector_t stop,
+                       int num, fdisk_sector_t start, fdisk_sector_t stop,
                        struct fdisk_parttype *t);
 
 /* dos.c */

diff --git a/libfdisk/src/libfdisk.h.in b/libfdisk/src/libfdisk.h.in
index 52b18db2675b9f8542d2b3bcf517347ef5ef1322..0b500b2364129b9f27ced46bbdfeb13cd30b09df 100644 (file)
--- a/libfdisk/src/libfdisk.h.in
+++ b/libfdisk/src/libfdisk.h.in
@@ -95,12 +95,16 @@ struct fdisk_field;
 /**
  * fdisk_script
  *
- * libraru handler for sfdisk compatible scripts
+ * library handler for sfdisk compatible scripts
  */
 struct fdisk_script;
 
-/* TODO: use uint64, the name is too generic */
-typedef unsigned long long sector_t;
+/**
+ * fdisk_sector_t
+ *
+ * LBA adresses type
+ */
+typedef uint64_t fdisk_sector_t;
 
 /**
  * fdisk_labeltype:
@@ -179,17 +183,17 @@ unsigned long fdisk_get_physector_size(struct fdisk_context *cxt);
 unsigned long fdisk_get_sector_size(struct fdisk_context *cxt);
 unsigned long fdisk_get_alignment_offset(struct fdisk_context *cxt);
 unsigned long fdisk_get_grain_size(struct fdisk_context *cxt);
-sector_t fdisk_get_first_lba(struct fdisk_context *cxt);
-sector_t fdisk_set_first_lba(struct fdisk_context *cxt, sector_t lba);
-sector_t fdisk_get_last_lba(struct fdisk_context *cxt);
-sector_t fdisk_set_last_lba(struct fdisk_context *cxt, sector_t lba);
-sector_t fdisk_get_nsectors(struct fdisk_context *cxt);
+fdisk_sector_t fdisk_get_first_lba(struct fdisk_context *cxt);
+fdisk_sector_t fdisk_set_first_lba(struct fdisk_context *cxt, fdisk_sector_t lba);
+fdisk_sector_t fdisk_get_last_lba(struct fdisk_context *cxt);
+fdisk_sector_t fdisk_set_last_lba(struct fdisk_context *cxt, fdisk_sector_t lba);
+fdisk_sector_t fdisk_get_nsectors(struct fdisk_context *cxt);
 const char *fdisk_get_devname(struct fdisk_context *cxt);
 int fdisk_get_devfd(struct fdisk_context *cxt);
 
 unsigned int fdisk_get_geom_heads(struct fdisk_context *cxt);
-sector_t fdisk_get_geom_sectors(struct fdisk_context *cxt);
-sector_t fdisk_get_geom_cylinders(struct fdisk_context *cxt);
+fdisk_sector_t fdisk_get_geom_sectors(struct fdisk_context *cxt);
+fdisk_sector_t fdisk_get_geom_cylinders(struct fdisk_context *cxt);
 
 
 
@@ -394,10 +398,10 @@ extern int fdisk_apply_table(struct fdisk_context *cxt, struct fdisk_table *tb);
 #define FDISK_ALIGN_DOWN       2
 #define FDISK_ALIGN_NEAREST    3
 
-sector_t fdisk_align_lba(struct fdisk_context *cxt, sector_t lba, int direction);
-sector_t fdisk_align_lba_in_range(struct fdisk_context *cxt,
-                                 sector_t lba, sector_t start, sector_t stop);
-int fdisk_lba_is_phy_aligned(struct fdisk_context *cxt, sector_t lba);
+fdisk_sector_t fdisk_align_lba(struct fdisk_context *cxt, fdisk_sector_t lba, int direction);
+fdisk_sector_t fdisk_align_lba_in_range(struct fdisk_context *cxt,
+                                 fdisk_sector_t lba, fdisk_sector_t start, fdisk_sector_t stop);
+int fdisk_lba_is_phy_aligned(struct fdisk_context *cxt, fdisk_sector_t lba);
 
 int fdisk_override_geometry(struct fdisk_context *cxt,
                            unsigned int cylinders,

diff --git a/libfdisk/src/partition.c b/libfdisk/src/partition.c
index 90276416e09a6a15a72e8a175d5a34540e1bd449..1ea0b7aea989f77a2d6608a957e69008db8eead0 100644 (file)
--- a/libfdisk/src/partition.c
+++ b/libfdisk/src/partition.c
@@ -114,7 +114,7 @@ void fdisk_unref_partition(struct fdisk_partition *pa)
  *
  * Returns: 0 on success, <0 on error.
  */
-int fdisk_partition_set_start(struct fdisk_partition *pa, uint64_t off)
+int fdisk_partition_set_start(struct fdisk_partition *pa, fdisk_sector_t off)
 {
        if (!pa)
                return -EINVAL;
@@ -151,7 +151,7 @@ int fdisk_partition_unset_start(struct fdisk_partition *pa)
  *
  * Returns: start offset in sectors
  */
-uint64_t fdisk_partition_get_start(struct fdisk_partition *pa)
+fdisk_sector_t fdisk_partition_get_start(struct fdisk_partition *pa)
 {
        return pa->start;
 }
@@ -236,7 +236,7 @@ int fdisk_partition_start_is_default(struct fdisk_partition *pa)
  *
  * Returns: 0 on success, <0 on error.
  */
-int fdisk_partition_set_size(struct fdisk_partition *pa, uint64_t sz)
+int fdisk_partition_set_size(struct fdisk_partition *pa, fdisk_sector_t sz)
 {
        if (!pa)
                return -EINVAL;
@@ -273,7 +273,7 @@ int fdisk_partition_unset_size(struct fdisk_partition *pa)
  *
  * Returns: size offset in sectors
  */
-uint64_t fdisk_partition_get_size(struct fdisk_partition *pa)
+fdisk_sector_t fdisk_partition_get_size(struct fdisk_partition *pa)
 {
        return pa->size;
 }
@@ -688,7 +688,8 @@ int fdisk_partition_to_string(struct fdisk_partition *pa,
                        fdisk_cround(cxt, fdisk_partition_has_size(pa) ? pa->size : 0));
                break;
        case FDISK_FIELD_SECTORS:
-               rc = asprintf(&p, "%ju", fdisk_partition_has_size(pa) ? pa->size : 0);
+               rc = asprintf(&p, "%ju",
+                       fdisk_partition_has_size(pa) ? (uintmax_t) pa->size : 0);
                break;
        case FDISK_FIELD_BSIZE:
                rc = asprintf(&p, "%ju", pa->bsize);

diff --git a/libfdisk/src/sgi.c b/libfdisk/src/sgi.c
index ce30f3e61ad93a1ae64c1e42ee9ce6cb349a29e0..a646cf39099f662df20285118c686483ca2c3b7d 100644 (file)
--- a/libfdisk/src/sgi.c
+++ b/libfdisk/src/sgi.c
@@ -332,7 +332,7 @@ static struct fdisk_parttype *sgi_get_parttype(struct fdisk_context *cxt, size_t
 /* fdisk_get_partition() backend */
 static int sgi_get_partition(struct fdisk_context *cxt, size_t n, struct fdisk_partition *pa)
 {
-       uint64_t start, len;
+       fdisk_sector_t start, len;
 
        pa->used = sgi_get_num_sectors(cxt, n) > 0;
        if (!pa->used)
@@ -945,11 +945,11 @@ static int sgi_create_disklabel(struct fdisk_context *cxt)
 
 #ifdef HDIO_GETGEO
        if (cxt->geom.heads && cxt->geom.sectors) {
-               sector_t llsectors;
+               fdisk_sector_t llsectors;
 
-               if (blkdev_get_sectors(cxt->dev_fd, &llsectors) == 0) {
+               if (blkdev_get_sectors(cxt->dev_fd, (unsigned long long *) &llsectors) == 0) {
                        /* the get device size ioctl was successful */
-                       sector_t llcyls;
+                       fdisk_sector_t llcyls;
                        int sec_fac = cxt->sector_size / 512;
 
                        llcyls = llsectors / (cxt->geom.heads * cxt->geom.sectors * sec_fac);

diff --git a/libfdisk/src/sun.c b/libfdisk/src/sun.c
index eb7bb43ebeedc688cbc517238217249738c36505..6c77a8f61a2290e8242bd79cd7c9a606de062202 100644 (file)
--- a/libfdisk/src/sun.c
+++ b/libfdisk/src/sun.c
@@ -227,11 +227,11 @@ static int sun_create_disklabel(struct fdisk_context *cxt)
 
 #ifdef HDIO_GETGEO
        if (cxt->geom.heads && cxt->geom.sectors) {
-               sector_t llsectors;
+               fdisk_sector_t llsectors;
 
-               if (blkdev_get_sectors(cxt->dev_fd, &llsectors) == 0) {
+               if (blkdev_get_sectors(cxt->dev_fd, (unsigned long long *) &llsectors) == 0) {
                        int sec_fac = cxt->sector_size / 512;
-                       sector_t llcyls;
+                       fdisk_sector_t llcyls;
 
                        llcyls = llsectors / (cxt->geom.heads * cxt->geom.sectors * sec_fac);
                        cxt->geom.cylinders = llcyls;
@@ -260,9 +260,11 @@ static int sun_create_disklabel(struct fdisk_context *cxt)
        sunlabel->ncyl   = cpu_to_be16(cxt->geom.cylinders);
 
        snprintf((char *) sunlabel->label_id, sizeof(sunlabel->label_id),
-                "Linux cyl %llu alt %u hd %u sec %llu",
-                cxt->geom.cylinders, be16_to_cpu(sunlabel->acyl),
-                cxt->geom.heads, cxt->geom.sectors);
+                "Linux cyl %ju alt %u hd %u sec %ju",
+                (uintmax_t) cxt->geom.cylinders,
+                be16_to_cpu(sunlabel->acyl),
+                cxt->geom.heads,
+                (uintmax_t) cxt->geom.sectors);
 
        if (cxt->geom.cylinders * cxt->geom.heads * cxt->geom.sectors >= 150 * 2048) {
                ndiv = cxt->geom.cylinders - (50 * 2048 / (cxt->geom.heads * cxt->geom.sectors)); /* 50M swap */
@@ -470,7 +472,7 @@ static int sun_verify_disklabel(struct fdisk_context *cxt)
 
 
 static int is_free_sector(struct fdisk_context *cxt,
-               sector_t s, uint32_t starts[], uint32_t lens[])
+               fdisk_sector_t s, uint32_t starts[], uint32_t lens[])
 {
        size_t i;
 

diff --git a/libfdisk/src/table.c b/libfdisk/src/table.c
index 9747f7dc8313e58ea9addc5059b3dde0dd890d7a..221ec46bd49c3675d362608b2e9827195f0f3e4b 100644 (file)
--- a/libfdisk/src/table.c
+++ b/libfdisk/src/table.c
@@ -335,8 +335,8 @@ int fdisk_table_sort_partitions(struct fdisk_table *tb,
 
 /* allocates a new freespace description */
 static int new_freespace(struct fdisk_context *cxt,
-                        uint64_t start,
-                        uint64_t end,
+                        fdisk_sector_t start,
+                        fdisk_sector_t end,
                         struct fdisk_partition *parent,
                         struct fdisk_partition **pa)
 {
@@ -365,8 +365,8 @@ static int new_freespace(struct fdisk_context *cxt,
 static int table_add_freespace(
                        struct fdisk_context *cxt,
                        struct fdisk_table *tb,
-                       uint64_t start,
-                       uint64_t end,
+                       fdisk_sector_t start,
+                       fdisk_sector_t end,
                        struct fdisk_partition *parent)
 {
        struct fdisk_partition *pa, *x, *real_parent = NULL, *best = NULL;
@@ -424,8 +424,7 @@ static int check_container_freespace(struct fdisk_context *cxt,
 {
        struct fdisk_iter itr;
        struct fdisk_partition *pa;
-       uint64_t x, last, grain;
-       uint64_t lastplusoff;
+       fdisk_sector_t x, last, grain, lastplusoff;
        int rc = 0;
 
        assert(cxt);
@@ -482,7 +481,7 @@ done:
 int fdisk_get_freespaces(struct fdisk_context *cxt, struct fdisk_table **tb)
 {
        int rc = 0;
-       uint64_t last, grain;
+       fdisk_sector_t last, grain;
        struct fdisk_table *parts = NULL;
        struct fdisk_partition *pa;
        struct fdisk_iter itr;
@@ -556,7 +555,7 @@ int fdisk_table_wrong_order(struct fdisk_table *tb)
 {
        struct fdisk_partition *pa;
        struct fdisk_iter itr;
-       sector_t last = 0;
+       fdisk_sector_t last = 0;
 
        DBG(TAB, ul_debugobj(tb, "wrong older check"));