Merge branch 'irq-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...

[linux.git] / fs / nfs / write.c

diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index f3ebabaa291dccbf7fda8802bcee89c7fd3600da..bc5bb932341290c217ad8c212e38c97640db35d9 100644 (file)
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -244,6 +244,12 @@ static void nfs_set_pageerror(struct address_space *mapping)
        nfs_zap_mapping(mapping->host, mapping);
 }
 
+static void nfs_mapping_set_error(struct page *page, int error)
+{
+       SetPageError(page);
+       mapping_set_error(page_file_mapping(page), error);
+}
+
 /*
  * nfs_page_group_search_locked
  * @head - head request of page group
@@ -582,11 +588,10 @@ nfs_lock_and_join_requests(struct page *page)
        return ERR_PTR(ret);
 }
 
-static void nfs_write_error_remove_page(struct nfs_page *req)
+static void nfs_write_error(struct nfs_page *req, int error)
 {
+       nfs_mapping_set_error(req->wb_page, error);
        nfs_end_page_writeback(req);
-       generic_error_remove_page(page_file_mapping(req->wb_page),
-                                 req->wb_page);
        nfs_release_request(req);
 }
 
@@ -609,6 +614,7 @@ nfs_error_is_fatal_on_server(int err)
 static int nfs_page_async_flush(struct nfs_pageio_descriptor *pgio,
                                struct page *page)
 {
+       struct address_space *mapping;
        struct nfs_page *req;
        int ret = 0;
 
@@ -622,19 +628,19 @@ static int nfs_page_async_flush(struct nfs_pageio_descriptor *pgio,
        nfs_set_page_writeback(page);
        WARN_ON_ONCE(test_bit(PG_CLEAN, &req->wb_flags));
 
-       ret = req->wb_context->error;
        /* If there is a fatal error that covers this write, just exit */
-       if (nfs_error_is_fatal_on_server(ret))
+       ret = 0;
+       mapping = page_file_mapping(page);
+       if (test_bit(AS_ENOSPC, &mapping->flags) ||
+           test_bit(AS_EIO, &mapping->flags))
                goto out_launder;
 
-       ret = 0;
        if (!nfs_pageio_add_request(pgio, req)) {
                ret = pgio->pg_error;
                /*
                 * Remove the problematic req upon fatal errors on the server
                 */
                if (nfs_error_is_fatal(ret)) {
-                       nfs_context_set_write_error(req->wb_context, ret);
                        if (nfs_error_is_fatal_on_server(ret))
                                goto out_launder;
                } else
@@ -646,8 +652,8 @@ static int nfs_page_async_flush(struct nfs_pageio_descriptor *pgio,
 out:
        return ret;
 out_launder:
-       nfs_write_error_remove_page(req);
-       return ret;
+       nfs_write_error(req, ret);
+       return 0;
 }
 
 static int nfs_do_writepage(struct page *page, struct writeback_control *wbc,
@@ -958,7 +964,8 @@ static void
 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);
@@ -999,10 +1006,12 @@ static void nfs_write_completion(struct nfs_pgio_header *hdr)
                if (test_bit(NFS_IOHDR_ERROR, &hdr->flags) &&
                    (hdr->good_bytes < bytes)) {
                        nfs_set_pageerror(page_file_mapping(req->wb_page));
-                       nfs_context_set_write_error(req->wb_context, hdr->error);
+                       nfs_mapping_set_error(req->wb_page, hdr->error);
                        goto remove_req;
                }
                if (nfs_write_need_commit(hdr)) {
+                       /* Reset wb_nio, since the write was successful. */
+                       req->wb_nio = 0;
                        memcpy(&req->wb_verf, &hdr->verf.verifier, sizeof(req->wb_verf));
                        nfs_mark_request_commit(req, hdr->lseg, &cinfo,
                                hdr->pgio_mirror_idx);
@@ -1136,6 +1145,7 @@ static struct nfs_page *nfs_try_to_update_request(struct inode *inode,
                req->wb_bytes = end - req->wb_offset;
        else
                req->wb_bytes = rqend - req->wb_offset;
+       req->wb_nio = 0;
        return req;
 out_flushme:
        /*
@@ -1165,7 +1175,7 @@ static struct nfs_page * nfs_setup_write_request(struct nfs_open_context* ctx,
        req = nfs_try_to_update_request(inode, page, offset, bytes);
        if (req != NULL)
                goto out;
-       req = nfs_create_request(ctx, page, NULL, offset, bytes);
+       req = nfs_create_request(ctx, page, offset, bytes);
        if (IS_ERR(req))
                goto out;
        nfs_inode_add_request(inode, req);
@@ -1210,7 +1220,7 @@ int nfs_flush_incompatible(struct file *file, struct page *page)
                        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))) {
@@ -1410,8 +1420,10 @@ static void nfs_initiate_write(struct nfs_pgio_header *hdr,
  */
 static void nfs_redirty_request(struct nfs_page *req)
 {
+       /* 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);
 }
@@ -1423,14 +1435,10 @@ static void nfs_async_write_error(struct list_head *head, int error)
        while (!list_empty(head)) {
                req = nfs_list_entry(head->next);
                nfs_list_remove_request(req);
-               if (nfs_error_is_fatal(error)) {
-                       nfs_context_set_write_error(req->wb_context, error);
-                       if (nfs_error_is_fatal_on_server(error)) {
-                               nfs_write_error_remove_page(req);
-                               continue;
-                       }
-               }
-               nfs_redirty_request(req);
+               if (nfs_error_is_fatal(error))
+                       nfs_write_error(req, error);
+               else
+                       nfs_redirty_request(req);
        }
 }
 
@@ -1735,7 +1743,8 @@ void nfs_init_commit(struct nfs_commit_data *data,
                     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. */
@@ -1743,7 +1752,7 @@ void nfs_init_commit(struct nfs_commit_data *data,
        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)
@@ -1756,7 +1765,7 @@ void nfs_init_commit(struct nfs_commit_data *data,
        /* 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);
@@ -1839,14 +1848,15 @@ static void nfs_commit_release_pages(struct nfs_commit_data *data)
                        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) {
-                       nfs_context_set_write_error(req->wb_context, status);
-                       if (req->wb_page)
+                       if (req->wb_page) {
+                               nfs_mapping_set_error(req->wb_page, status);
                                nfs_inode_remove_request(req);
+                       }
                        dprintk_cont(", error = %d\n", status);
                        goto next;
                }
@@ -1863,7 +1873,7 @@ static void nfs_commit_release_pages(struct nfs_commit_data *data)
                /* 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 */