spin_lock(&lmv->lmv_lock);
        for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
                tgt = lmv->tgts[i];
-               if (tgt == NULL || tgt->ltd_exp == NULL)
+               if (!tgt || !tgt->ltd_exp)
                        continue;
 
                CDEBUG(D_INFO, "Target idx %d is %s conn %#llx\n", i,
        }
 
        obd = class_exp2obd(tgt->ltd_exp);
-       if (obd == NULL) {
+       if (!obd) {
                rc = -ENOTCONN;
                goto out_lmv_lock;
        }
 
        for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
                tgt = lmv->tgts[i];
-               if (tgt == NULL || tgt->ltd_exp == NULL || tgt->ltd_active == 0)
+               if (!tgt || !tgt->ltd_exp || tgt->ltd_active == 0)
                        continue;
 
                obd_set_info_async(NULL, tgt->ltd_exp, sizeof(KEY_INTERMDS),
                return 0;
 
        for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
-               if (lmv->tgts[i] == NULL ||
-                   lmv->tgts[i]->ltd_exp == NULL ||
+               if (!lmv->tgts[i] || !lmv->tgts[i]->ltd_exp ||
                    lmv->tgts[i]->ltd_active == 0) {
                        CWARN("%s: NULL export for %d\n", obd->obd_name, i);
                        continue;
 
 static void lmv_del_target(struct lmv_obd *lmv, int index)
 {
-       if (lmv->tgts[index] == NULL)
+       if (!lmv->tgts[index])
                return;
 
        kfree(lmv->tgts[index]);
                }
        }
 
-       if ((index < lmv->tgts_size) && (lmv->tgts[index] != NULL)) {
+       if ((index < lmv->tgts_size) && lmv->tgts[index]) {
                tgt = lmv->tgts[index];
                CERROR("%s: UUID %s already assigned at LOV target index %d: rc = %d\n",
                       obd->obd_name,
                while (newsize < index + 1)
                        newsize <<= 1;
                newtgts = kcalloc(newsize, sizeof(*newtgts), GFP_NOFS);
-               if (newtgts == NULL) {
+               if (!newtgts) {
                        lmv_init_unlock(lmv);
                        return -ENOMEM;
                }
        CDEBUG(D_CONFIG, "Time to connect %s to %s\n",
               lmv->cluuid.uuid, obd->obd_name);
 
-       LASSERT(lmv->tgts != NULL);
-
        for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
                tgt = lmv->tgts[i];
-               if (tgt == NULL)
+               if (!tgt)
                        continue;
                rc = lmv_connect_mdc(obd, tgt);
                if (rc)
                int rc2;
 
                tgt = lmv->tgts[i];
-               if (tgt == NULL)
+               if (!tgt)
                        continue;
                tgt->ltd_active = 0;
                if (tgt->ltd_exp) {
        struct obd_device      *mdc_obd;
        int                  rc;
 
-       LASSERT(tgt != NULL);
-       LASSERT(obd != NULL);
-
        mdc_obd = class_exp2obd(tgt->ltd_exp);
 
        if (mdc_obd) {
                goto out_local;
 
        for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
-               if (lmv->tgts[i] == NULL || lmv->tgts[i]->ltd_exp == NULL)
+               if (!lmv->tgts[i] || !lmv->tgts[i]->ltd_exp)
                        continue;
 
                lmv_disconnect_mdc(obd, lmv->tgts[i]);
 
        /* If remote_gf != NULL, it means just building the
         * path on the remote MDT, copy this path segment to gf */
-       if (remote_gf != NULL) {
+       if (remote_gf) {
                struct getinfo_fid2path *ori_gf;
                char *ptr;
 
                goto out_fid2path;
 
        /* sigh, has to go to another MDT to do path building further */
-       if (remote_gf == NULL) {
+       if (!remote_gf) {
                remote_gf_size = sizeof(*remote_gf) + PATH_MAX;
                remote_gf = kzalloc(remote_gf_size, GFP_NOFS);
                if (!remote_gf) {
                if (index >= count)
                        return -ENODEV;
 
-               if (lmv->tgts[index] == NULL ||
-                   lmv->tgts[index]->ltd_active == 0)
+               if (!lmv->tgts[index] || lmv->tgts[index]->ltd_active == 0)
                        return -ENODATA;
 
                mdc_obd = class_exp2obd(lmv->tgts[index]->ltd_exp);
                                return -EINVAL;
 
                        tgt = lmv->tgts[qctl->qc_idx];
-                       if (tgt == NULL || tgt->ltd_exp == NULL)
+                       if (!tgt || !tgt->ltd_exp)
                                return -EINVAL;
                } else if (qctl->qc_valid == QC_UUID) {
                        for (i = 0; i < count; i++) {
                                tgt = lmv->tgts[i];
-                               if (tgt == NULL)
+                               if (!tgt)
                                        continue;
                                if (!obd_uuid_equals(&tgt->ltd_uuid,
                                                     &qctl->obd_uuid))
                                        continue;
 
-                               if (tgt->ltd_exp == NULL)
+                               if (!tgt->ltd_exp)
                                        return -EINVAL;
 
                                break;
                if (icc->icc_mdtindex >= count)
                        return -ENODEV;
 
-               if (lmv->tgts[icc->icc_mdtindex] == NULL ||
-                   lmv->tgts[icc->icc_mdtindex]->ltd_exp == NULL ||
+               if (!lmv->tgts[icc->icc_mdtindex] ||
+                   !lmv->tgts[icc->icc_mdtindex]->ltd_exp ||
                    lmv->tgts[icc->icc_mdtindex]->ltd_active == 0)
                        return -ENODEV;
                rc = obd_iocontrol(cmd, lmv->tgts[icc->icc_mdtindex]->ltd_exp,
                break;
        }
        case LL_IOC_GET_CONNECT_FLAGS: {
-               if (lmv->tgts[0] == NULL)
+               if (!lmv->tgts[0])
                        return -ENODATA;
                rc = obd_iocontrol(cmd, lmv->tgts[0]->ltd_exp, len, karg, uarg);
                break;
 
                tgt = lmv_find_target(lmv, &op_data->op_fid1);
                if (IS_ERR(tgt))
-                               return PTR_ERR(tgt);
+                       return PTR_ERR(tgt);
 
-               if (tgt->ltd_exp == NULL)
-                               return -EINVAL;
+               if (!tgt->ltd_exp)
+                       return -EINVAL;
 
                rc = obd_iocontrol(cmd, tgt->ltd_exp, len, karg, uarg);
                break;
                                                  hur_user_item[nr])
                                         + hur->hur_request.hr_data_len;
                                req = libcfs_kvzalloc(reqlen, GFP_NOFS);
-                               if (req == NULL)
+                               if (!req)
                                        return -ENOMEM;
 
                                lmv_hsm_req_build(lmv, hur, lmv->tgts[i], req);
                if (IS_ERR(tgt2))
                        return PTR_ERR(tgt2);
 
-               if ((tgt1->ltd_exp == NULL) || (tgt2->ltd_exp == NULL))
+               if (!tgt1->ltd_exp || !tgt2->ltd_exp)
                        return -EINVAL;
 
                /* only files on same MDT can have their layouts swapped */
                        struct obd_device *mdc_obd;
                        int err;
 
-                       if (lmv->tgts[i] == NULL ||
-                           lmv->tgts[i]->ltd_exp == NULL)
+                       if (!lmv->tgts[i] || !lmv->tgts[i]->ltd_exp)
                                continue;
                        /* ll_umount_begin() sets force flag but for lmv, not
                         * mdc. Let's pass it through */
 {
        struct lmv_obd    *lmv = &obd->u.lmv;
 
-       LASSERT(mds != NULL);
+       LASSERT(mds);
 
        if (lmv->desc.ld_tgt_count == 1) {
                *mds = 0;
         */
        mutex_lock(&tgt->ltd_fid_mutex);
 
-       if (tgt->ltd_active == 0 || tgt->ltd_exp == NULL) {
+       if (tgt->ltd_active == 0 || !tgt->ltd_exp) {
                rc = -ENODEV;
                goto out;
        }
        u32                    mds = 0;
        int                 rc;
 
-       LASSERT(op_data != NULL);
-       LASSERT(fid != NULL);
+       LASSERT(op_data);
+       LASSERT(fid);
 
        rc = lmv_placement_policy(obd, op_data, &mds);
        if (rc) {
        }
 
        lmv->tgts = kcalloc(32, sizeof(*lmv->tgts), GFP_NOFS);
-       if (lmv->tgts == NULL)
+       if (!lmv->tgts)
                return -ENOMEM;
        lmv->tgts_size = 32;
 
        struct lmv_obd   *lmv = &obd->u.lmv;
 
        fld_client_fini(&lmv->lmv_fld);
-       if (lmv->tgts != NULL) {
+       if (lmv->tgts) {
                int i;
 
                for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
-                       if (lmv->tgts[i] == NULL)
+                       if (!lmv->tgts[i])
                                continue;
                        lmv_del_target(lmv, i);
                }
                return -ENOMEM;
 
        for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
-               if (lmv->tgts[i] == NULL || lmv->tgts[i]->ltd_exp == NULL)
+               if (!lmv->tgts[i] || !lmv->tgts[i]->ltd_exp)
                        continue;
 
                rc = obd_statfs(env, lmv->tgts[i]->ltd_exp, temp,
         * space of MDT storing inode.
         */
        for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
-               if (lmv->tgts[i] == NULL || lmv->tgts[i]->ltd_exp == NULL)
+               if (!lmv->tgts[i] || !lmv->tgts[i]->ltd_exp)
                        continue;
                md_null_inode(lmv->tgts[i]->ltd_exp, fid);
        }
         * space of MDT storing inode.
         */
        for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
-               if (lmv->tgts[i] == NULL || lmv->tgts[i]->ltd_exp == NULL)
+               if (!lmv->tgts[i] || !lmv->tgts[i]->ltd_exp)
                        continue;
                rc = md_find_cbdata(lmv->tgts[i]->ltd_exp, fid, it, data);
                if (rc)
                       cap_effective, rdev, request);
 
        if (rc == 0) {
-               if (*request == NULL)
+               if (!*request)
                        return rc;
                CDEBUG(D_INODE, "Created - "DFID"\n", PFID(&op_data->op_fid2));
        }
        int                      pmode;
 
        body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
-       LASSERT(body != NULL);
 
        if (!(body->valid & OBD_MD_MDS))
                return 0;
 
        body = req_capsule_server_get(&(*request)->rq_pill,
                                      &RMF_MDT_BODY);
-       LASSERT(body != NULL);
 
        if (body->valid & OBD_MD_MDS) {
                struct lu_fid rid = body->fid1;
 
                while (--nlupgs > 0) {
                        ent = lu_dirent_start(dp);
-                       for (end_dirent = ent; ent != NULL;
+                       for (end_dirent = ent; ent;
                             end_dirent = ent, ent = lu_dirent_next(ent))
                                ;
 
                return rc;
 
        body = req_capsule_server_get(&(*request)->rq_pill, &RMF_MDT_BODY);
-       if (body == NULL)
+       if (!body)
                return -EPROTO;
 
        /* Not cross-ref case, just get out of here. */
        int                   rc = 0;
 
        obd = class_exp2obd(exp);
-       if (obd == NULL) {
+       if (!obd) {
                CDEBUG(D_IOCTL, "Invalid client cookie %#llx\n",
                       exp->exp_handle.h_cookie);
                return -EINVAL;
                        /*
                         * All tgts should be connected when this gets called.
                         */
-                       if (tgt == NULL || tgt->ltd_exp == NULL)
+                       if (!tgt || !tgt->ltd_exp)
                                continue;
 
                        if (!obd_get_info(env, tgt->ltd_exp, keylen, key,
        int rc = 0;
 
        obd = class_exp2obd(exp);
-       if (obd == NULL) {
+       if (!obd) {
                CDEBUG(D_IOCTL, "Invalid client cookie %#llx\n",
                       exp->exp_handle.h_cookie);
                return -EINVAL;
                for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
                        tgt = lmv->tgts[i];
 
-                       if (tgt == NULL || tgt->ltd_exp == NULL)
+                       if (!tgt || !tgt->ltd_exp)
                                continue;
 
                        err = obd_set_info_async(env, tgt->ltd_exp,
                return 0;
        }
 
-       if (*lmmp == NULL) {
+       if (!*lmmp) {
                *lmmp = libcfs_kvzalloc(mea_size, GFP_NOFS);
-               if (*lmmp == NULL)
+               if (!*lmmp)
                        return -ENOMEM;
        }
 
        __u32                  magic;
 
        mea_size = lmv_get_easize(lmv);
-       if (lsmp == NULL)
+       if (!lsmp)
                return mea_size;
 
-       if (*lsmp != NULL && lmm == NULL) {
+       if (*lsmp && !lmm) {
                kvfree(*tmea);
                *lsmp = NULL;
                return 0;
        LASSERT(mea_size == lmm_size);
 
        *tmea = libcfs_kvzalloc(mea_size, GFP_NOFS);
-       if (*tmea == NULL)
+       if (!*tmea)
                return -ENOMEM;
 
        if (!lmm)
        int                   err;
        int                   i;
 
-       LASSERT(fid != NULL);
+       LASSERT(fid);
 
        for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
-               if (lmv->tgts[i] == NULL || lmv->tgts[i]->ltd_exp == NULL ||
+               if (!lmv->tgts[i] || !lmv->tgts[i]->ltd_exp ||
                    lmv->tgts[i]->ltd_active == 0)
                        continue;
 
         * one fid was created in.
         */
        for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
-               if (lmv->tgts[i] == NULL ||
-                   lmv->tgts[i]->ltd_exp == NULL ||
+               if (!lmv->tgts[i] || !lmv->tgts[i]->ltd_exp ||
                    lmv->tgts[i]->ltd_active == 0)
                        continue;
 
 
                tgt = lmv->tgts[i];
 
-               if (tgt == NULL || tgt->ltd_exp == NULL || tgt->ltd_active == 0)
+               if (!tgt || !tgt->ltd_exp || tgt->ltd_active == 0)
                        continue;
                if (!tgt->ltd_active) {
                        CDEBUG(D_HA, "mdt %d is inactive.\n", i);
                int err;
 
                tgt = lmv->tgts[i];
-               if (tgt == NULL || tgt->ltd_exp == NULL || !tgt->ltd_active) {
+               if (!tgt || !tgt->ltd_exp || !tgt->ltd_active) {
                        CERROR("lmv idx %d inactive\n", i);
                        return -EIO;
                }