Patched in Tegra support.

1 files changed, 100 insertions, 126 deletions

diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index de7f9168a11..54b8f1e7da9 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -36,7 +36,6 @@
 #include <linux/kthread.h>
 #include <linux/freezer.h>
 #include <linux/namei.h>
-#include <linux/random.h>
 #include <net/ipv6.h>
 #include "cifsfs.h"
 #include "cifspdu.h"
@@ -49,48 +48,44 @@
 #include <linux/key-type.h>
 #include "cifs_spnego.h"
 #include "fscache.h"
-#ifdef CONFIG_CIFS_SMB2
-#include "smb2pdu.h"
-#endif
+#define CIFS_MAGIC_NUMBER 0xFF534D42    /* the first four bytes of SMB PDUs */
 
 int cifsFYI = 0;
+int cifsERROR = 1;
 int traceSMB = 0;
-bool enable_oplocks = true;
+unsigned int oplockEnabled = 1;
 unsigned int linuxExtEnabled = 1;
 unsigned int lookupCacheEnabled = 1;
+unsigned int multiuser_mount = 0;
 unsigned int global_secflags = CIFSSEC_DEF;
 /* unsigned int ntlmv2_support = 0; */
 unsigned int sign_CIFS_PDUs = 1;
 static const struct super_operations cifs_super_ops;
 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
-module_param(CIFSMaxBufSize, uint, 0);
+module_param(CIFSMaxBufSize, int, 0);
 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
                                  "Default: 16384 Range: 8192 to 130048");
 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
-module_param(cifs_min_rcv, uint, 0);
+module_param(cifs_min_rcv, int, 0);
 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
                                 "1 to 64");
 unsigned int cifs_min_small = 30;
-module_param(cifs_min_small, uint, 0);
+module_param(cifs_min_small, int, 0);
 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
                                  "Range: 2 to 256");
 unsigned int cifs_max_pending = CIFS_MAX_REQ;
-module_param(cifs_max_pending, uint, 0444);
+module_param(cifs_max_pending, int, 0);
 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
-                                   "Default: 32767 Range: 2 to 32767.");
-module_param(enable_oplocks, bool, 0644);
-MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks. Default: y/Y/1");
-
+                                   "Default: 50 Range: 2 to 256");
+unsigned short echo_retries = 5;
+module_param(echo_retries, ushort, 0644);
+MODULE_PARM_DESC(echo_retries, "Number of echo attempts before giving up and "
+                               "reconnecting server. Default: 5. 0 means "
+                               "never reconnect.");
 extern mempool_t *cifs_sm_req_poolp;
 extern mempool_t *cifs_req_poolp;
 extern mempool_t *cifs_mid_poolp;
 
-struct workqueue_struct *cifsiod_wq;
-
-#ifdef CONFIG_CIFS_SMB2
-__u8 cifs_client_guid[SMB2_CLIENT_GUID_SIZE];
-#endif
-
 static int
 cifs_read_super(struct super_block *sb)
 {
@@ -120,32 +115,37 @@ cifs_read_super(struct super_block *sb)
 
         if (IS_ERR(inode)) {
                 rc = PTR_ERR(inode);
+                inode = NULL;
                 goto out_no_root;
         }
 
-        sb->s_root = d_make_root(inode);
+        sb->s_root = d_alloc_root(inode);
+
         if (!sb->s_root) {
                 rc = -ENOMEM;
                 goto out_no_root;
         }
 
-        /* do that *after* d_make_root() - we want NULL ->d_op for root here */
+        /* do that *after* d_alloc_root() - we want NULL ->d_op for root here */
         if (cifs_sb_master_tcon(cifs_sb)->nocase)
                 sb->s_d_op = &cifs_ci_dentry_ops;
         else
                 sb->s_d_op = &cifs_dentry_ops;
 
-#ifdef CONFIG_CIFS_NFSD_EXPORT
+#ifdef CIFS_NFSD_EXPORT
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
                 cFYI(1, "export ops supported");
                 sb->s_export_op = &cifs_export_ops;
         }
-#endif /* CONFIG_CIFS_NFSD_EXPORT */
+#endif /* CIFS_NFSD_EXPORT */
 
         return 0;
 
 out_no_root:
         cERROR(1, "cifs_read_super: get root inode failed");
+        if (inode)
+                iput(inode);
+
         return rc;
 }
 
@@ -162,11 +162,12 @@ cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
         struct super_block *sb = dentry->d_sb;
         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
-        struct TCP_Server_Info *server = tcon->ses->server;
-        unsigned int xid;
-        int rc = 0;
+        int rc = -EOPNOTSUPP;
+        int xid;
+
+        xid = GetXid();
 
-        xid = get_xid();
+        buf->f_type = CIFS_MAGIC_NUMBER;
 
         /*
          * PATH_MAX may be too long - it would presumably be total path,
@@ -179,10 +180,29 @@ cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
         buf->f_files = 0;       /* undefined */
         buf->f_ffree = 0;       /* unlimited */
 
-        if (server->ops->queryfs)
-                rc = server->ops->queryfs(xid, tcon, buf);
+        /*
+         * We could add a second check for a QFS Unix capability bit
+         */
+        if ((tcon->ses->capabilities & CAP_UNIX) &&
+            (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
+                rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
+
+        /*
+         * Only need to call the old QFSInfo if failed on newer one,
+         * e.g. by OS/2.
+         **/
+        if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
+                rc = CIFSSMBQFSInfo(xid, tcon, buf);
+
+        /*
+         * Some old Windows servers also do not support level 103, retry with
+         * older level one if old server failed the previous call or we
+         * bypassed it because we detected that this was an older LANMAN sess
+         */
+        if (rc)
+                rc = SMBOldQFSInfo(xid, tcon, buf);
 
-        free_xid(xid);
+        FreeXid(xid);
         return 0;
 }
 
@@ -221,10 +241,9 @@ cifs_alloc_inode(struct super_block *sb)
                 return NULL;
         cifs_inode->cifsAttrs = 0x20;   /* default */
         cifs_inode->time = 0;
-        /*
-         * Until the file is open and we have gotten oplock info back from the
-         * server, can not assume caching of file data or metadata.
-         */
+        /* Until the file is open and we have gotten oplock
+        info back from the server, can not assume caching of
+        file data or metadata */
         cifs_set_oplock_level(cifs_inode, 0);
         cifs_inode->delete_pending = false;
         cifs_inode->invalid_mapping = false;
@@ -232,22 +251,18 @@ cifs_alloc_inode(struct super_block *sb)
         cifs_inode->server_eof = 0;
         cifs_inode->uniqueid = 0;
         cifs_inode->createtime = 0;
-#ifdef CONFIG_CIFS_SMB2
-        get_random_bytes(cifs_inode->lease_key, SMB2_LEASE_KEY_SIZE);
-#endif
-        /*
-         * Can not set i_flags here - they get immediately overwritten to zero
-         * by the VFS.
-         */
-        /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME; */
+
+        /* Can not set i_flags here - they get immediately overwritten
+           to zero by the VFS */
+/*      cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
         INIT_LIST_HEAD(&cifs_inode->openFileList);
-        INIT_LIST_HEAD(&cifs_inode->llist);
         return &cifs_inode->vfs_inode;
 }
 
 static void cifs_i_callback(struct rcu_head *head)
 {
         struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
 }
 
@@ -261,7 +276,7 @@ static void
 cifs_evict_inode(struct inode *inode)
 {
         truncate_inode_pages(&inode->i_data, 0);
-        clear_inode(inode);
+        end_writeback(inode);
         cifs_fscache_release_inode_cookie(inode);
 }
 
@@ -318,38 +333,22 @@ cifs_show_security(struct seq_file *s, struct TCP_Server_Info *server)
                 seq_printf(s, "i");
 }
 
-static void
-cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
-{
-        seq_printf(s, ",cache=");
-
-        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
-                seq_printf(s, "strict");
-        else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
-                seq_printf(s, "none");
-        else
-                seq_printf(s, "loose");
-}
-
 /*
  * cifs_show_options() is for displaying mount options in /proc/mounts.
  * Not all settable options are displayed but most of the important
  * ones are.
  */
 static int
-cifs_show_options(struct seq_file *s, struct dentry *root)
+cifs_show_options(struct seq_file *s, struct vfsmount *m)
 {
-        struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
+        struct cifs_sb_info *cifs_sb = CIFS_SB(m->mnt_sb);
         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
         struct sockaddr *srcaddr;
         srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
 
-        seq_printf(s, ",vers=%s", tcon->ses->server->vals->version_string);
         cifs_show_security(s, tcon->ses->server);
-        cifs_show_cache_flavor(s, cifs_sb);
 
-        seq_printf(s, ",unc=");
-        seq_escape(s, tcon->treeName, " \t\n\\");
+        seq_printf(s, ",unc=%s", tcon->treeName);
 
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
                 seq_printf(s, ",multiuser");
@@ -375,13 +374,13 @@ cifs_show_options(struct seq_file *s, struct dentry *root)
                                    (int)(srcaddr->sa_family));
         }
 
-        seq_printf(s, ",uid=%u", cifs_sb->mnt_uid);
+        seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
                 seq_printf(s, ",forceuid");
         else
                 seq_printf(s, ",noforceuid");
 
-        seq_printf(s, ",gid=%u", cifs_sb->mnt_gid);
+        seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
                 seq_printf(s, ",forcegid");
         else
@@ -390,7 +389,7 @@ cifs_show_options(struct seq_file *s, struct dentry *root)
         cifs_show_address(s, tcon->ses->server);
 
         if (!tcon->unix_ext)
-                seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
+                seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
                                            cifs_sb->mnt_file_mode,
                                            cifs_sb->mnt_dir_mode);
         if (tcon->seal)
@@ -413,6 +412,8 @@ cifs_show_options(struct seq_file *s, struct dentry *root)
                 seq_printf(s, ",rwpidforward");
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
                 seq_printf(s, ",forcemand");
+        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
+                seq_printf(s, ",directio");
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
                 seq_printf(s, ",nouser_xattr");
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
@@ -425,25 +426,17 @@ cifs_show_options(struct seq_file *s, struct dentry *root)
                 seq_printf(s, ",cifsacl");
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
                 seq_printf(s, ",dynperm");
-        if (root->d_sb->s_flags & MS_POSIXACL)
+        if (m->mnt_sb->s_flags & MS_POSIXACL)
                 seq_printf(s, ",acl");
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
                 seq_printf(s, ",mfsymlinks");
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
                 seq_printf(s, ",fsc");
-        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
-                seq_printf(s, ",nostrictsync");
-        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
-                seq_printf(s, ",noperm");
-        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
-                seq_printf(s, ",backupuid=%u", cifs_sb->mnt_backupuid);
-        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
-                seq_printf(s, ",backupgid=%u", cifs_sb->mnt_backupgid);
-
-        seq_printf(s, ",rsize=%u", cifs_sb->rsize);
-        seq_printf(s, ",wsize=%u", cifs_sb->wsize);
+
+        seq_printf(s, ",rsize=%d", cifs_sb->rsize);
+        seq_printf(s, ",wsize=%d", cifs_sb->wsize);
         /* convert actimeo and display it in seconds */
-        seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
+                seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
 
         return 0;
 }
@@ -485,7 +478,7 @@ static void cifs_umount_begin(struct super_block *sb)
 }
 
 #ifdef CONFIG_CIFS_STATS2
-static int cifs_show_stats(struct seq_file *s, struct dentry *root)
+static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
 {
         /* BB FIXME */
         return 0;
@@ -537,6 +530,7 @@ cifs_get_root(struct smb_vol *vol, struct super_block *sb)
         char *full_path = NULL;
         char *s, *p;
         char sep;
+        int xid;
 
         full_path = cifs_build_path_to_root(vol, cifs_sb,
                                             cifs_sb_master_tcon(cifs_sb));
@@ -545,6 +539,7 @@ cifs_get_root(struct smb_vol *vol, struct super_block *sb)
 
         cFYI(1, "Get root dentry for %s", full_path);
 
+        xid = GetXid();
         sep = CIFS_DIR_SEP(cifs_sb);
         dentry = dget(sb->s_root);
         p = s = full_path;
@@ -575,6 +570,7 @@ cifs_get_root(struct smb_vol *vol, struct super_block *sb)
                 dput(dentry);
                 dentry = child;
         } while (!IS_ERR(dentry));
+        _FreeXid(xid);
         kfree(full_path);
         return dentry;
 }
@@ -629,10 +625,7 @@ cifs_do_mount(struct file_system_type *fs_type,
         mnt_data.cifs_sb = cifs_sb;
         mnt_data.flags = flags;
 
-        /* BB should we make this contingent on mount parm? */
-        flags |= MS_NODIRATIME | MS_NOATIME;
-
-        sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
+        sb = sget(fs_type, cifs_match_super, cifs_set_super, &mnt_data);
         if (IS_ERR(sb)) {
                 root = ERR_CAST(sb);
                 cifs_umount(cifs_sb);
@@ -643,6 +636,10 @@ cifs_do_mount(struct file_system_type *fs_type,
                 cFYI(1, "Use existing superblock");
                 cifs_umount(cifs_sb);
         } else {
+                sb->s_flags = flags;
+                /* BB should we make this contingent on mount parm? */
+                sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
+
                 rc = cifs_read_super(sb);
                 if (rc) {
                         root = ERR_PTR(rc);
@@ -693,13 +690,13 @@ static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
         return written;
 }
 
-static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
+static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
 {
         /*
-         * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
+         * origin == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
          * the cached file length
          */
-        if (whence != SEEK_SET && whence != SEEK_CUR) {
+        if (origin != SEEK_SET || origin != SEEK_CUR) {
                 int rc;
                 struct inode *inode = file->f_path.dentry->d_inode;
 
@@ -726,7 +723,7 @@ static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
                 if (rc < 0)
                         return (loff_t)rc;
         }
-        return generic_file_llseek(file, offset, whence);
+        return generic_file_llseek_unlocked(file, offset, origin);
 }
 
 static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
@@ -768,7 +765,6 @@ struct file_system_type cifs_fs_type = {
 };
 const struct inode_operations cifs_dir_inode_ops = {
         .create = cifs_create,
-        .atomic_open = cifs_atomic_open,
         .lookup = cifs_lookup,
         .getattr = cifs_getattr,
         .unlink = cifs_unlink,
@@ -946,7 +942,7 @@ cifs_init_once(void *inode)
         struct cifsInodeInfo *cifsi = inode;
 
         inode_init_once(&cifsi->vfs_inode);
-        init_rwsem(&cifsi->lock_sem);
+        INIT_LIST_HEAD(&cifsi->lockList);
 }
 
 static int
@@ -966,25 +962,12 @@ cifs_init_inodecache(void)
 static void
 cifs_destroy_inodecache(void)
 {
-        /*
-         * Make sure all delayed rcu free inodes are flushed before we
-         * destroy cache.
-         */
-        rcu_barrier();
         kmem_cache_destroy(cifs_inode_cachep);
 }
 
 static int
 cifs_init_request_bufs(void)
 {
-        size_t max_hdr_size = MAX_CIFS_HDR_SIZE;
-#ifdef CONFIG_CIFS_SMB2
-        /*
-         * SMB2 maximum header size is bigger than CIFS one - no problems to
-         * allocate some more bytes for CIFS.
-         */
-        max_hdr_size = MAX_SMB2_HDR_SIZE;
-#endif
         if (CIFSMaxBufSize < 8192) {
         /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
         Unicode path name has to fit in any SMB/CIFS path based frames */
@@ -996,7 +979,8 @@ cifs_init_request_bufs(void)
         }
 /*      cERROR(1, "CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize); */
         cifs_req_cachep = kmem_cache_create("cifs_request",
-                                            CIFSMaxBufSize + max_hdr_size, 0,
+                                            CIFSMaxBufSize +
+                                            MAX_CIFS_HDR_SIZE, 0,
                                             SLAB_HWCACHE_ALIGN, NULL);
         if (cifs_req_cachep == NULL)
                 return -ENOMEM;
@@ -1121,27 +1105,17 @@ init_cifs(void)
         spin_lock_init(&cifs_file_list_lock);
         spin_lock_init(&GlobalMid_Lock);
 
-#ifdef CONFIG_CIFS_SMB2
-        get_random_bytes(cifs_client_guid, SMB2_CLIENT_GUID_SIZE);
-#endif
-
         if (cifs_max_pending < 2) {
                 cifs_max_pending = 2;
                 cFYI(1, "cifs_max_pending set to min of 2");
-        } else if (cifs_max_pending > CIFS_MAX_REQ) {
-                cifs_max_pending = CIFS_MAX_REQ;
-                cFYI(1, "cifs_max_pending set to max of %u", CIFS_MAX_REQ);
-        }
-
-        cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
-        if (!cifsiod_wq) {
-                rc = -ENOMEM;
-                goto out_clean_proc;
+        } else if (cifs_max_pending > 256) {
+                cifs_max_pending = 256;
+                cFYI(1, "cifs_max_pending set to max of 256");
         }
 
         rc = cifs_fscache_register();
         if (rc)
-                goto out_destroy_wq;
+                goto out_clean_proc;
 
         rc = cifs_init_inodecache();
         if (rc)
@@ -1189,8 +1163,6 @@ out_destroy_inodecache:
         cifs_destroy_inodecache();
 out_unreg_fscache:
         cifs_fscache_unregister();
-out_destroy_wq:
-        destroy_workqueue(cifsiod_wq);
 out_clean_proc:
         cifs_proc_clean();
         return rc;
@@ -1200,20 +1172,22 @@ static void __exit
 exit_cifs(void)
 {
         cFYI(DBG2, "exit_cifs");
-        unregister_filesystem(&cifs_fs_type);
+        cifs_proc_clean();
+        cifs_fscache_unregister();
+#ifdef CONFIG_CIFS_DFS_UPCALL
         cifs_dfs_release_automount_timer();
+#endif
 #ifdef CONFIG_CIFS_ACL
+        cifs_destroy_idmaptrees();
         exit_cifs_idmap();
 #endif
 #ifdef CONFIG_CIFS_UPCALL
         unregister_key_type(&cifs_spnego_key_type);
 #endif
-        cifs_destroy_request_bufs();
-        cifs_destroy_mids();
+        unregister_filesystem(&cifs_fs_type);
         cifs_destroy_inodecache();
-        cifs_fscache_unregister();
-        destroy_workqueue(cifsiod_wq);
-        cifs_proc_clean();
+        cifs_destroy_mids();
+        cifs_destroy_request_bufs();
 }
 
 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");