staging: lustre: Use parenthesis around sizeof

Convert sizeof foo to sizeof(foo) to be more kernel style compatible.

Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/staging/lustre/lustre/fld/fld_cache.c b/drivers/staging/lustre/lustre/fld/fld_cache.c
index 25099cbe37eb7bf9a7b95911322cde1400407b5c..45315101848cba68799853291361930a6bc0be44 100644 (file)
--- a/drivers/staging/lustre/lustre/fld/fld_cache.c
+++ b/drivers/staging/lustre/lustre/fld/fld_cache.c
@@ -267,7 +267,7 @@ void fld_cache_punch_hole(struct fld_cache *cache,
        const seqno_t new_end  = range->lsr_end;
        struct fld_cache_entry *fldt;
 
-       OBD_ALLOC_GFP(fldt, sizeof *fldt, GFP_ATOMIC);
+       OBD_ALLOC_GFP(fldt, sizeof(*fldt), GFP_ATOMIC);
        if (!fldt) {
                OBD_FREE_PTR(f_new);
                /* overlap is not allowed, so dont mess up list. */

diff --git a/drivers/staging/lustre/lustre/include/cl_object.h b/drivers/staging/lustre/lustre/include/cl_object.h
index edb40afe66f122be83e83e4b871064a96dc8e30a..c485206fc6c2207f1933a1cc4b19598c35a281bf 100644 (file)
--- a/drivers/staging/lustre/lustre/include/cl_object.h
+++ b/drivers/staging/lustre/lustre/include/cl_object.h
@@ -3096,13 +3096,13 @@ struct cl_io *cl_io_top(struct cl_io *io);
 void cl_io_print(const struct lu_env *env, void *cookie,
                 lu_printer_t printer, const struct cl_io *io);
 
-#define CL_IO_SLICE_CLEAN(foo_io, base)                                 \
-do {                                                               \
-       typeof(foo_io) __foo_io = (foo_io);                          \
+#define CL_IO_SLICE_CLEAN(foo_io, base)                                        \
+do {                                                                   \
+       typeof(foo_io) __foo_io = (foo_io);                             \
                                                                        \
-       CLASSERT(offsetof(typeof(*__foo_io), base) == 0);              \
-       memset(&__foo_io->base + 1, 0,                            \
-              (sizeof *__foo_io) - sizeof __foo_io->base);          \
+       CLASSERT(offsetof(typeof(*__foo_io), base) == 0);               \
+       memset(&__foo_io->base + 1, 0,                                  \
+              sizeof(*__foo_io) - sizeof(__foo_io->base));             \
 } while (0)
 
 /** @} cl_io */

diff --git a/drivers/staging/lustre/lustre/include/lclient.h b/drivers/staging/lustre/lustre/include/lclient.h
index 9d4011f2908b91752e73c05143dd2bc718118734..27316f7b7a70013ccf765d76686db595e77bf4bd 100644 (file)
--- a/drivers/staging/lustre/lustre/include/lclient.h
+++ b/drivers/staging/lustre/lustre/include/lclient.h
@@ -388,8 +388,8 @@ __u16 ll_dirent_type_get(struct lu_dirent *ent);
 __u64 cl_fid_build_ino(const struct lu_fid *fid, int api32);
 __u32 cl_fid_build_gen(const struct lu_fid *fid);
 
-# define CLOBINVRNT(env, clob, expr)                               \
-       ((void)sizeof(env), (void)sizeof(clob), (void)sizeof !!(expr))
+# define CLOBINVRNT(env, clob, expr)                                   \
+       ((void)sizeof(env), (void)sizeof(clob), (void)sizeof(!!(expr)))
 
 int cl_init_ea_size(struct obd_export *md_exp, struct obd_export *dt_exp);
 int cl_ocd_update(struct obd_device *host,

diff --git a/drivers/staging/lustre/lustre/include/lustre/lustre_idl.h b/drivers/staging/lustre/lustre/include/lustre/lustre_idl.h
index 984235ccd3a5fb92a687e3ca538f4a339afc53bd..5ca18d01601429e5452bee9b1a839d7ce1df4bd3 100644 (file)
--- a/drivers/staging/lustre/lustre/include/lustre/lustre_idl.h
+++ b/drivers/staging/lustre/lustre/include/lustre/lustre_idl.h
@@ -831,9 +831,10 @@ static inline void lu_igif_build(struct lu_fid *fid, __u32 ino, __u32 gen)
 static inline void fid_cpu_to_le(struct lu_fid *dst, const struct lu_fid *src)
 {
        /* check that all fields are converted */
-       CLASSERT(sizeof *src ==
-                sizeof fid_seq(src) +
-                sizeof fid_oid(src) + sizeof fid_ver(src));
+       CLASSERT(sizeof(*src) ==
+                sizeof(fid_seq(src)) +
+                sizeof(fid_oid(src)) +
+                sizeof(fid_ver(src)));
        dst->f_seq = cpu_to_le64(fid_seq(src));
        dst->f_oid = cpu_to_le32(fid_oid(src));
        dst->f_ver = cpu_to_le32(fid_ver(src));
@@ -842,9 +843,10 @@ static inline void fid_cpu_to_le(struct lu_fid *dst, const struct lu_fid *src)
 static inline void fid_le_to_cpu(struct lu_fid *dst, const struct lu_fid *src)
 {
        /* check that all fields are converted */
-       CLASSERT(sizeof *src ==
-                sizeof fid_seq(src) +
-                sizeof fid_oid(src) + sizeof fid_ver(src));
+       CLASSERT(sizeof(*src) ==
+                sizeof(fid_seq(src)) +
+                sizeof(fid_oid(src)) +
+                sizeof(fid_ver(src)));
        dst->f_seq = le64_to_cpu(fid_seq(src));
        dst->f_oid = le32_to_cpu(fid_oid(src));
        dst->f_ver = le32_to_cpu(fid_ver(src));
@@ -853,9 +855,10 @@ static inline void fid_le_to_cpu(struct lu_fid *dst, const struct lu_fid *src)
 static inline void fid_cpu_to_be(struct lu_fid *dst, const struct lu_fid *src)
 {
        /* check that all fields are converted */
-       CLASSERT(sizeof *src ==
-                sizeof fid_seq(src) +
-                sizeof fid_oid(src) + sizeof fid_ver(src));
+       CLASSERT(sizeof(*src) ==
+                sizeof(fid_seq(src)) +
+                sizeof(fid_oid(src)) +
+                sizeof(fid_ver(src)));
        dst->f_seq = cpu_to_be64(fid_seq(src));
        dst->f_oid = cpu_to_be32(fid_oid(src));
        dst->f_ver = cpu_to_be32(fid_ver(src));
@@ -864,9 +867,10 @@ static inline void fid_cpu_to_be(struct lu_fid *dst, const struct lu_fid *src)
 static inline void fid_be_to_cpu(struct lu_fid *dst, const struct lu_fid *src)
 {
        /* check that all fields are converted */
-       CLASSERT(sizeof *src ==
-                sizeof fid_seq(src) +
-                sizeof fid_oid(src) + sizeof fid_ver(src));
+       CLASSERT(sizeof(*src) ==
+                sizeof(fid_seq(src)) +
+                sizeof(fid_oid(src)) +
+                sizeof(fid_ver(src)));
        dst->f_seq = be64_to_cpu(fid_seq(src));
        dst->f_oid = be32_to_cpu(fid_oid(src));
        dst->f_ver = be32_to_cpu(fid_ver(src));
@@ -891,9 +895,11 @@ extern void lustre_swab_lu_seq_range(struct lu_seq_range *range);
 static inline int lu_fid_eq(const struct lu_fid *f0, const struct lu_fid *f1)
 {
        /* Check that there is no alignment padding. */
-       CLASSERT(sizeof *f0 ==
-                sizeof f0->f_seq + sizeof f0->f_oid + sizeof f0->f_ver);
-       return memcmp(f0, f1, sizeof *f0) == 0;
+       CLASSERT(sizeof(*f0) ==
+                sizeof(f0->f_seq) +
+                sizeof(f0->f_oid) +
+                sizeof(f0->f_ver));
+       return memcmp(f0, f1, sizeof(*f0)) == 0;
 }
 
 #define __diff_normalize(val0, val1)                       \
@@ -1638,8 +1644,10 @@ static inline void lmm_oi_cpu_to_le(struct ost_id *dst_oi,
 
 /* extern void lustre_swab_lov_mds_md(struct lov_mds_md *llm); */
 
-#define MAX_MD_SIZE (sizeof(struct lov_mds_md) + 4 * sizeof(struct lov_ost_data))
-#define MIN_MD_SIZE (sizeof(struct lov_mds_md) + 1 * sizeof(struct lov_ost_data))
+#define MAX_MD_SIZE                                                    \
+       (sizeof(struct lov_mds_md) + 4 * sizeof(struct lov_ost_data))
+#define MIN_MD_SIZE                                                    \
+       (sizeof(struct lov_mds_md) + 1 * sizeof(struct lov_ost_data))
 
 #define XATTR_NAME_ACL_ACCESS   "system.posix_acl_access"
 #define XATTR_NAME_ACL_DEFAULT  "system.posix_acl_default"

diff --git a/drivers/staging/lustre/lustre/include/lustre_fid.h b/drivers/staging/lustre/lustre/include/lustre_fid.h
index d9d5814e318d9e8105195d7bbc17db5e043c6815..ff119532dafb352b7a6f7f57bbba59b5791a14ca 100644 (file)
--- a/drivers/staging/lustre/lustre/include/lustre_fid.h
+++ b/drivers/staging/lustre/lustre/include/lustre_fid.h
@@ -590,7 +590,7 @@ fid_build_pdo_res_name(const struct lu_fid *fid, unsigned int hash,
 static inline void ostid_build_res_name(struct ost_id *oi,
                                        struct ldlm_res_id *name)
 {
-       memset(name, 0, sizeof *name);
+       memset(name, 0, sizeof(*name));
        if (fid_seq_is_mdt0(ostid_seq(oi))) {
                name->name[LUSTRE_RES_ID_SEQ_OFF] = ostid_id(oi);
                name->name[LUSTRE_RES_ID_VER_OID_OFF] = ostid_seq(oi);

diff --git a/drivers/staging/lustre/lustre/include/obd.h b/drivers/staging/lustre/lustre/include/obd.h
index a6122559d55d20fc01680414e7fb637f54fc16bb..4fd4af9f29c9c6931857d08057fcae0a334dae48 100644 (file)
--- a/drivers/staging/lustre/lustre/include/obd.h
+++ b/drivers/staging/lustre/lustre/include/obd.h
@@ -177,7 +177,7 @@ static inline int lov_stripe_md_cmp(struct lov_stripe_md *m1,
         * ->lsm_wire contains padding, but it should be zeroed out during
         * allocation.
         */
-       return memcmp(&m1->lsm_wire, &m2->lsm_wire, sizeof m1->lsm_wire);
+       return memcmp(&m1->lsm_wire, &m2->lsm_wire, sizeof(m1->lsm_wire));
 }
 
 static inline int lov_lum_lsm_cmp(struct lov_user_md *lum,

diff --git a/drivers/staging/lustre/lustre/include/obd_support.h b/drivers/staging/lustre/lustre/include/obd_support.h
index 03e6133ef50fc74fb969dc2a6203196675163c05..9697e7faff2fddbb62e484121e7186adcab4077c 100644 (file)
--- a/drivers/staging/lustre/lustre/include/obd_support.h
+++ b/drivers/staging/lustre/lustre/include/obd_support.h
@@ -633,8 +633,8 @@ do {                                                                              \
 
 #define OBD_ALLOC(ptr, size) OBD_ALLOC_GFP(ptr, size, __GFP_IO)
 #define OBD_ALLOC_WAIT(ptr, size) OBD_ALLOC_GFP(ptr, size, GFP_IOFS)
-#define OBD_ALLOC_PTR(ptr) OBD_ALLOC(ptr, sizeof *(ptr))
-#define OBD_ALLOC_PTR_WAIT(ptr) OBD_ALLOC_WAIT(ptr, sizeof *(ptr))
+#define OBD_ALLOC_PTR(ptr) OBD_ALLOC(ptr, sizeof(*(ptr)))
+#define OBD_ALLOC_PTR_WAIT(ptr) OBD_ALLOC_WAIT(ptr, sizeof(*(ptr)))
 
 #define OBD_CPT_ALLOC_GFP(ptr, cptab, cpt, size, gfp_mask)                   \
        __OBD_MALLOC_VERBOSE(ptr, cptab, cpt, size, gfp_mask)
@@ -643,7 +643,7 @@ do {                                                                              \
        OBD_CPT_ALLOC_GFP(ptr, cptab, cpt, size, __GFP_IO)
 
 #define OBD_CPT_ALLOC_PTR(ptr, cptab, cpt)                                   \
-       OBD_CPT_ALLOC(ptr, cptab, cpt, sizeof *(ptr))
+       OBD_CPT_ALLOC(ptr, cptab, cpt, sizeof(*(ptr)))
 
 # define __OBD_VMALLOC_VEROBSE(ptr, cptab, cpt, size)                        \
 do {                                                                         \
@@ -773,7 +773,7 @@ do {                                                                              \
 #define OBD_SLAB_CPT_ALLOC_GFP(ptr, slab, cptab, cpt, size, flags)           \
        __OBD_SLAB_ALLOC_VERBOSE(ptr, slab, cptab, cpt, size, flags)
 
-#define OBD_FREE_PTR(ptr) OBD_FREE(ptr, sizeof *(ptr))
+#define OBD_FREE_PTR(ptr) OBD_FREE(ptr, sizeof(*(ptr)))
 
 #define OBD_SLAB_FREE(ptr, slab, size)                                 \
 do {                                                                     \
@@ -789,19 +789,19 @@ do {                                                                        \
        OBD_SLAB_CPT_ALLOC_GFP(ptr, slab, cptab, cpt, size, __GFP_IO)
 
 #define OBD_SLAB_ALLOC_PTR(ptr, slab)                                        \
-       OBD_SLAB_ALLOC(ptr, slab, sizeof *(ptr))
+       OBD_SLAB_ALLOC(ptr, slab, sizeof(*(ptr)))
 
 #define OBD_SLAB_CPT_ALLOC_PTR(ptr, slab, cptab, cpt)                        \
-       OBD_SLAB_CPT_ALLOC(ptr, slab, cptab, cpt, sizeof *(ptr))
+       OBD_SLAB_CPT_ALLOC(ptr, slab, cptab, cpt, sizeof(*(ptr)))
 
 #define OBD_SLAB_ALLOC_PTR_GFP(ptr, slab, flags)                             \
-       OBD_SLAB_ALLOC_GFP(ptr, slab, sizeof *(ptr), flags)
+       OBD_SLAB_ALLOC_GFP(ptr, slab, sizeof(*(ptr)), flags)
 
 #define OBD_SLAB_CPT_ALLOC_PTR_GFP(ptr, slab, cptab, cpt, flags)                     \
-       OBD_SLAB_CPT_ALLOC_GFP(ptr, slab, cptab, cpt, sizeof *(ptr), flags)
+       OBD_SLAB_CPT_ALLOC_GFP(ptr, slab, cptab, cpt, sizeof(*(ptr)), flags)
 
 #define OBD_SLAB_FREE_PTR(ptr, slab)                                         \
-       OBD_SLAB_FREE((ptr), (slab), sizeof *(ptr))
+       OBD_SLAB_FREE((ptr), (slab), sizeof(*(ptr)))
 
 #define KEY_IS(str) \
        (keylen >= (sizeof(str)-1) && memcmp(key, str, (sizeof(str)-1)) == 0)

diff --git a/drivers/staging/lustre/lustre/lclient/lcommon_cl.c b/drivers/staging/lustre/lustre/lclient/lcommon_cl.c
index 8ff38c64b7a1fcf5e28c4f148f9b7d869464bd1a..e60c04d5393abaf6bf51ac3834adaf274d432d45 100644 (file)
--- a/drivers/staging/lustre/lustre/lclient/lcommon_cl.c
+++ b/drivers/staging/lustre/lustre/lclient/lcommon_cl.c
@@ -701,7 +701,7 @@ int ccc_io_one_lock_index(const struct lu_env *env, struct cl_io *io,
 
        CDEBUG(D_VFSTRACE, "lock: %d [%lu, %lu]\n", mode, start, end);
 
-       memset(&cio->cui_link, 0, sizeof cio->cui_link);
+       memset(&cio->cui_link, 0, sizeof(cio->cui_link));
 
        if (cio->cui_fd && (cio->cui_fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
                descr->cld_mode = CLM_GROUP;

diff --git a/drivers/staging/lustre/lustre/ldlm/ldlm_lock.c b/drivers/staging/lustre/lustre/ldlm/ldlm_lock.c
index 6133b3f347182f1d202f412ce4b10556fc1df3d2..027617f5083fb81343c541042167f0d034a81752 100644 (file)
--- a/drivers/staging/lustre/lustre/ldlm/ldlm_lock.c
+++ b/drivers/staging/lustre/lustre/ldlm/ldlm_lock.c
@@ -529,7 +529,7 @@ int ldlm_lock_change_resource(struct ldlm_namespace *ns, struct ldlm_lock *lock,
                lock_res_nested(oldres, LRT_NEW);
        }
        LASSERT(memcmp(new_resid, &oldres->lr_name,
-                      sizeof oldres->lr_name) != 0);
+                      sizeof(oldres->lr_name)) != 0);
        lock->l_resource = newres;
        unlock_res(oldres);
        unlock_res_and_lock(lock);

diff --git a/drivers/staging/lustre/lustre/ldlm/ldlm_resource.c b/drivers/staging/lustre/lustre/ldlm/ldlm_resource.c
index 208751a154b3c6de28194b30b937f48ddee54653..8d3dd6dad9b7dded72132d1dbd84fd17c04a6f9c 100644 (file)
--- a/drivers/staging/lustre/lustre/ldlm/ldlm_resource.c
+++ b/drivers/staging/lustre/lustre/ldlm/ldlm_resource.c
@@ -1115,7 +1115,7 @@ ldlm_resource_get(struct ldlm_namespace *ns, struct ldlm_resource *parent,
                lu_ref_fini(&res->lr_reference);
                /* We have taken lr_lvb_mutex. Drop it. */
                mutex_unlock(&res->lr_lvb_mutex);
-               OBD_SLAB_FREE(res, ldlm_resource_slab, sizeof *res);
+               OBD_SLAB_FREE(res, ldlm_resource_slab, sizeof(*res));
 
                res = hlist_entry(hnode, struct ldlm_resource, lr_hash);
                /* Synchronize with regard to resource creation. */
@@ -1226,7 +1226,7 @@ int ldlm_resource_putref(struct ldlm_resource *res)
                cfs_hash_bd_unlock(ns->ns_rs_hash, &bd, 1);
                if (ns->ns_lvbo && ns->ns_lvbo->lvbo_free)
                        ns->ns_lvbo->lvbo_free(res);
-               OBD_SLAB_FREE(res, ldlm_resource_slab, sizeof *res);
+               OBD_SLAB_FREE(res, ldlm_resource_slab, sizeof(*res));
                return 1;
        }
        return 0;
@@ -1256,7 +1256,7 @@ int ldlm_resource_putref_locked(struct ldlm_resource *res)
                 */
                if (ns->ns_lvbo && ns->ns_lvbo->lvbo_free)
                        ns->ns_lvbo->lvbo_free(res);
-               OBD_SLAB_FREE(res, ldlm_resource_slab, sizeof *res);
+               OBD_SLAB_FREE(res, ldlm_resource_slab, sizeof(*res));
 
                cfs_hash_bd_lock(ns->ns_rs_hash, &bd, 1);
                return 1;

diff --git a/drivers/staging/lustre/lustre/libcfs/linux/linux-debug.c b/drivers/staging/lustre/lustre/libcfs/linux/linux-debug.c
index ab1e73168472445cc59b5b1e9c3165325684510b..cc565b1fb994397e8322d5dc7a66701c546e3c8d 100644 (file)
--- a/drivers/staging/lustre/lustre/libcfs/linux/linux-debug.c
+++ b/drivers/staging/lustre/lustre/libcfs/linux/linux-debug.c
@@ -137,7 +137,7 @@ void libcfs_run_lbug_upcall(struct libcfs_debug_msg_data *msgdata)
        char *argv[6];
        char buf[32];
 
-       snprintf (buf, sizeof buf, "%d", msgdata->msg_line);
+       snprintf(buf, sizeof(buf), "%d", msgdata->msg_line);
 
        argv[1] = "LBUG";
        argv[2] = (char *)msgdata->msg_file;

diff --git a/drivers/staging/lustre/lustre/llite/file.c b/drivers/staging/lustre/lustre/llite/file.c
index 8c4b4fa0d59bcb60ad748f6bf3b20be8cb05d517..fb85a58db058ec3f34cf80065e4b9cdb5e35c05f 100644 (file)
--- a/drivers/staging/lustre/lustre/llite/file.c
+++ b/drivers/staging/lustre/lustre/llite/file.c
@@ -3011,7 +3011,7 @@ static int ll_layout_lock_set(struct lustre_handle *lockh, ldlm_mode_t mode,
 
        /* set layout to file. Unlikely this will fail as old layout was
         * surely eliminated */
-       memset(&conf, 0, sizeof conf);
+       memset(&conf, 0, sizeof(conf));
        conf.coc_opc = OBJECT_CONF_SET;
        conf.coc_inode = inode;
        conf.coc_lock = lock;
@@ -3034,7 +3034,7 @@ out:
                        ll_get_fsname(inode->i_sb, NULL, 0),
                        inode, PFID(&lli->lli_fid));
 
-               memset(&conf, 0, sizeof conf);
+               memset(&conf, 0, sizeof(conf));
                conf.coc_opc = OBJECT_CONF_WAIT;
                conf.coc_inode = inode;
                rc = ll_layout_conf(inode, &conf);

diff --git a/drivers/staging/lustre/lustre/llite/llite_lib.c b/drivers/staging/lustre/lustre/llite/llite_lib.c
index b868c2bd58d2a78787e2336d2c4b4a6259c3dd90..fd584ff7e2df0e22602347199a1ccfe02544ca41 100644 (file)
--- a/drivers/staging/lustre/lustre/llite/llite_lib.c
+++ b/drivers/staging/lustre/lustre/llite/llite_lib.c
@@ -1973,10 +1973,10 @@ void ll_umount_begin(struct super_block *sb)
        OBD_ALLOC_PTR(ioc_data);
        if (ioc_data) {
                obd_iocontrol(IOC_OSC_SET_ACTIVE, sbi->ll_md_exp,
-                             sizeof *ioc_data, ioc_data, NULL);
+                             sizeof(*ioc_data), ioc_data, NULL);
 
                obd_iocontrol(IOC_OSC_SET_ACTIVE, sbi->ll_dt_exp,
-                             sizeof *ioc_data, ioc_data, NULL);
+                             sizeof(*ioc_data), ioc_data, NULL);
 
                OBD_FREE_PTR(ioc_data);
        }

diff --git a/drivers/staging/lustre/lustre/llite/rw.c b/drivers/staging/lustre/lustre/llite/rw.c
index ae0dc441d1d9dd238ce0bfb4a5b37b46eeca607b..e9ba38a553cf3e62b90dfab2529efb8c491b1b72 100644 (file)
--- a/drivers/staging/lustre/lustre/llite/rw.c
+++ b/drivers/staging/lustre/lustre/llite/rw.c
@@ -717,7 +717,7 @@ int ll_readahead(const struct lu_env *env, struct cl_io *io,
        lli = ll_i2info(inode);
        clob = lli->lli_clob;
 
-       memset(ria, 0, sizeof *ria);
+       memset(ria, 0, sizeof(*ria));
 
        cl_object_attr_lock(clob);
        ret = cl_object_attr_get(env, clob, attr);

diff --git a/drivers/staging/lustre/lustre/lov/lov_dev.c b/drivers/staging/lustre/lustre/lov/lov_dev.c
index a4006ef46ad2a794eede17ee883fef91e6a259ea..099cebb05e445c6e20285aaf02c39923ba1b9fe1 100644 (file)
--- a/drivers/staging/lustre/lustre/lov/lov_dev.c
+++ b/drivers/staging/lustre/lustre/lov/lov_dev.c
@@ -286,7 +286,7 @@ static void lov_emerg_free(struct lov_device_emerg **emrg, int nr)
                        OBD_FREE_PTR(em);
                }
        }
-       OBD_FREE(emrg, nr * sizeof emrg[0]);
+       OBD_FREE(emrg, nr * sizeof(emrg[0]));
 }
 
 static struct lu_device *lov_device_free(const struct lu_env *env,
@@ -297,7 +297,7 @@ static struct lu_device *lov_device_free(const struct lu_env *env,
 
        cl_device_fini(lu2cl_dev(d));
        if (ld->ld_target != NULL)
-               OBD_FREE(ld->ld_target, nr * sizeof ld->ld_target[0]);
+               OBD_FREE(ld->ld_target, nr * sizeof(ld->ld_target[0]));
        if (ld->ld_emrg != NULL)
                lov_emerg_free(ld->ld_emrg, nr);
        OBD_FREE_PTR(ld);
@@ -321,7 +321,7 @@ static struct lov_device_emerg **lov_emerg_alloc(int nr)
        int i;
        int result;
 
-       OBD_ALLOC(emerg, nr * sizeof emerg[0]);
+       OBD_ALLOC(emerg, nr * sizeof(emerg[0]));
        if (emerg == NULL)
                return ERR_PTR(-ENOMEM);
        for (result = i = 0; i < nr && result == 0; i++) {
@@ -361,7 +361,7 @@ static int lov_expand_targets(const struct lu_env *env, struct lov_device *dev)
        if (sub_size < tgt_size) {
                struct lovsub_device    **newd;
                struct lov_device_emerg **emerg;
-               const size_t          sz   = sizeof newd[0];
+               const size_t          sz   = sizeof(newd[0]);
 
                emerg = lov_emerg_alloc(tgt_size);
                if (IS_ERR(emerg))

diff --git a/drivers/staging/lustre/lustre/lov/lov_internal.h b/drivers/staging/lustre/lustre/lov/lov_internal.h
index 16770d14ee04d8686204b3cfc94af6cd5e777b5c..9870d360a15a8c7555cca1e423f8ce81d20f0c03 100644 (file)
--- a/drivers/staging/lustre/lustre/lov/lov_internal.h
+++ b/drivers/staging/lustre/lustre/lov/lov_internal.h
@@ -124,7 +124,7 @@ static inline void lov_llh_put(struct lov_lock_handles *llh)
                if (atomic_read(&llh->llh_refcount))
                        return;
 
-               OBD_FREE_RCU(llh, sizeof *llh +
+               OBD_FREE_RCU(llh, sizeof(*llh) +
                             sizeof(*llh->llh_handles) * llh->llh_stripe_count,
                             &llh->llh_handle);
        }

diff --git a/drivers/staging/lustre/lustre/lov/lov_io.c b/drivers/staging/lustre/lustre/lov/lov_io.c
index b611aa4e9dcb9b9a97640317e994bd6dc08975a5..5be0e2c243b051933669a50e5ea907ccca994d94 100644 (file)
--- a/drivers/staging/lustre/lustre/lov/lov_io.c
+++ b/drivers/staging/lustre/lustre/lov/lov_io.c
@@ -282,7 +282,7 @@ static int lov_io_subio_init(const struct lu_env *env, struct lov_io *lio,
         * when writing a page. -jay
         */
        OBD_ALLOC_LARGE(lio->lis_subs,
-                       lsm->lsm_stripe_count * sizeof lio->lis_subs[0]);
+                       lsm->lsm_stripe_count * sizeof(lio->lis_subs[0]));
        if (lio->lis_subs != NULL) {
                lio->lis_nr_subios = lio->lis_stripe_count;
                lio->lis_single_subio_index = -1;
@@ -356,7 +356,7 @@ static void lov_io_fini(const struct lu_env *env, const struct cl_io_slice *ios)
                for (i = 0; i < lio->lis_nr_subios; i++)
                        lov_io_sub_fini(env, lio, &lio->lis_subs[i]);
                OBD_FREE_LARGE(lio->lis_subs,
-                        lio->lis_nr_subios * sizeof lio->lis_subs[0]);
+                        lio->lis_nr_subios * sizeof(lio->lis_subs[0]));
                lio->lis_nr_subios = 0;
        }
 

diff --git a/drivers/staging/lustre/lustre/lov/lov_lock.c b/drivers/staging/lustre/lustre/lov/lov_lock.c
index ec297e87c2a2c2a048b8aa57a61203af92fbd0e3..7682aeb3fa6adf946a10f2c9708235ae1c065603 100644 (file)
--- a/drivers/staging/lustre/lustre/lov/lov_lock.c
+++ b/drivers/staging/lustre/lustre/lov/lov_lock.c
@@ -313,7 +313,7 @@ static int lov_lock_sub_init(const struct lu_env *env,
                        nr++;
        }
        LASSERT(nr > 0);
-       OBD_ALLOC_LARGE(lck->lls_sub, nr * sizeof lck->lls_sub[0]);
+       OBD_ALLOC_LARGE(lck->lls_sub, nr * sizeof(lck->lls_sub[0]));
        if (lck->lls_sub == NULL)
                return -ENOMEM;
 
@@ -474,7 +474,7 @@ static void lov_lock_fini(const struct lu_env *env,
                         */
                        LASSERT(lck->lls_sub[i].sub_lock == NULL);
                OBD_FREE_LARGE(lck->lls_sub,
-                              lck->lls_nr * sizeof lck->lls_sub[0]);
+                              lck->lls_nr * sizeof(lck->lls_sub[0]));
        }
        OBD_SLAB_FREE_PTR(lck, lov_lock_kmem);
 }

diff --git a/drivers/staging/lustre/lustre/lov/lov_object.c b/drivers/staging/lustre/lustre/lov/lov_object.c
index 84e55ce3ccd2217236ce176fe3ee7cb7b20cc762..cf2fa8abfb1dede0e69de8d8a59a5f97a82816c9 100644 (file)
--- a/drivers/staging/lustre/lustre/lov/lov_object.c
+++ b/drivers/staging/lustre/lustre/lov/lov_object.c
@@ -214,7 +214,7 @@ static int lov_init_raid0(const struct lu_env *env,
        r0->lo_nr  = lsm->lsm_stripe_count;
        LASSERT(r0->lo_nr <= lov_targets_nr(dev));
 
-       OBD_ALLOC_LARGE(r0->lo_sub, r0->lo_nr * sizeof r0->lo_sub[0]);
+       OBD_ALLOC_LARGE(r0->lo_sub, r0->lo_nr * sizeof(r0->lo_sub[0]));
        if (r0->lo_sub != NULL) {
                result = 0;
                subconf->coc_inode = conf->coc_inode;
@@ -368,7 +368,7 @@ static void lov_fini_raid0(const struct lu_env *env, struct lov_object *lov,
        struct lov_layout_raid0 *r0 = &state->raid0;
 
        if (r0->lo_sub != NULL) {
-               OBD_FREE_LARGE(r0->lo_sub, r0->lo_nr * sizeof r0->lo_sub[0]);
+               OBD_FREE_LARGE(r0->lo_sub, r0->lo_nr * sizeof(r0->lo_sub[0]));
                r0->lo_sub = NULL;
        }
 

diff --git a/drivers/staging/lustre/lustre/lov/lov_pack.c b/drivers/staging/lustre/lustre/lov/lov_pack.c
index 55ec26778f8043cb16276f7b1c35404d772c92af..2f80833f164ac1370d63842b15a2bd1a6e852045 100644 (file)
--- a/drivers/staging/lustre/lustre/lov/lov_pack.c
+++ b/drivers/staging/lustre/lustre/lov/lov_pack.c
@@ -630,7 +630,7 @@ int lov_getstripe(struct obd_export *exp, struct lov_stripe_md *lsm,
        /* FIXME: Bug 1185 - copy fields properly when structs change */
        /* struct lov_user_md_v3 and struct lov_mds_md_v3 must be the same */
        CLASSERT(sizeof(lum) == sizeof(struct lov_mds_md_v3));
-       CLASSERT(sizeof lum.lmm_objects[0] == sizeof lmmk->lmm_objects[0]);
+       CLASSERT(sizeof(lum.lmm_objects[0]) == sizeof(lmmk->lmm_objects[0]));
 
        if ((cpu_to_le32(LOV_MAGIC) != LOV_MAGIC) &&
            ((lmmk->lmm_magic == cpu_to_le32(LOV_MAGIC_V1)) ||

diff --git a/drivers/staging/lustre/lustre/lov/lov_request.c b/drivers/staging/lustre/lustre/lov/lov_request.c
index 61e6d0b46c98e4898a43867ea0e79b20f8ada587..f80e626466832be512ffa3354e0d07a43fa45e54 100644 (file)
--- a/drivers/staging/lustre/lustre/lov/lov_request.c
+++ b/drivers/staging/lustre/lustre/lov/lov_request.c
@@ -245,7 +245,7 @@ int lov_update_enqueue_set(struct lov_request *req, __u32 mode, int rc)
        osc_update_enqueue(lov_lockhp, loi, oi->oi_flags,
                           &req->rq_oi.oi_md->lsm_oinfo[0]->loi_lvb, mode, rc);
        if (rc == ELDLM_LOCK_ABORTED && (oi->oi_flags & LDLM_FL_HAS_INTENT))
-               memset(lov_lockhp, 0, sizeof *lov_lockhp);
+               memset(lov_lockhp, 0, sizeof(*lov_lockhp));
        rc = lov_update_enqueue_lov(set->set_exp, lov_lockhp, loi, oi->oi_flags,
                                    req->rq_idx, &oi->oi_md->lsm_oi, rc);
        lov_stripe_unlock(oi->oi_md);
@@ -343,7 +343,7 @@ static struct lov_lock_handles *lov_llh_new(struct lov_stripe_md *lsm)
 {
        struct lov_lock_handles *llh;
 
-       OBD_ALLOC(llh, sizeof *llh +
+       OBD_ALLOC(llh, sizeof(*llh) +
                  sizeof(*llh->llh_handles) * lsm->lsm_stripe_count);
        if (llh == NULL)
                return NULL;

diff --git a/drivers/staging/lustre/lustre/obdclass/cl_io.c b/drivers/staging/lustre/lustre/obdclass/cl_io.c
index 42697934155493e5c1c5a79576bce699f3f1ee28..e048500edd60c680aa280d872fe34f576ba66172 100644 (file)
--- a/drivers/staging/lustre/lustre/obdclass/cl_io.c
+++ b/drivers/staging/lustre/lustre/obdclass/cl_io.c
@@ -1387,7 +1387,7 @@ static void cl_req_free(const struct lu_env *env, struct cl_req *req)
                                cl_object_put(env, obj);
                        }
                }
-               OBD_FREE(req->crq_o, req->crq_nrobjs * sizeof req->crq_o[0]);
+               OBD_FREE(req->crq_o, req->crq_nrobjs * sizeof(req->crq_o[0]));
        }
        OBD_FREE_PTR(req);
 }
@@ -1452,7 +1452,7 @@ struct cl_req *cl_req_alloc(const struct lu_env *env, struct cl_page *page,
        if (req != NULL) {
                int result;
 
-               OBD_ALLOC(req->crq_o, nr_objects * sizeof req->crq_o[0]);
+               OBD_ALLOC(req->crq_o, nr_objects * sizeof(req->crq_o[0]));
                if (req->crq_o != NULL) {
                        req->crq_nrobjs = nr_objects;
                        req->crq_type = crt;
@@ -1642,7 +1642,7 @@ int cl_sync_io_wait(const struct lu_env *env, struct cl_io *io,
                cpu_relax();
        }
 
-       POISON(anchor, 0x5a, sizeof *anchor);
+       POISON(anchor, 0x5a, sizeof(*anchor));
        return rc;
 }
 EXPORT_SYMBOL(cl_sync_io_wait);

diff --git a/drivers/staging/lustre/lustre/obdclass/class_obd.c b/drivers/staging/lustre/lustre/obdclass/class_obd.c
index b1024a6d37dd95ef215a489d07b5de76f2ec3f66..4afd962cdb64db50c83f5312b656ed0fe6131b4f 100644 (file)
--- a/drivers/staging/lustre/lustre/obdclass/class_obd.c
+++ b/drivers/staging/lustre/lustre/obdclass/class_obd.c
@@ -178,7 +178,7 @@ EXPORT_SYMBOL(obd_alloc_fail);
 static inline void obd_data2conn(struct lustre_handle *conn,
                                 struct obd_ioctl_data *data)
 {
-       memset(conn, 0, sizeof *conn);
+       memset(conn, 0, sizeof(*conn));
        conn->cookie = data->ioc_cookie;
 }
 

diff --git a/drivers/staging/lustre/lustre/obdclass/llog_test.c b/drivers/staging/lustre/lustre/obdclass/llog_test.c
index d9e6d12215f904307b7d42483fbac272a19b002e..178f89eccab11d25229c801f2e2ad9f244f33c07 100644 (file)
--- a/drivers/staging/lustre/lustre/obdclass/llog_test.c
+++ b/drivers/staging/lustre/lustre/obdclass/llog_test.c
@@ -242,7 +242,7 @@ static int llog_test_3(const struct lu_env *env, struct obd_device *obd,
 
                hdr.lrh_len = 8;
                hdr.lrh_type = OBD_CFG_REC;
-               memset(buf, 0, sizeof buf);
+               memset(buf, 0, sizeof(buf));
                rc = llog_write(env, llh, &hdr, NULL, 0, buf, -1);
                if (rc < 0) {
                        CERROR("3b: write 10 records failed at #%d: %d\n",
@@ -277,8 +277,8 @@ static int llog_test_3(const struct lu_env *env, struct obd_device *obd,
                char                    buf_even[24];
                char                    buf_odd[32];
 
-               memset(buf_odd, 0, sizeof buf_odd);
-               memset(buf_even, 0, sizeof buf_even);
+               memset(buf_odd, 0, sizeof(buf_odd));
+               memset(buf_even, 0, sizeof(buf_even));
                if ((i % 2) == 0) {
                        hdr.lrh_len = 24;
                        hdr.lrh_type = OBD_CFG_REC;

diff --git a/drivers/staging/lustre/lustre/obdclass/lu_object.c b/drivers/staging/lustre/lustre/obdclass/lu_object.c
index 3a3d5bc5a628a05e45def8d74112e55138655a80..e8f260781c0ef96b747145c7286628d2cad99102 100644 (file)
--- a/drivers/staging/lustre/lustre/obdclass/lu_object.c
+++ b/drivers/staging/lustre/lustre/obdclass/lu_object.c
@@ -980,7 +980,7 @@ int lu_site_init(struct lu_site *s, struct lu_device *top)
        int bits;
        int i;
 
-       memset(s, 0, sizeof *s);
+       memset(s, 0, sizeof(*s));
        bits = lu_htable_order();
        snprintf(name, 16, "lu_site_%s", top->ld_type->ldt_name);
        for (bits = min(max(LU_SITE_BITS_MIN, bits), LU_SITE_BITS_MAX);
@@ -1110,7 +1110,7 @@ int lu_device_init(struct lu_device *d, struct lu_device_type *t)
 {
        if (t->ldt_device_nr++ == 0 && t->ldt_ops->ldto_start != NULL)
                t->ldt_ops->ldto_start(t);
-       memset(d, 0, sizeof *d);
+       memset(d, 0, sizeof(*d));
        atomic_set(&d->ld_ref, 0);
        d->ld_type = t;
        lu_ref_init(&d->ld_reference);
@@ -1206,7 +1206,7 @@ EXPORT_SYMBOL(lu_object_add);
  */
 int lu_object_header_init(struct lu_object_header *h)
 {
-       memset(h, 0, sizeof *h);
+       memset(h, 0, sizeof(*h));
        atomic_set(&h->loh_ref, 1);
        INIT_HLIST_NODE(&h->loh_hash);
        INIT_LIST_HEAD(&h->loh_lru);
@@ -1525,7 +1525,7 @@ static void keys_fini(struct lu_context *ctx)
        for (i = 0; i < ARRAY_SIZE(lu_keys); ++i)
                key_fini(ctx, i);
 
-       OBD_FREE(ctx->lc_value, ARRAY_SIZE(lu_keys) * sizeof ctx->lc_value[0]);
+       OBD_FREE(ctx->lc_value, ARRAY_SIZE(lu_keys) * sizeof(ctx->lc_value[0]));
        ctx->lc_value = NULL;
 }
 
@@ -1574,7 +1574,8 @@ static int keys_fill(struct lu_context *ctx)
 
 static int keys_init(struct lu_context *ctx)
 {
-       OBD_ALLOC(ctx->lc_value, ARRAY_SIZE(lu_keys) * sizeof ctx->lc_value[0]);
+       OBD_ALLOC(ctx->lc_value,
+                 ARRAY_SIZE(lu_keys) * sizeof(ctx->lc_value[0]));
        if (likely(ctx->lc_value != NULL))
                return keys_fill(ctx);
 
@@ -1588,7 +1589,7 @@ int lu_context_init(struct lu_context *ctx, __u32 tags)
 {
        int     rc;
 
-       memset(ctx, 0, sizeof *ctx);
+       memset(ctx, 0, sizeof(*ctx));
        ctx->lc_state = LCS_INITIALIZED;
        ctx->lc_tags = tags;
        if (tags & LCT_REMEMBER) {

diff --git a/drivers/staging/lustre/lustre/obdclass/obd_config.c b/drivers/staging/lustre/lustre/obdclass/obd_config.c
index d0a64ff53581e5871abf99379fe387e0b979dd2c..73e2571f463ffa80c65facd2a757832301aaf7e4 100644 (file)
--- a/drivers/staging/lustre/lustre/obdclass/obd_config.c
+++ b/drivers/staging/lustre/lustre/obdclass/obd_config.c
@@ -417,7 +417,7 @@ int class_attach(struct lustre_cfg *lcfg)
 
        /* do the attach */
        if (OBP(obd, attach)) {
-               rc = OBP(obd,attach)(obd, sizeof *lcfg, lcfg);
+               rc = OBP(obd, attach)(obd, sizeof(*lcfg), lcfg);
                if (rc)
                        GOTO(out, rc = -EINVAL);
        }
@@ -900,7 +900,7 @@ void class_del_profile(const char *prof)
                OBD_FREE(lprof->lp_dt, strlen(lprof->lp_dt) + 1);
                if (lprof->lp_md)
                        OBD_FREE(lprof->lp_md, strlen(lprof->lp_md) + 1);
-               OBD_FREE(lprof, sizeof *lprof);
+               OBD_FREE(lprof, sizeof(*lprof));
        }
 }
 EXPORT_SYMBOL(class_del_profile);
@@ -916,7 +916,7 @@ void class_del_profiles(void)
                OBD_FREE(lprof->lp_dt, strlen(lprof->lp_dt) + 1);
                if (lprof->lp_md)
                        OBD_FREE(lprof->lp_md, strlen(lprof->lp_md) + 1);
-               OBD_FREE(lprof, sizeof *lprof);
+               OBD_FREE(lprof, sizeof(*lprof));
        }
 }
 EXPORT_SYMBOL(class_del_profiles);

diff --git a/drivers/staging/lustre/lustre/obdclass/uuid.c b/drivers/staging/lustre/lustre/obdclass/uuid.c
index af5f27f82bc5b157b02de284c2dff886c6974dee..e87a19900770574282e8a3da3357efc78b0292b1 100644 (file)
--- a/drivers/staging/lustre/lustre/obdclass/uuid.c
+++ b/drivers/staging/lustre/lustre/obdclass/uuid.c
@@ -48,7 +48,7 @@ static inline __u32 consume(int nob, __u8 **ptr)
 {
        __u32 value;
 
-       LASSERT(nob <= sizeof value);
+       LASSERT(nob <= sizeof(value));
 
        for (value = 0; nob > 0; --nob)
                value = (value << 8) | *((*ptr)++);
@@ -61,7 +61,7 @@ static void uuid_unpack(class_uuid_t in, __u16 *uu, int nr)
 {
        __u8 *ptr = in;
 
-       LASSERT(nr * sizeof *uu == sizeof(class_uuid_t));
+       LASSERT(nr * sizeof(*uu) == sizeof(class_uuid_t));
 
        while (nr-- > 0)
                CONSUME(uu[nr], &ptr);

diff --git a/drivers/staging/lustre/lustre/obdecho/echo_client.c b/drivers/staging/lustre/lustre/obdecho/echo_client.c
index c8b43442dc74be8c8cf1ee3f5b38470f63617e71..1fb0ac4e920d58136163b7bd244fe782ecdc493a 100644 (file)
--- a/drivers/staging/lustre/lustre/obdecho/echo_client.c
+++ b/drivers/staging/lustre/lustre/obdecho/echo_client.c
@@ -1089,7 +1089,7 @@ static struct echo_object *cl_echo_object_find(struct echo_device *d,
                } else {
                        struct lustre_md *md;
                        md = &info->eti_md;
-                       memset(md, 0, sizeof *md);
+                       memset(md, 0, sizeof(*md));
                        md->lsm = lsm;
                        conf->eoc_cl.u.coc_md = md;
                }

diff --git a/drivers/staging/lustre/lustre/osc/osc_lock.c b/drivers/staging/lustre/lustre/osc/osc_lock.c
index 5d7bdbfc871af2c9e0e2dd3b4bad76e3771f1a31..c90abfbb1d7a52cd25374d1336ab014a5252d08a 100644 (file)
--- a/drivers/staging/lustre/lustre/osc/osc_lock.c
+++ b/drivers/staging/lustre/lustre/osc/osc_lock.c
@@ -862,7 +862,7 @@ static int osc_ldlm_glimpse_ast(struct ldlm_lock *dlmlock, void *data)
                        cap = &req->rq_pill;
                        req_capsule_extend(cap, &RQF_LDLM_GL_CALLBACK);
                        req_capsule_set_size(cap, &RMF_DLM_LVB, RCL_SERVER,
-                                            sizeof *lvb);
+                                            sizeof(*lvb));
                        result = req_capsule_server_pack(cap);
                        if (result == 0) {
                                lvb = req_capsule_server_get(cap, &RMF_DLM_LVB);

diff --git a/drivers/staging/lustre/lustre/osc/osc_page.c b/drivers/staging/lustre/lustre/osc/osc_page.c
index d272322b29b6618ddad867720ae8be6c0b5825c2..6c20b8ecfb8200080c599236c6cb4445bde940ff 100644 (file)
--- a/drivers/staging/lustre/lustre/osc/osc_page.c
+++ b/drivers/staging/lustre/lustre/osc/osc_page.c
@@ -245,7 +245,7 @@ static int osc_page_cache_add(const struct lu_env *env,
 void osc_index2policy(ldlm_policy_data_t *policy, const struct cl_object *obj,
                      pgoff_t start, pgoff_t end)
 {
-       memset(policy, 0, sizeof *policy);
+       memset(policy, 0, sizeof(*policy));
        policy->l_extent.start = cl_offset(obj, start);
        policy->l_extent.end   = cl_offset(obj, end + 1) - 1;
 }

diff --git a/drivers/staging/lustre/lustre/osc/osc_request.c b/drivers/staging/lustre/lustre/osc/osc_request.c
index ee6707a5ea9d8e9ddb99053fa479836bfcc5cb77..cb197782d9a3378c0060a21614a8a5fda06be166 100644 (file)
--- a/drivers/staging/lustre/lustre/osc/osc_request.c
+++ b/drivers/staging/lustre/lustre/osc/osc_request.c
@@ -2554,7 +2554,7 @@ int osc_enqueue_base(struct obd_export *exp, struct ldlm_res_id *res_id,
                }
 
                req_capsule_set_size(&req->rq_pill, &RMF_DLM_LVB, RCL_SERVER,
-                                    sizeof *lvb);
+                                    sizeof(*lvb));
                ptlrpc_request_set_replen(req);
        }
 

diff --git a/drivers/staging/lustre/lustre/ptlrpc/client.c b/drivers/staging/lustre/lustre/ptlrpc/client.c
index 810a458caed73aaea8a34e0ba1abb65f12336d0a..c2ab0c8c4d42520b16be642385636240f7cb8a9e 100644 (file)
--- a/drivers/staging/lustre/lustre/ptlrpc/client.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/client.c
@@ -817,7 +817,7 @@ struct ptlrpc_request_set *ptlrpc_prep_set(void)
 {
        struct ptlrpc_request_set *set;
 
-       OBD_ALLOC(set, sizeof *set);
+       OBD_ALLOC(set, sizeof(*set));
        if (!set)
                return NULL;
        atomic_set(&set->set_refcount, 1);
@@ -2690,7 +2690,7 @@ int ptlrpc_replay_req(struct ptlrpc_request *req)
 
        LASSERT (sizeof (*aa) <= sizeof (req->rq_async_args));
        aa = ptlrpc_req_async_args(req);
-       memset(aa, 0, sizeof *aa);
+       memset(aa, 0, sizeof(*aa));
 
        /* Prepare request to be resent with ptlrpcd */
        aa->praa_old_state = req->rq_send_state;

diff --git a/drivers/staging/lustre/lustre/ptlrpc/import.c b/drivers/staging/lustre/lustre/ptlrpc/import.c
index 5ca69aec72e1594ffc8235ede4447ee63c31ead8..7b96a0e88cdbb5cd1f63d0096c2d7d81d737ea05 100644 (file)
--- a/drivers/staging/lustre/lustre/ptlrpc/import.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/import.c
@@ -682,7 +682,7 @@ int ptlrpc_connect_import(struct obd_import *imp)
 
        CLASSERT(sizeof (*aa) <= sizeof (request->rq_async_args));
        aa = ptlrpc_req_async_args(request);
-       memset(aa, 0, sizeof *aa);
+       memset(aa, 0, sizeof(*aa));
 
        aa->pcaa_peer_committed = committed_before_reconnect;
        aa->pcaa_initial_connect = initial_connect;

diff --git a/drivers/staging/lustre/lustre/ptlrpc/layout.c b/drivers/staging/lustre/lustre/ptlrpc/layout.c
index 2f55ce26ccbafc6dbded4a8ad08c69af9fb4c617..d0a6e56892271c2bc00072e207f74248f84209a1 100644 (file)
--- a/drivers/staging/lustre/lustre/ptlrpc/layout.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/layout.c
@@ -1669,7 +1669,7 @@ void req_capsule_init(struct req_capsule *pill,
        if (req != NULL && pill == &req->rq_pill && req->rq_pill_init)
                return;
 
-       memset(pill, 0, sizeof *pill);
+       memset(pill, 0, sizeof(*pill));
        pill->rc_req = req;
        pill->rc_loc = location;
        req_capsule_init_area(pill);

diff --git a/drivers/staging/lustre/lustre/ptlrpc/service.c b/drivers/staging/lustre/lustre/ptlrpc/service.c
index acf75f3873d1ffb0ab9cc4258150b3a9a1b2e3ba..21de868da522ae813d798d588132f74c5d819f7b 100644 (file)
--- a/drivers/staging/lustre/lustre/ptlrpc/service.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/service.c
@@ -263,7 +263,7 @@ static struct ptlrpc_hr_service             ptlrpc_hr;
  */
 static void rs_batch_init(struct rs_batch *b)
 {
-       memset(b, 0, sizeof *b);
+       memset(b, 0, sizeof(*b));
        INIT_LIST_HEAD(&b->rsb_replies);
 }
 
@@ -1306,12 +1306,12 @@ static int ptlrpc_at_send_early_reply(struct ptlrpc_request *req)
        }
        newdl = cfs_time_current_sec() + at_get(&svcpt->scp_at_estimate);
 
-       OBD_ALLOC(reqcopy, sizeof *reqcopy);
+       OBD_ALLOC(reqcopy, sizeof(*reqcopy));
        if (reqcopy == NULL)
                return -ENOMEM;
        OBD_ALLOC_LARGE(reqmsg, req->rq_reqlen);
        if (!reqmsg) {
-               OBD_FREE(reqcopy, sizeof *reqcopy);
+               OBD_FREE(reqcopy, sizeof(*reqcopy));
                return -ENOMEM;
        }
 
@@ -1370,7 +1370,7 @@ out_put:
 out:
        sptlrpc_svc_ctx_decref(reqcopy);
        OBD_FREE_LARGE(reqmsg, req->rq_reqlen);
-       OBD_FREE(reqcopy, sizeof *reqcopy);
+       OBD_FREE(reqcopy, sizeof(*reqcopy));
        return rc;
 }