Patched in Tegra support.

49 files changed, 5236 insertions, 18520 deletions

diff --git a/fs/cifs/Kconfig b/fs/cifs/Kconfig
index 21ff76c22a1..f66cc162515 100644
--- a/fs/cifs/Kconfig
+++ b/fs/cifs/Kconfig
@@ -9,14 +9,13 @@ config CIFS
         select CRYPTO_ARC4
         select CRYPTO_ECB
         select CRYPTO_DES
-        select CRYPTO_SHA256
         help
           This is the client VFS module for the Common Internet File System
           (CIFS) protocol which is the successor to the Server Message Block
           (SMB) protocol, the native file sharing mechanism for most early
           PC operating systems.  The CIFS protocol is fully supported by
-          file servers such as Windows 2000 (including Windows 2003, Windows 2008,
-          NT 4 and Windows XP) as well by Samba (which provides excellent CIFS
+          file servers such as Windows 2000 (including Windows 2003, NT 4
+          and Windows XP) as well by Samba (which provides excellent CIFS
           server support for Linux and many other operating systems). Limited
           support for OS/2 and Windows ME and similar servers is provided as
           well.
@@ -115,24 +114,9 @@ config CIFS_POSIX
           (such as Samba 3.10 and later) which can negotiate
           CIFS POSIX ACL support.  If unsure, say N.
 
-config CIFS_ACL
-          bool "Provide CIFS ACL support"
-          depends on CIFS_XATTR && KEYS
-          help
-            Allows fetching CIFS/NTFS ACL from the server.  The DACL blob
-            is handed over to the application/caller.
-
-config CIFS_DEBUG
-        bool "Enable CIFS debugging routines"
-        default y
-        depends on CIFS
-        help
-           Enabling this option adds helpful debugging messages to
-           the cifs code which increases the size of the cifs module.
-           If unsure, say Y.
 config CIFS_DEBUG2
         bool "Enable additional CIFS debugging routines"
-        depends on CIFS_DEBUG
+        depends on CIFS
         help
            Enabling this option adds a few more debugging routines
            to the cifs code which slightly increases the size of
@@ -154,37 +138,24 @@ config CIFS_DFS_UPCALL
             IP addresses) which is needed for implicit mounts of DFS junction
             points. If unsure, say N.
 
-config CIFS_NFSD_EXPORT
-          bool "Allow nfsd to export CIFS file system (EXPERIMENTAL)"
-          depends on CIFS && EXPERIMENTAL && BROKEN
-          help
-           Allows NFS server to export a CIFS mounted share (nfsd over cifs)
-
-config CIFS_SMB2
-        bool "SMB2 network file system support (EXPERIMENTAL)"
-        depends on CIFS && EXPERIMENTAL && INET
-        select NLS
-        select KEYS
-        select FSCACHE
-        select DNS_RESOLVER
-
-        help
-          This enables experimental support for the SMB2 (Server Message Block
-          version 2) protocol. The SMB2 protocol is the successor to the
-          popular CIFS and SMB network file sharing protocols. SMB2 is the
-          native file sharing mechanism for recent versions of Windows
-          operating systems (since Vista).  SMB2 enablement will eventually
-          allow users better performance, security and features, than would be
-          possible with cifs. Note that smb2 mount options also are simpler
-          (compared to cifs) due to protocol improvements.
-
-          Unless you are a developer or tester, say N.
-
 config CIFS_FSCACHE
-          bool "Provide CIFS client caching support"
+          bool "Provide CIFS client caching support (EXPERIMENTAL)"
+          depends on EXPERIMENTAL
           depends on CIFS=m && FSCACHE || CIFS=y && FSCACHE=y
           help
             Makes CIFS FS-Cache capable. Say Y here if you want your CIFS data
             to be cached locally on disk through the general filesystem cache
             manager. If unsure, say N.
 
+config CIFS_ACL
+          bool "Provide CIFS ACL support (EXPERIMENTAL)"
+          depends on EXPERIMENTAL && CIFS_XATTR && KEYS
+          help
+            Allows to fetch CIFS/NTFS ACL from the server.  The DACL blob
+            is handed over to the application/caller.
+
+config CIFS_NFSD_EXPORT
+          bool "Allow nfsd to export CIFS file system (EXPERIMENTAL)"
+          depends on CIFS && EXPERIMENTAL && BROKEN
+          help
+           Allows NFS server to export a CIFS mounted share (nfsd over cifs)
diff --git a/fs/cifs/Makefile b/fs/cifs/Makefile
index aa0d68b086e..005d524c3a4 100644
--- a/fs/cifs/Makefile
+++ b/fs/cifs/Makefile
@@ -6,7 +6,7 @@ obj-$(CONFIG_CIFS) += cifs.o
 cifs-y := cifsfs.o cifssmb.o cifs_debug.o connect.o dir.o file.o inode.o \
           link.o misc.o netmisc.o smbencrypt.o transport.o asn1.o \
           cifs_unicode.o nterr.o xattr.o cifsencrypt.o \
-          readdir.o ioctl.o sess.o export.o smb1ops.o
+          readdir.o ioctl.o sess.o export.o
 
 cifs-$(CONFIG_CIFS_ACL) += cifsacl.o
 
@@ -15,6 +15,3 @@ cifs-$(CONFIG_CIFS_UPCALL) += cifs_spnego.o
 cifs-$(CONFIG_CIFS_DFS_UPCALL) += dns_resolve.o cifs_dfs_ref.o
 
 cifs-$(CONFIG_CIFS_FSCACHE) += fscache.o cache.o
-
-cifs-$(CONFIG_CIFS_SMB2) += smb2ops.o smb2maperror.o smb2transport.o \
-                            smb2misc.o smb2pdu.o smb2inode.o smb2file.o
diff --git a/fs/cifs/README b/fs/cifs/README
index 2d5622f60e1..c5c2c5e5f0f 100644
--- a/fs/cifs/README
+++ b/fs/cifs/README
@@ -480,7 +480,7 @@ A partial list of the supported mount options follows:
                 Unicode on the wire.
  nomapchars     Do not translate any of these seven characters (default).
  nocase         Request case insensitive path name matching (case
-                sensitive is the default if the server supports it).
+                sensitive is the default if the server suports it).
                 (mount option "ignorecase" is identical to "nocase")
  posixpaths     If CIFS Unix extensions are supported, attempt to
                 negotiate posix path name support which allows certain
@@ -608,6 +608,11 @@ Stats			Lists summary resource usage information as well as per
                         in the kernel configuration.
 
 Configuration pseudo-files:
+MultiuserMount          If set to one, more than one CIFS session to 
+                        the same server ip address can be established
+                        if more than one uid accesses the same mount
+                        point and if the uids user/password mapping
+                        information is available. (default is 0)
 PacketSigningEnabled    If set to one, cifs packet signing is enabled
                         and will be used if the server requires 
                         it.  If set to two, cifs packet signing is
@@ -740,14 +745,4 @@ installed and something like the following lines should be added to the
 create cifs.spnego * * /usr/local/sbin/cifs.upcall %k
 create dns_resolver * * /usr/local/sbin/cifs.upcall %k
 
-CIFS kernel module parameters
-=============================
-These module parameters can be specified or modified either during the time of
-module loading or during the runtime by using the interface
-        /proc/module/cifs/parameters/<param>
-
-i.e. echo "value" > /sys/module/cifs/parameters/<param>
-
-1. enable_oplocks - Enable or disable oplocks. Oplocks are enabled by default.
-                    [Y/y/1]. To disable use any of [N/n/0].
 
diff --git a/fs/cifs/cache.c b/fs/cifs/cache.c
index 282d6de7e41..545509c3313 100644
--- a/fs/cifs/cache.c
+++ b/fs/cifs/cache.c
@@ -152,7 +152,7 @@ static uint16_t cifs_super_get_key(const void *cookie_netfs_data, void *buffer,
 
         sharename = extract_sharename(tcon->treeName);
         if (IS_ERR(sharename)) {
-                cFYI(1, "%s: couldn't extract sharename", __func__);
+                cFYI(1, "%s: couldn't extract sharename\n", __func__);
                 sharename = NULL;
                 return 0;
         }
diff --git a/fs/cifs/cifs_debug.c b/fs/cifs/cifs_debug.c
index d9ea6ede6a7..6d40656e1e2 100644
--- a/fs/cifs/cifs_debug.c
+++ b/fs/cifs/cifs_debug.c
@@ -57,21 +57,18 @@ cifs_dump_mem(char *label, void *data, int length)
         }
 }
 
-void cifs_dump_detail(void *buf)
-{
 #ifdef CONFIG_CIFS_DEBUG2
-        struct smb_hdr *smb = (struct smb_hdr *)buf;
-
+void cifs_dump_detail(struct smb_hdr *smb)
+{
         cERROR(1, "Cmd: %d Err: 0x%x Flags: 0x%x Flgs2: 0x%x Mid: %d Pid: %d",
                   smb->Command, smb->Status.CifsError,
                   smb->Flags, smb->Flags2, smb->Mid, smb->Pid);
-        cERROR(1, "smb buf %p len %u", smb, smbCalcSize(smb));
-#endif /* CONFIG_CIFS_DEBUG2 */
+        cERROR(1, "smb buf %p len %d", smb, smbCalcSize(smb));
 }
 
+
 void cifs_dump_mids(struct TCP_Server_Info *server)
 {
-#ifdef CONFIG_CIFS_DEBUG2
         struct list_head *tmp;
         struct mid_q_entry *mid_entry;
 
@@ -82,15 +79,15 @@ void cifs_dump_mids(struct TCP_Server_Info *server)
         spin_lock(&GlobalMid_Lock);
         list_for_each(tmp, &server->pending_mid_q) {
                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
-                cERROR(1, "State: %d Cmd: %d Pid: %d Cbdata: %p Mid %llu",
-                        mid_entry->mid_state,
-                        le16_to_cpu(mid_entry->command),
+                cERROR(1, "State: %d Cmd: %d Pid: %d Cbdata: %p Mid %d",
+                        mid_entry->midState,
+                        (int)mid_entry->command,
                         mid_entry->pid,
                         mid_entry->callback_data,
                         mid_entry->mid);
 #ifdef CONFIG_CIFS_STATS2
                 cERROR(1, "IsLarge: %d buf: %p time rcv: %ld now: %ld",
-                        mid_entry->large_buf,
+                        mid_entry->largeBuf,
                         mid_entry->resp_buf,
                         mid_entry->when_received,
                         jiffies);
@@ -104,8 +101,8 @@ void cifs_dump_mids(struct TCP_Server_Info *server)
                 }
         }
         spin_unlock(&GlobalMid_Lock);
-#endif /* CONFIG_CIFS_DEBUG2 */
 }
+#endif /* CONFIG_CIFS_DEBUG2 */
 
 #ifdef CONFIG_PROC_FS
 static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
@@ -174,7 +171,8 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
                         seq_printf(m, "TCP status: %d\n\tLocal Users To "
                                    "Server: %d SecMode: 0x%x Req On Wire: %d",
                                    server->tcpStatus, server->srv_count,
-                                   server->sec_mode, in_flight(server));
+                                   server->sec_mode,
+                                   atomic_read(&server->inFlight));
 
 #ifdef CONFIG_CIFS_STATS2
                         seq_printf(m, " In Send: %d In MaxReq Wait: %d",
@@ -220,12 +218,12 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
                                 mid_entry = list_entry(tmp3, struct mid_q_entry,
                                         qhead);
                                 seq_printf(m, "\tState: %d com: %d pid:"
-                                              " %d cbdata: %p mid %llu\n",
-                                              mid_entry->mid_state,
-                                              le16_to_cpu(mid_entry->command),
-                                              mid_entry->pid,
-                                              mid_entry->callback_data,
-                                              mid_entry->mid);
+                                                " %d cbdata: %p mid %d\n",
+                                                mid_entry->midState,
+                                                (int)mid_entry->command,
+                                                mid_entry->pid,
+                                                mid_entry->callback_data,
+                                                mid_entry->mid);
                         }
                         spin_unlock(&GlobalMid_Lock);
                 }
@@ -282,8 +280,24 @@ static ssize_t cifs_stats_proc_write(struct file *file,
                                                           struct cifs_tcon,
                                                           tcon_list);
                                         atomic_set(&tcon->num_smbs_sent, 0);
-                                        if (server->ops->clear_stats)
-                                                server->ops->clear_stats(tcon);
+                                        atomic_set(&tcon->num_writes, 0);
+                                        atomic_set(&tcon->num_reads, 0);
+                                        atomic_set(&tcon->num_oplock_brks, 0);
+                                        atomic_set(&tcon->num_opens, 0);
+                                        atomic_set(&tcon->num_posixopens, 0);
+                                        atomic_set(&tcon->num_posixmkdirs, 0);
+                                        atomic_set(&tcon->num_closes, 0);
+                                        atomic_set(&tcon->num_deletes, 0);
+                                        atomic_set(&tcon->num_mkdirs, 0);
+                                        atomic_set(&tcon->num_rmdirs, 0);
+                                        atomic_set(&tcon->num_renames, 0);
+                                        atomic_set(&tcon->num_t2renames, 0);
+                                        atomic_set(&tcon->num_ffirst, 0);
+                                        atomic_set(&tcon->num_fnext, 0);
+                                        atomic_set(&tcon->num_fclose, 0);
+                                        atomic_set(&tcon->num_hardlinks, 0);
+                                        atomic_set(&tcon->num_symlinks, 0);
+                                        atomic_set(&tcon->num_locks, 0);
                                 }
                         }
                 }
@@ -342,10 +356,42 @@ static int cifs_stats_proc_show(struct seq_file *m, void *v)
                                 seq_printf(m, "\n%d) %s", i, tcon->treeName);
                                 if (tcon->need_reconnect)
                                         seq_puts(m, "\tDISCONNECTED ");
-                                seq_printf(m, "\nSMBs: %d",
-                                           atomic_read(&tcon->num_smbs_sent));
-                                if (server->ops->print_stats)
-                                        server->ops->print_stats(m, tcon);
+                                seq_printf(m, "\nSMBs: %d Oplock Breaks: %d",
+                                        atomic_read(&tcon->num_smbs_sent),
+                                        atomic_read(&tcon->num_oplock_brks));
+                                seq_printf(m, "\nReads:  %d Bytes: %lld",
+                                        atomic_read(&tcon->num_reads),
+                                        (long long)(tcon->bytes_read));
+                                seq_printf(m, "\nWrites: %d Bytes: %lld",
+                                        atomic_read(&tcon->num_writes),
+                                        (long long)(tcon->bytes_written));
+                                seq_printf(m, "\nFlushes: %d",
+                                        atomic_read(&tcon->num_flushes));
+                                seq_printf(m, "\nLocks: %d HardLinks: %d "
+                                              "Symlinks: %d",
+                                        atomic_read(&tcon->num_locks),
+                                        atomic_read(&tcon->num_hardlinks),
+                                        atomic_read(&tcon->num_symlinks));
+                                seq_printf(m, "\nOpens: %d Closes: %d "
+                                              "Deletes: %d",
+                                        atomic_read(&tcon->num_opens),
+                                        atomic_read(&tcon->num_closes),
+                                        atomic_read(&tcon->num_deletes));
+                                seq_printf(m, "\nPosix Opens: %d "
+                                              "Posix Mkdirs: %d",
+                                        atomic_read(&tcon->num_posixopens),
+                                        atomic_read(&tcon->num_posixmkdirs));
+                                seq_printf(m, "\nMkdirs: %d Rmdirs: %d",
+                                        atomic_read(&tcon->num_mkdirs),
+                                        atomic_read(&tcon->num_rmdirs));
+                                seq_printf(m, "\nRenames: %d T2 Renames %d",
+                                        atomic_read(&tcon->num_renames),
+                                        atomic_read(&tcon->num_t2renames));
+                                seq_printf(m, "\nFindFirst: %d FNext %d "
+                                              "FClose %d",
+                                        atomic_read(&tcon->num_ffirst),
+                                        atomic_read(&tcon->num_fnext),
+                                        atomic_read(&tcon->num_fclose));
                         }
                 }
         }
@@ -372,8 +418,10 @@ static const struct file_operations cifs_stats_proc_fops = {
 
 static struct proc_dir_entry *proc_fs_cifs;
 static const struct file_operations cifsFYI_proc_fops;
+static const struct file_operations cifs_oplock_proc_fops;
 static const struct file_operations cifs_lookup_cache_proc_fops;
 static const struct file_operations traceSMB_proc_fops;
+static const struct file_operations cifs_multiuser_mount_proc_fops;
 static const struct file_operations cifs_security_flags_proc_fops;
 static const struct file_operations cifs_linux_ext_proc_fops;
 
@@ -391,8 +439,11 @@ cifs_proc_init(void)
 #endif /* STATS */
         proc_create("cifsFYI", 0, proc_fs_cifs, &cifsFYI_proc_fops);
         proc_create("traceSMB", 0, proc_fs_cifs, &traceSMB_proc_fops);
+        proc_create("OplockEnabled", 0, proc_fs_cifs, &cifs_oplock_proc_fops);
         proc_create("LinuxExtensionsEnabled", 0, proc_fs_cifs,
                     &cifs_linux_ext_proc_fops);
+        proc_create("MultiuserMount", 0, proc_fs_cifs,
+                    &cifs_multiuser_mount_proc_fops);
         proc_create("SecurityFlags", 0, proc_fs_cifs,
                     &cifs_security_flags_proc_fops);
         proc_create("LookupCacheEnabled", 0, proc_fs_cifs,
@@ -411,6 +462,8 @@ cifs_proc_clean(void)
 #ifdef CONFIG_CIFS_STATS
         remove_proc_entry("Stats", proc_fs_cifs);
 #endif
+        remove_proc_entry("MultiuserMount", proc_fs_cifs);
+        remove_proc_entry("OplockEnabled", proc_fs_cifs);
         remove_proc_entry("SecurityFlags", proc_fs_cifs);
         remove_proc_entry("LinuxExtensionsEnabled", proc_fs_cifs);
         remove_proc_entry("LookupCacheEnabled", proc_fs_cifs);
@@ -456,6 +509,43 @@ static const struct file_operations cifsFYI_proc_fops = {
         .write          = cifsFYI_proc_write,
 };
 
+static int cifs_oplock_proc_show(struct seq_file *m, void *v)
+{
+        seq_printf(m, "%d\n", oplockEnabled);
+        return 0;
+}
+
+static int cifs_oplock_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, cifs_oplock_proc_show, NULL);
+}
+
+static ssize_t cifs_oplock_proc_write(struct file *file,
+                const char __user *buffer, size_t count, loff_t *ppos)
+{
+        char c;
+        int rc;
+
+        rc = get_user(c, buffer);
+        if (rc)
+                return rc;
+        if (c == '0' || c == 'n' || c == 'N')
+                oplockEnabled = 0;
+        else if (c == '1' || c == 'y' || c == 'Y')
+                oplockEnabled = 1;
+
+        return count;
+}
+
+static const struct file_operations cifs_oplock_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = cifs_oplock_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+        .write          = cifs_oplock_proc_write,
+};
+
 static int cifs_linux_ext_proc_show(struct seq_file *m, void *v)
 {
         seq_printf(m, "%d\n", linuxExtEnabled);
@@ -567,6 +657,43 @@ static const struct file_operations traceSMB_proc_fops = {
         .write          = traceSMB_proc_write,
 };
 
+static int cifs_multiuser_mount_proc_show(struct seq_file *m, void *v)
+{
+        seq_printf(m, "%d\n", multiuser_mount);
+        return 0;
+}
+
+static int cifs_multiuser_mount_proc_open(struct inode *inode, struct file *fh)
+{
+        return single_open(fh, cifs_multiuser_mount_proc_show, NULL);
+}
+
+static ssize_t cifs_multiuser_mount_proc_write(struct file *file,
+                const char __user *buffer, size_t count, loff_t *ppos)
+{
+        char c;
+        int rc;
+
+        rc = get_user(c, buffer);
+        if (rc)
+                return rc;
+        if (c == '0' || c == 'n' || c == 'N')
+                multiuser_mount = 0;
+        else if (c == '1' || c == 'y' || c == 'Y')
+                multiuser_mount = 1;
+
+        return count;
+}
+
+static const struct file_operations cifs_multiuser_mount_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = cifs_multiuser_mount_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+        .write          = cifs_multiuser_mount_proc_write,
+};
+
 static int cifs_security_flags_proc_show(struct seq_file *m, void *v)
 {
         seq_printf(m, "0x%x\n", global_secflags);
diff --git a/fs/cifs/cifs_debug.h b/fs/cifs/cifs_debug.h
index 69ae3d3c3b3..8942b28cf80 100644
--- a/fs/cifs/cifs_debug.h
+++ b/fs/cifs/cifs_debug.h
@@ -18,57 +18,68 @@
  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  *
 */
+#define CIFS_DEBUG              /* BB temporary */
 
 #ifndef _H_CIFS_DEBUG
 #define _H_CIFS_DEBUG
 
 void cifs_dump_mem(char *label, void *data, int length);
-void cifs_dump_detail(void *);
-void cifs_dump_mids(struct TCP_Server_Info *);
 #ifdef CONFIG_CIFS_DEBUG2
 #define DBG2 2
+void cifs_dump_detail(struct smb_hdr *);
+void cifs_dump_mids(struct TCP_Server_Info *);
 #else
 #define DBG2 0
 #endif
 extern int traceSMB;            /* flag which enables the function below */
-void dump_smb(void *, int);
+void dump_smb(struct smb_hdr *, int);
 #define CIFS_INFO       0x01
 #define CIFS_RC         0x02
 #define CIFS_TIMER      0x04
 
-extern int cifsFYI;
-
 /*
  *      debug ON
  *      --------
  */
-#ifdef CONFIG_CIFS_DEBUG
+#ifdef CIFS_DEBUG
 
 /* information message: e.g., configuration, major event */
-#define cifsfyi(fmt, ...)                                               \
+extern int cifsFYI;
+#define cifsfyi(fmt, arg...)                                            \
 do {                                                                    \
         if (cifsFYI & CIFS_INFO)                                        \
-                printk(KERN_DEBUG "%s: " fmt "\n",                      \
-                       __FILE__, ##__VA_ARGS__);                        \
+                printk(KERN_DEBUG "%s: " fmt "\n", __FILE__, ##arg);    \
 } while (0)
 
-#define cFYI(set, fmt, ...)                                             \
-do {                                                                    \
-        if (set)                                                        \
-                cifsfyi(fmt, ##__VA_ARGS__);                            \
+#define cFYI(set, fmt, arg...)                  \
+do {                                            \
+        if (set)                                \
+                cifsfyi(fmt, ##arg);            \
 } while (0)
 
-#define cifswarn(fmt, ...)                                              \
-        printk(KERN_WARNING fmt "\n", ##__VA_ARGS__)
+#define cifswarn(fmt, arg...)                   \
+        printk(KERN_WARNING fmt "\n", ##arg)
 
-/* error event message: e.g., i/o error */
-#define cifserror(fmt, ...)                                             \
-        printk(KERN_ERR "CIFS VFS: " fmt "\n", ##__VA_ARGS__);          \
+/* debug event message: */
+extern int cifsERROR;
 
-#define cERROR(set, fmt, ...)                                           \
+#define cEVENT(fmt, arg...)                                             \
 do {                                                                    \
-        if (set)                                                        \
-                cifserror(fmt, ##__VA_ARGS__);                          \
+        if (cifsERROR)                                                  \
+                printk(KERN_EVENT "%s: " fmt "\n", __FILE__, ##arg);    \
+} while (0)
+
+/* error event message: e.g., i/o error */
+#define cifserror(fmt, arg...)                                  \
+do {                                                            \
+        if (cifsERROR)                                          \
+                printk(KERN_ERR "CIFS VFS: " fmt "\n", ##arg);  \
+} while (0)
+
+#define cERROR(set, fmt, arg...)                \
+do {                                            \
+        if (set)                                \
+                cifserror(fmt, ##arg);          \
 } while (0)
 
 /*
@@ -76,27 +87,10 @@ do {									\
  *      ---------
  */
 #else           /* _CIFS_DEBUG */
-#define cifsfyi(fmt, ...)                                               \
-do {                                                                    \
-        if (0)                                                          \
-                printk(KERN_DEBUG "%s: " fmt "\n",                      \
-                       __FILE__, ##__VA_ARGS__);                        \
-} while (0)
-#define cFYI(set, fmt, ...)                                             \
-do {                                                                    \
-        if (0 && set)                                                   \
-                cifsfyi(fmt, ##__VA_ARGS__);                            \
-} while (0)
-#define cifserror(fmt, ...)                                             \
-do {                                                                    \
-        if (0)                                                          \
-                printk(KERN_ERR "CIFS VFS: " fmt "\n", ##__VA_ARGS__);  \
-} while (0)
-#define cERROR(set, fmt, ...)                                           \
-do {                                                                    \
-        if (0 && set)                                                   \
-                cifserror(fmt, ##__VA_ARGS__);                          \
-} while (0)
+#define cERROR(set, fmt, arg...)
+#define cEVENT(fmt, arg...)
+#define cFYI(set, fmt, arg...)
+#define cifserror(fmt, arg...)
 #endif          /* _CIFS_DEBUG */
 
 #endif                          /* _H_CIFS_DEBUG */
diff --git a/fs/cifs/cifs_dfs_ref.c b/fs/cifs/cifs_dfs_ref.c
index ce5cbd717bf..6873bb634a9 100644
--- a/fs/cifs/cifs_dfs_ref.c
+++ b/fs/cifs/cifs_dfs_ref.c
@@ -275,8 +275,7 @@ static struct vfsmount *cifs_dfs_do_automount(struct dentry *mntpt)
         struct cifs_sb_info *cifs_sb;
         struct cifs_ses *ses;
         char *full_path;
-        unsigned int xid;
-        int i;
+        int xid, i;
         int rc;
         struct vfsmount *mnt;
         struct tcon_link *tlink;
@@ -303,11 +302,11 @@ static struct vfsmount *cifs_dfs_do_automount(struct dentry *mntpt)
         }
         ses = tlink_tcon(tlink)->ses;
 
-        xid = get_xid();
+        xid = GetXid();
         rc = get_dfs_path(xid, ses, full_path + 1, cifs_sb->local_nls,
                 &num_referrals, &referrals,
                 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
-        free_xid(xid);
+        FreeXid(xid);
 
         cifs_put_tlink(tlink);
 
diff --git a/fs/cifs/cifs_fs_sb.h b/fs/cifs/cifs_fs_sb.h
index c865bfdfe81..7260e11e21f 100644
--- a/fs/cifs/cifs_fs_sb.h
+++ b/fs/cifs/cifs_fs_sb.h
@@ -43,8 +43,6 @@
 #define CIFS_MOUNT_STRICT_IO    0x40000 /* strict cache mode */
 #define CIFS_MOUNT_RWPIDFORWARD 0x80000 /* use pid forwarding for rw */
 #define CIFS_MOUNT_POSIXACL     0x100000 /* mirror of MS_POSIXACL in mnt_cifs_flags */
-#define CIFS_MOUNT_CIFS_BACKUPUID 0x200000 /* backup intent bit for a user */
-#define CIFS_MOUNT_CIFS_BACKUPGID 0x400000 /* backup intent bit for a group */
 
 struct cifs_sb_info {
         struct rb_root tlink_tree;
@@ -57,10 +55,8 @@ struct cifs_sb_info {
         atomic_t active;
         uid_t   mnt_uid;
         gid_t   mnt_gid;
-        uid_t   mnt_backupuid;
-        gid_t   mnt_backupgid;
-        umode_t mnt_file_mode;
-        umode_t mnt_dir_mode;
+        mode_t  mnt_file_mode;
+        mode_t  mnt_dir_mode;
         unsigned int mnt_cifs_flags;
         char   *mountdata; /* options received at mount time or via DFS refs */
         struct backing_dev_info bdi;
diff --git a/fs/cifs/cifs_spnego.c b/fs/cifs/cifs_spnego.c
index 086f381d648..2272fd5fe5b 100644
--- a/fs/cifs/cifs_spnego.c
+++ b/fs/cifs/cifs_spnego.c
@@ -31,18 +31,18 @@
 
 /* create a new cifs key */
 static int
-cifs_spnego_key_instantiate(struct key *key, struct key_preparsed_payload *prep)
+cifs_spnego_key_instantiate(struct key *key, const void *data, size_t datalen)
 {
         char *payload;
         int ret;
 
         ret = -ENOMEM;
-        payload = kmalloc(prep->datalen, GFP_KERNEL);
+        payload = kmalloc(datalen, GFP_KERNEL);
         if (!payload)
                 goto error;
 
         /* attach the data */
-        memcpy(payload, prep->data, prep->datalen);
+        memcpy(payload, data, datalen);
         key->payload.data = payload;
         ret = 0;
 
@@ -113,11 +113,9 @@ cifs_get_spnego_key(struct cifs_ses *sesInfo)
                    MAX_MECH_STR_LEN +
                    UID_KEY_LEN + (sizeof(uid_t) * 2) +
                    CREDUID_KEY_LEN + (sizeof(uid_t) * 2) +
+                   USER_KEY_LEN + strlen(sesInfo->user_name) +
                    PID_KEY_LEN + (sizeof(pid_t) * 2) + 1;
 
-        if (sesInfo->user_name)
-                desc_len += USER_KEY_LEN + strlen(sesInfo->user_name);
-
         spnego_key = ERR_PTR(-ENOMEM);
         description = kzalloc(desc_len, GFP_KERNEL);
         if (description == NULL)
@@ -154,10 +152,8 @@ cifs_get_spnego_key(struct cifs_ses *sesInfo)
         dp = description + strlen(description);
         sprintf(dp, ";creduid=0x%x", sesInfo->cred_uid);
 
-        if (sesInfo->user_name) {
-                dp = description + strlen(description);
-                sprintf(dp, ";user=%s", sesInfo->user_name);
-        }
+        dp = description + strlen(description);
+        sprintf(dp, ";user=%s", sesInfo->user_name);
 
         dp = description + strlen(description);
         sprintf(dp, ";pid=0x%x", current->pid);
diff --git a/fs/cifs/cifs_unicode.c b/fs/cifs/cifs_unicode.c
index 71d5d0a5f6b..1b2e180b018 100644
--- a/fs/cifs/cifs_unicode.c
+++ b/fs/cifs/cifs_unicode.c
@@ -27,17 +27,17 @@
 #include "cifs_debug.h"
 
 /*
- * cifs_utf16_bytes - how long will a string be after conversion?
- * @utf16 - pointer to input string
+ * cifs_ucs2_bytes - how long will a string be after conversion?
+ * @ucs - pointer to input string
  * @maxbytes - don't go past this many bytes of input string
  * @codepage - destination codepage
  *
- * Walk a utf16le string and return the number of bytes that the string will
+ * Walk a ucs2le string and return the number of bytes that the string will
  * be after being converted to the given charset, not including any null
  * termination required. Don't walk past maxbytes in the source buffer.
  */
 int
-cifs_utf16_bytes(const __le16 *from, int maxbytes,
+cifs_ucs2_bytes(const __le16 *from, int maxbytes,
                 const struct nls_table *codepage)
 {
         int i;
@@ -122,7 +122,7 @@ cp_convert:
 }
 
 /*
- * cifs_from_utf16 - convert utf16le string to local charset
+ * cifs_from_ucs2 - convert utf16le string to local charset
  * @to - destination buffer
  * @from - source buffer
  * @tolen - destination buffer size (in bytes)
@@ -130,7 +130,7 @@ cp_convert:
  * @codepage - codepage to which characters should be converted
  * @mapchar - should characters be remapped according to the mapchars option?
  *
- * Convert a little-endian utf16le string (as sent by the server) to a string
+ * Convert a little-endian ucs2le string (as sent by the server) to a string
  * in the provided codepage. The tolen and fromlen parameters are to ensure
  * that the code doesn't walk off of the end of the buffer (which is always
  * a danger if the alignment of the source buffer is off). The destination
@@ -139,12 +139,12 @@ cp_convert:
  * null terminator).
  *
  * Note that some windows versions actually send multiword UTF-16 characters
- * instead of straight UTF16-2. The linux nls routines however aren't able to
+ * instead of straight UCS-2. The linux nls routines however aren't able to
  * deal with those characters properly. In the event that we get some of
  * those characters, they won't be translated properly.
  */
 int
-cifs_from_utf16(char *to, const __le16 *from, int tolen, int fromlen,
+cifs_from_ucs2(char *to, const __le16 *from, int tolen, int fromlen,
                  const struct nls_table *codepage, bool mapchar)
 {
         int i, charlen, safelen;
@@ -190,44 +190,23 @@ cifs_from_utf16(char *to, const __le16 *from, int tolen, int fromlen,
 }
 
 /*
- * NAME:        cifs_strtoUTF16()
+ * NAME:        cifs_strtoUCS()
  *
  * FUNCTION:    Convert character string to unicode string
  *
  */
 int
-cifs_strtoUTF16(__le16 *to, const char *from, int len,
+cifs_strtoUCS(__le16 *to, const char *from, int len,
               const struct nls_table *codepage)
 {
         int charlen;
         int i;
         wchar_t wchar_to; /* needed to quiet sparse */
 
-        /* special case for utf8 to handle no plane0 chars */
-        if (!strcmp(codepage->charset, "utf8")) {
-                /*
-                 * convert utf8 -> utf16, we assume we have enough space
-                 * as caller should have assumed conversion does not overflow
-                 * in destination len is length in wchar_t units (16bits)
-                 */
-                i  = utf8s_to_utf16s(from, len, UTF16_LITTLE_ENDIAN,
-                                       (wchar_t *) to, len);
-
-                /* if success terminate and exit */
-                if (i >= 0)
-                        goto success;
-                /*
-                 * if fails fall back to UCS encoding as this
-                 * function should not return negative values
-                 * currently can fail only if source contains
-                 * invalid encoded characters
-                 */
-        }
-
         for (i = 0; len && *from; i++, from += charlen, len -= charlen) {
                 charlen = codepage->char2uni(from, len, &wchar_to);
                 if (charlen < 1) {
-                        cERROR(1, "strtoUTF16: char2uni of 0x%x returned %d",
+                        cERROR(1, "strtoUCS: char2uni of 0x%x returned %d",
                                 *from, charlen);
                         /* A question mark */
                         wchar_to = 0x003f;
@@ -236,14 +215,12 @@ cifs_strtoUTF16(__le16 *to, const char *from, int len,
                 put_unaligned_le16(wchar_to, &to[i]);
         }
 
-success:
         put_unaligned_le16(0, &to[i]);
         return i;
 }
 
 /*
- * cifs_strndup_from_utf16 - copy a string from wire format to the local
- * codepage
+ * cifs_strndup_from_ucs - copy a string from wire format to the local codepage
  * @src - source string
  * @maxlen - don't walk past this many bytes in the source string
  * @is_unicode - is this a unicode string?
@@ -254,19 +231,19 @@ success:
  * error.
  */
 char *
-cifs_strndup_from_utf16(const char *src, const int maxlen,
-                        const bool is_unicode, const struct nls_table *codepage)
+cifs_strndup_from_ucs(const char *src, const int maxlen, const bool is_unicode,
+             const struct nls_table *codepage)
 {
         int len;
         char *dst;
 
         if (is_unicode) {
-                len = cifs_utf16_bytes((__le16 *) src, maxlen, codepage);
+                len = cifs_ucs2_bytes((__le16 *) src, maxlen, codepage);
                 len += nls_nullsize(codepage);
                 dst = kmalloc(len, GFP_KERNEL);
                 if (!dst)
                         return NULL;
-                cifs_from_utf16(dst, (__le16 *) src, len, maxlen, codepage,
+                cifs_from_ucs2(dst, (__le16 *) src, len, maxlen, codepage,
                                false);
         } else {
                 len = strnlen(src, maxlen);
@@ -287,7 +264,7 @@ cifs_strndup_from_utf16(const char *src, const int maxlen,
  * names are little endian 16 bit Unicode on the wire
  */
 int
-cifsConvertToUTF16(__le16 *target, const char *source, int srclen,
+cifsConvertToUCS(__le16 *target, const char *source, int srclen,
                  const struct nls_table *cp, int mapChars)
 {
         int i, j, charlen;
@@ -296,7 +273,7 @@ cifsConvertToUTF16(__le16 *target, const char *source, int srclen,
         wchar_t tmp;
 
         if (!mapChars)
-                return cifs_strtoUTF16(target, source, PATH_MAX, cp);
+                return cifs_strtoUCS(target, source, PATH_MAX, cp);
 
         for (i = 0, j = 0; i < srclen; j++) {
                 src_char = source[i];
@@ -304,7 +281,7 @@ cifsConvertToUTF16(__le16 *target, const char *source, int srclen,
                 switch (src_char) {
                 case 0:
                         put_unaligned(0, &target[j]);
-                        goto ctoUTF16_out;
+                        goto ctoUCS_out;
                 case ':':
                         dst_char = cpu_to_le16(UNI_COLON);
                         break;
@@ -349,67 +326,7 @@ cifsConvertToUTF16(__le16 *target, const char *source, int srclen,
                 put_unaligned(dst_char, &target[j]);
         }
 
-ctoUTF16_out:
-        return j;
-}
-
-#ifdef CONFIG_CIFS_SMB2
-/*
- * cifs_local_to_utf16_bytes - how long will a string be after conversion?
- * @from - pointer to input string
- * @maxbytes - don't go past this many bytes of input string
- * @codepage - source codepage
- *
- * Walk a string and return the number of bytes that the string will
- * be after being converted to the given charset, not including any null
- * termination required. Don't walk past maxbytes in the source buffer.
- */
-
-static int
-cifs_local_to_utf16_bytes(const char *from, int len,
-                          const struct nls_table *codepage)
-{
-        int charlen;
-        int i;
-        wchar_t wchar_to;
-
-        for (i = 0; len && *from; i++, from += charlen, len -= charlen) {
-                charlen = codepage->char2uni(from, len, &wchar_to);
-                /* Failed conversion defaults to a question mark */
-                if (charlen < 1)
-                        charlen = 1;
-        }
-        return 2 * i; /* UTF16 characters are two bytes */
+ctoUCS_out:
+        return i;
 }
 
-/*
- * cifs_strndup_to_utf16 - copy a string to wire format from the local codepage
- * @src - source string
- * @maxlen - don't walk past this many bytes in the source string
- * @utf16_len - the length of the allocated string in bytes (including null)
- * @cp - source codepage
- * @remap - map special chars
- *
- * Take a string convert it from the local codepage to UTF16 and
- * put it in a new buffer. Returns a pointer to the new string or NULL on
- * error.
- */
-__le16 *
-cifs_strndup_to_utf16(const char *src, const int maxlen, int *utf16_len,
-                      const struct nls_table *cp, int remap)
-{
-        int len;
-        __le16 *dst;
-
-        len = cifs_local_to_utf16_bytes(src, maxlen, cp);
-        len += 2; /* NULL */
-        dst = kmalloc(len, GFP_KERNEL);
-        if (!dst) {
-                *utf16_len = 0;
-                return NULL;
-        }
-        cifsConvertToUTF16(dst, src, strlen(src), cp, remap);
-        *utf16_len = len;
-        return dst;
-}
-#endif /* CONFIG_CIFS_SMB2 */
diff --git a/fs/cifs/cifs_unicode.h b/fs/cifs/cifs_unicode.h
index 4fb097468e2..6d02fd56056 100644
--- a/fs/cifs/cifs_unicode.h
+++ b/fs/cifs/cifs_unicode.h
@@ -74,21 +74,17 @@ extern const struct UniCaseRange CifsUniLowerRange[];
 #endif                          /* UNIUPR_NOLOWER */
 
 #ifdef __KERNEL__
-int cifs_from_utf16(char *to, const __le16 *from, int tolen, int fromlen,
-                    const struct nls_table *codepage, bool mapchar);
-int cifs_utf16_bytes(const __le16 *from, int maxbytes,
-                     const struct nls_table *codepage);
-int cifs_strtoUTF16(__le16 *, const char *, int, const struct nls_table *);
-char *cifs_strndup_from_utf16(const char *src, const int maxlen,
-                              const bool is_unicode,
-                              const struct nls_table *codepage);
-extern int cifsConvertToUTF16(__le16 *target, const char *source, int maxlen,
-                              const struct nls_table *cp, int mapChars);
-#ifdef CONFIG_CIFS_SMB2
-extern __le16 *cifs_strndup_to_utf16(const char *src, const int maxlen,
-                                     int *utf16_len, const struct nls_table *cp,
-                                     int remap);
-#endif /* CONFIG_CIFS_SMB2 */
+int cifs_from_ucs2(char *to, const __le16 *from, int tolen, int fromlen,
+                   const struct nls_table *codepage, bool mapchar);
+int cifs_ucs2_bytes(const __le16 *from, int maxbytes,
+                    const struct nls_table *codepage);
+int cifs_strtoUCS(__le16 *, const char *, int, const struct nls_table *);
+char *cifs_strndup_from_ucs(const char *src, const int maxlen,
+                            const bool is_unicode,
+                            const struct nls_table *codepage);
+extern int cifsConvertToUCS(__le16 *target, const char *source, int maxlen,
+                        const struct nls_table *cp, int mapChars);
+
 #endif
 
 /*
diff --git a/fs/cifs/cifsacl.c b/fs/cifs/cifsacl.c
index 5cbd00e7406..d0f59faefb7 100644
--- a/fs/cifs/cifsacl.c
+++ b/fs/cifs/cifsacl.c
@@ -42,45 +42,84 @@ static const struct cifs_sid sid_authusers = {
 /* group users */
 static const struct cifs_sid sid_user = {1, 2 , {0, 0, 0, 0, 0, 5}, {} };
 
-static const struct cred *root_cred;
+const struct cred *root_cred;
+
+static void
+shrink_idmap_tree(struct rb_root *root, int nr_to_scan, int *nr_rem,
+                        int *nr_del)
+{
+        struct rb_node *node;
+        struct rb_node *tmp;
+        struct cifs_sid_id *psidid;
+
+        node = rb_first(root);
+        while (node) {
+                tmp = node;
+                node = rb_next(tmp);
+                psidid = rb_entry(tmp, struct cifs_sid_id, rbnode);
+                if (nr_to_scan == 0 || *nr_del == nr_to_scan)
+                        ++(*nr_rem);
+                else {
+                        if (time_after(jiffies, psidid->time + SID_MAP_EXPIRE)
+                                                && psidid->refcount == 0) {
+                                rb_erase(tmp, root);
+                                ++(*nr_del);
+                        } else
+                                ++(*nr_rem);
+                }
+        }
+}
+
+/*
+ * Run idmap cache shrinker.
+ */
+static int
+cifs_idmap_shrinker(struct shrinker *shrink, struct shrink_control *sc)
+{
+        int nr_to_scan = sc->nr_to_scan;
+        int nr_del = 0;
+        int nr_rem = 0;
+        struct rb_root *root;
+
+        root = &uidtree;
+        spin_lock(&siduidlock);
+        shrink_idmap_tree(root, nr_to_scan, &nr_rem, &nr_del);
+        spin_unlock(&siduidlock);
+
+        root = &gidtree;
+        spin_lock(&sidgidlock);
+        shrink_idmap_tree(root, nr_to_scan, &nr_rem, &nr_del);
+        spin_unlock(&sidgidlock);
+
+        return nr_rem;
+}
+
+static struct shrinker cifs_shrinker = {
+        .shrink = cifs_idmap_shrinker,
+        .seeks = DEFAULT_SEEKS,
+};
 
 static int
-cifs_idmap_key_instantiate(struct key *key, struct key_preparsed_payload *prep)
+cifs_idmap_key_instantiate(struct key *key, const void *data, size_t datalen)
 {
         char *payload;
 
-        /*
-         * If the payload is less than or equal to the size of a pointer, then
-         * an allocation here is wasteful. Just copy the data directly to the
-         * payload.value union member instead.
-         *
-         * With this however, you must check the datalen before trying to
-         * dereference payload.data!
-         */
-        if (prep->datalen <= sizeof(key->payload)) {
-                key->payload.value = 0;
-                memcpy(&key->payload.value, prep->data, prep->datalen);
-                key->datalen = prep->datalen;
-                return 0;
-        }
-        payload = kmalloc(prep->datalen, GFP_KERNEL);
+        payload = kmalloc(datalen, GFP_KERNEL);
         if (!payload)
                 return -ENOMEM;
 
-        memcpy(payload, prep->data, prep->datalen);
+        memcpy(payload, data, datalen);
         key->payload.data = payload;
-        key->datalen = prep->datalen;
         return 0;
 }
 
 static inline void
 cifs_idmap_key_destroy(struct key *key)
 {
-        if (key->datalen > sizeof(key->payload))
-                kfree(key->payload.data);
+        kfree(key->payload.data);
 }
 
-static struct key_type cifs_idmap_key_type = {
+struct key_type cifs_idmap_key_type = {
         .name        = "cifs.idmap",
         .instantiate = cifs_idmap_key_instantiate,
         .destroy     = cifs_idmap_key_destroy,
@@ -88,174 +127,100 @@ static struct key_type cifs_idmap_key_type = {
         .match       = user_match,
 };
 
-static char *
-sid_to_key_str(struct cifs_sid *sidptr, unsigned int type)
+static void
+sid_to_str(struct cifs_sid *sidptr, char *sidstr)
 {
-        int i, len;
-        unsigned int saval;
-        char *sidstr, *strptr;
-        unsigned long long id_auth_val;
-
-        /* 3 bytes for prefix */
-        sidstr = kmalloc(3 + SID_STRING_BASE_SIZE +
-                         (SID_STRING_SUBAUTH_SIZE * sidptr->num_subauth),
-                         GFP_KERNEL);
-        if (!sidstr)
-                return sidstr;
+        int i;
+        unsigned long saval;
+        char *strptr;
 
         strptr = sidstr;
-        len = sprintf(strptr, "%cs:S-%hhu", type == SIDOWNER ? 'o' : 'g',
-                        sidptr->revision);
-        strptr += len;
-
-        /* The authority field is a single 48-bit number */
-        id_auth_val = (unsigned long long)sidptr->authority[5];
-        id_auth_val |= (unsigned long long)sidptr->authority[4] << 8;
-        id_auth_val |= (unsigned long long)sidptr->authority[3] << 16;
-        id_auth_val |= (unsigned long long)sidptr->authority[2] << 24;
-        id_auth_val |= (unsigned long long)sidptr->authority[1] << 32;
-        id_auth_val |= (unsigned long long)sidptr->authority[0] << 48;
 
-        /*
-         * MS-DTYP states that if the authority is >= 2^32, then it should be
-         * expressed as a hex value.
-         */
-        if (id_auth_val <= UINT_MAX)
-                len = sprintf(strptr, "-%llu", id_auth_val);
-        else
-                len = sprintf(strptr, "-0x%llx", id_auth_val);
+        sprintf(strptr, "%s", "S");
+        strptr = sidstr + strlen(sidstr);
 
-        strptr += len;
+        sprintf(strptr, "-%d", sidptr->revision);
+        strptr = sidstr + strlen(sidstr);
+
+        for (i = 0; i < 6; ++i) {
+                if (sidptr->authority[i]) {
+                        sprintf(strptr, "-%d", sidptr->authority[i]);
+                        strptr = sidstr + strlen(sidstr);
+                }
+        }
 
         for (i = 0; i < sidptr->num_subauth; ++i) {
                 saval = le32_to_cpu(sidptr->sub_auth[i]);
-                len = sprintf(strptr, "-%u", saval);
-                strptr += len;
+                sprintf(strptr, "-%ld", saval);
+                strptr = sidstr + strlen(sidstr);
         }
-
-        return sidstr;
 }
 
-/*
- * if the two SIDs (roughly equivalent to a UUID for a user or group) are
- * the same returns zero, if they do not match returns non-zero.
- */
-static int
-compare_sids(const struct cifs_sid *ctsid, const struct cifs_sid *cwsid)
+static void
+id_rb_insert(struct rb_root *root, struct cifs_sid *sidptr,
+                struct cifs_sid_id **psidid, char *typestr)
 {
-        int i;
-        int num_subauth, num_sat, num_saw;
-
-        if ((!ctsid) || (!cwsid))
-                return 1;
-
-        /* compare the revision */
-        if (ctsid->revision != cwsid->revision) {
-                if (ctsid->revision > cwsid->revision)
-                        return 1;
-                else
-                        return -1;
-        }
-
-        /* compare all of the six auth values */
-        for (i = 0; i < NUM_AUTHS; ++i) {
-                if (ctsid->authority[i] != cwsid->authority[i]) {
-                        if (ctsid->authority[i] > cwsid->authority[i])
-                                return 1;
-                        else
-                                return -1;
+        int rc;
+        char *strptr;
+        struct rb_node *node = root->rb_node;
+        struct rb_node *parent = NULL;
+        struct rb_node **linkto = &(root->rb_node);
+        struct cifs_sid_id *lsidid;
+
+        while (node) {
+                lsidid = rb_entry(node, struct cifs_sid_id, rbnode);
+                parent = node;
+                rc = compare_sids(sidptr, &((lsidid)->sid));
+                if (rc > 0) {
+                        linkto = &(node->rb_left);
+                        node = node->rb_left;
+                } else if (rc < 0) {
+                        linkto = &(node->rb_right);
+                        node = node->rb_right;
                 }
         }
 
-        /* compare all of the subauth values if any */
-        num_sat = ctsid->num_subauth;
-        num_saw = cwsid->num_subauth;
-        num_subauth = num_sat < num_saw ? num_sat : num_saw;
-        if (num_subauth) {
-                for (i = 0; i < num_subauth; ++i) {
-                        if (ctsid->sub_auth[i] != cwsid->sub_auth[i]) {
-                                if (le32_to_cpu(ctsid->sub_auth[i]) >
-                                        le32_to_cpu(cwsid->sub_auth[i]))
-                                        return 1;
-                                else
-                                        return -1;
-                        }
-                }
-        }
+        memcpy(&(*psidid)->sid, sidptr, sizeof(struct cifs_sid));
+        (*psidid)->time = jiffies - (SID_MAP_RETRY + 1);
+        (*psidid)->refcount = 0;
 
-        return 0; /* sids compare/match */
-}
+        sprintf((*psidid)->sidstr, "%s", typestr);
+        strptr = (*psidid)->sidstr + strlen((*psidid)->sidstr);
+        sid_to_str(&(*psidid)->sid, strptr);
 
-static void
-cifs_copy_sid(struct cifs_sid *dst, const struct cifs_sid *src)
-{
-        int i;
+        clear_bit(SID_ID_PENDING, &(*psidid)->state);
+        clear_bit(SID_ID_MAPPED, &(*psidid)->state);
 
-        dst->revision = src->revision;
-        dst->num_subauth = min_t(u8, src->num_subauth, SID_MAX_SUB_AUTHORITIES);
-        for (i = 0; i < NUM_AUTHS; ++i)
-                dst->authority[i] = src->authority[i];
-        for (i = 0; i < dst->num_subauth; ++i)
-                dst->sub_auth[i] = src->sub_auth[i];
+        rb_link_node(&(*psidid)->rbnode, parent, linkto);
+        rb_insert_color(&(*psidid)->rbnode, root);
 }
 
-static int
-id_to_sid(unsigned int cid, uint sidtype, struct cifs_sid *ssid)
+static struct cifs_sid_id *
+id_rb_search(struct rb_root *root, struct cifs_sid *sidptr)
 {
         int rc;
-        struct key *sidkey;
-        struct cifs_sid *ksid;
-        unsigned int ksid_size;
-        char desc[3 + 10 + 1]; /* 3 byte prefix + 10 bytes for value + NULL */
-        const struct cred *saved_cred;
-
-        rc = snprintf(desc, sizeof(desc), "%ci:%u",
-                        sidtype == SIDOWNER ? 'o' : 'g', cid);
-        if (rc >= sizeof(desc))
-                return -EINVAL;
-
-        rc = 0;
-        saved_cred = override_creds(root_cred);
-        sidkey = request_key(&cifs_idmap_key_type, desc, "");
-        if (IS_ERR(sidkey)) {
-                rc = -EINVAL;
-                cFYI(1, "%s: Can't map %cid %u to a SID", __func__,
-                        sidtype == SIDOWNER ? 'u' : 'g', cid);
-                goto out_revert_creds;
-        } else if (sidkey->datalen < CIFS_SID_BASE_SIZE) {
-                rc = -EIO;
-                cFYI(1, "%s: Downcall contained malformed key "
-                        "(datalen=%hu)", __func__, sidkey->datalen);
-                goto invalidate_key;
-        }
-
-        /*
-         * A sid is usually too large to be embedded in payload.value, but if
-         * there are no subauthorities and the host has 8-byte pointers, then
-         * it could be.
-         */
-        ksid = sidkey->datalen <= sizeof(sidkey->payload) ?
-                (struct cifs_sid *)&sidkey->payload.value :
-                (struct cifs_sid *)sidkey->payload.data;
-
-        ksid_size = CIFS_SID_BASE_SIZE + (ksid->num_subauth * sizeof(__le32));
-        if (ksid_size > sidkey->datalen) {
-                rc = -EIO;
-                cFYI(1, "%s: Downcall contained malformed key (datalen=%hu, "
-                        "ksid_size=%u)", __func__, sidkey->datalen, ksid_size);
-                goto invalidate_key;
+        struct rb_node *node = root->rb_node;
+        struct cifs_sid_id *lsidid;
+
+        while (node) {
+                lsidid = rb_entry(node, struct cifs_sid_id, rbnode);
+                rc = compare_sids(sidptr, &((lsidid)->sid));
+                if (rc > 0) {
+                        node = node->rb_left;
+                } else if (rc < 0) {
+                        node = node->rb_right;
+                } else /* node found */
+                        return lsidid;
         }
 
-        cifs_copy_sid(ssid, ksid);
-out_key_put:
-        key_put(sidkey);
-out_revert_creds:
-        revert_creds(saved_cred);
-        return rc;
+        return NULL;
+}
 
-invalidate_key:
-        key_invalidate(sidkey);
-        goto out_key_put;
+static int
+sidid_pending_wait(void *unused)
+{
+        schedule();
+        return signal_pending(current) ? -ERESTARTSYS : 0;
 }
 
 static int
@@ -263,67 +228,111 @@ sid_to_id(struct cifs_sb_info *cifs_sb, struct cifs_sid *psid,
                 struct cifs_fattr *fattr, uint sidtype)
 {
         int rc;
-        struct key *sidkey;
-        char *sidstr;
+        unsigned long cid;
+        struct key *idkey;
         const struct cred *saved_cred;
-        uid_t fuid = cifs_sb->mnt_uid;
-        gid_t fgid = cifs_sb->mnt_gid;
-
-        /*
-         * If we have too many subauthorities, then something is really wrong.
-         * Just return an error.
-         */
-        if (unlikely(psid->num_subauth > SID_MAX_SUB_AUTHORITIES)) {
-                cFYI(1, "%s: %u subauthorities is too many!", __func__,
-                        psid->num_subauth);
-                return -EIO;
-        }
-
-        sidstr = sid_to_key_str(psid, sidtype);
-        if (!sidstr)
-                return -ENOMEM;
+        struct cifs_sid_id *psidid, *npsidid;
+        struct rb_root *cidtree;
+        spinlock_t *cidlock;
+
+        if (sidtype == SIDOWNER) {
+                cid = cifs_sb->mnt_uid; /* default uid, in case upcall fails */
+                cidlock = &siduidlock;
+                cidtree = &uidtree;
+        } else if (sidtype == SIDGROUP) {
+                cid = cifs_sb->mnt_gid; /* default gid, in case upcall fails */
+                cidlock = &sidgidlock;
+                cidtree = &gidtree;
+        } else
+                return -ENOENT;
+
+        spin_lock(cidlock);
+        psidid = id_rb_search(cidtree, psid);
+
+        if (!psidid) { /* node does not exist, allocate one & attempt adding */
+                spin_unlock(cidlock);
+                npsidid = kzalloc(sizeof(struct cifs_sid_id), GFP_KERNEL);
+                if (!npsidid)
+                        return -ENOMEM;
+
+                npsidid->sidstr = kmalloc(SIDLEN, GFP_KERNEL);
+                if (!npsidid->sidstr) {
+                        kfree(npsidid);
+                        return -ENOMEM;
+                }
 
-        saved_cred = override_creds(root_cred);
-        sidkey = request_key(&cifs_idmap_key_type, sidstr, "");
-        if (IS_ERR(sidkey)) {
-                rc = -EINVAL;
-                cFYI(1, "%s: Can't map SID %s to a %cid", __func__, sidstr,
-                        sidtype == SIDOWNER ? 'u' : 'g');
-                goto out_revert_creds;
+                spin_lock(cidlock);
+                psidid = id_rb_search(cidtree, psid);
+                if (psidid) { /* node happened to get inserted meanwhile */
+                        ++psidid->refcount;
+                        spin_unlock(cidlock);
+                        kfree(npsidid->sidstr);
+                        kfree(npsidid);
+                } else {
+                        psidid = npsidid;
+                        id_rb_insert(cidtree, psid, &psidid,
+                                        sidtype == SIDOWNER ? "os:" : "gs:");
+                        ++psidid->refcount;
+                        spin_unlock(cidlock);
+                }
+        } else {
+                ++psidid->refcount;
+                spin_unlock(cidlock);
         }
 
         /*
-         * FIXME: Here we assume that uid_t and gid_t are same size. It's
-         * probably a safe assumption but might be better to check based on
-         * sidtype.
+         * If we are here, it is safe to access psidid and its fields
+         * since a reference was taken earlier while holding the spinlock.
+         * A reference on the node is put without holding the spinlock
+         * and it is OK to do so in this case, shrinker will not erase
+         * this node until all references are put and we do not access
+         * any fields of the node after a reference is put .
          */
-        if (sidkey->datalen != sizeof(uid_t)) {
-                rc = -EIO;
-                cFYI(1, "%s: Downcall contained malformed key "
-                        "(datalen=%hu)", __func__, sidkey->datalen);
-                key_invalidate(sidkey);
-                goto out_key_put;
+        if (test_bit(SID_ID_MAPPED, &psidid->state)) {
+                cid = psidid->id;
+                psidid->time = jiffies; /* update ts for accessing */
+                goto sid_to_id_out;
         }
 
-        if (sidtype == SIDOWNER)
-                memcpy(&fuid, &sidkey->payload.value, sizeof(uid_t));
-        else
-                memcpy(&fgid, &sidkey->payload.value, sizeof(gid_t));
-
-out_key_put:
-        key_put(sidkey);
-out_revert_creds:
-        revert_creds(saved_cred);
-        kfree(sidstr);
+        if (time_after(psidid->time + SID_MAP_RETRY, jiffies))
+                goto sid_to_id_out;
+
+        if (!test_and_set_bit(SID_ID_PENDING, &psidid->state)) {
+                saved_cred = override_creds(root_cred);
+                idkey = request_key(&cifs_idmap_key_type, psidid->sidstr, "");
+                if (IS_ERR(idkey))
+                        cFYI(1, "%s: Can't map SID to an id", __func__);
+                else {
+                        cid = *(unsigned long *)idkey->payload.value;
+                        psidid->id = cid;
+                        set_bit(SID_ID_MAPPED, &psidid->state);
+                        key_put(idkey);
+                        kfree(psidid->sidstr);
+                }
+                revert_creds(saved_cred);
+                psidid->time = jiffies; /* update ts for accessing */
+                clear_bit(SID_ID_PENDING, &psidid->state);
+                wake_up_bit(&psidid->state, SID_ID_PENDING);
+        } else {
+                rc = wait_on_bit(&psidid->state, SID_ID_PENDING,
+                                sidid_pending_wait, TASK_INTERRUPTIBLE);
+                if (rc) {
+                        cFYI(1, "%s: sidid_pending_wait interrupted %d",
+                                        __func__, rc);
+                        --psidid->refcount; /* decremented without spinlock */
+                        return rc;
+                }
+                if (test_bit(SID_ID_MAPPED, &psidid->state))
+                        cid = psidid->id;
+        }
 
-        /*
-         * Note that we return 0 here unconditionally. If the mapping
-         * fails then we just fall back to using the mnt_uid/mnt_gid.
-         */
+sid_to_id_out:
+        --psidid->refcount; /* decremented without spinlock */
         if (sidtype == SIDOWNER)
-                fattr->cf_uid = fuid;
+                fattr->cf_uid = cid;
         else
-                fattr->cf_gid = fgid;
+                fattr->cf_gid = cid;
+
         return 0;
 }
 
@@ -334,7 +343,7 @@ init_cifs_idmap(void)
         struct key *keyring;
         int ret;
 
-        cFYI(1, "Registering the %s key type", cifs_idmap_key_type.name);
+        cFYI(1, "Registering the %s key type\n", cifs_idmap_key_type.name);
 
         /* create an override credential set with a special thread keyring in
          * which requests are cached
@@ -346,27 +355,37 @@ init_cifs_idmap(void)
         if (!cred)
                 return -ENOMEM;
 
-        keyring = keyring_alloc(".cifs_idmap", 0, 0, cred,
-                                (KEY_POS_ALL & ~KEY_POS_SETATTR) |
-                                KEY_USR_VIEW | KEY_USR_READ,
-                                KEY_ALLOC_NOT_IN_QUOTA, NULL);
+        keyring = key_alloc(&key_type_keyring, ".cifs_idmap", 0, 0, cred,
+                            (KEY_POS_ALL & ~KEY_POS_SETATTR) |
+                            KEY_USR_VIEW | KEY_USR_READ,
+                            KEY_ALLOC_NOT_IN_QUOTA);
         if (IS_ERR(keyring)) {
                 ret = PTR_ERR(keyring);
                 goto failed_put_cred;
         }
 
+        ret = key_instantiate_and_link(keyring, NULL, 0, NULL, NULL);
+        if (ret < 0)
+                goto failed_put_key;
+
         ret = register_key_type(&cifs_idmap_key_type);
         if (ret < 0)
                 goto failed_put_key;
 
         /* instruct request_key() to use this special keyring as a cache for
          * the results it looks up */
-        set_bit(KEY_FLAG_ROOT_CAN_CLEAR, &keyring->flags);
         cred->thread_keyring = keyring;
         cred->jit_keyring = KEY_REQKEY_DEFL_THREAD_KEYRING;
         root_cred = cred;
 
-        cFYI(1, "cifs idmap keyring: %d", key_serial(keyring));
+        spin_lock_init(&siduidlock);
+        uidtree = RB_ROOT;
+        spin_lock_init(&sidgidlock);
+        gidtree = RB_ROOT;
+
+        register_shrinker(&cifs_shrinker);
+
+        cFYI(1, "cifs idmap keyring: %d\n", key_serial(keyring));
         return 0;
 
 failed_put_key:
@@ -382,13 +401,83 @@ exit_cifs_idmap(void)
         key_revoke(root_cred->thread_keyring);
         unregister_key_type(&cifs_idmap_key_type);
         put_cred(root_cred);
-        cFYI(1, "Unregistered %s key type", cifs_idmap_key_type.name);
+        unregister_shrinker(&cifs_shrinker);
+        cFYI(1, "Unregistered %s key type\n", cifs_idmap_key_type.name);
+}
+
+void
+cifs_destroy_idmaptrees(void)
+{
+        struct rb_root *root;
+        struct rb_node *node;
+
+        root = &uidtree;
+        spin_lock(&siduidlock);
+        while ((node = rb_first(root)))
+                rb_erase(node, root);
+        spin_unlock(&siduidlock);
+
+        root = &gidtree;
+        spin_lock(&sidgidlock);
+        while ((node = rb_first(root)))
+                rb_erase(node, root);
+        spin_unlock(&sidgidlock);
+}
+
+/* if the two SIDs (roughly equivalent to a UUID for a user or group) are
+   the same returns 1, if they do not match returns 0 */
+int compare_sids(const struct cifs_sid *ctsid, const struct cifs_sid *cwsid)
+{
+        int i;
+        int num_subauth, num_sat, num_saw;
+
+        if ((!ctsid) || (!cwsid))
+                return 1;
+
+        /* compare the revision */
+        if (ctsid->revision != cwsid->revision) {
+                if (ctsid->revision > cwsid->revision)
+                        return 1;
+                else
+                        return -1;
+        }
+
+        /* compare all of the six auth values */
+        for (i = 0; i < 6; ++i) {
+                if (ctsid->authority[i] != cwsid->authority[i]) {
+                        if (ctsid->authority[i] > cwsid->authority[i])
+                                return 1;
+                        else
+                                return -1;
+                }
+        }
+
+        /* compare all of the subauth values if any */
+        num_sat = ctsid->num_subauth;
+        num_saw = cwsid->num_subauth;
+        num_subauth = num_sat < num_saw ? num_sat : num_saw;
+        if (num_subauth) {
+                for (i = 0; i < num_subauth; ++i) {
+                        if (ctsid->sub_auth[i] != cwsid->sub_auth[i]) {
+                                if (le32_to_cpu(ctsid->sub_auth[i]) >
+                                        le32_to_cpu(cwsid->sub_auth[i]))
+                                        return 1;
+                                else
+                                        return -1;
+                        }
+                }
+        }
+
+        return 0; /* sids compare/match */
 }
 
+
 /* copy ntsd, owner sid, and group sid from a security descriptor to another */
 static void copy_sec_desc(const struct cifs_ntsd *pntsd,
                                 struct cifs_ntsd *pnntsd, __u32 sidsoffset)
 {
+        int i;
+
         struct cifs_sid *owner_sid_ptr, *group_sid_ptr;
         struct cifs_sid *nowner_sid_ptr, *ngroup_sid_ptr;
 
@@ -404,14 +493,26 @@ static void copy_sec_desc(const struct cifs_ntsd *pntsd,
         owner_sid_ptr = (struct cifs_sid *)((char *)pntsd +
                                 le32_to_cpu(pntsd->osidoffset));
         nowner_sid_ptr = (struct cifs_sid *)((char *)pnntsd + sidsoffset);
-        cifs_copy_sid(nowner_sid_ptr, owner_sid_ptr);
+
+        nowner_sid_ptr->revision = owner_sid_ptr->revision;
+        nowner_sid_ptr->num_subauth = owner_sid_ptr->num_subauth;
+        for (i = 0; i < 6; i++)
+                nowner_sid_ptr->authority[i] = owner_sid_ptr->authority[i];
+        for (i = 0; i < 5; i++)
+                nowner_sid_ptr->sub_auth[i] = owner_sid_ptr->sub_auth[i];
 
         /* copy group sid */
         group_sid_ptr = (struct cifs_sid *)((char *)pntsd +
                                 le32_to_cpu(pntsd->gsidoffset));
         ngroup_sid_ptr = (struct cifs_sid *)((char *)pnntsd + sidsoffset +
                                         sizeof(struct cifs_sid));
-        cifs_copy_sid(ngroup_sid_ptr, group_sid_ptr);
+
+        ngroup_sid_ptr->revision = group_sid_ptr->revision;
+        ngroup_sid_ptr->num_subauth = group_sid_ptr->num_subauth;
+        for (i = 0; i < 6; i++)
+                ngroup_sid_ptr->authority[i] = group_sid_ptr->authority[i];
+        for (i = 0; i < 5; i++)
+                ngroup_sid_ptr->sub_auth[i] = group_sid_ptr->sub_auth[i];
 
         return;
 }
@@ -518,7 +619,7 @@ static __u16 fill_ace_for_sid(struct cifs_ace *pntace,
 
         pntace->sid.revision = psid->revision;
         pntace->sid.num_subauth = psid->num_subauth;
-        for (i = 0; i < NUM_AUTHS; i++)
+        for (i = 0; i < 6; i++)
                 pntace->sid.authority[i] = psid->authority[i];
         for (i = 0; i < psid->num_subauth; i++)
                 pntace->sid.sub_auth[i] = psid->sub_auth[i];
@@ -605,13 +706,11 @@ static void parse_dacl(struct cifs_acl *pdacl, char *end_of_acl,
         acl_size = sizeof(struct cifs_acl);
 
         num_aces = le32_to_cpu(pdacl->num_aces);
-        if (num_aces > 0) {
+        if (num_aces  > 0) {
                 umode_t user_mask = S_IRWXU;
                 umode_t group_mask = S_IRWXG;
                 umode_t other_mask = S_IRWXU | S_IRWXG | S_IRWXO;
 
-                if (num_aces > ULONG_MAX / sizeof(struct cifs_ace *))
-                        return;
                 ppace = kmalloc(num_aces * sizeof(struct cifs_ace *),
                                 GFP_KERNEL);
                 if (!ppace) {
@@ -694,8 +793,8 @@ static int parse_sid(struct cifs_sid *psid, char *end_of_acl)
                 return -EINVAL;
         }
 
-#ifdef CONFIG_CIFS_DEBUG2
         if (psid->num_subauth) {
+#ifdef CONFIG_CIFS_DEBUG2
                 int i;
                 cFYI(1, "SID revision %d num_auth %d",
                         psid->revision, psid->num_subauth);
@@ -709,8 +808,8 @@ static int parse_sid(struct cifs_sid *psid, char *end_of_acl)
                         num auths and therefore go off the end */
                 cFYI(1, "RID 0x%x",
                         le32_to_cpu(psid->sub_auth[psid->num_subauth-1]));
-        }
 #endif
+        }
 
         return 0;
 }
@@ -769,80 +868,52 @@ static int parse_sec_desc(struct cifs_sb_info *cifs_sb,
         else
                 cFYI(1, "no ACL"); /* BB grant all or default perms? */
 
+/*      cifscred->uid = owner_sid_ptr->rid;
+        cifscred->gid = group_sid_ptr->rid;
+        memcpy((void *)(&(cifscred->osid)), (void *)owner_sid_ptr,
+                        sizeof(struct cifs_sid));
+        memcpy((void *)(&(cifscred->gsid)), (void *)group_sid_ptr,
+                        sizeof(struct cifs_sid)); */
+
         return rc;
 }
 
+
 /* Convert permission bits from mode to equivalent CIFS ACL */
 static int build_sec_desc(struct cifs_ntsd *pntsd, struct cifs_ntsd *pnntsd,
-        __u32 secdesclen, __u64 nmode, uid_t uid, gid_t gid, int *aclflag)
+                                struct inode *inode, __u64 nmode)
 {
         int rc = 0;
         __u32 dacloffset;
         __u32 ndacloffset;
         __u32 sidsoffset;
         struct cifs_sid *owner_sid_ptr, *group_sid_ptr;
-        struct cifs_sid *nowner_sid_ptr, *ngroup_sid_ptr;
         struct cifs_acl *dacl_ptr = NULL;  /* no need for SACL ptr */
         struct cifs_acl *ndacl_ptr = NULL; /* no need for SACL ptr */
 
-        if (nmode != NO_CHANGE_64) { /* chmod */
-                owner_sid_ptr = (struct cifs_sid *)((char *)pntsd +
+        if ((inode == NULL) || (pntsd == NULL) || (pnntsd == NULL))
+                return -EIO;
+
+        owner_sid_ptr = (struct cifs_sid *)((char *)pntsd +
                                 le32_to_cpu(pntsd->osidoffset));
-                group_sid_ptr = (struct cifs_sid *)((char *)pntsd +
+        group_sid_ptr = (struct cifs_sid *)((char *)pntsd +
                                 le32_to_cpu(pntsd->gsidoffset));
-                dacloffset = le32_to_cpu(pntsd->dacloffset);
-                dacl_ptr = (struct cifs_acl *)((char *)pntsd + dacloffset);
-                ndacloffset = sizeof(struct cifs_ntsd);
-                ndacl_ptr = (struct cifs_acl *)((char *)pnntsd + ndacloffset);
-                ndacl_ptr->revision = dacl_ptr->revision;
-                ndacl_ptr->size = 0;
-                ndacl_ptr->num_aces = 0;
-
-                rc = set_chmod_dacl(ndacl_ptr, owner_sid_ptr, group_sid_ptr,
-                                        nmode);
-                sidsoffset = ndacloffset + le16_to_cpu(ndacl_ptr->size);
-                /* copy sec desc control portion & owner and group sids */
-                copy_sec_desc(pntsd, pnntsd, sidsoffset);
-                *aclflag = CIFS_ACL_DACL;
-        } else {
-                memcpy(pnntsd, pntsd, secdesclen);
-                if (uid != NO_CHANGE_32) { /* chown */
-                        owner_sid_ptr = (struct cifs_sid *)((char *)pnntsd +
-                                        le32_to_cpu(pnntsd->osidoffset));
-                        nowner_sid_ptr = kmalloc(sizeof(struct cifs_sid),
-                                                                GFP_KERNEL);
-                        if (!nowner_sid_ptr)
-                                return -ENOMEM;
-                        rc = id_to_sid(uid, SIDOWNER, nowner_sid_ptr);
-                        if (rc) {
-                                cFYI(1, "%s: Mapping error %d for owner id %d",
-                                                __func__, rc, uid);
-                                kfree(nowner_sid_ptr);
-                                return rc;
-                        }
-                        cifs_copy_sid(owner_sid_ptr, nowner_sid_ptr);
-                        kfree(nowner_sid_ptr);
-                        *aclflag = CIFS_ACL_OWNER;
-                }
-                if (gid != NO_CHANGE_32) { /* chgrp */
-                        group_sid_ptr = (struct cifs_sid *)((char *)pnntsd +
-                                        le32_to_cpu(pnntsd->gsidoffset));
-                        ngroup_sid_ptr = kmalloc(sizeof(struct cifs_sid),
-                                                                GFP_KERNEL);
-                        if (!ngroup_sid_ptr)
-                                return -ENOMEM;
-                        rc = id_to_sid(gid, SIDGROUP, ngroup_sid_ptr);
-                        if (rc) {
-                                cFYI(1, "%s: Mapping error %d for group id %d",
-                                                __func__, rc, gid);
-                                kfree(ngroup_sid_ptr);
-                                return rc;
-                        }
-                        cifs_copy_sid(group_sid_ptr, ngroup_sid_ptr);
-                        kfree(ngroup_sid_ptr);
-                        *aclflag = CIFS_ACL_GROUP;
-                }
-        }
+
+        dacloffset = le32_to_cpu(pntsd->dacloffset);
+        dacl_ptr = (struct cifs_acl *)((char *)pntsd + dacloffset);
+
+        ndacloffset = sizeof(struct cifs_ntsd);
+        ndacl_ptr = (struct cifs_acl *)((char *)pnntsd + ndacloffset);
+        ndacl_ptr->revision = dacl_ptr->revision;
+        ndacl_ptr->size = 0;
+        ndacl_ptr->num_aces = 0;
+
+        rc = set_chmod_dacl(ndacl_ptr, owner_sid_ptr, group_sid_ptr, nmode);
+
+        sidsoffset = ndacloffset + le16_to_cpu(ndacl_ptr->size);
+
+        /* copy security descriptor control portion and owner and group sid */
+        copy_sec_desc(pntsd, pnntsd, sidsoffset);
 
         return rc;
 }
@@ -851,16 +922,15 @@ static struct cifs_ntsd *get_cifs_acl_by_fid(struct cifs_sb_info *cifs_sb,
                 __u16 fid, u32 *pacllen)
 {
         struct cifs_ntsd *pntsd = NULL;
-        unsigned int xid;
-        int rc;
+        int xid, rc;
         struct tcon_link *tlink = cifs_sb_tlink(cifs_sb);
 
         if (IS_ERR(tlink))
                 return ERR_CAST(tlink);
 
-        xid = get_xid();
+        xid = GetXid();
         rc = CIFSSMBGetCIFSACL(xid, tlink_tcon(tlink), fid, &pntsd, pacllen);
-        free_xid(xid);
+        FreeXid(xid);
 
         cifs_put_tlink(tlink);
 
@@ -875,8 +945,7 @@ static struct cifs_ntsd *get_cifs_acl_by_path(struct cifs_sb_info *cifs_sb,
 {
         struct cifs_ntsd *pntsd = NULL;
         int oplock = 0;
-        unsigned int xid;
-        int rc, create_options = 0;
+        int xid, rc;
         __u16 fid;
         struct cifs_tcon *tcon;
         struct tcon_link *tlink = cifs_sb_tlink(cifs_sb);
@@ -885,21 +954,18 @@ static struct cifs_ntsd *get_cifs_acl_by_path(struct cifs_sb_info *cifs_sb,
                 return ERR_CAST(tlink);
 
         tcon = tlink_tcon(tlink);
-        xid = get_xid();
-
-        if (backup_cred(cifs_sb))
-                create_options |= CREATE_OPEN_BACKUP_INTENT;
+        xid = GetXid();
 
-        rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, READ_CONTROL,
-                        create_options, &fid, &oplock, NULL, cifs_sb->local_nls,
-                        cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
+        rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, READ_CONTROL, 0,
+                         &fid, &oplock, NULL, cifs_sb->local_nls,
+                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
         if (!rc) {
                 rc = CIFSSMBGetCIFSACL(xid, tcon, fid, &pntsd, pacllen);
                 CIFSSMBClose(xid, tcon, fid);
         }
 
         cifs_put_tlink(tlink);
-        free_xid(xid);
+        FreeXid(xid);
 
         cFYI(1, "%s: rc = %d ACL len %d", __func__, rc, *pacllen);
         if (rc)
@@ -920,55 +986,55 @@ struct cifs_ntsd *get_cifs_acl(struct cifs_sb_info *cifs_sb,
         if (!open_file)
                 return get_cifs_acl_by_path(cifs_sb, path, pacllen);
 
-        pntsd = get_cifs_acl_by_fid(cifs_sb, open_file->fid.netfid, pacllen);
+        pntsd = get_cifs_acl_by_fid(cifs_sb, open_file->netfid, pacllen);
         cifsFileInfo_put(open_file);
         return pntsd;
 }
 
- /* Set an ACL on the server */
-int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
-                        struct inode *inode, const char *path, int aclflag)
+static int set_cifs_acl_by_path(struct cifs_sb_info *cifs_sb, const char *path,
+                struct cifs_ntsd *pnntsd, u32 acllen)
 {
         int oplock = 0;
-        unsigned int xid;
-        int rc, access_flags, create_options = 0;
+        int xid, rc;
         __u16 fid;
         struct cifs_tcon *tcon;
-        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
         struct tcon_link *tlink = cifs_sb_tlink(cifs_sb);
 
         if (IS_ERR(tlink))
                 return PTR_ERR(tlink);
 
         tcon = tlink_tcon(tlink);
-        xid = get_xid();
-
-        if (backup_cred(cifs_sb))
-                create_options |= CREATE_OPEN_BACKUP_INTENT;
-
-        if (aclflag == CIFS_ACL_OWNER || aclflag == CIFS_ACL_GROUP)
-                access_flags = WRITE_OWNER;
-        else
-                access_flags = WRITE_DAC;
+        xid = GetXid();
 
-        rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, access_flags,
-                        create_options, &fid, &oplock, NULL, cifs_sb->local_nls,
-                        cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
+        rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, WRITE_DAC, 0,
+                         &fid, &oplock, NULL, cifs_sb->local_nls,
+                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
         if (rc) {
                 cERROR(1, "Unable to open file to set ACL");
                 goto out;
         }
 
-        rc = CIFSSMBSetCIFSACL(xid, tcon, fid, pnntsd, acllen, aclflag);
+        rc = CIFSSMBSetCIFSACL(xid, tcon, fid, pnntsd, acllen);
         cFYI(DBG2, "SetCIFSACL rc = %d", rc);
 
         CIFSSMBClose(xid, tcon, fid);
 out:
-        free_xid(xid);
+        FreeXid(xid);
         cifs_put_tlink(tlink);
         return rc;
 }
 
+/* Set an ACL on the server */
+int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
+                                struct inode *inode, const char *path)
+{
+        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
+
+        cFYI(DBG2, "set ACL for %s from mode 0x%x", path, inode->i_mode);
+
+        return set_cifs_acl_by_path(cifs_sb, path, pnntsd, acllen);
+}
+
 /* Translate the CIFS ACL (simlar to NTFS ACL) for a file into mode bits */
 int
 cifs_acl_to_fattr(struct cifs_sb_info *cifs_sb, struct cifs_fattr *fattr,
@@ -1000,12 +1066,9 @@ cifs_acl_to_fattr(struct cifs_sb_info *cifs_sb, struct cifs_fattr *fattr,
 }
 
 /* Convert mode bits to an ACL so we can update the ACL on the server */
-int
-id_mode_to_cifs_acl(struct inode *inode, const char *path, __u64 nmode,
-                        uid_t uid, gid_t gid)
+int mode_to_cifs_acl(struct inode *inode, const char *path, __u64 nmode)
 {
         int rc = 0;
-        int aclflag = CIFS_ACL_DACL; /* default flag to set */
         __u32 secdesclen = 0;
         struct cifs_ntsd *pntsd = NULL; /* acl obtained from server */
         struct cifs_ntsd *pnntsd = NULL; /* modified acl to be sent to server */
@@ -1014,39 +1077,40 @@ id_mode_to_cifs_acl(struct inode *inode, const char *path, __u64 nmode,
 
         /* Get the security descriptor */
         pntsd = get_cifs_acl(CIFS_SB(inode->i_sb), inode, path, &secdesclen);
+
+        /* Add three ACEs for owner, group, everyone getting rid of
+           other ACEs as chmod disables ACEs and set the security descriptor */
+
         if (IS_ERR(pntsd)) {
                 rc = PTR_ERR(pntsd);
                 cERROR(1, "%s: error %d getting sec desc", __func__, rc);
-                goto out;
-        }
+        } else {
+                /* allocate memory for the smb header,
+                   set security descriptor request security descriptor
+                   parameters, and secuirty descriptor itself */
+
+                secdesclen = secdesclen < DEFSECDESCLEN ?
+                                        DEFSECDESCLEN : secdesclen;
+                pnntsd = kmalloc(secdesclen, GFP_KERNEL);
+                if (!pnntsd) {
+                        cERROR(1, "Unable to allocate security descriptor");
+                        kfree(pntsd);
+                        return -ENOMEM;
+                }
 
-        /*
-         * Add three ACEs for owner, group, everyone getting rid of other ACEs
-         * as chmod disables ACEs and set the security descriptor. Allocate
-         * memory for the smb header, set security descriptor request security
-         * descriptor parameters, and secuirty descriptor itself
-         */
-        secdesclen = max_t(u32, secdesclen, DEFAULT_SEC_DESC_LEN);
-        pnntsd = kmalloc(secdesclen, GFP_KERNEL);
-        if (!pnntsd) {
-                cERROR(1, "Unable to allocate security descriptor");
-                kfree(pntsd);
-                return -ENOMEM;
-        }
+                rc = build_sec_desc(pntsd, pnntsd, inode, nmode);
 
-        rc = build_sec_desc(pntsd, pnntsd, secdesclen, nmode, uid, gid,
-                                &aclflag);
+                cFYI(DBG2, "build_sec_desc rc: %d", rc);
 
-        cFYI(DBG2, "build_sec_desc rc: %d", rc);
+                if (!rc) {
+                        /* Set the security descriptor */
+                        rc = set_cifs_acl(pnntsd, secdesclen, inode, path);
+                        cFYI(DBG2, "set_cifs_acl rc: %d", rc);
+                }
 
-        if (!rc) {
-                /* Set the security descriptor */
-                rc = set_cifs_acl(pnntsd, secdesclen, inode, path, aclflag);
-                cFYI(DBG2, "set_cifs_acl rc: %d", rc);
+                kfree(pnntsd);
+                kfree(pntsd);
         }
 
-        kfree(pnntsd);
-        kfree(pntsd);
-out:
         return rc;
 }
diff --git a/fs/cifs/cifsacl.h b/fs/cifs/cifsacl.h
index 4f388483526..5c902c7ce52 100644
--- a/fs/cifs/cifsacl.h
+++ b/fs/cifs/cifsacl.h
@@ -23,8 +23,11 @@
 #define _CIFSACL_H
 
 
-#define NUM_AUTHS (6)   /* number of authority fields */
-#define SID_MAX_SUB_AUTHORITIES (15) /* max number of sub authority fields */
+#define NUM_AUTHS 6 /* number of authority fields */
+#define NUM_SUBAUTHS 5 /* number of sub authority fields */
+#define NUM_WK_SIDS 7 /* number of well known sids */
+#define SIDNAMELENGTH 20 /* long enough for the ones we care about */
+#define DEFSECDESCLEN 192 /* sec desc len contaiting a dacl with three aces */
 
 #define READ_BIT        0x4
 #define WRITE_BIT       0x2
@@ -38,32 +41,12 @@
 
 #define SIDOWNER 1
 #define SIDGROUP 2
+#define SIDLEN 150 /* S- 1 revision- 6 authorities- max 5 sub authorities */
 
-/*
- * Security Descriptor length containing DACL with 3 ACEs (one each for
- * owner, group and world).
- */
-#define DEFAULT_SEC_DESC_LEN (sizeof(struct cifs_ntsd) + \
-                              sizeof(struct cifs_acl) + \
-                              (sizeof(struct cifs_ace) * 3))
-
-/*
- * Maximum size of a string representation of a SID:
- *
- * The fields are unsigned values in decimal. So:
- *
- * u8:  max 3 bytes in decimal
- * u32: max 10 bytes in decimal
- *
- * "S-" + 3 bytes for version field + 15 for authority field + NULL terminator
- *
- * For authority field, max is when all 6 values are non-zero and it must be
- * represented in hex. So "-0x" + 12 hex digits.
- *
- * Add 11 bytes for each subauthority field (10 bytes each + 1 for '-')
- */
-#define SID_STRING_BASE_SIZE (2 + 3 + 15 + 1)
-#define SID_STRING_SUBAUTH_SIZE (11) /* size of a single subauth string */
+#define SID_ID_MAPPED 0
+#define SID_ID_PENDING 1
+#define SID_MAP_EXPIRE (3600 * HZ) /* map entry expires after one hour */
+#define SID_MAP_RETRY (300 * HZ)   /* wait 5 minutes for next attempt to map */
 
 struct cifs_ntsd {
         __le16 revision; /* revision level */
@@ -77,13 +60,10 @@ struct cifs_ntsd {
 struct cifs_sid {
         __u8 revision; /* revision level */
         __u8 num_subauth;
-        __u8 authority[NUM_AUTHS];
-        __le32 sub_auth[SID_MAX_SUB_AUTHORITIES]; /* sub_auth[num_subauth] */
+        __u8 authority[6];
+        __le32 sub_auth[5]; /* sub_auth[num_subauth] */
 } __attribute__((packed));
 
-/* size of a struct cifs_sid, sans sub_auth array */
-#define CIFS_SID_BASE_SIZE (1 + 1 + NUM_AUTHS)
-
 struct cifs_acl {
         __le16 revision; /* revision level */
         __le16 size;
@@ -98,4 +78,26 @@ struct cifs_ace {
         struct cifs_sid sid; /* ie UUID of user or group who gets these perms */
 } __attribute__((packed));
 
+struct cifs_wksid {
+        struct cifs_sid cifssid;
+        char sidname[SIDNAMELENGTH];
+} __attribute__((packed));
+
+struct cifs_sid_id {
+        unsigned int refcount; /* increment with spinlock, decrement without */
+        unsigned long id;
+        unsigned long time;
+        unsigned long state;
+        char *sidstr;
+        struct rb_node rbnode;
+        struct cifs_sid sid;
+};
+
+#ifdef __KERNEL__
+extern struct key_type cifs_idmap_key_type;
+extern const struct cred *root_cred;
+#endif /* KERNEL */
+
+extern int compare_sids(const struct cifs_sid *, const struct cifs_sid *);
+
 #endif /* _CIFSACL_H */
diff --git a/fs/cifs/cifsencrypt.c b/fs/cifs/cifsencrypt.c
index 652f5051be0..30acd22147e 100644
--- a/fs/cifs/cifsencrypt.c
+++ b/fs/cifs/cifsencrypt.c
@@ -29,7 +29,6 @@
 #include "ntlmssp.h"
 #include <linux/ctype.h>
 #include <linux/random.h>
-#include <linux/highmem.h>
 
 /*
  * Calculate and return the CIFS signature based on the mac key and SMB PDU.
@@ -38,32 +37,105 @@
  * the sequence number before this function is called. Also, this function
  * should be called with the server->srv_mutex held.
  */
-static int cifs_calc_signature(struct smb_rqst *rqst,
-                        struct TCP_Server_Info *server, char *signature)
+static int cifs_calculate_signature(const struct smb_hdr *cifs_pdu,
+                                struct TCP_Server_Info *server, char *signature)
+{
+        int rc;
+
+        if (cifs_pdu == NULL || signature == NULL || server == NULL)
+                return -EINVAL;
+
+        if (!server->secmech.sdescmd5) {
+                cERROR(1, "%s: Can't generate signature\n", __func__);
+                return -1;
+        }
+
+        rc = crypto_shash_init(&server->secmech.sdescmd5->shash);
+        if (rc) {
+                cERROR(1, "%s: Could not init md5\n", __func__);
+                return rc;
+        }
+
+        rc = crypto_shash_update(&server->secmech.sdescmd5->shash,
+                server->session_key.response, server->session_key.len);
+        if (rc) {
+                cERROR(1, "%s: Could not update with response\n", __func__);
+                return rc;
+        }
+
+        rc = crypto_shash_update(&server->secmech.sdescmd5->shash,
+                cifs_pdu->Protocol, be32_to_cpu(cifs_pdu->smb_buf_length));
+        if (rc) {
+                cERROR(1, "%s: Could not update with payload\n", __func__);
+                return rc;
+        }
+
+        rc = crypto_shash_final(&server->secmech.sdescmd5->shash, signature);
+        if (rc)
+                cERROR(1, "%s: Could not generate md5 hash\n", __func__);
+
+        return rc;
+}
+
+/* must be called with server->srv_mutex held */
+int cifs_sign_smb(struct smb_hdr *cifs_pdu, struct TCP_Server_Info *server,
+                  __u32 *pexpected_response_sequence_number)
+{
+        int rc = 0;
+        char smb_signature[20];
+
+        if ((cifs_pdu == NULL) || (server == NULL))
+                return -EINVAL;
+
+        if (!(cifs_pdu->Flags2 & SMBFLG2_SECURITY_SIGNATURE) ||
+            server->tcpStatus == CifsNeedNegotiate)
+                return rc;
+
+        if (!server->session_estab) {
+                strncpy(cifs_pdu->Signature.SecuritySignature, "BSRSPYL", 8);
+                return rc;
+        }
+
+        cifs_pdu->Signature.Sequence.SequenceNumber =
+                        cpu_to_le32(server->sequence_number);
+        cifs_pdu->Signature.Sequence.Reserved = 0;
+
+        *pexpected_response_sequence_number = server->sequence_number++;
+        server->sequence_number++;
+
+        rc = cifs_calculate_signature(cifs_pdu, server, smb_signature);
+        if (rc)
+                memset(cifs_pdu->Signature.SecuritySignature, 0, 8);
+        else
+                memcpy(cifs_pdu->Signature.SecuritySignature, smb_signature, 8);
+
+        return rc;
+}
+
+static int cifs_calc_signature2(const struct kvec *iov, int n_vec,
+                                struct TCP_Server_Info *server, char *signature)
 {
         int i;
         int rc;
-        struct kvec *iov = rqst->rq_iov;
-        int n_vec = rqst->rq_nvec;
 
         if (iov == NULL || signature == NULL || server == NULL)
                 return -EINVAL;
 
         if (!server->secmech.sdescmd5) {
-                cERROR(1, "%s: Can't generate signature", __func__);
+                cERROR(1, "%s: Can't generate signature\n", __func__);
                 return -1;
         }
 
         rc = crypto_shash_init(&server->secmech.sdescmd5->shash);
         if (rc) {
-                cERROR(1, "%s: Could not init md5", __func__);
+                cERROR(1, "%s: Could not init md5\n", __func__);
                 return rc;
         }
 
         rc = crypto_shash_update(&server->secmech.sdescmd5->shash,
                 server->session_key.response, server->session_key.len);
         if (rc) {
-                cERROR(1, "%s: Could not update with response", __func__);
+                cERROR(1, "%s: Could not update with response\n", __func__);
                 return rc;
         }
 
@@ -88,36 +160,26 @@ static int cifs_calc_signature(struct smb_rqst *rqst,
                                 iov[i].iov_base, iov[i].iov_len);
                 }
                 if (rc) {
-                        cERROR(1, "%s: Could not update with payload",
+                        cERROR(1, "%s: Could not update with payload\n",
                                                         __func__);
                         return rc;
                 }
         }
 
-        /* now hash over the rq_pages array */
-        for (i = 0; i < rqst->rq_npages; i++) {
-                struct kvec p_iov;
-
-                cifs_rqst_page_to_kvec(rqst, i, &p_iov);
-                crypto_shash_update(&server->secmech.sdescmd5->shash,
-                                        p_iov.iov_base, p_iov.iov_len);
-                kunmap(rqst->rq_pages[i]);
-        }
-
         rc = crypto_shash_final(&server->secmech.sdescmd5->shash, signature);
         if (rc)
-                cERROR(1, "%s: Could not generate md5 hash", __func__);
+                cERROR(1, "%s: Could not generate md5 hash\n", __func__);
 
         return rc;
 }
 
 /* must be called with server->srv_mutex held */
-int cifs_sign_rqst(struct smb_rqst *rqst, struct TCP_Server_Info *server,
+int cifs_sign_smb2(struct kvec *iov, int n_vec, struct TCP_Server_Info *server,
                    __u32 *pexpected_response_sequence_number)
 {
         int rc = 0;
         char smb_signature[20];
-        struct smb_hdr *cifs_pdu = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
+        struct smb_hdr *cifs_pdu = iov[0].iov_base;
 
         if ((cifs_pdu == NULL) || (server == NULL))
                 return -EINVAL;
@@ -127,7 +189,7 @@ int cifs_sign_rqst(struct smb_rqst *rqst, struct TCP_Server_Info *server,
                 return rc;
 
         if (!server->session_estab) {
-                memcpy(cifs_pdu->Signature.SecuritySignature, "BSRSPYL", 8);
+                strncpy(cifs_pdu->Signature.SecuritySignature, "BSRSPYL", 8);
                 return rc;
         }
 
@@ -138,7 +200,7 @@ int cifs_sign_rqst(struct smb_rqst *rqst, struct TCP_Server_Info *server,
         *pexpected_response_sequence_number = server->sequence_number++;
         server->sequence_number++;
 
-        rc = cifs_calc_signature(rqst, server, smb_signature);
+        rc = cifs_calc_signature2(iov, n_vec, server, smb_signature);
         if (rc)
                 memset(cifs_pdu->Signature.SecuritySignature, 0, 8);
         else
@@ -147,36 +209,13 @@ int cifs_sign_rqst(struct smb_rqst *rqst, struct TCP_Server_Info *server,
         return rc;
 }
 
-int cifs_sign_smbv(struct kvec *iov, int n_vec, struct TCP_Server_Info *server,
-                   __u32 *pexpected_response_sequence)
-{
-        struct smb_rqst rqst = { .rq_iov = iov,
-                                 .rq_nvec = n_vec };
-
-        return cifs_sign_rqst(&rqst, server, pexpected_response_sequence);
-}
-
-/* must be called with server->srv_mutex held */
-int cifs_sign_smb(struct smb_hdr *cifs_pdu, struct TCP_Server_Info *server,
-                  __u32 *pexpected_response_sequence_number)
-{
-        struct kvec iov;
-
-        iov.iov_base = cifs_pdu;
-        iov.iov_len = be32_to_cpu(cifs_pdu->smb_buf_length) + 4;
-
-        return cifs_sign_smbv(&iov, 1, server,
-                              pexpected_response_sequence_number);
-}
-
-int cifs_verify_signature(struct smb_rqst *rqst,
+int cifs_verify_signature(struct smb_hdr *cifs_pdu,
                           struct TCP_Server_Info *server,
                           __u32 expected_sequence_number)
 {
         unsigned int rc;
         char server_response_sig[8];
         char what_we_think_sig_should_be[20];
-        struct smb_hdr *cifs_pdu = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
 
         if (cifs_pdu == NULL || server == NULL)
                 return -EINVAL;
@@ -208,7 +247,8 @@ int cifs_verify_signature(struct smb_rqst *rqst,
         cifs_pdu->Signature.Sequence.Reserved = 0;
 
         mutex_lock(&server->srv_mutex);
-        rc = cifs_calc_signature(rqst, server, what_we_think_sig_should_be);
+        rc = cifs_calculate_signature(cifs_pdu, server,
+                what_we_think_sig_should_be);
         mutex_unlock(&server->srv_mutex);
 
         if (rc)
@@ -225,7 +265,7 @@ int cifs_verify_signature(struct smb_rqst *rqst,
 }
 
 /* first calculate 24 bytes ntlm response and then 16 byte session key */
-int setup_ntlm_response(struct cifs_ses *ses, const struct nls_table *nls_cp)
+int setup_ntlm_response(struct cifs_ses *ses)
 {
         int rc = 0;
         unsigned int temp_len = CIFS_SESS_KEY_SIZE + CIFS_AUTH_RESP_SIZE;
@@ -242,14 +282,14 @@ int setup_ntlm_response(struct cifs_ses *ses, const struct nls_table *nls_cp)
         ses->auth_key.len = temp_len;
 
         rc = SMBNTencrypt(ses->password, ses->server->cryptkey,
-                        ses->auth_key.response + CIFS_SESS_KEY_SIZE, nls_cp);
+                        ses->auth_key.response + CIFS_SESS_KEY_SIZE);
         if (rc) {
                 cFYI(1, "%s Can't generate NTLM response, error: %d",
                         __func__, rc);
                 return rc;
         }
 
-        rc = E_md4hash(ses->password, temp_key, nls_cp);
+        rc = E_md4hash(ses->password, temp_key);
         if (rc) {
                 cFYI(1, "%s Can't generate NT hash, error: %d", __func__, rc);
                 return rc;
@@ -348,7 +388,7 @@ build_avpair_blob(struct cifs_ses *ses, const struct nls_table *nls_cp)
         attrptr->type = cpu_to_le16(NTLMSSP_AV_NB_DOMAIN_NAME);
         attrptr->length = cpu_to_le16(2 * dlen);
         blobptr = (unsigned char *)attrptr + sizeof(struct ntlmssp2_name);
-        cifs_strtoUTF16((__le16 *)blobptr, ses->domainName, dlen, nls_cp);
+        cifs_strtoUCS((__le16 *)blobptr, ses->domainName, dlen, nls_cp);
 
         return 0;
 }
@@ -397,7 +437,7 @@ find_domain_name(struct cifs_ses *ses, const struct nls_table *nls_cp)
                                         kmalloc(attrsize + 1, GFP_KERNEL);
                                 if (!ses->domainName)
                                                 return -ENOMEM;
-                                cifs_from_utf16(ses->domainName,
+                                cifs_from_ucs2(ses->domainName,
                                         (__le16 *)blobptr, attrsize, attrsize,
                                         nls_cp, false);
                                 break;
@@ -420,12 +460,12 @@ static int calc_ntlmv2_hash(struct cifs_ses *ses, char *ntlmv2_hash,
         wchar_t *server;
 
         if (!ses->server->secmech.sdeschmacmd5) {
-                cERROR(1, "calc_ntlmv2_hash: can't generate ntlmv2 hash");
+                cERROR(1, "calc_ntlmv2_hash: can't generate ntlmv2 hash\n");
                 return -1;
         }
 
         /* calculate md4 hash of password */
-        E_md4hash(ses->password, nt_hash, nls_cp);
+        E_md4hash(ses->password, nt_hash);
 
         rc = crypto_shash_setkey(ses->server->secmech.hmacmd5, nt_hash,
                                 CIFS_NTHASH_SIZE);
@@ -436,31 +476,26 @@ static int calc_ntlmv2_hash(struct cifs_ses *ses, char *ntlmv2_hash,
 
         rc = crypto_shash_init(&ses->server->secmech.sdeschmacmd5->shash);
         if (rc) {
-                cERROR(1, "calc_ntlmv2_hash: could not init hmacmd5");
+                cERROR(1, "calc_ntlmv2_hash: could not init hmacmd5\n");
                 return rc;
         }
 
         /* convert ses->user_name to unicode and uppercase */
-        len = ses->user_name ? strlen(ses->user_name) : 0;
+        len = strlen(ses->user_name);
         user = kmalloc(2 + (len * 2), GFP_KERNEL);
         if (user == NULL) {
-                cERROR(1, "calc_ntlmv2_hash: user mem alloc failure");
+                cERROR(1, "calc_ntlmv2_hash: user mem alloc failure\n");
                 rc = -ENOMEM;
                 return rc;
         }
-
-        if (len) {
-                len = cifs_strtoUTF16((__le16 *)user, ses->user_name, len, nls_cp);
-                UniStrupr(user);
-        } else {
-                memset(user, '\0', 2);
-        }
+        len = cifs_strtoUCS((__le16 *)user, ses->user_name, len, nls_cp);
+        UniStrupr(user);
 
         rc = crypto_shash_update(&ses->server->secmech.sdeschmacmd5->shash,
                                 (char *)user, 2 * len);
         kfree(user);
         if (rc) {
-                cERROR(1, "%s: Could not update with user", __func__);
+                cERROR(1, "%s: Could not update with user\n", __func__);
                 return rc;
         }
 
@@ -474,14 +509,14 @@ static int calc_ntlmv2_hash(struct cifs_ses *ses, char *ntlmv2_hash,
                         rc = -ENOMEM;
                         return rc;
                 }
-                len = cifs_strtoUTF16((__le16 *)domain, ses->domainName, len,
-                                      nls_cp);
+                len = cifs_strtoUCS((__le16 *)domain, ses->domainName, len,
+                                        nls_cp);
                 rc =
                 crypto_shash_update(&ses->server->secmech.sdeschmacmd5->shash,
                                         (char *)domain, 2 * len);
                 kfree(domain);
                 if (rc) {
-                        cERROR(1, "%s: Could not update with domain",
+                        cERROR(1, "%s: Could not update with domain\n",
                                                                 __func__);
                         return rc;
                 }
@@ -494,14 +529,14 @@ static int calc_ntlmv2_hash(struct cifs_ses *ses, char *ntlmv2_hash,
                         rc = -ENOMEM;
                         return rc;
                 }
-                len = cifs_strtoUTF16((__le16 *)server, ses->serverName, len,
+                len = cifs_strtoUCS((__le16 *)server, ses->serverName, len,
                                         nls_cp);
                 rc =
                 crypto_shash_update(&ses->server->secmech.sdeschmacmd5->shash,
                                         (char *)server, 2 * len);
                 kfree(server);
                 if (rc) {
-                        cERROR(1, "%s: Could not update with server",
+                        cERROR(1, "%s: Could not update with server\n",
                                                                 __func__);
                         return rc;
                 }
@@ -510,7 +545,7 @@ static int calc_ntlmv2_hash(struct cifs_ses *ses, char *ntlmv2_hash,
         rc = crypto_shash_final(&ses->server->secmech.sdeschmacmd5->shash,
                                         ntlmv2_hash);
         if (rc)
-                cERROR(1, "%s: Could not generate md5 hash", __func__);
+                cERROR(1, "%s: Could not generate md5 hash\n", __func__);
 
         return rc;
 }
@@ -522,7 +557,7 @@ CalcNTLMv2_response(const struct cifs_ses *ses, char *ntlmv2_hash)
         unsigned int offset = CIFS_SESS_KEY_SIZE + 8;
 
         if (!ses->server->secmech.sdeschmacmd5) {
-                cERROR(1, "calc_ntlmv2_hash: can't generate ntlmv2 hash");
+                cERROR(1, "calc_ntlmv2_hash: can't generate ntlmv2 hash\n");
                 return -1;
         }
 
@@ -548,14 +583,14 @@ CalcNTLMv2_response(const struct cifs_ses *ses, char *ntlmv2_hash)
         rc = crypto_shash_update(&ses->server->secmech.sdeschmacmd5->shash,
                 ses->auth_key.response + offset, ses->auth_key.len - offset);
         if (rc) {
-                cERROR(1, "%s: Could not update with response", __func__);
+                cERROR(1, "%s: Could not update with response\n", __func__);
                 return rc;
         }
 
         rc = crypto_shash_final(&ses->server->secmech.sdeschmacmd5->shash,
                 ses->auth_key.response + CIFS_SESS_KEY_SIZE);
         if (rc)
-                cERROR(1, "%s: Could not generate md5 hash", __func__);
+                cERROR(1, "%s: Could not generate md5 hash\n", __func__);
 
         return rc;
 }
@@ -634,7 +669,7 @@ setup_ntlmv2_rsp(struct cifs_ses *ses, const struct nls_table *nls_cp)
 
         rc = crypto_shash_init(&ses->server->secmech.sdeschmacmd5->shash);
         if (rc) {
-                cERROR(1, "%s: Could not init hmacmd5", __func__);
+                cERROR(1, "%s: Could not init hmacmd5\n", __func__);
                 goto setup_ntlmv2_rsp_ret;
         }
 
@@ -642,14 +677,14 @@ setup_ntlmv2_rsp(struct cifs_ses *ses, const struct nls_table *nls_cp)
                 ses->auth_key.response + CIFS_SESS_KEY_SIZE,
                 CIFS_HMAC_MD5_HASH_SIZE);
         if (rc) {
-                cERROR(1, "%s: Could not update with response", __func__);
+                cERROR(1, "%s: Could not update with response\n", __func__);
                 goto setup_ntlmv2_rsp_ret;
         }
 
         rc = crypto_shash_final(&ses->server->secmech.sdeschmacmd5->shash,
                 ses->auth_key.response);
         if (rc)
-                cERROR(1, "%s: Could not generate md5 hash", __func__);
+                cERROR(1, "%s: Could not generate md5 hash\n", __func__);
 
 setup_ntlmv2_rsp_ret:
         kfree(tiblob);
@@ -671,7 +706,7 @@ calc_seckey(struct cifs_ses *ses)
         tfm_arc4 = crypto_alloc_blkcipher("ecb(arc4)", 0, CRYPTO_ALG_ASYNC);
         if (IS_ERR(tfm_arc4)) {
                 rc = PTR_ERR(tfm_arc4);
-                cERROR(1, "could not allocate crypto API arc4");
+                cERROR(1, "could not allocate crypto API arc4\n");
                 return rc;
         }
 
@@ -689,7 +724,7 @@ calc_seckey(struct cifs_ses *ses)
 
         rc = crypto_blkcipher_encrypt(&desc, &sgout, &sgin, CIFS_CPHTXT_SIZE);
         if (rc) {
-                cERROR(1, "could not encrypt session key rc: %d", rc);
+                cERROR(1, "could not encrypt session key rc: %d\n", rc);
                 crypto_free_blkcipher(tfm_arc4);
                 return rc;
         }
@@ -707,17 +742,12 @@ calc_seckey(struct cifs_ses *ses)
 void
 cifs_crypto_shash_release(struct TCP_Server_Info *server)
 {
-        if (server->secmech.hmacsha256)
-                crypto_free_shash(server->secmech.hmacsha256);
-
         if (server->secmech.md5)
                 crypto_free_shash(server->secmech.md5);
 
         if (server->secmech.hmacmd5)
                 crypto_free_shash(server->secmech.hmacmd5);
 
-        kfree(server->secmech.sdeschmacsha256);
-
         kfree(server->secmech.sdeschmacmd5);
 
         kfree(server->secmech.sdescmd5);
@@ -731,69 +761,46 @@ cifs_crypto_shash_allocate(struct TCP_Server_Info *server)
 
         server->secmech.hmacmd5 = crypto_alloc_shash("hmac(md5)", 0, 0);
         if (IS_ERR(server->secmech.hmacmd5)) {
-                cERROR(1, "could not allocate crypto hmacmd5");
+                cERROR(1, "could not allocate crypto hmacmd5\n");
                 return PTR_ERR(server->secmech.hmacmd5);
         }
 
         server->secmech.md5 = crypto_alloc_shash("md5", 0, 0);
         if (IS_ERR(server->secmech.md5)) {
-                cERROR(1, "could not allocate crypto md5");
+                cERROR(1, "could not allocate crypto md5\n");
                 rc = PTR_ERR(server->secmech.md5);
                 goto crypto_allocate_md5_fail;
         }
 
-        server->secmech.hmacsha256 = crypto_alloc_shash("hmac(sha256)", 0, 0);
-        if (IS_ERR(server->secmech.hmacsha256)) {
-                cERROR(1, "could not allocate crypto hmacsha256\n");
-                rc = PTR_ERR(server->secmech.hmacsha256);
-                goto crypto_allocate_hmacsha256_fail;
-        }
-
         size = sizeof(struct shash_desc) +
                         crypto_shash_descsize(server->secmech.hmacmd5);
         server->secmech.sdeschmacmd5 = kmalloc(size, GFP_KERNEL);
         if (!server->secmech.sdeschmacmd5) {
-                cERROR(1, "cifs_crypto_shash_allocate: can't alloc hmacmd5");
+                cERROR(1, "cifs_crypto_shash_allocate: can't alloc hmacmd5\n");
                 rc = -ENOMEM;
                 goto crypto_allocate_hmacmd5_sdesc_fail;
         }
         server->secmech.sdeschmacmd5->shash.tfm = server->secmech.hmacmd5;
         server->secmech.sdeschmacmd5->shash.flags = 0x0;
 
+
         size = sizeof(struct shash_desc) +
                         crypto_shash_descsize(server->secmech.md5);
         server->secmech.sdescmd5 = kmalloc(size, GFP_KERNEL);
         if (!server->secmech.sdescmd5) {
-                cERROR(1, "cifs_crypto_shash_allocate: can't alloc md5");
+                cERROR(1, "cifs_crypto_shash_allocate: can't alloc md5\n");
                 rc = -ENOMEM;
                 goto crypto_allocate_md5_sdesc_fail;
         }
         server->secmech.sdescmd5->shash.tfm = server->secmech.md5;
         server->secmech.sdescmd5->shash.flags = 0x0;
 
-        size = sizeof(struct shash_desc) +
-                        crypto_shash_descsize(server->secmech.hmacsha256);
-        server->secmech.sdeschmacsha256 = kmalloc(size, GFP_KERNEL);
-        if (!server->secmech.sdeschmacsha256) {
-                cERROR(1, "%s: Can't alloc hmacsha256\n", __func__);
-                rc = -ENOMEM;
-                goto crypto_allocate_hmacsha256_sdesc_fail;
-        }
-        server->secmech.sdeschmacsha256->shash.tfm = server->secmech.hmacsha256;
-        server->secmech.sdeschmacsha256->shash.flags = 0x0;
-
         return 0;
 
-crypto_allocate_hmacsha256_sdesc_fail:
-        kfree(server->secmech.sdescmd5);
-
 crypto_allocate_md5_sdesc_fail:
         kfree(server->secmech.sdeschmacmd5);
 
 crypto_allocate_hmacmd5_sdesc_fail:
-        crypto_free_shash(server->secmech.hmacsha256);
-
-crypto_allocate_hmacsha256_fail:
         crypto_free_shash(server->secmech.md5);
 
 crypto_allocate_md5_fail:
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>");
diff --git a/fs/cifs/cifsfs.h b/fs/cifs/cifsfs.h
index 7163419cecd..95da8027983 100644
--- a/fs/cifs/cifsfs.h
+++ b/fs/cifs/cifsfs.h
@@ -44,17 +44,14 @@ extern const struct address_space_operations cifs_addr_ops_smallbuf;
 /* Functions related to inodes */
 extern const struct inode_operations cifs_dir_inode_ops;
 extern struct inode *cifs_root_iget(struct super_block *);
-extern int cifs_create(struct inode *, struct dentry *, umode_t,
-                       bool excl);
-extern int cifs_atomic_open(struct inode *, struct dentry *,
-                            struct file *, unsigned, umode_t,
-                            int *);
+extern int cifs_create(struct inode *, struct dentry *, int,
+                       struct nameidata *);
 extern struct dentry *cifs_lookup(struct inode *, struct dentry *,
-                                  unsigned int);
+                                  struct nameidata *);
 extern int cifs_unlink(struct inode *dir, struct dentry *dentry);
 extern int cifs_hardlink(struct dentry *, struct inode *, struct dentry *);
-extern int cifs_mknod(struct inode *, struct dentry *, umode_t, dev_t);
-extern int cifs_mkdir(struct inode *, struct dentry *, umode_t);
+extern int cifs_mknod(struct inode *, struct dentry *, int, dev_t);
+extern int cifs_mkdir(struct inode *, struct dentry *, int);
 extern int cifs_rmdir(struct inode *, struct dentry *);
 extern int cifs_rename(struct inode *, struct dentry *, struct inode *,
                        struct dentry *);
@@ -124,9 +121,9 @@ extern ssize_t	cifs_getxattr(struct dentry *, const char *, void *, size_t);
 extern ssize_t  cifs_listxattr(struct dentry *, char *, size_t);
 extern long cifs_ioctl(struct file *filep, unsigned int cmd, unsigned long arg);
 
-#ifdef CONFIG_CIFS_NFSD_EXPORT
+#ifdef CIFS_NFSD_EXPORT
 extern const struct export_operations cifs_export_ops;
-#endif /* CONFIG_CIFS_NFSD_EXPORT */
+#endif /* CIFS_NFSD_EXPORT */
 
-#define CIFS_VERSION   "2.0"
+#define CIFS_VERSION   "1.75"
 #endif                          /* _CIFSFS_H */
diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
index e6899cea1c3..95dad9d14cf 100644
--- a/fs/cifs/cifsglob.h
+++ b/fs/cifs/cifsglob.h
@@ -22,17 +22,11 @@
 #include <linux/in.h>
 #include <linux/in6.h>
 #include <linux/slab.h>
-#include <linux/mempool.h>
 #include <linux/workqueue.h>
 #include "cifs_fs_sb.h"
 #include "cifsacl.h"
 #include <crypto/internal/hash.h>
 #include <linux/scatterlist.h>
-#ifdef CONFIG_CIFS_SMB2
-#include "smb2pdu.h"
-#endif
-
-#define CIFS_MAGIC_NUMBER 0xFF534D42      /* the first four bytes of SMB PDUs */
 
 /*
  * The sizes of various internal tables and strings
@@ -49,7 +43,6 @@
 
 #define CIFS_MIN_RCV_POOL 4
 
-#define MAX_REOPEN_ATT  5 /* these many maximum attempts to reopen a file */
 /*
  * default attribute cache timeout (jiffies)
  */
@@ -62,9 +55,14 @@
 
 /*
  * MAX_REQ is the maximum number of requests that WE will send
- * on one socket concurrently.
+ * on one socket concurrently. It also matches the most common
+ * value of max multiplex returned by servers.  We may
+ * eventually want to use the negotiated value (in case
+ * future servers can handle more) when we are more confident that
+ * we will not have problems oveloading the socket with pending
+ * write data.
  */
-#define CIFS_MAX_REQ 32767
+#define CIFS_MAX_REQ 50
 
 #define RFC1001_NAME_LEN 15
 #define RFC1001_NAME_LEN_WITH_NULL (RFC1001_NAME_LEN + 1)
@@ -78,9 +76,6 @@
 /*           (max path length + 1 for null) * 2 for unicode    */
 #define MAX_NAME 514
 
-/* SMB echo "timeout" -- FIXME: tunable? */
-#define SMB_ECHO_INTERVAL (60 * HZ)
-
 #include "cifspdu.h"
 
 #ifndef XATTR_DOS_ATTRIB
@@ -130,10 +125,8 @@ struct sdesc {
 struct cifs_secmech {
         struct crypto_shash *hmacmd5; /* hmac-md5 hash function */
         struct crypto_shash *md5; /* md5 hash function */
-        struct crypto_shash *hmacsha256; /* hmac-sha256 hash function */
         struct sdesc *sdeschmacmd5;  /* ctxt to generate ntlmv2 hash, CR1 */
         struct sdesc *sdescmd5; /* ctxt to generate cifs/smb signature */
-        struct sdesc *sdeschmacsha256;  /* ctxt to generate smb2 signature */
 };
 
 /* per smb session structure/fields */
@@ -162,251 +155,20 @@ struct cifs_cred {
  *****************************************************************
  */
 
-/*
- * A smb_rqst represents a complete request to be issued to a server. It's
- * formed by a kvec array, followed by an array of pages. Page data is assumed
- * to start at the beginning of the first page.
- */
-struct smb_rqst {
-        struct kvec     *rq_iov;        /* array of kvecs */
-        unsigned int    rq_nvec;        /* number of kvecs in array */
-        struct page     **rq_pages;     /* pointer to array of page ptrs */
-        unsigned int    rq_npages;      /* number pages in array */
-        unsigned int    rq_pagesz;      /* page size to use */
-        unsigned int    rq_tailsz;      /* length of last page */
-};
-
-enum smb_version {
-        Smb_1 = 1,
-        Smb_20,
-        Smb_21,
-        Smb_30,
-};
-
-struct mid_q_entry;
-struct TCP_Server_Info;
-struct cifsFileInfo;
-struct cifs_ses;
-struct cifs_tcon;
-struct dfs_info3_param;
-struct cifs_fattr;
-struct smb_vol;
-struct cifs_fid;
-struct cifs_readdata;
-struct cifs_writedata;
-struct cifs_io_parms;
-struct cifs_search_info;
-struct cifsInodeInfo;
-
-struct smb_version_operations {
-        int (*send_cancel)(struct TCP_Server_Info *, void *,
-                           struct mid_q_entry *);
-        bool (*compare_fids)(struct cifsFileInfo *, struct cifsFileInfo *);
-        /* setup request: allocate mid, sign message */
-        struct mid_q_entry *(*setup_request)(struct cifs_ses *,
-                                                struct smb_rqst *);
-        /* setup async request: allocate mid, sign message */
-        struct mid_q_entry *(*setup_async_request)(struct TCP_Server_Info *,
-                                                struct smb_rqst *);
-        /* check response: verify signature, map error */
-        int (*check_receive)(struct mid_q_entry *, struct TCP_Server_Info *,
-                             bool);
-        void (*add_credits)(struct TCP_Server_Info *, const unsigned int,
-                            const int);
-        void (*set_credits)(struct TCP_Server_Info *, const int);
-        int * (*get_credits_field)(struct TCP_Server_Info *, const int);
-        unsigned int (*get_credits)(struct mid_q_entry *);
-        __u64 (*get_next_mid)(struct TCP_Server_Info *);
-        /* data offset from read response message */
-        unsigned int (*read_data_offset)(char *);
-        /* data length from read response message */
-        unsigned int (*read_data_length)(char *);
-        /* map smb to linux error */
-        int (*map_error)(char *, bool);
-        /* find mid corresponding to the response message */
-        struct mid_q_entry * (*find_mid)(struct TCP_Server_Info *, char *);
-        void (*dump_detail)(void *);
-        void (*clear_stats)(struct cifs_tcon *);
-        void (*print_stats)(struct seq_file *m, struct cifs_tcon *);
-        /* verify the message */
-        int (*check_message)(char *, unsigned int);
-        bool (*is_oplock_break)(char *, struct TCP_Server_Info *);
-        /* process transaction2 response */
-        bool (*check_trans2)(struct mid_q_entry *, struct TCP_Server_Info *,
-                             char *, int);
-        /* check if we need to negotiate */
-        bool (*need_neg)(struct TCP_Server_Info *);
-        /* negotiate to the server */
-        int (*negotiate)(const unsigned int, struct cifs_ses *);
-        /* set negotiated write size */
-        unsigned int (*negotiate_wsize)(struct cifs_tcon *, struct smb_vol *);
-        /* set negotiated read size */
-        unsigned int (*negotiate_rsize)(struct cifs_tcon *, struct smb_vol *);
-        /* setup smb sessionn */
-        int (*sess_setup)(const unsigned int, struct cifs_ses *,
-                          const struct nls_table *);
-        /* close smb session */
-        int (*logoff)(const unsigned int, struct cifs_ses *);
-        /* connect to a server share */
-        int (*tree_connect)(const unsigned int, struct cifs_ses *, const char *,
-                            struct cifs_tcon *, const struct nls_table *);
-        /* close tree connecion */
-        int (*tree_disconnect)(const unsigned int, struct cifs_tcon *);
-        /* get DFS referrals */
-        int (*get_dfs_refer)(const unsigned int, struct cifs_ses *,
-                             const char *, struct dfs_info3_param **,
-                             unsigned int *, const struct nls_table *, int);
-        /* informational QFS call */
-        void (*qfs_tcon)(const unsigned int, struct cifs_tcon *);
-        /* check if a path is accessible or not */
-        int (*is_path_accessible)(const unsigned int, struct cifs_tcon *,
-                                  struct cifs_sb_info *, const char *);
-        /* query path data from the server */
-        int (*query_path_info)(const unsigned int, struct cifs_tcon *,
-                               struct cifs_sb_info *, const char *,
-                               FILE_ALL_INFO *, bool *);
-        /* query file data from the server */
-        int (*query_file_info)(const unsigned int, struct cifs_tcon *,
-                               struct cifs_fid *, FILE_ALL_INFO *);
-        /* get server index number */
-        int (*get_srv_inum)(const unsigned int, struct cifs_tcon *,
-                            struct cifs_sb_info *, const char *,
-                            u64 *uniqueid, FILE_ALL_INFO *);
-        /* set size by path */
-        int (*set_path_size)(const unsigned int, struct cifs_tcon *,
-                             const char *, __u64, struct cifs_sb_info *, bool);
-        /* set size by file handle */
-        int (*set_file_size)(const unsigned int, struct cifs_tcon *,
-                             struct cifsFileInfo *, __u64, bool);
-        /* set attributes */
-        int (*set_file_info)(struct inode *, const char *, FILE_BASIC_INFO *,
-                             const unsigned int);
-        /* check if we can send an echo or nor */
-        bool (*can_echo)(struct TCP_Server_Info *);
-        /* send echo request */
-        int (*echo)(struct TCP_Server_Info *);
-        /* create directory */
-        int (*mkdir)(const unsigned int, struct cifs_tcon *, const char *,
-                     struct cifs_sb_info *);
-        /* set info on created directory */
-        void (*mkdir_setinfo)(struct inode *, const char *,
-                              struct cifs_sb_info *, struct cifs_tcon *,
-                              const unsigned int);
-        /* remove directory */
-        int (*rmdir)(const unsigned int, struct cifs_tcon *, const char *,
-                     struct cifs_sb_info *);
-        /* unlink file */
-        int (*unlink)(const unsigned int, struct cifs_tcon *, const char *,
-                      struct cifs_sb_info *);
-        /* open, rename and delete file */
-        int (*rename_pending_delete)(const char *, struct dentry *,
-                                     const unsigned int);
-        /* send rename request */
-        int (*rename)(const unsigned int, struct cifs_tcon *, const char *,
-                      const char *, struct cifs_sb_info *);
-        /* send create hardlink request */
-        int (*create_hardlink)(const unsigned int, struct cifs_tcon *,
-                               const char *, const char *,
-                               struct cifs_sb_info *);
-        /* open a file for non-posix mounts */
-        int (*open)(const unsigned int, struct cifs_tcon *, const char *, int,
-                    int, int, struct cifs_fid *, __u32 *, FILE_ALL_INFO *,
-                    struct cifs_sb_info *);
-        /* set fid protocol-specific info */
-        void (*set_fid)(struct cifsFileInfo *, struct cifs_fid *, __u32);
-        /* close a file */
-        void (*close)(const unsigned int, struct cifs_tcon *,
-                      struct cifs_fid *);
-        /* send a flush request to the server */
-        int (*flush)(const unsigned int, struct cifs_tcon *, struct cifs_fid *);
-        /* async read from the server */
-        int (*async_readv)(struct cifs_readdata *);
-        /* async write to the server */
-        int (*async_writev)(struct cifs_writedata *);
-        /* sync read from the server */
-        int (*sync_read)(const unsigned int, struct cifsFileInfo *,
-                         struct cifs_io_parms *, unsigned int *, char **,
-                         int *);
-        /* sync write to the server */
-        int (*sync_write)(const unsigned int, struct cifsFileInfo *,
-                          struct cifs_io_parms *, unsigned int *, struct kvec *,
-                          unsigned long);
-        /* open dir, start readdir */
-        int (*query_dir_first)(const unsigned int, struct cifs_tcon *,
-                               const char *, struct cifs_sb_info *,
-                               struct cifs_fid *, __u16,
-                               struct cifs_search_info *);
-        /* continue readdir */
-        int (*query_dir_next)(const unsigned int, struct cifs_tcon *,
-                              struct cifs_fid *,
-                              __u16, struct cifs_search_info *srch_inf);
-        /* close dir */
-        int (*close_dir)(const unsigned int, struct cifs_tcon *,
-                         struct cifs_fid *);
-        /* calculate a size of SMB message */
-        unsigned int (*calc_smb_size)(void *);
-        /* check for STATUS_PENDING and process it in a positive case */
-        bool (*is_status_pending)(char *, struct TCP_Server_Info *, int);
-        /* send oplock break response */
-        int (*oplock_response)(struct cifs_tcon *, struct cifs_fid *,
-                               struct cifsInodeInfo *);
-        /* query remote filesystem */
-        int (*queryfs)(const unsigned int, struct cifs_tcon *,
-                       struct kstatfs *);
-        /* send mandatory brlock to the server */
-        int (*mand_lock)(const unsigned int, struct cifsFileInfo *, __u64,
-                         __u64, __u32, int, int, bool);
-        /* unlock range of mandatory locks */
-        int (*mand_unlock_range)(struct cifsFileInfo *, struct file_lock *,
-                                 const unsigned int);
-        /* push brlocks from the cache to the server */
-        int (*push_mand_locks)(struct cifsFileInfo *);
-        /* get lease key of the inode */
-        void (*get_lease_key)(struct inode *, struct cifs_fid *fid);
-        /* set lease key of the inode */
-        void (*set_lease_key)(struct inode *, struct cifs_fid *fid);
-        /* generate new lease key */
-        void (*new_lease_key)(struct cifs_fid *fid);
-        int (*calc_signature)(struct smb_rqst *rqst,
-                                   struct TCP_Server_Info *server);
-};
-
-struct smb_version_values {
-        char            *version_string;
-        __u16           protocol_id;
-        __u32           req_capabilities;
-        __u32           large_lock_type;
-        __u32           exclusive_lock_type;
-        __u32           shared_lock_type;
-        __u32           unlock_lock_type;
-        size_t          header_size;
-        size_t          max_header_size;
-        size_t          read_rsp_size;
-        __le16          lock_cmd;
-        unsigned int    cap_unix;
-        unsigned int    cap_nt_find;
-        unsigned int    cap_large_files;
-        unsigned int    oplock_read;
-};
-
-#define HEADER_SIZE(server) (server->vals->header_size)
-#define MAX_HEADER_SIZE(server) (server->vals->max_header_size)
-
 struct smb_vol {
         char *username;
         char *password;
         char *domainname;
         char *UNC;
+        char *UNCip;
         char *iocharset;  /* local code page for mapping to and from Unicode */
         char source_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* clnt nb name */
         char target_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* srvr nb name */
         uid_t cred_uid;
         uid_t linux_uid;
         gid_t linux_gid;
-        uid_t backupuid;
-        gid_t backupgid;
-        umode_t file_mode;
-        umode_t dir_mode;
+        mode_t file_mode;
+        mode_t dir_mode;
         unsigned secFlg;
         bool retry:1;
         bool intr:1;
@@ -417,8 +179,6 @@ struct smb_vol {
         bool noperm:1;
         bool no_psx_acl:1; /* set if posix acl support should be disabled */
         bool cifs_acl:1;
-        bool backupuid_specified; /* mount option  backupuid  is specified */
-        bool backupgid_specified; /* mount option  backupgid  is specified */
         bool no_xattr:1;   /* set if xattr (EA) support should be disabled*/
         bool server_ino:1; /* use inode numbers from server ie UniqueId */
         bool direct_io:1;
@@ -444,11 +204,9 @@ struct smb_vol {
         unsigned int rsize;
         unsigned int wsize;
         bool sockopt_tcp_nodelay:1;
+        unsigned short int port;
         unsigned long actimeo; /* attribute cache timeout (jiffies) */
-        struct smb_version_operations *ops;
-        struct smb_version_values *vals;
         char *prepath;
-        struct sockaddr_storage dstaddr; /* destination address */
         struct sockaddr_storage srcaddr; /* allow binding to a local IP */
         struct nls_table *local_nls;
 };
@@ -461,8 +219,7 @@ struct smb_vol {
                          CIFS_MOUNT_OVERR_GID | CIFS_MOUNT_DYNPERM | \
                          CIFS_MOUNT_NOPOSIXBRL | CIFS_MOUNT_NOSSYNC | \
                          CIFS_MOUNT_FSCACHE | CIFS_MOUNT_MF_SYMLINKS | \
-                         CIFS_MOUNT_MULTIUSER | CIFS_MOUNT_STRICT_IO | \
-                         CIFS_MOUNT_CIFS_BACKUPUID | CIFS_MOUNT_CIFS_BACKUPGID)
+                         CIFS_MOUNT_MULTIUSER | CIFS_MOUNT_STRICT_IO)
 
 #define CIFS_MS_MASK (MS_RDONLY | MS_MANDLOCK | MS_NOEXEC | MS_NOSUID | \
                       MS_NODEV | MS_SYNCHRONOUS)
@@ -473,26 +230,12 @@ struct cifs_mnt_data {
         int flags;
 };
 
-static inline unsigned int
-get_rfc1002_length(void *buf)
-{
-        return be32_to_cpu(*((__be32 *)buf));
-}
-
-static inline void
-inc_rfc1001_len(void *buf, int count)
-{
-        be32_add_cpu((__be32 *)buf, count);
-}
-
 struct TCP_Server_Info {
         struct list_head tcp_ses_list;
         struct list_head smb_ses_list;
         int srv_count; /* reference counter */
         /* 15 character server name + 0x20 16th byte indicating type = srv */
         char server_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL];
-        struct smb_version_operations   *ops;
-        struct smb_version_values       *vals;
         enum statusEnum tcpStatus; /* what we think the status is */
         char *hostname; /* hostname portion of UNC string */
         struct socket *ssocket;
@@ -507,22 +250,14 @@ struct TCP_Server_Info {
         bool noblocksnd;                /* use blocking sendmsg */
         bool noautotune;                /* do not autotune send buf sizes */
         bool tcp_nodelay;
-        int credits;  /* send no more requests at once */
-        unsigned int in_flight;  /* number of requests on the wire to server */
-        spinlock_t req_lock;  /* protect the two values above */
+        atomic_t inFlight;  /* number of requests on the wire to server */
         struct mutex srv_mutex;
         struct task_struct *tsk;
         char server_GUID[16];
-        __u16 sec_mode;
+        char sec_mode;
         bool session_estab; /* mark when very first sess is established */
-#ifdef CONFIG_CIFS_SMB2
-        int echo_credits;  /* echo reserved slots */
-        int oplock_credits;  /* oplock break reserved slots */
-        bool echoes:1; /* enable echoes */
-#endif
         u16 dialect; /* dialect index that server chose */
         enum securityEnum secType;
-        bool oplocks:1; /* enable oplocks */
         unsigned int maxReq;    /* Clients should submit no more */
         /* than maxReq distinct unanswered SMBs to the server when using  */
         /* multiplexed reads or writes */
@@ -536,9 +271,9 @@ struct TCP_Server_Info {
         unsigned int max_vcs;   /* maximum number of smb sessions, at least
                                    those that can be specified uniquely with
                                    vcnumbers */
-        unsigned int capabilities; /* selective disabling of caps by smb sess */
+        int capabilities; /* allow selective disabling of caps by smb sess */
         int timeAdj;  /* Adjust for difference in server time zone in sec */
-        __u64 CurrentMid;         /* multiplex id - rotating counter */
+        __u16 CurrentMid;         /* multiplex id - rotating counter */
         char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlm, ntlmv2 etc */
         /* 16th byte of RFC1001 workstation name is always null */
         char workstation_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL];
@@ -551,13 +286,7 @@ struct TCP_Server_Info {
         bool    sec_kerberosu2u;        /* supports U2U Kerberos */
         bool    sec_kerberos;           /* supports plain Kerberos */
         bool    sec_mskerberos;         /* supports legacy MS Kerberos */
-        bool    large_buf;              /* is current buffer large? */
         struct delayed_work     echo; /* echo ping workqueue job */
-        struct kvec *iov;       /* reusable kvec array for receives */
-        unsigned int nr_iov;    /* number of kvecs in array */
-        char    *smallbuf;      /* pointer to current "small" buffer */
-        char    *bigbuf;        /* pointer to current "big" buffer */
-        unsigned int total_read; /* total amount of data read in this pass */
 #ifdef CONFIG_CIFS_FSCACHE
         struct fscache_cookie   *fscache; /* client index cache cookie */
 #endif
@@ -565,96 +294,8 @@ struct TCP_Server_Info {
         atomic_t in_send; /* requests trying to send */
         atomic_t num_waiters;   /* blocked waiting to get in sendrecv */
 #endif
-#ifdef CONFIG_CIFS_SMB2
-        unsigned int    max_read;
-        unsigned int    max_write;
-#endif /* CONFIG_CIFS_SMB2 */
 };
 
-static inline unsigned int
-in_flight(struct TCP_Server_Info *server)
-{
-        unsigned int num;
-        spin_lock(&server->req_lock);
-        num = server->in_flight;
-        spin_unlock(&server->req_lock);
-        return num;
-}
-
-static inline bool
-has_credits(struct TCP_Server_Info *server, int *credits)
-{
-        int num;
-        spin_lock(&server->req_lock);
-        num = *credits;
-        spin_unlock(&server->req_lock);
-        return num > 0;
-}
-
-static inline void
-add_credits(struct TCP_Server_Info *server, const unsigned int add,
-            const int optype)
-{
-        server->ops->add_credits(server, add, optype);
-}
-
-static inline void
-set_credits(struct TCP_Server_Info *server, const int val)
-{
-        server->ops->set_credits(server, val);
-}
-
-static inline __u64
-get_next_mid(struct TCP_Server_Info *server)
-{
-        return server->ops->get_next_mid(server);
-}
-
-/*
- * When the server supports very large reads and writes via POSIX extensions,
- * we can allow up to 2^24-1, minus the size of a READ/WRITE_AND_X header, not
- * including the RFC1001 length.
- *
- * Note that this might make for "interesting" allocation problems during
- * writeback however as we have to allocate an array of pointers for the
- * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
- *
- * For reads, there is a similar problem as we need to allocate an array
- * of kvecs to handle the receive, though that should only need to be done
- * once.
- */
-#define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
-#define CIFS_MAX_RSIZE ((1<<24) - sizeof(READ_RSP) + 4)
-
-/*
- * When the server doesn't allow large posix writes, only allow a rsize/wsize
- * of 2^17-1 minus the size of the call header. That allows for a read or
- * write up to the maximum size described by RFC1002.
- */
-#define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
-#define CIFS_MAX_RFC1002_RSIZE ((1<<17) - 1 - sizeof(READ_RSP) + 4)
-
-/*
- * The default wsize is 1M. find_get_pages seems to return a maximum of 256
- * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
- * a single wsize request with a single call.
- */
-#define CIFS_DEFAULT_IOSIZE (1024 * 1024)
-
-/*
- * Windows only supports a max of 60kb reads and 65535 byte writes. Default to
- * those values when posix extensions aren't in force. In actuality here, we
- * use 65536 to allow for a write that is a multiple of 4k. Most servers seem
- * to be ok with the extra byte even though Windows doesn't send writes that
- * are that large.
- *
- * Citation:
- *
- * http://blogs.msdn.com/b/openspecification/archive/2009/04/10/smb-maximum-transmit-buffer-size-and-performance-tuning.aspx
- */
-#define CIFS_DEFAULT_NON_POSIX_RSIZE (60 * 1024)
-#define CIFS_DEFAULT_NON_POSIX_WSIZE (65536)
-
 /*
  * Macros to allow the TCP_Server_Info->net field and related code to drop out
  * when CONFIG_NET_NS isn't set.
@@ -702,10 +343,10 @@ struct cifs_ses {
         char *serverOS;         /* name of operating system underlying server */
         char *serverNOS;        /* name of network operating system of server */
         char *serverDomain;     /* security realm of server */
-        __u64 Suid;             /* remote smb uid  */
+        int Suid;               /* remote smb uid  */
         uid_t linux_uid;        /* overriding owner of files on the mount */
         uid_t cred_uid;         /* owner of credentials */
-        unsigned int capabilities;
+        int capabilities;
         char serverName[SERVER_NAME_LEN_WITH_NULL * 2]; /* BB make bigger for
                                 TCP names - will ipv6 and sctp addresses fit? */
         char *user_name;        /* must not be null except during init of sess
@@ -715,11 +356,7 @@ struct cifs_ses {
         struct session_key auth_key;
         struct ntlmssp_auth *ntlmssp; /* ciphertext, flags, server challenge */
         bool need_reconnect:1; /* connection reset, uid now invalid */
-#ifdef CONFIG_CIFS_SMB2
-        __u16 session_flags;
-#endif /* CONFIG_CIFS_SMB2 */
 };
-
 /* no more than one of the following three session flags may be set */
 #define CIFS_SES_NT4 1
 #define CIFS_SES_OS2 2
@@ -728,13 +365,6 @@ struct cifs_ses {
    which do not negotiate NTLM or POSIX dialects, but instead
    negotiate one of the older LANMAN dialects */
 #define CIFS_SES_LANMAN 8
-
-static inline bool
-cap_unix(struct cifs_ses *ses)
-{
-        return ses->server->vals->cap_unix & ses->capabilities;
-}
-
 /*
  * there is one of these for each connection to a resource on a particular
  * session
@@ -747,42 +377,32 @@ struct cifs_tcon {
         char treeName[MAX_TREE_SIZE + 1]; /* UNC name of resource in ASCII */
         char *nativeFileSystem;
         char *password;         /* for share-level security */
-        __u32 tid;              /* The 4 byte tree id */
+        __u16 tid;              /* The 2 byte tree id */
         __u16 Flags;            /* optional support bits */
         enum statusEnum tidStatus;
 #ifdef CONFIG_CIFS_STATS
         atomic_t num_smbs_sent;
-        union {
-                struct {
-                        atomic_t num_writes;
-                        atomic_t num_reads;
-                        atomic_t num_flushes;
-                        atomic_t num_oplock_brks;
-                        atomic_t num_opens;
-                        atomic_t num_closes;
-                        atomic_t num_deletes;
-                        atomic_t num_mkdirs;
-                        atomic_t num_posixopens;
-                        atomic_t num_posixmkdirs;
-                        atomic_t num_rmdirs;
-                        atomic_t num_renames;
-                        atomic_t num_t2renames;
-                        atomic_t num_ffirst;
-                        atomic_t num_fnext;
-                        atomic_t num_fclose;
-                        atomic_t num_hardlinks;
-                        atomic_t num_symlinks;
-                        atomic_t num_locks;
-                        atomic_t num_acl_get;
-                        atomic_t num_acl_set;
-                } cifs_stats;
-#ifdef CONFIG_CIFS_SMB2
-                struct {
-                        atomic_t smb2_com_sent[NUMBER_OF_SMB2_COMMANDS];
-                        atomic_t smb2_com_failed[NUMBER_OF_SMB2_COMMANDS];
-                } smb2_stats;
-#endif /* CONFIG_CIFS_SMB2 */
-        } stats;
+        atomic_t num_writes;
+        atomic_t num_reads;
+        atomic_t num_flushes;
+        atomic_t num_oplock_brks;
+        atomic_t num_opens;
+        atomic_t num_closes;
+        atomic_t num_deletes;
+        atomic_t num_mkdirs;
+        atomic_t num_posixopens;
+        atomic_t num_posixmkdirs;
+        atomic_t num_rmdirs;
+        atomic_t num_renames;
+        atomic_t num_t2renames;
+        atomic_t num_ffirst;
+        atomic_t num_fnext;
+        atomic_t num_fclose;
+        atomic_t num_hardlinks;
+        atomic_t num_symlinks;
+        atomic_t num_locks;
+        atomic_t num_acl_get;
+        atomic_t num_acl_set;
 #ifdef CONFIG_CIFS_STATS2
         unsigned long long time_writes;
         unsigned long long time_reads;
@@ -813,20 +433,10 @@ struct cifs_tcon {
         bool local_lease:1; /* check leases (only) on local system not remote */
         bool broken_posix_open; /* e.g. Samba server versions < 3.3.2, 3.2.9 */
         bool need_reconnect:1; /* connection reset, tid now invalid */
-#ifdef CONFIG_CIFS_SMB2
-        bool print:1;           /* set if connection to printer share */
-        bool bad_network_name:1; /* set if ret status STATUS_BAD_NETWORK_NAME */
-        __u32 capabilities;
-        __u32 share_flags;
-        __u32 maximal_access;
-        __u32 vol_serial_number;
-        __le64 vol_create_time;
-#endif /* CONFIG_CIFS_SMB2 */
 #ifdef CONFIG_CIFS_FSCACHE
         u64 resource_id;                /* server resource id */
         struct fscache_cookie *fscache; /* cookie for share */
 #endif
-        struct list_head pending_opens; /* list of incomplete opens */
         /* BB add field for back pointer to sb struct(s)? */
 };
 
@@ -869,27 +479,15 @@ cifs_get_tlink(struct tcon_link *tlink)
 /* This function is always expected to succeed */
 extern struct cifs_tcon *cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb);
 
-#define CIFS_OPLOCK_NO_CHANGE 0xfe
-
-struct cifs_pending_open {
-        struct list_head olist;
-        struct tcon_link *tlink;
-        __u8 lease_key[16];
-        __u32 oplock;
-};
-
 /*
  * This info hangs off the cifsFileInfo structure, pointed to by llist.
  * This is used to track byte stream locks on the file
  */
 struct cifsLockInfo {
         struct list_head llist; /* pointer to next cifsLockInfo */
-        struct list_head blist; /* pointer to locks blocked on this */
-        wait_queue_head_t block_q;
         __u64 offset;
         __u64 length;
-        __u32 pid;
-        __u32 type;
+        __u8 type;
 };
 
 /*
@@ -911,34 +509,19 @@ struct cifs_search_info {
         bool smallBuf:1; /* so we know which buf_release function to call */
 };
 
-struct cifs_fid {
-        __u16 netfid;
-#ifdef CONFIG_CIFS_SMB2
-        __u64 persistent_fid;   /* persist file id for smb2 */
-        __u64 volatile_fid;     /* volatile file id for smb2 */
-        __u8 lease_key[SMB2_LEASE_KEY_SIZE];    /* lease key for smb2 */
-#endif
-        struct cifs_pending_open *pending_open;
-};
-
-struct cifs_fid_locks {
-        struct list_head llist;
-        struct cifsFileInfo *cfile;     /* fid that owns locks */
-        struct list_head locks;         /* locks held by fid above */
-};
-
 struct cifsFileInfo {
         struct list_head tlist; /* pointer to next fid owned by tcon */
         struct list_head flist; /* next fid (file instance) for this inode */
-        struct cifs_fid_locks *llist;   /* brlocks held by this fid */
         unsigned int uid;       /* allows finding which FileInfo structure */
         __u32 pid;              /* process id who opened file */
-        struct cifs_fid fid;    /* file id from remote */
+        __u16 netfid;           /* file id from remote */
         /* BB add lock scope info here if needed */ ;
         /* lock scope id (0 if none) */
         struct dentry *dentry;
         unsigned int f_flags;
         struct tcon_link *tlink;
+        struct mutex lock_mutex;
+        struct list_head llist; /* list of byte range locks we have. */
         bool invalidHandle:1;   /* file closed via session abend */
         bool oplock_break_cancelled:1;
         int count;              /* refcount protected by cifs_file_list_lock */
@@ -949,71 +532,21 @@ struct cifsFileInfo {
 
 struct cifs_io_parms {
         __u16 netfid;
-#ifdef CONFIG_CIFS_SMB2
-        __u64 persistent_fid;   /* persist file id for smb2 */
-        __u64 volatile_fid;     /* volatile file id for smb2 */
-#endif
         __u32 pid;
         __u64 offset;
         unsigned int length;
         struct cifs_tcon *tcon;
 };
 
-struct cifs_readdata;
-
-/* asynchronous read support */
-struct cifs_readdata {
-        struct kref                     refcount;
-        struct list_head                list;
-        struct completion               done;
-        struct cifsFileInfo             *cfile;
-        struct address_space            *mapping;
-        __u64                           offset;
-        unsigned int                    bytes;
-        pid_t                           pid;
-        int                             result;
-        struct work_struct              work;
-        int (*read_into_pages)(struct TCP_Server_Info *server,
-                                struct cifs_readdata *rdata,
-                                unsigned int len);
-        struct kvec                     iov;
-        unsigned int                    pagesz;
-        unsigned int                    tailsz;
-        unsigned int                    nr_pages;
-        struct page                     *pages[];
-};
-
-struct cifs_writedata;
-
-/* asynchronous write support */
-struct cifs_writedata {
-        struct kref                     refcount;
-        struct list_head                list;
-        struct completion               done;
-        enum writeback_sync_modes       sync_mode;
-        struct work_struct              work;
-        struct cifsFileInfo             *cfile;
-        __u64                           offset;
-        pid_t                           pid;
-        unsigned int                    bytes;
-        int                             result;
-        unsigned int                    pagesz;
-        unsigned int                    tailsz;
-        unsigned int                    nr_pages;
-        struct page                     *pages[1];
-};
-
 /*
  * Take a reference on the file private data. Must be called with
  * cifs_file_list_lock held.
  */
-static inline void
-cifsFileInfo_get_locked(struct cifsFileInfo *cifs_file)
+static inline void cifsFileInfo_get(struct cifsFileInfo *cifs_file)
 {
         ++cifs_file->count;
 }
 
-struct cifsFileInfo *cifsFileInfo_get(struct cifsFileInfo *cifs_file);
 void cifsFileInfo_put(struct cifsFileInfo *cifs_file);
 
 /*
@@ -1021,9 +554,7 @@ void cifsFileInfo_put(struct cifsFileInfo *cifs_file);
  */
 
 struct cifsInodeInfo {
-        bool can_cache_brlcks;
-        struct list_head llist; /* locks helb by this inode */
-        struct rw_semaphore lock_sem;   /* protect the fields above */
+        struct list_head lockList;
         /* BB add in lists for dirty pages i.e. write caching info for oplock */
         struct list_head openFileList;
         __u32 cifsAttrs; /* e.g. DOS archive bit, sparse, compressed, system */
@@ -1032,12 +563,9 @@ struct cifsInodeInfo {
         bool delete_pending;            /* DELETE_ON_CLOSE is set */
         bool invalid_mapping;           /* pagecache is invalid */
         unsigned long time;             /* jiffies of last update of inode */
-        u64  server_eof;                /* current file size on server -- protected by i_lock */
+        u64  server_eof;                /* current file size on server */
         u64  uniqueid;                  /* server inode number */
         u64  createtime;                /* creation time on server */
-#ifdef CONFIG_CIFS_SMB2
-        __u8 lease_key[SMB2_LEASE_KEY_SIZE];    /* lease key for this inode */
-#endif
 #ifdef CONFIG_CIFS_FSCACHE
         struct fscache_cookie *fscache;
 #endif
@@ -1067,16 +595,21 @@ static inline char CIFS_DIR_SEP(const struct cifs_sb_info *cifs_sb)
 static inline void
 convert_delimiter(char *path, char delim)
 {
-        char old_delim, *pos;
+        int i;
+        char old_delim;
+
+        if (path == NULL)
+                return;
 
         if (delim == '/')
                 old_delim = '\\';
         else
                 old_delim = '/';
 
-        pos = path;
-        while ((pos = strchr(pos, old_delim)))
-                *pos = delim;
+        for (i = 0; path[i] != '\0'; i++) {
+                if (path[i] == old_delim)
+                        path[i] = delim;
+        }
 }
 
 #ifdef CONFIG_CIFS_STATS
@@ -1107,26 +640,11 @@ static inline void cifs_stats_bytes_read(struct cifs_tcon *tcon,
 
 #endif
 
+struct mid_q_entry;
 
 /*
- * This is the prototype for the mid receive function. This function is for
- * receiving the rest of the SMB frame, starting with the WordCount (which is
- * just after the MID in struct smb_hdr). Note:
- *
- * - This will be called by cifsd, with no locks held.
- * - The mid will still be on the pending_mid_q.
- * - mid->resp_buf will point to the current buffer.
- *
- * Returns zero on a successful receive, or an error. The receive state in
- * the TCP_Server_Info will also be updated.
- */
-typedef int (mid_receive_t)(struct TCP_Server_Info *server,
-                            struct mid_q_entry *mid);
-
-/*
- * This is the prototype for the mid callback function. This is called once the
- * mid has been received off of the socket. When creating one, take special
- * care to avoid deadlocks. Things to bear in mind:
+ * This is the prototype for the mid callback function. When creating one,
+ * take special care to avoid deadlocks. Things to bear in mind:
  *
  * - it will be called by cifsd, with no locks held
  * - the mid will be removed from any lists
@@ -1136,22 +654,20 @@ typedef void (mid_callback_t)(struct mid_q_entry *mid);
 /* one of these for every pending CIFS request to the server */
 struct mid_q_entry {
         struct list_head qhead; /* mids waiting on reply from this server */
-        struct TCP_Server_Info *server; /* server corresponding to this mid */
-        __u64 mid;              /* multiplex id */
-        __u32 pid;              /* process id */
+        __u16 mid;              /* multiplex id */
+        __u16 pid;              /* process id */
         __u32 sequence_number;  /* for CIFS signing */
         unsigned long when_alloc;  /* when mid was created */
 #ifdef CONFIG_CIFS_STATS2
         unsigned long when_sent; /* time when smb send finished */
         unsigned long when_received; /* when demux complete (taken off wire) */
 #endif
-        mid_receive_t *receive; /* call receive callback */
         mid_callback_t *callback; /* call completion callback */
         void *callback_data;      /* general purpose pointer for callback */
-        void *resp_buf;         /* pointer to received SMB header */
-        int mid_state;  /* wish this were enum but can not pass to wait_event */
-        __le16 command;         /* smb command code */
-        bool large_buf:1;       /* if valid response, is pointer to large buf */
+        struct smb_hdr *resp_buf;       /* response buffer */
+        int midState;   /* wish this were enum but can not pass to wait_event */
+        __u8 command;   /* smb command code */
+        bool largeBuf:1;        /* if valid response, is pointer to large buf */
         bool multiRsp:1;        /* multiple trans2 responses for one request  */
         bool multiEnd:1;        /* both received */
 };
@@ -1300,12 +816,6 @@ static inline void free_dfs_info_array(struct dfs_info3_param *param,
 #define   CIFS_LARGE_BUF_OP 0x020    /* large request buffer */
 #define   CIFS_NO_RESP      0x040    /* no response buffer required */
 
-/* Type of request operation */
-#define   CIFS_ECHO_OP      0x080    /* echo request */
-#define   CIFS_OBREAK_OP   0x0100    /* oplock break request */
-#define   CIFS_NEG_OP      0x0200    /* negotiate request */
-#define   CIFS_OP_MASK     0x0380    /* mask request type */
-
 /* Security Flags: indicate type of session setup needed */
 #define   CIFSSEC_MAY_SIGN      0x00001
 #define   CIFSSEC_MAY_NTLM      0x00002
@@ -1337,8 +847,6 @@ require use of the stronger protocol */
 #define   CIFSSEC_MASK          0xB70B7 /* current flags supported if weak */
 #endif /* UPCALL */
 #else /* do not allow weak pw hash */
-#define   CIFSSEC_MUST_LANMAN   0
-#define   CIFSSEC_MUST_PLNTXT   0
 #ifdef CONFIG_CIFS_UPCALL
 #define   CIFSSEC_MASK          0x8F08F /* flags supported if no weak allowed */
 #else
@@ -1348,7 +856,7 @@ require use of the stronger protocol */
 #define   CIFSSEC_MUST_SEAL     0x40040 /* not supported yet */
 #define   CIFSSEC_MUST_NTLMSSP  0x80080 /* raw ntlmssp with ntlmv2 */
 
-#define   CIFSSEC_DEF (CIFSSEC_MAY_SIGN | CIFSSEC_MAY_NTLMSSP)
+#define   CIFSSEC_DEF (CIFSSEC_MAY_SIGN | CIFSSEC_MAY_NTLM | CIFSSEC_MAY_NTLMV2)
 #define   CIFSSEC_MAX (CIFSSEC_MUST_SIGN | CIFSSEC_MUST_NTLMV2)
 #define   CIFSSEC_AUTH_MASK (CIFSSEC_MAY_NTLM | CIFSSEC_MAY_NTLMV2 | CIFSSEC_MAY_LANMAN | CIFSSEC_MAY_PLNTXT | CIFSSEC_MAY_KRB5 | CIFSSEC_MAY_NTLMSSP)
 /*
@@ -1452,7 +960,11 @@ GLOBAL_EXTERN atomic_t smBufAllocCount;
 GLOBAL_EXTERN atomic_t midCount;
 
 /* Misc globals */
-GLOBAL_EXTERN bool enable_oplocks; /* enable or disable oplocks */
+GLOBAL_EXTERN unsigned int multiuser_mount; /* if enabled allows new sessions
+                                to be established on existing mount if we
+                                have the uid/password or Kerberos credential
+                                or equivalent for current user */
+GLOBAL_EXTERN unsigned int oplockEnabled;
 GLOBAL_EXTERN unsigned int lookupCacheEnabled;
 GLOBAL_EXTERN unsigned int global_secflags;     /* if on, session setup sent
                                 with more secure ntlmssp2 challenge/resp */
@@ -1463,35 +975,16 @@ GLOBAL_EXTERN unsigned int cifs_min_rcv;    /* min size of big ntwrk buf pool */
 GLOBAL_EXTERN unsigned int cifs_min_small;  /* min size of small buf pool */
 GLOBAL_EXTERN unsigned int cifs_max_pending; /* MAX requests at once to server*/
 
-#ifdef CONFIG_CIFS_ACL
+/* reconnect after this many failed echo attempts */
+GLOBAL_EXTERN unsigned short echo_retries;
+
 GLOBAL_EXTERN struct rb_root uidtree;
 GLOBAL_EXTERN struct rb_root gidtree;
 GLOBAL_EXTERN spinlock_t siduidlock;
 GLOBAL_EXTERN spinlock_t sidgidlock;
-GLOBAL_EXTERN struct rb_root siduidtree;
-GLOBAL_EXTERN struct rb_root sidgidtree;
-GLOBAL_EXTERN spinlock_t uidsidlock;
-GLOBAL_EXTERN spinlock_t gidsidlock;
-#endif /* CONFIG_CIFS_ACL */
 
 void cifs_oplock_break(struct work_struct *work);
 
 extern const struct slow_work_ops cifs_oplock_break_ops;
-extern struct workqueue_struct *cifsiod_wq;
-
-extern mempool_t *cifs_mid_poolp;
-
-/* Operations for different SMB versions */
-#define SMB1_VERSION_STRING     "1.0"
-extern struct smb_version_operations smb1_operations;
-extern struct smb_version_values smb1_values;
-#define SMB20_VERSION_STRING    "2.0"
-/*extern struct smb_version_operations smb20_operations; */ /* not needed yet */
-extern struct smb_version_values smb20_values;
-#define SMB21_VERSION_STRING    "2.1"
-extern struct smb_version_operations smb21_operations;
-extern struct smb_version_values smb21_values;
-#define SMB30_VERSION_STRING    "3.0"
-extern struct smb_version_operations smb30_operations;
-extern struct smb_version_values smb30_values;
+
 #endif  /* _CIFS_GLOB_H */
diff --git a/fs/cifs/cifspdu.h b/fs/cifs/cifspdu.h
index b9d59a948a2..de3aa285de0 100644
--- a/fs/cifs/cifspdu.h
+++ b/fs/cifs/cifspdu.h
@@ -1089,7 +1089,9 @@ typedef struct smb_com_read_rsp {
         __le16 DataLengthHigh;
         __u64 Reserved2;
         __u16 ByteCount;
-        /* read response data immediately follows */
+        __u8 Pad;               /* BB check for whether padded to DWORD
+                                   boundary and optimum performance here */
+        char Data[1];
 } __attribute__((packed)) READ_RSP;
 
 typedef struct locking_andx_range {
@@ -1911,10 +1913,6 @@ typedef struct whoami_rsp_data { /* Query level 0x202 */
 
 /* SETFSInfo Levels */
 #define SMB_SET_CIFS_UNIX_INFO    0x200
-/* level 0x203 is defined above in list of QFS info levels */
-/* #define SMB_REQUEST_TRANSPORT_ENCRYPTION 0x203 */
-
-/* Level 0x200 request structure follows */
 typedef struct smb_com_transaction2_setfsi_req {
         struct smb_hdr hdr;     /* wct = 15 */
         __le16 TotalParameterCount;
@@ -1942,39 +1940,13 @@ typedef struct smb_com_transaction2_setfsi_req {
         __le64 ClientUnixCap;   /* Data end */
 } __attribute__((packed)) TRANSACTION2_SETFSI_REQ;
 
-/* level 0x203 request structure follows */
-typedef struct smb_com_transaction2_setfs_enc_req {
-        struct smb_hdr hdr;     /* wct = 15 */
-        __le16 TotalParameterCount;
-        __le16 TotalDataCount;
-        __le16 MaxParameterCount;
-        __le16 MaxDataCount;
-        __u8 MaxSetupCount;
-        __u8 Reserved;
-        __le16 Flags;
-        __le32 Timeout;
-        __u16 Reserved2;
-        __le16 ParameterCount;  /* 4 */
-        __le16 ParameterOffset;
-        __le16 DataCount;       /* 12 */
-        __le16 DataOffset;
-        __u8 SetupCount;        /* one */
-        __u8 Reserved3;
-        __le16 SubCommand;      /* TRANS2_SET_FS_INFORMATION */
-        __le16 ByteCount;
-        __u8 Pad;
-        __u16  Reserved4;       /* Parameters start. */
-        __le16 InformationLevel;/* Parameters end. */
-        /* NTLMSSP Blob, Data start. */
-} __attribute__((packed)) TRANSACTION2_SETFSI_ENC_REQ;
-
-/* response for setfsinfo levels 0x200 and 0x203 */
 typedef struct smb_com_transaction2_setfsi_rsp {
         struct smb_hdr hdr;     /* wct = 10 */
         struct trans2_resp t2;
         __u16 ByteCount;
 } __attribute__((packed)) TRANSACTION2_SETFSI_RSP;
 
+
 typedef struct smb_com_transaction2_get_dfs_refer_req {
         struct smb_hdr hdr;     /* wct = 15 */
         __le16 TotalParameterCount;
@@ -2126,13 +2098,13 @@ typedef struct {
 #define CIFS_UNIX_PROXY_CAP             0x00000400 /* Proxy cap: 0xACE ioctl and
                                                       QFS PROXY call */
 #ifdef CONFIG_CIFS_POSIX
-/* presumably don't need the 0x20 POSIX_PATH_OPS_CAP since we never send
-   LockingX instead of posix locking call on unix sess (and we do not expect
-   LockingX to use different (ie Windows) semantics than posix locking on
-   the same session (if WINE needs to do this later, we can add this cap
-   back in later */
+/* Can not set pathnames cap yet until we send new posix create SMB since
+   otherwise server can treat such handles opened with older ntcreatex
+   (by a new client which knows how to send posix path ops)
+   as non-posix handles (can affect write behavior with byte range locks.
+   We can add back in POSIX_PATH_OPS cap when Posix Create/Mkdir finished */
 /* #define CIFS_UNIX_CAP_MASK              0x000000fb */
-#define CIFS_UNIX_CAP_MASK              0x000003db
+#define CIFS_UNIX_CAP_MASK              0x000000db
 #else
 #define CIFS_UNIX_CAP_MASK              0x00000013
 #endif /* CONFIG_CIFS_POSIX */
@@ -2210,7 +2182,7 @@ typedef struct { /* data block encoding of response to level 263 QPathInfo */
         __u8 DeletePending;
         __u8 Directory;
         __u16 Pad2;
-        __le64 IndexNumber;
+        __u64 IndexNumber;
         __le32 EASize;
         __le32 AccessFlags;
         __u64 IndexNumber1;
diff --git a/fs/cifs/cifsproto.h b/fs/cifs/cifsproto.h
index 1988c1baa22..8df28e925e5 100644
--- a/fs/cifs/cifsproto.h
+++ b/fs/cifs/cifsproto.h
@@ -24,7 +24,6 @@
 
 struct statfs;
 struct smb_vol;
-struct smb_rqst;
 
 /*
  *****************************************************************
@@ -36,28 +35,27 @@ extern struct smb_hdr *cifs_buf_get(void);
 extern void cifs_buf_release(void *);
 extern struct smb_hdr *cifs_small_buf_get(void);
 extern void cifs_small_buf_release(void *);
-extern void cifs_rqst_page_to_kvec(struct smb_rqst *rqst, unsigned int idx,
-                                        struct kvec *iov);
 extern int smb_send(struct TCP_Server_Info *, struct smb_hdr *,
                         unsigned int /* length */);
-extern unsigned int _get_xid(void);
-extern void _free_xid(unsigned int);
-#define get_xid()                                               \
+extern unsigned int _GetXid(void);
+extern void _FreeXid(unsigned int);
+#define GetXid()                                                \
 ({                                                              \
-        unsigned int __xid = _get_xid();                                \
-        cFYI(1, "CIFS VFS: in %s as Xid: %u with uid: %d",      \
+        int __xid = (int)_GetXid();                             \
+        cFYI(1, "CIFS VFS: in %s as Xid: %d with uid: %d",      \
              __func__, __xid, current_fsuid());                 \
         __xid;                                                  \
 })
 
-#define free_xid(curr_xid)                                      \
+#define FreeXid(curr_xid)                                       \
 do {                                                            \
-        _free_xid(curr_xid);                                    \
-        cFYI(1, "CIFS VFS: leaving %s (xid = %u) rc = %d",      \
+        _FreeXid(curr_xid);                                     \
+        cFYI(1, "CIFS VFS: leaving %s (xid = %d) rc = %d",      \
              __func__, curr_xid, (int)rc);                      \
 } while (0)
 extern int init_cifs_idmap(void);
 extern void exit_cifs_idmap(void);
+extern void cifs_destroy_idmaptrees(void);
 extern char *build_path_from_dentry(struct dentry *);
 extern char *cifs_build_path_to_root(struct smb_vol *vol,
                                      struct cifs_sb_info *cifs_sb,
@@ -70,22 +68,15 @@ extern char *cifs_compose_mount_options(const char *sb_mountdata,
 extern struct mid_q_entry *AllocMidQEntry(const struct smb_hdr *smb_buffer,
                                         struct TCP_Server_Info *server);
 extern void DeleteMidQEntry(struct mid_q_entry *midEntry);
-extern void cifs_delete_mid(struct mid_q_entry *mid);
-extern void cifs_wake_up_task(struct mid_q_entry *mid);
-extern int cifs_call_async(struct TCP_Server_Info *server,
-                        struct smb_rqst *rqst,
-                        mid_receive_t *receive, mid_callback_t *callback,
-                        void *cbdata, const int flags);
+extern int cifs_call_async(struct TCP_Server_Info *server, struct kvec *iov,
+                           unsigned int nvec, mid_callback_t *callback,
+                           void *cbdata, bool ignore_pend);
 extern int SendReceive(const unsigned int /* xid */ , struct cifs_ses *,
                         struct smb_hdr * /* input */ ,
                         struct smb_hdr * /* out */ ,
-                        int * /* bytes returned */ , const int);
+                        int * /* bytes returned */ , const int long_op);
 extern int SendReceiveNoRsp(const unsigned int xid, struct cifs_ses *ses,
-                            char *in_buf, int flags);
-extern struct mid_q_entry *cifs_setup_request(struct cifs_ses *,
-                                struct smb_rqst *);
-extern struct mid_q_entry *cifs_setup_async_request(struct TCP_Server_Info *,
-                                                struct smb_rqst *);
+                        struct smb_hdr *in_buf, int flags);
 extern int cifs_check_receive(struct mid_q_entry *mid,
                         struct TCP_Server_Info *server, bool log_error);
 extern int SendReceive2(const unsigned int /* xid */ , struct cifs_ses *,
@@ -96,83 +87,70 @@ extern int SendReceiveBlockingLock(const unsigned int xid,
                         struct smb_hdr *in_buf ,
                         struct smb_hdr *out_buf,
                         int *bytes_returned);
-extern int cifs_reconnect(struct TCP_Server_Info *server);
-extern int checkSMB(char *buf, unsigned int length);
-extern bool is_valid_oplock_break(char *, struct TCP_Server_Info *);
-extern bool backup_cred(struct cifs_sb_info *);
+extern int checkSMB(struct smb_hdr *smb, __u16 mid, unsigned int length);
+extern bool is_valid_oplock_break(struct smb_hdr *smb,
+                                  struct TCP_Server_Info *);
 extern bool is_size_safe_to_change(struct cifsInodeInfo *, __u64 eof);
 extern void cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
                             unsigned int bytes_written);
 extern struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *, bool);
 extern struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *, bool);
-extern unsigned int smbCalcSize(void *buf);
+extern unsigned int smbCalcSize(struct smb_hdr *ptr);
 extern int decode_negTokenInit(unsigned char *security_blob, int length,
                         struct TCP_Server_Info *server);
 extern int cifs_convert_address(struct sockaddr *dst, const char *src, int len);
-extern void cifs_set_port(struct sockaddr *addr, const unsigned short int port);
-extern int map_smb_to_linux_error(char *buf, bool logErr);
+extern int cifs_set_port(struct sockaddr *addr, const unsigned short int port);
+extern int cifs_fill_sockaddr(struct sockaddr *dst, const char *src, int len,
+                                const unsigned short int port);
+extern int map_smb_to_linux_error(struct smb_hdr *smb, bool logErr);
 extern void header_assemble(struct smb_hdr *, char /* command */ ,
                             const struct cifs_tcon *, int /* length of
                             fixed section (word count) in two byte units */);
 extern int small_smb_init_no_tc(const int smb_cmd, const int wct,
                                 struct cifs_ses *ses,
                                 void **request_buf);
-extern int CIFS_SessSetup(const unsigned int xid, struct cifs_ses *ses,
-                          const struct nls_table *nls_cp);
+extern int CIFS_SessSetup(unsigned int xid, struct cifs_ses *ses,
+                             const struct nls_table *nls_cp);
+extern __u16 GetNextMid(struct TCP_Server_Info *server);
 extern struct timespec cifs_NTtimeToUnix(__le64 utc_nanoseconds_since_1601);
 extern u64 cifs_UnixTimeToNT(struct timespec);
 extern struct timespec cnvrtDosUnixTm(__le16 le_date, __le16 le_time,
                                       int offset);
 extern void cifs_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock);
-extern int cifs_unlock_range(struct cifsFileInfo *cfile,
-                             struct file_lock *flock, const unsigned int xid);
-extern int cifs_push_mandatory_locks(struct cifsFileInfo *cfile);
 
-extern struct cifsFileInfo *cifs_new_fileinfo(struct cifs_fid *fid,
-                                              struct file *file,
-                                              struct tcon_link *tlink,
-                                              __u32 oplock);
-extern int cifs_posix_open(char *full_path, struct inode **inode,
-                           struct super_block *sb, int mode,
-                           unsigned int f_flags, __u32 *oplock, __u16 *netfid,
-                           unsigned int xid);
+extern struct cifsFileInfo *cifs_new_fileinfo(__u16 fileHandle,
+                                struct file *file, struct tcon_link *tlink,
+                                __u32 oplock);
+extern int cifs_posix_open(char *full_path, struct inode **pinode,
+                                struct super_block *sb,
+                                int mode, unsigned int f_flags,
+                                __u32 *poplock, __u16 *pnetfid, int xid);
 void cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr);
 extern void cifs_unix_basic_to_fattr(struct cifs_fattr *fattr,
                                      FILE_UNIX_BASIC_INFO *info,
                                      struct cifs_sb_info *cifs_sb);
-extern void cifs_dir_info_to_fattr(struct cifs_fattr *, FILE_DIRECTORY_INFO *,
-                                        struct cifs_sb_info *);
 extern void cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr);
 extern struct inode *cifs_iget(struct super_block *sb,
                                struct cifs_fattr *fattr);
 
-extern int cifs_get_inode_info(struct inode **inode, const char *full_path,
-                               FILE_ALL_INFO *data, struct super_block *sb,
-                               int xid, const __u16 *fid);
+extern int cifs_get_file_info(struct file *filp);
+extern int cifs_get_inode_info(struct inode **pinode,
+                        const unsigned char *search_path,
+                        FILE_ALL_INFO *pfile_info,
+                        struct super_block *sb, int xid, const __u16 *pfid);
+extern int cifs_get_file_info_unix(struct file *filp);
 extern int cifs_get_inode_info_unix(struct inode **pinode,
                         const unsigned char *search_path,
-                        struct super_block *sb, unsigned int xid);
-extern int cifs_set_file_info(struct inode *inode, struct iattr *attrs,
-                              unsigned int xid, char *full_path, __u32 dosattr);
-extern int cifs_rename_pending_delete(const char *full_path,
-                                      struct dentry *dentry,
-                                      const unsigned int xid);
+                        struct super_block *sb, int xid);
 extern int cifs_acl_to_fattr(struct cifs_sb_info *cifs_sb,
                               struct cifs_fattr *fattr, struct inode *inode,
                               const char *path, const __u16 *pfid);
-extern int id_mode_to_cifs_acl(struct inode *inode, const char *path, __u64,
-                                        uid_t, gid_t);
+extern int mode_to_cifs_acl(struct inode *inode, const char *path, __u64);
 extern struct cifs_ntsd *get_cifs_acl(struct cifs_sb_info *, struct inode *,
                                         const char *, u32 *);
 extern int set_cifs_acl(struct cifs_ntsd *, __u32, struct inode *,
-                                const char *, int);
+                                const char *);
 
-extern void dequeue_mid(struct mid_q_entry *mid, bool malformed);
-extern int cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
-                     unsigned int to_read);
-extern int cifs_readv_from_socket(struct TCP_Server_Info *server,
-                struct kvec *iov_orig, unsigned int nr_segs,
-                unsigned int to_read);
 extern void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
                                struct cifs_sb_info *cifs_sb);
 extern int cifs_match_super(struct super_block *, void *);
@@ -181,123 +159,102 @@ extern struct smb_vol *cifs_get_volume_info(char *mount_data,
                                             const char *devname);
 extern int cifs_mount(struct cifs_sb_info *, struct smb_vol *);
 extern void cifs_umount(struct cifs_sb_info *);
-extern void cifs_mark_open_files_invalid(struct cifs_tcon *tcon);
-extern bool cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset,
-                                    __u64 length, __u8 type,
-                                    struct cifsLockInfo **conf_lock,
-                                    int rw_check);
-extern void cifs_add_pending_open(struct cifs_fid *fid,
-                                  struct tcon_link *tlink,
-                                  struct cifs_pending_open *open);
-extern void cifs_add_pending_open_locked(struct cifs_fid *fid,
-                                         struct tcon_link *tlink,
-                                         struct cifs_pending_open *open);
-extern void cifs_del_pending_open(struct cifs_pending_open *open);
-
-#if IS_ENABLED(CONFIG_CIFS_DFS_UPCALL)
 extern void cifs_dfs_release_automount_timer(void);
-#else /* ! IS_ENABLED(CONFIG_CIFS_DFS_UPCALL) */
-#define cifs_dfs_release_automount_timer()      do { } while (0)
-#endif /* ! IS_ENABLED(CONFIG_CIFS_DFS_UPCALL) */
-
 void cifs_proc_init(void);
 void cifs_proc_clean(void);
 
-extern void cifs_move_llist(struct list_head *source, struct list_head *dest);
-extern void cifs_free_llist(struct list_head *llist);
-extern void cifs_del_lock_waiters(struct cifsLockInfo *lock);
+extern int cifs_negotiate_protocol(unsigned int xid,
+                                  struct cifs_ses *ses);
+extern int cifs_setup_session(unsigned int xid, struct cifs_ses *ses,
+                        struct nls_table *nls_info);
+extern int CIFSSMBNegotiate(unsigned int xid, struct cifs_ses *ses);
 
-extern int cifs_negotiate_protocol(const unsigned int xid,
-                                   struct cifs_ses *ses);
-extern int cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
-                              struct nls_table *nls_info);
-extern int CIFSSMBNegotiate(const unsigned int xid, struct cifs_ses *ses);
-
-extern int CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
-                    const char *tree, struct cifs_tcon *tcon,
-                    const struct nls_table *);
+extern int CIFSTCon(unsigned int xid, struct cifs_ses *ses,
+                        const char *tree, struct cifs_tcon *tcon,
+                        const struct nls_table *);
 
-extern int CIFSFindFirst(const unsigned int xid, struct cifs_tcon *tcon,
-                const char *searchName, struct cifs_sb_info *cifs_sb,
-                __u16 *searchHandle, __u16 search_flags,
-                struct cifs_search_info *psrch_inf,
-                bool msearch);
+extern int CIFSFindFirst(const int xid, struct cifs_tcon *tcon,
+                const char *searchName, const struct nls_table *nls_codepage,
+                __u16 *searchHandle, struct cifs_search_info *psrch_inf,
+                int map, const char dirsep);
 
-extern int CIFSFindNext(const unsigned int xid, struct cifs_tcon *tcon,
-                __u16 searchHandle, __u16 search_flags,
-                struct cifs_search_info *psrch_inf);
+extern int CIFSFindNext(const int xid, struct cifs_tcon *tcon,
+                __u16 searchHandle, struct cifs_search_info *psrch_inf);
 
-extern int CIFSFindClose(const unsigned int xid, struct cifs_tcon *tcon,
+extern int CIFSFindClose(const int, struct cifs_tcon *tcon,
                         const __u16 search_handle);
 
-extern int CIFSSMBQFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
+extern int CIFSSMBQFileInfo(const int xid, struct cifs_tcon *tcon,
                         u16 netfid, FILE_ALL_INFO *pFindData);
-extern int CIFSSMBQPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
-                            const char *search_Name, FILE_ALL_INFO *data,
-                            int legacy /* whether to use old info level */,
-                            const struct nls_table *nls_codepage, int remap);
-extern int SMBQueryInformation(const unsigned int xid, struct cifs_tcon *tcon,
-                               const char *search_name, FILE_ALL_INFO *data,
-                               const struct nls_table *nls_codepage, int remap);
+extern int CIFSSMBQPathInfo(const int xid, struct cifs_tcon *tcon,
+                        const unsigned char *searchName,
+                        FILE_ALL_INFO *findData,
+                        int legacy /* whether to use old info level */,
+                        const struct nls_table *nls_codepage, int remap);
+extern int SMBQueryInformation(const int xid, struct cifs_tcon *tcon,
+                        const unsigned char *searchName,
+                        FILE_ALL_INFO *findData,
+                        const struct nls_table *nls_codepage, int remap);
 
-extern int CIFSSMBUnixQFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
+extern int CIFSSMBUnixQFileInfo(const int xid, struct cifs_tcon *tcon,
                         u16 netfid, FILE_UNIX_BASIC_INFO *pFindData);
-extern int CIFSSMBUnixQPathInfo(const unsigned int xid,
+extern int CIFSSMBUnixQPathInfo(const int xid,
                         struct cifs_tcon *tcon,
                         const unsigned char *searchName,
                         FILE_UNIX_BASIC_INFO *pFindData,
                         const struct nls_table *nls_codepage, int remap);
 
-extern int CIFSGetDFSRefer(const unsigned int xid, struct cifs_ses *ses,
-                           const char *search_name,
-                           struct dfs_info3_param **target_nodes,
-                           unsigned int *num_of_nodes,
-                           const struct nls_table *nls_codepage, int remap);
+extern int CIFSGetDFSRefer(const int xid, struct cifs_ses *ses,
+                        const unsigned char *searchName,
+                        struct dfs_info3_param **target_nodes,
+                        unsigned int *number_of_nodes_in_array,
+                        const struct nls_table *nls_codepage, int remap);
 
-extern int get_dfs_path(const unsigned int xid, struct cifs_ses *ses,
+extern int get_dfs_path(int xid, struct cifs_ses *pSesInfo,
                         const char *old_path,
                         const struct nls_table *nls_codepage,
-                        unsigned int *num_referrals,
-                        struct dfs_info3_param **referrals, int remap);
-extern void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
+                        unsigned int *pnum_referrals,
+                        struct dfs_info3_param **preferrals,
+                        int remap);
+extern void reset_cifs_unix_caps(int xid, struct cifs_tcon *tcon,
                                  struct cifs_sb_info *cifs_sb,
                                  struct smb_vol *vol);
-extern int CIFSSMBQFSInfo(const unsigned int xid, struct cifs_tcon *tcon,
+extern int CIFSSMBQFSInfo(const int xid, struct cifs_tcon *tcon,
                         struct kstatfs *FSData);
-extern int SMBOldQFSInfo(const unsigned int xid, struct cifs_tcon *tcon,
+extern int SMBOldQFSInfo(const int xid, struct cifs_tcon *tcon,
                         struct kstatfs *FSData);
-extern int CIFSSMBSetFSUnixInfo(const unsigned int xid, struct cifs_tcon *tcon,
+extern int CIFSSMBSetFSUnixInfo(const int xid, struct cifs_tcon *tcon,
                         __u64 cap);
 
-extern int CIFSSMBQFSAttributeInfo(const unsigned int xid,
+extern int CIFSSMBQFSAttributeInfo(const int xid,
                         struct cifs_tcon *tcon);
-extern int CIFSSMBQFSDeviceInfo(const unsigned int xid, struct cifs_tcon *tcon);
-extern int CIFSSMBQFSUnixInfo(const unsigned int xid, struct cifs_tcon *tcon);
-extern int CIFSSMBQFSPosixInfo(const unsigned int xid, struct cifs_tcon *tcon,
+extern int CIFSSMBQFSDeviceInfo(const int xid, struct cifs_tcon *tcon);
+extern int CIFSSMBQFSUnixInfo(const int xid, struct cifs_tcon *tcon);
+extern int CIFSSMBQFSPosixInfo(const int xid, struct cifs_tcon *tcon,
                         struct kstatfs *FSData);
 
-extern int CIFSSMBSetPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
+extern int CIFSSMBSetPathInfo(const int xid, struct cifs_tcon *tcon,
                         const char *fileName, const FILE_BASIC_INFO *data,
                         const struct nls_table *nls_codepage,
                         int remap_special_chars);
-extern int CIFSSMBSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
+extern int CIFSSMBSetFileInfo(const int xid, struct cifs_tcon *tcon,
                         const FILE_BASIC_INFO *data, __u16 fid,
                         __u32 pid_of_opener);
-extern int CIFSSMBSetFileDisposition(const unsigned int xid,
-                                     struct cifs_tcon *tcon,
-                                     bool delete_file, __u16 fid,
-                                     __u32 pid_of_opener);
+extern int CIFSSMBSetFileDisposition(const int xid, struct cifs_tcon *tcon,
+                        bool delete_file, __u16 fid, __u32 pid_of_opener);
 #if 0
-extern int CIFSSMBSetAttrLegacy(unsigned int xid, struct cifs_tcon *tcon,
+extern int CIFSSMBSetAttrLegacy(int xid, struct cifs_tcon *tcon,
                         char *fileName, __u16 dos_attributes,
                         const struct nls_table *nls_codepage);
 #endif /* possibly unneeded function */
-extern int CIFSSMBSetEOF(const unsigned int xid, struct cifs_tcon *tcon,
-                         const char *file_name, __u64 size,
-                         struct cifs_sb_info *cifs_sb, bool set_allocation);
-extern int CIFSSMBSetFileSize(const unsigned int xid, struct cifs_tcon *tcon,
-                              struct cifsFileInfo *cfile, __u64 size,
-                              bool set_allocation);
+extern int CIFSSMBSetEOF(const int xid, struct cifs_tcon *tcon,
+                        const char *fileName, __u64 size,
+                        bool setAllocationSizeFlag,
+                        const struct nls_table *nls_codepage,
+                        int remap_special_chars);
+extern int CIFSSMBSetFileSize(const int xid, struct cifs_tcon *tcon,
+                         __u64 size, __u16 fileHandle, __u32 opener_pid,
+                        bool AllocSizeFlag);
 
 struct cifs_unix_set_info_args {
         __u64   ctime;
@@ -309,125 +266,125 @@ struct cifs_unix_set_info_args {
         dev_t   device;
 };
 
-extern int CIFSSMBUnixSetFileInfo(const unsigned int xid,
-                                  struct cifs_tcon *tcon,
+extern int CIFSSMBUnixSetFileInfo(const int xid, struct cifs_tcon *tcon,
                                   const struct cifs_unix_set_info_args *args,
                                   u16 fid, u32 pid_of_opener);
 
-extern int CIFSSMBUnixSetPathInfo(const unsigned int xid,
-                                  struct cifs_tcon *tcon, const char *file_name,
-                                  const struct cifs_unix_set_info_args *args,
-                                  const struct nls_table *nls_codepage,
-                                  int remap);
+extern int CIFSSMBUnixSetPathInfo(const int xid, struct cifs_tcon *pTcon,
+                        char *fileName,
+                        const struct cifs_unix_set_info_args *args,
+                        const struct nls_table *nls_codepage,
+                        int remap_special_chars);
 
-extern int CIFSSMBMkDir(const unsigned int xid, struct cifs_tcon *tcon,
-                        const char *name, struct cifs_sb_info *cifs_sb);
-extern int CIFSSMBRmDir(const unsigned int xid, struct cifs_tcon *tcon,
-                        const char *name, struct cifs_sb_info *cifs_sb);
-extern int CIFSPOSIXDelFile(const unsigned int xid, struct cifs_tcon *tcon,
+extern int CIFSSMBMkDir(const int xid, struct cifs_tcon *tcon,
+                        const char *newName,
+                        const struct nls_table *nls_codepage,
+                        int remap_special_chars);
+extern int CIFSSMBRmDir(const int xid, struct cifs_tcon *tcon,
+                        const char *name, const struct nls_table *nls_codepage,
+                        int remap_special_chars);
+extern int CIFSPOSIXDelFile(const int xid, struct cifs_tcon *tcon,
                         const char *name, __u16 type,
                         const struct nls_table *nls_codepage,
                         int remap_special_chars);
-extern int CIFSSMBDelFile(const unsigned int xid, struct cifs_tcon *tcon,
-                          const char *name, struct cifs_sb_info *cifs_sb);
-extern int CIFSSMBRename(const unsigned int xid, struct cifs_tcon *tcon,
-                         const char *from_name, const char *to_name,
-                         struct cifs_sb_info *cifs_sb);
-extern int CIFSSMBRenameOpenFile(const unsigned int xid, struct cifs_tcon *tcon,
-                                 int netfid, const char *target_name,
-                                 const struct nls_table *nls_codepage,
-                                 int remap_special_chars);
-extern int CIFSCreateHardLink(const unsigned int xid, struct cifs_tcon *tcon,
-                              const char *from_name, const char *to_name,
-                              struct cifs_sb_info *cifs_sb);
-extern int CIFSUnixCreateHardLink(const unsigned int xid,
+extern int CIFSSMBDelFile(const int xid, struct cifs_tcon *tcon,
+                        const char *name,
+                        const struct nls_table *nls_codepage,
+                        int remap_special_chars);
+extern int CIFSSMBRename(const int xid, struct cifs_tcon *tcon,
+                        const char *fromName, const char *toName,
+                        const struct nls_table *nls_codepage,
+                        int remap_special_chars);
+extern int CIFSSMBRenameOpenFile(const int xid, struct cifs_tcon *pTcon,
+                        int netfid, const char *target_name,
+                        const struct nls_table *nls_codepage,
+                        int remap_special_chars);
+extern int CIFSCreateHardLink(const int xid,
+                        struct cifs_tcon *tcon,
+                        const char *fromName, const char *toName,
+                        const struct nls_table *nls_codepage,
+                        int remap_special_chars);
+extern int CIFSUnixCreateHardLink(const int xid,
                         struct cifs_tcon *tcon,
                         const char *fromName, const char *toName,
                         const struct nls_table *nls_codepage,
                         int remap_special_chars);
-extern int CIFSUnixCreateSymLink(const unsigned int xid,
+extern int CIFSUnixCreateSymLink(const int xid,
                         struct cifs_tcon *tcon,
                         const char *fromName, const char *toName,
                         const struct nls_table *nls_codepage);
-extern int CIFSSMBUnixQuerySymLink(const unsigned int xid,
+extern int CIFSSMBUnixQuerySymLink(const int xid,
                         struct cifs_tcon *tcon,
                         const unsigned char *searchName, char **syminfo,
                         const struct nls_table *nls_codepage);
 #ifdef CONFIG_CIFS_SYMLINK_EXPERIMENTAL
-extern int CIFSSMBQueryReparseLinkInfo(const unsigned int xid,
+extern int CIFSSMBQueryReparseLinkInfo(const int xid,
                         struct cifs_tcon *tcon,
                         const unsigned char *searchName,
                         char *symlinkinfo, const int buflen, __u16 fid,
                         const struct nls_table *nls_codepage);
 #endif /* temporarily unused until cifs_symlink fixed */
-extern int CIFSSMBOpen(const unsigned int xid, struct cifs_tcon *tcon,
+extern int CIFSSMBOpen(const int xid, struct cifs_tcon *tcon,
                         const char *fileName, const int disposition,
                         const int access_flags, const int omode,
                         __u16 *netfid, int *pOplock, FILE_ALL_INFO *,
                         const struct nls_table *nls_codepage, int remap);
-extern int SMBLegacyOpen(const unsigned int xid, struct cifs_tcon *tcon,
+extern int SMBLegacyOpen(const int xid, struct cifs_tcon *tcon,
                         const char *fileName, const int disposition,
                         const int access_flags, const int omode,
                         __u16 *netfid, int *pOplock, FILE_ALL_INFO *,
                         const struct nls_table *nls_codepage, int remap);
-extern int CIFSPOSIXCreate(const unsigned int xid, struct cifs_tcon *tcon,
+extern int CIFSPOSIXCreate(const int xid, struct cifs_tcon *tcon,
                         u32 posix_flags, __u64 mode, __u16 *netfid,
                         FILE_UNIX_BASIC_INFO *pRetData,
                         __u32 *pOplock, const char *name,
                         const struct nls_table *nls_codepage, int remap);
-extern int CIFSSMBClose(const unsigned int xid, struct cifs_tcon *tcon,
+extern int CIFSSMBClose(const int xid, struct cifs_tcon *tcon,
                         const int smb_file_id);
 
-extern int CIFSSMBFlush(const unsigned int xid, struct cifs_tcon *tcon,
+extern int CIFSSMBFlush(const int xid, struct cifs_tcon *tcon,
                         const int smb_file_id);
 
-extern int CIFSSMBRead(const unsigned int xid, struct cifs_io_parms *io_parms,
+extern int CIFSSMBRead(const int xid, struct cifs_io_parms *io_parms,
                         unsigned int *nbytes, char **buf,
                         int *return_buf_type);
-extern int CIFSSMBWrite(const unsigned int xid, struct cifs_io_parms *io_parms,
+extern int CIFSSMBWrite(const int xid, struct cifs_io_parms *io_parms,
                         unsigned int *nbytes, const char *buf,
                         const char __user *ubuf, const int long_op);
-extern int CIFSSMBWrite2(const unsigned int xid, struct cifs_io_parms *io_parms,
-                        unsigned int *nbytes, struct kvec *iov, const int nvec);
-extern int CIFSGetSrvInodeNumber(const unsigned int xid, struct cifs_tcon *tcon,
-                                 const char *search_name, __u64 *inode_number,
-                                 const struct nls_table *nls_codepage,
-                                 int remap);
+extern int CIFSSMBWrite2(const int xid, struct cifs_io_parms *io_parms,
+                        unsigned int *nbytes, struct kvec *iov, const int nvec,
+                        const int long_op);
+extern int CIFSGetSrvInodeNumber(const int xid, struct cifs_tcon *tcon,
+                        const unsigned char *searchName, __u64 *inode_number,
+                        const struct nls_table *nls_codepage,
+                        int remap_special_chars);
 
-extern int cifs_lockv(const unsigned int xid, struct cifs_tcon *tcon,
-                      const __u16 netfid, const __u8 lock_type,
-                      const __u32 num_unlock, const __u32 num_lock,
-                      LOCKING_ANDX_RANGE *buf);
-extern int CIFSSMBLock(const unsigned int xid, struct cifs_tcon *tcon,
-                        const __u16 netfid, const __u32 netpid, const __u64 len,
+extern int CIFSSMBLock(const int xid, struct cifs_tcon *tcon,
+                        const __u16 netfid, const __u64 len,
                         const __u64 offset, const __u32 numUnlock,
                         const __u32 numLock, const __u8 lockType,
                         const bool waitFlag, const __u8 oplock_level);
-extern int CIFSSMBPosixLock(const unsigned int xid, struct cifs_tcon *tcon,
-                        const __u16 smb_file_id, const __u32 netpid,
-                        const loff_t start_offset, const __u64 len,
-                        struct file_lock *, const __u16 lock_type,
-                        const bool waitFlag);
-extern int CIFSSMBTDis(const unsigned int xid, struct cifs_tcon *tcon);
+extern int CIFSSMBPosixLock(const int xid, struct cifs_tcon *tcon,
+                        const __u16 smb_file_id, const int get_flag,
+                        const __u64 len, struct file_lock *,
+                        const __u16 lock_type, const bool waitFlag);
+extern int CIFSSMBTDis(const int xid, struct cifs_tcon *tcon);
 extern int CIFSSMBEcho(struct TCP_Server_Info *server);
-extern int CIFSSMBLogoff(const unsigned int xid, struct cifs_ses *ses);
+extern int CIFSSMBLogoff(const int xid, struct cifs_ses *ses);
 
 extern struct cifs_ses *sesInfoAlloc(void);
 extern void sesInfoFree(struct cifs_ses *);
 extern struct cifs_tcon *tconInfoAlloc(void);
 extern void tconInfoFree(struct cifs_tcon *);
 
-extern int cifs_sign_rqst(struct smb_rqst *rqst, struct TCP_Server_Info *server,
-                   __u32 *pexpected_response_sequence_number);
-extern int cifs_sign_smbv(struct kvec *iov, int n_vec, struct TCP_Server_Info *,
-                          __u32 *);
 extern int cifs_sign_smb(struct smb_hdr *, struct TCP_Server_Info *, __u32 *);
-extern int cifs_verify_signature(struct smb_rqst *rqst,
+extern int cifs_sign_smb2(struct kvec *iov, int n_vec, struct TCP_Server_Info *,
+                          __u32 *);
+extern int cifs_verify_signature(struct smb_hdr *,
                                  struct TCP_Server_Info *server,
                                 __u32 expected_sequence_number);
-extern int SMBNTencrypt(unsigned char *, unsigned char *, unsigned char *,
-                        const struct nls_table *);
-extern int setup_ntlm_response(struct cifs_ses *, const struct nls_table *);
+extern int SMBNTencrypt(unsigned char *, unsigned char *, unsigned char *);
+extern int setup_ntlm_response(struct cifs_ses *);
 extern int setup_ntlmv2_rsp(struct cifs_ses *, const struct nls_table *);
 extern int cifs_crypto_shash_allocate(struct TCP_Server_Info *);
 extern void cifs_crypto_shash_release(struct TCP_Server_Info *);
@@ -438,60 +395,66 @@ extern int calc_lanman_hash(const char *password, const char *cryptkey,
                                 bool encrypt, char *lnm_session_key);
 #endif /* CIFS_WEAK_PW_HASH */
 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
-extern int CIFSSMBNotify(const unsigned int xid, struct cifs_tcon *tcon,
+extern int CIFSSMBNotify(const int xid, struct cifs_tcon *tcon,
                         const int notify_subdirs, const __u16 netfid,
                         __u32 filter, struct file *file, int multishot,
                         const struct nls_table *nls_codepage);
 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
-extern int CIFSSMBCopy(unsigned int xid,
+extern int CIFSSMBCopy(int xid,
                         struct cifs_tcon *source_tcon,
                         const char *fromName,
                         const __u16 target_tid,
                         const char *toName, const int flags,
                         const struct nls_table *nls_codepage,
                         int remap_special_chars);
-extern ssize_t CIFSSMBQAllEAs(const unsigned int xid, struct cifs_tcon *tcon,
+extern ssize_t CIFSSMBQAllEAs(const int xid, struct cifs_tcon *tcon,
                         const unsigned char *searchName,
                         const unsigned char *ea_name, char *EAData,
                         size_t bufsize, const struct nls_table *nls_codepage,
                         int remap_special_chars);
-extern int CIFSSMBSetEA(const unsigned int xid, struct cifs_tcon *tcon,
+extern int CIFSSMBSetEA(const int xid, struct cifs_tcon *tcon,
                 const char *fileName, const char *ea_name,
                 const void *ea_value, const __u16 ea_value_len,
                 const struct nls_table *nls_codepage, int remap_special_chars);
-extern int CIFSSMBGetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon,
+extern int CIFSSMBGetCIFSACL(const int xid, struct cifs_tcon *tcon,
                         __u16 fid, struct cifs_ntsd **acl_inf, __u32 *buflen);
-extern int CIFSSMBSetCIFSACL(const unsigned int, struct cifs_tcon *, __u16,
-                        struct cifs_ntsd *, __u32, int);
-extern int CIFSSMBGetPosixACL(const unsigned int xid, struct cifs_tcon *tcon,
+extern int CIFSSMBSetCIFSACL(const int, struct cifs_tcon *, __u16,
+                        struct cifs_ntsd *, __u32);
+extern int CIFSSMBGetPosixACL(const int xid, struct cifs_tcon *tcon,
                 const unsigned char *searchName,
                 char *acl_inf, const int buflen, const int acl_type,
                 const struct nls_table *nls_codepage, int remap_special_chars);
-extern int CIFSSMBSetPosixACL(const unsigned int xid, struct cifs_tcon *tcon,
+extern int CIFSSMBSetPosixACL(const int xid, struct cifs_tcon *tcon,
                 const unsigned char *fileName,
                 const char *local_acl, const int buflen, const int acl_type,
                 const struct nls_table *nls_codepage, int remap_special_chars);
-extern int CIFSGetExtAttr(const unsigned int xid, struct cifs_tcon *tcon,
+extern int CIFSGetExtAttr(const int xid, struct cifs_tcon *tcon,
                         const int netfid, __u64 *pExtAttrBits, __u64 *pMask);
 extern void cifs_autodisable_serverino(struct cifs_sb_info *cifs_sb);
 extern bool CIFSCouldBeMFSymlink(const struct cifs_fattr *fattr);
 extern int CIFSCheckMFSymlink(struct cifs_fattr *fattr,
                 const unsigned char *path,
-                struct cifs_sb_info *cifs_sb, unsigned int xid);
+                struct cifs_sb_info *cifs_sb, int xid);
 extern int mdfour(unsigned char *, unsigned char *, int);
-extern int E_md4hash(const unsigned char *passwd, unsigned char *p16,
-                        const struct nls_table *codepage);
+extern int E_md4hash(const unsigned char *passwd, unsigned char *p16);
 extern int SMBencrypt(unsigned char *passwd, const unsigned char *c8,
                         unsigned char *p24);
 
-void cifs_readdata_release(struct kref *refcount);
-int cifs_async_readv(struct cifs_readdata *rdata);
-int cifs_readv_receive(struct TCP_Server_Info *server, struct mid_q_entry *mid);
+/* asynchronous write support */
+struct cifs_writedata {
+        struct kref                     refcount;
+        enum writeback_sync_modes       sync_mode;
+        struct work_struct              work;
+        struct cifsFileInfo             *cfile;
+        __u64                           offset;
+        unsigned int                    bytes;
+        int                             result;
+        unsigned int                    nr_pages;
+        struct page                     *pages[1];
+};
 
 int cifs_async_writev(struct cifs_writedata *wdata);
-void cifs_writev_complete(struct work_struct *work);
-struct cifs_writedata *cifs_writedata_alloc(unsigned int nr_pages,
-                                                work_func_t complete);
+struct cifs_writedata *cifs_writedata_alloc(unsigned int nr_pages);
 void cifs_writedata_release(struct kref *refcount);
 
 #endif                  /* _CIFSPROTO_H */
diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c
index 76d0d299885..a80f7bd97b9 100644
--- a/fs/cifs/cifssmb.c
+++ b/fs/cifs/cifssmb.c
@@ -33,8 +33,6 @@
 #include <linux/slab.h>
 #include <linux/posix_acl_xattr.h>
 #include <linux/pagemap.h>
-#include <linux/swap.h>
-#include <linux/task_io_accounting_ops.h>
 #include <asm/uaccess.h>
 #include "cifspdu.h"
 #include "cifsglob.h"
@@ -42,7 +40,6 @@
 #include "cifsproto.h"
 #include "cifs_unicode.h"
 #include "cifs_debug.h"
-#include "fscache.h"
 
 #ifdef CONFIG_CIFS_POSIX
 static struct {
@@ -86,29 +83,24 @@ static struct {
 #endif /* CONFIG_CIFS_WEAK_PW_HASH */
 #endif /* CIFS_POSIX */
 
-/*
- * Mark as invalid, all open files on tree connections since they
- * were closed when session to server was lost.
- */
-void
-cifs_mark_open_files_invalid(struct cifs_tcon *tcon)
+/* Mark as invalid, all open files on tree connections since they
+   were closed when session to server was lost */
+static void mark_open_files_invalid(struct cifs_tcon *pTcon)
 {
         struct cifsFileInfo *open_file = NULL;
         struct list_head *tmp;
         struct list_head *tmp1;
 
-        /* list all files open on tree connection and mark them invalid */
+/* list all files open on tree connection and mark them invalid */
         spin_lock(&cifs_file_list_lock);
-        list_for_each_safe(tmp, tmp1, &tcon->openFileList) {
+        list_for_each_safe(tmp, tmp1, &pTcon->openFileList) {
                 open_file = list_entry(tmp, struct cifsFileInfo, tlist);
                 open_file->invalidHandle = true;
                 open_file->oplock_break_cancelled = true;
         }
         spin_unlock(&cifs_file_list_lock);
-        /*
-         * BB Add call to invalidate_inodes(sb) for all superblocks mounted
-         * to this tcon.
-         */
+        /* BB Add call to invalidate_inodes(sb) for all superblocks mounted
+           to this tcon */
 }
 
 /* reconnect the socket, tcon, and smb session if needed */
@@ -188,7 +180,7 @@ cifs_reconnect_tcon(struct cifs_tcon *tcon, int smb_command)
                 goto out;
         }
 
-        cifs_mark_open_files_invalid(tcon);
+        mark_open_files_invalid(tcon);
         rc = CIFSTCon(0, ses, tcon->treeName, tcon, nls_codepage);
         mutex_unlock(&ses->session_mutex);
         cFYI(1, "reconnect tcon rc = %d", rc);
@@ -271,7 +263,7 @@ small_smb_init_no_tc(const int smb_command, const int wct,
                 return rc;
 
         buffer = (struct smb_hdr *)*request_buf;
-        buffer->Mid = get_next_mid(ses->server);
+        buffer->Mid = GetNextMid(ses->server);
         if (ses->capabilities & CAP_UNICODE)
                 buffer->Flags2 |= SMBFLG2_UNICODE;
         if (ses->capabilities & CAP_STATUS32)
@@ -367,8 +359,15 @@ vt2_err:
         return -EINVAL;
 }
 
+static inline void inc_rfc1001_len(void *pSMB, int count)
+{
+        struct smb_hdr *hdr = (struct smb_hdr *)pSMB;
+
+        be32_add_cpu(&hdr->smb_buf_length, count);
+}
+
 int
-CIFSSMBNegotiate(const unsigned int xid, struct cifs_ses *ses)
+CIFSSMBNegotiate(unsigned int xid, struct cifs_ses *ses)
 {
         NEGOTIATE_REQ *pSMB;
         NEGOTIATE_RSP *pSMBr;
@@ -398,7 +397,7 @@ CIFSSMBNegotiate(const unsigned int xid, struct cifs_ses *ses)
 
         cFYI(1, "secFlags 0x%x", secFlags);
 
-        pSMB->hdr.Mid = get_next_mid(server);
+        pSMB->hdr.Mid = GetNextMid(server);
         pSMB->hdr.Flags2 |= (SMBFLG2_UNICODE | SMBFLG2_ERR_STATUS);
 
         if ((secFlags & CIFSSEC_MUST_KRB5) == CIFSSEC_MUST_KRB5)
@@ -452,12 +451,10 @@ CIFSSMBNegotiate(const unsigned int xid, struct cifs_ses *ses)
                         rc = -EOPNOTSUPP;
                         goto neg_err_exit;
                 }
-                server->sec_mode = le16_to_cpu(rsp->SecurityMode);
-                server->maxReq = min_t(unsigned int,
-                                       le16_to_cpu(rsp->MaxMpxCount),
-                                       cifs_max_pending);
-                set_credits(server, server->maxReq);
-                server->maxBuf = le16_to_cpu(rsp->MaxBufSize);
+                server->sec_mode = (__u8)le16_to_cpu(rsp->SecurityMode);
+                server->maxReq = le16_to_cpu(rsp->MaxMpxCount);
+                server->maxBuf = min((__u32)le16_to_cpu(rsp->MaxBufSize),
+                                (__u32)CIFSMaxBufSize + MAX_CIFS_HDR_SIZE);
                 server->max_vcs = le16_to_cpu(rsp->MaxNumberVcs);
                 /* even though we do not use raw we might as well set this
                 accurately, in case we ever find a need for it */
@@ -562,11 +559,10 @@ CIFSSMBNegotiate(const unsigned int xid, struct cifs_ses *ses)
 
         /* one byte, so no need to convert this or EncryptionKeyLen from
            little endian */
-        server->maxReq = min_t(unsigned int, le16_to_cpu(pSMBr->MaxMpxCount),
-                               cifs_max_pending);
-        set_credits(server, server->maxReq);
+        server->maxReq = le16_to_cpu(pSMBr->MaxMpxCount);
         /* probably no need to store and check maxvcs */
-        server->maxBuf = le32_to_cpu(pSMBr->MaxBufferSize);
+        server->maxBuf = min(le32_to_cpu(pSMBr->MaxBufferSize),
+                        (__u32) CIFSMaxBufSize + MAX_CIFS_HDR_SIZE);
         server->max_rw = le32_to_cpu(pSMBr->MaxRawSize);
         cFYI(DBG2, "Max buf = %d", ses->server->maxBuf);
         server->capabilities = le32_to_cpu(pSMBr->Capabilities);
@@ -666,7 +662,7 @@ neg_err_exit:
 }
 
 int
-CIFSSMBTDis(const unsigned int xid, struct cifs_tcon *tcon)
+CIFSSMBTDis(const int xid, struct cifs_tcon *tcon)
 {
         struct smb_hdr *smb_buffer;
         int rc = 0;
@@ -691,7 +687,7 @@ CIFSSMBTDis(const unsigned int xid, struct cifs_tcon *tcon)
         if (rc)
                 return rc;
 
-        rc = SendReceiveNoRsp(xid, tcon->ses, (char *)smb_buffer, 0);
+        rc = SendReceiveNoRsp(xid, tcon->ses, smb_buffer, 0);
         if (rc)
                 cFYI(1, "Tree disconnect failed %d", rc);
 
@@ -716,7 +712,8 @@ cifs_echo_callback(struct mid_q_entry *mid)
         struct TCP_Server_Info *server = mid->callback_data;
 
         DeleteMidQEntry(mid);
-        add_credits(server, 1, CIFS_ECHO_OP);
+        atomic_dec(&server->inFlight);
+        wake_up(&server->request_q);
 }
 
 int
@@ -725,8 +722,6 @@ CIFSSMBEcho(struct TCP_Server_Info *server)
         ECHO_REQ *smb;
         int rc = 0;
         struct kvec iov;
-        struct smb_rqst rqst = { .rq_iov = &iov,
-                                 .rq_nvec = 1 };
 
         cFYI(1, "In echo request");
 
@@ -744,8 +739,7 @@ CIFSSMBEcho(struct TCP_Server_Info *server)
         iov.iov_base = smb;
         iov.iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4;
 
-        rc = cifs_call_async(server, &rqst, NULL, cifs_echo_callback,
-                             server, CIFS_ASYNC_OP | CIFS_ECHO_OP);
+        rc = cifs_call_async(server, &iov, 1, cifs_echo_callback, server, true);
         if (rc)
                 cFYI(1, "Echo request failed: %d", rc);
 
@@ -755,7 +749,7 @@ CIFSSMBEcho(struct TCP_Server_Info *server)
 }
 
 int
-CIFSSMBLogoff(const unsigned int xid, struct cifs_ses *ses)
+CIFSSMBLogoff(const int xid, struct cifs_ses *ses)
 {
         LOGOFF_ANDX_REQ *pSMB;
         int rc = 0;
@@ -780,7 +774,7 @@ CIFSSMBLogoff(const unsigned int xid, struct cifs_ses *ses)
                 return rc;
         }
 
-        pSMB->hdr.Mid = get_next_mid(ses->server);
+        pSMB->hdr.Mid = GetNextMid(ses->server);
 
         if (ses->server->sec_mode &
                    (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
@@ -789,7 +783,7 @@ CIFSSMBLogoff(const unsigned int xid, struct cifs_ses *ses)
         pSMB->hdr.Uid = ses->Suid;
 
         pSMB->AndXCommand = 0xFF;
-        rc = SendReceiveNoRsp(xid, ses, (char *) pSMB, 0);
+        rc = SendReceiveNoRsp(xid, ses, (struct smb_hdr *) pSMB, 0);
 session_already_dead:
         mutex_unlock(&ses->session_mutex);
 
@@ -802,9 +796,8 @@ session_already_dead:
 }
 
 int
-CIFSPOSIXDelFile(const unsigned int xid, struct cifs_tcon *tcon,
-                 const char *fileName, __u16 type,
-                 const struct nls_table *nls_codepage, int remap)
+CIFSPOSIXDelFile(const int xid, struct cifs_tcon *tcon, const char *fileName,
+                 __u16 type, const struct nls_table *nls_codepage, int remap)
 {
         TRANSACTION2_SPI_REQ *pSMB = NULL;
         TRANSACTION2_SPI_RSP *pSMBr = NULL;
@@ -823,8 +816,8 @@ PsxDelete:
 
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
                 name_len =
-                    cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
-                                       PATH_MAX, nls_codepage, remap);
+                    cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
+                                     PATH_MAX, nls_codepage, remap);
                 name_len++;     /* trailing null */
                 name_len *= 2;
         } else { /* BB add path length overrun check */
@@ -869,7 +862,7 @@ PsxDelete:
                 cFYI(1, "Posix delete returned %d", rc);
         cifs_buf_release(pSMB);
 
-        cifs_stats_inc(&tcon->stats.cifs_stats.num_deletes);
+        cifs_stats_inc(&tcon->num_deletes);
 
         if (rc == -EAGAIN)
                 goto PsxDelete;
@@ -878,15 +871,14 @@ PsxDelete:
 }
 
 int
-CIFSSMBDelFile(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
-               struct cifs_sb_info *cifs_sb)
+CIFSSMBDelFile(const int xid, struct cifs_tcon *tcon, const char *fileName,
+               const struct nls_table *nls_codepage, int remap)
 {
         DELETE_FILE_REQ *pSMB = NULL;
         DELETE_FILE_RSP *pSMBr = NULL;
         int rc = 0;
         int bytes_returned;
         int name_len;
-        int remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
 
 DelFileRetry:
         rc = smb_init(SMB_COM_DELETE, 1, tcon, (void **) &pSMB,
@@ -895,15 +887,15 @@ DelFileRetry:
                 return rc;
 
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
-                name_len = cifsConvertToUTF16((__le16 *) pSMB->fileName, name,
-                                              PATH_MAX, cifs_sb->local_nls,
-                                              remap);
+                name_len =
+                    cifsConvertToUCS((__le16 *) pSMB->fileName, fileName,
+                                     PATH_MAX, nls_codepage, remap);
                 name_len++;     /* trailing null */
                 name_len *= 2;
         } else {                /* BB improve check for buffer overruns BB */
-                name_len = strnlen(name, PATH_MAX);
+                name_len = strnlen(fileName, PATH_MAX);
                 name_len++;     /* trailing null */
-                strncpy(pSMB->fileName, name, name_len);
+                strncpy(pSMB->fileName, fileName, name_len);
         }
         pSMB->SearchAttributes =
             cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM);
@@ -912,7 +904,7 @@ DelFileRetry:
         pSMB->ByteCount = cpu_to_le16(name_len + 1);
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        cifs_stats_inc(&tcon->stats.cifs_stats.num_deletes);
+        cifs_stats_inc(&tcon->num_deletes);
         if (rc)
                 cFYI(1, "Error in RMFile = %d", rc);
 
@@ -924,15 +916,14 @@ DelFileRetry:
 }
 
 int
-CIFSSMBRmDir(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
-             struct cifs_sb_info *cifs_sb)
+CIFSSMBRmDir(const int xid, struct cifs_tcon *tcon, const char *dirName,
+             const struct nls_table *nls_codepage, int remap)
 {
         DELETE_DIRECTORY_REQ *pSMB = NULL;
         DELETE_DIRECTORY_RSP *pSMBr = NULL;
         int rc = 0;
         int bytes_returned;
         int name_len;
-        int remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
 
         cFYI(1, "In CIFSSMBRmDir");
 RmDirRetry:
@@ -942,15 +933,14 @@ RmDirRetry:
                 return rc;
 
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
-                name_len = cifsConvertToUTF16((__le16 *) pSMB->DirName, name,
-                                              PATH_MAX, cifs_sb->local_nls,
-                                              remap);
+                name_len = cifsConvertToUCS((__le16 *) pSMB->DirName, dirName,
+                                         PATH_MAX, nls_codepage, remap);
                 name_len++;     /* trailing null */
                 name_len *= 2;
         } else {                /* BB improve check for buffer overruns BB */
-                name_len = strnlen(name, PATH_MAX);
+                name_len = strnlen(dirName, PATH_MAX);
                 name_len++;     /* trailing null */
-                strncpy(pSMB->DirName, name, name_len);
+                strncpy(pSMB->DirName, dirName, name_len);
         }
 
         pSMB->BufferFormat = 0x04;
@@ -958,7 +948,7 @@ RmDirRetry:
         pSMB->ByteCount = cpu_to_le16(name_len + 1);
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        cifs_stats_inc(&tcon->stats.cifs_stats.num_rmdirs);
+        cifs_stats_inc(&tcon->num_rmdirs);
         if (rc)
                 cFYI(1, "Error in RMDir = %d", rc);
 
@@ -969,15 +959,14 @@ RmDirRetry:
 }
 
 int
-CIFSSMBMkDir(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
-             struct cifs_sb_info *cifs_sb)
+CIFSSMBMkDir(const int xid, struct cifs_tcon *tcon,
+             const char *name, const struct nls_table *nls_codepage, int remap)
 {
         int rc = 0;
         CREATE_DIRECTORY_REQ *pSMB = NULL;
         CREATE_DIRECTORY_RSP *pSMBr = NULL;
         int bytes_returned;
         int name_len;
-        int remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
 
         cFYI(1, "In CIFSSMBMkDir");
 MkDirRetry:
@@ -987,9 +976,8 @@ MkDirRetry:
                 return rc;
 
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
-                name_len = cifsConvertToUTF16((__le16 *) pSMB->DirName, name,
-                                              PATH_MAX, cifs_sb->local_nls,
-                                              remap);
+                name_len = cifsConvertToUCS((__le16 *) pSMB->DirName, name,
+                                            PATH_MAX, nls_codepage, remap);
                 name_len++;     /* trailing null */
                 name_len *= 2;
         } else {                /* BB improve check for buffer overruns BB */
@@ -1003,7 +991,7 @@ MkDirRetry:
         pSMB->ByteCount = cpu_to_le16(name_len + 1);
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        cifs_stats_inc(&tcon->stats.cifs_stats.num_mkdirs);
+        cifs_stats_inc(&tcon->num_mkdirs);
         if (rc)
                 cFYI(1, "Error in Mkdir = %d", rc);
 
@@ -1014,11 +1002,10 @@ MkDirRetry:
 }
 
 int
-CIFSPOSIXCreate(const unsigned int xid, struct cifs_tcon *tcon,
-                __u32 posix_flags, __u64 mode, __u16 *netfid,
-                FILE_UNIX_BASIC_INFO *pRetData, __u32 *pOplock,
-                const char *name, const struct nls_table *nls_codepage,
-                int remap)
+CIFSPOSIXCreate(const int xid, struct cifs_tcon *tcon, __u32 posix_flags,
+                __u64 mode, __u16 *netfid, FILE_UNIX_BASIC_INFO *pRetData,
+                __u32 *pOplock, const char *name,
+                const struct nls_table *nls_codepage, int remap)
 {
         TRANSACTION2_SPI_REQ *pSMB = NULL;
         TRANSACTION2_SPI_RSP *pSMBr = NULL;
@@ -1038,8 +1025,8 @@ PsxCreat:
 
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
                 name_len =
-                    cifsConvertToUTF16((__le16 *) pSMB->FileName, name,
-                                       PATH_MAX, nls_codepage, remap);
+                    cifsConvertToUCS((__le16 *) pSMB->FileName, name,
+                                     PATH_MAX, nls_codepage, remap);
                 name_len++;     /* trailing null */
                 name_len *= 2;
         } else {        /* BB improve the check for buffer overruns BB */
@@ -1126,9 +1113,9 @@ psx_create_err:
         cifs_buf_release(pSMB);
 
         if (posix_flags & SMB_O_DIRECTORY)
-                cifs_stats_inc(&tcon->stats.cifs_stats.num_posixmkdirs);
+                cifs_stats_inc(&tcon->num_posixmkdirs);
         else
-                cifs_stats_inc(&tcon->stats.cifs_stats.num_posixopens);
+                cifs_stats_inc(&tcon->num_posixopens);
 
         if (rc == -EAGAIN)
                 goto PsxCreat;
@@ -1181,7 +1168,7 @@ access_flags_to_smbopen_mode(const int access_flags)
 }
 
 int
-SMBLegacyOpen(const unsigned int xid, struct cifs_tcon *tcon,
+SMBLegacyOpen(const int xid, struct cifs_tcon *tcon,
             const char *fileName, const int openDisposition,
             const int access_flags, const int create_options, __u16 *netfid,
             int *pOplock, FILE_ALL_INFO *pfile_info,
@@ -1205,8 +1192,8 @@ OldOpenRetry:
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
                 count = 1;      /* account for one byte pad to word boundary */
                 name_len =
-                   cifsConvertToUTF16((__le16 *) (pSMB->fileName + 1),
-                                      fileName, PATH_MAX, nls_codepage, remap);
+                   cifsConvertToUCS((__le16 *) (pSMB->fileName + 1),
+                                    fileName, PATH_MAX, nls_codepage, remap);
                 name_len++;     /* trailing null */
                 name_len *= 2;
         } else {                /* BB improve check for buffer overruns BB */
@@ -1249,7 +1236,7 @@ OldOpenRetry:
         /* long_op set to 1 to allow for oplock break timeouts */
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                         (struct smb_hdr *)pSMBr, &bytes_returned, 0);
-        cifs_stats_inc(&tcon->stats.cifs_stats.num_opens);
+        cifs_stats_inc(&tcon->num_opens);
         if (rc) {
                 cFYI(1, "Error in Open = %d", rc);
         } else {
@@ -1288,7 +1275,7 @@ OldOpenRetry:
 }
 
 int
-CIFSSMBOpen(const unsigned int xid, struct cifs_tcon *tcon,
+CIFSSMBOpen(const int xid, struct cifs_tcon *tcon,
             const char *fileName, const int openDisposition,
             const int access_flags, const int create_options, __u16 *netfid,
             int *pOplock, FILE_ALL_INFO *pfile_info,
@@ -1312,8 +1299,8 @@ openRetry:
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
                 count = 1;      /* account for one byte pad to word boundary */
                 name_len =
-                    cifsConvertToUTF16((__le16 *) (pSMB->fileName + 1),
-                                       fileName, PATH_MAX, nls_codepage, remap);
+                    cifsConvertToUCS((__le16 *) (pSMB->fileName + 1),
+                                     fileName, PATH_MAX, nls_codepage, remap);
                 name_len++;     /* trailing null */
                 name_len *= 2;
                 pSMB->NameLength = cpu_to_le16(name_len);
@@ -1362,7 +1349,7 @@ openRetry:
         /* long_op set to 1 to allow for oplock break timeouts */
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                         (struct smb_hdr *)pSMBr, &bytes_returned, 0);
-        cifs_stats_inc(&tcon->stats.cifs_stats.num_opens);
+        cifs_stats_inc(&tcon->num_opens);
         if (rc) {
                 cFYI(1, "Error in Open = %d", rc);
         } else {
@@ -1389,256 +1376,9 @@ openRetry:
         return rc;
 }
 
-/*
- * Discard any remaining data in the current SMB. To do this, we borrow the
- * current bigbuf.
- */
-static int
-cifs_readv_discard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
-{
-        unsigned int rfclen = get_rfc1002_length(server->smallbuf);
-        int remaining = rfclen + 4 - server->total_read;
-        struct cifs_readdata *rdata = mid->callback_data;
-
-        while (remaining > 0) {
-                int length;
-
-                length = cifs_read_from_socket(server, server->bigbuf,
-                                min_t(unsigned int, remaining,
-                                    CIFSMaxBufSize + MAX_HEADER_SIZE(server)));
-                if (length < 0)
-                        return length;
-                server->total_read += length;
-                remaining -= length;
-        }
-
-        dequeue_mid(mid, rdata->result);
-        return 0;
-}
-
-int
-cifs_readv_receive(struct TCP_Server_Info *server, struct mid_q_entry *mid)
-{
-        int length, len;
-        unsigned int data_offset, data_len;
-        struct cifs_readdata *rdata = mid->callback_data;
-        char *buf = server->smallbuf;
-        unsigned int buflen = get_rfc1002_length(buf) + 4;
-
-        cFYI(1, "%s: mid=%llu offset=%llu bytes=%u", __func__,
-                mid->mid, rdata->offset, rdata->bytes);
-
-        /*
-         * read the rest of READ_RSP header (sans Data array), or whatever we
-         * can if there's not enough data. At this point, we've read down to
-         * the Mid.
-         */
-        len = min_t(unsigned int, buflen, server->vals->read_rsp_size) -
-                                                        HEADER_SIZE(server) + 1;
-
-        rdata->iov.iov_base = buf + HEADER_SIZE(server) - 1;
-        rdata->iov.iov_len = len;
-
-        length = cifs_readv_from_socket(server, &rdata->iov, 1, len);
-        if (length < 0)
-                return length;
-        server->total_read += length;
-
-        /* Was the SMB read successful? */
-        rdata->result = server->ops->map_error(buf, false);
-        if (rdata->result != 0) {
-                cFYI(1, "%s: server returned error %d", __func__,
-                        rdata->result);
-                return cifs_readv_discard(server, mid);
-        }
-
-        /* Is there enough to get to the rest of the READ_RSP header? */
-        if (server->total_read < server->vals->read_rsp_size) {
-                cFYI(1, "%s: server returned short header. got=%u expected=%zu",
-                        __func__, server->total_read,
-                        server->vals->read_rsp_size);
-                rdata->result = -EIO;
-                return cifs_readv_discard(server, mid);
-        }
-
-        data_offset = server->ops->read_data_offset(buf) + 4;
-        if (data_offset < server->total_read) {
-                /*
-                 * win2k8 sometimes sends an offset of 0 when the read
-                 * is beyond the EOF. Treat it as if the data starts just after
-                 * the header.
-                 */
-                cFYI(1, "%s: data offset (%u) inside read response header",
-                        __func__, data_offset);
-                data_offset = server->total_read;
-        } else if (data_offset > MAX_CIFS_SMALL_BUFFER_SIZE) {
-                /* data_offset is beyond the end of smallbuf */
-                cFYI(1, "%s: data offset (%u) beyond end of smallbuf",
-                        __func__, data_offset);
-                rdata->result = -EIO;
-                return cifs_readv_discard(server, mid);
-        }
-
-        cFYI(1, "%s: total_read=%u data_offset=%u", __func__,
-                server->total_read, data_offset);
-
-        len = data_offset - server->total_read;
-        if (len > 0) {
-                /* read any junk before data into the rest of smallbuf */
-                rdata->iov.iov_base = buf + server->total_read;
-                rdata->iov.iov_len = len;
-                length = cifs_readv_from_socket(server, &rdata->iov, 1, len);
-                if (length < 0)
-                        return length;
-                server->total_read += length;
-        }
-
-        /* set up first iov for signature check */
-        rdata->iov.iov_base = buf;
-        rdata->iov.iov_len = server->total_read;
-        cFYI(1, "0: iov_base=%p iov_len=%zu",
-                rdata->iov.iov_base, rdata->iov.iov_len);
-
-        /* how much data is in the response? */
-        data_len = server->ops->read_data_length(buf);
-        if (data_offset + data_len > buflen) {
-                /* data_len is corrupt -- discard frame */
-                rdata->result = -EIO;
-                return cifs_readv_discard(server, mid);
-        }
-
-        length = rdata->read_into_pages(server, rdata, data_len);
-        if (length < 0)
-                return length;
-
-        server->total_read += length;
-        rdata->bytes = length;
-
-        cFYI(1, "total_read=%u buflen=%u remaining=%u", server->total_read,
-                buflen, data_len);
-
-        /* discard anything left over */
-        if (server->total_read < buflen)
-                return cifs_readv_discard(server, mid);
-
-        dequeue_mid(mid, false);
-        return length;
-}
-
-static void
-cifs_readv_callback(struct mid_q_entry *mid)
-{
-        struct cifs_readdata *rdata = mid->callback_data;
-        struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
-        struct TCP_Server_Info *server = tcon->ses->server;
-        struct smb_rqst rqst = { .rq_iov = &rdata->iov,
-                                 .rq_nvec = 1,
-                                 .rq_pages = rdata->pages,
-                                 .rq_npages = rdata->nr_pages,
-                                 .rq_pagesz = rdata->pagesz,
-                                 .rq_tailsz = rdata->tailsz };
-
-        cFYI(1, "%s: mid=%llu state=%d result=%d bytes=%u", __func__,
-                mid->mid, mid->mid_state, rdata->result, rdata->bytes);
-
-        switch (mid->mid_state) {
-        case MID_RESPONSE_RECEIVED:
-                /* result already set, check signature */
-                if (server->sec_mode &
-                    (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
-                        int rc = 0;
-
-                        rc = cifs_verify_signature(&rqst, server,
-                                                  mid->sequence_number + 1);
-                        if (rc)
-                                cERROR(1, "SMB signature verification returned "
-                                       "error = %d", rc);
-                }
-                /* FIXME: should this be counted toward the initiating task? */
-                task_io_account_read(rdata->bytes);
-                cifs_stats_bytes_read(tcon, rdata->bytes);
-                break;
-        case MID_REQUEST_SUBMITTED:
-        case MID_RETRY_NEEDED:
-                rdata->result = -EAGAIN;
-                break;
-        default:
-                rdata->result = -EIO;
-        }
-
-        queue_work(cifsiod_wq, &rdata->work);
-        DeleteMidQEntry(mid);
-        add_credits(server, 1, 0);
-}
-
-/* cifs_async_readv - send an async write, and set up mid to handle result */
 int
-cifs_async_readv(struct cifs_readdata *rdata)
-{
-        int rc;
-        READ_REQ *smb = NULL;
-        int wct;
-        struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
-        struct smb_rqst rqst = { .rq_iov = &rdata->iov,
-                                 .rq_nvec = 1 };
-
-        cFYI(1, "%s: offset=%llu bytes=%u", __func__,
-                rdata->offset, rdata->bytes);
-
-        if (tcon->ses->capabilities & CAP_LARGE_FILES)
-                wct = 12;
-        else {
-                wct = 10; /* old style read */
-                if ((rdata->offset >> 32) > 0)  {
-                        /* can not handle this big offset for old */
-                        return -EIO;
-                }
-        }
-
-        rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **)&smb);
-        if (rc)
-                return rc;
-
-        smb->hdr.Pid = cpu_to_le16((__u16)rdata->pid);
-        smb->hdr.PidHigh = cpu_to_le16((__u16)(rdata->pid >> 16));
-
-        smb->AndXCommand = 0xFF;        /* none */
-        smb->Fid = rdata->cfile->fid.netfid;
-        smb->OffsetLow = cpu_to_le32(rdata->offset & 0xFFFFFFFF);
-        if (wct == 12)
-                smb->OffsetHigh = cpu_to_le32(rdata->offset >> 32);
-        smb->Remaining = 0;
-        smb->MaxCount = cpu_to_le16(rdata->bytes & 0xFFFF);
-        smb->MaxCountHigh = cpu_to_le32(rdata->bytes >> 16);
-        if (wct == 12)
-                smb->ByteCount = 0;
-        else {
-                /* old style read */
-                struct smb_com_readx_req *smbr =
-                        (struct smb_com_readx_req *)smb;
-                smbr->ByteCount = 0;
-        }
-
-        /* 4 for RFC1001 length + 1 for BCC */
-        rdata->iov.iov_base = smb;
-        rdata->iov.iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4;
-
-        kref_get(&rdata->refcount);
-        rc = cifs_call_async(tcon->ses->server, &rqst, cifs_readv_receive,
-                             cifs_readv_callback, rdata, 0);
-
-        if (rc == 0)
-                cifs_stats_inc(&tcon->stats.cifs_stats.num_reads);
-        else
-                kref_put(&rdata->refcount, cifs_readdata_release);
-
-        cifs_small_buf_release(smb);
-        return rc;
-}
-
-int
-CIFSSMBRead(const unsigned int xid, struct cifs_io_parms *io_parms,
-            unsigned int *nbytes, char **buf, int *pbuf_type)
+CIFSSMBRead(const int xid, struct cifs_io_parms *io_parms, unsigned int *nbytes,
+            char **buf, int *pbuf_type)
 {
         int rc = -EACCES;
         READ_REQ *pSMB = NULL;
@@ -1698,7 +1438,7 @@ CIFSSMBRead(const unsigned int xid, struct cifs_io_parms *io_parms,
         iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
         rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
                          &resp_buf_type, CIFS_LOG_ERROR);
-        cifs_stats_inc(&tcon->stats.cifs_stats.num_reads);
+        cifs_stats_inc(&tcon->num_reads);
         pSMBr = (READ_RSP *)iov[0].iov_base;
         if (rc) {
                 cERROR(1, "Send error in read = %d", rc);
@@ -1749,7 +1489,7 @@ CIFSSMBRead(const unsigned int xid, struct cifs_io_parms *io_parms,
 
 
 int
-CIFSSMBWrite(const unsigned int xid, struct cifs_io_parms *io_parms,
+CIFSSMBWrite(const int xid, struct cifs_io_parms *io_parms,
              unsigned int *nbytes, const char *buf,
              const char __user *ubuf, const int long_op)
 {
@@ -1850,7 +1590,7 @@ CIFSSMBWrite(const unsigned int xid, struct cifs_io_parms *io_parms,
 
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, long_op);
-        cifs_stats_inc(&tcon->stats.cifs_stats.num_writes);
+        cifs_stats_inc(&tcon->num_writes);
         if (rc) {
                 cFYI(1, "Send error in write = %d", rc);
         } else {
@@ -1896,7 +1636,6 @@ cifs_writev_requeue(struct cifs_writedata *wdata)
 {
         int i, rc;
         struct inode *inode = wdata->cfile->dentry->d_inode;
-        struct TCP_Server_Info *server;
 
         for (i = 0; i < wdata->nr_pages; i++) {
                 lock_page(wdata->pages[i]);
@@ -1904,8 +1643,7 @@ cifs_writev_requeue(struct cifs_writedata *wdata)
         }
 
         do {
-                server = tlink_tcon(wdata->cfile->tlink)->ses->server;
-                rc = server->ops->async_writev(wdata);
+                rc = cifs_async_writev(wdata);
         } while (rc == -EAGAIN);
 
         for (i = 0; i < wdata->nr_pages; i++) {
@@ -1918,7 +1656,7 @@ cifs_writev_requeue(struct cifs_writedata *wdata)
         kref_put(&wdata->refcount, cifs_writedata_release);
 }
 
-void
+static void
 cifs_writev_complete(struct work_struct *work)
 {
         struct cifs_writedata *wdata = container_of(work,
@@ -1927,9 +1665,7 @@ cifs_writev_complete(struct work_struct *work)
         int i = 0;
 
         if (wdata->result == 0) {
-                spin_lock(&inode->i_lock);
                 cifs_update_eof(CIFS_I(inode), wdata->offset, wdata->bytes);
-                spin_unlock(&inode->i_lock);
                 cifs_stats_bytes_written(tlink_tcon(wdata->cfile->tlink),
                                          wdata->bytes);
         } else if (wdata->sync_mode == WB_SYNC_ALL && wdata->result == -EAGAIN)
@@ -1950,7 +1686,7 @@ cifs_writev_complete(struct work_struct *work)
 }
 
 struct cifs_writedata *
-cifs_writedata_alloc(unsigned int nr_pages, work_func_t complete)
+cifs_writedata_alloc(unsigned int nr_pages)
 {
         struct cifs_writedata *wdata;
 
@@ -1964,16 +1700,14 @@ cifs_writedata_alloc(unsigned int nr_pages, work_func_t complete)
         wdata = kzalloc(sizeof(*wdata) +
                         sizeof(struct page *) * (nr_pages - 1), GFP_NOFS);
         if (wdata != NULL) {
+                INIT_WORK(&wdata->work, cifs_writev_complete);
                 kref_init(&wdata->refcount);
-                INIT_LIST_HEAD(&wdata->list);
-                init_completion(&wdata->done);
-                INIT_WORK(&wdata->work, complete);
         }
         return wdata;
 }
 
 /*
- * Check the mid_state and signature on received buffer (if any), and queue the
+ * Check the midState and signature on received buffer (if any), and queue the
  * workqueue completion task.
  */
 static void
@@ -1984,7 +1718,7 @@ cifs_writev_callback(struct mid_q_entry *mid)
         unsigned int written;
         WRITE_RSP *smb = (WRITE_RSP *)mid->resp_buf;
 
-        switch (mid->mid_state) {
+        switch (mid->midState) {
         case MID_RESPONSE_RECEIVED:
                 wdata->result = cifs_check_receive(mid, tcon->ses->server, 0);
                 if (wdata->result != 0)
@@ -2016,21 +1750,22 @@ cifs_writev_callback(struct mid_q_entry *mid)
                 break;
         }
 
-        queue_work(cifsiod_wq, &wdata->work);
+        queue_work(system_nrt_wq, &wdata->work);
         DeleteMidQEntry(mid);
-        add_credits(tcon->ses->server, 1, 0);
+        atomic_dec(&tcon->ses->server->inFlight);
+        wake_up(&tcon->ses->server->request_q);
 }
 
 /* cifs_async_writev - send an async write, and set up mid to handle result */
 int
 cifs_async_writev(struct cifs_writedata *wdata)
 {
-        int rc = -EACCES;
+        int i, rc = -EACCES;
         WRITE_REQ *smb = NULL;
         int wct;
         struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
-        struct kvec iov;
-        struct smb_rqst rqst = { };
+        struct inode *inode = wdata->cfile->dentry->d_inode;
+        struct kvec *iov = NULL;
 
         if (tcon->ses->capabilities & CAP_LARGE_FILES) {
                 wct = 14;
@@ -2046,11 +1781,18 @@ cifs_async_writev(struct cifs_writedata *wdata)
         if (rc)
                 goto async_writev_out;
 
-        smb->hdr.Pid = cpu_to_le16((__u16)wdata->pid);
-        smb->hdr.PidHigh = cpu_to_le16((__u16)(wdata->pid >> 16));
+        /* 1 iov per page + 1 for header */
+        iov = kzalloc((wdata->nr_pages + 1) * sizeof(*iov), GFP_NOFS);
+        if (iov == NULL) {
+                rc = -ENOMEM;
+                goto async_writev_out;
+        }
+
+        smb->hdr.Pid = cpu_to_le16((__u16)wdata->cfile->pid);
+        smb->hdr.PidHigh = cpu_to_le16((__u16)(wdata->cfile->pid >> 16));
 
         smb->AndXCommand = 0xFF;        /* none */
-        smb->Fid = wdata->cfile->fid.netfid;
+        smb->Fid = wdata->cfile->netfid;
         smb->OffsetLow = cpu_to_le32(wdata->offset & 0xFFFFFFFF);
         if (wct == 14)
                 smb->OffsetHigh = cpu_to_le32(wdata->offset >> 32);
@@ -2062,15 +1804,18 @@ cifs_async_writev(struct cifs_writedata *wdata)
             cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
 
         /* 4 for RFC1001 length + 1 for BCC */
-        iov.iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4 + 1;
-        iov.iov_base = smb;
+        iov[0].iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4 + 1;
+        iov[0].iov_base = smb;
 
-        rqst.rq_iov = &iov;
-        rqst.rq_nvec = 1;
-        rqst.rq_pages = wdata->pages;
-        rqst.rq_npages = wdata->nr_pages;
-        rqst.rq_pagesz = wdata->pagesz;
-        rqst.rq_tailsz = wdata->tailsz;
+        /* marshal up the pages into iov array */
+        wdata->bytes = 0;
+        for (i = 0; i < wdata->nr_pages; i++) {
+                iov[i + 1].iov_len = min(inode->i_size -
+                                      page_offset(wdata->pages[i]),
+                                        (loff_t)PAGE_CACHE_SIZE);
+                iov[i + 1].iov_base = kmap(wdata->pages[i]);
+                wdata->bytes += iov[i + 1].iov_len;
+        }
 
         cFYI(1, "async write at %llu %u bytes", wdata->offset, wdata->bytes);
 
@@ -2086,26 +1831,32 @@ cifs_async_writev(struct cifs_writedata *wdata)
                                 (struct smb_com_writex_req *)smb;
                 inc_rfc1001_len(&smbw->hdr, wdata->bytes + 5);
                 put_bcc(wdata->bytes + 5, &smbw->hdr);
-                iov.iov_len += 4; /* pad bigger by four bytes */
+                iov[0].iov_len += 4; /* pad bigger by four bytes */
         }
 
         kref_get(&wdata->refcount);
-        rc = cifs_call_async(tcon->ses->server, &rqst, NULL,
-                                cifs_writev_callback, wdata, 0);
+        rc = cifs_call_async(tcon->ses->server, iov, wdata->nr_pages + 1,
+                             cifs_writev_callback, wdata, false);
 
         if (rc == 0)
-                cifs_stats_inc(&tcon->stats.cifs_stats.num_writes);
+                cifs_stats_inc(&tcon->num_writes);
         else
                 kref_put(&wdata->refcount, cifs_writedata_release);
 
+        /* send is done, unmap pages */
+        for (i = 0; i < wdata->nr_pages; i++)
+                kunmap(wdata->pages[i]);
+
 async_writev_out:
         cifs_small_buf_release(smb);
+        kfree(iov);
         return rc;
 }
 
 int
-CIFSSMBWrite2(const unsigned int xid, struct cifs_io_parms *io_parms,
-              unsigned int *nbytes, struct kvec *iov, int n_vec)
+CIFSSMBWrite2(const int xid, struct cifs_io_parms *io_parms,
+              unsigned int *nbytes, struct kvec *iov, int n_vec,
+              const int long_op)
 {
         int rc = -EACCES;
         WRITE_REQ *pSMB = NULL;
@@ -2176,8 +1927,9 @@ CIFSSMBWrite2(const unsigned int xid, struct cifs_io_parms *io_parms,
                 iov[0].iov_len = smb_hdr_len + 8;
 
 
-        rc = SendReceive2(xid, tcon->ses, iov, n_vec + 1, &resp_buf_type, 0);
-        cifs_stats_inc(&tcon->stats.cifs_stats.num_writes);
+        rc = SendReceive2(xid, tcon->ses, iov, n_vec + 1, &resp_buf_type,
+                          long_op);
+        cifs_stats_inc(&tcon->num_writes);
         if (rc) {
                 cFYI(1, "Send error Write2 = %d", rc);
         } else if (resp_buf_type == 0) {
@@ -2210,50 +1962,10 @@ CIFSSMBWrite2(const unsigned int xid, struct cifs_io_parms *io_parms,
         return rc;
 }
 
-int cifs_lockv(const unsigned int xid, struct cifs_tcon *tcon,
-               const __u16 netfid, const __u8 lock_type, const __u32 num_unlock,
-               const __u32 num_lock, LOCKING_ANDX_RANGE *buf)
-{
-        int rc = 0;
-        LOCK_REQ *pSMB = NULL;
-        struct kvec iov[2];
-        int resp_buf_type;
-        __u16 count;
-
-        cFYI(1, "cifs_lockv num lock %d num unlock %d", num_lock, num_unlock);
-
-        rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
-        if (rc)
-                return rc;
-
-        pSMB->Timeout = 0;
-        pSMB->NumberOfLocks = cpu_to_le16(num_lock);
-        pSMB->NumberOfUnlocks = cpu_to_le16(num_unlock);
-        pSMB->LockType = lock_type;
-        pSMB->AndXCommand = 0xFF; /* none */
-        pSMB->Fid = netfid; /* netfid stays le */
-
-        count = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
-        inc_rfc1001_len(pSMB, count);
-        pSMB->ByteCount = cpu_to_le16(count);
-
-        iov[0].iov_base = (char *)pSMB;
-        iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4 -
-                         (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
-        iov[1].iov_base = (char *)buf;
-        iov[1].iov_len = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
-
-        cifs_stats_inc(&tcon->stats.cifs_stats.num_locks);
-        rc = SendReceive2(xid, tcon->ses, iov, 2, &resp_buf_type, CIFS_NO_RESP);
-        if (rc)
-                cFYI(1, "Send error in cifs_lockv = %d", rc);
-
-        return rc;
-}
 
 int
-CIFSSMBLock(const unsigned int xid, struct cifs_tcon *tcon,
-            const __u16 smb_file_id, const __u32 netpid, const __u64 len,
+CIFSSMBLock(const int xid, struct cifs_tcon *tcon,
+            const __u16 smb_file_id, const __u64 len,
             const __u64 offset, const __u32 numUnlock,
             const __u32 numLock, const __u8 lockType,
             const bool waitFlag, const __u8 oplock_level)
@@ -2262,7 +1974,7 @@ CIFSSMBLock(const unsigned int xid, struct cifs_tcon *tcon,
         LOCK_REQ *pSMB = NULL;
 /*      LOCK_RSP *pSMBr = NULL; */ /* No response data other than rc to parse */
         int bytes_returned;
-        int flags = 0;
+        int timeout = 0;
         __u16 count;
 
         cFYI(1, "CIFSSMBLock timeout %d numLock %d", (int)waitFlag, numLock);
@@ -2272,11 +1984,10 @@ CIFSSMBLock(const unsigned int xid, struct cifs_tcon *tcon,
                 return rc;
 
         if (lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
-                /* no response expected */
-                flags = CIFS_ASYNC_OP | CIFS_OBREAK_OP;
+                timeout = CIFS_ASYNC_OP; /* no response expected */
                 pSMB->Timeout = 0;
         } else if (waitFlag) {
-                flags = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
+                timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
                 pSMB->Timeout = cpu_to_le32(-1);/* blocking - do not time out */
         } else {
                 pSMB->Timeout = 0;
@@ -2290,7 +2001,7 @@ CIFSSMBLock(const unsigned int xid, struct cifs_tcon *tcon,
         pSMB->Fid = smb_file_id; /* netfid stays le */
 
         if ((numLock != 0) || (numUnlock != 0)) {
-                pSMB->Locks[0].Pid = cpu_to_le16(netpid);
+                pSMB->Locks[0].Pid = cpu_to_le16(current->tgid);
                 /* BB where to store pid high? */
                 pSMB->Locks[0].LengthLow = cpu_to_le32((u32)len);
                 pSMB->Locks[0].LengthHigh = cpu_to_le32((u32)(len>>32));
@@ -2309,10 +2020,11 @@ CIFSSMBLock(const unsigned int xid, struct cifs_tcon *tcon,
                         (struct smb_hdr *) pSMB, &bytes_returned);
                 cifs_small_buf_release(pSMB);
         } else {
-                rc = SendReceiveNoRsp(xid, tcon->ses, (char *)pSMB, flags);
+                rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *)pSMB,
+                                      timeout);
                 /* SMB buffer freed by function above */
         }
-        cifs_stats_inc(&tcon->stats.cifs_stats.num_locks);
+        cifs_stats_inc(&tcon->num_locks);
         if (rc)
                 cFYI(1, "Send error in Lock = %d", rc);
 
@@ -2322,9 +2034,8 @@ CIFSSMBLock(const unsigned int xid, struct cifs_tcon *tcon,
 }
 
 int
-CIFSSMBPosixLock(const unsigned int xid, struct cifs_tcon *tcon,
-                const __u16 smb_file_id, const __u32 netpid,
-                const loff_t start_offset, const __u64 len,
+CIFSSMBPosixLock(const int xid, struct cifs_tcon *tcon,
+                const __u16 smb_file_id, const int get_flag, const __u64 len,
                 struct file_lock *pLockData, const __u16 lock_type,
                 const bool waitFlag)
 {
@@ -2340,6 +2051,9 @@ CIFSSMBPosixLock(const unsigned int xid, struct cifs_tcon *tcon,
 
         cFYI(1, "Posix Lock");
 
+        if (pLockData == NULL)
+                return -EINVAL;
+
         rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
 
         if (rc)
@@ -2360,7 +2074,7 @@ CIFSSMBPosixLock(const unsigned int xid, struct cifs_tcon *tcon,
         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
         pSMB->SetupCount = 1;
         pSMB->Reserved3 = 0;
-        if (pLockData)
+        if (get_flag)
                 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
         else
                 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
@@ -2381,8 +2095,8 @@ CIFSSMBPosixLock(const unsigned int xid, struct cifs_tcon *tcon,
         } else
                 pSMB->Timeout = 0;
 
-        parm_data->pid = cpu_to_le32(netpid);
-        parm_data->start = cpu_to_le64(start_offset);
+        parm_data->pid = cpu_to_le32(current->tgid);
+        parm_data->start = cpu_to_le64(pLockData->fl_start);
         parm_data->length = cpu_to_le64(len);  /* normalize negative numbers */
 
         pSMB->DataOffset = cpu_to_le16(offset);
@@ -2406,7 +2120,7 @@ CIFSSMBPosixLock(const unsigned int xid, struct cifs_tcon *tcon,
 
         if (rc) {
                 cFYI(1, "Send error in Posix Lock = %d", rc);
-        } else if (pLockData) {
+        } else if (get_flag) {
                 /* lock structure can be returned on get */
                 __u16 data_offset;
                 __u16 data_count;
@@ -2458,7 +2172,7 @@ plk_err_exit:
 
 
 int
-CIFSSMBClose(const unsigned int xid, struct cifs_tcon *tcon, int smb_file_id)
+CIFSSMBClose(const int xid, struct cifs_tcon *tcon, int smb_file_id)
 {
         int rc = 0;
         CLOSE_REQ *pSMB = NULL;
@@ -2474,8 +2188,8 @@ CIFSSMBClose(const unsigned int xid, struct cifs_tcon *tcon, int smb_file_id)
         pSMB->FileID = (__u16) smb_file_id;
         pSMB->LastWriteTime = 0xFFFFFFFF;
         pSMB->ByteCount = 0;
-        rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
-        cifs_stats_inc(&tcon->stats.cifs_stats.num_closes);
+        rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
+        cifs_stats_inc(&tcon->num_closes);
         if (rc) {
                 if (rc != -EINTR) {
                         /* EINTR is expected when user ctl-c to kill app */
@@ -2491,7 +2205,7 @@ CIFSSMBClose(const unsigned int xid, struct cifs_tcon *tcon, int smb_file_id)
 }
 
 int
-CIFSSMBFlush(const unsigned int xid, struct cifs_tcon *tcon, int smb_file_id)
+CIFSSMBFlush(const int xid, struct cifs_tcon *tcon, int smb_file_id)
 {
         int rc = 0;
         FLUSH_REQ *pSMB = NULL;
@@ -2503,8 +2217,8 @@ CIFSSMBFlush(const unsigned int xid, struct cifs_tcon *tcon, int smb_file_id)
 
         pSMB->FileID = (__u16) smb_file_id;
         pSMB->ByteCount = 0;
-        rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
-        cifs_stats_inc(&tcon->stats.cifs_stats.num_flushes);
+        rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
+        cifs_stats_inc(&tcon->num_flushes);
         if (rc)
                 cERROR(1, "Send error in Flush = %d", rc);
 
@@ -2512,9 +2226,9 @@ CIFSSMBFlush(const unsigned int xid, struct cifs_tcon *tcon, int smb_file_id)
 }
 
 int
-CIFSSMBRename(const unsigned int xid, struct cifs_tcon *tcon,
-              const char *from_name, const char *to_name,
-              struct cifs_sb_info *cifs_sb)
+CIFSSMBRename(const int xid, struct cifs_tcon *tcon,
+              const char *fromName, const char *toName,
+              const struct nls_table *nls_codepage, int remap)
 {
         int rc = 0;
         RENAME_REQ *pSMB = NULL;
@@ -2522,7 +2236,6 @@ CIFSSMBRename(const unsigned int xid, struct cifs_tcon *tcon,
         int bytes_returned;
         int name_len, name_len2;
         __u16 count;
-        int remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
 
         cFYI(1, "In CIFSSMBRename");
 renameRetry:
@@ -2537,28 +2250,27 @@ renameRetry:
                         ATTR_DIRECTORY);
 
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
-                name_len = cifsConvertToUTF16((__le16 *) pSMB->OldFileName,
-                                              from_name, PATH_MAX,
-                                              cifs_sb->local_nls, remap);
+                name_len =
+                    cifsConvertToUCS((__le16 *) pSMB->OldFileName, fromName,
+                                     PATH_MAX, nls_codepage, remap);
                 name_len++;     /* trailing null */
                 name_len *= 2;
                 pSMB->OldFileName[name_len] = 0x04;     /* pad */
         /* protocol requires ASCII signature byte on Unicode string */
                 pSMB->OldFileName[name_len + 1] = 0x00;
                 name_len2 =
-                    cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
-                                       to_name, PATH_MAX, cifs_sb->local_nls,
-                                       remap);
+                    cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2],
+                                     toName, PATH_MAX, nls_codepage, remap);
                 name_len2 += 1 /* trailing null */  + 1 /* Signature word */ ;
                 name_len2 *= 2; /* convert to bytes */
         } else {        /* BB improve the check for buffer overruns BB */
-                name_len = strnlen(from_name, PATH_MAX);
+                name_len = strnlen(fromName, PATH_MAX);
                 name_len++;     /* trailing null */
-                strncpy(pSMB->OldFileName, from_name, name_len);
-                name_len2 = strnlen(to_name, PATH_MAX);
+                strncpy(pSMB->OldFileName, fromName, name_len);
+                name_len2 = strnlen(toName, PATH_MAX);
                 name_len2++;    /* trailing null */
                 pSMB->OldFileName[name_len] = 0x04;  /* 2nd buffer format */
-                strncpy(&pSMB->OldFileName[name_len + 1], to_name, name_len2);
+                strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
                 name_len2++;    /* trailing null */
                 name_len2++;    /* signature byte */
         }
@@ -2569,7 +2281,7 @@ renameRetry:
 
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        cifs_stats_inc(&tcon->stats.cifs_stats.num_renames);
+        cifs_stats_inc(&tcon->num_renames);
         if (rc)
                 cFYI(1, "Send error in rename = %d", rc);
 
@@ -2581,7 +2293,7 @@ renameRetry:
         return rc;
 }
 
-int CIFSSMBRenameOpenFile(const unsigned int xid, struct cifs_tcon *pTcon,
+int CIFSSMBRenameOpenFile(const int xid, struct cifs_tcon *pTcon,
                 int netfid, const char *target_name,
                 const struct nls_table *nls_codepage, int remap)
 {
@@ -2628,12 +2340,10 @@ int CIFSSMBRenameOpenFile(const unsigned int xid, struct cifs_tcon *pTcon,
         /* unicode only call */
         if (target_name == NULL) {
                 sprintf(dummy_string, "cifs%x", pSMB->hdr.Mid);
-                len_of_str =
-                        cifsConvertToUTF16((__le16 *)rename_info->target_name,
+                len_of_str = cifsConvertToUCS((__le16 *)rename_info->target_name,
                                         dummy_string, 24, nls_codepage, remap);
         } else {
-                len_of_str =
-                        cifsConvertToUTF16((__le16 *)rename_info->target_name,
+                len_of_str = cifsConvertToUCS((__le16 *)rename_info->target_name,
                                         target_name, PATH_MAX, nls_codepage,
                                         remap);
         }
@@ -2650,7 +2360,7 @@ int CIFSSMBRenameOpenFile(const unsigned int xid, struct cifs_tcon *pTcon,
         pSMB->ByteCount = cpu_to_le16(byte_count);
         rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        cifs_stats_inc(&pTcon->stats.cifs_stats.num_t2renames);
+        cifs_stats_inc(&pTcon->num_t2renames);
         if (rc)
                 cFYI(1, "Send error in Rename (by file handle) = %d", rc);
 
@@ -2663,9 +2373,9 @@ int CIFSSMBRenameOpenFile(const unsigned int xid, struct cifs_tcon *pTcon,
 }
 
 int
-CIFSSMBCopy(const unsigned int xid, struct cifs_tcon *tcon,
-            const char *fromName, const __u16 target_tid, const char *toName,
-            const int flags, const struct nls_table *nls_codepage, int remap)
+CIFSSMBCopy(const int xid, struct cifs_tcon *tcon, const char *fromName,
+            const __u16 target_tid, const char *toName, const int flags,
+            const struct nls_table *nls_codepage, int remap)
 {
         int rc = 0;
         COPY_REQ *pSMB = NULL;
@@ -2687,17 +2397,17 @@ copyRetry:
         pSMB->Flags = cpu_to_le16(flags & COPY_TREE);
 
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
-                name_len = cifsConvertToUTF16((__le16 *) pSMB->OldFileName,
-                                              fromName, PATH_MAX, nls_codepage,
-                                              remap);
+                name_len = cifsConvertToUCS((__le16 *) pSMB->OldFileName,
+                                            fromName, PATH_MAX, nls_codepage,
+                                            remap);
                 name_len++;     /* trailing null */
                 name_len *= 2;
                 pSMB->OldFileName[name_len] = 0x04;     /* pad */
                 /* protocol requires ASCII signature byte on Unicode string */
                 pSMB->OldFileName[name_len + 1] = 0x00;
                 name_len2 =
-                    cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
-                                       toName, PATH_MAX, nls_codepage, remap);
+                    cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2],
+                                toName, PATH_MAX, nls_codepage, remap);
                 name_len2 += 1 /* trailing null */  + 1 /* Signature word */ ;
                 name_len2 *= 2; /* convert to bytes */
         } else {        /* BB improve the check for buffer overruns BB */
@@ -2731,7 +2441,7 @@ copyRetry:
 }
 
 int
-CIFSUnixCreateSymLink(const unsigned int xid, struct cifs_tcon *tcon,
+CIFSUnixCreateSymLink(const int xid, struct cifs_tcon *tcon,
                       const char *fromName, const char *toName,
                       const struct nls_table *nls_codepage)
 {
@@ -2753,9 +2463,9 @@ createSymLinkRetry:
 
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
                 name_len =
-                    cifs_strtoUTF16((__le16 *) pSMB->FileName, fromName,
-                                    /* find define for this maxpathcomponent */
-                                    PATH_MAX, nls_codepage);
+                    cifs_strtoUCS((__le16 *) pSMB->FileName, fromName, PATH_MAX
+                                  /* find define for this maxpathcomponent */
+                                  , nls_codepage);
                 name_len++;     /* trailing null */
                 name_len *= 2;
 
@@ -2777,9 +2487,9 @@ createSymLinkRetry:
         data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
                 name_len_target =
-                    cifs_strtoUTF16((__le16 *) data_offset, toName, PATH_MAX
-                                    /* find define for this maxpathcomponent */
-                                    , nls_codepage);
+                    cifs_strtoUCS((__le16 *) data_offset, toName, PATH_MAX
+                                  /* find define for this maxpathcomponent */
+                                  , nls_codepage);
                 name_len_target++;      /* trailing null */
                 name_len_target *= 2;
         } else {        /* BB improve the check for buffer overruns BB */
@@ -2807,7 +2517,7 @@ createSymLinkRetry:
         pSMB->ByteCount = cpu_to_le16(byte_count);
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        cifs_stats_inc(&tcon->stats.cifs_stats.num_symlinks);
+        cifs_stats_inc(&tcon->num_symlinks);
         if (rc)
                 cFYI(1, "Send error in SetPathInfo create symlink = %d", rc);
 
@@ -2820,7 +2530,7 @@ createSymLinkRetry:
 }
 
 int
-CIFSUnixCreateHardLink(const unsigned int xid, struct cifs_tcon *tcon,
+CIFSUnixCreateHardLink(const int xid, struct cifs_tcon *tcon,
                        const char *fromName, const char *toName,
                        const struct nls_table *nls_codepage, int remap)
 {
@@ -2841,8 +2551,8 @@ createHardLinkRetry:
                 return rc;
 
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
-                name_len = cifsConvertToUTF16((__le16 *) pSMB->FileName, toName,
-                                              PATH_MAX, nls_codepage, remap);
+                name_len = cifsConvertToUCS((__le16 *) pSMB->FileName, toName,
+                                            PATH_MAX, nls_codepage, remap);
                 name_len++;     /* trailing null */
                 name_len *= 2;
 
@@ -2864,8 +2574,8 @@ createHardLinkRetry:
         data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
                 name_len_target =
-                    cifsConvertToUTF16((__le16 *) data_offset, fromName,
-                                       PATH_MAX, nls_codepage, remap);
+                    cifsConvertToUCS((__le16 *) data_offset, fromName, PATH_MAX,
+                                     nls_codepage, remap);
                 name_len_target++;      /* trailing null */
                 name_len_target *= 2;
         } else {        /* BB improve the check for buffer overruns BB */
@@ -2893,7 +2603,7 @@ createHardLinkRetry:
         pSMB->ByteCount = cpu_to_le16(byte_count);
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        cifs_stats_inc(&tcon->stats.cifs_stats.num_hardlinks);
+        cifs_stats_inc(&tcon->num_hardlinks);
         if (rc)
                 cFYI(1, "Send error in SetPathInfo (hard link) = %d", rc);
 
@@ -2905,9 +2615,9 @@ createHardLinkRetry:
 }
 
 int
-CIFSCreateHardLink(const unsigned int xid, struct cifs_tcon *tcon,
-                   const char *from_name, const char *to_name,
-                   struct cifs_sb_info *cifs_sb)
+CIFSCreateHardLink(const int xid, struct cifs_tcon *tcon,
+                   const char *fromName, const char *toName,
+                   const struct nls_table *nls_codepage, int remap)
 {
         int rc = 0;
         NT_RENAME_REQ *pSMB = NULL;
@@ -2915,7 +2625,6 @@ CIFSCreateHardLink(const unsigned int xid, struct cifs_tcon *tcon,
         int bytes_returned;
         int name_len, name_len2;
         __u16 count;
-        int remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
 
         cFYI(1, "In CIFSCreateHardLink");
 winCreateHardLinkRetry:
@@ -2935,8 +2644,8 @@ winCreateHardLinkRetry:
 
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
                 name_len =
-                    cifsConvertToUTF16((__le16 *) pSMB->OldFileName, from_name,
-                                       PATH_MAX, cifs_sb->local_nls, remap);
+                    cifsConvertToUCS((__le16 *) pSMB->OldFileName, fromName,
+                                     PATH_MAX, nls_codepage, remap);
                 name_len++;     /* trailing null */
                 name_len *= 2;
 
@@ -2944,19 +2653,18 @@ winCreateHardLinkRetry:
                 pSMB->OldFileName[name_len] = 0x04;
                 pSMB->OldFileName[name_len + 1] = 0x00; /* pad */
                 name_len2 =
-                    cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
-                                       to_name, PATH_MAX, cifs_sb->local_nls,
-                                       remap);
+                    cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2],
+                                     toName, PATH_MAX, nls_codepage, remap);
                 name_len2 += 1 /* trailing null */  + 1 /* Signature word */ ;
                 name_len2 *= 2; /* convert to bytes */
         } else {        /* BB improve the check for buffer overruns BB */
-                name_len = strnlen(from_name, PATH_MAX);
+                name_len = strnlen(fromName, PATH_MAX);
                 name_len++;     /* trailing null */
-                strncpy(pSMB->OldFileName, from_name, name_len);
-                name_len2 = strnlen(to_name, PATH_MAX);
+                strncpy(pSMB->OldFileName, fromName, name_len);
+                name_len2 = strnlen(toName, PATH_MAX);
                 name_len2++;    /* trailing null */
                 pSMB->OldFileName[name_len] = 0x04;     /* 2nd buffer format */
-                strncpy(&pSMB->OldFileName[name_len + 1], to_name, name_len2);
+                strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
                 name_len2++;    /* trailing null */
                 name_len2++;    /* signature byte */
         }
@@ -2967,7 +2675,7 @@ winCreateHardLinkRetry:
 
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        cifs_stats_inc(&tcon->stats.cifs_stats.num_hardlinks);
+        cifs_stats_inc(&tcon->num_hardlinks);
         if (rc)
                 cFYI(1, "Send error in hard link (NT rename) = %d", rc);
 
@@ -2979,7 +2687,7 @@ winCreateHardLinkRetry:
 }
 
 int
-CIFSSMBUnixQuerySymLink(const unsigned int xid, struct cifs_tcon *tcon,
+CIFSSMBUnixQuerySymLink(const int xid, struct cifs_tcon *tcon,
                         const unsigned char *searchName, char **symlinkinfo,
                         const struct nls_table *nls_codepage)
 {
@@ -3002,8 +2710,8 @@ querySymLinkRetry:
 
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
                 name_len =
-                        cifs_strtoUTF16((__le16 *) pSMB->FileName, searchName,
-                                        PATH_MAX, nls_codepage);
+                    cifs_strtoUCS((__le16 *) pSMB->FileName, searchName,
+                                  PATH_MAX, nls_codepage);
                 name_len++;     /* trailing null */
                 name_len *= 2;
         } else {        /* BB improve the check for buffer overruns BB */
@@ -3060,8 +2768,8 @@ querySymLinkRetry:
                                 is_unicode = false;
 
                         /* BB FIXME investigate remapping reserved chars here */
-                        *symlinkinfo = cifs_strndup_from_utf16(data_start,
-                                        count, is_unicode, nls_codepage);
+                        *symlinkinfo = cifs_strndup_from_ucs(data_start, count,
+                                                    is_unicode, nls_codepage);
                         if (!*symlinkinfo)
                                 rc = -ENOMEM;
                 }
@@ -3084,7 +2792,7 @@ querySymLinkRetry:
  *      it is not compiled in by default until callers fixed up and more tested.
  */
 int
-CIFSSMBQueryReparseLinkInfo(const unsigned int xid, struct cifs_tcon *tcon,
+CIFSSMBQueryReparseLinkInfo(const int xid, struct cifs_tcon *tcon,
                         const unsigned char *searchName,
                         char *symlinkinfo, const int buflen, __u16 fid,
                         const struct nls_table *nls_codepage)
@@ -3104,7 +2812,8 @@ CIFSSMBQueryReparseLinkInfo(const unsigned int xid, struct cifs_tcon *tcon,
         pSMB->TotalDataCount = 0;
         pSMB->MaxParameterCount = cpu_to_le32(2);
         /* BB find exact data count max from sess structure BB */
-        pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
+        pSMB->MaxDataCount = cpu_to_le32((tcon->ses->server->maxBuf -
+                                          MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
         pSMB->MaxSetupCount = 4;
         pSMB->Reserved = 0;
         pSMB->ParameterOffset = 0;
@@ -3321,7 +3030,7 @@ static __u16 ACL_to_cifs_posix(char *parm_data, const char *pACL,
 }
 
 int
-CIFSSMBGetPosixACL(const unsigned int xid, struct cifs_tcon *tcon,
+CIFSSMBGetPosixACL(const int xid, struct cifs_tcon *tcon,
                    const unsigned char *searchName,
                    char *acl_inf, const int buflen, const int acl_type,
                    const struct nls_table *nls_codepage, int remap)
@@ -3344,9 +3053,8 @@ queryAclRetry:
 
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
                 name_len =
-                        cifsConvertToUTF16((__le16 *) pSMB->FileName,
-                                           searchName, PATH_MAX, nls_codepage,
-                                           remap);
+                        cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
+                                         PATH_MAX, nls_codepage, remap);
                 name_len++;     /* trailing null */
                 name_len *= 2;
                 pSMB->FileName[name_len] = 0;
@@ -3385,7 +3093,7 @@ queryAclRetry:
 
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        cifs_stats_inc(&tcon->stats.cifs_stats.num_acl_get);
+        cifs_stats_inc(&tcon->num_acl_get);
         if (rc) {
                 cFYI(1, "Send error in Query POSIX ACL = %d", rc);
         } else {
@@ -3410,7 +3118,7 @@ queryAclRetry:
 }
 
 int
-CIFSSMBSetPosixACL(const unsigned int xid, struct cifs_tcon *tcon,
+CIFSSMBSetPosixACL(const int xid, struct cifs_tcon *tcon,
                    const unsigned char *fileName,
                    const char *local_acl, const int buflen,
                    const int acl_type,
@@ -3432,8 +3140,8 @@ setAclRetry:
                 return rc;
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
                 name_len =
-                        cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
-                                           PATH_MAX, nls_codepage, remap);
+                        cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
+                                      PATH_MAX, nls_codepage, remap);
                 name_len++;     /* trailing null */
                 name_len *= 2;
         } else {        /* BB improve the check for buffer overruns BB */
@@ -3490,7 +3198,7 @@ setACLerrorExit:
 
 /* BB fix tabs in this function FIXME BB */
 int
-CIFSGetExtAttr(const unsigned int xid, struct cifs_tcon *tcon,
+CIFSGetExtAttr(const int xid, struct cifs_tcon *tcon,
                const int netfid, __u64 *pExtAttrBits, __u64 *pMask)
 {
         int rc = 0;
@@ -3598,7 +3306,8 @@ smb_init_nttransact(const __u16 sub_command, const int setup_count,
         pSMB->Reserved = 0;
         pSMB->TotalParameterCount = cpu_to_le32(parm_len);
         pSMB->TotalDataCount  = 0;
-        pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
+        pSMB->MaxDataCount = cpu_to_le32((tcon->ses->server->maxBuf -
+                                          MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
         pSMB->ParameterCount = pSMB->TotalParameterCount;
         pSMB->DataCount  = pSMB->TotalDataCount;
         temp_offset = offsetof(struct smb_com_ntransact_req, Parms) +
@@ -3665,7 +3374,7 @@ validate_ntransact(char *buf, char **ppparm, char **ppdata,
 
 /* Get Security Descriptor (by handle) from remote server for a file or dir */
 int
-CIFSSMBGetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon, __u16 fid,
+CIFSSMBGetCIFSACL(const int xid, struct cifs_tcon *tcon, __u16 fid,
                   struct cifs_ntsd **acl_inf, __u32 *pbuflen)
 {
         int rc = 0;
@@ -3696,7 +3405,7 @@ CIFSSMBGetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon, __u16 fid,
 
         rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovec */, &buf_type,
                          0);
-        cifs_stats_inc(&tcon->stats.cifs_stats.num_acl_get);
+        cifs_stats_inc(&tcon->num_acl_get);
         if (rc) {
                 cFYI(1, "Send error in QuerySecDesc = %d", rc);
         } else {                /* decode response */
@@ -3757,19 +3466,20 @@ qsec_out:
 }
 
 int
-CIFSSMBSetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon, __u16 fid,
-                        struct cifs_ntsd *pntsd, __u32 acllen, int aclflag)
+CIFSSMBSetCIFSACL(const int xid, struct cifs_tcon *tcon, __u16 fid,
+                        struct cifs_ntsd *pntsd, __u32 acllen)
 {
         __u16 byte_count, param_count, data_count, param_offset, data_offset;
         int rc = 0;
         int bytes_returned = 0;
         SET_SEC_DESC_REQ *pSMB = NULL;
-        void *pSMBr;
+        NTRANSACT_RSP *pSMBr = NULL;
 
 setCifsAclRetry:
-        rc = smb_init(SMB_COM_NT_TRANSACT, 19, tcon, (void **) &pSMB, &pSMBr);
+        rc = smb_init(SMB_COM_NT_TRANSACT, 19, tcon, (void **) &pSMB,
+                        (void **) &pSMBr);
         if (rc)
-                return rc;
+                        return (rc);
 
         pSMB->MaxSetupCount = 0;
         pSMB->Reserved = 0;
@@ -3794,11 +3504,12 @@ setCifsAclRetry:
 
         pSMB->Fid = fid; /* file handle always le */
         pSMB->Reserved2 = 0;
-        pSMB->AclFlags = cpu_to_le32(aclflag);
+        pSMB->AclFlags = cpu_to_le32(CIFS_ACL_DACL);
 
         if (pntsd && acllen) {
-                memcpy((char *)pSMBr + offsetof(struct smb_hdr, Protocol) +
-                                data_offset, pntsd, acllen);
+                memcpy((char *) &pSMBr->hdr.Protocol + data_offset,
+                        (char *) pntsd,
+                        acllen);
                 inc_rfc1001_len(pSMB, byte_count + data_count);
         } else
                 inc_rfc1001_len(pSMB, byte_count);
@@ -3821,10 +3532,10 @@ setCifsAclRetry:
 
 /* Legacy Query Path Information call for lookup to old servers such
    as Win9x/WinME */
-int
-SMBQueryInformation(const unsigned int xid, struct cifs_tcon *tcon,
-                    const char *search_name, FILE_ALL_INFO *data,
-                    const struct nls_table *nls_codepage, int remap)
+int SMBQueryInformation(const int xid, struct cifs_tcon *tcon,
+                        const unsigned char *searchName,
+                        FILE_ALL_INFO *pFinfo,
+                        const struct nls_table *nls_codepage, int remap)
 {
         QUERY_INFORMATION_REQ *pSMB;
         QUERY_INFORMATION_RSP *pSMBr;
@@ -3832,7 +3543,7 @@ SMBQueryInformation(const unsigned int xid, struct cifs_tcon *tcon,
         int bytes_returned;
         int name_len;
 
-        cFYI(1, "In SMBQPath path %s", search_name);
+        cFYI(1, "In SMBQPath path %s", searchName);
 QInfRetry:
         rc = smb_init(SMB_COM_QUERY_INFORMATION, 0, tcon, (void **) &pSMB,
                       (void **) &pSMBr);
@@ -3841,15 +3552,14 @@ QInfRetry:
 
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
                 name_len =
-                        cifsConvertToUTF16((__le16 *) pSMB->FileName,
-                                           search_name, PATH_MAX, nls_codepage,
-                                           remap);
+                        cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
+                                        PATH_MAX, nls_codepage, remap);
                 name_len++;     /* trailing null */
                 name_len *= 2;
         } else {
-                name_len = strnlen(search_name, PATH_MAX);
+                name_len = strnlen(searchName, PATH_MAX);
                 name_len++;     /* trailing null */
-                strncpy(pSMB->FileName, search_name, name_len);
+                strncpy(pSMB->FileName, searchName, name_len);
         }
         pSMB->BufferFormat = 0x04;
         name_len++; /* account for buffer type byte */
@@ -3860,23 +3570,23 @@ QInfRetry:
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
         if (rc) {
                 cFYI(1, "Send error in QueryInfo = %d", rc);
-        } else if (data) {
+        } else if (pFinfo) {
                 struct timespec ts;
                 __u32 time = le32_to_cpu(pSMBr->last_write_time);
 
                 /* decode response */
                 /* BB FIXME - add time zone adjustment BB */
-                memset(data, 0, sizeof(FILE_ALL_INFO));
+                memset(pFinfo, 0, sizeof(FILE_ALL_INFO));
                 ts.tv_nsec = 0;
                 ts.tv_sec = time;
                 /* decode time fields */
-                data->ChangeTime = cpu_to_le64(cifs_UnixTimeToNT(ts));
-                data->LastWriteTime = data->ChangeTime;
-                data->LastAccessTime = 0;
-                data->AllocationSize =
+                pFinfo->ChangeTime = cpu_to_le64(cifs_UnixTimeToNT(ts));
+                pFinfo->LastWriteTime = pFinfo->ChangeTime;
+                pFinfo->LastAccessTime = 0;
+                pFinfo->AllocationSize =
                         cpu_to_le64(le32_to_cpu(pSMBr->size));
-                data->EndOfFile = data->AllocationSize;
-                data->Attributes =
+                pFinfo->EndOfFile = pFinfo->AllocationSize;
+                pFinfo->Attributes =
                         cpu_to_le32(le16_to_cpu(pSMBr->attr));
         } else
                 rc = -EIO; /* bad buffer passed in */
@@ -3890,7 +3600,7 @@ QInfRetry:
 }
 
 int
-CIFSSMBQFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
+CIFSSMBQFileInfo(const int xid, struct cifs_tcon *tcon,
                  u16 netfid, FILE_ALL_INFO *pFindData)
 {
         struct smb_t2_qfi_req *pSMB = NULL;
@@ -3957,12 +3667,13 @@ QFileInfoRetry:
 }
 
 int
-CIFSSMBQPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
-                 const char *search_name, FILE_ALL_INFO *data,
+CIFSSMBQPathInfo(const int xid, struct cifs_tcon *tcon,
+                 const unsigned char *searchName,
+                 FILE_ALL_INFO *pFindData,
                  int legacy /* old style infolevel */,
                  const struct nls_table *nls_codepage, int remap)
 {
-        /* level 263 SMB_QUERY_FILE_ALL_INFO */
+/* level 263 SMB_QUERY_FILE_ALL_INFO */
         TRANSACTION2_QPI_REQ *pSMB = NULL;
         TRANSACTION2_QPI_RSP *pSMBr = NULL;
         int rc = 0;
@@ -3970,7 +3681,7 @@ CIFSSMBQPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
         int name_len;
         __u16 params, byte_count;
 
-        /* cFYI(1, "In QPathInfo path %s", search_name); */
+/* cFYI(1, "In QPathInfo path %s", searchName); */
 QPathInfoRetry:
         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
                       (void **) &pSMBr);
@@ -3979,14 +3690,14 @@ QPathInfoRetry:
 
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
                 name_len =
-                    cifsConvertToUTF16((__le16 *) pSMB->FileName, search_name,
-                                       PATH_MAX, nls_codepage, remap);
+                    cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
+                                     PATH_MAX, nls_codepage, remap);
                 name_len++;     /* trailing null */
                 name_len *= 2;
         } else {        /* BB improve the check for buffer overruns BB */
-                name_len = strnlen(search_name, PATH_MAX);
+                name_len = strnlen(searchName, PATH_MAX);
                 name_len++;     /* trailing null */
-                strncpy(pSMB->FileName, search_name, name_len);
+                strncpy(pSMB->FileName, searchName, name_len);
         }
 
         params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
@@ -4031,21 +3742,20 @@ QPathInfoRetry:
                 else if (legacy && get_bcc(&pSMBr->hdr) < 24)
                         rc = -EIO;  /* 24 or 26 expected but we do not read
                                         last field */
-                else if (data) {
+                else if (pFindData) {
                         int size;
                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
 
-                        /*
-                         * On legacy responses we do not read the last field,
-                         * EAsize, fortunately since it varies by subdialect and
-                         * also note it differs on Set vs Get, ie two bytes or 4
-                         * bytes depending but we don't care here.
-                         */
+                        /* On legacy responses we do not read the last field,
+                        EAsize, fortunately since it varies by subdialect and
+                        also note it differs on Set vs. Get, ie two bytes or 4
+                        bytes depending but we don't care here */
                         if (legacy)
                                 size = sizeof(FILE_INFO_STANDARD);
                         else
                                 size = sizeof(FILE_ALL_INFO);
-                        memcpy((char *) data, (char *) &pSMBr->hdr.Protocol +
+                        memcpy((char *) pFindData,
+                               (char *) &pSMBr->hdr.Protocol +
                                data_offset, size);
                 } else
                     rc = -ENOMEM;
@@ -4058,7 +3768,7 @@ QPathInfoRetry:
 }
 
 int
-CIFSSMBUnixQFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
+CIFSSMBUnixQFileInfo(const int xid, struct cifs_tcon *tcon,
                  u16 netfid, FILE_UNIX_BASIC_INFO *pFindData)
 {
         struct smb_t2_qfi_req *pSMB = NULL;
@@ -4106,7 +3816,7 @@ UnixQFileInfoRetry:
                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
 
                 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
-                        cERROR(1, "Malformed FILE_UNIX_BASIC_INFO response. "
+                        cERROR(1, "Malformed FILE_UNIX_BASIC_INFO response.\n"
                                    "Unix Extensions can be disabled on mount "
                                    "by specifying the nosfu mount option.");
                         rc = -EIO;      /* bad smb */
@@ -4127,7 +3837,7 @@ UnixQFileInfoRetry:
 }
 
 int
-CIFSSMBUnixQPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
+CIFSSMBUnixQPathInfo(const int xid, struct cifs_tcon *tcon,
                      const unsigned char *searchName,
                      FILE_UNIX_BASIC_INFO *pFindData,
                      const struct nls_table *nls_codepage, int remap)
@@ -4149,8 +3859,8 @@ UnixQPathInfoRetry:
 
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
                 name_len =
-                    cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
-                                       PATH_MAX, nls_codepage, remap);
+                    cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
+                                  PATH_MAX, nls_codepage, remap);
                 name_len++;     /* trailing null */
                 name_len *= 2;
         } else {        /* BB improve the check for buffer overruns BB */
@@ -4192,7 +3902,7 @@ UnixQPathInfoRetry:
                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
 
                 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
-                        cERROR(1, "Malformed FILE_UNIX_BASIC_INFO response. "
+                        cERROR(1, "Malformed FILE_UNIX_BASIC_INFO response.\n"
                                    "Unix Extensions can be disabled on mount "
                                    "by specifying the nosfu mount option.");
                         rc = -EIO;      /* bad smb */
@@ -4213,10 +3923,11 @@ UnixQPathInfoRetry:
 
 /* xid, tcon, searchName and codepage are input parms, rest are returned */
 int
-CIFSFindFirst(const unsigned int xid, struct cifs_tcon *tcon,
-              const char *searchName, struct cifs_sb_info *cifs_sb,
-              __u16 *pnetfid, __u16 search_flags,
-              struct cifs_search_info *psrch_inf, bool msearch)
+CIFSFindFirst(const int xid, struct cifs_tcon *tcon,
+              const char *searchName,
+              const struct nls_table *nls_codepage,
+              __u16 *pnetfid,
+              struct cifs_search_info *psrch_inf, int remap, const char dirsep)
 {
 /* level 257 SMB_ */
         TRANSACTION2_FFIRST_REQ *pSMB = NULL;
@@ -4224,9 +3935,8 @@ CIFSFindFirst(const unsigned int xid, struct cifs_tcon *tcon,
         T2_FFIRST_RSP_PARMS *parms;
         int rc = 0;
         int bytes_returned = 0;
-        int name_len, remap;
+        int name_len;
         __u16 params, byte_count;
-        struct nls_table *nls_codepage;
 
         cFYI(1, "In FindFirst for %s", searchName);
 
@@ -4236,46 +3946,39 @@ findFirstRetry:
         if (rc)
                 return rc;
 
-        nls_codepage = cifs_sb->local_nls;
-        remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
-
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
                 name_len =
-                    cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
-                                       PATH_MAX, nls_codepage, remap);
+                    cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
+                                 PATH_MAX, nls_codepage, remap);
                 /* We can not add the asterik earlier in case
                 it got remapped to 0xF03A as if it were part of the
                 directory name instead of a wildcard */
                 name_len *= 2;
-                if (msearch) {
-                        pSMB->FileName[name_len] = CIFS_DIR_SEP(cifs_sb);
-                        pSMB->FileName[name_len+1] = 0;
-                        pSMB->FileName[name_len+2] = '*';
-                        pSMB->FileName[name_len+3] = 0;
-                        name_len += 4; /* now the trailing null */
-                        /* null terminate just in case */
-                        pSMB->FileName[name_len] = 0;
-                        pSMB->FileName[name_len+1] = 0;
-                        name_len += 2;
-                }
+                pSMB->FileName[name_len] = dirsep;
+                pSMB->FileName[name_len+1] = 0;
+                pSMB->FileName[name_len+2] = '*';
+                pSMB->FileName[name_len+3] = 0;
+                name_len += 4; /* now the trailing null */
+                pSMB->FileName[name_len] = 0; /* null terminate just in case */
+                pSMB->FileName[name_len+1] = 0;
+                name_len += 2;
         } else {        /* BB add check for overrun of SMB buf BB */
                 name_len = strnlen(searchName, PATH_MAX);
 /* BB fix here and in unicode clause above ie
                 if (name_len > buffersize-header)
                         free buffer exit; BB */
                 strncpy(pSMB->FileName, searchName, name_len);
-                if (msearch) {
-                        pSMB->FileName[name_len] = CIFS_DIR_SEP(cifs_sb);
-                        pSMB->FileName[name_len+1] = '*';
-                        pSMB->FileName[name_len+2] = 0;
-                        name_len += 3;
-                }
+                pSMB->FileName[name_len] = dirsep;
+                pSMB->FileName[name_len+1] = '*';
+                pSMB->FileName[name_len+2] = 0;
+                name_len += 3;
         }
 
         params = 12 + name_len /* includes null */ ;
         pSMB->TotalDataCount = 0;       /* no EAs */
         pSMB->MaxParameterCount = cpu_to_le16(10);
-        pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
+        pSMB->MaxDataCount = cpu_to_le16((tcon->ses->server->maxBuf -
+                                          MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
         pSMB->MaxSetupCount = 0;
         pSMB->Reserved = 0;
         pSMB->Flags = 0;
@@ -4296,7 +3999,8 @@ findFirstRetry:
             cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
                         ATTR_DIRECTORY);
         pSMB->SearchCount = cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO));
-        pSMB->SearchFlags = cpu_to_le16(search_flags);
+        pSMB->SearchFlags = cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END |
+                CIFS_SEARCH_RETURN_RESUME);
         pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
 
         /* BB what should we set StorageType to? Does it matter? BB */
@@ -4306,7 +4010,7 @@ findFirstRetry:
 
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        cifs_stats_inc(&tcon->stats.cifs_stats.num_ffirst);
+        cifs_stats_inc(&tcon->num_ffirst);
 
         if (rc) {/* BB add logic to retry regular search if Unix search
                         rejected unexpectedly by server */
@@ -4348,7 +4052,8 @@ findFirstRetry:
                         psrch_inf->index_of_last_entry = 2 /* skip . and .. */ +
                                 psrch_inf->entries_in_buffer;
                         lnoff = le16_to_cpu(parms->LastNameOffset);
-                        if (CIFSMaxBufSize < lnoff) {
+                        if (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE <
+                              lnoff) {
                                 cERROR(1, "ignoring corrupt resume name");
                                 psrch_inf->last_entry = NULL;
                                 return rc;
@@ -4357,8 +4062,7 @@ findFirstRetry:
                         psrch_inf->last_entry = psrch_inf->srch_entries_start +
                                                         lnoff;
 
-                        if (pnetfid)
-                                *pnetfid = parms->SearchHandle;
+                        *pnetfid = parms->SearchHandle;
                 } else {
                         cifs_buf_release(pSMB);
                 }
@@ -4367,9 +4071,8 @@ findFirstRetry:
         return rc;
 }
 
-int CIFSFindNext(const unsigned int xid, struct cifs_tcon *tcon,
-                 __u16 searchHandle, __u16 search_flags,
-                 struct cifs_search_info *psrch_inf)
+int CIFSFindNext(const int xid, struct cifs_tcon *tcon,
+                 __u16 searchHandle, struct cifs_search_info *psrch_inf)
 {
         TRANSACTION2_FNEXT_REQ *pSMB = NULL;
         TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
@@ -4394,7 +4097,9 @@ int CIFSFindNext(const unsigned int xid, struct cifs_tcon *tcon,
         byte_count = 0;
         pSMB->TotalDataCount = 0;       /* no EAs */
         pSMB->MaxParameterCount = cpu_to_le16(8);
-        pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
+        pSMB->MaxDataCount =
+                cpu_to_le16((tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) &
+                                0xFFFFFF00);
         pSMB->MaxSetupCount = 0;
         pSMB->Reserved = 0;
         pSMB->Flags = 0;
@@ -4412,7 +4117,8 @@ int CIFSFindNext(const unsigned int xid, struct cifs_tcon *tcon,
                 cpu_to_le16(CIFSMaxBufSize / sizeof(FILE_UNIX_INFO));
         pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
         pSMB->ResumeKey = psrch_inf->resume_key;
-        pSMB->SearchFlags = cpu_to_le16(search_flags);
+        pSMB->SearchFlags =
+              cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME);
 
         name_len = psrch_inf->resume_name_len;
         params += name_len;
@@ -4434,7 +4140,7 @@ int CIFSFindNext(const unsigned int xid, struct cifs_tcon *tcon,
 
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        cifs_stats_inc(&tcon->stats.cifs_stats.num_fnext);
+        cifs_stats_inc(&tcon->num_fnext);
         if (rc) {
                 if (rc == -EBADF) {
                         psrch_inf->endOfSearch = true;
@@ -4475,7 +4181,8 @@ int CIFSFindNext(const unsigned int xid, struct cifs_tcon *tcon,
                         psrch_inf->index_of_last_entry +=
                                 psrch_inf->entries_in_buffer;
                         lnoff = le16_to_cpu(parms->LastNameOffset);
-                        if (CIFSMaxBufSize < lnoff) {
+                        if (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE <
+                              lnoff) {
                                 cERROR(1, "ignoring corrupt resume name");
                                 psrch_inf->last_entry = NULL;
                                 return rc;
@@ -4503,7 +4210,7 @@ FNext2_err_exit:
 }
 
 int
-CIFSFindClose(const unsigned int xid, struct cifs_tcon *tcon,
+CIFSFindClose(const int xid, struct cifs_tcon *tcon,
               const __u16 searchHandle)
 {
         int rc = 0;
@@ -4521,11 +4228,11 @@ CIFSFindClose(const unsigned int xid, struct cifs_tcon *tcon,
 
         pSMB->FileID = searchHandle;
         pSMB->ByteCount = 0;
-        rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
+        rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
         if (rc)
                 cERROR(1, "Send error in FindClose = %d", rc);
 
-        cifs_stats_inc(&tcon->stats.cifs_stats.num_fclose);
+        cifs_stats_inc(&tcon->num_fclose);
 
         /* Since session is dead, search handle closed on server already */
         if (rc == -EAGAIN)
@@ -4535,8 +4242,9 @@ CIFSFindClose(const unsigned int xid, struct cifs_tcon *tcon,
 }
 
 int
-CIFSGetSrvInodeNumber(const unsigned int xid, struct cifs_tcon *tcon,
-                      const char *search_name, __u64 *inode_number,
+CIFSGetSrvInodeNumber(const int xid, struct cifs_tcon *tcon,
+                      const unsigned char *searchName,
+                      __u64 *inode_number,
                       const struct nls_table *nls_codepage, int remap)
 {
         int rc = 0;
@@ -4545,7 +4253,7 @@ CIFSGetSrvInodeNumber(const unsigned int xid, struct cifs_tcon *tcon,
         int name_len, bytes_returned;
         __u16 params, byte_count;
 
-        cFYI(1, "In GetSrvInodeNum for %s", search_name);
+        cFYI(1, "In GetSrvInodeNum for %s", searchName);
         if (tcon == NULL)
                 return -ENODEV;
 
@@ -4557,15 +4265,14 @@ GetInodeNumberRetry:
 
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
                 name_len =
-                        cifsConvertToUTF16((__le16 *) pSMB->FileName,
-                                           search_name, PATH_MAX, nls_codepage,
-                                           remap);
+                        cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
+                                         PATH_MAX, nls_codepage, remap);
                 name_len++;     /* trailing null */
                 name_len *= 2;
         } else {        /* BB improve the check for buffer overruns BB */
-                name_len = strnlen(search_name, PATH_MAX);
+                name_len = strnlen(searchName, PATH_MAX);
                 name_len++;     /* trailing null */
-                strncpy(pSMB->FileName, search_name, name_len);
+                strncpy(pSMB->FileName, searchName, name_len);
         }
 
         params = 2 /* level */  + 4 /* rsrvd */  + name_len /* incl null */ ;
@@ -4653,7 +4360,7 @@ parse_DFS_referrals(TRANSACTION2_GET_DFS_REFER_RSP *pSMBr,
 
         if (*num_of_nodes < 1) {
                 cERROR(1, "num_referrals: must be at least > 0,"
-                        "but we get num_referrals = %d", *num_of_nodes);
+                        "but we get num_referrals = %d\n", *num_of_nodes);
                 rc = -EINVAL;
                 goto parse_DFS_referrals_exit;
         }
@@ -4670,14 +4377,14 @@ parse_DFS_referrals(TRANSACTION2_GET_DFS_REFER_RSP *pSMBr,
         data_end = (char *)(&(pSMBr->PathConsumed)) +
                                 le16_to_cpu(pSMBr->t2.DataCount);
 
-        cFYI(1, "num_referrals: %d dfs flags: 0x%x ...",
+        cFYI(1, "num_referrals: %d dfs flags: 0x%x ...\n",
                         *num_of_nodes,
                         le32_to_cpu(pSMBr->DFSFlags));
 
         *target_nodes = kzalloc(sizeof(struct dfs_info3_param) *
                         *num_of_nodes, GFP_KERNEL);
         if (*target_nodes == NULL) {
-                cERROR(1, "Failed to allocate buffer for target_nodes");
+                cERROR(1, "Failed to allocate buffer for target_nodes\n");
                 rc = -ENOMEM;
                 goto parse_DFS_referrals_exit;
         }
@@ -4696,9 +4403,9 @@ parse_DFS_referrals(TRANSACTION2_GET_DFS_REFER_RSP *pSMBr,
                                 rc = -ENOMEM;
                                 goto parse_DFS_referrals_exit;
                         }
-                        cifsConvertToUTF16((__le16 *) tmp, searchName,
-                                           PATH_MAX, nls_codepage, remap);
-                        node->path_consumed = cifs_utf16_bytes(tmp,
+                        cifsConvertToUCS((__le16 *) tmp, searchName,
+                                        PATH_MAX, nls_codepage, remap);
+                        node->path_consumed = cifs_ucs2_bytes(tmp,
                                         le16_to_cpu(pSMBr->PathConsumed),
                                         nls_codepage);
                         kfree(tmp);
@@ -4711,8 +4418,8 @@ parse_DFS_referrals(TRANSACTION2_GET_DFS_REFER_RSP *pSMBr,
                 /* copy DfsPath */
                 temp = (char *)ref + le16_to_cpu(ref->DfsPathOffset);
                 max_len = data_end - temp;
-                node->path_name = cifs_strndup_from_utf16(temp, max_len,
-                                                is_unicode, nls_codepage);
+                node->path_name = cifs_strndup_from_ucs(temp, max_len,
+                                                      is_unicode, nls_codepage);
                 if (!node->path_name) {
                         rc = -ENOMEM;
                         goto parse_DFS_referrals_exit;
@@ -4721,14 +4428,10 @@ parse_DFS_referrals(TRANSACTION2_GET_DFS_REFER_RSP *pSMBr,
                 /* copy link target UNC */
                 temp = (char *)ref + le16_to_cpu(ref->NetworkAddressOffset);
                 max_len = data_end - temp;
-                node->node_name = cifs_strndup_from_utf16(temp, max_len,
-                                                is_unicode, nls_codepage);
-                if (!node->node_name) {
+                node->node_name = cifs_strndup_from_ucs(temp, max_len,
+                                                      is_unicode, nls_codepage);
+                if (!node->node_name)
                         rc = -ENOMEM;
-                        goto parse_DFS_referrals_exit;
-                }
-
-                ref++;
         }
 
 parse_DFS_referrals_exit:
@@ -4741,8 +4444,9 @@ parse_DFS_referrals_exit:
 }
 
 int
-CIFSGetDFSRefer(const unsigned int xid, struct cifs_ses *ses,
-                const char *search_name, struct dfs_info3_param **target_nodes,
+CIFSGetDFSRefer(const int xid, struct cifs_ses *ses,
+                const unsigned char *searchName,
+                struct dfs_info3_param **target_nodes,
                 unsigned int *num_of_nodes,
                 const struct nls_table *nls_codepage, int remap)
 {
@@ -4756,7 +4460,7 @@ CIFSGetDFSRefer(const unsigned int xid, struct cifs_ses *ses,
         *num_of_nodes = 0;
         *target_nodes = NULL;
 
-        cFYI(1, "In GetDFSRefer the path %s", search_name);
+        cFYI(1, "In GetDFSRefer the path %s", searchName);
         if (ses == NULL)
                 return -ENODEV;
 getDFSRetry:
@@ -4767,7 +4471,7 @@ getDFSRetry:
 
         /* server pointer checked in called function,
         but should never be null here anyway */
-        pSMB->hdr.Mid = get_next_mid(ses->server);
+        pSMB->hdr.Mid = GetNextMid(ses->server);
         pSMB->hdr.Tid = ses->ipc_tid;
         pSMB->hdr.Uid = ses->Suid;
         if (ses->capabilities & CAP_STATUS32)
@@ -4778,15 +4482,14 @@ getDFSRetry:
         if (ses->capabilities & CAP_UNICODE) {
                 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
                 name_len =
-                    cifsConvertToUTF16((__le16 *) pSMB->RequestFileName,
-                                       search_name, PATH_MAX, nls_codepage,
-                                       remap);
+                    cifsConvertToUCS((__le16 *) pSMB->RequestFileName,
+                                     searchName, PATH_MAX, nls_codepage, remap);
                 name_len++;     /* trailing null */
                 name_len *= 2;
         } else {        /* BB improve the check for buffer overruns BB */
-                name_len = strnlen(search_name, PATH_MAX);
+                name_len = strnlen(searchName, PATH_MAX);
                 name_len++;     /* trailing null */
-                strncpy(pSMB->RequestFileName, search_name, name_len);
+                strncpy(pSMB->RequestFileName, searchName, name_len);
         }
 
         if (ses->server) {
@@ -4842,7 +4545,7 @@ getDFSRetry:
         /* parse returned result into more usable form */
         rc = parse_DFS_referrals(pSMBr, num_of_nodes,
                                  target_nodes, nls_codepage, remap,
-                                 search_name);
+                                 searchName);
 
 GetDFSRefExit:
         cifs_buf_release(pSMB);
@@ -4855,8 +4558,7 @@ GetDFSRefExit:
 
 /* Query File System Info such as free space to old servers such as Win 9x */
 int
-SMBOldQFSInfo(const unsigned int xid, struct cifs_tcon *tcon,
-              struct kstatfs *FSData)
+SMBOldQFSInfo(const int xid, struct cifs_tcon *tcon, struct kstatfs *FSData)
 {
 /* level 0x01 SMB_QUERY_FILE_SYSTEM_INFO */
         TRANSACTION2_QFSI_REQ *pSMB = NULL;
@@ -4935,8 +4637,7 @@ oldQFSInfoRetry:
 }
 
 int
-CIFSSMBQFSInfo(const unsigned int xid, struct cifs_tcon *tcon,
-               struct kstatfs *FSData)
+CIFSSMBQFSInfo(const int xid, struct cifs_tcon *tcon, struct kstatfs *FSData)
 {
 /* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
         TRANSACTION2_QFSI_REQ *pSMB = NULL;
@@ -5015,7 +4716,7 @@ QFSInfoRetry:
 }
 
 int
-CIFSSMBQFSAttributeInfo(const unsigned int xid, struct cifs_tcon *tcon)
+CIFSSMBQFSAttributeInfo(const int xid, struct cifs_tcon *tcon)
 {
 /* level 0x105  SMB_QUERY_FILE_SYSTEM_INFO */
         TRANSACTION2_QFSI_REQ *pSMB = NULL;
@@ -5085,7 +4786,7 @@ QFSAttributeRetry:
 }
 
 int
-CIFSSMBQFSDeviceInfo(const unsigned int xid, struct cifs_tcon *tcon)
+CIFSSMBQFSDeviceInfo(const int xid, struct cifs_tcon *tcon)
 {
 /* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
         TRANSACTION2_QFSI_REQ *pSMB = NULL;
@@ -5156,7 +4857,7 @@ QFSDeviceRetry:
 }
 
 int
-CIFSSMBQFSUnixInfo(const unsigned int xid, struct cifs_tcon *tcon)
+CIFSSMBQFSUnixInfo(const int xid, struct cifs_tcon *tcon)
 {
 /* level 0x200  SMB_QUERY_CIFS_UNIX_INFO */
         TRANSACTION2_QFSI_REQ *pSMB = NULL;
@@ -5226,7 +4927,7 @@ QFSUnixRetry:
 }
 
 int
-CIFSSMBSetFSUnixInfo(const unsigned int xid, struct cifs_tcon *tcon, __u64 cap)
+CIFSSMBSetFSUnixInfo(const int xid, struct cifs_tcon *tcon, __u64 cap)
 {
 /* level 0x200  SMB_SET_CIFS_UNIX_INFO */
         TRANSACTION2_SETFSI_REQ *pSMB = NULL;
@@ -5300,7 +5001,7 @@ SETFSUnixRetry:
 
 
 int
-CIFSSMBQFSPosixInfo(const unsigned int xid, struct cifs_tcon *tcon,
+CIFSSMBQFSPosixInfo(const int xid, struct cifs_tcon *tcon,
                    struct kstatfs *FSData)
 {
 /* level 0x201  SMB_QUERY_CIFS_POSIX_INFO */
@@ -5386,16 +5087,16 @@ QFSPosixRetry:
 }
 
 
-/*
- * We can not use write of zero bytes trick to set file size due to need for
- * large file support. Also note that this SetPathInfo is preferred to
- * SetFileInfo based method in next routine which is only needed to work around
- * a sharing violation bugin Samba which this routine can run into.
- */
+/* We can not use write of zero bytes trick to
+   set file size due to need for large file support.  Also note that
+   this SetPathInfo is preferred to SetFileInfo based method in next
+   routine which is only needed to work around a sharing violation bug
+   in Samba which this routine can run into */
+
 int
-CIFSSMBSetEOF(const unsigned int xid, struct cifs_tcon *tcon,
-              const char *file_name, __u64 size, struct cifs_sb_info *cifs_sb,
-              bool set_allocation)
+CIFSSMBSetEOF(const int xid, struct cifs_tcon *tcon, const char *fileName,
+              __u64 size, bool SetAllocation,
+              const struct nls_table *nls_codepage, int remap)
 {
         struct smb_com_transaction2_spi_req *pSMB = NULL;
         struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
@@ -5403,8 +5104,6 @@ CIFSSMBSetEOF(const unsigned int xid, struct cifs_tcon *tcon,
         int name_len;
         int rc = 0;
         int bytes_returned = 0;
-        int remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
-
         __u16 params, byte_count, data_count, param_offset, offset;
 
         cFYI(1, "In SetEOF");
@@ -5416,14 +5115,14 @@ SetEOFRetry:
 
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
                 name_len =
-                    cifsConvertToUTF16((__le16 *) pSMB->FileName, file_name,
-                                       PATH_MAX, cifs_sb->local_nls, remap);
+                    cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
+                                     PATH_MAX, nls_codepage, remap);
                 name_len++;     /* trailing null */
                 name_len *= 2;
         } else {        /* BB improve the check for buffer overruns BB */
-                name_len = strnlen(file_name, PATH_MAX);
+                name_len = strnlen(fileName, PATH_MAX);
                 name_len++;     /* trailing null */
-                strncpy(pSMB->FileName, file_name, name_len);
+                strncpy(pSMB->FileName, fileName, name_len);
         }
         params = 6 + name_len;
         data_count = sizeof(struct file_end_of_file_info);
@@ -5437,7 +5136,7 @@ SetEOFRetry:
         param_offset = offsetof(struct smb_com_transaction2_spi_req,
                                 InformationLevel) - 4;
         offset = param_offset + params;
-        if (set_allocation) {
+        if (SetAllocation) {
                 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
                         pSMB->InformationLevel =
                                 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
@@ -5484,8 +5183,8 @@ SetEOFRetry:
 }
 
 int
-CIFSSMBSetFileSize(const unsigned int xid, struct cifs_tcon *tcon,
-                   struct cifsFileInfo *cfile, __u64 size, bool set_allocation)
+CIFSSMBSetFileSize(const int xid, struct cifs_tcon *tcon, __u64 size,
+                   __u16 fid, __u32 pid_of_opener, bool SetAllocation)
 {
         struct smb_com_transaction2_sfi_req *pSMB  = NULL;
         struct file_end_of_file_info *parm_data;
@@ -5499,8 +5198,8 @@ CIFSSMBSetFileSize(const unsigned int xid, struct cifs_tcon *tcon,
         if (rc)
                 return rc;
 
-        pSMB->hdr.Pid = cpu_to_le16((__u16)cfile->pid);
-        pSMB->hdr.PidHigh = cpu_to_le16((__u16)(cfile->pid >> 16));
+        pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
+        pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
 
         params = 6;
         pSMB->MaxSetupCount = 0;
@@ -5529,8 +5228,8 @@ CIFSSMBSetFileSize(const unsigned int xid, struct cifs_tcon *tcon,
                                 + offset);
         pSMB->DataOffset = cpu_to_le16(offset);
         parm_data->FileSize = cpu_to_le64(size);
-        pSMB->Fid = cfile->fid.netfid;
-        if (set_allocation) {
+        pSMB->Fid = fid;
+        if (SetAllocation) {
                 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
                         pSMB->InformationLevel =
                                 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
@@ -5548,7 +5247,7 @@ CIFSSMBSetFileSize(const unsigned int xid, struct cifs_tcon *tcon,
         pSMB->Reserved4 = 0;
         inc_rfc1001_len(pSMB, byte_count);
         pSMB->ByteCount = cpu_to_le16(byte_count);
-        rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
+        rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
         if (rc) {
                 cFYI(1, "Send error in SetFileInfo (SetFileSize) = %d", rc);
         }
@@ -5566,7 +5265,7 @@ CIFSSMBSetFileSize(const unsigned int xid, struct cifs_tcon *tcon,
    time and resort to the original setpathinfo level which takes the ancient
    DOS time format with 2 second granularity */
 int
-CIFSSMBSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
+CIFSSMBSetFileInfo(const int xid, struct cifs_tcon *tcon,
                     const FILE_BASIC_INFO *data, __u16 fid, __u32 pid_of_opener)
 {
         struct smb_com_transaction2_sfi_req *pSMB  = NULL;
@@ -5592,8 +5291,7 @@ CIFSSMBSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
         param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
         offset = param_offset + params;
 
-        data_offset = (char *)pSMB +
-                        offsetof(struct smb_hdr, Protocol) + offset;
+        data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
 
         count = sizeof(FILE_BASIC_INFO);
         pSMB->MaxParameterCount = cpu_to_le16(2);
@@ -5618,7 +5316,7 @@ CIFSSMBSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
         inc_rfc1001_len(pSMB, byte_count);
         pSMB->ByteCount = cpu_to_le16(byte_count);
         memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
-        rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
+        rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
         if (rc)
                 cFYI(1, "Send error in Set Time (SetFileInfo) = %d", rc);
 
@@ -5629,7 +5327,7 @@ CIFSSMBSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
 }
 
 int
-CIFSSMBSetFileDisposition(const unsigned int xid, struct cifs_tcon *tcon,
+CIFSSMBSetFileDisposition(const int xid, struct cifs_tcon *tcon,
                           bool delete_file, __u16 fid, __u32 pid_of_opener)
 {
         struct smb_com_transaction2_sfi_req *pSMB  = NULL;
@@ -5677,7 +5375,7 @@ CIFSSMBSetFileDisposition(const unsigned int xid, struct cifs_tcon *tcon,
         inc_rfc1001_len(pSMB, byte_count);
         pSMB->ByteCount = cpu_to_le16(byte_count);
         *data_offset = delete_file ? 1 : 0;
-        rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
+        rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
         if (rc)
                 cFYI(1, "Send error in SetFileDisposition = %d", rc);
 
@@ -5685,7 +5383,7 @@ CIFSSMBSetFileDisposition(const unsigned int xid, struct cifs_tcon *tcon,
 }
 
 int
-CIFSSMBSetPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
+CIFSSMBSetPathInfo(const int xid, struct cifs_tcon *tcon,
                    const char *fileName, const FILE_BASIC_INFO *data,
                    const struct nls_table *nls_codepage, int remap)
 {
@@ -5707,8 +5405,8 @@ SetTimesRetry:
 
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
                 name_len =
-                    cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
-                                       PATH_MAX, nls_codepage, remap);
+                    cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
+                                     PATH_MAX, nls_codepage, remap);
                 name_len++;     /* trailing null */
                 name_len *= 2;
         } else {        /* BB improve the check for buffer overruns BB */
@@ -5769,7 +5467,7 @@ SetTimesRetry:
           handling it anyway and NT4 was what we thought it would be needed for
           Do not delete it until we prove whether needed for Win9x though */
 int
-CIFSSMBSetAttrLegacy(unsigned int xid, struct cifs_tcon *tcon, char *fileName,
+CIFSSMBSetAttrLegacy(int xid, struct cifs_tcon *tcon, char *fileName,
                 __u16 dos_attrs, const struct nls_table *nls_codepage)
 {
         SETATTR_REQ *pSMB = NULL;
@@ -5788,8 +5486,8 @@ SetAttrLgcyRetry:
 
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
                 name_len =
-                        ConvertToUTF16((__le16 *) pSMB->fileName, fileName,
-                                       PATH_MAX, nls_codepage);
+                        ConvertToUCS((__le16 *) pSMB->fileName, fileName,
+                                PATH_MAX, nls_codepage);
                 name_len++;     /* trailing null */
                 name_len *= 2;
         } else {        /* BB improve the check for buffer overruns BB */
@@ -5857,12 +5555,12 @@ cifs_fill_unix_set_info(FILE_UNIX_BASIC_INFO *data_offset,
 }
 
 int
-CIFSSMBUnixSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
+CIFSSMBUnixSetFileInfo(const int xid, struct cifs_tcon *tcon,
                        const struct cifs_unix_set_info_args *args,
                        u16 fid, u32 pid_of_opener)
 {
         struct smb_com_transaction2_sfi_req *pSMB  = NULL;
-        char *data_offset;
+        FILE_UNIX_BASIC_INFO *data_offset;
         int rc = 0;
         u16 params, param_offset, offset, byte_count, count;
 
@@ -5884,9 +5582,8 @@ CIFSSMBUnixSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
         param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
         offset = param_offset + params;
 
-        data_offset = (char *)pSMB +
-                        offsetof(struct smb_hdr, Protocol) + offset;
-
+        data_offset = (FILE_UNIX_BASIC_INFO *)
+                                ((char *)(&pSMB->hdr.Protocol) + offset);
         count = sizeof(FILE_UNIX_BASIC_INFO);
 
         pSMB->MaxParameterCount = cpu_to_le16(2);
@@ -5908,9 +5605,9 @@ CIFSSMBUnixSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
         inc_rfc1001_len(pSMB, byte_count);
         pSMB->ByteCount = cpu_to_le16(byte_count);
 
-        cifs_fill_unix_set_info((FILE_UNIX_BASIC_INFO *)data_offset, args);
+        cifs_fill_unix_set_info(data_offset, args);
 
-        rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
+        rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
         if (rc)
                 cFYI(1, "Send error in Set Time (SetFileInfo) = %d", rc);
 
@@ -5921,8 +5618,7 @@ CIFSSMBUnixSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
 }
 
 int
-CIFSSMBUnixSetPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
-                       const char *file_name,
+CIFSSMBUnixSetPathInfo(const int xid, struct cifs_tcon *tcon, char *fileName,
                        const struct cifs_unix_set_info_args *args,
                        const struct nls_table *nls_codepage, int remap)
 {
@@ -5943,14 +5639,14 @@ setPermsRetry:
 
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
                 name_len =
-                    cifsConvertToUTF16((__le16 *) pSMB->FileName, file_name,
-                                       PATH_MAX, nls_codepage, remap);
+                    cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
+                                     PATH_MAX, nls_codepage, remap);
                 name_len++;     /* trailing null */
                 name_len *= 2;
         } else {        /* BB improve the check for buffer overruns BB */
-                name_len = strnlen(file_name, PATH_MAX);
+                name_len = strnlen(fileName, PATH_MAX);
                 name_len++;     /* trailing null */
-                strncpy(pSMB->FileName, file_name, name_len);
+                strncpy(pSMB->FileName, fileName, name_len);
         }
 
         params = 6 + name_len;
@@ -6009,7 +5705,7 @@ setPermsRetry:
  * the data isn't copied to it, but the length is returned.
  */
 ssize_t
-CIFSSMBQAllEAs(const unsigned int xid, struct cifs_tcon *tcon,
+CIFSSMBQAllEAs(const int xid, struct cifs_tcon *tcon,
                 const unsigned char *searchName, const unsigned char *ea_name,
                 char *EAData, size_t buf_size,
                 const struct nls_table *nls_codepage, int remap)
@@ -6036,8 +5732,8 @@ QAllEAsRetry:
 
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
                 list_len =
-                    cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
-                                       PATH_MAX, nls_codepage, remap);
+                    cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
+                                     PATH_MAX, nls_codepage, remap);
                 list_len++;     /* trailing null */
                 list_len *= 2;
         } else {        /* BB improve the check for buffer overruns BB */
@@ -6144,7 +5840,7 @@ QAllEAsRetry:
 
                 if (ea_name) {
                         if (ea_name_len == name_len &&
-                            memcmp(ea_name, temp_ptr, name_len) == 0) {
+                            strncmp(ea_name, temp_ptr, name_len) == 0) {
                                 temp_ptr += name_len + 1;
                                 rc = value_len;
                                 if (buf_size == 0)
@@ -6192,8 +5888,8 @@ QAllEAsOut:
 }
 
 int
-CIFSSMBSetEA(const unsigned int xid, struct cifs_tcon *tcon,
-             const char *fileName, const char *ea_name, const void *ea_value,
+CIFSSMBSetEA(const int xid, struct cifs_tcon *tcon, const char *fileName,
+             const char *ea_name, const void *ea_value,
              const __u16 ea_value_len, const struct nls_table *nls_codepage,
              int remap)
 {
@@ -6214,8 +5910,8 @@ SetEARetry:
 
         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
                 name_len =
-                    cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
-                                       PATH_MAX, nls_codepage, remap);
+                    cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
+                                     PATH_MAX, nls_codepage, remap);
                 name_len++;     /* trailing null */
                 name_len *= 2;
         } else {        /* BB improve the check for buffer overruns BB */
@@ -6319,7 +6015,7 @@ SetEARetry:
  *      incompatible for network fs clients, we could instead simply
  *      expose this config flag by adding a future cifs (and smb2) notify ioctl.
  */
-int CIFSSMBNotify(const unsigned int xid, struct cifs_tcon *tcon,
+int CIFSSMBNotify(const int xid, struct cifs_tcon *tcon,
                   const int notify_subdirs, const __u16 netfid,
                   __u32 filter, struct file *pfile, int multishot,
                   const struct nls_table *nls_codepage)
@@ -6339,7 +6035,12 @@ int CIFSSMBNotify(const unsigned int xid, struct cifs_tcon *tcon,
         pSMB->TotalParameterCount = 0 ;
         pSMB->TotalDataCount = 0;
         pSMB->MaxParameterCount = cpu_to_le32(2);
-        pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
+        /* BB find exact data count max from sess structure BB */
+        pSMB->MaxDataCount = 0; /* same in little endian or be */
+/* BB VERIFY verify which is correct for above BB */
+        pSMB->MaxDataCount = cpu_to_le32((tcon->ses->server->maxBuf -
+                                             MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
+
         pSMB->MaxSetupCount = 4;
         pSMB->Reserved = 0;
         pSMB->ParameterOffset = 0;
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index 17c3643e595..28bba5791d9 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -1,7 +1,7 @@
 /*
  *   fs/cifs/connect.c
  *
- *   Copyright (C) International Business Machines  Corp., 2002,2011
+ *   Copyright (C) International Business Machines  Corp., 2002,2009
  *   Author(s): Steve French (sfrench@us.ibm.com)
  *
  *   This library is free software; you can redistribute it and/or modify
@@ -37,11 +37,7 @@
 #include <asm/uaccess.h>
 #include <asm/processor.h>
 #include <linux/inet.h>
-#include <linux/module.h>
-#include <keys/user-type.h>
 #include <net/ipv6.h>
-#include <linux/parser.h>
-
 #include "cifspdu.h"
 #include "cifsglob.h"
 #include "cifsproto.h"
@@ -56,230 +52,15 @@
 #define CIFS_PORT 445
 #define RFC1001_PORT 139
 
+/* SMB echo "timeout" -- FIXME: tunable? */
+#define SMB_ECHO_INTERVAL (60 * HZ)
+
 extern mempool_t *cifs_req_poolp;
 
 /* FIXME: should these be tunable? */
 #define TLINK_ERROR_EXPIRE      (1 * HZ)
 #define TLINK_IDLE_EXPIRE       (600 * HZ)
 
-enum {
-
-        /* Mount options that take no arguments */
-        Opt_user_xattr, Opt_nouser_xattr,
-        Opt_forceuid, Opt_noforceuid,
-        Opt_forcegid, Opt_noforcegid,
-        Opt_noblocksend, Opt_noautotune,
-        Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
-        Opt_mapchars, Opt_nomapchars, Opt_sfu,
-        Opt_nosfu, Opt_nodfs, Opt_posixpaths,
-        Opt_noposixpaths, Opt_nounix,
-        Opt_nocase,
-        Opt_brl, Opt_nobrl,
-        Opt_forcemandatorylock, Opt_setuids,
-        Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
-        Opt_nohard, Opt_nosoft,
-        Opt_nointr, Opt_intr,
-        Opt_nostrictsync, Opt_strictsync,
-        Opt_serverino, Opt_noserverino,
-        Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
-        Opt_acl, Opt_noacl, Opt_locallease,
-        Opt_sign, Opt_seal, Opt_noac,
-        Opt_fsc, Opt_mfsymlinks,
-        Opt_multiuser, Opt_sloppy,
-
-        /* Mount options which take numeric value */
-        Opt_backupuid, Opt_backupgid, Opt_uid,
-        Opt_cruid, Opt_gid, Opt_file_mode,
-        Opt_dirmode, Opt_port,
-        Opt_rsize, Opt_wsize, Opt_actimeo,
-
-        /* Mount options which take string value */
-        Opt_user, Opt_pass, Opt_ip,
-        Opt_unc, Opt_domain,
-        Opt_srcaddr, Opt_prefixpath,
-        Opt_iocharset, Opt_sockopt,
-        Opt_netbiosname, Opt_servern,
-        Opt_ver, Opt_vers, Opt_sec, Opt_cache,
-
-        /* Mount options to be ignored */
-        Opt_ignore,
-
-        /* Options which could be blank */
-        Opt_blank_pass,
-        Opt_blank_user,
-        Opt_blank_ip,
-
-        Opt_err
-};
-
-static const match_table_t cifs_mount_option_tokens = {
-
-        { Opt_user_xattr, "user_xattr" },
-        { Opt_nouser_xattr, "nouser_xattr" },
-        { Opt_forceuid, "forceuid" },
-        { Opt_noforceuid, "noforceuid" },
-        { Opt_forcegid, "forcegid" },
-        { Opt_noforcegid, "noforcegid" },
-        { Opt_noblocksend, "noblocksend" },
-        { Opt_noautotune, "noautotune" },
-        { Opt_hard, "hard" },
-        { Opt_soft, "soft" },
-        { Opt_perm, "perm" },
-        { Opt_noperm, "noperm" },
-        { Opt_mapchars, "mapchars" },
-        { Opt_nomapchars, "nomapchars" },
-        { Opt_sfu, "sfu" },
-        { Opt_nosfu, "nosfu" },
-        { Opt_nodfs, "nodfs" },
-        { Opt_posixpaths, "posixpaths" },
-        { Opt_noposixpaths, "noposixpaths" },
-        { Opt_nounix, "nounix" },
-        { Opt_nounix, "nolinux" },
-        { Opt_nocase, "nocase" },
-        { Opt_nocase, "ignorecase" },
-        { Opt_brl, "brl" },
-        { Opt_nobrl, "nobrl" },
-        { Opt_nobrl, "nolock" },
-        { Opt_forcemandatorylock, "forcemandatorylock" },
-        { Opt_forcemandatorylock, "forcemand" },
-        { Opt_setuids, "setuids" },
-        { Opt_nosetuids, "nosetuids" },
-        { Opt_dynperm, "dynperm" },
-        { Opt_nodynperm, "nodynperm" },
-        { Opt_nohard, "nohard" },
-        { Opt_nosoft, "nosoft" },
-        { Opt_nointr, "nointr" },
-        { Opt_intr, "intr" },
-        { Opt_nostrictsync, "nostrictsync" },
-        { Opt_strictsync, "strictsync" },
-        { Opt_serverino, "serverino" },
-        { Opt_noserverino, "noserverino" },
-        { Opt_rwpidforward, "rwpidforward" },
-        { Opt_cifsacl, "cifsacl" },
-        { Opt_nocifsacl, "nocifsacl" },
-        { Opt_acl, "acl" },
-        { Opt_noacl, "noacl" },
-        { Opt_locallease, "locallease" },
-        { Opt_sign, "sign" },
-        { Opt_seal, "seal" },
-        { Opt_noac, "noac" },
-        { Opt_fsc, "fsc" },
-        { Opt_mfsymlinks, "mfsymlinks" },
-        { Opt_multiuser, "multiuser" },
-        { Opt_sloppy, "sloppy" },
-
-        { Opt_backupuid, "backupuid=%s" },
-        { Opt_backupgid, "backupgid=%s" },
-        { Opt_uid, "uid=%s" },
-        { Opt_cruid, "cruid=%s" },
-        { Opt_gid, "gid=%s" },
-        { Opt_file_mode, "file_mode=%s" },
-        { Opt_dirmode, "dirmode=%s" },
-        { Opt_dirmode, "dir_mode=%s" },
-        { Opt_port, "port=%s" },
-        { Opt_rsize, "rsize=%s" },
-        { Opt_wsize, "wsize=%s" },
-        { Opt_actimeo, "actimeo=%s" },
-
-        { Opt_blank_user, "user=" },
-        { Opt_blank_user, "username=" },
-        { Opt_user, "user=%s" },
-        { Opt_user, "username=%s" },
-        { Opt_blank_pass, "pass=" },
-        { Opt_blank_pass, "password=" },
-        { Opt_pass, "pass=%s" },
-        { Opt_pass, "password=%s" },
-        { Opt_blank_ip, "ip=" },
-        { Opt_blank_ip, "addr=" },
-        { Opt_ip, "ip=%s" },
-        { Opt_ip, "addr=%s" },
-        { Opt_unc, "unc=%s" },
-        { Opt_unc, "target=%s" },
-        { Opt_unc, "path=%s" },
-        { Opt_domain, "dom=%s" },
-        { Opt_domain, "domain=%s" },
-        { Opt_domain, "workgroup=%s" },
-        { Opt_srcaddr, "srcaddr=%s" },
-        { Opt_prefixpath, "prefixpath=%s" },
-        { Opt_iocharset, "iocharset=%s" },
-        { Opt_sockopt, "sockopt=%s" },
-        { Opt_netbiosname, "netbiosname=%s" },
-        { Opt_servern, "servern=%s" },
-        { Opt_ver, "ver=%s" },
-        { Opt_vers, "vers=%s" },
-        { Opt_sec, "sec=%s" },
-        { Opt_cache, "cache=%s" },
-
-        { Opt_ignore, "cred" },
-        { Opt_ignore, "credentials" },
-        { Opt_ignore, "cred=%s" },
-        { Opt_ignore, "credentials=%s" },
-        { Opt_ignore, "guest" },
-        { Opt_ignore, "rw" },
-        { Opt_ignore, "ro" },
-        { Opt_ignore, "suid" },
-        { Opt_ignore, "nosuid" },
-        { Opt_ignore, "exec" },
-        { Opt_ignore, "noexec" },
-        { Opt_ignore, "nodev" },
-        { Opt_ignore, "noauto" },
-        { Opt_ignore, "dev" },
-        { Opt_ignore, "mand" },
-        { Opt_ignore, "nomand" },
-        { Opt_ignore, "_netdev" },
-
-        { Opt_err, NULL }
-};
-
-enum {
-        Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
-        Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
-        Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
-        Opt_sec_ntlmv2i, Opt_sec_lanman,
-        Opt_sec_none,
-
-        Opt_sec_err
-};
-
-static const match_table_t cifs_secflavor_tokens = {
-        { Opt_sec_krb5, "krb5" },
-        { Opt_sec_krb5i, "krb5i" },
-        { Opt_sec_krb5p, "krb5p" },
-        { Opt_sec_ntlmsspi, "ntlmsspi" },
-        { Opt_sec_ntlmssp, "ntlmssp" },
-        { Opt_ntlm, "ntlm" },
-        { Opt_sec_ntlmi, "ntlmi" },
-        { Opt_sec_ntlmv2, "nontlm" },
-        { Opt_sec_ntlmv2, "ntlmv2" },
-        { Opt_sec_ntlmv2i, "ntlmv2i" },
-        { Opt_sec_lanman, "lanman" },
-        { Opt_sec_none, "none" },
-
-        { Opt_sec_err, NULL }
-};
-
-/* cache flavors */
-enum {
-        Opt_cache_loose,
-        Opt_cache_strict,
-        Opt_cache_none,
-        Opt_cache_err
-};
-
-static const match_table_t cifs_cacheflavor_tokens = {
-        { Opt_cache_loose, "loose" },
-        { Opt_cache_strict, "strict" },
-        { Opt_cache_none, "none" },
-        { Opt_cache_err, NULL }
-};
-
-static const match_table_t cifs_smb_version_tokens = {
-        { Smb_1, SMB1_VERSION_STRING },
-        { Smb_20, SMB20_VERSION_STRING},
-        { Smb_21, SMB21_VERSION_STRING },
-        { Smb_30, SMB30_VERSION_STRING },
-};
-
 static int ip_connect(struct TCP_Server_Info *server);
 static int generic_ip_connect(struct TCP_Server_Info *server);
 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
@@ -295,7 +76,7 @@ static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
  * reconnect tcp session
  * wake up waiters on reconnection? - (not needed currently)
  */
-int
+static int
 cifs_reconnect(struct TCP_Server_Info *server)
 {
         int rc = 0;
@@ -315,9 +96,6 @@ cifs_reconnect(struct TCP_Server_Info *server)
                 server->tcpStatus = CifsNeedReconnect;
         spin_unlock(&GlobalMid_Lock);
         server->maxBuf = 0;
-#ifdef CONFIG_CIFS_SMB2
-        server->max_read = 0;
-#endif
 
         cFYI(1, "Reconnecting tcp session");
 
@@ -363,8 +141,8 @@ cifs_reconnect(struct TCP_Server_Info *server)
         spin_lock(&GlobalMid_Lock);
         list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
-                if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
-                        mid_entry->mid_state = MID_RETRY_NEEDED;
+                if (mid_entry->midState == MID_REQUEST_SUBMITTED)
+                        mid_entry->midState = MID_RETRY_NEEDED;
                 list_move(&mid_entry->qhead, &retry_list);
         }
         spin_unlock(&GlobalMid_Lock);
@@ -396,6 +174,126 @@ cifs_reconnect(struct TCP_Server_Info *server)
         return rc;
 }
 
+/*
+        return codes:
+                0       not a transact2, or all data present
+                >0      transact2 with that much data missing
+                -EINVAL = invalid transact2
+
+ */
+static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
+{
+        struct smb_t2_rsp *pSMBt;
+        int remaining;
+        __u16 total_data_size, data_in_this_rsp;
+
+        if (pSMB->Command != SMB_COM_TRANSACTION2)
+                return 0;
+
+        /* check for plausible wct, bcc and t2 data and parm sizes */
+        /* check for parm and data offset going beyond end of smb */
+        if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
+                cFYI(1, "invalid transact2 word count");
+                return -EINVAL;
+        }
+
+        pSMBt = (struct smb_t2_rsp *)pSMB;
+
+        total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
+        data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
+
+        if (total_data_size == data_in_this_rsp)
+                return 0;
+        else if (total_data_size < data_in_this_rsp) {
+                cFYI(1, "total data %d smaller than data in frame %d",
+                        total_data_size, data_in_this_rsp);
+                return -EINVAL;
+        }
+
+        remaining = total_data_size - data_in_this_rsp;
+
+        cFYI(1, "missing %d bytes from transact2, check next response",
+                remaining);
+        if (total_data_size > maxBufSize) {
+                cERROR(1, "TotalDataSize %d is over maximum buffer %d",
+                        total_data_size, maxBufSize);
+                return -EINVAL;
+        }
+        return remaining;
+}
+
+static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
+{
+        struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
+        struct smb_t2_rsp *pSMBt  = (struct smb_t2_rsp *)pTargetSMB;
+        char *data_area_of_target;
+        char *data_area_of_buf2;
+        int remaining;
+        unsigned int byte_count, total_in_buf;
+        __u16 total_data_size, total_in_buf2;
+
+        total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
+
+        if (total_data_size !=
+            get_unaligned_le16(&pSMB2->t2_rsp.TotalDataCount))
+                cFYI(1, "total data size of primary and secondary t2 differ");
+
+        total_in_buf = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
+
+        remaining = total_data_size - total_in_buf;
+
+        if (remaining < 0)
+                return -EPROTO;
+
+        if (remaining == 0) /* nothing to do, ignore */
+                return 0;
+
+        total_in_buf2 = get_unaligned_le16(&pSMB2->t2_rsp.DataCount);
+        if (remaining < total_in_buf2) {
+                cFYI(1, "transact2 2nd response contains too much data");
+        }
+
+        /* find end of first SMB data area */
+        data_area_of_target = (char *)&pSMBt->hdr.Protocol +
+                                get_unaligned_le16(&pSMBt->t2_rsp.DataOffset);
+        /* validate target area */
+
+        data_area_of_buf2 = (char *)&pSMB2->hdr.Protocol +
+                                get_unaligned_le16(&pSMB2->t2_rsp.DataOffset);
+
+        data_area_of_target += total_in_buf;
+
+        /* copy second buffer into end of first buffer */
+        total_in_buf += total_in_buf2;
+        /* is the result too big for the field? */
+        if (total_in_buf > USHRT_MAX)
+                return -EPROTO;
+        put_unaligned_le16(total_in_buf, &pSMBt->t2_rsp.DataCount);
+
+        /* fix up the BCC */
+        byte_count = get_bcc(pTargetSMB);
+        byte_count += total_in_buf2;
+        /* is the result too big for the field? */
+        if (byte_count > USHRT_MAX)
+                return -EPROTO;
+        put_bcc(byte_count, pTargetSMB);
+
+        byte_count = be32_to_cpu(pTargetSMB->smb_buf_length);
+        byte_count += total_in_buf2;
+        /* don't allow buffer to overflow */
+        if (byte_count > CIFSMaxBufSize)
+                return -ENOBUFS;
+        pTargetSMB->smb_buf_length = cpu_to_be32(byte_count);
+
+        memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
+
+        if (remaining == total_in_buf2) {
+                cFYI(1, "found the last secondary response");
+                return 0; /* we are done */
+        } else /* more responses to go */
+                return 1;
+}
+
 static void
 cifs_echo_request(struct work_struct *work)
 {
@@ -404,44 +302,45 @@ cifs_echo_request(struct work_struct *work)
                                         struct TCP_Server_Info, echo.work);
 
         /*
-         * We cannot send an echo if it is disabled or until the
-         * NEGOTIATE_PROTOCOL request is done, which is indicated by
-         * server->ops->need_neg() == true. Also, no need to ping if
-         * we got a response recently.
+         * We cannot send an echo until the NEGOTIATE_PROTOCOL request is
+         * done, which is indicated by maxBuf != 0. Also, no need to ping if
+         * we got a response recently
          */
-        if (!server->ops->need_neg || server->ops->need_neg(server) ||
-            (server->ops->can_echo && !server->ops->can_echo(server)) ||
+        if (server->maxBuf == 0 ||
             time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
                 goto requeue_echo;
 
-        rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
+        rc = CIFSSMBEcho(server);
         if (rc)
                 cFYI(1, "Unable to send echo request to server: %s",
                         server->hostname);
 
 requeue_echo:
-        queue_delayed_work(cifsiod_wq, &server->echo, SMB_ECHO_INTERVAL);
+        queue_delayed_work(system_nrt_wq, &server->echo, SMB_ECHO_INTERVAL);
 }
 
 static bool
-allocate_buffers(struct TCP_Server_Info *server)
+allocate_buffers(char **bigbuf, char **smallbuf, unsigned int size,
+                 bool is_large_buf)
 {
-        if (!server->bigbuf) {
-                server->bigbuf = (char *)cifs_buf_get();
-                if (!server->bigbuf) {
+        char *bbuf = *bigbuf, *sbuf = *smallbuf;
+
+        if (bbuf == NULL) {
+                bbuf = (char *)cifs_buf_get();
+                if (!bbuf) {
                         cERROR(1, "No memory for large SMB response");
                         msleep(3000);
                         /* retry will check if exiting */
                         return false;
                 }
-        } else if (server->large_buf) {
+        } else if (is_large_buf) {
                 /* we are reusing a dirty large buf, clear its start */
-                memset(server->bigbuf, 0, HEADER_SIZE(server));
+                memset(bbuf, 0, size);
         }
 
-        if (!server->smallbuf) {
-                server->smallbuf = (char *)cifs_small_buf_get();
-                if (!server->smallbuf) {
+        if (sbuf == NULL) {
+                sbuf = (char *)cifs_small_buf_get();
+                if (!sbuf) {
                         cERROR(1, "No memory for SMB response");
                         msleep(1000);
                         /* retry will check if exiting */
@@ -450,128 +349,36 @@ allocate_buffers(struct TCP_Server_Info *server)
                 /* beginning of smb buffer is cleared in our buf_get */
         } else {
                 /* if existing small buf clear beginning */
-                memset(server->smallbuf, 0, HEADER_SIZE(server));
-        }
-
-        return true;
-}
-
-static bool
-server_unresponsive(struct TCP_Server_Info *server)
-{
-        /*
-         * We need to wait 2 echo intervals to make sure we handle such
-         * situations right:
-         * 1s  client sends a normal SMB request
-         * 2s  client gets a response
-         * 30s echo workqueue job pops, and decides we got a response recently
-         *     and don't need to send another
-         * ...
-         * 65s kernel_recvmsg times out, and we see that we haven't gotten
-         *     a response in >60s.
-         */
-        if (server->tcpStatus == CifsGood &&
-            time_after(jiffies, server->lstrp + 2 * SMB_ECHO_INTERVAL)) {
-                cERROR(1, "Server %s has not responded in %d seconds. "
-                          "Reconnecting...", server->hostname,
-                          (2 * SMB_ECHO_INTERVAL) / HZ);
-                cifs_reconnect(server);
-                wake_up(&server->response_q);
-                return true;
+                memset(sbuf, 0, size);
         }
 
-        return false;
-}
-
-/*
- * kvec_array_init - clone a kvec array, and advance into it
- * @new:        pointer to memory for cloned array
- * @iov:        pointer to original array
- * @nr_segs:    number of members in original array
- * @bytes:      number of bytes to advance into the cloned array
- *
- * This function will copy the array provided in iov to a section of memory
- * and advance the specified number of bytes into the new array. It returns
- * the number of segments in the new array. "new" must be at least as big as
- * the original iov array.
- */
-static unsigned int
-kvec_array_init(struct kvec *new, struct kvec *iov, unsigned int nr_segs,
-                size_t bytes)
-{
-        size_t base = 0;
+        *bigbuf = bbuf;
+        *smallbuf = sbuf;
 
-        while (bytes || !iov->iov_len) {
-                int copy = min(bytes, iov->iov_len);
-
-                bytes -= copy;
-                base += copy;
-                if (iov->iov_len == base) {
-                        iov++;
-                        nr_segs--;
-                        base = 0;
-                }
-        }
-        memcpy(new, iov, sizeof(*iov) * nr_segs);
-        new->iov_base += base;
-        new->iov_len -= base;
-        return nr_segs;
-}
-
-static struct kvec *
-get_server_iovec(struct TCP_Server_Info *server, unsigned int nr_segs)
-{
-        struct kvec *new_iov;
-
-        if (server->iov && nr_segs <= server->nr_iov)
-                return server->iov;
-
-        /* not big enough -- allocate a new one and release the old */
-        new_iov = kmalloc(sizeof(*new_iov) * nr_segs, GFP_NOFS);
-        if (new_iov) {
-                kfree(server->iov);
-                server->iov = new_iov;
-                server->nr_iov = nr_segs;
-        }
-        return new_iov;
+        return true;
 }
 
-int
-cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
-                       unsigned int nr_segs, unsigned int to_read)
+static int
+read_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg,
+                 struct kvec *iov, unsigned int to_read,
+                 unsigned int *ptotal_read, bool is_header_read)
 {
-        int length = 0;
-        int total_read;
-        unsigned int segs;
-        struct msghdr smb_msg;
-        struct kvec *iov;
-
-        iov = get_server_iovec(server, nr_segs);
-        if (!iov)
-                return -ENOMEM;
-
-        smb_msg.msg_control = NULL;
-        smb_msg.msg_controllen = 0;
-
-        for (total_read = 0; to_read; total_read += length, to_read -= length) {
-                try_to_freeze();
-
-                if (server_unresponsive(server)) {
-                        total_read = -EAGAIN;
-                        break;
-                }
-
-                segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
-
-                length = kernel_recvmsg(server->ssocket, &smb_msg,
-                                        iov, segs, to_read, 0);
+        int length, rc = 0;
+        unsigned int total_read;
+        char *buf = iov->iov_base;
 
+        for (total_read = 0; total_read < to_read; total_read += length) {
+                length = kernel_recvmsg(server->ssocket, smb_msg, iov, 1,
+                                        to_read - total_read, 0);
                 if (server->tcpStatus == CifsExiting) {
-                        total_read = -ESHUTDOWN;
+                        /* then will exit */
+                        rc = 2;
                         break;
                 } else if (server->tcpStatus == CifsNeedReconnect) {
                         cifs_reconnect(server);
-                        total_read = -EAGAIN;
+                        /* Reconnect wakes up rspns q */
+                        /* Now we will reread sock */
+                        rc = 1;
                         break;
                 } else if (length == -ERESTARTSYS ||
                            length == -EAGAIN ||
@@ -583,54 +390,56 @@ cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
                          */
                         usleep_range(1000, 2000);
                         length = 0;
-                        continue;
+                        if (!is_header_read)
+                                continue;
+                        /* Special handling for header read */
+                        if (total_read) {
+                                iov->iov_base = (to_read - total_read) +
+                                                buf;
+                                iov->iov_len = to_read - total_read;
+                                smb_msg->msg_control = NULL;
+                                smb_msg->msg_controllen = 0;
+                                rc = 3;
+                        } else
+                                rc = 1;
+                        break;
                 } else if (length <= 0) {
-                        cFYI(1, "Received no data or error: expecting %d "
-                                "got %d", to_read, length);
+                        cERROR(1, "Received no data, expecting %d",
+                               to_read - total_read);
                         cifs_reconnect(server);
-                        total_read = -EAGAIN;
+                        rc = 1;
                         break;
                 }
         }
-        return total_read;
-}
 
-int
-cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
-                      unsigned int to_read)
-{
-        struct kvec iov;
-
-        iov.iov_base = buf;
-        iov.iov_len = to_read;
-
-        return cifs_readv_from_socket(server, &iov, 1, to_read);
+        *ptotal_read = total_read;
+        return rc;
 }
 
 static bool
-is_smb_response(struct TCP_Server_Info *server, unsigned char type)
+check_rfc1002_header(struct TCP_Server_Info *server, char *buf)
 {
+        char temp = *buf;
+        unsigned int pdu_length = be32_to_cpu(
+                                ((struct smb_hdr *)buf)->smb_buf_length);
+
         /*
          * The first byte big endian of the length field,
          * is actually not part of the length but the type
          * with the most common, zero, as regular data.
          */
-        switch (type) {
-        case RFC1002_SESSION_MESSAGE:
-                /* Regular SMB response */
-                return true;
-        case RFC1002_SESSION_KEEP_ALIVE:
-                cFYI(1, "RFC 1002 session keep alive");
-                break;
-        case RFC1002_POSITIVE_SESSION_RESPONSE:
-                cFYI(1, "RFC 1002 positive session response");
-                break;
-        case RFC1002_NEGATIVE_SESSION_RESPONSE:
+        if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
+                return false;
+        } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
+                cFYI(1, "Good RFC 1002 session rsp");
+                return false;
+        } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
                 /*
                  * We get this from Windows 98 instead of an error on
                  * SMB negprot response.
                  */
-                cFYI(1, "RFC 1002 negative session response");
+                cFYI(1, "Negative RFC1002 Session Response Error 0x%x)",
+                        pdu_length);
                 /* give server a second to clean up */
                 msleep(1000);
                 /*
@@ -639,51 +448,87 @@ is_smb_response(struct TCP_Server_Info *server, unsigned char type)
                  * is since we do not begin with RFC1001 session
                  * initialize frame).
                  */
-                cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
+                cifs_set_port((struct sockaddr *)
+                                &server->dstaddr, CIFS_PORT);
                 cifs_reconnect(server);
                 wake_up(&server->response_q);
-                break;
-        default:
-                cERROR(1, "RFC 1002 unknown response type 0x%x", type);
+                return false;
+        } else if (temp != (char) 0) {
+                cERROR(1, "Unknown RFC 1002 frame");
+                cifs_dump_mem(" Received Data: ", buf, 4);
                 cifs_reconnect(server);
+                return false;
         }
 
-        return false;
+        /* else we have an SMB response */
+        if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
+            (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
+                cERROR(1, "Invalid size SMB length %d pdu_length %d",
+                       4, pdu_length+4);
+                cifs_reconnect(server);
+                wake_up(&server->response_q);
+                return false;
+        }
+
+        return true;
 }
 
-void
-dequeue_mid(struct mid_q_entry *mid, bool malformed)
+static struct mid_q_entry *
+find_cifs_mid(struct TCP_Server_Info *server, struct smb_hdr *buf,
+              int *length, bool is_large_buf, bool *is_multi_rsp, char **bigbuf)
 {
-#ifdef CONFIG_CIFS_STATS2
-        mid->when_received = jiffies;
-#endif
+        struct mid_q_entry *mid = NULL, *tmp_mid, *ret = NULL;
+
         spin_lock(&GlobalMid_Lock);
-        if (!malformed)
-                mid->mid_state = MID_RESPONSE_RECEIVED;
-        else
-                mid->mid_state = MID_RESPONSE_MALFORMED;
-        list_del_init(&mid->qhead);
-        spin_unlock(&GlobalMid_Lock);
-}
+        list_for_each_entry_safe(mid, tmp_mid, &server->pending_mid_q, qhead) {
+                if (mid->mid != buf->Mid ||
+                    mid->midState != MID_REQUEST_SUBMITTED ||
+                    mid->command != buf->Command)
+                        continue;
 
-static void
-handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
-           char *buf, int malformed)
-{
-        if (server->ops->check_trans2 &&
-            server->ops->check_trans2(mid, server, buf, malformed))
-                return;
-        mid->resp_buf = buf;
-        mid->large_buf = server->large_buf;
-        /* Was previous buf put in mpx struct for multi-rsp? */
-        if (!mid->multiRsp) {
-                /* smb buffer will be freed by user thread */
-                if (server->large_buf)
-                        server->bigbuf = NULL;
+                if (*length == 0 && check2ndT2(buf, server->maxBuf) > 0) {
+                        /* We have a multipart transact2 resp */
+                        *is_multi_rsp = true;
+                        if (mid->resp_buf) {
+                                /* merge response - fix up 1st*/
+                                *length = coalesce_t2(buf, mid->resp_buf);
+                                if (*length > 0) {
+                                        *length = 0;
+                                        mid->multiRsp = true;
+                                        break;
+                                }
+                                /* All parts received or packet is malformed. */
+                                mid->multiEnd = true;
+                                goto multi_t2_fnd;
+                        }
+                        if (!is_large_buf) {
+                                /*FIXME: switch to already allocated largebuf?*/
+                                cERROR(1, "1st trans2 resp needs bigbuf");
+                        } else {
+                                /* Have first buffer */
+                                mid->resp_buf = buf;
+                                mid->largeBuf = true;
+                                *bigbuf = NULL;
+                        }
+                        break;
+                }
+                mid->resp_buf = buf;
+                mid->largeBuf = is_large_buf;
+multi_t2_fnd:
+                if (*length == 0)
+                        mid->midState = MID_RESPONSE_RECEIVED;
                 else
-                        server->smallbuf = NULL;
+                        mid->midState = MID_RESPONSE_MALFORMED;
+#ifdef CONFIG_CIFS_STATS2
+                mid->when_received = jiffies;
+#endif
+                list_del_init(&mid->qhead);
+                ret = mid;
+                break;
         }
-        dequeue_mid(mid, malformed);
+        spin_unlock(&GlobalMid_Lock);
+
+        return ret;
 }
 
 static void clean_demultiplex_info(struct TCP_Server_Info *server)
@@ -700,11 +545,19 @@ static void clean_demultiplex_info(struct TCP_Server_Info *server)
         spin_unlock(&GlobalMid_Lock);
         wake_up_all(&server->response_q);
 
-        /* check if we have blocked requests that need to free */
-        spin_lock(&server->req_lock);
-        if (server->credits <= 0)
-                server->credits = 1;
-        spin_unlock(&server->req_lock);
+        /*
+         * Check if we have blocked requests that need to free. Note that
+         * cifs_max_pending is normally 50, but can be set at module install
+         * time to as little as two.
+         */
+        spin_lock(&GlobalMid_Lock);
+        if (atomic_read(&server->inFlight) >= cifs_max_pending)
+                atomic_set(&server->inFlight, cifs_max_pending - 1);
+        /*
+         * We do not want to set the max_pending too low or we could end up
+         * with the counter going negative.
+         */
+        spin_unlock(&GlobalMid_Lock);
         /*
          * Although there should not be any requests blocked on this queue it
          * can not hurt to be paranoid and try to wake up requests that may
@@ -730,8 +583,8 @@ static void clean_demultiplex_info(struct TCP_Server_Info *server)
                 spin_lock(&GlobalMid_Lock);
                 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
                         mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
-                        cFYI(1, "Clearing mid 0x%llx", mid_entry->mid);
-                        mid_entry->mid_state = MID_SHUTDOWN;
+                        cFYI(1, "Clearing mid 0x%x", mid_entry->mid);
+                        mid_entry->midState = MID_SHUTDOWN;
                         list_move(&mid_entry->qhead, &dispose_list);
                 }
                 spin_unlock(&GlobalMid_Lock);
@@ -739,7 +592,7 @@ static void clean_demultiplex_info(struct TCP_Server_Info *server)
                 /* now walk dispose list and issue callbacks */
                 list_for_each_safe(tmp, tmp2, &dispose_list) {
                         mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
-                        cFYI(1, "Callback mid 0x%llx", mid_entry->mid);
+                        cFYI(1, "Callback mid 0x%x", mid_entry->mid);
                         list_del_init(&mid_entry->qhead);
                         mid_entry->callback(mid_entry);
                 }
@@ -765,7 +618,6 @@ static void clean_demultiplex_info(struct TCP_Server_Info *server)
         }
 
         kfree(server->hostname);
-        kfree(server->iov);
         kfree(server);
 
         length = atomic_dec_return(&tcpSesAllocCount);
@@ -775,71 +627,20 @@ static void clean_demultiplex_info(struct TCP_Server_Info *server)
 }
 
 static int
-standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
-{
-        int length;
-        char *buf = server->smallbuf;
-        unsigned int pdu_length = get_rfc1002_length(buf);
-
-        /* make sure this will fit in a large buffer */
-        if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
-                cERROR(1, "SMB response too long (%u bytes)",
-                        pdu_length);
-                cifs_reconnect(server);
-                wake_up(&server->response_q);
-                return -EAGAIN;
-        }
-
-        /* switch to large buffer if too big for a small one */
-        if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
-                server->large_buf = true;
-                memcpy(server->bigbuf, buf, server->total_read);
-                buf = server->bigbuf;
-        }
-
-        /* now read the rest */
-        length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
-                                pdu_length - HEADER_SIZE(server) + 1 + 4);
-        if (length < 0)
-                return length;
-        server->total_read += length;
-
-        dump_smb(buf, server->total_read);
-
-        /*
-         * We know that we received enough to get to the MID as we
-         * checked the pdu_length earlier. Now check to see
-         * if the rest of the header is OK. We borrow the length
-         * var for the rest of the loop to avoid a new stack var.
-         *
-         * 48 bytes is enough to display the header and a little bit
-         * into the payload for debugging purposes.
-         */
-        length = server->ops->check_message(buf, server->total_read);
-        if (length != 0)
-                cifs_dump_mem("Bad SMB: ", buf,
-                        min_t(unsigned int, server->total_read, 48));
-
-        if (server->ops->is_status_pending &&
-            server->ops->is_status_pending(buf, server, length))
-                return -1;
-
-        if (!mid)
-                return length;
-
-        handle_mid(mid, server, buf, length);
-        return 0;
-}
-
-static int
 cifs_demultiplex_thread(void *p)
 {
         int length;
         struct TCP_Server_Info *server = p;
-        unsigned int pdu_length;
-        char *buf = NULL;
+        unsigned int pdu_length, total_read;
+        char *buf = NULL, *bigbuf = NULL, *smallbuf = NULL;
+        struct smb_hdr *smb_buffer = NULL;
+        struct msghdr smb_msg;
+        struct kvec iov;
         struct task_struct *task_to_wake = NULL;
         struct mid_q_entry *mid_entry;
+        bool isLargeBuf = false;
+        bool isMultiRsp = false;
+        int rc;
 
         current->flags |= PF_MEMALLOC;
         cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
@@ -854,70 +655,117 @@ cifs_demultiplex_thread(void *p)
                 if (try_to_freeze())
                         continue;
 
-                if (!allocate_buffers(server))
+                if (!allocate_buffers(&bigbuf, &smallbuf,
+                                      sizeof(struct smb_hdr), isLargeBuf))
                         continue;
 
-                server->large_buf = false;
-                buf = server->smallbuf;
+                isLargeBuf = false;
+                isMultiRsp = false;
+                smb_buffer = (struct smb_hdr *)smallbuf;
+                buf = smallbuf;
+                iov.iov_base = buf;
+                iov.iov_len = 4;
+                smb_msg.msg_control = NULL;
+                smb_msg.msg_controllen = 0;
                 pdu_length = 4; /* enough to get RFC1001 header */
 
-                length = cifs_read_from_socket(server, buf, pdu_length);
-                if (length < 0)
+incomplete_rcv:
+                if (echo_retries > 0 && server->tcpStatus == CifsGood &&
+                    time_after(jiffies, server->lstrp +
+                                        (echo_retries * SMB_ECHO_INTERVAL))) {
+                        cERROR(1, "Server %s has not responded in %d seconds. "
+                                  "Reconnecting...", server->hostname,
+                                  (echo_retries * SMB_ECHO_INTERVAL / HZ));
+                        cifs_reconnect(server);
+                        wake_up(&server->response_q);
+                        continue;
+                }
+
+                rc = read_from_socket(server, &smb_msg, &iov, pdu_length,
+                                      &total_read, true /* header read */);
+                if (rc == 3)
+                        goto incomplete_rcv;
+                else if (rc == 2)
+                        break;
+                else if (rc == 1)
                         continue;
-                server->total_read = length;
 
                 /*
                  * The right amount was read from socket - 4 bytes,
                  * so we can now interpret the length field.
                  */
-                pdu_length = get_rfc1002_length(buf);
 
-                cFYI(1, "RFC1002 header 0x%x", pdu_length);
-                if (!is_smb_response(server, buf[0]))
-                        continue;
+                /*
+                 * Note that RFC 1001 length is big endian on the wire,
+                 * but we convert it here so it is always manipulated
+                 * as host byte order.
+                 */
+                pdu_length = be32_to_cpu(smb_buffer->smb_buf_length);
 
-                /* make sure we have enough to get to the MID */
-                if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
-                        cERROR(1, "SMB response too short (%u bytes)",
-                                pdu_length);
-                        cifs_reconnect(server);
-                        wake_up(&server->response_q);
+                cFYI(1, "rfc1002 length 0x%x", pdu_length+4);
+                if (!check_rfc1002_header(server, buf))
                         continue;
+
+                /* else length ok */
+                if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
+                        isLargeBuf = true;
+                        memcpy(bigbuf, smallbuf, 4);
+                        smb_buffer = (struct smb_hdr *)bigbuf;
+                        buf = bigbuf;
                 }
 
-                /* read down to the MID */
-                length = cifs_read_from_socket(server, buf + 4,
-                                               HEADER_SIZE(server) - 1 - 4);
-                if (length < 0)
+                iov.iov_base = 4 + buf;
+                iov.iov_len = pdu_length;
+                rc = read_from_socket(server, &smb_msg, &iov, pdu_length,
+                                      &total_read, false);
+                if (rc == 2)
+                        break;
+                else if (rc == 1)
                         continue;
-                server->total_read += length;
 
-                mid_entry = server->ops->find_mid(server, buf);
+                total_read += 4; /* account for rfc1002 hdr */
 
-                if (!mid_entry || !mid_entry->receive)
-                        length = standard_receive3(server, mid_entry);
-                else
-                        length = mid_entry->receive(server, mid_entry);
+                dump_smb(smb_buffer, total_read);
 
-                if (length < 0)
-                        continue;
-
-                if (server->large_buf)
-                        buf = server->bigbuf;
+                /*
+                 * We know that we received enough to get to the MID as we
+                 * checked the pdu_length earlier. Now check to see
+                 * if the rest of the header is OK. We borrow the length
+                 * var for the rest of the loop to avoid a new stack var.
+                 *
+                 * 48 bytes is enough to display the header and a little bit
+                 * into the payload for debugging purposes.
+                 */
+                length = checkSMB(smb_buffer, smb_buffer->Mid, total_read);
+                if (length != 0)
+                        cifs_dump_mem("Bad SMB: ", buf,
+                                      min_t(unsigned int, total_read, 48));
 
                 server->lstrp = jiffies;
+
+                mid_entry = find_cifs_mid(server, smb_buffer, &length,
+                                          isLargeBuf, &isMultiRsp, &bigbuf);
                 if (mid_entry != NULL) {
-                        if (!mid_entry->multiRsp || mid_entry->multiEnd)
-                                mid_entry->callback(mid_entry);
-                } else if (!server->ops->is_oplock_break ||
-                           !server->ops->is_oplock_break(buf, server)) {
+                        mid_entry->callback(mid_entry);
+                        /* Was previous buf put in mpx struct for multi-rsp? */
+                        if (!isMultiRsp) {
+                                /* smb buffer will be freed by user thread */
+                                if (isLargeBuf)
+                                        bigbuf = NULL;
+                                else
+                                        smallbuf = NULL;
+                        }
+                } else if (length != 0) {
+                        /* response sanity checks failed */
+                        continue;
+                } else if (!is_valid_oplock_break(smb_buffer, server) &&
+                           !isMultiRsp) {
                         cERROR(1, "No task to wake, unknown frame received! "
                                    "NumMids %d", atomic_read(&midCount));
                         cifs_dump_mem("Received Data is: ", buf,
-                                      HEADER_SIZE(server));
+                                      sizeof(struct smb_hdr));
 #ifdef CONFIG_CIFS_DEBUG2
-                        if (server->ops->dump_detail)
-                                server->ops->dump_detail(buf);
+                        cifs_dump_detail(smb_buffer);
                         cifs_dump_mids(server);
 #endif /* CIFS_DEBUG2 */
 
@@ -925,9 +773,9 @@ cifs_demultiplex_thread(void *p)
         } /* end while !EXITING */
 
         /* buffer usually freed in free_mid - need to free it here on exit */
-        cifs_buf_release(server->bigbuf);
-        if (server->smallbuf) /* no sense logging a debug message if NULL */
-                cifs_small_buf_release(server->smallbuf);
+        cifs_buf_release(bigbuf);
+        if (smallbuf) /* no sense logging a debug message if NULL */
+                cifs_small_buf_release(smallbuf);
 
         task_to_wake = xchg(&server->tsk, NULL);
         clean_demultiplex_info(server);
@@ -973,180 +821,11 @@ extract_hostname(const char *unc)
         return dst;
 }
 
-static int get_option_ul(substring_t args[], unsigned long *option)
-{
-        int rc;
-        char *string;
-
-        string = match_strdup(args);
-        if (string == NULL)
-                return -ENOMEM;
-        rc = kstrtoul(string, 0, option);
-        kfree(string);
-
-        return rc;
-}
-
-
-static int cifs_parse_security_flavors(char *value,
-                                       struct smb_vol *vol)
-{
-
-        substring_t args[MAX_OPT_ARGS];
-
-        switch (match_token(value, cifs_secflavor_tokens, args)) {
-        case Opt_sec_krb5:
-                vol->secFlg |= CIFSSEC_MAY_KRB5;
-                break;
-        case Opt_sec_krb5i:
-                vol->secFlg |= CIFSSEC_MAY_KRB5 | CIFSSEC_MUST_SIGN;
-                break;
-        case Opt_sec_krb5p:
-                /* vol->secFlg |= CIFSSEC_MUST_SEAL | CIFSSEC_MAY_KRB5; */
-                cERROR(1, "Krb5 cifs privacy not supported");
-                break;
-        case Opt_sec_ntlmssp:
-                vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
-                break;
-        case Opt_sec_ntlmsspi:
-                vol->secFlg |= CIFSSEC_MAY_NTLMSSP | CIFSSEC_MUST_SIGN;
-                break;
-        case Opt_ntlm:
-                /* ntlm is default so can be turned off too */
-                vol->secFlg |= CIFSSEC_MAY_NTLM;
-                break;
-        case Opt_sec_ntlmi:
-                vol->secFlg |= CIFSSEC_MAY_NTLM | CIFSSEC_MUST_SIGN;
-                break;
-        case Opt_sec_ntlmv2:
-                vol->secFlg |= CIFSSEC_MAY_NTLMV2;
-                break;
-        case Opt_sec_ntlmv2i:
-                vol->secFlg |= CIFSSEC_MAY_NTLMV2 | CIFSSEC_MUST_SIGN;
-                break;
-#ifdef CONFIG_CIFS_WEAK_PW_HASH
-        case Opt_sec_lanman:
-                vol->secFlg |= CIFSSEC_MAY_LANMAN;
-                break;
-#endif
-        case Opt_sec_none:
-                vol->nullauth = 1;
-                break;
-        default:
-                cERROR(1, "bad security option: %s", value);
-                return 1;
-        }
-
-        return 0;
-}
-
-static int
-cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
-{
-        substring_t args[MAX_OPT_ARGS];
-
-        switch (match_token(value, cifs_cacheflavor_tokens, args)) {
-        case Opt_cache_loose:
-                vol->direct_io = false;
-                vol->strict_io = false;
-                break;
-        case Opt_cache_strict:
-                vol->direct_io = false;
-                vol->strict_io = true;
-                break;
-        case Opt_cache_none:
-                vol->direct_io = true;
-                vol->strict_io = false;
-                break;
-        default:
-                cERROR(1, "bad cache= option: %s", value);
-                return 1;
-        }
-        return 0;
-}
-
-static int
-cifs_parse_smb_version(char *value, struct smb_vol *vol)
-{
-        substring_t args[MAX_OPT_ARGS];
-
-        switch (match_token(value, cifs_smb_version_tokens, args)) {
-        case Smb_1:
-                vol->ops = &smb1_operations;
-                vol->vals = &smb1_values;
-                break;
-#ifdef CONFIG_CIFS_SMB2
-        case Smb_20:
-                vol->ops = &smb21_operations; /* currently identical with 2.1 */
-                vol->vals = &smb20_values;
-                break;
-        case Smb_21:
-                vol->ops = &smb21_operations;
-                vol->vals = &smb21_values;
-                break;
-        case Smb_30:
-                vol->ops = &smb30_operations;
-                vol->vals = &smb30_values;
-                break;
-#endif
-        default:
-                cERROR(1, "Unknown vers= option specified: %s", value);
-                return 1;
-        }
-        return 0;
-}
-
-/*
- * Parse a devname into substrings and populate the vol->UNC and vol->prepath
- * fields with the result. Returns 0 on success and an error otherwise.
- */
-static int
-cifs_parse_devname(const char *devname, struct smb_vol *vol)
-{
-        char *pos;
-        const char *delims = "/\\";
-        size_t len;
-
-        /* make sure we have a valid UNC double delimiter prefix */
-        len = strspn(devname, delims);
-        if (len != 2)
-                return -EINVAL;
-
-        /* find delimiter between host and sharename */
-        pos = strpbrk(devname + 2, delims);
-        if (!pos)
-                return -EINVAL;
-
-        /* skip past delimiter */
-        ++pos;
-
-        /* now go until next delimiter or end of string */
-        len = strcspn(pos, delims);
-
-        /* move "pos" up to delimiter or NULL */
-        pos += len;
-        vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
-        if (!vol->UNC)
-                return -ENOMEM;
-
-        convert_delimiter(vol->UNC, '\\');
-
-        /* If pos is NULL, or is a bogus trailing delimiter then no prepath */
-        if (!*pos++ || !*pos)
-                return 0;
-
-        vol->prepath = kstrdup(pos, GFP_KERNEL);
-        if (!vol->prepath)
-                return -ENOMEM;
-
-        return 0;
-}
-
 static int
 cifs_parse_mount_options(const char *mountdata, const char *devname,
                          struct smb_vol *vol)
 {
-        char *data, *end;
+        char *value, *data, *end;
         char *mountdata_copy = NULL, *options;
         unsigned int  temp_len, i, j;
         char separator[2];
@@ -1154,22 +833,10 @@ cifs_parse_mount_options(const char *mountdata, const char *devname,
         short int override_gid = -1;
         bool uid_specified = false;
         bool gid_specified = false;
-        bool sloppy = false;
-        char *invalid = NULL;
         char *nodename = utsname()->nodename;
-        char *string = NULL;
-        char *tmp_end, *value;
-        char delim;
-        bool got_ip = false;
-        unsigned short port = 0;
-        struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
 
         separator[0] = ',';
         separator[1] = 0;
-        delim = separator[0];
-
-        /* ensure we always start with zeroed-out smb_vol */
-        memset(vol, 0, sizeof(*vol));
 
         /*
          * does not have to be perfect mapping since field is
@@ -1197,15 +864,8 @@ cifs_parse_mount_options(const char *mountdata, const char *devname,
         /* default to using server inode numbers where available */
         vol->server_ino = 1;
 
-        /* default is to use strict cifs caching semantics */
-        vol->strict_io = true;
-
         vol->actimeo = CIFS_DEF_ACTIMEO;
 
-        /* FIXME: add autonegotiation -- for now, SMB1 is default */
-        vol->ops = &smb1_operations;
-        vol->vals = &smb1_values;
-
         if (!mountdata)
                 goto cifs_parse_mount_err;
 
@@ -1215,7 +875,6 @@ cifs_parse_mount_options(const char *mountdata, const char *devname,
 
         options = mountdata_copy;
         end = options + strlen(options);
-
         if (strncmp(options, "sep=", 4) == 0) {
                 if (options[4] != 0) {
                         separator[0] = options[4];
@@ -1224,658 +883,605 @@ cifs_parse_mount_options(const char *mountdata, const char *devname,
                         cFYI(1, "Null separator not allowed");
                 }
         }
-        vol->backupuid_specified = false; /* no backup intent for a user */
-        vol->backupgid_specified = false; /* no backup intent for a group */
-
-        /*
-         * For now, we ignore -EINVAL errors under the assumption that the
-         * unc= and prefixpath= options will be usable.
-         */
-        if (cifs_parse_devname(devname, vol) == -ENOMEM) {
-                printk(KERN_ERR "CIFS: Unable to allocate memory to parse "
-                                "device string.\n");
-                goto out_nomem;
-        }
 
         while ((data = strsep(&options, separator)) != NULL) {
-                substring_t args[MAX_OPT_ARGS];
-                unsigned long option;
-                int token;
-
                 if (!*data)
                         continue;
+                if ((value = strchr(data, '=')) != NULL)
+                        *value++ = '\0';
 
-                token = match_token(data, cifs_mount_option_tokens, args);
-
-                switch (token) {
-
-                /* Ingnore the following */
-                case Opt_ignore:
-                        break;
-
-                /* Boolean values */
-                case Opt_user_xattr:
+                /* Have to parse this before we parse for "user" */
+                if (strnicmp(data, "user_xattr", 10) == 0) {
                         vol->no_xattr = 0;
-                        break;
-                case Opt_nouser_xattr:
+                } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
                         vol->no_xattr = 1;
-                        break;
-                case Opt_forceuid:
+                } else if (strnicmp(data, "user", 4) == 0) {
+                        if (!value) {
+                                printk(KERN_WARNING
+                                       "CIFS: invalid or missing username\n");
+                                goto cifs_parse_mount_err;
+                        } else if (!*value) {
+                                /* null user, ie anonymous, authentication */
+                                vol->nullauth = 1;
+                        }
+                        if (strnlen(value, MAX_USERNAME_SIZE) <
+                                                MAX_USERNAME_SIZE) {
+                                vol->username = kstrdup(value, GFP_KERNEL);
+                                if (!vol->username) {
+                                        printk(KERN_WARNING "CIFS: no memory "
+                                                            "for username\n");
+                                        goto cifs_parse_mount_err;
+                                }
+                        } else {
+                                printk(KERN_WARNING "CIFS: username too long\n");
+                                goto cifs_parse_mount_err;
+                        }
+                } else if (strnicmp(data, "pass", 4) == 0) {
+                        if (!value) {
+                                vol->password = NULL;
+                                continue;
+                        } else if (value[0] == 0) {
+                                /* check if string begins with double comma
+                                   since that would mean the password really
+                                   does start with a comma, and would not
+                                   indicate an empty string */
+                                if (value[1] != separator[0]) {
+                                        vol->password = NULL;
+                                        continue;
+                                }
+                        }
+                        temp_len = strlen(value);
+                        /* removed password length check, NTLM passwords
+                                can be arbitrarily long */
+
+                        /* if comma in password, the string will be
+                        prematurely null terminated.  Commas in password are
+                        specified across the cifs mount interface by a double
+                        comma ie ,, and a comma used as in other cases ie ','
+                        as a parameter delimiter/separator is single and due
+                        to the strsep above is temporarily zeroed. */
+
+                        /* NB: password legally can have multiple commas and
+                        the only illegal character in a password is null */
+
+                        if ((value[temp_len] == 0) &&
+                            (value + temp_len < end) &&
+                            (value[temp_len+1] == separator[0])) {
+                                /* reinsert comma */
+                                value[temp_len] = separator[0];
+                                temp_len += 2;  /* move after second comma */
+                                while (value[temp_len] != 0)  {
+                                        if (value[temp_len] == separator[0]) {
+                                                if (value[temp_len+1] ==
+                                                     separator[0]) {
+                                                /* skip second comma */
+                                                        temp_len++;
+                                                } else {
+                                                /* single comma indicating start
+                                                         of next parm */
+                                                        break;
+                                                }
+                                        }
+                                        temp_len++;
+                                }
+                                if (value[temp_len] == 0) {
+                                        options = NULL;
+                                } else {
+                                        value[temp_len] = 0;
+                                        /* point option to start of next parm */
+                                        options = value + temp_len + 1;
+                                }
+                                /* go from value to value + temp_len condensing
+                                double commas to singles. Note that this ends up
+                                allocating a few bytes too many, which is ok */
+                                vol->password = kzalloc(temp_len, GFP_KERNEL);
+                                if (vol->password == NULL) {
+                                        printk(KERN_WARNING "CIFS: no memory "
+                                                            "for password\n");
+                                        goto cifs_parse_mount_err;
+                                }
+                                for (i = 0, j = 0; i < temp_len; i++, j++) {
+                                        vol->password[j] = value[i];
+                                        if (value[i] == separator[0]
+                                                && value[i+1] == separator[0]) {
+                                                /* skip second comma */
+                                                i++;
+                                        }
+                                }
+                                vol->password[j] = 0;
+                        } else {
+                                vol->password = kzalloc(temp_len+1, GFP_KERNEL);
+                                if (vol->password == NULL) {
+                                        printk(KERN_WARNING "CIFS: no memory "
+                                                            "for password\n");
+                                        goto cifs_parse_mount_err;
+                                }
+                                strcpy(vol->password, value);
+                        }
+                } else if (!strnicmp(data, "ip", 2) ||
+                           !strnicmp(data, "addr", 4)) {
+                        if (!value || !*value) {
+                                vol->UNCip = NULL;
+                        } else if (strnlen(value, INET6_ADDRSTRLEN) <
+                                                        INET6_ADDRSTRLEN) {
+                                vol->UNCip = kstrdup(value, GFP_KERNEL);
+                                if (!vol->UNCip) {
+                                        printk(KERN_WARNING "CIFS: no memory "
+                                                            "for UNC IP\n");
+                                        goto cifs_parse_mount_err;
+                                }
+                        } else {
+                                printk(KERN_WARNING "CIFS: ip address "
+                                                    "too long\n");
+                                goto cifs_parse_mount_err;
+                        }
+                } else if (strnicmp(data, "sec", 3) == 0) {
+                        if (!value || !*value) {
+                                cERROR(1, "no security value specified");
+                                continue;
+                        } else if (strnicmp(value, "krb5i", 5) == 0) {
+                                vol->secFlg |= CIFSSEC_MAY_KRB5 |
+                                        CIFSSEC_MUST_SIGN;
+                        } else if (strnicmp(value, "krb5p", 5) == 0) {
+                                /* vol->secFlg |= CIFSSEC_MUST_SEAL |
+                                        CIFSSEC_MAY_KRB5; */
+                                cERROR(1, "Krb5 cifs privacy not supported");
+                                goto cifs_parse_mount_err;
+                        } else if (strnicmp(value, "krb5", 4) == 0) {
+                                vol->secFlg |= CIFSSEC_MAY_KRB5;
+                        } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
+                                vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
+                                        CIFSSEC_MUST_SIGN;
+                        } else if (strnicmp(value, "ntlmssp", 7) == 0) {
+                                vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
+                        } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
+                                vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
+                                        CIFSSEC_MUST_SIGN;
+                        } else if (strnicmp(value, "ntlmv2", 6) == 0) {
+                                vol->secFlg |= CIFSSEC_MAY_NTLMV2;
+                        } else if (strnicmp(value, "ntlmi", 5) == 0) {
+                                vol->secFlg |= CIFSSEC_MAY_NTLM |
+                                        CIFSSEC_MUST_SIGN;
+                        } else if (strnicmp(value, "ntlm", 4) == 0) {
+                                /* ntlm is default so can be turned off too */
+                                vol->secFlg |= CIFSSEC_MAY_NTLM;
+                        } else if (strnicmp(value, "nontlm", 6) == 0) {
+                                /* BB is there a better way to do this? */
+                                vol->secFlg |= CIFSSEC_MAY_NTLMV2;
+#ifdef CONFIG_CIFS_WEAK_PW_HASH
+                        } else if (strnicmp(value, "lanman", 6) == 0) {
+                                vol->secFlg |= CIFSSEC_MAY_LANMAN;
+#endif
+                        } else if (strnicmp(value, "none", 4) == 0) {
+                                vol->nullauth = 1;
+                        } else {
+                                cERROR(1, "bad security option: %s", value);
+                                goto cifs_parse_mount_err;
+                        }
+                } else if (strnicmp(data, "vers", 3) == 0) {
+                        if (!value || !*value) {
+                                cERROR(1, "no protocol version specified"
+                                          " after vers= mount option");
+                        } else if ((strnicmp(value, "cifs", 4) == 0) ||
+                                   (strnicmp(value, "1", 1) == 0)) {
+                                /* this is the default */
+                                continue;
+                        }
+                } else if ((strnicmp(data, "unc", 3) == 0)
+                           || (strnicmp(data, "target", 6) == 0)
+                           || (strnicmp(data, "path", 4) == 0)) {
+                        if (!value || !*value) {
+                                printk(KERN_WARNING "CIFS: invalid path to "
+                                                    "network resource\n");
+                                goto cifs_parse_mount_err;
+                        }
+                        if ((temp_len = strnlen(value, 300)) < 300) {
+                                vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
+                                if (vol->UNC == NULL)
+                                        goto cifs_parse_mount_err;
+                                strcpy(vol->UNC, value);
+                                if (strncmp(vol->UNC, "//", 2) == 0) {
+                                        vol->UNC[0] = '\\';
+                                        vol->UNC[1] = '\\';
+                                } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
+                                        printk(KERN_WARNING
+                                               "CIFS: UNC Path does not begin "
+                                               "with // or \\\\ \n");
+                                        goto cifs_parse_mount_err;
+                                }
+                        } else {
+                                printk(KERN_WARNING "CIFS: UNC name too long\n");
+                                goto cifs_parse_mount_err;
+                        }
+                } else if ((strnicmp(data, "domain", 3) == 0)
+                           || (strnicmp(data, "workgroup", 5) == 0)) {
+                        if (!value || !*value) {
+                                printk(KERN_WARNING "CIFS: invalid domain name\n");
+                                goto cifs_parse_mount_err;
+                        }
+                        /* BB are there cases in which a comma can be valid in
+                        a domain name and need special handling? */
+                        if (strnlen(value, 256) < 256) {
+                                vol->domainname = kstrdup(value, GFP_KERNEL);
+                                if (!vol->domainname) {
+                                        printk(KERN_WARNING "CIFS: no memory "
+                                                            "for domainname\n");
+                                        goto cifs_parse_mount_err;
+                                }
+                                cFYI(1, "Domain name set");
+                        } else {
+                                printk(KERN_WARNING "CIFS: domain name too "
+                                                    "long\n");
+                                goto cifs_parse_mount_err;
+                        }
+                } else if (strnicmp(data, "srcaddr", 7) == 0) {
+                        vol->srcaddr.ss_family = AF_UNSPEC;
+
+                        if (!value || !*value) {
+                                printk(KERN_WARNING "CIFS: srcaddr value"
+                                       " not specified.\n");
+                                goto cifs_parse_mount_err;
+                        }
+                        i = cifs_convert_address((struct sockaddr *)&vol->srcaddr,
+                                                 value, strlen(value));
+                        if (i == 0) {
+                                printk(KERN_WARNING "CIFS:  Could not parse"
+                                       " srcaddr: %s\n",
+                                       value);
+                                goto cifs_parse_mount_err;
+                        }
+                } else if (strnicmp(data, "prefixpath", 10) == 0) {
+                        if (!value || !*value) {
+                                printk(KERN_WARNING
+                                        "CIFS: invalid path prefix\n");
+                                goto cifs_parse_mount_err;
+                        }
+                        if ((temp_len = strnlen(value, 1024)) < 1024) {
+                                if (value[0] != '/')
+                                        temp_len++;  /* missing leading slash */
+                                vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
+                                if (vol->prepath == NULL)
+                                        goto cifs_parse_mount_err;
+                                if (value[0] != '/') {
+                                        vol->prepath[0] = '/';
+                                        strcpy(vol->prepath+1, value);
+                                } else
+                                        strcpy(vol->prepath, value);
+                                cFYI(1, "prefix path %s", vol->prepath);
+                        } else {
+                                printk(KERN_WARNING "CIFS: prefix too long\n");
+                                goto cifs_parse_mount_err;
+                        }
+                } else if (strnicmp(data, "iocharset", 9) == 0) {
+                        if (!value || !*value) {
+                                printk(KERN_WARNING "CIFS: invalid iocharset "
+                                                    "specified\n");
+                                goto cifs_parse_mount_err;
+                        }
+                        if (strnlen(value, 65) < 65) {
+                                if (strnicmp(value, "default", 7)) {
+                                        vol->iocharset = kstrdup(value,
+                                                                 GFP_KERNEL);
+
+                                        if (!vol->iocharset) {
+                                                printk(KERN_WARNING "CIFS: no "
+                                                                   "memory for"
+                                                                   "charset\n");
+                                                goto cifs_parse_mount_err;
+                                        }
+                                }
+                                /* if iocharset not set then load_nls_default
+                                   is used by caller */
+                                cFYI(1, "iocharset set to %s", value);
+                        } else {
+                                printk(KERN_WARNING "CIFS: iocharset name "
+                                                    "too long.\n");
+                                goto cifs_parse_mount_err;
+                        }
+                } else if (!strnicmp(data, "uid", 3) && value && *value) {
+                        vol->linux_uid = simple_strtoul(value, &value, 0);
+                        uid_specified = true;
+                } else if (!strnicmp(data, "cruid", 5) && value && *value) {
+                        vol->cred_uid = simple_strtoul(value, &value, 0);
+                } else if (!strnicmp(data, "forceuid", 8)) {
                         override_uid = 1;
-                        break;
-                case Opt_noforceuid:
+                } else if (!strnicmp(data, "noforceuid", 10)) {
                         override_uid = 0;
-                        break;
-                case Opt_forcegid:
+                } else if (!strnicmp(data, "gid", 3) && value && *value) {
+                        vol->linux_gid = simple_strtoul(value, &value, 0);
+                        gid_specified = true;
+                } else if (!strnicmp(data, "forcegid", 8)) {
                         override_gid = 1;
-                        break;
-                case Opt_noforcegid:
+                } else if (!strnicmp(data, "noforcegid", 10)) {
                         override_gid = 0;
-                        break;
-                case Opt_noblocksend:
+                } else if (strnicmp(data, "file_mode", 4) == 0) {
+                        if (value && *value) {
+                                vol->file_mode =
+                                        simple_strtoul(value, &value, 0);
+                        }
+                } else if (strnicmp(data, "dir_mode", 4) == 0) {
+                        if (value && *value) {
+                                vol->dir_mode =
+                                        simple_strtoul(value, &value, 0);
+                        }
+                } else if (strnicmp(data, "dirmode", 4) == 0) {
+                        if (value && *value) {
+                                vol->dir_mode =
+                                        simple_strtoul(value, &value, 0);
+                        }
+                } else if (strnicmp(data, "port", 4) == 0) {
+                        if (value && *value) {
+                                vol->port =
+                                        simple_strtoul(value, &value, 0);
+                        }
+                } else if (strnicmp(data, "rsize", 5) == 0) {
+                        if (value && *value) {
+                                vol->rsize =
+                                        simple_strtoul(value, &value, 0);
+                        }
+                } else if (strnicmp(data, "wsize", 5) == 0) {
+                        if (value && *value) {
+                                vol->wsize =
+                                        simple_strtoul(value, &value, 0);
+                        }
+                } else if (strnicmp(data, "sockopt", 5) == 0) {
+                        if (!value || !*value) {
+                                cERROR(1, "no socket option specified");
+                                continue;
+                        } else if (strnicmp(value, "TCP_NODELAY", 11) == 0) {
+                                vol->sockopt_tcp_nodelay = 1;
+                        }
+                } else if (strnicmp(data, "netbiosname", 4) == 0) {
+                        if (!value || !*value || (*value == ' ')) {
+                                cFYI(1, "invalid (empty) netbiosname");
+                        } else {
+                                memset(vol->source_rfc1001_name, 0x20,
+                                        RFC1001_NAME_LEN);
+                                /*
+                                 * FIXME: are there cases in which a comma can
+                                 * be valid in workstation netbios name (and
+                                 * need special handling)?
+                                 */
+                                for (i = 0; i < RFC1001_NAME_LEN; i++) {
+                                        /* don't ucase netbiosname for user */
+                                        if (value[i] == 0)
+                                                break;
+                                        vol->source_rfc1001_name[i] = value[i];
+                                }
+                                /* The string has 16th byte zero still from
+                                set at top of the function  */
+                                if (i == RFC1001_NAME_LEN && value[i] != 0)
+                                        printk(KERN_WARNING "CIFS: netbiosname"
+                                                " longer than 15 truncated.\n");
+                        }
+                } else if (strnicmp(data, "servern", 7) == 0) {
+                        /* servernetbiosname specified override *SMBSERVER */
+                        if (!value || !*value || (*value == ' ')) {
+                                cFYI(1, "empty server netbiosname specified");
+                        } else {
+                                /* last byte, type, is 0x20 for servr type */
+                                memset(vol->target_rfc1001_name, 0x20,
+                                        RFC1001_NAME_LEN_WITH_NULL);
+
+                                for (i = 0; i < 15; i++) {
+                                /* BB are there cases in which a comma can be
+                                   valid in this workstation netbios name
+                                   (and need special handling)? */
+
+                                /* user or mount helper must uppercase
+                                   the netbiosname */
+                                        if (value[i] == 0)
+                                                break;
+                                        else
+                                                vol->target_rfc1001_name[i] =
+                                                                value[i];
+                                }
+                                /* The string has 16th byte zero still from
+                                   set at top of the function  */
+                                if (i == RFC1001_NAME_LEN && value[i] != 0)
+                                        printk(KERN_WARNING "CIFS: server net"
+                                        "biosname longer than 15 truncated.\n");
+                        }
+                } else if (strnicmp(data, "actimeo", 7) == 0) {
+                        if (value && *value) {
+                                vol->actimeo = HZ * simple_strtoul(value,
+                                                                   &value, 0);
+                                if (vol->actimeo > CIFS_MAX_ACTIMEO) {
+                                        cERROR(1, "CIFS: attribute cache"
+                                                        "timeout too large");
+                                        goto cifs_parse_mount_err;
+                                }
+                        }
+                } else if (strnicmp(data, "credentials", 4) == 0) {
+                        /* ignore */
+                } else if (strnicmp(data, "version", 3) == 0) {
+                        /* ignore */
+                } else if (strnicmp(data, "guest", 5) == 0) {
+                        /* ignore */
+                } else if (strnicmp(data, "rw", 2) == 0 && strlen(data) == 2) {
+                        /* ignore */
+                } else if (strnicmp(data, "ro", 2) == 0) {
+                        /* ignore */
+                } else if (strnicmp(data, "noblocksend", 11) == 0) {
                         vol->noblocksnd = 1;
-                        break;
-                case Opt_noautotune:
+                } else if (strnicmp(data, "noautotune", 10) == 0) {
                         vol->noautotune = 1;
-                        break;
-                case Opt_hard:
+                } else if ((strnicmp(data, "suid", 4) == 0) ||
+                                   (strnicmp(data, "nosuid", 6) == 0) ||
+                                   (strnicmp(data, "exec", 4) == 0) ||
+                                   (strnicmp(data, "noexec", 6) == 0) ||
+                                   (strnicmp(data, "nodev", 5) == 0) ||
+                                   (strnicmp(data, "noauto", 6) == 0) ||
+                                   (strnicmp(data, "dev", 3) == 0)) {
+                        /*  The mount tool or mount.cifs helper (if present)
+                            uses these opts to set flags, and the flags are read
+                            by the kernel vfs layer before we get here (ie
+                            before read super) so there is no point trying to
+                            parse these options again and set anything and it
+                            is ok to just ignore them */
+                        continue;
+                } else if (strnicmp(data, "hard", 4) == 0) {
                         vol->retry = 1;
-                        break;
-                case Opt_soft:
+                } else if (strnicmp(data, "soft", 4) == 0) {
                         vol->retry = 0;
-                        break;
-                case Opt_perm:
+                } else if (strnicmp(data, "perm", 4) == 0) {
                         vol->noperm = 0;
-                        break;
-                case Opt_noperm:
+                } else if (strnicmp(data, "noperm", 6) == 0) {
                         vol->noperm = 1;
-                        break;
-                case Opt_mapchars:
+                } else if (strnicmp(data, "mapchars", 8) == 0) {
                         vol->remap = 1;
-                        break;
-                case Opt_nomapchars:
+                } else if (strnicmp(data, "nomapchars", 10) == 0) {
                         vol->remap = 0;
-                        break;
-                case Opt_sfu:
+                } else if (strnicmp(data, "sfu", 3) == 0) {
                         vol->sfu_emul = 1;
-                        break;
-                case Opt_nosfu:
+                } else if (strnicmp(data, "nosfu", 5) == 0) {
                         vol->sfu_emul = 0;
-                        break;
-                case Opt_nodfs:
+                } else if (strnicmp(data, "nodfs", 5) == 0) {
                         vol->nodfs = 1;
-                        break;
-                case Opt_posixpaths:
+                } else if (strnicmp(data, "posixpaths", 10) == 0) {
                         vol->posix_paths = 1;
-                        break;
-                case Opt_noposixpaths:
+                } else if (strnicmp(data, "noposixpaths", 12) == 0) {
                         vol->posix_paths = 0;
-                        break;
-                case Opt_nounix:
+                } else if (strnicmp(data, "nounix", 6) == 0) {
                         vol->no_linux_ext = 1;
-                        break;
-                case Opt_nocase:
+                } else if (strnicmp(data, "nolinux", 7) == 0) {
+                        vol->no_linux_ext = 1;
+                } else if ((strnicmp(data, "nocase", 6) == 0) ||
+                           (strnicmp(data, "ignorecase", 10)  == 0)) {
                         vol->nocase = 1;
-                        break;
-                case Opt_brl:
+                } else if (strnicmp(data, "mand", 4) == 0) {
+                        /* ignore */
+                } else if (strnicmp(data, "nomand", 6) == 0) {
+                        /* ignore */
+                } else if (strnicmp(data, "_netdev", 7) == 0) {
+                        /* ignore */
+                } else if (strnicmp(data, "brl", 3) == 0) {
                         vol->nobrl =  0;
-                        break;
-                case Opt_nobrl:
+                } else if ((strnicmp(data, "nobrl", 5) == 0) ||
+                           (strnicmp(data, "nolock", 6) == 0)) {
                         vol->nobrl =  1;
-                        /*
-                         * turn off mandatory locking in mode
-                         * if remote locking is turned off since the
-                         * local vfs will do advisory
-                         */
+                        /* turn off mandatory locking in mode
+                        if remote locking is turned off since the
+                        local vfs will do advisory */
                         if (vol->file_mode ==
                                 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
                                 vol->file_mode = S_IALLUGO;
-                        break;
-                case Opt_forcemandatorylock:
+                } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
+                        /* will take the shorter form "forcemand" as well */
+                        /* This mount option will force use of mandatory
+                          (DOS/Windows style) byte range locks, instead of
+                          using posix advisory byte range locks, even if the
+                          Unix extensions are available and posix locks would
+                          be supported otherwise. If Unix extensions are not
+                          negotiated this has no effect since mandatory locks
+                          would be used (mandatory locks is all that those
+                          those servers support) */
                         vol->mand_lock = 1;
-                        break;
-                case Opt_setuids:
+                } else if (strnicmp(data, "setuids", 7) == 0) {
                         vol->setuids = 1;
-                        break;
-                case Opt_nosetuids:
+                } else if (strnicmp(data, "nosetuids", 9) == 0) {
                         vol->setuids = 0;
-                        break;
-                case Opt_dynperm:
+                } else if (strnicmp(data, "dynperm", 7) == 0) {
                         vol->dynperm = true;
-                        break;
-                case Opt_nodynperm:
+                } else if (strnicmp(data, "nodynperm", 9) == 0) {
                         vol->dynperm = false;
-                        break;
-                case Opt_nohard:
+                } else if (strnicmp(data, "nohard", 6) == 0) {
                         vol->retry = 0;
-                        break;
-                case Opt_nosoft:
+                } else if (strnicmp(data, "nosoft", 6) == 0) {
                         vol->retry = 1;
-                        break;
-                case Opt_nointr:
+                } else if (strnicmp(data, "nointr", 6) == 0) {
                         vol->intr = 0;
-                        break;
-                case Opt_intr:
+                } else if (strnicmp(data, "intr", 4) == 0) {
                         vol->intr = 1;
-                        break;
-                case Opt_nostrictsync:
+                } else if (strnicmp(data, "nostrictsync", 12) == 0) {
                         vol->nostrictsync = 1;
-                        break;
-                case Opt_strictsync:
+                } else if (strnicmp(data, "strictsync", 10) == 0) {
                         vol->nostrictsync = 0;
-                        break;
-                case Opt_serverino:
+                } else if (strnicmp(data, "serverino", 7) == 0) {
                         vol->server_ino = 1;
-                        break;
-                case Opt_noserverino:
+                } else if (strnicmp(data, "noserverino", 9) == 0) {
                         vol->server_ino = 0;
-                        break;
-                case Opt_rwpidforward:
+                } else if (strnicmp(data, "rwpidforward", 12) == 0) {
                         vol->rwpidforward = 1;
-                        break;
-                case Opt_cifsacl:
+                } else if (strnicmp(data, "cifsacl", 7) == 0) {
                         vol->cifs_acl = 1;
-                        break;
-                case Opt_nocifsacl:
+                } else if (strnicmp(data, "nocifsacl", 9) == 0) {
                         vol->cifs_acl = 0;
-                        break;
-                case Opt_acl:
+                } else if (strnicmp(data, "acl", 3) == 0) {
                         vol->no_psx_acl = 0;
-                        break;
-                case Opt_noacl:
+                } else if (strnicmp(data, "noacl", 5) == 0) {
                         vol->no_psx_acl = 1;
-                        break;
-                case Opt_locallease:
+                } else if (strnicmp(data, "locallease", 6) == 0) {
                         vol->local_lease = 1;
-                        break;
-                case Opt_sign:
+                } else if (strnicmp(data, "sign", 4) == 0) {
                         vol->secFlg |= CIFSSEC_MUST_SIGN;
-                        break;
-                case Opt_seal:
+                } else if (strnicmp(data, "seal", 4) == 0) {
                         /* we do not do the following in secFlags because seal
-                         * is a per tree connection (mount) not a per socket
-                         * or per-smb connection option in the protocol
-                         * vol->secFlg |= CIFSSEC_MUST_SEAL;
-                         */
+                           is a per tree connection (mount) not a per socket
+                           or per-smb connection option in the protocol */
+                        /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
                         vol->seal = 1;
-                        break;
-                case Opt_noac:
+                } else if (strnicmp(data, "direct", 6) == 0) {
+                        vol->direct_io = 1;
+                } else if (strnicmp(data, "forcedirectio", 13) == 0) {
+                        vol->direct_io = 1;
+                } else if (strnicmp(data, "strictcache", 11) == 0) {
+                        vol->strict_io = 1;
+                } else if (strnicmp(data, "noac", 4) == 0) {
                         printk(KERN_WARNING "CIFS: Mount option noac not "
                                 "supported. Instead set "
                                 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
-                        break;
-                case Opt_fsc:
+                } else if (strnicmp(data, "fsc", 3) == 0) {
 #ifndef CONFIG_CIFS_FSCACHE
                         cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
                                   "kernel config option set");
                         goto cifs_parse_mount_err;
 #endif
                         vol->fsc = true;
-                        break;
-                case Opt_mfsymlinks:
+                } else if (strnicmp(data, "mfsymlinks", 10) == 0) {
                         vol->mfsymlinks = true;
-                        break;
-                case Opt_multiuser:
+                } else if (strnicmp(data, "multiuser", 8) == 0) {
                         vol->multiuser = true;
-                        break;
-                case Opt_sloppy:
-                        sloppy = true;
-                        break;
-
-                /* Numeric Values */
-                case Opt_backupuid:
-                        if (get_option_ul(args, &option)) {
-                                cERROR(1, "%s: Invalid backupuid value",
-                                        __func__);
-                                goto cifs_parse_mount_err;
-                        }
-                        vol->backupuid = option;
-                        vol->backupuid_specified = true;
-                        break;
-                case Opt_backupgid:
-                        if (get_option_ul(args, &option)) {
-                                cERROR(1, "%s: Invalid backupgid value",
-                                        __func__);
-                                goto cifs_parse_mount_err;
-                        }
-                        vol->backupgid = option;
-                        vol->backupgid_specified = true;
-                        break;
-                case Opt_uid:
-                        if (get_option_ul(args, &option)) {
-                                cERROR(1, "%s: Invalid uid value",
-                                        __func__);
-                                goto cifs_parse_mount_err;
-                        }
-                        vol->linux_uid = option;
-                        uid_specified = true;
-                        break;
-                case Opt_cruid:
-                        if (get_option_ul(args, &option)) {
-                                cERROR(1, "%s: Invalid cruid value",
-                                        __func__);
-                                goto cifs_parse_mount_err;
-                        }
-                        vol->cred_uid = option;
-                        break;
-                case Opt_gid:
-                        if (get_option_ul(args, &option)) {
-                                cERROR(1, "%s: Invalid gid value",
-                                                __func__);
-                                goto cifs_parse_mount_err;
-                        }
-                        vol->linux_gid = option;
-                        gid_specified = true;
-                        break;
-                case Opt_file_mode:
-                        if (get_option_ul(args, &option)) {
-                                cERROR(1, "%s: Invalid file_mode value",
-                                        __func__);
-                                goto cifs_parse_mount_err;
-                        }
-                        vol->file_mode = option;
-                        break;
-                case Opt_dirmode:
-                        if (get_option_ul(args, &option)) {
-                                cERROR(1, "%s: Invalid dir_mode value",
-                                        __func__);
-                                goto cifs_parse_mount_err;
-                        }
-                        vol->dir_mode = option;
-                        break;
-                case Opt_port:
-                        if (get_option_ul(args, &option) ||
-                            option > USHRT_MAX) {
-                                cERROR(1, "%s: Invalid port value", __func__);
-                                goto cifs_parse_mount_err;
-                        }
-                        port = (unsigned short)option;
-                        break;
-                case Opt_rsize:
-                        if (get_option_ul(args, &option)) {
-                                cERROR(1, "%s: Invalid rsize value",
-                                        __func__);
-                                goto cifs_parse_mount_err;
-                        }
-                        vol->rsize = option;
-                        break;
-                case Opt_wsize:
-                        if (get_option_ul(args, &option)) {
-                                cERROR(1, "%s: Invalid wsize value",
-                                        __func__);
-                                goto cifs_parse_mount_err;
-                        }
-                        vol->wsize = option;
-                        break;
-                case Opt_actimeo:
-                        if (get_option_ul(args, &option)) {
-                                cERROR(1, "%s: Invalid actimeo value",
-                                        __func__);
-                                goto cifs_parse_mount_err;
-                        }
-                        vol->actimeo = HZ * option;
-                        if (vol->actimeo > CIFS_MAX_ACTIMEO) {
-                                cERROR(1, "CIFS: attribute cache"
-                                          "timeout too large");
-                                goto cifs_parse_mount_err;
-                        }
-                        break;
-
-                /* String Arguments */
-
-                case Opt_blank_user:
-                        /* null user, ie. anonymous authentication */
-                        vol->nullauth = 1;
-                        vol->username = NULL;
-                        break;
-                case Opt_user:
-                        string = match_strdup(args);
-                        if (string == NULL)
-                                goto out_nomem;
-
-                        if (strnlen(string, MAX_USERNAME_SIZE) >
-                                                        MAX_USERNAME_SIZE) {
-                                printk(KERN_WARNING "CIFS: username too long\n");
-                                goto cifs_parse_mount_err;
-                        }
-                        vol->username = kstrdup(string, GFP_KERNEL);
-                        if (!vol->username) {
-                                printk(KERN_WARNING "CIFS: no memory "
-                                                    "for username\n");
-                                goto cifs_parse_mount_err;
-                        }
-                        break;
-                case Opt_blank_pass:
-                        vol->password = NULL;
-                        break;
-                case Opt_pass:
-                        /* passwords have to be handled differently
-                         * to allow the character used for deliminator
-                         * to be passed within them
-                         */
-
-                        /* Obtain the value string */
-                        value = strchr(data, '=');
-                        value++;
-
-                        /* Set tmp_end to end of the string */
-                        tmp_end = (char *) value + strlen(value);
-
-                        /* Check if following character is the deliminator
-                         * If yes, we have encountered a double deliminator
-                         * reset the NULL character to the deliminator
-                         */
-                        if (tmp_end < end && tmp_end[1] == delim) {
-                                tmp_end[0] = delim;
-
-                                /* Keep iterating until we get to a single
-                                 * deliminator OR the end
-                                 */
-                                while ((tmp_end = strchr(tmp_end, delim))
-                                        != NULL && (tmp_end[1] == delim)) {
-                                                tmp_end = (char *) &tmp_end[2];
-                                }
-
-                                /* Reset var options to point to next element */
-                                if (tmp_end) {
-                                        tmp_end[0] = '\0';
-                                        options = (char *) &tmp_end[1];
-                                } else
-                                        /* Reached the end of the mount option
-                                         * string */
-                                        options = end;
-                        }
-
-                        /* Now build new password string */
-                        temp_len = strlen(value);
-                        vol->password = kzalloc(temp_len+1, GFP_KERNEL);
-                        if (vol->password == NULL) {
-                                printk(KERN_WARNING "CIFS: no memory "
-                                                    "for password\n");
-                                goto cifs_parse_mount_err;
-                        }
-
-                        for (i = 0, j = 0; i < temp_len; i++, j++) {
-                                vol->password[j] = value[i];
-                                if ((value[i] == delim) &&
-                                     value[i+1] == delim)
-                                        /* skip the second deliminator */
-                                        i++;
-                        }
-                        vol->password[j] = '\0';
-                        break;
-                case Opt_blank_ip:
-                        /* FIXME: should this be an error instead? */
-                        got_ip = false;
-                        break;
-                case Opt_ip:
-                        string = match_strdup(args);
-                        if (string == NULL)
-                                goto out_nomem;
-
-                        if (!cifs_convert_address(dstaddr, string,
-                                        strlen(string))) {
-                                printk(KERN_ERR "CIFS: bad ip= option (%s).\n",
-                                        string);
-                                goto cifs_parse_mount_err;
-                        }
-                        got_ip = true;
-                        break;
-                case Opt_unc:
-                        string = vol->UNC;
-                        vol->UNC = match_strdup(args);
+                } else
+                        printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
+                                                data);
+        }
+        if (vol->UNC == NULL) {
+                if (devname == NULL) {
+                        printk(KERN_WARNING "CIFS: Missing UNC name for mount "
+                                                "target\n");
+                        goto cifs_parse_mount_err;
+                }
+                if ((temp_len = strnlen(devname, 300)) < 300) {
+                        vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
                         if (vol->UNC == NULL)
-                                goto out_nomem;
-
-                        convert_delimiter(vol->UNC, '\\');
-                        if (vol->UNC[0] != '\\' || vol->UNC[1] != '\\') {
-                                printk(KERN_ERR "CIFS: UNC Path does not "
-                                                "begin with // or \\\\\n");
-                                goto cifs_parse_mount_err;
-                        }
-
-                        /* Compare old unc= option to new one */
-                        if (!string || strcmp(string, vol->UNC))
-                                printk(KERN_WARNING "CIFS: the value of the "
-                                        "unc= mount option does not match the "
-                                        "device string. Using the unc= option "
-                                        "for now. In 3.10, that option will "
-                                        "be ignored and the contents of the "
-                                        "device string will be used "
-                                        "instead. (%s != %s)\n", string,
-                                        vol->UNC);
-                        break;
-                case Opt_domain:
-                        string = match_strdup(args);
-                        if (string == NULL)
-                                goto out_nomem;
-
-                        if (strnlen(string, 256) == 256) {
-                                printk(KERN_WARNING "CIFS: domain name too"
-                                                    " long\n");
-                                goto cifs_parse_mount_err;
-                        }
-
-                        vol->domainname = kstrdup(string, GFP_KERNEL);
-                        if (!vol->domainname) {
-                                printk(KERN_WARNING "CIFS: no memory "
-                                                    "for domainname\n");
                                 goto cifs_parse_mount_err;
-                        }
-                        cFYI(1, "Domain name set");
-                        break;
-                case Opt_srcaddr:
-                        string = match_strdup(args);
-                        if (string == NULL)
-                                goto out_nomem;
-
-                        if (!cifs_convert_address(
-                                        (struct sockaddr *)&vol->srcaddr,
-                                        string, strlen(string))) {
-                                printk(KERN_WARNING "CIFS:  Could not parse"
-                                                    " srcaddr: %s\n", string);
+                        strcpy(vol->UNC, devname);
+                        if (strncmp(vol->UNC, "//", 2) == 0) {
+                                vol->UNC[0] = '\\';
+                                vol->UNC[1] = '\\';
+                        } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
+                                printk(KERN_WARNING "CIFS: UNC Path does not "
+                                                    "begin with // or \\\\ \n");
                                 goto cifs_parse_mount_err;
                         }
-                        break;
-                case Opt_prefixpath:
-                        /* skip over any leading delimiter */
-                        if (*args[0].from == '/' || *args[0].from == '\\')
-                                args[0].from++;
-
-                        string = vol->prepath;
-                        vol->prepath = match_strdup(args);
-                        if (vol->prepath == NULL)
-                                goto out_nomem;
-                        /* Compare old prefixpath= option to new one */
-                        if (!string || strcmp(string, vol->prepath))
-                                printk(KERN_WARNING "CIFS: the value of the "
-                                        "prefixpath= mount option does not "
-                                        "match the device string. Using the "
-                                        "prefixpath= option for now. In 3.10, "
-                                        "that option will be ignored and the "
-                                        "contents of the device string will be "
-                                        "used instead.(%s != %s)\n", string,
-                                        vol->prepath);
-                        break;
-                case Opt_iocharset:
-                        string = match_strdup(args);
-                        if (string == NULL)
-                                goto out_nomem;
-
-                        if (strnlen(string, 1024) >= 65) {
-                                printk(KERN_WARNING "CIFS: iocharset name "
-                                                    "too long.\n");
-                                goto cifs_parse_mount_err;
-                        }
-
-                         if (strnicmp(string, "default", 7) != 0) {
-                                vol->iocharset = kstrdup(string,
-                                                         GFP_KERNEL);
-                                if (!vol->iocharset) {
-                                        printk(KERN_WARNING "CIFS: no memory"
-                                                            "for charset\n");
-                                        goto cifs_parse_mount_err;
-                                }
-                        }
-                        /* if iocharset not set then load_nls_default
-                         * is used by caller
-                         */
-                        cFYI(1, "iocharset set to %s", string);
-                        break;
-                case Opt_sockopt:
-                        string = match_strdup(args);
-                        if (string == NULL)
-                                goto out_nomem;
-
-                        if (strnicmp(string, "TCP_NODELAY", 11) == 0) {
-                                printk(KERN_WARNING "CIFS: the "
-                                        "sockopt=TCP_NODELAY option has been "
-                                        "deprecated and will be removed "
-                                        "in 3.9\n");
-                                vol->sockopt_tcp_nodelay = 1;
-                        }
-                        break;
-                case Opt_netbiosname:
-                        string = match_strdup(args);
-                        if (string == NULL)
-                                goto out_nomem;
-
-                        memset(vol->source_rfc1001_name, 0x20,
-                                RFC1001_NAME_LEN);
-                        /*
-                         * FIXME: are there cases in which a comma can
-                         * be valid in workstation netbios name (and
-                         * need special handling)?
-                         */
-                        for (i = 0; i < RFC1001_NAME_LEN; i++) {
-                                /* don't ucase netbiosname for user */
-                                if (string[i] == 0)
-                                        break;
-                                vol->source_rfc1001_name[i] = string[i];
-                        }
-                        /* The string has 16th byte zero still from
-                         * set at top of the function
-                         */
-                        if (i == RFC1001_NAME_LEN && string[i] != 0)
-                                printk(KERN_WARNING "CIFS: netbiosname"
-                                       " longer than 15 truncated.\n");
-
-                        break;
-                case Opt_servern:
-                        /* servernetbiosname specified override *SMBSERVER */
-                        string = match_strdup(args);
-                        if (string == NULL)
-                                goto out_nomem;
-
-                        /* last byte, type, is 0x20 for servr type */
-                        memset(vol->target_rfc1001_name, 0x20,
-                                RFC1001_NAME_LEN_WITH_NULL);
-
-                        /* BB are there cases in which a comma can be
-                           valid in this workstation netbios name
-                           (and need special handling)? */
-
-                        /* user or mount helper must uppercase the
-                           netbios name */
-                        for (i = 0; i < 15; i++) {
-                                if (string[i] == 0)
-                                        break;
-                                vol->target_rfc1001_name[i] = string[i];
-                        }
-                        /* The string has 16th byte zero still from
-                           set at top of the function  */
-                        if (i == RFC1001_NAME_LEN && string[i] != 0)
-                                printk(KERN_WARNING "CIFS: server net"
-                                       "biosname longer than 15 truncated.\n");
-                        break;
-                case Opt_ver:
-                        string = match_strdup(args);
-                        if (string == NULL)
-                                goto out_nomem;
-
-                        if (strnicmp(string, "1", 1) == 0) {
-                                /* This is the default */
-                                break;
-                        }
-                        /* For all other value, error */
-                        printk(KERN_WARNING "CIFS: Invalid version"
-                                            " specified\n");
+                        value = strpbrk(vol->UNC+2, "/\\");
+                        if (value)
+                                *value = '\\';
+                } else {
+                        printk(KERN_WARNING "CIFS: UNC name too long\n");
                         goto cifs_parse_mount_err;
-                case Opt_vers:
-                        string = match_strdup(args);
-                        if (string == NULL)
-                                goto out_nomem;
-
-                        if (cifs_parse_smb_version(string, vol) != 0)
-                                goto cifs_parse_mount_err;
-                        break;
-                case Opt_sec:
-                        string = match_strdup(args);
-                        if (string == NULL)
-                                goto out_nomem;
-
-                        if (cifs_parse_security_flavors(string, vol) != 0)
-                                goto cifs_parse_mount_err;
-                        break;
-                case Opt_cache:
-                        string = match_strdup(args);
-                        if (string == NULL)
-                                goto out_nomem;
-
-                        if (cifs_parse_cache_flavor(string, vol) != 0)
-                                goto cifs_parse_mount_err;
-                        break;
-                default:
-                        /*
-                         * An option we don't recognize. Save it off for later
-                         * if we haven't already found one
-                         */
-                        if (!invalid)
-                                invalid = data;
-                        break;
                 }
-                /* Free up any allocated string */
-                kfree(string);
-                string = NULL;
-        }
-
-        if (!sloppy && invalid) {
-                printk(KERN_ERR "CIFS: Unknown mount option \"%s\"\n", invalid);
-                goto cifs_parse_mount_err;
-        }
-
-#ifndef CONFIG_KEYS
-        /* Muliuser mounts require CONFIG_KEYS support */
-        if (vol->multiuser) {
-                cERROR(1, "Multiuser mounts require kernels with "
-                          "CONFIG_KEYS enabled.");
-                goto cifs_parse_mount_err;
-        }
-#endif
-        if (!vol->UNC) {
-                cERROR(1, "CIFS mount error: No usable UNC path provided in "
-                          "device string or in unc= option!");
-                goto cifs_parse_mount_err;
         }
 
-        /* make sure UNC has a share name */
-        if (!strchr(vol->UNC + 3, '\\')) {
-                cERROR(1, "Malformed UNC. Unable to find share name.");
+        if (vol->multiuser && !(vol->secFlg & CIFSSEC_MAY_KRB5)) {
+                cERROR(1, "Multiuser mounts currently require krb5 "
+                          "authentication!");
                 goto cifs_parse_mount_err;
         }
 
-        if (!got_ip) {
-                /* No ip= option specified? Try to get it from UNC */
-                if (!cifs_convert_address(dstaddr, &vol->UNC[2],
-                                                strlen(&vol->UNC[2]))) {
-                        printk(KERN_ERR "Unable to determine destination "
-                                        "address.\n");
-                        goto cifs_parse_mount_err;
-                }
-        }
-
-        /* set the port that we got earlier */
-        cifs_set_port(dstaddr, port);
+        if (vol->UNCip == NULL)
+                vol->UNCip = &vol->UNC[2];
 
         if (uid_specified)
                 vol->override_uid = override_uid;
@@ -1892,10 +1498,7 @@ cifs_parse_mount_options(const char *mountdata, const char *devname,
         kfree(mountdata_copy);
         return 0;
 
-out_nomem:
-        printk(KERN_WARNING "Could not allocate temporary buffer\n");
 cifs_parse_mount_err:
-        kfree(string);
         kfree(mountdata_copy);
         return 1;
 }
@@ -2046,13 +1649,9 @@ match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
         return true;
 }
 
-static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
+static int match_server(struct TCP_Server_Info *server, struct sockaddr *addr,
+                         struct smb_vol *vol)
 {
-        struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
-
-        if ((server->vals != vol->vals) || (server->ops != vol->ops))
-                return 0;
-
         if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
                 return 0;
 
@@ -2070,13 +1669,13 @@ static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
 }
 
 static struct TCP_Server_Info *
-cifs_find_tcp_session(struct smb_vol *vol)
+cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
 {
         struct TCP_Server_Info *server;
 
         spin_lock(&cifs_tcp_ses_lock);
         list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
-                if (!match_server(server, vol))
+                if (!match_server(server, addr, vol))
                         continue;
 
                 ++server->srv_count;
@@ -2126,12 +1725,40 @@ static struct TCP_Server_Info *
 cifs_get_tcp_session(struct smb_vol *volume_info)
 {
         struct TCP_Server_Info *tcp_ses = NULL;
+        struct sockaddr_storage addr;
+        struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
+        struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
         int rc;
 
-        cFYI(1, "UNC: %s", volume_info->UNC);
+        memset(&addr, 0, sizeof(struct sockaddr_storage));
+
+        cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
+
+        if (volume_info->UNCip && volume_info->UNC) {
+                rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
+                                        volume_info->UNCip,
+                                        strlen(volume_info->UNCip),
+                                        volume_info->port);
+                if (!rc) {
+                        /* we failed translating address */
+                        rc = -EINVAL;
+                        goto out_err;
+                }
+        } else if (volume_info->UNCip) {
+                /* BB using ip addr as tcp_ses name to connect to the
+                   DFS root below */
+                cERROR(1, "Connecting to DFS root not implemented yet");
+                rc = -EINVAL;
+                goto out_err;
+        } else /* which tcp_sess DFS root would we conect to */ {
+                cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
+                        "unc=//192.168.1.100/public) specified");
+                rc = -EINVAL;
+                goto out_err;
+        }
 
         /* see if we already have a matching tcp_ses */
-        tcp_ses = cifs_find_tcp_session(volume_info);
+        tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
         if (tcp_ses)
                 return tcp_ses;
 
@@ -2147,8 +1774,6 @@ cifs_get_tcp_session(struct smb_vol *volume_info)
                 goto out_err;
         }
 
-        tcp_ses->ops = volume_info->ops;
-        tcp_ses->vals = volume_info->vals;
         cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
         tcp_ses->hostname = extract_hostname(volume_info->UNC);
         if (IS_ERR(tcp_ses->hostname)) {
@@ -2159,8 +1784,7 @@ cifs_get_tcp_session(struct smb_vol *volume_info)
         tcp_ses->noblocksnd = volume_info->noblocksnd;
         tcp_ses->noautotune = volume_info->noautotune;
         tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
-        tcp_ses->in_flight = 0;
-        tcp_ses->credits = 1;
+        atomic_set(&tcp_ses->inFlight, 0);
         init_waitqueue_head(&tcp_ses->response_q);
         init_waitqueue_head(&tcp_ses->request_q);
         INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
@@ -2172,22 +1796,30 @@ cifs_get_tcp_session(struct smb_vol *volume_info)
         tcp_ses->session_estab = false;
         tcp_ses->sequence_number = 0;
         tcp_ses->lstrp = jiffies;
-        spin_lock_init(&tcp_ses->req_lock);
         INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
         INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
         INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
-        memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
-               sizeof(tcp_ses->srcaddr));
-        memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
-                sizeof(tcp_ses->dstaddr));
+
         /*
          * at this point we are the only ones with the pointer
          * to the struct since the kernel thread not created yet
          * no need to spinlock this init of tcpStatus or srv_count
          */
         tcp_ses->tcpStatus = CifsNew;
+        memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
+               sizeof(tcp_ses->srcaddr));
         ++tcp_ses->srv_count;
 
+        if (addr.ss_family == AF_INET6) {
+                cFYI(1, "attempting ipv6 connect");
+                /* BB should we allow ipv6 on port 139? */
+                /* other OS never observed in Wild doing 139 with v6 */
+                memcpy(&tcp_ses->dstaddr, sin_server6,
+                       sizeof(struct sockaddr_in6));
+        } else
+                memcpy(&tcp_ses->dstaddr, sin_server,
+                       sizeof(struct sockaddr_in));
+
         rc = ip_connect(tcp_ses);
         if (rc < 0) {
                 cERROR(1, "Error connecting to socket. Aborting operation");
@@ -2217,7 +1849,7 @@ cifs_get_tcp_session(struct smb_vol *volume_info)
         cifs_fscache_get_client_cookie(tcp_ses);
 
         /* queue echo request delayed work */
-        queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
+        queue_delayed_work(system_nrt_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
 
         return tcp_ses;
 
@@ -2245,16 +1877,10 @@ static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
                         return 0;
                 break;
         default:
-                /* NULL username means anonymous session */
-                if (ses->user_name == NULL) {
-                        if (!vol->nullauth)
-                                return 0;
-                        break;
-                }
-
                 /* anything else takes username/password */
-                if (strncmp(ses->user_name,
-                            vol->username ? vol->username : "",
+                if (ses->user_name == NULL)
+                        return 0;
+                if (strncmp(ses->user_name, vol->username,
                             MAX_USERNAME_SIZE))
                         return 0;
                 if (strlen(vol->username) != 0 &&
@@ -2287,10 +1913,10 @@ cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
 static void
 cifs_put_smb_ses(struct cifs_ses *ses)
 {
-        unsigned int xid;
+        int xid;
         struct TCP_Server_Info *server = ses->server;
 
-        cFYI(1, "%s: ses_count=%d", __func__, ses->ses_count);
+        cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
         spin_lock(&cifs_tcp_ses_lock);
         if (--ses->ses_count > 0) {
                 spin_unlock(&cifs_tcp_ses_lock);
@@ -2300,151 +1926,26 @@ cifs_put_smb_ses(struct cifs_ses *ses)
         list_del_init(&ses->smb_ses_list);
         spin_unlock(&cifs_tcp_ses_lock);
 
-        if (ses->status == CifsGood && server->ops->logoff) {
-                xid = get_xid();
-                server->ops->logoff(xid, ses);
-                _free_xid(xid);
+        if (ses->status == CifsGood) {
+                xid = GetXid();
+                CIFSSMBLogoff(xid, ses);
+                _FreeXid(xid);
         }
         sesInfoFree(ses);
         cifs_put_tcp_session(server);
 }
 
-#ifdef CONFIG_KEYS
-
-/* strlen("cifs:a:") + INET6_ADDRSTRLEN + 1 */
-#define CIFSCREDS_DESC_SIZE (7 + INET6_ADDRSTRLEN + 1)
-
-/* Populate username and pw fields from keyring if possible */
-static int
-cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
-{
-        int rc = 0;
-        char *desc, *delim, *payload;
-        ssize_t len;
-        struct key *key;
-        struct TCP_Server_Info *server = ses->server;
-        struct sockaddr_in *sa;
-        struct sockaddr_in6 *sa6;
-        struct user_key_payload *upayload;
-
-        desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
-        if (!desc)
-                return -ENOMEM;
-
-        /* try to find an address key first */
-        switch (server->dstaddr.ss_family) {
-        case AF_INET:
-                sa = (struct sockaddr_in *)&server->dstaddr;
-                sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
-                break;
-        case AF_INET6:
-                sa6 = (struct sockaddr_in6 *)&server->dstaddr;
-                sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
-                break;
-        default:
-                cFYI(1, "Bad ss_family (%hu)", server->dstaddr.ss_family);
-                rc = -EINVAL;
-                goto out_err;
-        }
-
-        cFYI(1, "%s: desc=%s", __func__, desc);
-        key = request_key(&key_type_logon, desc, "");
-        if (IS_ERR(key)) {
-                if (!ses->domainName) {
-                        cFYI(1, "domainName is NULL");
-                        rc = PTR_ERR(key);
-                        goto out_err;
-                }
-
-                /* didn't work, try to find a domain key */
-                sprintf(desc, "cifs:d:%s", ses->domainName);
-                cFYI(1, "%s: desc=%s", __func__, desc);
-                key = request_key(&key_type_logon, desc, "");
-                if (IS_ERR(key)) {
-                        rc = PTR_ERR(key);
-                        goto out_err;
-                }
-        }
-
-        down_read(&key->sem);
-        upayload = key->payload.data;
-        if (IS_ERR_OR_NULL(upayload)) {
-                rc = upayload ? PTR_ERR(upayload) : -EINVAL;
-                goto out_key_put;
-        }
-
-        /* find first : in payload */
-        payload = (char *)upayload->data;
-        delim = strnchr(payload, upayload->datalen, ':');
-        cFYI(1, "payload=%s", payload);
-        if (!delim) {
-                cFYI(1, "Unable to find ':' in payload (datalen=%d)",
-                                upayload->datalen);
-                rc = -EINVAL;
-                goto out_key_put;
-        }
-
-        len = delim - payload;
-        if (len > MAX_USERNAME_SIZE || len <= 0) {
-                cFYI(1, "Bad value from username search (len=%zd)", len);
-                rc = -EINVAL;
-                goto out_key_put;
-        }
-
-        vol->username = kstrndup(payload, len, GFP_KERNEL);
-        if (!vol->username) {
-                cFYI(1, "Unable to allocate %zd bytes for username", len);
-                rc = -ENOMEM;
-                goto out_key_put;
-        }
-        cFYI(1, "%s: username=%s", __func__, vol->username);
-
-        len = key->datalen - (len + 1);
-        if (len > MAX_PASSWORD_SIZE || len <= 0) {
-                cFYI(1, "Bad len for password search (len=%zd)", len);
-                rc = -EINVAL;
-                kfree(vol->username);
-                vol->username = NULL;
-                goto out_key_put;
-        }
-
-        ++delim;
-        vol->password = kstrndup(delim, len, GFP_KERNEL);
-        if (!vol->password) {
-                cFYI(1, "Unable to allocate %zd bytes for password", len);
-                rc = -ENOMEM;
-                kfree(vol->username);
-                vol->username = NULL;
-                goto out_key_put;
-        }
-
-out_key_put:
-        up_read(&key->sem);
-        key_put(key);
-out_err:
-        kfree(desc);
-        cFYI(1, "%s: returning %d", __func__, rc);
-        return rc;
-}
-#else /* ! CONFIG_KEYS */
-static inline int
-cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
-                   struct cifs_ses *ses __attribute__((unused)))
-{
-        return -ENOSYS;
-}
-#endif /* CONFIG_KEYS */
+static bool warned_on_ntlm;  /* globals init to false automatically */
 
 static struct cifs_ses *
 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
 {
-        int rc = -ENOMEM;
-        unsigned int xid;
+        int rc = -ENOMEM, xid;
         struct cifs_ses *ses;
         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
 
-        xid = get_xid();
+        xid = GetXid();
 
         ses = cifs_find_smb_ses(server, volume_info);
         if (ses) {
@@ -2456,7 +1957,7 @@ cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
                         mutex_unlock(&ses->session_mutex);
                         /* problem -- put our ses reference */
                         cifs_put_smb_ses(ses);
-                        free_xid(xid);
+                        FreeXid(xid);
                         return ERR_PTR(rc);
                 }
                 if (ses->need_reconnect) {
@@ -2467,7 +1968,7 @@ cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
                                 mutex_unlock(&ses->session_mutex);
                                 /* problem -- put our reference */
                                 cifs_put_smb_ses(ses);
-                                free_xid(xid);
+                                FreeXid(xid);
                                 return ERR_PTR(rc);
                         }
                 }
@@ -2475,7 +1976,7 @@ cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
 
                 /* existing SMB ses has a server reference already */
                 cifs_put_tcp_session(server);
-                free_xid(xid);
+                FreeXid(xid);
                 return ses;
         }
 
@@ -2511,6 +2012,14 @@ cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
         ses->cred_uid = volume_info->cred_uid;
         ses->linux_uid = volume_info->linux_uid;
 
+        /* ntlmv2 is much stronger than ntlm security, and has been broadly
+        supported for many years, time to update default security mechanism */
+        if ((volume_info->secFlg == 0) && warned_on_ntlm == false) {
+                warned_on_ntlm = true;
+                cERROR(1, "default security mechanism requested.  The default "
+                        "security mechanism will be upgraded from ntlm to "
+                        "ntlmv2 in kernel release 3.2");
+        }
         ses->overrideSecFlg = volume_info->secFlg;
 
         mutex_lock(&ses->session_mutex);
@@ -2526,12 +2035,12 @@ cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
         list_add(&ses->smb_ses_list, &server->smb_ses_list);
         spin_unlock(&cifs_tcp_ses_lock);
 
-        free_xid(xid);
+        FreeXid(xid);
         return ses;
 
 get_ses_fail:
         sesInfoFree(ses);
-        free_xid(xid);
+        FreeXid(xid);
         return ERR_PTR(rc);
 }
 
@@ -2566,10 +2075,10 @@ cifs_find_tcon(struct cifs_ses *ses, const char *unc)
 static void
 cifs_put_tcon(struct cifs_tcon *tcon)
 {
-        unsigned int xid;
+        int xid;
         struct cifs_ses *ses = tcon->ses;
 
-        cFYI(1, "%s: tc_count=%d", __func__, tcon->tc_count);
+        cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
         spin_lock(&cifs_tcp_ses_lock);
         if (--tcon->tc_count > 0) {
                 spin_unlock(&cifs_tcp_ses_lock);
@@ -2579,10 +2088,9 @@ cifs_put_tcon(struct cifs_tcon *tcon)
         list_del_init(&tcon->tcon_list);
         spin_unlock(&cifs_tcp_ses_lock);
 
-        xid = get_xid();
-        if (ses->server->ops->tree_disconnect)
-                ses->server->ops->tree_disconnect(xid, tcon);
-        _free_xid(xid);
+        xid = GetXid();
+        CIFSSMBTDis(xid, tcon);
+        _FreeXid(xid);
 
         cifs_fscache_release_super_cookie(tcon);
         tconInfoFree(tcon);
@@ -2606,11 +2114,6 @@ cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
                 return tcon;
         }
 
-        if (!ses->server->ops->tree_connect) {
-                rc = -ENOSYS;
-                goto out_fail;
-        }
-
         tcon = tconInfoAlloc();
         if (tcon == NULL) {
                 rc = -ENOMEM;
@@ -2626,15 +2129,20 @@ cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
                 }
         }
 
-        /*
-         * BB Do we need to wrap session_mutex around this TCon call and Unix
-         * SetFS as we do on SessSetup and reconnect?
-         */
-        xid = get_xid();
-        rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
-                                            volume_info->local_nls);
-        free_xid(xid);
-        cFYI(1, "Tcon rc = %d", rc);
+        if (strchr(volume_info->UNC + 3, '\\') == NULL
+            && strchr(volume_info->UNC + 3, '/') == NULL) {
+                cERROR(1, "Missing share name");
+                rc = -ENODEV;
+                goto out_fail;
+        }
+
+        /* BB Do we need to wrap session_mutex around
+         * this TCon call and Unix SetFS as
+         * we do on SessSetup and reconnect? */
+        xid = GetXid();
+        rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
+        FreeXid(xid);
+        cFYI(1, "CIFS Tcon rc = %d", rc);
         if (rc)
                 goto out_fail;
 
@@ -2643,15 +2151,13 @@ cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
                 cFYI(1, "DFS disabled (%d)", tcon->Flags);
         }
         tcon->seal = volume_info->seal;
-        /*
-         * We can have only one retry value for a connection to a share so for
-         * resources mounted more than once to the same server share the last
-         * value passed in for the retry flag is used.
-         */
+        /* we can have only one retry value for a connection
+           to a share so for resources mounted more than once
+           to the same server share the last value passed in
+           for the retry flag is used */
         tcon->retry = volume_info->retry;
         tcon->nocase = volume_info->nocase;
         tcon->local_lease = volume_info->local_lease;
-        INIT_LIST_HEAD(&tcon->pending_opens);
 
         spin_lock(&cifs_tcp_ses_lock);
         list_add(&tcon->tcon_list, &ses->tcon_list);
@@ -2703,16 +2209,16 @@ compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
             (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
                 return 0;
 
+        if (old->rsize != new->rsize)
+                return 0;
+
         /*
-         * We want to share sb only if we don't specify an r/wsize or
-         * specified r/wsize is greater than or equal to existing one.
+         * We want to share sb only if we don't specify wsize or specified wsize
+         * is greater or equal than existing one.
          */
         if (new->wsize && new->wsize < old->wsize)
                 return 0;
 
-        if (new->rsize && new->rsize < old->rsize)
-                return 0;
-
         if (old->mnt_uid != new->mnt_uid || old->mnt_gid != new->mnt_gid)
                 return 0;
 
@@ -2739,8 +2245,11 @@ cifs_match_super(struct super_block *sb, void *data)
         struct cifs_ses *ses;
         struct cifs_tcon *tcon;
         struct tcon_link *tlink;
+        struct sockaddr_storage addr;
         int rc = 0;
 
+        memset(&addr, 0, sizeof(struct sockaddr_storage));
+
         spin_lock(&cifs_tcp_ses_lock);
         cifs_sb = CIFS_SB(sb);
         tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
@@ -2754,7 +2263,17 @@ cifs_match_super(struct super_block *sb, void *data)
 
         volume_info = mnt_data->vol;
 
-        if (!match_server(tcp_srv, volume_info) ||
+        if (!volume_info->UNCip || !volume_info->UNC)
+                goto out;
+
+        rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
+                                volume_info->UNCip,
+                                strlen(volume_info->UNCip),
+                                volume_info->port);
+        if (!rc)
+                goto out;
+
+        if (!match_server(tcp_srv, (struct sockaddr *)&addr, volume_info) ||
             !match_session(ses, volume_info) ||
             !match_tcon(tcon, volume_info->UNC)) {
                 rc = 0;
@@ -2769,42 +2288,37 @@ out:
 }
 
 int
-get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
-             const struct nls_table *nls_codepage, unsigned int *num_referrals,
-             struct dfs_info3_param **referrals, int remap)
+get_dfs_path(int xid, struct cifs_ses *pSesInfo, const char *old_path,
+             const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
+             struct dfs_info3_param **preferrals, int remap)
 {
         char *temp_unc;
         int rc = 0;
 
-        if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
-                return -ENOSYS;
-
-        *num_referrals = 0;
-        *referrals = NULL;
+        *pnum_referrals = 0;
+        *preferrals = NULL;
 
-        if (ses->ipc_tid == 0) {
+        if (pSesInfo->ipc_tid == 0) {
                 temp_unc = kmalloc(2 /* for slashes */ +
-                        strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
-                                + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
+                        strnlen(pSesInfo->serverName,
+                                SERVER_NAME_LEN_WITH_NULL * 2)
+                                 + 1 + 4 /* slash IPC$ */  + 2,
+                                GFP_KERNEL);
                 if (temp_unc == NULL)
                         return -ENOMEM;
                 temp_unc[0] = '\\';
                 temp_unc[1] = '\\';
-                strcpy(temp_unc + 2, ses->serverName);
-                strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
-                rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
-                                                    nls_codepage);
-                cFYI(1, "Tcon rc = %d ipc_tid = %d", rc, ses->ipc_tid);
+                strcpy(temp_unc + 2, pSesInfo->serverName);
+                strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
+                rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
+                cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
                 kfree(temp_unc);
         }
         if (rc == 0)
-                rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
-                                                     referrals, num_referrals,
-                                                     nls_codepage, remap);
-        /*
-         * BB - map targetUNCs to dfs_info3 structures, here or in
-         * ses->server->ops->get_dfs_refer.
-         */
+                rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
+                                     pnum_referrals, nls_codepage, remap);
+        /* BB map targetUNCs to dfs_info3 structures, here or
+                in CIFSGetDFSRefer BB */
 
         return rc;
 }
@@ -2873,11 +2387,11 @@ bind_socket(struct TCP_Server_Info *server)
                         saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
                         if (saddr6->sin6_family == AF_INET6)
                                 cERROR(1, "cifs: "
-                                       "Failed to bind to: %pI6c, error: %d",
+                                       "Failed to bind to: %pI6c, error: %d\n",
                                        &saddr6->sin6_addr, rc);
                         else
                                 cERROR(1, "cifs: "
-                                       "Failed to bind to: %pI4, error: %d",
+                                       "Failed to bind to: %pI4, error: %d\n",
                                        &saddr4->sin_addr.s_addr, rc);
                 }
         }
@@ -3073,7 +2587,7 @@ ip_connect(struct TCP_Server_Info *server)
         return generic_ip_connect(server);
 }
 
-void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
+void reset_cifs_unix_caps(int xid, struct cifs_tcon *tcon,
                           struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
 {
         /* if we are reconnecting then should we check to see if
@@ -3142,6 +2656,14 @@ void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
                                         CIFS_MOUNT_POSIX_PATHS;
                 }
 
+                if (cifs_sb && (cifs_sb->rsize > 127 * 1024)) {
+                        if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
+                                cifs_sb->rsize = 127 * 1024;
+                                cFYI(DBG2, "larger reads not supported by srv");
+                        }
+                }
+
+
                 cFYI(1, "Negotiate caps 0x%x", (int)cap);
 #ifdef CONFIG_CIFS_DEBUG2
                 if (cap & CIFS_UNIX_FCNTL_CAP)
@@ -3168,9 +2690,9 @@ void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
                                 cFYI(1, "resetting capabilities failed");
                         } else
                                 cERROR(1, "Negotiating Unix capabilities "
-                                           "with the server failed. Consider "
-                                           "mounting with the Unix Extensions "
-                                           "disabled if problems are found "
+                                           "with the server failed.  Consider "
+                                           "mounting with the Unix Extensions\n"
+                                           "disabled, if problems are found, "
                                            "by specifying the nounix mount "
                                            "option.");
 
@@ -3186,18 +2708,34 @@ void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
         spin_lock_init(&cifs_sb->tlink_tree_lock);
         cifs_sb->tlink_tree = RB_ROOT;
 
+        if (pvolume_info->rsize > CIFSMaxBufSize) {
+                cERROR(1, "rsize %d too large, using MaxBufSize",
+                        pvolume_info->rsize);
+                cifs_sb->rsize = CIFSMaxBufSize;
+        } else if ((pvolume_info->rsize) &&
+                        (pvolume_info->rsize <= CIFSMaxBufSize))
+                cifs_sb->rsize = pvolume_info->rsize;
+        else /* default */
+                cifs_sb->rsize = CIFSMaxBufSize;
+
+        if (cifs_sb->rsize < 2048) {
+                cifs_sb->rsize = 2048;
+                /* Windows ME may prefer this */
+                cFYI(1, "readsize set to minimum: 2048");
+        }
+
         /*
-         * Temporarily set r/wsize for matching superblock. If we end up using
-         * new sb then client will later negotiate it downward if needed.
+         * Temporarily set wsize for matching superblock. If we end up using
+         * new sb then cifs_negotiate_wsize will later negotiate it downward
+         * if needed.
          */
-        cifs_sb->rsize = pvolume_info->rsize;
         cifs_sb->wsize = pvolume_info->wsize;
 
         cifs_sb->mnt_uid = pvolume_info->linux_uid;
         cifs_sb->mnt_gid = pvolume_info->linux_gid;
         cifs_sb->mnt_file_mode = pvolume_info->file_mode;
         cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
-        cFYI(1, "file mode: 0x%hx  dir mode: 0x%hx",
+        cFYI(1, "file mode: 0x%x  dir mode: 0x%x",
                 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
 
         cifs_sb->actimeo = pvolume_info->actimeo;
@@ -3225,14 +2763,6 @@ void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
         if (pvolume_info->cifs_acl)
                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
-        if (pvolume_info->backupuid_specified) {
-                cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
-                cifs_sb->mnt_backupuid = pvolume_info->backupuid;
-        }
-        if (pvolume_info->backupgid_specified) {
-                cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
-                cifs_sb->mnt_backupgid = pvolume_info->backupgid;
-        }
         if (pvolume_info->override_uid)
                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
         if (pvolume_info->override_gid)
@@ -3264,12 +2794,92 @@ void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
                            "mount option supported");
 }
 
+/*
+ * When the server supports very large writes via POSIX extensions, we can
+ * allow up to 2^24-1, minus the size of a WRITE_AND_X header, not including
+ * the RFC1001 length.
+ *
+ * Note that this might make for "interesting" allocation problems during
+ * writeback however as we have to allocate an array of pointers for the
+ * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
+ */
+#define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
+
+/*
+ * When the server doesn't allow large posix writes, only allow a wsize of
+ * 2^17-1 minus the size of the WRITE_AND_X header. That allows for a write up
+ * to the maximum size described by RFC1002.
+ */
+#define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
+
+/*
+ * The default wsize is 1M. find_get_pages seems to return a maximum of 256
+ * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
+ * a single wsize request with a single call.
+ */
+#define CIFS_DEFAULT_WSIZE (1024 * 1024)
+
+static unsigned int
+cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
+{
+        __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
+        struct TCP_Server_Info *server = tcon->ses->server;
+        unsigned int wsize = pvolume_info->wsize ? pvolume_info->wsize :
+                                CIFS_DEFAULT_WSIZE;
+
+        /* can server support 24-bit write sizes? (via UNIX extensions) */
+        if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
+                wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE);
+
+        /*
+         * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
+         * Limit it to max buffer offered by the server, minus the size of the
+         * WRITEX header, not including the 4 byte RFC1001 length.
+         */
+        if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
+            (!(server->capabilities & CAP_UNIX) &&
+             (server->sec_mode & (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED))))
+                wsize = min_t(unsigned int, wsize,
+                                server->maxBuf - sizeof(WRITE_REQ) + 4);
+
+        /* hard limit of CIFS_MAX_WSIZE */
+        wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
+
+        return wsize;
+}
+
+static int
+is_path_accessible(int xid, struct cifs_tcon *tcon,
+                   struct cifs_sb_info *cifs_sb, const char *full_path)
+{
+        int rc;
+        FILE_ALL_INFO *pfile_info;
+
+        pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
+        if (pfile_info == NULL)
+                return -ENOMEM;
+
+        rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
+                              0 /* not legacy */, cifs_sb->local_nls,
+                              cifs_sb->mnt_cifs_flags &
+                                CIFS_MOUNT_MAP_SPECIAL_CHR);
+
+        if (rc == -EOPNOTSUPP || rc == -EINVAL)
+                rc = SMBQueryInformation(xid, tcon, full_path, pfile_info,
+                                cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
+                                  CIFS_MOUNT_MAP_SPECIAL_CHR);
+        kfree(pfile_info);
+        return rc;
+}
+
 static void
 cleanup_volume_info_contents(struct smb_vol *volume_info)
 {
         kfree(volume_info->username);
         kzfree(volume_info->password);
         kfree(volume_info->UNC);
+        if (volume_info->UNCip != volume_info->UNC + 2)
+                kfree(volume_info->UNCip);
         kfree(volume_info->domainname);
         kfree(volume_info->iocharset);
         kfree(volume_info->prepath);
@@ -3286,16 +2896,14 @@ cifs_cleanup_volume_info(struct smb_vol *volume_info)
 
 
 #ifdef CONFIG_CIFS_DFS_UPCALL
-/*
- * cifs_build_path_to_root returns full path to root when we do not have an
- * exiting connection (tcon)
- */
+/* build_path_to_root returns full path to root when
+ * we do not have an exiting connection (tcon) */
 static char *
 build_unc_path_to_root(const struct smb_vol *vol,
                 const struct cifs_sb_info *cifs_sb)
 {
         char *full_path, *pos;
-        unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
+        unsigned int pplen = vol->prepath ? strlen(vol->prepath) : 0;
         unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
 
         full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
@@ -3306,7 +2914,6 @@ build_unc_path_to_root(const struct smb_vol *vol,
         pos = full_path + unc_len;
 
         if (pplen) {
-                *pos++ = CIFS_DIR_SEP(cifs_sb);
                 strncpy(pos, vol->prepath, pplen);
                 pos += pplen;
         }
@@ -3328,7 +2935,7 @@ build_unc_path_to_root(const struct smb_vol *vol,
  * determine whether there were referrals.
  */
 static int
-expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
+expand_dfs_referral(int xid, struct cifs_ses *pSesInfo,
                     struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
                     int check_prefix)
 {
@@ -3344,7 +2951,7 @@ expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
         /* For DFS paths, skip the first '\' of the UNC */
         ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
 
-        rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
+        rc = get_dfs_path(xid, pSesInfo , ref_path, cifs_sb->local_nls,
                           &num_referrals, &referrals,
                           cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
 
@@ -3362,6 +2969,7 @@ expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
                         mdata = NULL;
                 } else {
                         cleanup_volume_info_contents(volume_info);
+                        memset(volume_info, '\0', sizeof(*volume_info));
                         rc = cifs_setup_volume_info(volume_info, mdata,
                                                         fake_devname);
                 }
@@ -3384,9 +2992,10 @@ cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
                 return -EINVAL;
 
         if (volume_info->nullauth) {
-                cFYI(1, "Anonymous login");
-                kfree(volume_info->username);
-                volume_info->username = NULL;
+                cFYI(1, "null user");
+                volume_info->username = kzalloc(1, GFP_KERNEL);
+                if (volume_info->username == NULL)
+                        return -ENOMEM;
         } else if (volume_info->username) {
                 /* BB fixme parse for domain name here */
                 cFYI(1, "Username: %s", volume_info->username);
@@ -3419,7 +3028,7 @@ cifs_get_volume_info(char *mount_data, const char *devname)
         int rc;
         struct smb_vol *volume_info;
 
-        volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
+        volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
         if (!volume_info)
                 return ERR_PTR(-ENOMEM);
 
@@ -3435,11 +3044,11 @@ cifs_get_volume_info(char *mount_data, const char *devname)
 int
 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
 {
-        int rc;
-        unsigned int xid;
-        struct cifs_ses *ses;
+        int rc = 0;
+        int xid;
+        struct cifs_ses *pSesInfo;
         struct cifs_tcon *tcon;
-        struct TCP_Server_Info *server;
+        struct TCP_Server_Info *srvTcp;
         char   *full_path;
         struct tcon_link *tlink;
 #ifdef CONFIG_CIFS_DFS_UPCALL
@@ -3450,45 +3059,46 @@ cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
         if (rc)
                 return rc;
 
+        cifs_sb->bdi.ra_pages = default_backing_dev_info.ra_pages;
+
 #ifdef CONFIG_CIFS_DFS_UPCALL
 try_mount_again:
         /* cleanup activities if we're chasing a referral */
         if (referral_walks_count) {
                 if (tcon)
                         cifs_put_tcon(tcon);
-                else if (ses)
-                        cifs_put_smb_ses(ses);
+                else if (pSesInfo)
+                        cifs_put_smb_ses(pSesInfo);
 
-                free_xid(xid);
+                FreeXid(xid);
         }
 #endif
-        rc = 0;
         tcon = NULL;
-        ses = NULL;
-        server = NULL;
+        pSesInfo = NULL;
+        srvTcp = NULL;
         full_path = NULL;
         tlink = NULL;
 
-        xid = get_xid();
+        xid = GetXid();
 
         /* get a reference to a tcp session */
-        server = cifs_get_tcp_session(volume_info);
-        if (IS_ERR(server)) {
-                rc = PTR_ERR(server);
+        srvTcp = cifs_get_tcp_session(volume_info);
+        if (IS_ERR(srvTcp)) {
+                rc = PTR_ERR(srvTcp);
                 bdi_destroy(&cifs_sb->bdi);
                 goto out;
         }
 
         /* get a reference to a SMB session */
-        ses = cifs_get_smb_ses(server, volume_info);
-        if (IS_ERR(ses)) {
-                rc = PTR_ERR(ses);
-                ses = NULL;
+        pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
+        if (IS_ERR(pSesInfo)) {
+                rc = PTR_ERR(pSesInfo);
+                pSesInfo = NULL;
                 goto mount_fail_check;
         }
 
         /* search for existing tcon to this server share */
-        tcon = cifs_get_tcon(ses, volume_info);
+        tcon = cifs_get_tcon(pSesInfo, volume_info);
         if (IS_ERR(tcon)) {
                 rc = PTR_ERR(tcon);
                 tcon = NULL;
@@ -3496,7 +3106,7 @@ try_mount_again:
         }
 
         /* tell server which Unix caps we support */
-        if (cap_unix(tcon->ses)) {
+        if (tcon->ses->capabilities & CAP_UNIX) {
                 /* reset of caps checks mount to see if unix extensions
                    disabled for just this mount */
                 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
@@ -3509,15 +3119,21 @@ try_mount_again:
         } else
                 tcon->unix_ext = 0; /* server does not support them */
 
-        /* do not care if a following call succeed - informational */
-        if (!tcon->ipc && server->ops->qfs_tcon)
-                server->ops->qfs_tcon(xid, tcon);
+        /* do not care if following two calls succeed - informational */
+        if (!tcon->ipc) {
+                CIFSSMBQFSDeviceInfo(xid, tcon);
+                CIFSSMBQFSAttributeInfo(xid, tcon);
+        }
 
-        cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
-        cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
+        if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
+                cifs_sb->rsize = 1024 * 127;
+                cFYI(DBG2, "no very large read support, rsize now 127K");
+        }
+        if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
+                cifs_sb->rsize = min(cifs_sb->rsize,
+                               (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
 
-        /* tune readahead according to rsize */
-        cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
+        cifs_sb->wsize = cifs_negotiate_wsize(tcon, volume_info);
 
 remote_path_check:
 #ifdef CONFIG_CIFS_DFS_UPCALL
@@ -3529,8 +3145,8 @@ remote_path_check:
          * Chase the referral if found, otherwise continue normally.
          */
         if (referral_walks_count == 0) {
-                int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
-                                                false);
+                int refrc = expand_dfs_referral(xid, pSesInfo, volume_info,
+                                                cifs_sb, false);
                 if (!refrc) {
                         referral_walks_count++;
                         goto try_mount_again;
@@ -3540,20 +3156,13 @@ remote_path_check:
 
         /* check if a whole path is not remote */
         if (!rc && tcon) {
-                if (!server->ops->is_path_accessible) {
-                        rc = -ENOSYS;
-                        goto mount_fail_check;
-                }
-                /*
-                 * cifs_build_path_to_root works only when we have a valid tcon
-                 */
+                /* build_path_to_root works only when we have a valid tcon */
                 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
                 if (full_path == NULL) {
                         rc = -ENOMEM;
                         goto mount_fail_check;
                 }
-                rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
-                                                     full_path);
+                rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
                 if (rc != 0 && rc != -EREMOTE) {
                         kfree(full_path);
                         goto mount_fail_check;
@@ -3575,7 +3184,8 @@ remote_path_check:
                         goto mount_fail_check;
                 }
 
-                rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
+                rc = expand_dfs_referral(xid, pSesInfo, volume_info, cifs_sb,
+                                         true);
 
                 if (!rc) {
                         referral_walks_count++;
@@ -3597,7 +3207,7 @@ remote_path_check:
                 goto mount_fail_check;
         }
 
-        tlink->tl_uid = ses->linux_uid;
+        tlink->tl_uid = pSesInfo->linux_uid;
         tlink->tl_tcon = tcon;
         tlink->tl_time = jiffies;
         set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
@@ -3608,7 +3218,7 @@ remote_path_check:
         tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
         spin_unlock(&cifs_sb->tlink_tree_lock);
 
-        queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
+        queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
                                 TLINK_IDLE_EXPIRE);
 
 mount_fail_check:
@@ -3618,15 +3228,15 @@ mount_fail_check:
                 /* up accidentally freeing someone elses tcon struct */
                 if (tcon)
                         cifs_put_tcon(tcon);
-                else if (ses)
-                        cifs_put_smb_ses(ses);
+                else if (pSesInfo)
+                        cifs_put_smb_ses(pSesInfo);
                 else
-                        cifs_put_tcp_session(server);
+                        cifs_put_tcp_session(srvTcp);
                 bdi_destroy(&cifs_sb->bdi);
         }
 
 out:
-        free_xid(xid);
+        FreeXid(xid);
         return rc;
 }
 
@@ -3635,7 +3245,7 @@ out:
  * pointer may be NULL.
  */
 int
-CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
+CIFSTCon(unsigned int xid, struct cifs_ses *ses,
          const char *tree, struct cifs_tcon *tcon,
          const struct nls_table *nls_codepage)
 {
@@ -3660,7 +3270,7 @@ CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
         header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
                         NULL /*no tid */ , 4 /*wct */ );
 
-        smb_buffer->Mid = get_next_mid(ses->server);
+        smb_buffer->Mid = GetNextMid(ses->server);
         smb_buffer->Uid = ses->Suid;
         pSMB = (TCONX_REQ *) smb_buffer;
         pSMBr = (TCONX_RSP *) smb_buffer_response;
@@ -3691,7 +3301,7 @@ CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
                 else
 #endif /* CIFS_WEAK_PW_HASH */
                 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
-                                        bcc_ptr, nls_codepage);
+                                        bcc_ptr);
 
                 bcc_ptr += CIFS_AUTH_RESP_SIZE;
                 if (ses->capabilities & CAP_UNICODE) {
@@ -3714,7 +3324,7 @@ CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
         if (ses->capabilities & CAP_UNICODE) {
                 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
                 length =
-                    cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
+                    cifs_strtoUCS((__le16 *) bcc_ptr, tree,
                         6 /* max utf8 char length in bytes */ *
                         (/* server len*/ + 256 /* share len */), nls_codepage);
                 bcc_ptr += 2 * length;  /* convert num 16 bit words to bytes */
@@ -3769,7 +3379,7 @@ CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
 
                 /* mostly informational -- no need to fail on error here */
                 kfree(tcon->nativeFileSystem);
-                tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
+                tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
                                                       bytes_left, is_unicode,
                                                       nls_codepage);
 
@@ -3819,22 +3429,22 @@ cifs_umount(struct cifs_sb_info *cifs_sb)
         kfree(cifs_sb);
 }
 
-int
-cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
+int cifs_negotiate_protocol(unsigned int xid, struct cifs_ses *ses)
 {
         int rc = 0;
         struct TCP_Server_Info *server = ses->server;
 
-        if (!server->ops->need_neg || !server->ops->negotiate)
-                return -ENOSYS;
-
         /* only send once per connect */
-        if (!server->ops->need_neg(server))
+        if (server->maxBuf != 0)
                 return 0;
 
-        set_credits(server, 1);
-
-        rc = server->ops->negotiate(xid, ses);
+        rc = CIFSSMBNegotiate(xid, ses);
+        if (rc == -EAGAIN) {
+                /* retry only once on 1st time connection */
+                rc = CIFSSMBNegotiate(xid, ses);
+                if (rc == -EAGAIN)
+                        rc = -EHOSTDOWN;
+        }
         if (rc == 0) {
                 spin_lock(&GlobalMid_Lock);
                 if (server->tcpStatus == CifsNeedNegotiate)
@@ -3842,29 +3452,28 @@ cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
                 else
                         rc = -EHOSTDOWN;
                 spin_unlock(&GlobalMid_Lock);
+
         }
 
         return rc;
 }
 
-int
-cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
-                   struct nls_table *nls_info)
+
+int cifs_setup_session(unsigned int xid, struct cifs_ses *ses,
+                        struct nls_table *nls_info)
 {
-        int rc = -ENOSYS;
+        int rc = 0;
         struct TCP_Server_Info *server = ses->server;
 
         ses->flags = 0;
         ses->capabilities = server->capabilities;
         if (linuxExtEnabled == 0)
-                ses->capabilities &= (~server->vals->cap_unix);
+                ses->capabilities &= (~CAP_UNIX);
 
         cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
                  server->sec_mode, server->capabilities, server->timeAdj);
 
-        if (server->ops->sess_setup)
-                rc = server->ops->sess_setup(xid, ses, nls_info);
-
+        rc = CIFS_SessSetup(xid, ses, nls_info);
         if (rc) {
                 cERROR(1, "Send error in SessSetup = %d", rc);
         } else {
@@ -3894,43 +3503,25 @@ cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
         return rc;
 }
 
-static int
-cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
-{
-        switch (ses->server->secType) {
-        case Kerberos:
-                vol->secFlg = CIFSSEC_MUST_KRB5;
-                return 0;
-        case NTLMv2:
-                vol->secFlg = CIFSSEC_MUST_NTLMV2;
-                break;
-        case NTLM:
-                vol->secFlg = CIFSSEC_MUST_NTLM;
-                break;
-        case RawNTLMSSP:
-                vol->secFlg = CIFSSEC_MUST_NTLMSSP;
-                break;
-        case LANMAN:
-                vol->secFlg = CIFSSEC_MUST_LANMAN;
-                break;
-        }
-
-        return cifs_set_cifscreds(vol, ses);
-}
-
 static struct cifs_tcon *
 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
 {
-        int rc;
         struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
         struct cifs_ses *ses;
         struct cifs_tcon *tcon = NULL;
         struct smb_vol *vol_info;
+        char username[28]; /* big enough for "krb50x" + hex of ULONG_MAX 6+16 */
+                           /* We used to have this as MAX_USERNAME which is   */
+                           /* way too big now (256 instead of 32) */
 
         vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
-        if (vol_info == NULL)
-                return ERR_PTR(-ENOMEM);
+        if (vol_info == NULL) {
+                tcon = ERR_PTR(-ENOMEM);
+                goto out;
+        }
 
+        snprintf(username, sizeof(username), "krb50x%x", fsuid);
+        vol_info->username = username;
         vol_info->local_nls = cifs_sb->local_nls;
         vol_info->linux_uid = fsuid;
         vol_info->cred_uid = fsuid;
@@ -3940,11 +3531,8 @@ cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
         vol_info->local_lease = master_tcon->local_lease;
         vol_info->no_linux_ext = !master_tcon->unix_ext;
 
-        rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
-        if (rc) {
-                tcon = ERR_PTR(rc);
-                goto out;
-        }
+        /* FIXME: allow for other secFlg settings */
+        vol_info->secFlg = CIFSSEC_MUST_KRB5;
 
         /* get a reference for the same TCP session */
         spin_lock(&cifs_tcp_ses_lock);
@@ -3964,11 +3552,9 @@ cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
                 goto out;
         }
 
-        if (cap_unix(ses))
+        if (ses->capabilities & CAP_UNIX)
                 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
 out:
-        kfree(vol_info->username);
-        kfree(vol_info->password);
         kfree(vol_info);
 
         return tcon;
@@ -4161,6 +3747,6 @@ cifs_prune_tlinks(struct work_struct *work)
         }
         spin_unlock(&cifs_sb->tlink_tree_lock);
 
-        queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
+        queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
                                 TLINK_IDLE_EXPIRE);
 }
diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c
index 8719bbe0dcc..72d448bf96c 100644
--- a/fs/cifs/dir.c
+++ b/fs/cifs/dir.c
@@ -44,38 +44,6 @@ renew_parental_timestamps(struct dentry *direntry)
         } while (!IS_ROOT(direntry));
 }
 
-char *
-cifs_build_path_to_root(struct smb_vol *vol, struct cifs_sb_info *cifs_sb,
-                        struct cifs_tcon *tcon)
-{
-        int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
-        int dfsplen;
-        char *full_path = NULL;
-
-        /* if no prefix path, simply set path to the root of share to "" */
-        if (pplen == 0) {
-                full_path = kzalloc(1, GFP_KERNEL);
-                return full_path;
-        }
-
-        if (tcon->Flags & SMB_SHARE_IS_IN_DFS)
-                dfsplen = strnlen(tcon->treeName, MAX_TREE_SIZE + 1);
-        else
-                dfsplen = 0;
-
-        full_path = kmalloc(dfsplen + pplen + 1, GFP_KERNEL);
-        if (full_path == NULL)
-                return full_path;
-
-        if (dfsplen)
-                strncpy(full_path, tcon->treeName, dfsplen);
-        full_path[dfsplen] = CIFS_DIR_SEP(cifs_sb);
-        strncpy(full_path + dfsplen + 1, vol->prepath, pplen);
-        convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
-        full_path[dfsplen + pplen] = 0; /* add trailing null */
-        return full_path;
-}
-
 /* Note: caller must free return buffer */
 char *
 build_path_from_dentry(struct dentry *direntry)
@@ -165,148 +133,108 @@ cifs_bp_rename_retry:
         return full_path;
 }
 
-/*
- * Don't allow the separator character in a path component.
- * The VFS will not allow "/", but "\" is allowed by posix.
- */
-static int
-check_name(struct dentry *direntry)
-{
-        struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
-        int i;
-
-        if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)) {
-                for (i = 0; i < direntry->d_name.len; i++) {
-                        if (direntry->d_name.name[i] == '\\') {
-                                cFYI(1, "Invalid file name");
-                                return -EINVAL;
-                        }
-                }
-        }
-        return 0;
-}
-
-
 /* Inode operations in similar order to how they appear in Linux file fs.h */
 
-static int
-cifs_do_create(struct inode *inode, struct dentry *direntry, unsigned int xid,
-               struct tcon_link *tlink, unsigned oflags, umode_t mode,
-               __u32 *oplock, struct cifs_fid *fid, int *created)
+int
+cifs_create(struct inode *inode, struct dentry *direntry, int mode,
+                struct nameidata *nd)
 {
         int rc = -ENOENT;
+        int xid;
         int create_options = CREATE_NOT_DIR;
-        int desired_access;
-        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
-        struct cifs_tcon *tcon = tlink_tcon(tlink);
+        __u32 oplock = 0;
+        int oflags;
+        /*
+         * BB below access is probably too much for mknod to request
+         *    but we have to do query and setpathinfo so requesting
+         *    less could fail (unless we want to request getatr and setatr
+         *    permissions (only).  At least for POSIX we do not have to
+         *    request so much.
+         */
+        int desiredAccess = GENERIC_READ | GENERIC_WRITE;
+        __u16 fileHandle;
+        struct cifs_sb_info *cifs_sb;
+        struct tcon_link *tlink;
+        struct cifs_tcon *tcon;
         char *full_path = NULL;
         FILE_ALL_INFO *buf = NULL;
         struct inode *newinode = NULL;
-        int disposition;
-        struct TCP_Server_Info *server = tcon->ses->server;
+        int disposition = FILE_OVERWRITE_IF;
+
+        xid = GetXid();
+
+        cifs_sb = CIFS_SB(inode->i_sb);
+        tlink = cifs_sb_tlink(cifs_sb);
+        if (IS_ERR(tlink)) {
+                FreeXid(xid);
+                return PTR_ERR(tlink);
+        }
+        tcon = tlink_tcon(tlink);
 
-        *oplock = 0;
-        if (tcon->ses->server->oplocks)
-                *oplock = REQ_OPLOCK;
+        if (oplockEnabled)
+                oplock = REQ_OPLOCK;
+
+        if (nd)
+                oflags = nd->intent.open.file->f_flags;
+        else
+                oflags = O_RDONLY | O_CREAT;
 
         full_path = build_path_from_dentry(direntry);
         if (full_path == NULL) {
                 rc = -ENOMEM;
-                goto out;
+                goto cifs_create_out;
         }
 
-        if (tcon->unix_ext && cap_unix(tcon->ses) && !tcon->broken_posix_open &&
+        if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
                         le64_to_cpu(tcon->fsUnixInfo.Capability))) {
-                rc = cifs_posix_open(full_path, &newinode, inode->i_sb, mode,
-                                     oflags, oplock, &fid->netfid, xid);
-                switch (rc) {
-                case 0:
-                        if (newinode == NULL) {
-                                /* query inode info */
-                                goto cifs_create_get_file_info;
-                        }
-
-                        if (!S_ISREG(newinode->i_mode)) {
-                                /*
-                                 * The server may allow us to open things like
-                                 * FIFOs, but the client isn't set up to deal
-                                 * with that. If it's not a regular file, just
-                                 * close it and proceed as if it were a normal
-                                 * lookup.
-                                 */
-                                CIFSSMBClose(xid, tcon, fid->netfid);
+                rc = cifs_posix_open(full_path, &newinode,
+                        inode->i_sb, mode, oflags, &oplock, &fileHandle, xid);
+                /* EIO could indicate that (posix open) operation is not
+                   supported, despite what server claimed in capability
+                   negotiation.  EREMOTE indicates DFS junction, which is not
+                   handled in posix open */
+
+                if (rc == 0) {
+                        if (newinode == NULL) /* query inode info */
                                 goto cifs_create_get_file_info;
-                        }
-                        /* success, no need to query */
-                        goto cifs_create_set_dentry;
-
-                case -ENOENT:
-                        goto cifs_create_get_file_info;
-
-                case -EIO:
-                case -EINVAL:
-                        /*
-                         * EIO could indicate that (posix open) operation is not
-                         * supported, despite what server claimed in capability
-                         * negotiation.
-                         *
-                         * POSIX open in samba versions 3.3.1 and earlier could
-                         * incorrectly fail with invalid parameter.
-                         */
-                        tcon->broken_posix_open = true;
-                        break;
-
-                case -EREMOTE:
-                case -EOPNOTSUPP:
-                        /*
-                         * EREMOTE indicates DFS junction, which is not handled
-                         * in posix open.  If either that or op not supported
-                         * returned, follow the normal lookup.
-                         */
-                        break;
-
-                default:
-                        goto out;
-                }
-                /*
-                 * fallthrough to retry, using older open call, this is case
-                 * where server does not support this SMB level, and falsely
-                 * claims capability (also get here for DFS case which should be
-                 * rare for path not covered on files)
-                 */
+                        else /* success, no need to query */
+                                goto cifs_create_set_dentry;
+                } else if ((rc != -EIO) && (rc != -EREMOTE) &&
+                         (rc != -EOPNOTSUPP) && (rc != -EINVAL))
+                        goto cifs_create_out;
+                /* else fallthrough to retry, using older open call, this is
+                   case where server does not support this SMB level, and
+                   falsely claims capability (also get here for DFS case
+                   which should be rare for path not covered on files) */
         }
 
-        desired_access = 0;
-        if (OPEN_FMODE(oflags) & FMODE_READ)
-                desired_access |= GENERIC_READ; /* is this too little? */
-        if (OPEN_FMODE(oflags) & FMODE_WRITE)
-                desired_access |= GENERIC_WRITE;
-
-        disposition = FILE_OVERWRITE_IF;
-        if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
-                disposition = FILE_CREATE;
-        else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
-                disposition = FILE_OVERWRITE_IF;
-        else if ((oflags & O_CREAT) == O_CREAT)
-                disposition = FILE_OPEN_IF;
-        else
-                cFYI(1, "Create flag not set in create function");
-
-        /*
-         * BB add processing to set equivalent of mode - e.g. via CreateX with
-         * ACLs
-         */
-
-        if (!server->ops->open) {
-                rc = -ENOSYS;
-                goto out;
+        if (nd) {
+                /* if the file is going to stay open, then we
+                   need to set the desired access properly */
+                desiredAccess = 0;
+                if (OPEN_FMODE(oflags) & FMODE_READ)
+                        desiredAccess |= GENERIC_READ; /* is this too little? */
+                if (OPEN_FMODE(oflags) & FMODE_WRITE)
+                        desiredAccess |= GENERIC_WRITE;
+
+                if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
+                        disposition = FILE_CREATE;
+                else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
+                        disposition = FILE_OVERWRITE_IF;
+                else if ((oflags & O_CREAT) == O_CREAT)
+                        disposition = FILE_OPEN_IF;
+                else
+                        cFYI(1, "Create flag not set in create function");
         }
 
+        /* BB add processing to set equivalent of mode - e.g. via CreateX with
+           ACLs */
+
         buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
         if (buf == NULL) {
                 rc = -ENOMEM;
-                goto out;
+                goto cifs_create_out;
         }
 
         /*
@@ -316,22 +244,29 @@ cifs_do_create(struct inode *inode, struct dentry *direntry, unsigned int xid,
         if (!tcon->unix_ext && (mode & S_IWUGO) == 0)
                 create_options |= CREATE_OPTION_READONLY;
 
-        if (backup_cred(cifs_sb))
-                create_options |= CREATE_OPEN_BACKUP_INTENT;
-
-        rc = server->ops->open(xid, tcon, full_path, disposition,
-                               desired_access, create_options, fid, oplock,
-                               buf, cifs_sb);
+        if (tcon->ses->capabilities & CAP_NT_SMBS)
+                rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
+                         desiredAccess, create_options,
+                         &fileHandle, &oplock, buf, cifs_sb->local_nls,
+                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
+        else
+                rc = -EIO; /* no NT SMB support fall into legacy open below */
+
+        if (rc == -EIO) {
+                /* old server, retry the open legacy style */
+                rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
+                        desiredAccess, create_options,
+                        &fileHandle, &oplock, buf, cifs_sb->local_nls,
+                        cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
+        }
         if (rc) {
                 cFYI(1, "cifs_create returned 0x%x", rc);
-                goto out;
+                goto cifs_create_out;
         }
 
-        /*
-         * If Open reported that we actually created a file then we now have to
-         * set the mode if possible.
-         */
-        if ((tcon->unix_ext) && (*oplock & CIFS_CREATE_ACTION)) {
+        /* If Open reported that we actually created a file
+           then we now have to set the mode if possible */
+        if ((tcon->unix_ext) && (oplock & CIFS_CREATE_ACTION)) {
                 struct cifs_unix_set_info_args args = {
                                 .mode   = mode,
                                 .ctime  = NO_CHANGE_64,
@@ -340,7 +275,6 @@ cifs_do_create(struct inode *inode, struct dentry *direntry, unsigned int xid,
                                 .device = 0,
                 };
 
-                *created |= FILE_CREATED;
                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
                         args.uid = (__u64) current_fsuid();
                         if (inode->i_mode & S_ISGID)
@@ -351,13 +285,11 @@ cifs_do_create(struct inode *inode, struct dentry *direntry, unsigned int xid,
                         args.uid = NO_CHANGE_64;
                         args.gid = NO_CHANGE_64;
                 }
-                CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid->netfid,
-                                       current->tgid);
+                CIFSSMBUnixSetFileInfo(xid, tcon, &args, fileHandle,
+                                        current->tgid);
         } else {
-                /*
-                 * BB implement mode setting via Windows security
-                 * descriptors e.g.
-                 */
+                /* BB implement mode setting via Windows security
+                   descriptors e.g. */
                 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
 
                 /* Could set r/o dos attribute if mode & 0222 == 0 */
@@ -366,17 +298,15 @@ cifs_do_create(struct inode *inode, struct dentry *direntry, unsigned int xid,
 cifs_create_get_file_info:
         /* server might mask mode so we have to query for it */
         if (tcon->unix_ext)
-                rc = cifs_get_inode_info_unix(&newinode, full_path, inode->i_sb,
-                                              xid);
+                rc = cifs_get_inode_info_unix(&newinode, full_path,
+                                              inode->i_sb, xid);
         else {
-                rc = cifs_get_inode_info(&newinode, full_path, buf, inode->i_sb,
-                                         xid, &fid->netfid);
+                rc = cifs_get_inode_info(&newinode, full_path, buf,
+                                         inode->i_sb, xid, &fileHandle);
                 if (newinode) {
-                        if (server->ops->set_lease_key)
-                                server->ops->set_lease_key(newinode, fid);
                         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
                                 newinode->i_mode = mode;
-                        if ((*oplock & CIFS_CREATE_ACTION) &&
+                        if ((oplock & CIFS_CREATE_ACTION) &&
                             (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)) {
                                 newinode->i_uid = current_fsuid();
                                 if (inode->i_mode & S_ISGID)
@@ -388,167 +318,45 @@ cifs_create_get_file_info:
         }
 
 cifs_create_set_dentry:
-        if (rc != 0) {
+        if (rc == 0)
+                d_instantiate(direntry, newinode);
+        else
                 cFYI(1, "Create worked, get_inode_info failed rc = %d", rc);
-                if (server->ops->close)
-                        server->ops->close(xid, tcon, fid);
-                goto out;
-        }
-        d_drop(direntry);
-        d_add(direntry, newinode);
 
-out:
-        kfree(buf);
-        kfree(full_path);
-        return rc;
-}
-
-int
-cifs_atomic_open(struct inode *inode, struct dentry *direntry,
-                 struct file *file, unsigned oflags, umode_t mode,
-                 int *opened)
-{
-        int rc;
-        unsigned int xid;
-        struct tcon_link *tlink;
-        struct cifs_tcon *tcon;
-        struct TCP_Server_Info *server;
-        struct cifs_fid fid;
-        struct cifs_pending_open open;
-        __u32 oplock;
-        struct cifsFileInfo *file_info;
-
-        /*
-         * Posix open is only called (at lookup time) for file create now. For
-         * opens (rather than creates), because we do not know if it is a file
-         * or directory yet, and current Samba no longer allows us to do posix
-         * open on dirs, we could end up wasting an open call on what turns out
-         * to be a dir. For file opens, we wait to call posix open till
-         * cifs_open.  It could be added to atomic_open in the future but the
-         * performance tradeoff of the extra network request when EISDIR or
-         * EACCES is returned would have to be weighed against the 50% reduction
-         * in network traffic in the other paths.
-         */
-        if (!(oflags & O_CREAT)) {
-                struct dentry *res;
-
-                /*
-                 * Check for hashed negative dentry. We have already revalidated
-                 * the dentry and it is fine. No need to perform another lookup.
-                 */
-                if (!d_unhashed(direntry))
-                        return -ENOENT;
-
-                res = cifs_lookup(inode, direntry, 0);
-                if (IS_ERR(res))
-                        return PTR_ERR(res);
-
-                return finish_no_open(file, res);
-        }
-
-        rc = check_name(direntry);
-        if (rc)
-                return rc;
-
-        xid = get_xid();
-
-        cFYI(1, "parent inode = 0x%p name is: %s and dentry = 0x%p",
-             inode, direntry->d_name.name, direntry);
-
-        tlink = cifs_sb_tlink(CIFS_SB(inode->i_sb));
-        if (IS_ERR(tlink))
-                goto out_free_xid;
-
-        tcon = tlink_tcon(tlink);
-        server = tcon->ses->server;
-
-        if (server->ops->new_lease_key)
-                server->ops->new_lease_key(&fid);
-
-        cifs_add_pending_open(&fid, tlink, &open);
-
-        rc = cifs_do_create(inode, direntry, xid, tlink, oflags, mode,
-                            &oplock, &fid, opened);
+        if (newinode && nd) {
+                struct cifsFileInfo *pfile_info;
+                struct file *filp;
 
-        if (rc) {
-                cifs_del_pending_open(&open);
-                goto out;
-        }
-
-        rc = finish_open(file, direntry, generic_file_open, opened);
-        if (rc) {
-                if (server->ops->close)
-                        server->ops->close(xid, tcon, &fid);
-                cifs_del_pending_open(&open);
-                goto out;
-        }
+                filp = lookup_instantiate_filp(nd, direntry, generic_file_open);
+                if (IS_ERR(filp)) {
+                        rc = PTR_ERR(filp);
+                        CIFSSMBClose(xid, tcon, fileHandle);
+                        goto cifs_create_out;
+                }
 
-        file_info = cifs_new_fileinfo(&fid, file, tlink, oplock);
-        if (file_info == NULL) {
-                if (server->ops->close)
-                        server->ops->close(xid, tcon, &fid);
-                cifs_del_pending_open(&open);
-                rc = -ENOMEM;
+                pfile_info = cifs_new_fileinfo(fileHandle, filp, tlink, oplock);
+                if (pfile_info == NULL) {
+                        fput(filp);
+                        CIFSSMBClose(xid, tcon, fileHandle);
+                        rc = -ENOMEM;
+                }
+        } else {
+                CIFSSMBClose(xid, tcon, fileHandle);
         }
 
-out:
-        cifs_put_tlink(tlink);
-out_free_xid:
-        free_xid(xid);
-        return rc;
-}
-
-int cifs_create(struct inode *inode, struct dentry *direntry, umode_t mode,
-                bool excl)
-{
-        int rc;
-        unsigned int xid = get_xid();
-        /*
-         * BB below access is probably too much for mknod to request
-         *    but we have to do query and setpathinfo so requesting
-         *    less could fail (unless we want to request getatr and setatr
-         *    permissions (only).  At least for POSIX we do not have to
-         *    request so much.
-         */
-        unsigned oflags = O_EXCL | O_CREAT | O_RDWR;
-        struct tcon_link *tlink;
-        struct cifs_tcon *tcon;
-        struct TCP_Server_Info *server;
-        struct cifs_fid fid;
-        __u32 oplock;
-        int created = FILE_CREATED;
-
-        cFYI(1, "cifs_create parent inode = 0x%p name is: %s and dentry = 0x%p",
-             inode, direntry->d_name.name, direntry);
-
-        tlink = cifs_sb_tlink(CIFS_SB(inode->i_sb));
-        rc = PTR_ERR(tlink);
-        if (IS_ERR(tlink))
-                goto out_free_xid;
-
-        tcon = tlink_tcon(tlink);
-        server = tcon->ses->server;
-
-        if (server->ops->new_lease_key)
-                server->ops->new_lease_key(&fid);
-
-        rc = cifs_do_create(inode, direntry, xid, tlink, oflags, mode,
-                            &oplock, &fid, &created);
-        if (!rc && server->ops->close)
-                server->ops->close(xid, tcon, &fid);
-
+cifs_create_out:
+        kfree(buf);
+        kfree(full_path);
         cifs_put_tlink(tlink);
-out_free_xid:
-        free_xid(xid);
+        FreeXid(xid);
         return rc;
 }
 
-int cifs_mknod(struct inode *inode, struct dentry *direntry, umode_t mode,
+int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode,
                 dev_t device_number)
 {
         int rc = -EPERM;
-        unsigned int xid;
-        int create_options = CREATE_NOT_DIR | CREATE_OPTION_SPECIAL;
+        int xid;
         struct cifs_sb_info *cifs_sb;
         struct tcon_link *tlink;
         struct cifs_tcon *pTcon;
@@ -571,7 +379,7 @@ int cifs_mknod(struct inode *inode, struct dentry *direntry, umode_t mode,
 
         pTcon = tlink_tcon(tlink);
 
-        xid = get_xid();
+        xid = GetXid();
 
         full_path = build_path_from_dentry(direntry);
         if (full_path == NULL) {
@@ -619,15 +427,13 @@ int cifs_mknod(struct inode *inode, struct dentry *direntry, umode_t mode,
         if (buf == NULL) {
                 kfree(full_path);
                 rc = -ENOMEM;
-                free_xid(xid);
+                FreeXid(xid);
                 return rc;
         }
 
-        if (backup_cred(cifs_sb))
-                create_options |= CREATE_OPEN_BACKUP_INTENT;
-
+        /* FIXME: would WRITE_OWNER | WRITE_DAC be better? */
         rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_CREATE,
-                         GENERIC_WRITE, create_options,
+                         GENERIC_WRITE, CREATE_NOT_DIR | CREATE_OPTION_SPECIAL,
                          &fileHandle, &oplock, buf, cifs_sb->local_nls,
                          cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
         if (rc)
@@ -669,24 +475,29 @@ int cifs_mknod(struct inode *inode, struct dentry *direntry, umode_t mode,
 mknod_out:
         kfree(full_path);
         kfree(buf);
-        free_xid(xid);
+        FreeXid(xid);
         cifs_put_tlink(tlink);
         return rc;
 }
 
 struct dentry *
 cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
-            unsigned int flags)
+            struct nameidata *nd)
 {
-        unsigned int xid;
+        int xid;
         int rc = 0; /* to get around spurious gcc warning, set to zero here */
+        __u32 oplock = 0;
+        __u16 fileHandle = 0;
+        bool posix_open = false;
         struct cifs_sb_info *cifs_sb;
         struct tcon_link *tlink;
         struct cifs_tcon *pTcon;
+        struct cifsFileInfo *cfile;
         struct inode *newInode = NULL;
         char *full_path = NULL;
+        struct file *filp;
 
-        xid = get_xid();
+        xid = GetXid();
 
         cFYI(1, "parent inode = 0x%p name is: %s and dentry = 0x%p",
               parent_dir_inode, direntry->d_name.name, direntry);
@@ -696,14 +507,34 @@ cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
         cifs_sb = CIFS_SB(parent_dir_inode->i_sb);
         tlink = cifs_sb_tlink(cifs_sb);
         if (IS_ERR(tlink)) {
-                free_xid(xid);
+                FreeXid(xid);
                 return (struct dentry *)tlink;
         }
         pTcon = tlink_tcon(tlink);
 
-        rc = check_name(direntry);
-        if (rc)
+        /*
+         * Don't allow the separator character in a path component.
+         * The VFS will not allow "/", but "\" is allowed by posix.
+         */
+        if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)) {
+                int i;
+                for (i = 0; i < direntry->d_name.len; i++)
+                        if (direntry->d_name.name[i] == '\\') {
+                                cFYI(1, "Invalid file name");
+                                rc = -EINVAL;
+                                goto lookup_out;
+                        }
+        }
+
+        /*
+         * O_EXCL: optimize away the lookup, but don't hash the dentry. Let
+         * the VFS handle the create.
+         */
+        if (nd && (nd->flags & LOOKUP_EXCL)) {
+                d_instantiate(direntry, NULL);
+                rc = 0;
                 goto lookup_out;
+        }
 
         /* can not grab the rename sem here since it would
         deadlock in the cases (beginning of sys_rename itself)
@@ -721,16 +552,64 @@ cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
         }
         cFYI(1, "Full path: %s inode = 0x%p", full_path, direntry->d_inode);
 
+        /* Posix open is only called (at lookup time) for file create now.
+         * For opens (rather than creates), because we do not know if it
+         * is a file or directory yet, and current Samba no longer allows
+         * us to do posix open on dirs, we could end up wasting an open call
+         * on what turns out to be a dir. For file opens, we wait to call posix
+         * open till cifs_open.  It could be added here (lookup) in the future
+         * but the performance tradeoff of the extra network request when EISDIR
+         * or EACCES is returned would have to be weighed against the 50%
+         * reduction in network traffic in the other paths.
+         */
         if (pTcon->unix_ext) {
-                rc = cifs_get_inode_info_unix(&newInode, full_path,
-                                              parent_dir_inode->i_sb, xid);
-        } else {
+                if (nd && !(nd->flags & LOOKUP_DIRECTORY) &&
+                     (nd->flags & LOOKUP_OPEN) && !pTcon->broken_posix_open &&
+                     (nd->intent.open.file->f_flags & O_CREAT)) {
+                        rc = cifs_posix_open(full_path, &newInode,
+                                        parent_dir_inode->i_sb,
+                                        nd->intent.open.create_mode,
+                                        nd->intent.open.file->f_flags, &oplock,
+                                        &fileHandle, xid);
+                        /*
+                         * The check below works around a bug in POSIX
+                         * open in samba versions 3.3.1 and earlier where
+                         * open could incorrectly fail with invalid parameter.
+                         * If either that or op not supported returned, follow
+                         * the normal lookup.
+                         */
+                        if ((rc == 0) || (rc == -ENOENT))
+                                posix_open = true;
+                        else if ((rc == -EINVAL) || (rc != -EOPNOTSUPP))
+                                pTcon->broken_posix_open = true;
+                }
+                if (!posix_open)
+                        rc = cifs_get_inode_info_unix(&newInode, full_path,
+                                                parent_dir_inode->i_sb, xid);
+        } else
                 rc = cifs_get_inode_info(&newInode, full_path, NULL,
                                 parent_dir_inode->i_sb, xid, NULL);
-        }
 
         if ((rc == 0) && (newInode != NULL)) {
                 d_add(direntry, newInode);
+                if (posix_open) {
+                        filp = lookup_instantiate_filp(nd, direntry,
+                                                       generic_file_open);
+                        if (IS_ERR(filp)) {
+                                rc = PTR_ERR(filp);
+                                CIFSSMBClose(xid, pTcon, fileHandle);
+                                goto lookup_out;
+                        }
+
+                        cfile = cifs_new_fileinfo(fileHandle, filp, tlink,
+                                                  oplock);
+                        if (cfile == NULL) {
+                                fput(filp);
+                                CIFSSMBClose(xid, pTcon, fileHandle);
+                                rc = -ENOMEM;
+                                goto lookup_out;
+                        }
+                }
                 /* since paths are not looked up by component - the parent
                    directories are presumed to be good here */
                 renew_parental_timestamps(direntry);
@@ -750,43 +629,28 @@ cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
 lookup_out:
         kfree(full_path);
         cifs_put_tlink(tlink);
-        free_xid(xid);
+        FreeXid(xid);
         return ERR_PTR(rc);
 }
 
 static int
-cifs_d_revalidate(struct dentry *direntry, unsigned int flags)
+cifs_d_revalidate(struct dentry *direntry, struct nameidata *nd)
 {
-        if (flags & LOOKUP_RCU)
+        if (nd && (nd->flags & LOOKUP_RCU))
                 return -ECHILD;
 
         if (direntry->d_inode) {
                 if (cifs_revalidate_dentry(direntry))
                         return 0;
-                else {
-                        /*
-                         * If the inode wasn't known to be a dfs entry when
-                         * the dentry was instantiated, such as when created
-                         * via ->readdir(), it needs to be set now since the
-                         * attributes will have been updated by
-                         * cifs_revalidate_dentry().
-                         */
-                        if (IS_AUTOMOUNT(direntry->d_inode) &&
-                           !(direntry->d_flags & DCACHE_NEED_AUTOMOUNT)) {
-                                spin_lock(&direntry->d_lock);
-                                direntry->d_flags |= DCACHE_NEED_AUTOMOUNT;
-                                spin_unlock(&direntry->d_lock);
-                        }
-
+                else
                         return 1;
-                }
         }
 
         /*
          * This may be nfsd (or something), anyway, we can't see the
          * intent of this. So, since this can be for creation, drop it.
          */
-        if (!flags)
+        if (!nd)
                 return 0;
 
         /*
@@ -794,7 +658,7 @@ cifs_d_revalidate(struct dentry *direntry, unsigned int flags)
          * case sensitive name which is specified by user if this is
          * for creation.
          */
-        if (flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
+        if (nd->flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
                 return 0;
 
         if (time_after(jiffies, direntry->d_time + HZ) || !lookupCacheEnabled)
diff --git a/fs/cifs/export.c b/fs/cifs/export.c
index 9c7ecdccf2f..55d87ac5200 100644
--- a/fs/cifs/export.c
+++ b/fs/cifs/export.c
@@ -45,7 +45,7 @@
 #include "cifs_debug.h"
 #include "cifsfs.h"
 
-#ifdef CONFIG_CIFS_NFSD_EXPORT
+#ifdef CIFS_NFSD_EXPORT
 static struct dentry *cifs_get_parent(struct dentry *dentry)
 {
         /* BB need to add code here eventually to enable export via NFSD */
@@ -63,5 +63,5 @@ const struct export_operations cifs_export_ops = {
         .encode_fs =  */
 };
 
-#endif /* CONFIG_CIFS_NFSD_EXPORT */
+#endif /* CIFS_NFSD_EXPORT */
 
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 8ea6ca50a66..9f41a10523a 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -32,7 +32,6 @@
 #include <linux/delay.h>
 #include <linux/mount.h>
 #include <linux/slab.h>
-#include <linux/swap.h>
 #include <asm/div64.h>
 #include "cifsfs.h"
 #include "cifspdu.h"
@@ -107,7 +106,7 @@ static inline int cifs_get_disposition(unsigned int flags)
 
 int cifs_posix_open(char *full_path, struct inode **pinode,
                         struct super_block *sb, int mode, unsigned int f_flags,
-                        __u32 *poplock, __u16 *pnetfid, unsigned int xid)
+                        __u32 *poplock, __u16 *pnetfid, int xid)
 {
         int rc;
         FILE_UNIX_BASIC_INFO *presp_data;
@@ -169,20 +168,15 @@ posix_open_ret:
 
 static int
 cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
-             struct cifs_tcon *tcon, unsigned int f_flags, __u32 *oplock,
-             struct cifs_fid *fid, unsigned int xid)
+             struct cifs_tcon *tcon, unsigned int f_flags, __u32 *poplock,
+             __u16 *pnetfid, int xid)
 {
         int rc;
-        int desired_access;
+        int desiredAccess;
         int disposition;
-        int create_options = CREATE_NOT_DIR;
         FILE_ALL_INFO *buf;
-        struct TCP_Server_Info *server = tcon->ses->server;
 
-        if (!server->ops->open)
-                return -ENOSYS;
-
-        desired_access = cifs_convert_flags(f_flags);
+        desiredAccess = cifs_convert_flags(f_flags);
 
 /*********************************************************************
  *  open flag mapping table:
@@ -216,12 +210,16 @@ cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
         if (!buf)
                 return -ENOMEM;
 
-        if (backup_cred(cifs_sb))
-                create_options |= CREATE_OPEN_BACKUP_INTENT;
-
-        rc = server->ops->open(xid, tcon, full_path, disposition,
-                               desired_access, create_options, fid, oplock, buf,
-                               cifs_sb);
+        if (tcon->ses->capabilities & CAP_NT_SMBS)
+                rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
+                         desiredAccess, CREATE_NOT_DIR, pnetfid, poplock, buf,
+                         cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
+                                 & CIFS_MOUNT_MAP_SPECIAL_CHR);
+        else
+                rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
+                        desiredAccess, CREATE_NOT_DIR, pnetfid, poplock, buf,
+                        cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
+                                & CIFS_MOUNT_MAP_SPECIAL_CHR);
 
         if (rc)
                 goto out;
@@ -231,105 +229,52 @@ cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
                                               xid);
         else
                 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
-                                         xid, &fid->netfid);
+                                         xid, pnetfid);
 
 out:
         kfree(buf);
         return rc;
 }
 
-static bool
-cifs_has_mand_locks(struct cifsInodeInfo *cinode)
-{
-        struct cifs_fid_locks *cur;
-        bool has_locks = false;
-
-        down_read(&cinode->lock_sem);
-        list_for_each_entry(cur, &cinode->llist, llist) {
-                if (!list_empty(&cur->locks)) {
-                        has_locks = true;
-                        break;
-                }
-        }
-        up_read(&cinode->lock_sem);
-        return has_locks;
-}
-
 struct cifsFileInfo *
-cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
+cifs_new_fileinfo(__u16 fileHandle, struct file *file,
                   struct tcon_link *tlink, __u32 oplock)
 {
         struct dentry *dentry = file->f_path.dentry;
         struct inode *inode = dentry->d_inode;
-        struct cifsInodeInfo *cinode = CIFS_I(inode);
-        struct cifsFileInfo *cfile;
-        struct cifs_fid_locks *fdlocks;
-        struct cifs_tcon *tcon = tlink_tcon(tlink);
-        struct TCP_Server_Info *server = tcon->ses->server;
-
-        cfile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
-        if (cfile == NULL)
-                return cfile;
-
-        fdlocks = kzalloc(sizeof(struct cifs_fid_locks), GFP_KERNEL);
-        if (!fdlocks) {
-                kfree(cfile);
-                return NULL;
-        }
-
-        INIT_LIST_HEAD(&fdlocks->locks);
-        fdlocks->cfile = cfile;
-        cfile->llist = fdlocks;
-        down_write(&cinode->lock_sem);
-        list_add(&fdlocks->llist, &cinode->llist);
-        up_write(&cinode->lock_sem);
-
-        cfile->count = 1;
-        cfile->pid = current->tgid;
-        cfile->uid = current_fsuid();
-        cfile->dentry = dget(dentry);
-        cfile->f_flags = file->f_flags;
-        cfile->invalidHandle = false;
-        cfile->tlink = cifs_get_tlink(tlink);
-        INIT_WORK(&cfile->oplock_break, cifs_oplock_break);
-        mutex_init(&cfile->fh_mutex);
-
-        /*
-         * If the server returned a read oplock and we have mandatory brlocks,
-         * set oplock level to None.
-         */
-        if (oplock == server->vals->oplock_read &&
-                                                cifs_has_mand_locks(cinode)) {
-                cFYI(1, "Reset oplock val from read to None due to mand locks");
-                oplock = 0;
-        }
+        struct cifsInodeInfo *pCifsInode = CIFS_I(inode);
+        struct cifsFileInfo *pCifsFile;
+
+        pCifsFile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
+        if (pCifsFile == NULL)
+                return pCifsFile;
+
+        pCifsFile->count = 1;
+        pCifsFile->netfid = fileHandle;
+        pCifsFile->pid = current->tgid;
+        pCifsFile->uid = current_fsuid();
+        pCifsFile->dentry = dget(dentry);
+        pCifsFile->f_flags = file->f_flags;
+        pCifsFile->invalidHandle = false;
+        pCifsFile->tlink = cifs_get_tlink(tlink);
+        mutex_init(&pCifsFile->fh_mutex);
+        mutex_init(&pCifsFile->lock_mutex);
+        INIT_LIST_HEAD(&pCifsFile->llist);
+        INIT_WORK(&pCifsFile->oplock_break, cifs_oplock_break);
 
         spin_lock(&cifs_file_list_lock);
-        if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE && oplock)
-                oplock = fid->pending_open->oplock;
-        list_del(&fid->pending_open->olist);
-
-        server->ops->set_fid(cfile, fid, oplock);
-
-        list_add(&cfile->tlist, &tcon->openFileList);
+        list_add(&pCifsFile->tlist, &(tlink_tcon(tlink)->openFileList));
         /* if readable file instance put first in list*/
         if (file->f_mode & FMODE_READ)
-                list_add(&cfile->flist, &cinode->openFileList);
+                list_add(&pCifsFile->flist, &pCifsInode->openFileList);
         else
-                list_add_tail(&cfile->flist, &cinode->openFileList);
+                list_add_tail(&pCifsFile->flist, &pCifsInode->openFileList);
         spin_unlock(&cifs_file_list_lock);
 
-        file->private_data = cfile;
-        return cfile;
-}
+        cifs_set_oplock_level(pCifsInode, oplock);
 
-struct cifsFileInfo *
-cifsFileInfo_get(struct cifsFileInfo *cifs_file)
-{
-        spin_lock(&cifs_file_list_lock);
-        cifsFileInfo_get_locked(cifs_file);
-        spin_unlock(&cifs_file_list_lock);
-        return cifs_file;
+        file->private_data = pCifsFile;
+        return pCifsFile;
 }
 
 /*
@@ -341,12 +286,9 @@ void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
 {
         struct inode *inode = cifs_file->dentry->d_inode;
         struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
-        struct TCP_Server_Info *server = tcon->ses->server;
         struct cifsInodeInfo *cifsi = CIFS_I(inode);
         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
         struct cifsLockInfo *li, *tmp;
-        struct cifs_fid fid;
-        struct cifs_pending_open open;
 
         spin_lock(&cifs_file_list_lock);
         if (--cifs_file->count > 0) {
@@ -354,12 +296,6 @@ void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
                 return;
         }
 
-        if (server->ops->get_lease_key)
-                server->ops->get_lease_key(inode, &fid);
-
-        /* store open in pending opens to make sure we don't miss lease break */
-        cifs_add_pending_open_locked(&fid, cifs_file->tlink, &open);
-
         /* remove it from the lists */
         list_del(&cifs_file->flist);
         list_del(&cifs_file->tlist);
@@ -367,13 +303,13 @@ void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
         if (list_empty(&cifsi->openFileList)) {
                 cFYI(1, "closing last open instance for inode %p",
                         cifs_file->dentry->d_inode);
-                /*
-                 * In strict cache mode we need invalidate mapping on the last
-                 * close  because it may cause a error when we open this file
-                 * again and get at least level II oplock.
-                 */
+
+                /* in strict cache mode we need invalidate mapping on the last
+                   close  because it may cause a error when we open this file
+                   again and get at least level II oplock */
                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
                         CIFS_I(inode)->invalid_mapping = true;
+
                 cifs_set_oplock_level(cifsi, 0);
         }
         spin_unlock(&cifs_file_list_lock);
@@ -381,30 +317,22 @@ void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
         cancel_work_sync(&cifs_file->oplock_break);
 
         if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
-                struct TCP_Server_Info *server = tcon->ses->server;
-                unsigned int xid;
+                int xid, rc;
 
-                xid = get_xid();
-                if (server->ops->close)
-                        server->ops->close(xid, tcon, &cifs_file->fid);
-                _free_xid(xid);
+                xid = GetXid();
+                rc = CIFSSMBClose(xid, tcon, cifs_file->netfid);
+                FreeXid(xid);
         }
 
-        cifs_del_pending_open(&open);
-
-        /*
-         * Delete any outstanding lock records. We'll lose them when the file
+        /* Delete any outstanding lock records. We'll lose them when the file
          * is closed anyway.
          */
-        down_write(&cifsi->lock_sem);
-        list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
+        mutex_lock(&cifs_file->lock_mutex);
+        list_for_each_entry_safe(li, tmp, &cifs_file->llist, llist) {
                 list_del(&li->llist);
-                cifs_del_lock_waiters(li);
                 kfree(li);
         }
-        list_del(&cifs_file->llist->llist);
-        kfree(cifs_file->llist);
-        up_write(&cifsi->lock_sem);
+        mutex_unlock(&cifs_file->lock_mutex);
 
         cifs_put_tlink(cifs_file->tlink);
         dput(cifs_file->dentry);
@@ -412,31 +340,27 @@ void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
 }
 
 int cifs_open(struct inode *inode, struct file *file)
-
 {
         int rc = -EACCES;
-        unsigned int xid;
+        int xid;
         __u32 oplock;
         struct cifs_sb_info *cifs_sb;
-        struct TCP_Server_Info *server;
         struct cifs_tcon *tcon;
         struct tcon_link *tlink;
-        struct cifsFileInfo *cfile = NULL;
+        struct cifsFileInfo *pCifsFile = NULL;
         char *full_path = NULL;
         bool posix_open_ok = false;
-        struct cifs_fid fid;
-        struct cifs_pending_open open;
+        __u16 netfid;
 
-        xid = get_xid();
+        xid = GetXid();
 
         cifs_sb = CIFS_SB(inode->i_sb);
         tlink = cifs_sb_tlink(cifs_sb);
         if (IS_ERR(tlink)) {
-                free_xid(xid);
+                FreeXid(xid);
                 return PTR_ERR(tlink);
         }
         tcon = tlink_tcon(tlink);
-        server = tcon->ses->server;
 
         full_path = build_path_from_dentry(file->f_path.dentry);
         if (full_path == NULL) {
@@ -447,18 +371,19 @@ int cifs_open(struct inode *inode, struct file *file)
         cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
                  inode, file->f_flags, full_path);
 
-        if (server->oplocks)
+        if (oplockEnabled)
                 oplock = REQ_OPLOCK;
         else
                 oplock = 0;
 
         if (!tcon->broken_posix_open && tcon->unix_ext &&
-            cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
-                                le64_to_cpu(tcon->fsUnixInfo.Capability))) {
+            (tcon->ses->capabilities & CAP_UNIX) &&
+            (CIFS_UNIX_POSIX_PATH_OPS_CAP &
+                        le64_to_cpu(tcon->fsUnixInfo.Capability))) {
                 /* can not refresh inode info since size could be stale */
                 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
                                 cifs_sb->mnt_file_mode /* ignored */,
-                                file->f_flags, &oplock, &fid.netfid, xid);
+                                file->f_flags, &oplock, &netfid, xid);
                 if (rc == 0) {
                         cFYI(1, "posix open succeeded");
                         posix_open_ok = true;
@@ -474,34 +399,20 @@ int cifs_open(struct inode *inode, struct file *file)
                 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
                          (rc != -EOPNOTSUPP)) /* path not found or net err */
                         goto out;
-                /*
-                 * Else fallthrough to retry open the old way on network i/o
-                 * or DFS errors.
-                 */
+                /* else fallthrough to retry open the old way on network i/o
+                   or DFS errors */
         }
 
-        if (server->ops->get_lease_key)
-                server->ops->get_lease_key(inode, &fid);
-
-        cifs_add_pending_open(&fid, tlink, &open);
-
         if (!posix_open_ok) {
-                if (server->ops->get_lease_key)
-                        server->ops->get_lease_key(inode, &fid);
-
                 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
-                                  file->f_flags, &oplock, &fid, xid);
-                if (rc) {
-                        cifs_del_pending_open(&open);
+                                  file->f_flags, &oplock, &netfid, xid);
+                if (rc)
                         goto out;
-                }
         }
 
-        cfile = cifs_new_fileinfo(&fid, file, tlink, oplock);
-        if (cfile == NULL) {
-                if (server->ops->close)
-                        server->ops->close(xid, tcon, &fid);
-                cifs_del_pending_open(&open);
+        pCifsFile = cifs_new_fileinfo(netfid, file, tlink, oplock);
+        if (pCifsFile == NULL) {
+                CIFSSMBClose(xid, tcon, netfid);
                 rc = -ENOMEM;
                 goto out;
         }
@@ -509,10 +420,8 @@ int cifs_open(struct inode *inode, struct file *file)
         cifs_fscache_set_inode_cookie(inode, file);
 
         if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
-                /*
-                 * Time to set mode which we can not set earlier due to
-                 * problems creating new read-only files.
-                 */
+                /* time to set mode which we can not set earlier due to
+                   problems creating new read-only files */
                 struct cifs_unix_set_info_args args = {
                         .mode   = inode->i_mode,
                         .uid    = NO_CHANGE_64,
@@ -522,180 +431,147 @@ int cifs_open(struct inode *inode, struct file *file)
                         .mtime  = NO_CHANGE_64,
                         .device = 0,
                 };
-                CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
-                                       cfile->pid);
+                CIFSSMBUnixSetFileInfo(xid, tcon, &args, netfid,
+                                        pCifsFile->pid);
         }
 
 out:
         kfree(full_path);
-        free_xid(xid);
+        FreeXid(xid);
         cifs_put_tlink(tlink);
         return rc;
 }
 
-static int cifs_push_posix_locks(struct cifsFileInfo *cfile);
-
-/*
- * Try to reacquire byte range locks that were released when session
- * to server was lost.
- */
-static int
-cifs_relock_file(struct cifsFileInfo *cfile)
+/* Try to reacquire byte range locks that were released when session */
+/* to server was lost */
+static int cifs_relock_file(struct cifsFileInfo *cifsFile)
 {
-        struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
-        struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
-        struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
         int rc = 0;
 
-        /* we are going to update can_cache_brlcks here - need a write access */
-        down_write(&cinode->lock_sem);
-        if (cinode->can_cache_brlcks) {
-                /* can cache locks - no need to push them */
-                up_write(&cinode->lock_sem);
-                return rc;
-        }
-
-        if (cap_unix(tcon->ses) &&
-            (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
-            ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
-                rc = cifs_push_posix_locks(cfile);
-        else
-                rc = tcon->ses->server->ops->push_mand_locks(cfile);
+/* BB list all locks open on this file and relock */
 
-        up_write(&cinode->lock_sem);
         return rc;
 }
 
-static int
-cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
+static int cifs_reopen_file(struct cifsFileInfo *pCifsFile, bool can_flush)
 {
         int rc = -EACCES;
-        unsigned int xid;
+        int xid;
         __u32 oplock;
         struct cifs_sb_info *cifs_sb;
         struct cifs_tcon *tcon;
-        struct TCP_Server_Info *server;
-        struct cifsInodeInfo *cinode;
+        struct cifsInodeInfo *pCifsInode;
         struct inode *inode;
         char *full_path = NULL;
-        int desired_access;
+        int desiredAccess;
         int disposition = FILE_OPEN;
-        int create_options = CREATE_NOT_DIR;
-        struct cifs_fid fid;
+        __u16 netfid;
 
-        xid = get_xid();
-        mutex_lock(&cfile->fh_mutex);
-        if (!cfile->invalidHandle) {
-                mutex_unlock(&cfile->fh_mutex);
+        xid = GetXid();
+        mutex_lock(&pCifsFile->fh_mutex);
+        if (!pCifsFile->invalidHandle) {
+                mutex_unlock(&pCifsFile->fh_mutex);
                 rc = 0;
-                free_xid(xid);
+                FreeXid(xid);
                 return rc;
         }
 
-        inode = cfile->dentry->d_inode;
+        inode = pCifsFile->dentry->d_inode;
         cifs_sb = CIFS_SB(inode->i_sb);
-        tcon = tlink_tcon(cfile->tlink);
-        server = tcon->ses->server;
+        tcon = tlink_tcon(pCifsFile->tlink);
 
-        /*
-         * Can not grab rename sem here because various ops, including those
-         * that already have the rename sem can end up causing writepage to get
-         * called and if the server was down that means we end up here, and we
-         * can never tell if the caller already has the rename_sem.
-         */
-        full_path = build_path_from_dentry(cfile->dentry);
+/* can not grab rename sem here because various ops, including
+   those that already have the rename sem can end up causing writepage
+   to get called and if the server was down that means we end up here,
+   and we can never tell if the caller already has the rename_sem */
+        full_path = build_path_from_dentry(pCifsFile->dentry);
         if (full_path == NULL) {
                 rc = -ENOMEM;
-                mutex_unlock(&cfile->fh_mutex);
-                free_xid(xid);
+                mutex_unlock(&pCifsFile->fh_mutex);
+                FreeXid(xid);
                 return rc;
         }
 
-        cFYI(1, "inode = 0x%p file flags 0x%x for %s", inode, cfile->f_flags,
-             full_path);
+        cFYI(1, "inode = 0x%p file flags 0x%x for %s",
+                 inode, pCifsFile->f_flags, full_path);
 
-        if (tcon->ses->server->oplocks)
+        if (oplockEnabled)
                 oplock = REQ_OPLOCK;
         else
                 oplock = 0;
 
-        if (tcon->unix_ext && cap_unix(tcon->ses) &&
+        if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
-                                le64_to_cpu(tcon->fsUnixInfo.Capability))) {
+                        le64_to_cpu(tcon->fsUnixInfo.Capability))) {
+
                 /*
                  * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
                  * original open. Must mask them off for a reopen.
                  */
-                unsigned int oflags = cfile->f_flags &
+                unsigned int oflags = pCifsFile->f_flags &
                                                 ~(O_CREAT | O_EXCL | O_TRUNC);
 
                 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
-                                     cifs_sb->mnt_file_mode /* ignored */,
-                                     oflags, &oplock, &fid.netfid, xid);
+                                cifs_sb->mnt_file_mode /* ignored */,
+                                oflags, &oplock, &netfid, xid);
                 if (rc == 0) {
                         cFYI(1, "posix reopen succeeded");
                         goto reopen_success;
                 }
-                /*
-                 * fallthrough to retry open the old way on errors, especially
-                 * in the reconnect path it is important to retry hard
-                 */
+                /* fallthrough to retry open the old way on errors, especially
+                   in the reconnect path it is important to retry hard */
         }
 
-        desired_access = cifs_convert_flags(cfile->f_flags);
-
-        if (backup_cred(cifs_sb))
-                create_options |= CREATE_OPEN_BACKUP_INTENT;
+        desiredAccess = cifs_convert_flags(pCifsFile->f_flags);
 
-        if (server->ops->get_lease_key)
-                server->ops->get_lease_key(inode, &fid);
+        /* Can not refresh inode by passing in file_info buf to be returned
+           by SMBOpen and then calling get_inode_info with returned buf
+           since file might have write behind data that needs to be flushed
+           and server version of file size can be stale. If we knew for sure
+           that inode was not dirty locally we could do this */
 
-        /*
-         * Can not refresh inode by passing in file_info buf to be returned by
-         * CIFSSMBOpen and then calling get_inode_info with returned buf since
-         * file might have write behind data that needs to be flushed and server
-         * version of file size can be stale. If we knew for sure that inode was
-         * not dirty locally we could do this.
-         */
-        rc = server->ops->open(xid, tcon, full_path, disposition,
-                               desired_access, create_options, &fid, &oplock,
-                               NULL, cifs_sb);
+        rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
+                         CREATE_NOT_DIR, &netfid, &oplock, NULL,
+                         cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
+                                CIFS_MOUNT_MAP_SPECIAL_CHR);
         if (rc) {
-                mutex_unlock(&cfile->fh_mutex);
-                cFYI(1, "cifs_reopen returned 0x%x", rc);
+                mutex_unlock(&pCifsFile->fh_mutex);
+                cFYI(1, "cifs_open returned 0x%x", rc);
                 cFYI(1, "oplock: %d", oplock);
                 goto reopen_error_exit;
         }
 
 reopen_success:
-        cfile->invalidHandle = false;
-        mutex_unlock(&cfile->fh_mutex);
-        cinode = CIFS_I(inode);
+        pCifsFile->netfid = netfid;
+        pCifsFile->invalidHandle = false;
+        mutex_unlock(&pCifsFile->fh_mutex);
+        pCifsInode = CIFS_I(inode);
 
         if (can_flush) {
                 rc = filemap_write_and_wait(inode->i_mapping);
                 mapping_set_error(inode->i_mapping, rc);
 
                 if (tcon->unix_ext)
-                        rc = cifs_get_inode_info_unix(&inode, full_path,
-                                                      inode->i_sb, xid);
+                        rc = cifs_get_inode_info_unix(&inode,
+                                full_path, inode->i_sb, xid);
                 else
-                        rc = cifs_get_inode_info(&inode, full_path, NULL,
-                                                 inode->i_sb, xid, NULL);
-        }
-        /*
-         * Else we are writing out data to server already and could deadlock if
-         * we tried to flush data, and since we do not know if we have data that
-         * would invalidate the current end of file on the server we can not go
-         * to the server to get the new inode info.
-         */
+                        rc = cifs_get_inode_info(&inode,
+                                full_path, NULL, inode->i_sb,
+                                xid, NULL);
+        } /* else we are writing out data to server already
+             and could deadlock if we tried to flush data, and
+             since we do not know if we have data that would
+             invalidate the current end of file on the server
+             we can not go to the server to get the new inod
+             info */
+
+        cifs_set_oplock_level(pCifsInode, oplock);
 
-        server->ops->set_fid(cfile, &fid, oplock);
-        cifs_relock_file(cfile);
+        cifs_relock_file(pCifsFile);
 
 reopen_error_exit:
         kfree(full_path);
-        free_xid(xid);
+        FreeXid(xid);
         return rc;
 }
 
@@ -713,876 +589,266 @@ int cifs_close(struct inode *inode, struct file *file)
 int cifs_closedir(struct inode *inode, struct file *file)
 {
         int rc = 0;
-        unsigned int xid;
-        struct cifsFileInfo *cfile = file->private_data;
-        struct cifs_tcon *tcon;
-        struct TCP_Server_Info *server;
-        char *buf;
+        int xid;
+        struct cifsFileInfo *pCFileStruct = file->private_data;
+        char *ptmp;
 
         cFYI(1, "Closedir inode = 0x%p", inode);
 
-        if (cfile == NULL)
-                return rc;
-
-        xid = get_xid();
-        tcon = tlink_tcon(cfile->tlink);
-        server = tcon->ses->server;
+        xid = GetXid();
 
-        cFYI(1, "Freeing private data in close dir");
-        spin_lock(&cifs_file_list_lock);
-        if (!cfile->srch_inf.endOfSearch && !cfile->invalidHandle) {
-                cfile->invalidHandle = true;
-                spin_unlock(&cifs_file_list_lock);
-                if (server->ops->close_dir)
-                        rc = server->ops->close_dir(xid, tcon, &cfile->fid);
-                else
-                        rc = -ENOSYS;
-                cFYI(1, "Closing uncompleted readdir with rc %d", rc);
-                /* not much we can do if it fails anyway, ignore rc */
-                rc = 0;
-        } else
-                spin_unlock(&cifs_file_list_lock);
+        if (pCFileStruct) {
+                struct cifs_tcon *pTcon = tlink_tcon(pCFileStruct->tlink);
 
-        buf = cfile->srch_inf.ntwrk_buf_start;
-        if (buf) {
-                cFYI(1, "closedir free smb buf in srch struct");
-                cfile->srch_inf.ntwrk_buf_start = NULL;
-                if (cfile->srch_inf.smallBuf)
-                        cifs_small_buf_release(buf);
-                else
-                        cifs_buf_release(buf);
+                cFYI(1, "Freeing private data in close dir");
+                spin_lock(&cifs_file_list_lock);
+                if (!pCFileStruct->srch_inf.endOfSearch &&
+                    !pCFileStruct->invalidHandle) {
+                        pCFileStruct->invalidHandle = true;
+                        spin_unlock(&cifs_file_list_lock);
+                        rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
+                        cFYI(1, "Closing uncompleted readdir with rc %d",
+                                 rc);
+                        /* not much we can do if it fails anyway, ignore rc */
+                        rc = 0;
+                } else
+                        spin_unlock(&cifs_file_list_lock);
+                ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
+                if (ptmp) {
+                        cFYI(1, "closedir free smb buf in srch struct");
+                        pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
+                        if (pCFileStruct->srch_inf.smallBuf)
+                                cifs_small_buf_release(ptmp);
+                        else
+                                cifs_buf_release(ptmp);
+                }
+                cifs_put_tlink(pCFileStruct->tlink);
+                kfree(file->private_data);
+                file->private_data = NULL;
         }
-
-        cifs_put_tlink(cfile->tlink);
-        kfree(file->private_data);
-        file->private_data = NULL;
         /* BB can we lock the filestruct while this is going on? */
-        free_xid(xid);
+        FreeXid(xid);
         return rc;
 }
 
-static struct cifsLockInfo *
-cifs_lock_init(__u64 offset, __u64 length, __u8 type)
+static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
+                                __u64 offset, __u8 lockType)
 {
-        struct cifsLockInfo *lock =
+        struct cifsLockInfo *li =
                 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
-        if (!lock)
-                return lock;
-        lock->offset = offset;
-        lock->length = length;
-        lock->type = type;
-        lock->pid = current->tgid;
-        INIT_LIST_HEAD(&lock->blist);
-        init_waitqueue_head(&lock->block_q);
-        return lock;
-}
-
-void
-cifs_del_lock_waiters(struct cifsLockInfo *lock)
-{
-        struct cifsLockInfo *li, *tmp;
-        list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
-                list_del_init(&li->blist);
-                wake_up(&li->block_q);
-        }
-}
-
-#define CIFS_LOCK_OP    0
-#define CIFS_READ_OP    1
-#define CIFS_WRITE_OP   2
-
-/* @rw_check : 0 - no op, 1 - read, 2 - write */
-static bool
-cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
-                            __u64 length, __u8 type, struct cifsFileInfo *cfile,
-                            struct cifsLockInfo **conf_lock, int rw_check)
-{
-        struct cifsLockInfo *li;
-        struct cifsFileInfo *cur_cfile = fdlocks->cfile;
-        struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
-
-        list_for_each_entry(li, &fdlocks->locks, llist) {
-                if (offset + length <= li->offset ||
-                    offset >= li->offset + li->length)
-                        continue;
-                if (rw_check != CIFS_LOCK_OP && current->tgid == li->pid &&
-                    server->ops->compare_fids(cfile, cur_cfile)) {
-                        /* shared lock prevents write op through the same fid */
-                        if (!(li->type & server->vals->shared_lock_type) ||
-                            rw_check != CIFS_WRITE_OP)
-                                continue;
-                }
-                if ((type & server->vals->shared_lock_type) &&
-                    ((server->ops->compare_fids(cfile, cur_cfile) &&
-                     current->tgid == li->pid) || type == li->type))
-                        continue;
-                if (conf_lock)
-                        *conf_lock = li;
-                return true;
-        }
-        return false;
-}
-
-bool
-cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
-                        __u8 type, struct cifsLockInfo **conf_lock,
-                        int rw_check)
-{
-        bool rc = false;
-        struct cifs_fid_locks *cur;
-        struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
-
-        list_for_each_entry(cur, &cinode->llist, llist) {
-                rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
-                                                 cfile, conf_lock, rw_check);
-                if (rc)
-                        break;
-        }
-
-        return rc;
-}
-
-/*
- * Check if there is another lock that prevents us to set the lock (mandatory
- * style). If such a lock exists, update the flock structure with its
- * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
- * or leave it the same if we can't. Returns 0 if we don't need to request to
- * the server or 1 otherwise.
- */
-static int
-cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
-               __u8 type, struct file_lock *flock)
-{
-        int rc = 0;
-        struct cifsLockInfo *conf_lock;
-        struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
-        struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
-        bool exist;
-
-        down_read(&cinode->lock_sem);
-
-        exist = cifs_find_lock_conflict(cfile, offset, length, type,
-                                        &conf_lock, CIFS_LOCK_OP);
-        if (exist) {
-                flock->fl_start = conf_lock->offset;
-                flock->fl_end = conf_lock->offset + conf_lock->length - 1;
-                flock->fl_pid = conf_lock->pid;
-                if (conf_lock->type & server->vals->shared_lock_type)
-                        flock->fl_type = F_RDLCK;
-                else
-                        flock->fl_type = F_WRLCK;
-        } else if (!cinode->can_cache_brlcks)
-                rc = 1;
-        else
-                flock->fl_type = F_UNLCK;
-
-        up_read(&cinode->lock_sem);
-        return rc;
-}
-
-static void
-cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
-{
-        struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
-        down_write(&cinode->lock_sem);
-        list_add_tail(&lock->llist, &cfile->llist->locks);
-        up_write(&cinode->lock_sem);
-}
-
-/*
- * Set the byte-range lock (mandatory style). Returns:
- * 1) 0, if we set the lock and don't need to request to the server;
- * 2) 1, if no locks prevent us but we need to request to the server;
- * 3) -EACCESS, if there is a lock that prevents us and wait is false.
- */
-static int
-cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
-                 bool wait)
-{
-        struct cifsLockInfo *conf_lock;
-        struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
-        bool exist;
-        int rc = 0;
-
-try_again:
-        exist = false;
-        down_write(&cinode->lock_sem);
-
-        exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
-                                        lock->type, &conf_lock, CIFS_LOCK_OP);
-        if (!exist && cinode->can_cache_brlcks) {
-                list_add_tail(&lock->llist, &cfile->llist->locks);
-                up_write(&cinode->lock_sem);
-                return rc;
-        }
-
-        if (!exist)
-                rc = 1;
-        else if (!wait)
-                rc = -EACCES;
-        else {
-                list_add_tail(&lock->blist, &conf_lock->blist);
-                up_write(&cinode->lock_sem);
-                rc = wait_event_interruptible(lock->block_q,
-                                        (lock->blist.prev == &lock->blist) &&
-                                        (lock->blist.next == &lock->blist));
-                if (!rc)
-                        goto try_again;
-                down_write(&cinode->lock_sem);
-                list_del_init(&lock->blist);
-        }
-
-        up_write(&cinode->lock_sem);
-        return rc;
-}
-
-/*
- * Check if there is another lock that prevents us to set the lock (posix
- * style). If such a lock exists, update the flock structure with its
- * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
- * or leave it the same if we can't. Returns 0 if we don't need to request to
- * the server or 1 otherwise.
- */
-static int
-cifs_posix_lock_test(struct file *file, struct file_lock *flock)
-{
-        int rc = 0;
-        struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
-        unsigned char saved_type = flock->fl_type;
-
-        if ((flock->fl_flags & FL_POSIX) == 0)
-                return 1;
-
-        down_read(&cinode->lock_sem);
-        posix_test_lock(file, flock);
-
-        if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
-                flock->fl_type = saved_type;
-                rc = 1;
-        }
-
-        up_read(&cinode->lock_sem);
-        return rc;
-}
-
-/*
- * Set the byte-range lock (posix style). Returns:
- * 1) 0, if we set the lock and don't need to request to the server;
- * 2) 1, if we need to request to the server;
- * 3) <0, if the error occurs while setting the lock.
- */
-static int
-cifs_posix_lock_set(struct file *file, struct file_lock *flock)
-{
-        struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
-        int rc = 1;
-
-        if ((flock->fl_flags & FL_POSIX) == 0)
-                return rc;
-
-try_again:
-        down_write(&cinode->lock_sem);
-        if (!cinode->can_cache_brlcks) {
-                up_write(&cinode->lock_sem);
-                return rc;
-        }
-
-        rc = posix_lock_file(file, flock, NULL);
-        up_write(&cinode->lock_sem);
-        if (rc == FILE_LOCK_DEFERRED) {
-                rc = wait_event_interruptible(flock->fl_wait, !flock->fl_next);
-                if (!rc)
-                        goto try_again;
-                locks_delete_block(flock);
-        }
-        return rc;
-}
-
-int
-cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
-{
-        unsigned int xid;
-        int rc = 0, stored_rc;
-        struct cifsLockInfo *li, *tmp;
-        struct cifs_tcon *tcon;
-        unsigned int num, max_num, max_buf;
-        LOCKING_ANDX_RANGE *buf, *cur;
-        int types[] = {LOCKING_ANDX_LARGE_FILES,
-                       LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
-        int i;
-
-        xid = get_xid();
-        tcon = tlink_tcon(cfile->tlink);
-
-        /*
-         * Accessing maxBuf is racy with cifs_reconnect - need to store value
-         * and check it for zero before using.
-         */
-        max_buf = tcon->ses->server->maxBuf;
-        if (!max_buf) {
-                free_xid(xid);
-                return -EINVAL;
-        }
-
-        max_num = (max_buf - sizeof(struct smb_hdr)) /
-                                                sizeof(LOCKING_ANDX_RANGE);
-        buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
-        if (!buf) {
-                free_xid(xid);
+        if (li == NULL)
                 return -ENOMEM;
-        }
-
-        for (i = 0; i < 2; i++) {
-                cur = buf;
-                num = 0;
-                list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
-                        if (li->type != types[i])
-                                continue;
-                        cur->Pid = cpu_to_le16(li->pid);
-                        cur->LengthLow = cpu_to_le32((u32)li->length);
-                        cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
-                        cur->OffsetLow = cpu_to_le32((u32)li->offset);
-                        cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
-                        if (++num == max_num) {
-                                stored_rc = cifs_lockv(xid, tcon,
-                                                       cfile->fid.netfid,
-                                                       (__u8)li->type, 0, num,
-                                                       buf);
-                                if (stored_rc)
-                                        rc = stored_rc;
-                                cur = buf;
-                                num = 0;
-                        } else
-                                cur++;
-                }
-
-                if (num) {
-                        stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
-                                               (__u8)types[i], 0, num, buf);
-                        if (stored_rc)
-                                rc = stored_rc;
-                }
-        }
-
-        kfree(buf);
-        free_xid(xid);
-        return rc;
+        li->offset = offset;
+        li->length = len;
+        li->type = lockType;
+        mutex_lock(&fid->lock_mutex);
+        list_add(&li->llist, &fid->llist);
+        mutex_unlock(&fid->lock_mutex);
+        return 0;
 }
 
-/* copied from fs/locks.c with a name change */
-#define cifs_for_each_lock(inode, lockp) \
-        for (lockp = &inode->i_flock; *lockp != NULL; \
-             lockp = &(*lockp)->fl_next)
-
-struct lock_to_push {
-        struct list_head llist;
-        __u64 offset;
-        __u64 length;
-        __u32 pid;
-        __u16 netfid;
-        __u8 type;
-};
-
-static int
-cifs_push_posix_locks(struct cifsFileInfo *cfile)
+int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
 {
-        struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
-        struct file_lock *flock, **before;
-        unsigned int count = 0, i = 0;
-        int rc = 0, xid, type;
-        struct list_head locks_to_send, *el;
-        struct lock_to_push *lck, *tmp;
+        int rc, xid;
+        __u32 numLock = 0;
+        __u32 numUnlock = 0;
         __u64 length;
+        bool wait_flag = false;
+        struct cifs_sb_info *cifs_sb;
+        struct cifs_tcon *tcon;
+        __u16 netfid;
+        __u8 lockType = LOCKING_ANDX_LARGE_FILES;
+        bool posix_locking = 0;
 
-        xid = get_xid();
-
-        lock_flocks();
-        cifs_for_each_lock(cfile->dentry->d_inode, before) {
-                if ((*before)->fl_flags & FL_POSIX)
-                        count++;
-        }
-        unlock_flocks();
-
-        INIT_LIST_HEAD(&locks_to_send);
-
-        /*
-         * Allocating count locks is enough because no FL_POSIX locks can be
-         * added to the list while we are holding cinode->lock_sem that
-         * protects locking operations of this inode.
-         */
-        for (; i < count; i++) {
-                lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
-                if (!lck) {
-                        rc = -ENOMEM;
-                        goto err_out;
-                }
-                list_add_tail(&lck->llist, &locks_to_send);
-        }
-
-        el = locks_to_send.next;
-        lock_flocks();
-        cifs_for_each_lock(cfile->dentry->d_inode, before) {
-                flock = *before;
-                if ((flock->fl_flags & FL_POSIX) == 0)
-                        continue;
-                if (el == &locks_to_send) {
-                        /*
-                         * The list ended. We don't have enough allocated
-                         * structures - something is really wrong.
-                         */
-                        cERROR(1, "Can't push all brlocks!");
-                        break;
-                }
-                length = 1 + flock->fl_end - flock->fl_start;
-                if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
-                        type = CIFS_RDLCK;
-                else
-                        type = CIFS_WRLCK;
-                lck = list_entry(el, struct lock_to_push, llist);
-                lck->pid = flock->fl_pid;
-                lck->netfid = cfile->fid.netfid;
-                lck->length = length;
-                lck->type = type;
-                lck->offset = flock->fl_start;
-                el = el->next;
-        }
-        unlock_flocks();
-
-        list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
-                int stored_rc;
-
-                stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
-                                             lck->offset, lck->length, NULL,
-                                             lck->type, 0);
-                if (stored_rc)
-                        rc = stored_rc;
-                list_del(&lck->llist);
-                kfree(lck);
-        }
-
-out:
-        free_xid(xid);
-        return rc;
-err_out:
-        list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
-                list_del(&lck->llist);
-                kfree(lck);
-        }
-        goto out;
-}
-
-static int
-cifs_push_locks(struct cifsFileInfo *cfile)
-{
-        struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
-        struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
-        struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
-        int rc = 0;
-
-        /* we are going to update can_cache_brlcks here - need a write access */
-        down_write(&cinode->lock_sem);
-        if (!cinode->can_cache_brlcks) {
-                up_write(&cinode->lock_sem);
-                return rc;
-        }
-
-        if (cap_unix(tcon->ses) &&
-            (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
-            ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
-                rc = cifs_push_posix_locks(cfile);
-        else
-                rc = tcon->ses->server->ops->push_mand_locks(cfile);
+        length = 1 + pfLock->fl_end - pfLock->fl_start;
+        rc = -EACCES;
+        xid = GetXid();
 
-        cinode->can_cache_brlcks = false;
-        up_write(&cinode->lock_sem);
-        return rc;
-}
+        cFYI(1, "Lock parm: 0x%x flockflags: "
+                 "0x%x flocktype: 0x%x start: %lld end: %lld",
+                cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
+                pfLock->fl_end);
 
-static void
-cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
-                bool *wait_flag, struct TCP_Server_Info *server)
-{
-        if (flock->fl_flags & FL_POSIX)
+        if (pfLock->fl_flags & FL_POSIX)
                 cFYI(1, "Posix");
-        if (flock->fl_flags & FL_FLOCK)
+        if (pfLock->fl_flags & FL_FLOCK)
                 cFYI(1, "Flock");
-        if (flock->fl_flags & FL_SLEEP) {
+        if (pfLock->fl_flags & FL_SLEEP) {
                 cFYI(1, "Blocking lock");
-                *wait_flag = true;
+                wait_flag = true;
         }
-        if (flock->fl_flags & FL_ACCESS)
+        if (pfLock->fl_flags & FL_ACCESS)
                 cFYI(1, "Process suspended by mandatory locking - "
-                        "not implemented yet");
-        if (flock->fl_flags & FL_LEASE)
+                         "not implemented yet");
+        if (pfLock->fl_flags & FL_LEASE)
                 cFYI(1, "Lease on file - not implemented yet");
-        if (flock->fl_flags &
-            (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
-               FL_ACCESS | FL_LEASE | FL_CLOSE)))
-                cFYI(1, "Unknown lock flags 0x%x", flock->fl_flags);
+        if (pfLock->fl_flags &
+            (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
+                cFYI(1, "Unknown lock flags 0x%x", pfLock->fl_flags);
 
-        *type = server->vals->large_lock_type;
-        if (flock->fl_type == F_WRLCK) {
+        if (pfLock->fl_type == F_WRLCK) {
                 cFYI(1, "F_WRLCK ");
-                *type |= server->vals->exclusive_lock_type;
-                *lock = 1;
-        } else if (flock->fl_type == F_UNLCK) {
+                numLock = 1;
+        } else if (pfLock->fl_type == F_UNLCK) {
                 cFYI(1, "F_UNLCK");
-                *type |= server->vals->unlock_lock_type;
-                *unlock = 1;
-                /* Check if unlock includes more than one lock range */
-        } else if (flock->fl_type == F_RDLCK) {
+                numUnlock = 1;
+                /* Check if unlock includes more than
+                one lock range */
+        } else if (pfLock->fl_type == F_RDLCK) {
                 cFYI(1, "F_RDLCK");
-                *type |= server->vals->shared_lock_type;
-                *lock = 1;
-        } else if (flock->fl_type == F_EXLCK) {
+                lockType |= LOCKING_ANDX_SHARED_LOCK;
+                numLock = 1;
+        } else if (pfLock->fl_type == F_EXLCK) {
                 cFYI(1, "F_EXLCK");
-                *type |= server->vals->exclusive_lock_type;
-                *lock = 1;
-        } else if (flock->fl_type == F_SHLCK) {
+                numLock = 1;
+        } else if (pfLock->fl_type == F_SHLCK) {
                 cFYI(1, "F_SHLCK");
-                *type |= server->vals->shared_lock_type;
-                *lock = 1;
+                lockType |= LOCKING_ANDX_SHARED_LOCK;
+                numLock = 1;
         } else
                 cFYI(1, "Unknown type of lock");
-}
 
-static int
-cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
-           bool wait_flag, bool posix_lck, unsigned int xid)
-{
-        int rc = 0;
-        __u64 length = 1 + flock->fl_end - flock->fl_start;
-        struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
-        struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
-        struct TCP_Server_Info *server = tcon->ses->server;
-        __u16 netfid = cfile->fid.netfid;
-
-        if (posix_lck) {
-                int posix_lock_type;
+        cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
+        tcon = tlink_tcon(((struct cifsFileInfo *)file->private_data)->tlink);
+        netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
 
-                rc = cifs_posix_lock_test(file, flock);
-                if (!rc)
+        if ((tcon->ses->capabilities & CAP_UNIX) &&
+            (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
+            ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
+                posix_locking = 1;
+        /* BB add code here to normalize offset and length to
+        account for negative length which we can not accept over the
+        wire */
+        if (IS_GETLK(cmd)) {
+                if (posix_locking) {
+                        int posix_lock_type;
+                        if (lockType & LOCKING_ANDX_SHARED_LOCK)
+                                posix_lock_type = CIFS_RDLCK;
+                        else
+                                posix_lock_type = CIFS_WRLCK;
+                        rc = CIFSSMBPosixLock(xid, tcon, netfid, 1 /* get */,
+                                        length, pfLock, posix_lock_type,
+                                        wait_flag);
+                        FreeXid(xid);
                         return rc;
+                }
 
-                if (type & server->vals->shared_lock_type)
-                        posix_lock_type = CIFS_RDLCK;
-                else
-                        posix_lock_type = CIFS_WRLCK;
-                rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
-                                      flock->fl_start, length, flock,
-                                      posix_lock_type, wait_flag);
-                return rc;
-        }
-
-        rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
-        if (!rc)
-                return rc;
-
-        /* BB we could chain these into one lock request BB */
-        rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
-                                    1, 0, false);
-        if (rc == 0) {
-                rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
-                                            type, 0, 1, false);
-                flock->fl_type = F_UNLCK;
-                if (rc != 0)
-                        cERROR(1, "Error unlocking previously locked "
-                                  "range %d during test of lock", rc);
-                return 0;
-        }
-
-        if (type & server->vals->shared_lock_type) {
-                flock->fl_type = F_WRLCK;
-                return 0;
-        }
-
-        type &= ~server->vals->exclusive_lock_type;
-
-        rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
-                                    type | server->vals->shared_lock_type,
-                                    1, 0, false);
-        if (rc == 0) {
-                rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
-                        type | server->vals->shared_lock_type, 0, 1, false);
-                flock->fl_type = F_RDLCK;
-                if (rc != 0)
-                        cERROR(1, "Error unlocking previously locked "
-                                  "range %d during test of lock", rc);
-        } else
-                flock->fl_type = F_WRLCK;
-
-        return 0;
-}
-
-void
-cifs_move_llist(struct list_head *source, struct list_head *dest)
-{
-        struct list_head *li, *tmp;
-        list_for_each_safe(li, tmp, source)
-                list_move(li, dest);
-}
-
-void
-cifs_free_llist(struct list_head *llist)
-{
-        struct cifsLockInfo *li, *tmp;
-        list_for_each_entry_safe(li, tmp, llist, llist) {
-                cifs_del_lock_waiters(li);
-                list_del(&li->llist);
-                kfree(li);
-        }
-}
-
-int
-cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
-                  unsigned int xid)
-{
-        int rc = 0, stored_rc;
-        int types[] = {LOCKING_ANDX_LARGE_FILES,
-                       LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
-        unsigned int i;
-        unsigned int max_num, num, max_buf;
-        LOCKING_ANDX_RANGE *buf, *cur;
-        struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
-        struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
-        struct cifsLockInfo *li, *tmp;
-        __u64 length = 1 + flock->fl_end - flock->fl_start;
-        struct list_head tmp_llist;
-
-        INIT_LIST_HEAD(&tmp_llist);
-
-        /*
-         * Accessing maxBuf is racy with cifs_reconnect - need to store value
-         * and check it for zero before using.
-         */
-        max_buf = tcon->ses->server->maxBuf;
-        if (!max_buf)
-                return -EINVAL;
+                /* BB we could chain these into one lock request BB */
+                rc = CIFSSMBLock(xid, tcon, netfid, length, pfLock->fl_start,
+                                 0, 1, lockType, 0 /* wait flag */, 0);
+                if (rc == 0) {
+                        rc = CIFSSMBLock(xid, tcon, netfid, length,
+                                         pfLock->fl_start, 1 /* numUnlock */ ,
+                                         0 /* numLock */ , lockType,
+                                         0 /* wait flag */, 0);
+                        pfLock->fl_type = F_UNLCK;
+                        if (rc != 0)
+                                cERROR(1, "Error unlocking previously locked "
+                                           "range %d during test of lock", rc);
+                        rc = 0;
 
-        max_num = (max_buf - sizeof(struct smb_hdr)) /
-                                                sizeof(LOCKING_ANDX_RANGE);
-        buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
-        if (!buf)
-                return -ENOMEM;
+                } else {
+                        /* if rc == ERR_SHARING_VIOLATION ? */
+                        rc = 0;
 
-        down_write(&cinode->lock_sem);
-        for (i = 0; i < 2; i++) {
-                cur = buf;
-                num = 0;
-                list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
-                        if (flock->fl_start > li->offset ||
-                            (flock->fl_start + length) <
-                            (li->offset + li->length))
-                                continue;
-                        if (current->tgid != li->pid)
-                                continue;
-                        if (types[i] != li->type)
-                                continue;
-                        if (cinode->can_cache_brlcks) {
-                                /*
-                                 * We can cache brlock requests - simply remove
-                                 * a lock from the file's list.
-                                 */
-                                list_del(&li->llist);
-                                cifs_del_lock_waiters(li);
-                                kfree(li);
-                                continue;
+                        if (lockType & LOCKING_ANDX_SHARED_LOCK) {
+                                pfLock->fl_type = F_WRLCK;
+                        } else {
+                                rc = CIFSSMBLock(xid, tcon, netfid, length,
+                                        pfLock->fl_start, 0, 1,
+                                        lockType | LOCKING_ANDX_SHARED_LOCK,
+                                        0 /* wait flag */, 0);
+                                if (rc == 0) {
+                                        rc = CIFSSMBLock(xid, tcon, netfid,
+                                                length, pfLock->fl_start, 1, 0,
+                                                lockType |
+                                                LOCKING_ANDX_SHARED_LOCK,
+                                                0 /* wait flag */, 0);
+                                        pfLock->fl_type = F_RDLCK;
+                                        if (rc != 0)
+                                                cERROR(1, "Error unlocking "
+                                                "previously locked range %d "
+                                                "during test of lock", rc);
+                                        rc = 0;
+                                } else {
+                                        pfLock->fl_type = F_WRLCK;
+                                        rc = 0;
+                                }
                         }
-                        cur->Pid = cpu_to_le16(li->pid);
-                        cur->LengthLow = cpu_to_le32((u32)li->length);
-                        cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
-                        cur->OffsetLow = cpu_to_le32((u32)li->offset);
-                        cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
-                        /*
-                         * We need to save a lock here to let us add it again to
-                         * the file's list if the unlock range request fails on
-                         * the server.
-                         */
-                        list_move(&li->llist, &tmp_llist);
-                        if (++num == max_num) {
-                                stored_rc = cifs_lockv(xid, tcon,
-                                                       cfile->fid.netfid,
-                                                       li->type, num, 0, buf);
-                                if (stored_rc) {
-                                        /*
-                                         * We failed on the unlock range
-                                         * request - add all locks from the tmp
-                                         * list to the head of the file's list.
-                                         */
-                                        cifs_move_llist(&tmp_llist,
-                                                        &cfile->llist->locks);
-                                        rc = stored_rc;
-                                } else
-                                        /*
-                                         * The unlock range request succeed -
-                                         * free the tmp list.
-                                         */
-                                        cifs_free_llist(&tmp_llist);
-                                cur = buf;
-                                num = 0;
-                        } else
-                                cur++;
                 }
-                if (num) {
-                        stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
-                                               types[i], num, 0, buf);
-                        if (stored_rc) {
-                                cifs_move_llist(&tmp_llist,
-                                                &cfile->llist->locks);
-                                rc = stored_rc;
-                        } else
-                                cifs_free_llist(&tmp_llist);
-                }
-        }
 
-        up_write(&cinode->lock_sem);
-        kfree(buf);
-        return rc;
-}
+                FreeXid(xid);
+                return rc;
+        }
 
-static int
-cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
-           bool wait_flag, bool posix_lck, int lock, int unlock,
-           unsigned int xid)
-{
-        int rc = 0;
-        __u64 length = 1 + flock->fl_end - flock->fl_start;
-        struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
-        struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
-        struct TCP_Server_Info *server = tcon->ses->server;
-        struct inode *inode = cfile->dentry->d_inode;
+        if (!numLock && !numUnlock) {
+                /* if no lock or unlock then nothing
+                to do since we do not know what it is */
+                FreeXid(xid);
+                return -EOPNOTSUPP;
+        }
 
-        if (posix_lck) {
+        if (posix_locking) {
                 int posix_lock_type;
-
-                rc = cifs_posix_lock_set(file, flock);
-                if (!rc || rc < 0)
-                        return rc;
-
-                if (type & server->vals->shared_lock_type)
+                if (lockType & LOCKING_ANDX_SHARED_LOCK)
                         posix_lock_type = CIFS_RDLCK;
                 else
                         posix_lock_type = CIFS_WRLCK;
 
-                if (unlock == 1)
+                if (numUnlock == 1)
                         posix_lock_type = CIFS_UNLCK;
 
-                rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
-                                      current->tgid, flock->fl_start, length,
-                                      NULL, posix_lock_type, wait_flag);
-                goto out;
-        }
-
-        if (lock) {
-                struct cifsLockInfo *lock;
+                rc = CIFSSMBPosixLock(xid, tcon, netfid, 0 /* set */,
+                                      length, pfLock, posix_lock_type,
+                                      wait_flag);
+        } else {
+                struct cifsFileInfo *fid = file->private_data;
 
-                lock = cifs_lock_init(flock->fl_start, length, type);
-                if (!lock)
-                        return -ENOMEM;
+                if (numLock) {
+                        rc = CIFSSMBLock(xid, tcon, netfid, length,
+                                         pfLock->fl_start, 0, numLock, lockType,
+                                         wait_flag, 0);
 
-                rc = cifs_lock_add_if(cfile, lock, wait_flag);
-                if (rc < 0) {
-                        kfree(lock);
-                        return rc;
-                }
-                if (!rc)
-                        goto out;
-
-                /*
-                 * Windows 7 server can delay breaking lease from read to None
-                 * if we set a byte-range lock on a file - break it explicitly
-                 * before sending the lock to the server to be sure the next
-                 * read won't conflict with non-overlapted locks due to
-                 * pagereading.
-                 */
-                if (!CIFS_I(inode)->clientCanCacheAll &&
-                                        CIFS_I(inode)->clientCanCacheRead) {
-                        cifs_invalidate_mapping(inode);
-                        cFYI(1, "Set no oplock for inode=%p due to mand locks",
-                             inode);
-                        CIFS_I(inode)->clientCanCacheRead = false;
-                }
+                        if (rc == 0) {
+                                /* For Windows locks we must store them. */
+                                rc = store_file_lock(fid, length,
+                                                pfLock->fl_start, lockType);
+                        }
+                } else if (numUnlock) {
+                        /* For each stored lock that this unlock overlaps
+                           completely, unlock it. */
+                        int stored_rc = 0;
+                        struct cifsLockInfo *li, *tmp;
 
-                rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
-                                            type, 1, 0, wait_flag);
-                if (rc) {
-                        kfree(lock);
-                        return rc;
+                        rc = 0;
+                        mutex_lock(&fid->lock_mutex);
+                        list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
+                                if (pfLock->fl_start <= li->offset &&
+                                                (pfLock->fl_start + length) >=
+                                                (li->offset + li->length)) {
+                                        stored_rc = CIFSSMBLock(xid, tcon,
+                                                        netfid, li->length,
+                                                        li->offset, 1, 0,
+                                                        li->type, false, 0);
+                                        if (stored_rc)
+                                                rc = stored_rc;
+                                        else {
+                                                list_del(&li->llist);
+                                                kfree(li);
+                                        }
+                                }
+                        }
+                        mutex_unlock(&fid->lock_mutex);
                 }
-
-                cifs_lock_add(cfile, lock);
-        } else if (unlock)
-                rc = server->ops->mand_unlock_range(cfile, flock, xid);
-
-out:
-        if (flock->fl_flags & FL_POSIX)
-                posix_lock_file_wait(file, flock);
-        return rc;
-}
-
-int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
-{
-        int rc, xid;
-        int lock = 0, unlock = 0;
-        bool wait_flag = false;
-        bool posix_lck = false;
-        struct cifs_sb_info *cifs_sb;
-        struct cifs_tcon *tcon;
-        struct cifsInodeInfo *cinode;
-        struct cifsFileInfo *cfile;
-        __u16 netfid;
-        __u32 type;
-
-        rc = -EACCES;
-        xid = get_xid();
-
-        cFYI(1, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld "
-                "end: %lld", cmd, flock->fl_flags, flock->fl_type,
-                flock->fl_start, flock->fl_end);
-
-        cfile = (struct cifsFileInfo *)file->private_data;
-        tcon = tlink_tcon(cfile->tlink);
-
-        cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
-                        tcon->ses->server);
-
-        cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
-        netfid = cfile->fid.netfid;
-        cinode = CIFS_I(file->f_path.dentry->d_inode);
-
-        if (cap_unix(tcon->ses) &&
-            (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
-            ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
-                posix_lck = true;
-        /*
-         * BB add code here to normalize offset and length to account for
-         * negative length which we can not accept over the wire.
-         */
-        if (IS_GETLK(cmd)) {
-                rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
-                free_xid(xid);
-                return rc;
-        }
-
-        if (!lock && !unlock) {
-                /*
-                 * if no lock or unlock then nothing to do since we do not
-                 * know what it is
-                 */
-                free_xid(xid);
-                return -EOPNOTSUPP;
         }
 
-        rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
-                        xid);
-        free_xid(xid);
+        if (pfLock->fl_flags & FL_POSIX)
+                posix_lock_file_wait(file, pfLock);
+        FreeXid(xid);
         return rc;
 }
 
-/*
- * update the file size (if needed) after a write. Should be called with
- * the inode->i_lock held
- */
+/* update the file size (if needed) after a write */
 void
 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
                       unsigned int bytes_written)
@@ -1593,17 +859,16 @@ cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
                 cifsi->server_eof = end_of_write;
 }
 
-static ssize_t
-cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
-           size_t write_size, loff_t *offset)
+static ssize_t cifs_write(struct cifsFileInfo *open_file, __u32 pid,
+                          const char *write_data, size_t write_size,
+                          loff_t *poffset)
 {
         int rc = 0;
         unsigned int bytes_written = 0;
         unsigned int total_written;
         struct cifs_sb_info *cifs_sb;
-        struct cifs_tcon *tcon;
-        struct TCP_Server_Info *server;
-        unsigned int xid;
+        struct cifs_tcon *pTcon;
+        int xid;
         struct dentry *dentry = open_file->dentry;
         struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
         struct cifs_io_parms io_parms;
@@ -1611,15 +876,11 @@ cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
         cifs_sb = CIFS_SB(dentry->d_sb);
 
         cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
-             *offset, dentry->d_name.name);
-
-        tcon = tlink_tcon(open_file->tlink);
-        server = tcon->ses->server;
+           *poffset, dentry->d_name.name);
 
-        if (!server->ops->sync_write)
-                return -ENOSYS;
+        pTcon = tlink_tcon(open_file->tlink);
 
-        xid = get_xid();
+        xid = GetXid();
 
         for (total_written = 0; write_size > total_written;
              total_written += bytes_written) {
@@ -1643,38 +904,37 @@ cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
                         /* iov[0] is reserved for smb header */
                         iov[1].iov_base = (char *)write_data + total_written;
                         iov[1].iov_len = len;
+                        io_parms.netfid = open_file->netfid;
                         io_parms.pid = pid;
-                        io_parms.tcon = tcon;
-                        io_parms.offset = *offset;
+                        io_parms.tcon = pTcon;
+                        io_parms.offset = *poffset;
                         io_parms.length = len;
-                        rc = server->ops->sync_write(xid, open_file, &io_parms,
-                                                     &bytes_written, iov, 1);
+                        rc = CIFSSMBWrite2(xid, &io_parms, &bytes_written, iov,
+                                           1, 0);
                 }
                 if (rc || (bytes_written == 0)) {
                         if (total_written)
                                 break;
                         else {
-                                free_xid(xid);
+                                FreeXid(xid);
                                 return rc;
                         }
                 } else {
-                        spin_lock(&dentry->d_inode->i_lock);
-                        cifs_update_eof(cifsi, *offset, bytes_written);
-                        spin_unlock(&dentry->d_inode->i_lock);
-                        *offset += bytes_written;
+                        cifs_update_eof(cifsi, *poffset, bytes_written);
+                        *poffset += bytes_written;
                 }
         }
 
-        cifs_stats_bytes_written(tcon, total_written);
+        cifs_stats_bytes_written(pTcon, total_written);
 
         if (total_written > 0) {
                 spin_lock(&dentry->d_inode->i_lock);
-                if (*offset > dentry->d_inode->i_size)
-                        i_size_write(dentry->d_inode, *offset);
+                if (*poffset > dentry->d_inode->i_size)
+                        i_size_write(dentry->d_inode, *poffset);
                 spin_unlock(&dentry->d_inode->i_lock);
         }
         mark_inode_dirty_sync(dentry->d_inode);
-        free_xid(xid);
+        FreeXid(xid);
         return total_written;
 }
 
@@ -1699,7 +959,7 @@ struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
                         if (!open_file->invalidHandle) {
                                 /* found a good file */
                                 /* lock it so it will not be closed on us */
-                                cifsFileInfo_get_locked(open_file);
+                                cifsFileInfo_get(open_file);
                                 spin_unlock(&cifs_file_list_lock);
                                 return open_file;
                         } /* else might as well continue, and look for
@@ -1715,11 +975,10 @@ struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
                                         bool fsuid_only)
 {
-        struct cifsFileInfo *open_file, *inv_file = NULL;
+        struct cifsFileInfo *open_file;
         struct cifs_sb_info *cifs_sb;
         bool any_available = false;
         int rc;
-        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
@@ -1739,25 +998,40 @@ struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
 
         spin_lock(&cifs_file_list_lock);
 refind_writable:
-        if (refind > MAX_REOPEN_ATT) {
-                spin_unlock(&cifs_file_list_lock);
-                return NULL;
-        }
         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
                 if (!any_available && open_file->pid != current->tgid)
                         continue;
                 if (fsuid_only && open_file->uid != current_fsuid())
                         continue;
                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
+                        cifsFileInfo_get(open_file);
+
                         if (!open_file->invalidHandle) {
                                 /* found a good writable file */
-                                cifsFileInfo_get_locked(open_file);
                                 spin_unlock(&cifs_file_list_lock);
                                 return open_file;
-                        } else {
-                                if (!inv_file)
-                                        inv_file = open_file;
                         }
+
+                        spin_unlock(&cifs_file_list_lock);
+
+                        /* Had to unlock since following call can block */
+                        rc = cifs_reopen_file(open_file, false);
+                        if (!rc)
+                                return open_file;
+
+                        /* if it fails, try another handle if possible */
+                        cFYI(1, "wp failed on reopen file");
+                        cifsFileInfo_put(open_file);
+
+                        spin_lock(&cifs_file_list_lock);
+
+                        /* else we simply continue to the next entry. Thus
+                           we do not loop on reopen errors.  If we
+                           can not reopen the file, for example if we
+                           reconnected to a server with another client
+                           racing to delete or lock the file we would not
+                           make progress if we restarted before the beginning
+                           of the loop here. */
                 }
         }
         /* couldn't find useable FH with same pid, try any available */
@@ -1765,30 +1039,7 @@ refind_writable:
                 any_available = true;
                 goto refind_writable;
         }
-
-        if (inv_file) {
-                any_available = false;
-                cifsFileInfo_get_locked(inv_file);
-        }
-
         spin_unlock(&cifs_file_list_lock);
-
-        if (inv_file) {
-                rc = cifs_reopen_file(inv_file, false);
-                if (!rc)
-                        return inv_file;
-                else {
-                        spin_lock(&cifs_file_list_lock);
-                        list_move_tail(&inv_file->flist,
-                                        &cifs_inode->openFileList);
-                        spin_unlock(&cifs_file_list_lock);
-                        cifsFileInfo_put(inv_file);
-                        spin_lock(&cifs_file_list_lock);
-                        ++refind;
-                        goto refind_writable;
-                }
-        }
-
         return NULL;
 }
 
@@ -1853,7 +1104,6 @@ static int cifs_writepages(struct address_space *mapping,
         bool done = false, scanned = false, range_whole = false;
         pgoff_t end, index;
         struct cifs_writedata *wdata;
-        struct TCP_Server_Info *server;
         struct page *page;
         int rc = 0;
 
@@ -1883,8 +1133,7 @@ retry:
                 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
                                 end - index) + 1;
 
-                wdata = cifs_writedata_alloc((unsigned int)tofind,
-                                             cifs_writev_complete);
+                wdata = cifs_writedata_alloc((unsigned int)tofind);
                 if (!wdata) {
                         rc = -ENOMEM;
                         break;
@@ -1960,7 +1209,7 @@ retry:
                          */
                         set_page_writeback(page);
 
-                        if (page_offset(page) >= i_size_read(mapping->host)) {
+                        if (page_offset(page) >= mapping->host->i_size) {
                                 done = true;
                                 unlock_page(page);
                                 end_page_writeback(page);
@@ -1991,13 +1240,6 @@ retry:
                 wdata->sync_mode = wbc->sync_mode;
                 wdata->nr_pages = nr_pages;
                 wdata->offset = page_offset(wdata->pages[0]);
-                wdata->pagesz = PAGE_CACHE_SIZE;
-                wdata->tailsz =
-                        min(i_size_read(mapping->host) -
-                            page_offset(wdata->pages[nr_pages - 1]),
-                            (loff_t)PAGE_CACHE_SIZE);
-                wdata->bytes = ((nr_pages - 1) * PAGE_CACHE_SIZE) +
-                                        wdata->tailsz;
 
                 do {
                         if (wdata->cfile != NULL)
@@ -2009,9 +1251,7 @@ retry:
                                 rc = -EBADF;
                                 break;
                         }
-                        wdata->pid = wdata->cfile->pid;
-                        server = tlink_tcon(wdata->cfile->tlink)->ses->server;
-                        rc = server->ops->async_writev(wdata);
+                        rc = cifs_async_writev(wdata);
                 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
 
                 for (i = 0; i < nr_pages; ++i)
@@ -2060,9 +1300,9 @@ static int
 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
 {
         int rc;
-        unsigned int xid;
+        int xid;
 
-        xid = get_xid();
+        xid = GetXid();
 /* BB add check for wbc flags */
         page_cache_get(page);
         if (!PageUptodate(page))
@@ -2091,7 +1331,7 @@ retry_write:
                 SetPageUptodate(page);
         end_page_writeback(page);
         page_cache_release(page);
-        free_xid(xid);
+        FreeXid(xid);
         return rc;
 }
 
@@ -2130,9 +1370,9 @@ static int cifs_write_end(struct file *file, struct address_space *mapping,
         if (!PageUptodate(page)) {
                 char *page_data;
                 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
-                unsigned int xid;
+                int xid;
 
-                xid = get_xid();
+                xid = GetXid();
                 /* this is probably better than directly calling
                    partialpage_write since in this function the file handle is
                    known which we might as well leverage */
@@ -2143,7 +1383,7 @@ static int cifs_write_end(struct file *file, struct address_space *mapping,
                 /* if (rc < 0) should we set writebehind rc? */
                 kunmap(page);
 
-                free_xid(xid);
+                FreeXid(xid);
         } else {
                 rc = copied;
                 pos += copied;
@@ -2166,10 +1406,9 @@ static int cifs_write_end(struct file *file, struct address_space *mapping,
 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
                       int datasync)
 {
-        unsigned int xid;
+        int xid;
         int rc = 0;
         struct cifs_tcon *tcon;
-        struct TCP_Server_Info *server;
         struct cifsFileInfo *smbfile = file->private_data;
         struct inode *inode = file->f_path.dentry->d_inode;
         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
@@ -2179,7 +1418,7 @@ int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
                 return rc;
         mutex_lock(&inode->i_mutex);
 
-        xid = get_xid();
+        xid = GetXid();
 
         cFYI(1, "Sync file - name: %s datasync: 0x%x",
                 file->f_path.dentry->d_name.name, datasync);
@@ -2193,25 +1432,19 @@ int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
         }
 
         tcon = tlink_tcon(smbfile->tlink);
-        if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
-                server = tcon->ses->server;
-                if (server->ops->flush)
-                        rc = server->ops->flush(xid, tcon, &smbfile->fid);
-                else
-                        rc = -ENOSYS;
-        }
+        if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
+                rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
 
-        free_xid(xid);
+        FreeXid(xid);
         mutex_unlock(&inode->i_mutex);
         return rc;
 }
 
 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 {
-        unsigned int xid;
+        int xid;
         int rc = 0;
         struct cifs_tcon *tcon;
-        struct TCP_Server_Info *server;
         struct cifsFileInfo *smbfile = file->private_data;
         struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
         struct inode *inode = file->f_mapping->host;
@@ -2221,21 +1454,16 @@ int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
                 return rc;
         mutex_lock(&inode->i_mutex);
 
-        xid = get_xid();
+        xid = GetXid();
 
         cFYI(1, "Sync file - name: %s datasync: 0x%x",
                 file->f_path.dentry->d_name.name, datasync);
 
         tcon = tlink_tcon(smbfile->tlink);
-        if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
-                server = tcon->ses->server;
-                if (server->ops->flush)
-                        rc = server->ops->flush(xid, tcon, &smbfile->fid);
-                else
-                        rc = -ENOSYS;
-        }
+        if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
+                rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
 
-        free_xid(xid);
+        FreeXid(xid);
         mutex_unlock(&inode->i_mutex);
         return rc;
 }
@@ -2264,7 +1492,7 @@ cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
         unsigned long i;
 
         for (i = 0; i < num_pages; i++) {
-                pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
+                pages[i] = alloc_page(__GFP_HIGHMEM);
                 if (!pages[i]) {
                         /*
                          * save number of pages we have already allocated and
@@ -2272,14 +1500,15 @@ cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
                          */
                         num_pages = i;
                         rc = -ENOMEM;
-                        break;
+                        goto error;
                 }
         }
 
-        if (rc) {
-                for (i = 0; i < num_pages; i++)
-                        put_page(pages[i]);
-        }
+        return rc;
+
+error:
+        for (i = 0; i < num_pages; i++)
+                put_page(pages[i]);
         return rc;
 }
 
@@ -2290,7 +1519,9 @@ size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
         size_t clen;
 
         clen = min_t(const size_t, len, wsize);
-        num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
+        num_pages = clen / PAGE_CACHE_SIZE;
+        if (clen % PAGE_CACHE_SIZE)
+                num_pages++;
 
         if (cur_len)
                 *cur_len = clen;
@@ -2298,68 +1529,24 @@ size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
         return num_pages;
 }
 
-static void
-cifs_uncached_writev_complete(struct work_struct *work)
-{
-        int i;
-        struct cifs_writedata *wdata = container_of(work,
-                                        struct cifs_writedata, work);
-        struct inode *inode = wdata->cfile->dentry->d_inode;
-        struct cifsInodeInfo *cifsi = CIFS_I(inode);
-
-        spin_lock(&inode->i_lock);
-        cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
-        if (cifsi->server_eof > inode->i_size)
-                i_size_write(inode, cifsi->server_eof);
-        spin_unlock(&inode->i_lock);
-
-        complete(&wdata->done);
-
-        if (wdata->result != -EAGAIN) {
-                for (i = 0; i < wdata->nr_pages; i++)
-                        put_page(wdata->pages[i]);
-        }
-
-        kref_put(&wdata->refcount, cifs_writedata_release);
-}
-
-/* attempt to send write to server, retry on any -EAGAIN errors */
-static int
-cifs_uncached_retry_writev(struct cifs_writedata *wdata)
-{
-        int rc;
-        struct TCP_Server_Info *server;
-
-        server = tlink_tcon(wdata->cfile->tlink)->ses->server;
-
-        do {
-                if (wdata->cfile->invalidHandle) {
-                        rc = cifs_reopen_file(wdata->cfile, false);
-                        if (rc != 0)
-                                continue;
-                }
-                rc = server->ops->async_writev(wdata);
-        } while (rc == -EAGAIN);
-
-        return rc;
-}
-
 static ssize_t
 cifs_iovec_write(struct file *file, const struct iovec *iov,
                  unsigned long nr_segs, loff_t *poffset)
 {
-        unsigned long nr_pages, i;
+        unsigned int written;
+        unsigned long num_pages, npages, i;
         size_t copied, len, cur_len;
         ssize_t total_written = 0;
-        loff_t offset;
+        struct kvec *to_send;
+        struct page **pages;
         struct iov_iter it;
+        struct inode *inode;
         struct cifsFileInfo *open_file;
-        struct cifs_tcon *tcon;
+        struct cifs_tcon *pTcon;
         struct cifs_sb_info *cifs_sb;
-        struct cifs_writedata *wdata, *tmp;
-        struct list_head wdata_list;
-        int rc;
-        pid_t pid;
+        struct cifs_io_parms io_parms;
+        int xid, rc;
+        __u32 pid;
 
         len = iov_length(iov, nr_segs);
         if (!len)
@@ -2369,109 +1556,103 @@ cifs_iovec_write(struct file *file, const struct iovec *iov,
         if (rc)
                 return rc;
 
-        INIT_LIST_HEAD(&wdata_list);
         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
-        open_file = file->private_data;
-        tcon = tlink_tcon(open_file->tlink);
+        num_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
+
+        pages = kmalloc(sizeof(struct pages *)*num_pages, GFP_KERNEL);
+        if (!pages)
+                return -ENOMEM;
 
-        if (!tcon->ses->server->ops->async_writev)
-                return -ENOSYS;
+        to_send = kmalloc(sizeof(struct kvec)*(num_pages + 1), GFP_KERNEL);
+        if (!to_send) {
+                kfree(pages);
+                return -ENOMEM;
+        }
 
-        offset = *poffset;
+        rc = cifs_write_allocate_pages(pages, num_pages);
+        if (rc) {
+                kfree(pages);
+                kfree(to_send);
+                return rc;
+        }
+
+        xid = GetXid();
+        open_file = file->private_data;
 
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
                 pid = open_file->pid;
         else
                 pid = current->tgid;
 
-        iov_iter_init(&it, iov, nr_segs, len, 0);
-        do {
-                size_t save_len;
-
-                nr_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
-                wdata = cifs_writedata_alloc(nr_pages,
-                                             cifs_uncached_writev_complete);
-                if (!wdata) {
-                        rc = -ENOMEM;
-                        break;
-                }
+        pTcon = tlink_tcon(open_file->tlink);
+        inode = file->f_path.dentry->d_inode;
 
-                rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
-                if (rc) {
-                        kfree(wdata);
-                        break;
-                }
+        iov_iter_init(&it, iov, nr_segs, len, 0);
+        npages = num_pages;
 
-                save_len = cur_len;
-                for (i = 0; i < nr_pages; i++) {
-                        copied = min_t(const size_t, cur_len, PAGE_SIZE);
-                        copied = iov_iter_copy_from_user(wdata->pages[i], &it,
-                                                         0, copied);
+        do {
+                size_t save_len = cur_len;
+                for (i = 0; i < npages; i++) {
+                        copied = min_t(const size_t, cur_len, PAGE_CACHE_SIZE);
+                        copied = iov_iter_copy_from_user(pages[i], &it, 0,
+                                                         copied);
                         cur_len -= copied;
                         iov_iter_advance(&it, copied);
+                        to_send[i+1].iov_base = kmap(pages[i]);
+                        to_send[i+1].iov_len = copied;
                 }
+
                 cur_len = save_len - cur_len;
 
-                wdata->sync_mode = WB_SYNC_ALL;
-                wdata->nr_pages = nr_pages;
-                wdata->offset = (__u64)offset;
-                wdata->cfile = cifsFileInfo_get(open_file);
-                wdata->pid = pid;
-                wdata->bytes = cur_len;
-                wdata->pagesz = PAGE_SIZE;
-                wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
-                rc = cifs_uncached_retry_writev(wdata);
-                if (rc) {
-                        kref_put(&wdata->refcount, cifs_writedata_release);
+                do {
+                        if (open_file->invalidHandle) {
+                                rc = cifs_reopen_file(open_file, false);
+                                if (rc != 0)
+                                        break;
+                        }
+                        io_parms.netfid = open_file->netfid;
+                        io_parms.pid = pid;
+                        io_parms.tcon = pTcon;
+                        io_parms.offset = *poffset;
+                        io_parms.length = cur_len;
+                        rc = CIFSSMBWrite2(xid, &io_parms, &written, to_send,
+                                           npages, 0);
+                } while (rc == -EAGAIN);
+
+                for (i = 0; i < npages; i++)
+                        kunmap(pages[i]);
+
+                if (written) {
+                        len -= written;
+                        total_written += written;
+                        cifs_update_eof(CIFS_I(inode), *poffset, written);
+                        *poffset += written;
+                } else if (rc < 0) {
+                        if (!total_written)
+                                total_written = rc;
                         break;
                 }
 
-                list_add_tail(&wdata->list, &wdata_list);
-                offset += cur_len;
-                len -= cur_len;
+                /* get length and number of kvecs of the next write */
+                npages = get_numpages(cifs_sb->wsize, len, &cur_len);
         } while (len > 0);
 
-        /*
-         * If at least one write was successfully sent, then discard any rc
-         * value from the later writes. If the other write succeeds, then
-         * we'll end up returning whatever was written. If it fails, then
-         * we'll get a new rc value from that.
-         */
-        if (!list_empty(&wdata_list))
-                rc = 0;
-
-        /*
-         * Wait for and collect replies for any successful sends in order of
-         * increasing offset. Once an error is hit or we get a fatal signal
-         * while waiting, then return without waiting for any more replies.
-         */
-restart_loop:
-        list_for_each_entry_safe(wdata, tmp, &wdata_list, list) {
-                if (!rc) {
-                        /* FIXME: freezable too? */
-                        rc = wait_for_completion_killable(&wdata->done);
-                        if (rc)
-                                rc = -EINTR;
-                        else if (wdata->result)
-                                rc = wdata->result;
-                        else
-                                total_written += wdata->bytes;
-
-                        /* resend call if it's a retryable error */
-                        if (rc == -EAGAIN) {
-                                rc = cifs_uncached_retry_writev(wdata);
-                                goto restart_loop;
-                        }
-                }
-                list_del_init(&wdata->list);
-                kref_put(&wdata->refcount, cifs_writedata_release);
+        if (total_written > 0) {
+                spin_lock(&inode->i_lock);
+                if (*poffset > inode->i_size)
+                        i_size_write(inode, *poffset);
+                spin_unlock(&inode->i_lock);
         }
 
-        if (total_written > 0)
-                *poffset += total_written;
+        cifs_stats_bytes_written(pTcon, total_written);
+        mark_inode_dirty_sync(inode);
 
-        cifs_stats_bytes_written(tcon, total_written);
-        return total_written ? total_written : (ssize_t)rc;
+        for (i = 0; i < num_pages; i++)
+                put_page(pages[i]);
+        kfree(to_send);
+        kfree(pages);
+        FreeXid(xid);
+        return total_written;
 }
 
 ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
@@ -2497,304 +1678,43 @@ ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
         return written;
 }
 
-static ssize_t
-cifs_writev(struct kiocb *iocb, const struct iovec *iov,
-            unsigned long nr_segs, loff_t pos)
+ssize_t cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
+                           unsigned long nr_segs, loff_t pos)
 {
-        struct file *file = iocb->ki_filp;
-        struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
-        struct inode *inode = file->f_mapping->host;
-        struct cifsInodeInfo *cinode = CIFS_I(inode);
-        struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
-        ssize_t rc = -EACCES;
-
-        BUG_ON(iocb->ki_pos != pos);
-
-        sb_start_write(inode->i_sb);
-
-        /*
-         * We need to hold the sem to be sure nobody modifies lock list
-         * with a brlock that prevents writing.
-         */
-        down_read(&cinode->lock_sem);
-        if (!cifs_find_lock_conflict(cfile, pos, iov_length(iov, nr_segs),
-                                     server->vals->exclusive_lock_type, NULL,
-                                     CIFS_WRITE_OP)) {
-                mutex_lock(&inode->i_mutex);
-                rc = __generic_file_aio_write(iocb, iov, nr_segs,
-                                               &iocb->ki_pos);
-                mutex_unlock(&inode->i_mutex);
-        }
-
-        if (rc > 0 || rc == -EIOCBQUEUED) {
-                ssize_t err;
+        struct inode *inode;
 
-                err = generic_write_sync(file, pos, rc);
-                if (err < 0 && rc > 0)
-                        rc = err;
-        }
+        inode = iocb->ki_filp->f_path.dentry->d_inode;
 
-        up_read(&cinode->lock_sem);
-        sb_end_write(inode->i_sb);
-        return rc;
-}
+        if (CIFS_I(inode)->clientCanCacheAll)
+                return generic_file_aio_write(iocb, iov, nr_segs, pos);
 
-ssize_t
-cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
-                   unsigned long nr_segs, loff_t pos)
-{
-        struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
-        struct cifsInodeInfo *cinode = CIFS_I(inode);
-        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
-        struct cifsFileInfo *cfile = (struct cifsFileInfo *)
-                                                iocb->ki_filp->private_data;
-        struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
-        ssize_t written;
-
-        if (cinode->clientCanCacheAll) {
-                if (cap_unix(tcon->ses) &&
-                (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
-                    && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
-                        return generic_file_aio_write(iocb, iov, nr_segs, pos);
-                return cifs_writev(iocb, iov, nr_segs, pos);
-        }
         /*
-         * For non-oplocked files in strict cache mode we need to write the data
-         * to the server exactly from the pos to pos+len-1 rather than flush all
-         * affected pages because it may cause a error with mandatory locks on
-         * these pages but not on the region from pos to ppos+len-1.
+         * In strict cache mode we need to write the data to the server exactly
+         * from the pos to pos+len-1 rather than flush all affected pages
+         * because it may cause a error with mandatory locks on these pages but
+         * not on the region from pos to ppos+len-1.
          */
-        written = cifs_user_writev(iocb, iov, nr_segs, pos);
-        if (written > 0 && cinode->clientCanCacheRead) {
-                /*
-                 * Windows 7 server can delay breaking level2 oplock if a write
-                 * request comes - break it on the client to prevent reading
-                 * an old data.
-                 */
-                cifs_invalidate_mapping(inode);
-                cFYI(1, "Set no oplock for inode=%p after a write operation",
-                     inode);
-                cinode->clientCanCacheRead = false;
-        }
-        return written;
-}
 
-static struct cifs_readdata *
-cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
-{
-        struct cifs_readdata *rdata;
-
-        rdata = kzalloc(sizeof(*rdata) + (sizeof(struct page *) * nr_pages),
-                        GFP_KERNEL);
-        if (rdata != NULL) {
-                kref_init(&rdata->refcount);
-                INIT_LIST_HEAD(&rdata->list);
-                init_completion(&rdata->done);
-                INIT_WORK(&rdata->work, complete);
-        }
-
-        return rdata;
-}
-
-void
-cifs_readdata_release(struct kref *refcount)
-{
-        struct cifs_readdata *rdata = container_of(refcount,
-                                        struct cifs_readdata, refcount);
-
-        if (rdata->cfile)
-                cifsFileInfo_put(rdata->cfile);
-
-        kfree(rdata);
-}
-
-static int
-cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
-{
-        int rc = 0;
-        struct page *page;
-        unsigned int i;
-
-        for (i = 0; i < nr_pages; i++) {
-                page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
-                if (!page) {
-                        rc = -ENOMEM;
-                        break;
-                }
-                rdata->pages[i] = page;
-        }
-
-        if (rc) {
-                for (i = 0; i < nr_pages; i++) {
-                        put_page(rdata->pages[i]);
-                        rdata->pages[i] = NULL;
-                }
-        }
-        return rc;
-}
-
-static void
-cifs_uncached_readdata_release(struct kref *refcount)
-{
-        struct cifs_readdata *rdata = container_of(refcount,
-                                        struct cifs_readdata, refcount);
-        unsigned int i;
-
-        for (i = 0; i < rdata->nr_pages; i++) {
-                put_page(rdata->pages[i]);
-                rdata->pages[i] = NULL;
-        }
-        cifs_readdata_release(refcount);
-}
-
-static int
-cifs_retry_async_readv(struct cifs_readdata *rdata)
-{
-        int rc;
-        struct TCP_Server_Info *server;
-
-        server = tlink_tcon(rdata->cfile->tlink)->ses->server;
-
-        do {
-                if (rdata->cfile->invalidHandle) {
-                        rc = cifs_reopen_file(rdata->cfile, true);
-                        if (rc != 0)
-                                continue;
-                }
-                rc = server->ops->async_readv(rdata);
-        } while (rc == -EAGAIN);
-
-        return rc;
-}
-
-/**
- * cifs_readdata_to_iov - copy data from pages in response to an iovec
- * @rdata:      the readdata response with list of pages holding data
- * @iov:        vector in which we should copy the data
- * @nr_segs:    number of segments in vector
- * @offset:     offset into file of the first iovec
- * @copied:     used to return the amount of data copied to the iov
- *
- * This function copies data from a list of pages in a readdata response into
- * an array of iovecs. It will first calculate where the data should go
- * based on the info in the readdata and then copy the data into that spot.
- */
-static ssize_t
-cifs_readdata_to_iov(struct cifs_readdata *rdata, const struct iovec *iov,
-                        unsigned long nr_segs, loff_t offset, ssize_t *copied)
-{
-        int rc = 0;
-        struct iov_iter ii;
-        size_t pos = rdata->offset - offset;
-        ssize_t remaining = rdata->bytes;
-        unsigned char *pdata;
-        unsigned int i;
-
-        /* set up iov_iter and advance to the correct offset */
-        iov_iter_init(&ii, iov, nr_segs, iov_length(iov, nr_segs), 0);
-        iov_iter_advance(&ii, pos);
-
-        *copied = 0;
-        for (i = 0; i < rdata->nr_pages; i++) {
-                ssize_t copy;
-                struct page *page = rdata->pages[i];
-
-                /* copy a whole page or whatever's left */
-                copy = min_t(ssize_t, remaining, PAGE_SIZE);
-
-                /* ...but limit it to whatever space is left in the iov */
-                copy = min_t(ssize_t, copy, iov_iter_count(&ii));
-
-                /* go while there's data to be copied and no errors */
-                if (copy && !rc) {
-                        pdata = kmap(page);
-                        rc = memcpy_toiovecend(ii.iov, pdata, ii.iov_offset,
-                                                (int)copy);
-                        kunmap(page);
-                        if (!rc) {
-                                *copied += copy;
-                                remaining -= copy;
-                                iov_iter_advance(&ii, copy);
-                        }
-                }
-        }
-
-        return rc;
-}
-
-static void
-cifs_uncached_readv_complete(struct work_struct *work)
-{
-        struct cifs_readdata *rdata = container_of(work,
-                                                struct cifs_readdata, work);
-
-        complete(&rdata->done);
-        kref_put(&rdata->refcount, cifs_uncached_readdata_release);
-}
-
-static int
-cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
-                        struct cifs_readdata *rdata, unsigned int len)
-{
-        int total_read = 0, result = 0;
-        unsigned int i;
-        unsigned int nr_pages = rdata->nr_pages;
-        struct kvec iov;
-
-        rdata->tailsz = PAGE_SIZE;
-        for (i = 0; i < nr_pages; i++) {
-                struct page *page = rdata->pages[i];
-
-                if (len >= PAGE_SIZE) {
-                        /* enough data to fill the page */
-                        iov.iov_base = kmap(page);
-                        iov.iov_len = PAGE_SIZE;
-                        cFYI(1, "%u: iov_base=%p iov_len=%zu",
-                                i, iov.iov_base, iov.iov_len);
-                        len -= PAGE_SIZE;
-                } else if (len > 0) {
-                        /* enough for partial page, fill and zero the rest */
-                        iov.iov_base = kmap(page);
-                        iov.iov_len = len;
-                        cFYI(1, "%u: iov_base=%p iov_len=%zu",
-                                i, iov.iov_base, iov.iov_len);
-                        memset(iov.iov_base + len, '\0', PAGE_SIZE - len);
-                        rdata->tailsz = len;
-                        len = 0;
-                } else {
-                        /* no need to hold page hostage */
-                        rdata->pages[i] = NULL;
-                        rdata->nr_pages--;
-                        put_page(page);
-                        continue;
-                }
-
-                result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
-                kunmap(page);
-                if (result < 0)
-                        break;
-
-                total_read += result;
-        }
-
-        return total_read > 0 ? total_read : result;
+        return cifs_user_writev(iocb, iov, nr_segs, pos);
 }
 
 static ssize_t
 cifs_iovec_read(struct file *file, const struct iovec *iov,
                  unsigned long nr_segs, loff_t *poffset)
 {
-        ssize_t rc;
+        int rc;
+        int xid;
+        ssize_t total_read;
+        unsigned int bytes_read = 0;
         size_t len, cur_len;
-        ssize_t total_read = 0;
-        loff_t offset = *poffset;
-        unsigned int npages;
+        int iov_offset = 0;
         struct cifs_sb_info *cifs_sb;
-        struct cifs_tcon *tcon;
+        struct cifs_tcon *pTcon;
         struct cifsFileInfo *open_file;
-        struct cifs_readdata *rdata, *tmp;
-        struct list_head rdata_list;
-        pid_t pid;
+        struct smb_com_read_rsp *pSMBr;
+        struct cifs_io_parms io_parms;
+        char *read_data;
+        __u32 pid;
 
         if (!nr_segs)
                 return 0;
@@ -2803,13 +1723,11 @@ cifs_iovec_read(struct file *file, const struct iovec *iov,
         if (!len)
                 return 0;
 
-        INIT_LIST_HEAD(&rdata_list);
+        xid = GetXid();
         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
-        open_file = file->private_data;
-        tcon = tlink_tcon(open_file->tlink);
 
-        if (!tcon->ses->server->ops->async_readv)
-                return -ENOSYS;
+        open_file = file->private_data;
+        pTcon = tlink_tcon(open_file->tlink);
 
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
                 pid = open_file->pid;
@@ -2819,84 +1737,56 @@ cifs_iovec_read(struct file *file, const struct iovec *iov,
         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
                 cFYI(1, "attempting read on write only file instance");
 
-        do {
+        for (total_read = 0; total_read < len; total_read += bytes_read) {
                 cur_len = min_t(const size_t, len - total_read, cifs_sb->rsize);
-                npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
-
-                /* allocate a readdata struct */
-                rdata = cifs_readdata_alloc(npages,
-                                            cifs_uncached_readv_complete);
-                if (!rdata) {
-                        rc = -ENOMEM;
-                        goto error;
-                }
-
-                rc = cifs_read_allocate_pages(rdata, npages);
-                if (rc)
-                        goto error;
-
-                rdata->cfile = cifsFileInfo_get(open_file);
-                rdata->nr_pages = npages;
-                rdata->offset = offset;
-                rdata->bytes = cur_len;
-                rdata->pid = pid;
-                rdata->pagesz = PAGE_SIZE;
-                rdata->read_into_pages = cifs_uncached_read_into_pages;
-
-                rc = cifs_retry_async_readv(rdata);
-error:
-                if (rc) {
-                        kref_put(&rdata->refcount,
-                                 cifs_uncached_readdata_release);
-                        break;
-                }
-
-                list_add_tail(&rdata->list, &rdata_list);
-                offset += cur_len;
-                len -= cur_len;
-        } while (len > 0);
-
-        /* if at least one read request send succeeded, then reset rc */
-        if (!list_empty(&rdata_list))
-                rc = 0;
+                rc = -EAGAIN;
+                read_data = NULL;
 
-        /* the loop below should proceed in the order of increasing offsets */
-restart_loop:
-        list_for_each_entry_safe(rdata, tmp, &rdata_list, list) {
-                if (!rc) {
-                        ssize_t copied;
-
-                        /* FIXME: freezable sleep too? */
-                        rc = wait_for_completion_killable(&rdata->done);
-                        if (rc)
-                                rc = -EINTR;
-                        else if (rdata->result)
-                                rc = rdata->result;
-                        else {
-                                rc = cifs_readdata_to_iov(rdata, iov,
-                                                        nr_segs, *poffset,
-                                                        &copied);
-                                total_read += copied;
+                while (rc == -EAGAIN) {
+                        int buf_type = CIFS_NO_BUFFER;
+                        if (open_file->invalidHandle) {
+                                rc = cifs_reopen_file(open_file, true);
+                                if (rc != 0)
+                                        break;
+                        }
+                        io_parms.netfid = open_file->netfid;
+                        io_parms.pid = pid;
+                        io_parms.tcon = pTcon;
+                        io_parms.offset = *poffset;
+                        io_parms.length = cur_len;
+                        rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
+                                         &read_data, &buf_type);
+                        pSMBr = (struct smb_com_read_rsp *)read_data;
+                        if (read_data) {
+                                char *data_offset = read_data + 4 +
+                                                le16_to_cpu(pSMBr->DataOffset);
+                                if (memcpy_toiovecend(iov, data_offset,
+                                                      iov_offset, bytes_read))
+                                        rc = -EFAULT;
+                                if (buf_type == CIFS_SMALL_BUFFER)
+                                        cifs_small_buf_release(read_data);
+                                else if (buf_type == CIFS_LARGE_BUFFER)
+                                        cifs_buf_release(read_data);
+                                read_data = NULL;
+                                iov_offset += bytes_read;
                         }
+                }
 
-                        /* resend call if it's a retryable error */
-                        if (rc == -EAGAIN) {
-                                rc = cifs_retry_async_readv(rdata);
-                                goto restart_loop;
+                if (rc || (bytes_read == 0)) {
+                        if (total_read) {
+                                break;
+                        } else {
+                                FreeXid(xid);
+                                return rc;
                         }
+                } else {
+                        cifs_stats_bytes_read(pTcon, bytes_read);
+                        *poffset += bytes_read;
                 }
-                list_del_init(&rdata->list);
-                kref_put(&rdata->refcount, cifs_uncached_readdata_release);
         }
 
-        cifs_stats_bytes_read(tcon, total_read);
-        *poffset += total_read;
-
-        /* mask nodata case */
-        if (rc == -ENODATA)
-                rc = 0;
-
-        return total_read ? total_read : rc;
+        FreeXid(xid);
+        return total_read;
 }
 
 ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
@@ -2911,17 +1801,15 @@ ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
         return read;
 }
 
-ssize_t
-cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
-                  unsigned long nr_segs, loff_t pos)
+ssize_t cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
+                          unsigned long nr_segs, loff_t pos)
 {
-        struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
-        struct cifsInodeInfo *cinode = CIFS_I(inode);
-        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
-        struct cifsFileInfo *cfile = (struct cifsFileInfo *)
-                                                iocb->ki_filp->private_data;
-        struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
-        int rc = -EACCES;
+        struct inode *inode;
+
+        inode = iocb->ki_filp->f_path.dentry->d_inode;
+
+        if (CIFS_I(inode)->clientCanCacheRead)
+                return generic_file_aio_read(iocb, iov, nr_segs, pos);
 
         /*
          * In strict cache mode we need to read from the server all the time
@@ -2931,64 +1819,36 @@ cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
          * on pages affected by this read but not on the region from pos to
          * pos+len-1.
          */
-        if (!cinode->clientCanCacheRead)
-                return cifs_user_readv(iocb, iov, nr_segs, pos);
 
-        if (cap_unix(tcon->ses) &&
-            (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
-            ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
-                return generic_file_aio_read(iocb, iov, nr_segs, pos);
-
-        /*
-         * We need to hold the sem to be sure nobody modifies lock list
-         * with a brlock that prevents reading.
-         */
-        down_read(&cinode->lock_sem);
-        if (!cifs_find_lock_conflict(cfile, pos, iov_length(iov, nr_segs),
-                                     tcon->ses->server->vals->shared_lock_type,
-                                     NULL, CIFS_READ_OP))
-                rc = generic_file_aio_read(iocb, iov, nr_segs, pos);
-        up_read(&cinode->lock_sem);
-        return rc;
+        return cifs_user_readv(iocb, iov, nr_segs, pos);
 }
 
-static ssize_t
-cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
+static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
+                         loff_t *poffset)
 {
         int rc = -EACCES;
         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 *tcon;
-        struct TCP_Server_Info *server;
-        unsigned int xid;
-        char *cur_offset;
+        struct cifs_tcon *pTcon;
+        int xid;
+        char *current_offset;
         struct cifsFileInfo *open_file;
         struct cifs_io_parms io_parms;
         int buf_type = CIFS_NO_BUFFER;
         __u32 pid;
 
-        xid = get_xid();
+        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;
-                free_xid(xid);
+                FreeXid(xid);
                 return rc;
         }
         open_file = file->private_data;
-        tcon = tlink_tcon(open_file->tlink);
-        server = tcon->ses->server;
-
-        if (!server->ops->sync_read) {
-                free_xid(xid);
-                return -ENOSYS;
-        }
+        pTcon = tlink_tcon(open_file->tlink);
 
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
                 pid = open_file->pid;
@@ -2998,17 +1858,17 @@ cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
                 cFYI(1, "attempting read on write only file instance");
 
-        for (total_read = 0, cur_offset = read_data; read_size > total_read;
-             total_read += bytes_read, cur_offset += bytes_read) {
-                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 ((tcon->ses) && !(tcon->ses->capabilities &
-                                tcon->ses->server->vals->cap_large_files)) {
-                        current_read_size = min_t(uint, current_read_size,
-                                        CIFSMaxBufSize);
+        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(const int, read_size - total_read,
+                                          cifs_sb->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) &&
+                        !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
+                        current_read_size = min_t(const int, current_read_size,
+                                        pTcon->ses->server->maxBuf - 128);
                 }
                 rc = -EAGAIN;
                 while (rc == -EAGAIN) {
@@ -3017,27 +1877,27 @@ cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
                                 if (rc != 0)
                                         break;
                         }
+                        io_parms.netfid = open_file->netfid;
                         io_parms.pid = pid;
-                        io_parms.tcon = tcon;
-                        io_parms.offset = *offset;
+                        io_parms.tcon = pTcon;
+                        io_parms.offset = *poffset;
                         io_parms.length = current_read_size;
-                        rc = server->ops->sync_read(xid, open_file, &io_parms,
-                                                    &bytes_read, &cur_offset,
-                                                    &buf_type);
+                        rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
+                                         &current_offset, &buf_type);
                 }
                 if (rc || (bytes_read == 0)) {
                         if (total_read) {
                                 break;
                         } else {
-                                free_xid(xid);
+                                FreeXid(xid);
                                 return rc;
                         }
                 } else {
-                        cifs_stats_bytes_read(tcon, total_read);
-                        *offset += bytes_read;
+                        cifs_stats_bytes_read(pTcon, total_read);
+                        *poffset += bytes_read;
                 }
         }
-        free_xid(xid);
+        FreeXid(xid);
         return total_read;
 }
 
@@ -3057,7 +1917,6 @@ cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
 static struct vm_operations_struct cifs_file_vm_ops = {
         .fault = filemap_fault,
         .page_mkwrite = cifs_page_mkwrite,
-        .remap_pages = generic_file_remap_pages,
 };
 
 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
@@ -3065,7 +1924,7 @@ int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
         int rc, xid;
         struct inode *inode = file->f_path.dentry->d_inode;
 
-        xid = get_xid();
+        xid = GetXid();
 
         if (!CIFS_I(inode)->clientCanCacheRead) {
                 rc = cifs_invalidate_mapping(inode);
@@ -3076,7 +1935,7 @@ int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
         rc = generic_file_mmap(file, vma);
         if (rc == 0)
                 vma->vm_ops = &cifs_file_vm_ops;
-        free_xid(xid);
+        FreeXid(xid);
         return rc;
 }
 
@@ -3084,142 +1943,96 @@ int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
 {
         int rc, xid;
 
-        xid = get_xid();
+        xid = GetXid();
         rc = cifs_revalidate_file(file);
         if (rc) {
                 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
-                free_xid(xid);
+                FreeXid(xid);
                 return rc;
         }
         rc = generic_file_mmap(file, vma);
         if (rc == 0)
                 vma->vm_ops = &cifs_file_vm_ops;
-        free_xid(xid);
+        FreeXid(xid);
         return rc;
 }
 
-static void
-cifs_readv_complete(struct work_struct *work)
+
+static void cifs_copy_cache_pages(struct address_space *mapping,
+        struct list_head *pages, int bytes_read, char *data)
 {
-        unsigned int i;
-        struct cifs_readdata *rdata = container_of(work,
-                                                struct cifs_readdata, work);
+        struct page *page;
+        char *target;
 
-        for (i = 0; i < rdata->nr_pages; i++) {
-                struct page *page = rdata->pages[i];
+        while (bytes_read > 0) {
+                if (list_empty(pages))
+                        break;
 
-                lru_cache_add_file(page);
+                page = list_entry(pages->prev, struct page, lru);
+                list_del(&page->lru);
 
-                if (rdata->result == 0) {
-                        flush_dcache_page(page);
-                        SetPageUptodate(page);
+                if (add_to_page_cache_lru(page, mapping, page->index,
+                                      GFP_KERNEL)) {
+                        page_cache_release(page);
+                        cFYI(1, "Add page cache failed");
+                        data += PAGE_CACHE_SIZE;
+                        bytes_read -= PAGE_CACHE_SIZE;
+                        continue;
                 }
-
-                unlock_page(page);
-
-                if (rdata->result == 0)
-                        cifs_readpage_to_fscache(rdata->mapping->host, page);
-
                 page_cache_release(page);
-                rdata->pages[i] = NULL;
-        }
-        kref_put(&rdata->refcount, cifs_readdata_release);
-}
 
-static int
-cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
-                        struct cifs_readdata *rdata, unsigned int len)
-{
-        int total_read = 0, result = 0;
-        unsigned int i;
-        u64 eof;
-        pgoff_t eof_index;
-        unsigned int nr_pages = rdata->nr_pages;
-        struct kvec iov;
-
-        /* determine the eof that the server (probably) has */
-        eof = CIFS_I(rdata->mapping->host)->server_eof;
-        eof_index = eof ? (eof - 1) >> PAGE_CACHE_SHIFT : 0;
-        cFYI(1, "eof=%llu eof_index=%lu", eof, eof_index);
-
-        rdata->tailsz = PAGE_CACHE_SIZE;
-        for (i = 0; i < nr_pages; i++) {
-                struct page *page = rdata->pages[i];
-
-                if (len >= PAGE_CACHE_SIZE) {
-                        /* enough data to fill the page */
-                        iov.iov_base = kmap(page);
-                        iov.iov_len = PAGE_CACHE_SIZE;
-                        cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
-                                i, page->index, iov.iov_base, iov.iov_len);
-                        len -= PAGE_CACHE_SIZE;
-                } else if (len > 0) {
-                        /* enough for partial page, fill and zero the rest */
-                        iov.iov_base = kmap(page);
-                        iov.iov_len = len;
-                        cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
-                                i, page->index, iov.iov_base, iov.iov_len);
-                        memset(iov.iov_base + len,
-                                '\0', PAGE_CACHE_SIZE - len);
-                        rdata->tailsz = len;
-                        len = 0;
-                } else if (page->index > eof_index) {
-                        /*
-                         * The VFS will not try to do readahead past the
-                         * i_size, but it's possible that we have outstanding
-                         * writes with gaps in the middle and the i_size hasn't
-                         * caught up yet. Populate those with zeroed out pages
-                         * to prevent the VFS from repeatedly attempting to
-                         * fill them until the writes are flushed.
-                         */
-                        zero_user(page, 0, PAGE_CACHE_SIZE);
-                        lru_cache_add_file(page);
-                        flush_dcache_page(page);
-                        SetPageUptodate(page);
-                        unlock_page(page);
-                        page_cache_release(page);
-                        rdata->pages[i] = NULL;
-                        rdata->nr_pages--;
-                        continue;
+                target = kmap_atomic(page, KM_USER0);
+
+                if (PAGE_CACHE_SIZE > bytes_read) {
+                        memcpy(target, data, bytes_read);
+                        /* zero the tail end of this partial page */
+                        memset(target + bytes_read, 0,
+                               PAGE_CACHE_SIZE - bytes_read);
+                        bytes_read = 0;
                 } else {
-                        /* no need to hold page hostage */
-                        lru_cache_add_file(page);
-                        unlock_page(page);
-                        page_cache_release(page);
-                        rdata->pages[i] = NULL;
-                        rdata->nr_pages--;
-                        continue;
+                        memcpy(target, data, PAGE_CACHE_SIZE);
+                        bytes_read -= PAGE_CACHE_SIZE;
                 }
+                kunmap_atomic(target, KM_USER0);
 
-                result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
-                kunmap(page);
-                if (result < 0)
-                        break;
+                flush_dcache_page(page);
+                SetPageUptodate(page);
+                unlock_page(page);
+                data += PAGE_CACHE_SIZE;
 
-                total_read += result;
+                /* add page to FS-Cache */
+                cifs_readpage_to_fscache(mapping->host, page);
         }
-
-        return total_read > 0 ? total_read : result;
+        return;
 }
 
 static int cifs_readpages(struct file *file, struct address_space *mapping,
         struct list_head *page_list, unsigned num_pages)
 {
-        int rc;
-        struct list_head tmplist;
-        struct cifsFileInfo *open_file = file->private_data;
-        struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
-        unsigned int rsize = cifs_sb->rsize;
-        pid_t pid;
+        int rc = -EACCES;
+        int xid;
+        loff_t offset;
+        struct page *page;
+        struct cifs_sb_info *cifs_sb;
+        struct cifs_tcon *pTcon;
+        unsigned int bytes_read = 0;
+        unsigned int read_size, i;
+        char *smb_read_data = NULL;
+        struct smb_com_read_rsp *pSMBr;
+        struct cifsFileInfo *open_file;
+        struct cifs_io_parms io_parms;
+        int buf_type = CIFS_NO_BUFFER;
+        __u32 pid;
 
-        /*
-         * Give up immediately if rsize is too small to read an entire page.
-         * The VFS will fall back to readpage. We should never reach this
-         * point however since we set ra_pages to 0 when the rsize is smaller
-         * than a cache page.
-         */
-        if (unlikely(rsize < PAGE_CACHE_SIZE))
-                return 0;
+        xid = GetXid();
+        if (file->private_data == NULL) {
+                rc = -EBADF;
+                FreeXid(xid);
+                return rc;
+        }
+        open_file = file->private_data;
+        cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
+        pTcon = tlink_tcon(open_file->tlink);
 
         /*
          * Reads as many pages as possible from fscache. Returns -ENOBUFS
@@ -3228,124 +2041,125 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
         rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
                                          &num_pages);
         if (rc == 0)
-                return rc;
+                goto read_complete;
 
+        cFYI(DBG2, "rpages: num pages %d", num_pages);
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
                 pid = open_file->pid;
         else
                 pid = current->tgid;
 
-        rc = 0;
-        INIT_LIST_HEAD(&tmplist);
+        for (i = 0; i < num_pages; ) {
+                unsigned contig_pages;
+                struct page *tmp_page;
+                unsigned long expected_index;
 
-        cFYI(1, "%s: file=%p mapping=%p num_pages=%u", __func__, file,
-                mapping, num_pages);
-
-        /*
-         * Start with the page at end of list and move it to private
-         * list. Do the same with any following pages until we hit
-         * the rsize limit, hit an index discontinuity, or run out of
-         * pages. Issue the async read and then start the loop again
-         * until the list is empty.
-         *
-         * Note that list order is important. The page_list is in
-         * the order of declining indexes. When we put the pages in
-         * the rdata->pages, then we want them in increasing order.
-         */
-        while (!list_empty(page_list)) {
-                unsigned int i;
-                unsigned int bytes = PAGE_CACHE_SIZE;
-                unsigned int expected_index;
-                unsigned int nr_pages = 1;
-                loff_t offset;
-                struct page *page, *tpage;
-                struct cifs_readdata *rdata;
-
-                page = list_entry(page_list->prev, struct page, lru);
-
-                /*
-                 * Lock the page and put it in the cache. Since no one else
-                 * should have access to this page, we're safe to simply set
-                 * PG_locked without checking it first.
-                 */
-                __set_page_locked(page);
-                rc = add_to_page_cache_locked(page, mapping,
-                                              page->index, GFP_KERNEL);
-
-                /* give up if we can't stick it in the cache */
-                if (rc) {
-                        __clear_page_locked(page);
+                if (list_empty(page_list))
                         break;
-                }
 
-                /* move first page to the tmplist */
+                page = list_entry(page_list->prev, struct page, lru);
                 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
-                list_move_tail(&page->lru, &tmplist);
-
-                /* now try and add more pages onto the request */
-                expected_index = page->index + 1;
-                list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
-                        /* discontinuity ? */
-                        if (page->index != expected_index)
-                                break;
 
-                        /* would this page push the read over the rsize? */
-                        if (bytes + PAGE_CACHE_SIZE > rsize)
-                                break;
-
-                        __set_page_locked(page);
-                        if (add_to_page_cache_locked(page, mapping,
-                                                page->index, GFP_KERNEL)) {
-                                __clear_page_locked(page);
+                /* count adjacent pages that we will read into */
+                contig_pages = 0;
+                expected_index =
+                        list_entry(page_list->prev, struct page, lru)->index;
+                list_for_each_entry_reverse(tmp_page, page_list, lru) {
+                        if (tmp_page->index == expected_index) {
+                                contig_pages++;
+                                expected_index++;
+                        } else
                                 break;
-                        }
-                        list_move_tail(&page->lru, &tmplist);
-                        bytes += PAGE_CACHE_SIZE;
-                        expected_index++;
-                        nr_pages++;
                 }
-
-                rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
-                if (!rdata) {
-                        /* best to give up if we're out of mem */
-                        list_for_each_entry_safe(page, tpage, &tmplist, lru) {
-                                list_del(&page->lru);
-                                lru_cache_add_file(page);
-                                unlock_page(page);
-                                page_cache_release(page);
+                if (contig_pages + i >  num_pages)
+                        contig_pages = num_pages - i;
+
+                /* for reads over a certain size could initiate async
+                   read ahead */
+
+                read_size = contig_pages * PAGE_CACHE_SIZE;
+                /* Read size needs to be in multiples of one page */
+                read_size = min_t(const unsigned int, read_size,
+                                  cifs_sb->rsize & PAGE_CACHE_MASK);
+                cFYI(DBG2, "rpages: read size 0x%x  contiguous pages %d",
+                                read_size, contig_pages);
+                rc = -EAGAIN;
+                while (rc == -EAGAIN) {
+                        if (open_file->invalidHandle) {
+                                rc = cifs_reopen_file(open_file, true);
+                                if (rc != 0)
+                                        break;
+                        }
+                        io_parms.netfid = open_file->netfid;
+                        io_parms.pid = pid;
+                        io_parms.tcon = pTcon;
+                        io_parms.offset = offset;
+                        io_parms.length = read_size;
+                        rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
+                                         &smb_read_data, &buf_type);
+                        /* BB more RC checks ? */
+                        if (rc == -EAGAIN) {
+                                if (smb_read_data) {
+                                        if (buf_type == CIFS_SMALL_BUFFER)
+                                                cifs_small_buf_release(smb_read_data);
+                                        else if (buf_type == CIFS_LARGE_BUFFER)
+                                                cifs_buf_release(smb_read_data);
+                                        smb_read_data = NULL;
+                                }
                         }
-                        rc = -ENOMEM;
-                        break;
-                }
-
-                rdata->cfile = cifsFileInfo_get(open_file);
-                rdata->mapping = mapping;
-                rdata->offset = offset;
-                rdata->bytes = bytes;
-                rdata->pid = pid;
-                rdata->pagesz = PAGE_CACHE_SIZE;
-                rdata->read_into_pages = cifs_readpages_read_into_pages;
-
-                list_for_each_entry_safe(page, tpage, &tmplist, lru) {
-                        list_del(&page->lru);
-                        rdata->pages[rdata->nr_pages++] = page;
                 }
-
-                rc = cifs_retry_async_readv(rdata);
-                if (rc != 0) {
-                        for (i = 0; i < rdata->nr_pages; i++) {
-                                page = rdata->pages[i];
-                                lru_cache_add_file(page);
-                                unlock_page(page);
-                                page_cache_release(page);
+                if ((rc < 0) || (smb_read_data == NULL)) {
+                        cFYI(1, "Read error in readpages: %d", rc);
+                        break;
+                } else if (bytes_read > 0) {
+                        task_io_account_read(bytes_read);
+                        pSMBr = (struct smb_com_read_rsp *)smb_read_data;
+                        cifs_copy_cache_pages(mapping, page_list, bytes_read,
+                                smb_read_data + 4 /* RFC1001 hdr */ +
+                                le16_to_cpu(pSMBr->DataOffset));
+
+                        i +=  bytes_read >> PAGE_CACHE_SHIFT;
+                        cifs_stats_bytes_read(pTcon, bytes_read);
+                        if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
+                                i++; /* account for partial page */
+
+                                /* server copy of file can have smaller size
+                                   than client */
+                                /* BB do we need to verify this common case ?
+                                   this case is ok - if we are at server EOF
+                                   we will hit it on next read */
+
+                                /* break; */
                         }
-                        kref_put(&rdata->refcount, cifs_readdata_release);
+                } else {
+                        cFYI(1, "No bytes read (%d) at offset %lld . "
+                                "Cleaning remaining pages from readahead list",
+                                bytes_read, offset);
+                        /* BB turn off caching and do new lookup on
+                           file size at server? */
                         break;
                 }
+                if (smb_read_data) {
+                        if (buf_type == CIFS_SMALL_BUFFER)
+                                cifs_small_buf_release(smb_read_data);
+                        else if (buf_type == CIFS_LARGE_BUFFER)
+                                cifs_buf_release(smb_read_data);
+                        smb_read_data = NULL;
+                }
+                bytes_read = 0;
+        }
 
-                kref_put(&rdata->refcount, cifs_readdata_release);
+/* need to free smb_read_data buf before exit */
+        if (smb_read_data) {
+                if (buf_type == CIFS_SMALL_BUFFER)
+                        cifs_small_buf_release(smb_read_data);
+                else if (buf_type == CIFS_LARGE_BUFFER)
+                        cifs_buf_release(smb_read_data);
+                smb_read_data = NULL;
         }
 
+read_complete:
+        FreeXid(xid);
         return rc;
 }
 
@@ -3397,24 +2211,24 @@ static int cifs_readpage(struct file *file, struct page *page)
 {
         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
         int rc = -EACCES;
-        unsigned int xid;
+        int xid;
 
-        xid = get_xid();
+        xid = GetXid();
 
         if (file->private_data == NULL) {
                 rc = -EBADF;
-                free_xid(xid);
+                FreeXid(xid);
                 return rc;
         }
 
-        cFYI(1, "readpage %p at offset %d 0x%x",
+        cFYI(1, "readpage %p at offset %d 0x%x\n",
                  page, (int)offset, (int)offset);
 
         rc = cifs_readpage_worker(file, page, &offset);
 
         unlock_page(page);
 
-        free_xid(xid);
+        FreeXid(xid);
         return rc;
 }
 
@@ -3578,16 +2392,8 @@ void cifs_oplock_break(struct work_struct *work)
                                                   oplock_break);
         struct inode *inode = cfile->dentry->d_inode;
         struct cifsInodeInfo *cinode = CIFS_I(inode);
-        struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
         int rc = 0;
 
-        if (!cinode->clientCanCacheAll && cinode->clientCanCacheRead &&
-                                                cifs_has_mand_locks(cinode)) {
-                cFYI(1, "Reset oplock to None for inode=%p due to mand locks",
-                     inode);
-                cinode->clientCanCacheRead = false;
-        }
-
         if (inode && S_ISREG(inode->i_mode)) {
                 if (cinode->clientCanCacheRead)
                         break_lease(inode, O_RDONLY);
@@ -3597,15 +2403,11 @@ void cifs_oplock_break(struct work_struct *work)
                 if (cinode->clientCanCacheRead == 0) {
                         rc = filemap_fdatawait(inode->i_mapping);
                         mapping_set_error(inode->i_mapping, rc);
-                        cifs_invalidate_mapping(inode);
+                        invalidate_remote_inode(inode);
                 }
                 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
         }
 
-        rc = cifs_push_locks(cfile);
-        if (rc)
-                cERROR(1, "Push locks rc = %d", rc);
-
         /*
          * releasing stale oplock after recent reconnect of smb session using
          * a now incorrect file handle is not a data integrity issue but do
@@ -3613,8 +2415,9 @@ void cifs_oplock_break(struct work_struct *work)
          * disconnected since oplock already released by the server
          */
         if (!cfile->oplock_break_cancelled) {
-                rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
-                                                             cinode);
+                rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid, 0,
+                                 0, 0, 0, LOCKING_ANDX_OPLOCK_RELEASE, false,
+                                 cinode->clientCanCacheRead ? 1 : 0);
                 cFYI(1, "Oplock release rc = %d", rc);
         }
 }
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index ed6208ff85a..745e5cdca8f 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -124,15 +124,15 @@ cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
 {
         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
+        unsigned long oldtime = cifs_i->time;
 
         cifs_revalidate_cache(inode, fattr);
 
-        spin_lock(&inode->i_lock);
         inode->i_atime = fattr->cf_atime;
         inode->i_mtime = fattr->cf_mtime;
         inode->i_ctime = fattr->cf_ctime;
         inode->i_rdev = fattr->cf_rdev;
-        set_nlink(inode, fattr->cf_nlink);
+        inode->i_nlink = fattr->cf_nlink;
         inode->i_uid = fattr->cf_uid;
         inode->i_gid = fattr->cf_gid;
 
@@ -148,6 +148,9 @@ cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
         else
                 cifs_i->time = jiffies;
 
+        cFYI(1, "inode 0x%p old_time=%ld new_time=%ld", inode,
+                 oldtime, cifs_i->time);
+
         cifs_i->delete_pending = fattr->cf_flags & CIFS_FATTR_DELETE_PENDING;
 
         cifs_i->server_eof = fattr->cf_eof;
@@ -155,6 +158,7 @@ cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
          * Can't safely change the file size here if the client is writing to
          * it due to potential races.
          */
+        spin_lock(&inode->i_lock);
         if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
                 i_size_write(inode, fattr->cf_eof);
 
@@ -282,11 +286,10 @@ cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
         fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
 }
 
-static int
-cifs_get_file_info_unix(struct file *filp)
+int cifs_get_file_info_unix(struct file *filp)
 {
         int rc;
-        unsigned int xid;
+        int xid;
         FILE_UNIX_BASIC_INFO find_data;
         struct cifs_fattr fattr;
         struct inode *inode = filp->f_path.dentry->d_inode;
@@ -294,8 +297,8 @@ cifs_get_file_info_unix(struct file *filp)
         struct cifsFileInfo *cfile = filp->private_data;
         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
 
-        xid = get_xid();
-        rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
+        xid = GetXid();
+        rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->netfid, &find_data);
         if (!rc) {
                 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
         } else if (rc == -EREMOTE) {
@@ -304,13 +307,13 @@ cifs_get_file_info_unix(struct file *filp)
         }
 
         cifs_fattr_to_inode(inode, &fattr);
-        free_xid(xid);
+        FreeXid(xid);
         return rc;
 }
 
 int cifs_get_inode_info_unix(struct inode **pinode,
                              const unsigned char *full_path,
-                             struct super_block *sb, unsigned int xid)
+                             struct super_block *sb, int xid)
 {
         int rc;
         FILE_UNIX_BASIC_INFO find_data;
@@ -364,7 +367,7 @@ int cifs_get_inode_info_unix(struct inode **pinode,
 
 static int
 cifs_sfu_type(struct cifs_fattr *fattr, const unsigned char *path,
-              struct cifs_sb_info *cifs_sb, unsigned int xid)
+              struct cifs_sb_info *cifs_sb, int xid)
 {
         int rc;
         int oplock = 0;
@@ -463,7 +466,7 @@ cifs_sfu_type(struct cifs_fattr *fattr, const unsigned char *path,
  * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
  */
 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
-                         struct cifs_sb_info *cifs_sb, unsigned int xid)
+                         struct cifs_sb_info *cifs_sb, int xid)
 {
 #ifdef CONFIG_CIFS_XATTR
         ssize_t rc;
@@ -531,11 +534,6 @@ cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
         if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
                 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
                 fattr->cf_dtype = DT_DIR;
-                /*
-                 * Server can return wrong NumberOfLinks value for directories
-                 * when Unix extensions are disabled - fake it.
-                 */
-                fattr->cf_nlink = 2;
         } else {
                 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
                 fattr->cf_dtype = DT_REG;
@@ -543,32 +541,27 @@ cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
                 /* clear write bits if ATTR_READONLY is set */
                 if (fattr->cf_cifsattrs & ATTR_READONLY)
                         fattr->cf_mode &= ~(S_IWUGO);
-
-                fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
         }
 
+        fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
+
         fattr->cf_uid = cifs_sb->mnt_uid;
         fattr->cf_gid = cifs_sb->mnt_gid;
 }
 
-static int
-cifs_get_file_info(struct file *filp)
+int cifs_get_file_info(struct file *filp)
 {
         int rc;
-        unsigned int xid;
+        int xid;
         FILE_ALL_INFO find_data;
         struct cifs_fattr fattr;
         struct inode *inode = filp->f_path.dentry->d_inode;
         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
         struct cifsFileInfo *cfile = filp->private_data;
         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
-        struct TCP_Server_Info *server = tcon->ses->server;
 
-        if (!server->ops->query_file_info)
-                return -ENOSYS;
-
-        xid = get_xid();
-        rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
+        xid = GetXid();
+        rc = CIFSSMBQFileInfo(xid, tcon, cfile->netfid, &find_data);
         switch (rc) {
         case 0:
                 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false);
@@ -598,96 +591,71 @@ cifs_get_file_info(struct file *filp)
         fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
         cifs_fattr_to_inode(inode, &fattr);
 cgfi_exit:
-        free_xid(xid);
+        FreeXid(xid);
         return rc;
 }
 
-int
-cifs_get_inode_info(struct inode **inode, const char *full_path,
-                    FILE_ALL_INFO *data, struct super_block *sb, int xid,
-                    const __u16 *fid)
+int cifs_get_inode_info(struct inode **pinode,
+        const unsigned char *full_path, FILE_ALL_INFO *pfindData,
+        struct super_block *sb, int xid, const __u16 *pfid)
 {
-        bool validinum = false;
-        __u16 srchflgs;
-        int rc = 0, tmprc = ENOSYS;
-        struct cifs_tcon *tcon;
-        struct TCP_Server_Info *server;
+        int rc = 0, tmprc;
+        struct cifs_tcon *pTcon;
         struct tcon_link *tlink;
         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
         char *buf = NULL;
-        bool adjust_tz = false;
+        bool adjustTZ = false;
         struct cifs_fattr fattr;
-        struct cifs_search_info *srchinf = NULL;
 
         tlink = cifs_sb_tlink(cifs_sb);
         if (IS_ERR(tlink))
                 return PTR_ERR(tlink);
-        tcon = tlink_tcon(tlink);
-        server = tcon->ses->server;
+        pTcon = tlink_tcon(tlink);
 
         cFYI(1, "Getting info on %s", full_path);
 
-        if ((data == NULL) && (*inode != NULL)) {
-                if (CIFS_I(*inode)->clientCanCacheRead) {
+        if ((pfindData == NULL) && (*pinode != NULL)) {
+                if (CIFS_I(*pinode)->clientCanCacheRead) {
                         cFYI(1, "No need to revalidate cached inode sizes");
                         goto cgii_exit;
                 }
         }
 
-        /* if inode info is not passed, get it from server */
-        if (data == NULL) {
-                if (!server->ops->query_path_info) {
-                        rc = -ENOSYS;
-                        goto cgii_exit;
-                }
+        /* if file info not passed in then get it from server */
+        if (pfindData == NULL) {
                 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
                 if (buf == NULL) {
                         rc = -ENOMEM;
                         goto cgii_exit;
                 }
-                data = (FILE_ALL_INFO *)buf;
-                rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
-                                                  data, &adjust_tz);
+                pfindData = (FILE_ALL_INFO *)buf;
+
+                /* could do find first instead but this returns more info */
+                rc = CIFSSMBQPathInfo(xid, pTcon, full_path, pfindData,
+                              0 /* not legacy */,
+                              cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
+                                CIFS_MOUNT_MAP_SPECIAL_CHR);
+                /* BB optimize code so we do not make the above call
+                when server claims no NT SMB support and the above call
+                failed at least once - set flag in tcon or mount */
+                if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
+                        rc = SMBQueryInformation(xid, pTcon, full_path,
+                                        pfindData, cifs_sb->local_nls,
+                                        cifs_sb->mnt_cifs_flags &
+                                          CIFS_MOUNT_MAP_SPECIAL_CHR);
+                        adjustTZ = true;
+                }
         }
 
         if (!rc) {
-                cifs_all_info_to_fattr(&fattr, (FILE_ALL_INFO *)data, cifs_sb,
-                                       adjust_tz);
+                cifs_all_info_to_fattr(&fattr, (FILE_ALL_INFO *) pfindData,
+                                       cifs_sb, adjustTZ);
         } else if (rc == -EREMOTE) {
                 cifs_create_dfs_fattr(&fattr, sb);
                 rc = 0;
-        } else if (rc == -EACCES && backup_cred(cifs_sb)) {
-                        srchinf = kzalloc(sizeof(struct cifs_search_info),
-                                                GFP_KERNEL);
-                        if (srchinf == NULL) {
-                                rc = -ENOMEM;
-                                goto cgii_exit;
-                        }
-
-                        srchinf->endOfSearch = false;
-                        srchinf->info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
-
-                        srchflgs = CIFS_SEARCH_CLOSE_ALWAYS |
-                                        CIFS_SEARCH_CLOSE_AT_END |
-                                        CIFS_SEARCH_BACKUP_SEARCH;
-
-                        rc = CIFSFindFirst(xid, tcon, full_path,
-                                cifs_sb, NULL, srchflgs, srchinf, false);
-                        if (!rc) {
-                                data =
-                                (FILE_ALL_INFO *)srchinf->srch_entries_start;
-
-                                cifs_dir_info_to_fattr(&fattr,
-                                (FILE_DIRECTORY_INFO *)data, cifs_sb);
-                                fattr.cf_uniqueid = le64_to_cpu(
-                                ((SEARCH_ID_FULL_DIR_INFO *)data)->UniqueId);
-                                validinum = true;
-
-                                cifs_buf_release(srchinf->ntwrk_buf_start);
-                        }
-                        kfree(srchinf);
-        } else
+        } else {
                 goto cgii_exit;
+        }
 
         /*
          * If an inode wasn't passed in, then get the inode number
@@ -695,24 +663,37 @@ cifs_get_inode_info(struct inode **inode, const char *full_path,
          * Is an i_ino of zero legal? Can we use that to check if the server
          * supports returning inode numbers?  Are there other sanity checks we
          * can use to ensure that the server is really filling in that field?
+         *
+         * We can not use the IndexNumber field by default from Windows or
+         * Samba (in ALL_INFO buf) but we can request it explicitly. The SNIA
+         * CIFS spec claims that this value is unique within the scope of a
+         * share, and the windows docs hint that it's actually unique
+         * per-machine.
+         *
+         * There may be higher info levels that work but are there Windows
+         * server or network appliances for which IndexNumber field is not
+         * guaranteed unique?
          */
-        if (*inode == NULL) {
+        if (*pinode == NULL) {
                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
-                        if (validinum == false) {
-                                if (server->ops->get_srv_inum)
-                                        tmprc = server->ops->get_srv_inum(xid,
-                                                tcon, cifs_sb, full_path,
-                                                &fattr.cf_uniqueid, data);
-                                if (tmprc) {
-                                        cFYI(1, "GetSrvInodeNum rc %d", tmprc);
-                                        fattr.cf_uniqueid = iunique(sb, ROOT_I);
-                                        cifs_autodisable_serverino(cifs_sb);
-                                }
+                        int rc1 = 0;
+
+                        rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
+                                        full_path, &fattr.cf_uniqueid,
+                                        cifs_sb->local_nls,
+                                        cifs_sb->mnt_cifs_flags &
+                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
+                        if (rc1 || !fattr.cf_uniqueid) {
+                                cFYI(1, "GetSrvInodeNum rc %d", rc1);
+                                fattr.cf_uniqueid = iunique(sb, ROOT_I);
+                                cifs_autodisable_serverino(cifs_sb);
                         }
-                } else
+                } else {
                         fattr.cf_uniqueid = iunique(sb, ROOT_I);
-        } else
-                fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
+                }
+        } else {
+                fattr.cf_uniqueid = CIFS_I(*pinode)->uniqueid;
+        }
 
         /* query for SFU type info if supported and needed */
         if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
@@ -725,7 +706,8 @@ cifs_get_inode_info(struct inode **inode, const char *full_path,
 #ifdef CONFIG_CIFS_ACL
         /* fill in 0777 bits from ACL */
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
-                rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid);
+                rc = cifs_acl_to_fattr(cifs_sb, &fattr, *pinode, full_path,
+                                                pfid);
                 if (rc) {
                         cFYI(1, "%s: Getting ACL failed with error: %d",
                                 __func__, rc);
@@ -745,12 +727,12 @@ cifs_get_inode_info(struct inode **inode, const char *full_path,
                         cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
         }
 
-        if (!*inode) {
-                *inode = cifs_iget(sb, &fattr);
-                if (!*inode)
+        if (!*pinode) {
+                *pinode = cifs_iget(sb, &fattr);
+                if (!*pinode)
                         rc = -ENOMEM;
         } else {
-                cifs_fattr_to_inode(*inode, &fattr);
+                cifs_fattr_to_inode(*pinode, &fattr);
         }
 
 cgii_exit:
@@ -763,6 +745,38 @@ static const struct inode_operations cifs_ipc_inode_ops = {
         .lookup = cifs_lookup,
 };
 
+char *cifs_build_path_to_root(struct smb_vol *vol, struct cifs_sb_info *cifs_sb,
+                              struct cifs_tcon *tcon)
+{
+        int pplen = vol->prepath ? strlen(vol->prepath) : 0;
+        int dfsplen;
+        char *full_path = NULL;
+
+        /* if no prefix path, simply set path to the root of share to "" */
+        if (pplen == 0) {
+                full_path = kmalloc(1, GFP_KERNEL);
+                if (full_path)
+                        full_path[0] = 0;
+                return full_path;
+        }
+
+        if (tcon->Flags & SMB_SHARE_IS_IN_DFS)
+                dfsplen = strnlen(tcon->treeName, MAX_TREE_SIZE + 1);
+        else
+                dfsplen = 0;
+
+        full_path = kmalloc(dfsplen + pplen + 1, GFP_KERNEL);
+        if (full_path == NULL)
+                return full_path;
+
+        if (dfsplen)
+                strncpy(full_path, tcon->treeName, dfsplen);
+        strncpy(full_path + dfsplen, vol->prepath, pplen);
+        convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
+        full_path[dfsplen + pplen] = 0; /* add trailing null */
+        return full_path;
+}
+
 static int
 cifs_find_inode(struct inode *inode, void *opaque)
 {
@@ -781,7 +795,7 @@ cifs_find_inode(struct inode *inode, void *opaque)
                 return 0;
 
         /* if it's not a directory or has no dentries, then flag it */
-        if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
+        if (S_ISDIR(inode->i_mode) && !list_empty(&inode->i_dentry))
                 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
 
         return 1;
@@ -806,10 +820,9 @@ static bool
 inode_has_hashed_dentries(struct inode *inode)
 {
         struct dentry *dentry;
-        struct hlist_node *p;
 
         spin_lock(&inode->i_lock);
-        hlist_for_each_entry(dentry, p, &inode->i_dentry, d_alias) {
+        list_for_each_entry(dentry, &inode->i_dentry, d_alias) {
                 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
                         spin_unlock(&inode->i_lock);
                         return true;
@@ -867,13 +880,13 @@ retry_iget5_locked:
 /* gets root inode */
 struct inode *cifs_root_iget(struct super_block *sb)
 {
-        unsigned int xid;
+        int xid;
         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
         struct inode *inode = NULL;
         long rc;
         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 
-        xid = get_xid();
+        xid = GetXid();
         if (tcon->unix_ext)
                 rc = cifs_get_inode_info_unix(&inode, "", sb, xid);
         else
@@ -891,43 +904,44 @@ struct inode *cifs_root_iget(struct super_block *sb)
 
         if (rc && tcon->ipc) {
                 cFYI(1, "ipc connection - fake read inode");
-                spin_lock(&inode->i_lock);
                 inode->i_mode |= S_IFDIR;
-                set_nlink(inode, 2);
+                inode->i_nlink = 2;
                 inode->i_op = &cifs_ipc_inode_ops;
                 inode->i_fop = &simple_dir_operations;
                 inode->i_uid = cifs_sb->mnt_uid;
                 inode->i_gid = cifs_sb->mnt_gid;
-                spin_unlock(&inode->i_lock);
         } else if (rc) {
                 iget_failed(inode);
                 inode = ERR_PTR(rc);
         }
 
 out:
-        /* can not call macro free_xid here since in a void func
+        /* can not call macro FreeXid here since in a void func
          * TODO: This is no longer true
          */
-        _free_xid(xid);
+        _FreeXid(xid);
         return inode;
 }
 
-int
-cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
-                   char *full_path, __u32 dosattr)
+static int
+cifs_set_file_info(struct inode *inode, struct iattr *attrs, int xid,
+                    char *full_path, __u32 dosattr)
 {
+        int rc;
+        int oplock = 0;
+        __u16 netfid;
+        __u32 netpid;
         bool set_time = false;
+        struct cifsFileInfo *open_file;
+        struct cifsInodeInfo *cifsInode = CIFS_I(inode);
         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
-        struct TCP_Server_Info *server;
+        struct tcon_link *tlink = NULL;
+        struct cifs_tcon *pTcon;
         FILE_BASIC_INFO info_buf;
 
         if (attrs == NULL)
                 return -EINVAL;
 
-        server = cifs_sb_master_tcon(cifs_sb)->ses->server;
-        if (!server->ops->set_file_info)
-                return -ENOSYS;
-
         if (attrs->ia_valid & ATTR_ATIME) {
                 set_time = true;
                 info_buf.LastAccessTime =
@@ -958,17 +972,80 @@ cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
         info_buf.CreationTime = 0;      /* don't change */
         info_buf.Attributes = cpu_to_le32(dosattr);
 
-        return server->ops->set_file_info(inode, full_path, &info_buf, xid);
+        /*
+         * If the file is already open for write, just use that fileid
+         */
+        open_file = find_writable_file(cifsInode, true);
+        if (open_file) {
+                netfid = open_file->netfid;
+                netpid = open_file->pid;
+                pTcon = tlink_tcon(open_file->tlink);
+                goto set_via_filehandle;
+        }
+
+        tlink = cifs_sb_tlink(cifs_sb);
+        if (IS_ERR(tlink)) {
+                rc = PTR_ERR(tlink);
+                tlink = NULL;
+                goto out;
+        }
+        pTcon = tlink_tcon(tlink);
+
+        /*
+         * NT4 apparently returns success on this call, but it doesn't
+         * really work.
+         */
+        if (!(pTcon->ses->flags & CIFS_SES_NT4)) {
+                rc = CIFSSMBSetPathInfo(xid, pTcon, full_path,
+                                     &info_buf, cifs_sb->local_nls,
+                                     cifs_sb->mnt_cifs_flags &
+                                        CIFS_MOUNT_MAP_SPECIAL_CHR);
+                if (rc == 0) {
+                        cifsInode->cifsAttrs = dosattr;
+                        goto out;
+                } else if (rc != -EOPNOTSUPP && rc != -EINVAL)
+                        goto out;
+        }
+
+        cFYI(1, "calling SetFileInfo since SetPathInfo for "
+                 "times not supported by this server");
+        rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
+                         SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
+                         CREATE_NOT_DIR, &netfid, &oplock,
+                         NULL, cifs_sb->local_nls,
+                         cifs_sb->mnt_cifs_flags &
+                                CIFS_MOUNT_MAP_SPECIAL_CHR);
+
+        if (rc != 0) {
+                if (rc == -EIO)
+                        rc = -EINVAL;
+                goto out;
+        }
+
+        netpid = current->tgid;
+
+set_via_filehandle:
+        rc = CIFSSMBSetFileInfo(xid, pTcon, &info_buf, netfid, netpid);
+        if (!rc)
+                cifsInode->cifsAttrs = dosattr;
+
+        if (open_file == NULL)
+                CIFSSMBClose(xid, pTcon, netfid);
+        else
+                cifsFileInfo_put(open_file);
+out:
+        if (tlink != NULL)
+                cifs_put_tlink(tlink);
+        return rc;
 }
 
 /*
- * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
+ * open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
  * and rename it to a random name that hopefully won't conflict with
  * anything else.
  */
-int
-cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
-                           const unsigned int xid)
+static int
+cifs_rename_pending_delete(char *full_path, struct dentry *dentry, int xid)
 {
         int oplock = 0;
         int rc;
@@ -1077,15 +1154,6 @@ undo_setattr:
         goto out_close;
 }
 
-/* copied from fs/nfs/dir.c with small changes */
-static void
-cifs_drop_nlink(struct inode *inode)
-{
-        spin_lock(&inode->i_lock);
-        if (inode->i_nlink > 0)
-                drop_nlink(inode);
-        spin_unlock(&inode->i_lock);
-}
 
 /*
  * If dentry->d_inode is null (usually meaning the cached dentry
@@ -1097,7 +1165,7 @@ cifs_drop_nlink(struct inode *inode)
 int cifs_unlink(struct inode *dir, struct dentry *dentry)
 {
         int rc = 0;
-        unsigned int xid;
+        int xid;
         char *full_path = NULL;
         struct inode *inode = dentry->d_inode;
         struct cifsInodeInfo *cifs_inode;
@@ -1105,7 +1173,6 @@ int cifs_unlink(struct inode *dir, struct dentry *dentry)
         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
         struct tcon_link *tlink;
         struct cifs_tcon *tcon;
-        struct TCP_Server_Info *server;
         struct iattr *attrs = NULL;
         __u32 dosattr = 0, origattr = 0;
 
@@ -1115,9 +1182,8 @@ int cifs_unlink(struct inode *dir, struct dentry *dentry)
         if (IS_ERR(tlink))
                 return PTR_ERR(tlink);
         tcon = tlink_tcon(tlink);
-        server = tcon->ses->server;
 
-        xid = get_xid();
+        xid = GetXid();
 
         /* Unlink can be called from rename so we can not take the
          * sb->s_vfs_rename_mutex here */
@@ -1127,8 +1193,9 @@ int cifs_unlink(struct inode *dir, struct dentry *dentry)
                 goto unlink_out;
         }
 
-        if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
-                                le64_to_cpu(tcon->fsUnixInfo.Capability))) {
+        if ((tcon->ses->capabilities & CAP_UNIX) &&
+                (CIFS_UNIX_POSIX_PATH_OPS_CAP &
+                        le64_to_cpu(tcon->fsUnixInfo.Capability))) {
                 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
                         SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
@@ -1138,28 +1205,19 @@ int cifs_unlink(struct inode *dir, struct dentry *dentry)
         }
 
 retry_std_delete:
-        if (!server->ops->unlink) {
-                rc = -ENOSYS;
-                goto psx_del_no_retry;
-        }
-
-        rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
+        rc = CIFSSMBDelFile(xid, tcon, full_path, cifs_sb->local_nls,
+                        cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
 
 psx_del_no_retry:
         if (!rc) {
                 if (inode)
-                        cifs_drop_nlink(inode);
+                        drop_nlink(inode);
         } else if (rc == -ENOENT) {
                 d_drop(dentry);
         } else if (rc == -ETXTBSY) {
-                if (server->ops->rename_pending_delete) {
-                        rc = server->ops->rename_pending_delete(full_path,
-                                                                dentry, xid);
-                        if (rc == 0)
-                                cifs_drop_nlink(inode);
-                }
-                if (rc == -ETXTBSY)
-                        rc = -EBUSY;
+                rc = cifs_rename_pending_delete(full_path, dentry, xid);
+                if (rc == 0)
+                        drop_nlink(inode);
         } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
                 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
                 if (attrs == NULL) {
@@ -1201,166 +1259,31 @@ out_reval:
 unlink_out:
         kfree(full_path);
         kfree(attrs);
-        free_xid(xid);
+        FreeXid(xid);
         cifs_put_tlink(tlink);
         return rc;
 }
 
-static int
-cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
-                 const char *full_path, struct cifs_sb_info *cifs_sb,
-                 struct cifs_tcon *tcon, const unsigned int xid)
+int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
 {
-        int rc = 0;
-        struct inode *inode = NULL;
-
-        if (tcon->unix_ext)
-                rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
-                                              xid);
-        else
-                rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
-                                         xid, NULL);
-
-        if (rc)
-                return rc;
-
-        /*
-         * setting nlink not necessary except in cases where we failed to get it
-         * from the server or was set bogus. Also, since this is a brand new
-         * inode, no need to grab the i_lock before setting the i_nlink.
-         */
-        if (inode->i_nlink < 2)
-                set_nlink(inode, 2);
-        mode &= ~current_umask();
-        /* must turn on setgid bit if parent dir has it */
-        if (parent->i_mode & S_ISGID)
-                mode |= S_ISGID;
-
-        if (tcon->unix_ext) {
-                struct cifs_unix_set_info_args args = {
-                        .mode   = mode,
-                        .ctime  = NO_CHANGE_64,
-                        .atime  = NO_CHANGE_64,
-                        .mtime  = NO_CHANGE_64,
-                        .device = 0,
-                };
-                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
-                        args.uid = (__u64)current_fsuid();
-                        if (parent->i_mode & S_ISGID)
-                                args.gid = (__u64)parent->i_gid;
-                        else
-                                args.gid = (__u64)current_fsgid();
-                } else {
-                        args.uid = NO_CHANGE_64;
-                        args.gid = NO_CHANGE_64;
-                }
-                CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
-                                       cifs_sb->local_nls,
-                                       cifs_sb->mnt_cifs_flags &
-                                       CIFS_MOUNT_MAP_SPECIAL_CHR);
-        } else {
-                struct TCP_Server_Info *server = tcon->ses->server;
-                if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
-                    (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
-                        server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
-                                                   tcon, xid);
-                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
-                        inode->i_mode = (mode | S_IFDIR);
-
-                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
-                        inode->i_uid = current_fsuid();
-                        if (inode->i_mode & S_ISGID)
-                                inode->i_gid = parent->i_gid;
-                        else
-                                inode->i_gid = current_fsgid();
-                }
-        }
-        d_instantiate(dentry, inode);
-        return rc;
-}
-
-static int
-cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
-                 const char *full_path, struct cifs_sb_info *cifs_sb,
-                 struct cifs_tcon *tcon, const unsigned int xid)
-{
-        int rc = 0;
-        u32 oplock = 0;
-        FILE_UNIX_BASIC_INFO *info = NULL;
-        struct inode *newinode = NULL;
-        struct cifs_fattr fattr;
-
-        info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
-        if (info == NULL) {
-                rc = -ENOMEM;
-                goto posix_mkdir_out;
-        }
-
-        mode &= ~current_umask();
-        rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
-                             NULL /* netfid */, info, &oplock, full_path,
-                             cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
-                             CIFS_MOUNT_MAP_SPECIAL_CHR);
-        if (rc == -EOPNOTSUPP)
-                goto posix_mkdir_out;
-        else if (rc) {
-                cFYI(1, "posix mkdir returned 0x%x", rc);
-                d_drop(dentry);
-                goto posix_mkdir_out;
-        }
-
-        if (info->Type == cpu_to_le32(-1))
-                /* no return info, go query for it */
-                goto posix_mkdir_get_info;
-        /*
-         * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
-         * need to set uid/gid.
-         */
-
-        cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
-        cifs_fill_uniqueid(inode->i_sb, &fattr);
-        newinode = cifs_iget(inode->i_sb, &fattr);
-        if (!newinode)
-                goto posix_mkdir_get_info;
-
-        d_instantiate(dentry, newinode);
-
-#ifdef CONFIG_CIFS_DEBUG2
-        cFYI(1, "instantiated dentry %p %s to inode %p", dentry,
-             dentry->d_name.name, newinode);
-
-        if (newinode->i_nlink != 2)
-                cFYI(1, "unexpected number of links %d", newinode->i_nlink);
-#endif
-
-posix_mkdir_out:
-        kfree(info);
-        return rc;
-posix_mkdir_get_info:
-        rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
-                              xid);
-        goto posix_mkdir_out;
-}
-
-int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
-{
-        int rc = 0;
-        unsigned int xid;
+        int rc = 0, tmprc;
+        int xid;
         struct cifs_sb_info *cifs_sb;
         struct tcon_link *tlink;
-        struct cifs_tcon *tcon;
-        struct TCP_Server_Info *server;
-        char *full_path;
+        struct cifs_tcon *pTcon;
+        char *full_path = NULL;
+        struct inode *newinode = NULL;
+        struct cifs_fattr fattr;
 
-        cFYI(1, "In cifs_mkdir, mode = 0x%hx inode = 0x%p", mode, inode);
+        cFYI(1, "In cifs_mkdir, mode = 0x%x inode = 0x%p", mode, inode);
 
         cifs_sb = CIFS_SB(inode->i_sb);
         tlink = cifs_sb_tlink(cifs_sb);
         if (IS_ERR(tlink))
                 return PTR_ERR(tlink);
-        tcon = tlink_tcon(tlink);
+        pTcon = tlink_tcon(tlink);
 
-        xid = get_xid();
+        xid = GetXid();
 
         full_path = build_path_from_dentry(direntry);
         if (full_path == NULL) {
@@ -1368,39 +1291,153 @@ int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
                 goto mkdir_out;
         }
 
-        if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
-                                le64_to_cpu(tcon->fsUnixInfo.Capability))) {
-                rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
-                                      tcon, xid);
-                if (rc != -EOPNOTSUPP)
+        if ((pTcon->ses->capabilities & CAP_UNIX) &&
+                (CIFS_UNIX_POSIX_PATH_OPS_CAP &
+                        le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
+                u32 oplock = 0;
+                FILE_UNIX_BASIC_INFO *pInfo =
+                        kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
+                if (pInfo == NULL) {
+                        rc = -ENOMEM;
                         goto mkdir_out;
-        }
+                }
+
+                mode &= ~current_umask();
+                rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
+                                mode, NULL /* netfid */, pInfo, &oplock,
+                                full_path, cifs_sb->local_nls,
+                                cifs_sb->mnt_cifs_flags &
+                                        CIFS_MOUNT_MAP_SPECIAL_CHR);
+                if (rc == -EOPNOTSUPP) {
+                        kfree(pInfo);
+                        goto mkdir_retry_old;
+                } else if (rc) {
+                        cFYI(1, "posix mkdir returned 0x%x", rc);
+                        d_drop(direntry);
+                } else {
+                        if (pInfo->Type == cpu_to_le32(-1)) {
+                                /* no return info, go query for it */
+                                kfree(pInfo);
+                                goto mkdir_get_info;
+                        }
+/*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
+        to set uid/gid */
+                        inc_nlink(inode);
+
+                        cifs_unix_basic_to_fattr(&fattr, pInfo, cifs_sb);
+                        cifs_fill_uniqueid(inode->i_sb, &fattr);
+                        newinode = cifs_iget(inode->i_sb, &fattr);
+                        if (!newinode) {
+                                kfree(pInfo);
+                                goto mkdir_get_info;
+                        }
+
+                        d_instantiate(direntry, newinode);
 
-        server = tcon->ses->server;
+#ifdef CONFIG_CIFS_DEBUG2
+                        cFYI(1, "instantiated dentry %p %s to inode %p",
+                                direntry, direntry->d_name.name, newinode);
 
-        if (!server->ops->mkdir) {
-                rc = -ENOSYS;
+                        if (newinode->i_nlink != 2)
+                                cFYI(1, "unexpected number of links %d",
+                                        newinode->i_nlink);
+#endif
+                }
+                kfree(pInfo);
                 goto mkdir_out;
         }
-
+mkdir_retry_old:
         /* BB add setting the equivalent of mode via CreateX w/ACLs */
-        rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
+        rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
+                          cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
         if (rc) {
                 cFYI(1, "cifs_mkdir returned 0x%x", rc);
                 d_drop(direntry);
-                goto mkdir_out;
+        } else {
+mkdir_get_info:
+                inc_nlink(inode);
+                if (pTcon->unix_ext)
+                        rc = cifs_get_inode_info_unix(&newinode, full_path,
+                                                      inode->i_sb, xid);
+                else
+                        rc = cifs_get_inode_info(&newinode, full_path, NULL,
+                                                 inode->i_sb, xid, NULL);
+
+                d_instantiate(direntry, newinode);
+                 /* setting nlink not necessary except in cases where we
+                  * failed to get it from the server or was set bogus */
+                if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
+                                direntry->d_inode->i_nlink = 2;
+
+                mode &= ~current_umask();
+                /* must turn on setgid bit if parent dir has it */
+                if (inode->i_mode & S_ISGID)
+                        mode |= S_ISGID;
+
+                if (pTcon->unix_ext) {
+                        struct cifs_unix_set_info_args args = {
+                                .mode   = mode,
+                                .ctime  = NO_CHANGE_64,
+                                .atime  = NO_CHANGE_64,
+                                .mtime  = NO_CHANGE_64,
+                                .device = 0,
+                        };
+                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
+                                args.uid = (__u64)current_fsuid();
+                                if (inode->i_mode & S_ISGID)
+                                        args.gid = (__u64)inode->i_gid;
+                                else
+                                        args.gid = (__u64)current_fsgid();
+                        } else {
+                                args.uid = NO_CHANGE_64;
+                                args.gid = NO_CHANGE_64;
+                        }
+                        CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
+                                               cifs_sb->local_nls,
+                                               cifs_sb->mnt_cifs_flags &
+                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
+                } else {
+                        if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
+                            (mode & S_IWUGO) == 0) {
+                                FILE_BASIC_INFO pInfo;
+                                struct cifsInodeInfo *cifsInode;
+                                u32 dosattrs;
+
+                                memset(&pInfo, 0, sizeof(pInfo));
+                                cifsInode = CIFS_I(newinode);
+                                dosattrs = cifsInode->cifsAttrs|ATTR_READONLY;
+                                pInfo.Attributes = cpu_to_le32(dosattrs);
+                                tmprc = CIFSSMBSetPathInfo(xid, pTcon,
+                                                full_path, &pInfo,
+                                                cifs_sb->local_nls,
+                                                cifs_sb->mnt_cifs_flags &
+                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
+                                if (tmprc == 0)
+                                        cifsInode->cifsAttrs = dosattrs;
+                        }
+                        if (direntry->d_inode) {
+                                if (cifs_sb->mnt_cifs_flags &
+                                     CIFS_MOUNT_DYNPERM)
+                                        direntry->d_inode->i_mode =
+                                                (mode | S_IFDIR);
+
+                                if (cifs_sb->mnt_cifs_flags &
+                                     CIFS_MOUNT_SET_UID) {
+                                        direntry->d_inode->i_uid =
+                                                current_fsuid();
+                                        if (inode->i_mode & S_ISGID)
+                                                direntry->d_inode->i_gid =
+                                                        inode->i_gid;
+                                        else
+                                                direntry->d_inode->i_gid =
+                                                        current_fsgid();
+                                }
+                        }
+                }
         }
-
-        rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
-                              xid);
 mkdir_out:
-        /*
-         * Force revalidate to get parent dir info when needed since cached
-         * attributes are invalid now.
-         */
-        CIFS_I(inode)->time = 0;
         kfree(full_path);
-        free_xid(xid);
+        FreeXid(xid);
         cifs_put_tlink(tlink);
         return rc;
 }
@@ -1408,17 +1445,16 @@ mkdir_out:
 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
 {
         int rc = 0;
-        unsigned int xid;
+        int xid;
         struct cifs_sb_info *cifs_sb;
         struct tcon_link *tlink;
-        struct cifs_tcon *tcon;
-        struct TCP_Server_Info *server;
+        struct cifs_tcon *pTcon;
         char *full_path = NULL;
         struct cifsInodeInfo *cifsInode;
 
         cFYI(1, "cifs_rmdir, inode = 0x%p", inode);
 
-        xid = get_xid();
+        xid = GetXid();
 
         full_path = build_path_from_dentry(direntry);
         if (full_path == NULL) {
@@ -1432,19 +1468,14 @@ int cifs_rmdir(struct inode *inode, struct dentry *direntry)
                 rc = PTR_ERR(tlink);
                 goto rmdir_exit;
         }
-        tcon = tlink_tcon(tlink);
-        server = tcon->ses->server;
-
-        if (!server->ops->rmdir) {
-                rc = -ENOSYS;
-                cifs_put_tlink(tlink);
-                goto rmdir_exit;
-        }
+        pTcon = tlink_tcon(tlink);
 
-        rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
+        rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
+                          cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
         cifs_put_tlink(tlink);
 
         if (!rc) {
+                drop_nlink(inode);
                 spin_lock(&direntry->d_inode->i_lock);
                 i_size_write(direntry->d_inode, 0);
                 clear_nlink(direntry->d_inode);
@@ -1452,52 +1483,45 @@ int cifs_rmdir(struct inode *inode, struct dentry *direntry)
         }
 
         cifsInode = CIFS_I(direntry->d_inode);
-        /* force revalidate to go get info when needed */
-        cifsInode->time = 0;
+        cifsInode->time = 0;    /* force revalidate to go get info when
+                                   needed */
 
         cifsInode = CIFS_I(inode);
-        /*
-         * Force revalidate to get parent dir info when needed since cached
-         * attributes are invalid now.
-         */
-        cifsInode->time = 0;
+        cifsInode->time = 0;    /* force revalidate to get parent dir info
+                                   since cached search results now invalid */
 
         direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
                 current_fs_time(inode->i_sb);
 
 rmdir_exit:
         kfree(full_path);
-        free_xid(xid);
+        FreeXid(xid);
         return rc;
 }
 
 static int
-cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
-               const char *from_path, struct dentry *to_dentry,
-               const char *to_path)
+cifs_do_rename(int xid, struct dentry *from_dentry, const char *fromPath,
+                struct dentry *to_dentry, const char *toPath)
 {
         struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
         struct tcon_link *tlink;
-        struct cifs_tcon *tcon;
-        struct TCP_Server_Info *server;
+        struct cifs_tcon *pTcon;
         __u16 srcfid;
         int oplock, rc;
 
         tlink = cifs_sb_tlink(cifs_sb);
         if (IS_ERR(tlink))
                 return PTR_ERR(tlink);
-        tcon = tlink_tcon(tlink);
-        server = tcon->ses->server;
-
-        if (!server->ops->rename)
-                return -ENOSYS;
+        pTcon = tlink_tcon(tlink);
 
         /* try path-based rename first */
-        rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
+        rc = CIFSSMBRename(xid, pTcon, fromPath, toPath, cifs_sb->local_nls,
+                           cifs_sb->mnt_cifs_flags &
+                                CIFS_MOUNT_MAP_SPECIAL_CHR);
 
         /*
-         * Don't bother with rename by filehandle unless file is busy and
-         * source. Note that cross directory moves do not work with
+         * don't bother with rename by filehandle unless file is busy and
+         * source Note that cross directory moves do not work with
          * rename by filehandle to various Windows servers.
          */
         if (rc == 0 || rc != -ETXTBSY)
@@ -1508,35 +1532,35 @@ cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
                 goto do_rename_exit;
 
         /* open the file to be renamed -- we need DELETE perms */
-        rc = CIFSSMBOpen(xid, tcon, from_path, FILE_OPEN, DELETE,
+        rc = CIFSSMBOpen(xid, pTcon, fromPath, FILE_OPEN, DELETE,
                          CREATE_NOT_DIR, &srcfid, &oplock, NULL,
                          cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
+
         if (rc == 0) {
-                rc = CIFSSMBRenameOpenFile(xid, tcon, srcfid,
+                rc = CIFSSMBRenameOpenFile(xid, pTcon, srcfid,
                                 (const char *) to_dentry->d_name.name,
                                 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
-                CIFSSMBClose(xid, tcon, srcfid);
+
+                CIFSSMBClose(xid, pTcon, srcfid);
         }
 do_rename_exit:
         cifs_put_tlink(tlink);
         return rc;
 }
 
-int
-cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
-            struct inode *target_dir, struct dentry *target_dentry)
+int cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
+        struct inode *target_dir, struct dentry *target_dentry)
 {
-        char *from_name = NULL;
-        char *to_name = NULL;
+        char *fromName = NULL;
+        char *toName = NULL;
         struct cifs_sb_info *cifs_sb;
         struct tcon_link *tlink;
         struct cifs_tcon *tcon;
         FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
         FILE_UNIX_BASIC_INFO *info_buf_target;
-        unsigned int xid;
-        int rc, tmprc;
+        int xid, rc, tmprc;
 
         cifs_sb = CIFS_SB(source_dir->i_sb);
         tlink = cifs_sb_tlink(cifs_sb);
@@ -1544,31 +1568,31 @@ cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
                 return PTR_ERR(tlink);
         tcon = tlink_tcon(tlink);
 
-        xid = get_xid();
+        xid = GetXid();
 
         /*
          * we already have the rename sem so we do not need to
          * grab it again here to protect the path integrity
          */
-        from_name = build_path_from_dentry(source_dentry);
-        if (from_name == NULL) {
+        fromName = build_path_from_dentry(source_dentry);
+        if (fromName == NULL) {
                 rc = -ENOMEM;
                 goto cifs_rename_exit;
         }
 
-        to_name = build_path_from_dentry(target_dentry);
-        if (to_name == NULL) {
+        toName = build_path_from_dentry(target_dentry);
+        if (toName == NULL) {
                 rc = -ENOMEM;
                 goto cifs_rename_exit;
         }
 
-        rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
-                            to_name);
+        rc = cifs_do_rename(xid, source_dentry, fromName,
+                            target_dentry, toName);
 
         if (rc == -EEXIST && tcon->unix_ext) {
                 /*
-                 * Are src and dst hardlinks of same inode? We can only tell
-                 * with unix extensions enabled.
+                 * Are src and dst hardlinks of same inode? We can
+                 * only tell with unix extensions enabled
                  */
                 info_buf_source =
                         kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
@@ -1579,19 +1603,19 @@ cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
                 }
 
                 info_buf_target = info_buf_source + 1;
-                tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
-                                             info_buf_source,
-                                             cifs_sb->local_nls,
-                                             cifs_sb->mnt_cifs_flags &
-                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
+                tmprc = CIFSSMBUnixQPathInfo(xid, tcon, fromName,
+                                        info_buf_source,
+                                        cifs_sb->local_nls,
+                                        cifs_sb->mnt_cifs_flags &
+                                        CIFS_MOUNT_MAP_SPECIAL_CHR);
                 if (tmprc != 0)
                         goto unlink_target;
 
-                tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
-                                             info_buf_target,
-                                             cifs_sb->local_nls,
-                                             cifs_sb->mnt_cifs_flags &
-                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
+                tmprc = CIFSSMBUnixQPathInfo(xid, tcon, toName,
+                                        info_buf_target,
+                                        cifs_sb->local_nls,
+                                        cifs_sb->mnt_cifs_flags &
+                                        CIFS_MOUNT_MAP_SPECIAL_CHR);
 
                 if (tmprc == 0 && (info_buf_source->UniqueId ==
                                    info_buf_target->UniqueId)) {
@@ -1599,11 +1623,8 @@ cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
                         rc = 0;
                         goto cifs_rename_exit;
                 }
-        }
-        /*
-         * else ... BB we could add the same check for Windows by
-         * checking the UniqueId via FILE_INTERNAL_INFO
-         */
+        } /* else ... BB we could add the same check for Windows by
+                     checking the UniqueId via FILE_INTERNAL_INFO */
 
 unlink_target:
         /* Try unlinking the target dentry if it's not negative */
@@ -1611,15 +1632,16 @@ unlink_target:
                 tmprc = cifs_unlink(target_dir, target_dentry);
                 if (tmprc)
                         goto cifs_rename_exit;
-                rc = cifs_do_rename(xid, source_dentry, from_name,
-                                    target_dentry, to_name);
+
+                rc = cifs_do_rename(xid, source_dentry, fromName,
+                                    target_dentry, toName);
         }
 
 cifs_rename_exit:
         kfree(info_buf_source);
-        kfree(from_name);
-        kfree(to_name);
-        free_xid(xid);
+        kfree(fromName);
+        kfree(toName);
+        FreeXid(xid);
         cifs_put_tlink(tlink);
         return rc;
 }
@@ -1694,7 +1716,7 @@ int cifs_revalidate_file_attr(struct file *filp)
 
 int cifs_revalidate_dentry_attr(struct dentry *dentry)
 {
-        unsigned int xid;
+        int xid;
         int rc = 0;
         struct inode *inode = dentry->d_inode;
         struct super_block *sb = dentry->d_sb;
@@ -1706,7 +1728,7 @@ int cifs_revalidate_dentry_attr(struct dentry *dentry)
         if (!cifs_inode_needs_reval(inode))
                 return rc;
 
-        xid = get_xid();
+        xid = GetXid();
 
         /* can not safely grab the rename sem here if rename calls revalidate
            since that would deadlock */
@@ -1728,7 +1750,7 @@ int cifs_revalidate_dentry_attr(struct dentry *dentry)
 
 out:
         kfree(full_path);
-        free_xid(xid);
+        FreeXid(xid);
         return rc;
 }
 
@@ -1791,12 +1813,11 @@ int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
         stat->ino = CIFS_I(inode)->uniqueid;
 
         /*
-         * If on a multiuser mount without unix extensions or cifsacl being
-         * enabled, and the admin hasn't overridden them, set the ownership
-         * to the fsuid/fsgid of the current process.
+         * If on a multiuser mount without unix extensions, and the admin hasn't
+         * overridden them, set the ownership to the fsuid/fsgid of the current
+         * process.
          */
         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
-            !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
             !tcon->unix_ext) {
                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
                         stat->uid = current_fsuid();
@@ -1837,15 +1858,14 @@ static void cifs_setsize(struct inode *inode, loff_t offset)
 
 static int
 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
-                   unsigned int xid, char *full_path)
+                   int xid, char *full_path)
 {
         int rc;
         struct cifsFileInfo *open_file;
         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
         struct tcon_link *tlink = NULL;
-        struct cifs_tcon *tcon = NULL;
-        struct TCP_Server_Info *server;
+        struct cifs_tcon *pTcon = NULL;
         struct cifs_io_parms io_parms;
 
         /*
@@ -1859,21 +1879,19 @@ cifs_set_file_size(struct inode *inode, struct iattr *attrs,
          */
         open_file = find_writable_file(cifsInode, true);
         if (open_file) {
-                tcon = tlink_tcon(open_file->tlink);
-                server = tcon->ses->server;
-                if (server->ops->set_file_size)
-                        rc = server->ops->set_file_size(xid, tcon, open_file,
-                                                        attrs->ia_size, false);
-                else
-                        rc = -ENOSYS;
+                __u16 nfid = open_file->netfid;
+                __u32 npid = open_file->pid;
+                pTcon = tlink_tcon(open_file->tlink);
+                rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size, nfid,
+                                        npid, false);
                 cifsFileInfo_put(open_file);
                 cFYI(1, "SetFSize for attrs rc = %d", rc);
                 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
                         unsigned int bytes_written;
 
-                        io_parms.netfid = open_file->fid.netfid;
-                        io_parms.pid = open_file->pid;
-                        io_parms.tcon = tcon;
+                        io_parms.netfid = nfid;
+                        io_parms.pid = npid;
+                        io_parms.tcon = pTcon;
                         io_parms.offset = 0;
                         io_parms.length = attrs->ia_size;
                         rc = CIFSSMBWrite(xid, &io_parms, &bytes_written,
@@ -1883,55 +1901,52 @@ cifs_set_file_size(struct inode *inode, struct iattr *attrs,
         } else
                 rc = -EINVAL;
 
-        if (!rc)
-                goto set_size_out;
-
-        if (tcon == NULL) {
-                tlink = cifs_sb_tlink(cifs_sb);
-                if (IS_ERR(tlink))
-                        return PTR_ERR(tlink);
-                tcon = tlink_tcon(tlink);
-                server = tcon->ses->server;
-        }
+        if (rc != 0) {
+                if (pTcon == NULL) {
+                        tlink = cifs_sb_tlink(cifs_sb);
+                        if (IS_ERR(tlink))
+                                return PTR_ERR(tlink);
+                        pTcon = tlink_tcon(tlink);
+                }
 
-        /*
-         * Set file size by pathname rather than by handle either because no
-         * valid, writeable file handle for it was found or because there was
-         * an error setting it by handle.
-         */
-        if (server->ops->set_path_size)
-                rc = server->ops->set_path_size(xid, tcon, full_path,
-                                                attrs->ia_size, cifs_sb, false);
-        else
-                rc = -ENOSYS;
-        cFYI(1, "SetEOF by path (setattrs) rc = %d", rc);
-        if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
-                __u16 netfid;
-                int oplock = 0;
-
-                rc = SMBLegacyOpen(xid, tcon, full_path, FILE_OPEN,
-                                   GENERIC_WRITE, CREATE_NOT_DIR, &netfid,
-                                   &oplock, NULL, cifs_sb->local_nls,
+                /* Set file size by pathname rather than by handle
+                   either because no valid, writeable file handle for
+                   it was found or because there was an error setting
+                   it by handle */
+                rc = CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size,
+                                   false, cifs_sb->local_nls,
                                    cifs_sb->mnt_cifs_flags &
-                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
-                if (rc == 0) {
-                        unsigned int bytes_written;
-
-                        io_parms.netfid = netfid;
-                        io_parms.pid = current->tgid;
-                        io_parms.tcon = tcon;
-                        io_parms.offset = 0;
-                        io_parms.length = attrs->ia_size;
-                        rc = CIFSSMBWrite(xid, &io_parms, &bytes_written, NULL,
-                                          NULL,  1);
-                        cFYI(1, "wrt seteof rc %d", rc);
-                        CIFSSMBClose(xid, tcon, netfid);
+                                        CIFS_MOUNT_MAP_SPECIAL_CHR);
+                cFYI(1, "SetEOF by path (setattrs) rc = %d", rc);
+                if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
+                        __u16 netfid;
+                        int oplock = 0;
+
+                        rc = SMBLegacyOpen(xid, pTcon, full_path,
+                                FILE_OPEN, GENERIC_WRITE,
+                                CREATE_NOT_DIR, &netfid, &oplock, NULL,
+                                cifs_sb->local_nls,
+                                cifs_sb->mnt_cifs_flags &
+                                        CIFS_MOUNT_MAP_SPECIAL_CHR);
+                        if (rc == 0) {
+                                unsigned int bytes_written;
+
+                                io_parms.netfid = netfid;
+                                io_parms.pid = current->tgid;
+                                io_parms.tcon = pTcon;
+                                io_parms.offset = 0;
+                                io_parms.length = attrs->ia_size;
+                                rc = CIFSSMBWrite(xid, &io_parms,
+                                                  &bytes_written,
+                                                  NULL, NULL,  1);
+                                cFYI(1, "wrt seteof rc %d", rc);
+                                CIFSSMBClose(xid, pTcon, netfid);
+                        }
                 }
+                if (tlink)
+                        cifs_put_tlink(tlink);
         }
-        if (tlink)
-                cifs_put_tlink(tlink);
 
-set_size_out:
         if (rc == 0) {
                 cifsInode->server_eof = attrs->ia_size;
                 cifs_setsize(inode, attrs->ia_size);
@@ -1945,7 +1960,7 @@ static int
 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
 {
         int rc;
-        unsigned int xid;
+        int xid;
         char *full_path = NULL;
         struct inode *inode = direntry->d_inode;
         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
@@ -1958,7 +1973,7 @@ cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
         cFYI(1, "setattr_unix on file %s attrs->ia_valid=0x%x",
                  direntry->d_name.name, attrs->ia_valid);
 
-        xid = get_xid();
+        xid = GetXid();
 
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
                 attrs->ia_valid |= ATTR_FORCE;
@@ -2038,7 +2053,7 @@ cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
         args->device = 0;
         open_file = find_writable_file(cifsInode, true);
         if (open_file) {
-                u16 nfid = open_file->fid.netfid;
+                u16 nfid = open_file->netfid;
                 u32 npid = open_file->pid;
                 pTcon = tlink_tcon(open_file->tlink);
                 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
@@ -2078,16 +2093,14 @@ cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
 out:
         kfree(args);
         kfree(full_path);
-        free_xid(xid);
+        FreeXid(xid);
         return rc;
 }
 
 static int
 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
 {
-        unsigned int xid;
-        uid_t uid = NO_CHANGE_32;
-        gid_t gid = NO_CHANGE_32;
+        int xid;
         struct inode *inode = direntry->d_inode;
         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
@@ -2096,7 +2109,7 @@ cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
         __u32 dosattr = 0;
         __u64 mode = NO_CHANGE_64;
 
-        xid = get_xid();
+        xid = GetXid();
 
         cFYI(1, "setattr on file %s attrs->iavalid 0x%x",
                  direntry->d_name.name, attrs->ia_valid);
@@ -2106,14 +2119,14 @@ cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
 
         rc = inode_change_ok(inode, attrs);
         if (rc < 0) {
-                free_xid(xid);
+                FreeXid(xid);
                 return rc;
         }
 
         full_path = build_path_from_dentry(direntry);
         if (full_path == NULL) {
                 rc = -ENOMEM;
-                free_xid(xid);
+                FreeXid(xid);
                 return rc;
         }
 
@@ -2138,25 +2151,13 @@ cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
                         goto cifs_setattr_exit;
         }
 
-        if (attrs->ia_valid & ATTR_UID)
-                uid = attrs->ia_uid;
-
-        if (attrs->ia_valid & ATTR_GID)
-                gid = attrs->ia_gid;
-
-#ifdef CONFIG_CIFS_ACL
-        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
-                if (uid != NO_CHANGE_32 || gid != NO_CHANGE_32) {
-                        rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
-                                                        uid, gid);
-                        if (rc) {
-                                cFYI(1, "%s: Setting id failed with error: %d",
-                                        __func__, rc);
-                                goto cifs_setattr_exit;
-                        }
-                }
-        } else
-#endif /* CONFIG_CIFS_ACL */
+        /*
+         * Without unix extensions we can't send ownership changes to the
+         * server, so silently ignore them. This is consistent with how
+         * local DOS/Windows filesystems behave (VFAT, NTFS, etc). With
+         * CIFSACL support + proper Windows to Unix idmapping, we may be
+         * able to support this in the future.
+         */
         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
                 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
 
@@ -2165,12 +2166,15 @@ cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
                 attrs->ia_valid &= ~ATTR_MODE;
 
         if (attrs->ia_valid & ATTR_MODE) {
+                cFYI(1, "Mode changed to 0%o", attrs->ia_mode);
                 mode = attrs->ia_mode;
+        }
+
+        if (attrs->ia_valid & ATTR_MODE) {
                 rc = 0;
 #ifdef CONFIG_CIFS_ACL
                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
-                        rc = id_mode_to_cifs_acl(inode, full_path, mode,
-                                                NO_CHANGE_32, NO_CHANGE_32);
+                        rc = mode_to_cifs_acl(inode, full_path, mode);
                         if (rc) {
                                 cFYI(1, "%s: Setting ACL failed with error: %d",
                                         __func__, rc);
@@ -2239,7 +2243,7 @@ cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
 
 cifs_setattr_exit:
         kfree(full_path);
-        free_xid(xid);
+        FreeXid(xid);
         return rc;
 }
 
diff --git a/fs/cifs/ioctl.c b/fs/cifs/ioctl.c
index fd5009d56f9..4221b5e48a4 100644
--- a/fs/cifs/ioctl.c
+++ b/fs/cifs/ioctl.c
@@ -28,11 +28,13 @@
 #include "cifs_debug.h"
 #include "cifsfs.h"
 
+#define CIFS_IOC_CHECKUMOUNT _IO(0xCF, 2)
+
 long cifs_ioctl(struct file *filep, unsigned int command, unsigned long arg)
 {
         struct inode *inode = filep->f_dentry->d_inode;
         int rc = -ENOTTY; /* strange error - but the precedent */
-        unsigned int xid;
+        int xid;
         struct cifs_sb_info *cifs_sb;
 #ifdef CONFIG_CIFS_POSIX
         struct cifsFileInfo *pSMBFile = filep->private_data;
@@ -42,13 +44,22 @@ long cifs_ioctl(struct file *filep, unsigned int command, unsigned long arg)
         __u64   caps;
 #endif /* CONFIG_CIFS_POSIX */
 
-        xid = get_xid();
+        xid = GetXid();
 
         cFYI(1, "ioctl file %p  cmd %u  arg %lu", filep, command, arg);
 
         cifs_sb = CIFS_SB(inode->i_sb);
 
         switch (command) {
+                case CIFS_IOC_CHECKUMOUNT:
+                        cFYI(1, "User unmount attempted");
+                        if (cifs_sb->mnt_uid == current_uid())
+                                rc = 0;
+                        else {
+                                rc = -EACCES;
+                                cFYI(1, "uids do not match");
+                        }
+                        break;
 #ifdef CONFIG_CIFS_POSIX
                 case FS_IOC_GETFLAGS:
                         if (pSMBFile == NULL)
@@ -56,9 +67,8 @@ long cifs_ioctl(struct file *filep, unsigned int command, unsigned long arg)
                         tcon = tlink_tcon(pSMBFile->tlink);
                         caps = le64_to_cpu(tcon->fsUnixInfo.Capability);
                         if (CIFS_UNIX_EXTATTR_CAP & caps) {
-                                rc = CIFSGetExtAttr(xid, tcon,
-                                                    pSMBFile->fid.netfid,
-                                                    &ExtAttrBits, &ExtAttrMask);
+                                rc = CIFSGetExtAttr(xid, tcon, pSMBFile->netfid,
+                                        &ExtAttrBits, &ExtAttrMask);
                                 if (rc == 0)
                                         rc = put_user(ExtAttrBits &
                                                 FS_FL_USER_VISIBLE,
@@ -76,12 +86,8 @@ long cifs_ioctl(struct file *filep, unsigned int command, unsigned long arg)
                                         rc = -EFAULT;
                                         break;
                                 }
-                                /*
-                                 * rc = CIFSGetExtAttr(xid, tcon,
-                                 *                     pSMBFile->fid.netfid,
-                                 *                     extAttrBits,
-                                 *                     &ExtAttrMask);
-                                 */
+                                /* rc= CIFSGetExtAttr(xid,tcon,pSMBFile->netfid,
+                                        extAttrBits, &ExtAttrMask);*/
                         }
                         cFYI(1, "set flags not implemented yet");
                         break;
@@ -91,6 +97,6 @@ long cifs_ioctl(struct file *filep, unsigned int command, unsigned long arg)
                         break;
         }
 
-        free_xid(xid);
+        FreeXid(xid);
         return rc;
 }
diff --git a/fs/cifs/link.c b/fs/cifs/link.c
index 51dc2fb6e85..db3f18cdf02 100644
--- a/fs/cifs/link.c
+++ b/fs/cifs/link.c
@@ -56,14 +56,14 @@ symlink_hash(unsigned int link_len, const char *link_str, u8 *md5_hash)
         md5 = crypto_alloc_shash("md5", 0, 0);
         if (IS_ERR(md5)) {
                 rc = PTR_ERR(md5);
-                cERROR(1, "%s: Crypto md5 allocation error %d", __func__, rc);
+                cERROR(1, "%s: Crypto md5 allocation error %d\n", __func__, rc);
                 return rc;
         }
         size = sizeof(struct shash_desc) + crypto_shash_descsize(md5);
         sdescmd5 = kmalloc(size, GFP_KERNEL);
         if (!sdescmd5) {
                 rc = -ENOMEM;
-                cERROR(1, "%s: Memory allocation failure", __func__);
+                cERROR(1, "%s: Memory allocation failure\n", __func__);
                 goto symlink_hash_err;
         }
         sdescmd5->shash.tfm = md5;
@@ -71,17 +71,17 @@ symlink_hash(unsigned int link_len, const char *link_str, u8 *md5_hash)
 
         rc = crypto_shash_init(&sdescmd5->shash);
         if (rc) {
-                cERROR(1, "%s: Could not init md5 shash", __func__);
+                cERROR(1, "%s: Could not init md5 shash\n", __func__);
                 goto symlink_hash_err;
         }
         rc = crypto_shash_update(&sdescmd5->shash, link_str, link_len);
         if (rc) {
-                cERROR(1, "%s: Could not update iwth link_str", __func__);
+                cERROR(1, "%s: Could not update iwth link_str\n", __func__);
                 goto symlink_hash_err;
         }
         rc = crypto_shash_final(&sdescmd5->shash, md5_hash);
         if (rc)
-                cERROR(1, "%s: Could not generate md5 hash", __func__);
+                cERROR(1, "%s: Could not generate md5 hash\n", __func__);
 
 symlink_hash_err:
         crypto_free_shash(md5);
@@ -115,7 +115,7 @@ CIFSParseMFSymlink(const u8 *buf,
 
         rc = symlink_hash(link_len, link_str, md5_hash);
         if (rc) {
-                cFYI(1, "%s: MD5 hash failure: %d", __func__, rc);
+                cFYI(1, "%s: MD5 hash failure: %d\n", __func__, rc);
                 return rc;
         }
 
@@ -154,7 +154,7 @@ CIFSFormatMFSymlink(u8 *buf, unsigned int buf_len, const char *link_str)
 
         rc = symlink_hash(link_len, link_str, md5_hash);
         if (rc) {
-                cFYI(1, "%s: MD5 hash failure: %d", __func__, rc);
+                cFYI(1, "%s: MD5 hash failure: %d\n", __func__, rc);
                 return rc;
         }
 
@@ -181,22 +181,16 @@ CIFSFormatMFSymlink(u8 *buf, unsigned int buf_len, const char *link_str)
 }
 
 static int
-CIFSCreateMFSymLink(const unsigned int xid, struct cifs_tcon *tcon,
+CIFSCreateMFSymLink(const int xid, struct cifs_tcon *tcon,
                     const char *fromName, const char *toName,
-                    struct cifs_sb_info *cifs_sb)
+                    const struct nls_table *nls_codepage, int remap)
 {
         int rc;
         int oplock = 0;
-        int remap;
-        int create_options = CREATE_NOT_DIR;
         __u16 netfid = 0;
         u8 *buf;
         unsigned int bytes_written = 0;
         struct cifs_io_parms io_parms;
-        struct nls_table *nls_codepage;
-
-        nls_codepage = cifs_sb->local_nls;
-        remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
 
         buf = kmalloc(CIFS_MF_SYMLINK_FILE_SIZE, GFP_KERNEL);
         if (!buf)
@@ -208,11 +202,8 @@ CIFSCreateMFSymLink(const unsigned int xid, struct cifs_tcon *tcon,
                 return rc;
         }
 
-        if (backup_cred(cifs_sb))
-                create_options |= CREATE_OPEN_BACKUP_INTENT;
-
         rc = CIFSSMBOpen(xid, tcon, fromName, FILE_CREATE, GENERIC_WRITE,
-                         create_options, &netfid, &oplock, NULL,
+                         CREATE_NOT_DIR, &netfid, &oplock, NULL,
                          nls_codepage, remap);
         if (rc != 0) {
                 kfree(buf);
@@ -238,7 +229,7 @@ CIFSCreateMFSymLink(const unsigned int xid, struct cifs_tcon *tcon,
 }
 
 static int
-CIFSQueryMFSymLink(const unsigned int xid, struct cifs_tcon *tcon,
+CIFSQueryMFSymLink(const int xid, struct cifs_tcon *tcon,
                    const unsigned char *searchName, char **symlinkinfo,
                    const struct nls_table *nls_codepage, int remap)
 {
@@ -307,7 +298,7 @@ CIFSCouldBeMFSymlink(const struct cifs_fattr *fattr)
 int
 CIFSCheckMFSymlink(struct cifs_fattr *fattr,
                    const unsigned char *path,
-                   struct cifs_sb_info *cifs_sb, unsigned int xid)
+                   struct cifs_sb_info *cifs_sb, int xid)
 {
         int rc;
         int oplock = 0;
@@ -390,88 +381,72 @@ cifs_hardlink(struct dentry *old_file, struct inode *inode,
               struct dentry *direntry)
 {
         int rc = -EACCES;
-        unsigned int xid;
-        char *from_name = NULL;
-        char *to_name = NULL;
+        int xid;
+        char *fromName = NULL;
+        char *toName = NULL;
         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
         struct tcon_link *tlink;
-        struct cifs_tcon *tcon;
-        struct TCP_Server_Info *server;
+        struct cifs_tcon *pTcon;
         struct cifsInodeInfo *cifsInode;
 
         tlink = cifs_sb_tlink(cifs_sb);
         if (IS_ERR(tlink))
                 return PTR_ERR(tlink);
-        tcon = tlink_tcon(tlink);
+        pTcon = tlink_tcon(tlink);
 
-        xid = get_xid();
+        xid = GetXid();
 
-        from_name = build_path_from_dentry(old_file);
-        to_name = build_path_from_dentry(direntry);
-        if ((from_name == NULL) || (to_name == NULL)) {
+        fromName = build_path_from_dentry(old_file);
+        toName = build_path_from_dentry(direntry);
+        if ((fromName == NULL) || (toName == NULL)) {
                 rc = -ENOMEM;
                 goto cifs_hl_exit;
         }
 
-        if (tcon->unix_ext)
-                rc = CIFSUnixCreateHardLink(xid, tcon, from_name, to_name,
+        if (pTcon->unix_ext)
+                rc = CIFSUnixCreateHardLink(xid, pTcon, fromName, toName,
                                             cifs_sb->local_nls,
                                             cifs_sb->mnt_cifs_flags &
                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
         else {
-                server = tcon->ses->server;
-                if (!server->ops->create_hardlink)
-                        return -ENOSYS;
-                rc = server->ops->create_hardlink(xid, tcon, from_name, to_name,
-                                                  cifs_sb);
+                rc = CIFSCreateHardLink(xid, pTcon, fromName, toName,
+                                        cifs_sb->local_nls,
+                                        cifs_sb->mnt_cifs_flags &
+                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
                 if ((rc == -EIO) || (rc == -EINVAL))
                         rc = -EOPNOTSUPP;
         }
 
         d_drop(direntry);       /* force new lookup from server of target */
 
-        /*
-         * if source file is cached (oplocked) revalidate will not go to server
-         * until the file is closed or oplock broken so update nlinks locally
-         */
+        /* if source file is cached (oplocked) revalidate will not go to server
+           until the file is closed or oplock broken so update nlinks locally */
         if (old_file->d_inode) {
                 cifsInode = CIFS_I(old_file->d_inode);
                 if (rc == 0) {
-                        spin_lock(&old_file->d_inode->i_lock);
-                        inc_nlink(old_file->d_inode);
-                        spin_unlock(&old_file->d_inode->i_lock);
-                        /*
-                         * BB should we make this contingent on superblock flag
-                         * NOATIME?
-                         */
-                        /* old_file->d_inode->i_ctime = CURRENT_TIME; */
-                        /*
-                         * parent dir timestamps will update from srv within a
-                         * second, would it really be worth it to set the parent
-                         * dir cifs inode time to zero to force revalidate
-                         * (faster) for it too?
-                         */
+                        old_file->d_inode->i_nlink++;
+/* BB should we make this contingent on superblock flag NOATIME? */
+/*                      old_file->d_inode->i_ctime = CURRENT_TIME;*/
+                        /* parent dir timestamps will update from srv
+                        within a second, would it really be worth it
+                        to set the parent dir cifs inode time to zero
+                        to force revalidate (faster) for it too? */
                 }
-                /*
-                 * if not oplocked will force revalidate to get info on source
-                 * file from srv
-                 */
+                /* if not oplocked will force revalidate to get info
+                   on source file from srv */
                 cifsInode->time = 0;
 
-                /*
-                 * Will update parent dir timestamps from srv within a second.
-                 * Would it really be worth it to set the parent dir (cifs
-                 * inode) time field to zero to force revalidate on parent
-                 * directory faster ie
-                 *
-                 * CIFS_I(inode)->time = 0;
-                 */
+                /* Will update parent dir timestamps from srv within a second.
+                   Would it really be worth it to set the parent dir (cifs
+                   inode) time field to zero to force revalidate on parent
+                   directory faster ie
+                        CIFS_I(inode)->time = 0;  */
         }
 
 cifs_hl_exit:
-        kfree(from_name);
-        kfree(to_name);
-        free_xid(xid);
+        kfree(fromName);
+        kfree(toName);
+        FreeXid(xid);
         cifs_put_tlink(tlink);
         return rc;
 }
@@ -481,14 +456,14 @@ cifs_follow_link(struct dentry *direntry, struct nameidata *nd)
 {
         struct inode *inode = direntry->d_inode;
         int rc = -ENOMEM;
-        unsigned int xid;
+        int xid;
         char *full_path = NULL;
         char *target_path = NULL;
         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
         struct tcon_link *tlink = NULL;
         struct cifs_tcon *tcon;
 
-        xid = get_xid();
+        xid = GetXid();
 
         tlink = cifs_sb_tlink(cifs_sb);
         if (IS_ERR(tlink)) {
@@ -511,8 +486,8 @@ cifs_follow_link(struct dentry *direntry, struct nameidata *nd)
          * but there doesn't seem to be any harm in allowing the client to
          * read them.
          */
-        if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) &&
-            !cap_unix(tcon->ses)) {
+        if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
+            && !(tcon->ses->capabilities & CAP_UNIX)) {
                 rc = -EACCES;
                 goto out;
         }
@@ -534,7 +509,7 @@ cifs_follow_link(struct dentry *direntry, struct nameidata *nd)
                                         cifs_sb->mnt_cifs_flags &
                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 
-        if ((rc != 0) && cap_unix(tcon->ses))
+        if ((rc != 0) && (tcon->ses->capabilities & CAP_UNIX))
                 rc = CIFSSMBUnixQuerySymLink(xid, tcon, full_path, &target_path,
                                              cifs_sb->local_nls);
 
@@ -545,7 +520,7 @@ out:
                 target_path = ERR_PTR(rc);
         }
 
-        free_xid(xid);
+        FreeXid(xid);
         if (tlink)
                 cifs_put_tlink(tlink);
         nd_set_link(nd, target_path);
@@ -556,14 +531,14 @@ int
 cifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname)
 {
         int rc = -EOPNOTSUPP;
-        unsigned int xid;
+        int xid;
         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
         struct tcon_link *tlink;
         struct cifs_tcon *pTcon;
         char *full_path = NULL;
         struct inode *newinode = NULL;
 
-        xid = get_xid();
+        xid = GetXid();
 
         tlink = cifs_sb_tlink(cifs_sb);
         if (IS_ERR(tlink)) {
@@ -584,7 +559,9 @@ cifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname)
         /* BB what if DFS and this volume is on different share? BB */
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
                 rc = CIFSCreateMFSymLink(xid, pTcon, full_path, symname,
-                                        cifs_sb);
+                                         cifs_sb->local_nls,
+                                         cifs_sb->mnt_cifs_flags &
+                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
         else if (pTcon->unix_ext)
                 rc = CIFSUnixCreateSymLink(xid, pTcon, full_path, symname,
                                            cifs_sb->local_nls);
@@ -610,7 +587,7 @@ cifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname)
 symlink_exit:
         kfree(full_path);
         cifs_put_tlink(tlink);
-        free_xid(xid);
+        FreeXid(xid);
         return rc;
 }
 
diff --git a/fs/cifs/misc.c b/fs/cifs/misc.c
index 3a00c0d0cea..7c169339259 100644
--- a/fs/cifs/misc.c
+++ b/fs/cifs/misc.c
@@ -29,9 +29,6 @@
 #include "smberr.h"
 #include "nterr.h"
 #include "cifs_unicode.h"
-#ifdef CONFIG_CIFS_SMB2
-#include "smb2pdu.h"
-#endif
 
 extern mempool_t *cifs_sm_req_poolp;
 extern mempool_t *cifs_req_poolp;
@@ -43,7 +40,7 @@ extern mempool_t *cifs_req_poolp;
    since the cifs fs was mounted */
 
 unsigned int
-_get_xid(void)
+_GetXid(void)
 {
         unsigned int xid;
 
@@ -61,7 +58,7 @@ _get_xid(void)
 }
 
 void
-_free_xid(unsigned int xid)
+_FreeXid(unsigned int xid)
 {
         spin_lock(&GlobalMid_Lock);
         /* if (GlobalTotalActiveXid == 0)
@@ -146,27 +143,17 @@ struct smb_hdr *
 cifs_buf_get(void)
 {
         struct smb_hdr *ret_buf = NULL;
-        size_t buf_size = sizeof(struct smb_hdr);
-
-#ifdef CONFIG_CIFS_SMB2
-        /*
-         * SMB2 header is bigger than CIFS one - no problems to clean some
-         * more bytes for CIFS.
-         */
-        buf_size = sizeof(struct smb2_hdr);
-#endif
-        /*
-         * We could use negotiated size instead of max_msgsize -
-         * but it may be more efficient to always alloc same size
-         * albeit slightly larger than necessary and maxbuffersize
-         * defaults to this and can not be bigger.
-         */
+
+/* We could use negotiated size instead of max_msgsize -
+   but it may be more efficient to always alloc same size
+   albeit slightly larger than necessary and maxbuffersize
+   defaults to this and can not be bigger */
         ret_buf = mempool_alloc(cifs_req_poolp, GFP_NOFS);
 
         /* clear the first few header bytes */
         /* for most paths, more is cleared in header_assemble */
         if (ret_buf) {
-                memset(ret_buf, 0, buf_size + 3);
+                memset(ret_buf, 0, sizeof(struct smb_hdr) + 3);
                 atomic_inc(&bufAllocCount);
 #ifdef CONFIG_CIFS_STATS2
                 atomic_inc(&totBufAllocCount);
@@ -225,6 +212,85 @@ cifs_small_buf_release(void *buf_to_free)
         return;
 }
 
+/*
+        Find a free multiplex id (SMB mid). Otherwise there could be
+        mid collisions which might cause problems, demultiplexing the
+        wrong response to this request. Multiplex ids could collide if
+        one of a series requests takes much longer than the others, or
+        if a very large number of long lived requests (byte range
+        locks or FindNotify requests) are pending.  No more than
+        64K-1 requests can be outstanding at one time.  If no
+        mids are available, return zero.  A future optimization
+        could make the combination of mids and uid the key we use
+        to demultiplex on (rather than mid alone).
+        In addition to the above check, the cifs demultiplex
+        code already used the command code as a secondary
+        check of the frame and if signing is negotiated the
+        response would be discarded if the mid were the same
+        but the signature was wrong.  Since the mid is not put in the
+        pending queue until later (when it is about to be dispatched)
+        we do have to limit the number of outstanding requests
+        to somewhat less than 64K-1 although it is hard to imagine
+        so many threads being in the vfs at one time.
+*/
+__u16 GetNextMid(struct TCP_Server_Info *server)
+{
+        __u16 mid = 0;
+        __u16 last_mid;
+        bool collision;
+
+        spin_lock(&GlobalMid_Lock);
+        last_mid = server->CurrentMid; /* we do not want to loop forever */
+        server->CurrentMid++;
+        /* This nested loop looks more expensive than it is.
+        In practice the list of pending requests is short,
+        fewer than 50, and the mids are likely to be unique
+        on the first pass through the loop unless some request
+        takes longer than the 64 thousand requests before it
+        (and it would also have to have been a request that
+         did not time out) */
+        while (server->CurrentMid != last_mid) {
+                struct mid_q_entry *mid_entry;
+                unsigned int num_mids;
+
+                collision = false;
+                if (server->CurrentMid == 0)
+                        server->CurrentMid++;
+
+                num_mids = 0;
+                list_for_each_entry(mid_entry, &server->pending_mid_q, qhead) {
+                        ++num_mids;
+                        if (mid_entry->mid == server->CurrentMid &&
+                            mid_entry->midState == MID_REQUEST_SUBMITTED) {
+                                /* This mid is in use, try a different one */
+                                collision = true;
+                                break;
+                        }
+                }
+
+                /*
+                 * if we have more than 32k mids in the list, then something
+                 * is very wrong. Possibly a local user is trying to DoS the
+                 * box by issuing long-running calls and SIGKILL'ing them. If
+                 * we get to 2^16 mids then we're in big trouble as this
+                 * function could loop forever.
+                 *
+                 * Go ahead and assign out the mid in this situation, but force
+                 * an eventual reconnect to clean out the pending_mid_q.
+                 */
+                if (num_mids > 32768)
+                        server->tcpStatus = CifsNeedReconnect;
+
+                if (!collision) {
+                        mid = server->CurrentMid;
+                        break;
+                }
+                server->CurrentMid++;
+        }
+        spin_unlock(&GlobalMid_Lock);
+        return mid;
+}
+
 /* NB: MID can not be set if treeCon not passed in, in that
    case it is responsbility of caller to set the mid */
 void
@@ -232,6 +298,8 @@ header_assemble(struct smb_hdr *buffer, char smb_command /* command */ ,
                 const struct cifs_tcon *treeCon, int word_count
                 /* length of fixed section (word count) in two byte units  */)
 {
+        struct list_head *temp_item;
+        struct cifs_ses *ses;
         char *temp = (char *) buffer;
 
         memset(temp, 0, 256); /* bigger than MAX_CIFS_HDR_SIZE */
@@ -260,7 +328,52 @@ header_assemble(struct smb_hdr *buffer, char smb_command /* command */ ,
 
                         /* Uid is not converted */
                         buffer->Uid = treeCon->ses->Suid;
-                        buffer->Mid = get_next_mid(treeCon->ses->server);
+                        buffer->Mid = GetNextMid(treeCon->ses->server);
+                        if (multiuser_mount != 0) {
+                /* For the multiuser case, there are few obvious technically  */
+                /* possible mechanisms to match the local linux user (uid)    */
+                /* to a valid remote smb user (smb_uid):                      */
+                /*      1) Query Winbind (or other local pam/nss daemon       */
+                /*        for userid/password/logon_domain or credential      */
+                /*      2) Query Winbind for uid to sid to username mapping   */
+                /*         and see if we have a matching password for existing*/
+                /*         session for that user perhas getting password by   */
+                /*         adding a new pam_cifs module that stores passwords */
+                /*         so that the cifs vfs can get at that for all logged*/
+                /*         on users                                           */
+                /*      3) (Which is the mechanism we have chosen)            */
+                /*         Search through sessions to the same server for a   */
+                /*         a match on the uid that was passed in on mount     */
+                /*         with the current processes uid (or euid?) and use  */
+                /*         that smb uid.   If no existing smb session for     */
+                /*         that uid found, use the default smb session ie     */
+                /*         the smb session for the volume mounted which is    */
+                /*         the same as would be used if the multiuser mount   */
+                /*         flag were disabled.  */
+
+                /*  BB Add support for establishing new tCon and SMB Session  */
+                /*      with userid/password pairs found on the smb session   */
+                /*      for other target tcp/ip addresses               BB    */
+                                if (current_fsuid() != treeCon->ses->linux_uid) {
+                                        cFYI(1, "Multiuser mode and UID "
+                                                 "did not match tcon uid");
+                                        spin_lock(&cifs_tcp_ses_lock);
+                                        list_for_each(temp_item, &treeCon->ses->server->smb_ses_list) {
+                                                ses = list_entry(temp_item, struct cifs_ses, smb_ses_list);
+                                                if (ses->linux_uid == current_fsuid()) {
+                                                        if (ses->server == treeCon->ses->server) {
+                                                                cFYI(1, "found matching uid substitute right smb_uid");
+                                                                buffer->Uid = ses->Suid;
+                                                                break;
+                                                        } else {
+                                /* BB eventually call cifs_setup_session here */
+                                                                cFYI(1, "local UID found but no smb sess with this server exists");
+                                                        }
+                                                }
+                                        }
+                                        spin_unlock(&cifs_tcp_ses_lock);
+                                }
+                        }
                 }
                 if (treeCon->Flags & SMB_SHARE_IS_IN_DFS)
                         buffer->Flags2 |= SMBFLG2_DFS;
@@ -307,24 +420,19 @@ check_smb_hdr(struct smb_hdr *smb, __u16 mid)
 }
 
 int
-checkSMB(char *buf, unsigned int total_read)
+checkSMB(struct smb_hdr *smb, __u16 mid, unsigned int length)
 {
-        struct smb_hdr *smb = (struct smb_hdr *)buf;
-        __u16 mid = smb->Mid;
-        __u32 rfclen = be32_to_cpu(smb->smb_buf_length);
+        __u32 len = be32_to_cpu(smb->smb_buf_length);
         __u32 clc_len;  /* calculated length */
-        cFYI(0, "checkSMB Length: 0x%x, smb_buf_length: 0x%x",
-                total_read, rfclen);
+        cFYI(0, "checkSMB Length: 0x%x, smb_buf_length: 0x%x", length, len);
 
-        /* is this frame too small to even get to a BCC? */
-        if (total_read < 2 + sizeof(struct smb_hdr)) {
-                if ((total_read >= sizeof(struct smb_hdr) - 1)
+        if (length < 2 + sizeof(struct smb_hdr)) {
+                if ((length >= sizeof(struct smb_hdr) - 1)
                             && (smb->Status.CifsError != 0)) {
-                        /* it's an error return */
                         smb->WordCount = 0;
                         /* some error cases do not return wct and bcc */
                         return 0;
-                } else if ((total_read == sizeof(struct smb_hdr) + 1) &&
+                } else if ((length == sizeof(struct smb_hdr) + 1) &&
                                 (smb->WordCount == 0)) {
                         char *tmp = (char *)smb;
                         /* Need to work around a bug in two servers here */
@@ -344,35 +452,39 @@ checkSMB(char *buf, unsigned int total_read)
                 } else {
                         cERROR(1, "Length less than smb header size");
                 }
-                return -EIO;
+                return 1;
+        }
+        if (len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
+                cERROR(1, "smb length greater than MaxBufSize, mid=%d",
+                                   smb->Mid);
+                return 1;
         }
 
-        /* otherwise, there is enough to get to the BCC */
         if (check_smb_hdr(smb, mid))
-                return -EIO;
+                return 1;
         clc_len = smbCalcSize(smb);
 
-        if (4 + rfclen != total_read) {
+        if (4 + len != length) {
                 cERROR(1, "Length read does not match RFC1001 length %d",
-                                rfclen);
-                return -EIO;
+                           len);
+                return 1;
         }
 
-        if (4 + rfclen != clc_len) {
+        if (4 + len != clc_len) {
                 /* check if bcc wrapped around for large read responses */
-                if ((rfclen > 64 * 1024) && (rfclen > clc_len)) {
+                if ((len > 64 * 1024) && (len > clc_len)) {
                         /* check if lengths match mod 64K */
-                        if (((4 + rfclen) & 0xFFFF) == (clc_len & 0xFFFF))
+                        if (((4 + len) & 0xFFFF) == (clc_len & 0xFFFF))
                                 return 0; /* bcc wrapped */
                 }
                 cFYI(1, "Calculated size %u vs length %u mismatch for mid=%u",
-                                clc_len, 4 + rfclen, smb->Mid);
+                                clc_len, 4 + len, smb->Mid);
 
-                if (4 + rfclen < clc_len) {
+                if (4 + len < clc_len) {
                         cERROR(1, "RFC1001 size %u smaller than SMB for mid=%u",
-                                        rfclen, smb->Mid);
-                        return -EIO;
-                } else if (rfclen > clc_len + 512) {
+                                        len, smb->Mid);
+                        return 1;
+                } else if (len > clc_len + 512) {
                         /*
                          * Some servers (Windows XP in particular) send more
                          * data than the lengths in the SMB packet would
@@ -383,17 +495,16 @@ checkSMB(char *buf, unsigned int total_read)
                          * data to 512 bytes.
                          */
                         cERROR(1, "RFC1001 size %u more than 512 bytes larger "
-                                  "than SMB for mid=%u", rfclen, smb->Mid);
-                        return -EIO;
+                                  "than SMB for mid=%u", len, smb->Mid);
+                        return 1;
                 }
         }
         return 0;
 }
 
 bool
-is_valid_oplock_break(char *buffer, struct TCP_Server_Info *srv)
+is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
 {
-        struct smb_hdr *buf = (struct smb_hdr *)buffer;
         struct smb_com_lock_req *pSMB = (struct smb_com_lock_req *)buf;
         struct list_head *tmp, *tmp1, *tmp2;
         struct cifs_ses *ses;
@@ -461,12 +572,12 @@ is_valid_oplock_break(char *buffer, struct TCP_Server_Info *srv)
                         if (tcon->tid != buf->Tid)
                                 continue;
 
-                        cifs_stats_inc(&tcon->stats.cifs_stats.num_oplock_brks);
+                        cifs_stats_inc(&tcon->num_oplock_brks);
                         spin_lock(&cifs_file_list_lock);
                         list_for_each(tmp2, &tcon->openFileList) {
                                 netfile = list_entry(tmp2, struct cifsFileInfo,
                                                      tlist);
-                                if (pSMB->Fid != netfile->fid.netfid)
+                                if (pSMB->Fid != netfile->netfid)
                                         continue;
 
                                 cFYI(1, "file id match, oplock break");
@@ -474,7 +585,7 @@ is_valid_oplock_break(char *buffer, struct TCP_Server_Info *srv)
 
                                 cifs_set_oplock_level(pCifsInode,
                                         pSMB->OplockLevel ? OPLOCK_READ : 0);
-                                queue_work(cifsiod_wq,
+                                queue_work(system_nrt_wq,
                                            &netfile->oplock_break);
                                 netfile->oplock_break_cancelled = false;
 
@@ -494,15 +605,16 @@ is_valid_oplock_break(char *buffer, struct TCP_Server_Info *srv)
 }
 
 void
-dump_smb(void *buf, int smb_buf_length)
+dump_smb(struct smb_hdr *smb_buf, int smb_buf_length)
 {
         int i, j;
         char debug_line[17];
-        unsigned char *buffer = buf;
+        unsigned char *buffer;
 
         if (traceSMB == 0)
                 return;
 
+        buffer = (unsigned char *) smb_buf;
         for (i = 0, j = 0; i < smb_buf_length; i++, j++) {
                 if (i % 8 == 0) {
                         /* have reached the beginning of line */
@@ -564,48 +676,3 @@ void cifs_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock)
                 cinode->clientCanCacheRead = false;
         }
 }
-
-bool
-backup_cred(struct cifs_sb_info *cifs_sb)
-{
-        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID) {
-                if (cifs_sb->mnt_backupuid == current_fsuid())
-                        return true;
-        }
-        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID) {
-                if (in_group_p(cifs_sb->mnt_backupgid))
-                        return true;
-        }
-
-        return false;
-}
-
-void
-cifs_del_pending_open(struct cifs_pending_open *open)
-{
-        spin_lock(&cifs_file_list_lock);
-        list_del(&open->olist);
-        spin_unlock(&cifs_file_list_lock);
-}
-
-void
-cifs_add_pending_open_locked(struct cifs_fid *fid, struct tcon_link *tlink,
-                             struct cifs_pending_open *open)
-{
-#ifdef CONFIG_CIFS_SMB2
-        memcpy(open->lease_key, fid->lease_key, SMB2_LEASE_KEY_SIZE);
-#endif
-        open->oplock = CIFS_OPLOCK_NO_CHANGE;
-        open->tlink = tlink;
-        fid->pending_open = open;
-        list_add_tail(&open->olist, &tlink_tcon(tlink)->pending_opens);
-}
-
-void
-cifs_add_pending_open(struct cifs_fid *fid, struct tcon_link *tlink,
-                      struct cifs_pending_open *open)
-{
-        spin_lock(&cifs_file_list_lock);
-        cifs_add_pending_open_locked(fid, tlink, open);
-        spin_unlock(&cifs_file_list_lock);
-}
diff --git a/fs/cifs/netmisc.c b/fs/cifs/netmisc.c
index a82bc51fdc8..73e47e84b61 100644
--- a/fs/cifs/netmisc.c
+++ b/fs/cifs/netmisc.c
@@ -110,7 +110,7 @@ static const struct smb_to_posix_error mapping_table_ERRSRV[] = {
         {ERRnoroom, -ENOSPC},
         {ERRrmuns, -EUSERS},
         {ERRtimeout, -ETIME},
-        {ERRnoresource, -EREMOTEIO},
+        {ERRnoresource, -ENOBUFS},
         {ERRtoomanyuids, -EUSERS},
         {ERRbaduid, -EACCES},
         {ERRusempx, -EIO},
@@ -197,14 +197,15 @@ cifs_convert_address(struct sockaddr *dst, const char *src, int len)
                 memcpy(scope_id, pct + 1, slen);
                 scope_id[slen] = '\0';
 
-                rc = kstrtouint(scope_id, 0, &s6->sin6_scope_id);
+                rc = strict_strtoul(scope_id, 0,
+                                        (unsigned long *)&s6->sin6_scope_id);
                 rc = (rc == 0) ? 1 : 0;
         }
 
         return rc;
 }
 
-void
+int
 cifs_set_port(struct sockaddr *addr, const unsigned short int port)
 {
         switch (addr->sa_family) {
@@ -214,7 +215,19 @@ cifs_set_port(struct sockaddr *addr, const unsigned short int port)
         case AF_INET6:
                 ((struct sockaddr_in6 *)addr)->sin6_port = htons(port);
                 break;
+        default:
+                return 0;
         }
+        return 1;
+}
+
+int
+cifs_fill_sockaddr(struct sockaddr *dst, const char *src, int len,
+                   const unsigned short int port)
+{
+        if (!cifs_convert_address(dst, src, len))
+                return 0;
+        return cifs_set_port(dst, port);
 }
 
 /*****************************************************************************
@@ -400,7 +413,7 @@ static const struct {
          from NT_STATUS_INSUFFICIENT_RESOURCES to
          NT_STATUS_INSUFF_SERVER_RESOURCES during the session setup } */
         {
-        ERRDOS, ERRnoresource, NT_STATUS_INSUFFICIENT_RESOURCES}, {
+        ERRDOS, ERRnomem, NT_STATUS_INSUFFICIENT_RESOURCES}, {
         ERRDOS, ERRbadpath, NT_STATUS_DFS_EXIT_PATH_FOUND}, {
         ERRDOS, 23, NT_STATUS_DEVICE_DATA_ERROR}, {
         ERRHRD, ERRgeneral, NT_STATUS_DEVICE_NOT_CONNECTED}, {
@@ -670,7 +683,7 @@ static const struct {
         ERRHRD, ERRgeneral, NT_STATUS_NO_USER_SESSION_KEY}, {
         ERRDOS, 59, NT_STATUS_USER_SESSION_DELETED}, {
         ERRHRD, ERRgeneral, NT_STATUS_RESOURCE_LANG_NOT_FOUND}, {
-        ERRDOS, ERRnoresource, NT_STATUS_INSUFF_SERVER_RESOURCES}, {
+        ERRDOS, ERRnomem, NT_STATUS_INSUFF_SERVER_RESOURCES}, {
         ERRHRD, ERRgeneral, NT_STATUS_INVALID_BUFFER_SIZE}, {
         ERRHRD, ERRgeneral, NT_STATUS_INVALID_ADDRESS_COMPONENT}, {
         ERRHRD, ERRgeneral, NT_STATUS_INVALID_ADDRESS_WILDCARD}, {
@@ -823,9 +836,8 @@ ntstatus_to_dos(__u32 ntstatus, __u8 *eclass, __u16 *ecode)
 }
 
 int
-map_smb_to_linux_error(char *buf, bool logErr)
+map_smb_to_linux_error(struct smb_hdr *smb, bool logErr)
 {
-        struct smb_hdr *smb = (struct smb_hdr *)buf;
         unsigned int i;
         int rc = -EIO;  /* if transport error smb error may not be set */
         __u8 smberrclass;
@@ -901,9 +913,8 @@ map_smb_to_linux_error(char *buf, bool logErr)
  * portion, the number of word parameters and the data portion of the message
  */
 unsigned int
-smbCalcSize(void *buf)
+smbCalcSize(struct smb_hdr *ptr)
 {
-        struct smb_hdr *ptr = (struct smb_hdr *)buf;
         return (sizeof(struct smb_hdr) + (2 * ptr->WordCount) +
                 2 /* size of the bcc field */ + get_bcc(ptr));
 }
diff --git a/fs/cifs/nterr.c b/fs/cifs/nterr.c
index b6023c64612..819fd994b12 100644
--- a/fs/cifs/nterr.c
+++ b/fs/cifs/nterr.c
@@ -31,7 +31,7 @@ const struct nt_err_code_struct nt_errs[] = {
         {"NT_STATUS_INVALID_INFO_CLASS", NT_STATUS_INVALID_INFO_CLASS},
         {"NT_STATUS_INFO_LENGTH_MISMATCH", NT_STATUS_INFO_LENGTH_MISMATCH},
         {"NT_STATUS_ACCESS_VIOLATION", NT_STATUS_ACCESS_VIOLATION},
-        {"NT_STATUS_BUFFER_OVERFLOW", NT_STATUS_BUFFER_OVERFLOW},
+        {"STATUS_BUFFER_OVERFLOW", STATUS_BUFFER_OVERFLOW},
         {"NT_STATUS_IN_PAGE_ERROR", NT_STATUS_IN_PAGE_ERROR},
         {"NT_STATUS_PAGEFILE_QUOTA", NT_STATUS_PAGEFILE_QUOTA},
         {"NT_STATUS_INVALID_HANDLE", NT_STATUS_INVALID_HANDLE},
@@ -681,7 +681,7 @@ const struct nt_err_code_struct nt_errs[] = {
          NT_STATUS_QUOTA_LIST_INCONSISTENT},
         {"NT_STATUS_FILE_IS_OFFLINE", NT_STATUS_FILE_IS_OFFLINE},
         {"NT_STATUS_NO_MORE_ENTRIES", NT_STATUS_NO_MORE_ENTRIES},
-        {"NT_STATUS_MORE_ENTRIES", NT_STATUS_MORE_ENTRIES},
-        {"NT_STATUS_SOME_UNMAPPED", NT_STATUS_SOME_UNMAPPED},
+        {"STATUS_MORE_ENTRIES", STATUS_MORE_ENTRIES},
+        {"STATUS_SOME_UNMAPPED", STATUS_SOME_UNMAPPED},
         {NULL, 0}
 };
diff --git a/fs/cifs/nterr.h b/fs/cifs/nterr.h
index 7a0eae5ae7c..257267367d4 100644
--- a/fs/cifs/nterr.h
+++ b/fs/cifs/nterr.h
@@ -35,20 +35,18 @@ struct nt_err_code_struct {
 extern const struct nt_err_code_struct nt_errs[];
 
 /* Win32 Status codes. */
-#define NT_STATUS_MORE_ENTRIES         0x0105
-#define NT_ERROR_INVALID_PARAMETER     0x0057
-#define NT_ERROR_INSUFFICIENT_BUFFER   0x007a
-#define NT_STATUS_1804                 0x070c
-#define NT_STATUS_NOTIFY_ENUM_DIR      0x010c
+#define STATUS_MORE_ENTRIES               0x0105
+#define ERROR_INVALID_PARAMETER           0x0057
+#define ERROR_INSUFFICIENT_BUFFER         0x007a
+#define STATUS_1804                       0x070c
+#define STATUS_NOTIFY_ENUM_DIR            0x010c
 
-/*
- * Win32 Error codes extracted using a loop in smbclient then printing a netmon
- * sniff to a file.
- */
+/* Win32 Error codes extracted using a loop in smbclient then printing a
+   netmon sniff to a file. */
 
-#define NT_STATUS_OK                   0x0000
-#define NT_STATUS_SOME_UNMAPPED        0x0107
-#define NT_STATUS_BUFFER_OVERFLOW  0x80000005
+#define NT_STATUS_OK 0x0000
+#define STATUS_SOME_UNMAPPED       0x0107
+#define STATUS_BUFFER_OVERFLOW     0x80000005
 #define NT_STATUS_NO_MORE_ENTRIES  0x8000001a
 #define NT_STATUS_MEDIA_CHANGED    0x8000001c
 #define NT_STATUS_END_OF_MEDIA     0x8000001e
diff --git a/fs/cifs/ntlmssp.h b/fs/cifs/ntlmssp.h
index 848249fa120..5d52e4a3b1e 100644
--- a/fs/cifs/ntlmssp.h
+++ b/fs/cifs/ntlmssp.h
@@ -126,13 +126,3 @@ typedef struct _AUTHENTICATE_MESSAGE {
            do not set the version is present flag */
         char UserString[0];
 } __attribute__((packed)) AUTHENTICATE_MESSAGE, *PAUTHENTICATE_MESSAGE;
-
-/*
- * Size of the session key (crypto key encrypted with the password
- */
-
-int decode_ntlmssp_challenge(char *bcc_ptr, int blob_len, struct cifs_ses *ses);
-void build_ntlmssp_negotiate_blob(unsigned char *pbuffer, struct cifs_ses *ses);
-int build_ntlmssp_auth_blob(unsigned char *pbuffer, u16 *buflen,
-                        struct cifs_ses *ses,
-                        const struct nls_table *nls_cp);
diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c
index cdd6ff48246..a090bbe6ee2 100644
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -66,21 +66,18 @@ static inline void dump_cifs_file_struct(struct file *file, char *label)
 #endif /* DEBUG2 */
 
 /*
- * Attempt to preload the dcache with the results from the FIND_FIRST/NEXT
- *
  * Find the dentry that matches "name". If there isn't one, create one. If it's
  * a negative dentry or the uniqueid changed, then drop it and recreate it.
  */
-static void
-cifs_prime_dcache(struct dentry *parent, struct qstr *name,
+static struct dentry *
+cifs_readdir_lookup(struct dentry *parent, struct qstr *name,
                     struct cifs_fattr *fattr)
 {
         struct dentry *dentry, *alias;
         struct inode *inode;
         struct super_block *sb = parent->d_inode->i_sb;
-        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 
-        cFYI(1, "%s: for %s", __func__, name->name);
+        cFYI(1, "For %s", name->name);
 
         if (parent->d_op && parent->d_op->d_hash)
                 parent->d_op->d_hash(parent, parent->d_inode, name);
@@ -89,43 +86,32 @@ cifs_prime_dcache(struct dentry *parent, struct qstr *name,
 
         dentry = d_lookup(parent, name);
         if (dentry) {
-                int err;
-
-                inode = dentry->d_inode;
-                if (inode) {
-                        /*
-                         * If we're generating inode numbers, then we don't
-                         * want to clobber the existing one with the one that
-                         * the readdir code created.
-                         */
-                        if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM))
-                                fattr->cf_uniqueid = CIFS_I(inode)->uniqueid;
-
-                        /* update inode in place if i_ino didn't change */
-                        if (CIFS_I(inode)->uniqueid == fattr->cf_uniqueid) {
-                                cifs_fattr_to_inode(inode, fattr);
-                                goto out;
-                        }
-                }
-                err = d_invalidate(dentry);
+                /* FIXME: check for inode number changes? */
+                if (dentry->d_inode != NULL)
+                        return dentry;
+                d_drop(dentry);
                 dput(dentry);
-                if (err)
-                        return;
         }
 
         dentry = d_alloc(parent, name);
-        if (!dentry)
-                return;
+        if (dentry == NULL)
+                return NULL;
 
         inode = cifs_iget(sb, fattr);
-        if (!inode)
-                goto out;
+        if (!inode) {
+                dput(dentry);
+                return NULL;
+        }
 
         alias = d_materialise_unique(dentry, inode);
-        if (alias && !IS_ERR(alias))
-                dput(alias);
-out:
-        dput(dentry);
+        if (alias != NULL) {
+                dput(dentry);
+                if (IS_ERR(alias))
+                        return NULL;
+                dentry = alias;
+        }
+
+        return dentry;
 }
 
 static void
@@ -145,16 +131,6 @@ cifs_fill_common_info(struct cifs_fattr *fattr, struct cifs_sb_info *cifs_sb)
         if (fattr->cf_cifsattrs & ATTR_READONLY)
                 fattr->cf_mode &= ~S_IWUGO;
 
-        /*
-         * We of course don't get ACL info in FIND_FIRST/NEXT results, so
-         * mark it for revalidation so that "ls -l" will look right. It might
-         * be super-slow, but if we don't do this then the ownership of files
-         * may look wrong since the inodes may not have timed out by the time
-         * "ls" does a stat() call on them.
-         */
-        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
-                fattr->cf_flags |= CIFS_FATTR_NEED_REVAL;
-
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL &&
             fattr->cf_cifsattrs & ATTR_SYSTEM) {
                 if (fattr->cf_eof == 0)  {
@@ -172,7 +148,7 @@ cifs_fill_common_info(struct cifs_fattr *fattr, struct cifs_sb_info *cifs_sb)
         }
 }
 
-void
+static void
 cifs_dir_info_to_fattr(struct cifs_fattr *fattr, FILE_DIRECTORY_INFO *info,
                        struct cifs_sb_info *cifs_sb)
 {
@@ -214,7 +190,7 @@ cifs_std_info_to_fattr(struct cifs_fattr *fattr, FIND_FILE_STANDARD_INFO *info,
       we try to do FindFirst on (NTFS) directory symlinks */
 /*
 int get_symlink_reparse_path(char *full_path, struct cifs_sb_info *cifs_sb,
-                             unsigned int xid)
+                             int xid)
 {
         __u16 fid;
         int len;
@@ -241,17 +217,14 @@ int get_symlink_reparse_path(char *full_path, struct cifs_sb_info *cifs_sb,
 }
  */
 
-static int
-initiate_cifs_search(const unsigned int xid, struct file *file)
+static int initiate_cifs_search(const int xid, struct file *file)
 {
-        __u16 search_flags;
         int rc = 0;
         char *full_path = NULL;
         struct cifsFileInfo *cifsFile;
         struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
         struct tcon_link *tlink = NULL;
-        struct cifs_tcon *tcon;
-        struct TCP_Server_Info *server;
+        struct cifs_tcon *pTcon;
 
         if (file->private_data == NULL) {
                 tlink = cifs_sb_tlink(cifs_sb);
@@ -265,17 +238,10 @@ initiate_cifs_search(const unsigned int xid, struct file *file)
                 }
                 file->private_data = cifsFile;
                 cifsFile->tlink = cifs_get_tlink(tlink);
-                tcon = tlink_tcon(tlink);
+                pTcon = tlink_tcon(tlink);
         } else {
                 cifsFile = file->private_data;
-                tcon = tlink_tcon(cifsFile->tlink);
-        }
-
-        server = tcon->ses->server;
-
-        if (!server->ops->query_dir_first) {
-                rc = -ENOSYS;
-                goto error_exit;
+                pTcon = tlink_tcon(cifsFile->tlink);
         }
 
         cifsFile->invalidHandle = true;
@@ -292,11 +258,11 @@ initiate_cifs_search(const unsigned int xid, struct file *file)
 ffirst_retry:
         /* test for Unix extensions */
         /* but now check for them on the share/mount not on the SMB session */
-        /* if (cap_unix(tcon->ses) { */
-        if (tcon->unix_ext)
+/*      if (pTcon->ses->capabilities & CAP_UNIX) { */
+        if (pTcon->unix_ext)
                 cifsFile->srch_inf.info_level = SMB_FIND_FILE_UNIX;
-        else if ((tcon->ses->capabilities &
-                  tcon->ses->server->vals->cap_nt_find) == 0) {
+        else if ((pTcon->ses->capabilities &
+                        (CAP_NT_SMBS | CAP_NT_FIND)) == 0) {
                 cifsFile->srch_inf.info_level = SMB_FIND_FILE_INFO_STANDARD;
         } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
                 cifsFile->srch_inf.info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
@@ -304,14 +270,10 @@ ffirst_retry:
                 cifsFile->srch_inf.info_level = SMB_FIND_FILE_DIRECTORY_INFO;
         }
 
-        search_flags = CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME;
-        if (backup_cred(cifs_sb))
-                search_flags |= CIFS_SEARCH_BACKUP_SEARCH;
-
-        rc = server->ops->query_dir_first(xid, tcon, full_path, cifs_sb,
-                                          &cifsFile->fid, search_flags,
-                                          &cifsFile->srch_inf);
-
+        rc = CIFSFindFirst(xid, pTcon, full_path, cifs_sb->local_nls,
+                &cifsFile->netfid, &cifsFile->srch_inf,
+                cifs_sb->mnt_cifs_flags &
+                        CIFS_MOUNT_MAP_SPECIAL_CHR, CIFS_DIR_SEP(cifs_sb));
         if (rc == 0)
                 cifsFile->invalidHandle = false;
         /* BB add following call to handle readdir on new NTFS symlink errors
@@ -531,67 +493,60 @@ static int cifs_save_resume_key(const char *current_entry,
         return rc;
 }
 
-/*
- * Find the corresponding entry in the search. Note that the SMB server returns
- * search entries for . and .. which complicates logic here if we choose to
- * parse for them and we do not assume that they are located in the findfirst
- * return buffer. We start counting in the buffer with entry 2 and increment for
- * every entry (do not increment for . or .. entry).
- */
-static int
-find_cifs_entry(const unsigned int xid, struct cifs_tcon *tcon,
-                struct file *file, char **current_entry, int *num_to_ret)
+/* find the corresponding entry in the search */
+/* Note that the SMB server returns search entries for . and .. which
+   complicates logic here if we choose to parse for them and we do not
+   assume that they are located in the findfirst return buffer.*/
+/* We start counting in the buffer with entry 2 and increment for every
+   entry (do not increment for . or .. entry) */
+static int find_cifs_entry(const int xid, struct cifs_tcon *pTcon,
+        struct file *file, char **ppCurrentEntry, int *num_to_ret)
 {
-        __u16 search_flags;
         int rc = 0;
         int pos_in_buf = 0;
         loff_t first_entry_in_buffer;
         loff_t index_to_find = file->f_pos;
-        struct cifsFileInfo *cfile = file->private_data;
-        struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
-        struct TCP_Server_Info *server = tcon->ses->server;
+        struct cifsFileInfo *cifsFile = file->private_data;
         /* check if index in the buffer */
 
-        if (!server->ops->query_dir_first || !server->ops->query_dir_next)
-                return -ENOSYS;
-
-        if ((cfile == NULL) || (current_entry == NULL) || (num_to_ret == NULL))
+        if ((cifsFile == NULL) || (ppCurrentEntry == NULL) ||
+           (num_to_ret == NULL))
                 return -ENOENT;
 
-        *current_entry = NULL;
-        first_entry_in_buffer = cfile->srch_inf.index_of_last_entry -
-                                        cfile->srch_inf.entries_in_buffer;
+        *ppCurrentEntry = NULL;
+        first_entry_in_buffer =
+                cifsFile->srch_inf.index_of_last_entry -
+                        cifsFile->srch_inf.entries_in_buffer;
 
-        /*
-         * If first entry in buf is zero then is first buffer
-         * in search response data which means it is likely . and ..
-         * will be in this buffer, although some servers do not return
-         * . and .. for the root of a drive and for those we need
-         * to start two entries earlier.
-         */
+        /* if first entry in buf is zero then is first buffer
+        in search response data which means it is likely . and ..
+        will be in this buffer, although some servers do not return
+        . and .. for the root of a drive and for those we need
+        to start two entries earlier */
 
         dump_cifs_file_struct(file, "In fce ");
-        if (((index_to_find < cfile->srch_inf.index_of_last_entry) &&
-             is_dir_changed(file)) || (index_to_find < first_entry_in_buffer)) {
+        if (((index_to_find < cifsFile->srch_inf.index_of_last_entry) &&
+             is_dir_changed(file)) ||
+           (index_to_find < first_entry_in_buffer)) {
                 /* close and restart search */
                 cFYI(1, "search backing up - close and restart search");
                 spin_lock(&cifs_file_list_lock);
-                if (!cfile->srch_inf.endOfSearch && !cfile->invalidHandle) {
-                        cfile->invalidHandle = true;
+                if (!cifsFile->srch_inf.endOfSearch &&
+                    !cifsFile->invalidHandle) {
+                        cifsFile->invalidHandle = true;
                         spin_unlock(&cifs_file_list_lock);
-                        if (server->ops->close)
-                                server->ops->close(xid, tcon, &cfile->fid);
+                        CIFSFindClose(xid, pTcon, cifsFile->netfid);
                 } else
                         spin_unlock(&cifs_file_list_lock);
-                if (cfile->srch_inf.ntwrk_buf_start) {
+                if (cifsFile->srch_inf.ntwrk_buf_start) {
                         cFYI(1, "freeing SMB ff cache buf on search rewind");
-                        if (cfile->srch_inf.smallBuf)
-                                cifs_small_buf_release(cfile->srch_inf.
+                        if (cifsFile->srch_inf.smallBuf)
+                                cifs_small_buf_release(cifsFile->srch_inf.
                                                 ntwrk_buf_start);
                         else
-                                cifs_buf_release(cfile->srch_inf.
+                                cifs_buf_release(cifsFile->srch_inf.
                                                 ntwrk_buf_start);
-                        cfile->srch_inf.ntwrk_buf_start = NULL;
+                        cifsFile->srch_inf.ntwrk_buf_start = NULL;
                 }
                 rc = initiate_cifs_search(xid, file);
                 if (rc) {
@@ -600,64 +555,61 @@ find_cifs_entry(const unsigned int xid, struct cifs_tcon *tcon,
                         return rc;
                 }
                 /* FindFirst/Next set last_entry to NULL on malformed reply */
-                if (cfile->srch_inf.last_entry)
-                        cifs_save_resume_key(cfile->srch_inf.last_entry, cfile);
+                if (cifsFile->srch_inf.last_entry)
+                        cifs_save_resume_key(cifsFile->srch_inf.last_entry,
+                                                cifsFile);
         }
 
-        search_flags = CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME;
-        if (backup_cred(cifs_sb))
-                search_flags |= CIFS_SEARCH_BACKUP_SEARCH;
-
-        while ((index_to_find >= cfile->srch_inf.index_of_last_entry) &&
-               (rc == 0) && !cfile->srch_inf.endOfSearch) {
+        while ((index_to_find >= cifsFile->srch_inf.index_of_last_entry) &&
+              (rc == 0) && !cifsFile->srch_inf.endOfSearch) {
                 cFYI(1, "calling findnext2");
-                rc = server->ops->query_dir_next(xid, tcon, &cfile->fid,
-                                                 search_flags,
-                                                 &cfile->srch_inf);
+                rc = CIFSFindNext(xid, pTcon, cifsFile->netfid,
+                                  &cifsFile->srch_inf);
                 /* FindFirst/Next set last_entry to NULL on malformed reply */
-                if (cfile->srch_inf.last_entry)
-                        cifs_save_resume_key(cfile->srch_inf.last_entry, cfile);
+                if (cifsFile->srch_inf.last_entry)
+                        cifs_save_resume_key(cifsFile->srch_inf.last_entry,
+                                                cifsFile);
                 if (rc)
                         return -ENOENT;
         }
-        if (index_to_find < cfile->srch_inf.index_of_last_entry) {
+        if (index_to_find < cifsFile->srch_inf.index_of_last_entry) {
                 /* we found the buffer that contains the entry */
                 /* scan and find it */
                 int i;
-                char *cur_ent;
-                char *end_of_smb = cfile->srch_inf.ntwrk_buf_start +
-                        server->ops->calc_smb_size(
-                                        cfile->srch_inf.ntwrk_buf_start);
-
-                cur_ent = cfile->srch_inf.srch_entries_start;
-                first_entry_in_buffer = cfile->srch_inf.index_of_last_entry
-                                        - cfile->srch_inf.entries_in_buffer;
+                char *current_entry;
+                char *end_of_smb = cifsFile->srch_inf.ntwrk_buf_start +
+                        smbCalcSize((struct smb_hdr *)
+                                cifsFile->srch_inf.ntwrk_buf_start);
+
+                current_entry = cifsFile->srch_inf.srch_entries_start;
+                first_entry_in_buffer = cifsFile->srch_inf.index_of_last_entry
+                                        - cifsFile->srch_inf.entries_in_buffer;
                 pos_in_buf = index_to_find - first_entry_in_buffer;
                 cFYI(1, "found entry - pos_in_buf %d", pos_in_buf);
 
-                for (i = 0; (i < (pos_in_buf)) && (cur_ent != NULL); i++) {
+                for (i = 0; (i < (pos_in_buf)) && (current_entry != NULL); i++) {
                         /* go entry by entry figuring out which is first */
-                        cur_ent = nxt_dir_entry(cur_ent, end_of_smb,
-                                                cfile->srch_inf.info_level);
+                        current_entry = nxt_dir_entry(current_entry, end_of_smb,
+                                                cifsFile->srch_inf.info_level);
                 }
-                if ((cur_ent == NULL) && (i < pos_in_buf)) {
+                if ((current_entry == NULL) && (i < pos_in_buf)) {
                         /* BB fixme - check if we should flag this error */
                         cERROR(1, "reached end of buf searching for pos in buf"
-                                  " %d index to find %lld rc %d", pos_in_buf,
-                                  index_to_find, rc);
+                          " %d index to find %lld rc %d",
+                          pos_in_buf, index_to_find, rc);
                 }
                 rc = 0;
-                *current_entry = cur_ent;
+                *ppCurrentEntry = current_entry;
         } else {
                 cFYI(1, "index not in buffer - could not findnext into it");
                 return 0;
         }
 
-        if (pos_in_buf >= cfile->srch_inf.entries_in_buffer) {
+        if (pos_in_buf >= cifsFile->srch_inf.entries_in_buffer) {
                 cFYI(1, "can not return entries pos_in_buf beyond last");
                 *num_to_ret = 0;
         } else
-                *num_to_ret = cfile->srch_inf.entries_in_buffer - pos_in_buf;
+                *num_to_ret = cifsFile->srch_inf.entries_in_buffer - pos_in_buf;
 
         return rc;
 }
@@ -670,6 +622,7 @@ static int cifs_filldir(char *find_entry, struct file *file, filldir_t filldir,
         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
         struct cifs_dirent de = { NULL, };
         struct cifs_fattr fattr;
+        struct dentry *dentry;
         struct qstr name;
         int rc = 0;
         ino_t ino;
@@ -694,11 +647,10 @@ static int cifs_filldir(char *find_entry, struct file *file, filldir_t filldir,
 
                 name.name = scratch_buf;
                 name.len =
-                        cifs_from_utf16((char *)name.name, (__le16 *)de.name,
-                                        UNICODE_NAME_MAX,
-                                        min_t(size_t, de.namelen,
-                                              (size_t)max_len), nlt,
-                                        cifs_sb->mnt_cifs_flags &
+                        cifs_from_ucs2((char *)name.name, (__le16 *)de.name,
+                                       UNICODE_NAME_MAX,
+                                       min(de.namelen, (size_t)max_len), nlt,
+                                       cifs_sb->mnt_cifs_flags &
                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
                 name.len -= nls_nullsize(nlt);
         } else {
@@ -740,11 +692,13 @@ static int cifs_filldir(char *find_entry, struct file *file, filldir_t filldir,
                  */
                 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
 
-        cifs_prime_dcache(file->f_dentry, &name, &fattr);
-
         ino = cifs_uniqueid_to_ino_t(fattr.cf_uniqueid);
+        dentry = cifs_readdir_lookup(file->f_dentry, &name, &fattr);
+
         rc = filldir(dirent, name.name, name.len, file->f_pos, ino,
                      fattr.cf_dtype);
+
+        dput(dentry);
         return rc;
 }
 
@@ -752,9 +706,8 @@ static int cifs_filldir(char *find_entry, struct file *file, filldir_t filldir,
 int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
 {
         int rc = 0;
-        unsigned int xid;
-        int i;
-        struct cifs_tcon *tcon;
+        int xid, i;
+        struct cifs_tcon *pTcon;
         struct cifsFileInfo *cifsFile = NULL;
         char *current_entry;
         int num_to_fill = 0;
@@ -762,7 +715,7 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
         char *end_of_smb;
         unsigned int max_len;
 
-        xid = get_xid();
+        xid = GetXid();
 
         /*
          * Ensure FindFirst doesn't fail before doing filldir() for '.' and
@@ -800,7 +753,7 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
 
                 if (file->private_data == NULL) {
                         rc = -EINVAL;
-                        free_xid(xid);
+                        FreeXid(xid);
                         return rc;
                 }
                 cifsFile = file->private_data;
@@ -812,12 +765,12 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
                         }
                 } /* else {
                         cifsFile->invalidHandle = true;
-                        tcon->ses->server->close(xid, tcon, &cifsFile->fid);
+                        CIFSFindClose(xid, pTcon, cifsFile->netfid);
                 } */
 
-                tcon = tlink_tcon(cifsFile->tlink);
-                rc = find_cifs_entry(xid, tcon, file, &current_entry,
-                                     &num_to_fill);
+                pTcon = tlink_tcon(cifsFile->tlink);
+                rc = find_cifs_entry(xid, pTcon, file,
+                                &current_entry, &num_to_fill);
                 if (rc) {
                         cFYI(1, "fce error %d", rc);
                         goto rddir2_exit;
@@ -829,7 +782,7 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
                 }
                 cFYI(1, "loop through %d times filling dir for net buf %p",
                         num_to_fill, cifsFile->srch_inf.ntwrk_buf_start);
-                max_len = tcon->ses->server->ops->calc_smb_size(
+                max_len = smbCalcSize((struct smb_hdr *)
                                 cifsFile->srch_inf.ntwrk_buf_start);
                 end_of_smb = cifsFile->srch_inf.ntwrk_buf_start + max_len;
 
@@ -846,12 +799,10 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
                                           num_to_fill, i);
                                 break;
                         }
-                        /*
-                         * if buggy server returns . and .. late do we want to
-                         * check for that here?
-                         */
-                        rc = cifs_filldir(current_entry, file, filldir,
-                                          direntry, tmp_buf, max_len);
+                        /* if buggy server returns . and .. late do
+                        we want to check for that here? */
+                        rc = cifs_filldir(current_entry, file,
+                                        filldir, direntry, tmp_buf, max_len);
                         if (rc == -EOVERFLOW) {
                                 rc = 0;
                                 break;
@@ -874,6 +825,6 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
         } /* end switch */
 
 rddir2_exit:
-        free_xid(xid);
+        FreeXid(xid);
         return rc;
 }
diff --git a/fs/cifs/sess.c b/fs/cifs/sess.c
index 76809f4d342..d3e619692ee 100644
--- a/fs/cifs/sess.c
+++ b/fs/cifs/sess.c
@@ -124,9 +124,7 @@ static __u32 cifs_ssetup_hdr(struct cifs_ses *ses, SESSION_SETUP_ANDX *pSMB)
         /*      that we use in next few lines                               */
         /* Note that header is initialized to zero in header_assemble */
         pSMB->req.AndXCommand = 0xFF;
-        pSMB->req.MaxBufferSize = cpu_to_le16(min_t(u32,
-                                        CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4,
-                                        USHRT_MAX));
+        pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
         pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
         pSMB->req.VcNumber = get_next_vcnum(ses);
 
@@ -167,16 +165,16 @@ unicode_oslm_strings(char **pbcc_area, const struct nls_table *nls_cp)
         int bytes_ret = 0;
 
         /* Copy OS version */
-        bytes_ret = cifs_strtoUTF16((__le16 *)bcc_ptr, "Linux version ", 32,
-                                    nls_cp);
+        bytes_ret = cifs_strtoUCS((__le16 *)bcc_ptr, "Linux version ", 32,
+                                  nls_cp);
         bcc_ptr += 2 * bytes_ret;
-        bytes_ret = cifs_strtoUTF16((__le16 *) bcc_ptr, init_utsname()->release,
-                                    32, nls_cp);
+        bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, init_utsname()->release,
+                                  32, nls_cp);
         bcc_ptr += 2 * bytes_ret;
         bcc_ptr += 2; /* trailing null */
 
-        bytes_ret = cifs_strtoUTF16((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
-                                    32, nls_cp);
+        bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
+                                  32, nls_cp);
         bcc_ptr += 2 * bytes_ret;
         bcc_ptr += 2; /* trailing null */
 
@@ -197,8 +195,8 @@ static void unicode_domain_string(char **pbcc_area, struct cifs_ses *ses,
                 *(bcc_ptr+1) = 0;
                 bytes_ret = 0;
         } else
-                bytes_ret = cifs_strtoUTF16((__le16 *) bcc_ptr, ses->domainName,
-                                            256, nls_cp);
+                bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, ses->domainName,
+                                          256, nls_cp);
         bcc_ptr += 2 * bytes_ret;
         bcc_ptr += 2;  /* account for null terminator */
 
@@ -226,8 +224,8 @@ static void unicode_ssetup_strings(char **pbcc_area, struct cifs_ses *ses,
                 *bcc_ptr = 0;
                 *(bcc_ptr+1) = 0;
         } else {
-                bytes_ret = cifs_strtoUTF16((__le16 *) bcc_ptr, ses->user_name,
-                                            MAX_USERNAME_SIZE, nls_cp);
+                bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, ses->user_name,
+                                          MAX_USERNAME_SIZE, nls_cp);
         }
         bcc_ptr += 2 * bytes_ret;
         bcc_ptr += 2; /* account for null termination */
@@ -246,15 +244,16 @@ static void ascii_ssetup_strings(char **pbcc_area, struct cifs_ses *ses,
         /* copy user */
         /* BB what about null user mounts - check that we do this BB */
         /* copy user */
-        if (ses->user_name != NULL) {
+        if (ses->user_name != NULL)
                 strncpy(bcc_ptr, ses->user_name, MAX_USERNAME_SIZE);
-                bcc_ptr += strnlen(ses->user_name, MAX_USERNAME_SIZE);
-        }
         /* else null user mount */
+
+        bcc_ptr += strnlen(ses->user_name, MAX_USERNAME_SIZE);
         *bcc_ptr = 0;
         bcc_ptr++; /* account for null termination */
 
         /* copy domain */
+
         if (ses->domainName != NULL) {
                 strncpy(bcc_ptr, ses->domainName, 256);
                 bcc_ptr += strnlen(ses->domainName, 256);
@@ -286,7 +285,7 @@ decode_unicode_ssetup(char **pbcc_area, int bleft, struct cifs_ses *ses,
         cFYI(1, "bleft %d", bleft);
 
         kfree(ses->serverOS);
-        ses->serverOS = cifs_strndup_from_utf16(data, bleft, true, nls_cp);
+        ses->serverOS = cifs_strndup_from_ucs(data, bleft, true, nls_cp);
         cFYI(1, "serverOS=%s", ses->serverOS);
         len = (UniStrnlen((wchar_t *) data, bleft / 2) * 2) + 2;
         data += len;
@@ -295,7 +294,7 @@ decode_unicode_ssetup(char **pbcc_area, int bleft, struct cifs_ses *ses,
                 return;
 
         kfree(ses->serverNOS);
-        ses->serverNOS = cifs_strndup_from_utf16(data, bleft, true, nls_cp);
+        ses->serverNOS = cifs_strndup_from_ucs(data, bleft, true, nls_cp);
         cFYI(1, "serverNOS=%s", ses->serverNOS);
         len = (UniStrnlen((wchar_t *) data, bleft / 2) * 2) + 2;
         data += len;
@@ -304,7 +303,7 @@ decode_unicode_ssetup(char **pbcc_area, int bleft, struct cifs_ses *ses,
                 return;
 
         kfree(ses->serverDomain);
-        ses->serverDomain = cifs_strndup_from_utf16(data, bleft, true, nls_cp);
+        ses->serverDomain = cifs_strndup_from_ucs(data, bleft, true, nls_cp);
         cFYI(1, "serverDomain=%s", ses->serverDomain);
 
         return;
@@ -364,7 +363,7 @@ static int decode_ascii_ssetup(char **pbcc_area, __u16 bleft,
         return rc;
 }
 
-int decode_ntlmssp_challenge(char *bcc_ptr, int blob_len,
+static int decode_ntlmssp_challenge(char *bcc_ptr, int blob_len,
                                     struct cifs_ses *ses)
 {
         unsigned int tioffset; /* challenge message target info area */
@@ -394,10 +393,6 @@ int decode_ntlmssp_challenge(char *bcc_ptr, int blob_len,
         ses->ntlmssp->server_flags = le32_to_cpu(pblob->NegotiateFlags);
         tioffset = le32_to_cpu(pblob->TargetInfoArray.BufferOffset);
         tilen = le16_to_cpu(pblob->TargetInfoArray.Length);
-        if (tioffset > blob_len || tioffset + tilen > blob_len) {
-                cERROR(1, "tioffset + tilen too high %u + %u", tioffset, tilen);
-                return -EINVAL;
-        }
         if (tilen) {
                 ses->auth_key.response = kmalloc(tilen, GFP_KERNEL);
                 if (!ses->auth_key.response) {
@@ -415,7 +410,7 @@ int decode_ntlmssp_challenge(char *bcc_ptr, int blob_len,
 
 /* We do not malloc the blob, it is passed in pbuffer, because
    it is fixed size, and small, making this approach cleaner */
-void build_ntlmssp_negotiate_blob(unsigned char *pbuffer,
+static void build_ntlmssp_negotiate_blob(unsigned char *pbuffer,
                                          struct cifs_ses *ses)
 {
         NEGOTIATE_MESSAGE *sec_blob = (NEGOTIATE_MESSAGE *)pbuffer;
@@ -451,7 +446,7 @@ void build_ntlmssp_negotiate_blob(unsigned char *pbuffer,
 /* We do not malloc the blob, it is passed in pbuffer, because its
    maximum possible size is fixed and small, making this approach cleaner.
    This function returns the length of the data in the blob */
-int build_ntlmssp_auth_blob(unsigned char *pbuffer,
+static int build_ntlmssp_auth_blob(unsigned char *pbuffer,
                                         u16 *buflen,
                                    struct cifs_ses *ses,
                                    const struct nls_table *nls_cp)
@@ -505,8 +500,8 @@ int build_ntlmssp_auth_blob(unsigned char *pbuffer,
                 tmp += 2;
         } else {
                 int len;
-                len = cifs_strtoUTF16((__le16 *)tmp, ses->domainName,
-                                      MAX_USERNAME_SIZE, nls_cp);
+                len = cifs_strtoUCS((__le16 *)tmp, ses->domainName,
+                                    MAX_USERNAME_SIZE, nls_cp);
                 len *= 2; /* unicode is 2 bytes each */
                 sec_blob->DomainName.BufferOffset = cpu_to_le32(tmp - pbuffer);
                 sec_blob->DomainName.Length = cpu_to_le16(len);
@@ -521,8 +516,8 @@ int build_ntlmssp_auth_blob(unsigned char *pbuffer,
                 tmp += 2;
         } else {
                 int len;
-                len = cifs_strtoUTF16((__le16 *)tmp, ses->user_name,
-                                      MAX_USERNAME_SIZE, nls_cp);
+                len = cifs_strtoUCS((__le16 *)tmp, ses->user_name,
+                                    MAX_USERNAME_SIZE, nls_cp);
                 len *= 2; /* unicode is 2 bytes each */
                 sec_blob->UserName.BufferOffset = cpu_to_le32(tmp - pbuffer);
                 sec_blob->UserName.Length = cpu_to_le16(len);
@@ -556,7 +551,7 @@ setup_ntlmv2_ret:
 }
 
 int
-CIFS_SessSetup(const unsigned int xid, struct cifs_ses *ses,
+CIFS_SessSetup(unsigned int xid, struct cifs_ses *ses,
                const struct nls_table *nls_cp)
 {
         int rc = 0;
@@ -686,7 +681,7 @@ ssetup_ntlmssp_authenticate:
                         cpu_to_le16(CIFS_AUTH_RESP_SIZE);
 
                 /* calculate ntlm response and session key */
-                rc = setup_ntlm_response(ses, nls_cp);
+                rc = setup_ntlm_response(ses);
                 if (rc) {
                         cERROR(1, "Error %d during NTLM authentication", rc);
                         goto ssetup_exit;
@@ -876,8 +871,7 @@ ssetup_ntlmssp_authenticate:
         pSMB = (SESSION_SETUP_ANDX *)iov[0].iov_base;
         smb_buf = (struct smb_hdr *)iov[0].iov_base;
 
-        if ((type == RawNTLMSSP) && (resp_buf_type != CIFS_NO_BUFFER) &&
-            (smb_buf->Status.CifsError ==
+        if ((type == RawNTLMSSP) && (smb_buf->Status.CifsError ==
                         cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))) {
                 if (phase != NtLmNegotiate) {
                         cERROR(1, "Unexpected more processing error");
@@ -899,7 +893,7 @@ ssetup_ntlmssp_authenticate:
         if (action & GUEST_LOGIN)
                 cFYI(1, "Guest login"); /* BB mark SesInfo struct? */
         ses->Suid = smb_buf->Uid;   /* UID left in wire format (le) */
-        cFYI(1, "UID = %llu ", ses->Suid);
+        cFYI(1, "UID = %d ", ses->Suid);
         /* response can have either 3 or 4 word count - Samba sends 3 */
         /* and lanman response is 3 */
         bytes_remaining = get_bcc(smb_buf);
@@ -939,7 +933,7 @@ ssetup_ntlmssp_authenticate:
 
 ssetup_exit:
         if (spnego_key) {
-                key_invalidate(spnego_key);
+                key_revoke(spnego_key);
                 key_put(spnego_key);
         }
         kfree(str_area);
diff --git a/fs/cifs/smb1ops.c b/fs/cifs/smb1ops.c
deleted file mode 100644
index 47bc5a87f94..00000000000
--- a/fs/cifs/smb1ops.c
+++ /dev/null
@@ -1,963 +0,0 @@
-/*
- *  SMB1 (CIFS) version specific operations
- *
- *  Copyright (c) 2012, Jeff Layton <jlayton@redhat.com>
- *
- *  This library is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License v2 as published
- *  by the Free Software Foundation.
- *
- *  This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
- *  the GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this library; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-
-#include <linux/pagemap.h>
-#include <linux/vfs.h>
-#include "cifsglob.h"
-#include "cifsproto.h"
-#include "cifs_debug.h"
-#include "cifspdu.h"
-
-/*
- * An NT cancel request header looks just like the original request except:
- *
- * The Command is SMB_COM_NT_CANCEL
- * The WordCount is zeroed out
- * The ByteCount is zeroed out
- *
- * This function mangles an existing request buffer into a
- * SMB_COM_NT_CANCEL request and then sends it.
- */
-static int
-send_nt_cancel(struct TCP_Server_Info *server, void *buf,
-               struct mid_q_entry *mid)
-{
-        int rc = 0;
-        struct smb_hdr *in_buf = (struct smb_hdr *)buf;
-
-        /* -4 for RFC1001 length and +2 for BCC field */
-        in_buf->smb_buf_length = cpu_to_be32(sizeof(struct smb_hdr) - 4  + 2);
-        in_buf->Command = SMB_COM_NT_CANCEL;
-        in_buf->WordCount = 0;
-        put_bcc(0, in_buf);
-
-        mutex_lock(&server->srv_mutex);
-        rc = cifs_sign_smb(in_buf, server, &mid->sequence_number);
-        if (rc) {
-                mutex_unlock(&server->srv_mutex);
-                return rc;
-        }
-
-        /*
-         * The response to this call was already factored into the sequence
-         * number when the call went out, so we must adjust it back downward
-         * after signing here.
-         */
-        --server->sequence_number;
-        rc = smb_send(server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
-        mutex_unlock(&server->srv_mutex);
-
-        cFYI(1, "issued NT_CANCEL for mid %u, rc = %d",
-                in_buf->Mid, rc);
-
-        return rc;
-}
-
-static bool
-cifs_compare_fids(struct cifsFileInfo *ob1, struct cifsFileInfo *ob2)
-{
-        return ob1->fid.netfid == ob2->fid.netfid;
-}
-
-static unsigned int
-cifs_read_data_offset(char *buf)
-{
-        READ_RSP *rsp = (READ_RSP *)buf;
-        return le16_to_cpu(rsp->DataOffset);
-}
-
-static unsigned int
-cifs_read_data_length(char *buf)
-{
-        READ_RSP *rsp = (READ_RSP *)buf;
-        return (le16_to_cpu(rsp->DataLengthHigh) << 16) +
-               le16_to_cpu(rsp->DataLength);
-}
-
-static struct mid_q_entry *
-cifs_find_mid(struct TCP_Server_Info *server, char *buffer)
-{
-        struct smb_hdr *buf = (struct smb_hdr *)buffer;
-        struct mid_q_entry *mid;
-
-        spin_lock(&GlobalMid_Lock);
-        list_for_each_entry(mid, &server->pending_mid_q, qhead) {
-                if (mid->mid == buf->Mid &&
-                    mid->mid_state == MID_REQUEST_SUBMITTED &&
-                    le16_to_cpu(mid->command) == buf->Command) {
-                        spin_unlock(&GlobalMid_Lock);
-                        return mid;
-                }
-        }
-        spin_unlock(&GlobalMid_Lock);
-        return NULL;
-}
-
-static void
-cifs_add_credits(struct TCP_Server_Info *server, const unsigned int add,
-                 const int optype)
-{
-        spin_lock(&server->req_lock);
-        server->credits += add;
-        server->in_flight--;
-        spin_unlock(&server->req_lock);
-        wake_up(&server->request_q);
-}
-
-static void
-cifs_set_credits(struct TCP_Server_Info *server, const int val)
-{
-        spin_lock(&server->req_lock);
-        server->credits = val;
-        server->oplocks = val > 1 ? enable_oplocks : false;
-        spin_unlock(&server->req_lock);
-}
-
-static int *
-cifs_get_credits_field(struct TCP_Server_Info *server, const int optype)
-{
-        return &server->credits;
-}
-
-static unsigned int
-cifs_get_credits(struct mid_q_entry *mid)
-{
-        return 1;
-}
-
-/*
- * Find a free multiplex id (SMB mid). Otherwise there could be
- * mid collisions which might cause problems, demultiplexing the
- * wrong response to this request. Multiplex ids could collide if
- * one of a series requests takes much longer than the others, or
- * if a very large number of long lived requests (byte range
- * locks or FindNotify requests) are pending. No more than
- * 64K-1 requests can be outstanding at one time. If no
- * mids are available, return zero. A future optimization
- * could make the combination of mids and uid the key we use
- * to demultiplex on (rather than mid alone).
- * In addition to the above check, the cifs demultiplex
- * code already used the command code as a secondary
- * check of the frame and if signing is negotiated the
- * response would be discarded if the mid were the same
- * but the signature was wrong. Since the mid is not put in the
- * pending queue until later (when it is about to be dispatched)
- * we do have to limit the number of outstanding requests
- * to somewhat less than 64K-1 although it is hard to imagine
- * so many threads being in the vfs at one time.
- */
-static __u64
-cifs_get_next_mid(struct TCP_Server_Info *server)
-{
-        __u64 mid = 0;
-        __u16 last_mid, cur_mid;
-        bool collision;
-
-        spin_lock(&GlobalMid_Lock);
-
-        /* mid is 16 bit only for CIFS/SMB */
-        cur_mid = (__u16)((server->CurrentMid) & 0xffff);
-        /* we do not want to loop forever */
-        last_mid = cur_mid;
-        cur_mid++;
-
-        /*
-         * This nested loop looks more expensive than it is.
-         * In practice the list of pending requests is short,
-         * fewer than 50, and the mids are likely to be unique
-         * on the first pass through the loop unless some request
-         * takes longer than the 64 thousand requests before it
-         * (and it would also have to have been a request that
-         * did not time out).
-         */
-        while (cur_mid != last_mid) {
-                struct mid_q_entry *mid_entry;
-                unsigned int num_mids;
-
-                collision = false;
-                if (cur_mid == 0)
-                        cur_mid++;
-
-                num_mids = 0;
-                list_for_each_entry(mid_entry, &server->pending_mid_q, qhead) {
-                        ++num_mids;
-                        if (mid_entry->mid == cur_mid &&
-                            mid_entry->mid_state == MID_REQUEST_SUBMITTED) {
-                                /* This mid is in use, try a different one */
-                                collision = true;
-                                break;
-                        }
-                }
-
-                /*
-                 * if we have more than 32k mids in the list, then something
-                 * is very wrong. Possibly a local user is trying to DoS the
-                 * box by issuing long-running calls and SIGKILL'ing them. If
-                 * we get to 2^16 mids then we're in big trouble as this
-                 * function could loop forever.
-                 *
-                 * Go ahead and assign out the mid in this situation, but force
-                 * an eventual reconnect to clean out the pending_mid_q.
-                 */
-                if (num_mids > 32768)
-                        server->tcpStatus = CifsNeedReconnect;
-
-                if (!collision) {
-                        mid = (__u64)cur_mid;
-                        server->CurrentMid = mid;
-                        break;
-                }
-                cur_mid++;
-        }
-        spin_unlock(&GlobalMid_Lock);
-        return mid;
-}
-
-/*
-        return codes:
-                0       not a transact2, or all data present
-                >0      transact2 with that much data missing
-                -EINVAL invalid transact2
- */
-static int
-check2ndT2(char *buf)
-{
-        struct smb_hdr *pSMB = (struct smb_hdr *)buf;
-        struct smb_t2_rsp *pSMBt;
-        int remaining;
-        __u16 total_data_size, data_in_this_rsp;
-
-        if (pSMB->Command != SMB_COM_TRANSACTION2)
-                return 0;
-
-        /* check for plausible wct, bcc and t2 data and parm sizes */
-        /* check for parm and data offset going beyond end of smb */
-        if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
-                cFYI(1, "invalid transact2 word count");
-                return -EINVAL;
-        }
-
-        pSMBt = (struct smb_t2_rsp *)pSMB;
-
-        total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
-        data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
-
-        if (total_data_size == data_in_this_rsp)
-                return 0;
-        else if (total_data_size < data_in_this_rsp) {
-                cFYI(1, "total data %d smaller than data in frame %d",
-                        total_data_size, data_in_this_rsp);
-                return -EINVAL;
-        }
-
-        remaining = total_data_size - data_in_this_rsp;
-
-        cFYI(1, "missing %d bytes from transact2, check next response",
-                remaining);
-        if (total_data_size > CIFSMaxBufSize) {
-                cERROR(1, "TotalDataSize %d is over maximum buffer %d",
-                        total_data_size, CIFSMaxBufSize);
-                return -EINVAL;
-        }
-        return remaining;
-}
-
-static int
-coalesce_t2(char *second_buf, struct smb_hdr *target_hdr)
-{
-        struct smb_t2_rsp *pSMBs = (struct smb_t2_rsp *)second_buf;
-        struct smb_t2_rsp *pSMBt  = (struct smb_t2_rsp *)target_hdr;
-        char *data_area_of_tgt;
-        char *data_area_of_src;
-        int remaining;
-        unsigned int byte_count, total_in_tgt;
-        __u16 tgt_total_cnt, src_total_cnt, total_in_src;
-
-        src_total_cnt = get_unaligned_le16(&pSMBs->t2_rsp.TotalDataCount);
-        tgt_total_cnt = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
-
-        if (tgt_total_cnt != src_total_cnt)
-                cFYI(1, "total data count of primary and secondary t2 differ "
-                        "source=%hu target=%hu", src_total_cnt, tgt_total_cnt);
-
-        total_in_tgt = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
-
-        remaining = tgt_total_cnt - total_in_tgt;
-
-        if (remaining < 0) {
-                cFYI(1, "Server sent too much data. tgt_total_cnt=%hu "
-                        "total_in_tgt=%hu", tgt_total_cnt, total_in_tgt);
-                return -EPROTO;
-        }
-
-        if (remaining == 0) {
-                /* nothing to do, ignore */
-                cFYI(1, "no more data remains");
-                return 0;
-        }
-
-        total_in_src = get_unaligned_le16(&pSMBs->t2_rsp.DataCount);
-        if (remaining < total_in_src)
-                cFYI(1, "transact2 2nd response contains too much data");
-
-        /* find end of first SMB data area */
-        data_area_of_tgt = (char *)&pSMBt->hdr.Protocol +
-                                get_unaligned_le16(&pSMBt->t2_rsp.DataOffset);
-
-        /* validate target area */
-        data_area_of_src = (char *)&pSMBs->hdr.Protocol +
-                                get_unaligned_le16(&pSMBs->t2_rsp.DataOffset);
-
-        data_area_of_tgt += total_in_tgt;
-
-        total_in_tgt += total_in_src;
-        /* is the result too big for the field? */
-        if (total_in_tgt > USHRT_MAX) {
-                cFYI(1, "coalesced DataCount too large (%u)", total_in_tgt);
-                return -EPROTO;
-        }
-        put_unaligned_le16(total_in_tgt, &pSMBt->t2_rsp.DataCount);
-
-        /* fix up the BCC */
-        byte_count = get_bcc(target_hdr);
-        byte_count += total_in_src;
-        /* is the result too big for the field? */
-        if (byte_count > USHRT_MAX) {
-                cFYI(1, "coalesced BCC too large (%u)", byte_count);
-                return -EPROTO;
-        }
-        put_bcc(byte_count, target_hdr);
-
-        byte_count = be32_to_cpu(target_hdr->smb_buf_length);
-        byte_count += total_in_src;
-        /* don't allow buffer to overflow */
-        if (byte_count > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
-                cFYI(1, "coalesced BCC exceeds buffer size (%u)", byte_count);
-                return -ENOBUFS;
-        }
-        target_hdr->smb_buf_length = cpu_to_be32(byte_count);
-
-        /* copy second buffer into end of first buffer */
-        memcpy(data_area_of_tgt, data_area_of_src, total_in_src);
-
-        if (remaining != total_in_src) {
-                /* more responses to go */
-                cFYI(1, "waiting for more secondary responses");
-                return 1;
-        }
-
-        /* we are done */
-        cFYI(1, "found the last secondary response");
-        return 0;
-}
-
-static bool
-cifs_check_trans2(struct mid_q_entry *mid, struct TCP_Server_Info *server,
-                  char *buf, int malformed)
-{
-        if (malformed)
-                return false;
-        if (check2ndT2(buf) <= 0)
-                return false;
-        mid->multiRsp = true;
-        if (mid->resp_buf) {
-                /* merge response - fix up 1st*/
-                malformed = coalesce_t2(buf, mid->resp_buf);
-                if (malformed > 0)
-                        return true;
-                /* All parts received or packet is malformed. */
-                mid->multiEnd = true;
-                dequeue_mid(mid, malformed);
-                return true;
-        }
-        if (!server->large_buf) {
-                /*FIXME: switch to already allocated largebuf?*/
-                cERROR(1, "1st trans2 resp needs bigbuf");
-        } else {
-                /* Have first buffer */
-                mid->resp_buf = buf;
-                mid->large_buf = true;
-                server->bigbuf = NULL;
-        }
-        return true;
-}
-
-static bool
-cifs_need_neg(struct TCP_Server_Info *server)
-{
-        return server->maxBuf == 0;
-}
-
-static int
-cifs_negotiate(const unsigned int xid, struct cifs_ses *ses)
-{
-        int rc;
-        rc = CIFSSMBNegotiate(xid, ses);
-        if (rc == -EAGAIN) {
-                /* retry only once on 1st time connection */
-                set_credits(ses->server, 1);
-                rc = CIFSSMBNegotiate(xid, ses);
-                if (rc == -EAGAIN)
-                        rc = -EHOSTDOWN;
-        }
-        return rc;
-}
-
-static unsigned int
-cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *volume_info)
-{
-        __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
-        struct TCP_Server_Info *server = tcon->ses->server;
-        unsigned int wsize;
-
-        /* start with specified wsize, or default */
-        if (volume_info->wsize)
-                wsize = volume_info->wsize;
-        else if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
-                wsize = CIFS_DEFAULT_IOSIZE;
-        else
-                wsize = CIFS_DEFAULT_NON_POSIX_WSIZE;
-
-        /* can server support 24-bit write sizes? (via UNIX extensions) */
-        if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
-                wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE);
-
-        /*
-         * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
-         * Limit it to max buffer offered by the server, minus the size of the
-         * WRITEX header, not including the 4 byte RFC1001 length.
-         */
-        if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
-            (!(server->capabilities & CAP_UNIX) &&
-             (server->sec_mode & (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED))))
-                wsize = min_t(unsigned int, wsize,
-                                server->maxBuf - sizeof(WRITE_REQ) + 4);
-
-        /* hard limit of CIFS_MAX_WSIZE */
-        wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
-
-        return wsize;
-}
-
-static unsigned int
-cifs_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *volume_info)
-{
-        __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
-        struct TCP_Server_Info *server = tcon->ses->server;
-        unsigned int rsize, defsize;
-
-        /*
-         * Set default value...
-         *
-         * HACK alert! Ancient servers have very small buffers. Even though
-         * MS-CIFS indicates that servers are only limited by the client's
-         * bufsize for reads, testing against win98se shows that it throws
-         * INVALID_PARAMETER errors if you try to request too large a read.
-         * OS/2 just sends back short reads.
-         *
-         * If the server doesn't advertise CAP_LARGE_READ_X, then assume that
-         * it can't handle a read request larger than its MaxBufferSize either.
-         */
-        if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_READ_CAP))
-                defsize = CIFS_DEFAULT_IOSIZE;
-        else if (server->capabilities & CAP_LARGE_READ_X)
-                defsize = CIFS_DEFAULT_NON_POSIX_RSIZE;
-        else
-                defsize = server->maxBuf - sizeof(READ_RSP);
-
-        rsize = volume_info->rsize ? volume_info->rsize : defsize;
-
-        /*
-         * no CAP_LARGE_READ_X? Then MS-CIFS states that we must limit this to
-         * the client's MaxBufferSize.
-         */
-        if (!(server->capabilities & CAP_LARGE_READ_X))
-                rsize = min_t(unsigned int, CIFSMaxBufSize, rsize);
-
-        /* hard limit of CIFS_MAX_RSIZE */
-        rsize = min_t(unsigned int, rsize, CIFS_MAX_RSIZE);
-
-        return rsize;
-}
-
-static void
-cifs_qfs_tcon(const unsigned int xid, struct cifs_tcon *tcon)
-{
-        CIFSSMBQFSDeviceInfo(xid, tcon);
-        CIFSSMBQFSAttributeInfo(xid, tcon);
-}
-
-static int
-cifs_is_path_accessible(const unsigned int xid, struct cifs_tcon *tcon,
-                        struct cifs_sb_info *cifs_sb, const char *full_path)
-{
-        int rc;
-        FILE_ALL_INFO *file_info;
-
-        file_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
-        if (file_info == NULL)
-                return -ENOMEM;
-
-        rc = CIFSSMBQPathInfo(xid, tcon, full_path, file_info,
-                              0 /* not legacy */, cifs_sb->local_nls,
-                              cifs_sb->mnt_cifs_flags &
-                                CIFS_MOUNT_MAP_SPECIAL_CHR);
-
-        if (rc == -EOPNOTSUPP || rc == -EINVAL)
-                rc = SMBQueryInformation(xid, tcon, full_path, file_info,
-                                cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
-                                  CIFS_MOUNT_MAP_SPECIAL_CHR);
-        kfree(file_info);
-        return rc;
-}
-
-static int
-cifs_query_path_info(const unsigned int xid, struct cifs_tcon *tcon,
-                     struct cifs_sb_info *cifs_sb, const char *full_path,
-                     FILE_ALL_INFO *data, bool *adjustTZ)
-{
-        int rc;
-
-        /* could do find first instead but this returns more info */
-        rc = CIFSSMBQPathInfo(xid, tcon, full_path, data, 0 /* not legacy */,
-                              cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
-                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
-        /*
-         * BB optimize code so we do not make the above call when server claims
-         * no NT SMB support and the above call failed at least once - set flag
-         * in tcon or mount.
-         */
-        if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
-                rc = SMBQueryInformation(xid, tcon, full_path, data,
-                                         cifs_sb->local_nls,
-                                         cifs_sb->mnt_cifs_flags &
-                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
-                *adjustTZ = true;
-        }
-        return rc;
-}
-
-static int
-cifs_get_srv_inum(const unsigned int xid, struct cifs_tcon *tcon,
-                  struct cifs_sb_info *cifs_sb, const char *full_path,
-                  u64 *uniqueid, FILE_ALL_INFO *data)
-{
-        /*
-         * We can not use the IndexNumber field by default from Windows or
-         * Samba (in ALL_INFO buf) but we can request it explicitly. The SNIA
-         * CIFS spec claims that this value is unique within the scope of a
-         * share, and the windows docs hint that it's actually unique
-         * per-machine.
-         *
-         * There may be higher info levels that work but are there Windows
-         * server or network appliances for which IndexNumber field is not
-         * guaranteed unique?
-         */
-        return CIFSGetSrvInodeNumber(xid, tcon, full_path, uniqueid,
-                                     cifs_sb->local_nls,
-                                     cifs_sb->mnt_cifs_flags &
-                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
-}
-
-static int
-cifs_query_file_info(const unsigned int xid, struct cifs_tcon *tcon,
-                     struct cifs_fid *fid, FILE_ALL_INFO *data)
-{
-        return CIFSSMBQFileInfo(xid, tcon, fid->netfid, data);
-}
-
-static void
-cifs_clear_stats(struct cifs_tcon *tcon)
-{
-#ifdef CONFIG_CIFS_STATS
-        atomic_set(&tcon->stats.cifs_stats.num_writes, 0);
-        atomic_set(&tcon->stats.cifs_stats.num_reads, 0);
-        atomic_set(&tcon->stats.cifs_stats.num_flushes, 0);
-        atomic_set(&tcon->stats.cifs_stats.num_oplock_brks, 0);
-        atomic_set(&tcon->stats.cifs_stats.num_opens, 0);
-        atomic_set(&tcon->stats.cifs_stats.num_posixopens, 0);
-        atomic_set(&tcon->stats.cifs_stats.num_posixmkdirs, 0);
-        atomic_set(&tcon->stats.cifs_stats.num_closes, 0);
-        atomic_set(&tcon->stats.cifs_stats.num_deletes, 0);
-        atomic_set(&tcon->stats.cifs_stats.num_mkdirs, 0);
-        atomic_set(&tcon->stats.cifs_stats.num_rmdirs, 0);
-        atomic_set(&tcon->stats.cifs_stats.num_renames, 0);
-        atomic_set(&tcon->stats.cifs_stats.num_t2renames, 0);
-        atomic_set(&tcon->stats.cifs_stats.num_ffirst, 0);
-        atomic_set(&tcon->stats.cifs_stats.num_fnext, 0);
-        atomic_set(&tcon->stats.cifs_stats.num_fclose, 0);
-        atomic_set(&tcon->stats.cifs_stats.num_hardlinks, 0);
-        atomic_set(&tcon->stats.cifs_stats.num_symlinks, 0);
-        atomic_set(&tcon->stats.cifs_stats.num_locks, 0);
-        atomic_set(&tcon->stats.cifs_stats.num_acl_get, 0);
-        atomic_set(&tcon->stats.cifs_stats.num_acl_set, 0);
-#endif
-}
-
-static void
-cifs_print_stats(struct seq_file *m, struct cifs_tcon *tcon)
-{
-#ifdef CONFIG_CIFS_STATS
-        seq_printf(m, " Oplocks breaks: %d",
-                   atomic_read(&tcon->stats.cifs_stats.num_oplock_brks));
-        seq_printf(m, "\nReads:  %d Bytes: %llu",
-                   atomic_read(&tcon->stats.cifs_stats.num_reads),
-                   (long long)(tcon->bytes_read));
-        seq_printf(m, "\nWrites: %d Bytes: %llu",
-                   atomic_read(&tcon->stats.cifs_stats.num_writes),
-                   (long long)(tcon->bytes_written));
-        seq_printf(m, "\nFlushes: %d",
-                   atomic_read(&tcon->stats.cifs_stats.num_flushes));
-        seq_printf(m, "\nLocks: %d HardLinks: %d Symlinks: %d",
-                   atomic_read(&tcon->stats.cifs_stats.num_locks),
-                   atomic_read(&tcon->stats.cifs_stats.num_hardlinks),
-                   atomic_read(&tcon->stats.cifs_stats.num_symlinks));
-        seq_printf(m, "\nOpens: %d Closes: %d Deletes: %d",
-                   atomic_read(&tcon->stats.cifs_stats.num_opens),
-                   atomic_read(&tcon->stats.cifs_stats.num_closes),
-                   atomic_read(&tcon->stats.cifs_stats.num_deletes));
-        seq_printf(m, "\nPosix Opens: %d Posix Mkdirs: %d",
-                   atomic_read(&tcon->stats.cifs_stats.num_posixopens),
-                   atomic_read(&tcon->stats.cifs_stats.num_posixmkdirs));
-        seq_printf(m, "\nMkdirs: %d Rmdirs: %d",
-                   atomic_read(&tcon->stats.cifs_stats.num_mkdirs),
-                   atomic_read(&tcon->stats.cifs_stats.num_rmdirs));
-        seq_printf(m, "\nRenames: %d T2 Renames %d",
-                   atomic_read(&tcon->stats.cifs_stats.num_renames),
-                   atomic_read(&tcon->stats.cifs_stats.num_t2renames));
-        seq_printf(m, "\nFindFirst: %d FNext %d FClose %d",
-                   atomic_read(&tcon->stats.cifs_stats.num_ffirst),
-                   atomic_read(&tcon->stats.cifs_stats.num_fnext),
-                   atomic_read(&tcon->stats.cifs_stats.num_fclose));
-#endif
-}
-
-static void
-cifs_mkdir_setinfo(struct inode *inode, const char *full_path,
-                   struct cifs_sb_info *cifs_sb, struct cifs_tcon *tcon,
-                   const unsigned int xid)
-{
-        FILE_BASIC_INFO info;
-        struct cifsInodeInfo *cifsInode;
-        u32 dosattrs;
-        int rc;
-
-        memset(&info, 0, sizeof(info));
-        cifsInode = CIFS_I(inode);
-        dosattrs = cifsInode->cifsAttrs|ATTR_READONLY;
-        info.Attributes = cpu_to_le32(dosattrs);
-        rc = CIFSSMBSetPathInfo(xid, tcon, full_path, &info, cifs_sb->local_nls,
-                                cifs_sb->mnt_cifs_flags &
-                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
-        if (rc == 0)
-                cifsInode->cifsAttrs = dosattrs;
-}
-
-static int
-cifs_open_file(const unsigned int xid, struct cifs_tcon *tcon, const char *path,
-               int disposition, int desired_access, int create_options,
-               struct cifs_fid *fid, __u32 *oplock, FILE_ALL_INFO *buf,
-               struct cifs_sb_info *cifs_sb)
-{
-        if (!(tcon->ses->capabilities & CAP_NT_SMBS))
-                return SMBLegacyOpen(xid, tcon, path, disposition,
-                                     desired_access, create_options,
-                                     &fid->netfid, oplock, buf,
-                                     cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
-                                                & CIFS_MOUNT_MAP_SPECIAL_CHR);
-        return CIFSSMBOpen(xid, tcon, path, disposition, desired_access,
-                           create_options, &fid->netfid, oplock, buf,
-                           cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
-                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
-}
-
-static void
-cifs_set_fid(struct cifsFileInfo *cfile, struct cifs_fid *fid, __u32 oplock)
-{
-        struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
-        cfile->fid.netfid = fid->netfid;
-        cifs_set_oplock_level(cinode, oplock);
-        cinode->can_cache_brlcks = cinode->clientCanCacheAll;
-}
-
-static void
-cifs_close_file(const unsigned int xid, struct cifs_tcon *tcon,
-                struct cifs_fid *fid)
-{
-        CIFSSMBClose(xid, tcon, fid->netfid);
-}
-
-static int
-cifs_flush_file(const unsigned int xid, struct cifs_tcon *tcon,
-                struct cifs_fid *fid)
-{
-        return CIFSSMBFlush(xid, tcon, fid->netfid);
-}
-
-static int
-cifs_sync_read(const unsigned int xid, struct cifsFileInfo *cfile,
-               struct cifs_io_parms *parms, unsigned int *bytes_read,
-               char **buf, int *buf_type)
-{
-        parms->netfid = cfile->fid.netfid;
-        return CIFSSMBRead(xid, parms, bytes_read, buf, buf_type);
-}
-
-static int
-cifs_sync_write(const unsigned int xid, struct cifsFileInfo *cfile,
-                struct cifs_io_parms *parms, unsigned int *written,
-                struct kvec *iov, unsigned long nr_segs)
-{
-
-        parms->netfid = cfile->fid.netfid;
-        return CIFSSMBWrite2(xid, parms, written, iov, nr_segs);
-}
-
-static int
-smb_set_file_info(struct inode *inode, const char *full_path,
-                  FILE_BASIC_INFO *buf, const unsigned int xid)
-{
-        int oplock = 0;
-        int rc;
-        __u16 netfid;
-        __u32 netpid;
-        struct cifsFileInfo *open_file;
-        struct cifsInodeInfo *cinode = CIFS_I(inode);
-        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
-        struct tcon_link *tlink = NULL;
-        struct cifs_tcon *tcon;
-
-        /* if the file is already open for write, just use that fileid */
-        open_file = find_writable_file(cinode, true);
-        if (open_file) {
-                netfid = open_file->fid.netfid;
-                netpid = open_file->pid;
-                tcon = tlink_tcon(open_file->tlink);
-                goto set_via_filehandle;
-        }
-
-        tlink = cifs_sb_tlink(cifs_sb);
-        if (IS_ERR(tlink)) {
-                rc = PTR_ERR(tlink);
-                tlink = NULL;
-                goto out;
-        }
-        tcon = tlink_tcon(tlink);
-
-        /*
-         * NT4 apparently returns success on this call, but it doesn't really
-         * work.
-         */
-        if (!(tcon->ses->flags & CIFS_SES_NT4)) {
-                rc = CIFSSMBSetPathInfo(xid, tcon, full_path, buf,
-                                        cifs_sb->local_nls,
-                                        cifs_sb->mnt_cifs_flags &
-                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
-                if (rc == 0) {
-                        cinode->cifsAttrs = le32_to_cpu(buf->Attributes);
-                        goto out;
-                } else if (rc != -EOPNOTSUPP && rc != -EINVAL)
-                        goto out;
-        }
-
-        cFYI(1, "calling SetFileInfo since SetPathInfo for times not supported "
-                "by this server");
-        rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
-                         SYNCHRONIZE | FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
-                         &netfid, &oplock, NULL, cifs_sb->local_nls,
-                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
-
-        if (rc != 0) {
-                if (rc == -EIO)
-                        rc = -EINVAL;
-                goto out;
-        }
-
-        netpid = current->tgid;
-
-set_via_filehandle:
-        rc = CIFSSMBSetFileInfo(xid, tcon, buf, netfid, netpid);
-        if (!rc)
-                cinode->cifsAttrs = le32_to_cpu(buf->Attributes);
-
-        if (open_file == NULL)
-                CIFSSMBClose(xid, tcon, netfid);
-        else
-                cifsFileInfo_put(open_file);
-out:
-        if (tlink != NULL)
-                cifs_put_tlink(tlink);
-        return rc;
-}
-
-static int
-cifs_query_dir_first(const unsigned int xid, struct cifs_tcon *tcon,
-                     const char *path, struct cifs_sb_info *cifs_sb,
-                     struct cifs_fid *fid, __u16 search_flags,
-                     struct cifs_search_info *srch_inf)
-{
-        return CIFSFindFirst(xid, tcon, path, cifs_sb,
-                             &fid->netfid, search_flags, srch_inf, true);
-}
-
-static int
-cifs_query_dir_next(const unsigned int xid, struct cifs_tcon *tcon,
-                    struct cifs_fid *fid, __u16 search_flags,
-                    struct cifs_search_info *srch_inf)
-{
-        return CIFSFindNext(xid, tcon, fid->netfid, search_flags, srch_inf);
-}
-
-static int
-cifs_close_dir(const unsigned int xid, struct cifs_tcon *tcon,
-               struct cifs_fid *fid)
-{
-        return CIFSFindClose(xid, tcon, fid->netfid);
-}
-
-static int
-cifs_oplock_response(struct cifs_tcon *tcon, struct cifs_fid *fid,
-                     struct cifsInodeInfo *cinode)
-{
-        return CIFSSMBLock(0, tcon, fid->netfid, current->tgid, 0, 0, 0, 0,
-                           LOCKING_ANDX_OPLOCK_RELEASE, false,
-                           cinode->clientCanCacheRead ? 1 : 0);
-}
-
-static int
-cifs_queryfs(const unsigned int xid, struct cifs_tcon *tcon,
-             struct kstatfs *buf)
-{
-        int rc = -EOPNOTSUPP;
-
-        buf->f_type = CIFS_MAGIC_NUMBER;
-
-        /*
-         * 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);
-        return rc;
-}
-
-static int
-cifs_mand_lock(const unsigned int xid, struct cifsFileInfo *cfile, __u64 offset,
-               __u64 length, __u32 type, int lock, int unlock, bool wait)
-{
-        return CIFSSMBLock(xid, tlink_tcon(cfile->tlink), cfile->fid.netfid,
-                           current->tgid, length, offset, unlock, lock,
-                           (__u8)type, wait, 0);
-}
-
-struct smb_version_operations smb1_operations = {
-        .send_cancel = send_nt_cancel,
-        .compare_fids = cifs_compare_fids,
-        .setup_request = cifs_setup_request,
-        .setup_async_request = cifs_setup_async_request,
-        .check_receive = cifs_check_receive,
-        .add_credits = cifs_add_credits,
-        .set_credits = cifs_set_credits,
-        .get_credits_field = cifs_get_credits_field,
-        .get_credits = cifs_get_credits,
-        .get_next_mid = cifs_get_next_mid,
-        .read_data_offset = cifs_read_data_offset,
-        .read_data_length = cifs_read_data_length,
-        .map_error = map_smb_to_linux_error,
-        .find_mid = cifs_find_mid,
-        .check_message = checkSMB,
-        .dump_detail = cifs_dump_detail,
-        .clear_stats = cifs_clear_stats,
-        .print_stats = cifs_print_stats,
-        .is_oplock_break = is_valid_oplock_break,
-        .check_trans2 = cifs_check_trans2,
-        .need_neg = cifs_need_neg,
-        .negotiate = cifs_negotiate,
-        .negotiate_wsize = cifs_negotiate_wsize,
-        .negotiate_rsize = cifs_negotiate_rsize,
-        .sess_setup = CIFS_SessSetup,
-        .logoff = CIFSSMBLogoff,
-        .tree_connect = CIFSTCon,
-        .tree_disconnect = CIFSSMBTDis,
-        .get_dfs_refer = CIFSGetDFSRefer,
-        .qfs_tcon = cifs_qfs_tcon,
-        .is_path_accessible = cifs_is_path_accessible,
-        .query_path_info = cifs_query_path_info,
-        .query_file_info = cifs_query_file_info,
-        .get_srv_inum = cifs_get_srv_inum,
-        .set_path_size = CIFSSMBSetEOF,
-        .set_file_size = CIFSSMBSetFileSize,
-        .set_file_info = smb_set_file_info,
-        .echo = CIFSSMBEcho,
-        .mkdir = CIFSSMBMkDir,
-        .mkdir_setinfo = cifs_mkdir_setinfo,
-        .rmdir = CIFSSMBRmDir,
-        .unlink = CIFSSMBDelFile,
-        .rename_pending_delete = cifs_rename_pending_delete,
-        .rename = CIFSSMBRename,
-        .create_hardlink = CIFSCreateHardLink,
-        .open = cifs_open_file,
-        .set_fid = cifs_set_fid,
-        .close = cifs_close_file,
-        .flush = cifs_flush_file,
-        .async_readv = cifs_async_readv,
-        .async_writev = cifs_async_writev,
-        .sync_read = cifs_sync_read,
-        .sync_write = cifs_sync_write,
-        .query_dir_first = cifs_query_dir_first,
-        .query_dir_next = cifs_query_dir_next,
-        .close_dir = cifs_close_dir,
-        .calc_smb_size = smbCalcSize,
-        .oplock_response = cifs_oplock_response,
-        .queryfs = cifs_queryfs,
-        .mand_lock = cifs_mand_lock,
-        .mand_unlock_range = cifs_unlock_range,
-        .push_mand_locks = cifs_push_mandatory_locks,
-};
-
-struct smb_version_values smb1_values = {
-        .version_string = SMB1_VERSION_STRING,
-        .large_lock_type = LOCKING_ANDX_LARGE_FILES,
-        .exclusive_lock_type = 0,
-        .shared_lock_type = LOCKING_ANDX_SHARED_LOCK,
-        .unlock_lock_type = 0,
-        .header_size = sizeof(struct smb_hdr),
-        .max_header_size = MAX_CIFS_HDR_SIZE,
-        .read_rsp_size = sizeof(READ_RSP),
-        .lock_cmd = cpu_to_le16(SMB_COM_LOCKING_ANDX),
-        .cap_unix = CAP_UNIX,
-        .cap_nt_find = CAP_NT_SMBS | CAP_NT_FIND,
-        .cap_large_files = CAP_LARGE_FILES,
-        .oplock_read = OPLOCK_READ,
-};
diff --git a/fs/cifs/smb2file.c b/fs/cifs/smb2file.c
deleted file mode 100644
index 71e6aed4b38..00000000000
--- a/fs/cifs/smb2file.c
+++ /dev/null
@@ -1,290 +0,0 @@
-/*
- *   fs/cifs/smb2file.c
- *
- *   Copyright (C) International Business Machines  Corp., 2002, 2011
- *   Author(s): Steve French (sfrench@us.ibm.com),
- *              Pavel Shilovsky ((pshilovsky@samba.org) 2012
- *
- *   This library is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU Lesser General Public License as published
- *   by the Free Software Foundation; either version 2.1 of the License, or
- *   (at your option) any later version.
- *
- *   This library is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
- *   the GNU Lesser General Public License for more details.
- *
- *   You should have received a copy of the GNU Lesser General Public License
- *   along with this library; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-#include <linux/fs.h>
-#include <linux/stat.h>
-#include <linux/slab.h>
-#include <linux/pagemap.h>
-#include <asm/div64.h>
-#include "cifsfs.h"
-#include "cifspdu.h"
-#include "cifsglob.h"
-#include "cifsproto.h"
-#include "cifs_debug.h"
-#include "cifs_fs_sb.h"
-#include "cifs_unicode.h"
-#include "fscache.h"
-#include "smb2proto.h"
-
-void
-smb2_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock)
-{
-        oplock &= 0xFF;
-        if (oplock == SMB2_OPLOCK_LEVEL_NOCHANGE)
-                return;
-        if (oplock == SMB2_OPLOCK_LEVEL_EXCLUSIVE) {
-                cinode->clientCanCacheAll = true;
-                cinode->clientCanCacheRead = true;
-                cFYI(1, "Exclusive Oplock granted on inode %p",
-                     &cinode->vfs_inode);
-        } else if (oplock == SMB2_OPLOCK_LEVEL_II) {
-                cinode->clientCanCacheAll = false;
-                cinode->clientCanCacheRead = true;
-                cFYI(1, "Level II Oplock granted on inode %p",
-                    &cinode->vfs_inode);
-        } else {
-                cinode->clientCanCacheAll = false;
-                cinode->clientCanCacheRead = false;
-        }
-}
-
-int
-smb2_open_file(const unsigned int xid, struct cifs_tcon *tcon, const char *path,
-               int disposition, int desired_access, int create_options,
-               struct cifs_fid *fid, __u32 *oplock, FILE_ALL_INFO *buf,
-               struct cifs_sb_info *cifs_sb)
-{
-        int rc;
-        __le16 *smb2_path;
-        struct smb2_file_all_info *smb2_data = NULL;
-        __u8 smb2_oplock[17];
-
-        smb2_path = cifs_convert_path_to_utf16(path, cifs_sb);
-        if (smb2_path == NULL) {
-                rc = -ENOMEM;
-                goto out;
-        }
-
-        smb2_data = kzalloc(sizeof(struct smb2_file_all_info) + MAX_NAME * 2,
-                            GFP_KERNEL);
-        if (smb2_data == NULL) {
-                rc = -ENOMEM;
-                goto out;
-        }
-
-        desired_access |= FILE_READ_ATTRIBUTES;
-        *smb2_oplock = SMB2_OPLOCK_LEVEL_EXCLUSIVE;
-
-        if (tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_LEASING)
-                memcpy(smb2_oplock + 1, fid->lease_key, SMB2_LEASE_KEY_SIZE);
-
-        rc = SMB2_open(xid, tcon, smb2_path, &fid->persistent_fid,
-                       &fid->volatile_fid, desired_access, disposition,
-                       0, 0, smb2_oplock, smb2_data);
-        if (rc)
-                goto out;
-
-        if (buf) {
-                /* open response does not have IndexNumber field - get it */
-                rc = SMB2_get_srv_num(xid, tcon, fid->persistent_fid,
-                                      fid->volatile_fid,
-                                      &smb2_data->IndexNumber);
-                if (rc) {
-                        /* let get_inode_info disable server inode numbers */
-                        smb2_data->IndexNumber = 0;
-                        rc = 0;
-                }
-                move_smb2_info_to_cifs(buf, smb2_data);
-        }
-
-        *oplock = *smb2_oplock;
-out:
-        kfree(smb2_data);
-        kfree(smb2_path);
-        return rc;
-}
-
-int
-smb2_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
-                  const unsigned int xid)
-{
-        int rc = 0, stored_rc;
-        unsigned int max_num, num = 0, max_buf;
-        struct smb2_lock_element *buf, *cur;
-        struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
-        struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
-        struct cifsLockInfo *li, *tmp;
-        __u64 length = 1 + flock->fl_end - flock->fl_start;
-        struct list_head tmp_llist;
-
-        INIT_LIST_HEAD(&tmp_llist);
-
-        /*
-         * Accessing maxBuf is racy with cifs_reconnect - need to store value
-         * and check it for zero before using.
-         */
-        max_buf = tcon->ses->server->maxBuf;
-        if (!max_buf)
-                return -EINVAL;
-
-        max_num = max_buf / sizeof(struct smb2_lock_element);
-        buf = kzalloc(max_num * sizeof(struct smb2_lock_element), GFP_KERNEL);
-        if (!buf)
-                return -ENOMEM;
-
-        cur = buf;
-
-        down_write(&cinode->lock_sem);
-        list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
-                if (flock->fl_start > li->offset ||
-                    (flock->fl_start + length) <
-                    (li->offset + li->length))
-                        continue;
-                if (current->tgid != li->pid)
-                        continue;
-                if (cinode->can_cache_brlcks) {
-                        /*
-                         * We can cache brlock requests - simply remove a lock
-                         * from the file's list.
-                         */
-                        list_del(&li->llist);
-                        cifs_del_lock_waiters(li);
-                        kfree(li);
-                        continue;
-                }
-                cur->Length = cpu_to_le64(li->length);
-                cur->Offset = cpu_to_le64(li->offset);
-                cur->Flags = cpu_to_le32(SMB2_LOCKFLAG_UNLOCK);
-                /*
-                 * We need to save a lock here to let us add it again to the
-                 * file's list if the unlock range request fails on the server.
-                 */
-                list_move(&li->llist, &tmp_llist);
-                if (++num == max_num) {
-                        stored_rc = smb2_lockv(xid, tcon,
-                                               cfile->fid.persistent_fid,
-                                               cfile->fid.volatile_fid,
-                                               current->tgid, num, buf);
-                        if (stored_rc) {
-                                /*
-                                 * We failed on the unlock range request - add
-                                 * all locks from the tmp list to the head of
-                                 * the file's list.
-                                 */
-                                cifs_move_llist(&tmp_llist,
-                                                &cfile->llist->locks);
-                                rc = stored_rc;
-                        } else
-                                /*
-                                 * The unlock range request succeed - free the
-                                 * tmp list.
-                                 */
-                                cifs_free_llist(&tmp_llist);
-                        cur = buf;
-                        num = 0;
-                } else
-                        cur++;
-        }
-        if (num) {
-                stored_rc = smb2_lockv(xid, tcon, cfile->fid.persistent_fid,
-                                       cfile->fid.volatile_fid, current->tgid,
-                                       num, buf);
-                if (stored_rc) {
-                        cifs_move_llist(&tmp_llist, &cfile->llist->locks);
-                        rc = stored_rc;
-                } else
-                        cifs_free_llist(&tmp_llist);
-        }
-        up_write(&cinode->lock_sem);
-
-        kfree(buf);
-        return rc;
-}
-
-static int
-smb2_push_mand_fdlocks(struct cifs_fid_locks *fdlocks, const unsigned int xid,
-                       struct smb2_lock_element *buf, unsigned int max_num)
-{
-        int rc = 0, stored_rc;
-        struct cifsFileInfo *cfile = fdlocks->cfile;
-        struct cifsLockInfo *li;
-        unsigned int num = 0;
-        struct smb2_lock_element *cur = buf;
-        struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
-
-        list_for_each_entry(li, &fdlocks->locks, llist) {
-                cur->Length = cpu_to_le64(li->length);
-                cur->Offset = cpu_to_le64(li->offset);
-                cur->Flags = cpu_to_le32(li->type |
-                                                SMB2_LOCKFLAG_FAIL_IMMEDIATELY);
-                if (++num == max_num) {
-                        stored_rc = smb2_lockv(xid, tcon,
-                                               cfile->fid.persistent_fid,
-                                               cfile->fid.volatile_fid,
-                                               current->tgid, num, buf);
-                        if (stored_rc)
-                                rc = stored_rc;
-                        cur = buf;
-                        num = 0;
-                } else
-                        cur++;
-        }
-        if (num) {
-                stored_rc = smb2_lockv(xid, tcon,
-                                       cfile->fid.persistent_fid,
-                                       cfile->fid.volatile_fid,
-                                       current->tgid, num, buf);
-                if (stored_rc)
-                        rc = stored_rc;
-        }
-
-        return rc;
-}
-
-int
-smb2_push_mandatory_locks(struct cifsFileInfo *cfile)
-{
-        int rc = 0, stored_rc;
-        unsigned int xid;
-        unsigned int max_num, max_buf;
-        struct smb2_lock_element *buf;
-        struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
-        struct cifs_fid_locks *fdlocks;
-
-        xid = get_xid();
-
-        /*
-         * Accessing maxBuf is racy with cifs_reconnect - need to store value
-         * and check it for zero before using.
-         */
-        max_buf = tlink_tcon(cfile->tlink)->ses->server->maxBuf;
-        if (!max_buf) {
-                free_xid(xid);
-                return -EINVAL;
-        }
-
-        max_num = max_buf / sizeof(struct smb2_lock_element);
-        buf = kzalloc(max_num * sizeof(struct smb2_lock_element), GFP_KERNEL);
-        if (!buf) {
-                free_xid(xid);
-                return -ENOMEM;
-        }
-
-        list_for_each_entry(fdlocks, &cinode->llist, llist) {
-                stored_rc = smb2_push_mand_fdlocks(fdlocks, xid, buf, max_num);
-                if (stored_rc)
-                        rc = stored_rc;
-        }
-
-        kfree(buf);
-        free_xid(xid);
-        return rc;
-}
diff --git a/fs/cifs/smb2glob.h b/fs/cifs/smb2glob.h
deleted file mode 100644
index 7c0e2143e77..00000000000
--- a/fs/cifs/smb2glob.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- *   fs/cifs/smb2glob.h
- *
- *   Definitions for various global variables and structures
- *
- *   Copyright (C) International Business Machines  Corp., 2002, 2011
- *                 Etersoft, 2012
- *   Author(s): Steve French (sfrench@us.ibm.com)
- *              Jeremy Allison (jra@samba.org)
- *              Pavel Shilovsky (pshilovsky@samba.org) 2012
- *
- *   This library is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU Lesser General Public License as published
- *   by the Free Software Foundation; either version 2.1 of the License, or
- *   (at your option) any later version.
- *
- *   This library is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
- *   the GNU Lesser General Public License for more details.
- *
- */
-#ifndef _SMB2_GLOB_H
-#define _SMB2_GLOB_H
-
-#define SMB2_MAGIC_NUMBER 0xFE534D42
-
-/*
- *****************************************************************
- * Constants go here
- *****************************************************************
- */
-
-/*
- * Identifiers for functions that use the open, operation, close pattern
- * in smb2inode.c:smb2_open_op_close()
- */
-#define SMB2_OP_SET_DELETE 1
-#define SMB2_OP_SET_INFO 2
-#define SMB2_OP_QUERY_INFO 3
-#define SMB2_OP_QUERY_DIR 4
-#define SMB2_OP_MKDIR 5
-#define SMB2_OP_RENAME 6
-#define SMB2_OP_DELETE 7
-#define SMB2_OP_HARDLINK 8
-#define SMB2_OP_SET_EOF 9
-
-/* Used when constructing chained read requests. */
-#define CHAINED_REQUEST 1
-#define START_OF_CHAIN 2
-#define END_OF_CHAIN 4
-#define RELATED_REQUEST 8
-
-#define SMB2_SIGNATURE_SIZE (16)
-#define SMB2_NTLMV2_SESSKEY_SIZE (16)
-#define SMB2_HMACSHA256_SIZE (32)
-
-#endif  /* _SMB2_GLOB_H */
diff --git a/fs/cifs/smb2inode.c b/fs/cifs/smb2inode.c
deleted file mode 100644
index 706482452df..00000000000
--- a/fs/cifs/smb2inode.c
+++ /dev/null
@@ -1,257 +0,0 @@
-/*
- *   fs/cifs/smb2inode.c
- *
- *   Copyright (C) International Business Machines  Corp., 2002, 2011
- *                 Etersoft, 2012
- *   Author(s): Pavel Shilovsky (pshilovsky@samba.org),
- *              Steve French (sfrench@us.ibm.com)
- *
- *   This library is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU Lesser General Public License as published
- *   by the Free Software Foundation; either version 2.1 of the License, or
- *   (at your option) any later version.
- *
- *   This library is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
- *   the GNU Lesser General Public License for more details.
- *
- *   You should have received a copy of the GNU Lesser General Public License
- *   along with this library; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-#include <linux/fs.h>
-#include <linux/stat.h>
-#include <linux/slab.h>
-#include <linux/pagemap.h>
-#include <asm/div64.h>
-#include "cifsfs.h"
-#include "cifspdu.h"
-#include "cifsglob.h"
-#include "cifsproto.h"
-#include "cifs_debug.h"
-#include "cifs_fs_sb.h"
-#include "cifs_unicode.h"
-#include "fscache.h"
-#include "smb2glob.h"
-#include "smb2pdu.h"
-#include "smb2proto.h"
-
-static int
-smb2_open_op_close(const unsigned int xid, struct cifs_tcon *tcon,
-                   struct cifs_sb_info *cifs_sb, const char *full_path,
-                   __u32 desired_access, __u32 create_disposition,
-                   __u32 file_attributes, __u32 create_options,
-                   void *data, int command)
-{
-        int rc, tmprc = 0;
-        u64 persistent_fid, volatile_fid;
-        __le16 *utf16_path;
-        __u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
-
-        utf16_path = cifs_convert_path_to_utf16(full_path, cifs_sb);
-        if (!utf16_path)
-                return -ENOMEM;
-
-        rc = SMB2_open(xid, tcon, utf16_path, &persistent_fid, &volatile_fid,
-                       desired_access, create_disposition, file_attributes,
-                       create_options, &oplock, NULL);
-        if (rc) {
-                kfree(utf16_path);
-                return rc;
-        }
-
-        switch (command) {
-        case SMB2_OP_DELETE:
-                break;
-        case SMB2_OP_QUERY_INFO:
-                tmprc = SMB2_query_info(xid, tcon, persistent_fid,
-                                        volatile_fid,
-                                        (struct smb2_file_all_info *)data);
-                break;
-        case SMB2_OP_MKDIR:
-                /*
-                 * Directories are created through parameters in the
-                 * SMB2_open() call.
-                 */
-                break;
-        case SMB2_OP_RENAME:
-                tmprc = SMB2_rename(xid, tcon, persistent_fid, volatile_fid,
-                                    (__le16 *)data);
-                break;
-        case SMB2_OP_HARDLINK:
-                tmprc = SMB2_set_hardlink(xid, tcon, persistent_fid,
-                                          volatile_fid, (__le16 *)data);
-                break;
-        case SMB2_OP_SET_EOF:
-                tmprc = SMB2_set_eof(xid, tcon, persistent_fid, volatile_fid,
-                                     current->tgid, (__le64 *)data);
-                break;
-        case SMB2_OP_SET_INFO:
-                tmprc = SMB2_set_info(xid, tcon, persistent_fid, volatile_fid,
-                                      (FILE_BASIC_INFO *)data);
-                break;
-        default:
-                cERROR(1, "Invalid command");
-                break;
-        }
-
-        rc = SMB2_close(xid, tcon, persistent_fid, volatile_fid);
-        if (tmprc)
-                rc = tmprc;
-        kfree(utf16_path);
-        return rc;
-}
-
-void
-move_smb2_info_to_cifs(FILE_ALL_INFO *dst, struct smb2_file_all_info *src)
-{
-        memcpy(dst, src, (size_t)(&src->CurrentByteOffset) - (size_t)src);
-        dst->CurrentByteOffset = src->CurrentByteOffset;
-        dst->Mode = src->Mode;
-        dst->AlignmentRequirement = src->AlignmentRequirement;
-        dst->IndexNumber1 = 0; /* we don't use it */
-}
-
-int
-smb2_query_path_info(const unsigned int xid, struct cifs_tcon *tcon,
-                     struct cifs_sb_info *cifs_sb, const char *full_path,
-                     FILE_ALL_INFO *data, bool *adjust_tz)
-{
-        int rc;
-        struct smb2_file_all_info *smb2_data;
-
-        *adjust_tz = false;
-
-        smb2_data = kzalloc(sizeof(struct smb2_file_all_info) + MAX_NAME * 2,
-                            GFP_KERNEL);
-        if (smb2_data == NULL)
-                return -ENOMEM;
-
-        rc = smb2_open_op_close(xid, tcon, cifs_sb, full_path,
-                                FILE_READ_ATTRIBUTES, FILE_OPEN, 0, 0,
-                                smb2_data, SMB2_OP_QUERY_INFO);
-        if (rc)
-                goto out;
-
-        move_smb2_info_to_cifs(data, smb2_data);
-out:
-        kfree(smb2_data);
-        return rc;
-}
-
-int
-smb2_mkdir(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
-           struct cifs_sb_info *cifs_sb)
-{
-        return smb2_open_op_close(xid, tcon, cifs_sb, name,
-                                  FILE_WRITE_ATTRIBUTES, FILE_CREATE, 0,
-                                  CREATE_NOT_FILE, NULL, SMB2_OP_MKDIR);
-}
-
-void
-smb2_mkdir_setinfo(struct inode *inode, const char *name,
-                   struct cifs_sb_info *cifs_sb, struct cifs_tcon *tcon,
-                   const unsigned int xid)
-{
-        FILE_BASIC_INFO data;
-        struct cifsInodeInfo *cifs_i;
-        u32 dosattrs;
-        int tmprc;
-
-        memset(&data, 0, sizeof(data));
-        cifs_i = CIFS_I(inode);
-        dosattrs = cifs_i->cifsAttrs | ATTR_READONLY;
-        data.Attributes = cpu_to_le32(dosattrs);
-        tmprc = smb2_open_op_close(xid, tcon, cifs_sb, name,
-                                   FILE_WRITE_ATTRIBUTES, FILE_CREATE, 0,
-                                   CREATE_NOT_FILE, &data, SMB2_OP_SET_INFO);
-        if (tmprc == 0)
-                cifs_i->cifsAttrs = dosattrs;
-}
-
-int
-smb2_rmdir(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
-           struct cifs_sb_info *cifs_sb)
-{
-        return smb2_open_op_close(xid, tcon, cifs_sb, name, DELETE, FILE_OPEN,
-                                  0, CREATE_NOT_FILE | CREATE_DELETE_ON_CLOSE,
-                                  NULL, SMB2_OP_DELETE);
-}
-
-int
-smb2_unlink(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
-            struct cifs_sb_info *cifs_sb)
-{
-        return smb2_open_op_close(xid, tcon, cifs_sb, name, DELETE, FILE_OPEN,
-                                  0, CREATE_DELETE_ON_CLOSE, NULL,
-                                  SMB2_OP_DELETE);
-}
-
-static int
-smb2_set_path_attr(const unsigned int xid, struct cifs_tcon *tcon,
-                   const char *from_name, const char *to_name,
-                   struct cifs_sb_info *cifs_sb, __u32 access, int command)
-{
-        __le16 *smb2_to_name = NULL;
-        int rc;
-
-        smb2_to_name = cifs_convert_path_to_utf16(to_name, cifs_sb);
-        if (smb2_to_name == NULL) {
-                rc = -ENOMEM;
-                goto smb2_rename_path;
-        }
-
-        rc = smb2_open_op_close(xid, tcon, cifs_sb, from_name, access,
-                                FILE_OPEN, 0, 0, smb2_to_name, command);
-smb2_rename_path:
-        kfree(smb2_to_name);
-        return rc;
-}
-
-int
-smb2_rename_path(const unsigned int xid, struct cifs_tcon *tcon,
-                 const char *from_name, const char *to_name,
-                 struct cifs_sb_info *cifs_sb)
-{
-        return smb2_set_path_attr(xid, tcon, from_name, to_name, cifs_sb,
-                                  DELETE, SMB2_OP_RENAME);
-}
-
-int
-smb2_create_hardlink(const unsigned int xid, struct cifs_tcon *tcon,
-                     const char *from_name, const char *to_name,
-                     struct cifs_sb_info *cifs_sb)
-{
-        return smb2_set_path_attr(xid, tcon, from_name, to_name, cifs_sb,
-                                  FILE_READ_ATTRIBUTES, SMB2_OP_HARDLINK);
-}
-
-int
-smb2_set_path_size(const unsigned int xid, struct cifs_tcon *tcon,
-                   const char *full_path, __u64 size,
-                   struct cifs_sb_info *cifs_sb, bool set_alloc)
-{
-        __le64 eof = cpu_to_le64(size);
-        return smb2_open_op_close(xid, tcon, cifs_sb, full_path,
-                                  FILE_WRITE_DATA, FILE_OPEN, 0, 0, &eof,
-                                  SMB2_OP_SET_EOF);
-}
-
-int
-smb2_set_file_info(struct inode *inode, const char *full_path,
-                   FILE_BASIC_INFO *buf, const unsigned int xid)
-{
-        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
-        struct tcon_link *tlink;
-        int rc;
-
-        tlink = cifs_sb_tlink(cifs_sb);
-        if (IS_ERR(tlink))
-                return PTR_ERR(tlink);
-        rc = smb2_open_op_close(xid, tlink_tcon(tlink), cifs_sb, full_path,
-                                FILE_WRITE_ATTRIBUTES, FILE_OPEN, 0, 0, buf,
-                                SMB2_OP_SET_INFO);
-        cifs_put_tlink(tlink);
-        return rc;
-}
diff --git a/fs/cifs/smb2maperror.c b/fs/cifs/smb2maperror.c
deleted file mode 100644
index 494c912c76f..00000000000
--- a/fs/cifs/smb2maperror.c
+++ /dev/null
@@ -1,2479 +0,0 @@
-/*
- *   fs/smb2/smb2maperror.c
- *
- *   Functions which do error mapping of SMB2 status codes to POSIX errors
- *
- *   Copyright (C) International Business Machines  Corp., 2009
- *   Author(s): Steve French (sfrench@us.ibm.com)
- *
- *   This library is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU Lesser General Public License as published
- *   by the Free Software Foundation; either version 2.1 of the License, or
- *   (at your option) any later version.
- *
- *   This library is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
- *   the GNU Lesser General Public License for more details.
- *
- *   You should have received a copy of the GNU Lesser General Public License
- *   along with this library; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-#include <linux/errno.h>
-#include "cifsglob.h"
-#include "cifs_debug.h"
-#include "smb2pdu.h"
-#include "smb2proto.h"
-#include "smb2status.h"
-
-struct status_to_posix_error {
-        __le32 smb2_status;
-        int posix_error;
-        char *status_string;
-};
-
-static const struct status_to_posix_error smb2_error_map_table[] = {
-        {STATUS_SUCCESS, 0, "STATUS_SUCCESS"},
-        {STATUS_WAIT_0,  0, "STATUS_WAIT_0"},
-        {STATUS_WAIT_1, -EIO, "STATUS_WAIT_1"},
-        {STATUS_WAIT_2, -EIO, "STATUS_WAIT_2"},
-        {STATUS_WAIT_3, -EIO, "STATUS_WAIT_3"},
-        {STATUS_WAIT_63, -EIO, "STATUS_WAIT_63"},
-        {STATUS_ABANDONED, -EIO, "STATUS_ABANDONED"},
-        {STATUS_ABANDONED_WAIT_0, -EIO, "STATUS_ABANDONED_WAIT_0"},
-        {STATUS_ABANDONED_WAIT_63, -EIO, "STATUS_ABANDONED_WAIT_63"},
-        {STATUS_USER_APC, -EIO, "STATUS_USER_APC"},
-        {STATUS_KERNEL_APC, -EIO, "STATUS_KERNEL_APC"},
-        {STATUS_ALERTED, -EIO, "STATUS_ALERTED"},
-        {STATUS_TIMEOUT, -ETIMEDOUT, "STATUS_TIMEOUT"},
-        {STATUS_PENDING, -EIO, "STATUS_PENDING"},
-        {STATUS_REPARSE, -EIO, "STATUS_REPARSE"},
-        {STATUS_MORE_ENTRIES, -EIO, "STATUS_MORE_ENTRIES"},
-        {STATUS_NOT_ALL_ASSIGNED, -EIO, "STATUS_NOT_ALL_ASSIGNED"},
-        {STATUS_SOME_NOT_MAPPED, -EIO, "STATUS_SOME_NOT_MAPPED"},
-        {STATUS_OPLOCK_BREAK_IN_PROGRESS, -EIO,
-        "STATUS_OPLOCK_BREAK_IN_PROGRESS"},
-        {STATUS_VOLUME_MOUNTED, -EIO, "STATUS_VOLUME_MOUNTED"},
-        {STATUS_RXACT_COMMITTED, -EIO, "STATUS_RXACT_COMMITTED"},
-        {STATUS_NOTIFY_CLEANUP, -EIO, "STATUS_NOTIFY_CLEANUP"},
-        {STATUS_NOTIFY_ENUM_DIR, -EIO, "STATUS_NOTIFY_ENUM_DIR"},
-        {STATUS_NO_QUOTAS_FOR_ACCOUNT, -EIO, "STATUS_NO_QUOTAS_FOR_ACCOUNT"},
-        {STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED, -EIO,
-        "STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED"},
-        {STATUS_PAGE_FAULT_TRANSITION, -EIO, "STATUS_PAGE_FAULT_TRANSITION"},
-        {STATUS_PAGE_FAULT_DEMAND_ZERO, -EIO, "STATUS_PAGE_FAULT_DEMAND_ZERO"},
-        {STATUS_PAGE_FAULT_COPY_ON_WRITE, -EIO,
-        "STATUS_PAGE_FAULT_COPY_ON_WRITE"},
-        {STATUS_PAGE_FAULT_GUARD_PAGE, -EIO, "STATUS_PAGE_FAULT_GUARD_PAGE"},
-        {STATUS_PAGE_FAULT_PAGING_FILE, -EIO, "STATUS_PAGE_FAULT_PAGING_FILE"},
-        {STATUS_CACHE_PAGE_LOCKED, -EIO, "STATUS_CACHE_PAGE_LOCKED"},
-        {STATUS_CRASH_DUMP, -EIO, "STATUS_CRASH_DUMP"},
-        {STATUS_BUFFER_ALL_ZEROS, -EIO, "STATUS_BUFFER_ALL_ZEROS"},
-        {STATUS_REPARSE_OBJECT, -EIO, "STATUS_REPARSE_OBJECT"},
-        {STATUS_RESOURCE_REQUIREMENTS_CHANGED, -EIO,
-        "STATUS_RESOURCE_REQUIREMENTS_CHANGED"},
-        {STATUS_TRANSLATION_COMPLETE, -EIO, "STATUS_TRANSLATION_COMPLETE"},
-        {STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY, -EIO,
-        "STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY"},
-        {STATUS_NOTHING_TO_TERMINATE, -EIO, "STATUS_NOTHING_TO_TERMINATE"},
-        {STATUS_PROCESS_NOT_IN_JOB, -EIO, "STATUS_PROCESS_NOT_IN_JOB"},
-        {STATUS_PROCESS_IN_JOB, -EIO, "STATUS_PROCESS_IN_JOB"},
-        {STATUS_VOLSNAP_HIBERNATE_READY, -EIO,
-        "STATUS_VOLSNAP_HIBERNATE_READY"},
-        {STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY, -EIO,
-        "STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY"},
-        {STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED, -EIO,
-        "STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED"},
-        {STATUS_INTERRUPT_STILL_CONNECTED, -EIO,
-        "STATUS_INTERRUPT_STILL_CONNECTED"},
-        {STATUS_PROCESS_CLONED, -EIO, "STATUS_PROCESS_CLONED"},
-        {STATUS_FILE_LOCKED_WITH_ONLY_READERS, -EIO,
-        "STATUS_FILE_LOCKED_WITH_ONLY_READERS"},
-        {STATUS_FILE_LOCKED_WITH_WRITERS, -EIO,
-        "STATUS_FILE_LOCKED_WITH_WRITERS"},
-        {STATUS_RESOURCEMANAGER_READ_ONLY, -EROFS,
-        "STATUS_RESOURCEMANAGER_READ_ONLY"},
-        {STATUS_WAIT_FOR_OPLOCK, -EIO, "STATUS_WAIT_FOR_OPLOCK"},
-        {DBG_EXCEPTION_HANDLED, -EIO, "DBG_EXCEPTION_HANDLED"},
-        {DBG_CONTINUE, -EIO, "DBG_CONTINUE"},
-        {STATUS_FLT_IO_COMPLETE, -EIO, "STATUS_FLT_IO_COMPLETE"},
-        {STATUS_OBJECT_NAME_EXISTS, -EIO, "STATUS_OBJECT_NAME_EXISTS"},
-        {STATUS_THREAD_WAS_SUSPENDED, -EIO, "STATUS_THREAD_WAS_SUSPENDED"},
-        {STATUS_WORKING_SET_LIMIT_RANGE, -EIO,
-        "STATUS_WORKING_SET_LIMIT_RANGE"},
-        {STATUS_IMAGE_NOT_AT_BASE, -EIO, "STATUS_IMAGE_NOT_AT_BASE"},
-        {STATUS_RXACT_STATE_CREATED, -EIO, "STATUS_RXACT_STATE_CREATED"},
-        {STATUS_SEGMENT_NOTIFICATION, -EIO, "STATUS_SEGMENT_NOTIFICATION"},
-        {STATUS_LOCAL_USER_SESSION_KEY, -EIO, "STATUS_LOCAL_USER_SESSION_KEY"},
-        {STATUS_BAD_CURRENT_DIRECTORY, -EIO, "STATUS_BAD_CURRENT_DIRECTORY"},
-        {STATUS_SERIAL_MORE_WRITES, -EIO, "STATUS_SERIAL_MORE_WRITES"},
-        {STATUS_REGISTRY_RECOVERED, -EIO, "STATUS_REGISTRY_RECOVERED"},
-        {STATUS_FT_READ_RECOVERY_FROM_BACKUP, -EIO,
-        "STATUS_FT_READ_RECOVERY_FROM_BACKUP"},
-        {STATUS_FT_WRITE_RECOVERY, -EIO, "STATUS_FT_WRITE_RECOVERY"},
-        {STATUS_SERIAL_COUNTER_TIMEOUT, -ETIMEDOUT,
-        "STATUS_SERIAL_COUNTER_TIMEOUT"},
-        {STATUS_NULL_LM_PASSWORD, -EIO, "STATUS_NULL_LM_PASSWORD"},
-        {STATUS_IMAGE_MACHINE_TYPE_MISMATCH, -EIO,
-        "STATUS_IMAGE_MACHINE_TYPE_MISMATCH"},
-        {STATUS_RECEIVE_PARTIAL, -EIO, "STATUS_RECEIVE_PARTIAL"},
-        {STATUS_RECEIVE_EXPEDITED, -EIO, "STATUS_RECEIVE_EXPEDITED"},
-        {STATUS_RECEIVE_PARTIAL_EXPEDITED, -EIO,
-        "STATUS_RECEIVE_PARTIAL_EXPEDITED"},
-        {STATUS_EVENT_DONE, -EIO, "STATUS_EVENT_DONE"},
-        {STATUS_EVENT_PENDING, -EIO, "STATUS_EVENT_PENDING"},
-        {STATUS_CHECKING_FILE_SYSTEM, -EIO, "STATUS_CHECKING_FILE_SYSTEM"},
-        {STATUS_FATAL_APP_EXIT, -EIO, "STATUS_FATAL_APP_EXIT"},
-        {STATUS_PREDEFINED_HANDLE, -EIO, "STATUS_PREDEFINED_HANDLE"},
-        {STATUS_WAS_UNLOCKED, -EIO, "STATUS_WAS_UNLOCKED"},
-        {STATUS_SERVICE_NOTIFICATION, -EIO, "STATUS_SERVICE_NOTIFICATION"},
-        {STATUS_WAS_LOCKED, -EIO, "STATUS_WAS_LOCKED"},
-        {STATUS_LOG_HARD_ERROR, -EIO, "STATUS_LOG_HARD_ERROR"},
-        {STATUS_ALREADY_WIN32, -EIO, "STATUS_ALREADY_WIN32"},
-        {STATUS_WX86_UNSIMULATE, -EIO, "STATUS_WX86_UNSIMULATE"},
-        {STATUS_WX86_CONTINUE, -EIO, "STATUS_WX86_CONTINUE"},
-        {STATUS_WX86_SINGLE_STEP, -EIO, "STATUS_WX86_SINGLE_STEP"},
-        {STATUS_WX86_BREAKPOINT, -EIO, "STATUS_WX86_BREAKPOINT"},
-        {STATUS_WX86_EXCEPTION_CONTINUE, -EIO,
-        "STATUS_WX86_EXCEPTION_CONTINUE"},
-        {STATUS_WX86_EXCEPTION_LASTCHANCE, -EIO,
-        "STATUS_WX86_EXCEPTION_LASTCHANCE"},
-        {STATUS_WX86_EXCEPTION_CHAIN, -EIO, "STATUS_WX86_EXCEPTION_CHAIN"},
-        {STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE, -EIO,
-        "STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE"},
-        {STATUS_NO_YIELD_PERFORMED, -EIO, "STATUS_NO_YIELD_PERFORMED"},
-        {STATUS_TIMER_RESUME_IGNORED, -EIO, "STATUS_TIMER_RESUME_IGNORED"},
-        {STATUS_ARBITRATION_UNHANDLED, -EIO, "STATUS_ARBITRATION_UNHANDLED"},
-        {STATUS_CARDBUS_NOT_SUPPORTED, -ENOSYS, "STATUS_CARDBUS_NOT_SUPPORTED"},
-        {STATUS_WX86_CREATEWX86TIB, -EIO, "STATUS_WX86_CREATEWX86TIB"},
-        {STATUS_MP_PROCESSOR_MISMATCH, -EIO, "STATUS_MP_PROCESSOR_MISMATCH"},
-        {STATUS_HIBERNATED, -EIO, "STATUS_HIBERNATED"},
-        {STATUS_RESUME_HIBERNATION, -EIO, "STATUS_RESUME_HIBERNATION"},
-        {STATUS_FIRMWARE_UPDATED, -EIO, "STATUS_FIRMWARE_UPDATED"},
-        {STATUS_DRIVERS_LEAKING_LOCKED_PAGES, -EIO,
-        "STATUS_DRIVERS_LEAKING_LOCKED_PAGES"},
-        {STATUS_MESSAGE_RETRIEVED, -EIO, "STATUS_MESSAGE_RETRIEVED"},
-        {STATUS_SYSTEM_POWERSTATE_TRANSITION, -EIO,
-        "STATUS_SYSTEM_POWERSTATE_TRANSITION"},
-        {STATUS_ALPC_CHECK_COMPLETION_LIST, -EIO,
-        "STATUS_ALPC_CHECK_COMPLETION_LIST"},
-        {STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION, -EIO,
-        "STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION"},
-        {STATUS_ACCESS_AUDIT_BY_POLICY, -EIO, "STATUS_ACCESS_AUDIT_BY_POLICY"},
-        {STATUS_ABANDON_HIBERFILE, -EIO, "STATUS_ABANDON_HIBERFILE"},
-        {STATUS_BIZRULES_NOT_ENABLED, -EIO, "STATUS_BIZRULES_NOT_ENABLED"},
-        {STATUS_WAKE_SYSTEM, -EIO, "STATUS_WAKE_SYSTEM"},
-        {STATUS_DS_SHUTTING_DOWN, -EIO, "STATUS_DS_SHUTTING_DOWN"},
-        {DBG_REPLY_LATER, -EIO, "DBG_REPLY_LATER"},
-        {DBG_UNABLE_TO_PROVIDE_HANDLE, -EIO, "DBG_UNABLE_TO_PROVIDE_HANDLE"},
-        {DBG_TERMINATE_THREAD, -EIO, "DBG_TERMINATE_THREAD"},
-        {DBG_TERMINATE_PROCESS, -EIO, "DBG_TERMINATE_PROCESS"},
-        {DBG_CONTROL_C, -EIO, "DBG_CONTROL_C"},
-        {DBG_PRINTEXCEPTION_C, -EIO, "DBG_PRINTEXCEPTION_C"},
-        {DBG_RIPEXCEPTION, -EIO, "DBG_RIPEXCEPTION"},
-        {DBG_CONTROL_BREAK, -EIO, "DBG_CONTROL_BREAK"},
-        {DBG_COMMAND_EXCEPTION, -EIO, "DBG_COMMAND_EXCEPTION"},
-        {RPC_NT_UUID_LOCAL_ONLY, -EIO, "RPC_NT_UUID_LOCAL_ONLY"},
-        {RPC_NT_SEND_INCOMPLETE, -EIO, "RPC_NT_SEND_INCOMPLETE"},
-        {STATUS_CTX_CDM_CONNECT, -EIO, "STATUS_CTX_CDM_CONNECT"},
-        {STATUS_CTX_CDM_DISCONNECT, -EIO, "STATUS_CTX_CDM_DISCONNECT"},
-        {STATUS_SXS_RELEASE_ACTIVATION_CONTEXT, -EIO,
-        "STATUS_SXS_RELEASE_ACTIVATION_CONTEXT"},
-        {STATUS_RECOVERY_NOT_NEEDED, -EIO, "STATUS_RECOVERY_NOT_NEEDED"},
-        {STATUS_RM_ALREADY_STARTED, -EIO, "STATUS_RM_ALREADY_STARTED"},
-        {STATUS_LOG_NO_RESTART, -EIO, "STATUS_LOG_NO_RESTART"},
-        {STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST, -EIO,
-        "STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST"},
-        {STATUS_GRAPHICS_PARTIAL_DATA_POPULATED, -EIO,
-        "STATUS_GRAPHICS_PARTIAL_DATA_POPULATED"},
-        {STATUS_GRAPHICS_DRIVER_MISMATCH, -EIO,
-        "STATUS_GRAPHICS_DRIVER_MISMATCH"},
-        {STATUS_GRAPHICS_MODE_NOT_PINNED, -EIO,
-        "STATUS_GRAPHICS_MODE_NOT_PINNED"},
-        {STATUS_GRAPHICS_NO_PREFERRED_MODE, -EIO,
-        "STATUS_GRAPHICS_NO_PREFERRED_MODE"},
-        {STATUS_GRAPHICS_DATASET_IS_EMPTY, -EIO,
-        "STATUS_GRAPHICS_DATASET_IS_EMPTY"},
-        {STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET, -EIO,
-        "STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET"},
-        {STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED, -EIO,
-        "STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED"},
-        {STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS, -EIO,
-        "STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS"},
-        {STATUS_GRAPHICS_LEADLINK_START_DEFERRED, -EIO,
-        "STATUS_GRAPHICS_LEADLINK_START_DEFERRED"},
-        {STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY, -EIO,
-        "STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY"},
-        {STATUS_GRAPHICS_START_DEFERRED, -EIO,
-        "STATUS_GRAPHICS_START_DEFERRED"},
-        {STATUS_NDIS_INDICATION_REQUIRED, -EIO,
-        "STATUS_NDIS_INDICATION_REQUIRED"},
-        {STATUS_GUARD_PAGE_VIOLATION, -EIO, "STATUS_GUARD_PAGE_VIOLATION"},
-        {STATUS_DATATYPE_MISALIGNMENT, -EIO, "STATUS_DATATYPE_MISALIGNMENT"},
-        {STATUS_BREAKPOINT, -EIO, "STATUS_BREAKPOINT"},
-        {STATUS_SINGLE_STEP, -EIO, "STATUS_SINGLE_STEP"},
-        {STATUS_BUFFER_OVERFLOW, -EIO, "STATUS_BUFFER_OVERFLOW"},
-        {STATUS_NO_MORE_FILES, -EIO, "STATUS_NO_MORE_FILES"},
-        {STATUS_WAKE_SYSTEM_DEBUGGER, -EIO, "STATUS_WAKE_SYSTEM_DEBUGGER"},
-        {STATUS_HANDLES_CLOSED, -EIO, "STATUS_HANDLES_CLOSED"},
-        {STATUS_NO_INHERITANCE, -EIO, "STATUS_NO_INHERITANCE"},
-        {STATUS_GUID_SUBSTITUTION_MADE, -EIO, "STATUS_GUID_SUBSTITUTION_MADE"},
-        {STATUS_PARTIAL_COPY, -EIO, "STATUS_PARTIAL_COPY"},
-        {STATUS_DEVICE_PAPER_EMPTY, -EIO, "STATUS_DEVICE_PAPER_EMPTY"},
-        {STATUS_DEVICE_POWERED_OFF, -EIO, "STATUS_DEVICE_POWERED_OFF"},
-        {STATUS_DEVICE_OFF_LINE, -EIO, "STATUS_DEVICE_OFF_LINE"},
-        {STATUS_DEVICE_BUSY, -EBUSY, "STATUS_DEVICE_BUSY"},
-        {STATUS_NO_MORE_EAS, -EIO, "STATUS_NO_MORE_EAS"},
-        {STATUS_INVALID_EA_NAME, -EINVAL, "STATUS_INVALID_EA_NAME"},
-        {STATUS_EA_LIST_INCONSISTENT, -EIO, "STATUS_EA_LIST_INCONSISTENT"},
-        {STATUS_INVALID_EA_FLAG, -EINVAL, "STATUS_INVALID_EA_FLAG"},
-        {STATUS_VERIFY_REQUIRED, -EIO, "STATUS_VERIFY_REQUIRED"},
-        {STATUS_EXTRANEOUS_INFORMATION, -EIO, "STATUS_EXTRANEOUS_INFORMATION"},
-        {STATUS_RXACT_COMMIT_NECESSARY, -EIO, "STATUS_RXACT_COMMIT_NECESSARY"},
-        {STATUS_NO_MORE_ENTRIES, -EIO, "STATUS_NO_MORE_ENTRIES"},
-        {STATUS_FILEMARK_DETECTED, -EIO, "STATUS_FILEMARK_DETECTED"},
-        {STATUS_MEDIA_CHANGED, -EIO, "STATUS_MEDIA_CHANGED"},
-        {STATUS_BUS_RESET, -EIO, "STATUS_BUS_RESET"},
-        {STATUS_END_OF_MEDIA, -EIO, "STATUS_END_OF_MEDIA"},
-        {STATUS_BEGINNING_OF_MEDIA, -EIO, "STATUS_BEGINNING_OF_MEDIA"},
-        {STATUS_MEDIA_CHECK, -EIO, "STATUS_MEDIA_CHECK"},
-        {STATUS_SETMARK_DETECTED, -EIO, "STATUS_SETMARK_DETECTED"},
-        {STATUS_NO_DATA_DETECTED, -EIO, "STATUS_NO_DATA_DETECTED"},
-        {STATUS_REDIRECTOR_HAS_OPEN_HANDLES, -EIO,
-        "STATUS_REDIRECTOR_HAS_OPEN_HANDLES"},
-        {STATUS_SERVER_HAS_OPEN_HANDLES, -EIO,
-        "STATUS_SERVER_HAS_OPEN_HANDLES"},
-        {STATUS_ALREADY_DISCONNECTED, -EIO, "STATUS_ALREADY_DISCONNECTED"},
-        {STATUS_LONGJUMP, -EIO, "STATUS_LONGJUMP"},
-        {STATUS_CLEANER_CARTRIDGE_INSTALLED, -EIO,
-        "STATUS_CLEANER_CARTRIDGE_INSTALLED"},
-        {STATUS_PLUGPLAY_QUERY_VETOED, -EIO, "STATUS_PLUGPLAY_QUERY_VETOED"},
-        {STATUS_UNWIND_CONSOLIDATE, -EIO, "STATUS_UNWIND_CONSOLIDATE"},
-        {STATUS_REGISTRY_HIVE_RECOVERED, -EIO,
-        "STATUS_REGISTRY_HIVE_RECOVERED"},
-        {STATUS_DLL_MIGHT_BE_INSECURE, -EIO, "STATUS_DLL_MIGHT_BE_INSECURE"},
-        {STATUS_DLL_MIGHT_BE_INCOMPATIBLE, -EIO,
-        "STATUS_DLL_MIGHT_BE_INCOMPATIBLE"},
-        {STATUS_STOPPED_ON_SYMLINK, -EOPNOTSUPP, "STATUS_STOPPED_ON_SYMLINK"},
-        {STATUS_DEVICE_REQUIRES_CLEANING, -EIO,
-        "STATUS_DEVICE_REQUIRES_CLEANING"},
-        {STATUS_DEVICE_DOOR_OPEN, -EIO, "STATUS_DEVICE_DOOR_OPEN"},
-        {STATUS_DATA_LOST_REPAIR, -EIO, "STATUS_DATA_LOST_REPAIR"},
-        {DBG_EXCEPTION_NOT_HANDLED, -EIO, "DBG_EXCEPTION_NOT_HANDLED"},
-        {STATUS_CLUSTER_NODE_ALREADY_UP, -EIO,
-        "STATUS_CLUSTER_NODE_ALREADY_UP"},
-        {STATUS_CLUSTER_NODE_ALREADY_DOWN, -EIO,
-        "STATUS_CLUSTER_NODE_ALREADY_DOWN"},
-        {STATUS_CLUSTER_NETWORK_ALREADY_ONLINE, -EIO,
-        "STATUS_CLUSTER_NETWORK_ALREADY_ONLINE"},
-        {STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE, -EIO,
-        "STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE"},
-        {STATUS_CLUSTER_NODE_ALREADY_MEMBER, -EIO,
-        "STATUS_CLUSTER_NODE_ALREADY_MEMBER"},
-        {STATUS_COULD_NOT_RESIZE_LOG, -EIO, "STATUS_COULD_NOT_RESIZE_LOG"},
-        {STATUS_NO_TXF_METADATA, -EIO, "STATUS_NO_TXF_METADATA"},
-        {STATUS_CANT_RECOVER_WITH_HANDLE_OPEN, -EIO,
-        "STATUS_CANT_RECOVER_WITH_HANDLE_OPEN"},
-        {STATUS_TXF_METADATA_ALREADY_PRESENT, -EIO,
-        "STATUS_TXF_METADATA_ALREADY_PRESENT"},
-        {STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET, -EIO,
-        "STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET"},
-        {STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED, -EIO,
-        "STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED"},
-        {STATUS_FLT_BUFFER_TOO_SMALL, -ENOBUFS, "STATUS_FLT_BUFFER_TOO_SMALL"},
-        {STATUS_FVE_PARTIAL_METADATA, -EIO, "STATUS_FVE_PARTIAL_METADATA"},
-        {STATUS_UNSUCCESSFUL, -EIO, "STATUS_UNSUCCESSFUL"},
-        {STATUS_NOT_IMPLEMENTED, -ENOSYS, "STATUS_NOT_IMPLEMENTED"},
-        {STATUS_INVALID_INFO_CLASS, -EIO, "STATUS_INVALID_INFO_CLASS"},
-        {STATUS_INFO_LENGTH_MISMATCH, -EIO, "STATUS_INFO_LENGTH_MISMATCH"},
-        {STATUS_ACCESS_VIOLATION, -EACCES, "STATUS_ACCESS_VIOLATION"},
-        {STATUS_IN_PAGE_ERROR, -EFAULT, "STATUS_IN_PAGE_ERROR"},
-        {STATUS_PAGEFILE_QUOTA, -EDQUOT, "STATUS_PAGEFILE_QUOTA"},
-        {STATUS_INVALID_HANDLE, -EBADF, "STATUS_INVALID_HANDLE"},
-        {STATUS_BAD_INITIAL_STACK, -EIO, "STATUS_BAD_INITIAL_STACK"},
-        {STATUS_BAD_INITIAL_PC, -EIO, "STATUS_BAD_INITIAL_PC"},
-        {STATUS_INVALID_CID, -EIO, "STATUS_INVALID_CID"},
-        {STATUS_TIMER_NOT_CANCELED, -EIO, "STATUS_TIMER_NOT_CANCELED"},
-        {STATUS_INVALID_PARAMETER, -EINVAL, "STATUS_INVALID_PARAMETER"},
-        {STATUS_NO_SUCH_DEVICE, -ENODEV, "STATUS_NO_SUCH_DEVICE"},
-        {STATUS_NO_SUCH_FILE, -ENOENT, "STATUS_NO_SUCH_FILE"},
-        {STATUS_INVALID_DEVICE_REQUEST, -EIO, "STATUS_INVALID_DEVICE_REQUEST"},
-        {STATUS_END_OF_FILE, -ENODATA, "STATUS_END_OF_FILE"},
-        {STATUS_WRONG_VOLUME, -EIO, "STATUS_WRONG_VOLUME"},
-        {STATUS_NO_MEDIA_IN_DEVICE, -EIO, "STATUS_NO_MEDIA_IN_DEVICE"},
-        {STATUS_UNRECOGNIZED_MEDIA, -EIO, "STATUS_UNRECOGNIZED_MEDIA"},
-        {STATUS_NONEXISTENT_SECTOR, -EIO, "STATUS_NONEXISTENT_SECTOR"},
-        {STATUS_MORE_PROCESSING_REQUIRED, -EIO,
-        "STATUS_MORE_PROCESSING_REQUIRED"},
-        {STATUS_NO_MEMORY, -ENOMEM, "STATUS_NO_MEMORY"},
-        {STATUS_CONFLICTING_ADDRESSES, -EADDRINUSE,
-        "STATUS_CONFLICTING_ADDRESSES"},
-        {STATUS_NOT_MAPPED_VIEW, -EIO, "STATUS_NOT_MAPPED_VIEW"},
-        {STATUS_UNABLE_TO_FREE_VM, -EIO, "STATUS_UNABLE_TO_FREE_VM"},
-        {STATUS_UNABLE_TO_DELETE_SECTION, -EIO,
-        "STATUS_UNABLE_TO_DELETE_SECTION"},
-        {STATUS_INVALID_SYSTEM_SERVICE, -EIO, "STATUS_INVALID_SYSTEM_SERVICE"},
-        {STATUS_ILLEGAL_INSTRUCTION, -EIO, "STATUS_ILLEGAL_INSTRUCTION"},
-        {STATUS_INVALID_LOCK_SEQUENCE, -EIO, "STATUS_INVALID_LOCK_SEQUENCE"},
-        {STATUS_INVALID_VIEW_SIZE, -EIO, "STATUS_INVALID_VIEW_SIZE"},
-        {STATUS_INVALID_FILE_FOR_SECTION, -EIO,
-        "STATUS_INVALID_FILE_FOR_SECTION"},
-        {STATUS_ALREADY_COMMITTED, -EIO, "STATUS_ALREADY_COMMITTED"},
-        {STATUS_ACCESS_DENIED, -EACCES, "STATUS_ACCESS_DENIED"},
-        {STATUS_BUFFER_TOO_SMALL, -EIO, "STATUS_BUFFER_TOO_SMALL"},
-        {STATUS_OBJECT_TYPE_MISMATCH, -EIO, "STATUS_OBJECT_TYPE_MISMATCH"},
-        {STATUS_NONCONTINUABLE_EXCEPTION, -EIO,
-        "STATUS_NONCONTINUABLE_EXCEPTION"},
-        {STATUS_INVALID_DISPOSITION, -EIO, "STATUS_INVALID_DISPOSITION"},
-        {STATUS_UNWIND, -EIO, "STATUS_UNWIND"},
-        {STATUS_BAD_STACK, -EIO, "STATUS_BAD_STACK"},
-        {STATUS_INVALID_UNWIND_TARGET, -EIO, "STATUS_INVALID_UNWIND_TARGET"},
-        {STATUS_NOT_LOCKED, -EIO, "STATUS_NOT_LOCKED"},
-        {STATUS_PARITY_ERROR, -EIO, "STATUS_PARITY_ERROR"},
-        {STATUS_UNABLE_TO_DECOMMIT_VM, -EIO, "STATUS_UNABLE_TO_DECOMMIT_VM"},
-        {STATUS_NOT_COMMITTED, -EIO, "STATUS_NOT_COMMITTED"},
-        {STATUS_INVALID_PORT_ATTRIBUTES, -EIO,
-        "STATUS_INVALID_PORT_ATTRIBUTES"},
-        {STATUS_PORT_MESSAGE_TOO_LONG, -EIO, "STATUS_PORT_MESSAGE_TOO_LONG"},
-        {STATUS_INVALID_PARAMETER_MIX, -EINVAL, "STATUS_INVALID_PARAMETER_MIX"},
-        {STATUS_INVALID_QUOTA_LOWER, -EIO, "STATUS_INVALID_QUOTA_LOWER"},
-        {STATUS_DISK_CORRUPT_ERROR, -EIO, "STATUS_DISK_CORRUPT_ERROR"},
-        {STATUS_OBJECT_NAME_INVALID, -ENOENT, "STATUS_OBJECT_NAME_INVALID"},
-        {STATUS_OBJECT_NAME_NOT_FOUND, -ENOENT, "STATUS_OBJECT_NAME_NOT_FOUND"},
-        {STATUS_OBJECT_NAME_COLLISION, -EEXIST, "STATUS_OBJECT_NAME_COLLISION"},
-        {STATUS_PORT_DISCONNECTED, -EIO, "STATUS_PORT_DISCONNECTED"},
-        {STATUS_DEVICE_ALREADY_ATTACHED, -EIO,
-        "STATUS_DEVICE_ALREADY_ATTACHED"},
-        {STATUS_OBJECT_PATH_INVALID, -ENOTDIR, "STATUS_OBJECT_PATH_INVALID"},
-        {STATUS_OBJECT_PATH_NOT_FOUND, -ENOENT, "STATUS_OBJECT_PATH_NOT_FOUND"},
-        {STATUS_OBJECT_PATH_SYNTAX_BAD, -EIO, "STATUS_OBJECT_PATH_SYNTAX_BAD"},
-        {STATUS_DATA_OVERRUN, -EIO, "STATUS_DATA_OVERRUN"},
-        {STATUS_DATA_LATE_ERROR, -EIO, "STATUS_DATA_LATE_ERROR"},
-        {STATUS_DATA_ERROR, -EIO, "STATUS_DATA_ERROR"},
-        {STATUS_CRC_ERROR, -EIO, "STATUS_CRC_ERROR"},
-        {STATUS_SECTION_TOO_BIG, -EIO, "STATUS_SECTION_TOO_BIG"},
-        {STATUS_PORT_CONNECTION_REFUSED, -ECONNREFUSED,
-        "STATUS_PORT_CONNECTION_REFUSED"},
-        {STATUS_INVALID_PORT_HANDLE, -EIO, "STATUS_INVALID_PORT_HANDLE"},
-        {STATUS_SHARING_VIOLATION, -EBUSY, "STATUS_SHARING_VIOLATION"},
-        {STATUS_QUOTA_EXCEEDED, -EDQUOT, "STATUS_QUOTA_EXCEEDED"},
-        {STATUS_INVALID_PAGE_PROTECTION, -EIO,
-        "STATUS_INVALID_PAGE_PROTECTION"},
-        {STATUS_MUTANT_NOT_OWNED, -EIO, "STATUS_MUTANT_NOT_OWNED"},
-        {STATUS_SEMAPHORE_LIMIT_EXCEEDED, -EIO,
-        "STATUS_SEMAPHORE_LIMIT_EXCEEDED"},
-        {STATUS_PORT_ALREADY_SET, -EIO, "STATUS_PORT_ALREADY_SET"},
-        {STATUS_SECTION_NOT_IMAGE, -EIO, "STATUS_SECTION_NOT_IMAGE"},
-        {STATUS_SUSPEND_COUNT_EXCEEDED, -EIO, "STATUS_SUSPEND_COUNT_EXCEEDED"},
-        {STATUS_THREAD_IS_TERMINATING, -EIO, "STATUS_THREAD_IS_TERMINATING"},
-        {STATUS_BAD_WORKING_SET_LIMIT, -EIO, "STATUS_BAD_WORKING_SET_LIMIT"},
-        {STATUS_INCOMPATIBLE_FILE_MAP, -EIO, "STATUS_INCOMPATIBLE_FILE_MAP"},
-        {STATUS_SECTION_PROTECTION, -EIO, "STATUS_SECTION_PROTECTION"},
-        {STATUS_EAS_NOT_SUPPORTED, -EOPNOTSUPP, "STATUS_EAS_NOT_SUPPORTED"},
-        {STATUS_EA_TOO_LARGE, -EIO, "STATUS_EA_TOO_LARGE"},
-        {STATUS_NONEXISTENT_EA_ENTRY, -EIO, "STATUS_NONEXISTENT_EA_ENTRY"},
-        {STATUS_NO_EAS_ON_FILE, -ENODATA, "STATUS_NO_EAS_ON_FILE"},
-        {STATUS_EA_CORRUPT_ERROR, -EIO, "STATUS_EA_CORRUPT_ERROR"},
-        {STATUS_FILE_LOCK_CONFLICT, -EIO, "STATUS_FILE_LOCK_CONFLICT"},
-        {STATUS_LOCK_NOT_GRANTED, -EIO, "STATUS_LOCK_NOT_GRANTED"},
-        {STATUS_DELETE_PENDING, -ENOENT, "STATUS_DELETE_PENDING"},
-        {STATUS_CTL_FILE_NOT_SUPPORTED, -ENOSYS,
-        "STATUS_CTL_FILE_NOT_SUPPORTED"},
-        {STATUS_UNKNOWN_REVISION, -EIO, "STATUS_UNKNOWN_REVISION"},
-        {STATUS_REVISION_MISMATCH, -EIO, "STATUS_REVISION_MISMATCH"},
-        {STATUS_INVALID_OWNER, -EIO, "STATUS_INVALID_OWNER"},
-        {STATUS_INVALID_PRIMARY_GROUP, -EIO, "STATUS_INVALID_PRIMARY_GROUP"},
-        {STATUS_NO_IMPERSONATION_TOKEN, -EIO, "STATUS_NO_IMPERSONATION_TOKEN"},
-        {STATUS_CANT_DISABLE_MANDATORY, -EIO, "STATUS_CANT_DISABLE_MANDATORY"},
-        {STATUS_NO_LOGON_SERVERS, -EIO, "STATUS_NO_LOGON_SERVERS"},
-        {STATUS_NO_SUCH_LOGON_SESSION, -EIO, "STATUS_NO_SUCH_LOGON_SESSION"},
-        {STATUS_NO_SUCH_PRIVILEGE, -EIO, "STATUS_NO_SUCH_PRIVILEGE"},
-        {STATUS_PRIVILEGE_NOT_HELD, -EIO, "STATUS_PRIVILEGE_NOT_HELD"},
-        {STATUS_INVALID_ACCOUNT_NAME, -EIO, "STATUS_INVALID_ACCOUNT_NAME"},
-        {STATUS_USER_EXISTS, -EIO, "STATUS_USER_EXISTS"},
-        {STATUS_NO_SUCH_USER, -EIO, "STATUS_NO_SUCH_USER"},
-        {STATUS_GROUP_EXISTS, -EIO, "STATUS_GROUP_EXISTS"},
-        {STATUS_NO_SUCH_GROUP, -EIO, "STATUS_NO_SUCH_GROUP"},
-        {STATUS_MEMBER_IN_GROUP, -EIO, "STATUS_MEMBER_IN_GROUP"},
-        {STATUS_MEMBER_NOT_IN_GROUP, -EIO, "STATUS_MEMBER_NOT_IN_GROUP"},
-        {STATUS_LAST_ADMIN, -EIO, "STATUS_LAST_ADMIN"},
-        {STATUS_WRONG_PASSWORD, -EACCES, "STATUS_WRONG_PASSWORD"},
-        {STATUS_ILL_FORMED_PASSWORD, -EINVAL, "STATUS_ILL_FORMED_PASSWORD"},
-        {STATUS_PASSWORD_RESTRICTION, -EACCES, "STATUS_PASSWORD_RESTRICTION"},
-        {STATUS_LOGON_FAILURE, -EACCES, "STATUS_LOGON_FAILURE"},
-        {STATUS_ACCOUNT_RESTRICTION, -EACCES, "STATUS_ACCOUNT_RESTRICTION"},
-        {STATUS_INVALID_LOGON_HOURS, -EACCES, "STATUS_INVALID_LOGON_HOURS"},
-        {STATUS_INVALID_WORKSTATION, -EACCES, "STATUS_INVALID_WORKSTATION"},
-        {STATUS_PASSWORD_EXPIRED, -EKEYEXPIRED, "STATUS_PASSWORD_EXPIRED"},
-        {STATUS_ACCOUNT_DISABLED, -EKEYREVOKED, "STATUS_ACCOUNT_DISABLED"},
-        {STATUS_NONE_MAPPED, -EIO, "STATUS_NONE_MAPPED"},
-        {STATUS_TOO_MANY_LUIDS_REQUESTED, -EIO,
-        "STATUS_TOO_MANY_LUIDS_REQUESTED"},
-        {STATUS_LUIDS_EXHAUSTED, -EIO, "STATUS_LUIDS_EXHAUSTED"},
-        {STATUS_INVALID_SUB_AUTHORITY, -EIO, "STATUS_INVALID_SUB_AUTHORITY"},
-        {STATUS_INVALID_ACL, -EIO, "STATUS_INVALID_ACL"},
-        {STATUS_INVALID_SID, -EIO, "STATUS_INVALID_SID"},
-        {STATUS_INVALID_SECURITY_DESCR, -EIO, "STATUS_INVALID_SECURITY_DESCR"},
-        {STATUS_PROCEDURE_NOT_FOUND, -EIO, "STATUS_PROCEDURE_NOT_FOUND"},
-        {STATUS_INVALID_IMAGE_FORMAT, -EIO, "STATUS_INVALID_IMAGE_FORMAT"},
-        {STATUS_NO_TOKEN, -EIO, "STATUS_NO_TOKEN"},
-        {STATUS_BAD_INHERITANCE_ACL, -EIO, "STATUS_BAD_INHERITANCE_ACL"},
-        {STATUS_RANGE_NOT_LOCKED, -EIO, "STATUS_RANGE_NOT_LOCKED"},
-        {STATUS_DISK_FULL, -ENOSPC, "STATUS_DISK_FULL"},
-        {STATUS_SERVER_DISABLED, -EIO, "STATUS_SERVER_DISABLED"},
-        {STATUS_SERVER_NOT_DISABLED, -EIO, "STATUS_SERVER_NOT_DISABLED"},
-        {STATUS_TOO_MANY_GUIDS_REQUESTED, -EIO,
-        "STATUS_TOO_MANY_GUIDS_REQUESTED"},
-        {STATUS_GUIDS_EXHAUSTED, -EIO, "STATUS_GUIDS_EXHAUSTED"},
-        {STATUS_INVALID_ID_AUTHORITY, -EIO, "STATUS_INVALID_ID_AUTHORITY"},
-        {STATUS_AGENTS_EXHAUSTED, -EIO, "STATUS_AGENTS_EXHAUSTED"},
-        {STATUS_INVALID_VOLUME_LABEL, -EIO, "STATUS_INVALID_VOLUME_LABEL"},
-        {STATUS_SECTION_NOT_EXTENDED, -EIO, "STATUS_SECTION_NOT_EXTENDED"},
-        {STATUS_NOT_MAPPED_DATA, -EIO, "STATUS_NOT_MAPPED_DATA"},
-        {STATUS_RESOURCE_DATA_NOT_FOUND, -EIO,
-        "STATUS_RESOURCE_DATA_NOT_FOUND"},
-        {STATUS_RESOURCE_TYPE_NOT_FOUND, -EIO,
-        "STATUS_RESOURCE_TYPE_NOT_FOUND"},
-        {STATUS_RESOURCE_NAME_NOT_FOUND, -EIO,
-        "STATUS_RESOURCE_NAME_NOT_FOUND"},
-        {STATUS_ARRAY_BOUNDS_EXCEEDED, -EIO, "STATUS_ARRAY_BOUNDS_EXCEEDED"},
-        {STATUS_FLOAT_DENORMAL_OPERAND, -EIO, "STATUS_FLOAT_DENORMAL_OPERAND"},
-        {STATUS_FLOAT_DIVIDE_BY_ZERO, -EIO, "STATUS_FLOAT_DIVIDE_BY_ZERO"},
-        {STATUS_FLOAT_INEXACT_RESULT, -EIO, "STATUS_FLOAT_INEXACT_RESULT"},
-        {STATUS_FLOAT_INVALID_OPERATION, -EIO,
-        "STATUS_FLOAT_INVALID_OPERATION"},
-        {STATUS_FLOAT_OVERFLOW, -EIO, "STATUS_FLOAT_OVERFLOW"},
-        {STATUS_FLOAT_STACK_CHECK, -EIO, "STATUS_FLOAT_STACK_CHECK"},
-        {STATUS_FLOAT_UNDERFLOW, -EIO, "STATUS_FLOAT_UNDERFLOW"},
-        {STATUS_INTEGER_DIVIDE_BY_ZERO, -EIO, "STATUS_INTEGER_DIVIDE_BY_ZERO"},
-        {STATUS_INTEGER_OVERFLOW, -EIO, "STATUS_INTEGER_OVERFLOW"},
-        {STATUS_PRIVILEGED_INSTRUCTION, -EIO, "STATUS_PRIVILEGED_INSTRUCTION"},
-        {STATUS_TOO_MANY_PAGING_FILES, -EIO, "STATUS_TOO_MANY_PAGING_FILES"},
-        {STATUS_FILE_INVALID, -EIO, "STATUS_FILE_INVALID"},
-        {STATUS_ALLOTTED_SPACE_EXCEEDED, -EIO,
-        "STATUS_ALLOTTED_SPACE_EXCEEDED"},
-        {STATUS_INSUFFICIENT_RESOURCES, -EREMOTEIO,
-                                "STATUS_INSUFFICIENT_RESOURCES"},
-        {STATUS_DFS_EXIT_PATH_FOUND, -EIO, "STATUS_DFS_EXIT_PATH_FOUND"},
-        {STATUS_DEVICE_DATA_ERROR, -EIO, "STATUS_DEVICE_DATA_ERROR"},
-        {STATUS_DEVICE_NOT_CONNECTED, -EIO, "STATUS_DEVICE_NOT_CONNECTED"},
-        {STATUS_DEVICE_POWER_FAILURE, -EIO, "STATUS_DEVICE_POWER_FAILURE"},
-        {STATUS_FREE_VM_NOT_AT_BASE, -EIO, "STATUS_FREE_VM_NOT_AT_BASE"},
-        {STATUS_MEMORY_NOT_ALLOCATED, -EFAULT, "STATUS_MEMORY_NOT_ALLOCATED"},
-        {STATUS_WORKING_SET_QUOTA, -EIO, "STATUS_WORKING_SET_QUOTA"},
-        {STATUS_MEDIA_WRITE_PROTECTED, -EROFS, "STATUS_MEDIA_WRITE_PROTECTED"},
-        {STATUS_DEVICE_NOT_READY, -EIO, "STATUS_DEVICE_NOT_READY"},
-        {STATUS_INVALID_GROUP_ATTRIBUTES, -EIO,
-        "STATUS_INVALID_GROUP_ATTRIBUTES"},
-        {STATUS_BAD_IMPERSONATION_LEVEL, -EIO,
-        "STATUS_BAD_IMPERSONATION_LEVEL"},
-        {STATUS_CANT_OPEN_ANONYMOUS, -EIO, "STATUS_CANT_OPEN_ANONYMOUS"},
-        {STATUS_BAD_VALIDATION_CLASS, -EIO, "STATUS_BAD_VALIDATION_CLASS"},
-        {STATUS_BAD_TOKEN_TYPE, -EIO, "STATUS_BAD_TOKEN_TYPE"},
-        {STATUS_BAD_MASTER_BOOT_RECORD, -EIO, "STATUS_BAD_MASTER_BOOT_RECORD"},
-        {STATUS_INSTRUCTION_MISALIGNMENT, -EIO,
-        "STATUS_INSTRUCTION_MISALIGNMENT"},
-        {STATUS_INSTANCE_NOT_AVAILABLE, -EIO, "STATUS_INSTANCE_NOT_AVAILABLE"},
-        {STATUS_PIPE_NOT_AVAILABLE, -EIO, "STATUS_PIPE_NOT_AVAILABLE"},
-        {STATUS_INVALID_PIPE_STATE, -EIO, "STATUS_INVALID_PIPE_STATE"},
-        {STATUS_PIPE_BUSY, -EBUSY, "STATUS_PIPE_BUSY"},
-        {STATUS_ILLEGAL_FUNCTION, -EIO, "STATUS_ILLEGAL_FUNCTION"},
-        {STATUS_PIPE_DISCONNECTED, -EPIPE, "STATUS_PIPE_DISCONNECTED"},
-        {STATUS_PIPE_CLOSING, -EIO, "STATUS_PIPE_CLOSING"},
-        {STATUS_PIPE_CONNECTED, -EIO, "STATUS_PIPE_CONNECTED"},
-        {STATUS_PIPE_LISTENING, -EIO, "STATUS_PIPE_LISTENING"},
-        {STATUS_INVALID_READ_MODE, -EIO, "STATUS_INVALID_READ_MODE"},
-        {STATUS_IO_TIMEOUT, -ETIMEDOUT, "STATUS_IO_TIMEOUT"},
-        {STATUS_FILE_FORCED_CLOSED, -EIO, "STATUS_FILE_FORCED_CLOSED"},
-        {STATUS_PROFILING_NOT_STARTED, -EIO, "STATUS_PROFILING_NOT_STARTED"},
-        {STATUS_PROFILING_NOT_STOPPED, -EIO, "STATUS_PROFILING_NOT_STOPPED"},
-        {STATUS_COULD_NOT_INTERPRET, -EIO, "STATUS_COULD_NOT_INTERPRET"},
-        {STATUS_FILE_IS_A_DIRECTORY, -EISDIR, "STATUS_FILE_IS_A_DIRECTORY"},
-        {STATUS_NOT_SUPPORTED, -EOPNOTSUPP, "STATUS_NOT_SUPPORTED"},
-        {STATUS_REMOTE_NOT_LISTENING, -EHOSTDOWN,
-        "STATUS_REMOTE_NOT_LISTENING"},
-        {STATUS_DUPLICATE_NAME, -ENOTUNIQ, "STATUS_DUPLICATE_NAME"},
-        {STATUS_BAD_NETWORK_PATH, -EINVAL, "STATUS_BAD_NETWORK_PATH"},
-        {STATUS_NETWORK_BUSY, -EBUSY, "STATUS_NETWORK_BUSY"},
-        {STATUS_DEVICE_DOES_NOT_EXIST, -ENODEV, "STATUS_DEVICE_DOES_NOT_EXIST"},
-        {STATUS_TOO_MANY_COMMANDS, -EIO, "STATUS_TOO_MANY_COMMANDS"},
-        {STATUS_ADAPTER_HARDWARE_ERROR, -EIO, "STATUS_ADAPTER_HARDWARE_ERROR"},
-        {STATUS_INVALID_NETWORK_RESPONSE, -EIO,
-        "STATUS_INVALID_NETWORK_RESPONSE"},
-        {STATUS_UNEXPECTED_NETWORK_ERROR, -EIO,
-        "STATUS_UNEXPECTED_NETWORK_ERROR"},
-        {STATUS_BAD_REMOTE_ADAPTER, -EIO, "STATUS_BAD_REMOTE_ADAPTER"},
-        {STATUS_PRINT_QUEUE_FULL, -EIO, "STATUS_PRINT_QUEUE_FULL"},
-        {STATUS_NO_SPOOL_SPACE, -EIO, "STATUS_NO_SPOOL_SPACE"},
-        {STATUS_PRINT_CANCELLED, -EIO, "STATUS_PRINT_CANCELLED"},
-        {STATUS_NETWORK_NAME_DELETED, -EIO, "STATUS_NETWORK_NAME_DELETED"},
-        {STATUS_NETWORK_ACCESS_DENIED, -EACCES, "STATUS_NETWORK_ACCESS_DENIED"},
-        {STATUS_BAD_DEVICE_TYPE, -EIO, "STATUS_BAD_DEVICE_TYPE"},
-        {STATUS_BAD_NETWORK_NAME, -ENOENT, "STATUS_BAD_NETWORK_NAME"},
-        {STATUS_TOO_MANY_NAMES, -EIO, "STATUS_TOO_MANY_NAMES"},
-        {STATUS_TOO_MANY_SESSIONS, -EIO, "STATUS_TOO_MANY_SESSIONS"},
-        {STATUS_SHARING_PAUSED, -EIO, "STATUS_SHARING_PAUSED"},
-        {STATUS_REQUEST_NOT_ACCEPTED, -EIO, "STATUS_REQUEST_NOT_ACCEPTED"},
-        {STATUS_REDIRECTOR_PAUSED, -EIO, "STATUS_REDIRECTOR_PAUSED"},
-        {STATUS_NET_WRITE_FAULT, -EIO, "STATUS_NET_WRITE_FAULT"},
-        {STATUS_PROFILING_AT_LIMIT, -EIO, "STATUS_PROFILING_AT_LIMIT"},
-        {STATUS_NOT_SAME_DEVICE, -EXDEV, "STATUS_NOT_SAME_DEVICE"},
-        {STATUS_FILE_RENAMED, -EIO, "STATUS_FILE_RENAMED"},
-        {STATUS_VIRTUAL_CIRCUIT_CLOSED, -EIO, "STATUS_VIRTUAL_CIRCUIT_CLOSED"},
-        {STATUS_NO_SECURITY_ON_OBJECT, -EIO, "STATUS_NO_SECURITY_ON_OBJECT"},
-        {STATUS_CANT_WAIT, -EIO, "STATUS_CANT_WAIT"},
-        {STATUS_PIPE_EMPTY, -EIO, "STATUS_PIPE_EMPTY"},
-        {STATUS_CANT_ACCESS_DOMAIN_INFO, -EIO,
-        "STATUS_CANT_ACCESS_DOMAIN_INFO"},
-        {STATUS_CANT_TERMINATE_SELF, -EIO, "STATUS_CANT_TERMINATE_SELF"},
-        {STATUS_INVALID_SERVER_STATE, -EIO, "STATUS_INVALID_SERVER_STATE"},
-        {STATUS_INVALID_DOMAIN_STATE, -EIO, "STATUS_INVALID_DOMAIN_STATE"},
-        {STATUS_INVALID_DOMAIN_ROLE, -EIO, "STATUS_INVALID_DOMAIN_ROLE"},
-        {STATUS_NO_SUCH_DOMAIN, -EIO, "STATUS_NO_SUCH_DOMAIN"},
-        {STATUS_DOMAIN_EXISTS, -EIO, "STATUS_DOMAIN_EXISTS"},
-        {STATUS_DOMAIN_LIMIT_EXCEEDED, -EIO, "STATUS_DOMAIN_LIMIT_EXCEEDED"},
-        {STATUS_OPLOCK_NOT_GRANTED, -EIO, "STATUS_OPLOCK_NOT_GRANTED"},
-        {STATUS_INVALID_OPLOCK_PROTOCOL, -EIO,
-        "STATUS_INVALID_OPLOCK_PROTOCOL"},
-        {STATUS_INTERNAL_DB_CORRUPTION, -EIO, "STATUS_INTERNAL_DB_CORRUPTION"},
-        {STATUS_INTERNAL_ERROR, -EIO, "STATUS_INTERNAL_ERROR"},
-        {STATUS_GENERIC_NOT_MAPPED, -EIO, "STATUS_GENERIC_NOT_MAPPED"},
-        {STATUS_BAD_DESCRIPTOR_FORMAT, -EIO, "STATUS_BAD_DESCRIPTOR_FORMAT"},
-        {STATUS_INVALID_USER_BUFFER, -EIO, "STATUS_INVALID_USER_BUFFER"},
-        {STATUS_UNEXPECTED_IO_ERROR, -EIO, "STATUS_UNEXPECTED_IO_ERROR"},
-        {STATUS_UNEXPECTED_MM_CREATE_ERR, -EIO,
-        "STATUS_UNEXPECTED_MM_CREATE_ERR"},
-        {STATUS_UNEXPECTED_MM_MAP_ERROR, -EIO,
-        "STATUS_UNEXPECTED_MM_MAP_ERROR"},
-        {STATUS_UNEXPECTED_MM_EXTEND_ERR, -EIO,
-        "STATUS_UNEXPECTED_MM_EXTEND_ERR"},
-        {STATUS_NOT_LOGON_PROCESS, -EIO, "STATUS_NOT_LOGON_PROCESS"},
-        {STATUS_LOGON_SESSION_EXISTS, -EIO, "STATUS_LOGON_SESSION_EXISTS"},
-        {STATUS_INVALID_PARAMETER_1, -EINVAL, "STATUS_INVALID_PARAMETER_1"},
-        {STATUS_INVALID_PARAMETER_2, -EINVAL, "STATUS_INVALID_PARAMETER_2"},
-        {STATUS_INVALID_PARAMETER_3, -EINVAL, "STATUS_INVALID_PARAMETER_3"},
-        {STATUS_INVALID_PARAMETER_4, -EINVAL, "STATUS_INVALID_PARAMETER_4"},
-        {STATUS_INVALID_PARAMETER_5, -EINVAL, "STATUS_INVALID_PARAMETER_5"},
-        {STATUS_INVALID_PARAMETER_6, -EINVAL, "STATUS_INVALID_PARAMETER_6"},
-        {STATUS_INVALID_PARAMETER_7, -EINVAL, "STATUS_INVALID_PARAMETER_7"},
-        {STATUS_INVALID_PARAMETER_8, -EINVAL, "STATUS_INVALID_PARAMETER_8"},
-        {STATUS_INVALID_PARAMETER_9, -EINVAL, "STATUS_INVALID_PARAMETER_9"},
-        {STATUS_INVALID_PARAMETER_10, -EINVAL, "STATUS_INVALID_PARAMETER_10"},
-        {STATUS_INVALID_PARAMETER_11, -EINVAL, "STATUS_INVALID_PARAMETER_11"},
-        {STATUS_INVALID_PARAMETER_12, -EINVAL, "STATUS_INVALID_PARAMETER_12"},
-        {STATUS_REDIRECTOR_NOT_STARTED, -EIO, "STATUS_REDIRECTOR_NOT_STARTED"},
-        {STATUS_REDIRECTOR_STARTED, -EIO, "STATUS_REDIRECTOR_STARTED"},
-        {STATUS_STACK_OVERFLOW, -EIO, "STATUS_STACK_OVERFLOW"},
-        {STATUS_NO_SUCH_PACKAGE, -EIO, "STATUS_NO_SUCH_PACKAGE"},
-        {STATUS_BAD_FUNCTION_TABLE, -EIO, "STATUS_BAD_FUNCTION_TABLE"},
-        {STATUS_VARIABLE_NOT_FOUND, -EIO, "STATUS_VARIABLE_NOT_FOUND"},
-        {STATUS_DIRECTORY_NOT_EMPTY, -ENOTEMPTY, "STATUS_DIRECTORY_NOT_EMPTY"},
-        {STATUS_FILE_CORRUPT_ERROR, -EIO, "STATUS_FILE_CORRUPT_ERROR"},
-        {STATUS_NOT_A_DIRECTORY, -ENOTDIR, "STATUS_NOT_A_DIRECTORY"},
-        {STATUS_BAD_LOGON_SESSION_STATE, -EIO,
-        "STATUS_BAD_LOGON_SESSION_STATE"},
-        {STATUS_LOGON_SESSION_COLLISION, -EIO,
-        "STATUS_LOGON_SESSION_COLLISION"},
-        {STATUS_NAME_TOO_LONG, -ENAMETOOLONG, "STATUS_NAME_TOO_LONG"},
-        {STATUS_FILES_OPEN, -EIO, "STATUS_FILES_OPEN"},
-        {STATUS_CONNECTION_IN_USE, -EIO, "STATUS_CONNECTION_IN_USE"},
-        {STATUS_MESSAGE_NOT_FOUND, -EIO, "STATUS_MESSAGE_NOT_FOUND"},
-        {STATUS_PROCESS_IS_TERMINATING, -EIO, "STATUS_PROCESS_IS_TERMINATING"},
-        {STATUS_INVALID_LOGON_TYPE, -EIO, "STATUS_INVALID_LOGON_TYPE"},
-        {STATUS_NO_GUID_TRANSLATION, -EIO, "STATUS_NO_GUID_TRANSLATION"},
-        {STATUS_CANNOT_IMPERSONATE, -EIO, "STATUS_CANNOT_IMPERSONATE"},
-        {STATUS_IMAGE_ALREADY_LOADED, -EIO, "STATUS_IMAGE_ALREADY_LOADED"},
-        {STATUS_ABIOS_NOT_PRESENT, -EIO, "STATUS_ABIOS_NOT_PRESENT"},
-        {STATUS_ABIOS_LID_NOT_EXIST, -EIO, "STATUS_ABIOS_LID_NOT_EXIST"},
-        {STATUS_ABIOS_LID_ALREADY_OWNED, -EIO,
-        "STATUS_ABIOS_LID_ALREADY_OWNED"},
-        {STATUS_ABIOS_NOT_LID_OWNER, -EIO, "STATUS_ABIOS_NOT_LID_OWNER"},
-        {STATUS_ABIOS_INVALID_COMMAND, -EIO, "STATUS_ABIOS_INVALID_COMMAND"},
-        {STATUS_ABIOS_INVALID_LID, -EIO, "STATUS_ABIOS_INVALID_LID"},
-        {STATUS_ABIOS_SELECTOR_NOT_AVAILABLE, -EIO,
-        "STATUS_ABIOS_SELECTOR_NOT_AVAILABLE"},
-        {STATUS_ABIOS_INVALID_SELECTOR, -EIO, "STATUS_ABIOS_INVALID_SELECTOR"},
-        {STATUS_NO_LDT, -EIO, "STATUS_NO_LDT"},
-        {STATUS_INVALID_LDT_SIZE, -EIO, "STATUS_INVALID_LDT_SIZE"},
-        {STATUS_INVALID_LDT_OFFSET, -EIO, "STATUS_INVALID_LDT_OFFSET"},
-        {STATUS_INVALID_LDT_DESCRIPTOR, -EIO, "STATUS_INVALID_LDT_DESCRIPTOR"},
-        {STATUS_INVALID_IMAGE_NE_FORMAT, -EIO,
-        "STATUS_INVALID_IMAGE_NE_FORMAT"},
-        {STATUS_RXACT_INVALID_STATE, -EIO, "STATUS_RXACT_INVALID_STATE"},
-        {STATUS_RXACT_COMMIT_FAILURE, -EIO, "STATUS_RXACT_COMMIT_FAILURE"},
-        {STATUS_MAPPED_FILE_SIZE_ZERO, -EIO, "STATUS_MAPPED_FILE_SIZE_ZERO"},
-        {STATUS_TOO_MANY_OPENED_FILES, -EMFILE, "STATUS_TOO_MANY_OPENED_FILES"},
-        {STATUS_CANCELLED, -EIO, "STATUS_CANCELLED"},
-        {STATUS_CANNOT_DELETE, -EIO, "STATUS_CANNOT_DELETE"},
-        {STATUS_INVALID_COMPUTER_NAME, -EIO, "STATUS_INVALID_COMPUTER_NAME"},
-        {STATUS_FILE_DELETED, -EIO, "STATUS_FILE_DELETED"},
-        {STATUS_SPECIAL_ACCOUNT, -EIO, "STATUS_SPECIAL_ACCOUNT"},
-        {STATUS_SPECIAL_GROUP, -EIO, "STATUS_SPECIAL_GROUP"},
-        {STATUS_SPECIAL_USER, -EIO, "STATUS_SPECIAL_USER"},
-        {STATUS_MEMBERS_PRIMARY_GROUP, -EIO, "STATUS_MEMBERS_PRIMARY_GROUP"},
-        {STATUS_FILE_CLOSED, -EBADF, "STATUS_FILE_CLOSED"},
-        {STATUS_TOO_MANY_THREADS, -EIO, "STATUS_TOO_MANY_THREADS"},
-        {STATUS_THREAD_NOT_IN_PROCESS, -EIO, "STATUS_THREAD_NOT_IN_PROCESS"},
-        {STATUS_TOKEN_ALREADY_IN_USE, -EIO, "STATUS_TOKEN_ALREADY_IN_USE"},
-        {STATUS_PAGEFILE_QUOTA_EXCEEDED, -EDQUOT,
-        "STATUS_PAGEFILE_QUOTA_EXCEEDED"},
-        {STATUS_COMMITMENT_LIMIT, -EIO, "STATUS_COMMITMENT_LIMIT"},
-        {STATUS_INVALID_IMAGE_LE_FORMAT, -EIO,
-        "STATUS_INVALID_IMAGE_LE_FORMAT"},
-        {STATUS_INVALID_IMAGE_NOT_MZ, -EIO, "STATUS_INVALID_IMAGE_NOT_MZ"},
-        {STATUS_INVALID_IMAGE_PROTECT, -EIO, "STATUS_INVALID_IMAGE_PROTECT"},
-        {STATUS_INVALID_IMAGE_WIN_16, -EIO, "STATUS_INVALID_IMAGE_WIN_16"},
-        {STATUS_LOGON_SERVER_CONFLICT, -EIO, "STATUS_LOGON_SERVER_CONFLICT"},
-        {STATUS_TIME_DIFFERENCE_AT_DC, -EIO, "STATUS_TIME_DIFFERENCE_AT_DC"},
-        {STATUS_SYNCHRONIZATION_REQUIRED, -EIO,
-        "STATUS_SYNCHRONIZATION_REQUIRED"},
-        {STATUS_DLL_NOT_FOUND, -ENOENT, "STATUS_DLL_NOT_FOUND"},
-        {STATUS_OPEN_FAILED, -EIO, "STATUS_OPEN_FAILED"},
-        {STATUS_IO_PRIVILEGE_FAILED, -EIO, "STATUS_IO_PRIVILEGE_FAILED"},
-        {STATUS_ORDINAL_NOT_FOUND, -EIO, "STATUS_ORDINAL_NOT_FOUND"},
-        {STATUS_ENTRYPOINT_NOT_FOUND, -EIO, "STATUS_ENTRYPOINT_NOT_FOUND"},
-        {STATUS_CONTROL_C_EXIT, -EIO, "STATUS_CONTROL_C_EXIT"},
-        {STATUS_LOCAL_DISCONNECT, -EIO, "STATUS_LOCAL_DISCONNECT"},
-        {STATUS_REMOTE_DISCONNECT, -ESHUTDOWN, "STATUS_REMOTE_DISCONNECT"},
-        {STATUS_REMOTE_RESOURCES, -EIO, "STATUS_REMOTE_RESOURCES"},
-        {STATUS_LINK_FAILED, -EXDEV, "STATUS_LINK_FAILED"},
-        {STATUS_LINK_TIMEOUT, -ETIMEDOUT, "STATUS_LINK_TIMEOUT"},
-        {STATUS_INVALID_CONNECTION, -EIO, "STATUS_INVALID_CONNECTION"},
-        {STATUS_INVALID_ADDRESS, -EIO, "STATUS_INVALID_ADDRESS"},
-        {STATUS_DLL_INIT_FAILED, -EIO, "STATUS_DLL_INIT_FAILED"},
-        {STATUS_MISSING_SYSTEMFILE, -EIO, "STATUS_MISSING_SYSTEMFILE"},
-        {STATUS_UNHANDLED_EXCEPTION, -EIO, "STATUS_UNHANDLED_EXCEPTION"},
-        {STATUS_APP_INIT_FAILURE, -EIO, "STATUS_APP_INIT_FAILURE"},
-        {STATUS_PAGEFILE_CREATE_FAILED, -EIO, "STATUS_PAGEFILE_CREATE_FAILED"},
-        {STATUS_NO_PAGEFILE, -EIO, "STATUS_NO_PAGEFILE"},
-        {STATUS_INVALID_LEVEL, -EIO, "STATUS_INVALID_LEVEL"},
-        {STATUS_WRONG_PASSWORD_CORE, -EIO, "STATUS_WRONG_PASSWORD_CORE"},
-        {STATUS_ILLEGAL_FLOAT_CONTEXT, -EIO, "STATUS_ILLEGAL_FLOAT_CONTEXT"},
-        {STATUS_PIPE_BROKEN, -EPIPE, "STATUS_PIPE_BROKEN"},
-        {STATUS_REGISTRY_CORRUPT, -EIO, "STATUS_REGISTRY_CORRUPT"},
-        {STATUS_REGISTRY_IO_FAILED, -EIO, "STATUS_REGISTRY_IO_FAILED"},
-        {STATUS_NO_EVENT_PAIR, -EIO, "STATUS_NO_EVENT_PAIR"},
-        {STATUS_UNRECOGNIZED_VOLUME, -EIO, "STATUS_UNRECOGNIZED_VOLUME"},
-        {STATUS_SERIAL_NO_DEVICE_INITED, -EIO,
-        "STATUS_SERIAL_NO_DEVICE_INITED"},
-        {STATUS_NO_SUCH_ALIAS, -EIO, "STATUS_NO_SUCH_ALIAS"},
-        {STATUS_MEMBER_NOT_IN_ALIAS, -EIO, "STATUS_MEMBER_NOT_IN_ALIAS"},
-        {STATUS_MEMBER_IN_ALIAS, -EIO, "STATUS_MEMBER_IN_ALIAS"},
-        {STATUS_ALIAS_EXISTS, -EIO, "STATUS_ALIAS_EXISTS"},
-        {STATUS_LOGON_NOT_GRANTED, -EIO, "STATUS_LOGON_NOT_GRANTED"},
-        {STATUS_TOO_MANY_SECRETS, -EIO, "STATUS_TOO_MANY_SECRETS"},
-        {STATUS_SECRET_TOO_LONG, -EIO, "STATUS_SECRET_TOO_LONG"},
-        {STATUS_INTERNAL_DB_ERROR, -EIO, "STATUS_INTERNAL_DB_ERROR"},
-        {STATUS_FULLSCREEN_MODE, -EIO, "STATUS_FULLSCREEN_MODE"},
-        {STATUS_TOO_MANY_CONTEXT_IDS, -EIO, "STATUS_TOO_MANY_CONTEXT_IDS"},
-        {STATUS_LOGON_TYPE_NOT_GRANTED, -EIO, "STATUS_LOGON_TYPE_NOT_GRANTED"},
-        {STATUS_NOT_REGISTRY_FILE, -EIO, "STATUS_NOT_REGISTRY_FILE"},
-        {STATUS_NT_CROSS_ENCRYPTION_REQUIRED, -EIO,
-        "STATUS_NT_CROSS_ENCRYPTION_REQUIRED"},
-        {STATUS_DOMAIN_CTRLR_CONFIG_ERROR, -EIO,
-        "STATUS_DOMAIN_CTRLR_CONFIG_ERROR"},
-        {STATUS_FT_MISSING_MEMBER, -EIO, "STATUS_FT_MISSING_MEMBER"},
-        {STATUS_ILL_FORMED_SERVICE_ENTRY, -EIO,
-        "STATUS_ILL_FORMED_SERVICE_ENTRY"},
-        {STATUS_ILLEGAL_CHARACTER, -EIO, "STATUS_ILLEGAL_CHARACTER"},
-        {STATUS_UNMAPPABLE_CHARACTER, -EIO, "STATUS_UNMAPPABLE_CHARACTER"},
-        {STATUS_UNDEFINED_CHARACTER, -EIO, "STATUS_UNDEFINED_CHARACTER"},
-        {STATUS_FLOPPY_VOLUME, -EIO, "STATUS_FLOPPY_VOLUME"},
-        {STATUS_FLOPPY_ID_MARK_NOT_FOUND, -EIO,
-        "STATUS_FLOPPY_ID_MARK_NOT_FOUND"},
-        {STATUS_FLOPPY_WRONG_CYLINDER, -EIO, "STATUS_FLOPPY_WRONG_CYLINDER"},
-        {STATUS_FLOPPY_UNKNOWN_ERROR, -EIO, "STATUS_FLOPPY_UNKNOWN_ERROR"},
-        {STATUS_FLOPPY_BAD_REGISTERS, -EIO, "STATUS_FLOPPY_BAD_REGISTERS"},
-        {STATUS_DISK_RECALIBRATE_FAILED, -EIO,
-        "STATUS_DISK_RECALIBRATE_FAILED"},
-        {STATUS_DISK_OPERATION_FAILED, -EIO, "STATUS_DISK_OPERATION_FAILED"},
-        {STATUS_DISK_RESET_FAILED, -EIO, "STATUS_DISK_RESET_FAILED"},
-        {STATUS_SHARED_IRQ_BUSY, -EBUSY, "STATUS_SHARED_IRQ_BUSY"},
-        {STATUS_FT_ORPHANING, -EIO, "STATUS_FT_ORPHANING"},
-        {STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT, -EIO,
-        "STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT"},
-        {STATUS_PARTITION_FAILURE, -EIO, "STATUS_PARTITION_FAILURE"},
-        {STATUS_INVALID_BLOCK_LENGTH, -EIO, "STATUS_INVALID_BLOCK_LENGTH"},
-        {STATUS_DEVICE_NOT_PARTITIONED, -EIO, "STATUS_DEVICE_NOT_PARTITIONED"},
-        {STATUS_UNABLE_TO_LOCK_MEDIA, -EIO, "STATUS_UNABLE_TO_LOCK_MEDIA"},
-        {STATUS_UNABLE_TO_UNLOAD_MEDIA, -EIO, "STATUS_UNABLE_TO_UNLOAD_MEDIA"},
-        {STATUS_EOM_OVERFLOW, -EIO, "STATUS_EOM_OVERFLOW"},
-        {STATUS_NO_MEDIA, -EIO, "STATUS_NO_MEDIA"},
-        {STATUS_NO_SUCH_MEMBER, -EIO, "STATUS_NO_SUCH_MEMBER"},
-        {STATUS_INVALID_MEMBER, -EIO, "STATUS_INVALID_MEMBER"},
-        {STATUS_KEY_DELETED, -EIO, "STATUS_KEY_DELETED"},
-        {STATUS_NO_LOG_SPACE, -EIO, "STATUS_NO_LOG_SPACE"},
-        {STATUS_TOO_MANY_SIDS, -EIO, "STATUS_TOO_MANY_SIDS"},
-        {STATUS_LM_CROSS_ENCRYPTION_REQUIRED, -EIO,
-        "STATUS_LM_CROSS_ENCRYPTION_REQUIRED"},
-        {STATUS_KEY_HAS_CHILDREN, -EIO, "STATUS_KEY_HAS_CHILDREN"},
-        {STATUS_CHILD_MUST_BE_VOLATILE, -EIO, "STATUS_CHILD_MUST_BE_VOLATILE"},
-        {STATUS_DEVICE_CONFIGURATION_ERROR, -EIO,
-        "STATUS_DEVICE_CONFIGURATION_ERROR"},
-        {STATUS_DRIVER_INTERNAL_ERROR, -EIO, "STATUS_DRIVER_INTERNAL_ERROR"},
-        {STATUS_INVALID_DEVICE_STATE, -EIO, "STATUS_INVALID_DEVICE_STATE"},
-        {STATUS_IO_DEVICE_ERROR, -EIO, "STATUS_IO_DEVICE_ERROR"},
-        {STATUS_DEVICE_PROTOCOL_ERROR, -EIO, "STATUS_DEVICE_PROTOCOL_ERROR"},
-        {STATUS_BACKUP_CONTROLLER, -EIO, "STATUS_BACKUP_CONTROLLER"},
-        {STATUS_LOG_FILE_FULL, -EIO, "STATUS_LOG_FILE_FULL"},
-        {STATUS_TOO_LATE, -EIO, "STATUS_TOO_LATE"},
-        {STATUS_NO_TRUST_LSA_SECRET, -EIO, "STATUS_NO_TRUST_LSA_SECRET"},
-        {STATUS_NO_TRUST_SAM_ACCOUNT, -EIO, "STATUS_NO_TRUST_SAM_ACCOUNT"},
-        {STATUS_TRUSTED_DOMAIN_FAILURE, -EIO, "STATUS_TRUSTED_DOMAIN_FAILURE"},
-        {STATUS_TRUSTED_RELATIONSHIP_FAILURE, -EIO,
-        "STATUS_TRUSTED_RELATIONSHIP_FAILURE"},
-        {STATUS_EVENTLOG_FILE_CORRUPT, -EIO, "STATUS_EVENTLOG_FILE_CORRUPT"},
-        {STATUS_EVENTLOG_CANT_START, -EIO, "STATUS_EVENTLOG_CANT_START"},
-        {STATUS_TRUST_FAILURE, -EIO, "STATUS_TRUST_FAILURE"},
-        {STATUS_MUTANT_LIMIT_EXCEEDED, -EIO, "STATUS_MUTANT_LIMIT_EXCEEDED"},
-        {STATUS_NETLOGON_NOT_STARTED, -EIO, "STATUS_NETLOGON_NOT_STARTED"},
-        {STATUS_ACCOUNT_EXPIRED, -EKEYEXPIRED, "STATUS_ACCOUNT_EXPIRED"},
-        {STATUS_POSSIBLE_DEADLOCK, -EIO, "STATUS_POSSIBLE_DEADLOCK"},
-        {STATUS_NETWORK_CREDENTIAL_CONFLICT, -EIO,
-        "STATUS_NETWORK_CREDENTIAL_CONFLICT"},
-        {STATUS_REMOTE_SESSION_LIMIT, -EIO, "STATUS_REMOTE_SESSION_LIMIT"},
-        {STATUS_EVENTLOG_FILE_CHANGED, -EIO, "STATUS_EVENTLOG_FILE_CHANGED"},
-        {STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT, -EIO,
-        "STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT"},
-        {STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT, -EIO,
-        "STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT"},
-        {STATUS_NOLOGON_SERVER_TRUST_ACCOUNT, -EIO,
-        "STATUS_NOLOGON_SERVER_TRUST_ACCOUNT"},
-        {STATUS_DOMAIN_TRUST_INCONSISTENT, -EIO,
-        "STATUS_DOMAIN_TRUST_INCONSISTENT"},
-        {STATUS_FS_DRIVER_REQUIRED, -EIO, "STATUS_FS_DRIVER_REQUIRED"},
-        {STATUS_IMAGE_ALREADY_LOADED_AS_DLL, -EIO,
-        "STATUS_IMAGE_ALREADY_LOADED_AS_DLL"},
-        {STATUS_NETWORK_OPEN_RESTRICTION, -EIO,
-        "STATUS_NETWORK_OPEN_RESTRICTION"},
-        {STATUS_NO_USER_SESSION_KEY, -EIO, "STATUS_NO_USER_SESSION_KEY"},
-        {STATUS_USER_SESSION_DELETED, -EIO, "STATUS_USER_SESSION_DELETED"},
-        {STATUS_RESOURCE_LANG_NOT_FOUND, -EIO,
-        "STATUS_RESOURCE_LANG_NOT_FOUND"},
-        {STATUS_INSUFF_SERVER_RESOURCES, -EIO,
-        "STATUS_INSUFF_SERVER_RESOURCES"},
-        {STATUS_INVALID_BUFFER_SIZE, -EIO, "STATUS_INVALID_BUFFER_SIZE"},
-        {STATUS_INVALID_ADDRESS_COMPONENT, -EIO,
-        "STATUS_INVALID_ADDRESS_COMPONENT"},
-        {STATUS_INVALID_ADDRESS_WILDCARD, -EIO,
-        "STATUS_INVALID_ADDRESS_WILDCARD"},
-        {STATUS_TOO_MANY_ADDRESSES, -EIO, "STATUS_TOO_MANY_ADDRESSES"},
-        {STATUS_ADDRESS_ALREADY_EXISTS, -EADDRINUSE,
-        "STATUS_ADDRESS_ALREADY_EXISTS"},
-        {STATUS_ADDRESS_CLOSED, -EIO, "STATUS_ADDRESS_CLOSED"},
-        {STATUS_CONNECTION_DISCONNECTED, -ECONNABORTED,
-        "STATUS_CONNECTION_DISCONNECTED"},
-        {STATUS_CONNECTION_RESET, -ENETRESET, "STATUS_CONNECTION_RESET"},
-        {STATUS_TOO_MANY_NODES, -EIO, "STATUS_TOO_MANY_NODES"},
-        {STATUS_TRANSACTION_ABORTED, -EIO, "STATUS_TRANSACTION_ABORTED"},
-        {STATUS_TRANSACTION_TIMED_OUT, -EIO, "STATUS_TRANSACTION_TIMED_OUT"},
-        {STATUS_TRANSACTION_NO_RELEASE, -EIO, "STATUS_TRANSACTION_NO_RELEASE"},
-        {STATUS_TRANSACTION_NO_MATCH, -EIO, "STATUS_TRANSACTION_NO_MATCH"},
-        {STATUS_TRANSACTION_RESPONDED, -EIO, "STATUS_TRANSACTION_RESPONDED"},
-        {STATUS_TRANSACTION_INVALID_ID, -EIO, "STATUS_TRANSACTION_INVALID_ID"},
-        {STATUS_TRANSACTION_INVALID_TYPE, -EIO,
-        "STATUS_TRANSACTION_INVALID_TYPE"},
-        {STATUS_NOT_SERVER_SESSION, -EIO, "STATUS_NOT_SERVER_SESSION"},
-        {STATUS_NOT_CLIENT_SESSION, -EIO, "STATUS_NOT_CLIENT_SESSION"},
-        {STATUS_CANNOT_LOAD_REGISTRY_FILE, -EIO,
-        "STATUS_CANNOT_LOAD_REGISTRY_FILE"},
-        {STATUS_DEBUG_ATTACH_FAILED, -EIO, "STATUS_DEBUG_ATTACH_FAILED"},
-        {STATUS_SYSTEM_PROCESS_TERMINATED, -EIO,
-        "STATUS_SYSTEM_PROCESS_TERMINATED"},
-        {STATUS_DATA_NOT_ACCEPTED, -EIO, "STATUS_DATA_NOT_ACCEPTED"},
-        {STATUS_NO_BROWSER_SERVERS_FOUND, -EIO,
-        "STATUS_NO_BROWSER_SERVERS_FOUND"},
-        {STATUS_VDM_HARD_ERROR, -EIO, "STATUS_VDM_HARD_ERROR"},
-        {STATUS_DRIVER_CANCEL_TIMEOUT, -EIO, "STATUS_DRIVER_CANCEL_TIMEOUT"},
-        {STATUS_REPLY_MESSAGE_MISMATCH, -EIO, "STATUS_REPLY_MESSAGE_MISMATCH"},
-        {STATUS_MAPPED_ALIGNMENT, -EIO, "STATUS_MAPPED_ALIGNMENT"},
-        {STATUS_IMAGE_CHECKSUM_MISMATCH, -EIO,
-        "STATUS_IMAGE_CHECKSUM_MISMATCH"},
-        {STATUS_LOST_WRITEBEHIND_DATA, -EIO, "STATUS_LOST_WRITEBEHIND_DATA"},
-        {STATUS_CLIENT_SERVER_PARAMETERS_INVALID, -EIO,
-        "STATUS_CLIENT_SERVER_PARAMETERS_INVALID"},
-        {STATUS_PASSWORD_MUST_CHANGE, -EIO, "STATUS_PASSWORD_MUST_CHANGE"},
-        {STATUS_NOT_FOUND, -ENOENT, "STATUS_NOT_FOUND"},
-        {STATUS_NOT_TINY_STREAM, -EIO, "STATUS_NOT_TINY_STREAM"},
-        {STATUS_RECOVERY_FAILURE, -EIO, "STATUS_RECOVERY_FAILURE"},
-        {STATUS_STACK_OVERFLOW_READ, -EIO, "STATUS_STACK_OVERFLOW_READ"},
-        {STATUS_FAIL_CHECK, -EIO, "STATUS_FAIL_CHECK"},
-        {STATUS_DUPLICATE_OBJECTID, -EIO, "STATUS_DUPLICATE_OBJECTID"},
-        {STATUS_OBJECTID_EXISTS, -EIO, "STATUS_OBJECTID_EXISTS"},
-        {STATUS_CONVERT_TO_LARGE, -EIO, "STATUS_CONVERT_TO_LARGE"},
-        {STATUS_RETRY, -EAGAIN, "STATUS_RETRY"},
-        {STATUS_FOUND_OUT_OF_SCOPE, -EIO, "STATUS_FOUND_OUT_OF_SCOPE"},
-        {STATUS_ALLOCATE_BUCKET, -EIO, "STATUS_ALLOCATE_BUCKET"},
-        {STATUS_PROPSET_NOT_FOUND, -EIO, "STATUS_PROPSET_NOT_FOUND"},
-        {STATUS_MARSHALL_OVERFLOW, -EIO, "STATUS_MARSHALL_OVERFLOW"},
-        {STATUS_INVALID_VARIANT, -EIO, "STATUS_INVALID_VARIANT"},
-        {STATUS_DOMAIN_CONTROLLER_NOT_FOUND, -EIO,
-        "STATUS_DOMAIN_CONTROLLER_NOT_FOUND"},
-        {STATUS_ACCOUNT_LOCKED_OUT, -EIO, "STATUS_ACCOUNT_LOCKED_OUT"},
-        {STATUS_HANDLE_NOT_CLOSABLE, -EIO, "STATUS_HANDLE_NOT_CLOSABLE"},
-        {STATUS_CONNECTION_REFUSED, -EIO, "STATUS_CONNECTION_REFUSED"},
-        {STATUS_GRACEFUL_DISCONNECT, -EIO, "STATUS_GRACEFUL_DISCONNECT"},
-        {STATUS_ADDRESS_ALREADY_ASSOCIATED, -EIO,
-        "STATUS_ADDRESS_ALREADY_ASSOCIATED"},
-        {STATUS_ADDRESS_NOT_ASSOCIATED, -EIO, "STATUS_ADDRESS_NOT_ASSOCIATED"},
-        {STATUS_CONNECTION_INVALID, -EIO, "STATUS_CONNECTION_INVALID"},
-        {STATUS_CONNECTION_ACTIVE, -EIO, "STATUS_CONNECTION_ACTIVE"},
-        {STATUS_NETWORK_UNREACHABLE, -ENETUNREACH,
-        "STATUS_NETWORK_UNREACHABLE"},
-        {STATUS_HOST_UNREACHABLE, -EHOSTDOWN, "STATUS_HOST_UNREACHABLE"},
-        {STATUS_PROTOCOL_UNREACHABLE, -ENETUNREACH,
-        "STATUS_PROTOCOL_UNREACHABLE"},
-        {STATUS_PORT_UNREACHABLE, -ENETUNREACH, "STATUS_PORT_UNREACHABLE"},
-        {STATUS_REQUEST_ABORTED, -EIO, "STATUS_REQUEST_ABORTED"},
-        {STATUS_CONNECTION_ABORTED, -ECONNABORTED, "STATUS_CONNECTION_ABORTED"},
-        {STATUS_BAD_COMPRESSION_BUFFER, -EIO, "STATUS_BAD_COMPRESSION_BUFFER"},
-        {STATUS_USER_MAPPED_FILE, -EIO, "STATUS_USER_MAPPED_FILE"},
-        {STATUS_AUDIT_FAILED, -EIO, "STATUS_AUDIT_FAILED"},
-        {STATUS_TIMER_RESOLUTION_NOT_SET, -EIO,
-        "STATUS_TIMER_RESOLUTION_NOT_SET"},
-        {STATUS_CONNECTION_COUNT_LIMIT, -EIO, "STATUS_CONNECTION_COUNT_LIMIT"},
-        {STATUS_LOGIN_TIME_RESTRICTION, -EACCES,
-        "STATUS_LOGIN_TIME_RESTRICTION"},
-        {STATUS_LOGIN_WKSTA_RESTRICTION, -EACCES,
-        "STATUS_LOGIN_WKSTA_RESTRICTION"},
-        {STATUS_IMAGE_MP_UP_MISMATCH, -EIO, "STATUS_IMAGE_MP_UP_MISMATCH"},
-        {STATUS_INSUFFICIENT_LOGON_INFO, -EIO,
-        "STATUS_INSUFFICIENT_LOGON_INFO"},
-        {STATUS_BAD_DLL_ENTRYPOINT, -EIO, "STATUS_BAD_DLL_ENTRYPOINT"},
-        {STATUS_BAD_SERVICE_ENTRYPOINT, -EIO, "STATUS_BAD_SERVICE_ENTRYPOINT"},
-        {STATUS_LPC_REPLY_LOST, -EIO, "STATUS_LPC_REPLY_LOST"},
-        {STATUS_IP_ADDRESS_CONFLICT1, -EIO, "STATUS_IP_ADDRESS_CONFLICT1"},
-        {STATUS_IP_ADDRESS_CONFLICT2, -EIO, "STATUS_IP_ADDRESS_CONFLICT2"},
-        {STATUS_REGISTRY_QUOTA_LIMIT, -EDQUOT, "STATUS_REGISTRY_QUOTA_LIMIT"},
-        {STATUS_PATH_NOT_COVERED, -EREMOTE, "STATUS_PATH_NOT_COVERED"},
-        {STATUS_NO_CALLBACK_ACTIVE, -EIO, "STATUS_NO_CALLBACK_ACTIVE"},
-        {STATUS_LICENSE_QUOTA_EXCEEDED, -EACCES,
-        "STATUS_LICENSE_QUOTA_EXCEEDED"},
-        {STATUS_PWD_TOO_SHORT, -EIO, "STATUS_PWD_TOO_SHORT"},
-        {STATUS_PWD_TOO_RECENT, -EIO, "STATUS_PWD_TOO_RECENT"},
-        {STATUS_PWD_HISTORY_CONFLICT, -EIO, "STATUS_PWD_HISTORY_CONFLICT"},
-        {STATUS_PLUGPLAY_NO_DEVICE, -EIO, "STATUS_PLUGPLAY_NO_DEVICE"},
-        {STATUS_UNSUPPORTED_COMPRESSION, -EIO,
-        "STATUS_UNSUPPORTED_COMPRESSION"},
-        {STATUS_INVALID_HW_PROFILE, -EIO, "STATUS_INVALID_HW_PROFILE"},
-        {STATUS_INVALID_PLUGPLAY_DEVICE_PATH, -EIO,
-        "STATUS_INVALID_PLUGPLAY_DEVICE_PATH"},
-        {STATUS_DRIVER_ORDINAL_NOT_FOUND, -EIO,
-        "STATUS_DRIVER_ORDINAL_NOT_FOUND"},
-        {STATUS_DRIVER_ENTRYPOINT_NOT_FOUND, -EIO,
-        "STATUS_DRIVER_ENTRYPOINT_NOT_FOUND"},
-        {STATUS_RESOURCE_NOT_OWNED, -EIO, "STATUS_RESOURCE_NOT_OWNED"},
-        {STATUS_TOO_MANY_LINKS, -EMLINK, "STATUS_TOO_MANY_LINKS"},
-        {STATUS_QUOTA_LIST_INCONSISTENT, -EIO,
-        "STATUS_QUOTA_LIST_INCONSISTENT"},
-        {STATUS_FILE_IS_OFFLINE, -EIO, "STATUS_FILE_IS_OFFLINE"},
-        {STATUS_EVALUATION_EXPIRATION, -EIO, "STATUS_EVALUATION_EXPIRATION"},
-        {STATUS_ILLEGAL_DLL_RELOCATION, -EIO, "STATUS_ILLEGAL_DLL_RELOCATION"},
-        {STATUS_LICENSE_VIOLATION, -EIO, "STATUS_LICENSE_VIOLATION"},
-        {STATUS_DLL_INIT_FAILED_LOGOFF, -EIO, "STATUS_DLL_INIT_FAILED_LOGOFF"},
-        {STATUS_DRIVER_UNABLE_TO_LOAD, -EIO, "STATUS_DRIVER_UNABLE_TO_LOAD"},
-        {STATUS_DFS_UNAVAILABLE, -EIO, "STATUS_DFS_UNAVAILABLE"},
-        {STATUS_VOLUME_DISMOUNTED, -EIO, "STATUS_VOLUME_DISMOUNTED"},
-        {STATUS_WX86_INTERNAL_ERROR, -EIO, "STATUS_WX86_INTERNAL_ERROR"},
-        {STATUS_WX86_FLOAT_STACK_CHECK, -EIO, "STATUS_WX86_FLOAT_STACK_CHECK"},
-        {STATUS_VALIDATE_CONTINUE, -EIO, "STATUS_VALIDATE_CONTINUE"},
-        {STATUS_NO_MATCH, -EIO, "STATUS_NO_MATCH"},
-        {STATUS_NO_MORE_MATCHES, -EIO, "STATUS_NO_MORE_MATCHES"},
-        {STATUS_NOT_A_REPARSE_POINT, -EIO, "STATUS_NOT_A_REPARSE_POINT"},
-        {STATUS_IO_REPARSE_TAG_INVALID, -EIO, "STATUS_IO_REPARSE_TAG_INVALID"},
-        {STATUS_IO_REPARSE_TAG_MISMATCH, -EIO,
-        "STATUS_IO_REPARSE_TAG_MISMATCH"},
-        {STATUS_IO_REPARSE_DATA_INVALID, -EIO,
-        "STATUS_IO_REPARSE_DATA_INVALID"},
-        {STATUS_IO_REPARSE_TAG_NOT_HANDLED, -EIO,
-        "STATUS_IO_REPARSE_TAG_NOT_HANDLED"},
-        {STATUS_REPARSE_POINT_NOT_RESOLVED, -EIO,
-        "STATUS_REPARSE_POINT_NOT_RESOLVED"},
-        {STATUS_DIRECTORY_IS_A_REPARSE_POINT, -EIO,
-        "STATUS_DIRECTORY_IS_A_REPARSE_POINT"},
-        {STATUS_RANGE_LIST_CONFLICT, -EIO, "STATUS_RANGE_LIST_CONFLICT"},
-        {STATUS_SOURCE_ELEMENT_EMPTY, -EIO, "STATUS_SOURCE_ELEMENT_EMPTY"},
-        {STATUS_DESTINATION_ELEMENT_FULL, -EIO,
-        "STATUS_DESTINATION_ELEMENT_FULL"},
-        {STATUS_ILLEGAL_ELEMENT_ADDRESS, -EIO,
-        "STATUS_ILLEGAL_ELEMENT_ADDRESS"},
-        {STATUS_MAGAZINE_NOT_PRESENT, -EIO, "STATUS_MAGAZINE_NOT_PRESENT"},
-        {STATUS_REINITIALIZATION_NEEDED, -EIO,
-        "STATUS_REINITIALIZATION_NEEDED"},
-        {STATUS_ENCRYPTION_FAILED, -EIO, "STATUS_ENCRYPTION_FAILED"},
-        {STATUS_DECRYPTION_FAILED, -EIO, "STATUS_DECRYPTION_FAILED"},
-        {STATUS_RANGE_NOT_FOUND, -EIO, "STATUS_RANGE_NOT_FOUND"},
-        {STATUS_NO_RECOVERY_POLICY, -EIO, "STATUS_NO_RECOVERY_POLICY"},
-        {STATUS_NO_EFS, -EIO, "STATUS_NO_EFS"},
-        {STATUS_WRONG_EFS, -EIO, "STATUS_WRONG_EFS"},
-        {STATUS_NO_USER_KEYS, -EIO, "STATUS_NO_USER_KEYS"},
-        {STATUS_FILE_NOT_ENCRYPTED, -EIO, "STATUS_FILE_NOT_ENCRYPTED"},
-        {STATUS_NOT_EXPORT_FORMAT, -EIO, "STATUS_NOT_EXPORT_FORMAT"},
-        {STATUS_FILE_ENCRYPTED, -EIO, "STATUS_FILE_ENCRYPTED"},
-        {STATUS_WMI_GUID_NOT_FOUND, -EIO, "STATUS_WMI_GUID_NOT_FOUND"},
-        {STATUS_WMI_INSTANCE_NOT_FOUND, -EIO, "STATUS_WMI_INSTANCE_NOT_FOUND"},
-        {STATUS_WMI_ITEMID_NOT_FOUND, -EIO, "STATUS_WMI_ITEMID_NOT_FOUND"},
-        {STATUS_WMI_TRY_AGAIN, -EIO, "STATUS_WMI_TRY_AGAIN"},
-        {STATUS_SHARED_POLICY, -EIO, "STATUS_SHARED_POLICY"},
-        {STATUS_POLICY_OBJECT_NOT_FOUND, -EIO,
-        "STATUS_POLICY_OBJECT_NOT_FOUND"},
-        {STATUS_POLICY_ONLY_IN_DS, -EIO, "STATUS_POLICY_ONLY_IN_DS"},
-        {STATUS_VOLUME_NOT_UPGRADED, -EIO, "STATUS_VOLUME_NOT_UPGRADED"},
-        {STATUS_REMOTE_STORAGE_NOT_ACTIVE, -EIO,
-        "STATUS_REMOTE_STORAGE_NOT_ACTIVE"},
-        {STATUS_REMOTE_STORAGE_MEDIA_ERROR, -EIO,
-        "STATUS_REMOTE_STORAGE_MEDIA_ERROR"},
-        {STATUS_NO_TRACKING_SERVICE, -EIO, "STATUS_NO_TRACKING_SERVICE"},
-        {STATUS_SERVER_SID_MISMATCH, -EIO, "STATUS_SERVER_SID_MISMATCH"},
-        {STATUS_DS_NO_ATTRIBUTE_OR_VALUE, -EIO,
-        "STATUS_DS_NO_ATTRIBUTE_OR_VALUE"},
-        {STATUS_DS_INVALID_ATTRIBUTE_SYNTAX, -EIO,
-        "STATUS_DS_INVALID_ATTRIBUTE_SYNTAX"},
-        {STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED, -EIO,
-        "STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED"},
-        {STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS, -EIO,
-        "STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS"},
-        {STATUS_DS_BUSY, -EBUSY, "STATUS_DS_BUSY"},
-        {STATUS_DS_UNAVAILABLE, -EIO, "STATUS_DS_UNAVAILABLE"},
-        {STATUS_DS_NO_RIDS_ALLOCATED, -EIO, "STATUS_DS_NO_RIDS_ALLOCATED"},
-        {STATUS_DS_NO_MORE_RIDS, -EIO, "STATUS_DS_NO_MORE_RIDS"},
-        {STATUS_DS_INCORRECT_ROLE_OWNER, -EIO,
-        "STATUS_DS_INCORRECT_ROLE_OWNER"},
-        {STATUS_DS_RIDMGR_INIT_ERROR, -EIO, "STATUS_DS_RIDMGR_INIT_ERROR"},
-        {STATUS_DS_OBJ_CLASS_VIOLATION, -EIO, "STATUS_DS_OBJ_CLASS_VIOLATION"},
-        {STATUS_DS_CANT_ON_NON_LEAF, -EIO, "STATUS_DS_CANT_ON_NON_LEAF"},
-        {STATUS_DS_CANT_ON_RDN, -EIO, "STATUS_DS_CANT_ON_RDN"},
-        {STATUS_DS_CANT_MOD_OBJ_CLASS, -EIO, "STATUS_DS_CANT_MOD_OBJ_CLASS"},
-        {STATUS_DS_CROSS_DOM_MOVE_FAILED, -EIO,
-        "STATUS_DS_CROSS_DOM_MOVE_FAILED"},
-        {STATUS_DS_GC_NOT_AVAILABLE, -EIO, "STATUS_DS_GC_NOT_AVAILABLE"},
-        {STATUS_DIRECTORY_SERVICE_REQUIRED, -EIO,
-        "STATUS_DIRECTORY_SERVICE_REQUIRED"},
-        {STATUS_REPARSE_ATTRIBUTE_CONFLICT, -EIO,
-        "STATUS_REPARSE_ATTRIBUTE_CONFLICT"},
-        {STATUS_CANT_ENABLE_DENY_ONLY, -EIO, "STATUS_CANT_ENABLE_DENY_ONLY"},
-        {STATUS_FLOAT_MULTIPLE_FAULTS, -EIO, "STATUS_FLOAT_MULTIPLE_FAULTS"},
-        {STATUS_FLOAT_MULTIPLE_TRAPS, -EIO, "STATUS_FLOAT_MULTIPLE_TRAPS"},
-        {STATUS_DEVICE_REMOVED, -EIO, "STATUS_DEVICE_REMOVED"},
-        {STATUS_JOURNAL_DELETE_IN_PROGRESS, -EIO,
-        "STATUS_JOURNAL_DELETE_IN_PROGRESS"},
-        {STATUS_JOURNAL_NOT_ACTIVE, -EIO, "STATUS_JOURNAL_NOT_ACTIVE"},
-        {STATUS_NOINTERFACE, -EIO, "STATUS_NOINTERFACE"},
-        {STATUS_DS_ADMIN_LIMIT_EXCEEDED, -EIO,
-        "STATUS_DS_ADMIN_LIMIT_EXCEEDED"},
-        {STATUS_DRIVER_FAILED_SLEEP, -EIO, "STATUS_DRIVER_FAILED_SLEEP"},
-        {STATUS_MUTUAL_AUTHENTICATION_FAILED, -EIO,
-        "STATUS_MUTUAL_AUTHENTICATION_FAILED"},
-        {STATUS_CORRUPT_SYSTEM_FILE, -EIO, "STATUS_CORRUPT_SYSTEM_FILE"},
-        {STATUS_DATATYPE_MISALIGNMENT_ERROR, -EIO,
-        "STATUS_DATATYPE_MISALIGNMENT_ERROR"},
-        {STATUS_WMI_READ_ONLY, -EROFS, "STATUS_WMI_READ_ONLY"},
-        {STATUS_WMI_SET_FAILURE, -EIO, "STATUS_WMI_SET_FAILURE"},
-        {STATUS_COMMITMENT_MINIMUM, -EIO, "STATUS_COMMITMENT_MINIMUM"},
-        {STATUS_REG_NAT_CONSUMPTION, -EIO, "STATUS_REG_NAT_CONSUMPTION"},
-        {STATUS_TRANSPORT_FULL, -EIO, "STATUS_TRANSPORT_FULL"},
-        {STATUS_DS_SAM_INIT_FAILURE, -EIO, "STATUS_DS_SAM_INIT_FAILURE"},
-        {STATUS_ONLY_IF_CONNECTED, -EIO, "STATUS_ONLY_IF_CONNECTED"},
-        {STATUS_DS_SENSITIVE_GROUP_VIOLATION, -EIO,
-        "STATUS_DS_SENSITIVE_GROUP_VIOLATION"},
-        {STATUS_PNP_RESTART_ENUMERATION, -EIO,
-        "STATUS_PNP_RESTART_ENUMERATION"},
-        {STATUS_JOURNAL_ENTRY_DELETED, -EIO, "STATUS_JOURNAL_ENTRY_DELETED"},
-        {STATUS_DS_CANT_MOD_PRIMARYGROUPID, -EIO,
-        "STATUS_DS_CANT_MOD_PRIMARYGROUPID"},
-        {STATUS_SYSTEM_IMAGE_BAD_SIGNATURE, -EIO,
-        "STATUS_SYSTEM_IMAGE_BAD_SIGNATURE"},
-        {STATUS_PNP_REBOOT_REQUIRED, -EIO, "STATUS_PNP_REBOOT_REQUIRED"},
-        {STATUS_POWER_STATE_INVALID, -EIO, "STATUS_POWER_STATE_INVALID"},
-        {STATUS_DS_INVALID_GROUP_TYPE, -EIO, "STATUS_DS_INVALID_GROUP_TYPE"},
-        {STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN, -EIO,
-        "STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN"},
-        {STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN, -EIO,
-        "STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN"},
-        {STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER, -EIO,
-        "STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER"},
-        {STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER, -EIO,
-        "STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER"},
-        {STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER, -EIO,
-        "STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER"},
-        {STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER, -EIO,
-        "STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER"},
-        {STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER, -EIO,
-        "STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER"},
-        {STATUS_DS_HAVE_PRIMARY_MEMBERS, -EIO,
-        "STATUS_DS_HAVE_PRIMARY_MEMBERS"},
-        {STATUS_WMI_NOT_SUPPORTED, -EOPNOTSUPP, "STATUS_WMI_NOT_SUPPORTED"},
-        {STATUS_INSUFFICIENT_POWER, -EIO, "STATUS_INSUFFICIENT_POWER"},
-        {STATUS_SAM_NEED_BOOTKEY_PASSWORD, -EIO,
-        "STATUS_SAM_NEED_BOOTKEY_PASSWORD"},
-        {STATUS_SAM_NEED_BOOTKEY_FLOPPY, -EIO,
-        "STATUS_SAM_NEED_BOOTKEY_FLOPPY"},
-        {STATUS_DS_CANT_START, -EIO, "STATUS_DS_CANT_START"},
-        {STATUS_DS_INIT_FAILURE, -EIO, "STATUS_DS_INIT_FAILURE"},
-        {STATUS_SAM_INIT_FAILURE, -EIO, "STATUS_SAM_INIT_FAILURE"},
-        {STATUS_DS_GC_REQUIRED, -EIO, "STATUS_DS_GC_REQUIRED"},
-        {STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY, -EIO,
-        "STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY"},
-        {STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS, -EIO,
-        "STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS"},
-        {STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED, -EDQUOT,
-        "STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED"},
-        {STATUS_MULTIPLE_FAULT_VIOLATION, -EIO,
-        "STATUS_MULTIPLE_FAULT_VIOLATION"},
-        {STATUS_CURRENT_DOMAIN_NOT_ALLOWED, -EIO,
-        "STATUS_CURRENT_DOMAIN_NOT_ALLOWED"},
-        {STATUS_CANNOT_MAKE, -EIO, "STATUS_CANNOT_MAKE"},
-        {STATUS_SYSTEM_SHUTDOWN, -EIO, "STATUS_SYSTEM_SHUTDOWN"},
-        {STATUS_DS_INIT_FAILURE_CONSOLE, -EIO,
-        "STATUS_DS_INIT_FAILURE_CONSOLE"},
-        {STATUS_DS_SAM_INIT_FAILURE_CONSOLE, -EIO,
-        "STATUS_DS_SAM_INIT_FAILURE_CONSOLE"},
-        {STATUS_UNFINISHED_CONTEXT_DELETED, -EIO,
-        "STATUS_UNFINISHED_CONTEXT_DELETED"},
-        {STATUS_NO_TGT_REPLY, -EIO, "STATUS_NO_TGT_REPLY"},
-        {STATUS_OBJECTID_NOT_FOUND, -EIO, "STATUS_OBJECTID_NOT_FOUND"},
-        {STATUS_NO_IP_ADDRESSES, -EIO, "STATUS_NO_IP_ADDRESSES"},
-        {STATUS_WRONG_CREDENTIAL_HANDLE, -EIO,
-        "STATUS_WRONG_CREDENTIAL_HANDLE"},
-        {STATUS_CRYPTO_SYSTEM_INVALID, -EIO, "STATUS_CRYPTO_SYSTEM_INVALID"},
-        {STATUS_MAX_REFERRALS_EXCEEDED, -EIO, "STATUS_MAX_REFERRALS_EXCEEDED"},
-        {STATUS_MUST_BE_KDC, -EIO, "STATUS_MUST_BE_KDC"},
-        {STATUS_STRONG_CRYPTO_NOT_SUPPORTED, -EIO,
-        "STATUS_STRONG_CRYPTO_NOT_SUPPORTED"},
-        {STATUS_TOO_MANY_PRINCIPALS, -EIO, "STATUS_TOO_MANY_PRINCIPALS"},
-        {STATUS_NO_PA_DATA, -EIO, "STATUS_NO_PA_DATA"},
-        {STATUS_PKINIT_NAME_MISMATCH, -EIO, "STATUS_PKINIT_NAME_MISMATCH"},
-        {STATUS_SMARTCARD_LOGON_REQUIRED, -EIO,
-        "STATUS_SMARTCARD_LOGON_REQUIRED"},
-        {STATUS_KDC_INVALID_REQUEST, -EIO, "STATUS_KDC_INVALID_REQUEST"},
-        {STATUS_KDC_UNABLE_TO_REFER, -EIO, "STATUS_KDC_UNABLE_TO_REFER"},
-        {STATUS_KDC_UNKNOWN_ETYPE, -EIO, "STATUS_KDC_UNKNOWN_ETYPE"},
-        {STATUS_SHUTDOWN_IN_PROGRESS, -EIO, "STATUS_SHUTDOWN_IN_PROGRESS"},
-        {STATUS_SERVER_SHUTDOWN_IN_PROGRESS, -EIO,
-        "STATUS_SERVER_SHUTDOWN_IN_PROGRESS"},
-        {STATUS_NOT_SUPPORTED_ON_SBS, -EOPNOTSUPP,
-        "STATUS_NOT_SUPPORTED_ON_SBS"},
-        {STATUS_WMI_GUID_DISCONNECTED, -EIO, "STATUS_WMI_GUID_DISCONNECTED"},
-        {STATUS_WMI_ALREADY_DISABLED, -EIO, "STATUS_WMI_ALREADY_DISABLED"},
-        {STATUS_WMI_ALREADY_ENABLED, -EIO, "STATUS_WMI_ALREADY_ENABLED"},
-        {STATUS_MFT_TOO_FRAGMENTED, -EIO, "STATUS_MFT_TOO_FRAGMENTED"},
-        {STATUS_COPY_PROTECTION_FAILURE, -EIO,
-        "STATUS_COPY_PROTECTION_FAILURE"},
-        {STATUS_CSS_AUTHENTICATION_FAILURE, -EIO,
-        "STATUS_CSS_AUTHENTICATION_FAILURE"},
-        {STATUS_CSS_KEY_NOT_PRESENT, -EIO, "STATUS_CSS_KEY_NOT_PRESENT"},
-        {STATUS_CSS_KEY_NOT_ESTABLISHED, -EIO,
-        "STATUS_CSS_KEY_NOT_ESTABLISHED"},
-        {STATUS_CSS_SCRAMBLED_SECTOR, -EIO, "STATUS_CSS_SCRAMBLED_SECTOR"},
-        {STATUS_CSS_REGION_MISMATCH, -EIO, "STATUS_CSS_REGION_MISMATCH"},
-        {STATUS_CSS_RESETS_EXHAUSTED, -EIO, "STATUS_CSS_RESETS_EXHAUSTED"},
-        {STATUS_PKINIT_FAILURE, -EIO, "STATUS_PKINIT_FAILURE"},
-        {STATUS_SMARTCARD_SUBSYSTEM_FAILURE, -EIO,
-        "STATUS_SMARTCARD_SUBSYSTEM_FAILURE"},
-        {STATUS_NO_KERB_KEY, -EIO, "STATUS_NO_KERB_KEY"},
-        {STATUS_HOST_DOWN, -EIO, "STATUS_HOST_DOWN"},
-        {STATUS_UNSUPPORTED_PREAUTH, -EIO, "STATUS_UNSUPPORTED_PREAUTH"},
-        {STATUS_EFS_ALG_BLOB_TOO_BIG, -EIO, "STATUS_EFS_ALG_BLOB_TOO_BIG"},
-        {STATUS_PORT_NOT_SET, -EIO, "STATUS_PORT_NOT_SET"},
-        {STATUS_DEBUGGER_INACTIVE, -EIO, "STATUS_DEBUGGER_INACTIVE"},
-        {STATUS_DS_VERSION_CHECK_FAILURE, -EIO,
-        "STATUS_DS_VERSION_CHECK_FAILURE"},
-        {STATUS_AUDITING_DISABLED, -EIO, "STATUS_AUDITING_DISABLED"},
-        {STATUS_PRENT4_MACHINE_ACCOUNT, -EIO, "STATUS_PRENT4_MACHINE_ACCOUNT"},
-        {STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER, -EIO,
-        "STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER"},
-        {STATUS_INVALID_IMAGE_WIN_32, -EIO, "STATUS_INVALID_IMAGE_WIN_32"},
-        {STATUS_INVALID_IMAGE_WIN_64, -EIO, "STATUS_INVALID_IMAGE_WIN_64"},
-        {STATUS_BAD_BINDINGS, -EIO, "STATUS_BAD_BINDINGS"},
-        {STATUS_NETWORK_SESSION_EXPIRED, -EIO,
-        "STATUS_NETWORK_SESSION_EXPIRED"},
-        {STATUS_APPHELP_BLOCK, -EIO, "STATUS_APPHELP_BLOCK"},
-        {STATUS_ALL_SIDS_FILTERED, -EIO, "STATUS_ALL_SIDS_FILTERED"},
-        {STATUS_NOT_SAFE_MODE_DRIVER, -EIO, "STATUS_NOT_SAFE_MODE_DRIVER"},
-        {STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT, -EACCES,
-        "STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT"},
-        {STATUS_ACCESS_DISABLED_BY_POLICY_PATH, -EACCES,
-        "STATUS_ACCESS_DISABLED_BY_POLICY_PATH"},
-        {STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER, -EACCES,
-        "STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER"},
-        {STATUS_ACCESS_DISABLED_BY_POLICY_OTHER, -EACCES,
-        "STATUS_ACCESS_DISABLED_BY_POLICY_OTHER"},
-        {STATUS_FAILED_DRIVER_ENTRY, -EIO, "STATUS_FAILED_DRIVER_ENTRY"},
-        {STATUS_DEVICE_ENUMERATION_ERROR, -EIO,
-        "STATUS_DEVICE_ENUMERATION_ERROR"},
-        {STATUS_MOUNT_POINT_NOT_RESOLVED, -EIO,
-        "STATUS_MOUNT_POINT_NOT_RESOLVED"},
-        {STATUS_INVALID_DEVICE_OBJECT_PARAMETER, -EIO,
-        "STATUS_INVALID_DEVICE_OBJECT_PARAMETER"},
-        {STATUS_MCA_OCCURED, -EIO, "STATUS_MCA_OCCURED"},
-        {STATUS_DRIVER_BLOCKED_CRITICAL, -EIO,
-        "STATUS_DRIVER_BLOCKED_CRITICAL"},
-        {STATUS_DRIVER_BLOCKED, -EIO, "STATUS_DRIVER_BLOCKED"},
-        {STATUS_DRIVER_DATABASE_ERROR, -EIO, "STATUS_DRIVER_DATABASE_ERROR"},
-        {STATUS_SYSTEM_HIVE_TOO_LARGE, -EIO, "STATUS_SYSTEM_HIVE_TOO_LARGE"},
-        {STATUS_INVALID_IMPORT_OF_NON_DLL, -EIO,
-        "STATUS_INVALID_IMPORT_OF_NON_DLL"},
-        {STATUS_NO_SECRETS, -EIO, "STATUS_NO_SECRETS"},
-        {STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY, -EACCES,
-        "STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY"},
-        {STATUS_FAILED_STACK_SWITCH, -EIO, "STATUS_FAILED_STACK_SWITCH"},
-        {STATUS_HEAP_CORRUPTION, -EIO, "STATUS_HEAP_CORRUPTION"},
-        {STATUS_SMARTCARD_WRONG_PIN, -EIO, "STATUS_SMARTCARD_WRONG_PIN"},
-        {STATUS_SMARTCARD_CARD_BLOCKED, -EIO, "STATUS_SMARTCARD_CARD_BLOCKED"},
-        {STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED, -EIO,
-        "STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED"},
-        {STATUS_SMARTCARD_NO_CARD, -EIO, "STATUS_SMARTCARD_NO_CARD"},
-        {STATUS_SMARTCARD_NO_KEY_CONTAINER, -EIO,
-        "STATUS_SMARTCARD_NO_KEY_CONTAINER"},
-        {STATUS_SMARTCARD_NO_CERTIFICATE, -EIO,
-        "STATUS_SMARTCARD_NO_CERTIFICATE"},
-        {STATUS_SMARTCARD_NO_KEYSET, -EIO, "STATUS_SMARTCARD_NO_KEYSET"},
-        {STATUS_SMARTCARD_IO_ERROR, -EIO, "STATUS_SMARTCARD_IO_ERROR"},
-        {STATUS_DOWNGRADE_DETECTED, -EIO, "STATUS_DOWNGRADE_DETECTED"},
-        {STATUS_SMARTCARD_CERT_REVOKED, -EIO, "STATUS_SMARTCARD_CERT_REVOKED"},
-        {STATUS_ISSUING_CA_UNTRUSTED, -EIO, "STATUS_ISSUING_CA_UNTRUSTED"},
-        {STATUS_REVOCATION_OFFLINE_C, -EIO, "STATUS_REVOCATION_OFFLINE_C"},
-        {STATUS_PKINIT_CLIENT_FAILURE, -EIO, "STATUS_PKINIT_CLIENT_FAILURE"},
-        {STATUS_SMARTCARD_CERT_EXPIRED, -EIO, "STATUS_SMARTCARD_CERT_EXPIRED"},
-        {STATUS_DRIVER_FAILED_PRIOR_UNLOAD, -EIO,
-        "STATUS_DRIVER_FAILED_PRIOR_UNLOAD"},
-        {STATUS_SMARTCARD_SILENT_CONTEXT, -EIO,
-        "STATUS_SMARTCARD_SILENT_CONTEXT"},
-        {STATUS_PER_USER_TRUST_QUOTA_EXCEEDED, -EDQUOT,
-        "STATUS_PER_USER_TRUST_QUOTA_EXCEEDED"},
-        {STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED, -EDQUOT,
-        "STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED"},
-        {STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED, -EDQUOT,
-        "STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED"},
-        {STATUS_DS_NAME_NOT_UNIQUE, -EIO, "STATUS_DS_NAME_NOT_UNIQUE"},
-        {STATUS_DS_DUPLICATE_ID_FOUND, -EIO, "STATUS_DS_DUPLICATE_ID_FOUND"},
-        {STATUS_DS_GROUP_CONVERSION_ERROR, -EIO,
-        "STATUS_DS_GROUP_CONVERSION_ERROR"},
-        {STATUS_VOLSNAP_PREPARE_HIBERNATE, -EIO,
-        "STATUS_VOLSNAP_PREPARE_HIBERNATE"},
-        {STATUS_USER2USER_REQUIRED, -EIO, "STATUS_USER2USER_REQUIRED"},
-        {STATUS_STACK_BUFFER_OVERRUN, -EIO, "STATUS_STACK_BUFFER_OVERRUN"},
-        {STATUS_NO_S4U_PROT_SUPPORT, -EIO, "STATUS_NO_S4U_PROT_SUPPORT"},
-        {STATUS_CROSSREALM_DELEGATION_FAILURE, -EIO,
-        "STATUS_CROSSREALM_DELEGATION_FAILURE"},
-        {STATUS_REVOCATION_OFFLINE_KDC, -EIO, "STATUS_REVOCATION_OFFLINE_KDC"},
-        {STATUS_ISSUING_CA_UNTRUSTED_KDC, -EIO,
-        "STATUS_ISSUING_CA_UNTRUSTED_KDC"},
-        {STATUS_KDC_CERT_EXPIRED, -EIO, "STATUS_KDC_CERT_EXPIRED"},
-        {STATUS_KDC_CERT_REVOKED, -EIO, "STATUS_KDC_CERT_REVOKED"},
-        {STATUS_PARAMETER_QUOTA_EXCEEDED, -EDQUOT,
-        "STATUS_PARAMETER_QUOTA_EXCEEDED"},
-        {STATUS_HIBERNATION_FAILURE, -EIO, "STATUS_HIBERNATION_FAILURE"},
-        {STATUS_DELAY_LOAD_FAILED, -EIO, "STATUS_DELAY_LOAD_FAILED"},
-        {STATUS_AUTHENTICATION_FIREWALL_FAILED, -EIO,
-        "STATUS_AUTHENTICATION_FIREWALL_FAILED"},
-        {STATUS_VDM_DISALLOWED, -EIO, "STATUS_VDM_DISALLOWED"},
-        {STATUS_HUNG_DISPLAY_DRIVER_THREAD, -EIO,
-        "STATUS_HUNG_DISPLAY_DRIVER_THREAD"},
-        {STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE, -EIO,
-        "STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE"},
-        {STATUS_INVALID_CRUNTIME_PARAMETER, -EIO,
-        "STATUS_INVALID_CRUNTIME_PARAMETER"},
-        {STATUS_NTLM_BLOCKED, -EIO, "STATUS_NTLM_BLOCKED"},
-        {STATUS_ASSERTION_FAILURE, -EIO, "STATUS_ASSERTION_FAILURE"},
-        {STATUS_VERIFIER_STOP, -EIO, "STATUS_VERIFIER_STOP"},
-        {STATUS_CALLBACK_POP_STACK, -EIO, "STATUS_CALLBACK_POP_STACK"},
-        {STATUS_INCOMPATIBLE_DRIVER_BLOCKED, -EIO,
-        "STATUS_INCOMPATIBLE_DRIVER_BLOCKED"},
-        {STATUS_HIVE_UNLOADED, -EIO, "STATUS_HIVE_UNLOADED"},
-        {STATUS_COMPRESSION_DISABLED, -EIO, "STATUS_COMPRESSION_DISABLED"},
-        {STATUS_FILE_SYSTEM_LIMITATION, -EIO, "STATUS_FILE_SYSTEM_LIMITATION"},
-        {STATUS_INVALID_IMAGE_HASH, -EIO, "STATUS_INVALID_IMAGE_HASH"},
-        {STATUS_NOT_CAPABLE, -EIO, "STATUS_NOT_CAPABLE"},
-        {STATUS_REQUEST_OUT_OF_SEQUENCE, -EIO,
-        "STATUS_REQUEST_OUT_OF_SEQUENCE"},
-        {STATUS_IMPLEMENTATION_LIMIT, -EIO, "STATUS_IMPLEMENTATION_LIMIT"},
-        {STATUS_ELEVATION_REQUIRED, -EIO, "STATUS_ELEVATION_REQUIRED"},
-        {STATUS_BEYOND_VDL, -EIO, "STATUS_BEYOND_VDL"},
-        {STATUS_ENCOUNTERED_WRITE_IN_PROGRESS, -EIO,
-        "STATUS_ENCOUNTERED_WRITE_IN_PROGRESS"},
-        {STATUS_PTE_CHANGED, -EIO, "STATUS_PTE_CHANGED"},
-        {STATUS_PURGE_FAILED, -EIO, "STATUS_PURGE_FAILED"},
-        {STATUS_CRED_REQUIRES_CONFIRMATION, -EIO,
-        "STATUS_CRED_REQUIRES_CONFIRMATION"},
-        {STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE, -EIO,
-        "STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE"},
-        {STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER, -EIO,
-        "STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER"},
-        {STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE, -EIO,
-        "STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE"},
-        {STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE, -EIO,
-        "STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE"},
-        {STATUS_CS_ENCRYPTION_FILE_NOT_CSE, -EIO,
-        "STATUS_CS_ENCRYPTION_FILE_NOT_CSE"},
-        {STATUS_INVALID_LABEL, -EIO, "STATUS_INVALID_LABEL"},
-        {STATUS_DRIVER_PROCESS_TERMINATED, -EIO,
-        "STATUS_DRIVER_PROCESS_TERMINATED"},
-        {STATUS_AMBIGUOUS_SYSTEM_DEVICE, -EIO,
-        "STATUS_AMBIGUOUS_SYSTEM_DEVICE"},
-        {STATUS_SYSTEM_DEVICE_NOT_FOUND, -EIO,
-        "STATUS_SYSTEM_DEVICE_NOT_FOUND"},
-        {STATUS_RESTART_BOOT_APPLICATION, -EIO,
-        "STATUS_RESTART_BOOT_APPLICATION"},
-        {STATUS_INVALID_TASK_NAME, -EIO, "STATUS_INVALID_TASK_NAME"},
-        {STATUS_INVALID_TASK_INDEX, -EIO, "STATUS_INVALID_TASK_INDEX"},
-        {STATUS_THREAD_ALREADY_IN_TASK, -EIO, "STATUS_THREAD_ALREADY_IN_TASK"},
-        {STATUS_CALLBACK_BYPASS, -EIO, "STATUS_CALLBACK_BYPASS"},
-        {STATUS_PORT_CLOSED, -EIO, "STATUS_PORT_CLOSED"},
-        {STATUS_MESSAGE_LOST, -EIO, "STATUS_MESSAGE_LOST"},
-        {STATUS_INVALID_MESSAGE, -EIO, "STATUS_INVALID_MESSAGE"},
-        {STATUS_REQUEST_CANCELED, -EIO, "STATUS_REQUEST_CANCELED"},
-        {STATUS_RECURSIVE_DISPATCH, -EIO, "STATUS_RECURSIVE_DISPATCH"},
-        {STATUS_LPC_RECEIVE_BUFFER_EXPECTED, -EIO,
-        "STATUS_LPC_RECEIVE_BUFFER_EXPECTED"},
-        {STATUS_LPC_INVALID_CONNECTION_USAGE, -EIO,
-        "STATUS_LPC_INVALID_CONNECTION_USAGE"},
-        {STATUS_LPC_REQUESTS_NOT_ALLOWED, -EIO,
-        "STATUS_LPC_REQUESTS_NOT_ALLOWED"},
-        {STATUS_RESOURCE_IN_USE, -EIO, "STATUS_RESOURCE_IN_USE"},
-        {STATUS_HARDWARE_MEMORY_ERROR, -EIO, "STATUS_HARDWARE_MEMORY_ERROR"},
-        {STATUS_THREADPOOL_HANDLE_EXCEPTION, -EIO,
-        "STATUS_THREADPOOL_HANDLE_EXCEPTION"},
-        {STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED, -EIO,
-        "STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED"},
-        {STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED, -EIO,
-        "STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED"},
-        {STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED, -EIO,
-        "STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED"},
-        {STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED, -EIO,
-        "STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED"},
-        {STATUS_THREADPOOL_RELEASED_DURING_OPERATION, -EIO,
-        "STATUS_THREADPOOL_RELEASED_DURING_OPERATION"},
-        {STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING, -EIO,
-        "STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING"},
-        {STATUS_APC_RETURNED_WHILE_IMPERSONATING, -EIO,
-        "STATUS_APC_RETURNED_WHILE_IMPERSONATING"},
-        {STATUS_PROCESS_IS_PROTECTED, -EIO, "STATUS_PROCESS_IS_PROTECTED"},
-        {STATUS_MCA_EXCEPTION, -EIO, "STATUS_MCA_EXCEPTION"},
-        {STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE, -EIO,
-        "STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE"},
-        {STATUS_SYMLINK_CLASS_DISABLED, -EIO, "STATUS_SYMLINK_CLASS_DISABLED"},
-        {STATUS_INVALID_IDN_NORMALIZATION, -EIO,
-        "STATUS_INVALID_IDN_NORMALIZATION"},
-        {STATUS_NO_UNICODE_TRANSLATION, -EIO, "STATUS_NO_UNICODE_TRANSLATION"},
-        {STATUS_ALREADY_REGISTERED, -EIO, "STATUS_ALREADY_REGISTERED"},
-        {STATUS_CONTEXT_MISMATCH, -EIO, "STATUS_CONTEXT_MISMATCH"},
-        {STATUS_PORT_ALREADY_HAS_COMPLETION_LIST, -EIO,
-        "STATUS_PORT_ALREADY_HAS_COMPLETION_LIST"},
-        {STATUS_CALLBACK_RETURNED_THREAD_PRIORITY, -EIO,
-        "STATUS_CALLBACK_RETURNED_THREAD_PRIORITY"},
-        {STATUS_INVALID_THREAD, -EIO, "STATUS_INVALID_THREAD"},
-        {STATUS_CALLBACK_RETURNED_TRANSACTION, -EIO,
-        "STATUS_CALLBACK_RETURNED_TRANSACTION"},
-        {STATUS_CALLBACK_RETURNED_LDR_LOCK, -EIO,
-        "STATUS_CALLBACK_RETURNED_LDR_LOCK"},
-        {STATUS_CALLBACK_RETURNED_LANG, -EIO, "STATUS_CALLBACK_RETURNED_LANG"},
-        {STATUS_CALLBACK_RETURNED_PRI_BACK, -EIO,
-        "STATUS_CALLBACK_RETURNED_PRI_BACK"},
-        {STATUS_CALLBACK_RETURNED_THREAD_AFFINITY, -EIO,
-        "STATUS_CALLBACK_RETURNED_THREAD_AFFINITY"},
-        {STATUS_DISK_REPAIR_DISABLED, -EIO, "STATUS_DISK_REPAIR_DISABLED"},
-        {STATUS_DS_DOMAIN_RENAME_IN_PROGRESS, -EIO,
-        "STATUS_DS_DOMAIN_RENAME_IN_PROGRESS"},
-        {STATUS_DISK_QUOTA_EXCEEDED, -EDQUOT, "STATUS_DISK_QUOTA_EXCEEDED"},
-        {STATUS_CONTENT_BLOCKED, -EIO, "STATUS_CONTENT_BLOCKED"},
-        {STATUS_BAD_CLUSTERS, -EIO, "STATUS_BAD_CLUSTERS"},
-        {STATUS_VOLUME_DIRTY, -EIO, "STATUS_VOLUME_DIRTY"},
-        {STATUS_FILE_CHECKED_OUT, -EIO, "STATUS_FILE_CHECKED_OUT"},
-        {STATUS_CHECKOUT_REQUIRED, -EIO, "STATUS_CHECKOUT_REQUIRED"},
-        {STATUS_BAD_FILE_TYPE, -EIO, "STATUS_BAD_FILE_TYPE"},
-        {STATUS_FILE_TOO_LARGE, -EIO, "STATUS_FILE_TOO_LARGE"},
-        {STATUS_FORMS_AUTH_REQUIRED, -EIO, "STATUS_FORMS_AUTH_REQUIRED"},
-        {STATUS_VIRUS_INFECTED, -EIO, "STATUS_VIRUS_INFECTED"},
-        {STATUS_VIRUS_DELETED, -EIO, "STATUS_VIRUS_DELETED"},
-        {STATUS_BAD_MCFG_TABLE, -EIO, "STATUS_BAD_MCFG_TABLE"},
-        {STATUS_WOW_ASSERTION, -EIO, "STATUS_WOW_ASSERTION"},
-        {STATUS_INVALID_SIGNATURE, -EIO, "STATUS_INVALID_SIGNATURE"},
-        {STATUS_HMAC_NOT_SUPPORTED, -EIO, "STATUS_HMAC_NOT_SUPPORTED"},
-        {STATUS_IPSEC_QUEUE_OVERFLOW, -EIO, "STATUS_IPSEC_QUEUE_OVERFLOW"},
-        {STATUS_ND_QUEUE_OVERFLOW, -EIO, "STATUS_ND_QUEUE_OVERFLOW"},
-        {STATUS_HOPLIMIT_EXCEEDED, -EIO, "STATUS_HOPLIMIT_EXCEEDED"},
-        {STATUS_PROTOCOL_NOT_SUPPORTED, -EOPNOTSUPP,
-        "STATUS_PROTOCOL_NOT_SUPPORTED"},
-        {STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED, -EIO,
-        "STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED"},
-        {STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR, -EIO,
-        "STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR"},
-        {STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR, -EIO,
-        "STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR"},
-        {STATUS_XML_PARSE_ERROR, -EIO, "STATUS_XML_PARSE_ERROR"},
-        {STATUS_XMLDSIG_ERROR, -EIO, "STATUS_XMLDSIG_ERROR"},
-        {STATUS_WRONG_COMPARTMENT, -EIO, "STATUS_WRONG_COMPARTMENT"},
-        {STATUS_AUTHIP_FAILURE, -EIO, "STATUS_AUTHIP_FAILURE"},
-        {DBG_NO_STATE_CHANGE, -EIO, "DBG_NO_STATE_CHANGE"},
-        {DBG_APP_NOT_IDLE, -EIO, "DBG_APP_NOT_IDLE"},
-        {RPC_NT_INVALID_STRING_BINDING, -EIO, "RPC_NT_INVALID_STRING_BINDING"},
-        {RPC_NT_WRONG_KIND_OF_BINDING, -EIO, "RPC_NT_WRONG_KIND_OF_BINDING"},
-        {RPC_NT_INVALID_BINDING, -EIO, "RPC_NT_INVALID_BINDING"},
-        {RPC_NT_PROTSEQ_NOT_SUPPORTED, -EOPNOTSUPP,
-        "RPC_NT_PROTSEQ_NOT_SUPPORTED"},
-        {RPC_NT_INVALID_RPC_PROTSEQ, -EIO, "RPC_NT_INVALID_RPC_PROTSEQ"},
-        {RPC_NT_INVALID_STRING_UUID, -EIO, "RPC_NT_INVALID_STRING_UUID"},
-        {RPC_NT_INVALID_ENDPOINT_FORMAT, -EIO,
-        "RPC_NT_INVALID_ENDPOINT_FORMAT"},
-        {RPC_NT_INVALID_NET_ADDR, -EIO, "RPC_NT_INVALID_NET_ADDR"},
-        {RPC_NT_NO_ENDPOINT_FOUND, -EIO, "RPC_NT_NO_ENDPOINT_FOUND"},
-        {RPC_NT_INVALID_TIMEOUT, -EINVAL, "RPC_NT_INVALID_TIMEOUT"},
-        {RPC_NT_OBJECT_NOT_FOUND, -ENOENT, "RPC_NT_OBJECT_NOT_FOUND"},
-        {RPC_NT_ALREADY_REGISTERED, -EIO, "RPC_NT_ALREADY_REGISTERED"},
-        {RPC_NT_TYPE_ALREADY_REGISTERED, -EIO,
-        "RPC_NT_TYPE_ALREADY_REGISTERED"},
-        {RPC_NT_ALREADY_LISTENING, -EIO, "RPC_NT_ALREADY_LISTENING"},
-        {RPC_NT_NO_PROTSEQS_REGISTERED, -EIO, "RPC_NT_NO_PROTSEQS_REGISTERED"},
-        {RPC_NT_NOT_LISTENING, -EIO, "RPC_NT_NOT_LISTENING"},
-        {RPC_NT_UNKNOWN_MGR_TYPE, -EIO, "RPC_NT_UNKNOWN_MGR_TYPE"},
-        {RPC_NT_UNKNOWN_IF, -EIO, "RPC_NT_UNKNOWN_IF"},
-        {RPC_NT_NO_BINDINGS, -EIO, "RPC_NT_NO_BINDINGS"},
-        {RPC_NT_NO_PROTSEQS, -EIO, "RPC_NT_NO_PROTSEQS"},
-        {RPC_NT_CANT_CREATE_ENDPOINT, -EIO, "RPC_NT_CANT_CREATE_ENDPOINT"},
-        {RPC_NT_OUT_OF_RESOURCES, -EIO, "RPC_NT_OUT_OF_RESOURCES"},
-        {RPC_NT_SERVER_UNAVAILABLE, -EIO, "RPC_NT_SERVER_UNAVAILABLE"},
-        {RPC_NT_SERVER_TOO_BUSY, -EBUSY, "RPC_NT_SERVER_TOO_BUSY"},
-        {RPC_NT_INVALID_NETWORK_OPTIONS, -EIO,
-        "RPC_NT_INVALID_NETWORK_OPTIONS"},
-        {RPC_NT_NO_CALL_ACTIVE, -EIO, "RPC_NT_NO_CALL_ACTIVE"},
-        {RPC_NT_CALL_FAILED, -EIO, "RPC_NT_CALL_FAILED"},
-        {RPC_NT_CALL_FAILED_DNE, -EIO, "RPC_NT_CALL_FAILED_DNE"},
-        {RPC_NT_PROTOCOL_ERROR, -EIO, "RPC_NT_PROTOCOL_ERROR"},
-        {RPC_NT_UNSUPPORTED_TRANS_SYN, -EIO, "RPC_NT_UNSUPPORTED_TRANS_SYN"},
-        {RPC_NT_UNSUPPORTED_TYPE, -EIO, "RPC_NT_UNSUPPORTED_TYPE"},
-        {RPC_NT_INVALID_TAG, -EIO, "RPC_NT_INVALID_TAG"},
-        {RPC_NT_INVALID_BOUND, -EIO, "RPC_NT_INVALID_BOUND"},
-        {RPC_NT_NO_ENTRY_NAME, -EIO, "RPC_NT_NO_ENTRY_NAME"},
-        {RPC_NT_INVALID_NAME_SYNTAX, -EIO, "RPC_NT_INVALID_NAME_SYNTAX"},
-        {RPC_NT_UNSUPPORTED_NAME_SYNTAX, -EIO,
-        "RPC_NT_UNSUPPORTED_NAME_SYNTAX"},
-        {RPC_NT_UUID_NO_ADDRESS, -EIO, "RPC_NT_UUID_NO_ADDRESS"},
-        {RPC_NT_DUPLICATE_ENDPOINT, -ENOTUNIQ, "RPC_NT_DUPLICATE_ENDPOINT"},
-        {RPC_NT_UNKNOWN_AUTHN_TYPE, -EIO, "RPC_NT_UNKNOWN_AUTHN_TYPE"},
-        {RPC_NT_MAX_CALLS_TOO_SMALL, -EIO, "RPC_NT_MAX_CALLS_TOO_SMALL"},
-        {RPC_NT_STRING_TOO_LONG, -EIO, "RPC_NT_STRING_TOO_LONG"},
-        {RPC_NT_PROTSEQ_NOT_FOUND, -EIO, "RPC_NT_PROTSEQ_NOT_FOUND"},
-        {RPC_NT_PROCNUM_OUT_OF_RANGE, -EIO, "RPC_NT_PROCNUM_OUT_OF_RANGE"},
-        {RPC_NT_BINDING_HAS_NO_AUTH, -EIO, "RPC_NT_BINDING_HAS_NO_AUTH"},
-        {RPC_NT_UNKNOWN_AUTHN_SERVICE, -EIO, "RPC_NT_UNKNOWN_AUTHN_SERVICE"},
-        {RPC_NT_UNKNOWN_AUTHN_LEVEL, -EIO, "RPC_NT_UNKNOWN_AUTHN_LEVEL"},
-        {RPC_NT_INVALID_AUTH_IDENTITY, -EIO, "RPC_NT_INVALID_AUTH_IDENTITY"},
-        {RPC_NT_UNKNOWN_AUTHZ_SERVICE, -EIO, "RPC_NT_UNKNOWN_AUTHZ_SERVICE"},
-        {EPT_NT_INVALID_ENTRY, -EIO, "EPT_NT_INVALID_ENTRY"},
-        {EPT_NT_CANT_PERFORM_OP, -EIO, "EPT_NT_CANT_PERFORM_OP"},
-        {EPT_NT_NOT_REGISTERED, -EIO, "EPT_NT_NOT_REGISTERED"},
-        {RPC_NT_NOTHING_TO_EXPORT, -EIO, "RPC_NT_NOTHING_TO_EXPORT"},
-        {RPC_NT_INCOMPLETE_NAME, -EIO, "RPC_NT_INCOMPLETE_NAME"},
-        {RPC_NT_INVALID_VERS_OPTION, -EIO, "RPC_NT_INVALID_VERS_OPTION"},
-        {RPC_NT_NO_MORE_MEMBERS, -EIO, "RPC_NT_NO_MORE_MEMBERS"},
-        {RPC_NT_NOT_ALL_OBJS_UNEXPORTED, -EIO,
-        "RPC_NT_NOT_ALL_OBJS_UNEXPORTED"},
-        {RPC_NT_INTERFACE_NOT_FOUND, -EIO, "RPC_NT_INTERFACE_NOT_FOUND"},
-        {RPC_NT_ENTRY_ALREADY_EXISTS, -EIO, "RPC_NT_ENTRY_ALREADY_EXISTS"},
-        {RPC_NT_ENTRY_NOT_FOUND, -EIO, "RPC_NT_ENTRY_NOT_FOUND"},
-        {RPC_NT_NAME_SERVICE_UNAVAILABLE, -EIO,
-        "RPC_NT_NAME_SERVICE_UNAVAILABLE"},
-        {RPC_NT_INVALID_NAF_ID, -EIO, "RPC_NT_INVALID_NAF_ID"},
-        {RPC_NT_CANNOT_SUPPORT, -EOPNOTSUPP, "RPC_NT_CANNOT_SUPPORT"},
-        {RPC_NT_NO_CONTEXT_AVAILABLE, -EIO, "RPC_NT_NO_CONTEXT_AVAILABLE"},
-        {RPC_NT_INTERNAL_ERROR, -EIO, "RPC_NT_INTERNAL_ERROR"},
-        {RPC_NT_ZERO_DIVIDE, -EIO, "RPC_NT_ZERO_DIVIDE"},
-        {RPC_NT_ADDRESS_ERROR, -EIO, "RPC_NT_ADDRESS_ERROR"},
-        {RPC_NT_FP_DIV_ZERO, -EIO, "RPC_NT_FP_DIV_ZERO"},
-        {RPC_NT_FP_UNDERFLOW, -EIO, "RPC_NT_FP_UNDERFLOW"},
-        {RPC_NT_FP_OVERFLOW, -EIO, "RPC_NT_FP_OVERFLOW"},
-        {RPC_NT_CALL_IN_PROGRESS, -EIO, "RPC_NT_CALL_IN_PROGRESS"},
-        {RPC_NT_NO_MORE_BINDINGS, -EIO, "RPC_NT_NO_MORE_BINDINGS"},
-        {RPC_NT_GROUP_MEMBER_NOT_FOUND, -EIO, "RPC_NT_GROUP_MEMBER_NOT_FOUND"},
-        {EPT_NT_CANT_CREATE, -EIO, "EPT_NT_CANT_CREATE"},
-        {RPC_NT_INVALID_OBJECT, -EIO, "RPC_NT_INVALID_OBJECT"},
-        {RPC_NT_NO_INTERFACES, -EIO, "RPC_NT_NO_INTERFACES"},
-        {RPC_NT_CALL_CANCELLED, -EIO, "RPC_NT_CALL_CANCELLED"},
-        {RPC_NT_BINDING_INCOMPLETE, -EIO, "RPC_NT_BINDING_INCOMPLETE"},
-        {RPC_NT_COMM_FAILURE, -EIO, "RPC_NT_COMM_FAILURE"},
-        {RPC_NT_UNSUPPORTED_AUTHN_LEVEL, -EIO,
-        "RPC_NT_UNSUPPORTED_AUTHN_LEVEL"},
-        {RPC_NT_NO_PRINC_NAME, -EIO, "RPC_NT_NO_PRINC_NAME"},
-        {RPC_NT_NOT_RPC_ERROR, -EIO, "RPC_NT_NOT_RPC_ERROR"},
-        {RPC_NT_SEC_PKG_ERROR, -EIO, "RPC_NT_SEC_PKG_ERROR"},
-        {RPC_NT_NOT_CANCELLED, -EIO, "RPC_NT_NOT_CANCELLED"},
-        {RPC_NT_INVALID_ASYNC_HANDLE, -EIO, "RPC_NT_INVALID_ASYNC_HANDLE"},
-        {RPC_NT_INVALID_ASYNC_CALL, -EIO, "RPC_NT_INVALID_ASYNC_CALL"},
-        {RPC_NT_PROXY_ACCESS_DENIED, -EACCES, "RPC_NT_PROXY_ACCESS_DENIED"},
-        {RPC_NT_NO_MORE_ENTRIES, -EIO, "RPC_NT_NO_MORE_ENTRIES"},
-        {RPC_NT_SS_CHAR_TRANS_OPEN_FAIL, -EIO,
-        "RPC_NT_SS_CHAR_TRANS_OPEN_FAIL"},
-        {RPC_NT_SS_CHAR_TRANS_SHORT_FILE, -EIO,
-        "RPC_NT_SS_CHAR_TRANS_SHORT_FILE"},
-        {RPC_NT_SS_IN_NULL_CONTEXT, -EIO, "RPC_NT_SS_IN_NULL_CONTEXT"},
-        {RPC_NT_SS_CONTEXT_MISMATCH, -EIO, "RPC_NT_SS_CONTEXT_MISMATCH"},
-        {RPC_NT_SS_CONTEXT_DAMAGED, -EIO, "RPC_NT_SS_CONTEXT_DAMAGED"},
-        {RPC_NT_SS_HANDLES_MISMATCH, -EIO, "RPC_NT_SS_HANDLES_MISMATCH"},
-        {RPC_NT_SS_CANNOT_GET_CALL_HANDLE, -EIO,
-        "RPC_NT_SS_CANNOT_GET_CALL_HANDLE"},
-        {RPC_NT_NULL_REF_POINTER, -EIO, "RPC_NT_NULL_REF_POINTER"},
-        {RPC_NT_ENUM_VALUE_OUT_OF_RANGE, -EIO,
-        "RPC_NT_ENUM_VALUE_OUT_OF_RANGE"},
-        {RPC_NT_BYTE_COUNT_TOO_SMALL, -EIO, "RPC_NT_BYTE_COUNT_TOO_SMALL"},
-        {RPC_NT_BAD_STUB_DATA, -EIO, "RPC_NT_BAD_STUB_DATA"},
-        {RPC_NT_INVALID_ES_ACTION, -EIO, "RPC_NT_INVALID_ES_ACTION"},
-        {RPC_NT_WRONG_ES_VERSION, -EIO, "RPC_NT_WRONG_ES_VERSION"},
-        {RPC_NT_WRONG_STUB_VERSION, -EIO, "RPC_NT_WRONG_STUB_VERSION"},
-        {RPC_NT_INVALID_PIPE_OBJECT, -EIO, "RPC_NT_INVALID_PIPE_OBJECT"},
-        {RPC_NT_INVALID_PIPE_OPERATION, -EIO, "RPC_NT_INVALID_PIPE_OPERATION"},
-        {RPC_NT_WRONG_PIPE_VERSION, -EIO, "RPC_NT_WRONG_PIPE_VERSION"},
-        {RPC_NT_PIPE_CLOSED, -EIO, "RPC_NT_PIPE_CLOSED"},
-        {RPC_NT_PIPE_DISCIPLINE_ERROR, -EIO, "RPC_NT_PIPE_DISCIPLINE_ERROR"},
-        {RPC_NT_PIPE_EMPTY, -EIO, "RPC_NT_PIPE_EMPTY"},
-        {STATUS_PNP_BAD_MPS_TABLE, -EIO, "STATUS_PNP_BAD_MPS_TABLE"},
-        {STATUS_PNP_TRANSLATION_FAILED, -EIO, "STATUS_PNP_TRANSLATION_FAILED"},
-        {STATUS_PNP_IRQ_TRANSLATION_FAILED, -EIO,
-        "STATUS_PNP_IRQ_TRANSLATION_FAILED"},
-        {STATUS_PNP_INVALID_ID, -EIO, "STATUS_PNP_INVALID_ID"},
-        {STATUS_IO_REISSUE_AS_CACHED, -EIO, "STATUS_IO_REISSUE_AS_CACHED"},
-        {STATUS_CTX_WINSTATION_NAME_INVALID, -EIO,
-        "STATUS_CTX_WINSTATION_NAME_INVALID"},
-        {STATUS_CTX_INVALID_PD, -EIO, "STATUS_CTX_INVALID_PD"},
-        {STATUS_CTX_PD_NOT_FOUND, -EIO, "STATUS_CTX_PD_NOT_FOUND"},
-        {STATUS_CTX_CLOSE_PENDING, -EIO, "STATUS_CTX_CLOSE_PENDING"},
-        {STATUS_CTX_NO_OUTBUF, -EIO, "STATUS_CTX_NO_OUTBUF"},
-        {STATUS_CTX_MODEM_INF_NOT_FOUND, -EIO,
-        "STATUS_CTX_MODEM_INF_NOT_FOUND"},
-        {STATUS_CTX_INVALID_MODEMNAME, -EIO, "STATUS_CTX_INVALID_MODEMNAME"},
-        {STATUS_CTX_RESPONSE_ERROR, -EIO, "STATUS_CTX_RESPONSE_ERROR"},
-        {STATUS_CTX_MODEM_RESPONSE_TIMEOUT, -ETIMEDOUT,
-        "STATUS_CTX_MODEM_RESPONSE_TIMEOUT"},
-        {STATUS_CTX_MODEM_RESPONSE_NO_CARRIER, -EIO,
-        "STATUS_CTX_MODEM_RESPONSE_NO_CARRIER"},
-        {STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE, -EIO,
-        "STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE"},
-        {STATUS_CTX_MODEM_RESPONSE_BUSY, -EBUSY,
-        "STATUS_CTX_MODEM_RESPONSE_BUSY"},
-        {STATUS_CTX_MODEM_RESPONSE_VOICE, -EIO,
-        "STATUS_CTX_MODEM_RESPONSE_VOICE"},
-        {STATUS_CTX_TD_ERROR, -EIO, "STATUS_CTX_TD_ERROR"},
-        {STATUS_CTX_LICENSE_CLIENT_INVALID, -EIO,
-        "STATUS_CTX_LICENSE_CLIENT_INVALID"},
-        {STATUS_CTX_LICENSE_NOT_AVAILABLE, -EIO,
-        "STATUS_CTX_LICENSE_NOT_AVAILABLE"},
-        {STATUS_CTX_LICENSE_EXPIRED, -EIO, "STATUS_CTX_LICENSE_EXPIRED"},
-        {STATUS_CTX_WINSTATION_NOT_FOUND, -EIO,
-        "STATUS_CTX_WINSTATION_NOT_FOUND"},
-        {STATUS_CTX_WINSTATION_NAME_COLLISION, -EIO,
-        "STATUS_CTX_WINSTATION_NAME_COLLISION"},
-        {STATUS_CTX_WINSTATION_BUSY, -EBUSY, "STATUS_CTX_WINSTATION_BUSY"},
-        {STATUS_CTX_BAD_VIDEO_MODE, -EIO, "STATUS_CTX_BAD_VIDEO_MODE"},
-        {STATUS_CTX_GRAPHICS_INVALID, -EIO, "STATUS_CTX_GRAPHICS_INVALID"},
-        {STATUS_CTX_NOT_CONSOLE, -EIO, "STATUS_CTX_NOT_CONSOLE"},
-        {STATUS_CTX_CLIENT_QUERY_TIMEOUT, -EIO,
-        "STATUS_CTX_CLIENT_QUERY_TIMEOUT"},
-        {STATUS_CTX_CONSOLE_DISCONNECT, -EIO, "STATUS_CTX_CONSOLE_DISCONNECT"},
-        {STATUS_CTX_CONSOLE_CONNECT, -EIO, "STATUS_CTX_CONSOLE_CONNECT"},
-        {STATUS_CTX_SHADOW_DENIED, -EIO, "STATUS_CTX_SHADOW_DENIED"},
-        {STATUS_CTX_WINSTATION_ACCESS_DENIED, -EACCES,
-        "STATUS_CTX_WINSTATION_ACCESS_DENIED"},
-        {STATUS_CTX_INVALID_WD, -EIO, "STATUS_CTX_INVALID_WD"},
-        {STATUS_CTX_WD_NOT_FOUND, -EIO, "STATUS_CTX_WD_NOT_FOUND"},
-        {STATUS_CTX_SHADOW_INVALID, -EIO, "STATUS_CTX_SHADOW_INVALID"},
-        {STATUS_CTX_SHADOW_DISABLED, -EIO, "STATUS_CTX_SHADOW_DISABLED"},
-        {STATUS_RDP_PROTOCOL_ERROR, -EIO, "STATUS_RDP_PROTOCOL_ERROR"},
-        {STATUS_CTX_CLIENT_LICENSE_NOT_SET, -EIO,
-        "STATUS_CTX_CLIENT_LICENSE_NOT_SET"},
-        {STATUS_CTX_CLIENT_LICENSE_IN_USE, -EIO,
-        "STATUS_CTX_CLIENT_LICENSE_IN_USE"},
-        {STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE, -EIO,
-        "STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE"},
-        {STATUS_CTX_SHADOW_NOT_RUNNING, -EIO, "STATUS_CTX_SHADOW_NOT_RUNNING"},
-        {STATUS_CTX_LOGON_DISABLED, -EIO, "STATUS_CTX_LOGON_DISABLED"},
-        {STATUS_CTX_SECURITY_LAYER_ERROR, -EIO,
-        "STATUS_CTX_SECURITY_LAYER_ERROR"},
-        {STATUS_TS_INCOMPATIBLE_SESSIONS, -EIO,
-        "STATUS_TS_INCOMPATIBLE_SESSIONS"},
-        {STATUS_MUI_FILE_NOT_FOUND, -EIO, "STATUS_MUI_FILE_NOT_FOUND"},
-        {STATUS_MUI_INVALID_FILE, -EIO, "STATUS_MUI_INVALID_FILE"},
-        {STATUS_MUI_INVALID_RC_CONFIG, -EIO, "STATUS_MUI_INVALID_RC_CONFIG"},
-        {STATUS_MUI_INVALID_LOCALE_NAME, -EIO,
-        "STATUS_MUI_INVALID_LOCALE_NAME"},
-        {STATUS_MUI_INVALID_ULTIMATEFALLBACK_NAME, -EIO,
-        "STATUS_MUI_INVALID_ULTIMATEFALLBACK_NAME"},
-        {STATUS_MUI_FILE_NOT_LOADED, -EIO, "STATUS_MUI_FILE_NOT_LOADED"},
-        {STATUS_RESOURCE_ENUM_USER_STOP, -EIO,
-        "STATUS_RESOURCE_ENUM_USER_STOP"},
-        {STATUS_CLUSTER_INVALID_NODE, -EIO, "STATUS_CLUSTER_INVALID_NODE"},
-        {STATUS_CLUSTER_NODE_EXISTS, -EIO, "STATUS_CLUSTER_NODE_EXISTS"},
-        {STATUS_CLUSTER_JOIN_IN_PROGRESS, -EIO,
-        "STATUS_CLUSTER_JOIN_IN_PROGRESS"},
-        {STATUS_CLUSTER_NODE_NOT_FOUND, -EIO, "STATUS_CLUSTER_NODE_NOT_FOUND"},
-        {STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND, -EIO,
-        "STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND"},
-        {STATUS_CLUSTER_NETWORK_EXISTS, -EIO, "STATUS_CLUSTER_NETWORK_EXISTS"},
-        {STATUS_CLUSTER_NETWORK_NOT_FOUND, -EIO,
-        "STATUS_CLUSTER_NETWORK_NOT_FOUND"},
-        {STATUS_CLUSTER_NETINTERFACE_EXISTS, -EIO,
-        "STATUS_CLUSTER_NETINTERFACE_EXISTS"},
-        {STATUS_CLUSTER_NETINTERFACE_NOT_FOUND, -EIO,
-        "STATUS_CLUSTER_NETINTERFACE_NOT_FOUND"},
-        {STATUS_CLUSTER_INVALID_REQUEST, -EIO,
-        "STATUS_CLUSTER_INVALID_REQUEST"},
-        {STATUS_CLUSTER_INVALID_NETWORK_PROVIDER, -EIO,
-        "STATUS_CLUSTER_INVALID_NETWORK_PROVIDER"},
-        {STATUS_CLUSTER_NODE_DOWN, -EIO, "STATUS_CLUSTER_NODE_DOWN"},
-        {STATUS_CLUSTER_NODE_UNREACHABLE, -EIO,
-        "STATUS_CLUSTER_NODE_UNREACHABLE"},
-        {STATUS_CLUSTER_NODE_NOT_MEMBER, -EIO,
-        "STATUS_CLUSTER_NODE_NOT_MEMBER"},
-        {STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS, -EIO,
-        "STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS"},
-        {STATUS_CLUSTER_INVALID_NETWORK, -EIO,
-        "STATUS_CLUSTER_INVALID_NETWORK"},
-        {STATUS_CLUSTER_NO_NET_ADAPTERS, -EIO,
-        "STATUS_CLUSTER_NO_NET_ADAPTERS"},
-        {STATUS_CLUSTER_NODE_UP, -EIO, "STATUS_CLUSTER_NODE_UP"},
-        {STATUS_CLUSTER_NODE_PAUSED, -EIO, "STATUS_CLUSTER_NODE_PAUSED"},
-        {STATUS_CLUSTER_NODE_NOT_PAUSED, -EIO,
-        "STATUS_CLUSTER_NODE_NOT_PAUSED"},
-        {STATUS_CLUSTER_NO_SECURITY_CONTEXT, -EIO,
-        "STATUS_CLUSTER_NO_SECURITY_CONTEXT"},
-        {STATUS_CLUSTER_NETWORK_NOT_INTERNAL, -EIO,
-        "STATUS_CLUSTER_NETWORK_NOT_INTERNAL"},
-        {STATUS_CLUSTER_POISONED, -EIO, "STATUS_CLUSTER_POISONED"},
-        {STATUS_ACPI_INVALID_OPCODE, -EIO, "STATUS_ACPI_INVALID_OPCODE"},
-        {STATUS_ACPI_STACK_OVERFLOW, -EIO, "STATUS_ACPI_STACK_OVERFLOW"},
-        {STATUS_ACPI_ASSERT_FAILED, -EIO, "STATUS_ACPI_ASSERT_FAILED"},
-        {STATUS_ACPI_INVALID_INDEX, -EIO, "STATUS_ACPI_INVALID_INDEX"},
-        {STATUS_ACPI_INVALID_ARGUMENT, -EIO, "STATUS_ACPI_INVALID_ARGUMENT"},
-        {STATUS_ACPI_FATAL, -EIO, "STATUS_ACPI_FATAL"},
-        {STATUS_ACPI_INVALID_SUPERNAME, -EIO, "STATUS_ACPI_INVALID_SUPERNAME"},
-        {STATUS_ACPI_INVALID_ARGTYPE, -EIO, "STATUS_ACPI_INVALID_ARGTYPE"},
-        {STATUS_ACPI_INVALID_OBJTYPE, -EIO, "STATUS_ACPI_INVALID_OBJTYPE"},
-        {STATUS_ACPI_INVALID_TARGETTYPE, -EIO,
-        "STATUS_ACPI_INVALID_TARGETTYPE"},
-        {STATUS_ACPI_INCORRECT_ARGUMENT_COUNT, -EIO,
-        "STATUS_ACPI_INCORRECT_ARGUMENT_COUNT"},
-        {STATUS_ACPI_ADDRESS_NOT_MAPPED, -EIO,
-        "STATUS_ACPI_ADDRESS_NOT_MAPPED"},
-        {STATUS_ACPI_INVALID_EVENTTYPE, -EIO, "STATUS_ACPI_INVALID_EVENTTYPE"},
-        {STATUS_ACPI_HANDLER_COLLISION, -EIO, "STATUS_ACPI_HANDLER_COLLISION"},
-        {STATUS_ACPI_INVALID_DATA, -EIO, "STATUS_ACPI_INVALID_DATA"},
-        {STATUS_ACPI_INVALID_REGION, -EIO, "STATUS_ACPI_INVALID_REGION"},
-        {STATUS_ACPI_INVALID_ACCESS_SIZE, -EIO,
-        "STATUS_ACPI_INVALID_ACCESS_SIZE"},
-        {STATUS_ACPI_ACQUIRE_GLOBAL_LOCK, -EIO,
-        "STATUS_ACPI_ACQUIRE_GLOBAL_LOCK"},
-        {STATUS_ACPI_ALREADY_INITIALIZED, -EIO,
-        "STATUS_ACPI_ALREADY_INITIALIZED"},
-        {STATUS_ACPI_NOT_INITIALIZED, -EIO, "STATUS_ACPI_NOT_INITIALIZED"},
-        {STATUS_ACPI_INVALID_MUTEX_LEVEL, -EIO,
-        "STATUS_ACPI_INVALID_MUTEX_LEVEL"},
-        {STATUS_ACPI_MUTEX_NOT_OWNED, -EIO, "STATUS_ACPI_MUTEX_NOT_OWNED"},
-        {STATUS_ACPI_MUTEX_NOT_OWNER, -EIO, "STATUS_ACPI_MUTEX_NOT_OWNER"},
-        {STATUS_ACPI_RS_ACCESS, -EIO, "STATUS_ACPI_RS_ACCESS"},
-        {STATUS_ACPI_INVALID_TABLE, -EIO, "STATUS_ACPI_INVALID_TABLE"},
-        {STATUS_ACPI_REG_HANDLER_FAILED, -EIO,
-        "STATUS_ACPI_REG_HANDLER_FAILED"},
-        {STATUS_ACPI_POWER_REQUEST_FAILED, -EIO,
-        "STATUS_ACPI_POWER_REQUEST_FAILED"},
-        {STATUS_SXS_SECTION_NOT_FOUND, -EIO, "STATUS_SXS_SECTION_NOT_FOUND"},
-        {STATUS_SXS_CANT_GEN_ACTCTX, -EIO, "STATUS_SXS_CANT_GEN_ACTCTX"},
-        {STATUS_SXS_INVALID_ACTCTXDATA_FORMAT, -EIO,
-        "STATUS_SXS_INVALID_ACTCTXDATA_FORMAT"},
-        {STATUS_SXS_ASSEMBLY_NOT_FOUND, -EIO, "STATUS_SXS_ASSEMBLY_NOT_FOUND"},
-        {STATUS_SXS_MANIFEST_FORMAT_ERROR, -EIO,
-        "STATUS_SXS_MANIFEST_FORMAT_ERROR"},
-        {STATUS_SXS_MANIFEST_PARSE_ERROR, -EIO,
-        "STATUS_SXS_MANIFEST_PARSE_ERROR"},
-        {STATUS_SXS_ACTIVATION_CONTEXT_DISABLED, -EIO,
-        "STATUS_SXS_ACTIVATION_CONTEXT_DISABLED"},
-        {STATUS_SXS_KEY_NOT_FOUND, -EIO, "STATUS_SXS_KEY_NOT_FOUND"},
-        {STATUS_SXS_VERSION_CONFLICT, -EIO, "STATUS_SXS_VERSION_CONFLICT"},
-        {STATUS_SXS_WRONG_SECTION_TYPE, -EIO, "STATUS_SXS_WRONG_SECTION_TYPE"},
-        {STATUS_SXS_THREAD_QUERIES_DISABLED, -EIO,
-        "STATUS_SXS_THREAD_QUERIES_DISABLED"},
-        {STATUS_SXS_ASSEMBLY_MISSING, -EIO, "STATUS_SXS_ASSEMBLY_MISSING"},
-        {STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET, -EIO,
-        "STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET"},
-        {STATUS_SXS_EARLY_DEACTIVATION, -EIO, "STATUS_SXS_EARLY_DEACTIVATION"},
-        {STATUS_SXS_INVALID_DEACTIVATION, -EIO,
-        "STATUS_SXS_INVALID_DEACTIVATION"},
-        {STATUS_SXS_MULTIPLE_DEACTIVATION, -EIO,
-        "STATUS_SXS_MULTIPLE_DEACTIVATION"},
-        {STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY, -EIO,
-        "STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY"},
-        {STATUS_SXS_PROCESS_TERMINATION_REQUESTED, -EIO,
-        "STATUS_SXS_PROCESS_TERMINATION_REQUESTED"},
-        {STATUS_SXS_CORRUPT_ACTIVATION_STACK, -EIO,
-        "STATUS_SXS_CORRUPT_ACTIVATION_STACK"},
-        {STATUS_SXS_CORRUPTION, -EIO, "STATUS_SXS_CORRUPTION"},
-        {STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE, -EIO,
-        "STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE"},
-        {STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME, -EIO,
-        "STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME"},
-        {STATUS_SXS_IDENTITY_DUPLICATE_ATTRIBUTE, -EIO,
-        "STATUS_SXS_IDENTITY_DUPLICATE_ATTRIBUTE"},
-        {STATUS_SXS_IDENTITY_PARSE_ERROR, -EIO,
-        "STATUS_SXS_IDENTITY_PARSE_ERROR"},
-        {STATUS_SXS_COMPONENT_STORE_CORRUPT, -EIO,
-        "STATUS_SXS_COMPONENT_STORE_CORRUPT"},
-        {STATUS_SXS_FILE_HASH_MISMATCH, -EIO, "STATUS_SXS_FILE_HASH_MISMATCH"},
-        {STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT, -EIO,
-        "STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT"},
-        {STATUS_SXS_IDENTITIES_DIFFERENT, -EIO,
-        "STATUS_SXS_IDENTITIES_DIFFERENT"},
-        {STATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT, -EIO,
-        "STATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT"},
-        {STATUS_SXS_FILE_NOT_PART_OF_ASSEMBLY, -EIO,
-        "STATUS_SXS_FILE_NOT_PART_OF_ASSEMBLY"},
-        {STATUS_ADVANCED_INSTALLER_FAILED, -EIO,
-        "STATUS_ADVANCED_INSTALLER_FAILED"},
-        {STATUS_XML_ENCODING_MISMATCH, -EIO, "STATUS_XML_ENCODING_MISMATCH"},
-        {STATUS_SXS_MANIFEST_TOO_BIG, -EIO, "STATUS_SXS_MANIFEST_TOO_BIG"},
-        {STATUS_SXS_SETTING_NOT_REGISTERED, -EIO,
-        "STATUS_SXS_SETTING_NOT_REGISTERED"},
-        {STATUS_SXS_TRANSACTION_CLOSURE_INCOMPLETE, -EIO,
-        "STATUS_SXS_TRANSACTION_CLOSURE_INCOMPLETE"},
-        {STATUS_SMI_PRIMITIVE_INSTALLER_FAILED, -EIO,
-        "STATUS_SMI_PRIMITIVE_INSTALLER_FAILED"},
-        {STATUS_GENERIC_COMMAND_FAILED, -EIO, "STATUS_GENERIC_COMMAND_FAILED"},
-        {STATUS_SXS_FILE_HASH_MISSING, -EIO, "STATUS_SXS_FILE_HASH_MISSING"},
-        {STATUS_TRANSACTIONAL_CONFLICT, -EIO, "STATUS_TRANSACTIONAL_CONFLICT"},
-        {STATUS_INVALID_TRANSACTION, -EIO, "STATUS_INVALID_TRANSACTION"},
-        {STATUS_TRANSACTION_NOT_ACTIVE, -EIO, "STATUS_TRANSACTION_NOT_ACTIVE"},
-        {STATUS_TM_INITIALIZATION_FAILED, -EIO,
-        "STATUS_TM_INITIALIZATION_FAILED"},
-        {STATUS_RM_NOT_ACTIVE, -EIO, "STATUS_RM_NOT_ACTIVE"},
-        {STATUS_RM_METADATA_CORRUPT, -EIO, "STATUS_RM_METADATA_CORRUPT"},
-        {STATUS_TRANSACTION_NOT_JOINED, -EIO, "STATUS_TRANSACTION_NOT_JOINED"},
-        {STATUS_DIRECTORY_NOT_RM, -EIO, "STATUS_DIRECTORY_NOT_RM"},
-        {STATUS_TRANSACTIONS_UNSUPPORTED_REMOTE, -EIO,
-        "STATUS_TRANSACTIONS_UNSUPPORTED_REMOTE"},
-        {STATUS_LOG_RESIZE_INVALID_SIZE, -EIO,
-        "STATUS_LOG_RESIZE_INVALID_SIZE"},
-        {STATUS_REMOTE_FILE_VERSION_MISMATCH, -EIO,
-        "STATUS_REMOTE_FILE_VERSION_MISMATCH"},
-        {STATUS_CRM_PROTOCOL_ALREADY_EXISTS, -EIO,
-        "STATUS_CRM_PROTOCOL_ALREADY_EXISTS"},
-        {STATUS_TRANSACTION_PROPAGATION_FAILED, -EIO,
-        "STATUS_TRANSACTION_PROPAGATION_FAILED"},
-        {STATUS_CRM_PROTOCOL_NOT_FOUND, -EIO, "STATUS_CRM_PROTOCOL_NOT_FOUND"},
-        {STATUS_TRANSACTION_SUPERIOR_EXISTS, -EIO,
-        "STATUS_TRANSACTION_SUPERIOR_EXISTS"},
-        {STATUS_TRANSACTION_REQUEST_NOT_VALID, -EIO,
-        "STATUS_TRANSACTION_REQUEST_NOT_VALID"},
-        {STATUS_TRANSACTION_NOT_REQUESTED, -EIO,
-        "STATUS_TRANSACTION_NOT_REQUESTED"},
-        {STATUS_TRANSACTION_ALREADY_ABORTED, -EIO,
-        "STATUS_TRANSACTION_ALREADY_ABORTED"},
-        {STATUS_TRANSACTION_ALREADY_COMMITTED, -EIO,
-        "STATUS_TRANSACTION_ALREADY_COMMITTED"},
-        {STATUS_TRANSACTION_INVALID_MARSHALL_BUFFER, -EIO,
-        "STATUS_TRANSACTION_INVALID_MARSHALL_BUFFER"},
-        {STATUS_CURRENT_TRANSACTION_NOT_VALID, -EIO,
-        "STATUS_CURRENT_TRANSACTION_NOT_VALID"},
-        {STATUS_LOG_GROWTH_FAILED, -EIO, "STATUS_LOG_GROWTH_FAILED"},
-        {STATUS_OBJECT_NO_LONGER_EXISTS, -EIO,
-        "STATUS_OBJECT_NO_LONGER_EXISTS"},
-        {STATUS_STREAM_MINIVERSION_NOT_FOUND, -EIO,
-        "STATUS_STREAM_MINIVERSION_NOT_FOUND"},
-        {STATUS_STREAM_MINIVERSION_NOT_VALID, -EIO,
-        "STATUS_STREAM_MINIVERSION_NOT_VALID"},
-        {STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION, -EIO,
-        "STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION"},
-        {STATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT, -EIO,
-        "STATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT"},
-        {STATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONS, -EIO,
-        "STATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONS"},
-        {STATUS_HANDLE_NO_LONGER_VALID, -EIO, "STATUS_HANDLE_NO_LONGER_VALID"},
-        {STATUS_LOG_CORRUPTION_DETECTED, -EIO,
-        "STATUS_LOG_CORRUPTION_DETECTED"},
-        {STATUS_RM_DISCONNECTED, -EIO, "STATUS_RM_DISCONNECTED"},
-        {STATUS_ENLISTMENT_NOT_SUPERIOR, -EIO,
-        "STATUS_ENLISTMENT_NOT_SUPERIOR"},
-        {STATUS_FILE_IDENTITY_NOT_PERSISTENT, -EIO,
-        "STATUS_FILE_IDENTITY_NOT_PERSISTENT"},
-        {STATUS_CANT_BREAK_TRANSACTIONAL_DEPENDENCY, -EIO,
-        "STATUS_CANT_BREAK_TRANSACTIONAL_DEPENDENCY"},
-        {STATUS_CANT_CROSS_RM_BOUNDARY, -EIO, "STATUS_CANT_CROSS_RM_BOUNDARY"},
-        {STATUS_TXF_DIR_NOT_EMPTY, -EIO, "STATUS_TXF_DIR_NOT_EMPTY"},
-        {STATUS_INDOUBT_TRANSACTIONS_EXIST, -EIO,
-        "STATUS_INDOUBT_TRANSACTIONS_EXIST"},
-        {STATUS_TM_VOLATILE, -EIO, "STATUS_TM_VOLATILE"},
-        {STATUS_ROLLBACK_TIMER_EXPIRED, -EIO, "STATUS_ROLLBACK_TIMER_EXPIRED"},
-        {STATUS_TXF_ATTRIBUTE_CORRUPT, -EIO, "STATUS_TXF_ATTRIBUTE_CORRUPT"},
-        {STATUS_EFS_NOT_ALLOWED_IN_TRANSACTION, -EIO,
-        "STATUS_EFS_NOT_ALLOWED_IN_TRANSACTION"},
-        {STATUS_TRANSACTIONAL_OPEN_NOT_ALLOWED, -EIO,
-        "STATUS_TRANSACTIONAL_OPEN_NOT_ALLOWED"},
-        {STATUS_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE, -EIO,
-        "STATUS_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE"},
-        {STATUS_TRANSACTION_REQUIRED_PROMOTION, -EIO,
-        "STATUS_TRANSACTION_REQUIRED_PROMOTION"},
-        {STATUS_CANNOT_EXECUTE_FILE_IN_TRANSACTION, -EIO,
-        "STATUS_CANNOT_EXECUTE_FILE_IN_TRANSACTION"},
-        {STATUS_TRANSACTIONS_NOT_FROZEN, -EIO,
-        "STATUS_TRANSACTIONS_NOT_FROZEN"},
-        {STATUS_TRANSACTION_FREEZE_IN_PROGRESS, -EIO,
-        "STATUS_TRANSACTION_FREEZE_IN_PROGRESS"},
-        {STATUS_NOT_SNAPSHOT_VOLUME, -EIO, "STATUS_NOT_SNAPSHOT_VOLUME"},
-        {STATUS_NO_SAVEPOINT_WITH_OPEN_FILES, -EIO,
-        "STATUS_NO_SAVEPOINT_WITH_OPEN_FILES"},
-        {STATUS_SPARSE_NOT_ALLOWED_IN_TRANSACTION, -EIO,
-        "STATUS_SPARSE_NOT_ALLOWED_IN_TRANSACTION"},
-        {STATUS_TM_IDENTITY_MISMATCH, -EIO, "STATUS_TM_IDENTITY_MISMATCH"},
-        {STATUS_FLOATED_SECTION, -EIO, "STATUS_FLOATED_SECTION"},
-        {STATUS_CANNOT_ACCEPT_TRANSACTED_WORK, -EIO,
-        "STATUS_CANNOT_ACCEPT_TRANSACTED_WORK"},
-        {STATUS_CANNOT_ABORT_TRANSACTIONS, -EIO,
-        "STATUS_CANNOT_ABORT_TRANSACTIONS"},
-        {STATUS_TRANSACTION_NOT_FOUND, -EIO, "STATUS_TRANSACTION_NOT_FOUND"},
-        {STATUS_RESOURCEMANAGER_NOT_FOUND, -EIO,
-        "STATUS_RESOURCEMANAGER_NOT_FOUND"},
-        {STATUS_ENLISTMENT_NOT_FOUND, -EIO, "STATUS_ENLISTMENT_NOT_FOUND"},
-        {STATUS_TRANSACTIONMANAGER_NOT_FOUND, -EIO,
-        "STATUS_TRANSACTIONMANAGER_NOT_FOUND"},
-        {STATUS_TRANSACTIONMANAGER_NOT_ONLINE, -EIO,
-        "STATUS_TRANSACTIONMANAGER_NOT_ONLINE"},
-        {STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION, -EIO,
-        "STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION"},
-        {STATUS_TRANSACTION_NOT_ROOT, -EIO, "STATUS_TRANSACTION_NOT_ROOT"},
-        {STATUS_TRANSACTION_OBJECT_EXPIRED, -EIO,
-        "STATUS_TRANSACTION_OBJECT_EXPIRED"},
-        {STATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION, -EIO,
-        "STATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION"},
-        {STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED, -EIO,
-        "STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED"},
-        {STATUS_TRANSACTION_RECORD_TOO_LONG, -EIO,
-        "STATUS_TRANSACTION_RECORD_TOO_LONG"},
-        {STATUS_NO_LINK_TRACKING_IN_TRANSACTION, -EIO,
-        "STATUS_NO_LINK_TRACKING_IN_TRANSACTION"},
-        {STATUS_OPERATION_NOT_SUPPORTED_IN_TRANSACTION, -EOPNOTSUPP,
-        "STATUS_OPERATION_NOT_SUPPORTED_IN_TRANSACTION"},
-        {STATUS_TRANSACTION_INTEGRITY_VIOLATED, -EIO,
-        "STATUS_TRANSACTION_INTEGRITY_VIOLATED"},
-        {STATUS_LOG_SECTOR_INVALID, -EIO, "STATUS_LOG_SECTOR_INVALID"},
-        {STATUS_LOG_SECTOR_PARITY_INVALID, -EIO,
-        "STATUS_LOG_SECTOR_PARITY_INVALID"},
-        {STATUS_LOG_SECTOR_REMAPPED, -EIO, "STATUS_LOG_SECTOR_REMAPPED"},
-        {STATUS_LOG_BLOCK_INCOMPLETE, -EIO, "STATUS_LOG_BLOCK_INCOMPLETE"},
-        {STATUS_LOG_INVALID_RANGE, -EIO, "STATUS_LOG_INVALID_RANGE"},
-        {STATUS_LOG_BLOCKS_EXHAUSTED, -EIO, "STATUS_LOG_BLOCKS_EXHAUSTED"},
-        {STATUS_LOG_READ_CONTEXT_INVALID, -EIO,
-        "STATUS_LOG_READ_CONTEXT_INVALID"},
-        {STATUS_LOG_RESTART_INVALID, -EIO, "STATUS_LOG_RESTART_INVALID"},
-        {STATUS_LOG_BLOCK_VERSION, -EIO, "STATUS_LOG_BLOCK_VERSION"},
-        {STATUS_LOG_BLOCK_INVALID, -EIO, "STATUS_LOG_BLOCK_INVALID"},
-        {STATUS_LOG_READ_MODE_INVALID, -EIO, "STATUS_LOG_READ_MODE_INVALID"},
-        {STATUS_LOG_METADATA_CORRUPT, -EIO, "STATUS_LOG_METADATA_CORRUPT"},
-        {STATUS_LOG_METADATA_INVALID, -EIO, "STATUS_LOG_METADATA_INVALID"},
-        {STATUS_LOG_METADATA_INCONSISTENT, -EIO,
-        "STATUS_LOG_METADATA_INCONSISTENT"},
-        {STATUS_LOG_RESERVATION_INVALID, -EIO,
-        "STATUS_LOG_RESERVATION_INVALID"},
-        {STATUS_LOG_CANT_DELETE, -EIO, "STATUS_LOG_CANT_DELETE"},
-        {STATUS_LOG_CONTAINER_LIMIT_EXCEEDED, -EIO,
-        "STATUS_LOG_CONTAINER_LIMIT_EXCEEDED"},
-        {STATUS_LOG_START_OF_LOG, -EIO, "STATUS_LOG_START_OF_LOG"},
-        {STATUS_LOG_POLICY_ALREADY_INSTALLED, -EIO,
-        "STATUS_LOG_POLICY_ALREADY_INSTALLED"},
-        {STATUS_LOG_POLICY_NOT_INSTALLED, -EIO,
-        "STATUS_LOG_POLICY_NOT_INSTALLED"},
-        {STATUS_LOG_POLICY_INVALID, -EIO, "STATUS_LOG_POLICY_INVALID"},
-        {STATUS_LOG_POLICY_CONFLICT, -EIO, "STATUS_LOG_POLICY_CONFLICT"},
-        {STATUS_LOG_PINNED_ARCHIVE_TAIL, -EIO,
-        "STATUS_LOG_PINNED_ARCHIVE_TAIL"},
-        {STATUS_LOG_RECORD_NONEXISTENT, -EIO, "STATUS_LOG_RECORD_NONEXISTENT"},
-        {STATUS_LOG_RECORDS_RESERVED_INVALID, -EIO,
-        "STATUS_LOG_RECORDS_RESERVED_INVALID"},
-        {STATUS_LOG_SPACE_RESERVED_INVALID, -EIO,
-        "STATUS_LOG_SPACE_RESERVED_INVALID"},
-        {STATUS_LOG_TAIL_INVALID, -EIO, "STATUS_LOG_TAIL_INVALID"},
-        {STATUS_LOG_FULL, -EIO, "STATUS_LOG_FULL"},
-        {STATUS_LOG_MULTIPLEXED, -EIO, "STATUS_LOG_MULTIPLEXED"},
-        {STATUS_LOG_DEDICATED, -EIO, "STATUS_LOG_DEDICATED"},
-        {STATUS_LOG_ARCHIVE_NOT_IN_PROGRESS, -EIO,
-        "STATUS_LOG_ARCHIVE_NOT_IN_PROGRESS"},
-        {STATUS_LOG_ARCHIVE_IN_PROGRESS, -EIO,
-        "STATUS_LOG_ARCHIVE_IN_PROGRESS"},
-        {STATUS_LOG_EPHEMERAL, -EIO, "STATUS_LOG_EPHEMERAL"},
-        {STATUS_LOG_NOT_ENOUGH_CONTAINERS, -EIO,
-        "STATUS_LOG_NOT_ENOUGH_CONTAINERS"},
-        {STATUS_LOG_CLIENT_ALREADY_REGISTERED, -EIO,
-        "STATUS_LOG_CLIENT_ALREADY_REGISTERED"},
-        {STATUS_LOG_CLIENT_NOT_REGISTERED, -EIO,
-        "STATUS_LOG_CLIENT_NOT_REGISTERED"},
-        {STATUS_LOG_FULL_HANDLER_IN_PROGRESS, -EIO,
-        "STATUS_LOG_FULL_HANDLER_IN_PROGRESS"},
-        {STATUS_LOG_CONTAINER_READ_FAILED, -EIO,
-        "STATUS_LOG_CONTAINER_READ_FAILED"},
-        {STATUS_LOG_CONTAINER_WRITE_FAILED, -EIO,
-        "STATUS_LOG_CONTAINER_WRITE_FAILED"},
-        {STATUS_LOG_CONTAINER_OPEN_FAILED, -EIO,
-        "STATUS_LOG_CONTAINER_OPEN_FAILED"},
-        {STATUS_LOG_CONTAINER_STATE_INVALID, -EIO,
-        "STATUS_LOG_CONTAINER_STATE_INVALID"},
-        {STATUS_LOG_STATE_INVALID, -EIO, "STATUS_LOG_STATE_INVALID"},
-        {STATUS_LOG_PINNED, -EIO, "STATUS_LOG_PINNED"},
-        {STATUS_LOG_METADATA_FLUSH_FAILED, -EIO,
-        "STATUS_LOG_METADATA_FLUSH_FAILED"},
-        {STATUS_LOG_INCONSISTENT_SECURITY, -EIO,
-        "STATUS_LOG_INCONSISTENT_SECURITY"},
-        {STATUS_LOG_APPENDED_FLUSH_FAILED, -EIO,
-        "STATUS_LOG_APPENDED_FLUSH_FAILED"},
-        {STATUS_LOG_PINNED_RESERVATION, -EIO, "STATUS_LOG_PINNED_RESERVATION"},
-        {STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD, -EIO,
-        "STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD"},
-        {STATUS_FLT_NO_HANDLER_DEFINED, -EIO, "STATUS_FLT_NO_HANDLER_DEFINED"},
-        {STATUS_FLT_CONTEXT_ALREADY_DEFINED, -EIO,
-        "STATUS_FLT_CONTEXT_ALREADY_DEFINED"},
-        {STATUS_FLT_INVALID_ASYNCHRONOUS_REQUEST, -EIO,
-        "STATUS_FLT_INVALID_ASYNCHRONOUS_REQUEST"},
-        {STATUS_FLT_DISALLOW_FAST_IO, -EIO, "STATUS_FLT_DISALLOW_FAST_IO"},
-        {STATUS_FLT_INVALID_NAME_REQUEST, -EIO,
-        "STATUS_FLT_INVALID_NAME_REQUEST"},
-        {STATUS_FLT_NOT_SAFE_TO_POST_OPERATION, -EIO,
-        "STATUS_FLT_NOT_SAFE_TO_POST_OPERATION"},
-        {STATUS_FLT_NOT_INITIALIZED, -EIO, "STATUS_FLT_NOT_INITIALIZED"},
-        {STATUS_FLT_FILTER_NOT_READY, -EIO, "STATUS_FLT_FILTER_NOT_READY"},
-        {STATUS_FLT_POST_OPERATION_CLEANUP, -EIO,
-        "STATUS_FLT_POST_OPERATION_CLEANUP"},
-        {STATUS_FLT_INTERNAL_ERROR, -EIO, "STATUS_FLT_INTERNAL_ERROR"},
-        {STATUS_FLT_DELETING_OBJECT, -EIO, "STATUS_FLT_DELETING_OBJECT"},
-        {STATUS_FLT_MUST_BE_NONPAGED_POOL, -EIO,
-        "STATUS_FLT_MUST_BE_NONPAGED_POOL"},
-        {STATUS_FLT_DUPLICATE_ENTRY, -EIO, "STATUS_FLT_DUPLICATE_ENTRY"},
-        {STATUS_FLT_CBDQ_DISABLED, -EIO, "STATUS_FLT_CBDQ_DISABLED"},
-        {STATUS_FLT_DO_NOT_ATTACH, -EIO, "STATUS_FLT_DO_NOT_ATTACH"},
-        {STATUS_FLT_DO_NOT_DETACH, -EIO, "STATUS_FLT_DO_NOT_DETACH"},
-        {STATUS_FLT_INSTANCE_ALTITUDE_COLLISION, -EIO,
-        "STATUS_FLT_INSTANCE_ALTITUDE_COLLISION"},
-        {STATUS_FLT_INSTANCE_NAME_COLLISION, -EIO,
-        "STATUS_FLT_INSTANCE_NAME_COLLISION"},
-        {STATUS_FLT_FILTER_NOT_FOUND, -EIO, "STATUS_FLT_FILTER_NOT_FOUND"},
-        {STATUS_FLT_VOLUME_NOT_FOUND, -EIO, "STATUS_FLT_VOLUME_NOT_FOUND"},
-        {STATUS_FLT_INSTANCE_NOT_FOUND, -EIO, "STATUS_FLT_INSTANCE_NOT_FOUND"},
-        {STATUS_FLT_CONTEXT_ALLOCATION_NOT_FOUND, -EIO,
-        "STATUS_FLT_CONTEXT_ALLOCATION_NOT_FOUND"},
-        {STATUS_FLT_INVALID_CONTEXT_REGISTRATION, -EIO,
-        "STATUS_FLT_INVALID_CONTEXT_REGISTRATION"},
-        {STATUS_FLT_NAME_CACHE_MISS, -EIO, "STATUS_FLT_NAME_CACHE_MISS"},
-        {STATUS_FLT_NO_DEVICE_OBJECT, -EIO, "STATUS_FLT_NO_DEVICE_OBJECT"},
-        {STATUS_FLT_VOLUME_ALREADY_MOUNTED, -EIO,
-        "STATUS_FLT_VOLUME_ALREADY_MOUNTED"},
-        {STATUS_FLT_ALREADY_ENLISTED, -EIO, "STATUS_FLT_ALREADY_ENLISTED"},
-        {STATUS_FLT_CONTEXT_ALREADY_LINKED, -EIO,
-        "STATUS_FLT_CONTEXT_ALREADY_LINKED"},
-        {STATUS_FLT_NO_WAITER_FOR_REPLY, -EIO,
-        "STATUS_FLT_NO_WAITER_FOR_REPLY"},
-        {STATUS_MONITOR_NO_DESCRIPTOR, -EIO, "STATUS_MONITOR_NO_DESCRIPTOR"},
-        {STATUS_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT, -EIO,
-        "STATUS_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT"},
-        {STATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUM, -EIO,
-        "STATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUM"},
-        {STATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCK, -EIO,
-        "STATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCK"},
-        {STATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED, -EIO,
-        "STATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED"},
-        {STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK, -EIO,
-        "STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK"},
-        {STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK, -EIO,
-        "STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK"},
-        {STATUS_MONITOR_NO_MORE_DESCRIPTOR_DATA, -EIO,
-        "STATUS_MONITOR_NO_MORE_DESCRIPTOR_DATA"},
-        {STATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCK, -EIO,
-        "STATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCK"},
-        {STATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER, -EIO,
-        "STATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER"},
-        {STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER, -EIO,
-        "STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER"},
-        {STATUS_GRAPHICS_INVALID_DISPLAY_ADAPTER, -EIO,
-        "STATUS_GRAPHICS_INVALID_DISPLAY_ADAPTER"},
-        {STATUS_GRAPHICS_ADAPTER_WAS_RESET, -EIO,
-        "STATUS_GRAPHICS_ADAPTER_WAS_RESET"},
-        {STATUS_GRAPHICS_INVALID_DRIVER_MODEL, -EIO,
-        "STATUS_GRAPHICS_INVALID_DRIVER_MODEL"},
-        {STATUS_GRAPHICS_PRESENT_MODE_CHANGED, -EIO,
-        "STATUS_GRAPHICS_PRESENT_MODE_CHANGED"},
-        {STATUS_GRAPHICS_PRESENT_OCCLUDED, -EIO,
-        "STATUS_GRAPHICS_PRESENT_OCCLUDED"},
-        {STATUS_GRAPHICS_PRESENT_DENIED, -EIO,
-        "STATUS_GRAPHICS_PRESENT_DENIED"},
-        {STATUS_GRAPHICS_CANNOTCOLORCONVERT, -EIO,
-        "STATUS_GRAPHICS_CANNOTCOLORCONVERT"},
-        {STATUS_GRAPHICS_NO_VIDEO_MEMORY, -EIO,
-        "STATUS_GRAPHICS_NO_VIDEO_MEMORY"},
-        {STATUS_GRAPHICS_CANT_LOCK_MEMORY, -EIO,
-        "STATUS_GRAPHICS_CANT_LOCK_MEMORY"},
-        {STATUS_GRAPHICS_ALLOCATION_BUSY, -EBUSY,
-        "STATUS_GRAPHICS_ALLOCATION_BUSY"},
-        {STATUS_GRAPHICS_TOO_MANY_REFERENCES, -EIO,
-        "STATUS_GRAPHICS_TOO_MANY_REFERENCES"},
-        {STATUS_GRAPHICS_TRY_AGAIN_LATER, -EIO,
-        "STATUS_GRAPHICS_TRY_AGAIN_LATER"},
-        {STATUS_GRAPHICS_TRY_AGAIN_NOW, -EIO, "STATUS_GRAPHICS_TRY_AGAIN_NOW"},
-        {STATUS_GRAPHICS_ALLOCATION_INVALID, -EIO,
-        "STATUS_GRAPHICS_ALLOCATION_INVALID"},
-        {STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE, -EIO,
-        "STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE"},
-        {STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED, -EIO,
-        "STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED"},
-        {STATUS_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION, -EIO,
-        "STATUS_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION"},
-        {STATUS_GRAPHICS_INVALID_ALLOCATION_USAGE, -EIO,
-        "STATUS_GRAPHICS_INVALID_ALLOCATION_USAGE"},
-        {STATUS_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION, -EIO,
-        "STATUS_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION"},
-        {STATUS_GRAPHICS_ALLOCATION_CLOSED, -EIO,
-        "STATUS_GRAPHICS_ALLOCATION_CLOSED"},
-        {STATUS_GRAPHICS_INVALID_ALLOCATION_INSTANCE, -EIO,
-        "STATUS_GRAPHICS_INVALID_ALLOCATION_INSTANCE"},
-        {STATUS_GRAPHICS_INVALID_ALLOCATION_HANDLE, -EIO,
-        "STATUS_GRAPHICS_INVALID_ALLOCATION_HANDLE"},
-        {STATUS_GRAPHICS_WRONG_ALLOCATION_DEVICE, -EIO,
-        "STATUS_GRAPHICS_WRONG_ALLOCATION_DEVICE"},
-        {STATUS_GRAPHICS_ALLOCATION_CONTENT_LOST, -EIO,
-        "STATUS_GRAPHICS_ALLOCATION_CONTENT_LOST"},
-        {STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE, -EIO,
-        "STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE"},
-        {STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY, -EIO,
-        "STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY"},
-        {STATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED, -EIO,
-        "STATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED"},
-        {STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED, -EIO,
-        "STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED"},
-        {STATUS_GRAPHICS_INVALID_VIDPN, -EIO, "STATUS_GRAPHICS_INVALID_VIDPN"},
-        {STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE, -EIO,
-        "STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE"},
-        {STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET, -EIO,
-        "STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET"},
-        {STATUS_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED, -EIO,
-        "STATUS_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED"},
-        {STATUS_GRAPHICS_INVALID_VIDPN_SOURCEMODESET, -EIO,
-        "STATUS_GRAPHICS_INVALID_VIDPN_SOURCEMODESET"},
-        {STATUS_GRAPHICS_INVALID_VIDPN_TARGETMODESET, -EIO,
-        "STATUS_GRAPHICS_INVALID_VIDPN_TARGETMODESET"},
-        {STATUS_GRAPHICS_INVALID_FREQUENCY, -EIO,
-        "STATUS_GRAPHICS_INVALID_FREQUENCY"},
-        {STATUS_GRAPHICS_INVALID_ACTIVE_REGION, -EIO,
-        "STATUS_GRAPHICS_INVALID_ACTIVE_REGION"},
-        {STATUS_GRAPHICS_INVALID_TOTAL_REGION, -EIO,
-        "STATUS_GRAPHICS_INVALID_TOTAL_REGION"},
-        {STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE, -EIO,
-        "STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE"},
-        {STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE, -EIO,
-        "STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE"},
-        {STATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET, -EIO,
-        "STATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET"},
-        {STATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY, -EIO,
-        "STATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY"},
-        {STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET, -EIO,
-        "STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET"},
-        {STATUS_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET, -EIO,
-        "STATUS_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET"},
-        {STATUS_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET, -EIO,
-        "STATUS_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET"},
-        {STATUS_GRAPHICS_SOURCE_ALREADY_IN_SET, -EIO,
-        "STATUS_GRAPHICS_SOURCE_ALREADY_IN_SET"},
-        {STATUS_GRAPHICS_TARGET_ALREADY_IN_SET, -EIO,
-        "STATUS_GRAPHICS_TARGET_ALREADY_IN_SET"},
-        {STATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATH, -EIO,
-        "STATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATH"},
-        {STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY, -EIO,
-        "STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY"},
-        {STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET, -EIO,
-        "STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET"},
-        {STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE, -EIO,
-        "STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE"},
-        {STATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET, -EIO,
-        "STATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET"},
-        {STATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET, -EIO,
-        "STATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET"},
-        {STATUS_GRAPHICS_STALE_MODESET, -EIO, "STATUS_GRAPHICS_STALE_MODESET"},
-        {STATUS_GRAPHICS_INVALID_MONITOR_SOURCEMODESET, -EIO,
-        "STATUS_GRAPHICS_INVALID_MONITOR_SOURCEMODESET"},
-        {STATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODE, -EIO,
-        "STATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODE"},
-        {STATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN, -EIO,
-        "STATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN"},
-        {STATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUE, -EIO,
-        "STATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUE"},
-        {STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION, -EIO,
-        "STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION"},
-        {STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES, -EIO,
-        "STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES"},
-        {STATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGY, -EIO,
-        "STATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGY"},
-        {STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE, -EIO,
-        "STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE"},
-        {STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET, -EIO,
-        "STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET"},
-        {STATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSET, -EIO,
-        "STATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSET"},
-        {STATUS_GRAPHICS_INVALID_MONITORDESCRIPTOR, -EIO,
-        "STATUS_GRAPHICS_INVALID_MONITORDESCRIPTOR"},
-        {STATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET, -EIO,
-        "STATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET"},
-        {STATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET, -EIO,
-        "STATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET"},
-        {STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE, -EIO,
-        "STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE"},
-        {STATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE, -EIO,
-        "STATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE"},
-        {STATUS_GRAPHICS_RESOURCES_NOT_RELATED, -EIO,
-        "STATUS_GRAPHICS_RESOURCES_NOT_RELATED"},
-        {STATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE, -EIO,
-        "STATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE"},
-        {STATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE, -EIO,
-        "STATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE"},
-        {STATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET, -EIO,
-        "STATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET"},
-        {STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER, -EIO,
-        "STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER"},
-        {STATUS_GRAPHICS_NO_VIDPNMGR, -EIO, "STATUS_GRAPHICS_NO_VIDPNMGR"},
-        {STATUS_GRAPHICS_NO_ACTIVE_VIDPN, -EIO,
-        "STATUS_GRAPHICS_NO_ACTIVE_VIDPN"},
-        {STATUS_GRAPHICS_STALE_VIDPN_TOPOLOGY, -EIO,
-        "STATUS_GRAPHICS_STALE_VIDPN_TOPOLOGY"},
-        {STATUS_GRAPHICS_MONITOR_NOT_CONNECTED, -EIO,
-        "STATUS_GRAPHICS_MONITOR_NOT_CONNECTED"},
-        {STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY, -EIO,
-        "STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY"},
-        {STATUS_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE, -EIO,
-        "STATUS_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE"},
-        {STATUS_GRAPHICS_INVALID_VISIBLEREGION_SIZE, -EIO,
-        "STATUS_GRAPHICS_INVALID_VISIBLEREGION_SIZE"},
-        {STATUS_GRAPHICS_INVALID_STRIDE, -EIO,
-        "STATUS_GRAPHICS_INVALID_STRIDE"},
-        {STATUS_GRAPHICS_INVALID_PIXELFORMAT, -EIO,
-        "STATUS_GRAPHICS_INVALID_PIXELFORMAT"},
-        {STATUS_GRAPHICS_INVALID_COLORBASIS, -EIO,
-        "STATUS_GRAPHICS_INVALID_COLORBASIS"},
-        {STATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODE, -EIO,
-        "STATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODE"},
-        {STATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGY, -EIO,
-        "STATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGY"},
-        {STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT, -EIO,
-        "STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT"},
-        {STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE, -EIO,
-        "STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE"},
-        {STATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN, -EIO,
-        "STATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN"},
-        {STATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL, -EIO,
-        "STATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL"},
-        {STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION, -EIO,
-        "STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION"},
-        {STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED,
-        -EIO,
-        "STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED"},
-        {STATUS_GRAPHICS_INVALID_GAMMA_RAMP, -EIO,
-        "STATUS_GRAPHICS_INVALID_GAMMA_RAMP"},
-        {STATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED, -EIO,
-        "STATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED"},
-        {STATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED, -EIO,
-        "STATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED"},
-        {STATUS_GRAPHICS_MODE_NOT_IN_MODESET, -EIO,
-        "STATUS_GRAPHICS_MODE_NOT_IN_MODESET"},
-        {STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON, -EIO,
-        "STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON"},
-        {STATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPE, -EIO,
-        "STATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPE"},
-        {STATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPE, -EIO,
-        "STATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPE"},
-        {STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS, -EIO,
-        "STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS"},
-        {STATUS_GRAPHICS_INVALID_SCANLINE_ORDERING, -EIO,
-        "STATUS_GRAPHICS_INVALID_SCANLINE_ORDERING"},
-        {STATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED, -EIO,
-        "STATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED"},
-        {STATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS, -EIO,
-        "STATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS"},
-        {STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT, -EIO,
-        "STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT"},
-        {STATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM, -EIO,
-        "STATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM"},
-        {STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN, -EIO,
-        "STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN"},
-        {STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT, -EIO,
-        "STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT"},
-        {STATUS_GRAPHICS_MAX_NUM_PATHS_REACHED, -EIO,
-        "STATUS_GRAPHICS_MAX_NUM_PATHS_REACHED"},
-        {STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION, -EIO,
-        "STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION"},
-        {STATUS_GRAPHICS_INVALID_CLIENT_TYPE, -EIO,
-        "STATUS_GRAPHICS_INVALID_CLIENT_TYPE"},
-        {STATUS_GRAPHICS_CLIENTVIDPN_NOT_SET, -EIO,
-        "STATUS_GRAPHICS_CLIENTVIDPN_NOT_SET"},
-        {STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED, -EIO,
-        "STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED"},
-        {STATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED, -EIO,
-        "STATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED"},
-        {STATUS_GRAPHICS_NOT_A_LINKED_ADAPTER, -EIO,
-        "STATUS_GRAPHICS_NOT_A_LINKED_ADAPTER"},
-        {STATUS_GRAPHICS_LEADLINK_NOT_ENUMERATED, -EIO,
-        "STATUS_GRAPHICS_LEADLINK_NOT_ENUMERATED"},
-        {STATUS_GRAPHICS_CHAINLINKS_NOT_ENUMERATED, -EIO,
-        "STATUS_GRAPHICS_CHAINLINKS_NOT_ENUMERATED"},
-        {STATUS_GRAPHICS_ADAPTER_CHAIN_NOT_READY, -EIO,
-        "STATUS_GRAPHICS_ADAPTER_CHAIN_NOT_READY"},
-        {STATUS_GRAPHICS_CHAINLINKS_NOT_STARTED, -EIO,
-        "STATUS_GRAPHICS_CHAINLINKS_NOT_STARTED"},
-        {STATUS_GRAPHICS_CHAINLINKS_NOT_POWERED_ON, -EIO,
-        "STATUS_GRAPHICS_CHAINLINKS_NOT_POWERED_ON"},
-        {STATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE, -EIO,
-        "STATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE"},
-        {STATUS_GRAPHICS_NOT_POST_DEVICE_DRIVER, -EIO,
-        "STATUS_GRAPHICS_NOT_POST_DEVICE_DRIVER"},
-        {STATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED, -EIO,
-        "STATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED"},
-        {STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS,
-        -EIO,
-        "STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS"},
-        {STATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST, -EIO,
-        "STATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST"},
-        {STATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR, -EIO,
-        "STATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR"},
-        {STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS, -EIO,
-        "STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS"},
-        {STATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED, -EIO,
-        "STATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED"},
-        {STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST, -EIO,
-        "STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST"},
-        {STATUS_GRAPHICS_OPM_NOT_SUPPORTED, -EIO,
-        "STATUS_GRAPHICS_OPM_NOT_SUPPORTED"},
-        {STATUS_GRAPHICS_COPP_NOT_SUPPORTED, -EIO,
-        "STATUS_GRAPHICS_COPP_NOT_SUPPORTED"},
-        {STATUS_GRAPHICS_UAB_NOT_SUPPORTED, -EIO,
-        "STATUS_GRAPHICS_UAB_NOT_SUPPORTED"},
-        {STATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS, -EIO,
-        "STATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS"},
-        {STATUS_GRAPHICS_OPM_PARAMETER_ARRAY_TOO_SMALL, -EIO,
-        "STATUS_GRAPHICS_OPM_PARAMETER_ARRAY_TOO_SMALL"},
-        {STATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXIST, -EIO,
-        "STATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXIST"},
-        {STATUS_GRAPHICS_PVP_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME, -EIO,
-        "STATUS_GRAPHICS_PVP_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME"},
-        {STATUS_GRAPHICS_PVP_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP, -EIO,
-        "STATUS_GRAPHICS_PVP_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP"},
-        {STATUS_GRAPHICS_PVP_MIRRORING_DEVICES_NOT_SUPPORTED, -EIO,
-        "STATUS_GRAPHICS_PVP_MIRRORING_DEVICES_NOT_SUPPORTED"},
-        {STATUS_GRAPHICS_OPM_INVALID_POINTER, -EIO,
-        "STATUS_GRAPHICS_OPM_INVALID_POINTER"},
-        {STATUS_GRAPHICS_OPM_INTERNAL_ERROR, -EIO,
-        "STATUS_GRAPHICS_OPM_INTERNAL_ERROR"},
-        {STATUS_GRAPHICS_OPM_INVALID_HANDLE, -EIO,
-        "STATUS_GRAPHICS_OPM_INVALID_HANDLE"},
-        {STATUS_GRAPHICS_PVP_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE, -EIO,
-        "STATUS_GRAPHICS_PVP_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE"},
-        {STATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH, -EIO,
-        "STATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH"},
-        {STATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLED, -EIO,
-        "STATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLED"},
-        {STATUS_GRAPHICS_OPM_THEATER_MODE_ENABLED, -EIO,
-        "STATUS_GRAPHICS_OPM_THEATER_MODE_ENABLED"},
-        {STATUS_GRAPHICS_PVP_HFS_FAILED, -EIO,
-        "STATUS_GRAPHICS_PVP_HFS_FAILED"},
-        {STATUS_GRAPHICS_OPM_INVALID_SRM, -EIO,
-        "STATUS_GRAPHICS_OPM_INVALID_SRM"},
-        {STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP, -EIO,
-        "STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP"},
-        {STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP, -EIO,
-        "STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP"},
-        {STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA, -EIO,
-        "STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA"},
-        {STATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SET, -EIO,
-        "STATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SET"},
-        {STATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGH, -EIO,
-        "STATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGH"},
-        {STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE, -EIO,
-        "STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE"},
-        {STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS, -EIO,
-        "STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS"},
-        {STATUS_GRAPHICS_OPM_SESSION_TYPE_CHANGE_IN_PROGRESS, -EIO,
-        "STATUS_GRAPHICS_OPM_SESSION_TYPE_CHANGE_IN_PROGRESS"},
-        {STATUS_GRAPHICS_I2C_NOT_SUPPORTED, -EIO,
-        "STATUS_GRAPHICS_I2C_NOT_SUPPORTED"},
-        {STATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST, -EIO,
-        "STATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST"},
-        {STATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA, -EIO,
-        "STATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA"},
-        {STATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATA, -EIO,
-        "STATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATA"},
-        {STATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED, -EIO,
-        "STATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED"},
-        {STATUS_GRAPHICS_DDCCI_INVALID_DATA, -EIO,
-        "STATUS_GRAPHICS_DDCCI_INVALID_DATA"},
-        {STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE,
-        -EIO,
-        "STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE"},
-        {STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING, -EIO,
-        "STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING"},
-        {STATUS_GRAPHICS_MCA_INTERNAL_ERROR, -EIO,
-        "STATUS_GRAPHICS_MCA_INTERNAL_ERROR"},
-        {STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND, -EIO,
-        "STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND"},
-        {STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH, -EIO,
-        "STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH"},
-        {STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM, -EIO,
-        "STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM"},
-        {STATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE, -EIO,
-        "STATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE"},
-        {STATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTS, -EIO,
-        "STATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTS"},
-        {STATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED, -EIO,
-        "STATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED"},
-        {STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME, -EIO,
-        "STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME"},
-        {STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP, -EIO,
-        "STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP"},
-        {STATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED, -EIO,
-        "STATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED"},
-        {STATUS_GRAPHICS_INVALID_POINTER, -EIO,
-        "STATUS_GRAPHICS_INVALID_POINTER"},
-        {STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE, -EIO,
-        "STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE"},
-        {STATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL, -EIO,
-        "STATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL"},
-        {STATUS_GRAPHICS_INTERNAL_ERROR, -EIO,
-        "STATUS_GRAPHICS_INTERNAL_ERROR"},
-        {STATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS, -EIO,
-        "STATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS"},
-        {STATUS_FVE_LOCKED_VOLUME, -EIO, "STATUS_FVE_LOCKED_VOLUME"},
-        {STATUS_FVE_NOT_ENCRYPTED, -EIO, "STATUS_FVE_NOT_ENCRYPTED"},
-        {STATUS_FVE_BAD_INFORMATION, -EIO, "STATUS_FVE_BAD_INFORMATION"},
-        {STATUS_FVE_TOO_SMALL, -EIO, "STATUS_FVE_TOO_SMALL"},
-        {STATUS_FVE_FAILED_WRONG_FS, -EIO, "STATUS_FVE_FAILED_WRONG_FS"},
-        {STATUS_FVE_FAILED_BAD_FS, -EIO, "STATUS_FVE_FAILED_BAD_FS"},
-        {STATUS_FVE_FS_NOT_EXTENDED, -EIO, "STATUS_FVE_FS_NOT_EXTENDED"},
-        {STATUS_FVE_FS_MOUNTED, -EIO, "STATUS_FVE_FS_MOUNTED"},
-        {STATUS_FVE_NO_LICENSE, -EIO, "STATUS_FVE_NO_LICENSE"},
-        {STATUS_FVE_ACTION_NOT_ALLOWED, -EIO, "STATUS_FVE_ACTION_NOT_ALLOWED"},
-        {STATUS_FVE_BAD_DATA, -EIO, "STATUS_FVE_BAD_DATA"},
-        {STATUS_FVE_VOLUME_NOT_BOUND, -EIO, "STATUS_FVE_VOLUME_NOT_BOUND"},
-        {STATUS_FVE_NOT_DATA_VOLUME, -EIO, "STATUS_FVE_NOT_DATA_VOLUME"},
-        {STATUS_FVE_CONV_READ_ERROR, -EIO, "STATUS_FVE_CONV_READ_ERROR"},
-        {STATUS_FVE_CONV_WRITE_ERROR, -EIO, "STATUS_FVE_CONV_WRITE_ERROR"},
-        {STATUS_FVE_OVERLAPPED_UPDATE, -EIO, "STATUS_FVE_OVERLAPPED_UPDATE"},
-        {STATUS_FVE_FAILED_SECTOR_SIZE, -EIO, "STATUS_FVE_FAILED_SECTOR_SIZE"},
-        {STATUS_FVE_FAILED_AUTHENTICATION, -EIO,
-        "STATUS_FVE_FAILED_AUTHENTICATION"},
-        {STATUS_FVE_NOT_OS_VOLUME, -EIO, "STATUS_FVE_NOT_OS_VOLUME"},
-        {STATUS_FVE_KEYFILE_NOT_FOUND, -EIO, "STATUS_FVE_KEYFILE_NOT_FOUND"},
-        {STATUS_FVE_KEYFILE_INVALID, -EIO, "STATUS_FVE_KEYFILE_INVALID"},
-        {STATUS_FVE_KEYFILE_NO_VMK, -EIO, "STATUS_FVE_KEYFILE_NO_VMK"},
-        {STATUS_FVE_TPM_DISABLED, -EIO, "STATUS_FVE_TPM_DISABLED"},
-        {STATUS_FVE_TPM_SRK_AUTH_NOT_ZERO, -EIO,
-        "STATUS_FVE_TPM_SRK_AUTH_NOT_ZERO"},
-        {STATUS_FVE_TPM_INVALID_PCR, -EIO, "STATUS_FVE_TPM_INVALID_PCR"},
-        {STATUS_FVE_TPM_NO_VMK, -EIO, "STATUS_FVE_TPM_NO_VMK"},
-        {STATUS_FVE_PIN_INVALID, -EIO, "STATUS_FVE_PIN_INVALID"},
-        {STATUS_FVE_AUTH_INVALID_APPLICATION, -EIO,
-        "STATUS_FVE_AUTH_INVALID_APPLICATION"},
-        {STATUS_FVE_AUTH_INVALID_CONFIG, -EIO,
-        "STATUS_FVE_AUTH_INVALID_CONFIG"},
-        {STATUS_FVE_DEBUGGER_ENABLED, -EIO, "STATUS_FVE_DEBUGGER_ENABLED"},
-        {STATUS_FVE_DRY_RUN_FAILED, -EIO, "STATUS_FVE_DRY_RUN_FAILED"},
-        {STATUS_FVE_BAD_METADATA_POINTER, -EIO,
-        "STATUS_FVE_BAD_METADATA_POINTER"},
-        {STATUS_FVE_OLD_METADATA_COPY, -EIO, "STATUS_FVE_OLD_METADATA_COPY"},
-        {STATUS_FVE_REBOOT_REQUIRED, -EIO, "STATUS_FVE_REBOOT_REQUIRED"},
-        {STATUS_FVE_RAW_ACCESS, -EIO, "STATUS_FVE_RAW_ACCESS"},
-        {STATUS_FVE_RAW_BLOCKED, -EIO, "STATUS_FVE_RAW_BLOCKED"},
-        {STATUS_FWP_CALLOUT_NOT_FOUND, -EIO, "STATUS_FWP_CALLOUT_NOT_FOUND"},
-        {STATUS_FWP_CONDITION_NOT_FOUND, -EIO,
-        "STATUS_FWP_CONDITION_NOT_FOUND"},
-        {STATUS_FWP_FILTER_NOT_FOUND, -EIO, "STATUS_FWP_FILTER_NOT_FOUND"},
-        {STATUS_FWP_LAYER_NOT_FOUND, -EIO, "STATUS_FWP_LAYER_NOT_FOUND"},
-        {STATUS_FWP_PROVIDER_NOT_FOUND, -EIO, "STATUS_FWP_PROVIDER_NOT_FOUND"},
-        {STATUS_FWP_PROVIDER_CONTEXT_NOT_FOUND, -EIO,
-        "STATUS_FWP_PROVIDER_CONTEXT_NOT_FOUND"},
-        {STATUS_FWP_SUBLAYER_NOT_FOUND, -EIO, "STATUS_FWP_SUBLAYER_NOT_FOUND"},
-        {STATUS_FWP_NOT_FOUND, -EIO, "STATUS_FWP_NOT_FOUND"},
-        {STATUS_FWP_ALREADY_EXISTS, -EIO, "STATUS_FWP_ALREADY_EXISTS"},
-        {STATUS_FWP_IN_USE, -EIO, "STATUS_FWP_IN_USE"},
-        {STATUS_FWP_DYNAMIC_SESSION_IN_PROGRESS, -EIO,
-        "STATUS_FWP_DYNAMIC_SESSION_IN_PROGRESS"},
-        {STATUS_FWP_WRONG_SESSION, -EIO, "STATUS_FWP_WRONG_SESSION"},
-        {STATUS_FWP_NO_TXN_IN_PROGRESS, -EIO, "STATUS_FWP_NO_TXN_IN_PROGRESS"},
-        {STATUS_FWP_TXN_IN_PROGRESS, -EIO, "STATUS_FWP_TXN_IN_PROGRESS"},
-        {STATUS_FWP_TXN_ABORTED, -EIO, "STATUS_FWP_TXN_ABORTED"},
-        {STATUS_FWP_SESSION_ABORTED, -EIO, "STATUS_FWP_SESSION_ABORTED"},
-        {STATUS_FWP_INCOMPATIBLE_TXN, -EIO, "STATUS_FWP_INCOMPATIBLE_TXN"},
-        {STATUS_FWP_TIMEOUT, -ETIMEDOUT, "STATUS_FWP_TIMEOUT"},
-        {STATUS_FWP_NET_EVENTS_DISABLED, -EIO,
-        "STATUS_FWP_NET_EVENTS_DISABLED"},
-        {STATUS_FWP_INCOMPATIBLE_LAYER, -EIO, "STATUS_FWP_INCOMPATIBLE_LAYER"},
-        {STATUS_FWP_KM_CLIENTS_ONLY, -EIO, "STATUS_FWP_KM_CLIENTS_ONLY"},
-        {STATUS_FWP_LIFETIME_MISMATCH, -EIO, "STATUS_FWP_LIFETIME_MISMATCH"},
-        {STATUS_FWP_BUILTIN_OBJECT, -EIO, "STATUS_FWP_BUILTIN_OBJECT"},
-        {STATUS_FWP_TOO_MANY_BOOTTIME_FILTERS, -EIO,
-        "STATUS_FWP_TOO_MANY_BOOTTIME_FILTERS"},
-        {STATUS_FWP_TOO_MANY_CALLOUTS, -EIO, "STATUS_FWP_TOO_MANY_CALLOUTS"},
-        {STATUS_FWP_NOTIFICATION_DROPPED, -EIO,
-        "STATUS_FWP_NOTIFICATION_DROPPED"},
-        {STATUS_FWP_TRAFFIC_MISMATCH, -EIO, "STATUS_FWP_TRAFFIC_MISMATCH"},
-        {STATUS_FWP_INCOMPATIBLE_SA_STATE, -EIO,
-        "STATUS_FWP_INCOMPATIBLE_SA_STATE"},
-        {STATUS_FWP_NULL_POINTER, -EIO, "STATUS_FWP_NULL_POINTER"},
-        {STATUS_FWP_INVALID_ENUMERATOR, -EIO, "STATUS_FWP_INVALID_ENUMERATOR"},
-        {STATUS_FWP_INVALID_FLAGS, -EIO, "STATUS_FWP_INVALID_FLAGS"},
-        {STATUS_FWP_INVALID_NET_MASK, -EIO, "STATUS_FWP_INVALID_NET_MASK"},
-        {STATUS_FWP_INVALID_RANGE, -EIO, "STATUS_FWP_INVALID_RANGE"},
-        {STATUS_FWP_INVALID_INTERVAL, -EIO, "STATUS_FWP_INVALID_INTERVAL"},
-        {STATUS_FWP_ZERO_LENGTH_ARRAY, -EIO, "STATUS_FWP_ZERO_LENGTH_ARRAY"},
-        {STATUS_FWP_NULL_DISPLAY_NAME, -EIO, "STATUS_FWP_NULL_DISPLAY_NAME"},
-        {STATUS_FWP_INVALID_ACTION_TYPE, -EIO,
-        "STATUS_FWP_INVALID_ACTION_TYPE"},
-        {STATUS_FWP_INVALID_WEIGHT, -EIO, "STATUS_FWP_INVALID_WEIGHT"},
-        {STATUS_FWP_MATCH_TYPE_MISMATCH, -EIO,
-        "STATUS_FWP_MATCH_TYPE_MISMATCH"},
-        {STATUS_FWP_TYPE_MISMATCH, -EIO, "STATUS_FWP_TYPE_MISMATCH"},
-        {STATUS_FWP_OUT_OF_BOUNDS, -EIO, "STATUS_FWP_OUT_OF_BOUNDS"},
-        {STATUS_FWP_RESERVED, -EIO, "STATUS_FWP_RESERVED"},
-        {STATUS_FWP_DUPLICATE_CONDITION, -EIO,
-        "STATUS_FWP_DUPLICATE_CONDITION"},
-        {STATUS_FWP_DUPLICATE_KEYMOD, -EIO, "STATUS_FWP_DUPLICATE_KEYMOD"},
-        {STATUS_FWP_ACTION_INCOMPATIBLE_WITH_LAYER, -EIO,
-        "STATUS_FWP_ACTION_INCOMPATIBLE_WITH_LAYER"},
-        {STATUS_FWP_ACTION_INCOMPATIBLE_WITH_SUBLAYER, -EIO,
-        "STATUS_FWP_ACTION_INCOMPATIBLE_WITH_SUBLAYER"},
-        {STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_LAYER, -EIO,
-        "STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_LAYER"},
-        {STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_CALLOUT, -EIO,
-        "STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_CALLOUT"},
-        {STATUS_FWP_INCOMPATIBLE_AUTH_METHOD, -EIO,
-        "STATUS_FWP_INCOMPATIBLE_AUTH_METHOD"},
-        {STATUS_FWP_INCOMPATIBLE_DH_GROUP, -EIO,
-        "STATUS_FWP_INCOMPATIBLE_DH_GROUP"},
-        {STATUS_FWP_EM_NOT_SUPPORTED, -EOPNOTSUPP,
-        "STATUS_FWP_EM_NOT_SUPPORTED"},
-        {STATUS_FWP_NEVER_MATCH, -EIO, "STATUS_FWP_NEVER_MATCH"},
-        {STATUS_FWP_PROVIDER_CONTEXT_MISMATCH, -EIO,
-        "STATUS_FWP_PROVIDER_CONTEXT_MISMATCH"},
-        {STATUS_FWP_INVALID_PARAMETER, -EIO, "STATUS_FWP_INVALID_PARAMETER"},
-        {STATUS_FWP_TOO_MANY_SUBLAYERS, -EIO, "STATUS_FWP_TOO_MANY_SUBLAYERS"},
-        {STATUS_FWP_CALLOUT_NOTIFICATION_FAILED, -EIO,
-        "STATUS_FWP_CALLOUT_NOTIFICATION_FAILED"},
-        {STATUS_FWP_INCOMPATIBLE_AUTH_CONFIG, -EIO,
-        "STATUS_FWP_INCOMPATIBLE_AUTH_CONFIG"},
-        {STATUS_FWP_INCOMPATIBLE_CIPHER_CONFIG, -EIO,
-        "STATUS_FWP_INCOMPATIBLE_CIPHER_CONFIG"},
-        {STATUS_FWP_TCPIP_NOT_READY, -EIO, "STATUS_FWP_TCPIP_NOT_READY"},
-        {STATUS_FWP_INJECT_HANDLE_CLOSING, -EIO,
-        "STATUS_FWP_INJECT_HANDLE_CLOSING"},
-        {STATUS_FWP_INJECT_HANDLE_STALE, -EIO,
-        "STATUS_FWP_INJECT_HANDLE_STALE"},
-        {STATUS_FWP_CANNOT_PEND, -EIO, "STATUS_FWP_CANNOT_PEND"},
-        {STATUS_NDIS_CLOSING, -EIO, "STATUS_NDIS_CLOSING"},
-        {STATUS_NDIS_BAD_VERSION, -EIO, "STATUS_NDIS_BAD_VERSION"},
-        {STATUS_NDIS_BAD_CHARACTERISTICS, -EIO,
-        "STATUS_NDIS_BAD_CHARACTERISTICS"},
-        {STATUS_NDIS_ADAPTER_NOT_FOUND, -EIO, "STATUS_NDIS_ADAPTER_NOT_FOUND"},
-        {STATUS_NDIS_OPEN_FAILED, -EIO, "STATUS_NDIS_OPEN_FAILED"},
-        {STATUS_NDIS_DEVICE_FAILED, -EIO, "STATUS_NDIS_DEVICE_FAILED"},
-        {STATUS_NDIS_MULTICAST_FULL, -EIO, "STATUS_NDIS_MULTICAST_FULL"},
-        {STATUS_NDIS_MULTICAST_EXISTS, -EIO, "STATUS_NDIS_MULTICAST_EXISTS"},
-        {STATUS_NDIS_MULTICAST_NOT_FOUND, -EIO,
-        "STATUS_NDIS_MULTICAST_NOT_FOUND"},
-        {STATUS_NDIS_REQUEST_ABORTED, -EIO, "STATUS_NDIS_REQUEST_ABORTED"},
-        {STATUS_NDIS_RESET_IN_PROGRESS, -EIO, "STATUS_NDIS_RESET_IN_PROGRESS"},
-        {STATUS_NDIS_INVALID_PACKET, -EIO, "STATUS_NDIS_INVALID_PACKET"},
-        {STATUS_NDIS_INVALID_DEVICE_REQUEST, -EIO,
-        "STATUS_NDIS_INVALID_DEVICE_REQUEST"},
-        {STATUS_NDIS_ADAPTER_NOT_READY, -EIO, "STATUS_NDIS_ADAPTER_NOT_READY"},
-        {STATUS_NDIS_INVALID_LENGTH, -EIO, "STATUS_NDIS_INVALID_LENGTH"},
-        {STATUS_NDIS_INVALID_DATA, -EIO, "STATUS_NDIS_INVALID_DATA"},
-        {STATUS_NDIS_BUFFER_TOO_SHORT, -ENOBUFS,
-        "STATUS_NDIS_BUFFER_TOO_SHORT"},
-        {STATUS_NDIS_INVALID_OID, -EIO, "STATUS_NDIS_INVALID_OID"},
-        {STATUS_NDIS_ADAPTER_REMOVED, -EIO, "STATUS_NDIS_ADAPTER_REMOVED"},
-        {STATUS_NDIS_UNSUPPORTED_MEDIA, -EIO, "STATUS_NDIS_UNSUPPORTED_MEDIA"},
-        {STATUS_NDIS_GROUP_ADDRESS_IN_USE, -EIO,
-        "STATUS_NDIS_GROUP_ADDRESS_IN_USE"},
-        {STATUS_NDIS_FILE_NOT_FOUND, -EIO, "STATUS_NDIS_FILE_NOT_FOUND"},
-        {STATUS_NDIS_ERROR_READING_FILE, -EIO,
-        "STATUS_NDIS_ERROR_READING_FILE"},
-        {STATUS_NDIS_ALREADY_MAPPED, -EIO, "STATUS_NDIS_ALREADY_MAPPED"},
-        {STATUS_NDIS_RESOURCE_CONFLICT, -EIO, "STATUS_NDIS_RESOURCE_CONFLICT"},
-        {STATUS_NDIS_MEDIA_DISCONNECTED, -EIO,
-        "STATUS_NDIS_MEDIA_DISCONNECTED"},
-        {STATUS_NDIS_INVALID_ADDRESS, -EIO, "STATUS_NDIS_INVALID_ADDRESS"},
-        {STATUS_NDIS_PAUSED, -EIO, "STATUS_NDIS_PAUSED"},
-        {STATUS_NDIS_INTERFACE_NOT_FOUND, -EIO,
-        "STATUS_NDIS_INTERFACE_NOT_FOUND"},
-        {STATUS_NDIS_UNSUPPORTED_REVISION, -EIO,
-        "STATUS_NDIS_UNSUPPORTED_REVISION"},
-        {STATUS_NDIS_INVALID_PORT, -EIO, "STATUS_NDIS_INVALID_PORT"},
-        {STATUS_NDIS_INVALID_PORT_STATE, -EIO,
-        "STATUS_NDIS_INVALID_PORT_STATE"},
-        {STATUS_NDIS_LOW_POWER_STATE, -EIO, "STATUS_NDIS_LOW_POWER_STATE"},
-        {STATUS_NDIS_NOT_SUPPORTED, -ENOSYS, "STATUS_NDIS_NOT_SUPPORTED"},
-        {STATUS_NDIS_DOT11_AUTO_CONFIG_ENABLED, -EIO,
-        "STATUS_NDIS_DOT11_AUTO_CONFIG_ENABLED"},
-        {STATUS_NDIS_DOT11_MEDIA_IN_USE, -EIO,
-        "STATUS_NDIS_DOT11_MEDIA_IN_USE"},
-        {STATUS_NDIS_DOT11_POWER_STATE_INVALID, -EIO,
-        "STATUS_NDIS_DOT11_POWER_STATE_INVALID"},
-        {STATUS_IPSEC_BAD_SPI, -EIO, "STATUS_IPSEC_BAD_SPI"},
-        {STATUS_IPSEC_SA_LIFETIME_EXPIRED, -EIO,
-        "STATUS_IPSEC_SA_LIFETIME_EXPIRED"},
-        {STATUS_IPSEC_WRONG_SA, -EIO, "STATUS_IPSEC_WRONG_SA"},
-        {STATUS_IPSEC_REPLAY_CHECK_FAILED, -EIO,
-        "STATUS_IPSEC_REPLAY_CHECK_FAILED"},
-        {STATUS_IPSEC_INVALID_PACKET, -EIO, "STATUS_IPSEC_INVALID_PACKET"},
-        {STATUS_IPSEC_INTEGRITY_CHECK_FAILED, -EIO,
-        "STATUS_IPSEC_INTEGRITY_CHECK_FAILED"},
-        {STATUS_IPSEC_CLEAR_TEXT_DROP, -EIO, "STATUS_IPSEC_CLEAR_TEXT_DROP"},
-        {0, 0, NULL}
-};
-
-/*****************************************************************************
- Print an error message from the status code
- *****************************************************************************/
-static void
-smb2_print_status(__le32 status)
-{
-        int idx = 0;
-
-        while (smb2_error_map_table[idx].status_string != NULL) {
-                if ((smb2_error_map_table[idx].smb2_status) == status) {
-                        pr_notice("Status code returned 0x%08x %s\n", status,
-                                  smb2_error_map_table[idx].status_string);
-                }
-                idx++;
-        }
-        return;
-}
-
-int
-map_smb2_to_linux_error(char *buf, bool log_err)
-{
-        struct smb2_hdr *hdr = (struct smb2_hdr *)buf;
-        unsigned int i;
-        int rc = -EIO;
-        __le32 smb2err = hdr->Status;
-
-        if (smb2err == 0)
-                return 0;
-
-        /* mask facility */
-        if (log_err && (smb2err != STATUS_MORE_PROCESSING_REQUIRED) &&
-            (smb2err != STATUS_END_OF_FILE))
-                smb2_print_status(smb2err);
-        else if (cifsFYI & CIFS_RC)
-                smb2_print_status(smb2err);
-
-        for (i = 0; i < sizeof(smb2_error_map_table) /
-                        sizeof(struct status_to_posix_error); i++) {
-                if (smb2_error_map_table[i].smb2_status == smb2err) {
-                        rc = smb2_error_map_table[i].posix_error;
-                        break;
-                }
-        }
-
-        /* on error mapping not found  - return EIO */
-
-        cFYI(1, "Mapping SMB2 status code %d to POSIX err %d",
-                 smb2err, rc);
-
-        return rc;
-}
diff --git a/fs/cifs/smb2misc.c b/fs/cifs/smb2misc.c
deleted file mode 100644
index 7b1c5e3287f..00000000000
--- a/fs/cifs/smb2misc.c
+++ /dev/null
@@ -1,583 +0,0 @@
-/*
- *   fs/cifs/smb2misc.c
- *
- *   Copyright (C) International Business Machines  Corp., 2002,2011
- *                 Etersoft, 2012
- *   Author(s): Steve French (sfrench@us.ibm.com)
- *              Pavel Shilovsky (pshilovsky@samba.org) 2012
- *
- *   This library is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU Lesser General Public License as published
- *   by the Free Software Foundation; either version 2.1 of the License, or
- *   (at your option) any later version.
- *
- *   This library is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
- *   the GNU Lesser General Public License for more details.
- *
- *   You should have received a copy of the GNU Lesser General Public License
- *   along with this library; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-#include <linux/ctype.h>
-#include "smb2pdu.h"
-#include "cifsglob.h"
-#include "cifsproto.h"
-#include "smb2proto.h"
-#include "cifs_debug.h"
-#include "cifs_unicode.h"
-#include "smb2status.h"
-
-static int
-check_smb2_hdr(struct smb2_hdr *hdr, __u64 mid)
-{
-        /*
-         * Make sure that this really is an SMB, that it is a response,
-         * and that the message ids match.
-         */
-        if ((*(__le32 *)hdr->ProtocolId == SMB2_PROTO_NUMBER) &&
-            (mid == hdr->MessageId)) {
-                if (hdr->Flags & SMB2_FLAGS_SERVER_TO_REDIR)
-                        return 0;
-                else {
-                        /* only one valid case where server sends us request */
-                        if (hdr->Command == SMB2_OPLOCK_BREAK)
-                                return 0;
-                        else
-                                cERROR(1, "Received Request not response");
-                }
-        } else { /* bad signature or mid */
-                if (*(__le32 *)hdr->ProtocolId != SMB2_PROTO_NUMBER)
-                        cERROR(1, "Bad protocol string signature header %x",
-                                  *(unsigned int *) hdr->ProtocolId);
-                if (mid != hdr->MessageId)
-                        cERROR(1, "Mids do not match: %llu and %llu", mid,
-                                  hdr->MessageId);
-        }
-        cERROR(1, "Bad SMB detected. The Mid=%llu", hdr->MessageId);
-        return 1;
-}
-
-/*
- *  The following table defines the expected "StructureSize" of SMB2 responses
- *  in order by SMB2 command.  This is similar to "wct" in SMB/CIFS responses.
- *
- *  Note that commands are defined in smb2pdu.h in le16 but the array below is
- *  indexed by command in host byte order
- */
-static const __le16 smb2_rsp_struct_sizes[NUMBER_OF_SMB2_COMMANDS] = {
-        /* SMB2_NEGOTIATE */ __constant_cpu_to_le16(65),
-        /* SMB2_SESSION_SETUP */ __constant_cpu_to_le16(9),
-        /* SMB2_LOGOFF */ __constant_cpu_to_le16(4),
-        /* SMB2_TREE_CONNECT */ __constant_cpu_to_le16(16),
-        /* SMB2_TREE_DISCONNECT */ __constant_cpu_to_le16(4),
-        /* SMB2_CREATE */ __constant_cpu_to_le16(89),
-        /* SMB2_CLOSE */ __constant_cpu_to_le16(60),
-        /* SMB2_FLUSH */ __constant_cpu_to_le16(4),
-        /* SMB2_READ */ __constant_cpu_to_le16(17),
-        /* SMB2_WRITE */ __constant_cpu_to_le16(17),
-        /* SMB2_LOCK */ __constant_cpu_to_le16(4),
-        /* SMB2_IOCTL */ __constant_cpu_to_le16(49),
-        /* BB CHECK this ... not listed in documentation */
-        /* SMB2_CANCEL */ __constant_cpu_to_le16(0),
-        /* SMB2_ECHO */ __constant_cpu_to_le16(4),
-        /* SMB2_QUERY_DIRECTORY */ __constant_cpu_to_le16(9),
-        /* SMB2_CHANGE_NOTIFY */ __constant_cpu_to_le16(9),
-        /* SMB2_QUERY_INFO */ __constant_cpu_to_le16(9),
-        /* SMB2_SET_INFO */ __constant_cpu_to_le16(2),
-        /* BB FIXME can also be 44 for lease break */
-        /* SMB2_OPLOCK_BREAK */ __constant_cpu_to_le16(24)
-};
-
-int
-smb2_check_message(char *buf, unsigned int length)
-{
-        struct smb2_hdr *hdr = (struct smb2_hdr *)buf;
-        struct smb2_pdu *pdu = (struct smb2_pdu *)hdr;
-        __u64 mid = hdr->MessageId;
-        __u32 len = get_rfc1002_length(buf);
-        __u32 clc_len;  /* calculated length */
-        int command;
-
-        /* BB disable following printk later */
-        cFYI(1, "%s length: 0x%x, smb_buf_length: 0x%x", __func__, length, len);
-
-        /*
-         * Add function to do table lookup of StructureSize by command
-         * ie Validate the wct via smb2_struct_sizes table above
-         */
-
-        if (length < sizeof(struct smb2_pdu)) {
-                if ((length >= sizeof(struct smb2_hdr)) && (hdr->Status != 0)) {
-                        pdu->StructureSize2 = 0;
-                        /*
-                         * As with SMB/CIFS, on some error cases servers may
-                         * not return wct properly
-                         */
-                        return 0;
-                } else {
-                        cERROR(1, "Length less than SMB header size");
-                }
-                return 1;
-        }
-        if (len > CIFSMaxBufSize + MAX_SMB2_HDR_SIZE - 4) {
-                cERROR(1, "SMB length greater than maximum, mid=%llu", mid);
-                return 1;
-        }
-
-        if (check_smb2_hdr(hdr, mid))
-                return 1;
-
-        if (hdr->StructureSize != SMB2_HEADER_STRUCTURE_SIZE) {
-                cERROR(1, "Illegal structure size %u",
-                          le16_to_cpu(hdr->StructureSize));
-                return 1;
-        }
-
-        command = le16_to_cpu(hdr->Command);
-        if (command >= NUMBER_OF_SMB2_COMMANDS) {
-                cERROR(1, "Illegal SMB2 command %d", command);
-                return 1;
-        }
-
-        if (smb2_rsp_struct_sizes[command] != pdu->StructureSize2) {
-                if (command != SMB2_OPLOCK_BREAK_HE && (hdr->Status == 0 ||
-                    pdu->StructureSize2 != SMB2_ERROR_STRUCTURE_SIZE2)) {
-                        /* error packets have 9 byte structure size */
-                        cERROR(1, "Illegal response size %u for command %d",
-                                   le16_to_cpu(pdu->StructureSize2), command);
-                        return 1;
-                } else if (command == SMB2_OPLOCK_BREAK_HE && (hdr->Status == 0)
-                           && (le16_to_cpu(pdu->StructureSize2) != 44)
-                           && (le16_to_cpu(pdu->StructureSize2) != 36)) {
-                        /* special case for SMB2.1 lease break message */
-                        cERROR(1, "Illegal response size %d for oplock break",
-                                   le16_to_cpu(pdu->StructureSize2));
-                        return 1;
-                }
-        }
-
-        if (4 + len != length) {
-                cERROR(1, "Total length %u RFC1002 length %u mismatch mid %llu",
-                          length, 4 + len, mid);
-                return 1;
-        }
-
-        clc_len = smb2_calc_size(hdr);
-
-        if (4 + len != clc_len) {
-                cFYI(1, "Calculated size %u length %u mismatch mid %llu",
-                        clc_len, 4 + len, mid);
-                /* Windows 7 server returns 24 bytes more */
-                if (clc_len + 20 == len && command == SMB2_OPLOCK_BREAK_HE)
-                        return 0;
-                /* server can return one byte more */
-                if (clc_len == 4 + len + 1)
-                        return 0;
-                return 1;
-        }
-        return 0;
-}
-
-/*
- * The size of the variable area depends on the offset and length fields
- * located in different fields for various SMB2 responses. SMB2 responses
- * with no variable length info, show an offset of zero for the offset field.
- */
-static const bool has_smb2_data_area[NUMBER_OF_SMB2_COMMANDS] = {
-        /* SMB2_NEGOTIATE */ true,
-        /* SMB2_SESSION_SETUP */ true,
-        /* SMB2_LOGOFF */ false,
-        /* SMB2_TREE_CONNECT */ false,
-        /* SMB2_TREE_DISCONNECT */ false,
-        /* SMB2_CREATE */ true,
-        /* SMB2_CLOSE */ false,
-        /* SMB2_FLUSH */ false,
-        /* SMB2_READ */ true,
-        /* SMB2_WRITE */ false,
-        /* SMB2_LOCK */ false,
-        /* SMB2_IOCTL */ true,
-        /* SMB2_CANCEL */ false, /* BB CHECK this not listed in documentation */
-        /* SMB2_ECHO */ false,
-        /* SMB2_QUERY_DIRECTORY */ true,
-        /* SMB2_CHANGE_NOTIFY */ true,
-        /* SMB2_QUERY_INFO */ true,
-        /* SMB2_SET_INFO */ false,
-        /* SMB2_OPLOCK_BREAK */ false
-};
-
-/*
- * Returns the pointer to the beginning of the data area. Length of the data
- * area and the offset to it (from the beginning of the smb are also returned.
- */
-char *
-smb2_get_data_area_len(int *off, int *len, struct smb2_hdr *hdr)
-{
-        *off = 0;
-        *len = 0;
-
-        /* error responses do not have data area */
-        if (hdr->Status && hdr->Status != STATUS_MORE_PROCESSING_REQUIRED &&
-            (((struct smb2_err_rsp *)hdr)->StructureSize) ==
-                                                SMB2_ERROR_STRUCTURE_SIZE2)
-                return NULL;
-
-        /*
-         * Following commands have data areas so we have to get the location
-         * of the data buffer offset and data buffer length for the particular
-         * command.
-         */
-        switch (hdr->Command) {
-        case SMB2_NEGOTIATE:
-                *off = le16_to_cpu(
-                    ((struct smb2_negotiate_rsp *)hdr)->SecurityBufferOffset);
-                *len = le16_to_cpu(
-                    ((struct smb2_negotiate_rsp *)hdr)->SecurityBufferLength);
-                break;
-        case SMB2_SESSION_SETUP:
-                *off = le16_to_cpu(
-                    ((struct smb2_sess_setup_rsp *)hdr)->SecurityBufferOffset);
-                *len = le16_to_cpu(
-                    ((struct smb2_sess_setup_rsp *)hdr)->SecurityBufferLength);
-                break;
-        case SMB2_CREATE:
-                *off = le32_to_cpu(
-                    ((struct smb2_create_rsp *)hdr)->CreateContextsOffset);
-                *len = le32_to_cpu(
-                    ((struct smb2_create_rsp *)hdr)->CreateContextsLength);
-                break;
-        case SMB2_QUERY_INFO:
-                *off = le16_to_cpu(
-                    ((struct smb2_query_info_rsp *)hdr)->OutputBufferOffset);
-                *len = le32_to_cpu(
-                    ((struct smb2_query_info_rsp *)hdr)->OutputBufferLength);
-                break;
-        case SMB2_READ:
-                *off = ((struct smb2_read_rsp *)hdr)->DataOffset;
-                *len = le32_to_cpu(((struct smb2_read_rsp *)hdr)->DataLength);
-                break;
-        case SMB2_QUERY_DIRECTORY:
-                *off = le16_to_cpu(
-                  ((struct smb2_query_directory_rsp *)hdr)->OutputBufferOffset);
-                *len = le32_to_cpu(
-                  ((struct smb2_query_directory_rsp *)hdr)->OutputBufferLength);
-                break;
-        case SMB2_IOCTL:
-        case SMB2_CHANGE_NOTIFY:
-        default:
-                /* BB FIXME for unimplemented cases above */
-                cERROR(1, "no length check for command");
-                break;
-        }
-
-        /*
-         * Invalid length or offset probably means data area is invalid, but
-         * we have little choice but to ignore the data area in this case.
-         */
-        if (*off > 4096) {
-                cERROR(1, "offset %d too large, data area ignored", *off);
-                *len = 0;
-                *off = 0;
-        } else if (*off < 0) {
-                cERROR(1, "negative offset %d to data invalid ignore data area",
-                          *off);
-                *off = 0;
-                *len = 0;
-        } else if (*len < 0) {
-                cERROR(1, "negative data length %d invalid, data area ignored",
-                          *len);
-                *len = 0;
-        } else if (*len > 128 * 1024) {
-                cERROR(1, "data area larger than 128K: %d", *len);
-                *len = 0;
-        }
-
-        /* return pointer to beginning of data area, ie offset from SMB start */
-        if ((*off != 0) && (*len != 0))
-                return hdr->ProtocolId + *off;
-        else
-                return NULL;
-}
-
-/*
- * Calculate the size of the SMB message based on the fixed header
- * portion, the number of word parameters and the data portion of the message.
- */
-unsigned int
-smb2_calc_size(void *buf)
-{
-        struct smb2_hdr *hdr = (struct smb2_hdr *)buf;
-        struct smb2_pdu *pdu = (struct smb2_pdu *)hdr;
-        int offset; /* the offset from the beginning of SMB to data area */
-        int data_length; /* the length of the variable length data area */
-        /* Structure Size has already been checked to make sure it is 64 */
-        int len = 4 + le16_to_cpu(pdu->hdr.StructureSize);
-
-        /*
-         * StructureSize2, ie length of fixed parameter area has already
-         * been checked to make sure it is the correct length.
-         */
-        len += le16_to_cpu(pdu->StructureSize2);
-
-        if (has_smb2_data_area[le16_to_cpu(hdr->Command)] == false)
-                goto calc_size_exit;
-
-        smb2_get_data_area_len(&offset, &data_length, hdr);
-        cFYI(1, "SMB2 data length %d offset %d", data_length, offset);
-
-        if (data_length > 0) {
-                /*
-                 * Check to make sure that data area begins after fixed area,
-                 * Note that last byte of the fixed area is part of data area
-                 * for some commands, typically those with odd StructureSize,
-                 * so we must add one to the calculation (and 4 to account for
-                 * the size of the RFC1001 hdr.
-                 */
-                if (offset + 4 + 1 < len) {
-                        cERROR(1, "data area offset %d overlaps SMB2 header %d",
-                                  offset + 4 + 1, len);
-                        data_length = 0;
-                } else {
-                        len = 4 + offset + data_length;
-                }
-        }
-calc_size_exit:
-        cFYI(1, "SMB2 len %d", len);
-        return len;
-}
-
-/* Note: caller must free return buffer */
-__le16 *
-cifs_convert_path_to_utf16(const char *from, struct cifs_sb_info *cifs_sb)
-{
-        int len;
-        const char *start_of_path;
-        __le16 *to;
-
-        /* Windows doesn't allow paths beginning with \ */
-        if (from[0] == '\\')
-                start_of_path = from + 1;
-        else
-                start_of_path = from;
-        to = cifs_strndup_to_utf16(start_of_path, PATH_MAX, &len,
-                                   cifs_sb->local_nls,
-                                   cifs_sb->mnt_cifs_flags &
-                                        CIFS_MOUNT_MAP_SPECIAL_CHR);
-        return to;
-}
-
-__le32
-smb2_get_lease_state(struct cifsInodeInfo *cinode)
-{
-        if (cinode->clientCanCacheAll)
-                return SMB2_LEASE_WRITE_CACHING | SMB2_LEASE_READ_CACHING;
-        else if (cinode->clientCanCacheRead)
-                return SMB2_LEASE_READ_CACHING;
-        return 0;
-}
-
-__u8 smb2_map_lease_to_oplock(__le32 lease_state)
-{
-        if (lease_state & SMB2_LEASE_WRITE_CACHING) {
-                if (lease_state & SMB2_LEASE_HANDLE_CACHING)
-                        return SMB2_OPLOCK_LEVEL_BATCH;
-                else
-                        return SMB2_OPLOCK_LEVEL_EXCLUSIVE;
-        } else if (lease_state & SMB2_LEASE_READ_CACHING)
-                return SMB2_OPLOCK_LEVEL_II;
-        return 0;
-}
-
-struct smb2_lease_break_work {
-        struct work_struct lease_break;
-        struct tcon_link *tlink;
-        __u8 lease_key[16];
-        __le32 lease_state;
-};
-
-static void
-cifs_ses_oplock_break(struct work_struct *work)
-{
-        struct smb2_lease_break_work *lw = container_of(work,
-                                struct smb2_lease_break_work, lease_break);
-        int rc;
-
-        rc = SMB2_lease_break(0, tlink_tcon(lw->tlink), lw->lease_key,
-                              lw->lease_state);
-        cFYI(1, "Lease release rc %d", rc);
-        cifs_put_tlink(lw->tlink);
-        kfree(lw);
-}
-
-static bool
-smb2_is_valid_lease_break(char *buffer, struct TCP_Server_Info *server)
-{
-        struct smb2_lease_break *rsp = (struct smb2_lease_break *)buffer;
-        struct list_head *tmp, *tmp1, *tmp2;
-        struct cifs_ses *ses;
-        struct cifs_tcon *tcon;
-        struct cifsInodeInfo *cinode;
-        struct cifsFileInfo *cfile;
-        struct cifs_pending_open *open;
-        struct smb2_lease_break_work *lw;
-        bool found;
-        int ack_req = le32_to_cpu(rsp->Flags &
-                                  SMB2_NOTIFY_BREAK_LEASE_FLAG_ACK_REQUIRED);
-
-        lw = kmalloc(sizeof(struct smb2_lease_break_work), GFP_KERNEL);
-        if (!lw) {
-                cERROR(1, "Memory allocation failed during lease break check");
-                return false;
-        }
-
-        INIT_WORK(&lw->lease_break, cifs_ses_oplock_break);
-        lw->lease_state = rsp->NewLeaseState;
-
-        cFYI(1, "Checking for lease break");
-
-        /* look up tcon based on tid & uid */
-        spin_lock(&cifs_tcp_ses_lock);
-        list_for_each(tmp, &server->smb_ses_list) {
-                ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
-
-                spin_lock(&cifs_file_list_lock);
-                list_for_each(tmp1, &ses->tcon_list) {
-                        tcon = list_entry(tmp1, struct cifs_tcon, tcon_list);
-
-                        cifs_stats_inc(&tcon->stats.cifs_stats.num_oplock_brks);
-                        list_for_each(tmp2, &tcon->openFileList) {
-                                cfile = list_entry(tmp2, struct cifsFileInfo,
-                                                   tlist);
-                                cinode = CIFS_I(cfile->dentry->d_inode);
-
-                                if (memcmp(cinode->lease_key, rsp->LeaseKey,
-                                           SMB2_LEASE_KEY_SIZE))
-                                        continue;
-
-                                cFYI(1, "found in the open list");
-                                cFYI(1, "lease key match, lease break 0x%d",
-                                     le32_to_cpu(rsp->NewLeaseState));
-
-                                smb2_set_oplock_level(cinode,
-                                  smb2_map_lease_to_oplock(rsp->NewLeaseState));
-
-                                if (ack_req)
-                                        cfile->oplock_break_cancelled = false;
-                                else
-                                        cfile->oplock_break_cancelled = true;
-
-                                queue_work(cifsiod_wq, &cfile->oplock_break);
-
-                                spin_unlock(&cifs_file_list_lock);
-                                spin_unlock(&cifs_tcp_ses_lock);
-                                return true;
-                        }
-
-                        found = false;
-                        list_for_each_entry(open, &tcon->pending_opens, olist) {
-                                if (memcmp(open->lease_key, rsp->LeaseKey,
-                                           SMB2_LEASE_KEY_SIZE))
-                                        continue;
-
-                                if (!found && ack_req) {
-                                        found = true;
-                                        memcpy(lw->lease_key, open->lease_key,
-                                               SMB2_LEASE_KEY_SIZE);
-                                        lw->tlink = cifs_get_tlink(open->tlink);
-                                        queue_work(cifsiod_wq,
-                                                   &lw->lease_break);
-                                }
-
-                                cFYI(1, "found in the pending open list");
-                                cFYI(1, "lease key match, lease break 0x%d",
-                                     le32_to_cpu(rsp->NewLeaseState));
-
-                                open->oplock =
-                                  smb2_map_lease_to_oplock(rsp->NewLeaseState);
-                        }
-                        if (found) {
-                                spin_unlock(&cifs_file_list_lock);
-                                spin_unlock(&cifs_tcp_ses_lock);
-                                return true;
-                        }
-                }
-                spin_unlock(&cifs_file_list_lock);
-        }
-        spin_unlock(&cifs_tcp_ses_lock);
-        kfree(lw);
-        cFYI(1, "Can not process lease break - no lease matched");
-        return false;
-}
-
-bool
-smb2_is_valid_oplock_break(char *buffer, struct TCP_Server_Info *server)
-{
-        struct smb2_oplock_break *rsp = (struct smb2_oplock_break *)buffer;
-        struct list_head *tmp, *tmp1, *tmp2;
-        struct cifs_ses *ses;
-        struct cifs_tcon *tcon;
-        struct cifsInodeInfo *cinode;
-        struct cifsFileInfo *cfile;
-
-        cFYI(1, "Checking for oplock break");
-
-        if (rsp->hdr.Command != SMB2_OPLOCK_BREAK)
-                return false;
-
-        if (rsp->StructureSize !=
-                                smb2_rsp_struct_sizes[SMB2_OPLOCK_BREAK_HE]) {
-                if (le16_to_cpu(rsp->StructureSize) == 44)
-                        return smb2_is_valid_lease_break(buffer, server);
-                else
-                        return false;
-        }
-
-        cFYI(1, "oplock level 0x%d", rsp->OplockLevel);
-
-        /* look up tcon based on tid & uid */
-        spin_lock(&cifs_tcp_ses_lock);
-        list_for_each(tmp, &server->smb_ses_list) {
-                ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
-                list_for_each(tmp1, &ses->tcon_list) {
-                        tcon = list_entry(tmp1, struct cifs_tcon, tcon_list);
-
-                        cifs_stats_inc(&tcon->stats.cifs_stats.num_oplock_brks);
-                        spin_lock(&cifs_file_list_lock);
-                        list_for_each(tmp2, &tcon->openFileList) {
-                                cfile = list_entry(tmp2, struct cifsFileInfo,
-                                                     tlist);
-                                if (rsp->PersistentFid !=
-                                    cfile->fid.persistent_fid ||
-                                    rsp->VolatileFid !=
-                                    cfile->fid.volatile_fid)
-                                        continue;
-
-                                cFYI(1, "file id match, oplock break");
-                                cinode = CIFS_I(cfile->dentry->d_inode);
-
-                                if (!cinode->clientCanCacheAll &&
-                                    rsp->OplockLevel == SMB2_OPLOCK_LEVEL_NONE)
-                                        cfile->oplock_break_cancelled = true;
-                                else
-                                        cfile->oplock_break_cancelled = false;
-
-                                smb2_set_oplock_level(cinode,
-                                  rsp->OplockLevel ? SMB2_OPLOCK_LEVEL_II : 0);
-
-                                queue_work(cifsiod_wq, &cfile->oplock_break);
-
-                                spin_unlock(&cifs_file_list_lock);
-                                spin_unlock(&cifs_tcp_ses_lock);
-                                return true;
-                        }
-                        spin_unlock(&cifs_file_list_lock);
-                        spin_unlock(&cifs_tcp_ses_lock);
-                        cFYI(1, "No matching file for oplock break");
-                        return true;
-                }
-        }
-        spin_unlock(&cifs_tcp_ses_lock);
-        cFYI(1, "Can not process oplock break for non-existent connection");
-        return false;
-}
diff --git a/fs/cifs/smb2ops.c b/fs/cifs/smb2ops.c
deleted file mode 100644
index c9c7aa7ed96..00000000000
--- a/fs/cifs/smb2ops.c
+++ /dev/null
@@ -1,747 +0,0 @@
-/*
- *  SMB2 version specific operations
- *
- *  Copyright (c) 2012, Jeff Layton <jlayton@redhat.com>
- *
- *  This library is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License v2 as published
- *  by the Free Software Foundation.
- *
- *  This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
- *  the GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this library; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-
-#include <linux/pagemap.h>
-#include <linux/vfs.h>
-#include "cifsglob.h"
-#include "smb2pdu.h"
-#include "smb2proto.h"
-#include "cifsproto.h"
-#include "cifs_debug.h"
-#include "smb2status.h"
-#include "smb2glob.h"
-
-static int
-change_conf(struct TCP_Server_Info *server)
-{
-        server->credits += server->echo_credits + server->oplock_credits;
-        server->oplock_credits = server->echo_credits = 0;
-        switch (server->credits) {
-        case 0:
-                return -1;
-        case 1:
-                server->echoes = false;
-                server->oplocks = false;
-                cERROR(1, "disabling echoes and oplocks");
-                break;
-        case 2:
-                server->echoes = true;
-                server->oplocks = false;
-                server->echo_credits = 1;
-                cFYI(1, "disabling oplocks");
-                break;
-        default:
-                server->echoes = true;
-                server->oplocks = true;
-                server->echo_credits = 1;
-                server->oplock_credits = 1;
-        }
-        server->credits -= server->echo_credits + server->oplock_credits;
-        return 0;
-}
-
-static void
-smb2_add_credits(struct TCP_Server_Info *server, const unsigned int add,
-                 const int optype)
-{
-        int *val, rc = 0;
-        spin_lock(&server->req_lock);
-        val = server->ops->get_credits_field(server, optype);
-        *val += add;
-        server->in_flight--;
-        if (server->in_flight == 0 && (optype & CIFS_OP_MASK) != CIFS_NEG_OP)
-                rc = change_conf(server);
-        /*
-         * Sometimes server returns 0 credits on oplock break ack - we need to
-         * rebalance credits in this case.
-         */
-        else if (server->in_flight > 0 && server->oplock_credits == 0 &&
-                 server->oplocks) {
-                if (server->credits > 1) {
-                        server->credits--;
-                        server->oplock_credits++;
-                }
-        }
-        spin_unlock(&server->req_lock);
-        wake_up(&server->request_q);
-        if (rc)
-                cifs_reconnect(server);
-}
-
-static void
-smb2_set_credits(struct TCP_Server_Info *server, const int val)
-{
-        spin_lock(&server->req_lock);
-        server->credits = val;
-        spin_unlock(&server->req_lock);
-}
-
-static int *
-smb2_get_credits_field(struct TCP_Server_Info *server, const int optype)
-{
-        switch (optype) {
-        case CIFS_ECHO_OP:
-                return &server->echo_credits;
-        case CIFS_OBREAK_OP:
-                return &server->oplock_credits;
-        default:
-                return &server->credits;
-        }
-}
-
-static unsigned int
-smb2_get_credits(struct mid_q_entry *mid)
-{
-        return le16_to_cpu(((struct smb2_hdr *)mid->resp_buf)->CreditRequest);
-}
-
-static __u64
-smb2_get_next_mid(struct TCP_Server_Info *server)
-{
-        __u64 mid;
-        /* for SMB2 we need the current value */
-        spin_lock(&GlobalMid_Lock);
-        mid = server->CurrentMid++;
-        spin_unlock(&GlobalMid_Lock);
-        return mid;
-}
-
-static struct mid_q_entry *
-smb2_find_mid(struct TCP_Server_Info *server, char *buf)
-{
-        struct mid_q_entry *mid;
-        struct smb2_hdr *hdr = (struct smb2_hdr *)buf;
-
-        spin_lock(&GlobalMid_Lock);
-        list_for_each_entry(mid, &server->pending_mid_q, qhead) {
-                if ((mid->mid == hdr->MessageId) &&
-                    (mid->mid_state == MID_REQUEST_SUBMITTED) &&
-                    (mid->command == hdr->Command)) {
-                        spin_unlock(&GlobalMid_Lock);
-                        return mid;
-                }
-        }
-        spin_unlock(&GlobalMid_Lock);
-        return NULL;
-}
-
-static void
-smb2_dump_detail(void *buf)
-{
-#ifdef CONFIG_CIFS_DEBUG2
-        struct smb2_hdr *smb = (struct smb2_hdr *)buf;
-
-        cERROR(1, "Cmd: %d Err: 0x%x Flags: 0x%x Mid: %llu Pid: %d",
-                  smb->Command, smb->Status, smb->Flags, smb->MessageId,
-                  smb->ProcessId);
-        cERROR(1, "smb buf %p len %u", smb, smb2_calc_size(smb));
-#endif
-}
-
-static bool
-smb2_need_neg(struct TCP_Server_Info *server)
-{
-        return server->max_read == 0;
-}
-
-static int
-smb2_negotiate(const unsigned int xid, struct cifs_ses *ses)
-{
-        int rc;
-        ses->server->CurrentMid = 0;
-        rc = SMB2_negotiate(xid, ses);
-        /* BB we probably don't need to retry with modern servers */
-        if (rc == -EAGAIN)
-                rc = -EHOSTDOWN;
-        return rc;
-}
-
-static unsigned int
-smb2_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *volume_info)
-{
-        struct TCP_Server_Info *server = tcon->ses->server;
-        unsigned int wsize;
-
-        /* start with specified wsize, or default */
-        wsize = volume_info->wsize ? volume_info->wsize : CIFS_DEFAULT_IOSIZE;
-        wsize = min_t(unsigned int, wsize, server->max_write);
-        /*
-         * limit write size to 2 ** 16, because we don't support multicredit
-         * requests now.
-         */
-        wsize = min_t(unsigned int, wsize, 2 << 15);
-
-        return wsize;
-}
-
-static unsigned int
-smb2_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *volume_info)
-{
-        struct TCP_Server_Info *server = tcon->ses->server;
-        unsigned int rsize;
-
-        /* start with specified rsize, or default */
-        rsize = volume_info->rsize ? volume_info->rsize : CIFS_DEFAULT_IOSIZE;
-        rsize = min_t(unsigned int, rsize, server->max_read);
-        /*
-         * limit write size to 2 ** 16, because we don't support multicredit
-         * requests now.
-         */
-        rsize = min_t(unsigned int, rsize, 2 << 15);
-
-        return rsize;
-}
-
-static int
-smb2_is_path_accessible(const unsigned int xid, struct cifs_tcon *tcon,
-                        struct cifs_sb_info *cifs_sb, const char *full_path)
-{
-        int rc;
-        __u64 persistent_fid, volatile_fid;
-        __le16 *utf16_path;
-        __u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
-
-        utf16_path = cifs_convert_path_to_utf16(full_path, cifs_sb);
-        if (!utf16_path)
-                return -ENOMEM;
-
-        rc = SMB2_open(xid, tcon, utf16_path, &persistent_fid, &volatile_fid,
-                       FILE_READ_ATTRIBUTES, FILE_OPEN, 0, 0, &oplock, NULL);
-        if (rc) {
-                kfree(utf16_path);
-                return rc;
-        }
-
-        rc = SMB2_close(xid, tcon, persistent_fid, volatile_fid);
-        kfree(utf16_path);
-        return rc;
-}
-
-static int
-smb2_get_srv_inum(const unsigned int xid, struct cifs_tcon *tcon,
-                  struct cifs_sb_info *cifs_sb, const char *full_path,
-                  u64 *uniqueid, FILE_ALL_INFO *data)
-{
-        *uniqueid = le64_to_cpu(data->IndexNumber);
-        return 0;
-}
-
-static int
-smb2_query_file_info(const unsigned int xid, struct cifs_tcon *tcon,
-                     struct cifs_fid *fid, FILE_ALL_INFO *data)
-{
-        int rc;
-        struct smb2_file_all_info *smb2_data;
-
-        smb2_data = kzalloc(sizeof(struct smb2_file_all_info) + MAX_NAME * 2,
-                            GFP_KERNEL);
-        if (smb2_data == NULL)
-                return -ENOMEM;
-
-        rc = SMB2_query_info(xid, tcon, fid->persistent_fid, fid->volatile_fid,
-                             smb2_data);
-        if (!rc)
-                move_smb2_info_to_cifs(data, smb2_data);
-        kfree(smb2_data);
-        return rc;
-}
-
-static bool
-smb2_can_echo(struct TCP_Server_Info *server)
-{
-        return server->echoes;
-}
-
-static void
-smb2_clear_stats(struct cifs_tcon *tcon)
-{
-#ifdef CONFIG_CIFS_STATS
-        int i;
-        for (i = 0; i < NUMBER_OF_SMB2_COMMANDS; i++) {
-                atomic_set(&tcon->stats.smb2_stats.smb2_com_sent[i], 0);
-                atomic_set(&tcon->stats.smb2_stats.smb2_com_failed[i], 0);
-        }
-#endif
-}
-
-static void
-smb2_print_stats(struct seq_file *m, struct cifs_tcon *tcon)
-{
-#ifdef CONFIG_CIFS_STATS
-        atomic_t *sent = tcon->stats.smb2_stats.smb2_com_sent;
-        atomic_t *failed = tcon->stats.smb2_stats.smb2_com_failed;
-        seq_printf(m, "\nNegotiates: %d sent %d failed",
-                   atomic_read(&sent[SMB2_NEGOTIATE_HE]),
-                   atomic_read(&failed[SMB2_NEGOTIATE_HE]));
-        seq_printf(m, "\nSessionSetups: %d sent %d failed",
-                   atomic_read(&sent[SMB2_SESSION_SETUP_HE]),
-                   atomic_read(&failed[SMB2_SESSION_SETUP_HE]));
-#define SMB2LOGOFF              0x0002 /* trivial request/resp */
-        seq_printf(m, "\nLogoffs: %d sent %d failed",
-                   atomic_read(&sent[SMB2_LOGOFF_HE]),
-                   atomic_read(&failed[SMB2_LOGOFF_HE]));
-        seq_printf(m, "\nTreeConnects: %d sent %d failed",
-                   atomic_read(&sent[SMB2_TREE_CONNECT_HE]),
-                   atomic_read(&failed[SMB2_TREE_CONNECT_HE]));
-        seq_printf(m, "\nTreeDisconnects: %d sent %d failed",
-                   atomic_read(&sent[SMB2_TREE_DISCONNECT_HE]),
-                   atomic_read(&failed[SMB2_TREE_DISCONNECT_HE]));
-        seq_printf(m, "\nCreates: %d sent %d failed",
-                   atomic_read(&sent[SMB2_CREATE_HE]),
-                   atomic_read(&failed[SMB2_CREATE_HE]));
-        seq_printf(m, "\nCloses: %d sent %d failed",
-                   atomic_read(&sent[SMB2_CLOSE_HE]),
-                   atomic_read(&failed[SMB2_CLOSE_HE]));
-        seq_printf(m, "\nFlushes: %d sent %d failed",
-                   atomic_read(&sent[SMB2_FLUSH_HE]),
-                   atomic_read(&failed[SMB2_FLUSH_HE]));
-        seq_printf(m, "\nReads: %d sent %d failed",
-                   atomic_read(&sent[SMB2_READ_HE]),
-                   atomic_read(&failed[SMB2_READ_HE]));
-        seq_printf(m, "\nWrites: %d sent %d failed",
-                   atomic_read(&sent[SMB2_WRITE_HE]),
-                   atomic_read(&failed[SMB2_WRITE_HE]));
-        seq_printf(m, "\nLocks: %d sent %d failed",
-                   atomic_read(&sent[SMB2_LOCK_HE]),
-                   atomic_read(&failed[SMB2_LOCK_HE]));
-        seq_printf(m, "\nIOCTLs: %d sent %d failed",
-                   atomic_read(&sent[SMB2_IOCTL_HE]),
-                   atomic_read(&failed[SMB2_IOCTL_HE]));
-        seq_printf(m, "\nCancels: %d sent %d failed",
-                   atomic_read(&sent[SMB2_CANCEL_HE]),
-                   atomic_read(&failed[SMB2_CANCEL_HE]));
-        seq_printf(m, "\nEchos: %d sent %d failed",
-                   atomic_read(&sent[SMB2_ECHO_HE]),
-                   atomic_read(&failed[SMB2_ECHO_HE]));
-        seq_printf(m, "\nQueryDirectories: %d sent %d failed",
-                   atomic_read(&sent[SMB2_QUERY_DIRECTORY_HE]),
-                   atomic_read(&failed[SMB2_QUERY_DIRECTORY_HE]));
-        seq_printf(m, "\nChangeNotifies: %d sent %d failed",
-                   atomic_read(&sent[SMB2_CHANGE_NOTIFY_HE]),
-                   atomic_read(&failed[SMB2_CHANGE_NOTIFY_HE]));
-        seq_printf(m, "\nQueryInfos: %d sent %d failed",
-                   atomic_read(&sent[SMB2_QUERY_INFO_HE]),
-                   atomic_read(&failed[SMB2_QUERY_INFO_HE]));
-        seq_printf(m, "\nSetInfos: %d sent %d failed",
-                   atomic_read(&sent[SMB2_SET_INFO_HE]),
-                   atomic_read(&failed[SMB2_SET_INFO_HE]));
-        seq_printf(m, "\nOplockBreaks: %d sent %d failed",
-                   atomic_read(&sent[SMB2_OPLOCK_BREAK_HE]),
-                   atomic_read(&failed[SMB2_OPLOCK_BREAK_HE]));
-#endif
-}
-
-static void
-smb2_set_fid(struct cifsFileInfo *cfile, struct cifs_fid *fid, __u32 oplock)
-{
-        struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
-        cfile->fid.persistent_fid = fid->persistent_fid;
-        cfile->fid.volatile_fid = fid->volatile_fid;
-        smb2_set_oplock_level(cinode, oplock);
-        cinode->can_cache_brlcks = cinode->clientCanCacheAll;
-}
-
-static void
-smb2_close_file(const unsigned int xid, struct cifs_tcon *tcon,
-                struct cifs_fid *fid)
-{
-        SMB2_close(xid, tcon, fid->persistent_fid, fid->volatile_fid);
-}
-
-static int
-smb2_flush_file(const unsigned int xid, struct cifs_tcon *tcon,
-                struct cifs_fid *fid)
-{
-        return SMB2_flush(xid, tcon, fid->persistent_fid, fid->volatile_fid);
-}
-
-static unsigned int
-smb2_read_data_offset(char *buf)
-{
-        struct smb2_read_rsp *rsp = (struct smb2_read_rsp *)buf;
-        return rsp->DataOffset;
-}
-
-static unsigned int
-smb2_read_data_length(char *buf)
-{
-        struct smb2_read_rsp *rsp = (struct smb2_read_rsp *)buf;
-        return le32_to_cpu(rsp->DataLength);
-}
-
-
-static int
-smb2_sync_read(const unsigned int xid, struct cifsFileInfo *cfile,
-               struct cifs_io_parms *parms, unsigned int *bytes_read,
-               char **buf, int *buf_type)
-{
-        parms->persistent_fid = cfile->fid.persistent_fid;
-        parms->volatile_fid = cfile->fid.volatile_fid;
-        return SMB2_read(xid, parms, bytes_read, buf, buf_type);
-}
-
-static int
-smb2_sync_write(const unsigned int xid, struct cifsFileInfo *cfile,
-                struct cifs_io_parms *parms, unsigned int *written,
-                struct kvec *iov, unsigned long nr_segs)
-{
-
-        parms->persistent_fid = cfile->fid.persistent_fid;
-        parms->volatile_fid = cfile->fid.volatile_fid;
-        return SMB2_write(xid, parms, written, iov, nr_segs);
-}
-
-static int
-smb2_set_file_size(const unsigned int xid, struct cifs_tcon *tcon,
-                   struct cifsFileInfo *cfile, __u64 size, bool set_alloc)
-{
-        __le64 eof = cpu_to_le64(size);
-        return SMB2_set_eof(xid, tcon, cfile->fid.persistent_fid,
-                            cfile->fid.volatile_fid, cfile->pid, &eof);
-}
-
-static int
-smb2_query_dir_first(const unsigned int xid, struct cifs_tcon *tcon,
-                     const char *path, struct cifs_sb_info *cifs_sb,
-                     struct cifs_fid *fid, __u16 search_flags,
-                     struct cifs_search_info *srch_inf)
-{
-        __le16 *utf16_path;
-        int rc;
-        __u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
-        __u64 persistent_fid, volatile_fid;
-
-        utf16_path = cifs_convert_path_to_utf16(path, cifs_sb);
-        if (!utf16_path)
-                return -ENOMEM;
-
-        rc = SMB2_open(xid, tcon, utf16_path, &persistent_fid, &volatile_fid,
-                       FILE_READ_ATTRIBUTES | FILE_READ_DATA, FILE_OPEN, 0, 0,
-                       &oplock, NULL);
-        kfree(utf16_path);
-        if (rc) {
-                cERROR(1, "open dir failed");
-                return rc;
-        }
-
-        srch_inf->entries_in_buffer = 0;
-        srch_inf->index_of_last_entry = 0;
-        fid->persistent_fid = persistent_fid;
-        fid->volatile_fid = volatile_fid;
-
-        rc = SMB2_query_directory(xid, tcon, persistent_fid, volatile_fid, 0,
-                                  srch_inf);
-        if (rc) {
-                cERROR(1, "query directory failed");
-                SMB2_close(xid, tcon, persistent_fid, volatile_fid);
-        }
-        return rc;
-}
-
-static int
-smb2_query_dir_next(const unsigned int xid, struct cifs_tcon *tcon,
-                    struct cifs_fid *fid, __u16 search_flags,
-                    struct cifs_search_info *srch_inf)
-{
-        return SMB2_query_directory(xid, tcon, fid->persistent_fid,
-                                    fid->volatile_fid, 0, srch_inf);
-}
-
-static int
-smb2_close_dir(const unsigned int xid, struct cifs_tcon *tcon,
-               struct cifs_fid *fid)
-{
-        return SMB2_close(xid, tcon, fid->persistent_fid, fid->volatile_fid);
-}
-
-/*
-* If we negotiate SMB2 protocol and get STATUS_PENDING - update
-* the number of credits and return true. Otherwise - return false.
-*/
-static bool
-smb2_is_status_pending(char *buf, struct TCP_Server_Info *server, int length)
-{
-        struct smb2_hdr *hdr = (struct smb2_hdr *)buf;
-
-        if (hdr->Status != STATUS_PENDING)
-                return false;
-
-        if (!length) {
-                spin_lock(&server->req_lock);
-                server->credits += le16_to_cpu(hdr->CreditRequest);
-                spin_unlock(&server->req_lock);
-                wake_up(&server->request_q);
-        }
-
-        return true;
-}
-
-static int
-smb2_oplock_response(struct cifs_tcon *tcon, struct cifs_fid *fid,
-                     struct cifsInodeInfo *cinode)
-{
-        if (tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_LEASING)
-                return SMB2_lease_break(0, tcon, cinode->lease_key,
-                                        smb2_get_lease_state(cinode));
-
-        return SMB2_oplock_break(0, tcon, fid->persistent_fid,
-                                 fid->volatile_fid,
-                                 cinode->clientCanCacheRead ? 1 : 0);
-}
-
-static int
-smb2_queryfs(const unsigned int xid, struct cifs_tcon *tcon,
-             struct kstatfs *buf)
-{
-        int rc;
-        u64 persistent_fid, volatile_fid;
-        __le16 srch_path = 0; /* Null - open root of share */
-        u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
-
-        rc = SMB2_open(xid, tcon, &srch_path, &persistent_fid, &volatile_fid,
-                       FILE_READ_ATTRIBUTES, FILE_OPEN, 0, 0, &oplock, NULL);
-        if (rc)
-                return rc;
-        buf->f_type = SMB2_MAGIC_NUMBER;
-        rc = SMB2_QFS_info(xid, tcon, persistent_fid, volatile_fid, buf);
-        SMB2_close(xid, tcon, persistent_fid, volatile_fid);
-        return rc;
-}
-
-static bool
-smb2_compare_fids(struct cifsFileInfo *ob1, struct cifsFileInfo *ob2)
-{
-        return ob1->fid.persistent_fid == ob2->fid.persistent_fid &&
-               ob1->fid.volatile_fid == ob2->fid.volatile_fid;
-}
-
-static int
-smb2_mand_lock(const unsigned int xid, struct cifsFileInfo *cfile, __u64 offset,
-               __u64 length, __u32 type, int lock, int unlock, bool wait)
-{
-        if (unlock && !lock)
-                type = SMB2_LOCKFLAG_UNLOCK;
-        return SMB2_lock(xid, tlink_tcon(cfile->tlink),
-                         cfile->fid.persistent_fid, cfile->fid.volatile_fid,
-                         current->tgid, length, offset, type, wait);
-}
-
-static void
-smb2_get_lease_key(struct inode *inode, struct cifs_fid *fid)
-{
-        memcpy(fid->lease_key, CIFS_I(inode)->lease_key, SMB2_LEASE_KEY_SIZE);
-}
-
-static void
-smb2_set_lease_key(struct inode *inode, struct cifs_fid *fid)
-{
-        memcpy(CIFS_I(inode)->lease_key, fid->lease_key, SMB2_LEASE_KEY_SIZE);
-}
-
-static void
-smb2_new_lease_key(struct cifs_fid *fid)
-{
-        get_random_bytes(fid->lease_key, SMB2_LEASE_KEY_SIZE);
-}
-
-struct smb_version_operations smb21_operations = {
-        .compare_fids = smb2_compare_fids,
-        .setup_request = smb2_setup_request,
-        .setup_async_request = smb2_setup_async_request,
-        .check_receive = smb2_check_receive,
-        .add_credits = smb2_add_credits,
-        .set_credits = smb2_set_credits,
-        .get_credits_field = smb2_get_credits_field,
-        .get_credits = smb2_get_credits,
-        .get_next_mid = smb2_get_next_mid,
-        .read_data_offset = smb2_read_data_offset,
-        .read_data_length = smb2_read_data_length,
-        .map_error = map_smb2_to_linux_error,
-        .find_mid = smb2_find_mid,
-        .check_message = smb2_check_message,
-        .dump_detail = smb2_dump_detail,
-        .clear_stats = smb2_clear_stats,
-        .print_stats = smb2_print_stats,
-        .is_oplock_break = smb2_is_valid_oplock_break,
-        .need_neg = smb2_need_neg,
-        .negotiate = smb2_negotiate,
-        .negotiate_wsize = smb2_negotiate_wsize,
-        .negotiate_rsize = smb2_negotiate_rsize,
-        .sess_setup = SMB2_sess_setup,
-        .logoff = SMB2_logoff,
-        .tree_connect = SMB2_tcon,
-        .tree_disconnect = SMB2_tdis,
-        .is_path_accessible = smb2_is_path_accessible,
-        .can_echo = smb2_can_echo,
-        .echo = SMB2_echo,
-        .query_path_info = smb2_query_path_info,
-        .get_srv_inum = smb2_get_srv_inum,
-        .query_file_info = smb2_query_file_info,
-        .set_path_size = smb2_set_path_size,
-        .set_file_size = smb2_set_file_size,
-        .set_file_info = smb2_set_file_info,
-        .mkdir = smb2_mkdir,
-        .mkdir_setinfo = smb2_mkdir_setinfo,
-        .rmdir = smb2_rmdir,
-        .unlink = smb2_unlink,
-        .rename = smb2_rename_path,
-        .create_hardlink = smb2_create_hardlink,
-        .open = smb2_open_file,
-        .set_fid = smb2_set_fid,
-        .close = smb2_close_file,
-        .flush = smb2_flush_file,
-        .async_readv = smb2_async_readv,
-        .async_writev = smb2_async_writev,
-        .sync_read = smb2_sync_read,
-        .sync_write = smb2_sync_write,
-        .query_dir_first = smb2_query_dir_first,
-        .query_dir_next = smb2_query_dir_next,
-        .close_dir = smb2_close_dir,
-        .calc_smb_size = smb2_calc_size,
-        .is_status_pending = smb2_is_status_pending,
-        .oplock_response = smb2_oplock_response,
-        .queryfs = smb2_queryfs,
-        .mand_lock = smb2_mand_lock,
-        .mand_unlock_range = smb2_unlock_range,
-        .push_mand_locks = smb2_push_mandatory_locks,
-        .get_lease_key = smb2_get_lease_key,
-        .set_lease_key = smb2_set_lease_key,
-        .new_lease_key = smb2_new_lease_key,
-        .calc_signature = smb2_calc_signature,
-};
-
-
-struct smb_version_operations smb30_operations = {
-        .compare_fids = smb2_compare_fids,
-        .setup_request = smb2_setup_request,
-        .setup_async_request = smb2_setup_async_request,
-        .check_receive = smb2_check_receive,
-        .add_credits = smb2_add_credits,
-        .set_credits = smb2_set_credits,
-        .get_credits_field = smb2_get_credits_field,
-        .get_credits = smb2_get_credits,
-        .get_next_mid = smb2_get_next_mid,
-        .read_data_offset = smb2_read_data_offset,
-        .read_data_length = smb2_read_data_length,
-        .map_error = map_smb2_to_linux_error,
-        .find_mid = smb2_find_mid,
-        .check_message = smb2_check_message,
-        .dump_detail = smb2_dump_detail,
-        .clear_stats = smb2_clear_stats,
-        .print_stats = smb2_print_stats,
-        .is_oplock_break = smb2_is_valid_oplock_break,
-        .need_neg = smb2_need_neg,
-        .negotiate = smb2_negotiate,
-        .negotiate_wsize = smb2_negotiate_wsize,
-        .negotiate_rsize = smb2_negotiate_rsize,
-        .sess_setup = SMB2_sess_setup,
-        .logoff = SMB2_logoff,
-        .tree_connect = SMB2_tcon,
-        .tree_disconnect = SMB2_tdis,
-        .is_path_accessible = smb2_is_path_accessible,
-        .can_echo = smb2_can_echo,
-        .echo = SMB2_echo,
-        .query_path_info = smb2_query_path_info,
-        .get_srv_inum = smb2_get_srv_inum,
-        .query_file_info = smb2_query_file_info,
-        .set_path_size = smb2_set_path_size,
-        .set_file_size = smb2_set_file_size,
-        .set_file_info = smb2_set_file_info,
-        .mkdir = smb2_mkdir,
-        .mkdir_setinfo = smb2_mkdir_setinfo,
-        .rmdir = smb2_rmdir,
-        .unlink = smb2_unlink,
-        .rename = smb2_rename_path,
-        .create_hardlink = smb2_create_hardlink,
-        .open = smb2_open_file,
-        .set_fid = smb2_set_fid,
-        .close = smb2_close_file,
-        .flush = smb2_flush_file,
-        .async_readv = smb2_async_readv,
-        .async_writev = smb2_async_writev,
-        .sync_read = smb2_sync_read,
-        .sync_write = smb2_sync_write,
-        .query_dir_first = smb2_query_dir_first,
-        .query_dir_next = smb2_query_dir_next,
-        .close_dir = smb2_close_dir,
-        .calc_smb_size = smb2_calc_size,
-        .is_status_pending = smb2_is_status_pending,
-        .oplock_response = smb2_oplock_response,
-        .queryfs = smb2_queryfs,
-        .mand_lock = smb2_mand_lock,
-        .mand_unlock_range = smb2_unlock_range,
-        .push_mand_locks = smb2_push_mandatory_locks,
-        .get_lease_key = smb2_get_lease_key,
-        .set_lease_key = smb2_set_lease_key,
-        .new_lease_key = smb2_new_lease_key,
-        .calc_signature = smb3_calc_signature,
-};
-
-struct smb_version_values smb20_values = {
-        .version_string = SMB20_VERSION_STRING,
-        .protocol_id = SMB20_PROT_ID,
-        .req_capabilities = 0, /* MBZ */
-        .large_lock_type = 0,
-        .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK,
-        .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK,
-        .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK,
-        .header_size = sizeof(struct smb2_hdr),
-        .max_header_size = MAX_SMB2_HDR_SIZE,
-        .read_rsp_size = sizeof(struct smb2_read_rsp) - 1,
-        .lock_cmd = SMB2_LOCK,
-        .cap_unix = 0,
-        .cap_nt_find = SMB2_NT_FIND,
-        .cap_large_files = SMB2_LARGE_FILES,
-        .oplock_read = SMB2_OPLOCK_LEVEL_II,
-};
-
-struct smb_version_values smb21_values = {
-        .version_string = SMB21_VERSION_STRING,
-        .protocol_id = SMB21_PROT_ID,
-        .req_capabilities = 0, /* MBZ on negotiate req until SMB3 dialect */
-        .large_lock_type = 0,
-        .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK,
-        .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK,
-        .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK,
-        .header_size = sizeof(struct smb2_hdr),
-        .max_header_size = MAX_SMB2_HDR_SIZE,
-        .read_rsp_size = sizeof(struct smb2_read_rsp) - 1,
-        .lock_cmd = SMB2_LOCK,
-        .cap_unix = 0,
-        .cap_nt_find = SMB2_NT_FIND,
-        .cap_large_files = SMB2_LARGE_FILES,
-        .oplock_read = SMB2_OPLOCK_LEVEL_II,
-};
-
-struct smb_version_values smb30_values = {
-        .version_string = SMB30_VERSION_STRING,
-        .protocol_id = SMB30_PROT_ID,
-        .req_capabilities = SMB2_GLOBAL_CAP_DFS | SMB2_GLOBAL_CAP_LEASING | SMB2_GLOBAL_CAP_LARGE_MTU,
-        .large_lock_type = 0,
-        .exclusive_lock_type = SMB2_LOCKFLAG_EXCLUSIVE_LOCK,
-        .shared_lock_type = SMB2_LOCKFLAG_SHARED_LOCK,
-        .unlock_lock_type = SMB2_LOCKFLAG_UNLOCK,
-        .header_size = sizeof(struct smb2_hdr),
-        .max_header_size = MAX_SMB2_HDR_SIZE,
-        .read_rsp_size = sizeof(struct smb2_read_rsp) - 1,
-        .lock_cmd = SMB2_LOCK,
-        .cap_unix = 0,
-        .cap_nt_find = SMB2_NT_FIND,
-        .cap_large_files = SMB2_LARGE_FILES,
-};
diff --git a/fs/cifs/smb2pdu.c b/fs/cifs/smb2pdu.c
deleted file mode 100644
index 41d9d0725f0..00000000000
--- a/fs/cifs/smb2pdu.c
+++ /dev/null
@@ -1,2211 +0,0 @@
-/*
- *   fs/cifs/smb2pdu.c
- *
- *   Copyright (C) International Business Machines  Corp., 2009, 2012
- *                 Etersoft, 2012
- *   Author(s): Steve French (sfrench@us.ibm.com)
- *              Pavel Shilovsky (pshilovsky@samba.org) 2012
- *
- *   Contains the routines for constructing the SMB2 PDUs themselves
- *
- *   This library is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU Lesser General Public License as published
- *   by the Free Software Foundation; either version 2.1 of the License, or
- *   (at your option) any later version.
- *
- *   This library is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
- *   the GNU Lesser General Public License for more details.
- *
- *   You should have received a copy of the GNU Lesser General Public License
- *   along with this library; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-
- /* SMB2 PDU handling routines here - except for leftovers (eg session setup) */
- /* Note that there are handle based routines which must be                   */
- /* treated slightly differently for reconnection purposes since we never     */
- /* want to reuse a stale file handle and only the caller knows the file info */
-
-#include <linux/fs.h>
-#include <linux/kernel.h>
-#include <linux/vfs.h>
-#include <linux/task_io_accounting_ops.h>
-#include <linux/uaccess.h>
-#include <linux/pagemap.h>
-#include <linux/xattr.h>
-#include "smb2pdu.h"
-#include "cifsglob.h"
-#include "cifsacl.h"
-#include "cifsproto.h"
-#include "smb2proto.h"
-#include "cifs_unicode.h"
-#include "cifs_debug.h"
-#include "ntlmssp.h"
-#include "smb2status.h"
-#include "smb2glob.h"
-#include "cifspdu.h"
-
-/*
- *  The following table defines the expected "StructureSize" of SMB2 requests
- *  in order by SMB2 command.  This is similar to "wct" in SMB/CIFS requests.
- *
- *  Note that commands are defined in smb2pdu.h in le16 but the array below is
- *  indexed by command in host byte order.
- */
-static const int smb2_req_struct_sizes[NUMBER_OF_SMB2_COMMANDS] = {
-        /* SMB2_NEGOTIATE */ 36,
-        /* SMB2_SESSION_SETUP */ 25,
-        /* SMB2_LOGOFF */ 4,
-        /* SMB2_TREE_CONNECT */ 9,
-        /* SMB2_TREE_DISCONNECT */ 4,
-        /* SMB2_CREATE */ 57,
-        /* SMB2_CLOSE */ 24,
-        /* SMB2_FLUSH */ 24,
-        /* SMB2_READ */ 49,
-        /* SMB2_WRITE */ 49,
-        /* SMB2_LOCK */ 48,
-        /* SMB2_IOCTL */ 57,
-        /* SMB2_CANCEL */ 4,
-        /* SMB2_ECHO */ 4,
-        /* SMB2_QUERY_DIRECTORY */ 33,
-        /* SMB2_CHANGE_NOTIFY */ 32,
-        /* SMB2_QUERY_INFO */ 41,
-        /* SMB2_SET_INFO */ 33,
-        /* SMB2_OPLOCK_BREAK */ 24 /* BB this is 36 for LEASE_BREAK variant */
-};
-
-
-static void
-smb2_hdr_assemble(struct smb2_hdr *hdr, __le16 smb2_cmd /* command */ ,
-                  const struct cifs_tcon *tcon)
-{
-        struct smb2_pdu *pdu = (struct smb2_pdu *)hdr;
-        char *temp = (char *)hdr;
-        /* lookup word count ie StructureSize from table */
-        __u16 parmsize = smb2_req_struct_sizes[le16_to_cpu(smb2_cmd)];
-
-        /*
-         * smaller than SMALL_BUFFER_SIZE but bigger than fixed area of
-         * largest operations (Create)
-         */
-        memset(temp, 0, 256);
-
-        /* Note this is only network field converted to big endian */
-        hdr->smb2_buf_length = cpu_to_be32(parmsize + sizeof(struct smb2_hdr)
-                        - 4 /*  RFC 1001 length field itself not counted */);
-
-        hdr->ProtocolId[0] = 0xFE;
-        hdr->ProtocolId[1] = 'S';
-        hdr->ProtocolId[2] = 'M';
-        hdr->ProtocolId[3] = 'B';
-        hdr->StructureSize = cpu_to_le16(64);
-        hdr->Command = smb2_cmd;
-        hdr->CreditRequest = cpu_to_le16(2); /* BB make this dynamic */
-        hdr->ProcessId = cpu_to_le32((__u16)current->tgid);
-
-        if (!tcon)
-                goto out;
-
-        hdr->TreeId = tcon->tid;
-        /* Uid is not converted */
-        if (tcon->ses)
-                hdr->SessionId = tcon->ses->Suid;
-        /* BB check following DFS flags BB */
-        /* BB do we have to add check for SHI1005_FLAGS_DFS_ROOT too? */
-        if (tcon->share_flags & SHI1005_FLAGS_DFS)
-                hdr->Flags |= SMB2_FLAGS_DFS_OPERATIONS;
-        /* BB how does SMB2 do case sensitive? */
-        /* if (tcon->nocase)
-                hdr->Flags |= SMBFLG_CASELESS; */
-        if (tcon->ses && tcon->ses->server &&
-            (tcon->ses->server->sec_mode & SECMODE_SIGN_REQUIRED))
-                hdr->Flags |= SMB2_FLAGS_SIGNED;
-out:
-        pdu->StructureSize2 = cpu_to_le16(parmsize);
-        return;
-}
-
-static int
-smb2_reconnect(__le16 smb2_command, struct cifs_tcon *tcon)
-{
-        int rc = 0;
-        struct nls_table *nls_codepage;
-        struct cifs_ses *ses;
-        struct TCP_Server_Info *server;
-
-        /*
-         * SMB2s NegProt, SessSetup, Logoff do not have tcon yet so
-         * check for tcp and smb session status done differently
-         * for those three - in the calling routine.
-         */
-        if (tcon == NULL)
-                return rc;
-
-        if (smb2_command == SMB2_TREE_CONNECT)
-                return rc;
-
-        if (tcon->tidStatus == CifsExiting) {
-                /*
-                 * only tree disconnect, open, and write,
-                 * (and ulogoff which does not have tcon)
-                 * are allowed as we start force umount.
-                 */
-                if ((smb2_command != SMB2_WRITE) &&
-                   (smb2_command != SMB2_CREATE) &&
-                   (smb2_command != SMB2_TREE_DISCONNECT)) {
-                        cFYI(1, "can not send cmd %d while umounting",
-                                smb2_command);
-                        return -ENODEV;
-                }
-        }
-        if ((!tcon->ses) || (tcon->ses->status == CifsExiting) ||
-            (!tcon->ses->server))
-                return -EIO;
-
-        ses = tcon->ses;
-        server = ses->server;
-
-        /*
-         * Give demultiplex thread up to 10 seconds to reconnect, should be
-         * greater than cifs socket timeout which is 7 seconds
-         */
-        while (server->tcpStatus == CifsNeedReconnect) {
-                /*
-                 * Return to caller for TREE_DISCONNECT and LOGOFF and CLOSE
-                 * here since they are implicitly done when session drops.
-                 */
-                switch (smb2_command) {
-                /*
-                 * BB Should we keep oplock break and add flush to exceptions?
-                 */
-                case SMB2_TREE_DISCONNECT:
-                case SMB2_CANCEL:
-                case SMB2_CLOSE:
-                case SMB2_OPLOCK_BREAK:
-                        return -EAGAIN;
-                }
-
-                wait_event_interruptible_timeout(server->response_q,
-                        (server->tcpStatus != CifsNeedReconnect), 10 * HZ);
-
-                /* are we still trying to reconnect? */
-                if (server->tcpStatus != CifsNeedReconnect)
-                        break;
-
-                /*
-                 * on "soft" mounts we wait once. Hard mounts keep
-                 * retrying until process is killed or server comes
-                 * back on-line
-                 */
-                if (!tcon->retry) {
-                        cFYI(1, "gave up waiting on reconnect in smb_init");
-                        return -EHOSTDOWN;
-                }
-        }
-
-        if (!tcon->ses->need_reconnect && !tcon->need_reconnect)
-                return rc;
-
-        nls_codepage = load_nls_default();
-
-        /*
-         * need to prevent multiple threads trying to simultaneously reconnect
-         * the same SMB session
-         */
-        mutex_lock(&tcon->ses->session_mutex);
-        rc = cifs_negotiate_protocol(0, tcon->ses);
-        if (!rc && tcon->ses->need_reconnect)
-                rc = cifs_setup_session(0, tcon->ses, nls_codepage);
-
-        if (rc || !tcon->need_reconnect) {
-                mutex_unlock(&tcon->ses->session_mutex);
-                goto out;
-        }
-
-        cifs_mark_open_files_invalid(tcon);
-        rc = SMB2_tcon(0, tcon->ses, tcon->treeName, tcon, nls_codepage);
-        mutex_unlock(&tcon->ses->session_mutex);
-        cFYI(1, "reconnect tcon rc = %d", rc);
-        if (rc)
-                goto out;
-        atomic_inc(&tconInfoReconnectCount);
-        /*
-         * BB FIXME add code to check if wsize needs update due to negotiated
-         * smb buffer size shrinking.
-         */
-out:
-        /*
-         * Check if handle based operation so we know whether we can continue
-         * or not without returning to caller to reset file handle.
-         */
-        /*
-         * BB Is flush done by server on drop of tcp session? Should we special
-         * case it and skip above?
-         */
-        switch (smb2_command) {
-        case SMB2_FLUSH:
-        case SMB2_READ:
-        case SMB2_WRITE:
-        case SMB2_LOCK:
-        case SMB2_IOCTL:
-        case SMB2_QUERY_DIRECTORY:
-        case SMB2_CHANGE_NOTIFY:
-        case SMB2_QUERY_INFO:
-        case SMB2_SET_INFO:
-                return -EAGAIN;
-        }
-        unload_nls(nls_codepage);
-        return rc;
-}
-
-/*
- * Allocate and return pointer to an SMB request hdr, and set basic
- * SMB information in the SMB header. If the return code is zero, this
- * function must have filled in request_buf pointer.
- */
-static int
-small_smb2_init(__le16 smb2_command, struct cifs_tcon *tcon,
-                void **request_buf)
-{
-        int rc = 0;
-
-        rc = smb2_reconnect(smb2_command, tcon);
-        if (rc)
-                return rc;
-
-        /* BB eventually switch this to SMB2 specific small buf size */
-        *request_buf = cifs_small_buf_get();
-        if (*request_buf == NULL) {
-                /* BB should we add a retry in here if not a writepage? */
-                return -ENOMEM;
-        }
-
-        smb2_hdr_assemble((struct smb2_hdr *) *request_buf, smb2_command, tcon);
-
-        if (tcon != NULL) {
-#ifdef CONFIG_CIFS_STATS2
-                uint16_t com_code = le16_to_cpu(smb2_command);
-                cifs_stats_inc(&tcon->stats.smb2_stats.smb2_com_sent[com_code]);
-#endif
-                cifs_stats_inc(&tcon->num_smbs_sent);
-        }
-
-        return rc;
-}
-
-static void
-free_rsp_buf(int resp_buftype, void *rsp)
-{
-        if (resp_buftype == CIFS_SMALL_BUFFER)
-                cifs_small_buf_release(rsp);
-        else if (resp_buftype == CIFS_LARGE_BUFFER)
-                cifs_buf_release(rsp);
-}
-
-
-/*
- *
- *      SMB2 Worker functions follow:
- *
- *      The general structure of the worker functions is:
- *      1) Call smb2_init (assembles SMB2 header)
- *      2) Initialize SMB2 command specific fields in fixed length area of SMB
- *      3) Call smb_sendrcv2 (sends request on socket and waits for response)
- *      4) Decode SMB2 command specific fields in the fixed length area
- *      5) Decode variable length data area (if any for this SMB2 command type)
- *      6) Call free smb buffer
- *      7) return
- *
- */
-
-int
-SMB2_negotiate(const unsigned int xid, struct cifs_ses *ses)
-{
-        struct smb2_negotiate_req *req;
-        struct smb2_negotiate_rsp *rsp;
-        struct kvec iov[1];
-        int rc = 0;
-        int resp_buftype;
-        struct TCP_Server_Info *server;
-        unsigned int sec_flags;
-        u16 temp = 0;
-        int blob_offset, blob_length;
-        char *security_blob;
-        int flags = CIFS_NEG_OP;
-
-        cFYI(1, "Negotiate protocol");
-
-        if (ses->server)
-                server = ses->server;
-        else {
-                rc = -EIO;
-                return rc;
-        }
-
-        rc = small_smb2_init(SMB2_NEGOTIATE, NULL, (void **) &req);
-        if (rc)
-                return rc;
-
-        /* if any of auth flags (ie not sign or seal) are overriden use them */
-        if (ses->overrideSecFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
-                sec_flags = ses->overrideSecFlg;  /* BB FIXME fix sign flags?*/
-        else /* if override flags set only sign/seal OR them with global auth */
-                sec_flags = global_secflags | ses->overrideSecFlg;
-
-        cFYI(1, "sec_flags 0x%x", sec_flags);
-
-        req->hdr.SessionId = 0;
-
-        req->Dialects[0] = cpu_to_le16(ses->server->vals->protocol_id);
-
-        req->DialectCount = cpu_to_le16(1); /* One vers= at a time for now */
-        inc_rfc1001_len(req, 2);
-
-        /* only one of SMB2 signing flags may be set in SMB2 request */
-        if ((sec_flags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN)
-                temp = SMB2_NEGOTIATE_SIGNING_REQUIRED;
-        else if (sec_flags & CIFSSEC_MAY_SIGN) /* MAY_SIGN is a single flag */
-                temp = SMB2_NEGOTIATE_SIGNING_ENABLED;
-
-        req->SecurityMode = cpu_to_le16(temp);
-
-        req->Capabilities = cpu_to_le32(ses->server->vals->req_capabilities);
-
-        memcpy(req->ClientGUID, cifs_client_guid, SMB2_CLIENT_GUID_SIZE);
-
-        iov[0].iov_base = (char *)req;
-        /* 4 for rfc1002 length field */
-        iov[0].iov_len = get_rfc1002_length(req) + 4;
-
-        rc = SendReceive2(xid, ses, iov, 1, &resp_buftype, flags);
-
-        rsp = (struct smb2_negotiate_rsp *)iov[0].iov_base;
-        /*
-         * No tcon so can't do
-         * cifs_stats_inc(&tcon->stats.smb2_stats.smb2_com_fail[SMB2...]);
-         */
-        if (rc != 0)
-                goto neg_exit;
-
-        cFYI(1, "mode 0x%x", rsp->SecurityMode);
-
-        /* BB we may eventually want to match the negotiated vs. requested
-           dialect, even though we are only requesting one at a time */
-        if (rsp->DialectRevision == cpu_to_le16(SMB20_PROT_ID))
-                cFYI(1, "negotiated smb2.0 dialect");
-        else if (rsp->DialectRevision == cpu_to_le16(SMB21_PROT_ID))
-                cFYI(1, "negotiated smb2.1 dialect");
-        else if (rsp->DialectRevision == cpu_to_le16(SMB30_PROT_ID))
-                cFYI(1, "negotiated smb3.0 dialect");
-        else {
-                cERROR(1, "Illegal dialect returned by server %d",
-                           le16_to_cpu(rsp->DialectRevision));
-                rc = -EIO;
-                goto neg_exit;
-        }
-        server->dialect = le16_to_cpu(rsp->DialectRevision);
-
-        server->maxBuf = le32_to_cpu(rsp->MaxTransactSize);
-        server->max_read = le32_to_cpu(rsp->MaxReadSize);
-        server->max_write = le32_to_cpu(rsp->MaxWriteSize);
-        /* BB Do we need to validate the SecurityMode? */
-        server->sec_mode = le16_to_cpu(rsp->SecurityMode);
-        server->capabilities = le32_to_cpu(rsp->Capabilities);
-        /* Internal types */
-        server->capabilities |= SMB2_NT_FIND | SMB2_LARGE_FILES;
-
-        security_blob = smb2_get_data_area_len(&blob_offset, &blob_length,
-                                               &rsp->hdr);
-        if (blob_length == 0) {
-                cERROR(1, "missing security blob on negprot");
-                rc = -EIO;
-                goto neg_exit;
-        }
-
-        cFYI(1, "sec_flags 0x%x", sec_flags);
-        if ((sec_flags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) {
-                cFYI(1, "Signing required");
-                if (!(server->sec_mode & (SMB2_NEGOTIATE_SIGNING_REQUIRED |
-                      SMB2_NEGOTIATE_SIGNING_ENABLED))) {
-                        cERROR(1, "signing required but server lacks support");
-                        rc = -EOPNOTSUPP;
-                        goto neg_exit;
-                }
-                server->sec_mode |= SECMODE_SIGN_REQUIRED;
-        } else if (sec_flags & CIFSSEC_MAY_SIGN) {
-                cFYI(1, "Signing optional");
-                if (server->sec_mode & SMB2_NEGOTIATE_SIGNING_REQUIRED) {
-                        cFYI(1, "Server requires signing");
-                        server->sec_mode |= SECMODE_SIGN_REQUIRED;
-                } else {
-                        server->sec_mode &=
-                                ~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
-                }
-        } else {
-                cFYI(1, "Signing disabled");
-                if (server->sec_mode & SMB2_NEGOTIATE_SIGNING_REQUIRED) {
-                        cERROR(1, "Server requires packet signing to be enabled"
-                                  " in /proc/fs/cifs/SecurityFlags.");
-                        rc = -EOPNOTSUPP;
-                        goto neg_exit;
-                }
-                server->sec_mode &=
-                        ~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
-        }
-
-#ifdef CONFIG_SMB2_ASN1  /* BB REMOVEME when updated asn1.c ready */
-        rc = decode_neg_token_init(security_blob, blob_length,
-                                   &server->sec_type);
-        if (rc == 1)
-                rc = 0;
-        else if (rc == 0) {
-                rc = -EIO;
-                goto neg_exit;
-        }
-#endif
-
-neg_exit:
-        free_rsp_buf(resp_buftype, rsp);
-        return rc;
-}
-
-int
-SMB2_sess_setup(const unsigned int xid, struct cifs_ses *ses,
-                const struct nls_table *nls_cp)
-{
-        struct smb2_sess_setup_req *req;
-        struct smb2_sess_setup_rsp *rsp = NULL;
-        struct kvec iov[2];
-        int rc = 0;
-        int resp_buftype;
-        __le32 phase = NtLmNegotiate; /* NTLMSSP, if needed, is multistage */
-        struct TCP_Server_Info *server;
-        unsigned int sec_flags;
-        u8 temp = 0;
-        u16 blob_length = 0;
-        char *security_blob;
-        char *ntlmssp_blob = NULL;
-        bool use_spnego = false; /* else use raw ntlmssp */
-
-        cFYI(1, "Session Setup");
-
-        if (ses->server)
-                server = ses->server;
-        else {
-                rc = -EIO;
-                return rc;
-        }
-
-        /*
-         * If memory allocation is successful, caller of this function
-         * frees it.
-         */
-        ses->ntlmssp = kmalloc(sizeof(struct ntlmssp_auth), GFP_KERNEL);
-        if (!ses->ntlmssp)
-                return -ENOMEM;
-
-        ses->server->secType = RawNTLMSSP;
-
-ssetup_ntlmssp_authenticate:
-        if (phase == NtLmChallenge)
-                phase = NtLmAuthenticate; /* if ntlmssp, now final phase */
-
-        rc = small_smb2_init(SMB2_SESSION_SETUP, NULL, (void **) &req);
-        if (rc)
-                return rc;
-
-        /* if any of auth flags (ie not sign or seal) are overriden use them */
-        if (ses->overrideSecFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
-                sec_flags = ses->overrideSecFlg;  /* BB FIXME fix sign flags?*/
-        else /* if override flags set only sign/seal OR them with global auth */
-                sec_flags = global_secflags | ses->overrideSecFlg;
-
-        cFYI(1, "sec_flags 0x%x", sec_flags);
-
-        req->hdr.SessionId = 0; /* First session, not a reauthenticate */
-        req->VcNumber = 0; /* MBZ */
-        /* to enable echos and oplocks */
-        req->hdr.CreditRequest = cpu_to_le16(3);
-
-        /* only one of SMB2 signing flags may be set in SMB2 request */
-        if ((sec_flags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN)
-                temp = SMB2_NEGOTIATE_SIGNING_REQUIRED;
-        else if (ses->server->sec_mode & SMB2_NEGOTIATE_SIGNING_REQUIRED)
-                temp = SMB2_NEGOTIATE_SIGNING_REQUIRED;
-        else if (sec_flags & CIFSSEC_MAY_SIGN) /* MAY_SIGN is a single flag */
-                temp = SMB2_NEGOTIATE_SIGNING_ENABLED;
-
-        req->SecurityMode = temp;
-        req->Capabilities = 0;
-        req->Channel = 0; /* MBZ */
-
-        iov[0].iov_base = (char *)req;
-        /* 4 for rfc1002 length field and 1 for pad */
-        iov[0].iov_len = get_rfc1002_length(req) + 4 - 1;
-        if (phase == NtLmNegotiate) {
-                ntlmssp_blob = kmalloc(sizeof(struct _NEGOTIATE_MESSAGE),
-                                       GFP_KERNEL);
-                if (ntlmssp_blob == NULL) {
-                        rc = -ENOMEM;
-                        goto ssetup_exit;
-                }
-                build_ntlmssp_negotiate_blob(ntlmssp_blob, ses);
-                if (use_spnego) {
-                        /* blob_length = build_spnego_ntlmssp_blob(
-                                        &security_blob,
-                                        sizeof(struct _NEGOTIATE_MESSAGE),
-                                        ntlmssp_blob); */
-                        /* BB eventually need to add this */
-                        cERROR(1, "spnego not supported for SMB2 yet");
-                        rc = -EOPNOTSUPP;
-                        kfree(ntlmssp_blob);
-                        goto ssetup_exit;
-                } else {
-                        blob_length = sizeof(struct _NEGOTIATE_MESSAGE);
-                        /* with raw NTLMSSP we don't encapsulate in SPNEGO */
-                        security_blob = ntlmssp_blob;
-                }
-        } else if (phase == NtLmAuthenticate) {
-                req->hdr.SessionId = ses->Suid;
-                ntlmssp_blob = kzalloc(sizeof(struct _NEGOTIATE_MESSAGE) + 500,
-                                       GFP_KERNEL);
-                if (ntlmssp_blob == NULL) {
-                        cERROR(1, "failed to malloc ntlmssp blob");
-                        rc = -ENOMEM;
-                        goto ssetup_exit;
-                }
-                rc = build_ntlmssp_auth_blob(ntlmssp_blob, &blob_length, ses,
-                                             nls_cp);
-                if (rc) {
-                        cFYI(1, "build_ntlmssp_auth_blob failed %d", rc);
-                        goto ssetup_exit; /* BB double check error handling */
-                }
-                if (use_spnego) {
-                        /* blob_length = build_spnego_ntlmssp_blob(
-                                                        &security_blob,
-                                                        blob_length,
-                                                        ntlmssp_blob); */
-                        cERROR(1, "spnego not supported for SMB2 yet");
-                        rc = -EOPNOTSUPP;
-                        kfree(ntlmssp_blob);
-                        goto ssetup_exit;
-                } else {
-                        security_blob = ntlmssp_blob;
-                }
-        } else {
-                cERROR(1, "illegal ntlmssp phase");
-                rc = -EIO;
-                goto ssetup_exit;
-        }
-
-        /* Testing shows that buffer offset must be at location of Buffer[0] */
-        req->SecurityBufferOffset =
-                                cpu_to_le16(sizeof(struct smb2_sess_setup_req) -
-                                            1 /* pad */ - 4 /* rfc1001 len */);
-        req->SecurityBufferLength = cpu_to_le16(blob_length);
-        iov[1].iov_base = security_blob;
-        iov[1].iov_len = blob_length;
-
-        inc_rfc1001_len(req, blob_length - 1 /* pad */);
-
-        /* BB add code to build os and lm fields */
-
-        rc = SendReceive2(xid, ses, iov, 2, &resp_buftype,
-                          CIFS_LOG_ERROR | CIFS_NEG_OP);
-
-        kfree(security_blob);
-        rsp = (struct smb2_sess_setup_rsp *)iov[0].iov_base;
-        if (resp_buftype != CIFS_NO_BUFFER &&
-            rsp->hdr.Status == STATUS_MORE_PROCESSING_REQUIRED) {
-                if (phase != NtLmNegotiate) {
-                        cERROR(1, "Unexpected more processing error");
-                        goto ssetup_exit;
-                }
-                if (offsetof(struct smb2_sess_setup_rsp, Buffer) - 4 !=
-                                le16_to_cpu(rsp->SecurityBufferOffset)) {
-                        cERROR(1, "Invalid security buffer offset %d",
-                                  le16_to_cpu(rsp->SecurityBufferOffset));
-                        rc = -EIO;
-                        goto ssetup_exit;
-                }
-
-                /* NTLMSSP Negotiate sent now processing challenge (response) */
-                phase = NtLmChallenge; /* process ntlmssp challenge */
-                rc = 0; /* MORE_PROCESSING is not an error here but expected */
-                ses->Suid = rsp->hdr.SessionId;
-                rc = decode_ntlmssp_challenge(rsp->Buffer,
-                                le16_to_cpu(rsp->SecurityBufferLength), ses);
-        }
-
-        /*
-         * BB eventually add code for SPNEGO decoding of NtlmChallenge blob,
-         * but at least the raw NTLMSSP case works.
-         */
-        /*
-         * No tcon so can't do
-         * cifs_stats_inc(&tcon->stats.smb2_stats.smb2_com_fail[SMB2...]);
-         */
-        if (rc != 0)
-                goto ssetup_exit;
-
-        ses->session_flags = le16_to_cpu(rsp->SessionFlags);
-ssetup_exit:
-        free_rsp_buf(resp_buftype, rsp);
-
-        /* if ntlmssp, and negotiate succeeded, proceed to authenticate phase */
-        if ((phase == NtLmChallenge) && (rc == 0))
-                goto ssetup_ntlmssp_authenticate;
-        return rc;
-}
-
-int
-SMB2_logoff(const unsigned int xid, struct cifs_ses *ses)
-{
-        struct smb2_logoff_req *req; /* response is also trivial struct */
-        int rc = 0;
-        struct TCP_Server_Info *server;
-
-        cFYI(1, "disconnect session %p", ses);
-
-        if (ses && (ses->server))
-                server = ses->server;
-        else
-                return -EIO;
-
-        rc = small_smb2_init(SMB2_LOGOFF, NULL, (void **) &req);
-        if (rc)
-                return rc;
-
-         /* since no tcon, smb2_init can not do this, so do here */
-        req->hdr.SessionId = ses->Suid;
-        if (server->sec_mode & SECMODE_SIGN_REQUIRED)
-                req->hdr.Flags |= SMB2_FLAGS_SIGNED;
-
-        rc = SendReceiveNoRsp(xid, ses, (char *) &req->hdr, 0);
-        /*
-         * No tcon so can't do
-         * cifs_stats_inc(&tcon->stats.smb2_stats.smb2_com_fail[SMB2...]);
-         */
-        return rc;
-}
-
-static inline void cifs_stats_fail_inc(struct cifs_tcon *tcon, uint16_t code)
-{
-        cifs_stats_inc(&tcon->stats.smb2_stats.smb2_com_failed[code]);
-}
-
-#define MAX_SHARENAME_LENGTH (255 /* server */ + 80 /* share */ + 1 /* NULL */)
-
-int
-SMB2_tcon(const unsigned int xid, struct cifs_ses *ses, const char *tree,
-          struct cifs_tcon *tcon, const struct nls_table *cp)
-{
-        struct smb2_tree_connect_req *req;
-        struct smb2_tree_connect_rsp *rsp = NULL;
-        struct kvec iov[2];
-        int rc = 0;
-        int resp_buftype;
-        int unc_path_len;
-        struct TCP_Server_Info *server;
-        __le16 *unc_path = NULL;
-
-        cFYI(1, "TCON");
-
-        if ((ses->server) && tree)
-                server = ses->server;
-        else
-                return -EIO;
-
-        if (tcon && tcon->bad_network_name)
-                return -ENOENT;
-
-        unc_path = kmalloc(MAX_SHARENAME_LENGTH * 2, GFP_KERNEL);
-        if (unc_path == NULL)
-                return -ENOMEM;
-
-        unc_path_len = cifs_strtoUTF16(unc_path, tree, strlen(tree), cp) + 1;
-        unc_path_len *= 2;
-        if (unc_path_len < 2) {
-                kfree(unc_path);
-                return -EINVAL;
-        }
-
-        rc = small_smb2_init(SMB2_TREE_CONNECT, tcon, (void **) &req);
-        if (rc) {
-                kfree(unc_path);
-                return rc;
-        }
-
-        if (tcon == NULL) {
-                /* since no tcon, smb2_init can not do this, so do here */
-                req->hdr.SessionId = ses->Suid;
-                /* if (ses->server->sec_mode & SECMODE_SIGN_REQUIRED)
-                        req->hdr.Flags |= SMB2_FLAGS_SIGNED; */
-        }
-
-        iov[0].iov_base = (char *)req;
-        /* 4 for rfc1002 length field and 1 for pad */
-        iov[0].iov_len = get_rfc1002_length(req) + 4 - 1;
-
-        /* Testing shows that buffer offset must be at location of Buffer[0] */
-        req->PathOffset = cpu_to_le16(sizeof(struct smb2_tree_connect_req)
-                        - 1 /* pad */ - 4 /* do not count rfc1001 len field */);
-        req->PathLength = cpu_to_le16(unc_path_len - 2);
-        iov[1].iov_base = unc_path;
-        iov[1].iov_len = unc_path_len;
-
-        inc_rfc1001_len(req, unc_path_len - 1 /* pad */);
-
-        rc = SendReceive2(xid, ses, iov, 2, &resp_buftype, 0);
-        rsp = (struct smb2_tree_connect_rsp *)iov[0].iov_base;
-
-        if (rc != 0) {
-                if (tcon) {
-                        cifs_stats_fail_inc(tcon, SMB2_TREE_CONNECT_HE);
-                        tcon->need_reconnect = true;
-                }
-                goto tcon_error_exit;
-        }
-
-        if (tcon == NULL) {
-                ses->ipc_tid = rsp->hdr.TreeId;
-                goto tcon_exit;
-        }
-
-        if (rsp->ShareType & SMB2_SHARE_TYPE_DISK)
-                cFYI(1, "connection to disk share");
-        else if (rsp->ShareType & SMB2_SHARE_TYPE_PIPE) {
-                tcon->ipc = true;
-                cFYI(1, "connection to pipe share");
-        } else if (rsp->ShareType & SMB2_SHARE_TYPE_PRINT) {
-                tcon->print = true;
-                cFYI(1, "connection to printer");
-        } else {
-                cERROR(1, "unknown share type %d", rsp->ShareType);
-                rc = -EOPNOTSUPP;
-                goto tcon_error_exit;
-        }
-
-        tcon->share_flags = le32_to_cpu(rsp->ShareFlags);
-        tcon->maximal_access = le32_to_cpu(rsp->MaximalAccess);
-        tcon->tidStatus = CifsGood;
-        tcon->need_reconnect = false;
-        tcon->tid = rsp->hdr.TreeId;
-        strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
-
-        if ((rsp->Capabilities & SMB2_SHARE_CAP_DFS) &&
-            ((tcon->share_flags & SHI1005_FLAGS_DFS) == 0))
-                cERROR(1, "DFS capability contradicts DFS flag");
-
-tcon_exit:
-        free_rsp_buf(resp_buftype, rsp);
-        kfree(unc_path);
-        return rc;
-
-tcon_error_exit:
-        if (rsp->hdr.Status == STATUS_BAD_NETWORK_NAME) {
-                cERROR(1, "BAD_NETWORK_NAME: %s", tree);
-                tcon->bad_network_name = true;
-        }
-        goto tcon_exit;
-}
-
-int
-SMB2_tdis(const unsigned int xid, struct cifs_tcon *tcon)
-{
-        struct smb2_tree_disconnect_req *req; /* response is trivial */
-        int rc = 0;
-        struct TCP_Server_Info *server;
-        struct cifs_ses *ses = tcon->ses;
-
-        cFYI(1, "Tree Disconnect");
-
-        if (ses && (ses->server))
-                server = ses->server;
-        else
-                return -EIO;
-
-        if ((tcon->need_reconnect) || (tcon->ses->need_reconnect))
-                return 0;
-
-        rc = small_smb2_init(SMB2_TREE_DISCONNECT, tcon, (void **) &req);
-        if (rc)
-                return rc;
-
-        rc = SendReceiveNoRsp(xid, ses, (char *)&req->hdr, 0);
-        if (rc)
-                cifs_stats_fail_inc(tcon, SMB2_TREE_DISCONNECT_HE);
-
-        return rc;
-}
-
-static struct create_lease *
-create_lease_buf(u8 *lease_key, u8 oplock)
-{
-        struct create_lease *buf;
-
-        buf = kmalloc(sizeof(struct create_lease), GFP_KERNEL);
-        if (!buf)
-                return NULL;
-
-        memset(buf, 0, sizeof(struct create_lease));
-
-        buf->lcontext.LeaseKeyLow = cpu_to_le64(*((u64 *)lease_key));
-        buf->lcontext.LeaseKeyHigh = cpu_to_le64(*((u64 *)(lease_key + 8)));
-        if (oplock == SMB2_OPLOCK_LEVEL_EXCLUSIVE)
-                buf->lcontext.LeaseState = SMB2_LEASE_WRITE_CACHING |
-                                           SMB2_LEASE_READ_CACHING;
-        else if (oplock == SMB2_OPLOCK_LEVEL_II)
-                buf->lcontext.LeaseState = SMB2_LEASE_READ_CACHING;
-        else if (oplock == SMB2_OPLOCK_LEVEL_BATCH)
-                buf->lcontext.LeaseState = SMB2_LEASE_HANDLE_CACHING |
-                                           SMB2_LEASE_READ_CACHING |
-                                           SMB2_LEASE_WRITE_CACHING;
-
-        buf->ccontext.DataOffset = cpu_to_le16(offsetof
-                                        (struct create_lease, lcontext));
-        buf->ccontext.DataLength = cpu_to_le32(sizeof(struct lease_context));
-        buf->ccontext.NameOffset = cpu_to_le16(offsetof
-                                (struct create_lease, Name));
-        buf->ccontext.NameLength = cpu_to_le16(4);
-        buf->Name[0] = 'R';
-        buf->Name[1] = 'q';
-        buf->Name[2] = 'L';
-        buf->Name[3] = 's';
-        return buf;
-}
-
-static __u8
-parse_lease_state(struct smb2_create_rsp *rsp)
-{
-        char *data_offset;
-        struct create_lease *lc;
-        bool found = false;
-
-        data_offset = (char *)rsp;
-        data_offset += 4 + le32_to_cpu(rsp->CreateContextsOffset);
-        lc = (struct create_lease *)data_offset;
-        do {
-                char *name = le16_to_cpu(lc->ccontext.NameOffset) + (char *)lc;
-                if (le16_to_cpu(lc->ccontext.NameLength) != 4 ||
-                    strncmp(name, "RqLs", 4)) {
-                        lc = (struct create_lease *)((char *)lc
-                                        + le32_to_cpu(lc->ccontext.Next));
-                        continue;
-                }
-                if (lc->lcontext.LeaseFlags & SMB2_LEASE_FLAG_BREAK_IN_PROGRESS)
-                        return SMB2_OPLOCK_LEVEL_NOCHANGE;
-                found = true;
-                break;
-        } while (le32_to_cpu(lc->ccontext.Next) != 0);
-
-        if (!found)
-                return 0;
-
-        return smb2_map_lease_to_oplock(lc->lcontext.LeaseState);
-}
-
-int
-SMB2_open(const unsigned int xid, struct cifs_tcon *tcon, __le16 *path,
-          u64 *persistent_fid, u64 *volatile_fid, __u32 desired_access,
-          __u32 create_disposition, __u32 file_attributes, __u32 create_options,
-          __u8 *oplock, struct smb2_file_all_info *buf)
-{
-        struct smb2_create_req *req;
-        struct smb2_create_rsp *rsp;
-        struct TCP_Server_Info *server;
-        struct cifs_ses *ses = tcon->ses;
-        struct kvec iov[3];
-        int resp_buftype;
-        int uni_path_len;
-        __le16 *copy_path = NULL;
-        int copy_size;
-        int rc = 0;
-        int num_iovecs = 2;
-
-        cFYI(1, "create/open");
-
-        if (ses && (ses->server))
-                server = ses->server;
-        else
-                return -EIO;
-
-        rc = small_smb2_init(SMB2_CREATE, tcon, (void **) &req);
-        if (rc)
-                return rc;
-
-        req->ImpersonationLevel = IL_IMPERSONATION;
-        req->DesiredAccess = cpu_to_le32(desired_access);
-        /* File attributes ignored on open (used in create though) */
-        req->FileAttributes = cpu_to_le32(file_attributes);
-        req->ShareAccess = FILE_SHARE_ALL_LE;
-        req->CreateDisposition = cpu_to_le32(create_disposition);
-        req->CreateOptions = cpu_to_le32(create_options);
-        uni_path_len = (2 * UniStrnlen((wchar_t *)path, PATH_MAX)) + 2;
-        req->NameOffset = cpu_to_le16(sizeof(struct smb2_create_req)
-                        - 8 /* pad */ - 4 /* do not count rfc1001 len field */);
-
-        iov[0].iov_base = (char *)req;
-        /* 4 for rfc1002 length field */
-        iov[0].iov_len = get_rfc1002_length(req) + 4;
-
-        /* MUST set path len (NameLength) to 0 opening root of share */
-        if (uni_path_len >= 4) {
-                req->NameLength = cpu_to_le16(uni_path_len - 2);
-                /* -1 since last byte is buf[0] which is sent below (path) */
-                iov[0].iov_len--;
-                if (uni_path_len % 8 != 0) {
-                        copy_size = uni_path_len / 8 * 8;
-                        if (copy_size < uni_path_len)
-                                copy_size += 8;
-
-                        copy_path = kzalloc(copy_size, GFP_KERNEL);
-                        if (!copy_path)
-                                return -ENOMEM;
-                        memcpy((char *)copy_path, (const char *)path,
-                                uni_path_len);
-                        uni_path_len = copy_size;
-                        path = copy_path;
-                }
-
-                iov[1].iov_len = uni_path_len;
-                iov[1].iov_base = path;
-                /*
-                 * -1 since last byte is buf[0] which was counted in
-                 * smb2_buf_len.
-                 */
-                inc_rfc1001_len(req, uni_path_len - 1);
-        } else {
-                iov[0].iov_len += 7;
-                req->hdr.smb2_buf_length = cpu_to_be32(be32_to_cpu(
-                                req->hdr.smb2_buf_length) + 8 - 1);
-                num_iovecs = 1;
-                req->NameLength = 0;
-        }
-
-        if (!server->oplocks)
-                *oplock = SMB2_OPLOCK_LEVEL_NONE;
-
-        if (!(tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_LEASING) ||
-            *oplock == SMB2_OPLOCK_LEVEL_NONE)
-                req->RequestedOplockLevel = *oplock;
-        else {
-                iov[num_iovecs].iov_base = create_lease_buf(oplock+1, *oplock);
-                if (iov[num_iovecs].iov_base == NULL) {
-                        cifs_small_buf_release(req);
-                        kfree(copy_path);
-                        return -ENOMEM;
-                }
-                iov[num_iovecs].iov_len = sizeof(struct create_lease);
-                req->RequestedOplockLevel = SMB2_OPLOCK_LEVEL_LEASE;
-                req->CreateContextsOffset = cpu_to_le32(
-                        sizeof(struct smb2_create_req) - 4 - 8 +
-                        iov[num_iovecs-1].iov_len);
-                req->CreateContextsLength = cpu_to_le32(
-                        sizeof(struct create_lease));
-                inc_rfc1001_len(&req->hdr, sizeof(struct create_lease));
-                num_iovecs++;
-        }
-
-        rc = SendReceive2(xid, ses, iov, num_iovecs, &resp_buftype, 0);
-        rsp = (struct smb2_create_rsp *)iov[0].iov_base;
-
-        if (rc != 0) {
-                cifs_stats_fail_inc(tcon, SMB2_CREATE_HE);
-                goto creat_exit;
-        }
-
-        *persistent_fid = rsp->PersistentFileId;
-        *volatile_fid = rsp->VolatileFileId;
-
-        if (buf) {
-                memcpy(buf, &rsp->CreationTime, 32);
-                buf->AllocationSize = rsp->AllocationSize;
-                buf->EndOfFile = rsp->EndofFile;
-                buf->Attributes = rsp->FileAttributes;
-                buf->NumberOfLinks = cpu_to_le32(1);
-                buf->DeletePending = 0;
-        }
-
-        if (rsp->OplockLevel == SMB2_OPLOCK_LEVEL_LEASE)
-                *oplock = parse_lease_state(rsp);
-        else
-                *oplock = rsp->OplockLevel;
-creat_exit:
-        kfree(copy_path);
-        free_rsp_buf(resp_buftype, rsp);
-        return rc;
-}
-
-int
-SMB2_close(const unsigned int xid, struct cifs_tcon *tcon,
-           u64 persistent_fid, u64 volatile_fid)
-{
-        struct smb2_close_req *req;
-        struct smb2_close_rsp *rsp;
-        struct TCP_Server_Info *server;
-        struct cifs_ses *ses = tcon->ses;
-        struct kvec iov[1];
-        int resp_buftype;
-        int rc = 0;
-
-        cFYI(1, "Close");
-
-        if (ses && (ses->server))
-                server = ses->server;
-        else
-                return -EIO;
-
-        rc = small_smb2_init(SMB2_CLOSE, tcon, (void **) &req);
-        if (rc)
-                return rc;
-
-        req->PersistentFileId = persistent_fid;
-        req->VolatileFileId = volatile_fid;
-
-        iov[0].iov_base = (char *)req;
-        /* 4 for rfc1002 length field */
-        iov[0].iov_len = get_rfc1002_length(req) + 4;
-
-        rc = SendReceive2(xid, ses, iov, 1, &resp_buftype, 0);
-        rsp = (struct smb2_close_rsp *)iov[0].iov_base;
-
-        if (rc != 0) {
-                if (tcon)
-                        cifs_stats_fail_inc(tcon, SMB2_CLOSE_HE);
-                goto close_exit;
-        }
-
-        /* BB FIXME - decode close response, update inode for caching */
-
-close_exit:
-        free_rsp_buf(resp_buftype, rsp);
-        return rc;
-}
-
-static int
-validate_buf(unsigned int offset, unsigned int buffer_length,
-             struct smb2_hdr *hdr, unsigned int min_buf_size)
-
-{
-        unsigned int smb_len = be32_to_cpu(hdr->smb2_buf_length);
-        char *end_of_smb = smb_len + 4 /* RFC1001 length field */ + (char *)hdr;
-        char *begin_of_buf = 4 /* RFC1001 len field */ + offset + (char *)hdr;
-        char *end_of_buf = begin_of_buf + buffer_length;
-
-
-        if (buffer_length < min_buf_size) {
-                cERROR(1, "buffer length %d smaller than minimum size %d",
-                           buffer_length, min_buf_size);
-                return -EINVAL;
-        }
-
-        /* check if beyond RFC1001 maximum length */
-        if ((smb_len > 0x7FFFFF) || (buffer_length > 0x7FFFFF)) {
-                cERROR(1, "buffer length %d or smb length %d too large",
-                           buffer_length, smb_len);
-                return -EINVAL;
-        }
-
-        if ((begin_of_buf > end_of_smb) || (end_of_buf > end_of_smb)) {
-                cERROR(1, "illegal server response, bad offset to data");
-                return -EINVAL;
-        }
-
-        return 0;
-}
-
-/*
- * If SMB buffer fields are valid, copy into temporary buffer to hold result.
- * Caller must free buffer.
- */
-static int
-validate_and_copy_buf(unsigned int offset, unsigned int buffer_length,
-                      struct smb2_hdr *hdr, unsigned int minbufsize,
-                      char *data)
-
-{
-        char *begin_of_buf = 4 /* RFC1001 len field */ + offset + (char *)hdr;
-        int rc;
-
-        if (!data)
-                return -EINVAL;
-
-        rc = validate_buf(offset, buffer_length, hdr, minbufsize);
-        if (rc)
-                return rc;
-
-        memcpy(data, begin_of_buf, buffer_length);
-
-        return 0;
-}
-
-static int
-query_info(const unsigned int xid, struct cifs_tcon *tcon,
-           u64 persistent_fid, u64 volatile_fid, u8 info_class,
-           size_t output_len, size_t min_len, void *data)
-{
-        struct smb2_query_info_req *req;
-        struct smb2_query_info_rsp *rsp = NULL;
-        struct kvec iov[2];
-        int rc = 0;
-        int resp_buftype;
-        struct TCP_Server_Info *server;
-        struct cifs_ses *ses = tcon->ses;
-
-        cFYI(1, "Query Info");
-
-        if (ses && (ses->server))
-                server = ses->server;
-        else
-                return -EIO;
-
-        rc = small_smb2_init(SMB2_QUERY_INFO, tcon, (void **) &req);
-        if (rc)
-                return rc;
-
-        req->InfoType = SMB2_O_INFO_FILE;
-        req->FileInfoClass = info_class;
-        req->PersistentFileId = persistent_fid;
-        req->VolatileFileId = volatile_fid;
-        /* 4 for rfc1002 length field and 1 for Buffer */
-        req->InputBufferOffset =
-                cpu_to_le16(sizeof(struct smb2_query_info_req) - 1 - 4);
-        req->OutputBufferLength = cpu_to_le32(output_len);
-
-        iov[0].iov_base = (char *)req;
-        /* 4 for rfc1002 length field */
-        iov[0].iov_len = get_rfc1002_length(req) + 4;
-
-        rc = SendReceive2(xid, ses, iov, 1, &resp_buftype, 0);
-        rsp = (struct smb2_query_info_rsp *)iov[0].iov_base;
-
-        if (rc) {
-                cifs_stats_fail_inc(tcon, SMB2_QUERY_INFO_HE);
-                goto qinf_exit;
-        }
-
-        rc = validate_and_copy_buf(le16_to_cpu(rsp->OutputBufferOffset),
-                                   le32_to_cpu(rsp->OutputBufferLength),
-                                   &rsp->hdr, min_len, data);
-
-qinf_exit:
-        free_rsp_buf(resp_buftype, rsp);
-        return rc;
-}
-
-int
-SMB2_query_info(const unsigned int xid, struct cifs_tcon *tcon,
-                u64 persistent_fid, u64 volatile_fid,
-                struct smb2_file_all_info *data)
-{
-        return query_info(xid, tcon, persistent_fid, volatile_fid,
-                          FILE_ALL_INFORMATION,
-                          sizeof(struct smb2_file_all_info) + MAX_NAME * 2,
-                          sizeof(struct smb2_file_all_info), data);
-}
-
-int
-SMB2_get_srv_num(const unsigned int xid, struct cifs_tcon *tcon,
-                 u64 persistent_fid, u64 volatile_fid, __le64 *uniqueid)
-{
-        return query_info(xid, tcon, persistent_fid, volatile_fid,
-                          FILE_INTERNAL_INFORMATION,
-                          sizeof(struct smb2_file_internal_info),
-                          sizeof(struct smb2_file_internal_info), uniqueid);
-}
-
-/*
- * This is a no-op for now. We're not really interested in the reply, but
- * rather in the fact that the server sent one and that server->lstrp
- * gets updated.
- *
- * FIXME: maybe we should consider checking that the reply matches request?
- */
-static void
-smb2_echo_callback(struct mid_q_entry *mid)
-{
-        struct TCP_Server_Info *server = mid->callback_data;
-        struct smb2_echo_rsp *smb2 = (struct smb2_echo_rsp *)mid->resp_buf;
-        unsigned int credits_received = 1;
-
-        if (mid->mid_state == MID_RESPONSE_RECEIVED)
-                credits_received = le16_to_cpu(smb2->hdr.CreditRequest);
-
-        DeleteMidQEntry(mid);
-        add_credits(server, credits_received, CIFS_ECHO_OP);
-}
-
-int
-SMB2_echo(struct TCP_Server_Info *server)
-{
-        struct smb2_echo_req *req;
-        int rc = 0;
-        struct kvec iov;
-        struct smb_rqst rqst = { .rq_iov = &iov,
-                                 .rq_nvec = 1 };
-
-        cFYI(1, "In echo request");
-
-        rc = small_smb2_init(SMB2_ECHO, NULL, (void **)&req);
-        if (rc)
-                return rc;
-
-        req->hdr.CreditRequest = cpu_to_le16(1);
-
-        iov.iov_base = (char *)req;
-        /* 4 for rfc1002 length field */
-        iov.iov_len = get_rfc1002_length(req) + 4;
-
-        rc = cifs_call_async(server, &rqst, NULL, smb2_echo_callback, server,
-                             CIFS_ECHO_OP);
-        if (rc)
-                cFYI(1, "Echo request failed: %d", rc);
-
-        cifs_small_buf_release(req);
-        return rc;
-}
-
-int
-SMB2_flush(const unsigned int xid, struct cifs_tcon *tcon, u64 persistent_fid,
-           u64 volatile_fid)
-{
-        struct smb2_flush_req *req;
-        struct TCP_Server_Info *server;
-        struct cifs_ses *ses = tcon->ses;
-        struct kvec iov[1];
-        int resp_buftype;
-        int rc = 0;
-
-        cFYI(1, "Flush");
-
-        if (ses && (ses->server))
-                server = ses->server;
-        else
-                return -EIO;
-
-        rc = small_smb2_init(SMB2_FLUSH, tcon, (void **) &req);
-        if (rc)
-                return rc;
-
-        req->PersistentFileId = persistent_fid;
-        req->VolatileFileId = volatile_fid;
-
-        iov[0].iov_base = (char *)req;
-        /* 4 for rfc1002 length field */
-        iov[0].iov_len = get_rfc1002_length(req) + 4;
-
-        rc = SendReceive2(xid, ses, iov, 1, &resp_buftype, 0);
-
-        if ((rc != 0) && tcon)
-                cifs_stats_fail_inc(tcon, SMB2_FLUSH_HE);
-
-        free_rsp_buf(resp_buftype, iov[0].iov_base);
-        return rc;
-}
-
-/*
- * To form a chain of read requests, any read requests after the first should
- * have the end_of_chain boolean set to true.
- */
-static int
-smb2_new_read_req(struct kvec *iov, struct cifs_io_parms *io_parms,
-                  unsigned int remaining_bytes, int request_type)
-{
-        int rc = -EACCES;
-        struct smb2_read_req *req = NULL;
-
-        rc = small_smb2_init(SMB2_READ, io_parms->tcon, (void **) &req);
-        if (rc)
-                return rc;
-        if (io_parms->tcon->ses->server == NULL)
-                return -ECONNABORTED;
-
-        req->hdr.ProcessId = cpu_to_le32(io_parms->pid);
-
-        req->PersistentFileId = io_parms->persistent_fid;
-        req->VolatileFileId = io_parms->volatile_fid;
-        req->ReadChannelInfoOffset = 0; /* reserved */
-        req->ReadChannelInfoLength = 0; /* reserved */
-        req->Channel = 0; /* reserved */
-        req->MinimumCount = 0;
-        req->Length = cpu_to_le32(io_parms->length);
-        req->Offset = cpu_to_le64(io_parms->offset);
-
-        if (request_type & CHAINED_REQUEST) {
-                if (!(request_type & END_OF_CHAIN)) {
-                        /* 4 for rfc1002 length field */
-                        req->hdr.NextCommand =
-                                cpu_to_le32(get_rfc1002_length(req) + 4);
-                } else /* END_OF_CHAIN */
-                        req->hdr.NextCommand = 0;
-                if (request_type & RELATED_REQUEST) {
-                        req->hdr.Flags |= SMB2_FLAGS_RELATED_OPERATIONS;
-                        /*
-                         * Related requests use info from previous read request
-                         * in chain.
-                         */
-                        req->hdr.SessionId = 0xFFFFFFFF;
-                        req->hdr.TreeId = 0xFFFFFFFF;
-                        req->PersistentFileId = 0xFFFFFFFF;
-                        req->VolatileFileId = 0xFFFFFFFF;
-                }
-        }
-        if (remaining_bytes > io_parms->length)
-                req->RemainingBytes = cpu_to_le32(remaining_bytes);
-        else
-                req->RemainingBytes = 0;
-
-        iov[0].iov_base = (char *)req;
-        /* 4 for rfc1002 length field */
-        iov[0].iov_len = get_rfc1002_length(req) + 4;
-        return rc;
-}
-
-static void
-smb2_readv_callback(struct mid_q_entry *mid)
-{
-        struct cifs_readdata *rdata = mid->callback_data;
-        struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
-        struct TCP_Server_Info *server = tcon->ses->server;
-        struct smb2_hdr *buf = (struct smb2_hdr *)rdata->iov.iov_base;
-        unsigned int credits_received = 1;
-        struct smb_rqst rqst = { .rq_iov = &rdata->iov,
-                                 .rq_nvec = 1,
-                                 .rq_pages = rdata->pages,
-                                 .rq_npages = rdata->nr_pages,
-                                 .rq_pagesz = rdata->pagesz,
-                                 .rq_tailsz = rdata->tailsz };
-
-        cFYI(1, "%s: mid=%llu state=%d result=%d bytes=%u", __func__,
-                mid->mid, mid->mid_state, rdata->result, rdata->bytes);
-
-        switch (mid->mid_state) {
-        case MID_RESPONSE_RECEIVED:
-                credits_received = le16_to_cpu(buf->CreditRequest);
-                /* result already set, check signature */
-                if (server->sec_mode &
-                    (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
-                        int rc;
-
-                        rc = smb2_verify_signature(&rqst, server);
-                        if (rc)
-                                cERROR(1, "SMB signature verification returned "
-                                       "error = %d", rc);
-                }
-                /* FIXME: should this be counted toward the initiating task? */
-                task_io_account_read(rdata->bytes);
-                cifs_stats_bytes_read(tcon, rdata->bytes);
-                break;
-        case MID_REQUEST_SUBMITTED:
-        case MID_RETRY_NEEDED:
-                rdata->result = -EAGAIN;
-                break;
-        default:
-                if (rdata->result != -ENODATA)
-                        rdata->result = -EIO;
-        }
-
-        if (rdata->result)
-                cifs_stats_fail_inc(tcon, SMB2_READ_HE);
-
-        queue_work(cifsiod_wq, &rdata->work);
-        DeleteMidQEntry(mid);
-        add_credits(server, credits_received, 0);
-}
-
-/* smb2_async_readv - send an async write, and set up mid to handle result */
-int
-smb2_async_readv(struct cifs_readdata *rdata)
-{
-        int rc;
-        struct smb2_hdr *buf;
-        struct cifs_io_parms io_parms;
-        struct smb_rqst rqst = { .rq_iov = &rdata->iov,
-                                 .rq_nvec = 1 };
-
-        cFYI(1, "%s: offset=%llu bytes=%u", __func__,
-                rdata->offset, rdata->bytes);
-
-        io_parms.tcon = tlink_tcon(rdata->cfile->tlink);
-        io_parms.offset = rdata->offset;
-        io_parms.length = rdata->bytes;
-        io_parms.persistent_fid = rdata->cfile->fid.persistent_fid;
-        io_parms.volatile_fid = rdata->cfile->fid.volatile_fid;
-        io_parms.pid = rdata->pid;
-        rc = smb2_new_read_req(&rdata->iov, &io_parms, 0, 0);
-        if (rc)
-                return rc;
-
-        buf = (struct smb2_hdr *)rdata->iov.iov_base;
-        /* 4 for rfc1002 length field */
-        rdata->iov.iov_len = get_rfc1002_length(rdata->iov.iov_base) + 4;
-
-        kref_get(&rdata->refcount);
-        rc = cifs_call_async(io_parms.tcon->ses->server, &rqst,
-                             cifs_readv_receive, smb2_readv_callback,
-                             rdata, 0);
-        if (rc) {
-                kref_put(&rdata->refcount, cifs_readdata_release);
-                cifs_stats_fail_inc(io_parms.tcon, SMB2_READ_HE);
-        }
-
-        cifs_small_buf_release(buf);
-        return rc;
-}
-
-int
-SMB2_read(const unsigned int xid, struct cifs_io_parms *io_parms,
-          unsigned int *nbytes, char **buf, int *buf_type)
-{
-        int resp_buftype, rc = -EACCES;
-        struct smb2_read_rsp *rsp = NULL;
-        struct kvec iov[1];
-
-        *nbytes = 0;
-        rc = smb2_new_read_req(iov, io_parms, 0, 0);
-        if (rc)
-                return rc;
-
-        rc = SendReceive2(xid, io_parms->tcon->ses, iov, 1,
-                          &resp_buftype, CIFS_LOG_ERROR);
-
-        rsp = (struct smb2_read_rsp *)iov[0].iov_base;
-
-        if (rsp->hdr.Status == STATUS_END_OF_FILE) {
-                free_rsp_buf(resp_buftype, iov[0].iov_base);
-                return 0;
-        }
-
-        if (rc) {
-                cifs_stats_fail_inc(io_parms->tcon, SMB2_READ_HE);
-                cERROR(1, "Send error in read = %d", rc);
-        } else {
-                *nbytes = le32_to_cpu(rsp->DataLength);
-                if ((*nbytes > CIFS_MAX_MSGSIZE) ||
-                    (*nbytes > io_parms->length)) {
-                        cFYI(1, "bad length %d for count %d", *nbytes,
-                                io_parms->length);
-                        rc = -EIO;
-                        *nbytes = 0;
-                }
-        }
-
-        if (*buf) {
-                memcpy(*buf, (char *)rsp->hdr.ProtocolId + rsp->DataOffset,
-                       *nbytes);
-                free_rsp_buf(resp_buftype, iov[0].iov_base);
-        } else if (resp_buftype != CIFS_NO_BUFFER) {
-                *buf = iov[0].iov_base;
-                if (resp_buftype == CIFS_SMALL_BUFFER)
-                        *buf_type = CIFS_SMALL_BUFFER;
-                else if (resp_buftype == CIFS_LARGE_BUFFER)
-                        *buf_type = CIFS_LARGE_BUFFER;
-        }
-        return rc;
-}
-
-/*
- * Check the mid_state and signature on received buffer (if any), and queue the
- * workqueue completion task.
- */
-static void
-smb2_writev_callback(struct mid_q_entry *mid)
-{
-        struct cifs_writedata *wdata = mid->callback_data;
-        struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
-        unsigned int written;
-        struct smb2_write_rsp *rsp = (struct smb2_write_rsp *)mid->resp_buf;
-        unsigned int credits_received = 1;
-
-        switch (mid->mid_state) {
-        case MID_RESPONSE_RECEIVED:
-                credits_received = le16_to_cpu(rsp->hdr.CreditRequest);
-                wdata->result = smb2_check_receive(mid, tcon->ses->server, 0);
-                if (wdata->result != 0)
-                        break;
-
-                written = le32_to_cpu(rsp->DataLength);
-                /*
-                 * Mask off high 16 bits when bytes written as returned
-                 * by the server is greater than bytes requested by the
-                 * client. OS/2 servers are known to set incorrect
-                 * CountHigh values.
-                 */
-                if (written > wdata->bytes)
-                        written &= 0xFFFF;
-
-                if (written < wdata->bytes)
-                        wdata->result = -ENOSPC;
-                else
-                        wdata->bytes = written;
-                break;
-        case MID_REQUEST_SUBMITTED:
-        case MID_RETRY_NEEDED:
-                wdata->result = -EAGAIN;
-                break;
-        default:
-                wdata->result = -EIO;
-                break;
-        }
-
-        if (wdata->result)
-                cifs_stats_fail_inc(tcon, SMB2_WRITE_HE);
-
-        queue_work(cifsiod_wq, &wdata->work);
-        DeleteMidQEntry(mid);
-        add_credits(tcon->ses->server, credits_received, 0);
-}
-
-/* smb2_async_writev - send an async write, and set up mid to handle result */
-int
-smb2_async_writev(struct cifs_writedata *wdata)
-{
-        int rc = -EACCES;
-        struct smb2_write_req *req = NULL;
-        struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
-        struct kvec iov;
-        struct smb_rqst rqst;
-
-        rc = small_smb2_init(SMB2_WRITE, tcon, (void **) &req);
-        if (rc)
-                goto async_writev_out;
-
-        req->hdr.ProcessId = cpu_to_le32(wdata->cfile->pid);
-
-        req->PersistentFileId = wdata->cfile->fid.persistent_fid;
-        req->VolatileFileId = wdata->cfile->fid.volatile_fid;
-        req->WriteChannelInfoOffset = 0;
-        req->WriteChannelInfoLength = 0;
-        req->Channel = 0;
-        req->Offset = cpu_to_le64(wdata->offset);
-        /* 4 for rfc1002 length field */
-        req->DataOffset = cpu_to_le16(
-                                offsetof(struct smb2_write_req, Buffer) - 4);
-        req->RemainingBytes = 0;
-
-        /* 4 for rfc1002 length field and 1 for Buffer */
-        iov.iov_len = get_rfc1002_length(req) + 4 - 1;
-        iov.iov_base = req;
-
-        rqst.rq_iov = &iov;
-        rqst.rq_nvec = 1;
-        rqst.rq_pages = wdata->pages;
-        rqst.rq_npages = wdata->nr_pages;
-        rqst.rq_pagesz = wdata->pagesz;
-        rqst.rq_tailsz = wdata->tailsz;
-
-        cFYI(1, "async write at %llu %u bytes", wdata->offset, wdata->bytes);
-
-        req->Length = cpu_to_le32(wdata->bytes);
-
-        inc_rfc1001_len(&req->hdr, wdata->bytes - 1 /* Buffer */);
-
-        kref_get(&wdata->refcount);
-        rc = cifs_call_async(tcon->ses->server, &rqst, NULL,
-                                smb2_writev_callback, wdata, 0);
-
-        if (rc) {
-                kref_put(&wdata->refcount, cifs_writedata_release);
-                cifs_stats_fail_inc(tcon, SMB2_WRITE_HE);
-        }
-
-async_writev_out:
-        cifs_small_buf_release(req);
-        return rc;
-}
-
-/*
- * SMB2_write function gets iov pointer to kvec array with n_vec as a length.
- * The length field from io_parms must be at least 1 and indicates a number of
- * elements with data to write that begins with position 1 in iov array. All
- * data length is specified by count.
- */
-int
-SMB2_write(const unsigned int xid, struct cifs_io_parms *io_parms,
-           unsigned int *nbytes, struct kvec *iov, int n_vec)
-{
-        int rc = 0;
-        struct smb2_write_req *req = NULL;
-        struct smb2_write_rsp *rsp = NULL;
-        int resp_buftype;
-        *nbytes = 0;
-
-        if (n_vec < 1)
-                return rc;
-
-        rc = small_smb2_init(SMB2_WRITE, io_parms->tcon, (void **) &req);
-        if (rc)
-                return rc;
-
-        if (io_parms->tcon->ses->server == NULL)
-                return -ECONNABORTED;
-
-        req->hdr.ProcessId = cpu_to_le32(io_parms->pid);
-
-        req->PersistentFileId = io_parms->persistent_fid;
-        req->VolatileFileId = io_parms->volatile_fid;
-        req->WriteChannelInfoOffset = 0;
-        req->WriteChannelInfoLength = 0;
-        req->Channel = 0;
-        req->Length = cpu_to_le32(io_parms->length);
-        req->Offset = cpu_to_le64(io_parms->offset);
-        /* 4 for rfc1002 length field */
-        req->DataOffset = cpu_to_le16(
-                                offsetof(struct smb2_write_req, Buffer) - 4);
-        req->RemainingBytes = 0;
-
-        iov[0].iov_base = (char *)req;
-        /* 4 for rfc1002 length field and 1 for Buffer */
-        iov[0].iov_len = get_rfc1002_length(req) + 4 - 1;
-
-        /* length of entire message including data to be written */
-        inc_rfc1001_len(req, io_parms->length - 1 /* Buffer */);
-
-        rc = SendReceive2(xid, io_parms->tcon->ses, iov, n_vec + 1,
-                          &resp_buftype, 0);
-        rsp = (struct smb2_write_rsp *)iov[0].iov_base;
-
-        if (rc) {
-                cifs_stats_fail_inc(io_parms->tcon, SMB2_WRITE_HE);
-                cERROR(1, "Send error in write = %d", rc);
-        } else
-                *nbytes = le32_to_cpu(rsp->DataLength);
-
-        free_rsp_buf(resp_buftype, rsp);
-        return rc;
-}
-
-static unsigned int
-num_entries(char *bufstart, char *end_of_buf, char **lastentry, size_t size)
-{
-        int len;
-        unsigned int entrycount = 0;
-        unsigned int next_offset = 0;
-        FILE_DIRECTORY_INFO *entryptr;
-
-        if (bufstart == NULL)
-                return 0;
-
-        entryptr = (FILE_DIRECTORY_INFO *)bufstart;
-
-        while (1) {
-                entryptr = (FILE_DIRECTORY_INFO *)
-                                        ((char *)entryptr + next_offset);
-
-                if ((char *)entryptr + size > end_of_buf) {
-                        cERROR(1, "malformed search entry would overflow");
-                        break;
-                }
-
-                len = le32_to_cpu(entryptr->FileNameLength);
-                if ((char *)entryptr + len + size > end_of_buf) {
-                        cERROR(1, "directory entry name would overflow frame "
-                                  "end of buf %p", end_of_buf);
-                        break;
-                }
-
-                *lastentry = (char *)entryptr;
-                entrycount++;
-
-                next_offset = le32_to_cpu(entryptr->NextEntryOffset);
-                if (!next_offset)
-                        break;
-        }
-
-        return entrycount;
-}
-
-/*
- * Readdir/FindFirst
- */
-int
-SMB2_query_directory(const unsigned int xid, struct cifs_tcon *tcon,
-                     u64 persistent_fid, u64 volatile_fid, int index,
-                     struct cifs_search_info *srch_inf)
-{
-        struct smb2_query_directory_req *req;
-        struct smb2_query_directory_rsp *rsp = NULL;
-        struct kvec iov[2];
-        int rc = 0;
-        int len;
-        int resp_buftype;
-        unsigned char *bufptr;
-        struct TCP_Server_Info *server;
-        struct cifs_ses *ses = tcon->ses;
-        __le16 asteriks = cpu_to_le16('*');
-        char *end_of_smb;
-        unsigned int output_size = CIFSMaxBufSize;
-        size_t info_buf_size;
-
-        if (ses && (ses->server))
-                server = ses->server;
-        else
-                return -EIO;
-
-        rc = small_smb2_init(SMB2_QUERY_DIRECTORY, tcon, (void **) &req);
-        if (rc)
-                return rc;
-
-        switch (srch_inf->info_level) {
-        case SMB_FIND_FILE_DIRECTORY_INFO:
-                req->FileInformationClass = FILE_DIRECTORY_INFORMATION;
-                info_buf_size = sizeof(FILE_DIRECTORY_INFO) - 1;
-                break;
-        case SMB_FIND_FILE_ID_FULL_DIR_INFO:
-                req->FileInformationClass = FILEID_FULL_DIRECTORY_INFORMATION;
-                info_buf_size = sizeof(SEARCH_ID_FULL_DIR_INFO) - 1;
-                break;
-        default:
-                cERROR(1, "info level %u isn't supported",
-                       srch_inf->info_level);
-                rc = -EINVAL;
-                goto qdir_exit;
-        }
-
-        req->FileIndex = cpu_to_le32(index);
-        req->PersistentFileId = persistent_fid;
-        req->VolatileFileId = volatile_fid;
-
-        len = 0x2;
-        bufptr = req->Buffer;
-        memcpy(bufptr, &asteriks, len);
-
-        req->FileNameOffset =
-                cpu_to_le16(sizeof(struct smb2_query_directory_req) - 1 - 4);
-        req->FileNameLength = cpu_to_le16(len);
-        /*
-         * BB could be 30 bytes or so longer if we used SMB2 specific
-         * buffer lengths, but this is safe and close enough.
-         */
-        output_size = min_t(unsigned int, output_size, server->maxBuf);
-        output_size = min_t(unsigned int, output_size, 2 << 15);
-        req->OutputBufferLength = cpu_to_le32(output_size);
-
-        iov[0].iov_base = (char *)req;
-        /* 4 for RFC1001 length and 1 for Buffer */
-        iov[0].iov_len = get_rfc1002_length(req) + 4 - 1;
-
-        iov[1].iov_base = (char *)(req->Buffer);
-        iov[1].iov_len = len;
-
-        inc_rfc1001_len(req, len - 1 /* Buffer */);
-
-        rc = SendReceive2(xid, ses, iov, 2, &resp_buftype, 0);
-        rsp = (struct smb2_query_directory_rsp *)iov[0].iov_base;
-
-        if (rc) {
-                cifs_stats_fail_inc(tcon, SMB2_QUERY_DIRECTORY_HE);
-                goto qdir_exit;
-        }
-
-        rc = validate_buf(le16_to_cpu(rsp->OutputBufferOffset),
-                          le32_to_cpu(rsp->OutputBufferLength), &rsp->hdr,
-                          info_buf_size);
-        if (rc)
-                goto qdir_exit;
-
-        srch_inf->unicode = true;
-
-        if (srch_inf->ntwrk_buf_start) {
-                if (srch_inf->smallBuf)
-                        cifs_small_buf_release(srch_inf->ntwrk_buf_start);
-                else
-                        cifs_buf_release(srch_inf->ntwrk_buf_start);
-        }
-        srch_inf->ntwrk_buf_start = (char *)rsp;
-        srch_inf->srch_entries_start = srch_inf->last_entry = 4 /* rfclen */ +
-                (char *)&rsp->hdr + le16_to_cpu(rsp->OutputBufferOffset);
-        /* 4 for rfc1002 length field */
-        end_of_smb = get_rfc1002_length(rsp) + 4 + (char *)&rsp->hdr;
-        srch_inf->entries_in_buffer =
-                        num_entries(srch_inf->srch_entries_start, end_of_smb,
-                                    &srch_inf->last_entry, info_buf_size);
-        srch_inf->index_of_last_entry += srch_inf->entries_in_buffer;
-        cFYI(1, "num entries %d last_index %lld srch start %p srch end %p",
-                srch_inf->entries_in_buffer, srch_inf->index_of_last_entry,
-                srch_inf->srch_entries_start, srch_inf->last_entry);
-        if (resp_buftype == CIFS_LARGE_BUFFER)
-                srch_inf->smallBuf = false;
-        else if (resp_buftype == CIFS_SMALL_BUFFER)
-                srch_inf->smallBuf = true;
-        else
-                cERROR(1, "illegal search buffer type");
-
-        if (rsp->hdr.Status == STATUS_NO_MORE_FILES)
-                srch_inf->endOfSearch = 1;
-        else
-                srch_inf->endOfSearch = 0;
-
-        return rc;
-
-qdir_exit:
-        free_rsp_buf(resp_buftype, rsp);
-        return rc;
-}
-
-static int
-send_set_info(const unsigned int xid, struct cifs_tcon *tcon,
-               u64 persistent_fid, u64 volatile_fid, u32 pid, int info_class,
-               unsigned int num, void **data, unsigned int *size)
-{
-        struct smb2_set_info_req *req;
-        struct smb2_set_info_rsp *rsp = NULL;
-        struct kvec *iov;
-        int rc = 0;
-        int resp_buftype;
-        unsigned int i;
-        struct TCP_Server_Info *server;
-        struct cifs_ses *ses = tcon->ses;
-
-        if (ses && (ses->server))
-                server = ses->server;
-        else
-                return -EIO;
-
-        if (!num)
-                return -EINVAL;
-
-        iov = kmalloc(sizeof(struct kvec) * num, GFP_KERNEL);
-        if (!iov)
-                return -ENOMEM;
-
-        rc = small_smb2_init(SMB2_SET_INFO, tcon, (void **) &req);
-        if (rc) {
-                kfree(iov);
-                return rc;
-        }
-
-        req->hdr.ProcessId = cpu_to_le32(pid);
-
-        req->InfoType = SMB2_O_INFO_FILE;
-        req->FileInfoClass = info_class;
-        req->PersistentFileId = persistent_fid;
-        req->VolatileFileId = volatile_fid;
-
-        /* 4 for RFC1001 length and 1 for Buffer */
-        req->BufferOffset =
-                        cpu_to_le16(sizeof(struct smb2_set_info_req) - 1 - 4);
-        req->BufferLength = cpu_to_le32(*size);
-
-        inc_rfc1001_len(req, *size - 1 /* Buffer */);
-
-        memcpy(req->Buffer, *data, *size);
-
-        iov[0].iov_base = (char *)req;
-        /* 4 for RFC1001 length */
-        iov[0].iov_len = get_rfc1002_length(req) + 4;
-
-        for (i = 1; i < num; i++) {
-                inc_rfc1001_len(req, size[i]);
-                le32_add_cpu(&req->BufferLength, size[i]);
-                iov[i].iov_base = (char *)data[i];
-                iov[i].iov_len = size[i];
-        }
-
-        rc = SendReceive2(xid, ses, iov, num, &resp_buftype, 0);
-        rsp = (struct smb2_set_info_rsp *)iov[0].iov_base;
-
-        if (rc != 0) {
-                cifs_stats_fail_inc(tcon, SMB2_SET_INFO_HE);
-                goto out;
-        }
-out:
-        free_rsp_buf(resp_buftype, rsp);
-        kfree(iov);
-        return rc;
-}
-
-int
-SMB2_rename(const unsigned int xid, struct cifs_tcon *tcon,
-            u64 persistent_fid, u64 volatile_fid, __le16 *target_file)
-{
-        struct smb2_file_rename_info info;
-        void **data;
-        unsigned int size[2];
-        int rc;
-        int len = (2 * UniStrnlen((wchar_t *)target_file, PATH_MAX));
-
-        data = kmalloc(sizeof(void *) * 2, GFP_KERNEL);
-        if (!data)
-                return -ENOMEM;
-
-        info.ReplaceIfExists = 1; /* 1 = replace existing target with new */
-                              /* 0 = fail if target already exists */
-        info.RootDirectory = 0;  /* MBZ for network ops (why does spec say?) */
-        info.FileNameLength = cpu_to_le32(len);
-
-        data[0] = &info;
-        size[0] = sizeof(struct smb2_file_rename_info);
-
-        data[1] = target_file;
-        size[1] = len + 2 /* null */;
-
-        rc = send_set_info(xid, tcon, persistent_fid, volatile_fid,
-                           current->tgid, FILE_RENAME_INFORMATION, 2, data,
-                           size);
-        kfree(data);
-        return rc;
-}
-
-int
-SMB2_set_hardlink(const unsigned int xid, struct cifs_tcon *tcon,
-                  u64 persistent_fid, u64 volatile_fid, __le16 *target_file)
-{
-        struct smb2_file_link_info info;
-        void **data;
-        unsigned int size[2];
-        int rc;
-        int len = (2 * UniStrnlen((wchar_t *)target_file, PATH_MAX));
-
-        data = kmalloc(sizeof(void *) * 2, GFP_KERNEL);
-        if (!data)
-                return -ENOMEM;
-
-        info.ReplaceIfExists = 0; /* 1 = replace existing link with new */
-                              /* 0 = fail if link already exists */
-        info.RootDirectory = 0;  /* MBZ for network ops (why does spec say?) */
-        info.FileNameLength = cpu_to_le32(len);
-
-        data[0] = &info;
-        size[0] = sizeof(struct smb2_file_link_info);
-
-        data[1] = target_file;
-        size[1] = len + 2 /* null */;
-
-        rc = send_set_info(xid, tcon, persistent_fid, volatile_fid,
-                           current->tgid, FILE_LINK_INFORMATION, 2, data, size);
-        kfree(data);
-        return rc;
-}
-
-int
-SMB2_set_eof(const unsigned int xid, struct cifs_tcon *tcon, u64 persistent_fid,
-             u64 volatile_fid, u32 pid, __le64 *eof)
-{
-        struct smb2_file_eof_info info;
-        void *data;
-        unsigned int size;
-
-        info.EndOfFile = *eof;
-
-        data = &info;
-        size = sizeof(struct smb2_file_eof_info);
-
-        return send_set_info(xid, tcon, persistent_fid, volatile_fid, pid,
-                             FILE_END_OF_FILE_INFORMATION, 1, &data, &size);
-}
-
-int
-SMB2_set_info(const unsigned int xid, struct cifs_tcon *tcon,
-              u64 persistent_fid, u64 volatile_fid, FILE_BASIC_INFO *buf)
-{
-        unsigned int size;
-        size = sizeof(FILE_BASIC_INFO);
-        return send_set_info(xid, tcon, persistent_fid, volatile_fid,
-                             current->tgid, FILE_BASIC_INFORMATION, 1,
-                             (void **)&buf, &size);
-}
-
-int
-SMB2_oplock_break(const unsigned int xid, struct cifs_tcon *tcon,
-                  const u64 persistent_fid, const u64 volatile_fid,
-                  __u8 oplock_level)
-{
-        int rc;
-        struct smb2_oplock_break *req = NULL;
-
-        cFYI(1, "SMB2_oplock_break");
-        rc = small_smb2_init(SMB2_OPLOCK_BREAK, tcon, (void **) &req);
-
-        if (rc)
-                return rc;
-
-        req->VolatileFid = volatile_fid;
-        req->PersistentFid = persistent_fid;
-        req->OplockLevel = oplock_level;
-        req->hdr.CreditRequest = cpu_to_le16(1);
-
-        rc = SendReceiveNoRsp(xid, tcon->ses, (char *) req, CIFS_OBREAK_OP);
-        /* SMB2 buffer freed by function above */
-
-        if (rc) {
-                cifs_stats_fail_inc(tcon, SMB2_OPLOCK_BREAK_HE);
-                cFYI(1, "Send error in Oplock Break = %d", rc);
-        }
-
-        return rc;
-}
-
-static void
-copy_fs_info_to_kstatfs(struct smb2_fs_full_size_info *pfs_inf,
-                        struct kstatfs *kst)
-{
-        kst->f_bsize = le32_to_cpu(pfs_inf->BytesPerSector) *
-                          le32_to_cpu(pfs_inf->SectorsPerAllocationUnit);
-        kst->f_blocks = le64_to_cpu(pfs_inf->TotalAllocationUnits);
-        kst->f_bfree  = le64_to_cpu(pfs_inf->ActualAvailableAllocationUnits);
-        kst->f_bavail = le64_to_cpu(pfs_inf->CallerAvailableAllocationUnits);
-        return;
-}
-
-static int
-build_qfs_info_req(struct kvec *iov, struct cifs_tcon *tcon, int level,
-                   int outbuf_len, u64 persistent_fid, u64 volatile_fid)
-{
-        int rc;
-        struct smb2_query_info_req *req;
-
-        cFYI(1, "Query FSInfo level %d", level);
-
-        if ((tcon->ses == NULL) || (tcon->ses->server == NULL))
-                return -EIO;
-
-        rc = small_smb2_init(SMB2_QUERY_INFO, tcon, (void **) &req);
-        if (rc)
-                return rc;
-
-        req->InfoType = SMB2_O_INFO_FILESYSTEM;
-        req->FileInfoClass = level;
-        req->PersistentFileId = persistent_fid;
-        req->VolatileFileId = volatile_fid;
-        /* 4 for rfc1002 length field and 1 for pad */
-        req->InputBufferOffset =
-                        cpu_to_le16(sizeof(struct smb2_query_info_req) - 1 - 4);
-        req->OutputBufferLength = cpu_to_le32(
-                outbuf_len + sizeof(struct smb2_query_info_rsp) - 1 - 4);
-
-        iov->iov_base = (char *)req;
-        /* 4 for rfc1002 length field */
-        iov->iov_len = get_rfc1002_length(req) + 4;
-        return 0;
-}
-
-int
-SMB2_QFS_info(const unsigned int xid, struct cifs_tcon *tcon,
-              u64 persistent_fid, u64 volatile_fid, struct kstatfs *fsdata)
-{
-        struct smb2_query_info_rsp *rsp = NULL;
-        struct kvec iov;
-        int rc = 0;
-        int resp_buftype;
-        struct cifs_ses *ses = tcon->ses;
-        struct smb2_fs_full_size_info *info = NULL;
-
-        rc = build_qfs_info_req(&iov, tcon, FS_FULL_SIZE_INFORMATION,
-                                sizeof(struct smb2_fs_full_size_info),
-                                persistent_fid, volatile_fid);
-        if (rc)
-                return rc;
-
-        rc = SendReceive2(xid, ses, &iov, 1, &resp_buftype, 0);
-        if (rc) {
-                cifs_stats_fail_inc(tcon, SMB2_QUERY_INFO_HE);
-                goto qinf_exit;
-        }
-        rsp = (struct smb2_query_info_rsp *)iov.iov_base;
-
-        info = (struct smb2_fs_full_size_info *)(4 /* RFC1001 len */ +
-                le16_to_cpu(rsp->OutputBufferOffset) + (char *)&rsp->hdr);
-        rc = validate_buf(le16_to_cpu(rsp->OutputBufferOffset),
-                          le32_to_cpu(rsp->OutputBufferLength), &rsp->hdr,
-                          sizeof(struct smb2_fs_full_size_info));
-        if (!rc)
-                copy_fs_info_to_kstatfs(info, fsdata);
-
-qinf_exit:
-        free_rsp_buf(resp_buftype, iov.iov_base);
-        return rc;
-}
-
-int
-smb2_lockv(const unsigned int xid, struct cifs_tcon *tcon,
-           const __u64 persist_fid, const __u64 volatile_fid, const __u32 pid,
-           const __u32 num_lock, struct smb2_lock_element *buf)
-{
-        int rc = 0;
-        struct smb2_lock_req *req = NULL;
-        struct kvec iov[2];
-        int resp_buf_type;
-        unsigned int count;
-
-        cFYI(1, "smb2_lockv num lock %d", num_lock);
-
-        rc = small_smb2_init(SMB2_LOCK, tcon, (void **) &req);
-        if (rc)
-                return rc;
-
-        req->hdr.ProcessId = cpu_to_le32(pid);
-        req->LockCount = cpu_to_le16(num_lock);
-
-        req->PersistentFileId = persist_fid;
-        req->VolatileFileId = volatile_fid;
-
-        count = num_lock * sizeof(struct smb2_lock_element);
-        inc_rfc1001_len(req, count - sizeof(struct smb2_lock_element));
-
-        iov[0].iov_base = (char *)req;
-        /* 4 for rfc1002 length field and count for all locks */
-        iov[0].iov_len = get_rfc1002_length(req) + 4 - count;
-        iov[1].iov_base = (char *)buf;
-        iov[1].iov_len = count;
-
-        cifs_stats_inc(&tcon->stats.cifs_stats.num_locks);
-        rc = SendReceive2(xid, tcon->ses, iov, 2, &resp_buf_type, CIFS_NO_RESP);
-        if (rc) {
-                cFYI(1, "Send error in smb2_lockv = %d", rc);
-                cifs_stats_fail_inc(tcon, SMB2_LOCK_HE);
-        }
-
-        return rc;
-}
-
-int
-SMB2_lock(const unsigned int xid, struct cifs_tcon *tcon,
-          const __u64 persist_fid, const __u64 volatile_fid, const __u32 pid,
-          const __u64 length, const __u64 offset, const __u32 lock_flags,
-          const bool wait)
-{
-        struct smb2_lock_element lock;
-
-        lock.Offset = cpu_to_le64(offset);
-        lock.Length = cpu_to_le64(length);
-        lock.Flags = cpu_to_le32(lock_flags);
-        if (!wait && lock_flags != SMB2_LOCKFLAG_UNLOCK)
-                lock.Flags |= cpu_to_le32(SMB2_LOCKFLAG_FAIL_IMMEDIATELY);
-
-        return smb2_lockv(xid, tcon, persist_fid, volatile_fid, pid, 1, &lock);
-}
-
-int
-SMB2_lease_break(const unsigned int xid, struct cifs_tcon *tcon,
-                 __u8 *lease_key, const __le32 lease_state)
-{
-        int rc;
-        struct smb2_lease_ack *req = NULL;
-
-        cFYI(1, "SMB2_lease_break");
-        rc = small_smb2_init(SMB2_OPLOCK_BREAK, tcon, (void **) &req);
-
-        if (rc)
-                return rc;
-
-        req->hdr.CreditRequest = cpu_to_le16(1);
-        req->StructureSize = cpu_to_le16(36);
-        inc_rfc1001_len(req, 12);
-
-        memcpy(req->LeaseKey, lease_key, 16);
-        req->LeaseState = lease_state;
-
-        rc = SendReceiveNoRsp(xid, tcon->ses, (char *) req, CIFS_OBREAK_OP);
-        /* SMB2 buffer freed by function above */
-
-        if (rc) {
-                cifs_stats_fail_inc(tcon, SMB2_OPLOCK_BREAK_HE);
-                cFYI(1, "Send error in Lease Break = %d", rc);
-        }
-
-        return rc;
-}
diff --git a/fs/cifs/smb2pdu.h b/fs/cifs/smb2pdu.h
deleted file mode 100644
index 4cb4ced258c..00000000000
--- a/fs/cifs/smb2pdu.h
+++ /dev/null
@@ -1,857 +0,0 @@
-/*
- *   fs/cifs/smb2pdu.h
- *
- *   Copyright (c) International Business Machines  Corp., 2009, 2010
- *                 Etersoft, 2012
- *   Author(s): Steve French (sfrench@us.ibm.com)
- *              Pavel Shilovsky (pshilovsky@samba.org) 2012
- *
- *   This library is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU Lesser General Public License as published
- *   by the Free Software Foundation; either version 2.1 of the License, or
- *   (at your option) any later version.
- *
- *   This library is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
- *   the GNU Lesser General Public License for more details.
- *
- *   You should have received a copy of the GNU Lesser General Public License
- *   along with this library; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-
-#ifndef _SMB2PDU_H
-#define _SMB2PDU_H
-
-#include <net/sock.h>
-
-/*
- * Note that, due to trying to use names similar to the protocol specifications,
- * there are many mixed case field names in the structures below.  Although
- * this does not match typical Linux kernel style, it is necessary to be
- * be able to match against the protocol specfication.
- *
- * SMB2 commands
- * Some commands have minimal (wct=0,bcc=0), or uninteresting, responses
- * (ie no useful data other than the SMB error code itself) and are marked such.
- * Knowing this helps avoid response buffer allocations and copy in some cases.
- */
-
-/* List of commands in host endian */
-#define SMB2_NEGOTIATE_HE       0x0000
-#define SMB2_SESSION_SETUP_HE   0x0001
-#define SMB2_LOGOFF_HE          0x0002 /* trivial request/resp */
-#define SMB2_TREE_CONNECT_HE    0x0003
-#define SMB2_TREE_DISCONNECT_HE 0x0004 /* trivial req/resp */
-#define SMB2_CREATE_HE          0x0005
-#define SMB2_CLOSE_HE           0x0006
-#define SMB2_FLUSH_HE           0x0007 /* trivial resp */
-#define SMB2_READ_HE            0x0008
-#define SMB2_WRITE_HE           0x0009
-#define SMB2_LOCK_HE            0x000A
-#define SMB2_IOCTL_HE           0x000B
-#define SMB2_CANCEL_HE          0x000C
-#define SMB2_ECHO_HE            0x000D
-#define SMB2_QUERY_DIRECTORY_HE 0x000E
-#define SMB2_CHANGE_NOTIFY_HE   0x000F
-#define SMB2_QUERY_INFO_HE      0x0010
-#define SMB2_SET_INFO_HE        0x0011
-#define SMB2_OPLOCK_BREAK_HE    0x0012
-
-/* The same list in little endian */
-#define SMB2_NEGOTIATE          cpu_to_le16(SMB2_NEGOTIATE_HE)
-#define SMB2_SESSION_SETUP      cpu_to_le16(SMB2_SESSION_SETUP_HE)
-#define SMB2_LOGOFF             cpu_to_le16(SMB2_LOGOFF_HE)
-#define SMB2_TREE_CONNECT       cpu_to_le16(SMB2_TREE_CONNECT_HE)
-#define SMB2_TREE_DISCONNECT    cpu_to_le16(SMB2_TREE_DISCONNECT_HE)
-#define SMB2_CREATE             cpu_to_le16(SMB2_CREATE_HE)
-#define SMB2_CLOSE              cpu_to_le16(SMB2_CLOSE_HE)
-#define SMB2_FLUSH              cpu_to_le16(SMB2_FLUSH_HE)
-#define SMB2_READ               cpu_to_le16(SMB2_READ_HE)
-#define SMB2_WRITE              cpu_to_le16(SMB2_WRITE_HE)
-#define SMB2_LOCK               cpu_to_le16(SMB2_LOCK_HE)
-#define SMB2_IOCTL              cpu_to_le16(SMB2_IOCTL_HE)
-#define SMB2_CANCEL             cpu_to_le16(SMB2_CANCEL_HE)
-#define SMB2_ECHO               cpu_to_le16(SMB2_ECHO_HE)
-#define SMB2_QUERY_DIRECTORY    cpu_to_le16(SMB2_QUERY_DIRECTORY_HE)
-#define SMB2_CHANGE_NOTIFY      cpu_to_le16(SMB2_CHANGE_NOTIFY_HE)
-#define SMB2_QUERY_INFO         cpu_to_le16(SMB2_QUERY_INFO_HE)
-#define SMB2_SET_INFO           cpu_to_le16(SMB2_SET_INFO_HE)
-#define SMB2_OPLOCK_BREAK       cpu_to_le16(SMB2_OPLOCK_BREAK_HE)
-
-#define NUMBER_OF_SMB2_COMMANDS 0x0013
-
-/* BB FIXME - analyze following length BB */
-#define MAX_SMB2_HDR_SIZE 0x78 /* 4 len + 64 hdr + (2*24 wct) + 2 bct + 2 pad */
-
-#define SMB2_PROTO_NUMBER __constant_cpu_to_le32(0x424d53fe)
-
-/*
- * SMB2 Header Definition
- *
- * "MBZ" :  Must be Zero
- * "BB"  :  BugBug, Something to check/review/analyze later
- * "PDU" :  "Protocol Data Unit" (ie a network "frame")
- *
- */
-
-#define SMB2_HEADER_STRUCTURE_SIZE __constant_cpu_to_le16(64)
-
-struct smb2_hdr {
-        __be32 smb2_buf_length; /* big endian on wire */
-                                /* length is only two or three bytes - with
-                                 one or two byte type preceding it that MBZ */
-        __u8   ProtocolId[4];   /* 0xFE 'S' 'M' 'B' */
-        __le16 StructureSize;   /* 64 */
-        __le16 CreditCharge;    /* MBZ */
-        __le32 Status;          /* Error from server */
-        __le16 Command;
-        __le16 CreditRequest;  /* CreditResponse */
-        __le32 Flags;
-        __le32 NextCommand;
-        __u64  MessageId;       /* opaque - so can stay little endian */
-        __le32 ProcessId;
-        __u32  TreeId;          /* opaque - so do not make little endian */
-        __u64  SessionId;       /* opaque - so do not make little endian */
-        __u8   Signature[16];
-} __packed;
-
-struct smb2_pdu {
-        struct smb2_hdr hdr;
-        __le16 StructureSize2; /* size of wct area (varies, request specific) */
-} __packed;
-
-/*
- *      SMB2 flag definitions
- */
-#define SMB2_FLAGS_SERVER_TO_REDIR      __constant_cpu_to_le32(0x00000001)
-#define SMB2_FLAGS_ASYNC_COMMAND        __constant_cpu_to_le32(0x00000002)
-#define SMB2_FLAGS_RELATED_OPERATIONS   __constant_cpu_to_le32(0x00000004)
-#define SMB2_FLAGS_SIGNED               __constant_cpu_to_le32(0x00000008)
-#define SMB2_FLAGS_DFS_OPERATIONS       __constant_cpu_to_le32(0x10000000)
-
-/*
- *      Definitions for SMB2 Protocol Data Units (network frames)
- *
- *  See MS-SMB2.PDF specification for protocol details.
- *  The Naming convention is the lower case version of the SMB2
- *  command code name for the struct. Note that structures must be packed.
- *
- */
-
-#define SMB2_ERROR_STRUCTURE_SIZE2 __constant_cpu_to_le16(9)
-
-struct smb2_err_rsp {
-        struct smb2_hdr hdr;
-        __le16 StructureSize;
-        __le16 Reserved; /* MBZ */
-        __le32 ByteCount;  /* even if zero, at least one byte follows */
-        __u8   ErrorData[1];  /* variable length */
-} __packed;
-
-#define SMB2_CLIENT_GUID_SIZE 16
-
-extern __u8 cifs_client_guid[SMB2_CLIENT_GUID_SIZE];
-
-struct smb2_negotiate_req {
-        struct smb2_hdr hdr;
-        __le16 StructureSize; /* Must be 36 */
-        __le16 DialectCount;
-        __le16 SecurityMode;
-        __le16 Reserved;        /* MBZ */
-        __le32 Capabilities;
-        __u8   ClientGUID[SMB2_CLIENT_GUID_SIZE];
-        __le64 ClientStartTime; /* MBZ */
-        __le16 Dialects[1]; /* One dialect (vers=) at a time for now */
-} __packed;
-
-/* Dialects */
-#define SMB20_PROT_ID 0x0202
-#define SMB21_PROT_ID 0x0210
-#define SMB30_PROT_ID 0x0300
-#define BAD_PROT_ID   0xFFFF
-
-/* SecurityMode flags */
-#define SMB2_NEGOTIATE_SIGNING_ENABLED  0x0001
-#define SMB2_NEGOTIATE_SIGNING_REQUIRED 0x0002
-/* Capabilities flags */
-#define SMB2_GLOBAL_CAP_DFS             0x00000001
-#define SMB2_GLOBAL_CAP_LEASING         0x00000002 /* Resp only New to SMB2.1 */
-#define SMB2_GLOBAL_CAP_LARGE_MTU       0X00000004 /* Resp only New to SMB2.1 */
-#define SMB2_GLOBAL_CAP_MULTI_CHANNEL   0x00000008 /* New to SMB3 */
-#define SMB2_GLOBAL_CAP_PERSISTENT_HANDLES 0x00000010 /* New to SMB3 */
-#define SMB2_GLOBAL_CAP_DIRECTORY_LEASING  0x00000020 /* New to SMB3 */
-#define SMB2_GLOBAL_CAP_ENCRYPTION      0x00000040 /* New to SMB3 */
-/* Internal types */
-#define SMB2_NT_FIND                    0x00100000
-#define SMB2_LARGE_FILES                0x00200000
-
-struct smb2_negotiate_rsp {
-        struct smb2_hdr hdr;
-        __le16 StructureSize;   /* Must be 65 */
-        __le16 SecurityMode;
-        __le16 DialectRevision;
-        __le16 Reserved;        /* MBZ */
-        __u8   ServerGUID[16];
-        __le32 Capabilities;
-        __le32 MaxTransactSize;
-        __le32 MaxReadSize;
-        __le32 MaxWriteSize;
-        __le64 SystemTime;      /* MBZ */
-        __le64 ServerStartTime;
-        __le16 SecurityBufferOffset;
-        __le16 SecurityBufferLength;
-        __le32 Reserved2;       /* may be any value, ignore */
-        __u8   Buffer[1];       /* variable length GSS security buffer */
-} __packed;
-
-struct smb2_sess_setup_req {
-        struct smb2_hdr hdr;
-        __le16 StructureSize; /* Must be 25 */
-        __u8   VcNumber;
-        __u8   SecurityMode;
-        __le32 Capabilities;
-        __le32 Channel;
-        __le16 SecurityBufferOffset;
-        __le16 SecurityBufferLength;
-        __le64 PreviousSessionId;
-        __u8   Buffer[1];       /* variable length GSS security buffer */
-} __packed;
-
-/* Currently defined SessionFlags */
-#define SMB2_SESSION_FLAG_IS_GUEST      0x0001
-#define SMB2_SESSION_FLAG_IS_NULL       0x0002
-struct smb2_sess_setup_rsp {
-        struct smb2_hdr hdr;
-        __le16 StructureSize; /* Must be 9 */
-        __le16 SessionFlags;
-        __le16 SecurityBufferOffset;
-        __le16 SecurityBufferLength;
-        __u8   Buffer[1];       /* variable length GSS security buffer */
-} __packed;
-
-struct smb2_logoff_req {
-        struct smb2_hdr hdr;
-        __le16 StructureSize;   /* Must be 4 */
-        __le16 Reserved;
-} __packed;
-
-struct smb2_logoff_rsp {
-        struct smb2_hdr hdr;
-        __le16 StructureSize;   /* Must be 4 */
-        __le16 Reserved;
-} __packed;
-
-struct smb2_tree_connect_req {
-        struct smb2_hdr hdr;
-        __le16 StructureSize;   /* Must be 9 */
-        __le16 Reserved;
-        __le16 PathOffset;
-        __le16 PathLength;
-        __u8   Buffer[1];       /* variable length */
-} __packed;
-
-struct smb2_tree_connect_rsp {
-        struct smb2_hdr hdr;
-        __le16 StructureSize;   /* Must be 16 */
-        __u8   ShareType;  /* see below */
-        __u8   Reserved;
-        __le32 ShareFlags; /* see below */
-        __le32 Capabilities; /* see below */
-        __le32 MaximalAccess;
-} __packed;
-
-/* Possible ShareType values */
-#define SMB2_SHARE_TYPE_DISK    0x01
-#define SMB2_SHARE_TYPE_PIPE    0x02
-#define SMB2_SHARE_TYPE_PRINT   0x03
-
-/*
- * Possible ShareFlags - exactly one and only one of the first 4 caching flags
- * must be set (any of the remaining, SHI1005, flags may be set individually
- * or in combination.
- */
-#define SMB2_SHAREFLAG_MANUAL_CACHING                   0x00000000
-#define SMB2_SHAREFLAG_AUTO_CACHING                     0x00000010
-#define SMB2_SHAREFLAG_VDO_CACHING                      0x00000020
-#define SMB2_SHAREFLAG_NO_CACHING                       0x00000030
-#define SHI1005_FLAGS_DFS                               0x00000001
-#define SHI1005_FLAGS_DFS_ROOT                          0x00000002
-#define SHI1005_FLAGS_RESTRICT_EXCLUSIVE_OPENS          0x00000100
-#define SHI1005_FLAGS_FORCE_SHARED_DELETE               0x00000200
-#define SHI1005_FLAGS_ALLOW_NAMESPACE_CACHING           0x00000400
-#define SHI1005_FLAGS_ACCESS_BASED_DIRECTORY_ENUM       0x00000800
-#define SHI1005_FLAGS_FORCE_LEVELII_OPLOCK              0x00001000
-#define SHI1005_FLAGS_ENABLE_HASH                       0x00002000
-
-/* Possible share capabilities */
-#define SMB2_SHARE_CAP_DFS      cpu_to_le32(0x00000008)
-
-struct smb2_tree_disconnect_req {
-        struct smb2_hdr hdr;
-        __le16 StructureSize;   /* Must be 4 */
-        __le16 Reserved;
-} __packed;
-
-struct smb2_tree_disconnect_rsp {
-        struct smb2_hdr hdr;
-        __le16 StructureSize;   /* Must be 4 */
-        __le16 Reserved;
-} __packed;
-
-/* File Attrubutes */
-#define FILE_ATTRIBUTE_READONLY                 0x00000001
-#define FILE_ATTRIBUTE_HIDDEN                   0x00000002
-#define FILE_ATTRIBUTE_SYSTEM                   0x00000004
-#define FILE_ATTRIBUTE_DIRECTORY                0x00000010
-#define FILE_ATTRIBUTE_ARCHIVE                  0x00000020
-#define FILE_ATTRIBUTE_NORMAL                   0x00000080
-#define FILE_ATTRIBUTE_TEMPORARY                0x00000100
-#define FILE_ATTRIBUTE_SPARSE_FILE              0x00000200
-#define FILE_ATTRIBUTE_REPARSE_POINT            0x00000400
-#define FILE_ATTRIBUTE_COMPRESSED               0x00000800
-#define FILE_ATTRIBUTE_OFFLINE                  0x00001000
-#define FILE_ATTRIBUTE_NOT_CONTENT_INDEXED      0x00002000
-#define FILE_ATTRIBUTE_ENCRYPTED                0x00004000
-
-/* Oplock levels */
-#define SMB2_OPLOCK_LEVEL_NONE          0x00
-#define SMB2_OPLOCK_LEVEL_II            0x01
-#define SMB2_OPLOCK_LEVEL_EXCLUSIVE     0x08
-#define SMB2_OPLOCK_LEVEL_BATCH         0x09
-#define SMB2_OPLOCK_LEVEL_LEASE         0xFF
-/* Non-spec internal type */
-#define SMB2_OPLOCK_LEVEL_NOCHANGE      0x99
-
-/* Desired Access Flags */
-#define FILE_READ_DATA_LE               cpu_to_le32(0x00000001)
-#define FILE_WRITE_DATA_LE              cpu_to_le32(0x00000002)
-#define FILE_APPEND_DATA_LE             cpu_to_le32(0x00000004)
-#define FILE_READ_EA_LE                 cpu_to_le32(0x00000008)
-#define FILE_WRITE_EA_LE                cpu_to_le32(0x00000010)
-#define FILE_EXECUTE_LE                 cpu_to_le32(0x00000020)
-#define FILE_READ_ATTRIBUTES_LE         cpu_to_le32(0x00000080)
-#define FILE_WRITE_ATTRIBUTES_LE        cpu_to_le32(0x00000100)
-#define FILE_DELETE_LE                  cpu_to_le32(0x00010000)
-#define FILE_READ_CONTROL_LE            cpu_to_le32(0x00020000)
-#define FILE_WRITE_DAC_LE               cpu_to_le32(0x00040000)
-#define FILE_WRITE_OWNER_LE             cpu_to_le32(0x00080000)
-#define FILE_SYNCHRONIZE_LE             cpu_to_le32(0x00100000)
-#define FILE_ACCESS_SYSTEM_SECURITY_LE  cpu_to_le32(0x01000000)
-#define FILE_MAXIMAL_ACCESS_LE          cpu_to_le32(0x02000000)
-#define FILE_GENERIC_ALL_LE             cpu_to_le32(0x10000000)
-#define FILE_GENERIC_EXECUTE_LE         cpu_to_le32(0x20000000)
-#define FILE_GENERIC_WRITE_LE           cpu_to_le32(0x40000000)
-#define FILE_GENERIC_READ_LE            cpu_to_le32(0x80000000)
-
-/* ShareAccess Flags */
-#define FILE_SHARE_READ_LE              cpu_to_le32(0x00000001)
-#define FILE_SHARE_WRITE_LE             cpu_to_le32(0x00000002)
-#define FILE_SHARE_DELETE_LE            cpu_to_le32(0x00000004)
-#define FILE_SHARE_ALL_LE               cpu_to_le32(0x00000007)
-
-/* CreateDisposition Flags */
-#define FILE_SUPERSEDE_LE               cpu_to_le32(0x00000000)
-#define FILE_OPEN_LE                    cpu_to_le32(0x00000001)
-#define FILE_CREATE_LE                  cpu_to_le32(0x00000002)
-#define FILE_OPEN_IF_LE                 cpu_to_le32(0x00000003)
-#define FILE_OVERWRITE_LE               cpu_to_le32(0x00000004)
-#define FILE_OVERWRITE_IF_LE            cpu_to_le32(0x00000005)
-
-/* CreateOptions Flags */
-#define FILE_DIRECTORY_FILE_LE          cpu_to_le32(0x00000001)
-/* same as #define CREATE_NOT_FILE_LE   cpu_to_le32(0x00000001) */
-#define FILE_WRITE_THROUGH_LE           cpu_to_le32(0x00000002)
-#define FILE_SEQUENTIAL_ONLY_LE         cpu_to_le32(0x00000004)
-#define FILE_NO_INTERMEDIATE_BUFFERRING_LE cpu_to_le32(0x00000008)
-#define FILE_SYNCHRONOUS_IO_ALERT_LE    cpu_to_le32(0x00000010)
-#define FILE_SYNCHRONOUS_IO_NON_ALERT_LE        cpu_to_le32(0x00000020)
-#define FILE_NON_DIRECTORY_FILE_LE      cpu_to_le32(0x00000040)
-#define FILE_COMPLETE_IF_OPLOCKED_LE    cpu_to_le32(0x00000100)
-#define FILE_NO_EA_KNOWLEDGE_LE         cpu_to_le32(0x00000200)
-#define FILE_RANDOM_ACCESS_LE           cpu_to_le32(0x00000800)
-#define FILE_DELETE_ON_CLOSE_LE         cpu_to_le32(0x00001000)
-#define FILE_OPEN_BY_FILE_ID_LE         cpu_to_le32(0x00002000)
-#define FILE_OPEN_FOR_BACKUP_INTENT_LE  cpu_to_le32(0x00004000)
-#define FILE_NO_COMPRESSION_LE          cpu_to_le32(0x00008000)
-#define FILE_RESERVE_OPFILTER_LE        cpu_to_le32(0x00100000)
-#define FILE_OPEN_REPARSE_POINT_LE      cpu_to_le32(0x00200000)
-#define FILE_OPEN_NO_RECALL_LE          cpu_to_le32(0x00400000)
-#define FILE_OPEN_FOR_FREE_SPACE_QUERY_LE cpu_to_le32(0x00800000)
-
-#define FILE_READ_RIGHTS_LE (FILE_READ_DATA_LE | FILE_READ_EA_LE \
-                        | FILE_READ_ATTRIBUTES_LE)
-#define FILE_WRITE_RIGHTS_LE (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE \
-                        | FILE_WRITE_EA_LE | FILE_WRITE_ATTRIBUTES_LE)
-#define FILE_EXEC_RIGHTS_LE (FILE_EXECUTE_LE)
-
-/* Impersonation Levels */
-#define IL_ANONYMOUS            cpu_to_le32(0x00000000)
-#define IL_IDENTIFICATION       cpu_to_le32(0x00000001)
-#define IL_IMPERSONATION        cpu_to_le32(0x00000002)
-#define IL_DELEGATE             cpu_to_le32(0x00000003)
-
-/* Create Context Values */
-#define SMB2_CREATE_EA_BUFFER                   "ExtA" /* extended attributes */
-#define SMB2_CREATE_SD_BUFFER                   "SecD" /* security descriptor */
-#define SMB2_CREATE_DURABLE_HANDLE_REQUEST      "DHnQ"
-#define SMB2_CREATE_DURABLE_HANDLE_RECONNECT    "DHnC"
-#define SMB2_CREATE_ALLOCATION_SIZE             "AlSi"
-#define SMB2_CREATE_QUERY_MAXIMAL_ACCESS_REQUEST "MxAc"
-#define SMB2_CREATE_TIMEWARP_REQUEST            "TWrp"
-#define SMB2_CREATE_QUERY_ON_DISK_ID            "QFid"
-#define SMB2_CREATE_REQUEST_LEASE               "RqLs"
-
-struct smb2_create_req {
-        struct smb2_hdr hdr;
-        __le16 StructureSize;   /* Must be 57 */
-        __u8   SecurityFlags;
-        __u8   RequestedOplockLevel;
-        __le32 ImpersonationLevel;
-        __le64 SmbCreateFlags;
-        __le64 Reserved;
-        __le32 DesiredAccess;
-        __le32 FileAttributes;
-        __le32 ShareAccess;
-        __le32 CreateDisposition;
-        __le32 CreateOptions;
-        __le16 NameOffset;
-        __le16 NameLength;
-        __le32 CreateContextsOffset;
-        __le32 CreateContextsLength;
-        __u8   Buffer[8];
-} __packed;
-
-struct smb2_create_rsp {
-        struct smb2_hdr hdr;
-        __le16 StructureSize;   /* Must be 89 */
-        __u8   OplockLevel;
-        __u8   Reserved;
-        __le32 CreateAction;
-        __le64 CreationTime;
-        __le64 LastAccessTime;
-        __le64 LastWriteTime;
-        __le64 ChangeTime;
-        __le64 AllocationSize;
-        __le64 EndofFile;
-        __le32 FileAttributes;
-        __le32 Reserved2;
-        __u64  PersistentFileId; /* opaque endianness */
-        __u64  VolatileFileId; /* opaque endianness */
-        __le32 CreateContextsOffset;
-        __le32 CreateContextsLength;
-        __u8   Buffer[1];
-} __packed;
-
-struct create_context {
-        __le32 Next;
-        __le16 NameOffset;
-        __le16 NameLength;
-        __le16 Reserved;
-        __le16 DataOffset;
-        __le32 DataLength;
-        __u8 Buffer[0];
-} __packed;
-
-#define SMB2_LEASE_NONE                 __constant_cpu_to_le32(0x00)
-#define SMB2_LEASE_READ_CACHING         __constant_cpu_to_le32(0x01)
-#define SMB2_LEASE_HANDLE_CACHING       __constant_cpu_to_le32(0x02)
-#define SMB2_LEASE_WRITE_CACHING        __constant_cpu_to_le32(0x04)
-
-#define SMB2_LEASE_FLAG_BREAK_IN_PROGRESS __constant_cpu_to_le32(0x02)
-
-#define SMB2_LEASE_KEY_SIZE 16
-
-struct lease_context {
-        __le64 LeaseKeyLow;
-        __le64 LeaseKeyHigh;
-        __le32 LeaseState;
-        __le32 LeaseFlags;
-        __le64 LeaseDuration;
-} __packed;
-
-struct create_lease {
-        struct create_context ccontext;
-        __u8   Name[8];
-        struct lease_context lcontext;
-} __packed;
-
-/* Currently defined values for close flags */
-#define SMB2_CLOSE_FLAG_POSTQUERY_ATTRIB        cpu_to_le16(0x0001)
-struct smb2_close_req {
-        struct smb2_hdr hdr;
-        __le16 StructureSize;   /* Must be 24 */
-        __le16 Flags;
-        __le32 Reserved;
-        __u64  PersistentFileId; /* opaque endianness */
-        __u64  VolatileFileId; /* opaque endianness */
-} __packed;
-
-struct smb2_close_rsp {
-        struct smb2_hdr hdr;
-        __le16 StructureSize; /* 60 */
-        __le16 Flags;
-        __le32 Reserved;
-        __le64 CreationTime;
-        __le64 LastAccessTime;
-        __le64 LastWriteTime;
-        __le64 ChangeTime;
-        __le64 AllocationSize;  /* Beginning of FILE_STANDARD_INFO equivalent */
-        __le64 EndOfFile;
-        __le32 Attributes;
-} __packed;
-
-struct smb2_flush_req {
-        struct smb2_hdr hdr;
-        __le16 StructureSize;   /* Must be 24 */
-        __le16 Reserved1;
-        __le32 Reserved2;
-        __u64  PersistentFileId; /* opaque endianness */
-        __u64  VolatileFileId; /* opaque endianness */
-} __packed;
-
-struct smb2_flush_rsp {
-        struct smb2_hdr hdr;
-        __le16 StructureSize;
-        __le16 Reserved;
-} __packed;
-
-struct smb2_read_req {
-        struct smb2_hdr hdr;
-        __le16 StructureSize; /* Must be 49 */
-        __u8   Padding; /* offset from start of SMB2 header to place read */
-        __u8   Reserved;
-        __le32 Length;
-        __le64 Offset;
-        __u64  PersistentFileId; /* opaque endianness */
-        __u64  VolatileFileId; /* opaque endianness */
-        __le32 MinimumCount;
-        __le32 Channel; /* Reserved MBZ */
-        __le32 RemainingBytes;
-        __le16 ReadChannelInfoOffset; /* Reserved MBZ */
-        __le16 ReadChannelInfoLength; /* Reserved MBZ */
-        __u8   Buffer[1];
-} __packed;
-
-struct smb2_read_rsp {
-        struct smb2_hdr hdr;
-        __le16 StructureSize; /* Must be 17 */
-        __u8   DataOffset;
-        __u8   Reserved;
-        __le32 DataLength;
-        __le32 DataRemaining;
-        __u32  Reserved2;
-        __u8   Buffer[1];
-} __packed;
-
-/* For write request Flags field below the following flag is defined: */
-#define SMB2_WRITEFLAG_WRITE_THROUGH 0x00000001
-
-struct smb2_write_req {
-        struct smb2_hdr hdr;
-        __le16 StructureSize; /* Must be 49 */
-        __le16 DataOffset; /* offset from start of SMB2 header to write data */
-        __le32 Length;
-        __le64 Offset;
-        __u64  PersistentFileId; /* opaque endianness */
-        __u64  VolatileFileId; /* opaque endianness */
-        __le32 Channel; /* Reserved MBZ */
-        __le32 RemainingBytes;
-        __le16 WriteChannelInfoOffset; /* Reserved MBZ */
-        __le16 WriteChannelInfoLength; /* Reserved MBZ */
-        __le32 Flags;
-        __u8   Buffer[1];
-} __packed;
-
-struct smb2_write_rsp {
-        struct smb2_hdr hdr;
-        __le16 StructureSize; /* Must be 17 */
-        __u8   DataOffset;
-        __u8   Reserved;
-        __le32 DataLength;
-        __le32 DataRemaining;
-        __u32  Reserved2;
-        __u8   Buffer[1];
-} __packed;
-
-#define SMB2_LOCKFLAG_SHARED_LOCK       0x0001
-#define SMB2_LOCKFLAG_EXCLUSIVE_LOCK    0x0002
-#define SMB2_LOCKFLAG_UNLOCK            0x0004
-#define SMB2_LOCKFLAG_FAIL_IMMEDIATELY  0x0010
-
-struct smb2_lock_element {
-        __le64 Offset;
-        __le64 Length;
-        __le32 Flags;
-        __le32 Reserved;
-} __packed;
-
-struct smb2_lock_req {
-        struct smb2_hdr hdr;
-        __le16 StructureSize; /* Must be 48 */
-        __le16 LockCount;
-        __le32 Reserved;
-        __u64  PersistentFileId; /* opaque endianness */
-        __u64  VolatileFileId; /* opaque endianness */
-        /* Followed by at least one */
-        struct smb2_lock_element locks[1];
-} __packed;
-
-struct smb2_lock_rsp {
-        struct smb2_hdr hdr;
-        __le16 StructureSize; /* Must be 4 */
-        __le16 Reserved;
-} __packed;
-
-struct smb2_echo_req {
-        struct smb2_hdr hdr;
-        __le16 StructureSize;   /* Must be 4 */
-        __u16  Reserved;
-} __packed;
-
-struct smb2_echo_rsp {
-        struct smb2_hdr hdr;
-        __le16 StructureSize;   /* Must be 4 */
-        __u16  Reserved;
-} __packed;
-
-/* search (query_directory) Flags field */
-#define SMB2_RESTART_SCANS              0x01
-#define SMB2_RETURN_SINGLE_ENTRY        0x02
-#define SMB2_INDEX_SPECIFIED            0x04
-#define SMB2_REOPEN                     0x10
-
-struct smb2_query_directory_req {
-        struct smb2_hdr hdr;
-        __le16 StructureSize; /* Must be 33 */
-        __u8   FileInformationClass;
-        __u8   Flags;
-        __le32 FileIndex;
-        __u64  PersistentFileId; /* opaque endianness */
-        __u64  VolatileFileId; /* opaque endianness */
-        __le16 FileNameOffset;
-        __le16 FileNameLength;
-        __le32 OutputBufferLength;
-        __u8   Buffer[1];
-} __packed;
-
-struct smb2_query_directory_rsp {
-        struct smb2_hdr hdr;
-        __le16 StructureSize; /* Must be 9 */
-        __le16 OutputBufferOffset;
-        __le32 OutputBufferLength;
-        __u8   Buffer[1];
-} __packed;
-
-/* Possible InfoType values */
-#define SMB2_O_INFO_FILE        0x01
-#define SMB2_O_INFO_FILESYSTEM  0x02
-#define SMB2_O_INFO_SECURITY    0x03
-#define SMB2_O_INFO_QUOTA       0x04
-
-struct smb2_query_info_req {
-        struct smb2_hdr hdr;
-        __le16 StructureSize; /* Must be 41 */
-        __u8   InfoType;
-        __u8   FileInfoClass;
-        __le32 OutputBufferLength;
-        __le16 InputBufferOffset;
-        __u16  Reserved;
-        __le32 InputBufferLength;
-        __le32 AdditionalInformation;
-        __le32 Flags;
-        __u64  PersistentFileId; /* opaque endianness */
-        __u64  VolatileFileId; /* opaque endianness */
-        __u8   Buffer[1];
-} __packed;
-
-struct smb2_query_info_rsp {
-        struct smb2_hdr hdr;
-        __le16 StructureSize; /* Must be 9 */
-        __le16 OutputBufferOffset;
-        __le32 OutputBufferLength;
-        __u8   Buffer[1];
-} __packed;
-
-struct smb2_set_info_req {
-        struct smb2_hdr hdr;
-        __le16 StructureSize; /* Must be 33 */
-        __u8   InfoType;
-        __u8   FileInfoClass;
-        __le32 BufferLength;
-        __le16 BufferOffset;
-        __u16  Reserved;
-        __le32 AdditionalInformation;
-        __u64  PersistentFileId; /* opaque endianness */
-        __u64  VolatileFileId; /* opaque endianness */
-        __u8   Buffer[1];
-} __packed;
-
-struct smb2_set_info_rsp {
-        struct smb2_hdr hdr;
-        __le16 StructureSize; /* Must be 2 */
-} __packed;
-
-struct smb2_oplock_break {
-        struct smb2_hdr hdr;
-        __le16 StructureSize; /* Must be 24 */
-        __u8   OplockLevel;
-        __u8   Reserved;
-        __le32 Reserved2;
-        __u64  PersistentFid;
-        __u64  VolatileFid;
-} __packed;
-
-#define SMB2_NOTIFY_BREAK_LEASE_FLAG_ACK_REQUIRED cpu_to_le32(0x01)
-
-struct smb2_lease_break {
-        struct smb2_hdr hdr;
-        __le16 StructureSize; /* Must be 44 */
-        __le16 Reserved;
-        __le32 Flags;
-        __u8   LeaseKey[16];
-        __le32 CurrentLeaseState;
-        __le32 NewLeaseState;
-        __le32 BreakReason;
-        __le32 AccessMaskHint;
-        __le32 ShareMaskHint;
-} __packed;
-
-struct smb2_lease_ack {
-        struct smb2_hdr hdr;
-        __le16 StructureSize; /* Must be 36 */
-        __le16 Reserved;
-        __le32 Flags;
-        __u8   LeaseKey[16];
-        __le32 LeaseState;
-        __le64 LeaseDuration;
-} __packed;
-
-/*
- *      PDU infolevel structure definitions
- *      BB consider moving to a different header
- */
-
-/* File System Information Classes */
-#define FS_VOLUME_INFORMATION           1 /* Query */
-#define FS_LABEL_INFORMATION            2 /* Set */
-#define FS_SIZE_INFORMATION             3 /* Query */
-#define FS_DEVICE_INFORMATION           4 /* Query */
-#define FS_ATTRIBUTE_INFORMATION        5 /* Query */
-#define FS_CONTROL_INFORMATION          6 /* Query, Set */
-#define FS_FULL_SIZE_INFORMATION        7 /* Query */
-#define FS_OBJECT_ID_INFORMATION        8 /* Query, Set */
-#define FS_DRIVER_PATH_INFORMATION      9 /* Query */
-
-struct smb2_fs_full_size_info {
-        __le64 TotalAllocationUnits;
-        __le64 CallerAvailableAllocationUnits;
-        __le64 ActualAvailableAllocationUnits;
-        __le32 SectorsPerAllocationUnit;
-        __le32 BytesPerSector;
-} __packed;
-
-/* partial list of QUERY INFO levels */
-#define FILE_DIRECTORY_INFORMATION      1
-#define FILE_FULL_DIRECTORY_INFORMATION 2
-#define FILE_BOTH_DIRECTORY_INFORMATION 3
-#define FILE_BASIC_INFORMATION          4
-#define FILE_STANDARD_INFORMATION       5
-#define FILE_INTERNAL_INFORMATION       6
-#define FILE_EA_INFORMATION             7
-#define FILE_ACCESS_INFORMATION         8
-#define FILE_NAME_INFORMATION           9
-#define FILE_RENAME_INFORMATION         10
-#define FILE_LINK_INFORMATION           11
-#define FILE_NAMES_INFORMATION          12
-#define FILE_DISPOSITION_INFORMATION    13
-#define FILE_POSITION_INFORMATION       14
-#define FILE_FULL_EA_INFORMATION        15
-#define FILE_MODE_INFORMATION           16
-#define FILE_ALIGNMENT_INFORMATION      17
-#define FILE_ALL_INFORMATION            18
-#define FILE_ALLOCATION_INFORMATION     19
-#define FILE_END_OF_FILE_INFORMATION    20
-#define FILE_ALTERNATE_NAME_INFORMATION 21
-#define FILE_STREAM_INFORMATION         22
-#define FILE_PIPE_INFORMATION           23
-#define FILE_PIPE_LOCAL_INFORMATION     24
-#define FILE_PIPE_REMOTE_INFORMATION    25
-#define FILE_MAILSLOT_QUERY_INFORMATION 26
-#define FILE_MAILSLOT_SET_INFORMATION   27
-#define FILE_COMPRESSION_INFORMATION    28
-#define FILE_OBJECT_ID_INFORMATION      29
-/* Number 30 not defined in documents */
-#define FILE_MOVE_CLUSTER_INFORMATION   31
-#define FILE_QUOTA_INFORMATION          32
-#define FILE_REPARSE_POINT_INFORMATION  33
-#define FILE_NETWORK_OPEN_INFORMATION   34
-#define FILE_ATTRIBUTE_TAG_INFORMATION  35
-#define FILE_TRACKING_INFORMATION       36
-#define FILEID_BOTH_DIRECTORY_INFORMATION 37
-#define FILEID_FULL_DIRECTORY_INFORMATION 38
-#define FILE_VALID_DATA_LENGTH_INFORMATION 39
-#define FILE_SHORT_NAME_INFORMATION     40
-#define FILE_SFIO_RESERVE_INFORMATION   44
-#define FILE_SFIO_VOLUME_INFORMATION    45
-#define FILE_HARD_LINK_INFORMATION      46
-#define FILE_NORMALIZED_NAME_INFORMATION 48
-#define FILEID_GLOBAL_TX_DIRECTORY_INFORMATION 50
-#define FILE_STANDARD_LINK_INFORMATION  54
-
-struct smb2_file_internal_info {
-        __le64 IndexNumber;
-} __packed; /* level 6 Query */
-
-struct smb2_file_rename_info { /* encoding of request for level 10 */
-        __u8   ReplaceIfExists; /* 1 = replace existing target with new */
-                                /* 0 = fail if target already exists */
-        __u8   Reserved[7];
-        __u64  RootDirectory;  /* MBZ for network operations (why says spec?) */
-        __le32 FileNameLength;
-        char   FileName[0];     /* New name to be assigned */
-} __packed; /* level 10 Set */
-
-struct smb2_file_link_info { /* encoding of request for level 11 */
-        __u8   ReplaceIfExists; /* 1 = replace existing link with new */
-                                /* 0 = fail if link already exists */
-        __u8   Reserved[7];
-        __u64  RootDirectory;  /* MBZ for network operations (why says spec?) */
-        __le32 FileNameLength;
-        char   FileName[0];     /* Name to be assigned to new link */
-} __packed; /* level 11 Set */
-
-/*
- * This level 18, although with struct with same name is different from cifs
- * level 0x107. Level 0x107 has an extra u64 between AccessFlags and
- * CurrentByteOffset.
- */
-struct smb2_file_all_info { /* data block encoding of response to level 18 */
-        __le64 CreationTime;    /* Beginning of FILE_BASIC_INFO equivalent */
-        __le64 LastAccessTime;
-        __le64 LastWriteTime;
-        __le64 ChangeTime;
-        __le32 Attributes;
-        __u32  Pad1;            /* End of FILE_BASIC_INFO_INFO equivalent */
-        __le64 AllocationSize;  /* Beginning of FILE_STANDARD_INFO equivalent */
-        __le64 EndOfFile;       /* size ie offset to first free byte in file */
-        __le32 NumberOfLinks;   /* hard links */
-        __u8   DeletePending;
-        __u8   Directory;
-        __u16  Pad2;            /* End of FILE_STANDARD_INFO equivalent */
-        __le64 IndexNumber;
-        __le32 EASize;
-        __le32 AccessFlags;
-        __le64 CurrentByteOffset;
-        __le32 Mode;
-        __le32 AlignmentRequirement;
-        __le32 FileNameLength;
-        char   FileName[1];
-} __packed; /* level 18 Query */
-
-struct smb2_file_eof_info { /* encoding of request for level 10 */
-        __le64 EndOfFile; /* new end of file value */
-} __packed; /* level 20 Set */
-
-#endif                          /* _SMB2PDU_H */
diff --git a/fs/cifs/smb2proto.h b/fs/cifs/smb2proto.h
deleted file mode 100644
index 2aa3535e38c..00000000000
--- a/fs/cifs/smb2proto.h
+++ /dev/null
@@ -1,163 +0,0 @@
-/*
- *   fs/cifs/smb2proto.h
- *
- *   Copyright (c) International Business Machines  Corp., 2002, 2011
- *                 Etersoft, 2012
- *   Author(s): Steve French (sfrench@us.ibm.com)
- *              Pavel Shilovsky (pshilovsky@samba.org) 2012
- *
- *   This library is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU Lesser General Public License as published
- *   by the Free Software Foundation; either version 2.1 of the License, or
- *   (at your option) any later version.
- *
- *   This library is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
- *   the GNU Lesser General Public License for more details.
- *
- *   You should have received a copy of the GNU Lesser General Public License
- *   along with this library; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-#ifndef _SMB2PROTO_H
-#define _SMB2PROTO_H
-#include <linux/nls.h>
-#include <linux/key-type.h>
-
-struct statfs;
-struct smb_rqst;
-
-/*
- *****************************************************************
- * All Prototypes
- *****************************************************************
- */
-extern int map_smb2_to_linux_error(char *buf, bool log_err);
-extern int smb2_check_message(char *buf, unsigned int length);
-extern unsigned int smb2_calc_size(void *buf);
-extern char *smb2_get_data_area_len(int *off, int *len, struct smb2_hdr *hdr);
-extern __le16 *cifs_convert_path_to_utf16(const char *from,
-                                          struct cifs_sb_info *cifs_sb);
-
-extern int smb2_verify_signature(struct smb_rqst *, struct TCP_Server_Info *);
-extern int smb2_check_receive(struct mid_q_entry *mid,
-                              struct TCP_Server_Info *server, bool log_error);
-extern struct mid_q_entry *smb2_setup_request(struct cifs_ses *ses,
-                              struct smb_rqst *rqst);
-extern struct mid_q_entry *smb2_setup_async_request(
-                        struct TCP_Server_Info *server, struct smb_rqst *rqst);
-extern int smb2_calc_signature(struct smb_rqst *rqst,
-                                struct TCP_Server_Info *server);
-extern int smb3_calc_signature(struct smb_rqst *rqst,
-                                struct TCP_Server_Info *server);
-extern void smb2_echo_request(struct work_struct *work);
-extern __le32 smb2_get_lease_state(struct cifsInodeInfo *cinode);
-extern __u8 smb2_map_lease_to_oplock(__le32 lease_state);
-extern bool smb2_is_valid_oplock_break(char *buffer,
-                                       struct TCP_Server_Info *srv);
-
-extern void move_smb2_info_to_cifs(FILE_ALL_INFO *dst,
-                                   struct smb2_file_all_info *src);
-extern int smb2_query_path_info(const unsigned int xid, struct cifs_tcon *tcon,
-                                struct cifs_sb_info *cifs_sb,
-                                const char *full_path, FILE_ALL_INFO *data,
-                                bool *adjust_tz);
-extern int smb2_set_path_size(const unsigned int xid, struct cifs_tcon *tcon,
-                              const char *full_path, __u64 size,
-                              struct cifs_sb_info *cifs_sb, bool set_alloc);
-extern int smb2_set_file_info(struct inode *inode, const char *full_path,
-                              FILE_BASIC_INFO *buf, const unsigned int xid);
-extern int smb2_mkdir(const unsigned int xid, struct cifs_tcon *tcon,
-                      const char *name, struct cifs_sb_info *cifs_sb);
-extern void smb2_mkdir_setinfo(struct inode *inode, const char *full_path,
-                               struct cifs_sb_info *cifs_sb,
-                               struct cifs_tcon *tcon, const unsigned int xid);
-extern int smb2_rmdir(const unsigned int xid, struct cifs_tcon *tcon,
-                      const char *name, struct cifs_sb_info *cifs_sb);
-extern int smb2_unlink(const unsigned int xid, struct cifs_tcon *tcon,
-                       const char *name, struct cifs_sb_info *cifs_sb);
-extern int smb2_rename_path(const unsigned int xid, struct cifs_tcon *tcon,
-                            const char *from_name, const char *to_name,
-                            struct cifs_sb_info *cifs_sb);
-extern int smb2_create_hardlink(const unsigned int xid, struct cifs_tcon *tcon,
-                                const char *from_name, const char *to_name,
-                                struct cifs_sb_info *cifs_sb);
-
-extern int smb2_open_file(const unsigned int xid, struct cifs_tcon *tcon,
-                          const char *full_path, int disposition,
-                          int desired_access, int create_options,
-                          struct cifs_fid *fid, __u32 *oplock,
-                          FILE_ALL_INFO *buf, struct cifs_sb_info *cifs_sb);
-extern void smb2_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock);
-extern int smb2_unlock_range(struct cifsFileInfo *cfile,
-                             struct file_lock *flock, const unsigned int xid);
-extern int smb2_push_mandatory_locks(struct cifsFileInfo *cfile);
-
-/*
- * SMB2 Worker functions - most of protocol specific implementation details
- * are contained within these calls.
- */
-extern int SMB2_negotiate(const unsigned int xid, struct cifs_ses *ses);
-extern int SMB2_sess_setup(const unsigned int xid, struct cifs_ses *ses,
-                           const struct nls_table *nls_cp);
-extern int SMB2_logoff(const unsigned int xid, struct cifs_ses *ses);
-extern int SMB2_tcon(const unsigned int xid, struct cifs_ses *ses,
-                     const char *tree, struct cifs_tcon *tcon,
-                     const struct nls_table *);
-extern int SMB2_tdis(const unsigned int xid, struct cifs_tcon *tcon);
-extern int SMB2_open(const unsigned int xid, struct cifs_tcon *tcon,
-                     __le16 *path, u64 *persistent_fid, u64 *volatile_fid,
-                     __u32 desired_access, __u32 create_disposition,
-                     __u32 file_attributes, __u32 create_options,
-                     __u8 *oplock, struct smb2_file_all_info *buf);
-extern int SMB2_close(const unsigned int xid, struct cifs_tcon *tcon,
-                      u64 persistent_file_id, u64 volatile_file_id);
-extern int SMB2_flush(const unsigned int xid, struct cifs_tcon *tcon,
-                      u64 persistent_file_id, u64 volatile_file_id);
-extern int SMB2_query_info(const unsigned int xid, struct cifs_tcon *tcon,
-                           u64 persistent_file_id, u64 volatile_file_id,
-                           struct smb2_file_all_info *data);
-extern int SMB2_get_srv_num(const unsigned int xid, struct cifs_tcon *tcon,
-                            u64 persistent_fid, u64 volatile_fid,
-                            __le64 *uniqueid);
-extern int smb2_async_readv(struct cifs_readdata *rdata);
-extern int SMB2_read(const unsigned int xid, struct cifs_io_parms *io_parms,
-                     unsigned int *nbytes, char **buf, int *buf_type);
-extern int smb2_async_writev(struct cifs_writedata *wdata);
-extern int SMB2_write(const unsigned int xid, struct cifs_io_parms *io_parms,
-                      unsigned int *nbytes, struct kvec *iov, int n_vec);
-extern int SMB2_echo(struct TCP_Server_Info *server);
-extern int SMB2_query_directory(const unsigned int xid, struct cifs_tcon *tcon,
-                                u64 persistent_fid, u64 volatile_fid, int index,
-                                struct cifs_search_info *srch_inf);
-extern int SMB2_rename(const unsigned int xid, struct cifs_tcon *tcon,
-                       u64 persistent_fid, u64 volatile_fid,
-                       __le16 *target_file);
-extern int SMB2_set_hardlink(const unsigned int xid, struct cifs_tcon *tcon,
-                             u64 persistent_fid, u64 volatile_fid,
-                             __le16 *target_file);
-extern int SMB2_set_eof(const unsigned int xid, struct cifs_tcon *tcon,
-                        u64 persistent_fid, u64 volatile_fid, u32 pid,
-                        __le64 *eof);
-extern int SMB2_set_info(const unsigned int xid, struct cifs_tcon *tcon,
-                         u64 persistent_fid, u64 volatile_fid,
-                         FILE_BASIC_INFO *buf);
-extern int SMB2_oplock_break(const unsigned int xid, struct cifs_tcon *tcon,
-                             const u64 persistent_fid, const u64 volatile_fid,
-                             const __u8 oplock_level);
-extern int SMB2_QFS_info(const unsigned int xid, struct cifs_tcon *tcon,
-                         u64 persistent_file_id, u64 volatile_file_id,
-                         struct kstatfs *FSData);
-extern int SMB2_lock(const unsigned int xid, struct cifs_tcon *tcon,
-                     const __u64 persist_fid, const __u64 volatile_fid,
-                     const __u32 pid, const __u64 length, const __u64 offset,
-                     const __u32 lockFlags, const bool wait);
-extern int smb2_lockv(const unsigned int xid, struct cifs_tcon *tcon,
-                      const __u64 persist_fid, const __u64 volatile_fid,
-                      const __u32 pid, const __u32 num_lock,
-                      struct smb2_lock_element *buf);
-extern int SMB2_lease_break(const unsigned int xid, struct cifs_tcon *tcon,
-                            __u8 *lease_key, const __le32 lease_state);
-
-#endif                  /* _SMB2PROTO_H */
diff --git a/fs/cifs/smb2status.h b/fs/cifs/smb2status.h
deleted file mode 100644
index 3d5f62150de..00000000000
--- a/fs/cifs/smb2status.h
+++ /dev/null
@@ -1,1782 +0,0 @@
-/*
- *   fs/cifs/smb2status.h
- *
- *   SMB2 Status code (network error) definitions
- *   Definitions are from MS-ERREF
- *
- *   Copyright (c) International Business Machines  Corp., 2009,2011
- *   Author(s): Steve French (sfrench@us.ibm.com)
- *
- *   This library is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU Lesser General Public License as published
- *   by the Free Software Foundation; either version 2.1 of the License, or
- *   (at your option) any later version.
- *
- *   This library is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
- *   the GNU Lesser General Public License for more details.
- *
- *   You should have received a copy of the GNU Lesser General Public License
- *   along with this library; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-
-/*
- *  0 1 2 3 4 5 6 7 8 9 0 A B C D E F 0 1 2 3 4 5 6 7 8 9 A B C D E F
- *  SEV C N <-------Facility--------> <------Error Status Code------>
- *
- *  C is set if "customer defined" error, N bit is reserved and MBZ
- */
-
-#define STATUS_SEVERITY_SUCCESS __constant_cpu_to_le32(0x0000)
-#define STATUS_SEVERITY_INFORMATIONAL __constanst_cpu_to_le32(0x0001)
-#define STATUS_SEVERITY_WARNING __constanst_cpu_to_le32(0x0002)
-#define STATUS_SEVERITY_ERROR __constanst_cpu_to_le32(0x0003)
-
-struct ntstatus {
-        /* Facility is the high 12 bits of the following field */
-        __le32 Facility; /* low 2 bits Severity, next is Customer, then rsrvd */
-        __le32 Code;
-};
-
-#define STATUS_SUCCESS __constant_cpu_to_le32(0x00000000)
-#define STATUS_WAIT_0 __constant_cpu_to_le32(0x00000000)
-#define STATUS_WAIT_1 __constant_cpu_to_le32(0x00000001)
-#define STATUS_WAIT_2 __constant_cpu_to_le32(0x00000002)
-#define STATUS_WAIT_3 __constant_cpu_to_le32(0x00000003)
-#define STATUS_WAIT_63 __constant_cpu_to_le32(0x0000003F)
-#define STATUS_ABANDONED __constant_cpu_to_le32(0x00000080)
-#define STATUS_ABANDONED_WAIT_0 __constant_cpu_to_le32(0x00000080)
-#define STATUS_ABANDONED_WAIT_63 __constant_cpu_to_le32(0x000000BF)
-#define STATUS_USER_APC __constant_cpu_to_le32(0x000000C0)
-#define STATUS_KERNEL_APC __constant_cpu_to_le32(0x00000100)
-#define STATUS_ALERTED __constant_cpu_to_le32(0x00000101)
-#define STATUS_TIMEOUT __constant_cpu_to_le32(0x00000102)
-#define STATUS_PENDING __constant_cpu_to_le32(0x00000103)
-#define STATUS_REPARSE __constant_cpu_to_le32(0x00000104)
-#define STATUS_MORE_ENTRIES __constant_cpu_to_le32(0x00000105)
-#define STATUS_NOT_ALL_ASSIGNED __constant_cpu_to_le32(0x00000106)
-#define STATUS_SOME_NOT_MAPPED __constant_cpu_to_le32(0x00000107)
-#define STATUS_OPLOCK_BREAK_IN_PROGRESS __constant_cpu_to_le32(0x00000108)
-#define STATUS_VOLUME_MOUNTED __constant_cpu_to_le32(0x00000109)
-#define STATUS_RXACT_COMMITTED __constant_cpu_to_le32(0x0000010A)
-#define STATUS_NOTIFY_CLEANUP __constant_cpu_to_le32(0x0000010B)
-#define STATUS_NOTIFY_ENUM_DIR __constant_cpu_to_le32(0x0000010C)
-#define STATUS_NO_QUOTAS_FOR_ACCOUNT __constant_cpu_to_le32(0x0000010D)
-#define STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED __constant_cpu_to_le32(0x0000010E)
-#define STATUS_PAGE_FAULT_TRANSITION __constant_cpu_to_le32(0x00000110)
-#define STATUS_PAGE_FAULT_DEMAND_ZERO __constant_cpu_to_le32(0x00000111)
-#define STATUS_PAGE_FAULT_COPY_ON_WRITE __constant_cpu_to_le32(0x00000112)
-#define STATUS_PAGE_FAULT_GUARD_PAGE __constant_cpu_to_le32(0x00000113)
-#define STATUS_PAGE_FAULT_PAGING_FILE __constant_cpu_to_le32(0x00000114)
-#define STATUS_CACHE_PAGE_LOCKED __constant_cpu_to_le32(0x00000115)
-#define STATUS_CRASH_DUMP __constant_cpu_to_le32(0x00000116)
-#define STATUS_BUFFER_ALL_ZEROS __constant_cpu_to_le32(0x00000117)
-#define STATUS_REPARSE_OBJECT __constant_cpu_to_le32(0x00000118)
-#define STATUS_RESOURCE_REQUIREMENTS_CHANGED __constant_cpu_to_le32(0x00000119)
-#define STATUS_TRANSLATION_COMPLETE __constant_cpu_to_le32(0x00000120)
-#define STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY __constant_cpu_to_le32(0x00000121)
-#define STATUS_NOTHING_TO_TERMINATE __constant_cpu_to_le32(0x00000122)
-#define STATUS_PROCESS_NOT_IN_JOB __constant_cpu_to_le32(0x00000123)
-#define STATUS_PROCESS_IN_JOB __constant_cpu_to_le32(0x00000124)
-#define STATUS_VOLSNAP_HIBERNATE_READY __constant_cpu_to_le32(0x00000125)
-#define STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY __constant_cpu_to_le32(0x00000126)
-#define STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED __constant_cpu_to_le32(0x00000127)
-#define STATUS_INTERRUPT_STILL_CONNECTED __constant_cpu_to_le32(0x00000128)
-#define STATUS_PROCESS_CLONED __constant_cpu_to_le32(0x00000129)
-#define STATUS_FILE_LOCKED_WITH_ONLY_READERS __constant_cpu_to_le32(0x0000012A)
-#define STATUS_FILE_LOCKED_WITH_WRITERS __constant_cpu_to_le32(0x0000012B)
-#define STATUS_RESOURCEMANAGER_READ_ONLY __constant_cpu_to_le32(0x00000202)
-#define STATUS_WAIT_FOR_OPLOCK __constant_cpu_to_le32(0x00000367)
-#define DBG_EXCEPTION_HANDLED __constant_cpu_to_le32(0x00010001)
-#define DBG_CONTINUE __constant_cpu_to_le32(0x00010002)
-#define STATUS_FLT_IO_COMPLETE __constant_cpu_to_le32(0x001C0001)
-#define STATUS_OBJECT_NAME_EXISTS __constant_cpu_to_le32(0x40000000)
-#define STATUS_THREAD_WAS_SUSPENDED __constant_cpu_to_le32(0x40000001)
-#define STATUS_WORKING_SET_LIMIT_RANGE __constant_cpu_to_le32(0x40000002)
-#define STATUS_IMAGE_NOT_AT_BASE __constant_cpu_to_le32(0x40000003)
-#define STATUS_RXACT_STATE_CREATED __constant_cpu_to_le32(0x40000004)
-#define STATUS_SEGMENT_NOTIFICATION __constant_cpu_to_le32(0x40000005)
-#define STATUS_LOCAL_USER_SESSION_KEY __constant_cpu_to_le32(0x40000006)
-#define STATUS_BAD_CURRENT_DIRECTORY __constant_cpu_to_le32(0x40000007)
-#define STATUS_SERIAL_MORE_WRITES __constant_cpu_to_le32(0x40000008)
-#define STATUS_REGISTRY_RECOVERED __constant_cpu_to_le32(0x40000009)
-#define STATUS_FT_READ_RECOVERY_FROM_BACKUP __constant_cpu_to_le32(0x4000000A)
-#define STATUS_FT_WRITE_RECOVERY __constant_cpu_to_le32(0x4000000B)
-#define STATUS_SERIAL_COUNTER_TIMEOUT __constant_cpu_to_le32(0x4000000C)
-#define STATUS_NULL_LM_PASSWORD __constant_cpu_to_le32(0x4000000D)
-#define STATUS_IMAGE_MACHINE_TYPE_MISMATCH __constant_cpu_to_le32(0x4000000E)
-#define STATUS_RECEIVE_PARTIAL __constant_cpu_to_le32(0x4000000F)
-#define STATUS_RECEIVE_EXPEDITED __constant_cpu_to_le32(0x40000010)
-#define STATUS_RECEIVE_PARTIAL_EXPEDITED __constant_cpu_to_le32(0x40000011)
-#define STATUS_EVENT_DONE __constant_cpu_to_le32(0x40000012)
-#define STATUS_EVENT_PENDING __constant_cpu_to_le32(0x40000013)
-#define STATUS_CHECKING_FILE_SYSTEM __constant_cpu_to_le32(0x40000014)
-#define STATUS_FATAL_APP_EXIT __constant_cpu_to_le32(0x40000015)
-#define STATUS_PREDEFINED_HANDLE __constant_cpu_to_le32(0x40000016)
-#define STATUS_WAS_UNLOCKED __constant_cpu_to_le32(0x40000017)
-#define STATUS_SERVICE_NOTIFICATION __constant_cpu_to_le32(0x40000018)
-#define STATUS_WAS_LOCKED __constant_cpu_to_le32(0x40000019)
-#define STATUS_LOG_HARD_ERROR __constant_cpu_to_le32(0x4000001A)
-#define STATUS_ALREADY_WIN32 __constant_cpu_to_le32(0x4000001B)
-#define STATUS_WX86_UNSIMULATE __constant_cpu_to_le32(0x4000001C)
-#define STATUS_WX86_CONTINUE __constant_cpu_to_le32(0x4000001D)
-#define STATUS_WX86_SINGLE_STEP __constant_cpu_to_le32(0x4000001E)
-#define STATUS_WX86_BREAKPOINT __constant_cpu_to_le32(0x4000001F)
-#define STATUS_WX86_EXCEPTION_CONTINUE __constant_cpu_to_le32(0x40000020)
-#define STATUS_WX86_EXCEPTION_LASTCHANCE __constant_cpu_to_le32(0x40000021)
-#define STATUS_WX86_EXCEPTION_CHAIN __constant_cpu_to_le32(0x40000022)
-#define STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE __constant_cpu_to_le32(0x40000023)
-#define STATUS_NO_YIELD_PERFORMED __constant_cpu_to_le32(0x40000024)
-#define STATUS_TIMER_RESUME_IGNORED __constant_cpu_to_le32(0x40000025)
-#define STATUS_ARBITRATION_UNHANDLED __constant_cpu_to_le32(0x40000026)
-#define STATUS_CARDBUS_NOT_SUPPORTED __constant_cpu_to_le32(0x40000027)
-#define STATUS_WX86_CREATEWX86TIB __constant_cpu_to_le32(0x40000028)
-#define STATUS_MP_PROCESSOR_MISMATCH __constant_cpu_to_le32(0x40000029)
-#define STATUS_HIBERNATED __constant_cpu_to_le32(0x4000002A)
-#define STATUS_RESUME_HIBERNATION __constant_cpu_to_le32(0x4000002B)
-#define STATUS_FIRMWARE_UPDATED __constant_cpu_to_le32(0x4000002C)
-#define STATUS_DRIVERS_LEAKING_LOCKED_PAGES __constant_cpu_to_le32(0x4000002D)
-#define STATUS_MESSAGE_RETRIEVED __constant_cpu_to_le32(0x4000002E)
-#define STATUS_SYSTEM_POWERSTATE_TRANSITION __constant_cpu_to_le32(0x4000002F)
-#define STATUS_ALPC_CHECK_COMPLETION_LIST __constant_cpu_to_le32(0x40000030)
-#define STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION __constant_cpu_to_le32(0x40000031)
-#define STATUS_ACCESS_AUDIT_BY_POLICY __constant_cpu_to_le32(0x40000032)
-#define STATUS_ABANDON_HIBERFILE __constant_cpu_to_le32(0x40000033)
-#define STATUS_BIZRULES_NOT_ENABLED __constant_cpu_to_le32(0x40000034)
-#define STATUS_WAKE_SYSTEM __constant_cpu_to_le32(0x40000294)
-#define STATUS_DS_SHUTTING_DOWN __constant_cpu_to_le32(0x40000370)
-#define DBG_REPLY_LATER __constant_cpu_to_le32(0x40010001)
-#define DBG_UNABLE_TO_PROVIDE_HANDLE __constant_cpu_to_le32(0x40010002)
-#define DBG_TERMINATE_THREAD __constant_cpu_to_le32(0x40010003)
-#define DBG_TERMINATE_PROCESS __constant_cpu_to_le32(0x40010004)
-#define DBG_CONTROL_C __constant_cpu_to_le32(0x40010005)
-#define DBG_PRINTEXCEPTION_C __constant_cpu_to_le32(0x40010006)
-#define DBG_RIPEXCEPTION __constant_cpu_to_le32(0x40010007)
-#define DBG_CONTROL_BREAK __constant_cpu_to_le32(0x40010008)
-#define DBG_COMMAND_EXCEPTION __constant_cpu_to_le32(0x40010009)
-#define RPC_NT_UUID_LOCAL_ONLY __constant_cpu_to_le32(0x40020056)
-#define RPC_NT_SEND_INCOMPLETE __constant_cpu_to_le32(0x400200AF)
-#define STATUS_CTX_CDM_CONNECT __constant_cpu_to_le32(0x400A0004)
-#define STATUS_CTX_CDM_DISCONNECT __constant_cpu_to_le32(0x400A0005)
-#define STATUS_SXS_RELEASE_ACTIVATION_CONTEXT __constant_cpu_to_le32(0x4015000D)
-#define STATUS_RECOVERY_NOT_NEEDED __constant_cpu_to_le32(0x40190034)
-#define STATUS_RM_ALREADY_STARTED __constant_cpu_to_le32(0x40190035)
-#define STATUS_LOG_NO_RESTART __constant_cpu_to_le32(0x401A000C)
-#define STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST __constant_cpu_to_le32(0x401B00EC)
-#define STATUS_GRAPHICS_PARTIAL_DATA_POPULATED __constant_cpu_to_le32(0x401E000A)
-#define STATUS_GRAPHICS_DRIVER_MISMATCH __constant_cpu_to_le32(0x401E0117)
-#define STATUS_GRAPHICS_MODE_NOT_PINNED __constant_cpu_to_le32(0x401E0307)
-#define STATUS_GRAPHICS_NO_PREFERRED_MODE __constant_cpu_to_le32(0x401E031E)
-#define STATUS_GRAPHICS_DATASET_IS_EMPTY __constant_cpu_to_le32(0x401E034B)
-#define STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET __constant_cpu_to_le32(0x401E034C)
-#define STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED __constant_cpu_to_le32(0x401E0351)
-#define STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS __constant_cpu_to_le32(0x401E042F)
-#define STATUS_GRAPHICS_LEADLINK_START_DEFERRED __constant_cpu_to_le32(0x401E0437)
-#define STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY __constant_cpu_to_le32(0x401E0439)
-#define STATUS_GRAPHICS_START_DEFERRED __constant_cpu_to_le32(0x401E043A)
-#define STATUS_NDIS_INDICATION_REQUIRED __constant_cpu_to_le32(0x40230001)
-#define STATUS_GUARD_PAGE_VIOLATION __constant_cpu_to_le32(0x80000001)
-#define STATUS_DATATYPE_MISALIGNMENT __constant_cpu_to_le32(0x80000002)
-#define STATUS_BREAKPOINT __constant_cpu_to_le32(0x80000003)
-#define STATUS_SINGLE_STEP __constant_cpu_to_le32(0x80000004)
-#define STATUS_BUFFER_OVERFLOW __constant_cpu_to_le32(0x80000005)
-#define STATUS_NO_MORE_FILES __constant_cpu_to_le32(0x80000006)
-#define STATUS_WAKE_SYSTEM_DEBUGGER __constant_cpu_to_le32(0x80000007)
-#define STATUS_HANDLES_CLOSED __constant_cpu_to_le32(0x8000000A)
-#define STATUS_NO_INHERITANCE __constant_cpu_to_le32(0x8000000B)
-#define STATUS_GUID_SUBSTITUTION_MADE __constant_cpu_to_le32(0x8000000C)
-#define STATUS_PARTIAL_COPY __constant_cpu_to_le32(0x8000000D)
-#define STATUS_DEVICE_PAPER_EMPTY __constant_cpu_to_le32(0x8000000E)
-#define STATUS_DEVICE_POWERED_OFF __constant_cpu_to_le32(0x8000000F)
-#define STATUS_DEVICE_OFF_LINE __constant_cpu_to_le32(0x80000010)
-#define STATUS_DEVICE_BUSY __constant_cpu_to_le32(0x80000011)
-#define STATUS_NO_MORE_EAS __constant_cpu_to_le32(0x80000012)
-#define STATUS_INVALID_EA_NAME __constant_cpu_to_le32(0x80000013)
-#define STATUS_EA_LIST_INCONSISTENT __constant_cpu_to_le32(0x80000014)
-#define STATUS_INVALID_EA_FLAG __constant_cpu_to_le32(0x80000015)
-#define STATUS_VERIFY_REQUIRED __constant_cpu_to_le32(0x80000016)
-#define STATUS_EXTRANEOUS_INFORMATION __constant_cpu_to_le32(0x80000017)
-#define STATUS_RXACT_COMMIT_NECESSARY __constant_cpu_to_le32(0x80000018)
-#define STATUS_NO_MORE_ENTRIES __constant_cpu_to_le32(0x8000001A)
-#define STATUS_FILEMARK_DETECTED __constant_cpu_to_le32(0x8000001B)
-#define STATUS_MEDIA_CHANGED __constant_cpu_to_le32(0x8000001C)
-#define STATUS_BUS_RESET __constant_cpu_to_le32(0x8000001D)
-#define STATUS_END_OF_MEDIA __constant_cpu_to_le32(0x8000001E)
-#define STATUS_BEGINNING_OF_MEDIA __constant_cpu_to_le32(0x8000001F)
-#define STATUS_MEDIA_CHECK __constant_cpu_to_le32(0x80000020)
-#define STATUS_SETMARK_DETECTED __constant_cpu_to_le32(0x80000021)
-#define STATUS_NO_DATA_DETECTED __constant_cpu_to_le32(0x80000022)
-#define STATUS_REDIRECTOR_HAS_OPEN_HANDLES __constant_cpu_to_le32(0x80000023)
-#define STATUS_SERVER_HAS_OPEN_HANDLES __constant_cpu_to_le32(0x80000024)
-#define STATUS_ALREADY_DISCONNECTED __constant_cpu_to_le32(0x80000025)
-#define STATUS_LONGJUMP __constant_cpu_to_le32(0x80000026)
-#define STATUS_CLEANER_CARTRIDGE_INSTALLED __constant_cpu_to_le32(0x80000027)
-#define STATUS_PLUGPLAY_QUERY_VETOED __constant_cpu_to_le32(0x80000028)
-#define STATUS_UNWIND_CONSOLIDATE __constant_cpu_to_le32(0x80000029)
-#define STATUS_REGISTRY_HIVE_RECOVERED __constant_cpu_to_le32(0x8000002A)
-#define STATUS_DLL_MIGHT_BE_INSECURE __constant_cpu_to_le32(0x8000002B)
-#define STATUS_DLL_MIGHT_BE_INCOMPATIBLE __constant_cpu_to_le32(0x8000002C)
-#define STATUS_STOPPED_ON_SYMLINK __constant_cpu_to_le32(0x8000002D)
-#define STATUS_DEVICE_REQUIRES_CLEANING __constant_cpu_to_le32(0x80000288)
-#define STATUS_DEVICE_DOOR_OPEN __constant_cpu_to_le32(0x80000289)
-#define STATUS_DATA_LOST_REPAIR __constant_cpu_to_le32(0x80000803)
-#define DBG_EXCEPTION_NOT_HANDLED __constant_cpu_to_le32(0x80010001)
-#define STATUS_CLUSTER_NODE_ALREADY_UP __constant_cpu_to_le32(0x80130001)
-#define STATUS_CLUSTER_NODE_ALREADY_DOWN __constant_cpu_to_le32(0x80130002)
-#define STATUS_CLUSTER_NETWORK_ALREADY_ONLINE __constant_cpu_to_le32(0x80130003)
-#define STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE __constant_cpu_to_le32(0x80130004)
-#define STATUS_CLUSTER_NODE_ALREADY_MEMBER __constant_cpu_to_le32(0x80130005)
-#define STATUS_COULD_NOT_RESIZE_LOG __constant_cpu_to_le32(0x80190009)
-#define STATUS_NO_TXF_METADATA __constant_cpu_to_le32(0x80190029)
-#define STATUS_CANT_RECOVER_WITH_HANDLE_OPEN __constant_cpu_to_le32(0x80190031)
-#define STATUS_TXF_METADATA_ALREADY_PRESENT __constant_cpu_to_le32(0x80190041)
-#define STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET __constant_cpu_to_le32(0x80190042)
-#define STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED __constant_cpu_to_le32(0x801B00EB)
-#define STATUS_FLT_BUFFER_TOO_SMALL __constant_cpu_to_le32(0x801C0001)
-#define STATUS_FVE_PARTIAL_METADATA __constant_cpu_to_le32(0x80210001)
-#define STATUS_UNSUCCESSFUL __constant_cpu_to_le32(0xC0000001)
-#define STATUS_NOT_IMPLEMENTED __constant_cpu_to_le32(0xC0000002)
-#define STATUS_INVALID_INFO_CLASS __constant_cpu_to_le32(0xC0000003)
-#define STATUS_INFO_LENGTH_MISMATCH __constant_cpu_to_le32(0xC0000004)
-#define STATUS_ACCESS_VIOLATION __constant_cpu_to_le32(0xC0000005)
-#define STATUS_IN_PAGE_ERROR __constant_cpu_to_le32(0xC0000006)
-#define STATUS_PAGEFILE_QUOTA __constant_cpu_to_le32(0xC0000007)
-#define STATUS_INVALID_HANDLE __constant_cpu_to_le32(0xC0000008)
-#define STATUS_BAD_INITIAL_STACK __constant_cpu_to_le32(0xC0000009)
-#define STATUS_BAD_INITIAL_PC __constant_cpu_to_le32(0xC000000A)
-#define STATUS_INVALID_CID __constant_cpu_to_le32(0xC000000B)
-#define STATUS_TIMER_NOT_CANCELED __constant_cpu_to_le32(0xC000000C)
-#define STATUS_INVALID_PARAMETER __constant_cpu_to_le32(0xC000000D)
-#define STATUS_NO_SUCH_DEVICE __constant_cpu_to_le32(0xC000000E)
-#define STATUS_NO_SUCH_FILE __constant_cpu_to_le32(0xC000000F)
-#define STATUS_INVALID_DEVICE_REQUEST __constant_cpu_to_le32(0xC0000010)
-#define STATUS_END_OF_FILE __constant_cpu_to_le32(0xC0000011)
-#define STATUS_WRONG_VOLUME __constant_cpu_to_le32(0xC0000012)
-#define STATUS_NO_MEDIA_IN_DEVICE __constant_cpu_to_le32(0xC0000013)
-#define STATUS_UNRECOGNIZED_MEDIA __constant_cpu_to_le32(0xC0000014)
-#define STATUS_NONEXISTENT_SECTOR __constant_cpu_to_le32(0xC0000015)
-#define STATUS_MORE_PROCESSING_REQUIRED __constant_cpu_to_le32(0xC0000016)
-#define STATUS_NO_MEMORY __constant_cpu_to_le32(0xC0000017)
-#define STATUS_CONFLICTING_ADDRESSES __constant_cpu_to_le32(0xC0000018)
-#define STATUS_NOT_MAPPED_VIEW __constant_cpu_to_le32(0xC0000019)
-#define STATUS_UNABLE_TO_FREE_VM __constant_cpu_to_le32(0xC000001A)
-#define STATUS_UNABLE_TO_DELETE_SECTION __constant_cpu_to_le32(0xC000001B)
-#define STATUS_INVALID_SYSTEM_SERVICE __constant_cpu_to_le32(0xC000001C)
-#define STATUS_ILLEGAL_INSTRUCTION __constant_cpu_to_le32(0xC000001D)
-#define STATUS_INVALID_LOCK_SEQUENCE __constant_cpu_to_le32(0xC000001E)
-#define STATUS_INVALID_VIEW_SIZE __constant_cpu_to_le32(0xC000001F)
-#define STATUS_INVALID_FILE_FOR_SECTION __constant_cpu_to_le32(0xC0000020)
-#define STATUS_ALREADY_COMMITTED __constant_cpu_to_le32(0xC0000021)
-#define STATUS_ACCESS_DENIED __constant_cpu_to_le32(0xC0000022)
-#define STATUS_BUFFER_TOO_SMALL __constant_cpu_to_le32(0xC0000023)
-#define STATUS_OBJECT_TYPE_MISMATCH __constant_cpu_to_le32(0xC0000024)
-#define STATUS_NONCONTINUABLE_EXCEPTION __constant_cpu_to_le32(0xC0000025)
-#define STATUS_INVALID_DISPOSITION __constant_cpu_to_le32(0xC0000026)
-#define STATUS_UNWIND __constant_cpu_to_le32(0xC0000027)
-#define STATUS_BAD_STACK __constant_cpu_to_le32(0xC0000028)
-#define STATUS_INVALID_UNWIND_TARGET __constant_cpu_to_le32(0xC0000029)
-#define STATUS_NOT_LOCKED __constant_cpu_to_le32(0xC000002A)
-#define STATUS_PARITY_ERROR __constant_cpu_to_le32(0xC000002B)
-#define STATUS_UNABLE_TO_DECOMMIT_VM __constant_cpu_to_le32(0xC000002C)
-#define STATUS_NOT_COMMITTED __constant_cpu_to_le32(0xC000002D)
-#define STATUS_INVALID_PORT_ATTRIBUTES __constant_cpu_to_le32(0xC000002E)
-#define STATUS_PORT_MESSAGE_TOO_LONG __constant_cpu_to_le32(0xC000002F)
-#define STATUS_INVALID_PARAMETER_MIX __constant_cpu_to_le32(0xC0000030)
-#define STATUS_INVALID_QUOTA_LOWER __constant_cpu_to_le32(0xC0000031)
-#define STATUS_DISK_CORRUPT_ERROR __constant_cpu_to_le32(0xC0000032)
-#define STATUS_OBJECT_NAME_INVALID __constant_cpu_to_le32(0xC0000033)
-#define STATUS_OBJECT_NAME_NOT_FOUND __constant_cpu_to_le32(0xC0000034)
-#define STATUS_OBJECT_NAME_COLLISION __constant_cpu_to_le32(0xC0000035)
-#define STATUS_PORT_DISCONNECTED __constant_cpu_to_le32(0xC0000037)
-#define STATUS_DEVICE_ALREADY_ATTACHED __constant_cpu_to_le32(0xC0000038)
-#define STATUS_OBJECT_PATH_INVALID __constant_cpu_to_le32(0xC0000039)
-#define STATUS_OBJECT_PATH_NOT_FOUND __constant_cpu_to_le32(0xC000003A)
-#define STATUS_OBJECT_PATH_SYNTAX_BAD __constant_cpu_to_le32(0xC000003B)
-#define STATUS_DATA_OVERRUN __constant_cpu_to_le32(0xC000003C)
-#define STATUS_DATA_LATE_ERROR __constant_cpu_to_le32(0xC000003D)
-#define STATUS_DATA_ERROR __constant_cpu_to_le32(0xC000003E)
-#define STATUS_CRC_ERROR __constant_cpu_to_le32(0xC000003F)
-#define STATUS_SECTION_TOO_BIG __constant_cpu_to_le32(0xC0000040)
-#define STATUS_PORT_CONNECTION_REFUSED __constant_cpu_to_le32(0xC0000041)
-#define STATUS_INVALID_PORT_HANDLE __constant_cpu_to_le32(0xC0000042)
-#define STATUS_SHARING_VIOLATION __constant_cpu_to_le32(0xC0000043)
-#define STATUS_QUOTA_EXCEEDED __constant_cpu_to_le32(0xC0000044)
-#define STATUS_INVALID_PAGE_PROTECTION __constant_cpu_to_le32(0xC0000045)
-#define STATUS_MUTANT_NOT_OWNED __constant_cpu_to_le32(0xC0000046)
-#define STATUS_SEMAPHORE_LIMIT_EXCEEDED __constant_cpu_to_le32(0xC0000047)
-#define STATUS_PORT_ALREADY_SET __constant_cpu_to_le32(0xC0000048)
-#define STATUS_SECTION_NOT_IMAGE __constant_cpu_to_le32(0xC0000049)
-#define STATUS_SUSPEND_COUNT_EXCEEDED __constant_cpu_to_le32(0xC000004A)
-#define STATUS_THREAD_IS_TERMINATING __constant_cpu_to_le32(0xC000004B)
-#define STATUS_BAD_WORKING_SET_LIMIT __constant_cpu_to_le32(0xC000004C)
-#define STATUS_INCOMPATIBLE_FILE_MAP __constant_cpu_to_le32(0xC000004D)
-#define STATUS_SECTION_PROTECTION __constant_cpu_to_le32(0xC000004E)
-#define STATUS_EAS_NOT_SUPPORTED __constant_cpu_to_le32(0xC000004F)
-#define STATUS_EA_TOO_LARGE __constant_cpu_to_le32(0xC0000050)
-#define STATUS_NONEXISTENT_EA_ENTRY __constant_cpu_to_le32(0xC0000051)
-#define STATUS_NO_EAS_ON_FILE __constant_cpu_to_le32(0xC0000052)
-#define STATUS_EA_CORRUPT_ERROR __constant_cpu_to_le32(0xC0000053)
-#define STATUS_FILE_LOCK_CONFLICT __constant_cpu_to_le32(0xC0000054)
-#define STATUS_LOCK_NOT_GRANTED __constant_cpu_to_le32(0xC0000055)
-#define STATUS_DELETE_PENDING __constant_cpu_to_le32(0xC0000056)
-#define STATUS_CTL_FILE_NOT_SUPPORTED __constant_cpu_to_le32(0xC0000057)
-#define STATUS_UNKNOWN_REVISION __constant_cpu_to_le32(0xC0000058)
-#define STATUS_REVISION_MISMATCH __constant_cpu_to_le32(0xC0000059)
-#define STATUS_INVALID_OWNER __constant_cpu_to_le32(0xC000005A)
-#define STATUS_INVALID_PRIMARY_GROUP __constant_cpu_to_le32(0xC000005B)
-#define STATUS_NO_IMPERSONATION_TOKEN __constant_cpu_to_le32(0xC000005C)
-#define STATUS_CANT_DISABLE_MANDATORY __constant_cpu_to_le32(0xC000005D)
-#define STATUS_NO_LOGON_SERVERS __constant_cpu_to_le32(0xC000005E)
-#define STATUS_NO_SUCH_LOGON_SESSION __constant_cpu_to_le32(0xC000005F)
-#define STATUS_NO_SUCH_PRIVILEGE __constant_cpu_to_le32(0xC0000060)
-#define STATUS_PRIVILEGE_NOT_HELD __constant_cpu_to_le32(0xC0000061)
-#define STATUS_INVALID_ACCOUNT_NAME __constant_cpu_to_le32(0xC0000062)
-#define STATUS_USER_EXISTS __constant_cpu_to_le32(0xC0000063)
-#define STATUS_NO_SUCH_USER __constant_cpu_to_le32(0xC0000064)
-#define STATUS_GROUP_EXISTS __constant_cpu_to_le32(0xC0000065)
-#define STATUS_NO_SUCH_GROUP __constant_cpu_to_le32(0xC0000066)
-#define STATUS_MEMBER_IN_GROUP __constant_cpu_to_le32(0xC0000067)
-#define STATUS_MEMBER_NOT_IN_GROUP __constant_cpu_to_le32(0xC0000068)
-#define STATUS_LAST_ADMIN __constant_cpu_to_le32(0xC0000069)
-#define STATUS_WRONG_PASSWORD __constant_cpu_to_le32(0xC000006A)
-#define STATUS_ILL_FORMED_PASSWORD __constant_cpu_to_le32(0xC000006B)
-#define STATUS_PASSWORD_RESTRICTION __constant_cpu_to_le32(0xC000006C)
-#define STATUS_LOGON_FAILURE __constant_cpu_to_le32(0xC000006D)
-#define STATUS_ACCOUNT_RESTRICTION __constant_cpu_to_le32(0xC000006E)
-#define STATUS_INVALID_LOGON_HOURS __constant_cpu_to_le32(0xC000006F)
-#define STATUS_INVALID_WORKSTATION __constant_cpu_to_le32(0xC0000070)
-#define STATUS_PASSWORD_EXPIRED __constant_cpu_to_le32(0xC0000071)
-#define STATUS_ACCOUNT_DISABLED __constant_cpu_to_le32(0xC0000072)
-#define STATUS_NONE_MAPPED __constant_cpu_to_le32(0xC0000073)
-#define STATUS_TOO_MANY_LUIDS_REQUESTED __constant_cpu_to_le32(0xC0000074)
-#define STATUS_LUIDS_EXHAUSTED __constant_cpu_to_le32(0xC0000075)
-#define STATUS_INVALID_SUB_AUTHORITY __constant_cpu_to_le32(0xC0000076)
-#define STATUS_INVALID_ACL __constant_cpu_to_le32(0xC0000077)
-#define STATUS_INVALID_SID __constant_cpu_to_le32(0xC0000078)
-#define STATUS_INVALID_SECURITY_DESCR __constant_cpu_to_le32(0xC0000079)
-#define STATUS_PROCEDURE_NOT_FOUND __constant_cpu_to_le32(0xC000007A)
-#define STATUS_INVALID_IMAGE_FORMAT __constant_cpu_to_le32(0xC000007B)
-#define STATUS_NO_TOKEN __constant_cpu_to_le32(0xC000007C)
-#define STATUS_BAD_INHERITANCE_ACL __constant_cpu_to_le32(0xC000007D)
-#define STATUS_RANGE_NOT_LOCKED __constant_cpu_to_le32(0xC000007E)
-#define STATUS_DISK_FULL __constant_cpu_to_le32(0xC000007F)
-#define STATUS_SERVER_DISABLED __constant_cpu_to_le32(0xC0000080)
-#define STATUS_SERVER_NOT_DISABLED __constant_cpu_to_le32(0xC0000081)
-#define STATUS_TOO_MANY_GUIDS_REQUESTED __constant_cpu_to_le32(0xC0000082)
-#define STATUS_GUIDS_EXHAUSTED __constant_cpu_to_le32(0xC0000083)
-#define STATUS_INVALID_ID_AUTHORITY __constant_cpu_to_le32(0xC0000084)
-#define STATUS_AGENTS_EXHAUSTED __constant_cpu_to_le32(0xC0000085)
-#define STATUS_INVALID_VOLUME_LABEL __constant_cpu_to_le32(0xC0000086)
-#define STATUS_SECTION_NOT_EXTENDED __constant_cpu_to_le32(0xC0000087)
-#define STATUS_NOT_MAPPED_DATA __constant_cpu_to_le32(0xC0000088)
-#define STATUS_RESOURCE_DATA_NOT_FOUND __constant_cpu_to_le32(0xC0000089)
-#define STATUS_RESOURCE_TYPE_NOT_FOUND __constant_cpu_to_le32(0xC000008A)
-#define STATUS_RESOURCE_NAME_NOT_FOUND __constant_cpu_to_le32(0xC000008B)
-#define STATUS_ARRAY_BOUNDS_EXCEEDED __constant_cpu_to_le32(0xC000008C)
-#define STATUS_FLOAT_DENORMAL_OPERAND __constant_cpu_to_le32(0xC000008D)
-#define STATUS_FLOAT_DIVIDE_BY_ZERO __constant_cpu_to_le32(0xC000008E)
-#define STATUS_FLOAT_INEXACT_RESULT __constant_cpu_to_le32(0xC000008F)
-#define STATUS_FLOAT_INVALID_OPERATION __constant_cpu_to_le32(0xC0000090)
-#define STATUS_FLOAT_OVERFLOW __constant_cpu_to_le32(0xC0000091)
-#define STATUS_FLOAT_STACK_CHECK __constant_cpu_to_le32(0xC0000092)
-#define STATUS_FLOAT_UNDERFLOW __constant_cpu_to_le32(0xC0000093)
-#define STATUS_INTEGER_DIVIDE_BY_ZERO __constant_cpu_to_le32(0xC0000094)
-#define STATUS_INTEGER_OVERFLOW __constant_cpu_to_le32(0xC0000095)
-#define STATUS_PRIVILEGED_INSTRUCTION __constant_cpu_to_le32(0xC0000096)
-#define STATUS_TOO_MANY_PAGING_FILES __constant_cpu_to_le32(0xC0000097)
-#define STATUS_FILE_INVALID __constant_cpu_to_le32(0xC0000098)
-#define STATUS_ALLOTTED_SPACE_EXCEEDED __constant_cpu_to_le32(0xC0000099)
-#define STATUS_INSUFFICIENT_RESOURCES __constant_cpu_to_le32(0xC000009A)
-#define STATUS_DFS_EXIT_PATH_FOUND __constant_cpu_to_le32(0xC000009B)
-#define STATUS_DEVICE_DATA_ERROR __constant_cpu_to_le32(0xC000009C)
-#define STATUS_DEVICE_NOT_CONNECTED __constant_cpu_to_le32(0xC000009D)
-#define STATUS_DEVICE_POWER_FAILURE __constant_cpu_to_le32(0xC000009E)
-#define STATUS_FREE_VM_NOT_AT_BASE __constant_cpu_to_le32(0xC000009F)
-#define STATUS_MEMORY_NOT_ALLOCATED __constant_cpu_to_le32(0xC00000A0)
-#define STATUS_WORKING_SET_QUOTA __constant_cpu_to_le32(0xC00000A1)
-#define STATUS_MEDIA_WRITE_PROTECTED __constant_cpu_to_le32(0xC00000A2)
-#define STATUS_DEVICE_NOT_READY __constant_cpu_to_le32(0xC00000A3)
-#define STATUS_INVALID_GROUP_ATTRIBUTES __constant_cpu_to_le32(0xC00000A4)
-#define STATUS_BAD_IMPERSONATION_LEVEL __constant_cpu_to_le32(0xC00000A5)
-#define STATUS_CANT_OPEN_ANONYMOUS __constant_cpu_to_le32(0xC00000A6)
-#define STATUS_BAD_VALIDATION_CLASS __constant_cpu_to_le32(0xC00000A7)
-#define STATUS_BAD_TOKEN_TYPE __constant_cpu_to_le32(0xC00000A8)
-#define STATUS_BAD_MASTER_BOOT_RECORD __constant_cpu_to_le32(0xC00000A9)
-#define STATUS_INSTRUCTION_MISALIGNMENT __constant_cpu_to_le32(0xC00000AA)
-#define STATUS_INSTANCE_NOT_AVAILABLE __constant_cpu_to_le32(0xC00000AB)
-#define STATUS_PIPE_NOT_AVAILABLE __constant_cpu_to_le32(0xC00000AC)
-#define STATUS_INVALID_PIPE_STATE __constant_cpu_to_le32(0xC00000AD)
-#define STATUS_PIPE_BUSY __constant_cpu_to_le32(0xC00000AE)
-#define STATUS_ILLEGAL_FUNCTION __constant_cpu_to_le32(0xC00000AF)
-#define STATUS_PIPE_DISCONNECTED __constant_cpu_to_le32(0xC00000B0)
-#define STATUS_PIPE_CLOSING __constant_cpu_to_le32(0xC00000B1)
-#define STATUS_PIPE_CONNECTED __constant_cpu_to_le32(0xC00000B2)
-#define STATUS_PIPE_LISTENING __constant_cpu_to_le32(0xC00000B3)
-#define STATUS_INVALID_READ_MODE __constant_cpu_to_le32(0xC00000B4)
-#define STATUS_IO_TIMEOUT __constant_cpu_to_le32(0xC00000B5)
-#define STATUS_FILE_FORCED_CLOSED __constant_cpu_to_le32(0xC00000B6)
-#define STATUS_PROFILING_NOT_STARTED __constant_cpu_to_le32(0xC00000B7)
-#define STATUS_PROFILING_NOT_STOPPED __constant_cpu_to_le32(0xC00000B8)
-#define STATUS_COULD_NOT_INTERPRET __constant_cpu_to_le32(0xC00000B9)
-#define STATUS_FILE_IS_A_DIRECTORY __constant_cpu_to_le32(0xC00000BA)
-#define STATUS_NOT_SUPPORTED __constant_cpu_to_le32(0xC00000BB)
-#define STATUS_REMOTE_NOT_LISTENING __constant_cpu_to_le32(0xC00000BC)
-#define STATUS_DUPLICATE_NAME __constant_cpu_to_le32(0xC00000BD)
-#define STATUS_BAD_NETWORK_PATH __constant_cpu_to_le32(0xC00000BE)
-#define STATUS_NETWORK_BUSY __constant_cpu_to_le32(0xC00000BF)
-#define STATUS_DEVICE_DOES_NOT_EXIST __constant_cpu_to_le32(0xC00000C0)
-#define STATUS_TOO_MANY_COMMANDS __constant_cpu_to_le32(0xC00000C1)
-#define STATUS_ADAPTER_HARDWARE_ERROR __constant_cpu_to_le32(0xC00000C2)
-#define STATUS_INVALID_NETWORK_RESPONSE __constant_cpu_to_le32(0xC00000C3)
-#define STATUS_UNEXPECTED_NETWORK_ERROR __constant_cpu_to_le32(0xC00000C4)
-#define STATUS_BAD_REMOTE_ADAPTER __constant_cpu_to_le32(0xC00000C5)
-#define STATUS_PRINT_QUEUE_FULL __constant_cpu_to_le32(0xC00000C6)
-#define STATUS_NO_SPOOL_SPACE __constant_cpu_to_le32(0xC00000C7)
-#define STATUS_PRINT_CANCELLED __constant_cpu_to_le32(0xC00000C8)
-#define STATUS_NETWORK_NAME_DELETED __constant_cpu_to_le32(0xC00000C9)
-#define STATUS_NETWORK_ACCESS_DENIED __constant_cpu_to_le32(0xC00000CA)
-#define STATUS_BAD_DEVICE_TYPE __constant_cpu_to_le32(0xC00000CB)
-#define STATUS_BAD_NETWORK_NAME __constant_cpu_to_le32(0xC00000CC)
-#define STATUS_TOO_MANY_NAMES __constant_cpu_to_le32(0xC00000CD)
-#define STATUS_TOO_MANY_SESSIONS __constant_cpu_to_le32(0xC00000CE)
-#define STATUS_SHARING_PAUSED __constant_cpu_to_le32(0xC00000CF)
-#define STATUS_REQUEST_NOT_ACCEPTED __constant_cpu_to_le32(0xC00000D0)
-#define STATUS_REDIRECTOR_PAUSED __constant_cpu_to_le32(0xC00000D1)
-#define STATUS_NET_WRITE_FAULT __constant_cpu_to_le32(0xC00000D2)
-#define STATUS_PROFILING_AT_LIMIT __constant_cpu_to_le32(0xC00000D3)
-#define STATUS_NOT_SAME_DEVICE __constant_cpu_to_le32(0xC00000D4)
-#define STATUS_FILE_RENAMED __constant_cpu_to_le32(0xC00000D5)
-#define STATUS_VIRTUAL_CIRCUIT_CLOSED __constant_cpu_to_le32(0xC00000D6)
-#define STATUS_NO_SECURITY_ON_OBJECT __constant_cpu_to_le32(0xC00000D7)
-#define STATUS_CANT_WAIT __constant_cpu_to_le32(0xC00000D8)
-#define STATUS_PIPE_EMPTY __constant_cpu_to_le32(0xC00000D9)
-#define STATUS_CANT_ACCESS_DOMAIN_INFO __constant_cpu_to_le32(0xC00000DA)
-#define STATUS_CANT_TERMINATE_SELF __constant_cpu_to_le32(0xC00000DB)
-#define STATUS_INVALID_SERVER_STATE __constant_cpu_to_le32(0xC00000DC)
-#define STATUS_INVALID_DOMAIN_STATE __constant_cpu_to_le32(0xC00000DD)
-#define STATUS_INVALID_DOMAIN_ROLE __constant_cpu_to_le32(0xC00000DE)
-#define STATUS_NO_SUCH_DOMAIN __constant_cpu_to_le32(0xC00000DF)
-#define STATUS_DOMAIN_EXISTS __constant_cpu_to_le32(0xC00000E0)
-#define STATUS_DOMAIN_LIMIT_EXCEEDED __constant_cpu_to_le32(0xC00000E1)
-#define STATUS_OPLOCK_NOT_GRANTED __constant_cpu_to_le32(0xC00000E2)
-#define STATUS_INVALID_OPLOCK_PROTOCOL __constant_cpu_to_le32(0xC00000E3)
-#define STATUS_INTERNAL_DB_CORRUPTION __constant_cpu_to_le32(0xC00000E4)
-#define STATUS_INTERNAL_ERROR __constant_cpu_to_le32(0xC00000E5)
-#define STATUS_GENERIC_NOT_MAPPED __constant_cpu_to_le32(0xC00000E6)
-#define STATUS_BAD_DESCRIPTOR_FORMAT __constant_cpu_to_le32(0xC00000E7)
-#define STATUS_INVALID_USER_BUFFER __constant_cpu_to_le32(0xC00000E8)
-#define STATUS_UNEXPECTED_IO_ERROR __constant_cpu_to_le32(0xC00000E9)
-#define STATUS_UNEXPECTED_MM_CREATE_ERR __constant_cpu_to_le32(0xC00000EA)
-#define STATUS_UNEXPECTED_MM_MAP_ERROR __constant_cpu_to_le32(0xC00000EB)
-#define STATUS_UNEXPECTED_MM_EXTEND_ERR __constant_cpu_to_le32(0xC00000EC)
-#define STATUS_NOT_LOGON_PROCESS __constant_cpu_to_le32(0xC00000ED)
-#define STATUS_LOGON_SESSION_EXISTS __constant_cpu_to_le32(0xC00000EE)
-#define STATUS_INVALID_PARAMETER_1 __constant_cpu_to_le32(0xC00000EF)
-#define STATUS_INVALID_PARAMETER_2 __constant_cpu_to_le32(0xC00000F0)
-#define STATUS_INVALID_PARAMETER_3 __constant_cpu_to_le32(0xC00000F1)
-#define STATUS_INVALID_PARAMETER_4 __constant_cpu_to_le32(0xC00000F2)
-#define STATUS_INVALID_PARAMETER_5 __constant_cpu_to_le32(0xC00000F3)
-#define STATUS_INVALID_PARAMETER_6 __constant_cpu_to_le32(0xC00000F4)
-#define STATUS_INVALID_PARAMETER_7 __constant_cpu_to_le32(0xC00000F5)
-#define STATUS_INVALID_PARAMETER_8 __constant_cpu_to_le32(0xC00000F6)
-#define STATUS_INVALID_PARAMETER_9 __constant_cpu_to_le32(0xC00000F7)
-#define STATUS_INVALID_PARAMETER_10 __constant_cpu_to_le32(0xC00000F8)
-#define STATUS_INVALID_PARAMETER_11 __constant_cpu_to_le32(0xC00000F9)
-#define STATUS_INVALID_PARAMETER_12 __constant_cpu_to_le32(0xC00000FA)
-#define STATUS_REDIRECTOR_NOT_STARTED __constant_cpu_to_le32(0xC00000FB)
-#define STATUS_REDIRECTOR_STARTED __constant_cpu_to_le32(0xC00000FC)
-#define STATUS_STACK_OVERFLOW __constant_cpu_to_le32(0xC00000FD)
-#define STATUS_NO_SUCH_PACKAGE __constant_cpu_to_le32(0xC00000FE)
-#define STATUS_BAD_FUNCTION_TABLE __constant_cpu_to_le32(0xC00000FF)
-#define STATUS_VARIABLE_NOT_FOUND __constant_cpu_to_le32(0xC0000100)
-#define STATUS_DIRECTORY_NOT_EMPTY __constant_cpu_to_le32(0xC0000101)
-#define STATUS_FILE_CORRUPT_ERROR __constant_cpu_to_le32(0xC0000102)
-#define STATUS_NOT_A_DIRECTORY __constant_cpu_to_le32(0xC0000103)
-#define STATUS_BAD_LOGON_SESSION_STATE __constant_cpu_to_le32(0xC0000104)
-#define STATUS_LOGON_SESSION_COLLISION __constant_cpu_to_le32(0xC0000105)
-#define STATUS_NAME_TOO_LONG __constant_cpu_to_le32(0xC0000106)
-#define STATUS_FILES_OPEN __constant_cpu_to_le32(0xC0000107)
-#define STATUS_CONNECTION_IN_USE __constant_cpu_to_le32(0xC0000108)
-#define STATUS_MESSAGE_NOT_FOUND __constant_cpu_to_le32(0xC0000109)
-#define STATUS_PROCESS_IS_TERMINATING __constant_cpu_to_le32(0xC000010A)
-#define STATUS_INVALID_LOGON_TYPE __constant_cpu_to_le32(0xC000010B)
-#define STATUS_NO_GUID_TRANSLATION __constant_cpu_to_le32(0xC000010C)
-#define STATUS_CANNOT_IMPERSONATE __constant_cpu_to_le32(0xC000010D)
-#define STATUS_IMAGE_ALREADY_LOADED __constant_cpu_to_le32(0xC000010E)
-#define STATUS_ABIOS_NOT_PRESENT __constant_cpu_to_le32(0xC000010F)
-#define STATUS_ABIOS_LID_NOT_EXIST __constant_cpu_to_le32(0xC0000110)
-#define STATUS_ABIOS_LID_ALREADY_OWNED __constant_cpu_to_le32(0xC0000111)
-#define STATUS_ABIOS_NOT_LID_OWNER __constant_cpu_to_le32(0xC0000112)
-#define STATUS_ABIOS_INVALID_COMMAND __constant_cpu_to_le32(0xC0000113)
-#define STATUS_ABIOS_INVALID_LID __constant_cpu_to_le32(0xC0000114)
-#define STATUS_ABIOS_SELECTOR_NOT_AVAILABLE __constant_cpu_to_le32(0xC0000115)
-#define STATUS_ABIOS_INVALID_SELECTOR __constant_cpu_to_le32(0xC0000116)
-#define STATUS_NO_LDT __constant_cpu_to_le32(0xC0000117)
-#define STATUS_INVALID_LDT_SIZE __constant_cpu_to_le32(0xC0000118)
-#define STATUS_INVALID_LDT_OFFSET __constant_cpu_to_le32(0xC0000119)
-#define STATUS_INVALID_LDT_DESCRIPTOR __constant_cpu_to_le32(0xC000011A)
-#define STATUS_INVALID_IMAGE_NE_FORMAT __constant_cpu_to_le32(0xC000011B)
-#define STATUS_RXACT_INVALID_STATE __constant_cpu_to_le32(0xC000011C)
-#define STATUS_RXACT_COMMIT_FAILURE __constant_cpu_to_le32(0xC000011D)
-#define STATUS_MAPPED_FILE_SIZE_ZERO __constant_cpu_to_le32(0xC000011E)
-#define STATUS_TOO_MANY_OPENED_FILES __constant_cpu_to_le32(0xC000011F)
-#define STATUS_CANCELLED __constant_cpu_to_le32(0xC0000120)
-#define STATUS_CANNOT_DELETE __constant_cpu_to_le32(0xC0000121)
-#define STATUS_INVALID_COMPUTER_NAME __constant_cpu_to_le32(0xC0000122)
-#define STATUS_FILE_DELETED __constant_cpu_to_le32(0xC0000123)
-#define STATUS_SPECIAL_ACCOUNT __constant_cpu_to_le32(0xC0000124)
-#define STATUS_SPECIAL_GROUP __constant_cpu_to_le32(0xC0000125)
-#define STATUS_SPECIAL_USER __constant_cpu_to_le32(0xC0000126)
-#define STATUS_MEMBERS_PRIMARY_GROUP __constant_cpu_to_le32(0xC0000127)
-#define STATUS_FILE_CLOSED __constant_cpu_to_le32(0xC0000128)
-#define STATUS_TOO_MANY_THREADS __constant_cpu_to_le32(0xC0000129)
-#define STATUS_THREAD_NOT_IN_PROCESS __constant_cpu_to_le32(0xC000012A)
-#define STATUS_TOKEN_ALREADY_IN_USE __constant_cpu_to_le32(0xC000012B)
-#define STATUS_PAGEFILE_QUOTA_EXCEEDED __constant_cpu_to_le32(0xC000012C)
-#define STATUS_COMMITMENT_LIMIT __constant_cpu_to_le32(0xC000012D)
-#define STATUS_INVALID_IMAGE_LE_FORMAT __constant_cpu_to_le32(0xC000012E)
-#define STATUS_INVALID_IMAGE_NOT_MZ __constant_cpu_to_le32(0xC000012F)
-#define STATUS_INVALID_IMAGE_PROTECT __constant_cpu_to_le32(0xC0000130)
-#define STATUS_INVALID_IMAGE_WIN_16 __constant_cpu_to_le32(0xC0000131)
-#define STATUS_LOGON_SERVER_CONFLICT __constant_cpu_to_le32(0xC0000132)
-#define STATUS_TIME_DIFFERENCE_AT_DC __constant_cpu_to_le32(0xC0000133)
-#define STATUS_SYNCHRONIZATION_REQUIRED __constant_cpu_to_le32(0xC0000134)
-#define STATUS_DLL_NOT_FOUND __constant_cpu_to_le32(0xC0000135)
-#define STATUS_OPEN_FAILED __constant_cpu_to_le32(0xC0000136)
-#define STATUS_IO_PRIVILEGE_FAILED __constant_cpu_to_le32(0xC0000137)
-#define STATUS_ORDINAL_NOT_FOUND __constant_cpu_to_le32(0xC0000138)
-#define STATUS_ENTRYPOINT_NOT_FOUND __constant_cpu_to_le32(0xC0000139)
-#define STATUS_CONTROL_C_EXIT __constant_cpu_to_le32(0xC000013A)
-#define STATUS_LOCAL_DISCONNECT __constant_cpu_to_le32(0xC000013B)
-#define STATUS_REMOTE_DISCONNECT __constant_cpu_to_le32(0xC000013C)
-#define STATUS_REMOTE_RESOURCES __constant_cpu_to_le32(0xC000013D)
-#define STATUS_LINK_FAILED __constant_cpu_to_le32(0xC000013E)
-#define STATUS_LINK_TIMEOUT __constant_cpu_to_le32(0xC000013F)
-#define STATUS_INVALID_CONNECTION __constant_cpu_to_le32(0xC0000140)
-#define STATUS_INVALID_ADDRESS __constant_cpu_to_le32(0xC0000141)
-#define STATUS_DLL_INIT_FAILED __constant_cpu_to_le32(0xC0000142)
-#define STATUS_MISSING_SYSTEMFILE __constant_cpu_to_le32(0xC0000143)
-#define STATUS_UNHANDLED_EXCEPTION __constant_cpu_to_le32(0xC0000144)
-#define STATUS_APP_INIT_FAILURE __constant_cpu_to_le32(0xC0000145)
-#define STATUS_PAGEFILE_CREATE_FAILED __constant_cpu_to_le32(0xC0000146)
-#define STATUS_NO_PAGEFILE __constant_cpu_to_le32(0xC0000147)
-#define STATUS_INVALID_LEVEL __constant_cpu_to_le32(0xC0000148)
-#define STATUS_WRONG_PASSWORD_CORE __constant_cpu_to_le32(0xC0000149)
-#define STATUS_ILLEGAL_FLOAT_CONTEXT __constant_cpu_to_le32(0xC000014A)
-#define STATUS_PIPE_BROKEN __constant_cpu_to_le32(0xC000014B)
-#define STATUS_REGISTRY_CORRUPT __constant_cpu_to_le32(0xC000014C)
-#define STATUS_REGISTRY_IO_FAILED __constant_cpu_to_le32(0xC000014D)
-#define STATUS_NO_EVENT_PAIR __constant_cpu_to_le32(0xC000014E)
-#define STATUS_UNRECOGNIZED_VOLUME __constant_cpu_to_le32(0xC000014F)
-#define STATUS_SERIAL_NO_DEVICE_INITED __constant_cpu_to_le32(0xC0000150)
-#define STATUS_NO_SUCH_ALIAS __constant_cpu_to_le32(0xC0000151)
-#define STATUS_MEMBER_NOT_IN_ALIAS __constant_cpu_to_le32(0xC0000152)
-#define STATUS_MEMBER_IN_ALIAS __constant_cpu_to_le32(0xC0000153)
-#define STATUS_ALIAS_EXISTS __constant_cpu_to_le32(0xC0000154)
-#define STATUS_LOGON_NOT_GRANTED __constant_cpu_to_le32(0xC0000155)
-#define STATUS_TOO_MANY_SECRETS __constant_cpu_to_le32(0xC0000156)
-#define STATUS_SECRET_TOO_LONG __constant_cpu_to_le32(0xC0000157)
-#define STATUS_INTERNAL_DB_ERROR __constant_cpu_to_le32(0xC0000158)
-#define STATUS_FULLSCREEN_MODE __constant_cpu_to_le32(0xC0000159)
-#define STATUS_TOO_MANY_CONTEXT_IDS __constant_cpu_to_le32(0xC000015A)
-#define STATUS_LOGON_TYPE_NOT_GRANTED __constant_cpu_to_le32(0xC000015B)
-#define STATUS_NOT_REGISTRY_FILE __constant_cpu_to_le32(0xC000015C)
-#define STATUS_NT_CROSS_ENCRYPTION_REQUIRED __constant_cpu_to_le32(0xC000015D)
-#define STATUS_DOMAIN_CTRLR_CONFIG_ERROR __constant_cpu_to_le32(0xC000015E)
-#define STATUS_FT_MISSING_MEMBER __constant_cpu_to_le32(0xC000015F)
-#define STATUS_ILL_FORMED_SERVICE_ENTRY __constant_cpu_to_le32(0xC0000160)
-#define STATUS_ILLEGAL_CHARACTER __constant_cpu_to_le32(0xC0000161)
-#define STATUS_UNMAPPABLE_CHARACTER __constant_cpu_to_le32(0xC0000162)
-#define STATUS_UNDEFINED_CHARACTER __constant_cpu_to_le32(0xC0000163)
-#define STATUS_FLOPPY_VOLUME __constant_cpu_to_le32(0xC0000164)
-#define STATUS_FLOPPY_ID_MARK_NOT_FOUND __constant_cpu_to_le32(0xC0000165)
-#define STATUS_FLOPPY_WRONG_CYLINDER __constant_cpu_to_le32(0xC0000166)
-#define STATUS_FLOPPY_UNKNOWN_ERROR __constant_cpu_to_le32(0xC0000167)
-#define STATUS_FLOPPY_BAD_REGISTERS __constant_cpu_to_le32(0xC0000168)
-#define STATUS_DISK_RECALIBRATE_FAILED __constant_cpu_to_le32(0xC0000169)
-#define STATUS_DISK_OPERATION_FAILED __constant_cpu_to_le32(0xC000016A)
-#define STATUS_DISK_RESET_FAILED __constant_cpu_to_le32(0xC000016B)
-#define STATUS_SHARED_IRQ_BUSY __constant_cpu_to_le32(0xC000016C)
-#define STATUS_FT_ORPHANING __constant_cpu_to_le32(0xC000016D)
-#define STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT __constant_cpu_to_le32(0xC000016E)
-#define STATUS_PARTITION_FAILURE __constant_cpu_to_le32(0xC0000172)
-#define STATUS_INVALID_BLOCK_LENGTH __constant_cpu_to_le32(0xC0000173)
-#define STATUS_DEVICE_NOT_PARTITIONED __constant_cpu_to_le32(0xC0000174)
-#define STATUS_UNABLE_TO_LOCK_MEDIA __constant_cpu_to_le32(0xC0000175)
-#define STATUS_UNABLE_TO_UNLOAD_MEDIA __constant_cpu_to_le32(0xC0000176)
-#define STATUS_EOM_OVERFLOW __constant_cpu_to_le32(0xC0000177)
-#define STATUS_NO_MEDIA __constant_cpu_to_le32(0xC0000178)
-#define STATUS_NO_SUCH_MEMBER __constant_cpu_to_le32(0xC000017A)
-#define STATUS_INVALID_MEMBER __constant_cpu_to_le32(0xC000017B)
-#define STATUS_KEY_DELETED __constant_cpu_to_le32(0xC000017C)
-#define STATUS_NO_LOG_SPACE __constant_cpu_to_le32(0xC000017D)
-#define STATUS_TOO_MANY_SIDS __constant_cpu_to_le32(0xC000017E)
-#define STATUS_LM_CROSS_ENCRYPTION_REQUIRED __constant_cpu_to_le32(0xC000017F)
-#define STATUS_KEY_HAS_CHILDREN __constant_cpu_to_le32(0xC0000180)
-#define STATUS_CHILD_MUST_BE_VOLATILE __constant_cpu_to_le32(0xC0000181)
-#define STATUS_DEVICE_CONFIGURATION_ERROR __constant_cpu_to_le32(0xC0000182)
-#define STATUS_DRIVER_INTERNAL_ERROR __constant_cpu_to_le32(0xC0000183)
-#define STATUS_INVALID_DEVICE_STATE __constant_cpu_to_le32(0xC0000184)
-#define STATUS_IO_DEVICE_ERROR __constant_cpu_to_le32(0xC0000185)
-#define STATUS_DEVICE_PROTOCOL_ERROR __constant_cpu_to_le32(0xC0000186)
-#define STATUS_BACKUP_CONTROLLER __constant_cpu_to_le32(0xC0000187)
-#define STATUS_LOG_FILE_FULL __constant_cpu_to_le32(0xC0000188)
-#define STATUS_TOO_LATE __constant_cpu_to_le32(0xC0000189)
-#define STATUS_NO_TRUST_LSA_SECRET __constant_cpu_to_le32(0xC000018A)
-#define STATUS_NO_TRUST_SAM_ACCOUNT __constant_cpu_to_le32(0xC000018B)
-#define STATUS_TRUSTED_DOMAIN_FAILURE __constant_cpu_to_le32(0xC000018C)
-#define STATUS_TRUSTED_RELATIONSHIP_FAILURE __constant_cpu_to_le32(0xC000018D)
-#define STATUS_EVENTLOG_FILE_CORRUPT __constant_cpu_to_le32(0xC000018E)
-#define STATUS_EVENTLOG_CANT_START __constant_cpu_to_le32(0xC000018F)
-#define STATUS_TRUST_FAILURE __constant_cpu_to_le32(0xC0000190)
-#define STATUS_MUTANT_LIMIT_EXCEEDED __constant_cpu_to_le32(0xC0000191)
-#define STATUS_NETLOGON_NOT_STARTED __constant_cpu_to_le32(0xC0000192)
-#define STATUS_ACCOUNT_EXPIRED __constant_cpu_to_le32(0xC0000193)
-#define STATUS_POSSIBLE_DEADLOCK __constant_cpu_to_le32(0xC0000194)
-#define STATUS_NETWORK_CREDENTIAL_CONFLICT __constant_cpu_to_le32(0xC0000195)
-#define STATUS_REMOTE_SESSION_LIMIT __constant_cpu_to_le32(0xC0000196)
-#define STATUS_EVENTLOG_FILE_CHANGED __constant_cpu_to_le32(0xC0000197)
-#define STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT __constant_cpu_to_le32(0xC0000198)
-#define STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT __constant_cpu_to_le32(0xC0000199)
-#define STATUS_NOLOGON_SERVER_TRUST_ACCOUNT __constant_cpu_to_le32(0xC000019A)
-#define STATUS_DOMAIN_TRUST_INCONSISTENT __constant_cpu_to_le32(0xC000019B)
-#define STATUS_FS_DRIVER_REQUIRED __constant_cpu_to_le32(0xC000019C)
-#define STATUS_IMAGE_ALREADY_LOADED_AS_DLL __constant_cpu_to_le32(0xC000019D)
-#define STATUS_NETWORK_OPEN_RESTRICTION __constant_cpu_to_le32(0xC0000201)
-#define STATUS_NO_USER_SESSION_KEY __constant_cpu_to_le32(0xC0000202)
-#define STATUS_USER_SESSION_DELETED __constant_cpu_to_le32(0xC0000203)
-#define STATUS_RESOURCE_LANG_NOT_FOUND __constant_cpu_to_le32(0xC0000204)
-#define STATUS_INSUFF_SERVER_RESOURCES __constant_cpu_to_le32(0xC0000205)
-#define STATUS_INVALID_BUFFER_SIZE __constant_cpu_to_le32(0xC0000206)
-#define STATUS_INVALID_ADDRESS_COMPONENT __constant_cpu_to_le32(0xC0000207)
-#define STATUS_INVALID_ADDRESS_WILDCARD __constant_cpu_to_le32(0xC0000208)
-#define STATUS_TOO_MANY_ADDRESSES __constant_cpu_to_le32(0xC0000209)
-#define STATUS_ADDRESS_ALREADY_EXISTS __constant_cpu_to_le32(0xC000020A)
-#define STATUS_ADDRESS_CLOSED __constant_cpu_to_le32(0xC000020B)
-#define STATUS_CONNECTION_DISCONNECTED __constant_cpu_to_le32(0xC000020C)
-#define STATUS_CONNECTION_RESET __constant_cpu_to_le32(0xC000020D)
-#define STATUS_TOO_MANY_NODES __constant_cpu_to_le32(0xC000020E)
-#define STATUS_TRANSACTION_ABORTED __constant_cpu_to_le32(0xC000020F)
-#define STATUS_TRANSACTION_TIMED_OUT __constant_cpu_to_le32(0xC0000210)
-#define STATUS_TRANSACTION_NO_RELEASE __constant_cpu_to_le32(0xC0000211)
-#define STATUS_TRANSACTION_NO_MATCH __constant_cpu_to_le32(0xC0000212)
-#define STATUS_TRANSACTION_RESPONDED __constant_cpu_to_le32(0xC0000213)
-#define STATUS_TRANSACTION_INVALID_ID __constant_cpu_to_le32(0xC0000214)
-#define STATUS_TRANSACTION_INVALID_TYPE __constant_cpu_to_le32(0xC0000215)
-#define STATUS_NOT_SERVER_SESSION __constant_cpu_to_le32(0xC0000216)
-#define STATUS_NOT_CLIENT_SESSION __constant_cpu_to_le32(0xC0000217)
-#define STATUS_CANNOT_LOAD_REGISTRY_FILE __constant_cpu_to_le32(0xC0000218)
-#define STATUS_DEBUG_ATTACH_FAILED __constant_cpu_to_le32(0xC0000219)
-#define STATUS_SYSTEM_PROCESS_TERMINATED __constant_cpu_to_le32(0xC000021A)
-#define STATUS_DATA_NOT_ACCEPTED __constant_cpu_to_le32(0xC000021B)
-#define STATUS_NO_BROWSER_SERVERS_FOUND __constant_cpu_to_le32(0xC000021C)
-#define STATUS_VDM_HARD_ERROR __constant_cpu_to_le32(0xC000021D)
-#define STATUS_DRIVER_CANCEL_TIMEOUT __constant_cpu_to_le32(0xC000021E)
-#define STATUS_REPLY_MESSAGE_MISMATCH __constant_cpu_to_le32(0xC000021F)
-#define STATUS_MAPPED_ALIGNMENT __constant_cpu_to_le32(0xC0000220)
-#define STATUS_IMAGE_CHECKSUM_MISMATCH __constant_cpu_to_le32(0xC0000221)
-#define STATUS_LOST_WRITEBEHIND_DATA __constant_cpu_to_le32(0xC0000222)
-#define STATUS_CLIENT_SERVER_PARAMETERS_INVALID __constant_cpu_to_le32(0xC0000223)
-#define STATUS_PASSWORD_MUST_CHANGE __constant_cpu_to_le32(0xC0000224)
-#define STATUS_NOT_FOUND __constant_cpu_to_le32(0xC0000225)
-#define STATUS_NOT_TINY_STREAM __constant_cpu_to_le32(0xC0000226)
-#define STATUS_RECOVERY_FAILURE __constant_cpu_to_le32(0xC0000227)
-#define STATUS_STACK_OVERFLOW_READ __constant_cpu_to_le32(0xC0000228)
-#define STATUS_FAIL_CHECK __constant_cpu_to_le32(0xC0000229)
-#define STATUS_DUPLICATE_OBJECTID __constant_cpu_to_le32(0xC000022A)
-#define STATUS_OBJECTID_EXISTS __constant_cpu_to_le32(0xC000022B)
-#define STATUS_CONVERT_TO_LARGE __constant_cpu_to_le32(0xC000022C)
-#define STATUS_RETRY __constant_cpu_to_le32(0xC000022D)
-#define STATUS_FOUND_OUT_OF_SCOPE __constant_cpu_to_le32(0xC000022E)
-#define STATUS_ALLOCATE_BUCKET __constant_cpu_to_le32(0xC000022F)
-#define STATUS_PROPSET_NOT_FOUND __constant_cpu_to_le32(0xC0000230)
-#define STATUS_MARSHALL_OVERFLOW __constant_cpu_to_le32(0xC0000231)
-#define STATUS_INVALID_VARIANT __constant_cpu_to_le32(0xC0000232)
-#define STATUS_DOMAIN_CONTROLLER_NOT_FOUND __constant_cpu_to_le32(0xC0000233)
-#define STATUS_ACCOUNT_LOCKED_OUT __constant_cpu_to_le32(0xC0000234)
-#define STATUS_HANDLE_NOT_CLOSABLE __constant_cpu_to_le32(0xC0000235)
-#define STATUS_CONNECTION_REFUSED __constant_cpu_to_le32(0xC0000236)
-#define STATUS_GRACEFUL_DISCONNECT __constant_cpu_to_le32(0xC0000237)
-#define STATUS_ADDRESS_ALREADY_ASSOCIATED __constant_cpu_to_le32(0xC0000238)
-#define STATUS_ADDRESS_NOT_ASSOCIATED __constant_cpu_to_le32(0xC0000239)
-#define STATUS_CONNECTION_INVALID __constant_cpu_to_le32(0xC000023A)
-#define STATUS_CONNECTION_ACTIVE __constant_cpu_to_le32(0xC000023B)
-#define STATUS_NETWORK_UNREACHABLE __constant_cpu_to_le32(0xC000023C)
-#define STATUS_HOST_UNREACHABLE __constant_cpu_to_le32(0xC000023D)
-#define STATUS_PROTOCOL_UNREACHABLE __constant_cpu_to_le32(0xC000023E)
-#define STATUS_PORT_UNREACHABLE __constant_cpu_to_le32(0xC000023F)
-#define STATUS_REQUEST_ABORTED __constant_cpu_to_le32(0xC0000240)
-#define STATUS_CONNECTION_ABORTED __constant_cpu_to_le32(0xC0000241)
-#define STATUS_BAD_COMPRESSION_BUFFER __constant_cpu_to_le32(0xC0000242)
-#define STATUS_USER_MAPPED_FILE __constant_cpu_to_le32(0xC0000243)
-#define STATUS_AUDIT_FAILED __constant_cpu_to_le32(0xC0000244)
-#define STATUS_TIMER_RESOLUTION_NOT_SET __constant_cpu_to_le32(0xC0000245)
-#define STATUS_CONNECTION_COUNT_LIMIT __constant_cpu_to_le32(0xC0000246)
-#define STATUS_LOGIN_TIME_RESTRICTION __constant_cpu_to_le32(0xC0000247)
-#define STATUS_LOGIN_WKSTA_RESTRICTION __constant_cpu_to_le32(0xC0000248)
-#define STATUS_IMAGE_MP_UP_MISMATCH __constant_cpu_to_le32(0xC0000249)
-#define STATUS_INSUFFICIENT_LOGON_INFO __constant_cpu_to_le32(0xC0000250)
-#define STATUS_BAD_DLL_ENTRYPOINT __constant_cpu_to_le32(0xC0000251)
-#define STATUS_BAD_SERVICE_ENTRYPOINT __constant_cpu_to_le32(0xC0000252)
-#define STATUS_LPC_REPLY_LOST __constant_cpu_to_le32(0xC0000253)
-#define STATUS_IP_ADDRESS_CONFLICT1 __constant_cpu_to_le32(0xC0000254)
-#define STATUS_IP_ADDRESS_CONFLICT2 __constant_cpu_to_le32(0xC0000255)
-#define STATUS_REGISTRY_QUOTA_LIMIT __constant_cpu_to_le32(0xC0000256)
-#define STATUS_PATH_NOT_COVERED __constant_cpu_to_le32(0xC0000257)
-#define STATUS_NO_CALLBACK_ACTIVE __constant_cpu_to_le32(0xC0000258)
-#define STATUS_LICENSE_QUOTA_EXCEEDED __constant_cpu_to_le32(0xC0000259)
-#define STATUS_PWD_TOO_SHORT __constant_cpu_to_le32(0xC000025A)
-#define STATUS_PWD_TOO_RECENT __constant_cpu_to_le32(0xC000025B)
-#define STATUS_PWD_HISTORY_CONFLICT __constant_cpu_to_le32(0xC000025C)
-#define STATUS_PLUGPLAY_NO_DEVICE __constant_cpu_to_le32(0xC000025E)
-#define STATUS_UNSUPPORTED_COMPRESSION __constant_cpu_to_le32(0xC000025F)
-#define STATUS_INVALID_HW_PROFILE __constant_cpu_to_le32(0xC0000260)
-#define STATUS_INVALID_PLUGPLAY_DEVICE_PATH __constant_cpu_to_le32(0xC0000261)
-#define STATUS_DRIVER_ORDINAL_NOT_FOUND __constant_cpu_to_le32(0xC0000262)
-#define STATUS_DRIVER_ENTRYPOINT_NOT_FOUND __constant_cpu_to_le32(0xC0000263)
-#define STATUS_RESOURCE_NOT_OWNED __constant_cpu_to_le32(0xC0000264)
-#define STATUS_TOO_MANY_LINKS __constant_cpu_to_le32(0xC0000265)
-#define STATUS_QUOTA_LIST_INCONSISTENT __constant_cpu_to_le32(0xC0000266)
-#define STATUS_FILE_IS_OFFLINE __constant_cpu_to_le32(0xC0000267)
-#define STATUS_EVALUATION_EXPIRATION __constant_cpu_to_le32(0xC0000268)
-#define STATUS_ILLEGAL_DLL_RELOCATION __constant_cpu_to_le32(0xC0000269)
-#define STATUS_LICENSE_VIOLATION __constant_cpu_to_le32(0xC000026A)
-#define STATUS_DLL_INIT_FAILED_LOGOFF __constant_cpu_to_le32(0xC000026B)
-#define STATUS_DRIVER_UNABLE_TO_LOAD __constant_cpu_to_le32(0xC000026C)
-#define STATUS_DFS_UNAVAILABLE __constant_cpu_to_le32(0xC000026D)
-#define STATUS_VOLUME_DISMOUNTED __constant_cpu_to_le32(0xC000026E)
-#define STATUS_WX86_INTERNAL_ERROR __constant_cpu_to_le32(0xC000026F)
-#define STATUS_WX86_FLOAT_STACK_CHECK __constant_cpu_to_le32(0xC0000270)
-#define STATUS_VALIDATE_CONTINUE __constant_cpu_to_le32(0xC0000271)
-#define STATUS_NO_MATCH __constant_cpu_to_le32(0xC0000272)
-#define STATUS_NO_MORE_MATCHES __constant_cpu_to_le32(0xC0000273)
-#define STATUS_NOT_A_REPARSE_POINT __constant_cpu_to_le32(0xC0000275)
-#define STATUS_IO_REPARSE_TAG_INVALID __constant_cpu_to_le32(0xC0000276)
-#define STATUS_IO_REPARSE_TAG_MISMATCH __constant_cpu_to_le32(0xC0000277)
-#define STATUS_IO_REPARSE_DATA_INVALID __constant_cpu_to_le32(0xC0000278)
-#define STATUS_IO_REPARSE_TAG_NOT_HANDLED __constant_cpu_to_le32(0xC0000279)
-#define STATUS_REPARSE_POINT_NOT_RESOLVED __constant_cpu_to_le32(0xC0000280)
-#define STATUS_DIRECTORY_IS_A_REPARSE_POINT __constant_cpu_to_le32(0xC0000281)
-#define STATUS_RANGE_LIST_CONFLICT __constant_cpu_to_le32(0xC0000282)
-#define STATUS_SOURCE_ELEMENT_EMPTY __constant_cpu_to_le32(0xC0000283)
-#define STATUS_DESTINATION_ELEMENT_FULL __constant_cpu_to_le32(0xC0000284)
-#define STATUS_ILLEGAL_ELEMENT_ADDRESS __constant_cpu_to_le32(0xC0000285)
-#define STATUS_MAGAZINE_NOT_PRESENT __constant_cpu_to_le32(0xC0000286)
-#define STATUS_REINITIALIZATION_NEEDED __constant_cpu_to_le32(0xC0000287)
-#define STATUS_ENCRYPTION_FAILED __constant_cpu_to_le32(0xC000028A)
-#define STATUS_DECRYPTION_FAILED __constant_cpu_to_le32(0xC000028B)
-#define STATUS_RANGE_NOT_FOUND __constant_cpu_to_le32(0xC000028C)
-#define STATUS_NO_RECOVERY_POLICY __constant_cpu_to_le32(0xC000028D)
-#define STATUS_NO_EFS __constant_cpu_to_le32(0xC000028E)
-#define STATUS_WRONG_EFS __constant_cpu_to_le32(0xC000028F)
-#define STATUS_NO_USER_KEYS __constant_cpu_to_le32(0xC0000290)
-#define STATUS_FILE_NOT_ENCRYPTED __constant_cpu_to_le32(0xC0000291)
-#define STATUS_NOT_EXPORT_FORMAT __constant_cpu_to_le32(0xC0000292)
-#define STATUS_FILE_ENCRYPTED __constant_cpu_to_le32(0xC0000293)
-#define STATUS_WMI_GUID_NOT_FOUND __constant_cpu_to_le32(0xC0000295)
-#define STATUS_WMI_INSTANCE_NOT_FOUND __constant_cpu_to_le32(0xC0000296)
-#define STATUS_WMI_ITEMID_NOT_FOUND __constant_cpu_to_le32(0xC0000297)
-#define STATUS_WMI_TRY_AGAIN __constant_cpu_to_le32(0xC0000298)
-#define STATUS_SHARED_POLICY __constant_cpu_to_le32(0xC0000299)
-#define STATUS_POLICY_OBJECT_NOT_FOUND __constant_cpu_to_le32(0xC000029A)
-#define STATUS_POLICY_ONLY_IN_DS __constant_cpu_to_le32(0xC000029B)
-#define STATUS_VOLUME_NOT_UPGRADED __constant_cpu_to_le32(0xC000029C)
-#define STATUS_REMOTE_STORAGE_NOT_ACTIVE __constant_cpu_to_le32(0xC000029D)
-#define STATUS_REMOTE_STORAGE_MEDIA_ERROR __constant_cpu_to_le32(0xC000029E)
-#define STATUS_NO_TRACKING_SERVICE __constant_cpu_to_le32(0xC000029F)
-#define STATUS_SERVER_SID_MISMATCH __constant_cpu_to_le32(0xC00002A0)
-#define STATUS_DS_NO_ATTRIBUTE_OR_VALUE __constant_cpu_to_le32(0xC00002A1)
-#define STATUS_DS_INVALID_ATTRIBUTE_SYNTAX __constant_cpu_to_le32(0xC00002A2)
-#define STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED __constant_cpu_to_le32(0xC00002A3)
-#define STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS __constant_cpu_to_le32(0xC00002A4)
-#define STATUS_DS_BUSY __constant_cpu_to_le32(0xC00002A5)
-#define STATUS_DS_UNAVAILABLE __constant_cpu_to_le32(0xC00002A6)
-#define STATUS_DS_NO_RIDS_ALLOCATED __constant_cpu_to_le32(0xC00002A7)
-#define STATUS_DS_NO_MORE_RIDS __constant_cpu_to_le32(0xC00002A8)
-#define STATUS_DS_INCORRECT_ROLE_OWNER __constant_cpu_to_le32(0xC00002A9)
-#define STATUS_DS_RIDMGR_INIT_ERROR __constant_cpu_to_le32(0xC00002AA)
-#define STATUS_DS_OBJ_CLASS_VIOLATION __constant_cpu_to_le32(0xC00002AB)
-#define STATUS_DS_CANT_ON_NON_LEAF __constant_cpu_to_le32(0xC00002AC)
-#define STATUS_DS_CANT_ON_RDN __constant_cpu_to_le32(0xC00002AD)
-#define STATUS_DS_CANT_MOD_OBJ_CLASS __constant_cpu_to_le32(0xC00002AE)
-#define STATUS_DS_CROSS_DOM_MOVE_FAILED __constant_cpu_to_le32(0xC00002AF)
-#define STATUS_DS_GC_NOT_AVAILABLE __constant_cpu_to_le32(0xC00002B0)
-#define STATUS_DIRECTORY_SERVICE_REQUIRED __constant_cpu_to_le32(0xC00002B1)
-#define STATUS_REPARSE_ATTRIBUTE_CONFLICT __constant_cpu_to_le32(0xC00002B2)
-#define STATUS_CANT_ENABLE_DENY_ONLY __constant_cpu_to_le32(0xC00002B3)
-#define STATUS_FLOAT_MULTIPLE_FAULTS __constant_cpu_to_le32(0xC00002B4)
-#define STATUS_FLOAT_MULTIPLE_TRAPS __constant_cpu_to_le32(0xC00002B5)
-#define STATUS_DEVICE_REMOVED __constant_cpu_to_le32(0xC00002B6)
-#define STATUS_JOURNAL_DELETE_IN_PROGRESS __constant_cpu_to_le32(0xC00002B7)
-#define STATUS_JOURNAL_NOT_ACTIVE __constant_cpu_to_le32(0xC00002B8)
-#define STATUS_NOINTERFACE __constant_cpu_to_le32(0xC00002B9)
-#define STATUS_DS_ADMIN_LIMIT_EXCEEDED __constant_cpu_to_le32(0xC00002C1)
-#define STATUS_DRIVER_FAILED_SLEEP __constant_cpu_to_le32(0xC00002C2)
-#define STATUS_MUTUAL_AUTHENTICATION_FAILED __constant_cpu_to_le32(0xC00002C3)
-#define STATUS_CORRUPT_SYSTEM_FILE __constant_cpu_to_le32(0xC00002C4)
-#define STATUS_DATATYPE_MISALIGNMENT_ERROR __constant_cpu_to_le32(0xC00002C5)
-#define STATUS_WMI_READ_ONLY __constant_cpu_to_le32(0xC00002C6)
-#define STATUS_WMI_SET_FAILURE __constant_cpu_to_le32(0xC00002C7)
-#define STATUS_COMMITMENT_MINIMUM __constant_cpu_to_le32(0xC00002C8)
-#define STATUS_REG_NAT_CONSUMPTION __constant_cpu_to_le32(0xC00002C9)
-#define STATUS_TRANSPORT_FULL __constant_cpu_to_le32(0xC00002CA)
-#define STATUS_DS_SAM_INIT_FAILURE __constant_cpu_to_le32(0xC00002CB)
-#define STATUS_ONLY_IF_CONNECTED __constant_cpu_to_le32(0xC00002CC)
-#define STATUS_DS_SENSITIVE_GROUP_VIOLATION __constant_cpu_to_le32(0xC00002CD)
-#define STATUS_PNP_RESTART_ENUMERATION __constant_cpu_to_le32(0xC00002CE)
-#define STATUS_JOURNAL_ENTRY_DELETED __constant_cpu_to_le32(0xC00002CF)
-#define STATUS_DS_CANT_MOD_PRIMARYGROUPID __constant_cpu_to_le32(0xC00002D0)
-#define STATUS_SYSTEM_IMAGE_BAD_SIGNATURE __constant_cpu_to_le32(0xC00002D1)
-#define STATUS_PNP_REBOOT_REQUIRED __constant_cpu_to_le32(0xC00002D2)
-#define STATUS_POWER_STATE_INVALID __constant_cpu_to_le32(0xC00002D3)
-#define STATUS_DS_INVALID_GROUP_TYPE __constant_cpu_to_le32(0xC00002D4)
-#define STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN __constant_cpu_to_le32(0xC00002D5)
-#define STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN __constant_cpu_to_le32(0xC00002D6)
-#define STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER __constant_cpu_to_le32(0xC00002D7)
-#define STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER __constant_cpu_to_le32(0xC00002D8)
-#define STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER __constant_cpu_to_le32(0xC00002D9)
-#define STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER __constant_cpu_to_le32(0xC00002DA)
-#define STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER __constant_cpu_to_le32(0xC00002DB)
-#define STATUS_DS_HAVE_PRIMARY_MEMBERS __constant_cpu_to_le32(0xC00002DC)
-#define STATUS_WMI_NOT_SUPPORTED __constant_cpu_to_le32(0xC00002DD)
-#define STATUS_INSUFFICIENT_POWER __constant_cpu_to_le32(0xC00002DE)
-#define STATUS_SAM_NEED_BOOTKEY_PASSWORD __constant_cpu_to_le32(0xC00002DF)
-#define STATUS_SAM_NEED_BOOTKEY_FLOPPY __constant_cpu_to_le32(0xC00002E0)
-#define STATUS_DS_CANT_START __constant_cpu_to_le32(0xC00002E1)
-#define STATUS_DS_INIT_FAILURE __constant_cpu_to_le32(0xC00002E2)
-#define STATUS_SAM_INIT_FAILURE __constant_cpu_to_le32(0xC00002E3)
-#define STATUS_DS_GC_REQUIRED __constant_cpu_to_le32(0xC00002E4)
-#define STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY __constant_cpu_to_le32(0xC00002E5)
-#define STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS __constant_cpu_to_le32(0xC00002E6)
-#define STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED __constant_cpu_to_le32(0xC00002E7)
-#define STATUS_MULTIPLE_FAULT_VIOLATION __constant_cpu_to_le32(0xC00002E8)
-#define STATUS_CURRENT_DOMAIN_NOT_ALLOWED __constant_cpu_to_le32(0xC00002E9)
-#define STATUS_CANNOT_MAKE __constant_cpu_to_le32(0xC00002EA)
-#define STATUS_SYSTEM_SHUTDOWN __constant_cpu_to_le32(0xC00002EB)
-#define STATUS_DS_INIT_FAILURE_CONSOLE __constant_cpu_to_le32(0xC00002EC)
-#define STATUS_DS_SAM_INIT_FAILURE_CONSOLE __constant_cpu_to_le32(0xC00002ED)
-#define STATUS_UNFINISHED_CONTEXT_DELETED __constant_cpu_to_le32(0xC00002EE)
-#define STATUS_NO_TGT_REPLY __constant_cpu_to_le32(0xC00002EF)
-#define STATUS_OBJECTID_NOT_FOUND __constant_cpu_to_le32(0xC00002F0)
-#define STATUS_NO_IP_ADDRESSES __constant_cpu_to_le32(0xC00002F1)
-#define STATUS_WRONG_CREDENTIAL_HANDLE __constant_cpu_to_le32(0xC00002F2)
-#define STATUS_CRYPTO_SYSTEM_INVALID __constant_cpu_to_le32(0xC00002F3)
-#define STATUS_MAX_REFERRALS_EXCEEDED __constant_cpu_to_le32(0xC00002F4)
-#define STATUS_MUST_BE_KDC __constant_cpu_to_le32(0xC00002F5)
-#define STATUS_STRONG_CRYPTO_NOT_SUPPORTED __constant_cpu_to_le32(0xC00002F6)
-#define STATUS_TOO_MANY_PRINCIPALS __constant_cpu_to_le32(0xC00002F7)
-#define STATUS_NO_PA_DATA __constant_cpu_to_le32(0xC00002F8)
-#define STATUS_PKINIT_NAME_MISMATCH __constant_cpu_to_le32(0xC00002F9)
-#define STATUS_SMARTCARD_LOGON_REQUIRED __constant_cpu_to_le32(0xC00002FA)
-#define STATUS_KDC_INVALID_REQUEST __constant_cpu_to_le32(0xC00002FB)
-#define STATUS_KDC_UNABLE_TO_REFER __constant_cpu_to_le32(0xC00002FC)
-#define STATUS_KDC_UNKNOWN_ETYPE __constant_cpu_to_le32(0xC00002FD)
-#define STATUS_SHUTDOWN_IN_PROGRESS __constant_cpu_to_le32(0xC00002FE)
-#define STATUS_SERVER_SHUTDOWN_IN_PROGRESS __constant_cpu_to_le32(0xC00002FF)
-#define STATUS_NOT_SUPPORTED_ON_SBS __constant_cpu_to_le32(0xC0000300)
-#define STATUS_WMI_GUID_DISCONNECTED __constant_cpu_to_le32(0xC0000301)
-#define STATUS_WMI_ALREADY_DISABLED __constant_cpu_to_le32(0xC0000302)
-#define STATUS_WMI_ALREADY_ENABLED __constant_cpu_to_le32(0xC0000303)
-#define STATUS_MFT_TOO_FRAGMENTED __constant_cpu_to_le32(0xC0000304)
-#define STATUS_COPY_PROTECTION_FAILURE __constant_cpu_to_le32(0xC0000305)
-#define STATUS_CSS_AUTHENTICATION_FAILURE __constant_cpu_to_le32(0xC0000306)
-#define STATUS_CSS_KEY_NOT_PRESENT __constant_cpu_to_le32(0xC0000307)
-#define STATUS_CSS_KEY_NOT_ESTABLISHED __constant_cpu_to_le32(0xC0000308)
-#define STATUS_CSS_SCRAMBLED_SECTOR __constant_cpu_to_le32(0xC0000309)
-#define STATUS_CSS_REGION_MISMATCH __constant_cpu_to_le32(0xC000030A)
-#define STATUS_CSS_RESETS_EXHAUSTED __constant_cpu_to_le32(0xC000030B)
-#define STATUS_PKINIT_FAILURE __constant_cpu_to_le32(0xC0000320)
-#define STATUS_SMARTCARD_SUBSYSTEM_FAILURE __constant_cpu_to_le32(0xC0000321)
-#define STATUS_NO_KERB_KEY __constant_cpu_to_le32(0xC0000322)
-#define STATUS_HOST_DOWN __constant_cpu_to_le32(0xC0000350)
-#define STATUS_UNSUPPORTED_PREAUTH __constant_cpu_to_le32(0xC0000351)
-#define STATUS_EFS_ALG_BLOB_TOO_BIG __constant_cpu_to_le32(0xC0000352)
-#define STATUS_PORT_NOT_SET __constant_cpu_to_le32(0xC0000353)
-#define STATUS_DEBUGGER_INACTIVE __constant_cpu_to_le32(0xC0000354)
-#define STATUS_DS_VERSION_CHECK_FAILURE __constant_cpu_to_le32(0xC0000355)
-#define STATUS_AUDITING_DISABLED __constant_cpu_to_le32(0xC0000356)
-#define STATUS_PRENT4_MACHINE_ACCOUNT __constant_cpu_to_le32(0xC0000357)
-#define STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER __constant_cpu_to_le32(0xC0000358)
-#define STATUS_INVALID_IMAGE_WIN_32 __constant_cpu_to_le32(0xC0000359)
-#define STATUS_INVALID_IMAGE_WIN_64 __constant_cpu_to_le32(0xC000035A)
-#define STATUS_BAD_BINDINGS __constant_cpu_to_le32(0xC000035B)
-#define STATUS_NETWORK_SESSION_EXPIRED __constant_cpu_to_le32(0xC000035C)
-#define STATUS_APPHELP_BLOCK __constant_cpu_to_le32(0xC000035D)
-#define STATUS_ALL_SIDS_FILTERED __constant_cpu_to_le32(0xC000035E)
-#define STATUS_NOT_SAFE_MODE_DRIVER __constant_cpu_to_le32(0xC000035F)
-#define STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT __constant_cpu_to_le32(0xC0000361)
-#define STATUS_ACCESS_DISABLED_BY_POLICY_PATH __constant_cpu_to_le32(0xC0000362)
-#define STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER __constant_cpu_to_le32(0xC0000363)
-#define STATUS_ACCESS_DISABLED_BY_POLICY_OTHER __constant_cpu_to_le32(0xC0000364)
-#define STATUS_FAILED_DRIVER_ENTRY __constant_cpu_to_le32(0xC0000365)
-#define STATUS_DEVICE_ENUMERATION_ERROR __constant_cpu_to_le32(0xC0000366)
-#define STATUS_MOUNT_POINT_NOT_RESOLVED __constant_cpu_to_le32(0xC0000368)
-#define STATUS_INVALID_DEVICE_OBJECT_PARAMETER __constant_cpu_to_le32(0xC0000369)
-#define STATUS_MCA_OCCURED __constant_cpu_to_le32(0xC000036A)
-#define STATUS_DRIVER_BLOCKED_CRITICAL __constant_cpu_to_le32(0xC000036B)
-#define STATUS_DRIVER_BLOCKED __constant_cpu_to_le32(0xC000036C)
-#define STATUS_DRIVER_DATABASE_ERROR __constant_cpu_to_le32(0xC000036D)
-#define STATUS_SYSTEM_HIVE_TOO_LARGE __constant_cpu_to_le32(0xC000036E)
-#define STATUS_INVALID_IMPORT_OF_NON_DLL __constant_cpu_to_le32(0xC000036F)
-#define STATUS_NO_SECRETS __constant_cpu_to_le32(0xC0000371)
-#define STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY __constant_cpu_to_le32(0xC0000372)
-#define STATUS_FAILED_STACK_SWITCH __constant_cpu_to_le32(0xC0000373)
-#define STATUS_HEAP_CORRUPTION __constant_cpu_to_le32(0xC0000374)
-#define STATUS_SMARTCARD_WRONG_PIN __constant_cpu_to_le32(0xC0000380)
-#define STATUS_SMARTCARD_CARD_BLOCKED __constant_cpu_to_le32(0xC0000381)
-#define STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED __constant_cpu_to_le32(0xC0000382)
-#define STATUS_SMARTCARD_NO_CARD __constant_cpu_to_le32(0xC0000383)
-#define STATUS_SMARTCARD_NO_KEY_CONTAINER __constant_cpu_to_le32(0xC0000384)
-#define STATUS_SMARTCARD_NO_CERTIFICATE __constant_cpu_to_le32(0xC0000385)
-#define STATUS_SMARTCARD_NO_KEYSET __constant_cpu_to_le32(0xC0000386)
-#define STATUS_SMARTCARD_IO_ERROR __constant_cpu_to_le32(0xC0000387)
-#define STATUS_DOWNGRADE_DETECTED __constant_cpu_to_le32(0xC0000388)
-#define STATUS_SMARTCARD_CERT_REVOKED __constant_cpu_to_le32(0xC0000389)
-#define STATUS_ISSUING_CA_UNTRUSTED __constant_cpu_to_le32(0xC000038A)
-#define STATUS_REVOCATION_OFFLINE_C __constant_cpu_to_le32(0xC000038B)
-#define STATUS_PKINIT_CLIENT_FAILURE __constant_cpu_to_le32(0xC000038C)
-#define STATUS_SMARTCARD_CERT_EXPIRED __constant_cpu_to_le32(0xC000038D)
-#define STATUS_DRIVER_FAILED_PRIOR_UNLOAD __constant_cpu_to_le32(0xC000038E)
-#define STATUS_SMARTCARD_SILENT_CONTEXT __constant_cpu_to_le32(0xC000038F)
-#define STATUS_PER_USER_TRUST_QUOTA_EXCEEDED __constant_cpu_to_le32(0xC0000401)
-#define STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED __constant_cpu_to_le32(0xC0000402)
-#define STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED __constant_cpu_to_le32(0xC0000403)
-#define STATUS_DS_NAME_NOT_UNIQUE __constant_cpu_to_le32(0xC0000404)
-#define STATUS_DS_DUPLICATE_ID_FOUND __constant_cpu_to_le32(0xC0000405)
-#define STATUS_DS_GROUP_CONVERSION_ERROR __constant_cpu_to_le32(0xC0000406)
-#define STATUS_VOLSNAP_PREPARE_HIBERNATE __constant_cpu_to_le32(0xC0000407)
-#define STATUS_USER2USER_REQUIRED __constant_cpu_to_le32(0xC0000408)
-#define STATUS_STACK_BUFFER_OVERRUN __constant_cpu_to_le32(0xC0000409)
-#define STATUS_NO_S4U_PROT_SUPPORT __constant_cpu_to_le32(0xC000040A)
-#define STATUS_CROSSREALM_DELEGATION_FAILURE __constant_cpu_to_le32(0xC000040B)
-#define STATUS_REVOCATION_OFFLINE_KDC __constant_cpu_to_le32(0xC000040C)
-#define STATUS_ISSUING_CA_UNTRUSTED_KDC __constant_cpu_to_le32(0xC000040D)
-#define STATUS_KDC_CERT_EXPIRED __constant_cpu_to_le32(0xC000040E)
-#define STATUS_KDC_CERT_REVOKED __constant_cpu_to_le32(0xC000040F)
-#define STATUS_PARAMETER_QUOTA_EXCEEDED __constant_cpu_to_le32(0xC0000410)
-#define STATUS_HIBERNATION_FAILURE __constant_cpu_to_le32(0xC0000411)
-#define STATUS_DELAY_LOAD_FAILED __constant_cpu_to_le32(0xC0000412)
-#define STATUS_AUTHENTICATION_FIREWALL_FAILED __constant_cpu_to_le32(0xC0000413)
-#define STATUS_VDM_DISALLOWED __constant_cpu_to_le32(0xC0000414)
-#define STATUS_HUNG_DISPLAY_DRIVER_THREAD __constant_cpu_to_le32(0xC0000415)
-#define STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE __constant_cpu_to_le32(0xC0000416)
-#define STATUS_INVALID_CRUNTIME_PARAMETER __constant_cpu_to_le32(0xC0000417)
-#define STATUS_NTLM_BLOCKED __constant_cpu_to_le32(0xC0000418)
-#define STATUS_ASSERTION_FAILURE __constant_cpu_to_le32(0xC0000420)
-#define STATUS_VERIFIER_STOP __constant_cpu_to_le32(0xC0000421)
-#define STATUS_CALLBACK_POP_STACK __constant_cpu_to_le32(0xC0000423)
-#define STATUS_INCOMPATIBLE_DRIVER_BLOCKED __constant_cpu_to_le32(0xC0000424)
-#define STATUS_HIVE_UNLOADED __constant_cpu_to_le32(0xC0000425)
-#define STATUS_COMPRESSION_DISABLED __constant_cpu_to_le32(0xC0000426)
-#define STATUS_FILE_SYSTEM_LIMITATION __constant_cpu_to_le32(0xC0000427)
-#define STATUS_INVALID_IMAGE_HASH __constant_cpu_to_le32(0xC0000428)
-#define STATUS_NOT_CAPABLE __constant_cpu_to_le32(0xC0000429)
-#define STATUS_REQUEST_OUT_OF_SEQUENCE __constant_cpu_to_le32(0xC000042A)
-#define STATUS_IMPLEMENTATION_LIMIT __constant_cpu_to_le32(0xC000042B)
-#define STATUS_ELEVATION_REQUIRED __constant_cpu_to_le32(0xC000042C)
-#define STATUS_BEYOND_VDL __constant_cpu_to_le32(0xC0000432)
-#define STATUS_ENCOUNTERED_WRITE_IN_PROGRESS __constant_cpu_to_le32(0xC0000433)
-#define STATUS_PTE_CHANGED __constant_cpu_to_le32(0xC0000434)
-#define STATUS_PURGE_FAILED __constant_cpu_to_le32(0xC0000435)
-#define STATUS_CRED_REQUIRES_CONFIRMATION __constant_cpu_to_le32(0xC0000440)
-#define STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE __constant_cpu_to_le32(0xC0000441)
-#define STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER __constant_cpu_to_le32(0xC0000442)
-#define STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE __constant_cpu_to_le32(0xC0000443)
-#define STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE __constant_cpu_to_le32(0xC0000444)
-#define STATUS_CS_ENCRYPTION_FILE_NOT_CSE __constant_cpu_to_le32(0xC0000445)
-#define STATUS_INVALID_LABEL __constant_cpu_to_le32(0xC0000446)
-#define STATUS_DRIVER_PROCESS_TERMINATED __constant_cpu_to_le32(0xC0000450)
-#define STATUS_AMBIGUOUS_SYSTEM_DEVICE __constant_cpu_to_le32(0xC0000451)
-#define STATUS_SYSTEM_DEVICE_NOT_FOUND __constant_cpu_to_le32(0xC0000452)
-#define STATUS_RESTART_BOOT_APPLICATION __constant_cpu_to_le32(0xC0000453)
-#define STATUS_INVALID_TASK_NAME __constant_cpu_to_le32(0xC0000500)
-#define STATUS_INVALID_TASK_INDEX __constant_cpu_to_le32(0xC0000501)
-#define STATUS_THREAD_ALREADY_IN_TASK __constant_cpu_to_le32(0xC0000502)
-#define STATUS_CALLBACK_BYPASS __constant_cpu_to_le32(0xC0000503)
-#define STATUS_PORT_CLOSED __constant_cpu_to_le32(0xC0000700)
-#define STATUS_MESSAGE_LOST __constant_cpu_to_le32(0xC0000701)
-#define STATUS_INVALID_MESSAGE __constant_cpu_to_le32(0xC0000702)
-#define STATUS_REQUEST_CANCELED __constant_cpu_to_le32(0xC0000703)
-#define STATUS_RECURSIVE_DISPATCH __constant_cpu_to_le32(0xC0000704)
-#define STATUS_LPC_RECEIVE_BUFFER_EXPECTED __constant_cpu_to_le32(0xC0000705)
-#define STATUS_LPC_INVALID_CONNECTION_USAGE __constant_cpu_to_le32(0xC0000706)
-#define STATUS_LPC_REQUESTS_NOT_ALLOWED __constant_cpu_to_le32(0xC0000707)
-#define STATUS_RESOURCE_IN_USE __constant_cpu_to_le32(0xC0000708)
-#define STATUS_HARDWARE_MEMORY_ERROR __constant_cpu_to_le32(0xC0000709)
-#define STATUS_THREADPOOL_HANDLE_EXCEPTION __constant_cpu_to_le32(0xC000070A)
-#define STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED __constant_cpu_to_le32(0xC000070B)
-#define STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED __constant_cpu_to_le32(0xC000070C)
-#define STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED __constant_cpu_to_le32(0xC000070D)
-#define STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED __constant_cpu_to_le32(0xC000070E)
-#define STATUS_THREADPOOL_RELEASED_DURING_OPERATION __constant_cpu_to_le32(0xC000070F)
-#define STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING __constant_cpu_to_le32(0xC0000710)
-#define STATUS_APC_RETURNED_WHILE_IMPERSONATING __constant_cpu_to_le32(0xC0000711)
-#define STATUS_PROCESS_IS_PROTECTED __constant_cpu_to_le32(0xC0000712)
-#define STATUS_MCA_EXCEPTION __constant_cpu_to_le32(0xC0000713)
-#define STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE __constant_cpu_to_le32(0xC0000714)
-#define STATUS_SYMLINK_CLASS_DISABLED __constant_cpu_to_le32(0xC0000715)
-#define STATUS_INVALID_IDN_NORMALIZATION __constant_cpu_to_le32(0xC0000716)
-#define STATUS_NO_UNICODE_TRANSLATION __constant_cpu_to_le32(0xC0000717)
-#define STATUS_ALREADY_REGISTERED __constant_cpu_to_le32(0xC0000718)
-#define STATUS_CONTEXT_MISMATCH __constant_cpu_to_le32(0xC0000719)
-#define STATUS_PORT_ALREADY_HAS_COMPLETION_LIST __constant_cpu_to_le32(0xC000071A)
-#define STATUS_CALLBACK_RETURNED_THREAD_PRIORITY __constant_cpu_to_le32(0xC000071B)
-#define STATUS_INVALID_THREAD __constant_cpu_to_le32(0xC000071C)
-#define STATUS_CALLBACK_RETURNED_TRANSACTION __constant_cpu_to_le32(0xC000071D)
-#define STATUS_CALLBACK_RETURNED_LDR_LOCK __constant_cpu_to_le32(0xC000071E)
-#define STATUS_CALLBACK_RETURNED_LANG __constant_cpu_to_le32(0xC000071F)
-#define STATUS_CALLBACK_RETURNED_PRI_BACK __constant_cpu_to_le32(0xC0000720)
-#define STATUS_CALLBACK_RETURNED_THREAD_AFFINITY __constant_cpu_to_le32(0xC0000721)
-#define STATUS_DISK_REPAIR_DISABLED __constant_cpu_to_le32(0xC0000800)
-#define STATUS_DS_DOMAIN_RENAME_IN_PROGRESS __constant_cpu_to_le32(0xC0000801)
-#define STATUS_DISK_QUOTA_EXCEEDED __constant_cpu_to_le32(0xC0000802)
-#define STATUS_CONTENT_BLOCKED __constant_cpu_to_le32(0xC0000804)
-#define STATUS_BAD_CLUSTERS __constant_cpu_to_le32(0xC0000805)
-#define STATUS_VOLUME_DIRTY __constant_cpu_to_le32(0xC0000806)
-#define STATUS_FILE_CHECKED_OUT __constant_cpu_to_le32(0xC0000901)
-#define STATUS_CHECKOUT_REQUIRED __constant_cpu_to_le32(0xC0000902)
-#define STATUS_BAD_FILE_TYPE __constant_cpu_to_le32(0xC0000903)
-#define STATUS_FILE_TOO_LARGE __constant_cpu_to_le32(0xC0000904)
-#define STATUS_FORMS_AUTH_REQUIRED __constant_cpu_to_le32(0xC0000905)
-#define STATUS_VIRUS_INFECTED __constant_cpu_to_le32(0xC0000906)
-#define STATUS_VIRUS_DELETED __constant_cpu_to_le32(0xC0000907)
-#define STATUS_BAD_MCFG_TABLE __constant_cpu_to_le32(0xC0000908)
-#define STATUS_WOW_ASSERTION __constant_cpu_to_le32(0xC0009898)
-#define STATUS_INVALID_SIGNATURE __constant_cpu_to_le32(0xC000A000)
-#define STATUS_HMAC_NOT_SUPPORTED __constant_cpu_to_le32(0xC000A001)
-#define STATUS_IPSEC_QUEUE_OVERFLOW __constant_cpu_to_le32(0xC000A010)
-#define STATUS_ND_QUEUE_OVERFLOW __constant_cpu_to_le32(0xC000A011)
-#define STATUS_HOPLIMIT_EXCEEDED __constant_cpu_to_le32(0xC000A012)
-#define STATUS_PROTOCOL_NOT_SUPPORTED __constant_cpu_to_le32(0xC000A013)
-#define STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED __constant_cpu_to_le32(0xC000A080)
-#define STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR __constant_cpu_to_le32(0xC000A081)
-#define STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR __constant_cpu_to_le32(0xC000A082)
-#define STATUS_XML_PARSE_ERROR __constant_cpu_to_le32(0xC000A083)
-#define STATUS_XMLDSIG_ERROR __constant_cpu_to_le32(0xC000A084)
-#define STATUS_WRONG_COMPARTMENT __constant_cpu_to_le32(0xC000A085)
-#define STATUS_AUTHIP_FAILURE __constant_cpu_to_le32(0xC000A086)
-#define DBG_NO_STATE_CHANGE __constant_cpu_to_le32(0xC0010001)
-#define DBG_APP_NOT_IDLE __constant_cpu_to_le32(0xC0010002)
-#define RPC_NT_INVALID_STRING_BINDING __constant_cpu_to_le32(0xC0020001)
-#define RPC_NT_WRONG_KIND_OF_BINDING __constant_cpu_to_le32(0xC0020002)
-#define RPC_NT_INVALID_BINDING __constant_cpu_to_le32(0xC0020003)
-#define RPC_NT_PROTSEQ_NOT_SUPPORTED __constant_cpu_to_le32(0xC0020004)
-#define RPC_NT_INVALID_RPC_PROTSEQ __constant_cpu_to_le32(0xC0020005)
-#define RPC_NT_INVALID_STRING_UUID __constant_cpu_to_le32(0xC0020006)
-#define RPC_NT_INVALID_ENDPOINT_FORMAT __constant_cpu_to_le32(0xC0020007)
-#define RPC_NT_INVALID_NET_ADDR __constant_cpu_to_le32(0xC0020008)
-#define RPC_NT_NO_ENDPOINT_FOUND __constant_cpu_to_le32(0xC0020009)
-#define RPC_NT_INVALID_TIMEOUT __constant_cpu_to_le32(0xC002000A)
-#define RPC_NT_OBJECT_NOT_FOUND __constant_cpu_to_le32(0xC002000B)
-#define RPC_NT_ALREADY_REGISTERED __constant_cpu_to_le32(0xC002000C)
-#define RPC_NT_TYPE_ALREADY_REGISTERED __constant_cpu_to_le32(0xC002000D)
-#define RPC_NT_ALREADY_LISTENING __constant_cpu_to_le32(0xC002000E)
-#define RPC_NT_NO_PROTSEQS_REGISTERED __constant_cpu_to_le32(0xC002000F)
-#define RPC_NT_NOT_LISTENING __constant_cpu_to_le32(0xC0020010)
-#define RPC_NT_UNKNOWN_MGR_TYPE __constant_cpu_to_le32(0xC0020011)
-#define RPC_NT_UNKNOWN_IF __constant_cpu_to_le32(0xC0020012)
-#define RPC_NT_NO_BINDINGS __constant_cpu_to_le32(0xC0020013)
-#define RPC_NT_NO_PROTSEQS __constant_cpu_to_le32(0xC0020014)
-#define RPC_NT_CANT_CREATE_ENDPOINT __constant_cpu_to_le32(0xC0020015)
-#define RPC_NT_OUT_OF_RESOURCES __constant_cpu_to_le32(0xC0020016)
-#define RPC_NT_SERVER_UNAVAILABLE __constant_cpu_to_le32(0xC0020017)
-#define RPC_NT_SERVER_TOO_BUSY __constant_cpu_to_le32(0xC0020018)
-#define RPC_NT_INVALID_NETWORK_OPTIONS __constant_cpu_to_le32(0xC0020019)
-#define RPC_NT_NO_CALL_ACTIVE __constant_cpu_to_le32(0xC002001A)
-#define RPC_NT_CALL_FAILED __constant_cpu_to_le32(0xC002001B)
-#define RPC_NT_CALL_FAILED_DNE __constant_cpu_to_le32(0xC002001C)
-#define RPC_NT_PROTOCOL_ERROR __constant_cpu_to_le32(0xC002001D)
-#define RPC_NT_UNSUPPORTED_TRANS_SYN __constant_cpu_to_le32(0xC002001F)
-#define RPC_NT_UNSUPPORTED_TYPE __constant_cpu_to_le32(0xC0020021)
-#define RPC_NT_INVALID_TAG __constant_cpu_to_le32(0xC0020022)
-#define RPC_NT_INVALID_BOUND __constant_cpu_to_le32(0xC0020023)
-#define RPC_NT_NO_ENTRY_NAME __constant_cpu_to_le32(0xC0020024)
-#define RPC_NT_INVALID_NAME_SYNTAX __constant_cpu_to_le32(0xC0020025)
-#define RPC_NT_UNSUPPORTED_NAME_SYNTAX __constant_cpu_to_le32(0xC0020026)
-#define RPC_NT_UUID_NO_ADDRESS __constant_cpu_to_le32(0xC0020028)
-#define RPC_NT_DUPLICATE_ENDPOINT __constant_cpu_to_le32(0xC0020029)
-#define RPC_NT_UNKNOWN_AUTHN_TYPE __constant_cpu_to_le32(0xC002002A)
-#define RPC_NT_MAX_CALLS_TOO_SMALL __constant_cpu_to_le32(0xC002002B)
-#define RPC_NT_STRING_TOO_LONG __constant_cpu_to_le32(0xC002002C)
-#define RPC_NT_PROTSEQ_NOT_FOUND __constant_cpu_to_le32(0xC002002D)
-#define RPC_NT_PROCNUM_OUT_OF_RANGE __constant_cpu_to_le32(0xC002002E)
-#define RPC_NT_BINDING_HAS_NO_AUTH __constant_cpu_to_le32(0xC002002F)
-#define RPC_NT_UNKNOWN_AUTHN_SERVICE __constant_cpu_to_le32(0xC0020030)
-#define RPC_NT_UNKNOWN_AUTHN_LEVEL __constant_cpu_to_le32(0xC0020031)
-#define RPC_NT_INVALID_AUTH_IDENTITY __constant_cpu_to_le32(0xC0020032)
-#define RPC_NT_UNKNOWN_AUTHZ_SERVICE __constant_cpu_to_le32(0xC0020033)
-#define EPT_NT_INVALID_ENTRY __constant_cpu_to_le32(0xC0020034)
-#define EPT_NT_CANT_PERFORM_OP __constant_cpu_to_le32(0xC0020035)
-#define EPT_NT_NOT_REGISTERED __constant_cpu_to_le32(0xC0020036)
-#define RPC_NT_NOTHING_TO_EXPORT __constant_cpu_to_le32(0xC0020037)
-#define RPC_NT_INCOMPLETE_NAME __constant_cpu_to_le32(0xC0020038)
-#define RPC_NT_INVALID_VERS_OPTION __constant_cpu_to_le32(0xC0020039)
-#define RPC_NT_NO_MORE_MEMBERS __constant_cpu_to_le32(0xC002003A)
-#define RPC_NT_NOT_ALL_OBJS_UNEXPORTED __constant_cpu_to_le32(0xC002003B)
-#define RPC_NT_INTERFACE_NOT_FOUND __constant_cpu_to_le32(0xC002003C)
-#define RPC_NT_ENTRY_ALREADY_EXISTS __constant_cpu_to_le32(0xC002003D)
-#define RPC_NT_ENTRY_NOT_FOUND __constant_cpu_to_le32(0xC002003E)
-#define RPC_NT_NAME_SERVICE_UNAVAILABLE __constant_cpu_to_le32(0xC002003F)
-#define RPC_NT_INVALID_NAF_ID __constant_cpu_to_le32(0xC0020040)
-#define RPC_NT_CANNOT_SUPPORT __constant_cpu_to_le32(0xC0020041)
-#define RPC_NT_NO_CONTEXT_AVAILABLE __constant_cpu_to_le32(0xC0020042)
-#define RPC_NT_INTERNAL_ERROR __constant_cpu_to_le32(0xC0020043)
-#define RPC_NT_ZERO_DIVIDE __constant_cpu_to_le32(0xC0020044)
-#define RPC_NT_ADDRESS_ERROR __constant_cpu_to_le32(0xC0020045)
-#define RPC_NT_FP_DIV_ZERO __constant_cpu_to_le32(0xC0020046)
-#define RPC_NT_FP_UNDERFLOW __constant_cpu_to_le32(0xC0020047)
-#define RPC_NT_FP_OVERFLOW __constant_cpu_to_le32(0xC0020048)
-#define RPC_NT_CALL_IN_PROGRESS __constant_cpu_to_le32(0xC0020049)
-#define RPC_NT_NO_MORE_BINDINGS __constant_cpu_to_le32(0xC002004A)
-#define RPC_NT_GROUP_MEMBER_NOT_FOUND __constant_cpu_to_le32(0xC002004B)
-#define EPT_NT_CANT_CREATE __constant_cpu_to_le32(0xC002004C)
-#define RPC_NT_INVALID_OBJECT __constant_cpu_to_le32(0xC002004D)
-#define RPC_NT_NO_INTERFACES __constant_cpu_to_le32(0xC002004F)
-#define RPC_NT_CALL_CANCELLED __constant_cpu_to_le32(0xC0020050)
-#define RPC_NT_BINDING_INCOMPLETE __constant_cpu_to_le32(0xC0020051)
-#define RPC_NT_COMM_FAILURE __constant_cpu_to_le32(0xC0020052)
-#define RPC_NT_UNSUPPORTED_AUTHN_LEVEL __constant_cpu_to_le32(0xC0020053)
-#define RPC_NT_NO_PRINC_NAME __constant_cpu_to_le32(0xC0020054)
-#define RPC_NT_NOT_RPC_ERROR __constant_cpu_to_le32(0xC0020055)
-#define RPC_NT_SEC_PKG_ERROR __constant_cpu_to_le32(0xC0020057)
-#define RPC_NT_NOT_CANCELLED __constant_cpu_to_le32(0xC0020058)
-#define RPC_NT_INVALID_ASYNC_HANDLE __constant_cpu_to_le32(0xC0020062)
-#define RPC_NT_INVALID_ASYNC_CALL __constant_cpu_to_le32(0xC0020063)
-#define RPC_NT_PROXY_ACCESS_DENIED __constant_cpu_to_le32(0xC0020064)
-#define RPC_NT_NO_MORE_ENTRIES __constant_cpu_to_le32(0xC0030001)
-#define RPC_NT_SS_CHAR_TRANS_OPEN_FAIL __constant_cpu_to_le32(0xC0030002)
-#define RPC_NT_SS_CHAR_TRANS_SHORT_FILE __constant_cpu_to_le32(0xC0030003)
-#define RPC_NT_SS_IN_NULL_CONTEXT __constant_cpu_to_le32(0xC0030004)
-#define RPC_NT_SS_CONTEXT_MISMATCH __constant_cpu_to_le32(0xC0030005)
-#define RPC_NT_SS_CONTEXT_DAMAGED __constant_cpu_to_le32(0xC0030006)
-#define RPC_NT_SS_HANDLES_MISMATCH __constant_cpu_to_le32(0xC0030007)
-#define RPC_NT_SS_CANNOT_GET_CALL_HANDLE __constant_cpu_to_le32(0xC0030008)
-#define RPC_NT_NULL_REF_POINTER __constant_cpu_to_le32(0xC0030009)
-#define RPC_NT_ENUM_VALUE_OUT_OF_RANGE __constant_cpu_to_le32(0xC003000A)
-#define RPC_NT_BYTE_COUNT_TOO_SMALL __constant_cpu_to_le32(0xC003000B)
-#define RPC_NT_BAD_STUB_DATA __constant_cpu_to_le32(0xC003000C)
-#define RPC_NT_INVALID_ES_ACTION __constant_cpu_to_le32(0xC0030059)
-#define RPC_NT_WRONG_ES_VERSION __constant_cpu_to_le32(0xC003005A)
-#define RPC_NT_WRONG_STUB_VERSION __constant_cpu_to_le32(0xC003005B)
-#define RPC_NT_INVALID_PIPE_OBJECT __constant_cpu_to_le32(0xC003005C)
-#define RPC_NT_INVALID_PIPE_OPERATION __constant_cpu_to_le32(0xC003005D)
-#define RPC_NT_WRONG_PIPE_VERSION __constant_cpu_to_le32(0xC003005E)
-#define RPC_NT_PIPE_CLOSED __constant_cpu_to_le32(0xC003005F)
-#define RPC_NT_PIPE_DISCIPLINE_ERROR __constant_cpu_to_le32(0xC0030060)
-#define RPC_NT_PIPE_EMPTY __constant_cpu_to_le32(0xC0030061)
-#define STATUS_PNP_BAD_MPS_TABLE __constant_cpu_to_le32(0xC0040035)
-#define STATUS_PNP_TRANSLATION_FAILED __constant_cpu_to_le32(0xC0040036)
-#define STATUS_PNP_IRQ_TRANSLATION_FAILED __constant_cpu_to_le32(0xC0040037)
-#define STATUS_PNP_INVALID_ID __constant_cpu_to_le32(0xC0040038)
-#define STATUS_IO_REISSUE_AS_CACHED __constant_cpu_to_le32(0xC0040039)
-#define STATUS_CTX_WINSTATION_NAME_INVALID __constant_cpu_to_le32(0xC00A0001)
-#define STATUS_CTX_INVALID_PD __constant_cpu_to_le32(0xC00A0002)
-#define STATUS_CTX_PD_NOT_FOUND __constant_cpu_to_le32(0xC00A0003)
-#define STATUS_CTX_CLOSE_PENDING __constant_cpu_to_le32(0xC00A0006)
-#define STATUS_CTX_NO_OUTBUF __constant_cpu_to_le32(0xC00A0007)
-#define STATUS_CTX_MODEM_INF_NOT_FOUND __constant_cpu_to_le32(0xC00A0008)
-#define STATUS_CTX_INVALID_MODEMNAME __constant_cpu_to_le32(0xC00A0009)
-#define STATUS_CTX_RESPONSE_ERROR __constant_cpu_to_le32(0xC00A000A)
-#define STATUS_CTX_MODEM_RESPONSE_TIMEOUT __constant_cpu_to_le32(0xC00A000B)
-#define STATUS_CTX_MODEM_RESPONSE_NO_CARRIER __constant_cpu_to_le32(0xC00A000C)
-#define STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE __constant_cpu_to_le32(0xC00A000D)
-#define STATUS_CTX_MODEM_RESPONSE_BUSY __constant_cpu_to_le32(0xC00A000E)
-#define STATUS_CTX_MODEM_RESPONSE_VOICE __constant_cpu_to_le32(0xC00A000F)
-#define STATUS_CTX_TD_ERROR __constant_cpu_to_le32(0xC00A0010)
-#define STATUS_CTX_LICENSE_CLIENT_INVALID __constant_cpu_to_le32(0xC00A0012)
-#define STATUS_CTX_LICENSE_NOT_AVAILABLE __constant_cpu_to_le32(0xC00A0013)
-#define STATUS_CTX_LICENSE_EXPIRED __constant_cpu_to_le32(0xC00A0014)
-#define STATUS_CTX_WINSTATION_NOT_FOUND __constant_cpu_to_le32(0xC00A0015)
-#define STATUS_CTX_WINSTATION_NAME_COLLISION __constant_cpu_to_le32(0xC00A0016)
-#define STATUS_CTX_WINSTATION_BUSY __constant_cpu_to_le32(0xC00A0017)
-#define STATUS_CTX_BAD_VIDEO_MODE __constant_cpu_to_le32(0xC00A0018)
-#define STATUS_CTX_GRAPHICS_INVALID __constant_cpu_to_le32(0xC00A0022)
-#define STATUS_CTX_NOT_CONSOLE __constant_cpu_to_le32(0xC00A0024)
-#define STATUS_CTX_CLIENT_QUERY_TIMEOUT __constant_cpu_to_le32(0xC00A0026)
-#define STATUS_CTX_CONSOLE_DISCONNECT __constant_cpu_to_le32(0xC00A0027)
-#define STATUS_CTX_CONSOLE_CONNECT __constant_cpu_to_le32(0xC00A0028)
-#define STATUS_CTX_SHADOW_DENIED __constant_cpu_to_le32(0xC00A002A)
-#define STATUS_CTX_WINSTATION_ACCESS_DENIED __constant_cpu_to_le32(0xC00A002B)
-#define STATUS_CTX_INVALID_WD __constant_cpu_to_le32(0xC00A002E)
-#define STATUS_CTX_WD_NOT_FOUND __constant_cpu_to_le32(0xC00A002F)
-#define STATUS_CTX_SHADOW_INVALID __constant_cpu_to_le32(0xC00A0030)
-#define STATUS_CTX_SHADOW_DISABLED __constant_cpu_to_le32(0xC00A0031)
-#define STATUS_RDP_PROTOCOL_ERROR __constant_cpu_to_le32(0xC00A0032)
-#define STATUS_CTX_CLIENT_LICENSE_NOT_SET __constant_cpu_to_le32(0xC00A0033)
-#define STATUS_CTX_CLIENT_LICENSE_IN_USE __constant_cpu_to_le32(0xC00A0034)
-#define STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE __constant_cpu_to_le32(0xC00A0035)
-#define STATUS_CTX_SHADOW_NOT_RUNNING __constant_cpu_to_le32(0xC00A0036)
-#define STATUS_CTX_LOGON_DISABLED __constant_cpu_to_le32(0xC00A0037)
-#define STATUS_CTX_SECURITY_LAYER_ERROR __constant_cpu_to_le32(0xC00A0038)
-#define STATUS_TS_INCOMPATIBLE_SESSIONS __constant_cpu_to_le32(0xC00A0039)
-#define STATUS_MUI_FILE_NOT_FOUND __constant_cpu_to_le32(0xC00B0001)
-#define STATUS_MUI_INVALID_FILE __constant_cpu_to_le32(0xC00B0002)
-#define STATUS_MUI_INVALID_RC_CONFIG __constant_cpu_to_le32(0xC00B0003)
-#define STATUS_MUI_INVALID_LOCALE_NAME __constant_cpu_to_le32(0xC00B0004)
-#define STATUS_MUI_INVALID_ULTIMATEFALLBACK_NAME __constant_cpu_to_le32(0xC00B0005)
-#define STATUS_MUI_FILE_NOT_LOADED __constant_cpu_to_le32(0xC00B0006)
-#define STATUS_RESOURCE_ENUM_USER_STOP __constant_cpu_to_le32(0xC00B0007)
-#define STATUS_CLUSTER_INVALID_NODE __constant_cpu_to_le32(0xC0130001)
-#define STATUS_CLUSTER_NODE_EXISTS __constant_cpu_to_le32(0xC0130002)
-#define STATUS_CLUSTER_JOIN_IN_PROGRESS __constant_cpu_to_le32(0xC0130003)
-#define STATUS_CLUSTER_NODE_NOT_FOUND __constant_cpu_to_le32(0xC0130004)
-#define STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND __constant_cpu_to_le32(0xC0130005)
-#define STATUS_CLUSTER_NETWORK_EXISTS __constant_cpu_to_le32(0xC0130006)
-#define STATUS_CLUSTER_NETWORK_NOT_FOUND __constant_cpu_to_le32(0xC0130007)
-#define STATUS_CLUSTER_NETINTERFACE_EXISTS __constant_cpu_to_le32(0xC0130008)
-#define STATUS_CLUSTER_NETINTERFACE_NOT_FOUND __constant_cpu_to_le32(0xC0130009)
-#define STATUS_CLUSTER_INVALID_REQUEST __constant_cpu_to_le32(0xC013000A)
-#define STATUS_CLUSTER_INVALID_NETWORK_PROVIDER __constant_cpu_to_le32(0xC013000B)
-#define STATUS_CLUSTER_NODE_DOWN __constant_cpu_to_le32(0xC013000C)
-#define STATUS_CLUSTER_NODE_UNREACHABLE __constant_cpu_to_le32(0xC013000D)
-#define STATUS_CLUSTER_NODE_NOT_MEMBER __constant_cpu_to_le32(0xC013000E)
-#define STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS __constant_cpu_to_le32(0xC013000F)
-#define STATUS_CLUSTER_INVALID_NETWORK __constant_cpu_to_le32(0xC0130010)
-#define STATUS_CLUSTER_NO_NET_ADAPTERS __constant_cpu_to_le32(0xC0130011)
-#define STATUS_CLUSTER_NODE_UP __constant_cpu_to_le32(0xC0130012)
-#define STATUS_CLUSTER_NODE_PAUSED __constant_cpu_to_le32(0xC0130013)
-#define STATUS_CLUSTER_NODE_NOT_PAUSED __constant_cpu_to_le32(0xC0130014)
-#define STATUS_CLUSTER_NO_SECURITY_CONTEXT __constant_cpu_to_le32(0xC0130015)
-#define STATUS_CLUSTER_NETWORK_NOT_INTERNAL __constant_cpu_to_le32(0xC0130016)
-#define STATUS_CLUSTER_POISONED __constant_cpu_to_le32(0xC0130017)
-#define STATUS_ACPI_INVALID_OPCODE __constant_cpu_to_le32(0xC0140001)
-#define STATUS_ACPI_STACK_OVERFLOW __constant_cpu_to_le32(0xC0140002)
-#define STATUS_ACPI_ASSERT_FAILED __constant_cpu_to_le32(0xC0140003)
-#define STATUS_ACPI_INVALID_INDEX __constant_cpu_to_le32(0xC0140004)
-#define STATUS_ACPI_INVALID_ARGUMENT __constant_cpu_to_le32(0xC0140005)
-#define STATUS_ACPI_FATAL __constant_cpu_to_le32(0xC0140006)
-#define STATUS_ACPI_INVALID_SUPERNAME __constant_cpu_to_le32(0xC0140007)
-#define STATUS_ACPI_INVALID_ARGTYPE __constant_cpu_to_le32(0xC0140008)
-#define STATUS_ACPI_INVALID_OBJTYPE __constant_cpu_to_le32(0xC0140009)
-#define STATUS_ACPI_INVALID_TARGETTYPE __constant_cpu_to_le32(0xC014000A)
-#define STATUS_ACPI_INCORRECT_ARGUMENT_COUNT __constant_cpu_to_le32(0xC014000B)
-#define STATUS_ACPI_ADDRESS_NOT_MAPPED __constant_cpu_to_le32(0xC014000C)
-#define STATUS_ACPI_INVALID_EVENTTYPE __constant_cpu_to_le32(0xC014000D)
-#define STATUS_ACPI_HANDLER_COLLISION __constant_cpu_to_le32(0xC014000E)
-#define STATUS_ACPI_INVALID_DATA __constant_cpu_to_le32(0xC014000F)
-#define STATUS_ACPI_INVALID_REGION __constant_cpu_to_le32(0xC0140010)
-#define STATUS_ACPI_INVALID_ACCESS_SIZE __constant_cpu_to_le32(0xC0140011)
-#define STATUS_ACPI_ACQUIRE_GLOBAL_LOCK __constant_cpu_to_le32(0xC0140012)
-#define STATUS_ACPI_ALREADY_INITIALIZED __constant_cpu_to_le32(0xC0140013)
-#define STATUS_ACPI_NOT_INITIALIZED __constant_cpu_to_le32(0xC0140014)
-#define STATUS_ACPI_INVALID_MUTEX_LEVEL __constant_cpu_to_le32(0xC0140015)
-#define STATUS_ACPI_MUTEX_NOT_OWNED __constant_cpu_to_le32(0xC0140016)
-#define STATUS_ACPI_MUTEX_NOT_OWNER __constant_cpu_to_le32(0xC0140017)
-#define STATUS_ACPI_RS_ACCESS __constant_cpu_to_le32(0xC0140018)
-#define STATUS_ACPI_INVALID_TABLE __constant_cpu_to_le32(0xC0140019)
-#define STATUS_ACPI_REG_HANDLER_FAILED __constant_cpu_to_le32(0xC0140020)
-#define STATUS_ACPI_POWER_REQUEST_FAILED __constant_cpu_to_le32(0xC0140021)
-#define STATUS_SXS_SECTION_NOT_FOUND __constant_cpu_to_le32(0xC0150001)
-#define STATUS_SXS_CANT_GEN_ACTCTX __constant_cpu_to_le32(0xC0150002)
-#define STATUS_SXS_INVALID_ACTCTXDATA_FORMAT __constant_cpu_to_le32(0xC0150003)
-#define STATUS_SXS_ASSEMBLY_NOT_FOUND __constant_cpu_to_le32(0xC0150004)
-#define STATUS_SXS_MANIFEST_FORMAT_ERROR __constant_cpu_to_le32(0xC0150005)
-#define STATUS_SXS_MANIFEST_PARSE_ERROR __constant_cpu_to_le32(0xC0150006)
-#define STATUS_SXS_ACTIVATION_CONTEXT_DISABLED __constant_cpu_to_le32(0xC0150007)
-#define STATUS_SXS_KEY_NOT_FOUND __constant_cpu_to_le32(0xC0150008)
-#define STATUS_SXS_VERSION_CONFLICT __constant_cpu_to_le32(0xC0150009)
-#define STATUS_SXS_WRONG_SECTION_TYPE __constant_cpu_to_le32(0xC015000A)
-#define STATUS_SXS_THREAD_QUERIES_DISABLED __constant_cpu_to_le32(0xC015000B)
-#define STATUS_SXS_ASSEMBLY_MISSING __constant_cpu_to_le32(0xC015000C)
-#define STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET __constant_cpu_to_le32(0xC015000E)
-#define STATUS_SXS_EARLY_DEACTIVATION __constant_cpu_to_le32(0xC015000F)
-#define STATUS_SXS_INVALID_DEACTIVATION __constant_cpu_to_le32(0xC0150010)
-#define STATUS_SXS_MULTIPLE_DEACTIVATION __constant_cpu_to_le32(0xC0150011)
-#define STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY __constant_cpu_to_le32(0xC0150012)
-#define STATUS_SXS_PROCESS_TERMINATION_REQUESTED __constant_cpu_to_le32(0xC0150013)
-#define STATUS_SXS_CORRUPT_ACTIVATION_STACK __constant_cpu_to_le32(0xC0150014)
-#define STATUS_SXS_CORRUPTION __constant_cpu_to_le32(0xC0150015)
-#define STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE __constant_cpu_to_le32(0xC0150016)
-#define STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME __constant_cpu_to_le32(0xC0150017)
-#define STATUS_SXS_IDENTITY_DUPLICATE_ATTRIBUTE __constant_cpu_to_le32(0xC0150018)
-#define STATUS_SXS_IDENTITY_PARSE_ERROR __constant_cpu_to_le32(0xC0150019)
-#define STATUS_SXS_COMPONENT_STORE_CORRUPT __constant_cpu_to_le32(0xC015001A)
-#define STATUS_SXS_FILE_HASH_MISMATCH __constant_cpu_to_le32(0xC015001B)
-#define STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT __constant_cpu_to_le32(0xC015001C)
-#define STATUS_SXS_IDENTITIES_DIFFERENT __constant_cpu_to_le32(0xC015001D)
-#define STATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT __constant_cpu_to_le32(0xC015001E)
-#define STATUS_SXS_FILE_NOT_PART_OF_ASSEMBLY __constant_cpu_to_le32(0xC015001F)
-#define STATUS_ADVANCED_INSTALLER_FAILED __constant_cpu_to_le32(0xC0150020)
-#define STATUS_XML_ENCODING_MISMATCH __constant_cpu_to_le32(0xC0150021)
-#define STATUS_SXS_MANIFEST_TOO_BIG __constant_cpu_to_le32(0xC0150022)
-#define STATUS_SXS_SETTING_NOT_REGISTERED __constant_cpu_to_le32(0xC0150023)
-#define STATUS_SXS_TRANSACTION_CLOSURE_INCOMPLETE __constant_cpu_to_le32(0xC0150024)
-#define STATUS_SMI_PRIMITIVE_INSTALLER_FAILED __constant_cpu_to_le32(0xC0150025)
-#define STATUS_GENERIC_COMMAND_FAILED __constant_cpu_to_le32(0xC0150026)
-#define STATUS_SXS_FILE_HASH_MISSING __constant_cpu_to_le32(0xC0150027)
-#define STATUS_TRANSACTIONAL_CONFLICT __constant_cpu_to_le32(0xC0190001)
-#define STATUS_INVALID_TRANSACTION __constant_cpu_to_le32(0xC0190002)
-#define STATUS_TRANSACTION_NOT_ACTIVE __constant_cpu_to_le32(0xC0190003)
-#define STATUS_TM_INITIALIZATION_FAILED __constant_cpu_to_le32(0xC0190004)
-#define STATUS_RM_NOT_ACTIVE __constant_cpu_to_le32(0xC0190005)
-#define STATUS_RM_METADATA_CORRUPT __constant_cpu_to_le32(0xC0190006)
-#define STATUS_TRANSACTION_NOT_JOINED __constant_cpu_to_le32(0xC0190007)
-#define STATUS_DIRECTORY_NOT_RM __constant_cpu_to_le32(0xC0190008)
-#define STATUS_TRANSACTIONS_UNSUPPORTED_REMOTE __constant_cpu_to_le32(0xC019000A)
-#define STATUS_LOG_RESIZE_INVALID_SIZE __constant_cpu_to_le32(0xC019000B)
-#define STATUS_REMOTE_FILE_VERSION_MISMATCH __constant_cpu_to_le32(0xC019000C)
-#define STATUS_CRM_PROTOCOL_ALREADY_EXISTS __constant_cpu_to_le32(0xC019000F)
-#define STATUS_TRANSACTION_PROPAGATION_FAILED __constant_cpu_to_le32(0xC0190010)
-#define STATUS_CRM_PROTOCOL_NOT_FOUND __constant_cpu_to_le32(0xC0190011)
-#define STATUS_TRANSACTION_SUPERIOR_EXISTS __constant_cpu_to_le32(0xC0190012)
-#define STATUS_TRANSACTION_REQUEST_NOT_VALID __constant_cpu_to_le32(0xC0190013)
-#define STATUS_TRANSACTION_NOT_REQUESTED __constant_cpu_to_le32(0xC0190014)
-#define STATUS_TRANSACTION_ALREADY_ABORTED __constant_cpu_to_le32(0xC0190015)
-#define STATUS_TRANSACTION_ALREADY_COMMITTED __constant_cpu_to_le32(0xC0190016)
-#define STATUS_TRANSACTION_INVALID_MARSHALL_BUFFER __constant_cpu_to_le32(0xC0190017)
-#define STATUS_CURRENT_TRANSACTION_NOT_VALID __constant_cpu_to_le32(0xC0190018)
-#define STATUS_LOG_GROWTH_FAILED __constant_cpu_to_le32(0xC0190019)
-#define STATUS_OBJECT_NO_LONGER_EXISTS __constant_cpu_to_le32(0xC0190021)
-#define STATUS_STREAM_MINIVERSION_NOT_FOUND __constant_cpu_to_le32(0xC0190022)
-#define STATUS_STREAM_MINIVERSION_NOT_VALID __constant_cpu_to_le32(0xC0190023)
-#define STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION __constant_cpu_to_le32(0xC0190024)
-#define STATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT __constant_cpu_to_le32(0xC0190025)
-#define STATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONS __constant_cpu_to_le32(0xC0190026)
-#define STATUS_HANDLE_NO_LONGER_VALID __constant_cpu_to_le32(0xC0190028)
-#define STATUS_LOG_CORRUPTION_DETECTED __constant_cpu_to_le32(0xC0190030)
-#define STATUS_RM_DISCONNECTED __constant_cpu_to_le32(0xC0190032)
-#define STATUS_ENLISTMENT_NOT_SUPERIOR __constant_cpu_to_le32(0xC0190033)
-#define STATUS_FILE_IDENTITY_NOT_PERSISTENT __constant_cpu_to_le32(0xC0190036)
-#define STATUS_CANT_BREAK_TRANSACTIONAL_DEPENDENCY __constant_cpu_to_le32(0xC0190037)
-#define STATUS_CANT_CROSS_RM_BOUNDARY __constant_cpu_to_le32(0xC0190038)
-#define STATUS_TXF_DIR_NOT_EMPTY __constant_cpu_to_le32(0xC0190039)
-#define STATUS_INDOUBT_TRANSACTIONS_EXIST __constant_cpu_to_le32(0xC019003A)
-#define STATUS_TM_VOLATILE __constant_cpu_to_le32(0xC019003B)
-#define STATUS_ROLLBACK_TIMER_EXPIRED __constant_cpu_to_le32(0xC019003C)
-#define STATUS_TXF_ATTRIBUTE_CORRUPT __constant_cpu_to_le32(0xC019003D)
-#define STATUS_EFS_NOT_ALLOWED_IN_TRANSACTION __constant_cpu_to_le32(0xC019003E)
-#define STATUS_TRANSACTIONAL_OPEN_NOT_ALLOWED __constant_cpu_to_le32(0xC019003F)
-#define STATUS_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE __constant_cpu_to_le32(0xC0190040)
-#define STATUS_TRANSACTION_REQUIRED_PROMOTION __constant_cpu_to_le32(0xC0190043)
-#define STATUS_CANNOT_EXECUTE_FILE_IN_TRANSACTION __constant_cpu_to_le32(0xC0190044)
-#define STATUS_TRANSACTIONS_NOT_FROZEN __constant_cpu_to_le32(0xC0190045)
-#define STATUS_TRANSACTION_FREEZE_IN_PROGRESS __constant_cpu_to_le32(0xC0190046)
-#define STATUS_NOT_SNAPSHOT_VOLUME __constant_cpu_to_le32(0xC0190047)
-#define STATUS_NO_SAVEPOINT_WITH_OPEN_FILES __constant_cpu_to_le32(0xC0190048)
-#define STATUS_SPARSE_NOT_ALLOWED_IN_TRANSACTION __constant_cpu_to_le32(0xC0190049)
-#define STATUS_TM_IDENTITY_MISMATCH __constant_cpu_to_le32(0xC019004A)
-#define STATUS_FLOATED_SECTION __constant_cpu_to_le32(0xC019004B)
-#define STATUS_CANNOT_ACCEPT_TRANSACTED_WORK __constant_cpu_to_le32(0xC019004C)
-#define STATUS_CANNOT_ABORT_TRANSACTIONS __constant_cpu_to_le32(0xC019004D)
-#define STATUS_TRANSACTION_NOT_FOUND __constant_cpu_to_le32(0xC019004E)
-#define STATUS_RESOURCEMANAGER_NOT_FOUND __constant_cpu_to_le32(0xC019004F)
-#define STATUS_ENLISTMENT_NOT_FOUND __constant_cpu_to_le32(0xC0190050)
-#define STATUS_TRANSACTIONMANAGER_NOT_FOUND __constant_cpu_to_le32(0xC0190051)
-#define STATUS_TRANSACTIONMANAGER_NOT_ONLINE __constant_cpu_to_le32(0xC0190052)
-#define STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION __constant_cpu_to_le32(0xC0190053)
-#define STATUS_TRANSACTION_NOT_ROOT __constant_cpu_to_le32(0xC0190054)
-#define STATUS_TRANSACTION_OBJECT_EXPIRED __constant_cpu_to_le32(0xC0190055)
-#define STATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION __constant_cpu_to_le32(0xC0190056)
-#define STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED __constant_cpu_to_le32(0xC0190057)
-#define STATUS_TRANSACTION_RECORD_TOO_LONG __constant_cpu_to_le32(0xC0190058)
-#define STATUS_NO_LINK_TRACKING_IN_TRANSACTION __constant_cpu_to_le32(0xC0190059)
-#define STATUS_OPERATION_NOT_SUPPORTED_IN_TRANSACTION __constant_cpu_to_le32(0xC019005A)
-#define STATUS_TRANSACTION_INTEGRITY_VIOLATED __constant_cpu_to_le32(0xC019005B)
-#define STATUS_LOG_SECTOR_INVALID __constant_cpu_to_le32(0xC01A0001)
-#define STATUS_LOG_SECTOR_PARITY_INVALID __constant_cpu_to_le32(0xC01A0002)
-#define STATUS_LOG_SECTOR_REMAPPED __constant_cpu_to_le32(0xC01A0003)
-#define STATUS_LOG_BLOCK_INCOMPLETE __constant_cpu_to_le32(0xC01A0004)
-#define STATUS_LOG_INVALID_RANGE __constant_cpu_to_le32(0xC01A0005)
-#define STATUS_LOG_BLOCKS_EXHAUSTED __constant_cpu_to_le32(0xC01A0006)
-#define STATUS_LOG_READ_CONTEXT_INVALID __constant_cpu_to_le32(0xC01A0007)
-#define STATUS_LOG_RESTART_INVALID __constant_cpu_to_le32(0xC01A0008)
-#define STATUS_LOG_BLOCK_VERSION __constant_cpu_to_le32(0xC01A0009)
-#define STATUS_LOG_BLOCK_INVALID __constant_cpu_to_le32(0xC01A000A)
-#define STATUS_LOG_READ_MODE_INVALID __constant_cpu_to_le32(0xC01A000B)
-#define STATUS_LOG_METADATA_CORRUPT __constant_cpu_to_le32(0xC01A000D)
-#define STATUS_LOG_METADATA_INVALID __constant_cpu_to_le32(0xC01A000E)
-#define STATUS_LOG_METADATA_INCONSISTENT __constant_cpu_to_le32(0xC01A000F)
-#define STATUS_LOG_RESERVATION_INVALID __constant_cpu_to_le32(0xC01A0010)
-#define STATUS_LOG_CANT_DELETE __constant_cpu_to_le32(0xC01A0011)
-#define STATUS_LOG_CONTAINER_LIMIT_EXCEEDED __constant_cpu_to_le32(0xC01A0012)
-#define STATUS_LOG_START_OF_LOG __constant_cpu_to_le32(0xC01A0013)
-#define STATUS_LOG_POLICY_ALREADY_INSTALLED __constant_cpu_to_le32(0xC01A0014)
-#define STATUS_LOG_POLICY_NOT_INSTALLED __constant_cpu_to_le32(0xC01A0015)
-#define STATUS_LOG_POLICY_INVALID __constant_cpu_to_le32(0xC01A0016)
-#define STATUS_LOG_POLICY_CONFLICT __constant_cpu_to_le32(0xC01A0017)
-#define STATUS_LOG_PINNED_ARCHIVE_TAIL __constant_cpu_to_le32(0xC01A0018)
-#define STATUS_LOG_RECORD_NONEXISTENT __constant_cpu_to_le32(0xC01A0019)
-#define STATUS_LOG_RECORDS_RESERVED_INVALID __constant_cpu_to_le32(0xC01A001A)
-#define STATUS_LOG_SPACE_RESERVED_INVALID __constant_cpu_to_le32(0xC01A001B)
-#define STATUS_LOG_TAIL_INVALID __constant_cpu_to_le32(0xC01A001C)
-#define STATUS_LOG_FULL __constant_cpu_to_le32(0xC01A001D)
-#define STATUS_LOG_MULTIPLEXED __constant_cpu_to_le32(0xC01A001E)
-#define STATUS_LOG_DEDICATED __constant_cpu_to_le32(0xC01A001F)
-#define STATUS_LOG_ARCHIVE_NOT_IN_PROGRESS __constant_cpu_to_le32(0xC01A0020)
-#define STATUS_LOG_ARCHIVE_IN_PROGRESS __constant_cpu_to_le32(0xC01A0021)
-#define STATUS_LOG_EPHEMERAL __constant_cpu_to_le32(0xC01A0022)
-#define STATUS_LOG_NOT_ENOUGH_CONTAINERS __constant_cpu_to_le32(0xC01A0023)
-#define STATUS_LOG_CLIENT_ALREADY_REGISTERED __constant_cpu_to_le32(0xC01A0024)
-#define STATUS_LOG_CLIENT_NOT_REGISTERED __constant_cpu_to_le32(0xC01A0025)
-#define STATUS_LOG_FULL_HANDLER_IN_PROGRESS __constant_cpu_to_le32(0xC01A0026)
-#define STATUS_LOG_CONTAINER_READ_FAILED __constant_cpu_to_le32(0xC01A0027)
-#define STATUS_LOG_CONTAINER_WRITE_FAILED __constant_cpu_to_le32(0xC01A0028)
-#define STATUS_LOG_CONTAINER_OPEN_FAILED __constant_cpu_to_le32(0xC01A0029)
-#define STATUS_LOG_CONTAINER_STATE_INVALID __constant_cpu_to_le32(0xC01A002A)
-#define STATUS_LOG_STATE_INVALID __constant_cpu_to_le32(0xC01A002B)
-#define STATUS_LOG_PINNED __constant_cpu_to_le32(0xC01A002C)
-#define STATUS_LOG_METADATA_FLUSH_FAILED __constant_cpu_to_le32(0xC01A002D)
-#define STATUS_LOG_INCONSISTENT_SECURITY __constant_cpu_to_le32(0xC01A002E)
-#define STATUS_LOG_APPENDED_FLUSH_FAILED __constant_cpu_to_le32(0xC01A002F)
-#define STATUS_LOG_PINNED_RESERVATION __constant_cpu_to_le32(0xC01A0030)
-#define STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD __constant_cpu_to_le32(0xC01B00EA)
-#define STATUS_FLT_NO_HANDLER_DEFINED __constant_cpu_to_le32(0xC01C0001)
-#define STATUS_FLT_CONTEXT_ALREADY_DEFINED __constant_cpu_to_le32(0xC01C0002)
-#define STATUS_FLT_INVALID_ASYNCHRONOUS_REQUEST __constant_cpu_to_le32(0xC01C0003)
-#define STATUS_FLT_DISALLOW_FAST_IO __constant_cpu_to_le32(0xC01C0004)
-#define STATUS_FLT_INVALID_NAME_REQUEST __constant_cpu_to_le32(0xC01C0005)
-#define STATUS_FLT_NOT_SAFE_TO_POST_OPERATION __constant_cpu_to_le32(0xC01C0006)
-#define STATUS_FLT_NOT_INITIALIZED __constant_cpu_to_le32(0xC01C0007)
-#define STATUS_FLT_FILTER_NOT_READY __constant_cpu_to_le32(0xC01C0008)
-#define STATUS_FLT_POST_OPERATION_CLEANUP __constant_cpu_to_le32(0xC01C0009)
-#define STATUS_FLT_INTERNAL_ERROR __constant_cpu_to_le32(0xC01C000A)
-#define STATUS_FLT_DELETING_OBJECT __constant_cpu_to_le32(0xC01C000B)
-#define STATUS_FLT_MUST_BE_NONPAGED_POOL __constant_cpu_to_le32(0xC01C000C)
-#define STATUS_FLT_DUPLICATE_ENTRY __constant_cpu_to_le32(0xC01C000D)
-#define STATUS_FLT_CBDQ_DISABLED __constant_cpu_to_le32(0xC01C000E)
-#define STATUS_FLT_DO_NOT_ATTACH __constant_cpu_to_le32(0xC01C000F)
-#define STATUS_FLT_DO_NOT_DETACH __constant_cpu_to_le32(0xC01C0010)
-#define STATUS_FLT_INSTANCE_ALTITUDE_COLLISION __constant_cpu_to_le32(0xC01C0011)
-#define STATUS_FLT_INSTANCE_NAME_COLLISION __constant_cpu_to_le32(0xC01C0012)
-#define STATUS_FLT_FILTER_NOT_FOUND __constant_cpu_to_le32(0xC01C0013)
-#define STATUS_FLT_VOLUME_NOT_FOUND __constant_cpu_to_le32(0xC01C0014)
-#define STATUS_FLT_INSTANCE_NOT_FOUND __constant_cpu_to_le32(0xC01C0015)
-#define STATUS_FLT_CONTEXT_ALLOCATION_NOT_FOUND __constant_cpu_to_le32(0xC01C0016)
-#define STATUS_FLT_INVALID_CONTEXT_REGISTRATION __constant_cpu_to_le32(0xC01C0017)
-#define STATUS_FLT_NAME_CACHE_MISS __constant_cpu_to_le32(0xC01C0018)
-#define STATUS_FLT_NO_DEVICE_OBJECT __constant_cpu_to_le32(0xC01C0019)
-#define STATUS_FLT_VOLUME_ALREADY_MOUNTED __constant_cpu_to_le32(0xC01C001A)
-#define STATUS_FLT_ALREADY_ENLISTED __constant_cpu_to_le32(0xC01C001B)
-#define STATUS_FLT_CONTEXT_ALREADY_LINKED __constant_cpu_to_le32(0xC01C001C)
-#define STATUS_FLT_NO_WAITER_FOR_REPLY __constant_cpu_to_le32(0xC01C0020)
-#define STATUS_MONITOR_NO_DESCRIPTOR __constant_cpu_to_le32(0xC01D0001)
-#define STATUS_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT __constant_cpu_to_le32(0xC01D0002)
-#define STATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUM __constant_cpu_to_le32(0xC01D0003)
-#define STATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCK __constant_cpu_to_le32(0xC01D0004)
-#define STATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED __constant_cpu_to_le32(0xC01D0005)
-#define STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK __constant_cpu_to_le32(0xC01D0006)
-#define STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK __constant_cpu_to_le32(0xC01D0007)
-#define STATUS_MONITOR_NO_MORE_DESCRIPTOR_DATA __constant_cpu_to_le32(0xC01D0008)
-#define STATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCK __constant_cpu_to_le32(0xC01D0009)
-#define STATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER __constant_cpu_to_le32(0xC01E0000)
-#define STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER __constant_cpu_to_le32(0xC01E0001)
-#define STATUS_GRAPHICS_INVALID_DISPLAY_ADAPTER __constant_cpu_to_le32(0xC01E0002)
-#define STATUS_GRAPHICS_ADAPTER_WAS_RESET __constant_cpu_to_le32(0xC01E0003)
-#define STATUS_GRAPHICS_INVALID_DRIVER_MODEL __constant_cpu_to_le32(0xC01E0004)
-#define STATUS_GRAPHICS_PRESENT_MODE_CHANGED __constant_cpu_to_le32(0xC01E0005)
-#define STATUS_GRAPHICS_PRESENT_OCCLUDED __constant_cpu_to_le32(0xC01E0006)
-#define STATUS_GRAPHICS_PRESENT_DENIED __constant_cpu_to_le32(0xC01E0007)
-#define STATUS_GRAPHICS_CANNOTCOLORCONVERT __constant_cpu_to_le32(0xC01E0008)
-#define STATUS_GRAPHICS_NO_VIDEO_MEMORY __constant_cpu_to_le32(0xC01E0100)
-#define STATUS_GRAPHICS_CANT_LOCK_MEMORY __constant_cpu_to_le32(0xC01E0101)
-#define STATUS_GRAPHICS_ALLOCATION_BUSY __constant_cpu_to_le32(0xC01E0102)
-#define STATUS_GRAPHICS_TOO_MANY_REFERENCES __constant_cpu_to_le32(0xC01E0103)
-#define STATUS_GRAPHICS_TRY_AGAIN_LATER __constant_cpu_to_le32(0xC01E0104)
-#define STATUS_GRAPHICS_TRY_AGAIN_NOW __constant_cpu_to_le32(0xC01E0105)
-#define STATUS_GRAPHICS_ALLOCATION_INVALID __constant_cpu_to_le32(0xC01E0106)
-#define STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE __constant_cpu_to_le32(0xC01E0107)
-#define STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED __constant_cpu_to_le32(0xC01E0108)
-#define STATUS_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION __constant_cpu_to_le32(0xC01E0109)
-#define STATUS_GRAPHICS_INVALID_ALLOCATION_USAGE __constant_cpu_to_le32(0xC01E0110)
-#define STATUS_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION __constant_cpu_to_le32(0xC01E0111)
-#define STATUS_GRAPHICS_ALLOCATION_CLOSED __constant_cpu_to_le32(0xC01E0112)
-#define STATUS_GRAPHICS_INVALID_ALLOCATION_INSTANCE __constant_cpu_to_le32(0xC01E0113)
-#define STATUS_GRAPHICS_INVALID_ALLOCATION_HANDLE __constant_cpu_to_le32(0xC01E0114)
-#define STATUS_GRAPHICS_WRONG_ALLOCATION_DEVICE __constant_cpu_to_le32(0xC01E0115)
-#define STATUS_GRAPHICS_ALLOCATION_CONTENT_LOST __constant_cpu_to_le32(0xC01E0116)
-#define STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE __constant_cpu_to_le32(0xC01E0200)
-#define STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY __constant_cpu_to_le32(0xC01E0300)
-#define STATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0301)
-#define STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0302)
-#define STATUS_GRAPHICS_INVALID_VIDPN __constant_cpu_to_le32(0xC01E0303)
-#define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE __constant_cpu_to_le32(0xC01E0304)
-#define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET __constant_cpu_to_le32(0xC01E0305)
-#define STATUS_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0306)
-#define STATUS_GRAPHICS_INVALID_VIDPN_SOURCEMODESET __constant_cpu_to_le32(0xC01E0308)
-#define STATUS_GRAPHICS_INVALID_VIDPN_TARGETMODESET __constant_cpu_to_le32(0xC01E0309)
-#define STATUS_GRAPHICS_INVALID_FREQUENCY __constant_cpu_to_le32(0xC01E030A)
-#define STATUS_GRAPHICS_INVALID_ACTIVE_REGION __constant_cpu_to_le32(0xC01E030B)
-#define STATUS_GRAPHICS_INVALID_TOTAL_REGION __constant_cpu_to_le32(0xC01E030C)
-#define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE __constant_cpu_to_le32(0xC01E0310)
-#define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE __constant_cpu_to_le32(0xC01E0311)
-#define STATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET __constant_cpu_to_le32(0xC01E0312)
-#define STATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY __constant_cpu_to_le32(0xC01E0313)
-#define STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET __constant_cpu_to_le32(0xC01E0314)
-#define STATUS_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET __constant_cpu_to_le32(0xC01E0315)
-#define STATUS_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET __constant_cpu_to_le32(0xC01E0316)
-#define STATUS_GRAPHICS_SOURCE_ALREADY_IN_SET __constant_cpu_to_le32(0xC01E0317)
-#define STATUS_GRAPHICS_TARGET_ALREADY_IN_SET __constant_cpu_to_le32(0xC01E0318)
-#define STATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATH __constant_cpu_to_le32(0xC01E0319)
-#define STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY __constant_cpu_to_le32(0xC01E031A)
-#define STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET __constant_cpu_to_le32(0xC01E031B)
-#define STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE __constant_cpu_to_le32(0xC01E031C)
-#define STATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET __constant_cpu_to_le32(0xC01E031D)
-#define STATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET __constant_cpu_to_le32(0xC01E031F)
-#define STATUS_GRAPHICS_STALE_MODESET __constant_cpu_to_le32(0xC01E0320)
-#define STATUS_GRAPHICS_INVALID_MONITOR_SOURCEMODESET __constant_cpu_to_le32(0xC01E0321)
-#define STATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODE __constant_cpu_to_le32(0xC01E0322)
-#define STATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN __constant_cpu_to_le32(0xC01E0323)
-#define STATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUE __constant_cpu_to_le32(0xC01E0324)
-#define STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION __constant_cpu_to_le32(0xC01E0325)
-#define STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES __constant_cpu_to_le32(0xC01E0326)
-#define STATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGY __constant_cpu_to_le32(0xC01E0327)
-#define STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE __constant_cpu_to_le32(0xC01E0328)
-#define STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET __constant_cpu_to_le32(0xC01E0329)
-#define STATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSET __constant_cpu_to_le32(0xC01E032A)
-#define STATUS_GRAPHICS_INVALID_MONITORDESCRIPTOR __constant_cpu_to_le32(0xC01E032B)
-#define STATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET __constant_cpu_to_le32(0xC01E032C)
-#define STATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET __constant_cpu_to_le32(0xC01E032D)
-#define STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE __constant_cpu_to_le32(0xC01E032E)
-#define STATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE __constant_cpu_to_le32(0xC01E032F)
-#define STATUS_GRAPHICS_RESOURCES_NOT_RELATED __constant_cpu_to_le32(0xC01E0330)
-#define STATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE __constant_cpu_to_le32(0xC01E0331)
-#define STATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE __constant_cpu_to_le32(0xC01E0332)
-#define STATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET __constant_cpu_to_le32(0xC01E0333)
-#define STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER __constant_cpu_to_le32(0xC01E0334)
-#define STATUS_GRAPHICS_NO_VIDPNMGR __constant_cpu_to_le32(0xC01E0335)
-#define STATUS_GRAPHICS_NO_ACTIVE_VIDPN __constant_cpu_to_le32(0xC01E0336)
-#define STATUS_GRAPHICS_STALE_VIDPN_TOPOLOGY __constant_cpu_to_le32(0xC01E0337)
-#define STATUS_GRAPHICS_MONITOR_NOT_CONNECTED __constant_cpu_to_le32(0xC01E0338)
-#define STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY __constant_cpu_to_le32(0xC01E0339)
-#define STATUS_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE __constant_cpu_to_le32(0xC01E033A)
-#define STATUS_GRAPHICS_INVALID_VISIBLEREGION_SIZE __constant_cpu_to_le32(0xC01E033B)
-#define STATUS_GRAPHICS_INVALID_STRIDE __constant_cpu_to_le32(0xC01E033C)
-#define STATUS_GRAPHICS_INVALID_PIXELFORMAT __constant_cpu_to_le32(0xC01E033D)
-#define STATUS_GRAPHICS_INVALID_COLORBASIS __constant_cpu_to_le32(0xC01E033E)
-#define STATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODE __constant_cpu_to_le32(0xC01E033F)
-#define STATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGY __constant_cpu_to_le32(0xC01E0340)
-#define STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT __constant_cpu_to_le32(0xC01E0341)
-#define STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE __constant_cpu_to_le32(0xC01E0342)
-#define STATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN __constant_cpu_to_le32(0xC01E0343)
-#define STATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL __constant_cpu_to_le32(0xC01E0344)
-#define STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION __constant_cpu_to_le32(0xC01E0345)
-#define STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0346)
-#define STATUS_GRAPHICS_INVALID_GAMMA_RAMP __constant_cpu_to_le32(0xC01E0347)
-#define STATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0348)
-#define STATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0349)
-#define STATUS_GRAPHICS_MODE_NOT_IN_MODESET __constant_cpu_to_le32(0xC01E034A)
-#define STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON __constant_cpu_to_le32(0xC01E034D)
-#define STATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPE __constant_cpu_to_le32(0xC01E034E)
-#define STATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPE __constant_cpu_to_le32(0xC01E034F)
-#define STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS __constant_cpu_to_le32(0xC01E0350)
-#define STATUS_GRAPHICS_INVALID_SCANLINE_ORDERING __constant_cpu_to_le32(0xC01E0352)
-#define STATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED __constant_cpu_to_le32(0xC01E0353)
-#define STATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS __constant_cpu_to_le32(0xC01E0354)
-#define STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT __constant_cpu_to_le32(0xC01E0355)
-#define STATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM __constant_cpu_to_le32(0xC01E0356)
-#define STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN __constant_cpu_to_le32(0xC01E0357)
-#define STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT __constant_cpu_to_le32(0xC01E0358)
-#define STATUS_GRAPHICS_MAX_NUM_PATHS_REACHED __constant_cpu_to_le32(0xC01E0359)
-#define STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION __constant_cpu_to_le32(0xC01E035A)
-#define STATUS_GRAPHICS_INVALID_CLIENT_TYPE __constant_cpu_to_le32(0xC01E035B)
-#define STATUS_GRAPHICS_CLIENTVIDPN_NOT_SET __constant_cpu_to_le32(0xC01E035C)
-#define STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED __constant_cpu_to_le32(0xC01E0400)
-#define STATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0401)
-#define STATUS_GRAPHICS_NOT_A_LINKED_ADAPTER __constant_cpu_to_le32(0xC01E0430)
-#define STATUS_GRAPHICS_LEADLINK_NOT_ENUMERATED __constant_cpu_to_le32(0xC01E0431)
-#define STATUS_GRAPHICS_CHAINLINKS_NOT_ENUMERATED __constant_cpu_to_le32(0xC01E0432)
-#define STATUS_GRAPHICS_ADAPTER_CHAIN_NOT_READY __constant_cpu_to_le32(0xC01E0433)
-#define STATUS_GRAPHICS_CHAINLINKS_NOT_STARTED __constant_cpu_to_le32(0xC01E0434)
-#define STATUS_GRAPHICS_CHAINLINKS_NOT_POWERED_ON __constant_cpu_to_le32(0xC01E0435)
-#define STATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE __constant_cpu_to_le32(0xC01E0436)
-#define STATUS_GRAPHICS_NOT_POST_DEVICE_DRIVER __constant_cpu_to_le32(0xC01E0438)
-#define STATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED __constant_cpu_to_le32(0xC01E043B)
-#define STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS __constant_cpu_to_le32(0xC01E051C)
-#define STATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST __constant_cpu_to_le32(0xC01E051D)
-#define STATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR __constant_cpu_to_le32(0xC01E051E)
-#define STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS __constant_cpu_to_le32(0xC01E051F)
-#define STATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0520)
-#define STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST __constant_cpu_to_le32(0xC01E0521)
-#define STATUS_GRAPHICS_OPM_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0500)
-#define STATUS_GRAPHICS_COPP_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0501)
-#define STATUS_GRAPHICS_UAB_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0502)
-#define STATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS __constant_cpu_to_le32(0xC01E0503)
-#define STATUS_GRAPHICS_OPM_PARAMETER_ARRAY_TOO_SMALL __constant_cpu_to_le32(0xC01E0504)
-#define STATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXIST __constant_cpu_to_le32(0xC01E0505)
-#define STATUS_GRAPHICS_PVP_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME __constant_cpu_to_le32(0xC01E0506)
-#define STATUS_GRAPHICS_PVP_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP __constant_cpu_to_le32(0xC01E0507)
-#define STATUS_GRAPHICS_PVP_MIRRORING_DEVICES_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0508)
-#define STATUS_GRAPHICS_OPM_INVALID_POINTER __constant_cpu_to_le32(0xC01E050A)
-#define STATUS_GRAPHICS_OPM_INTERNAL_ERROR __constant_cpu_to_le32(0xC01E050B)
-#define STATUS_GRAPHICS_OPM_INVALID_HANDLE __constant_cpu_to_le32(0xC01E050C)
-#define STATUS_GRAPHICS_PVP_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE __constant_cpu_to_le32(0xC01E050D)
-#define STATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH __constant_cpu_to_le32(0xC01E050E)
-#define STATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLED __constant_cpu_to_le32(0xC01E050F)
-#define STATUS_GRAPHICS_OPM_THEATER_MODE_ENABLED __constant_cpu_to_le32(0xC01E0510)
-#define STATUS_GRAPHICS_PVP_HFS_FAILED __constant_cpu_to_le32(0xC01E0511)
-#define STATUS_GRAPHICS_OPM_INVALID_SRM __constant_cpu_to_le32(0xC01E0512)
-#define STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP __constant_cpu_to_le32(0xC01E0513)
-#define STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP __constant_cpu_to_le32(0xC01E0514)
-#define STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA __constant_cpu_to_le32(0xC01E0515)
-#define STATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SET __constant_cpu_to_le32(0xC01E0516)
-#define STATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGH __constant_cpu_to_le32(0xC01E0517)
-#define STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE __constant_cpu_to_le32(0xC01E0518)
-#define STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS __constant_cpu_to_le32(0xC01E051A)
-#define STATUS_GRAPHICS_OPM_SESSION_TYPE_CHANGE_IN_PROGRESS __constant_cpu_to_le32(0xC01E051B)
-#define STATUS_GRAPHICS_I2C_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0580)
-#define STATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST __constant_cpu_to_le32(0xC01E0581)
-#define STATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA __constant_cpu_to_le32(0xC01E0582)
-#define STATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATA __constant_cpu_to_le32(0xC01E0583)
-#define STATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0584)
-#define STATUS_GRAPHICS_DDCCI_INVALID_DATA __constant_cpu_to_le32(0xC01E0585)
-#define STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE __constant_cpu_to_le32(0xC01E0586)
-#define STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING __constant_cpu_to_le32(0xC01E0587)
-#define STATUS_GRAPHICS_MCA_INTERNAL_ERROR __constant_cpu_to_le32(0xC01E0588)
-#define STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND __constant_cpu_to_le32(0xC01E0589)
-#define STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH __constant_cpu_to_le32(0xC01E058A)
-#define STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM __constant_cpu_to_le32(0xC01E058B)
-#define STATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE __constant_cpu_to_le32(0xC01E058C)
-#define STATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTS __constant_cpu_to_le32(0xC01E058D)
-#define STATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED __constant_cpu_to_le32(0xC01E05E0)
-#define STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME __constant_cpu_to_le32(0xC01E05E1)
-#define STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP __constant_cpu_to_le32(0xC01E05E2)
-#define STATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E05E3)
-#define STATUS_GRAPHICS_INVALID_POINTER __constant_cpu_to_le32(0xC01E05E4)
-#define STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE __constant_cpu_to_le32(0xC01E05E5)
-#define STATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL __constant_cpu_to_le32(0xC01E05E6)
-#define STATUS_GRAPHICS_INTERNAL_ERROR __constant_cpu_to_le32(0xC01E05E7)
-#define STATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS __constant_cpu_to_le32(0xC01E05E8)
-#define STATUS_FVE_LOCKED_VOLUME __constant_cpu_to_le32(0xC0210000)
-#define STATUS_FVE_NOT_ENCRYPTED __constant_cpu_to_le32(0xC0210001)
-#define STATUS_FVE_BAD_INFORMATION __constant_cpu_to_le32(0xC0210002)
-#define STATUS_FVE_TOO_SMALL __constant_cpu_to_le32(0xC0210003)
-#define STATUS_FVE_FAILED_WRONG_FS __constant_cpu_to_le32(0xC0210004)
-#define STATUS_FVE_FAILED_BAD_FS __constant_cpu_to_le32(0xC0210005)
-#define STATUS_FVE_FS_NOT_EXTENDED __constant_cpu_to_le32(0xC0210006)
-#define STATUS_FVE_FS_MOUNTED __constant_cpu_to_le32(0xC0210007)
-#define STATUS_FVE_NO_LICENSE __constant_cpu_to_le32(0xC0210008)
-#define STATUS_FVE_ACTION_NOT_ALLOWED __constant_cpu_to_le32(0xC0210009)
-#define STATUS_FVE_BAD_DATA __constant_cpu_to_le32(0xC021000A)
-#define STATUS_FVE_VOLUME_NOT_BOUND __constant_cpu_to_le32(0xC021000B)
-#define STATUS_FVE_NOT_DATA_VOLUME __constant_cpu_to_le32(0xC021000C)
-#define STATUS_FVE_CONV_READ_ERROR __constant_cpu_to_le32(0xC021000D)
-#define STATUS_FVE_CONV_WRITE_ERROR __constant_cpu_to_le32(0xC021000E)
-#define STATUS_FVE_OVERLAPPED_UPDATE __constant_cpu_to_le32(0xC021000F)
-#define STATUS_FVE_FAILED_SECTOR_SIZE __constant_cpu_to_le32(0xC0210010)
-#define STATUS_FVE_FAILED_AUTHENTICATION __constant_cpu_to_le32(0xC0210011)
-#define STATUS_FVE_NOT_OS_VOLUME __constant_cpu_to_le32(0xC0210012)
-#define STATUS_FVE_KEYFILE_NOT_FOUND __constant_cpu_to_le32(0xC0210013)
-#define STATUS_FVE_KEYFILE_INVALID __constant_cpu_to_le32(0xC0210014)
-#define STATUS_FVE_KEYFILE_NO_VMK __constant_cpu_to_le32(0xC0210015)
-#define STATUS_FVE_TPM_DISABLED __constant_cpu_to_le32(0xC0210016)
-#define STATUS_FVE_TPM_SRK_AUTH_NOT_ZERO __constant_cpu_to_le32(0xC0210017)
-#define STATUS_FVE_TPM_INVALID_PCR __constant_cpu_to_le32(0xC0210018)
-#define STATUS_FVE_TPM_NO_VMK __constant_cpu_to_le32(0xC0210019)
-#define STATUS_FVE_PIN_INVALID __constant_cpu_to_le32(0xC021001A)
-#define STATUS_FVE_AUTH_INVALID_APPLICATION __constant_cpu_to_le32(0xC021001B)
-#define STATUS_FVE_AUTH_INVALID_CONFIG __constant_cpu_to_le32(0xC021001C)
-#define STATUS_FVE_DEBUGGER_ENABLED __constant_cpu_to_le32(0xC021001D)
-#define STATUS_FVE_DRY_RUN_FAILED __constant_cpu_to_le32(0xC021001E)
-#define STATUS_FVE_BAD_METADATA_POINTER __constant_cpu_to_le32(0xC021001F)
-#define STATUS_FVE_OLD_METADATA_COPY __constant_cpu_to_le32(0xC0210020)
-#define STATUS_FVE_REBOOT_REQUIRED __constant_cpu_to_le32(0xC0210021)
-#define STATUS_FVE_RAW_ACCESS __constant_cpu_to_le32(0xC0210022)
-#define STATUS_FVE_RAW_BLOCKED __constant_cpu_to_le32(0xC0210023)
-#define STATUS_FWP_CALLOUT_NOT_FOUND __constant_cpu_to_le32(0xC0220001)
-#define STATUS_FWP_CONDITION_NOT_FOUND __constant_cpu_to_le32(0xC0220002)
-#define STATUS_FWP_FILTER_NOT_FOUND __constant_cpu_to_le32(0xC0220003)
-#define STATUS_FWP_LAYER_NOT_FOUND __constant_cpu_to_le32(0xC0220004)
-#define STATUS_FWP_PROVIDER_NOT_FOUND __constant_cpu_to_le32(0xC0220005)
-#define STATUS_FWP_PROVIDER_CONTEXT_NOT_FOUND __constant_cpu_to_le32(0xC0220006)
-#define STATUS_FWP_SUBLAYER_NOT_FOUND __constant_cpu_to_le32(0xC0220007)
-#define STATUS_FWP_NOT_FOUND __constant_cpu_to_le32(0xC0220008)
-#define STATUS_FWP_ALREADY_EXISTS __constant_cpu_to_le32(0xC0220009)
-#define STATUS_FWP_IN_USE __constant_cpu_to_le32(0xC022000A)
-#define STATUS_FWP_DYNAMIC_SESSION_IN_PROGRESS __constant_cpu_to_le32(0xC022000B)
-#define STATUS_FWP_WRONG_SESSION __constant_cpu_to_le32(0xC022000C)
-#define STATUS_FWP_NO_TXN_IN_PROGRESS __constant_cpu_to_le32(0xC022000D)
-#define STATUS_FWP_TXN_IN_PROGRESS __constant_cpu_to_le32(0xC022000E)
-#define STATUS_FWP_TXN_ABORTED __constant_cpu_to_le32(0xC022000F)
-#define STATUS_FWP_SESSION_ABORTED __constant_cpu_to_le32(0xC0220010)
-#define STATUS_FWP_INCOMPATIBLE_TXN __constant_cpu_to_le32(0xC0220011)
-#define STATUS_FWP_TIMEOUT __constant_cpu_to_le32(0xC0220012)
-#define STATUS_FWP_NET_EVENTS_DISABLED __constant_cpu_to_le32(0xC0220013)
-#define STATUS_FWP_INCOMPATIBLE_LAYER __constant_cpu_to_le32(0xC0220014)
-#define STATUS_FWP_KM_CLIENTS_ONLY __constant_cpu_to_le32(0xC0220015)
-#define STATUS_FWP_LIFETIME_MISMATCH __constant_cpu_to_le32(0xC0220016)
-#define STATUS_FWP_BUILTIN_OBJECT __constant_cpu_to_le32(0xC0220017)
-#define STATUS_FWP_TOO_MANY_BOOTTIME_FILTERS __constant_cpu_to_le32(0xC0220018)
-#define STATUS_FWP_TOO_MANY_CALLOUTS __constant_cpu_to_le32(0xC0220018)
-#define STATUS_FWP_NOTIFICATION_DROPPED __constant_cpu_to_le32(0xC0220019)
-#define STATUS_FWP_TRAFFIC_MISMATCH __constant_cpu_to_le32(0xC022001A)
-#define STATUS_FWP_INCOMPATIBLE_SA_STATE __constant_cpu_to_le32(0xC022001B)
-#define STATUS_FWP_NULL_POINTER __constant_cpu_to_le32(0xC022001C)
-#define STATUS_FWP_INVALID_ENUMERATOR __constant_cpu_to_le32(0xC022001D)
-#define STATUS_FWP_INVALID_FLAGS __constant_cpu_to_le32(0xC022001E)
-#define STATUS_FWP_INVALID_NET_MASK __constant_cpu_to_le32(0xC022001F)
-#define STATUS_FWP_INVALID_RANGE __constant_cpu_to_le32(0xC0220020)
-#define STATUS_FWP_INVALID_INTERVAL __constant_cpu_to_le32(0xC0220021)
-#define STATUS_FWP_ZERO_LENGTH_ARRAY __constant_cpu_to_le32(0xC0220022)
-#define STATUS_FWP_NULL_DISPLAY_NAME __constant_cpu_to_le32(0xC0220023)
-#define STATUS_FWP_INVALID_ACTION_TYPE __constant_cpu_to_le32(0xC0220024)
-#define STATUS_FWP_INVALID_WEIGHT __constant_cpu_to_le32(0xC0220025)
-#define STATUS_FWP_MATCH_TYPE_MISMATCH __constant_cpu_to_le32(0xC0220026)
-#define STATUS_FWP_TYPE_MISMATCH __constant_cpu_to_le32(0xC0220027)
-#define STATUS_FWP_OUT_OF_BOUNDS __constant_cpu_to_le32(0xC0220028)
-#define STATUS_FWP_RESERVED __constant_cpu_to_le32(0xC0220029)
-#define STATUS_FWP_DUPLICATE_CONDITION __constant_cpu_to_le32(0xC022002A)
-#define STATUS_FWP_DUPLICATE_KEYMOD __constant_cpu_to_le32(0xC022002B)
-#define STATUS_FWP_ACTION_INCOMPATIBLE_WITH_LAYER __constant_cpu_to_le32(0xC022002C)
-#define STATUS_FWP_ACTION_INCOMPATIBLE_WITH_SUBLAYER __constant_cpu_to_le32(0xC022002D)
-#define STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_LAYER __constant_cpu_to_le32(0xC022002E)
-#define STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_CALLOUT __constant_cpu_to_le32(0xC022002F)
-#define STATUS_FWP_INCOMPATIBLE_AUTH_METHOD __constant_cpu_to_le32(0xC0220030)
-#define STATUS_FWP_INCOMPATIBLE_DH_GROUP __constant_cpu_to_le32(0xC0220031)
-#define STATUS_FWP_EM_NOT_SUPPORTED __constant_cpu_to_le32(0xC0220032)
-#define STATUS_FWP_NEVER_MATCH __constant_cpu_to_le32(0xC0220033)
-#define STATUS_FWP_PROVIDER_CONTEXT_MISMATCH __constant_cpu_to_le32(0xC0220034)
-#define STATUS_FWP_INVALID_PARAMETER __constant_cpu_to_le32(0xC0220035)
-#define STATUS_FWP_TOO_MANY_SUBLAYERS __constant_cpu_to_le32(0xC0220036)
-#define STATUS_FWP_CALLOUT_NOTIFICATION_FAILED __constant_cpu_to_le32(0xC0220037)
-#define STATUS_FWP_INCOMPATIBLE_AUTH_CONFIG __constant_cpu_to_le32(0xC0220038)
-#define STATUS_FWP_INCOMPATIBLE_CIPHER_CONFIG __constant_cpu_to_le32(0xC0220039)
-#define STATUS_FWP_TCPIP_NOT_READY __constant_cpu_to_le32(0xC0220100)
-#define STATUS_FWP_INJECT_HANDLE_CLOSING __constant_cpu_to_le32(0xC0220101)
-#define STATUS_FWP_INJECT_HANDLE_STALE __constant_cpu_to_le32(0xC0220102)
-#define STATUS_FWP_CANNOT_PEND __constant_cpu_to_le32(0xC0220103)
-#define STATUS_NDIS_CLOSING __constant_cpu_to_le32(0xC0230002)
-#define STATUS_NDIS_BAD_VERSION __constant_cpu_to_le32(0xC0230004)
-#define STATUS_NDIS_BAD_CHARACTERISTICS __constant_cpu_to_le32(0xC0230005)
-#define STATUS_NDIS_ADAPTER_NOT_FOUND __constant_cpu_to_le32(0xC0230006)
-#define STATUS_NDIS_OPEN_FAILED __constant_cpu_to_le32(0xC0230007)
-#define STATUS_NDIS_DEVICE_FAILED __constant_cpu_to_le32(0xC0230008)
-#define STATUS_NDIS_MULTICAST_FULL __constant_cpu_to_le32(0xC0230009)
-#define STATUS_NDIS_MULTICAST_EXISTS __constant_cpu_to_le32(0xC023000A)
-#define STATUS_NDIS_MULTICAST_NOT_FOUND __constant_cpu_to_le32(0xC023000B)
-#define STATUS_NDIS_REQUEST_ABORTED __constant_cpu_to_le32(0xC023000C)
-#define STATUS_NDIS_RESET_IN_PROGRESS __constant_cpu_to_le32(0xC023000D)
-#define STATUS_NDIS_INVALID_PACKET __constant_cpu_to_le32(0xC023000F)
-#define STATUS_NDIS_INVALID_DEVICE_REQUEST __constant_cpu_to_le32(0xC0230010)
-#define STATUS_NDIS_ADAPTER_NOT_READY __constant_cpu_to_le32(0xC0230011)
-#define STATUS_NDIS_INVALID_LENGTH __constant_cpu_to_le32(0xC0230014)
-#define STATUS_NDIS_INVALID_DATA __constant_cpu_to_le32(0xC0230015)
-#define STATUS_NDIS_BUFFER_TOO_SHORT __constant_cpu_to_le32(0xC0230016)
-#define STATUS_NDIS_INVALID_OID __constant_cpu_to_le32(0xC0230017)
-#define STATUS_NDIS_ADAPTER_REMOVED __constant_cpu_to_le32(0xC0230018)
-#define STATUS_NDIS_UNSUPPORTED_MEDIA __constant_cpu_to_le32(0xC0230019)
-#define STATUS_NDIS_GROUP_ADDRESS_IN_USE __constant_cpu_to_le32(0xC023001A)
-#define STATUS_NDIS_FILE_NOT_FOUND __constant_cpu_to_le32(0xC023001B)
-#define STATUS_NDIS_ERROR_READING_FILE __constant_cpu_to_le32(0xC023001C)
-#define STATUS_NDIS_ALREADY_MAPPED __constant_cpu_to_le32(0xC023001D)
-#define STATUS_NDIS_RESOURCE_CONFLICT __constant_cpu_to_le32(0xC023001E)
-#define STATUS_NDIS_MEDIA_DISCONNECTED __constant_cpu_to_le32(0xC023001F)
-#define STATUS_NDIS_INVALID_ADDRESS __constant_cpu_to_le32(0xC0230022)
-#define STATUS_NDIS_PAUSED __constant_cpu_to_le32(0xC023002A)
-#define STATUS_NDIS_INTERFACE_NOT_FOUND __constant_cpu_to_le32(0xC023002B)
-#define STATUS_NDIS_UNSUPPORTED_REVISION __constant_cpu_to_le32(0xC023002C)
-#define STATUS_NDIS_INVALID_PORT __constant_cpu_to_le32(0xC023002D)
-#define STATUS_NDIS_INVALID_PORT_STATE __constant_cpu_to_le32(0xC023002E)
-#define STATUS_NDIS_LOW_POWER_STATE __constant_cpu_to_le32(0xC023002F)
-#define STATUS_NDIS_NOT_SUPPORTED __constant_cpu_to_le32(0xC02300BB)
-#define STATUS_NDIS_DOT11_AUTO_CONFIG_ENABLED __constant_cpu_to_le32(0xC0232000)
-#define STATUS_NDIS_DOT11_MEDIA_IN_USE __constant_cpu_to_le32(0xC0232001)
-#define STATUS_NDIS_DOT11_POWER_STATE_INVALID __constant_cpu_to_le32(0xC0232002)
-#define STATUS_IPSEC_BAD_SPI __constant_cpu_to_le32(0xC0360001)
-#define STATUS_IPSEC_SA_LIFETIME_EXPIRED __constant_cpu_to_le32(0xC0360002)
-#define STATUS_IPSEC_WRONG_SA __constant_cpu_to_le32(0xC0360003)
-#define STATUS_IPSEC_REPLAY_CHECK_FAILED __constant_cpu_to_le32(0xC0360004)
-#define STATUS_IPSEC_INVALID_PACKET __constant_cpu_to_le32(0xC0360005)
-#define STATUS_IPSEC_INTEGRITY_CHECK_FAILED __constant_cpu_to_le32(0xC0360006)
-#define STATUS_IPSEC_CLEAR_TEXT_DROP __constant_cpu_to_le32(0xC0360007)
diff --git a/fs/cifs/smb2transport.c b/fs/cifs/smb2transport.c
deleted file mode 100644
index 8dd73e61d76..00000000000
--- a/fs/cifs/smb2transport.c
+++ /dev/null
@@ -1,331 +0,0 @@
-/*
- *   fs/cifs/smb2transport.c
- *
- *   Copyright (C) International Business Machines  Corp., 2002, 2011
- *                 Etersoft, 2012
- *   Author(s): Steve French (sfrench@us.ibm.com)
- *              Jeremy Allison (jra@samba.org) 2006
- *              Pavel Shilovsky (pshilovsky@samba.org) 2012
- *
- *   This library is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU Lesser General Public License as published
- *   by the Free Software Foundation; either version 2.1 of the License, or
- *   (at your option) any later version.
- *
- *   This library is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
- *   the GNU Lesser General Public License for more details.
- *
- *   You should have received a copy of the GNU Lesser General Public License
- *   along with this library; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-
-#include <linux/fs.h>
-#include <linux/list.h>
-#include <linux/wait.h>
-#include <linux/net.h>
-#include <linux/delay.h>
-#include <linux/uaccess.h>
-#include <asm/processor.h>
-#include <linux/mempool.h>
-#include <linux/highmem.h>
-#include "smb2pdu.h"
-#include "cifsglob.h"
-#include "cifsproto.h"
-#include "smb2proto.h"
-#include "cifs_debug.h"
-#include "smb2status.h"
-#include "smb2glob.h"
-
-int
-smb2_calc_signature(struct smb_rqst *rqst, struct TCP_Server_Info *server)
-{
-        int i, rc;
-        unsigned char smb2_signature[SMB2_HMACSHA256_SIZE];
-        unsigned char *sigptr = smb2_signature;
-        struct kvec *iov = rqst->rq_iov;
-        int n_vec = rqst->rq_nvec;
-        struct smb2_hdr *smb2_pdu = (struct smb2_hdr *)iov[0].iov_base;
-
-        memset(smb2_signature, 0x0, SMB2_HMACSHA256_SIZE);
-        memset(smb2_pdu->Signature, 0x0, SMB2_SIGNATURE_SIZE);
-
-        rc = crypto_shash_setkey(server->secmech.hmacsha256,
-                server->session_key.response, SMB2_NTLMV2_SESSKEY_SIZE);
-        if (rc) {
-                cERROR(1, "%s: Could not update with response\n", __func__);
-                return rc;
-        }
-
-        rc = crypto_shash_init(&server->secmech.sdeschmacsha256->shash);
-        if (rc) {
-                cERROR(1, "%s: Could not init md5\n", __func__);
-                return rc;
-        }
-
-        for (i = 0; i < n_vec; i++) {
-                if (iov[i].iov_len == 0)
-                        continue;
-                if (iov[i].iov_base == NULL) {
-                        cERROR(1, "null iovec entry");
-                        return -EIO;
-                }
-                /*
-                 * The first entry includes a length field (which does not get
-                 * signed that occupies the first 4 bytes before the header).
-                 */
-                if (i == 0) {
-                        if (iov[0].iov_len <= 8) /* cmd field at offset 9 */
-                                break; /* nothing to sign or corrupt header */
-                        rc =
-                        crypto_shash_update(
-                                &server->secmech.sdeschmacsha256->shash,
-                                iov[i].iov_base + 4, iov[i].iov_len - 4);
-                } else {
-                        rc =
-                        crypto_shash_update(
-                                &server->secmech.sdeschmacsha256->shash,
-                                iov[i].iov_base, iov[i].iov_len);
-                }
-                if (rc) {
-                        cERROR(1, "%s: Could not update with payload\n",
-                                                        __func__);
-                        return rc;
-                }
-        }
-
-        /* now hash over the rq_pages array */
-        for (i = 0; i < rqst->rq_npages; i++) {
-                struct kvec p_iov;
-
-                cifs_rqst_page_to_kvec(rqst, i, &p_iov);
-                crypto_shash_update(&server->secmech.sdeschmacsha256->shash,
-                                        p_iov.iov_base, p_iov.iov_len);
-                kunmap(rqst->rq_pages[i]);
-        }
-
-        rc = crypto_shash_final(&server->secmech.sdeschmacsha256->shash,
-                                sigptr);
-        if (rc)
-                cERROR(1, "%s: Could not generate sha256 hash\n", __func__);
-
-        memcpy(smb2_pdu->Signature, sigptr, SMB2_SIGNATURE_SIZE);
-
-        return rc;
-}
-
-int
-smb3_calc_signature(struct smb_rqst *rqst, struct TCP_Server_Info *server)
-{
-        cFYI(1, "smb3 signatures not supported yet");
-        return -EOPNOTSUPP;
-}
-
-/* must be called with server->srv_mutex held */
-static int
-smb2_sign_rqst(struct smb_rqst *rqst, struct TCP_Server_Info *server)
-{
-        int rc = 0;
-        struct smb2_hdr *smb2_pdu = rqst->rq_iov[0].iov_base;
-
-        if (!(smb2_pdu->Flags & SMB2_FLAGS_SIGNED) ||
-            server->tcpStatus == CifsNeedNegotiate)
-                return rc;
-
-        if (!server->session_estab) {
-                strncpy(smb2_pdu->Signature, "BSRSPYL", 8);
-                return rc;
-        }
-
-        rc = server->ops->calc_signature(rqst, server);
-
-        return rc;
-}
-
-int
-smb2_verify_signature(struct smb_rqst *rqst, struct TCP_Server_Info *server)
-{
-        unsigned int rc;
-        char server_response_sig[16];
-        struct smb2_hdr *smb2_pdu = (struct smb2_hdr *)rqst->rq_iov[0].iov_base;
-
-        if ((smb2_pdu->Command == SMB2_NEGOTIATE) ||
-            (smb2_pdu->Command == SMB2_OPLOCK_BREAK) ||
-            (!server->session_estab))
-                return 0;
-
-        /*
-         * BB what if signatures are supposed to be on for session but
-         * server does not send one? BB
-         */
-
-        /* Do not need to verify session setups with signature "BSRSPYL " */
-        if (memcmp(smb2_pdu->Signature, "BSRSPYL ", 8) == 0)
-                cFYI(1, "dummy signature received for smb command 0x%x",
-                        smb2_pdu->Command);
-
-        /*
-         * Save off the origiginal signature so we can modify the smb and check
-         * our calculated signature against what the server sent.
-         */
-        memcpy(server_response_sig, smb2_pdu->Signature, SMB2_SIGNATURE_SIZE);
-
-        memset(smb2_pdu->Signature, 0, SMB2_SIGNATURE_SIZE);
-
-        mutex_lock(&server->srv_mutex);
-        rc = server->ops->calc_signature(rqst, server);
-        mutex_unlock(&server->srv_mutex);
-
-        if (rc)
-                return rc;
-
-        if (memcmp(server_response_sig, smb2_pdu->Signature,
-                   SMB2_SIGNATURE_SIZE))
-                return -EACCES;
-        else
-                return 0;
-}
-
-/*
- * Set message id for the request. Should be called after wait_for_free_request
- * and when srv_mutex is held.
- */
-static inline void
-smb2_seq_num_into_buf(struct TCP_Server_Info *server, struct smb2_hdr *hdr)
-{
-        hdr->MessageId = get_next_mid(server);
-}
-
-static struct mid_q_entry *
-smb2_mid_entry_alloc(const struct smb2_hdr *smb_buffer,
-                     struct TCP_Server_Info *server)
-{
-        struct mid_q_entry *temp;
-
-        if (server == NULL) {
-                cERROR(1, "Null TCP session in smb2_mid_entry_alloc");
-                return NULL;
-        }
-
-        temp = mempool_alloc(cifs_mid_poolp, GFP_NOFS);
-        if (temp == NULL)
-                return temp;
-        else {
-                memset(temp, 0, sizeof(struct mid_q_entry));
-                temp->mid = smb_buffer->MessageId;      /* always LE */
-                temp->pid = current->pid;
-                temp->command = smb_buffer->Command;    /* Always LE */
-                temp->when_alloc = jiffies;
-                temp->server = server;
-
-                /*
-                 * The default is for the mid to be synchronous, so the
-                 * default callback just wakes up the current task.
-                 */
-                temp->callback = cifs_wake_up_task;
-                temp->callback_data = current;
-        }
-
-        atomic_inc(&midCount);
-        temp->mid_state = MID_REQUEST_ALLOCATED;
-        return temp;
-}
-
-static int
-smb2_get_mid_entry(struct cifs_ses *ses, struct smb2_hdr *buf,
-                   struct mid_q_entry **mid)
-{
-        if (ses->server->tcpStatus == CifsExiting)
-                return -ENOENT;
-
-        if (ses->server->tcpStatus == CifsNeedReconnect) {
-                cFYI(1, "tcp session dead - return to caller to retry");
-                return -EAGAIN;
-        }
-
-        if (ses->status != CifsGood) {
-                /* check if SMB2 session is bad because we are setting it up */
-                if ((buf->Command != SMB2_SESSION_SETUP) &&
-                    (buf->Command != SMB2_NEGOTIATE))
-                        return -EAGAIN;
-                /* else ok - we are setting up session */
-        }
-        *mid = smb2_mid_entry_alloc(buf, ses->server);
-        if (*mid == NULL)
-                return -ENOMEM;
-        spin_lock(&GlobalMid_Lock);
-        list_add_tail(&(*mid)->qhead, &ses->server->pending_mid_q);
-        spin_unlock(&GlobalMid_Lock);
-        return 0;
-}
-
-int
-smb2_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,
-                   bool log_error)
-{
-        unsigned int len = get_rfc1002_length(mid->resp_buf);
-        struct kvec iov;
-        struct smb_rqst rqst = { .rq_iov = &iov,
-                                 .rq_nvec = 1 };
-
-        iov.iov_base = (char *)mid->resp_buf;
-        iov.iov_len = get_rfc1002_length(mid->resp_buf) + 4;
-
-        dump_smb(mid->resp_buf, min_t(u32, 80, len));
-        /* convert the length into a more usable form */
-        if ((len > 24) &&
-            (server->sec_mode & (SECMODE_SIGN_REQUIRED|SECMODE_SIGN_ENABLED))) {
-                int rc;
-
-                rc = smb2_verify_signature(&rqst, server);
-                if (rc)
-                        cERROR(1, "SMB signature verification returned error = "
-                               "%d", rc);
-        }
-
-        return map_smb2_to_linux_error(mid->resp_buf, log_error);
-}
-
-struct mid_q_entry *
-smb2_setup_request(struct cifs_ses *ses, struct smb_rqst *rqst)
-{
-        int rc;
-        struct smb2_hdr *hdr = (struct smb2_hdr *)rqst->rq_iov[0].iov_base;
-        struct mid_q_entry *mid;
-
-        smb2_seq_num_into_buf(ses->server, hdr);
-
-        rc = smb2_get_mid_entry(ses, hdr, &mid);
-        if (rc)
-                return ERR_PTR(rc);
-        rc = smb2_sign_rqst(rqst, ses->server);
-        if (rc) {
-                cifs_delete_mid(mid);
-                return ERR_PTR(rc);
-        }
-        return mid;
-}
-
-struct mid_q_entry *
-smb2_setup_async_request(struct TCP_Server_Info *server, struct smb_rqst *rqst)
-{
-        int rc;
-        struct smb2_hdr *hdr = (struct smb2_hdr *)rqst->rq_iov[0].iov_base;
-        struct mid_q_entry *mid;
-
-        smb2_seq_num_into_buf(server, hdr);
-
-        mid = smb2_mid_entry_alloc(hdr, server);
-        if (mid == NULL)
-                return ERR_PTR(-ENOMEM);
-
-        rc = smb2_sign_rqst(rqst, server);
-        if (rc) {
-                DeleteMidQEntry(mid);
-                return ERR_PTR(rc);
-        }
-
-        return mid;
-}
diff --git a/fs/cifs/smbencrypt.c b/fs/cifs/smbencrypt.c
index a0a58fbe2c1..42b9fff4875 100644
--- a/fs/cifs/smbencrypt.c
+++ b/fs/cifs/smbencrypt.c
@@ -78,7 +78,7 @@ smbhash(unsigned char *out, const unsigned char *in, unsigned char *key)
         tfm_des = crypto_alloc_blkcipher("ecb(des)", 0, CRYPTO_ALG_ASYNC);
         if (IS_ERR(tfm_des)) {
                 rc = PTR_ERR(tfm_des);
-                cERROR(1, "could not allocate des crypto API");
+                cERROR(1, "could not allocate des crypto API\n");
                 goto smbhash_err;
         }
 
@@ -91,7 +91,7 @@ smbhash(unsigned char *out, const unsigned char *in, unsigned char *key)
 
         rc = crypto_blkcipher_encrypt(&desc, &sgout, &sgin, 8);
         if (rc)
-                cERROR(1, "could not encrypt crypt key rc: %d", rc);
+                cERROR(1, "could not encrypt crypt key rc: %d\n", rc);
 
         crypto_free_blkcipher(tfm_des);
 smbhash_err:
@@ -139,14 +139,14 @@ mdfour(unsigned char *md4_hash, unsigned char *link_str, int link_len)
         md4 = crypto_alloc_shash("md4", 0, 0);
         if (IS_ERR(md4)) {
                 rc = PTR_ERR(md4);
-                cERROR(1, "%s: Crypto md4 allocation error %d", __func__, rc);
+                cERROR(1, "%s: Crypto md4 allocation error %d\n", __func__, rc);
                 return rc;
         }
         size = sizeof(struct shash_desc) + crypto_shash_descsize(md4);
         sdescmd4 = kmalloc(size, GFP_KERNEL);
         if (!sdescmd4) {
                 rc = -ENOMEM;
-                cERROR(1, "%s: Memory allocation failure", __func__);
+                cERROR(1, "%s: Memory allocation failure\n", __func__);
                 goto mdfour_err;
         }
         sdescmd4->shash.tfm = md4;
@@ -154,17 +154,17 @@ mdfour(unsigned char *md4_hash, unsigned char *link_str, int link_len)
 
         rc = crypto_shash_init(&sdescmd4->shash);
         if (rc) {
-                cERROR(1, "%s: Could not init md4 shash", __func__);
+                cERROR(1, "%s: Could not init md4 shash\n", __func__);
                 goto mdfour_err;
         }
         rc = crypto_shash_update(&sdescmd4->shash, link_str, link_len);
         if (rc) {
-                cERROR(1, "%s: Could not update with link_str", __func__);
+                cERROR(1, "%s: Could not update with link_str\n", __func__);
                 goto mdfour_err;
         }
         rc = crypto_shash_final(&sdescmd4->shash, md4_hash);
         if (rc)
-                cERROR(1, "%s: Could not genereate md4 hash", __func__);
+                cERROR(1, "%s: Could not genereate md4 hash\n", __func__);
 
 mdfour_err:
         crypto_free_shash(md4);
@@ -199,36 +199,160 @@ SMBencrypt(unsigned char *passwd, const unsigned char *c8, unsigned char *p24)
         return rc;
 }
 
+/* Routines for Windows NT MD4 Hash functions. */
+static int
+_my_wcslen(__u16 *str)
+{
+        int len = 0;
+        while (*str++ != 0)
+                len++;
+        return len;
+}
+
+/*
+ * Convert a string into an NT UNICODE string.
+ * Note that regardless of processor type
+ * this must be in intel (little-endian)
+ * format.
+ */
+
+static int
+_my_mbstowcs(__u16 *dst, const unsigned char *src, int len)
+{       /* BB not a very good conversion routine - change/fix */
+        int i;
+        __u16 val;
+
+        for (i = 0; i < len; i++) {
+                val = *src;
+                SSVAL(dst, 0, val);
+                dst++;
+                src++;
+                if (val == 0)
+                        break;
+        }
+        return i;
+}
+
 /*
  * Creates the MD4 Hash of the users password in NT UNICODE.
  */
 
 int
-E_md4hash(const unsigned char *passwd, unsigned char *p16,
-        const struct nls_table *codepage)
+E_md4hash(const unsigned char *passwd, unsigned char *p16)
 {
         int rc;
         int len;
-        __le16 wpwd[129];
+        __u16 wpwd[129];
 
         /* Password cannot be longer than 128 characters */
-        if (passwd) /* Password must be converted to NT unicode */
-                len = cifs_strtoUTF16(wpwd, passwd, 128, codepage);
-        else {
+        if (passwd) {
+                len = strlen((char *) passwd);
+                if (len > 128)
+                        len = 128;
+
+                /* Password must be converted to NT unicode */
+                _my_mbstowcs(wpwd, passwd, len);
+        } else
                 len = 0;
-                *wpwd = 0; /* Ensure string is null terminated */
-        }
 
-        rc = mdfour(p16, (unsigned char *) wpwd, len * sizeof(__le16));
-        memset(wpwd, 0, 129 * sizeof(__le16));
+        wpwd[len] = 0;  /* Ensure string is null terminated */
+        /* Calculate length in bytes */
+        len = _my_wcslen(wpwd) * sizeof(__u16);
+
+        rc = mdfour(p16, (unsigned char *) wpwd, len);
+        memset(wpwd, 0, 129 * 2);
 
         return rc;
 }
 
+#if 0 /* currently unused */
+/* Does both the NT and LM owfs of a user's password */
+static void
+nt_lm_owf_gen(char *pwd, unsigned char nt_p16[16], unsigned char p16[16])
+{
+        char passwd[514];
+
+        memset(passwd, '\0', 514);
+        if (strlen(pwd) < 513)
+                strcpy(passwd, pwd);
+        else
+                memcpy(passwd, pwd, 512);
+        /* Calculate the MD4 hash (NT compatible) of the password */
+        memset(nt_p16, '\0', 16);
+        E_md4hash(passwd, nt_p16);
+
+        /* Mangle the passwords into Lanman format */
+        passwd[14] = '\0';
+/*      strupper(passwd); */
+
+        /* Calculate the SMB (lanman) hash functions of the password */
+
+        memset(p16, '\0', 16);
+        E_P16((unsigned char *) passwd, (unsigned char *) p16);
+
+        /* clear out local copy of user's password (just being paranoid). */
+        memset(passwd, '\0', sizeof(passwd));
+}
+#endif
+
+/* Does the NTLMv2 owfs of a user's password */
+#if 0  /* function not needed yet - but will be soon */
+static void
+ntv2_owf_gen(const unsigned char owf[16], const char *user_n,
+                const char *domain_n, unsigned char kr_buf[16],
+                const struct nls_table *nls_codepage)
+{
+        wchar_t *user_u;
+        wchar_t *dom_u;
+        int user_l, domain_l;
+        struct HMACMD5Context ctx;
+
+        /* might as well do one alloc to hold both (user_u and dom_u) */
+        user_u = kmalloc(2048 * sizeof(wchar_t), GFP_KERNEL);
+        if (user_u == NULL)
+                return;
+        dom_u = user_u + 1024;
+
+        /* push_ucs2(NULL, user_u, user_n, (user_l+1)*2,
+                        STR_UNICODE|STR_NOALIGN|STR_TERMINATE|STR_UPPER);
+           push_ucs2(NULL, dom_u, domain_n, (domain_l+1)*2,
+                        STR_UNICODE|STR_NOALIGN|STR_TERMINATE|STR_UPPER); */
+
+        /* BB user and domain may need to be uppercased */
+        user_l = cifs_strtoUCS(user_u, user_n, 511, nls_codepage);
+        domain_l = cifs_strtoUCS(dom_u, domain_n, 511, nls_codepage);
+
+        user_l++;               /* trailing null */
+        domain_l++;
+
+        hmac_md5_init_limK_to_64(owf, 16, &ctx);
+        hmac_md5_update((const unsigned char *) user_u, user_l * 2, &ctx);
+        hmac_md5_update((const unsigned char *) dom_u, domain_l * 2, &ctx);
+        hmac_md5_final(kr_buf, &ctx);
+
+        kfree(user_u);
+}
+#endif
+
+/* Does the des encryption from the FIRST 8 BYTES of the NT or LM MD4 hash. */
+#if 0 /* currently unused */
+static void
+NTLMSSPOWFencrypt(unsigned char passwd[8],
+                  unsigned char *ntlmchalresp, unsigned char p24[24])
+{
+        unsigned char p21[21];
+
+        memset(p21, '\0', 21);
+        memcpy(p21, passwd, 8);
+        memset(p21 + 8, 0xbd, 8);
+
+        E_P24(p21, ntlmchalresp, p24);
+}
+#endif
+
 /* Does the NT MD4 hash then des encryption. */
 int
-SMBNTencrypt(unsigned char *passwd, unsigned char *c8, unsigned char *p24,
-                const struct nls_table *codepage)
+SMBNTencrypt(unsigned char *passwd, unsigned char *c8, unsigned char *p24)
 {
         int rc;
         unsigned char p16[16], p21[21];
@@ -236,7 +360,7 @@ SMBNTencrypt(unsigned char *passwd, unsigned char *c8, unsigned char *p24,
         memset(p16, '\0', 16);
         memset(p21, '\0', 21);
 
-        rc = E_md4hash(passwd, p16, codepage);
+        rc = E_md4hash(passwd, p16);
         if (rc) {
                 cFYI(1, "%s Can't generate NT hash, error: %d", __func__, rc);
                 return rc;
@@ -245,3 +369,39 @@ SMBNTencrypt(unsigned char *passwd, unsigned char *c8, unsigned char *p24,
         rc = E_P24(p21, c8, p24);
         return rc;
 }
+
+
+/* Does the md5 encryption from the NT hash for NTLMv2. */
+/* These routines will be needed later */
+#if 0
+static void
+SMBOWFencrypt_ntv2(const unsigned char kr[16],
+                   const struct data_blob *srv_chal,
+                   const struct data_blob *cli_chal, unsigned char resp_buf[16])
+{
+        struct HMACMD5Context ctx;
+
+        hmac_md5_init_limK_to_64(kr, 16, &ctx);
+        hmac_md5_update(srv_chal->data, srv_chal->length, &ctx);
+        hmac_md5_update(cli_chal->data, cli_chal->length, &ctx);
+        hmac_md5_final(resp_buf, &ctx);
+}
+
+static void
+SMBsesskeygen_ntv2(const unsigned char kr[16],
+                   const unsigned char *nt_resp, __u8 sess_key[16])
+{
+        struct HMACMD5Context ctx;
+
+        hmac_md5_init_limK_to_64(kr, 16, &ctx);
+        hmac_md5_update(nt_resp, 16, &ctx);
+        hmac_md5_final((unsigned char *) sess_key, &ctx);
+}
+
+static void
+SMBsesskeygen_ntv1(const unsigned char kr[16],
+                   const unsigned char *nt_resp, __u8 sess_key[16])
+{
+        mdfour((unsigned char *) sess_key, (unsigned char *) kr, 16);
+}
+#endif
diff --git a/fs/cifs/transport.c b/fs/cifs/transport.c
index 1a528680ec5..10ca6b2c26b 100644
--- a/fs/cifs/transport.c
+++ b/fs/cifs/transport.c
@@ -26,9 +26,6 @@
 #include <linux/wait.h>
 #include <linux/net.h>
 #include <linux/delay.h>
-#include <linux/freezer.h>
-#include <linux/tcp.h>
-#include <linux/highmem.h>
 #include <asm/uaccess.h>
 #include <asm/processor.h>
 #include <linux/mempool.h>
@@ -37,8 +34,10 @@
 #include "cifsproto.h"
 #include "cifs_debug.h"
 
-void
-cifs_wake_up_task(struct mid_q_entry *mid)
+extern mempool_t *cifs_mid_poolp;
+
+static void
+wake_up_task(struct mid_q_entry *mid)
 {
         wake_up_process(mid->callback_data);
 }
@@ -60,23 +59,22 @@ AllocMidQEntry(const struct smb_hdr *smb_buffer, struct TCP_Server_Info *server)
                 memset(temp, 0, sizeof(struct mid_q_entry));
                 temp->mid = smb_buffer->Mid;    /* always LE */
                 temp->pid = current->pid;
-                temp->command = cpu_to_le16(smb_buffer->Command);
-                cFYI(1, "For smb_command %d", smb_buffer->Command);
+                temp->command = smb_buffer->Command;
+                cFYI(1, "For smb_command %d", temp->command);
         /*      do_gettimeofday(&temp->when_sent);*/ /* easier to use jiffies */
                 /* when mid allocated can be before when sent */
                 temp->when_alloc = jiffies;
-                temp->server = server;
 
                 /*
                  * The default is for the mid to be synchronous, so the
                  * default callback just wakes up the current task.
                  */
-                temp->callback = cifs_wake_up_task;
+                temp->callback = wake_up_task;
                 temp->callback_data = current;
         }
 
         atomic_inc(&midCount);
-        temp->mid_state = MID_REQUEST_ALLOCATED;
+        temp->midState = MID_REQUEST_ALLOCATED;
         return temp;
 }
 
@@ -84,12 +82,11 @@ void
 DeleteMidQEntry(struct mid_q_entry *midEntry)
 {
 #ifdef CONFIG_CIFS_STATS2
-        __le16 command = midEntry->server->vals->lock_cmd;
         unsigned long now;
 #endif
-        midEntry->mid_state = MID_FREE;
+        midEntry->midState = MID_FREE;
         atomic_dec(&midCount);
-        if (midEntry->large_buf)
+        if (midEntry->largeBuf)
                 cifs_buf_release(midEntry->resp_buf);
         else
                 cifs_small_buf_release(midEntry->resp_buf);
@@ -98,8 +95,9 @@ DeleteMidQEntry(struct mid_q_entry *midEntry)
         /* commands taking longer than one second are indications that
            something is wrong, unless it is quite a slow link or server */
         if ((now - midEntry->when_alloc) > HZ) {
-                if ((cifsFYI & CIFS_TIMER) && (midEntry->command != command)) {
-                        printk(KERN_DEBUG " CIFS slow rsp: cmd %d mid %llu",
+                if ((cifsFYI & CIFS_TIMER) &&
+                   (midEntry->command != SMB_COM_LOCKING_ANDX)) {
+                        printk(KERN_DEBUG " CIFS slow rsp: cmd %d mid %d",
                                midEntry->command, midEntry->mid);
                         printk(" A: 0x%lx S: 0x%lx R: 0x%lx\n",
                                now - midEntry->when_alloc,
@@ -111,8 +109,8 @@ DeleteMidQEntry(struct mid_q_entry *midEntry)
         mempool_free(midEntry, cifs_mid_poolp);
 }
 
-void
-cifs_delete_mid(struct mid_q_entry *mid)
+static void
+delete_mid(struct mid_q_entry *mid)
 {
         spin_lock(&GlobalMid_Lock);
         list_del(&mid->qhead);
@@ -121,28 +119,21 @@ cifs_delete_mid(struct mid_q_entry *mid)
         DeleteMidQEntry(mid);
 }
 
-/*
- * smb_send_kvec - send an array of kvecs to the server
- * @server:     Server to send the data to
- * @iov:        Pointer to array of kvecs
- * @n_vec:      length of kvec array
- * @sent:       amount of data sent on socket is stored here
- *
- * Our basic "send data to server" function. Should be called with srv_mutex
- * held. The caller is responsible for handling the results.
- */
 static int
-smb_send_kvec(struct TCP_Server_Info *server, struct kvec *iov, size_t n_vec,
-                size_t *sent)
+smb_sendv(struct TCP_Server_Info *server, struct kvec *iov, int n_vec)
 {
         int rc = 0;
         int i = 0;
         struct msghdr smb_msg;
-        unsigned int remaining;
-        size_t first_vec = 0;
+        struct smb_hdr *smb_buffer = iov[0].iov_base;
+        unsigned int len = iov[0].iov_len;
+        unsigned int total_len;
+        int first_vec = 0;
+        unsigned int smb_buf_length = be32_to_cpu(smb_buffer->smb_buf_length);
         struct socket *ssocket = server->ssocket;
 
-        *sent = 0;
+        if (ssocket == NULL)
+                return -ENOTSOCK; /* BB eventually add reconnect code here */
 
         smb_msg.msg_name = (struct sockaddr *) &server->dstaddr;
         smb_msg.msg_namelen = sizeof(struct sockaddr);
@@ -153,66 +144,56 @@ smb_send_kvec(struct TCP_Server_Info *server, struct kvec *iov, size_t n_vec,
         else
                 smb_msg.msg_flags = MSG_NOSIGNAL;
 
-        remaining = 0;
+        total_len = 0;
         for (i = 0; i < n_vec; i++)
-                remaining += iov[i].iov_len;
+                total_len += iov[i].iov_len;
+
+        cFYI(1, "Sending smb:  total_len %d", total_len);
+        dump_smb(smb_buffer, len);
 
         i = 0;
-        while (remaining) {
-                /*
-                 * If blocking send, we try 3 times, since each can block
-                 * for 5 seconds. For nonblocking  we have to try more
-                 * but wait increasing amounts of time allowing time for
-                 * socket to clear.  The overall time we wait in either
-                 * case to send on the socket is about 15 seconds.
-                 * Similarly we wait for 15 seconds for a response from
-                 * the server in SendReceive[2] for the server to send
-                 * a response back for most types of requests (except
-                 * SMB Write past end of file which can be slow, and
-                 * blocking lock operations). NFS waits slightly longer
-                 * than CIFS, but this can make it take longer for
-                 * nonresponsive servers to be detected and 15 seconds
-                 * is more than enough time for modern networks to
-                 * send a packet.  In most cases if we fail to send
-                 * after the retries we will kill the socket and
-                 * reconnect which may clear the network problem.
-                 */
+        while (total_len) {
                 rc = kernel_sendmsg(ssocket, &smb_msg, &iov[first_vec],
-                                    n_vec - first_vec, remaining);
-                if (rc == -ENOSPC || rc == -EAGAIN) {
-                        /*
-                         * Catch if a low level driver returns -ENOSPC. This
-                         * WARN_ON will be removed by 3.10 if no one reports
-                         * seeing this.
-                         */
-                        WARN_ON_ONCE(rc == -ENOSPC);
+                                    n_vec - first_vec, total_len);
+                if ((rc == -ENOSPC) || (rc == -EAGAIN)) {
                         i++;
-                        if (i >= 14 || (!server->noblocksnd && (i > 2))) {
-                                cERROR(1, "sends on sock %p stuck for 15 "
-                                          "seconds", ssocket);
+                        /* if blocking send we try 3 times, since each can block
+                           for 5 seconds. For nonblocking  we have to try more
+                           but wait increasing amounts of time allowing time for
+                           socket to clear.  The overall time we wait in either
+                           case to send on the socket is about 15 seconds.
+                           Similarly we wait for 15 seconds for
+                           a response from the server in SendReceive[2]
+                           for the server to send a response back for
+                           most types of requests (except SMB Write
+                           past end of file which can be slow, and
+                           blocking lock operations). NFS waits slightly longer
+                           than CIFS, but this can make it take longer for
+                           nonresponsive servers to be detected and 15 seconds
+                           is more than enough time for modern networks to
+                           send a packet.  In most cases if we fail to send
+                           after the retries we will kill the socket and
+                           reconnect which may clear the network problem.
+                        */
+                        if ((i >= 14) || (!server->noblocksnd && (i > 2))) {
+                                cERROR(1, "sends on sock %p stuck for 15 seconds",
+                                    ssocket);
                                 rc = -EAGAIN;
                                 break;
                         }
                         msleep(1 << i);
                         continue;
                 }
-
                 if (rc < 0)
                         break;
 
-                /* send was at least partially successful */
-                *sent += rc;
-
-                if (rc == remaining) {
-                        remaining = 0;
+                if (rc == total_len) {
+                        total_len = 0;
                         break;
-                }
-
-                if (rc > remaining) {
-                        cERROR(1, "sent %d requested %d", rc, remaining);
+                } else if (rc > total_len) {
+                        cERROR(1, "sent %d requested %d", rc, total_len);
                         break;
                 }
-
                 if (rc == 0) {
                         /* should never happen, letting socket clear before
                            retrying is our only obvious option here */
@@ -220,9 +201,7 @@ smb_send_kvec(struct TCP_Server_Info *server, struct kvec *iov, size_t n_vec,
                         msleep(500);
                         continue;
                 }
-
-                remaining -= rc;
-
+                total_len -= rc;
                 /* the line below resets i */
                 for (i = first_vec; i < n_vec; i++) {
                         if (iov[i].iov_len) {
@@ -237,100 +216,16 @@ smb_send_kvec(struct TCP_Server_Info *server, struct kvec *iov, size_t n_vec,
                                 }
                         }
                 }
-
                 i = 0; /* in case we get ENOSPC on the next send */
-                rc = 0;
         }
-        return rc;
-}
-
-/**
- * rqst_page_to_kvec - Turn a slot in the smb_rqst page array into a kvec
- * @rqst: pointer to smb_rqst
- * @idx: index into the array of the page
- * @iov: pointer to struct kvec that will hold the result
- *
- * Helper function to convert a slot in the rqst->rq_pages array into a kvec.
- * The page will be kmapped and the address placed into iov_base. The length
- * will then be adjusted according to the ptailoff.
- */
-void
-cifs_rqst_page_to_kvec(struct smb_rqst *rqst, unsigned int idx,
-                        struct kvec *iov)
-{
-        /*
-         * FIXME: We could avoid this kmap altogether if we used
-         * kernel_sendpage instead of kernel_sendmsg. That will only
-         * work if signing is disabled though as sendpage inlines the
-         * page directly into the fraglist. If userspace modifies the
-         * page after we calculate the signature, then the server will
-         * reject it and may break the connection. kernel_sendmsg does
-         * an extra copy of the data and avoids that issue.
-         */
-        iov->iov_base = kmap(rqst->rq_pages[idx]);
-
-        /* if last page, don't send beyond this offset into page */
-        if (idx == (rqst->rq_npages - 1))
-                iov->iov_len = rqst->rq_tailsz;
-        else
-                iov->iov_len = rqst->rq_pagesz;
-}
-
-static int
-smb_send_rqst(struct TCP_Server_Info *server, struct smb_rqst *rqst)
-{
-        int rc;
-        struct kvec *iov = rqst->rq_iov;
-        int n_vec = rqst->rq_nvec;
-        unsigned int smb_buf_length = get_rfc1002_length(iov[0].iov_base);
-        unsigned int i;
-        size_t total_len = 0, sent;
-        struct socket *ssocket = server->ssocket;
-        int val = 1;
-
-        if (ssocket == NULL)
-                return -ENOTSOCK;
-
-        cFYI(1, "Sending smb: smb_len=%u", smb_buf_length);
-        dump_smb(iov[0].iov_base, iov[0].iov_len);
-
-        /* cork the socket */
-        kernel_setsockopt(ssocket, SOL_TCP, TCP_CORK,
-                                (char *)&val, sizeof(val));
-
-        rc = smb_send_kvec(server, iov, n_vec, &sent);
-        if (rc < 0)
-                goto uncork;
-
-        total_len += sent;
-
-        /* now walk the page array and send each page in it */
-        for (i = 0; i < rqst->rq_npages; i++) {
-                struct kvec p_iov;
-
-                cifs_rqst_page_to_kvec(rqst, i, &p_iov);
-                rc = smb_send_kvec(server, &p_iov, 1, &sent);
-                kunmap(rqst->rq_pages[i]);
-                if (rc < 0)
-                        break;
-
-                total_len += sent;
-        }
-
-uncork:
-        /* uncork it */
-        val = 0;
-        kernel_setsockopt(ssocket, SOL_TCP, TCP_CORK,
-                                (char *)&val, sizeof(val));
 
         if ((total_len > 0) && (total_len != smb_buf_length + 4)) {
-                cFYI(1, "partial send (wanted=%u sent=%zu): terminating "
-                        "session", smb_buf_length + 4, total_len);
-                /*
-                 * If we have only sent part of an SMB then the next SMB could
-                 * be taken as the remainder of this one. We need to kill the
-                 * socket so the server throws away the partial SMB
-                 */
+                cFYI(1, "partial send (%d remaining), terminating session",
+                        total_len);
+                /* If we have only sent part of an SMB then the next SMB
+                   could be taken as the remainder of this one.  We need
+                   to kill the socket so the server throws away the partial
+                   SMB */
                 server->tcpStatus = CifsNeedReconnect;
         }
 
@@ -339,16 +234,11 @@ uncork:
         else
                 rc = 0;
 
-        return rc;
-}
+        /* Don't want to modify the buffer as a
+           side effect of this call. */
+        smb_buffer->smb_buf_length = cpu_to_be32(smb_buf_length);
 
-static int
-smb_sendv(struct TCP_Server_Info *server, struct kvec *iov, int n_vec)
-{
-        struct smb_rqst rqst = { .rq_iov = iov,
-                                 .rq_nvec = n_vec };
-
-        return smb_send_rqst(server, &rqst);
+        return rc;
 }
 
 int
@@ -363,62 +253,44 @@ smb_send(struct TCP_Server_Info *server, struct smb_hdr *smb_buffer,
         return smb_sendv(server, &iov, 1);
 }
 
-static int
-wait_for_free_credits(struct TCP_Server_Info *server, const int timeout,
-                      int *credits)
+static int wait_for_free_request(struct TCP_Server_Info *server,
+                                 const int long_op)
 {
-        int rc;
-
-        spin_lock(&server->req_lock);
-        if (timeout == CIFS_ASYNC_OP) {
+        if (long_op == CIFS_ASYNC_OP) {
                 /* oplock breaks must not be held up */
-                server->in_flight++;
-                *credits -= 1;
-                spin_unlock(&server->req_lock);
+                atomic_inc(&server->inFlight);
                 return 0;
         }
 
+        spin_lock(&GlobalMid_Lock);
         while (1) {
-                if (*credits <= 0) {
-                        spin_unlock(&server->req_lock);
+                if (atomic_read(&server->inFlight) >= cifs_max_pending) {
+                        spin_unlock(&GlobalMid_Lock);
                         cifs_num_waiters_inc(server);
-                        rc = wait_event_killable(server->request_q,
-                                                 has_credits(server, credits));
+                        wait_event(server->request_q,
+                                   atomic_read(&server->inFlight)
+                                     < cifs_max_pending);
                         cifs_num_waiters_dec(server);
-                        if (rc)
-                                return rc;
-                        spin_lock(&server->req_lock);
+                        spin_lock(&GlobalMid_Lock);
                 } else {
                         if (server->tcpStatus == CifsExiting) {
-                                spin_unlock(&server->req_lock);
+                                spin_unlock(&GlobalMid_Lock);
                                 return -ENOENT;
                         }
 
-                        /*
-                         * Can not count locking commands against total
-                         * as they are allowed to block on server.
-                         */
+                        /* can not count locking commands against total
+                           as they are allowed to block on server */
 
                         /* update # of requests on the wire to server */
-                        if (timeout != CIFS_BLOCKING_OP) {
-                                *credits -= 1;
-                                server->in_flight++;
-                        }
-                        spin_unlock(&server->req_lock);
+                        if (long_op != CIFS_BLOCKING_OP)
+                                atomic_inc(&server->inFlight);
+                        spin_unlock(&GlobalMid_Lock);
                         break;
                 }
         }
         return 0;
 }
 
-static int
-wait_for_free_request(struct TCP_Server_Info *server, const int timeout,
-                      const int optype)
-{
-        return wait_for_free_credits(server, timeout,
-                                server->ops->get_credits_field(server, optype));
-}
-
 static int allocate_mid(struct cifs_ses *ses, struct smb_hdr *in_buf,
                         struct mid_q_entry **ppmidQ)
 {
@@ -452,88 +324,73 @@ wait_for_response(struct TCP_Server_Info *server, struct mid_q_entry *midQ)
 {
         int error;
 
-        error = wait_event_freezekillable(server->response_q,
-                                    midQ->mid_state != MID_REQUEST_SUBMITTED);
+        error = wait_event_killable(server->response_q,
+                                    midQ->midState != MID_REQUEST_SUBMITTED);
         if (error < 0)
                 return -ERESTARTSYS;
 
         return 0;
 }
 
-struct mid_q_entry *
-cifs_setup_async_request(struct TCP_Server_Info *server, struct smb_rqst *rqst)
-{
-        int rc;
-        struct smb_hdr *hdr = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
-        struct mid_q_entry *mid;
-
-        /* enable signing if server requires it */
-        if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
-                hdr->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
-
-        mid = AllocMidQEntry(hdr, server);
-        if (mid == NULL)
-                return ERR_PTR(-ENOMEM);
-
-        rc = cifs_sign_rqst(rqst, server, &mid->sequence_number);
-        if (rc) {
-                DeleteMidQEntry(mid);
-                return ERR_PTR(rc);
-        }
-
-        return mid;
-}
 
 /*
  * Send a SMB request and set the callback function in the mid to handle
  * the result. Caller is responsible for dealing with timeouts.
  */
 int
-cifs_call_async(struct TCP_Server_Info *server, struct smb_rqst *rqst,
-                mid_receive_t *receive, mid_callback_t *callback,
-                void *cbdata, const int flags)
+cifs_call_async(struct TCP_Server_Info *server, struct kvec *iov,
+                unsigned int nvec, mid_callback_t *callback, void *cbdata,
+                bool ignore_pend)
 {
-        int rc, timeout, optype;
+        int rc;
         struct mid_q_entry *mid;
+        struct smb_hdr *hdr = (struct smb_hdr *)iov[0].iov_base;
 
-        timeout = flags & CIFS_TIMEOUT_MASK;
-        optype = flags & CIFS_OP_MASK;
-
-        rc = wait_for_free_request(server, timeout, optype);
+        rc = wait_for_free_request(server, ignore_pend ? CIFS_ASYNC_OP : 0);
         if (rc)
                 return rc;
 
+        /* enable signing if server requires it */
+        if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
+                hdr->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
+
         mutex_lock(&server->srv_mutex);
-        mid = server->ops->setup_async_request(server, rqst);
-        if (IS_ERR(mid)) {
+        mid = AllocMidQEntry(hdr, server);
+        if (mid == NULL) {
                 mutex_unlock(&server->srv_mutex);
-                add_credits(server, 1, optype);
+                atomic_dec(&server->inFlight);
                 wake_up(&server->request_q);
-                return PTR_ERR(mid);
+                return -ENOMEM;
         }
 
-        mid->receive = receive;
-        mid->callback = callback;
-        mid->callback_data = cbdata;
-        mid->mid_state = MID_REQUEST_SUBMITTED;
-
         /* put it on the pending_mid_q */
         spin_lock(&GlobalMid_Lock);
         list_add_tail(&mid->qhead, &server->pending_mid_q);
         spin_unlock(&GlobalMid_Lock);
 
+        rc = cifs_sign_smb2(iov, nvec, server, &mid->sequence_number);
+        if (rc) {
+                mutex_unlock(&server->srv_mutex);
+                goto out_err;
+        }
+
+        mid->callback = callback;
+        mid->callback_data = cbdata;
+        mid->midState = MID_REQUEST_SUBMITTED;
 
         cifs_in_send_inc(server);
-        rc = smb_send_rqst(server, rqst);
+        rc = smb_sendv(server, iov, nvec);
         cifs_in_send_dec(server);
         cifs_save_when_sent(mid);
         mutex_unlock(&server->srv_mutex);
 
-        if (rc == 0)
-                return 0;
+        if (rc)
+                goto out_err;
 
-        cifs_delete_mid(mid);
-        add_credits(server, 1, optype);
+        return rc;
+out_err:
+        delete_mid(mid);
+        atomic_dec(&server->inFlight);
         wake_up(&server->request_q);
         return rc;
 }
@@ -549,14 +406,14 @@ cifs_call_async(struct TCP_Server_Info *server, struct smb_rqst *rqst,
  */
 int
 SendReceiveNoRsp(const unsigned int xid, struct cifs_ses *ses,
-                 char *in_buf, int flags)
+                struct smb_hdr *in_buf, int flags)
 {
         int rc;
         struct kvec iov[1];
         int resp_buf_type;
 
-        iov[0].iov_base = in_buf;
-        iov[0].iov_len = get_rfc1002_length(in_buf) + 4;
+        iov[0].iov_base = (char *)in_buf;
+        iov[0].iov_len = be32_to_cpu(in_buf->smb_buf_length) + 4;
         flags |= CIFS_NO_RESP;
         rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags);
         cFYI(DBG2, "SendRcvNoRsp flags %d rc %d", flags, rc);
@@ -569,11 +426,11 @@ cifs_sync_mid_result(struct mid_q_entry *mid, struct TCP_Server_Info *server)
 {
         int rc = 0;
 
-        cFYI(1, "%s: cmd=%d mid=%llu state=%d", __func__,
-             le16_to_cpu(mid->command), mid->mid, mid->mid_state);
+        cFYI(1, "%s: cmd=%d mid=%d state=%d", __func__, mid->command,
+                mid->mid, mid->midState);
 
         spin_lock(&GlobalMid_Lock);
-        switch (mid->mid_state) {
+        switch (mid->midState) {
         case MID_RESPONSE_RECEIVED:
                 spin_unlock(&GlobalMid_Lock);
                 return rc;
@@ -588,8 +445,8 @@ cifs_sync_mid_result(struct mid_q_entry *mid, struct TCP_Server_Info *server)
                 break;
         default:
                 list_del_init(&mid->qhead);
-                cERROR(1, "%s: invalid mid state mid=%llu state=%d", __func__,
-                       mid->mid, mid->mid_state);
+                cERROR(1, "%s: invalid mid state mid=%d state=%d", __func__,
+                        mid->mid, mid->midState);
                 rc = -EIO;
         }
         spin_unlock(&GlobalMid_Lock);
@@ -598,119 +455,120 @@ cifs_sync_mid_result(struct mid_q_entry *mid, struct TCP_Server_Info *server)
         return rc;
 }
 
-static inline int
-send_cancel(struct TCP_Server_Info *server, void *buf, struct mid_q_entry *mid)
+/*
+ * An NT cancel request header looks just like the original request except:
+ *
+ * The Command is SMB_COM_NT_CANCEL
+ * The WordCount is zeroed out
+ * The ByteCount is zeroed out
+ *
+ * This function mangles an existing request buffer into a
+ * SMB_COM_NT_CANCEL request and then sends it.
+ */
+static int
+send_nt_cancel(struct TCP_Server_Info *server, struct smb_hdr *in_buf,
+                struct mid_q_entry *mid)
 {
-        return server->ops->send_cancel ?
-                                server->ops->send_cancel(server, buf, mid) : 0;
+        int rc = 0;
+
+        /* -4 for RFC1001 length and +2 for BCC field */
+        in_buf->smb_buf_length = cpu_to_be32(sizeof(struct smb_hdr) - 4  + 2);
+        in_buf->Command = SMB_COM_NT_CANCEL;
+        in_buf->WordCount = 0;
+        put_bcc(0, in_buf);
+
+        mutex_lock(&server->srv_mutex);
+        rc = cifs_sign_smb(in_buf, server, &mid->sequence_number);
+        if (rc) {
+                mutex_unlock(&server->srv_mutex);
+                return rc;
+        }
+        rc = smb_send(server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
+        mutex_unlock(&server->srv_mutex);
+
+        cFYI(1, "issued NT_CANCEL for mid %u, rc = %d",
+                in_buf->Mid, rc);
+
+        return rc;
 }
 
 int
 cifs_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,
                    bool log_error)
 {
-        unsigned int len = get_rfc1002_length(mid->resp_buf) + 4;
-
-        dump_smb(mid->resp_buf, min_t(u32, 92, len));
+        dump_smb(mid->resp_buf,
+                 min_t(u32, 92, be32_to_cpu(mid->resp_buf->smb_buf_length)));
 
         /* convert the length into a more usable form */
         if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
-                struct kvec iov;
-                int rc = 0;
-                struct smb_rqst rqst = { .rq_iov = &iov,
-                                         .rq_nvec = 1 };
-
-                iov.iov_base = mid->resp_buf;
-                iov.iov_len = len;
                 /* FIXME: add code to kill session */
-                rc = cifs_verify_signature(&rqst, server,
-                                           mid->sequence_number + 1);
-                if (rc)
-                        cERROR(1, "SMB signature verification returned error = "
-                               "%d", rc);
+                if (cifs_verify_signature(mid->resp_buf, server,
+                                          mid->sequence_number + 1) != 0)
+                        cERROR(1, "Unexpected SMB signature");
         }
 
         /* BB special case reconnect tid and uid here? */
         return map_smb_to_linux_error(mid->resp_buf, log_error);
 }
 
-struct mid_q_entry *
-cifs_setup_request(struct cifs_ses *ses, struct smb_rqst *rqst)
-{
-        int rc;
-        struct smb_hdr *hdr = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
-        struct mid_q_entry *mid;
-
-        rc = allocate_mid(ses, hdr, &mid);
-        if (rc)
-                return ERR_PTR(rc);
-        rc = cifs_sign_rqst(rqst, ses->server, &mid->sequence_number);
-        if (rc) {
-                cifs_delete_mid(mid);
-                return ERR_PTR(rc);
-        }
-        return mid;
-}
-
 int
 SendReceive2(const unsigned int xid, struct cifs_ses *ses,
-             struct kvec *iov, int n_vec, int *resp_buf_type /* ret */,
+             struct kvec *iov, int n_vec, int *pRespBufType /* ret */,
              const int flags)
 {
         int rc = 0;
-        int timeout, optype;
+        int long_op;
         struct mid_q_entry *midQ;
-        char *buf = iov[0].iov_base;
-        unsigned int credits = 1;
-        struct smb_rqst rqst = { .rq_iov = iov,
-                                 .rq_nvec = n_vec };
+        struct smb_hdr *in_buf = iov[0].iov_base;
 
-        timeout = flags & CIFS_TIMEOUT_MASK;
-        optype = flags & CIFS_OP_MASK;
+        long_op = flags & CIFS_TIMEOUT_MASK;
 
-        *resp_buf_type = CIFS_NO_BUFFER;  /* no response buf yet */
+        *pRespBufType = CIFS_NO_BUFFER;  /* no response buf yet */
 
         if ((ses == NULL) || (ses->server == NULL)) {
-                cifs_small_buf_release(buf);
+                cifs_small_buf_release(in_buf);
                 cERROR(1, "Null session");
                 return -EIO;
         }
 
         if (ses->server->tcpStatus == CifsExiting) {
-                cifs_small_buf_release(buf);
+                cifs_small_buf_release(in_buf);
                 return -ENOENT;
         }
 
-        /*
-         * Ensure that we do not send more than 50 overlapping requests
-         * to the same server. We may make this configurable later or
-         * use ses->maxReq.
-         */
+        /* Ensure that we do not send more than 50 overlapping requests
+           to the same server. We may make this configurable later or
+           use ses->maxReq */
 
-        rc = wait_for_free_request(ses->server, timeout, optype);
+        rc = wait_for_free_request(ses->server, long_op);
         if (rc) {
-                cifs_small_buf_release(buf);
+                cifs_small_buf_release(in_buf);
                 return rc;
         }
 
-        /*
-         * Make sure that we sign in the same order that we send on this socket
-         * and avoid races inside tcp sendmsg code that could cause corruption
-         * of smb data.
-         */
+        /* make sure that we sign in the same order that we send on this socket
+           and avoid races inside tcp sendmsg code that could cause corruption
+           of smb data */
 
         mutex_lock(&ses->server->srv_mutex);
 
-        midQ = ses->server->ops->setup_request(ses, &rqst);
-        if (IS_ERR(midQ)) {
+        rc = allocate_mid(ses, in_buf, &midQ);
+        if (rc) {
                 mutex_unlock(&ses->server->srv_mutex);
-                cifs_small_buf_release(buf);
+                cifs_small_buf_release(in_buf);
                 /* Update # of requests on wire to server */
-                add_credits(ses->server, 1, optype);
-                return PTR_ERR(midQ);
+                atomic_dec(&ses->server->inFlight);
+                wake_up(&ses->server->request_q);
+                return rc;
+        }
+        rc = cifs_sign_smb2(iov, n_vec, ses->server, &midQ->sequence_number);
+        if (rc) {
+                mutex_unlock(&ses->server->srv_mutex);
+                cifs_small_buf_release(in_buf);
+                goto out;
         }
 
-        midQ->mid_state = MID_REQUEST_SUBMITTED;
+        midQ->midState = MID_REQUEST_SUBMITTED;
         cifs_in_send_inc(ses->server);
         rc = smb_sendv(ses->server, iov, n_vec);
         cifs_in_send_dec(ses->server);
@@ -719,62 +577,61 @@ SendReceive2(const unsigned int xid, struct cifs_ses *ses,
         mutex_unlock(&ses->server->srv_mutex);
 
         if (rc < 0) {
-                cifs_small_buf_release(buf);
+                cifs_small_buf_release(in_buf);
                 goto out;
         }
 
-        if (timeout == CIFS_ASYNC_OP) {
-                cifs_small_buf_release(buf);
+        if (long_op == CIFS_ASYNC_OP) {
+                cifs_small_buf_release(in_buf);
                 goto out;
         }
 
         rc = wait_for_response(ses->server, midQ);
         if (rc != 0) {
-                send_cancel(ses->server, buf, midQ);
+                send_nt_cancel(ses->server, in_buf, midQ);
                 spin_lock(&GlobalMid_Lock);
-                if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
+                if (midQ->midState == MID_REQUEST_SUBMITTED) {
                         midQ->callback = DeleteMidQEntry;
                         spin_unlock(&GlobalMid_Lock);
-                        cifs_small_buf_release(buf);
-                        add_credits(ses->server, 1, optype);
+                        cifs_small_buf_release(in_buf);
+                        atomic_dec(&ses->server->inFlight);
+                        wake_up(&ses->server->request_q);
                         return rc;
                 }
                 spin_unlock(&GlobalMid_Lock);
         }
 
-        cifs_small_buf_release(buf);
+        cifs_small_buf_release(in_buf);
 
         rc = cifs_sync_mid_result(midQ, ses->server);
         if (rc != 0) {
-                add_credits(ses->server, 1, optype);
+                atomic_dec(&ses->server->inFlight);
+                wake_up(&ses->server->request_q);
                 return rc;
         }
 
-        if (!midQ->resp_buf || midQ->mid_state != MID_RESPONSE_RECEIVED) {
+        if (!midQ->resp_buf || midQ->midState != MID_RESPONSE_RECEIVED) {
                 rc = -EIO;
                 cFYI(1, "Bad MID state?");
                 goto out;
         }
 
-        buf = (char *)midQ->resp_buf;
-        iov[0].iov_base = buf;
-        iov[0].iov_len = get_rfc1002_length(buf) + 4;
-        if (midQ->large_buf)
-                *resp_buf_type = CIFS_LARGE_BUFFER;
+        iov[0].iov_base = (char *)midQ->resp_buf;
+        iov[0].iov_len = be32_to_cpu(midQ->resp_buf->smb_buf_length) + 4;
+        if (midQ->largeBuf)
+                *pRespBufType = CIFS_LARGE_BUFFER;
         else
-                *resp_buf_type = CIFS_SMALL_BUFFER;
-
-        credits = ses->server->ops->get_credits(midQ);
+                *pRespBufType = CIFS_SMALL_BUFFER;
 
-        rc = ses->server->ops->check_receive(midQ, ses->server,
-                                             flags & CIFS_LOG_ERROR);
+        rc = cifs_check_receive(midQ, ses->server, flags & CIFS_LOG_ERROR);
 
-        /* mark it so buf will not be freed by cifs_delete_mid */
+        /* mark it so buf will not be freed by delete_mid */
         if ((flags & CIFS_NO_RESP) == 0)
                 midQ->resp_buf = NULL;
 out:
-        cifs_delete_mid(midQ);
-        add_credits(ses->server, credits, optype);
+        delete_mid(midQ);
+        atomic_dec(&ses->server->inFlight);
+        wake_up(&ses->server->request_q);
 
         return rc;
 }
@@ -782,7 +639,7 @@ out:
 int
 SendReceive(const unsigned int xid, struct cifs_ses *ses,
             struct smb_hdr *in_buf, struct smb_hdr *out_buf,
-            int *pbytes_returned, const int timeout)
+            int *pbytes_returned, const int long_op)
 {
         int rc = 0;
         struct mid_q_entry *midQ;
@@ -810,7 +667,7 @@ SendReceive(const unsigned int xid, struct cifs_ses *ses,
                 return -EIO;
         }
 
-        rc = wait_for_free_request(ses->server, timeout, 0);
+        rc = wait_for_free_request(ses->server, long_op);
         if (rc)
                 return rc;
 
@@ -824,7 +681,8 @@ SendReceive(const unsigned int xid, struct cifs_ses *ses,
         if (rc) {
                 mutex_unlock(&ses->server->srv_mutex);
                 /* Update # of requests on wire to server */
-                add_credits(ses->server, 1, 0);
+                atomic_dec(&ses->server->inFlight);
+                wake_up(&ses->server->request_q);
                 return rc;
         }
 
@@ -834,7 +692,7 @@ SendReceive(const unsigned int xid, struct cifs_ses *ses,
                 goto out;
         }
 
-        midQ->mid_state = MID_REQUEST_SUBMITTED;
+        midQ->midState = MID_REQUEST_SUBMITTED;
 
         cifs_in_send_inc(ses->server);
         rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
@@ -845,18 +703,19 @@ SendReceive(const unsigned int xid, struct cifs_ses *ses,
         if (rc < 0)
                 goto out;
 
-        if (timeout == CIFS_ASYNC_OP)
+        if (long_op == CIFS_ASYNC_OP)
                 goto out;
 
         rc = wait_for_response(ses->server, midQ);
         if (rc != 0) {
-                send_cancel(ses->server, in_buf, midQ);
+                send_nt_cancel(ses->server, in_buf, midQ);
                 spin_lock(&GlobalMid_Lock);
-                if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
+                if (midQ->midState == MID_REQUEST_SUBMITTED) {
                         /* no longer considered to be "in-flight" */
                         midQ->callback = DeleteMidQEntry;
                         spin_unlock(&GlobalMid_Lock);
-                        add_credits(ses->server, 1, 0);
+                        atomic_dec(&ses->server->inFlight);
+                        wake_up(&ses->server->request_q);
                         return rc;
                 }
                 spin_unlock(&GlobalMid_Lock);
@@ -864,23 +723,25 @@ SendReceive(const unsigned int xid, struct cifs_ses *ses,
 
         rc = cifs_sync_mid_result(midQ, ses->server);
         if (rc != 0) {
-                add_credits(ses->server, 1, 0);
+                atomic_dec(&ses->server->inFlight);
+                wake_up(&ses->server->request_q);
                 return rc;
         }
 
         if (!midQ->resp_buf || !out_buf ||
-            midQ->mid_state != MID_RESPONSE_RECEIVED) {
+            midQ->midState != MID_RESPONSE_RECEIVED) {
                 rc = -EIO;
                 cERROR(1, "Bad MID state?");
                 goto out;
         }
 
-        *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
+        *pbytes_returned = be32_to_cpu(midQ->resp_buf->smb_buf_length);
         memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
         rc = cifs_check_receive(midQ, ses->server, 0);
 out:
-        cifs_delete_mid(midQ);
-        add_credits(ses->server, 1, 0);
+        delete_mid(midQ);
+        atomic_dec(&ses->server->inFlight);
+        wake_up(&ses->server->request_q);
 
         return rc;
 }
@@ -904,7 +765,7 @@ send_lock_cancel(const unsigned int xid, struct cifs_tcon *tcon,
 
         pSMB->LockType = LOCKING_ANDX_CANCEL_LOCK|LOCKING_ANDX_LARGE_FILES;
         pSMB->Timeout = 0;
-        pSMB->hdr.Mid = get_next_mid(ses->server);
+        pSMB->hdr.Mid = GetNextMid(ses->server);
 
         return SendReceive(xid, ses, in_buf, out_buf,
                         &bytes_returned, 0);
@@ -945,7 +806,7 @@ SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
                 return -EIO;
         }
 
-        rc = wait_for_free_request(ses->server, CIFS_BLOCKING_OP, 0);
+        rc = wait_for_free_request(ses->server, CIFS_BLOCKING_OP);
         if (rc)
                 return rc;
 
@@ -963,12 +824,12 @@ SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
 
         rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
         if (rc) {
-                cifs_delete_mid(midQ);
+                delete_mid(midQ);
                 mutex_unlock(&ses->server->srv_mutex);
                 return rc;
         }
 
-        midQ->mid_state = MID_REQUEST_SUBMITTED;
+        midQ->midState = MID_REQUEST_SUBMITTED;
         cifs_in_send_inc(ses->server);
         rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
         cifs_in_send_dec(ses->server);
@@ -976,28 +837,28 @@ SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
         mutex_unlock(&ses->server->srv_mutex);
 
         if (rc < 0) {
-                cifs_delete_mid(midQ);
+                delete_mid(midQ);
                 return rc;
         }
 
         /* Wait for a reply - allow signals to interrupt. */
         rc = wait_event_interruptible(ses->server->response_q,
-                (!(midQ->mid_state == MID_REQUEST_SUBMITTED)) ||
+                (!(midQ->midState == MID_REQUEST_SUBMITTED)) ||
                 ((ses->server->tcpStatus != CifsGood) &&
                  (ses->server->tcpStatus != CifsNew)));
 
         /* Were we interrupted by a signal ? */
         if ((rc == -ERESTARTSYS) &&
-                (midQ->mid_state == MID_REQUEST_SUBMITTED) &&
+                (midQ->midState == MID_REQUEST_SUBMITTED) &&
                 ((ses->server->tcpStatus == CifsGood) ||
                  (ses->server->tcpStatus == CifsNew))) {
 
                 if (in_buf->Command == SMB_COM_TRANSACTION2) {
                         /* POSIX lock. We send a NT_CANCEL SMB to cause the
                            blocking lock to return. */
-                        rc = send_cancel(ses->server, in_buf, midQ);
+                        rc = send_nt_cancel(ses->server, in_buf, midQ);
                         if (rc) {
-                                cifs_delete_mid(midQ);
+                                delete_mid(midQ);
                                 return rc;
                         }
                 } else {
@@ -1009,16 +870,16 @@ SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
                         /* If we get -ENOLCK back the lock may have
                            already been removed. Don't exit in this case. */
                         if (rc && rc != -ENOLCK) {
-                                cifs_delete_mid(midQ);
+                                delete_mid(midQ);
                                 return rc;
                         }
                 }
 
                 rc = wait_for_response(ses->server, midQ);
                 if (rc) {
-                        send_cancel(ses->server, in_buf, midQ);
+                        send_nt_cancel(ses->server, in_buf, midQ);
                         spin_lock(&GlobalMid_Lock);
-                        if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
+                        if (midQ->midState == MID_REQUEST_SUBMITTED) {
                                 /* no longer considered to be "in-flight" */
                                 midQ->callback = DeleteMidQEntry;
                                 spin_unlock(&GlobalMid_Lock);
@@ -1036,17 +897,17 @@ SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
                 return rc;
 
         /* rcvd frame is ok */
-        if (out_buf == NULL || midQ->mid_state != MID_RESPONSE_RECEIVED) {
+        if (out_buf == NULL || midQ->midState != MID_RESPONSE_RECEIVED) {
                 rc = -EIO;
                 cERROR(1, "Bad MID state?");
                 goto out;
         }
 
-        *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
+        *pbytes_returned = be32_to_cpu(midQ->resp_buf->smb_buf_length);
         memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
         rc = cifs_check_receive(midQ, ses->server, 0);
 out:
-        cifs_delete_mid(midQ);
+        delete_mid(midQ);
         if (rstart && rc == -EACCES)
                 return -ERESTARTSYS;
         return rc;
diff --git a/fs/cifs/xattr.c b/fs/cifs/xattr.c
index 5142f2c6027..2a22fb2989e 100644
--- a/fs/cifs/xattr.c
+++ b/fs/cifs/xattr.c
@@ -22,7 +22,6 @@
 #include <linux/fs.h>
 #include <linux/posix_acl_xattr.h>
 #include <linux/slab.h>
-#include <linux/xattr.h>
 #include "cifsfs.h"
 #include "cifspdu.h"
 #include "cifsglob.h"
@@ -32,14 +31,22 @@
 #define MAX_EA_VALUE_SIZE 65535
 #define CIFS_XATTR_DOS_ATTRIB "user.DosAttrib"
 #define CIFS_XATTR_CIFS_ACL "system.cifs_acl"
-
+#define CIFS_XATTR_USER_PREFIX "user."
+#define CIFS_XATTR_SYSTEM_PREFIX "system."
+#define CIFS_XATTR_OS2_PREFIX "os2."
+#define CIFS_XATTR_SECURITY_PREFIX "security."
+#define CIFS_XATTR_TRUSTED_PREFIX "trusted."
+#define XATTR_TRUSTED_PREFIX_LEN  8
+#define XATTR_SECURITY_PREFIX_LEN 9
 /* BB need to add server (Samba e.g) support for security and trusted prefix */
 
+
+
 int cifs_removexattr(struct dentry *direntry, const char *ea_name)
 {
         int rc = -EOPNOTSUPP;
 #ifdef CONFIG_CIFS_XATTR
-        unsigned int xid;
+        int xid;
         struct cifs_sb_info *cifs_sb;
         struct tcon_link *tlink;
         struct cifs_tcon *pTcon;
@@ -60,7 +67,7 @@ int cifs_removexattr(struct dentry *direntry, const char *ea_name)
                 return PTR_ERR(tlink);
         pTcon = tlink_tcon(tlink);
 
-        xid = get_xid();
+        xid = GetXid();
 
         full_path = build_path_from_dentry(direntry);
         if (full_path == NULL) {
@@ -69,8 +76,8 @@ int cifs_removexattr(struct dentry *direntry, const char *ea_name)
         }
         if (ea_name == NULL) {
                 cFYI(1, "Null xattr names not supported");
-        } else if (strncmp(ea_name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)
-                && (strncmp(ea_name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN))) {
+        } else if (strncmp(ea_name, CIFS_XATTR_USER_PREFIX, 5)
+                && (strncmp(ea_name, CIFS_XATTR_OS2_PREFIX, 4))) {
                 cFYI(1,
                      "illegal xattr request %s (only user namespace supported)",
                      ea_name);
@@ -81,14 +88,14 @@ int cifs_removexattr(struct dentry *direntry, const char *ea_name)
                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
                         goto remove_ea_exit;
 
-                ea_name += XATTR_USER_PREFIX_LEN; /* skip past user. prefix */
+                ea_name += 5; /* skip past user. prefix */
                 rc = CIFSSMBSetEA(xid, pTcon, full_path, ea_name, NULL,
                         (__u16)0, cifs_sb->local_nls,
                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
         }
 remove_ea_exit:
         kfree(full_path);
-        free_xid(xid);
+        FreeXid(xid);
         cifs_put_tlink(tlink);
 #endif
         return rc;
@@ -99,12 +106,13 @@ int cifs_setxattr(struct dentry *direntry, const char *ea_name,
 {
         int rc = -EOPNOTSUPP;
 #ifdef CONFIG_CIFS_XATTR
-        unsigned int xid;
+        int xid;
         struct cifs_sb_info *cifs_sb;
         struct tcon_link *tlink;
         struct cifs_tcon *pTcon;
         struct super_block *sb;
         char *full_path;
+        struct cifs_ntsd *pacl;
 
         if (direntry == NULL)
                 return -EIO;
@@ -120,7 +128,7 @@ int cifs_setxattr(struct dentry *direntry, const char *ea_name,
                 return PTR_ERR(tlink);
         pTcon = tlink_tcon(tlink);
 
-        xid = get_xid();
+        xid = GetXid();
 
         full_path = build_path_from_dentry(direntry);
         if (full_path == NULL) {
@@ -141,46 +149,43 @@ int cifs_setxattr(struct dentry *direntry, const char *ea_name,
 
         if (ea_name == NULL) {
                 cFYI(1, "Null xattr names not supported");
-        } else if (strncmp(ea_name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)
-                   == 0) {
+        } else if (strncmp(ea_name, CIFS_XATTR_USER_PREFIX, 5) == 0) {
                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
                         goto set_ea_exit;
                 if (strncmp(ea_name, CIFS_XATTR_DOS_ATTRIB, 14) == 0)
                         cFYI(1, "attempt to set cifs inode metadata");
 
-                ea_name += XATTR_USER_PREFIX_LEN; /* skip past user. prefix */
+                ea_name += 5; /* skip past user. prefix */
                 rc = CIFSSMBSetEA(xid, pTcon, full_path, ea_name, ea_value,
                         (__u16)value_size, cifs_sb->local_nls,
                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
-        } else if (strncmp(ea_name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN)
-                   == 0) {
+        } else if (strncmp(ea_name, CIFS_XATTR_OS2_PREFIX, 4) == 0) {
                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
                         goto set_ea_exit;
 
-                ea_name += XATTR_OS2_PREFIX_LEN; /* skip past os2. prefix */
+                ea_name += 4; /* skip past os2. prefix */
                 rc = CIFSSMBSetEA(xid, pTcon, full_path, ea_name, ea_value,
                         (__u16)value_size, cifs_sb->local_nls,
                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
         } else if (strncmp(ea_name, CIFS_XATTR_CIFS_ACL,
                         strlen(CIFS_XATTR_CIFS_ACL)) == 0) {
-#ifdef CONFIG_CIFS_ACL
-                struct cifs_ntsd *pacl;
                 pacl = kmalloc(value_size, GFP_KERNEL);
                 if (!pacl) {
                         cFYI(1, "%s: Can't allocate memory for ACL",
                                         __func__);
                         rc = -ENOMEM;
                 } else {
+#ifdef CONFIG_CIFS_ACL
                         memcpy(pacl, ea_value, value_size);
                         rc = set_cifs_acl(pacl, value_size,
-                                direntry->d_inode, full_path, CIFS_ACL_DACL);
+                                direntry->d_inode, full_path);
                         if (rc == 0) /* force revalidate of the inode */
                                 CIFS_I(direntry->d_inode)->time = 0;
                         kfree(pacl);
-                }
 #else
                         cFYI(1, "Set CIFS ACL not supported yet");
 #endif /* CONFIG_CIFS_ACL */
+                }
         } else {
                 int temp;
                 temp = strncmp(ea_name, POSIX_ACL_XATTR_ACCESS,
@@ -221,7 +226,7 @@ int cifs_setxattr(struct dentry *direntry, const char *ea_name,
 
 set_ea_exit:
         kfree(full_path);
-        free_xid(xid);
+        FreeXid(xid);
         cifs_put_tlink(tlink);
 #endif
         return rc;
@@ -232,7 +237,7 @@ ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,
 {
         ssize_t rc = -EOPNOTSUPP;
 #ifdef CONFIG_CIFS_XATTR
-        unsigned int xid;
+        int xid;
         struct cifs_sb_info *cifs_sb;
         struct tcon_link *tlink;
         struct cifs_tcon *pTcon;
@@ -253,7 +258,7 @@ ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,
                 return PTR_ERR(tlink);
         pTcon = tlink_tcon(tlink);
 
-        xid = get_xid();
+        xid = GetXid();
 
         full_path = build_path_from_dentry(direntry);
         if (full_path == NULL) {
@@ -264,8 +269,7 @@ ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,
         /* return alt name if available as pseudo attr */
         if (ea_name == NULL) {
                 cFYI(1, "Null xattr names not supported");
-        } else if (strncmp(ea_name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)
-                   == 0) {
+        } else if (strncmp(ea_name, CIFS_XATTR_USER_PREFIX, 5) == 0) {
                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
                         goto get_ea_exit;
 
@@ -273,15 +277,15 @@ ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,
                         cFYI(1, "attempt to query cifs inode metadata");
                         /* revalidate/getattr then populate from inode */
                 } /* BB add else when above is implemented */
-                ea_name += XATTR_USER_PREFIX_LEN; /* skip past user. prefix */
+                ea_name += 5; /* skip past user. prefix */
                 rc = CIFSSMBQAllEAs(xid, pTcon, full_path, ea_name, ea_value,
                         buf_size, cifs_sb->local_nls,
                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
-        } else if (strncmp(ea_name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN) == 0) {
+        } else if (strncmp(ea_name, CIFS_XATTR_OS2_PREFIX, 4) == 0) {
                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
                         goto get_ea_exit;
 
-                ea_name += XATTR_OS2_PREFIX_LEN; /* skip past os2. prefix */
+                ea_name += 4; /* skip past os2. prefix */
                 rc = CIFSSMBQAllEAs(xid, pTcon, full_path, ea_name, ea_value,
                         buf_size, cifs_sb->local_nls,
                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
@@ -335,10 +339,10 @@ ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,
                 cFYI(1, "Query CIFS ACL not supported yet");
 #endif /* CONFIG_CIFS_ACL */
         } else if (strncmp(ea_name,
-                  XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) == 0) {
+                  CIFS_XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) == 0) {
                 cFYI(1, "Trusted xattr namespace not supported yet");
         } else if (strncmp(ea_name,
-                  XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) == 0) {
+                  CIFS_XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) == 0) {
                 cFYI(1, "Security xattr namespace not supported yet");
         } else
                 cFYI(1,
@@ -355,7 +359,7 @@ ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,
 
 get_ea_exit:
         kfree(full_path);
-        free_xid(xid);
+        FreeXid(xid);
         cifs_put_tlink(tlink);
 #endif
         return rc;
@@ -365,7 +369,7 @@ ssize_t cifs_listxattr(struct dentry *direntry, char *data, size_t buf_size)
 {
         ssize_t rc = -EOPNOTSUPP;
 #ifdef CONFIG_CIFS_XATTR
-        unsigned int xid;
+        int xid;
         struct cifs_sb_info *cifs_sb;
         struct tcon_link *tlink;
         struct cifs_tcon *pTcon;
@@ -389,7 +393,7 @@ ssize_t cifs_listxattr(struct dentry *direntry, char *data, size_t buf_size)
                 return PTR_ERR(tlink);
         pTcon = tlink_tcon(tlink);
 
-        xid = get_xid();
+        xid = GetXid();
 
         full_path = build_path_from_dentry(direntry);
         if (full_path == NULL) {
@@ -409,7 +413,7 @@ ssize_t cifs_listxattr(struct dentry *direntry, char *data, size_t buf_size)
 
 list_ea_exit:
         kfree(full_path);
-        free_xid(xid);
+        FreeXid(xid);
         cifs_put_tlink(tlink);
 #endif
         return rc;