[PATCH] fs: Use ARRAY_SIZE macro

Use ARRAY_SIZE macro instead of sizeof(x)/sizeof(x[0]) and remove a
duplicate of ARRAY_SIZE.  Some trailing whitespaces are also deleted.

Signed-off-by: Tobias Klauser <tklauser@nuerscht.ch>
Cc: David Howells <dhowells@redhat.com>
Cc: Dave Kleikamp <shaggy@austin.ibm.com>
Acked-by: Trond Myklebust <trond.myklebust@fys.uio.no>
Cc: Neil Brown <neilb@cse.unsw.edu.au>
Cc: Chris Mason <mason@suse.com>
Cc: Jeff Mahoney <jeffm@suse.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Nathan Scott <nathans@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

diff --git a/fs/afs/cmservice.c b/fs/afs/cmservice.c
index 9eef6bf156ab5a4c804e3a0712a1b436d22988e1..3d097fddcb7a7d1943420bc143dc62eb34f9d377 100644 (file)
--- a/fs/afs/cmservice.c
+++ b/fs/afs/cmservice.c
@@ -94,7 +94,7 @@ static struct rxrpc_service AFSCM_service = {
        .error_func     = afscm_error,
        .aemap_func     = afscm_aemap,
        .ops_begin      = &AFSCM_ops[0],
-       .ops_end        = &AFSCM_ops[sizeof(AFSCM_ops) / sizeof(AFSCM_ops[0])],
+       .ops_end        = &AFSCM_ops[ARRAY_SIZE(AFSCM_ops)],
 };
 
 static DECLARE_COMPLETION(kafscmd_alive);

diff --git a/fs/compat_ioctl.c b/fs/compat_ioctl.c
index 7c031f00fd798ede5c3edf885c7d8a6fef51250b..d2c38875ab296e45741c5dcf966da56ec51d8f96 100644 (file)
--- a/fs/compat_ioctl.c
+++ b/fs/compat_ioctl.c
@@ -1522,8 +1522,7 @@ static struct {
        { ATM_QUERYLOOP32,   ATM_QUERYLOOP }
 };
 
-#define NR_ATM_IOCTL (sizeof(atm_ioctl_map)/sizeof(atm_ioctl_map[0]))
-
+#define NR_ATM_IOCTL ARRAY_SIZE(atm_ioctl_map)
 
 static int do_atm_iobuf(unsigned int fd, unsigned int cmd, unsigned long arg)
 {
@@ -1824,7 +1823,7 @@ static struct {
        { FDWERRORGET32, FDWERRORGET }
 };
 
-#define NR_FD_IOCTL_TRANS (sizeof(fd_ioctl_trans_table)/sizeof(fd_ioctl_trans_table[0]))
+#define NR_FD_IOCTL_TRANS ARRAY_SIZE(fd_ioctl_trans_table)
 
 static int fd_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
 {

diff --git a/fs/jfs/jfs_debug.c b/fs/jfs/jfs_debug.c
index 4caea6b43b92a9171b508a6e243ef7cf497253e7..81f0e514c4900c8fa679b429a3709ceb6decc318 100644 (file)
--- a/fs/jfs/jfs_debug.c
+++ b/fs/jfs/jfs_debug.c
@@ -111,7 +111,7 @@ static struct {
        { "loglevel",   loglevel_read, loglevel_write }
 #endif
 };
-#define NPROCENT       (sizeof(Entries)/sizeof(Entries[0]))
+#define NPROCENT       ARRAY_SIZE(Entries)
 
 void jfs_proc_init(void)
 {

diff --git a/fs/lockd/mon.c b/fs/lockd/mon.c
index 0edc03e67966fdc6b355341f92447645f262e685..a89cb8aa2c88f459d164a879ccefb67cb95d13a0 100644 (file)
--- a/fs/lockd/mon.c
+++ b/fs/lockd/mon.c
@@ -224,8 +224,8 @@ static struct rpc_procinfo  nsm_procedures[] = {
 };
 
 static struct rpc_version      nsm_version1 = {
-               .number         = 1, 
-               .nrprocs        = sizeof(nsm_procedures)/sizeof(nsm_procedures[0]),
+               .number         = 1,
+               .nrprocs        = ARRAY_SIZE(nsm_procedures),
                .procs          = nsm_procedures
 };
 
@@ -238,7 +238,7 @@ static struct rpc_stat              nsm_stats;
 static struct rpc_program      nsm_program = {
                .name           = "statd",
                .number         = SM_PROGRAM,
-               .nrvers         = sizeof(nsm_version)/sizeof(nsm_version[0]),
+               .nrvers         = ARRAY_SIZE(nsm_version),
                .version        = nsm_version,
                .stats          = &nsm_stats
 };

diff --git a/fs/lockd/svc.c b/fs/lockd/svc.c
index 71a30b416d1a279561ed04d011cac3e7ee4fb360..5e85bde6c123e89fb271706ffeaf2e99080dca32 100644 (file)
--- a/fs/lockd/svc.c
+++ b/fs/lockd/svc.c
@@ -509,7 +509,7 @@ static struct svc_version * nlmsvc_version[] = {
 
 static struct svc_stat         nlmsvc_stats;
 
-#define NLM_NRVERS     (sizeof(nlmsvc_version)/sizeof(nlmsvc_version[0]))
+#define NLM_NRVERS     ARRAY_SIZE(nlmsvc_version)
 static struct svc_program      nlmsvc_program = {
        .pg_prog                = NLM_PROGRAM,          /* program number */
        .pg_nvers               = NLM_NRVERS,           /* number of entries in nlmsvc_version */

diff --git a/fs/lockd/xdr.c b/fs/lockd/xdr.c
index 200fbda2c6d152368f08c742ed2db4dacf12b65a..1d700a4dd0b5ab0e74510dbae5d973813119fbff 100644 (file)
--- a/fs/lockd/xdr.c
+++ b/fs/lockd/xdr.c
@@ -599,7 +599,7 @@ static struct rpc_stat              nlm_stats;
 struct rpc_program             nlm_program = {
                .name           = "lockd",
                .number         = NLM_PROGRAM,
-               .nrvers         = sizeof(nlm_versions) / sizeof(nlm_versions[0]),
+               .nrvers         = ARRAY_SIZE(nlm_versions),
                .version        = nlm_versions,
                .stats          = &nlm_stats,
 };

diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 37e55c328ebcda201720610254c9e4e7a6fdd7b7..419d1d254f9fe6e15cd3dd3ea1182c83c31c306c 100644 (file)
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -103,7 +103,7 @@ static struct rpc_version * nfs_version[] = {
 static struct rpc_program      nfs_program = {
        .name                   = "nfs",
        .number                 = NFS_PROGRAM,
-       .nrvers                 = sizeof(nfs_version) / sizeof(nfs_version[0]),
+       .nrvers                 = ARRAY_SIZE(nfs_version),
        .version                = nfs_version,
        .stats                  = &nfs_rpcstat,
        .pipe_dir_name          = "/nfs",
@@ -118,7 +118,7 @@ static struct rpc_version * nfsacl_version[] = {
 struct rpc_program             nfsacl_program = {
        .name =                 "nfsacl",
        .number =               NFS_ACL_PROGRAM,
-       .nrvers =               sizeof(nfsacl_version) / sizeof(nfsacl_version[0]),
+       .nrvers =               ARRAY_SIZE(nfsacl_version),
        .version =              nfsacl_version,
        .stats =                &nfsacl_rpcstat,
 };

diff --git a/fs/nfs/mount_clnt.c b/fs/nfs/mount_clnt.c
index db99b8f678f89c9bbb697041261ac94566aa1ba6..0b9a78353d6ef80c6dcf1de67dfab382fd239344 100644 (file)
--- a/fs/nfs/mount_clnt.c
+++ b/fs/nfs/mount_clnt.c
@@ -174,7 +174,7 @@ static struct rpc_stat              mnt_stats;
 static struct rpc_program      mnt_program = {
        .name           = "mount",
        .number         = NFS_MNT_PROGRAM,
-       .nrvers         = sizeof(mnt_version)/sizeof(mnt_version[0]),
+       .nrvers         = ARRAY_SIZE(mnt_version),
        .version        = mnt_version,
        .stats          = &mnt_stats,
 };

diff --git a/fs/nfs/nfs2xdr.c b/fs/nfs/nfs2xdr.c
index 7fc0560c89c99187e8a7a8b386f69712aa19b347..6548a65de9444e56dc8fe67382c599b9b76b4216 100644 (file)
--- a/fs/nfs/nfs2xdr.c
+++ b/fs/nfs/nfs2xdr.c
@@ -704,6 +704,6 @@ struct rpc_procinfo nfs_procedures[] = {
 
 struct rpc_version             nfs_version2 = {
        .number                 = 2,
-       .nrprocs                = sizeof(nfs_procedures)/sizeof(nfs_procedures[0]),
+       .nrprocs                = ARRAY_SIZE(nfs_procedures),
        .procs                  = nfs_procedures
 };

diff --git a/fs/nfs/nfs3xdr.c b/fs/nfs/nfs3xdr.c
index b6c0b5012bce36c551d333e2348f777a5162074e..5224a191efb657486e7bb10a21fcc29b3bb2b95d 100644 (file)
--- a/fs/nfs/nfs3xdr.c
+++ b/fs/nfs/nfs3xdr.c
@@ -1138,7 +1138,7 @@ struct rpc_procinfo       nfs3_procedures[] = {
 
 struct rpc_version             nfs_version3 = {
        .number                 = 3,
-       .nrprocs                = sizeof(nfs3_procedures)/sizeof(nfs3_procedures[0]),
+       .nrprocs                = ARRAY_SIZE(nfs3_procedures),
        .procs                  = nfs3_procedures
 };
 

diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
index 4bbf5ef57785959dcb3ea555bcd68e3f45537c7e..0a1bd36a4837ca87b494b45a1233c42fc7b970c5 100644 (file)
--- a/fs/nfs/nfs4xdr.c
+++ b/fs/nfs/nfs4xdr.c
@@ -4384,7 +4384,7 @@ struct rpc_procinfo       nfs4_procedures[] = {
 
 struct rpc_version             nfs_version4 = {
        .number                 = 4,
-       .nrprocs                = sizeof(nfs4_procedures)/sizeof(nfs4_procedures[0]),
+       .nrprocs                = ARRAY_SIZE(nfs4_procedures),
        .procs                  = nfs4_procedures
 };
 

diff --git a/fs/nfsctl.c b/fs/nfsctl.c
index 1c72c7f85ddc183ae24103baa80dafeee7a47a04..a5a18d4aca40a89661ac5dc219c5041e83ac75bb 100644 (file)
--- a/fs/nfsctl.c
+++ b/fs/nfsctl.c
@@ -101,7 +101,7 @@ asmlinkage sys_nfsservctl(int cmd, struct nfsctl_arg __user *arg, void __user *r
        if (version != NFSCTL_VERSION)
                return -EINVAL;
 
-       if (cmd < 0 || cmd >= sizeof(map)/sizeof(map[0]) || !map[cmd].name)
+       if (cmd < 0 || cmd >= ARRAY_SIZE(map) || !map[cmd].name)
                return -EINVAL;
 
        file = do_open(map[cmd].name, map[cmd].rsize ? O_RDWR : O_WRONLY);      

diff --git a/fs/nfsd/nfs4acl.c b/fs/nfsd/nfs4acl.c
index 4a2105552ac4c5ca46847f3e41d18d9c4acd985e..7391f4aabedb0bd07e78ef26e64689ef2503f97f 100644 (file)
--- a/fs/nfsd/nfs4acl.c
+++ b/fs/nfsd/nfs4acl.c
@@ -907,7 +907,7 @@ nfs4_acl_get_whotype(char *p, u32 len)
 {
        int i;
 
-       for (i=0; i < sizeof(s2t_map) / sizeof(*s2t_map); i++) {
+       for (i = 0; i < ARRAY_SIZE(s2t_map); i++) {
                if (s2t_map[i].stringlen == len &&
                                0 == memcmp(s2t_map[i].string, p, len))
                        return s2t_map[i].type;
@@ -920,7 +920,7 @@ nfs4_acl_write_who(int who, char *p)
 {
        int i;
 
-       for (i=0; i < sizeof(s2t_map) / sizeof(*s2t_map); i++) {
+       for (i = 0; i < ARRAY_SIZE(s2t_map); i++) {
                if (s2t_map[i].type == who) {
                        memcpy(p, s2t_map[i].string, s2t_map[i].stringlen);
                        return s2t_map[i].stringlen;

diff --git a/fs/nfsd/nfs4callback.c b/fs/nfsd/nfs4callback.c
index d828662d737d22569c78fefec1623409f520cb9c..8d3d23c8a4d25f0328f578947acbe94bdc87a3fb 100644 (file)
--- a/fs/nfsd/nfs4callback.c
+++ b/fs/nfsd/nfs4callback.c
@@ -335,7 +335,7 @@ static struct rpc_procinfo     nfs4_cb_procedures[] = {
 
 static struct rpc_version       nfs_cb_version4 = {
         .number                 = 1,
-        .nrprocs                = sizeof(nfs4_cb_procedures)/sizeof(nfs4_cb_procedures[0]),
+        .nrprocs                = ARRAY_SIZE(nfs4_cb_procedures),
         .procs                  = nfs4_cb_procedures
 };
 
@@ -411,7 +411,7 @@ nfsd4_probe_callback(struct nfs4_client *clp)
        /* Initialize rpc_program */
        program->name = "nfs4_cb";
        program->number = cb->cb_prog;
-       program->nrvers = sizeof(nfs_cb_version)/sizeof(nfs_cb_version[0]);
+       program->nrvers = ARRAY_SIZE(nfs_cb_version);
        program->version = nfs_cb_version;
        program->stats = stat;
 

diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
index 69d3501173a8e79b2b0c01c167a45713f5867c2a..03857fd8112632a044ddab6d0a4ade576e762298 100644 (file)
--- a/fs/nfsd/nfs4xdr.c
+++ b/fs/nfsd/nfs4xdr.c
@@ -992,7 +992,7 @@ nfsd4_decode_compound(struct nfsd4_compoundargs *argp)
        if (argp->opcnt > 100)
                goto xdr_error;
 
-       if (argp->opcnt > sizeof(argp->iops)/sizeof(argp->iops[0])) {
+       if (argp->opcnt > ARRAY_SIZE(argp->iops)) {
                argp->ops = kmalloc(argp->opcnt * sizeof(*argp->ops), GFP_KERNEL);
                if (!argp->ops) {
                        argp->ops = argp->iops;

diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c
index a0871b3efeb7e35f1c80608ec3dd871d9e663d3f..c8960aff09685957e5b20dccf6b0a2fcdef27684 100644 (file)
--- a/fs/nfsd/nfsctl.c
+++ b/fs/nfsd/nfsctl.c
@@ -105,7 +105,7 @@ static ssize_t nfsctl_transaction_write(struct file *file, const char __user *bu
        char *data;
        ssize_t rv;
 
-       if (ino >= sizeof(write_op)/sizeof(write_op[0]) || !write_op[ino])
+       if (ino >= ARRAY_SIZE(write_op) || !write_op[ino])
                return -EINVAL;
 
        data = simple_transaction_get(file, buf, size);

diff --git a/fs/nfsd/nfssvc.c b/fs/nfsd/nfssvc.c
index 1d163b6169151ce870c911dc1c7eb0eb40c80a74..3790727e5dfdb8a8fb94ba4c5c7ca497d4ae6ae4 100644 (file)
--- a/fs/nfsd/nfssvc.c
+++ b/fs/nfsd/nfssvc.c
@@ -72,7 +72,7 @@ static struct svc_version *   nfsd_acl_version[] = {
 };
 
 #define NFSD_ACL_MINVERS            2
-#define NFSD_ACL_NRVERS                (sizeof(nfsd_acl_version)/sizeof(nfsd_acl_version[0]))
+#define NFSD_ACL_NRVERS                ARRAY_SIZE(nfsd_acl_version)
 static struct svc_version *nfsd_acl_versions[NFSD_ACL_NRVERS];
 
 static struct svc_program      nfsd_acl_program = {
@@ -101,7 +101,7 @@ static struct svc_version * nfsd_version[] = {
 };
 
 #define NFSD_MINVERS           2
-#define NFSD_NRVERS            (sizeof(nfsd_version)/sizeof(nfsd_version[0]))
+#define NFSD_NRVERS            ARRAY_SIZE(nfsd_version)
 static struct svc_version *nfsd_versions[NFSD_NRVERS];
 
 struct svc_program             nfsd_program = {

diff --git a/fs/nls/nls_euc-jp.c b/fs/nls/nls_euc-jp.c
index 80f108ae6661fb9aadb6c22e82a290aed52c6aeb..06640c3e402102db7e32d5ddf6d742c00c4a935e 100644 (file)
--- a/fs/nls/nls_euc-jp.c
+++ b/fs/nls/nls_euc-jp.c
@@ -268,8 +268,6 @@ static unsigned char euc2sjisibm_g3upper_map[][2] = {
        {0xFC, 0x4B},
 };
 
-#define MAP_ELEMENT_OF(map)    (sizeof(map) / sizeof(map[0]))
-
 static inline int sjisibm2euc(unsigned char *euc, const unsigned char sjis_hi,
                              const unsigned char sjis_lo);
 static inline int euc2sjisibm_jisx0212(unsigned char *sjis, const unsigned char euc_hi,
@@ -310,7 +308,7 @@ static inline int euc2sjisibm_jisx0212(unsigned char *sjis, const unsigned char
        unsigned short euc;
 
        min_index = 0;
-       max_index = MAP_ELEMENT_OF(euc2sjisibm_jisx0212_map) - 1;
+       max_index = ARRAY_SIZE(euc2sjisibm_jisx0212_map) - 1;
        euc = (euc_hi << 8) | euc_lo;
 
        while (min_index <= max_index) {
@@ -339,7 +337,7 @@ static inline int euc2sjisibm_g3upper(unsigned char *sjis, const unsigned char e
        else
                index = ((euc_hi << 8) | euc_lo) - 0xF4A1 + 12;
 
-       if ((index < 0) || (index >= MAP_ELEMENT_OF(euc2sjisibm_g3upper_map)))
+       if ((index < 0) || (index >= ARRAY_SIZE(euc2sjisibm_g3upper_map)))
                return 0;
 
        sjis[0] = euc2sjisibm_g3upper_map[index][0];

diff --git a/fs/reiserfs/prints.c b/fs/reiserfs/prints.c
index d55e164bd5c22b66d80cff459af5bc2655c1dd81..78b40621b88b7571e5065aa005feae888092cb0e 100644 (file)
--- a/fs/reiserfs/prints.c
+++ b/fs/reiserfs/prints.c
@@ -601,8 +601,7 @@ void store_print_tb(struct tree_balance *tb)
                tb->tb_mode, PATH_LAST_POSITION(tb->tb_path),
                tb->tb_path->pos_in_item);
 
-       for (h = 0; h < sizeof(tb->insert_size) / sizeof(tb->insert_size[0]);
-            h++) {
+       for (h = 0; h < ARRAY_SIZE(tb->insert_size); h++) {
                if (PATH_H_PATH_OFFSET(tb->tb_path, h) <=
                    tb->tb_path->path_length
                    && PATH_H_PATH_OFFSET(tb->tb_path,
@@ -658,15 +657,13 @@ void store_print_tb(struct tree_balance *tb)
 
        /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
        h = 0;
-       for (i = 0; i < sizeof(tb->FEB) / sizeof(tb->FEB[0]); i++)
+       for (i = 0; i < ARRAY_SIZE(tb->FEB); i++)
                sprintf(print_tb_buf + strlen(print_tb_buf),
                        "%p (%llu %d)%s", tb->FEB[i],
                        tb->FEB[i] ? (unsigned long long)tb->FEB[i]->
                        b_blocknr : 0ULL,
                        tb->FEB[i] ? atomic_read(&(tb->FEB[i]->b_count)) : 0,
-                       (i ==
-                        sizeof(tb->FEB) / sizeof(tb->FEB[0]) -
-                        1) ? "\n" : ", ");
+                       (i == ARRAY_SIZE(tb->FEB) - 1) ? "\n" : ", ");
 
        sprintf(print_tb_buf + strlen(print_tb_buf),
                "======================== the end ====================================\n");

diff --git a/fs/sysv/super.c b/fs/sysv/super.c
index 59e76b51142bf8b634d46526f8ad72ef4c743f1f..e92b991e6dda0fff10cb4ba5211a6b995a2ce153 100644 (file)
--- a/fs/sysv/super.c
+++ b/fs/sysv/super.c
@@ -377,10 +377,10 @@ static int sysv_fill_super(struct super_block *sb, void *data, int silent)
        sbi->s_sb = sb;
        sbi->s_block_base = 0;
        sb->s_fs_info = sbi;
-       
+
        sb_set_blocksize(sb, BLOCK_SIZE);
 
-       for (i = 0; i < sizeof(flavours)/sizeof(flavours[0]) && !size; i++) {
+       for (i = 0; i < ARRAY_SIZE(flavours) && !size; i++) {
                brelse(bh);
                bh = sb_bread(sb, flavours[i].block);
                if (!bh)

diff --git a/fs/udf/super.c b/fs/udf/super.c
index 9303c50c5d559d365389e6f69566f5d42f332fb1..0d555616c9396c10d3c52a3d17f5a450887a06b0 100644 (file)
--- a/fs/udf/super.c
+++ b/fs/udf/super.c
@@ -660,8 +660,7 @@ udf_find_anchor(struct super_block *sb)
                 *     lastblock
                 *  however, if the disc isn't closed, it could be 512 */
 
-               for (i=0; (!lastblock && i<sizeof(last)/sizeof(int)); i++)
-               {
+               for (i = 0; !lastblock && i < ARRAY_SIZE(last); i++) {
                        if (last[i] < 0 || !(bh = sb_bread(sb, last[i])))
                        {
                                ident = location = 0;
@@ -672,7 +671,7 @@ udf_find_anchor(struct super_block *sb)
                                location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
                                udf_release_data(bh);
                        }
-       
+
                        if (ident == TAG_IDENT_AVDP)
                        {
                                if (location == last[i] - UDF_SB_SESSION(sb))
@@ -753,8 +752,7 @@ udf_find_anchor(struct super_block *sb)
                }
        }
 
-       for (i=0; i<sizeof(UDF_SB_ANCHOR(sb))/sizeof(int); i++)
-       {
+       for (i = 0; i < ARRAY_SIZE(UDF_SB_ANCHOR(sb)); i++) {
                if (UDF_SB_ANCHOR(sb)[i])
                {
                        if (!(bh = udf_read_tagged(sb,
@@ -1313,8 +1311,7 @@ udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
        if (!sb)
                return 1;
 
-       for (i=0; i<sizeof(UDF_SB_ANCHOR(sb))/sizeof(int); i++)
-       {
+       for (i = 0; i < ARRAY_SIZE(UDF_SB_ANCHOR(sb)); i++) {
                if (UDF_SB_ANCHOR(sb)[i] && (bh = udf_read_tagged(sb,
                        UDF_SB_ANCHOR(sb)[i], UDF_SB_ANCHOR(sb)[i], &ident)))
                {
@@ -1325,7 +1322,7 @@ udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
                        main_e = le32_to_cpu( anchor->mainVolDescSeqExt.extLength );
                        main_e = main_e >> sb->s_blocksize_bits;
                        main_e += main_s;
-       
+
                        /* Locate the reserve sequence */
                        reserve_s = le32_to_cpu(anchor->reserveVolDescSeqExt.extLocation);
                        reserve_e = le32_to_cpu(anchor->reserveVolDescSeqExt.extLength);
@@ -1344,12 +1341,10 @@ udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
                }
        }
 
-       if (i == sizeof(UDF_SB_ANCHOR(sb))/sizeof(int))
-       {
+       if (i == ARRAY_SIZE(UDF_SB_ANCHOR(sb))) {
                udf_debug("No Anchor block found\n");
                return 1;
-       }
-       else
+       } else
                udf_debug("Using anchor in block %d\n", UDF_SB_ANCHOR(sb)[i]);
 
        for (i=0; i<UDF_SB_NUMPARTS(sb); i++)

diff --git a/fs/xfs/linux-2.6/xfs_stats.c b/fs/xfs/linux-2.6/xfs_stats.c
index 713e6a7505d0b98d78c9132e6db9bc619d81d82f..1f0589a05ecadb4f357e36d8470e9f1b8d4277b0 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_stats.c
+++ b/fs/xfs/linux-2.6/xfs_stats.c
@@ -56,7 +56,7 @@ xfs_read_xfsstats(
        };
 
        /* Loop over all stats groups */
-       for (i=j=len = 0; i < sizeof(xstats)/sizeof(struct xstats_entry); i++) {
+       for (i=j=len = 0; i < ARRAY_SIZE(xstats); i++) {
                len += sprintf(buffer + len, xstats[i].desc);
                /* inner loop does each group */
                while (j < xstats[i].endpoint) {

diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index a478f42e63ff520972f21860102f0134e45a02eb..0f0a64e81db9ceb765decc56ab4eb68a7bb68b97 100644 (file)
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -1335,7 +1335,7 @@ xfs_inactive_symlink_rmt(
         */
        done = 0;
        XFS_BMAP_INIT(&free_list, &first_block);
-       nmaps = sizeof(mval) / sizeof(mval[0]);
+       nmaps = ARRAY_SIZE(mval);
        if ((error = xfs_bmapi(tp, ip, 0, XFS_B_TO_FSB(mp, size),
                        XFS_BMAPI_METADATA, &first_block, 0, mval, &nmaps,
                        &free_list)))