pnfs_generic_pg_check_layout(pgio);
        if (!pgio->pg_lseg) {
                pgio->pg_lseg = fl_pnfs_update_layout(pgio->pg_inode,
-                                                     req->wb_context,
+                                                     nfs_req_openctx(req),
                                                      0,
                                                      NFS4_MAX_UINT64,
                                                      IOMODE_READ,
        pnfs_generic_pg_check_layout(pgio);
        if (!pgio->pg_lseg) {
                pgio->pg_lseg = fl_pnfs_update_layout(pgio->pg_inode,
-                                                     req->wb_context,
+                                                     nfs_req_openctx(req),
                                                      0,
                                                      NFS4_MAX_UINT64,
                                                      IOMODE_RW,
 
 {
        pnfs_put_lseg(pgio->pg_lseg);
        pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode,
-                                          req->wb_context,
+                                          nfs_req_openctx(req),
                                           0,
                                           NFS4_MAX_UINT64,
                                           IOMODE_READ,
        pnfs_generic_pg_check_layout(pgio);
        if (!pgio->pg_lseg) {
                pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode,
-                                                  req->wb_context,
+                                                  nfs_req_openctx(req),
                                                   0,
                                                   NFS4_MAX_UINT64,
                                                   IOMODE_RW,
 {
        if (!pgio->pg_lseg) {
                pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode,
-                                                  req->wb_context,
+                                                  nfs_req_openctx(req),
                                                   0,
                                                   NFS4_MAX_UINT64,
                                                   IOMODE_RW,
 
 
        hdr->req = nfs_list_entry(mirror->pg_list.next);
        hdr->inode = desc->pg_inode;
-       hdr->cred = hdr->req->wb_context->cred;
+       hdr->cred = nfs_req_openctx(hdr->req)->cred;
        hdr->io_start = req_offset(hdr->req);
        hdr->good_bytes = mirror->pg_count;
        hdr->io_completion = desc->pg_io_completion;
        hdr->args.pgbase = req->wb_pgbase;
        hdr->args.pages  = hdr->page_array.pagevec;
        hdr->args.count  = count;
-       hdr->args.context = get_nfs_open_context(req->wb_context);
+       hdr->args.context = get_nfs_open_context(nfs_req_openctx(req));
        hdr->args.lock_context = req->wb_lock_context;
        hdr->args.stable  = NFS_UNSTABLE;
        switch (how & (FLUSH_STABLE | FLUSH_COND_STABLE)) {
        struct file_lock_context *flctx;
 
        if (prev) {
-               if (!nfs_match_open_context(req->wb_context, prev->wb_context))
+               if (!nfs_match_open_context(nfs_req_openctx(req), nfs_req_openctx(prev)))
                        return false;
-               flctx = d_inode(req->wb_context->dentry)->i_flctx;
+               flctx = d_inode(nfs_req_openctx(req)->dentry)->i_flctx;
                if (flctx != NULL &&
                    !(list_empty_careful(&flctx->flc_posix) &&
                      list_empty_careful(&flctx->flc_flock)) &&
 
                        rd_size = nfs_dreq_bytes_left(pgio->pg_dreq);
 
                pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode,
-                                                  req->wb_context,
+                                                  nfs_req_openctx(req),
                                                   req_offset(req),
                                                   rd_size,
                                                   IOMODE_READ,
        pnfs_generic_pg_check_range(pgio, req);
        if (pgio->pg_lseg == NULL) {
                pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode,
-                                                  req->wb_context,
+                                                  nfs_req_openctx(req),
                                                   req_offset(req),
                                                   wb_size,
                                                   IOMODE_RW,
 
 pnfs_mark_request_commit(struct nfs_page *req, struct pnfs_layout_segment *lseg,
                         struct nfs_commit_info *cinfo, u32 ds_commit_idx)
 {
-       struct inode *inode = d_inode(req->wb_context->dentry);
+       struct inode *inode = d_inode(nfs_req_openctx(req)->dentry);
        struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld;
 
        if (lseg == NULL || ld->mark_request_commit == NULL)
 static inline bool
 pnfs_clear_request_commit(struct nfs_page *req, struct nfs_commit_info *cinfo)
 {
-       struct inode *inode = d_inode(req->wb_context->dentry);
+       struct inode *inode = d_inode(nfs_req_openctx(req)->dentry);
        struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld;
 
        if (ld == NULL || ld->clear_request_commit == NULL)
 
 
 static void nfs_readpage_release(struct nfs_page *req)
 {
-       struct inode *inode = d_inode(req->wb_context->dentry);
+       struct inode *inode = d_inode(nfs_req_openctx(req)->dentry);
 
        dprintk("NFS: read done (%s/%llu %d@%lld)\n", inode->i_sb->s_id,
                (unsigned long long)NFS_FILEID(inode), req->wb_bytes,
 
 nfs_clear_request_commit(struct nfs_page *req)
 {
        if (test_bit(PG_CLEAN, &req->wb_flags)) {
-               struct inode *inode = d_inode(req->wb_context->dentry);
+               struct nfs_open_context *ctx = nfs_req_openctx(req);
+               struct inode *inode = d_inode(ctx->dentry);
                struct nfs_commit_info cinfo;
 
                nfs_init_cinfo_from_inode(&cinfo, inode);
                        return 0;
                l_ctx = req->wb_lock_context;
                do_flush = req->wb_page != page ||
-                       !nfs_match_open_context(req->wb_context, ctx);
+                       !nfs_match_open_context(nfs_req_openctx(req), ctx);
                if (l_ctx && flctx &&
                    !(list_empty_careful(&flctx->flc_posix) &&
                      list_empty_careful(&flctx->flc_flock))) {
        /* Bump the transmission count */
        req->wb_nio++;
        nfs_mark_request_dirty(req);
-       set_bit(NFS_CONTEXT_RESEND_WRITES, &req->wb_context->flags);
+       set_bit(NFS_CONTEXT_RESEND_WRITES, &nfs_req_openctx(req)->flags);
        nfs_end_page_writeback(req);
        nfs_release_request(req);
 }
                     struct nfs_commit_info *cinfo)
 {
        struct nfs_page *first = nfs_list_entry(head->next);
-       struct inode *inode = d_inode(first->wb_context->dentry);
+       struct nfs_open_context *ctx = nfs_req_openctx(first);
+       struct inode *inode = d_inode(ctx->dentry);
 
        /* Set up the RPC argument and reply structs
         * NB: take care not to mess about with data->commit et al. */
        list_splice_init(head, &data->pages);
 
        data->inode       = inode;
-       data->cred        = first->wb_context->cred;
+       data->cred        = ctx->cred;
        data->lseg        = lseg; /* reference transferred */
        /* only set lwb for pnfs commit */
        if (lseg)
        /* Note: we always request a commit of the entire inode */
        data->args.offset = 0;
        data->args.count  = 0;
-       data->context     = get_nfs_open_context(first->wb_context);
+       data->context     = get_nfs_open_context(ctx);
        data->res.fattr   = &data->fattr;
        data->res.verf    = &data->verf;
        nfs_fattr_init(&data->fattr);
                        nfs_clear_page_commit(req->wb_page);
 
                dprintk("NFS:       commit (%s/%llu %d@%lld)",
-                       req->wb_context->dentry->d_sb->s_id,
-                       (unsigned long long)NFS_FILEID(d_inode(req->wb_context->dentry)),
+                       nfs_req_openctx(req)->dentry->d_sb->s_id,
+                       (unsigned long long)NFS_FILEID(d_inode(nfs_req_openctx(req)->dentry)),
                        req->wb_bytes,
                        (long long)req_offset(req));
                if (status < 0) {
                /* We have a mismatch. Write the page again */
                dprintk_cont(" mismatch\n");
                nfs_mark_request_dirty(req);
-               set_bit(NFS_CONTEXT_RESEND_WRITES, &req->wb_context->flags);
+               set_bit(NFS_CONTEXT_RESEND_WRITES, &nfs_req_openctx(req)->flags);
        next:
                nfs_unlock_and_release_request(req);
                /* Latency breaker */
 
        return (((loff_t)req->wb_index) << PAGE_SHIFT) + req->wb_offset;
 }
 
+static inline struct nfs_open_context *
+nfs_req_openctx(struct nfs_page *req)
+{
+       return req->wb_context;
+}
+
 #endif /* _LINUX_NFS_PAGE_H */