int             it_lock_mode;
        int             it_remote_lock_mode;
        __u64      it_remote_lock_handle;
-       void       *it_data;
+       struct ptlrpc_request *it_request;
        unsigned int    it_lock_set:1;
 };
 
 
        ll_intent_drop_lock(it);
        /* We are still holding extra reference on a request, need to free it */
        if (it_disposition(it, DISP_ENQ_OPEN_REF))
-               ptlrpc_req_finished(it->it_data); /* ll_file_open */
+               ptlrpc_req_finished(it->it_request); /* ll_file_open */
 
        if (it_disposition(it, DISP_ENQ_CREATE_REF)) /* create rec */
-               ptlrpc_req_finished(it->it_data);
+               ptlrpc_req_finished(it->it_request);
 
        it->it_disposition = 0;
-       it->it_data = NULL;
+       it->it_request = NULL;
 }
 
 void ll_invalidate_aliases(struct inode *inode)
 
 
                ll_finish_md_op_data(op_data);
 
-               request = (struct ptlrpc_request *)it.it_data;
+               request = (struct ptlrpc_request *)it.it_request;
                if (request)
                        ptlrpc_req_finished(request);
                if (rc < 0) {
 
 static int ll_och_fill(struct obd_export *md_exp, struct lookup_intent *it,
                       struct obd_client_handle *och)
 {
-       struct ptlrpc_request *req = it->it_data;
        struct mdt_body *body;
 
-       body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
+       body = req_capsule_server_get(&it->it_request->rq_pill, &RMF_MDT_BODY);
        och->och_fh = body->handle;
        och->och_fid = body->fid1;
        och->och_lease_handle.cookie = it->it_lock_handle;
        LASSERT(fd);
 
        if (och) {
-               struct ptlrpc_request *req = it->it_data;
                struct mdt_body *body;
                int rc;
 
                if (rc != 0)
                        return rc;
 
-               body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
+               body = req_capsule_server_get(&it->it_request->rq_pill,
+                                             &RMF_MDT_BODY);
                ll_ioepoch_open(lli, body->ioepoch);
        }
 
        }
 
        if (it && it_disposition(it, DISP_ENQ_OPEN_REF)) {
-               ptlrpc_req_finished(it->it_data);
+               ptlrpc_req_finished(it->it_request);
                it_clear_disposition(it, DISP_ENQ_OPEN_REF);
        }
 
 out:
        return rc;
 out_req_free:
-       ptlrpc_req_finished((struct ptlrpc_request *)oit.it_data);
+       ptlrpc_req_finished((struct ptlrpc_request *)oit.it_request);
        goto out;
 }
 
 out:
        /* this one is in place of ll_file_open */
        if (it_disposition(it, DISP_ENQ_OPEN_REF)) {
-               ptlrpc_req_finished(it->it_data);
+               ptlrpc_req_finished(it->it_request);
                it_clear_disposition(it, DISP_ENQ_OPEN_REF);
        }
        return rc;
 
        rc = md_enqueue(sbi->ll_md_exp, &einfo, &it, op_data, &lockh,
                        NULL, 0, NULL, 0);
-       ptlrpc_req_finished(it.it_data);
-       it.it_data = NULL;
+       ptlrpc_req_finished(it.it_request);
+       it.it_request = NULL;
 
        ll_finish_md_op_data(op_data);
 
 
        LASSERT(it && it->it_disposition);
 
        LASSERT(it_disposition(it, DISP_ENQ_CREATE_REF));
-       request = it->it_data;
+       request = it->it_request;
        it_clear_disposition(it, DISP_ENQ_CREATE_REF);
        rc = ll_prep_inode(&inode, request, dir->i_sb, it);
        if (rc) {
 
                return rc;
        }
 
-       *req = (struct ptlrpc_request *)oit->it_data;
+       *req = oit->it_request;
 out:
        down_write(&lli->lli_xattrs_list_rwsem);
        mutex_unlock(&lli->lli_xattrs_enq_lock);
 
        if (pmode) {
                plock.cookie = it->it_lock_handle;
                it->it_lock_mode = 0;
-               it->it_data = NULL;
+               it->it_request = NULL;
        }
 
        LASSERT(fid_is_sane(&body->fid1));
 
                   struct lustre_handle *lockh, void *lmm, int lmmsize,
                   __u64 extra_lock_flags)
 {
-       struct ptlrpc_request      *req = it->it_data;
+       struct ptlrpc_request      *req = it->it_request;
        struct obd_device         *obd = exp->exp_obd;
        struct lmv_obd       *lmv = &obd->u.lmv;
        struct lustre_handle    plock;
        LASSERT(pmode != 0);
        memcpy(&plock, lockh, sizeof(plock));
        it->it_lock_mode = 0;
-       it->it_data = NULL;
+       it->it_request = NULL;
        fid1 = body->fid1;
 
        ptlrpc_req_finished(req);
 
        it->it_status = (int)lockrep->lock_policy_res2;
        it->it_lock_mode = einfo->ei_mode;
        it->it_lock_handle = lockh->cookie;
-       it->it_data = req;
+       it->it_request = req;
 
        /* Technically speaking rq_transno must already be zero if
         * it_status is in error, so the check is a bit redundant
 
                it->it_lock_handle = 0;
                it->it_lock_mode = 0;
-               it->it_data = NULL;
+               it->it_request = NULL;
        }
 
        return rc;
        if (rc < 0)
                return rc;
 
-       *reqp = it->it_data;
+       *reqp = it->it_request;
        rc = mdc_finish_intent_lock(exp, *reqp, op_data, it, &lockh);
        return rc;
 }
 
        struct md_open_data   *mod;
        struct mdt_rec_create *rec;
        struct mdt_body       *body;
-       struct ptlrpc_request *open_req = it->it_data;
+       struct ptlrpc_request *open_req = it->it_request;
        struct obd_import     *imp = open_req->rq_import;
 
        if (!open_req->rq_replay)