bump minor version number.

diff --git a/VERSION b/VERSION
index d11b4e5d3f10a48c2505c06ffb977aaf98ca4604..2271587e91bef87cf4f77a75722bae2456fd7893 100644 (file)
--- a/VERSION
+++ b/VERSION
@@ -3,5 +3,5 @@
 #
 PKG_MAJOR=1
 PKG_MINOR=2
-PKG_REVISION=1
+PKG_REVISION=2
 PKG_BUILD=0

diff --git a/bmap/xfs_bmap.c b/bmap/xfs_bmap.c
index bd594a7bcfda33e449605ee2b051b122289fbb2e..ce413e3436a8043d5fc7d1b2d23789d3a79d6bc6 100644 (file)
--- a/bmap/xfs_bmap.c
+++ b/bmap/xfs_bmap.c
@@ -180,7 +180,7 @@ dofile(char *fname)
        map = malloc(map_size*sizeof(*map));
        if (map == NULL) {
                fprintf(stderr, "malloc of %d bytes failed.\n",
-                                                       map_size*sizeof(*map));
+                               (int)(map_size * sizeof(*map)));
                close(fd);
                return 1;
        }
@@ -227,9 +227,10 @@ dofile(char *fname)
                        printf(
                "xfs_bmap: i=%d map.bmv_offset=%lld, map.bmv_block=%lld, "
                "map.bmv_length=%lld, map.bmv_count=%d, map.bmv_entries=%d\n",
-                                       i, map->bmv_offset, map->bmv_block,
-                                       map->bmv_length, map->bmv_count,
-                                       map->bmv_entries);
+                                       i, (long long)map->bmv_offset,
+                                       (long long)map->bmv_block,
+                                       (long long)map->bmv_length,
+                                       map->bmv_count, map->bmv_entries);
                if (i < 0) {
                        if (   errno == EINVAL
                            && !aflag && file_size(fd, fname) == 0) {
@@ -263,8 +264,8 @@ dofile(char *fname)
                        map_size = 2*(fsx.fsx_nextents+1);
                        map = realloc(map, map_size*sizeof(*map));
                        if (map == NULL) {
-                               fprintf(stderr,"cannot realloc %d bytes.\n",
-                                               map_size*sizeof(*map));
+                               fprintf(stderr, "cannot realloc %d bytes.\n",
+                                               (int)(map_size * sizeof(*map)));
                                close(fd);
                                return 1;
                        }
@@ -283,19 +284,20 @@ dofile(char *fname)
        if (!vflag) {
                for (i = 0; i < map->bmv_entries; i++) {
                        printf("\t%d: [%lld..%lld]: ", i,
-                               map[i + 1].bmv_offset,
-                               map[i + 1].bmv_offset + 
-                               map[i + 1].bmv_length - 1LL);
+                               (long long) map[i + 1].bmv_offset,
+                               (long long)(map[i + 1].bmv_offset + 
+                               map[i + 1].bmv_length - 1LL));
                        if (map[i + 1].bmv_block == -1)
                                printf("hole");
                        else {
-                               printf("%lld..%lld", map[i + 1].bmv_block,
-                                       map[i + 1].bmv_block +
-                                               map[i + 1].bmv_length - 1LL);
+                               printf("%lld..%lld",
+                                       (long long) map[i + 1].bmv_block,
+                                       (long long)(map[i + 1].bmv_block +
+                                               map[i + 1].bmv_length - 1LL));
 
                        }
                        if (lflag)
-                               printf(" %lld blocks\n", map[i+1].bmv_length);
+                               printf(" %lld blocks\n", (long long)map[i+1].bmv_length);
                        else
                                printf("\n");
                }
@@ -325,22 +327,22 @@ dofile(char *fname)
                 */
                for (i = 0; i < map->bmv_entries; i++) {
                        sprintf(rbuf, "[%lld..%lld]:", 
-                               map[i + 1].bmv_offset,
-                               map[i + 1].bmv_offset +
-                               map[i + 1].bmv_length - 1LL);
+                               (long long) map[i + 1].bmv_offset,
+                               (long long)(map[i + 1].bmv_offset +
+                               map[i + 1].bmv_length - 1LL));
                        if (map[i + 1].bmv_block == -1) {
                                foff_w = max(foff_w, strlen(rbuf)); 
                                tot_w = max(tot_w, 
                                        numlen(map[i+1].bmv_length));
                        } else {
                                sprintf(bbuf, "%lld..%lld", 
-                                       map[i + 1].bmv_block,
-                                       map[i + 1].bmv_block +
-                                               map[i + 1].bmv_length - 1LL);
+                                       (long long) map[i + 1].bmv_block,
+                                       (long long)(map[i + 1].bmv_block +
+                                               map[i + 1].bmv_length - 1LL));
                                agno = map[i + 1].bmv_block / bbperag;
                                agoff = map[i + 1].bmv_block - (agno * bbperag);
                                sprintf(abuf, "(%lld..%lld)", 
-                                       agoff, 
+                                       (long long)agoff,  (long long)
                                        (agoff + map[i + 1].bmv_length - 1LL));
                                foff_w = max(foff_w, strlen(rbuf)); 
                                boff_w = max(boff_w, strlen(bbuf)); 
@@ -359,9 +361,9 @@ dofile(char *fname)
                        tot_w, "TOTAL");
                for (i = 0; i < map->bmv_entries; i++) {
                        sprintf(rbuf, "[%lld..%lld]:", 
-                               map[i + 1].bmv_offset,
-                               map[i + 1].bmv_offset +
-                               map[i + 1].bmv_length - 1LL);
+                               (long long) map[i + 1].bmv_offset,
+                               (long long)(map[i + 1].bmv_offset +
+                               map[i + 1].bmv_length - 1LL));
                        if (map[i + 1].bmv_block == -1) {
                                printf("%4d: %-*s %-*s %*s %-*s %*lld\n", 
                                        i, 
@@ -369,16 +371,16 @@ dofile(char *fname)
                                        boff_w, "hole", 
                                        agno_w, "",
                                        aoff_w, "", 
-                                       tot_w, map[i+1].bmv_length);
+                                       tot_w, (long long)map[i+1].bmv_length);
                        } else {
                                sprintf(bbuf, "%lld..%lld", 
-                                       map[i + 1].bmv_block,
-                                       map[i + 1].bmv_block +
-                                               map[i + 1].bmv_length - 1LL);
+                                       (long long) map[i + 1].bmv_block,
+                                       (long long)(map[i + 1].bmv_block +
+                                               map[i + 1].bmv_length - 1LL));
                                agno = map[i + 1].bmv_block / bbperag;
                                agoff = map[i + 1].bmv_block - (agno * bbperag);
                                sprintf(abuf, "(%lld..%lld)", 
-                                       agoff, 
+                                       (long long)agoff,  (long long)
                                        (agoff + map[i + 1].bmv_length - 1LL));
                                printf("%4d: %-*s %-*s %*d %-*s %*lld\n", 
                                        i, 
@@ -386,7 +388,7 @@ dofile(char *fname)
                                        boff_w, bbuf, 
                                        agno_w, agno, 
                                        aoff_w, abuf, 
-                                       tot_w, map[i+1].bmv_length);
+                                       tot_w, (long long)map[i+1].bmv_length);
                        }
                }
        }

diff --git a/db/io.c b/db/io.c
index 849103d4b71c0c68e158b713784a580f19a72744..bb247b98f85561fafe19fa10858e3b38502366a6 100644 (file)
--- a/db/io.c
+++ b/db/io.c
@@ -567,7 +567,7 @@ set_cur(
 
 #ifdef DEBUG
        if (bbmap)
-               printf("xfs_db got a bbmap for %lld\n", d);
+               printf("xfs_db got a bbmap for %lld\n", (long long)d);
 #endif
        ino = iocur_top->ino;
        dirino = iocur_top->dirino;

diff --git a/doc/CHANGES b/doc/CHANGES
index c28f8454380b791b10ab198b44496c7a23ba1d9e..8c5c1a7ded3bb8dd86449b24a3e557dc934d851d 100644 (file)
--- a/doc/CHANGES
+++ b/doc/CHANGES
@@ -1,3 +1,8 @@
+
+xfsprogs-1.2.2 (09 April 2001)
+       - fix problem in xfs_db (check) group quota logic
+       - fixes to warnings from recent gcc and/or 64-bit builds
+
 xfsprogs-1.2.1 (04 April 2001)
        - sync up with recent changes to XFS kernel headers
 

diff --git a/growfs/xfs_growfs.c b/growfs/xfs_growfs.c
index 555f924b408e1c4721bf8de02bea8428dbf298d9..a03a248517edd7ce494393d4c7563e61074fa468 100644 (file)
--- a/growfs/xfs_growfs.c
+++ b/growfs/xfs_growfs.c
@@ -79,12 +79,13 @@ report_info(
               "log      =%-22s bsize=%-6d blocks=%d\n"
               "realtime =%-22s extsz=%-6d blocks=%lld, rtextents=%lld\n",
               mntpoint, geo.inodesize, geo.agcount, geo.agblocks,
-              "", geo.blocksize, geo.datablocks, geo.imaxpct,
+              "", geo.blocksize, (long long)geo.datablocks, geo.imaxpct,
               "", geo.sunit, geo.swidth, unwritten,
               dirversion, geo.dirblocksize,
               isint ? "internal" : "external", geo.blocksize, geo.logblocks,
               geo.rtblocks ? "external" : "none",
-              geo.rtextsize * geo.blocksize, geo.rtblocks, geo.rtextents);
+              geo.rtextsize * geo.blocksize,
+              (long long)geo.rtblocks, (long long)geo.rtextents);
 }
 
 void
@@ -319,14 +320,15 @@ main(int argc, char **argv)
                        dsize = ddsize / (geo.blocksize / BBSIZE);
                else if (dsize > ddsize / (geo.blocksize / BBSIZE)) {
                        fprintf(stderr,
-                               "data size %llu too large, maximum is %lld\n",
-                               (__u64)dsize, ddsize/(geo.blocksize/BBSIZE));
+                               "data size %lld too large, maximum is %lld\n",
+                               (long long)dsize,
+                               (long long)(ddsize/(geo.blocksize/BBSIZE)));
                        error = 1;
                }
                if (!error && dsize < geo.datablocks) {
-                       fprintf(stderr, "data size %llu too small,"
+                       fprintf(stderr, "data size %lld too small,"
                                " old size is %lld\n",
-                               (__u64)dsize, geo.datablocks);
+                               (long long)dsize, (long long)geo.datablocks);
                        error = 1;
                } else if (!error &&
                           dsize == geo.datablocks && maxpct == geo.imaxpct) {
@@ -369,7 +371,7 @@ main(int argc, char **argv)
                if (!error && rsize < geo.rtblocks) {
                        fprintf(stderr,
                        "realtime size %lld too small, old size is %lld\n",
-                               rsize, geo.rtblocks);
+                               (long long)rsize, (long long)geo.rtblocks);
                        error = 1;
                } else if (!error && rsize == geo.rtblocks) {
                        if (rflag)
@@ -437,7 +439,7 @@ main(int argc, char **argv)
        }
        if (geo.datablocks != ngeo.datablocks)
                printf("data blocks changed from %lld to %lld\n",
-                       geo.datablocks, ngeo.datablocks);
+                       (long long)geo.datablocks, (long long)ngeo.datablocks);
        if (geo.imaxpct != ngeo.imaxpct)
                printf("inode max percent changed from %d to %d\n",
                        geo.imaxpct, ngeo.imaxpct);
@@ -450,7 +452,7 @@ main(int argc, char **argv)
                        ngeo.logstart ? "internal" : "external");
        if (geo.rtblocks != ngeo.rtblocks)
                printf("realtime blocks changed from %lld to %lld\n",
-                       geo.rtblocks, ngeo.rtblocks);
+                       (long long)geo.rtblocks, (long long)ngeo.rtblocks);
        if (geo.rtextsize != ngeo.rtextsize)
                printf("realtime extent size changed from %d to %d\n",
                        geo.rtextsize, ngeo.rtextsize);

diff --git a/include/platform_defs.h.in b/include/platform_defs.h.in
index 262a7b492fafa541a583ca47ab249a871476ed60..75e9c854aeb74266f7a1039cbd52eeeb97796d2b 100644 (file)
--- a/include/platform_defs.h.in
+++ b/include/platform_defs.h.in
@@ -45,7 +45,7 @@
 #include <sys/param.h>
 #include <sys/types.h>
 
-#if (__GLIBC__ <= 2) && (__GLIBC_MINOR__ <= 1)
+#if (__GLIBC__ < 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ <= 1))
 # define constpp       const char * const *
 #else
 # define constpp       char * const *

diff --git a/include/xfs_types.h b/include/xfs_types.h
index 83d07197a8db6d9634c67e06aed43c5a06b9fe05..86f5237a15dd7f7c1bc8bba49f75f37de5be75b7 100644 (file)
--- a/include/xfs_types.h
+++ b/include/xfs_types.h
@@ -143,7 +143,7 @@ typedef enum {
 } xfs_btnum_t;
 
 
-#ifdef CONFIG_PROC_FS
+#if defined(CONFIG_PROC_FS) && defined(__KERNEL__)
 /*
  * XFS global statistics
  */

diff --git a/libhandle/handle.c b/libhandle/handle.c
index 80b0a0bf915a609bcdb9f77521bb6383684aa14d..103e7c3ef4553b5e81870ba59745c68e07e3647c 100644 (file)
--- a/libhandle/handle.c
+++ b/libhandle/handle.c
@@ -65,7 +65,7 @@ typedef union {
 int
 obj_to_handle (
        int             fsfd,
-       int             opcode,
+       unsigned int    opcode,
        comarg_t        obj,
        void            **hanp,
        size_t          *hlen);
@@ -213,7 +213,7 @@ handle_to_fsfd(void *hanp)
 int
 obj_to_handle (
        int             fsfd,
-       int             opcode,
+       unsigned int    opcode,
        comarg_t        obj,
        void            **hanp,
        size_t          *hlen)
@@ -234,7 +234,7 @@ obj_to_handle (
        hreq.ihandle  = NULL;
        hreq.ihandlen = 0;
        hreq.ohandle  = hbuf;
-       hreq.ohandlen = hlen;
+       hreq.ohandlen = (__u32 *)hlen;
 
        ret = (int) ioctl(fsfd, opcode, &hreq);
 
@@ -305,7 +305,7 @@ readlink_by_handle (
        hreq.ihandle  = hanp;
        hreq.ihandlen = hlen;
        hreq.ohandle  = buf;
-       hreq.ohandlen = &bufsiz;
+       hreq.ohandlen = (__u32 *)&bufsiz;
 
        return (int) ioctl(fd, XFS_IOC_READLINK_BY_HANDLE, &hreq);
 }

diff --git a/libxfs/init.c b/libxfs/init.c
index 88297138f36216dc94504fd25cee2e4cf678c707..b58b05be3bc070dc85b0bcffa26972c382a886e4 100644 (file)
--- a/libxfs/init.c
+++ b/libxfs/init.c
@@ -169,8 +169,8 @@ libxfs_device_to_fd(dev_t device)
                if (dev_map[d].dev == device) 
                        return dev_map[d].fd;
        
-       fprintf(stderr, "%s: device_to_fd: device %Ld is not open\n", 
-               progname, device);
+       fprintf(stderr, "%s: device_to_fd: device %lld is not open\n", 
+               progname, (long long)device);
        exit(1);
 }
 
@@ -218,8 +218,8 @@ libxfs_device_open(char *path, int creat, int readonly, int setblksize)
 
        for (d=0;d<MAX_DEVS;d++)
                if (dev_map[d].dev == dev) {
-                       fprintf(stderr, "%s: device %Ld is already open\n", 
-                           progname, dev);
+                       fprintf(stderr, "%s: device %lld is already open\n", 
+                           progname, (long long)dev);
                        exit(1);
                }
 
@@ -254,8 +254,8 @@ libxfs_device_close(dev_t dev)
                        return;
                }
 
-       fprintf(stderr, "%s: device_close: device %Ld is not open\n",
-                       progname, dev);
+       fprintf(stderr, "%s: device_close: device %lld is not open\n",
+                       progname, (long long)dev);
        ASSERT(0);
        exit(1);
 }
@@ -731,8 +731,8 @@ libxfs_mount(
        /* Allocate and initialize the per-ag data */
        size = sbp->sb_agcount * sizeof(xfs_perag_t);
        if ((mp->m_perag = calloc(size, 1)) == NULL) {
-               fprintf(stderr, "%s: failed to alloc %d bytes: %s\n",
-                       progname, size, strerror(errno));
+               fprintf(stderr, "%s: failed to alloc %ld bytes: %s\n",
+                       progname, (long)size, strerror(errno));
                exit(1);
        }
 

diff --git a/libxfs/rdwr.c b/libxfs/rdwr.c
index 06fb1a5e29c385988b42ac5159b49527b2b2e8ae..1e1d44ae4942f9873c1cde0c27d5a09f0df001b4 100644 (file)
--- a/libxfs/rdwr.c
+++ b/libxfs/rdwr.c
@@ -169,8 +169,8 @@ libxfs_getbuf(dev_t device, xfs_daddr_t blkno, int len)
 
        total = sizeof(xfs_buf_t) + BBTOB(len);
        if ((buf = calloc(total, 1)) == NULL) {
-               fprintf(stderr, "%s: buf calloc failed (%d bytes): %s\n",
-                       progname, total, strerror(errno));
+               fprintf(stderr, "%s: buf calloc failed (%ld bytes): %s\n",
+                       progname, (long)total, strerror(errno));
                exit(1);
        }
        /* by default, we allocate buffer directly after the header */
@@ -196,8 +196,8 @@ libxfs_readbufr(dev_t dev, xfs_daddr_t blkno, xfs_buf_t *buf, int len, int die)
        ASSERT(BBTOB(len) <= buf->b_bcount);
 
        if (lseek64(fd, BBTOOFF64(blkno), SEEK_SET) < 0) {
-               fprintf(stderr, "%s: lseek64 to %llu failed: %s\n",
-                       progname, BBTOOFF64(blkno), strerror(errno));
+               fprintf(stderr, "%s: lseek64 to %llu failed: %s\n", progname,
+                       (unsigned long long)BBTOOFF64(blkno), strerror(errno));
                ASSERT(0);
                if (die)
                        exit(1);
@@ -246,8 +246,8 @@ libxfs_writebuf_int(xfs_buf_t *buf, int die)
        int     fd = libxfs_device_to_fd(buf->b_dev);
 
        if (lseek64(fd, BBTOOFF64(buf->b_blkno), SEEK_SET) < 0) {
-               fprintf(stderr, "%s: lseek64 to %llu failed: %s\n",
-                       progname, BBTOOFF64(buf->b_blkno), strerror(errno));
+               fprintf(stderr, "%s: lseek64 to %llu failed: %s\n", progname,
+                       (unsigned long long)BBTOOFF64(buf->b_blkno), strerror(errno));
                ASSERT(0);
                if (die)
                        exit(1);
@@ -316,7 +316,7 @@ libxfs_zone_init(int size, char *name)
 
        if ((ptr = malloc(sizeof(xfs_zone_t))) == NULL) {
                fprintf(stderr, "%s: zone init failed (%s, %d bytes): %s\n",
-                       progname, name, sizeof(xfs_zone_t), strerror(errno));
+                       progname, name, (int)sizeof(xfs_zone_t), strerror(errno));
                exit(1);
        }
        ptr->zone_unitsize = size;
@@ -371,7 +371,7 @@ libxfs_malloc(size_t size)
 
        if ((ptr = malloc(size)) == NULL) {
                fprintf(stderr, "%s: malloc failed (%d bytes): %s\n",
-                       progname, size, strerror(errno));
+                       progname, (int)size, strerror(errno));
                exit(1);
        }
 #ifdef MEM_DEBUG
@@ -402,7 +402,7 @@ libxfs_realloc(void *ptr, size_t size)
 #endif
        if ((ptr = realloc(ptr, size)) == NULL) {
                fprintf(stderr, "%s: realloc failed (%d bytes): %s\n",
-                       progname, size, strerror(errno));
+                       progname, (int)size, strerror(errno));
                exit(1);
        }
 #ifdef MEM_DEBUG

diff --git a/libxfs/trans.c b/libxfs/trans.c
index 980d69a09c738699e7600cbe1bb9cdf15fa21492..63c894ea2f514cba7864c53aa29d0e64d4be1a06 100644 (file)
--- a/libxfs/trans.c
+++ b/libxfs/trans.c
@@ -43,7 +43,7 @@ libxfs_trans_alloc(xfs_mount_t *mp, int type)
 
        if ((ptr = calloc(sizeof(xfs_trans_t), 1)) == NULL) {
                fprintf(stderr, "%s: xact calloc failed (%d bytes): %s\n",
-                       progname, sizeof(xfs_trans_t), strerror(errno));
+                       progname, (int)sizeof(xfs_trans_t), strerror(errno));
                exit(1);
        }
        ptr->t_mountp = mp;

diff --git a/libxfs/util.c b/libxfs/util.c
index 44222c30e4724495b073255bcc5f8fa9f84c6fc0..71cfbad2b903f20b61c69cdeaaad2517a3845238 100644 (file)
--- a/libxfs/util.c
+++ b/libxfs/util.c
@@ -236,30 +236,31 @@ libxfs_iprint(xfs_inode_t *ip)
        xfs_extnum_t    i;
        xfs_extnum_t    nextents;
 
-       printf("Inode %p\n", ip);
-       printf("    i_dev %x\n", (uint)ip->i_dev);
-       printf("    i_ino %Lx\n", ip->i_ino);
+       printf("Inode %lx\n", (unsigned long)ip);
+       printf("    i_dev %llx\n", (unsigned long long)ip->i_dev);
+       printf("    i_ino %llx\n", (unsigned long long)ip->i_ino);
 
        if (ip->i_df.if_flags & XFS_IFEXTENTS)
                printf("EXTENTS ");
        printf("\n");
        printf("    i_df.if_bytes %d\n", ip->i_df.if_bytes);
-       printf("    i_df.if_u1.if_extents/if_data %p\n", ip->i_df.if_u1.if_extents);
+       printf("    i_df.if_u1.if_extents/if_data %lx\n",
+               (unsigned long)ip->i_df.if_u1.if_extents);
        if (ip->i_df.if_flags & XFS_IFEXTENTS) {
                nextents = ip->i_df.if_bytes / (uint)sizeof(*ep);
                for (ep = ip->i_df.if_u1.if_extents, i = 0; i < nextents; i++, ep++) {
                        xfs_bmbt_irec_t rec;
 
                        xfs_bmbt_get_all(ep, &rec);
-                       printf("\t%d: startoff %Lu, startblock 0x%Lx,"
-                       " blockcount %Lu, state %d\n",
-                               i, (xfs_dfiloff_t)rec.br_startoff,
-                               (xfs_dfsbno_t)rec.br_startblock,
-                               (xfs_dfilblks_t)rec.br_blockcount,
+                       printf("\t%d: startoff %llu, startblock 0x%llx,"
+                               " blockcount %llu, state %d\n",
+                               i, (unsigned long long)rec.br_startoff,
+                               (unsigned long long)rec.br_startblock,
+                               (unsigned long long)rec.br_blockcount,
                                (int)rec.br_state);
                }
        }
-       printf("    i_df.if_broot %p\n", ip->i_df.if_broot);
+       printf("    i_df.if_broot %lx\n", (unsigned long)ip->i_df.if_broot);
        printf("    i_df.if_broot_bytes %x\n", ip->i_df.if_broot_bytes);
 
        dip = &(ip->i_d);
@@ -285,11 +286,11 @@ libxfs_iprint(xfs_inode_t *ip)
        printf("   di_uid %d\n", dip->di_uid);
        printf("   di_gid %d\n", dip->di_gid);
        printf("   di_nextents %d\n", dip->di_nextents);
-       printf("   di_size %Ld\n", dip->di_size);
+       printf("   di_size %llu\n", (unsigned long long)dip->di_size);
        printf("   di_gen %x\n", dip->di_gen);
        printf("   di_extsize %d\n", dip->di_extsize);
        printf("   di_flags %x\n", dip->di_flags);
-       printf("   di_nblocks %Ld\n", dip->di_nblocks);
+       printf("   di_nblocks %llu\n", (unsigned long long)dip->di_nblocks);
 }
 
 /*

diff --git a/libxfs/xfs.h b/libxfs/xfs.h
index 7ed0b8e071d603a59a1f0bfe7983e2090661ac43..80d482641757196832abb38766af1d91a0283d58 100644 (file)
--- a/libxfs/xfs.h
+++ b/libxfs/xfs.h
@@ -237,8 +237,6 @@ typedef struct { dev_t dev; } buftarg_t;
 #define m_ddev_targp   m_dev
 #define KERN_WARNING
 #define XFS_ERROR(e)   (e)
-#define xfs_fs_cmn_err(a,b,msg,args...)        ( fprintf(stderr, msg, ## args) )
-#define printk(msg,args...)            ( fprintf(stderr, msg, ## args) )
 #define XFS_TEST_ERROR(expr,a,b,c)     ( expr )
 #define TRACE_FREE(s,a,b,x,f)          ((void) 0)
 #define TRACE_ALLOC(s,a)               ((void) 0)
@@ -259,6 +257,14 @@ typedef struct { dev_t dev; } buftarg_t;
 #undef  XFS_DIR_SHORTFORM_VALIDATE_ONDISK
 #define XFS_DIR_SHORTFORM_VALIDATE_ONDISK(mp,dip) 0
 
+#if (__GNUC__ < 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ <= 95))
+# define xfs_fs_cmn_err(a,b,msg,args...)( fprintf(stderr, msg, ## args) )
+# define printk(msg,args...)           ( fprintf(stderr, msg, ## args) )
+#else
+# define xfs_fs_cmn_err(a,b,...)       ( fprintf(stderr, __VA_ARGS__) )
+# define printk(...)                   ( fprintf(stderr, __VA_ARGS__) )
+#endif
+
 #define do_mod(a, b)   ((a) % (b))
 #define do_div(n,base) ({ \
        int __res; \

diff --git a/logprint/log_misc.c b/logprint/log_misc.c
index bc53bfa40fc6b6b26c9c28b5a07a0ae358a10976..2b6ce6fe07b31fb8462a41b37e158c59a1cf9264 100644 (file)
--- a/logprint/log_misc.c
+++ b/logprint/log_misc.c
@@ -297,7 +297,7 @@ xlog_print_trans_buffer(xfs_caddr_t *ptr, int len, int *i, int num_ops)
     if (len >= struct_size) {
        ASSERT((len - sizeof(struct_size)) % sizeof(int) == 0);
        printf("#regs: %d   start blkno: %lld (0x%llx)  len: %d  bmap size: %d\n",
-              size, blkno, blkno, blen, map_size);
+              size, (long long)blkno, (unsigned long long)blkno, blen, map_size);
        if (blkno == 0)
            super_block = 1;
     } else {
@@ -420,16 +420,22 @@ xlog_print_trans_buffer(xfs_caddr_t *ptr, int len, int *i, int num_ops)
                                INT_GET(dq->d_flags, ARCH_CONVERT),
                                INT_GET(dq->d_id, ARCH_CONVERT));
                        printf("blk limits  hard: %llu  soft: %llu\n",
+                               (unsigned long long)
                                INT_GET(dq->d_blk_hardlimit, ARCH_CONVERT),
+                               (unsigned long long)
                                INT_GET(dq->d_blk_softlimit, ARCH_CONVERT));
                        printf("blk  count: %llu  warns: %d  timer: %d\n",
+                               (unsigned long long)
                                INT_GET(dq->d_bcount, ARCH_CONVERT),
                                INT_GET(dq->d_bwarns, ARCH_CONVERT),
                                INT_GET(dq->d_btimer, ARCH_CONVERT));
                        printf("ino limits  hard: %llu  soft: %llu\n",
+                               (unsigned long long)
                                INT_GET(dq->d_ino_hardlimit, ARCH_CONVERT),
+                               (unsigned long long)
                                INT_GET(dq->d_ino_softlimit, ARCH_CONVERT));
                        printf("ino  count: %llu  warns: %d  timer: %d\n",
+                               (unsigned long long)
                                INT_GET(dq->d_icount, ARCH_CONVERT),
                                INT_GET(dq->d_iwarns, ARCH_CONVERT),
                                INT_GET(dq->d_itimer, ARCH_CONVERT));
@@ -478,10 +484,11 @@ xlog_print_trans_efd(xfs_caddr_t *ptr, uint len)
     *ptr += len;
     if (len >= sizeof(xfs_efd_log_format_t)) {
        printf("EFD:  #regs: %d    num_extents: %d  id: 0x%llx\n",
-              f->efd_size, f->efd_nextents, f->efd_efi_id);
+              f->efd_size, f->efd_nextents, (unsigned long long)f->efd_efi_id);
        ex = f->efd_extents;
        for (i=0; i< f->efd_size; i++) {
-               printf("(s: 0x%llx, l: %d) ", ex->ext_start, ex->ext_len);
+               printf("(s: 0x%llx, l: %d) ",
+                       (unsigned long long)ex->ext_start, ex->ext_len);
                if (i % 4 == 3) printf("\n");
                ex++;
        }
@@ -511,10 +518,11 @@ xlog_print_trans_efi(xfs_caddr_t *ptr, uint len)
     *ptr += len;
     if (len >= sizeof(xfs_efi_log_format_t)) {
        printf("EFI:  #regs: %d    num_extents: %d  id: 0x%llx\n",
-              f->efi_size, f->efi_nextents, f->efi_id);
+              f->efi_size, f->efi_nextents, (unsigned long long)f->efi_id);
        ex = f->efi_extents;
        for (i=0; i< f->efi_size; i++) {
-               printf("(s: 0x%llx, l: %d) ", ex->ext_start, ex->ext_len);
+               printf("(s: 0x%llx, l: %d) ",
+                       (unsigned long long)ex->ext_start, ex->ext_len);
                if (i % 4 == 3) printf("\n");
                ex++;
        }
@@ -540,7 +548,8 @@ xlog_print_trans_inode_core(xfs_dinode_core_t *ip)
     printf("atime 0x%x mtime 0x%x ctime 0x%x\n",
           ip->di_atime.t_sec, ip->di_mtime.t_sec, ip->di_ctime.t_sec);
     printf("size 0x%llx nblocks 0x%llx extsize 0x%x nextents 0x%x\n",
-          ip->di_size, ip->di_nblocks, ip->di_extsize, ip->di_nextents);
+          (unsigned long long)ip->di_size, (unsigned long long)ip->di_nblocks,
+          ip->di_extsize, ip->di_nextents);
     printf("naextents 0x%x forkoff %d dmevmask 0x%x dmstate 0x%hx\n",
           ip->di_anextents, (int)ip->di_forkoff, ip->di_dmevmask,
           ip->di_dmstate);
@@ -569,7 +578,7 @@ xlog_print_dir_sf(xfs_dir_shortform_t *sfp, int size)
        printf("SHORTFORM DIRECTORY size %d count %d\n",
               size, sfp->hdr.count);
        bcopy(&(sfp->hdr.parent), &ino, sizeof(ino));
-       printf(".. ino 0x%llx\n", INT_GET(ino, ARCH_CONVERT));
+       printf(".. ino 0x%llx\n", (unsigned long long)INT_GET(ino, ARCH_CONVERT));
 
        count = (uint)(sfp->hdr.count);
        sfep = &(sfp->list[0]);
@@ -578,7 +587,7 @@ xlog_print_dir_sf(xfs_dir_shortform_t *sfp, int size)
                bcopy((sfep->name), namebuf, sfep->namelen);
                namebuf[sfep->namelen] = '\0';
                printf("%s ino 0x%llx namelen %d\n",
-                      namebuf, ino, sfep->namelen);
+                      namebuf, (unsigned long long)ino, sfep->namelen);
                sfep = XFS_DIR_SF_NEXTENTRY(sfep);
        }
 }
@@ -612,7 +621,7 @@ xlog_print_trans_inode(xfs_caddr_t *ptr, int len, int *i, int num_ops)
        old_f = (xfs_inode_log_format_t_v1 *)f;
        if (len == sizeof(xfs_inode_log_format_t_v1)) {
            printf("5.3 INODE: #regs: %d   ino: 0x%llx  flags: 0x%x   dsize: %d\n",
-                  old_f->ilf_size, old_f->ilf_ino,
+                  old_f->ilf_size, (unsigned long long)old_f->ilf_ino,
                   old_f->ilf_fields, old_f->ilf_dsize);
        } else {
            ASSERT(len >= 4);   /* must have at least 4 bytes if != 0 */
@@ -626,9 +635,10 @@ xlog_print_trans_inode(xfs_caddr_t *ptr, int len, int *i, int num_ops)
                printf("6.1 INODE: ");
            else printf("INODE: ");
            printf("#regs: %d   ino: 0x%llx  flags: 0x%x   dsize: %d\n",
-                  f->ilf_size, f->ilf_ino, f->ilf_fields, f->ilf_dsize);
+                  f->ilf_size, (unsigned long long)f->ilf_ino,
+                  f->ilf_fields, f->ilf_dsize);
            printf("        blkno: %lld  len: %d  boff: %d\n",
-                  f->ilf_blkno, f->ilf_len, f->ilf_boffset);
+                  (long long)f->ilf_blkno, f->ilf_len, f->ilf_boffset);
        } else {
            ASSERT(len >= 4);   /* must have at least 4 bytes if != 0 */
            printf("INODE: #regs: %d   Not printing rest of data\n",
@@ -738,7 +748,7 @@ xlog_print_lseek(xlog_t *log, int fd, xfs_daddr_t blkno, int whence)
                offset = BBTOOFF64(blkno);
        if (lseek64(fd, offset, whence) < 0) {
                fprintf(stderr, "%s: lseek64 to %llu failed: %s\n",
-                       progname, offset, strerror(errno));
+                       progname, (unsigned long long)offset, strerror(errno));
                exit(1);
        }
 }      /* xlog_print_lseek */
@@ -984,7 +994,7 @@ print_xlog_bad_zeroed(xfs_daddr_t blkno)
 {
         print_stars();
        printf("* ERROR: found data after zeroed blocks block=%-21lld  *\n",
-                (__int64_t)blkno);
+                (long long)blkno);
         print_stars();
        if (print_exit)
            xlog_exit("Bad log - data after zeroed blocks");
@@ -995,7 +1005,7 @@ print_xlog_bad_header(xfs_daddr_t blkno, xfs_caddr_t buf)
 {
         print_stars();
        printf("* ERROR: header cycle=%-11d block=%-21lld        *\n",
-               GET_CYCLE(buf, ARCH_CONVERT), (__int64_t)blkno);
+               GET_CYCLE(buf, ARCH_CONVERT), (long long)blkno);
         print_stars();
        if (print_exit)
            xlog_exit("Bad log record header");
@@ -1006,7 +1016,7 @@ print_xlog_bad_data(xfs_daddr_t blkno)
 {
         print_stars();
        printf("* ERROR: data block=%-21lld                             *\n", 
-                (__int64_t)blkno);
+                (long long)blkno);
         print_stars();
        if (print_exit)
            xlog_exit("Bad data in log");
@@ -1052,7 +1062,7 @@ void xfs_log_print(xlog_t       *log,
            break;
         }
        if (print_only_data) {
-               printf("BLKNO: %lld\n", (__int64_t)blkno);
+               printf("BLKNO: %lld\n", (long long)blkno);
                xlog_recover_print_data(hbuf, 512);
                blkno++;
                goto loop;
@@ -1139,7 +1149,7 @@ loop:
                xlog_panic("xlog_find_head: bad read");
            }
            if (print_only_data) {
-               printf("BLKNO: %lld\n", (__int64_t)blkno);
+               printf("BLKNO: %lld\n", (long long)blkno);
                xlog_recover_print_data(hbuf, 512);
                blkno++;
                goto loop2;

diff --git a/logprint/log_print_all.c b/logprint/log_print_all.c
index b0a0e410536a012d891465070e959471d84a6581..0cba5212aed9b20fffd7f0dc152293219ba6a1ab 100644 (file)
--- a/logprint/log_print_all.c
+++ b/logprint/log_print_all.c
@@ -130,8 +130,8 @@ xlog_recover_print_buffer(
            }
        } 
        if (f->blf_type == XFS_LI_BUF) {
-               printf("#regs:%d   start blkno:0x%Lx   len:%d   bmap size:%d\n",
-                      f->blf_size, f->blf_blkno, f->blf_len, f->blf_map_size);
+               printf("#regs:%d   start blkno:0x%llx   len:%d   bmap size:%d\n",
+                      f->blf_size, (long long)f->blf_blkno, f->blf_len, f->blf_map_size);
                blkno = (xfs_daddr_t)f->blf_blkno;
        } else {
                printf("#regs:%d   start blkno:0x%x   len:%d   bmap size:%d\n",
@@ -201,9 +201,9 @@ xlog_recover_print_buffer(
                        ddq = (xfs_disk_dquot_t *)p;
                        printf("        DQUOT Buffer:\n");
                        if (!print_buffer) continue;
-                       printf("                UIDs 0x%x-0x%x\n", 
-                              INT_GET(ddq->d_id, ARCH_CONVERT),
-                              INT_GET(ddq->d_id, ARCH_CONVERT) +
+                       printf("                UIDs 0x%lx-0x%lx\n", 
+                              (unsigned long)INT_GET(ddq->d_id, ARCH_CONVERT),
+                              (unsigned long)INT_GET(ddq->d_id, ARCH_CONVERT) +
                               (BBTOB(f->blf_len) / sizeof(xfs_dqblk_t)) - 1);
                } else {
                        printf("        BUF DATA\n");
@@ -242,8 +242,8 @@ xlog_recover_print_dquot(
        ASSERT(f);
        ASSERT(f->qlf_len == 1);
        d = (xfs_disk_dquot_t *)item->ri_buf[1].i_addr;
-       printf("\tDQUOT: #regs:%d  blkno:%Ld  boffset:%u id: %d\n",
-              f->qlf_size, f->qlf_blkno, f->qlf_boffset, f->qlf_id);
+       printf("\tDQUOT: #regs:%d  blkno:%lld  boffset:%u id: %d\n",
+              f->qlf_size, (long long)f->qlf_blkno, f->qlf_boffset, f->qlf_id);
        if (!print_quota)
                return;
        printf("\t\tmagic 0x%x\tversion 0x%x\tID 0x%x (%d)\t\n",
@@ -282,10 +282,10 @@ xlog_recover_print_inode_core(
               di->di_uid, di->di_gid, di->di_nlink, (uint)di->di_projid);
        printf("                atime:%d  mtime:%d  ctime:%d\n",
               di->di_atime.t_sec, di->di_mtime.t_sec, di->di_ctime.t_sec);
-       printf("                size:0x%Lx  nblks:0x%Lx  exsize:%d  nextents:%d"
-              "  anextents:%d\n",
-              di->di_size, di->di_nblocks, di->di_extsize, di->di_nextents,
-              (int)di->di_anextents);
+       printf("                size:0x%llx  nblks:0x%llx  exsize:%d  "
+            "nextents:%d  anextents:%d\n", (unsigned long long)
+              di->di_size, (unsigned long long)di->di_nblocks,
+              di->di_extsize, di->di_nextents, (int)di->di_anextents);
        printf("                forkoff:%d  dmevmask:0x%x  dmstate:%d  flags:0x%x  "
             "gen:%d\n",
               (int)di->di_forkoff, di->di_dmevmask, (int)di->di_dmstate,
@@ -304,8 +304,9 @@ xlog_recover_print_inode(
 
        f = (xfs_inode_log_format_t *)item->ri_buf[0].i_addr;
        ASSERT(item->ri_buf[0].i_len == sizeof(xfs_inode_log_format_t));
-       printf("        INODE: #regs:%d   ino:0x%Lx  flags:0x%x   dsize:%d\n",
-              f->ilf_size, f->ilf_ino, f->ilf_fields, f->ilf_dsize);
+       printf("        INODE: #regs:%d   ino:0x%llx  flags:0x%x   dsize:%d\n",
+              f->ilf_size, (unsigned long long)f->ilf_ino, f->ilf_fields,
+              f->ilf_dsize);
 
        /* core inode comes 2nd */
        ASSERT(item->ri_buf[1].i_len == sizeof(xfs_dinode_core_t));
@@ -423,12 +424,13 @@ xlog_recover_print_efd(
        ASSERT(item->ri_buf[0].i_len == 
               sizeof(xfs_efd_log_format_t) + sizeof(xfs_extent_t) *
               (f->efd_nextents-1));
-       printf("        EFD:  #regs: %d    num_extents: %d  id: 0x%Lx\n",
-              f->efd_size, f->efd_nextents, f->efd_efi_id);
+       printf("        EFD:  #regs: %d    num_extents: %d  id: 0x%llx\n",
+              f->efd_size, f->efd_nextents, (unsigned long long)f->efd_efi_id);
        ex = f->efd_extents;
        printf("        ");
        for (i=0; i < f->efd_size; i++) {
-               printf("(s: 0x%Lx, l: %d) ", ex->ext_start, ex->ext_len);
+               printf("(s: 0x%llx, l: %d) ",
+                       (unsigned long long) ex->ext_start, ex->ext_len);
                if (i % 4 == 3)
                        printf("\n");
                ex++;
@@ -455,12 +457,13 @@ xlog_recover_print_efi(
               sizeof(xfs_efi_log_format_t) + sizeof(xfs_extent_t) *
               (f->efi_nextents-1));
        
-       printf("        EFI:  #regs:%d    num_extents:%d  id:0x%Lx\n",
-              f->efi_size, f->efi_nextents, f->efi_id);
+       printf("        EFI:  #regs:%d    num_extents:%d  id:0x%llx\n",
+              f->efi_size, f->efi_nextents, (unsigned long long)f->efi_id);
        ex = f->efi_extents;
        printf("        ");
        for (i=0; i< f->efi_nextents; i++) {
-               printf("(s: 0x%Lx, l: %d) ", ex->ext_start, ex->ext_len);
+               printf("(s: 0x%llx, l: %d) ",
+                       (unsigned long long)ex->ext_start, ex->ext_len);
                if (i % 4 == 3) printf("\n");
                ex++;
        }
@@ -566,8 +569,8 @@ xlog_recover_print_item(xlog_recover_item_t *item)
 */
        printf(": cnt:%d total:%d ", item->ri_cnt, item->ri_total);
        for (i=0; i<item->ri_cnt; i++) {
-               printf("a:%p len:%d ",
-                      item->ri_buf[i].i_addr, item->ri_buf[i].i_len);
+               printf("a:%lx len:%d ",
+                      (long)item->ri_buf[i].i_addr, item->ri_buf[i].i_len);
        }
        printf("\n");
        xlog_recover_print_logitem(item);

diff --git a/logprint/log_print_trans.c b/logprint/log_print_trans.c
index 9b830468ab09e792c1a923f97b801581ed4cba22..30fa2ed2d52ab2f83ca6cd799c4690c346b29385 100644 (file)
--- a/logprint/log_print_trans.c
+++ b/logprint/log_print_trans.c
@@ -36,10 +36,10 @@ void
 xlog_recover_print_trans_head(
         xlog_recover_t *tr)
 {
-        printf("TRANS: tid:0x%x  type:%s  #items:%d  trans:0x%x  q:%p\n",
+        printf("TRANS: tid:0x%x  type:%s  #items:%d  trans:0x%x  q:%lx\n",
                tr->r_log_tid, trans_type[tr->r_theader.th_type],
                tr->r_theader.th_num_items,
-               tr->r_theader.th_tid, tr->r_itemq);
+               tr->r_theader.th_tid, (long)tr->r_itemq);
 }       /* xlog_recover_print_trans_head */
 
 int
@@ -63,13 +63,13 @@ xfs_log_print_trans(xlog_t      *log,
             exit(1);
         
        printf("    log tail: %lld head: %lld state: %s\n",
-                (__int64_t)tail_blk, 
-                (__int64_t)head_blk,
+                (long long)tail_blk, 
+                (long long)head_blk,
                 (tail_blk == head_blk)?"<CLEAN>":"<DIRTY>");
         
         if (print_block_start != -1) {
            printf("    override tail: %lld\n",
-                   (__int64_t)print_block_start);
+                   (long long)print_block_start);
            tail_blk = print_block_start;
         }
         printf("\n");

diff --git a/logprint/logprint.c b/logprint/logprint.c
index 16a652d56f92cdafab118df804620dfa3f16712e..cea2f0ce2a34a9df6c79fb193238d5c858a28d28 100644 (file)
--- a/logprint/logprint.c
+++ b/logprint/logprint.c
@@ -216,22 +216,22 @@ main(int argc, char **argv)
 
        logstat(&x);
 
-        logfd=(x.logfd<0)?(x.dfd):(x.logfd);
-        
-        printf("    data device: 0x%Lx\n", x.ddev);
-        
-        if (x.logname) {
-                printf("    log file: \"%s\" ", x.logname);
-        } else {
-                printf("    log device: 0x%Lx ", x.logdev);
-        }
-
-        printf("daddr: %Ld length: %Ld\n\n",
-                (__int64_t)x.logBBstart, (__int64_t)x.logBBsize);
-        
-        ASSERT(x.logBBstart <= INT_MAX);
+       logfd=(x.logfd<0)?(x.dfd):(x.logfd);
+ 
+       printf("    data device: 0x%llx\n", (unsigned long long)x.ddev);
+
+       if (x.logname) {
+               printf("    log file: \"%s\" ", x.logname);
+       } else {
+               printf("    log device: 0x%llx ", (unsigned long long)x.logdev);
+       }
+
+       printf("daddr: %lld length: %lld\n\n",
+               (long long)x.logBBstart, (long long)x.logBBsize);
+
+       ASSERT(x.logBBstart <= INT_MAX);
 
-        /* init log structure */
+       /* init log structure */
        log.l_dev          = x.logdev;
        log.l_logsize     = BBTOB(x.logBBsize);
        log.l_logBBstart  = x.logBBstart;

diff --git a/logprint/logprint.h b/logprint/logprint.h
index 307747f7dcc1383d34006726883eb583a2a06625..565de940b014933db9cec6f0c513edaec0273217 100644 (file)
--- a/logprint/logprint.h
+++ b/logprint/logprint.h
@@ -77,14 +77,25 @@ typedef struct log {
 #define EFSCORRUPTED            990
 #define XFS_ERROR(e)           (e)
 
-#define xlog_warn(fmt,args...) \
+#if (__GNUC__ < 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ <= 95))
+# define xlog_warn(fmt,args...) \
        ( fprintf(stderr,fmt,## args), fputc('\n', stderr) )
-#define cmn_err(sev,fmt,args...) \
-        xlog_warn(fmt,## args)
-#define xlog_exit(fmt,args...) \
+# define cmn_err(sev,fmt,args...) \
+       xlog_warn(fmt,## args)
+# define xlog_exit(fmt,args...) \
        ( xlog_warn(fmt,## args), exit(1) )
-#define xlog_panic(fmt,args...) \
+# define xlog_panic(fmt,args...) \
        xlog_exit(fmt,## args)
+#else
+# define xlog_warn(...) \
+       ( fprintf(stderr,__VA_ARGS__), fputc('\n', stderr) )
+# define cmn_err(sev,...) \
+       xlog_warn(__VA_ARGS__)
+# define xlog_exit(...) \
+       ( xlog_warn(__VA_ARGS__), exit(1) )
+# define xlog_panic(...) \
+       xlog_exit(__VA_ARGS__)
+#endif
 
 #define xlog_get_bp(nbblks, mp)        libxfs_getbuf(x.logdev, 0, (nbblks))
 #define xlog_put_bp(bp)                libxfs_putbuf(bp)

diff --git a/mkfile/xfs_mkfile.c b/mkfile/xfs_mkfile.c
index c7745a93ce44ac00767e41854a9b8723092865d7..e5b026cd98ee688403177c91f0bfaaaabd76668a 100644 (file)
--- a/mkfile/xfs_mkfile.c
+++ b/mkfile/xfs_mkfile.c
@@ -136,7 +136,7 @@ main(int argc, char **argv)
        while (optind < argc) {
                if (verbose)
                        fprintf(stdout, "%s %lld bytes %s\n",
-                                               argv[optind], size,
+                                               argv[optind], (long long)size,
                                                prealloc
                                                  ? "(pre-allocated)"
                                                  : "");
@@ -174,8 +174,8 @@ main(int argc, char **argv)
                         * This check doesn't actually work for 6.2
                         * efs and nfs2, although it should.
                         */
-                       fprintf(stderr,
-                               "lseek64 error, result = %lld\n", result);
+                       fprintf(stderr, "lseek64 error, result = %lld\n",
+                               (long long)result);
                        if (errno)
                                perror(argv[optind]);
                        errs++;

diff --git a/mkfs/maxtrres.c b/mkfs/maxtrres.c
index 638d945d4689b0639f5ecdcbbf39056a69d2e2fa..3088bcc9b53d59fe4dd5c61444b8b1a90b818ccb 100644 (file)
--- a/mkfs/maxtrres.c
+++ b/mkfs/maxtrres.c
@@ -182,7 +182,7 @@ main(int argc, char **argv)
                                        printf(
                                "#define\tMAXTRRES_B%d_I%d_D%d_V%d\t%lld\t"
                                "/* LOG_FACTOR %d */\n",
-                                               bl, il, dl, dv,
+                                               bl, il, dl, dv, (long long)
                                                XFS_B_TO_FSB(&m, i), mul);
                                        libxfs_umount(&m);
                                }

diff --git a/mkfs/xfs_mkfs.c b/mkfs/xfs_mkfs.c
index 5c4833251811d84ee66f5a5443a3b3d92a9b9561..b1934e1386d75d872543112d4e57fb3f0e769c25 100644 (file)
--- a/mkfs/xfs_mkfs.c
+++ b/mkfs/xfs_mkfs.c
@@ -937,14 +937,15 @@ main(int argc, char **argv)
                if (dbytes % XFS_MIN_BLOCKSIZE) {
                        fprintf(stderr,
                        "illegal data length %lld, not a multiple of %d\n",
-                               dbytes, XFS_MIN_BLOCKSIZE);
+                               (long long)dbytes, XFS_MIN_BLOCKSIZE);
                        usage();
                }
                dblocks = (xfs_drfsbno_t)(dbytes >> blocklog);
                if (dbytes % blocksize)
                        fprintf(stderr,
        "warning: data length %lld not a multiple of %d, truncated to %lld\n",
-                               dbytes, blocksize, dblocks << blocklog);
+                               (long long)dbytes, blocksize,
+                               (long long)(dblocks << blocklog));
        }
        if (ipflag) {
                inodelog = blocklog - libxfs_highbit32(inopblock);
@@ -967,14 +968,15 @@ main(int argc, char **argv)
                if (logbytes % XFS_MIN_BLOCKSIZE) {
                        fprintf(stderr,
                        "illegal log length %lld, not a multiple of %d\n",
-                               logbytes, XFS_MIN_BLOCKSIZE);
+                               (long long)logbytes, XFS_MIN_BLOCKSIZE);
                        usage();
                }
                logblocks = (xfs_drfsbno_t)(logbytes >> blocklog);
                if (logbytes % blocksize)
                        fprintf(stderr,
        "warning: log length %lld not a multiple of %d, truncated to %lld\n",
-                               logbytes, blocksize, logblocks << blocklog);
+                               (long long)logbytes, blocksize,
+                               (long long)(logblocks << blocklog));
        }
 #ifdef HAVE_VOLUME_MANAGER
        if (xi.risfile && (!rtsize || !xi.rtname)) {
@@ -990,14 +992,15 @@ main(int argc, char **argv)
                if (rtbytes % XFS_MIN_BLOCKSIZE) {
                        fprintf(stderr,
                        "illegal rt length %lld, not a multiple of %d\n",
-                               rtbytes, XFS_MIN_BLOCKSIZE);
+                               (long long)rtbytes, XFS_MIN_BLOCKSIZE);
                        usage();
                }
                rtblocks = (xfs_drfsbno_t)(rtbytes >> blocklog);
                if (rtbytes % blocksize)
                        fprintf(stderr,
        "warning: rt length %lld not a multiple of %d, truncated to %lld\n",
-                               rtbytes, blocksize, rtblocks << blocklog);
+                               (long long)rtbytes, blocksize,
+                               (long long)(rtblocks << blocklog));
        }
        /*
         * If specified, check rt extent size against its constraints.
@@ -1009,7 +1012,7 @@ main(int argc, char **argv)
                if (rtextbytes % blocksize) {
                        fprintf(stderr,
                        "illegal rt extent size %lld, not a multiple of %d\n",
-                               rtextbytes, blocksize);
+                               (long long)rtextbytes, blocksize);
                        usage();
                }
                if (rtextbytes > XFS_MAX_RTEXTSIZE) {
@@ -1214,7 +1217,7 @@ main(int argc, char **argv)
        if (dsize && xi.dsize > 0 && dblocks > DTOBT(xi.dsize)) {
                fprintf(stderr,
 "size %s specified for data subvolume is too large, maximum is %lld blocks\n",
-                       dsize, DTOBT(xi.dsize));
+                       dsize, (long long)DTOBT(xi.dsize));
                usage();
        } else if (!dsize && xi.dsize > 0)
                dblocks = DTOBT(xi.dsize);
@@ -1225,7 +1228,7 @@ main(int argc, char **argv)
        if (dblocks < XFS_MIN_DATA_BLOCKS) {
                fprintf(stderr,
                "size %lld of data subvolume is too small, minimum %d blocks\n",
-                       dblocks, XFS_MIN_DATA_BLOCKS);
+                       (long long)dblocks, XFS_MIN_DATA_BLOCKS);
                usage();
        }
        if (xi.logdev && loginternal) {
@@ -1243,7 +1246,7 @@ main(int argc, char **argv)
        if (logsize && xi.logBBsize > 0 && logblocks > DTOBT(xi.logBBsize)) {
                fprintf(stderr,
 "size %s specified for log subvolume is too large, maximum is %lld blocks\n",
-                       logsize, DTOBT(xi.logBBsize));
+                       logsize, (long long)DTOBT(xi.logBBsize));
                usage();
        } else if (!logsize && xi.logBBsize > 0)
                logblocks = DTOBT(xi.logBBsize);
@@ -1253,7 +1256,7 @@ main(int argc, char **argv)
                usage();
        } else if (loginternal && logsize && logblocks >= dblocks) {
                fprintf(stderr, "size %lld too large for internal log\n",
-                       logblocks);
+                       (long long)logblocks);
                usage();
        } else if (!loginternal && !xi.logdev)
                logblocks = 0;
@@ -1265,25 +1268,25 @@ main(int argc, char **argv)
        if (logblocks < min_logblocks) {
                fprintf(stderr,
                "log size %lld blocks too small, minimum size is %d blocks\n",
-                       logblocks, min_logblocks);
+                       (long long)logblocks, min_logblocks);
                usage();
        }
        if (logblocks > XFS_MAX_LOG_BLOCKS) {
                fprintf(stderr,
                "log size %lld blocks too large, maximum size is %d blocks\n",
-                       logblocks, XFS_MAX_LOG_BLOCKS);
+                       (long long)logblocks, XFS_MAX_LOG_BLOCKS);
                usage();
        }
        if ((logblocks << blocklog) > XFS_MAX_LOG_BYTES) {
                fprintf(stderr,
                "log size %lld bytes too large, maximum size is %d bytes\n",
-                       logblocks << blocklog, XFS_MAX_LOG_BYTES);
+                       (long long)(logblocks << blocklog), XFS_MAX_LOG_BYTES);
                usage();
        }
        if (rtsize && xi.rtsize > 0 && rtblocks > DTOBT(xi.rtsize)) {
                fprintf(stderr,
 "size %s specified for rt subvolume is too large, maximum is %lld blocks\n",
-                       rtsize, DTOBT(xi.rtsize));
+                       rtsize, (long long)DTOBT(xi.rtsize));
                usage();
        } else if (!rtsize && xi.rtsize > 0)
                rtblocks = DTOBT(xi.rtsize);
@@ -1310,8 +1313,9 @@ main(int argc, char **argv)
                        fprintf(stderr,
                                "too many allocation groups for size\n");
                        fprintf(stderr, "need at most %lld allocation groups\n",
-                               dblocks / XFS_AG_MIN_BLOCKS(blocklog) +
-                               (dblocks % XFS_AG_MIN_BLOCKS(blocklog) != 0));
+                               (long long)
+                               (dblocks / XFS_AG_MIN_BLOCKS(blocklog) +
+                               (dblocks % XFS_AG_MIN_BLOCKS(blocklog) != 0)));
                        usage();
                }
                agsize = XFS_AG_MIN_BLOCKS(blocklog);
@@ -1331,8 +1335,9 @@ main(int argc, char **argv)
                        fprintf(stderr, "too few allocation groups for size\n");
                        fprintf(stderr,
                                "need at least %lld allocation groups\n",
-                               dblocks / XFS_AG_MAX_BLOCKS(blocklog) + 
-                               (dblocks % XFS_AG_MAX_BLOCKS(blocklog) != 0));
+                               (long long)
+                               (dblocks / XFS_AG_MAX_BLOCKS(blocklog) + 
+                               (dblocks % XFS_AG_MAX_BLOCKS(blocklog) != 0)));
                        usage();
                }
                agsize = XFS_AG_MAX_BLOCKS(blocklog);
@@ -1421,7 +1426,7 @@ main(int argc, char **argv)
                                else { 
                                        fprintf(stderr,
 "Allocation group size %lld is not a multiple of the stripe unit %d\n",
-                                               agsize, dsunit);
+                                               (long long)agsize, dsunit);
                                        exit(1);
                                }
                        }
@@ -1450,14 +1455,14 @@ main(int argc, char **argv)
                if (logblocks > agsize - XFS_PREALLOC_BLOCKS(mp)) {
                        fprintf(stderr,
        "internal log size %lld too large, must fit in allocation group\n",
-                               logblocks);
+                               (long long)logblocks);
                        usage();
                }
                if (laflag) {
                        if (logagno >= agcount) {
                                fprintf(stderr,
                        "log ag number %d too large, must be less than %lld\n",
-                                       logagno, agcount);
+                                       logagno, (long long)agcount);
                                usage();
                        }
                } else
@@ -1481,7 +1486,7 @@ main(int argc, char **argv)
                           else {
                                fprintf(stderr,
        "internal log size %lld is not a multiple of the stripe unit %d\n", 
-                                       logblocks, dsunit);
+                                       (long long)logblocks, dsunit);
                                usage();
                           }
 
@@ -1489,7 +1494,7 @@ main(int argc, char **argv)
                                fprintf(stderr,
        "Due to stripe alignment, the internal log size %lld is too large.\n"
        "Must fit in allocation group\n",
-                                       logblocks);
+                                       (long long)logblocks);
                                usage();
                        }
                        lalign = 1;
@@ -1554,12 +1559,13 @@ main(int argc, char **argv)
                   "naming   =version %-14d bsize=%-6d\n"
                   "log      =%-22s bsize=%-6d blocks=%lld\n"
                   "realtime =%-22s extsz=%-6d blocks=%lld, rtextents=%lld\n",
-                       dfile, isize, agcount, agsize,
-                       "", blocksize, dblocks, sbp->sb_imax_pct,
+                       dfile, isize, (long long)agcount, (long long)agsize,
+                       "", blocksize, (long long)dblocks, sbp->sb_imax_pct,
                        "", dsunit, dswidth, extent_flagging,
                        dirversion, dirversion == 1 ? blocksize : dirblocksize,
-                       logfile, 1 << blocklog, logblocks,
-                       rtfile, rtextblocks << blocklog, rtblocks, rtextents);
+                       logfile, 1 << blocklog, (long long)logblocks,
+                       rtfile, rtextblocks << blocklog,
+                       (long long)rtblocks, (long long)rtextents);
        /*
         * If the data area is a file, then grow it out to its final size
         * so that the reads for the end of the device in the mount code
@@ -1593,7 +1599,7 @@ main(int argc, char **argv)
            XFS_MIN_LOG_FACTOR * max_trans_res(mp)) {
                fprintf(stderr, "%s: log size (%lld) is too small for "
                                "transaction reservations\n",
-                       progname, logblocks);
+                       progname, (long long)logblocks);
                exit(1);
        }
 

diff --git a/repair/avl.c b/repair/avl.c
index 4d1a4ac8227f034c562cd2a7edc034b00ae022de..d7025c292ed3fe8d2c2a5be1ef82e5b6bed4ab9e 100644 (file)
--- a/repair/avl.c
+++ b/repair/avl.c
@@ -1058,8 +1058,8 @@ avl_insert(
                if (start != end)  { /* non-zero length range */
 #ifdef AVL_USER_MODE
                        printf(
-                       "avl_insert: Warning! duplicate range [0x%x,0x%x)\n",
-                               start, end);
+                       "avl_insert: Warning! duplicate range [0x%llx,0x%lx)\n",
+                               (unsigned long long)start, (unsigned long)end);
 #else
                        /*
                         * lockmetering tree can't afford printfs here.

diff --git a/repair/avl64.c b/repair/avl64.c
index 091bc81807a80b62b9a5809e0a0a37408a08892b..dbaf211dd54bb83c2b64006788df5a25d7b19c98 100644 (file)
--- a/repair/avl64.c
+++ b/repair/avl64.c
@@ -1056,7 +1056,7 @@ avl64_insert(
                if (start != end)  { /* non-zero length range */
 #ifdef AVL_USER_MODE
                printf("avl_insert: Warning! duplicate range [0x%llx,0x%llx)\n",
-                               start, end);
+                       (unsigned long long)start, (unsigned long long)end);
 #else
                        cmn_err(CE_CONT,
                "!avl_insert: Warning! duplicate range [0x%llx,0x%llx)\n",

diff --git a/repair/dinode.c b/repair/dinode.c
index a1f372b8a633a921c9832d078377ceb97b0ee055..724407d37f19368477dd044f88c9d5732a882641 100644 (file)
--- a/repair/dinode.c
+++ b/repair/dinode.c
@@ -98,10 +98,11 @@ clear_dinode_attr(xfs_mount_t *mp, xfs_dinode_t *dino, xfs_ino_t ino_num)
        ASSERT(dinoc->di_forkoff != 0);
 
        if (!no_modify)
-               fprintf(stderr, "clearing inode %llu attributes \n", ino_num);
+               fprintf(stderr, "clearing inode %llu attributes \n",
+                       (unsigned long long)ino_num);
        else
                fprintf(stderr, "would have cleared inode %llu attributes\n",
-                       ino_num);
+                       (unsigned long long)ino_num);
 
        if (INT_GET(dinoc->di_anextents, ARCH_CONVERT) != 0)  {
                if (no_modify)

diff --git a/repair/incore_ino.c b/repair/incore_ino.c
index bb14a370f852b967518a23b63e775cbbd613069a..4acce2a46bb05d6b763700734bbf870be80af19f 100644 (file)
--- a/repair/incore_ino.c
+++ b/repair/incore_ino.c
@@ -424,11 +424,11 @@ print_inode_list_int(xfs_agnumber_t agno, int uncertain)
 
        while(ino_rec != NULL)  {
                fprintf(stderr,
-       "\tptr = %p, start = 0x%x, free = 0x%llx, confirmed = 0x%llx\n",
-                       ino_rec,
+       "\tptr = %lx, start = 0x%x, free = 0x%llx, confirmed = 0x%llx\n",
+                       (unsigned long)ino_rec,
                        ino_rec->ino_startnum,
-                       ino_rec->ir_free,
-                       ino_rec->ino_confirmed);
+                       (unsigned long long)ino_rec->ir_free,
+                       (unsigned long long)ino_rec->ino_confirmed);
                if (ino_rec->ino_startnum == 0)
                        ino_rec = ino_rec;
                ino_rec = next_ino_rec(ino_rec);

diff --git a/repair/phase6.c b/repair/phase6.c
index db2dd98f0f102ad5afc83c8db5c6045115c8cef4..65d88e7111f7cc835790f6b13e0b414b1084a820 100644 (file)
--- a/repair/phase6.c
+++ b/repair/phase6.c
@@ -823,7 +823,7 @@ mv_orphanage(xfs_mount_t    *mp,
        char            fname[MAXPATHLEN + 1];
        int             nres;
 
-       sprintf(fname, "%llu", ino);
+       sprintf(fname, "%llu", (unsigned long long)ino);
 
        if (err = libxfs_iget(mp, NULL, dir_ino, 0, &dir_ino_p, 0))
                do_error("%d - couldn't iget orphanage inode\n", err);