1 files changed, 185 insertions, 84 deletions

diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 659ce1b92c44..4c144c1f50eb 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -1842,24 +1842,30 @@ struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
         return NULL;
 }
 
-struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
-                                        bool fsuid_only)
+/* Return -EBADF if no handle is found and general rc otherwise */
+int
+cifs_get_writable_file(struct cifsInodeInfo *cifs_inode, bool fsuid_only,
+                       struct cifsFileInfo **ret_file)
 {
         struct cifsFileInfo *open_file, *inv_file = NULL;
         struct cifs_sb_info *cifs_sb;
         struct cifs_tcon *tcon;
         bool any_available = false;
-        int rc;
+        int rc = -EBADF;
         unsigned int refind = 0;
 
-        /* Having a null inode here (because mapping->host was set to zero by
-        the VFS or MM) should not happen but we had reports of on oops (due to
-        it being zero) during stress testcases so we need to check for it */
+        *ret_file = NULL;
+
+        /*
+         * Having a null inode here (because mapping->host was set to zero by
+         * the VFS or MM) should not happen but we had reports of on oops (due
+         * to it being zero) during stress testcases so we need to check for it
+         */
 
         if (cifs_inode == NULL) {
                 cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
                 dump_stack();
-                return NULL;
+                return rc;
         }
 
         cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
@@ -1873,7 +1879,7 @@ struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
 refind_writable:
         if (refind > MAX_REOPEN_ATT) {
                 spin_unlock(&tcon->open_file_lock);
-                return NULL;
+                return rc;
         }
         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
                 if (!any_available && open_file->pid != current->tgid)
@@ -1885,7 +1891,8 @@ refind_writable:
                                 /* found a good writable file */
                                 cifsFileInfo_get(open_file);
                                 spin_unlock(&tcon->open_file_lock);
-                                return open_file;
+                                *ret_file = open_file;
+                                return 0;
                         } else {
                                 if (!inv_file)
                                         inv_file = open_file;
@@ -1907,22 +1914,35 @@ refind_writable:
 
         if (inv_file) {
                 rc = cifs_reopen_file(inv_file, false);
-                if (!rc)
-                        return inv_file;
-                else {
-                        spin_lock(&tcon->open_file_lock);
-                        list_move_tail(&inv_file->flist,
-                                        &cifs_inode->openFileList);
-                        spin_unlock(&tcon->open_file_lock);
-                        cifsFileInfo_put(inv_file);
-                        ++refind;
-                        inv_file = NULL;
-                        spin_lock(&tcon->open_file_lock);
-                        goto refind_writable;
+                if (!rc) {
+                        *ret_file = inv_file;
+                        return 0;
                 }
+
+                spin_lock(&tcon->open_file_lock);
+                list_move_tail(&inv_file->flist, &cifs_inode->openFileList);
+                spin_unlock(&tcon->open_file_lock);
+                cifsFileInfo_put(inv_file);
+                ++refind;
+                inv_file = NULL;
+                spin_lock(&tcon->open_file_lock);
+                goto refind_writable;
         }
 
-        return NULL;
+        return rc;
+}
+
+struct cifsFileInfo *
+find_writable_file(struct cifsInodeInfo *cifs_inode, bool fsuid_only)
+{
+        struct cifsFileInfo *cfile;
+        int rc;
+
+        rc = cifs_get_writable_file(cifs_inode, fsuid_only, &cfile);
+        if (rc)
+                cifs_dbg(FYI, "couldn't find writable handle rc=%d", rc);
+
+        return cfile;
 }
 
 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
@@ -1959,8 +1979,8 @@ static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
         if (mapping->host->i_size - offset < (loff_t)to)
                 to = (unsigned)(mapping->host->i_size - offset);
 
-        open_file = find_writable_file(CIFS_I(mapping->host), false);
-        if (open_file) {
+        rc = cifs_get_writable_file(CIFS_I(mapping->host), false, &open_file);
+        if (!rc) {
                 bytes_written = cifs_write(open_file, open_file->pid,
                                            write_data, to - from, &offset);
                 cifsFileInfo_put(open_file);
@@ -1970,9 +1990,12 @@ static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
                         rc = 0;
                 else if (bytes_written < 0)
                         rc = bytes_written;
+                else
+                        rc = -EFAULT;
         } else {
-                cifs_dbg(FYI, "No writeable filehandles for inode\n");
-                rc = -EIO;
+                cifs_dbg(FYI, "No writable handle for write page rc=%d\n", rc);
+                if (!is_retryable_error(rc))
+                        rc = -EIO;
         }
 
         kunmap(page);
@@ -2079,9 +2102,9 @@ static int
 wdata_send_pages(struct cifs_writedata *wdata, unsigned int nr_pages,
                  struct address_space *mapping, struct writeback_control *wbc)
 {
-        int rc = 0;
-        struct TCP_Server_Info *server;
-        unsigned int i;
+        int rc;
+        struct TCP_Server_Info *server =
+                                tlink_tcon(wdata->cfile->tlink)->ses->server;
 
         wdata->sync_mode = wbc->sync_mode;
         wdata->nr_pages = nr_pages;
@@ -2091,21 +2114,16 @@ wdata_send_pages(struct cifs_writedata *wdata, unsigned int nr_pages,
                         page_offset(wdata->pages[nr_pages - 1]),
                         (loff_t)PAGE_SIZE);
         wdata->bytes = ((nr_pages - 1) * PAGE_SIZE) + wdata->tailsz;
+        wdata->pid = wdata->cfile->pid;
 
-        if (wdata->cfile != NULL)
-                cifsFileInfo_put(wdata->cfile);
-        wdata->cfile = find_writable_file(CIFS_I(mapping->host), false);
-        if (!wdata->cfile) {
-                cifs_dbg(VFS, "No writable handles for inode\n");
-                rc = -EBADF;
-        } else {
-                wdata->pid = wdata->cfile->pid;
-                server = tlink_tcon(wdata->cfile->tlink)->ses->server;
-                rc = server->ops->async_writev(wdata, cifs_writedata_release);
-        }
+        rc = adjust_credits(server, &wdata->credits, wdata->bytes);
+        if (rc)
+                return rc;
 
-        for (i = 0; i < nr_pages; ++i)
-                unlock_page(wdata->pages[i]);
+        if (wdata->cfile->invalidHandle)
+                rc = -EAGAIN;
+        else
+                rc = server->ops->async_writev(wdata, cifs_writedata_release);
 
         return rc;
 }
@@ -2113,11 +2131,13 @@ wdata_send_pages(struct cifs_writedata *wdata, unsigned int nr_pages,
 static int cifs_writepages(struct address_space *mapping,
                            struct writeback_control *wbc)
 {
-        struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
+        struct inode *inode = mapping->host;
+        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
         struct TCP_Server_Info *server;
         bool done = false, scanned = false, range_whole = false;
         pgoff_t end, index;
         struct cifs_writedata *wdata;
+        struct cifsFileInfo *cfile = NULL;
         int rc = 0;
         int saved_rc = 0;
         unsigned int xid;
@@ -2143,11 +2163,23 @@ static int cifs_writepages(struct address_space *mapping,
         server = cifs_sb_master_tcon(cifs_sb)->ses->server;
 retry:
         while (!done && index <= end) {
-                unsigned int i, nr_pages, found_pages, wsize, credits;
+                unsigned int i, nr_pages, found_pages, wsize;
                 pgoff_t next = 0, tofind, saved_index = index;
+                struct cifs_credits credits_on_stack;
+                struct cifs_credits *credits = &credits_on_stack;
+                int get_file_rc = 0;
+
+                if (cfile)
+                        cifsFileInfo_put(cfile);
+
+                rc = cifs_get_writable_file(CIFS_I(inode), false, &cfile);
+
+                /* in case of an error store it to return later */
+                if (rc)
+                        get_file_rc = rc;
 
                 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
-                                                   &wsize, &credits);
+                                                   &wsize, credits);
                 if (rc != 0) {
                         done = true;
                         break;
@@ -2180,13 +2212,26 @@ retry:
                         continue;
                 }
 
-                wdata->credits = credits;
+                wdata->credits = credits_on_stack;
+                wdata->cfile = cfile;
+                cfile = NULL;
 
-                rc = wdata_send_pages(wdata, nr_pages, mapping, wbc);
+                if (!wdata->cfile) {
+                        cifs_dbg(VFS, "No writable handle in writepages rc=%d\n",
+                                 get_file_rc);
+                        if (is_retryable_error(get_file_rc))
+                                rc = get_file_rc;
+                        else
+                                rc = -EBADF;
+                } else
+                        rc = wdata_send_pages(wdata, nr_pages, mapping, wbc);
+
+                for (i = 0; i < nr_pages; ++i)
+                        unlock_page(wdata->pages[i]);
 
                 /* send failure -- clean up the mess */
                 if (rc != 0) {
-                        add_credits_and_wake_if(server, wdata->credits, 0);
+                        add_credits_and_wake_if(server, &wdata->credits, 0);
                         for (i = 0; i < nr_pages; ++i) {
                                 if (is_retryable_error(rc))
                                         redirty_page_for_writepage(wbc,
@@ -2238,6 +2283,8 @@ retry:
         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
                 mapping->writeback_index = index;
 
+        if (cfile)
+                cifsFileInfo_put(cfile);
         free_xid(xid);
         return rc;
 }
@@ -2567,7 +2614,8 @@ static int
 cifs_resend_wdata(struct cifs_writedata *wdata, struct list_head *wdata_list,
         struct cifs_aio_ctx *ctx)
 {
-        unsigned int wsize, credits;
+        unsigned int wsize;
+        struct cifs_credits credits;
         int rc;
         struct TCP_Server_Info *server =
                 tlink_tcon(wdata->cfile->tlink)->ses->server;
@@ -2577,18 +2625,19 @@ cifs_resend_wdata(struct cifs_writedata *wdata, struct list_head *wdata_list,
          * Note: we are attempting to resend the whole wdata not in segments
          */
         do {
-                rc = server->ops->wait_mtu_credits(
-                        server, wdata->bytes, &wsize, &credits);
+                rc = server->ops->wait_mtu_credits(server, wdata->bytes, &wsize,
+                                                   &credits);
 
                 if (rc)
                         goto out;
 
                 if (wsize < wdata->bytes) {
-                        add_credits_and_wake_if(server, credits, 0);
+                        add_credits_and_wake_if(server, &credits, 0);
                         msleep(1000);
                 }
         } while (wsize < wdata->bytes);
 
+        wdata->credits = credits;
         rc = -EAGAIN;
         while (rc == -EAGAIN) {
                 rc = 0;
@@ -2604,7 +2653,7 @@ cifs_resend_wdata(struct cifs_writedata *wdata, struct list_head *wdata_list,
                 return 0;
         }
 
-        add_credits_and_wake_if(server, wdata->credits, 0);
+        add_credits_and_wake_if(server, &wdata->credits, 0);
 out:
         kref_put(&wdata->refcount, cifs_uncached_writedata_release);
 
@@ -2627,6 +2676,7 @@ cifs_write_from_iter(loff_t offset, size_t len, struct iov_iter *from,
         struct TCP_Server_Info *server;
         struct page **pagevec;
         size_t start;
+        unsigned int xid;
 
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
                 pid = open_file->pid;
@@ -2634,12 +2684,23 @@ cifs_write_from_iter(loff_t offset, size_t len, struct iov_iter *from,
                 pid = current->tgid;
 
         server = tlink_tcon(open_file->tlink)->ses->server;
+        xid = get_xid();
 
         do {
-                unsigned int wsize, credits;
+                unsigned int wsize;
+                struct cifs_credits credits_on_stack;
+                struct cifs_credits *credits = &credits_on_stack;
+
+                if (open_file->invalidHandle) {
+                        rc = cifs_reopen_file(open_file, false);
+                        if (rc == -EAGAIN)
+                                continue;
+                        else if (rc)
+                                break;
+                }
 
                 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
-                                                   &wsize, &credits);
+                                                   &wsize, credits);
                 if (rc)
                         break;
 
@@ -2731,16 +2792,22 @@ cifs_write_from_iter(loff_t offset, size_t len, struct iov_iter *from,
                 wdata->pid = pid;
                 wdata->bytes = cur_len;
                 wdata->pagesz = PAGE_SIZE;
-                wdata->credits = credits;
+                wdata->credits = credits_on_stack;
                 wdata->ctx = ctx;
                 kref_get(&ctx->refcount);
 
-                if (!wdata->cfile->invalidHandle ||
-                    !(rc = cifs_reopen_file(wdata->cfile, false)))
-                        rc = server->ops->async_writev(wdata,
+                rc = adjust_credits(server, &wdata->credits, wdata->bytes);
+
+                if (!rc) {
+                        if (wdata->cfile->invalidHandle)
+                                rc = -EAGAIN;
+                        else
+                                rc = server->ops->async_writev(wdata,
                                         cifs_uncached_writedata_release);
+                }
+
                 if (rc) {
-                        add_credits_and_wake_if(server, wdata->credits, 0);
+                        add_credits_and_wake_if(server, &wdata->credits, 0);
                         kref_put(&wdata->refcount,
                                  cifs_uncached_writedata_release);
                         if (rc == -EAGAIN) {
@@ -2756,6 +2823,7 @@ cifs_write_from_iter(loff_t offset, size_t len, struct iov_iter *from,
                 len -= cur_len;
         } while (len > 0);
 
+        free_xid(xid);
         return rc;
 }
 
@@ -3028,14 +3096,16 @@ cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
          * these pages but not on the region from pos to ppos+len-1.
          */
         written = cifs_user_writev(iocb, from);
-        if (written > 0 && CIFS_CACHE_READ(cinode)) {
+        if (CIFS_CACHE_READ(cinode)) {
                 /*
-                 * Windows 7 server can delay breaking level2 oplock if a write
-                 * request comes - break it on the client to prevent reading
-                 * an old data.
+                 * We have read level caching and we have just sent a write
+                 * request to the server thus making data in the cache stale.
+                 * Zap the cache and set oplock/lease level to NONE to avoid
+                 * reading stale data from the cache. All subsequent read
+                 * operations will read new data from the server.
                  */
                 cifs_zap_mapping(inode);
-                cifs_dbg(FYI, "Set no oplock for inode=%p after a write operation\n",
+                cifs_dbg(FYI, "Set Oplock/Lease to NONE for inode=%p after write\n",
                          inode);
                 cinode->oplock = 0;
         }
@@ -3260,7 +3330,8 @@ static int cifs_resend_rdata(struct cifs_readdata *rdata,
                         struct list_head *rdata_list,
                         struct cifs_aio_ctx *ctx)
 {
-        unsigned int rsize, credits;
+        unsigned int rsize;
+        struct cifs_credits credits;
         int rc;
         struct TCP_Server_Info *server =
                 tlink_tcon(rdata->cfile->tlink)->ses->server;
@@ -3277,11 +3348,12 @@ static int cifs_resend_rdata(struct cifs_readdata *rdata,
                         goto out;
 
                 if (rsize < rdata->bytes) {
-                        add_credits_and_wake_if(server, credits, 0);
+                        add_credits_and_wake_if(server, &credits, 0);
                         msleep(1000);
                 }
         } while (rsize < rdata->bytes);
 
+        rdata->credits = credits;
         rc = -EAGAIN;
         while (rc == -EAGAIN) {
                 rc = 0;
@@ -3297,7 +3369,7 @@ static int cifs_resend_rdata(struct cifs_readdata *rdata,
                 return 0;
         }
 
-        add_credits_and_wake_if(server, rdata->credits, 0);
+        add_credits_and_wake_if(server, &rdata->credits, 0);
 out:
         kref_put(&rdata->refcount,
                 cifs_uncached_readdata_release);
@@ -3311,7 +3383,9 @@ cifs_send_async_read(loff_t offset, size_t len, struct cifsFileInfo *open_file,
                      struct cifs_aio_ctx *ctx)
 {
         struct cifs_readdata *rdata;
-        unsigned int npages, rsize, credits;
+        unsigned int npages, rsize;
+        struct cifs_credits credits_on_stack;
+        struct cifs_credits *credits = &credits_on_stack;
         size_t cur_len;
         int rc;
         pid_t pid;
@@ -3331,8 +3405,16 @@ cifs_send_async_read(loff_t offset, size_t len, struct cifsFileInfo *open_file,
                 iov_iter_advance(&direct_iov, offset - ctx->pos);
 
         do {
+                if (open_file->invalidHandle) {
+                        rc = cifs_reopen_file(open_file, true);
+                        if (rc == -EAGAIN)
+                                continue;
+                        else if (rc)
+                                break;
+                }
+
                 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
-                                                   &rsize, &credits);
+                                                   &rsize, credits);
                 if (rc)
                         break;
 
@@ -3406,15 +3488,21 @@ cifs_send_async_read(loff_t offset, size_t len, struct cifsFileInfo *open_file,
                 rdata->pagesz = PAGE_SIZE;
                 rdata->read_into_pages = cifs_uncached_read_into_pages;
                 rdata->copy_into_pages = cifs_uncached_copy_into_pages;
-                rdata->credits = credits;
+                rdata->credits = credits_on_stack;
                 rdata->ctx = ctx;
                 kref_get(&ctx->refcount);
 
-                if (!rdata->cfile->invalidHandle ||
-                    !(rc = cifs_reopen_file(rdata->cfile, true)))
-                        rc = server->ops->async_readv(rdata);
+                rc = adjust_credits(server, &rdata->credits, rdata->bytes);
+
+                if (!rc) {
+                        if (rdata->cfile->invalidHandle)
+                                rc = -EAGAIN;
+                        else
+                                rc = server->ops->async_readv(rdata);
+                }
+
                 if (rc) {
-                        add_credits_and_wake_if(server, rdata->credits, 0);
+                        add_credits_and_wake_if(server, &rdata->credits, 0);
                         kref_put(&rdata->refcount,
                                 cifs_uncached_readdata_release);
                         if (rc == -EAGAIN) {
@@ -3533,8 +3621,6 @@ again:
                 ctx->total_len = ctx->len - iov_iter_count(to);
         }
 
-        cifs_stats_bytes_read(tcon, ctx->total_len);
-
         /* mask nodata case */
         if (rc == -ENODATA)
                 rc = 0;
@@ -4095,10 +4181,19 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
                 loff_t offset;
                 struct page *page, *tpage;
                 struct cifs_readdata *rdata;
-                unsigned credits;
+                struct cifs_credits credits_on_stack;
+                struct cifs_credits *credits = &credits_on_stack;
+
+                if (open_file->invalidHandle) {
+                        rc = cifs_reopen_file(open_file, true);
+                        if (rc == -EAGAIN)
+                                continue;
+                        else if (rc)
+                                break;
+                }
 
                 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
-                                                   &rsize, &credits);
+                                                   &rsize, credits);
                 if (rc)
                         break;
 
@@ -4144,18 +4239,24 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
                 rdata->tailsz = PAGE_SIZE;
                 rdata->read_into_pages = cifs_readpages_read_into_pages;
                 rdata->copy_into_pages = cifs_readpages_copy_into_pages;
-                rdata->credits = credits;
+                rdata->credits = credits_on_stack;
 
                 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
                         list_del(&page->lru);
                         rdata->pages[rdata->nr_pages++] = page;
                 }
 
-                if (!rdata->cfile->invalidHandle ||
-                    !(rc = cifs_reopen_file(rdata->cfile, true)))
-                        rc = server->ops->async_readv(rdata);
+                rc = adjust_credits(server, &rdata->credits, rdata->bytes);
+
+                if (!rc) {
+                        if (rdata->cfile->invalidHandle)
+                                rc = -EAGAIN;
+                        else
+                                rc = server->ops->async_readv(rdata);
+                }
+
                 if (rc) {
-                        add_credits_and_wake_if(server, rdata->credits, 0);
+                        add_credits_and_wake_if(server, &rdata->credits, 0);
                         for (i = 0; i < rdata->nr_pages; i++) {
                                 page = rdata->pages[i];
                                 lru_cache_add_file(page);