cifs: allow for larger rsize= options and change defaults

Currently we cap the rsize at a value that fits in CIFSMaxBufSize. That's
not needed any longer for readpages. Allow the use of larger values for
readpages. cifs_iovec_read and cifs_read however are still limited to the
CIFSMaxBufSize. Make sure they don't exceed that.

The patch also changes the rsize defaults. The default when unix
extensions are enabled is set to 1M for parity with the wsize, and there
is a hard cap of ~16M.

When unix extensions are not enabled, the default is set to 60k. According
to MS-CIFS, Windows servers can only send a max of 60k at a time, so
this is more efficient than requesting a larger size. If the user wishes
however, the max can be extended up to 128k - the length of the READ_RSP
header.

Really old servers however require a special hack to ensure that we don't
request too large a read.

Reviewed-and-Tested-by: Pavel Shilovsky <piastry@etersoft.ru>
Signed-off-by: Jeff Layton <jlayton@redhat.com>

1 files changed, 11 insertions, 3 deletions

diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 8f6917816fec..a3b545ff5250 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -1758,6 +1758,7 @@ cifs_iovec_read(struct file *file, const struct iovec *iov,
         struct smb_com_read_rsp *pSMBr;
         struct cifs_io_parms io_parms;
         char *read_data;
+        unsigned int rsize;
         __u32 pid;
 
         if (!nr_segs)
@@ -1770,6 +1771,9 @@ cifs_iovec_read(struct file *file, const struct iovec *iov,
         xid = GetXid();
         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
 
+        /* FIXME: set up handlers for larger reads and/or convert to async */
+        rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
+
         open_file = file->private_data;
         pTcon = tlink_tcon(open_file->tlink);
 
@@ -1782,7 +1786,7 @@ cifs_iovec_read(struct file *file, const struct iovec *iov,
                 cFYI(1, "attempting read on write only file instance");
 
         for (total_read = 0; total_read < len; total_read += bytes_read) {
-                cur_len = min_t(const size_t, len - total_read, cifs_sb->rsize);
+                cur_len = min_t(const size_t, len - total_read, rsize);
                 rc = -EAGAIN;
                 read_data = NULL;
 
@@ -1874,6 +1878,7 @@ static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
         unsigned int bytes_read = 0;
         unsigned int total_read;
         unsigned int current_read_size;
+        unsigned int rsize;
         struct cifs_sb_info *cifs_sb;
         struct cifs_tcon *pTcon;
         int xid;
@@ -1886,6 +1891,9 @@ static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
         xid = GetXid();
         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
 
+        /* FIXME: set up handlers for larger reads and/or convert to async */
+        rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
+
         if (file->private_data == NULL) {
                 rc = -EBADF;
                 FreeXid(xid);
@@ -1905,8 +1913,8 @@ static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
         for (total_read = 0, current_offset = read_data;
              read_size > total_read;
              total_read += bytes_read, current_offset += bytes_read) {
-                current_read_size = min_t(uint, read_size - total_read,
-                                          cifs_sb->rsize);
+                current_read_size = min_t(uint, read_size - total_read, rsize);
+
                 /* For windows me and 9x we do not want to request more
                 than it negotiated since it will refuse the read then */
                 if ((pTcon->ses) &&