Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6

Conflicts: drivers/net/wireless/iwlwifi/iwl-4965-rs.c drivers/net/wireless/rt2x00/rt61pci.c
author: David S. Miller <davem@davemloft.net> 2008-05-15 03:34:44 -0400
committer: David S. Miller <davem@davemloft.net> 2008-05-15 03:34:44 -0400
commit: 63fe46da9c380b3f2bbdf3765044649517cc717c (patch)
tree: 9478c1aca1d692b408955aea20c9cd9a37e589c0 /fs/cifs
parent: 99dd1a2b8347ac2ae802300b7862f6f7bcf17139 (diff)
parent: 066b2118976e6e7cc50eed39e2747c75343a23c4 (diff)
22 files changed, 421 insertions, 411 deletions
diff --git a/fs/cifs/CHANGES b/fs/cifs/CHANGES
index 05c9da6181c3..8355e918fddf 100644
--- a/fs/cifs/CHANGES
+++ b/fs/cifs/CHANGES
@@ -1,3 +1,6 @@
+Version 1.53
+------------
 Version 1.52
 ------------
 Fix oops on second mount to server when null auth is used.
diff --git a/fs/cifs/asn1.c b/fs/cifs/asn1.c
index bcda2c6b6a04..cb52cbbe45ff 100644
--- a/fs/cifs/asn1.c
+++ b/fs/cifs/asn1.c
@@ -460,8 +460,8 @@ decode_negTokenInit(unsigned char *security_blob, int length,
        unsigned char *sequence_end;
        unsigned long *oid = NULL;
        unsigned int cls, con, tag, oidlen, rc;
-        int use_ntlmssp = FALSE;
+        bool use_ntlmssp = false;
-        int use_kerberos = FALSE;
+        bool use_kerberos = false;
        *secType = NTLM; /* BB eventually make Kerberos or NLTMSSP the default*/
@@ -561,15 +561,15 @@ decode_negTokenInit(unsigned char *security_blob, int length,
                                        if (compare_oid(oid, oidlen,
                                                        MSKRB5_OID,
                                                        MSKRB5_OID_LEN))
-                                                use_kerberos = TRUE;
+                                                use_kerberos = true;
                                        else if (compare_oid(oid, oidlen,
                                                             KRB5_OID,
                                                             KRB5_OID_LEN))
-                                                use_kerberos = TRUE;
+                                                use_kerberos = true;
                                        else if (compare_oid(oid, oidlen,
                                                             NTLMSSP_OID,
                                                             NTLMSSP_OID_LEN))
-                                                use_ntlmssp = TRUE;
+                                                use_ntlmssp = true;
                                        kfree(oid);
                                }
diff --git a/fs/cifs/cifs_dfs_ref.c b/fs/cifs/cifs_dfs_ref.c
index 95024c066d89..f6fdecf6598c 100644
--- a/fs/cifs/cifs_dfs_ref.c
+++ b/fs/cifs/cifs_dfs_ref.c
@@ -93,15 +93,11 @@ static char *cifs_get_share_name(const char *node_name)
        /* find sharename end */
        pSep++;
        pSep = memchr(UNC+(pSep-UNC), '\\', len-(pSep-UNC));
-        if (!pSep) {
+        if (pSep) {
-                cERROR(1, ("%s:2 cant find share name in node name: %s",
+                /* trim path up to sharename end
-                        __func__, node_name));
+                 * now we have share name in UNC */
-                kfree(UNC);
+                *pSep = 0;
-                return NULL;
        }
-        /* trim path up to sharename end
-         *          * now we have share name in UNC */
-        *pSep = 0;
        return UNC;
 }
@@ -188,7 +184,7 @@ static char *compose_mount_options(const char *sb_mountdata,
                tkn_e = strchr(tkn_e+1, '\\');
                if (tkn_e) {
                        strcat(mountdata, ",prefixpath=");
-                        strcat(mountdata, tkn_e);
+                        strcat(mountdata, tkn_e+1);
                }
        }
@@ -244,7 +240,8 @@ static char *build_full_dfs_path_from_dentry(struct dentry *dentry)
                return NULL;
        if (cifs_sb->tcon->Flags & SMB_SHARE_IS_IN_DFS) {
-                /* we should use full path name to correct working with DFS */
+                int i;
+                /* we should use full path name for correct working with DFS */
                l_max_len = strnlen(cifs_sb->tcon->treeName, MAX_TREE_SIZE+1) +
                                        strnlen(search_path, MAX_PATHCONF) + 1;
                tmp_path = kmalloc(l_max_len, GFP_KERNEL);
@@ -253,8 +250,14 @@ static char *build_full_dfs_path_from_dentry(struct dentry *dentry)
                        return NULL;
                }
                strncpy(tmp_path, cifs_sb->tcon->treeName, l_max_len);
-                strcat(tmp_path, search_path);
                tmp_path[l_max_len-1] = 0;
+                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
+                        for (i = 0; i < l_max_len; i++) {
+                                if (tmp_path[i] == '\\')
+                                        tmp_path[i] = '/';
+                        }
+                strncat(tmp_path, search_path, l_max_len - strlen(tmp_path));
                full_path = tmp_path;
                kfree(search_path);
        } else {
diff --git a/fs/cifs/cifsacl.c b/fs/cifs/cifsacl.c
index e99d4faf5f02..34902cff5400 100644
--- a/fs/cifs/cifsacl.c
+++ b/fs/cifs/cifsacl.c
@@ -559,7 +559,7 @@ static struct cifs_ntsd *get_cifs_acl(u32 *pacllen, struct inode *inode,
                                       const char *path, const __u16 *pfid)
 {
        struct cifsFileInfo *open_file = NULL;
-        int unlock_file = FALSE;
+        bool unlock_file = false;
        int xid;
        int rc = -EIO;
        __u16 fid;
@@ -586,10 +586,10 @@ static struct cifs_ntsd *get_cifs_acl(u32 *pacllen, struct inode *inode,
        cifs_sb = CIFS_SB(sb);
        if (open_file) {
-                unlock_file = TRUE;
+                unlock_file = true;
                fid = open_file->netfid;
        } else if (pfid == NULL) {
-                int oplock = FALSE;
+                int oplock = 0;
                /* open file */
                rc = CIFSSMBOpen(xid, cifs_sb->tcon, path, FILE_OPEN,
                                READ_CONTROL, 0, &fid, &oplock, NULL,
@@ -604,7 +604,7 @@ static struct cifs_ntsd *get_cifs_acl(u32 *pacllen, struct inode *inode,
        rc = CIFSSMBGetCIFSACL(xid, cifs_sb->tcon, fid, &pntsd, pacllen);
        cFYI(1, ("GetCIFSACL rc = %d ACL len %d", rc, *pacllen));
-        if (unlock_file == TRUE) /* find_readable_file increments ref count */
+        if (unlock_file == true) /* find_readable_file increments ref count */
                atomic_dec(&open_file->wrtPending);
        else if (pfid == NULL) /* if opened above we have to close the handle */
                CIFSSMBClose(xid, cifs_sb->tcon, fid);
@@ -619,7 +619,7 @@ static int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
                                struct inode *inode, const char *path)
 {
        struct cifsFileInfo *open_file;
-        int unlock_file = FALSE;
+        bool unlock_file = false;
        int xid;
        int rc = -EIO;
        __u16 fid;
@@ -640,10 +640,10 @@ static int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
        open_file = find_readable_file(CIFS_I(inode));
        if (open_file) {
-                unlock_file = TRUE;
+                unlock_file = true;
                fid = open_file->netfid;
        } else {
-                int oplock = FALSE;
+                int oplock = 0;
                /* open file */
                rc = CIFSSMBOpen(xid, cifs_sb->tcon, path, FILE_OPEN,
                                WRITE_DAC, 0, &fid, &oplock, NULL,
@@ -658,7 +658,7 @@ static int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
        rc = CIFSSMBSetCIFSACL(xid, cifs_sb->tcon, fid, pnntsd, acllen);
        cFYI(DBG2, ("SetCIFSACL rc = %d", rc));
-        if (unlock_file == TRUE)
+        if (unlock_file)
                atomic_dec(&open_file->wrtPending);
        else
                CIFSSMBClose(xid, cifs_sb->tcon, fid);
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 39c2cbdface7..427a7c695896 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -222,50 +222,50 @@ static int
 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
        struct super_block *sb = dentry->d_sb;
-        int xid;
+        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
+        struct cifsTconInfo *tcon = cifs_sb->tcon;
        int rc = -EOPNOTSUPP;
-        struct cifs_sb_info *cifs_sb;
+        int xid;
-        struct cifsTconInfo *pTcon;
        xid = GetXid();
-        cifs_sb = CIFS_SB(sb);
-        pTcon = cifs_sb->tcon;
        buf->f_type = CIFS_MAGIC_NUMBER;
-        /* instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO */
+        /*
-        buf->f_namelen = PATH_MAX; /* PATH_MAX may be too long - it would
+         * PATH_MAX may be too long - it would presumably be total path,
-                                      presumably be total path, but note
+         * but note that some servers (includinng Samba 3) have a shorter
-                                      that some servers (includinng Samba 3)
+         * maximum path.
-                                      have a shorter maximum path */
+         *
+         * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
+         */
+        buf->f_namelen = PATH_MAX;
        buf->f_files = 0;       /* undefined */
        buf->f_ffree = 0;       /* unlimited */
-/* BB we could add a second check for a QFS Unix capability bit */
+        /*
-/* BB FIXME check CIFS_POSIX_EXTENSIONS Unix cap first FIXME BB */
+         * We could add a second check for a QFS Unix capability bit
-    if ((pTcon->ses->capabilities & CAP_UNIX) && (CIFS_POSIX_EXTENSIONS &
+         */
-                        le64_to_cpu(pTcon->fsUnixInfo.Capability)))
+        if ((tcon->ses->capabilities & CAP_UNIX) &&
-            rc = CIFSSMBQFSPosixInfo(xid, pTcon, buf);
+            (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 */
+        /*
-    if (rc)
+         * Only need to call the old QFSInfo if failed on newer one,
-        if (pTcon->ses->capabilities & CAP_NT_SMBS)
+         * e.g. by OS/2.
-                rc = CIFSSMBQFSInfo(xid, pTcon, buf); /* not supported by OS2 */
+         **/
+        if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
-        /* Some old Windows servers also do not support level 103, retry with
+                rc = CIFSSMBQFSInfo(xid, tcon, buf);
-           older level one if old server failed the previous call or we
-           bypassed it because we detected that this was an older LANMAN sess */
+        /*
+         * 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, pTcon, buf);
+                rc = SMBOldQFSInfo(xid, tcon, buf);
-        /* int f_type;
-           __fsid_t f_fsid;
-           int f_namelen;  */
-        /* BB get from info in tcon struct at mount time call to QFSAttrInfo */
        FreeXid(xid);
-        return 0;               /* always return success? what if volume is no
+        return 0;
-                                   longer available? */
 }
 static int cifs_permission(struct inode *inode, int mask, struct nameidata *nd)
@@ -306,8 +306,8 @@ cifs_alloc_inode(struct super_block *sb)
        /* 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_inode->clientCanCacheRead = FALSE;
+        cifs_inode->clientCanCacheRead = false;
-        cifs_inode->clientCanCacheAll = FALSE;
+        cifs_inode->clientCanCacheAll = false;
        cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
        /* Can not set i_flags here - they get immediately overwritten
@@ -940,7 +940,7 @@ static int cifs_oplock_thread(void *dummyarg)
                                    rc = CIFSSMBLock(0, pTcon, netfid,
                                            0 /* len */ , 0 /* offset */, 0,
                                            0, LOCKING_ANDX_OPLOCK_RELEASE,
-                                            0 /* wait flag */);
+                                            false /* wait flag */);
                                        cFYI(1, ("Oplock release rc = %d", rc));
                                }
                        } else
diff --git a/fs/cifs/cifsfs.h b/fs/cifs/cifsfs.h
index e1dd9f32e1d7..cd1301a09b3b 100644
--- a/fs/cifs/cifsfs.h
+++ b/fs/cifs/cifsfs.h
@@ -24,14 +24,6 @@
 #define ROOT_I 2
-#ifndef FALSE
-#define FALSE 0
-#endif
-#ifndef TRUE
-#define TRUE 1
-#endif
 extern struct file_system_type cifs_fs_type;
 extern const struct address_space_operations cifs_addr_ops;
 extern const struct address_space_operations cifs_addr_ops_smallbuf;
@@ -110,5 +102,5 @@ extern int cifs_ioctl(struct inode *inode, struct file *filep,
 extern const struct export_operations cifs_export_ops;
 #endif /* EXPERIMENTAL */
-#define CIFS_VERSION   "1.52"
+#define CIFS_VERSION   "1.53"
 #endif                          /* _CIFSFS_H */
diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
index 69a2e1942542..b7d9f698e63e 100644
--- a/fs/cifs/cifsglob.h
+++ b/fs/cifs/cifsglob.h
@@ -57,14 +57,6 @@
 #include "cifspdu.h"
-#ifndef FALSE
-#define FALSE 0
-#endif
-#ifndef TRUE
-#define TRUE 1
-#endif
 #ifndef XATTR_DOS_ATTRIB
 #define XATTR_DOS_ATTRIB "user.DOSATTRIB"
 #endif
@@ -147,7 +139,7 @@ struct TCP_Server_Info {
        enum protocolEnum protocolType;
        char versionMajor;
        char versionMinor;
-        unsigned svlocal:1;     /* local server or remote */
+        bool svlocal:1;                 /* local server or remote */
        atomic_t socketUseCount; /* number of open cifs sessions on socket */
        atomic_t inFlight;  /* number of requests on the wire to server */
 #ifdef CONFIG_CIFS_STATS2
@@ -286,10 +278,10 @@ struct cifsTconInfo {
        FILE_SYSTEM_DEVICE_INFO fsDevInfo;
        FILE_SYSTEM_ATTRIBUTE_INFO fsAttrInfo; /* ok if fs name truncated */
        FILE_SYSTEM_UNIX_INFO fsUnixInfo;
-        unsigned ipc:1;         /* set if connection to IPC$ eg for RPC/PIPES */
+        bool ipc:1;             /* set if connection to IPC$ eg for RPC/PIPES */
-        unsigned retry:1;
+        bool retry:1;
-        unsigned nocase:1;
+        bool nocase:1;
-        unsigned unix_ext:1; /* if off disable Linux extensions to CIFS protocol
+        bool unix_ext:1;  /* if false disable Linux extensions to CIFS protocol
                                for this mount even if server would support */
        /* BB add field for back pointer to sb struct(s)? */
 };
@@ -317,10 +309,10 @@ struct cifs_search_info {
        char *srch_entries_start;
        char *presume_name;
        unsigned int resume_name_len;
-        unsigned endOfSearch:1;
+        bool endOfSearch:1;
-        unsigned emptyDir:1;
+        bool emptyDir:1;
-        unsigned unicode:1;
+        bool unicode:1;
-        unsigned smallBuf:1; /* so we know which buf_release function to call */
+        bool smallBuf:1; /* so we know which buf_release function to call */
 };
 struct cifsFileInfo {
@@ -335,9 +327,9 @@ struct cifsFileInfo {
        struct inode *pInode; /* needed for oplock break */
        struct mutex lock_mutex;
        struct list_head llist; /* list of byte range locks we have. */
-        unsigned closePend:1;   /* file is marked to close */
+        bool closePend:1;       /* file is marked to close */
-        unsigned invalidHandle:1;  /* file closed via session abend */
+        bool invalidHandle:1;   /* file closed via session abend */
-        unsigned messageMode:1;    /* for pipes: message vs byte mode */
+        bool messageMode:1;     /* for pipes: message vs byte mode */
        atomic_t wrtPending;   /* handle in use - defer close */
        struct semaphore fh_sem; /* prevents reopen race after dead ses*/
        char *search_resume_name; /* BB removeme BB */
@@ -356,9 +348,9 @@ struct cifsInodeInfo {
        __u32 cifsAttrs; /* e.g. DOS archive bit, sparse, compressed, system */
        atomic_t inUse;  /* num concurrent users (local openers cifs) of file*/
        unsigned long time;     /* jiffies of last update/check of inode */
-        unsigned clientCanCacheRead:1; /* read oplock */
+        bool clientCanCacheRead:1;      /* read oplock */
-        unsigned clientCanCacheAll:1;  /* read and writebehind oplock */
+        bool clientCanCacheAll:1;       /* read and writebehind oplock */
-        unsigned oplockPending:1;
+        bool oplockPending:1;
        struct inode vfs_inode;
 };
@@ -426,9 +418,9 @@ struct mid_q_entry {
        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 */
-        unsigned largeBuf:1;    /* if valid response, is pointer to large buf */
+        bool largeBuf:1;        /* if valid response, is pointer to large buf */
-        unsigned multiRsp:1;   /* multiple trans2 responses for one request  */
+        bool multiRsp:1;        /* multiple trans2 responses for one request  */
-        unsigned multiEnd:1; /* both received */
+        bool multiEnd:1;        /* both received */
 };
 struct oplock_q_entry {
diff --git a/fs/cifs/cifspdu.h b/fs/cifs/cifspdu.h
index 9f49c2f3582c..c43bf4b7a556 100644
--- a/fs/cifs/cifspdu.h
+++ b/fs/cifs/cifspdu.h
@@ -340,6 +340,7 @@
 #define OPEN_NO_RECALL          0x00400000
 #define OPEN_FREE_SPACE_QUERY   0x00800000      /* should be zero */
 #define CREATE_OPTIONS_MASK     0x007FFFFF
+#define CREATE_OPTION_READONLY  0x10000000
 #define CREATE_OPTION_SPECIAL   0x20000000   /* system. NB not sent over wire */
 /* ImpersonationLevel flags */
@@ -2050,7 +2051,7 @@ typedef struct {
                                                      to 0xFFFF00 */
 #define CIFS_UNIX_LARGE_WRITE_CAP       0x00000080
 #define CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP 0x00000100 /* can do SPNEGO crypt */
-#define CIFS_UNIX_TRANPSORT_ENCRYPTION_MANDATORY_CAP  0x00000200 /* must do  */
+#define CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP  0x00000200 /* must do  */
 #define CIFS_UNIX_PROXY_CAP             0x00000400 /* Proxy cap: 0xACE ioctl and
                                                      QFS PROXY call */
 #ifdef CONFIG_CIFS_POSIX
diff --git a/fs/cifs/cifsproto.h b/fs/cifs/cifsproto.h
index 50f9fdae19b3..d481f6c5a2be 100644
--- a/fs/cifs/cifsproto.h
+++ b/fs/cifs/cifsproto.h
@@ -59,8 +59,9 @@ extern int SendReceiveBlockingLock(const unsigned int xid,
                        struct smb_hdr *out_buf,
                        int *bytes_returned);
 extern int checkSMB(struct smb_hdr *smb, __u16 mid, unsigned int length);
-extern int is_valid_oplock_break(struct smb_hdr *smb, struct TCP_Server_Info *);
+extern bool is_valid_oplock_break(struct smb_hdr *smb,
-extern int is_size_safe_to_change(struct cifsInodeInfo *, __u64 eof);
+                                  struct TCP_Server_Info *);
+extern bool is_size_safe_to_change(struct cifsInodeInfo *, __u64 eof);
 extern struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *);
 #ifdef CONFIG_CIFS_EXPERIMENTAL
 extern struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *);
@@ -69,7 +70,7 @@ extern unsigned int smbCalcSize(struct smb_hdr *ptr);
 extern unsigned int smbCalcSize_LE(struct smb_hdr *ptr);
 extern int decode_negTokenInit(unsigned char *security_blob, int length,
                        enum securityEnum *secType);
-extern int cifs_inet_pton(int, char *source, void *dst);
+extern int cifs_inet_pton(const int, const char *source, void *dst);
 extern int map_smb_to_linux_error(struct smb_hdr *smb, int logErr);
 extern void header_assemble(struct smb_hdr *, char /* command */ ,
                            const struct cifsTconInfo *, int /* length of
@@ -187,12 +188,12 @@ extern int CIFSSMBSetAttrLegacy(int xid, struct cifsTconInfo *tcon,
 #endif /* possibly unneeded function */
 extern int CIFSSMBSetEOF(const int xid, struct cifsTconInfo *tcon,
                        const char *fileName, __u64 size,
-                        int setAllocationSizeFlag,
+                        bool setAllocationSizeFlag,
                        const struct nls_table *nls_codepage,
                        int remap_special_chars);
 extern int CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon,
                         __u64 size, __u16 fileHandle, __u32 opener_pid,
-                        int AllocSizeFlag);
+                        bool AllocSizeFlag);
 extern int CIFSSMBUnixSetPerms(const int xid, struct cifsTconInfo *pTcon,
                        char *full_path, __u64 mode, __u64 uid,
                        __u64 gid, dev_t dev,
@@ -291,11 +292,11 @@ extern int CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
                        const __u16 netfid, const __u64 len,
                        const __u64 offset, const __u32 numUnlock,
                        const __u32 numLock, const __u8 lockType,
-                        const int waitFlag);
+                        const bool waitFlag);
 extern int CIFSSMBPosixLock(const int xid, struct cifsTconInfo *tcon,
                        const __u16 smb_file_id, const int get_flag,
                        const __u64 len, struct file_lock *,
-                        const __u16 lock_type, const int waitFlag);
+                        const __u16 lock_type, const bool waitFlag);
 extern int CIFSSMBTDis(const int xid, struct cifsTconInfo *tcon);
 extern int CIFSSMBLogoff(const int xid, struct cifsSesInfo *ses);
diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c
index 4728fa982a4e..95fbba4ea7d4 100644
--- a/fs/cifs/cifssmb.c
+++ b/fs/cifs/cifssmb.c
@@ -95,7 +95,7 @@ static void mark_open_files_invalid(struct cifsTconInfo *pTcon)
        list_for_each_safe(tmp, tmp1, &pTcon->openFileList) {
                open_file = list_entry(tmp, struct cifsFileInfo, tlist);
                if (open_file)
-                        open_file->invalidHandle = TRUE;
+                        open_file->invalidHandle = true;
        }
        write_unlock(&GlobalSMBSeslock);
        /* BB Add call to invalidate_inodes(sb) for all superblocks mounted
@@ -141,7 +141,7 @@ small_smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
                                if (tcon->ses->server->tcpStatus ==
                                                        CifsNeedReconnect) {
                                        /* on "soft" mounts we wait once */
-                                        if ((tcon->retry == FALSE) ||
+                                        if (!tcon->retry ||
                                           (tcon->ses->status == CifsExiting)) {
                                                cFYI(1, ("gave up waiting on "
                                                      "reconnect in smb_init"));
@@ -289,7 +289,7 @@ smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
                                if (tcon->ses->server->tcpStatus ==
                                                CifsNeedReconnect) {
                                        /* on "soft" mounts we wait once */
-                                        if ((tcon->retry == FALSE) ||
+                                        if (!tcon->retry ||
                                           (tcon->ses->status == CifsExiting)) {
                                                cFYI(1, ("gave up waiting on "
                                                      "reconnect in smb_init"));
@@ -1224,11 +1224,8 @@ OldOpenRetry:
        else /* BB FIXME BB */
                pSMB->FileAttributes = cpu_to_le16(0/*ATTR_NORMAL*/);
-        /* if ((omode & S_IWUGO) == 0)
+        if (create_options & CREATE_OPTION_READONLY)
-                pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);*/
+                pSMB->FileAttributes |= cpu_to_le16(ATTR_READONLY);
-        /*  Above line causes problems due to vfs splitting create into two
-            pieces - need to set mode after file created not while it is
-            being created */
        /* BB FIXME BB */
 /*      pSMB->CreateOptions = cpu_to_le32(create_options &
@@ -1331,17 +1328,16 @@ openRetry:
                pSMB->FileAttributes = cpu_to_le32(ATTR_SYSTEM);
        else
                pSMB->FileAttributes = cpu_to_le32(ATTR_NORMAL);
        /* XP does not handle ATTR_POSIX_SEMANTICS */
        /* but it helps speed up case sensitive checks for other
        servers such as Samba */
        if (tcon->ses->capabilities & CAP_UNIX)
                pSMB->FileAttributes |= cpu_to_le32(ATTR_POSIX_SEMANTICS);
-        /* if ((omode & S_IWUGO) == 0)
+        if (create_options & CREATE_OPTION_READONLY)
-                pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);*/
+                pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);
-        /*  Above line causes problems due to vfs splitting create into two
-                pieces - need to set mode after file created not while it is
-                being created */
        pSMB->ShareAccess = cpu_to_le32(FILE_SHARE_ALL);
        pSMB->CreateDisposition = cpu_to_le32(openDisposition);
        pSMB->CreateOptions = cpu_to_le32(create_options & CREATE_OPTIONS_MASK);
@@ -1686,7 +1682,7 @@ int
 CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
            const __u16 smb_file_id, const __u64 len,
            const __u64 offset, const __u32 numUnlock,
-            const __u32 numLock, const __u8 lockType, const int waitFlag)
+            const __u32 numLock, const __u8 lockType, const bool waitFlag)
 {
        int rc = 0;
        LOCK_REQ *pSMB = NULL;
@@ -1695,7 +1691,7 @@ CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
        int timeout = 0;
        __u16 count;
-        cFYI(1, ("CIFSSMBLock timeout %d numLock %d", waitFlag, numLock));
+        cFYI(1, ("CIFSSMBLock timeout %d numLock %d", (int)waitFlag, numLock));
        rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
        if (rc)
@@ -1706,7 +1702,7 @@ CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
        if (lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
                timeout = CIFS_ASYNC_OP; /* no response expected */
                pSMB->Timeout = 0;
-        } else if (waitFlag == TRUE) {
+        } else if (waitFlag) {
                timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
                pSMB->Timeout = cpu_to_le32(-1);/* blocking - do not time out */
        } else {
@@ -1756,7 +1752,7 @@ int
 CIFSSMBPosixLock(const int xid, struct cifsTconInfo *tcon,
                const __u16 smb_file_id, const int get_flag, const __u64 len,
                struct file_lock *pLockData, const __u16 lock_type,
-                const int waitFlag)
+                const bool waitFlag)
 {
        struct smb_com_transaction2_sfi_req *pSMB  = NULL;
        struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
@@ -3581,9 +3577,9 @@ findFirstRetry:
                rc = validate_t2((struct smb_t2_rsp *)pSMBr);
                if (rc == 0) {
                        if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
-                                psrch_inf->unicode = TRUE;
+                                psrch_inf->unicode = true;
                        else
-                                psrch_inf->unicode = FALSE;
+                                psrch_inf->unicode = false;
                        psrch_inf->ntwrk_buf_start = (char *)pSMBr;
                        psrch_inf->smallBuf = 0;
@@ -3594,9 +3590,9 @@ findFirstRetry:
                               le16_to_cpu(pSMBr->t2.ParameterOffset));
                        if (parms->EndofSearch)
-                                psrch_inf->endOfSearch = TRUE;
+                                psrch_inf->endOfSearch = true;
                        else
-                                psrch_inf->endOfSearch = FALSE;
+                                psrch_inf->endOfSearch = false;
                        psrch_inf->entries_in_buffer =
                                        le16_to_cpu(parms->SearchCount);
@@ -3624,7 +3620,7 @@ int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
        cFYI(1, ("In FindNext"));
-        if (psrch_inf->endOfSearch == TRUE)
+        if (psrch_inf->endOfSearch)
                return -ENOENT;
        rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
@@ -3682,7 +3678,7 @@ int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
        cifs_stats_inc(&tcon->num_fnext);
        if (rc) {
                if (rc == -EBADF) {
-                        psrch_inf->endOfSearch = TRUE;
+                        psrch_inf->endOfSearch = true;
                        rc = 0; /* search probably was closed at end of search*/
                } else
                        cFYI(1, ("FindNext returned = %d", rc));
@@ -3692,9 +3688,9 @@ int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
                if (rc == 0) {
                        /* BB fixme add lock for file (srch_info) struct here */
                        if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
-                                psrch_inf->unicode = TRUE;
+                                psrch_inf->unicode = true;
                        else
-                                psrch_inf->unicode = FALSE;
+                                psrch_inf->unicode = false;
                        response_data = (char *) &pSMBr->hdr.Protocol +
                               le16_to_cpu(pSMBr->t2.ParameterOffset);
                        parms = (T2_FNEXT_RSP_PARMS *)response_data;
@@ -3709,9 +3705,9 @@ int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
                        psrch_inf->ntwrk_buf_start = (char *)pSMB;
                        psrch_inf->smallBuf = 0;
                        if (parms->EndofSearch)
-                                psrch_inf->endOfSearch = TRUE;
+                                psrch_inf->endOfSearch = true;
                        else
-                                psrch_inf->endOfSearch = FALSE;
+                                psrch_inf->endOfSearch = false;
                        psrch_inf->entries_in_buffer =
                                                le16_to_cpu(parms->SearchCount);
                        psrch_inf->index_of_last_entry +=
@@ -4586,7 +4582,7 @@ QFSPosixRetry:
 int
 CIFSSMBSetEOF(const int xid, struct cifsTconInfo *tcon, const char *fileName,
-              __u64 size, int SetAllocation,
+              __u64 size, bool SetAllocation,
              const struct nls_table *nls_codepage, int remap)
 {
        struct smb_com_transaction2_spi_req *pSMB = NULL;
@@ -4675,7 +4671,7 @@ SetEOFRetry:
 int
 CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon, __u64 size,
-                   __u16 fid, __u32 pid_of_opener, int SetAllocation)
+                   __u16 fid, __u32 pid_of_opener, bool SetAllocation)
 {
        struct smb_com_transaction2_sfi_req *pSMB  = NULL;
        char *data_offset;
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index e17106730168..f428bf3bf1a9 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -49,8 +49,6 @@
 #define CIFS_PORT 445
 #define RFC1001_PORT 139
-static DECLARE_COMPLETION(cifsd_complete);
 extern void SMBNTencrypt(unsigned char *passwd, unsigned char *c8,
                         unsigned char *p24);
@@ -71,23 +69,23 @@ struct smb_vol {
        mode_t file_mode;
        mode_t dir_mode;
        unsigned secFlg;
-        unsigned rw:1;
+        bool rw:1;
-        unsigned retry:1;
+        bool retry:1;
-        unsigned intr:1;
+        bool intr:1;
-        unsigned setuids:1;
+        bool setuids:1;
-        unsigned override_uid:1;
+        bool override_uid:1;
-        unsigned override_gid:1;
+        bool override_gid:1;
-        unsigned noperm:1;
+        bool noperm:1;
-        unsigned no_psx_acl:1; /* set if posix acl support should be disabled */
+        bool no_psx_acl:1; /* set if posix acl support should be disabled */
-        unsigned cifs_acl:1;
+        bool cifs_acl:1;
-        unsigned no_xattr:1;   /* set if xattr (EA) support should be disabled*/
+        bool no_xattr:1;   /* set if xattr (EA) support should be disabled*/
-        unsigned server_ino:1; /* use inode numbers from server ie UniqueId */
+        bool server_ino:1; /* use inode numbers from server ie UniqueId */
-        unsigned direct_io:1;
+        bool direct_io:1;
-        unsigned remap:1;   /* set to remap seven reserved chars in filenames */
+        bool remap:1;     /* set to remap seven reserved chars in filenames */
-        unsigned posix_paths:1;   /* unset to not ask for posix pathnames. */
+        bool posix_paths:1;   /* unset to not ask for posix pathnames. */
-        unsigned no_linux_ext:1;
+        bool no_linux_ext:1;
-        unsigned sfu_emul:1;
+        bool sfu_emul:1;
-        unsigned nullauth:1; /* attempt to authenticate with null user */
+        bool nullauth:1; /* attempt to authenticate with null user */
        unsigned nocase;     /* request case insensitive filenames */
        unsigned nobrl;      /* disable sending byte range locks to srv */
        unsigned int rsize;
@@ -345,18 +343,16 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
        struct task_struct *task_to_wake = NULL;
        struct mid_q_entry *mid_entry;
        char temp;
-        int isLargeBuf = FALSE;
+        bool isLargeBuf = false;
-        int isMultiRsp;
+        bool isMultiRsp;
        int reconnect;
        current->flags |= PF_MEMALLOC;
-        server->tsk = current;  /* save process info to wake at shutdown */
        cFYI(1, ("Demultiplex PID: %d", task_pid_nr(current)));
        write_lock(&GlobalSMBSeslock);
        atomic_inc(&tcpSesAllocCount);
        length = tcpSesAllocCount.counter;
        write_unlock(&GlobalSMBSeslock);
-        complete(&cifsd_complete);
        if (length  > 1)
                mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
                                GFP_KERNEL);
@@ -390,8 +386,8 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
                } else /* if existing small buf clear beginning */
                        memset(smallbuf, 0, sizeof(struct smb_hdr));
-                isLargeBuf = FALSE;
+                isLargeBuf = false;
-                isMultiRsp = FALSE;
+                isMultiRsp = false;
                smb_buffer = smallbuf;
                iov.iov_base = smb_buffer;
                iov.iov_len = 4;
@@ -517,7 +513,7 @@ incomplete_rcv:
                reconnect = 0;
                if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
-                        isLargeBuf = TRUE;
+                        isLargeBuf = true;
                        memcpy(bigbuf, smallbuf, 4);
                        smb_buffer = bigbuf;
                }
@@ -582,16 +578,18 @@ incomplete_rcv:
                            (mid_entry->command == smb_buffer->Command)) {
                                if (check2ndT2(smb_buffer,server->maxBuf) > 0) {
                                        /* We have a multipart transact2 resp */
-                                        isMultiRsp = TRUE;
+                                        isMultiRsp = true;
                                        if (mid_entry->resp_buf) {
                                                /* merge response - fix up 1st*/
                                                if (coalesce_t2(smb_buffer,
                                                        mid_entry->resp_buf)) {
-                                                        mid_entry->multiRsp = 1;
+                                                        mid_entry->multiRsp =
+                                                                 true;
                                                        break;
                                                } else {
                                                        /* all parts received */
-                                                        mid_entry->multiEnd = 1;
+                                                        mid_entry->multiEnd =
+                                                                 true;
                                                        goto multi_t2_fnd;
                                                }
                                        } else {
@@ -603,17 +601,15 @@ incomplete_rcv:
                                                        /* Have first buffer */
                                                        mid_entry->resp_buf =
                                                                 smb_buffer;
-                                                        mid_entry->largeBuf = 1;
+                                                        mid_entry->largeBuf =
+                                                                 true;
                                                        bigbuf = NULL;
                                                }
                                        }
                                        break;
                                }
                                mid_entry->resp_buf = smb_buffer;
-                                if (isLargeBuf)
+                                mid_entry->largeBuf = isLargeBuf;
-                                        mid_entry->largeBuf = 1;
-                                else
-                                        mid_entry->largeBuf = 0;
 multi_t2_fnd:
                                task_to_wake = mid_entry->tsk;
                                mid_entry->midState = MID_RESPONSE_RECEIVED;
@@ -638,8 +634,8 @@ multi_t2_fnd:
                                        smallbuf = NULL;
                        }
                        wake_up_process(task_to_wake);
-                } else if ((is_valid_oplock_break(smb_buffer, server) == FALSE)
+                } else if (!is_valid_oplock_break(smb_buffer, server) &&
-                    && (isMultiRsp == FALSE)) {
+                           !isMultiRsp) {
                        cERROR(1, ("No task to wake, unknown frame received! "
                                   "NumMids %d", midCount.counter));
                        cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
@@ -654,10 +650,20 @@ multi_t2_fnd:
        spin_lock(&GlobalMid_Lock);
        server->tcpStatus = CifsExiting;
-        server->tsk = NULL;
+        spin_unlock(&GlobalMid_Lock);
+        /* don't exit until kthread_stop is called */
+        set_current_state(TASK_UNINTERRUPTIBLE);
+        while (!kthread_should_stop()) {
+                schedule();
+                set_current_state(TASK_UNINTERRUPTIBLE);
+        }
+        set_current_state(TASK_RUNNING);
        /* 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
@@ -825,7 +831,7 @@ cifs_parse_mount_options(char *options, const char *devname,
        vol->file_mode = (S_IRWXUGO | S_ISGID) & (~S_IXGRP);
        /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
-        vol->rw = TRUE;
+        vol->rw = true;
        /* default is always to request posix paths. */
        vol->posix_paths = 1;
@@ -1181,7 +1187,7 @@ cifs_parse_mount_options(char *options, const char *devname,
                } else if (strnicmp(data, "guest", 5) == 0) {
                        /* ignore */
                } else if (strnicmp(data, "rw", 2) == 0) {
-                        vol->rw = TRUE;
+                        vol->rw = true;
                } else if ((strnicmp(data, "suid", 4) == 0) ||
                                   (strnicmp(data, "nosuid", 6) == 0) ||
                                   (strnicmp(data, "exec", 4) == 0) ||
@@ -1197,7 +1203,7 @@ cifs_parse_mount_options(char *options, const char *devname,
                            is ok to just ignore them */
                        continue;
                } else if (strnicmp(data, "ro", 2) == 0) {
-                        vol->rw = FALSE;
+                        vol->rw = false;
                } else if (strnicmp(data, "hard", 4) == 0) {
                        vol->retry = 1;
                } else if (strnicmp(data, "soft", 4) == 0) {
@@ -1305,6 +1311,9 @@ cifs_parse_mount_options(char *options, const char *devname,
                                                    "begin with // or \\\\ \n");
                                return 1;
                        }
+                        value = strpbrk(vol->UNC+2, "/\\");
+                        if (value)
+                                *value = '\\';
                } else {
                        printk(KERN_WARNING "CIFS: UNC name too long\n");
                        return 1;
@@ -1318,42 +1327,43 @@ cifs_parse_mount_options(char *options, const char *devname,
 static struct cifsSesInfo *
 cifs_find_tcp_session(struct in_addr *target_ip_addr,
-                struct in6_addr *target_ip6_addr,
+                      struct in6_addr *target_ip6_addr,
-                 char *userName, struct TCP_Server_Info **psrvTcp)
+                      char *userName, struct TCP_Server_Info **psrvTcp)
 {
        struct list_head *tmp;
        struct cifsSesInfo *ses;
        *psrvTcp = NULL;
-        read_lock(&GlobalSMBSeslock);
+        read_lock(&GlobalSMBSeslock);
        list_for_each(tmp, &GlobalSMBSessionList) {
                ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
-                if (ses->server) {
+                if (!ses->server)
-                        if ((target_ip_addr &&
+                        continue;
-                                (ses->server->addr.sockAddr.sin_addr.s_addr
-                                  == target_ip_addr->s_addr)) || (target_ip6_addr
+                if (target_ip_addr &&
-                                && memcmp(&ses->server->addr.sockAddr6.sin6_addr,
+                    ses->server->addr.sockAddr.sin_addr.s_addr != target_ip_addr->s_addr)
-                                        target_ip6_addr, sizeof(*target_ip6_addr)))) {
+                                continue;
-                                /* BB lock server and tcp session and increment
+                else if (target_ip6_addr &&
-                                      use count here?? */
+                         memcmp(&ses->server->addr.sockAddr6.sin6_addr,
+                                target_ip6_addr, sizeof(*target_ip6_addr)))
-                                /* found a match on the TCP session */
+                                continue;
-                                *psrvTcp = ses->server;
+                /* BB lock server and tcp session; increment use count here?? */
-                                /* BB check if reconnection needed */
+                /* found a match on the TCP session */
-                                if (strncmp
+                *psrvTcp = ses->server;
-                                    (ses->userName, userName,
-                                     MAX_USERNAME_SIZE) == 0){
+                /* BB check if reconnection needed */
-                                        read_unlock(&GlobalSMBSeslock);
+                if (strncmp(ses->userName, userName, MAX_USERNAME_SIZE) == 0) {
-                                        /* Found exact match on both TCP and
+                        read_unlock(&GlobalSMBSeslock);
-                                           SMB sessions */
+                        /* Found exact match on both TCP and
-                                        return ses;
+                           SMB sessions */
-                                }
+                        return ses;
-                        }
                }
                /* else tcp and smb sessions need reconnection */
        }
        read_unlock(&GlobalSMBSeslock);
        return NULL;
 }
@@ -1362,45 +1372,43 @@ find_unc(__be32 new_target_ip_addr, char *uncName, char *userName)
 {
        struct list_head *tmp;
        struct cifsTconInfo *tcon;
+        __be32 old_ip;
        read_lock(&GlobalSMBSeslock);
        list_for_each(tmp, &GlobalTreeConnectionList) {
                cFYI(1, ("Next tcon"));
                tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
-                if (tcon->ses) {
+                if (!tcon->ses || !tcon->ses->server)
-                        if (tcon->ses->server) {
+                        continue;
-                                cFYI(1,
-                                     ("old ip addr: %x == new ip %x ?",
+                old_ip = tcon->ses->server->addr.sockAddr.sin_addr.s_addr;
-                                      tcon->ses->server->addr.sockAddr.sin_addr.
+                cFYI(1, ("old ip addr: %x == new ip %x ?",
-                                      s_addr, new_target_ip_addr));
+                        old_ip, new_target_ip_addr));
-                                if (tcon->ses->server->addr.sockAddr.sin_addr.
-                                    s_addr == new_target_ip_addr) {
+                if (old_ip != new_target_ip_addr)
-        /* BB lock tcon, server and tcp session and increment use count here? */
+                        continue;
-                                        /* found a match on the TCP session */
-                                        /* BB check if reconnection needed */
+                /* BB lock tcon, server, tcp session and increment use count? */
-                                        cFYI(1,
+                /* found a match on the TCP session */
-                                              ("IP match, old UNC: %s new: %s",
+                /* BB check if reconnection needed */
-                                              tcon->treeName, uncName));
+                cFYI(1, ("IP match, old UNC: %s new: %s",
-                                        if (strncmp
+                        tcon->treeName, uncName));
-                                            (tcon->treeName, uncName,
-                                             MAX_TREE_SIZE) == 0) {
+                if (strncmp(tcon->treeName, uncName, MAX_TREE_SIZE))
-                                                cFYI(1,
+                        continue;
-                                                     ("and old usr: %s new: %s",
-                                                      tcon->treeName, uncName));
+                cFYI(1, ("and old usr: %s new: %s",
-                                                if (strncmp
+                        tcon->treeName, uncName));
-                                                    (tcon->ses->userName,
-                                                     userName,
+                if (strncmp(tcon->ses->userName, userName, MAX_USERNAME_SIZE))
-                                                     MAX_USERNAME_SIZE) == 0) {
+                        continue;
-                                                        read_unlock(&GlobalSMBSeslock);
-                                                        /* matched smb session
+                /* matched smb session (user name) */
-                                                        (user name */
+                read_unlock(&GlobalSMBSeslock);
-                                                        return tcon;
+                return tcon;
-                                                }
-                                        }
-                                }
-                        }
-                }
        }
        read_unlock(&GlobalSMBSeslock);
        return NULL;
 }
@@ -1982,7 +1990,6 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                                kfree(srvTcp->hostname);
                                goto out;
                        }
-                        wait_for_completion(&cifsd_complete);
                        rc = 0;
                        memcpy(srvTcp->workstation_RFC1001_name,
                                volume_info.source_rfc1001_name, 16);
@@ -2189,15 +2196,12 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                        srvTcp->tcpStatus = CifsExiting;
                        spin_unlock(&GlobalMid_Lock);
                        if (srvTcp->tsk) {
-                                struct task_struct *tsk;
                                /* If we could verify that kthread_stop would
                                   always wake up processes blocked in
                                   tcp in recv_mesg then we could remove the
                                   send_sig call */
                                force_sig(SIGKILL, srvTcp->tsk);
-                                tsk = srvTcp->tsk;
+                                kthread_stop(srvTcp->tsk);
-                                if (tsk)
-                                        kthread_stop(tsk);
                        }
                }
                 /* If find_unc succeeded then rc == 0 so we can not end */
@@ -2213,23 +2217,17 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                                        if ((temp_rc == -ESHUTDOWN) &&
                                            (pSesInfo->server) &&
                                            (pSesInfo->server->tsk)) {
-                                                struct task_struct *tsk;
                                                force_sig(SIGKILL,
                                                        pSesInfo->server->tsk);
-                                                tsk = pSesInfo->server->tsk;
+                                                kthread_stop(pSesInfo->server->tsk);
-                                                if (tsk)
-                                                        kthread_stop(tsk);
                                        }
                                } else {
                                        cFYI(1, ("No session or bad tcon"));
                                        if ((pSesInfo->server) &&
                                            (pSesInfo->server->tsk)) {
-                                                struct task_struct *tsk;
                                                force_sig(SIGKILL,
                                                        pSesInfo->server->tsk);
-                                                tsk = pSesInfo->server->tsk;
+                                                kthread_stop(pSesInfo->server->tsk);
-                                                if (tsk)
-                                                        kthread_stop(tsk);
                                        }
                                }
                                sesInfoFree(pSesInfo);
@@ -2602,7 +2600,7 @@ sesssetup_nomem:	/* do not return an error on nomem for the info strings,
 static int
 CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
-                              struct cifsSesInfo *ses, int *pNTLMv2_flag,
+                              struct cifsSesInfo *ses, bool *pNTLMv2_flag,
                              const struct nls_table *nls_codepage)
 {
        struct smb_hdr *smb_buffer;
@@ -2625,7 +2623,7 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
        if (ses == NULL)
                return -EINVAL;
        domain = ses->domainName;
-        *pNTLMv2_flag = FALSE;
+        *pNTLMv2_flag = false;
        smb_buffer = cifs_buf_get();
        if (smb_buffer == NULL) {
                return -ENOMEM;
@@ -2778,7 +2776,7 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
                                       CIFS_CRYPTO_KEY_SIZE);
                                if (SecurityBlob2->NegotiateFlags &
                                        cpu_to_le32(NTLMSSP_NEGOTIATE_NTLMV2))
-                                        *pNTLMv2_flag = TRUE;
+                                        *pNTLMv2_flag = true;
                                if ((SecurityBlob2->NegotiateFlags &
                                        cpu_to_le32(NTLMSSP_NEGOTIATE_ALWAYS_SIGN))
@@ -2939,7 +2937,7 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
 }
 static int
 CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
-                        char *ntlm_session_key, int ntlmv2_flag,
+                        char *ntlm_session_key, bool ntlmv2_flag,
                        const struct nls_table *nls_codepage)
 {
        struct smb_hdr *smb_buffer;
@@ -3556,8 +3554,6 @@ cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
        cifs_sb->prepath = NULL;
        kfree(tmp);
        if (ses)
-                schedule_timeout_interruptible(msecs_to_jiffies(500));
-        if (ses)
                sesInfoFree(ses);
        FreeXid(xid);
@@ -3569,7 +3565,7 @@ int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
 {
        int rc = 0;
        char ntlm_session_key[CIFS_SESS_KEY_SIZE];
-        int ntlmv2_flag = FALSE;
+        bool ntlmv2_flag = false;
        int first_time = 0;
        /* what if server changes its buffer size after dropping the session? */
diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c
index 0f5c62ba4038..e4e0078a0526 100644
--- a/fs/cifs/dir.c
+++ b/fs/cifs/dir.c
@@ -119,6 +119,7 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
 {
        int rc = -ENOENT;
        int xid;
+        int create_options = CREATE_NOT_DIR;
        int oplock = 0;
        int desiredAccess = GENERIC_READ | GENERIC_WRITE;
        __u16 fileHandle;
@@ -130,7 +131,7 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
        struct cifsFileInfo *pCifsFile = NULL;
        struct cifsInodeInfo *pCifsInode;
        int disposition = FILE_OVERWRITE_IF;
-        int write_only = FALSE;
+        bool write_only = false;
        xid = GetXid();
@@ -152,7 +153,7 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
                if (oflags & FMODE_WRITE) {
                        desiredAccess |= GENERIC_WRITE;
                        if (!(oflags & FMODE_READ))
-                                write_only = TRUE;
+                                write_only = true;
                }
                if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
@@ -176,9 +177,19 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
                FreeXid(xid);
                return -ENOMEM;
        }
+        mode &= ~current->fs->umask;
+        /*
+         * if we're not using unix extensions, see if we need to set
+         * ATTR_READONLY on the create call
+         */
+        if (!pTcon->unix_ext && (mode & S_IWUGO) == 0)
+                create_options |= CREATE_OPTION_READONLY;
        if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
                rc = CIFSSMBOpen(xid, pTcon, full_path, disposition,
-                         desiredAccess, CREATE_NOT_DIR,
+                         desiredAccess, create_options,
                         &fileHandle, &oplock, buf, cifs_sb->local_nls,
                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
        else
@@ -187,7 +198,7 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
        if (rc == -EIO) {
                /* old server, retry the open legacy style */
                rc = SMBLegacyOpen(xid, pTcon, full_path, disposition,
-                        desiredAccess, CREATE_NOT_DIR,
+                        desiredAccess, create_options,
                        &fileHandle, &oplock, buf, cifs_sb->local_nls,
                        cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
        }
@@ -197,7 +208,6 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
                /* If Open reported that we actually created a file
                then we now have to set the mode if possible */
                if ((pTcon->unix_ext) && (oplock & CIFS_CREATE_ACTION)) {
-                        mode &= ~current->fs->umask;
                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
                                CIFSSMBUnixSetPerms(xid, pTcon, full_path, mode,
                                        (__u64)current->fsuid,
@@ -254,7 +264,7 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
                        d_instantiate(direntry, newinode);
                }
                if ((nd == NULL /* nfsd case - nfs srv does not set nd */) ||
-                        ((nd->flags & LOOKUP_OPEN) == FALSE)) {
+                        (!(nd->flags & LOOKUP_OPEN))) {
                        /* mknod case - do not leave file open */
                        CIFSSMBClose(xid, pTcon, fileHandle);
                } else if (newinode) {
@@ -266,8 +276,8 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
                        pCifsFile->netfid = fileHandle;
                        pCifsFile->pid = current->tgid;
                        pCifsFile->pInode = newinode;
-                        pCifsFile->invalidHandle = FALSE;
+                        pCifsFile->invalidHandle = false;
-                        pCifsFile->closePend     = FALSE;
+                        pCifsFile->closePend     = false;
                        init_MUTEX(&pCifsFile->fh_sem);
                        mutex_init(&pCifsFile->lock_mutex);
                        INIT_LIST_HEAD(&pCifsFile->llist);
@@ -280,7 +290,7 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
                        pCifsInode = CIFS_I(newinode);
                        if (pCifsInode) {
                                /* if readable file instance put first in list*/
-                                if (write_only == TRUE) {
+                                if (write_only) {
                                        list_add_tail(&pCifsFile->flist,
                                                &pCifsInode->openFileList);
                                } else {
@@ -288,12 +298,12 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
                                                &pCifsInode->openFileList);
                                }
                                if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
-                                        pCifsInode->clientCanCacheAll = TRUE;
+                                        pCifsInode->clientCanCacheAll = true;
-                                        pCifsInode->clientCanCacheRead = TRUE;
+                                        pCifsInode->clientCanCacheRead = true;
                                        cFYI(1, ("Exclusive Oplock inode %p",
                                                newinode));
                                } else if ((oplock & 0xF) == OPLOCK_READ)
-                                        pCifsInode->clientCanCacheRead = TRUE;
+                                        pCifsInode->clientCanCacheRead = true;
                        }
                        write_unlock(&GlobalSMBSeslock);
                }
diff --git a/fs/cifs/dns_resolve.c b/fs/cifs/dns_resolve.c
index 7cc86c418182..939e256f8497 100644
--- a/fs/cifs/dns_resolve.c
+++ b/fs/cifs/dns_resolve.c
@@ -55,6 +55,32 @@ struct key_type key_type_dns_resolver = {
        .match       = user_match,
 };
+/* Checks if supplied name is IP address
+ * returns:
+ *              1 - name is IP
+ *              0 - name is not IP
+ */
+static int is_ip(const char *name)
+{
+        int rc;
+        struct sockaddr_in sin_server;
+        struct sockaddr_in6 sin_server6;
+        rc = cifs_inet_pton(AF_INET, name,
+                        &sin_server.sin_addr.s_addr);
+        if (rc <= 0) {
+                /* not ipv4 address, try ipv6 */
+                rc = cifs_inet_pton(AF_INET6, name,
+                                &sin_server6.sin6_addr.in6_u);
+                if (rc > 0)
+                        return 1;
+        } else {
+                return 1;
+        }
+        /* we failed translating address */
+        return 0;
+}
 /* Resolves server name to ip address.
 * input:
@@ -67,8 +93,9 @@ int
 dns_resolve_server_name_to_ip(const char *unc, char **ip_addr)
 {
        int rc = -EAGAIN;
-        struct key *rkey;
+        struct key *rkey = ERR_PTR(-EAGAIN);
        char *name;
+        char *data = NULL;
        int len;
        if (!ip_addr || !unc)
@@ -97,26 +124,41 @@ dns_resolve_server_name_to_ip(const char *unc, char **ip_addr)
        memcpy(name, unc+2, len);
        name[len] = 0;
+        if (is_ip(name)) {
+                cFYI(1, ("%s: it is IP, skipping dns upcall: %s",
+                                        __func__, name));
+                data = name;
+                goto skip_upcall;
+        }
        rkey = request_key(&key_type_dns_resolver, name, "");
        if (!IS_ERR(rkey)) {
-                len = strlen(rkey->payload.data);
+                data = rkey->payload.data;
-                *ip_addr = kmalloc(len+1, GFP_KERNEL);
+                cFYI(1, ("%s: resolved: %s to %s", __func__,
-                if (*ip_addr) {
-                        memcpy(*ip_addr, rkey->payload.data, len);
-                        (*ip_addr)[len] = '\0';
-                        cFYI(1, ("%s: resolved: %s to %s", __func__,
                                        rkey->description,
                                        *ip_addr
                                ));
+        } else {
+                cERROR(1, ("%s: unable to resolve: %s", __func__, name));
+                goto out;
+        }
+skip_upcall:
+        if (data) {
+                len = strlen(data);
+                *ip_addr = kmalloc(len+1, GFP_KERNEL);
+                if (*ip_addr) {
+                        memcpy(*ip_addr, data, len);
+                        (*ip_addr)[len] = '\0';
                        rc = 0;
                } else {
                        rc = -ENOMEM;
                }
-                key_put(rkey);
+                if (!IS_ERR(rkey))
-        } else {
+                        key_put(rkey);
-                cERROR(1, ("%s: unable to resolve: %s", __func__, name));
        }
+out:
        kfree(name);
        return rc;
 }
diff --git a/fs/cifs/fcntl.c b/fs/cifs/fcntl.c
index 7d1d5aa4c430..5a57581eb4b2 100644
--- a/fs/cifs/fcntl.c
+++ b/fs/cifs/fcntl.c
@@ -68,7 +68,7 @@ int cifs_dir_notify(struct file *file, unsigned long arg)
 {
        int xid;
        int rc = -EINVAL;
-        int oplock = FALSE;
+        int oplock = 0;
        struct cifs_sb_info *cifs_sb;
        struct cifsTconInfo *pTcon;
        char *full_path = NULL;
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 40b690073fc1..31a0a33b9d95 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -51,8 +51,8 @@ static inline struct cifsFileInfo *cifs_init_private(
        INIT_LIST_HEAD(&private_data->llist);
        private_data->pfile = file; /* needed for writepage */
        private_data->pInode = inode;
-        private_data->invalidHandle = FALSE;
+        private_data->invalidHandle = false;
-        private_data->closePend = FALSE;
+        private_data->closePend = false;
        /* we have to track num writers to the inode, since writepages
        does not tell us which handle the write is for so there can
        be a close (overlapping with write) of the filehandle that
@@ -148,12 +148,12 @@ client_can_cache:
                        full_path, buf, inode->i_sb, xid, NULL);
        if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
-                pCifsInode->clientCanCacheAll = TRUE;
+                pCifsInode->clientCanCacheAll = true;
-                pCifsInode->clientCanCacheRead = TRUE;
+                pCifsInode->clientCanCacheRead = true;
                cFYI(1, ("Exclusive Oplock granted on inode %p",
                         file->f_path.dentry->d_inode));
        } else if ((*oplock & 0xF) == OPLOCK_READ)
-                pCifsInode->clientCanCacheRead = TRUE;
+                pCifsInode->clientCanCacheRead = true;
        return rc;
 }
@@ -247,7 +247,7 @@ int cifs_open(struct inode *inode, struct file *file)
        if (oplockEnabled)
                oplock = REQ_OPLOCK;
        else
-                oplock = FALSE;
+                oplock = 0;
        /* BB pass O_SYNC flag through on file attributes .. BB */
@@ -339,7 +339,7 @@ static int cifs_relock_file(struct cifsFileInfo *cifsFile)
        return rc;
 }
-static int cifs_reopen_file(struct file *file, int can_flush)
+static int cifs_reopen_file(struct file *file, bool can_flush)
 {
        int rc = -EACCES;
        int xid, oplock;
@@ -360,7 +360,7 @@ static int cifs_reopen_file(struct file *file, int can_flush)
        xid = GetXid();
        down(&pCifsFile->fh_sem);
-        if (pCifsFile->invalidHandle == FALSE) {
+        if (!pCifsFile->invalidHandle) {
                up(&pCifsFile->fh_sem);
                FreeXid(xid);
                return 0;
@@ -404,7 +404,7 @@ reopen_error_exit:
        if (oplockEnabled)
                oplock = REQ_OPLOCK;
        else
-                oplock = FALSE;
+                oplock = 0;
        /* Can not refresh inode by passing in file_info buf to be returned
           by SMBOpen and then calling get_inode_info with returned buf
@@ -422,7 +422,7 @@ reopen_error_exit:
                cFYI(1, ("oplock: %d", oplock));
        } else {
                pCifsFile->netfid = netfid;
-                pCifsFile->invalidHandle = FALSE;
+                pCifsFile->invalidHandle = false;
                up(&pCifsFile->fh_sem);
                pCifsInode = CIFS_I(inode);
                if (pCifsInode) {
@@ -432,8 +432,8 @@ reopen_error_exit:
                                        CIFS_I(inode)->write_behind_rc = rc;
                        /* temporarily disable caching while we
                           go to server to get inode info */
-                                pCifsInode->clientCanCacheAll = FALSE;
+                                pCifsInode->clientCanCacheAll = false;
-                                pCifsInode->clientCanCacheRead = FALSE;
+                                pCifsInode->clientCanCacheRead = false;
                                if (pTcon->unix_ext)
                                        rc = cifs_get_inode_info_unix(&inode,
                                                full_path, inode->i_sb, xid);
@@ -448,16 +448,16 @@ reopen_error_exit:
                             we can not go to the server to get the new inod
                             info */
                        if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
-                                pCifsInode->clientCanCacheAll = TRUE;
+                                pCifsInode->clientCanCacheAll = true;
-                                pCifsInode->clientCanCacheRead = TRUE;
+                                pCifsInode->clientCanCacheRead = true;
                                cFYI(1, ("Exclusive Oplock granted on inode %p",
                                         file->f_path.dentry->d_inode));
                        } else if ((oplock & 0xF) == OPLOCK_READ) {
-                                pCifsInode->clientCanCacheRead = TRUE;
+                                pCifsInode->clientCanCacheRead = true;
-                                pCifsInode->clientCanCacheAll = FALSE;
+                                pCifsInode->clientCanCacheAll = false;
                        } else {
-                                pCifsInode->clientCanCacheRead = FALSE;
+                                pCifsInode->clientCanCacheRead = false;
-                                pCifsInode->clientCanCacheAll = FALSE;
+                                pCifsInode->clientCanCacheAll = false;
                        }
                        cifs_relock_file(pCifsFile);
                }
@@ -484,7 +484,7 @@ int cifs_close(struct inode *inode, struct file *file)
        if (pSMBFile) {
                struct cifsLockInfo *li, *tmp;
-                pSMBFile->closePend = TRUE;
+                pSMBFile->closePend = true;
                if (pTcon) {
                        /* no sense reconnecting to close a file that is
                           already closed */
@@ -553,8 +553,8 @@ int cifs_close(struct inode *inode, struct file *file)
                cFYI(1, ("closing last open instance for inode %p", inode));
                /* if the file is not open we do not know if we can cache info
                   on this inode, much less write behind and read ahead */
-                CIFS_I(inode)->clientCanCacheRead = FALSE;
+                CIFS_I(inode)->clientCanCacheRead = false;
-                CIFS_I(inode)->clientCanCacheAll  = FALSE;
+                CIFS_I(inode)->clientCanCacheAll  = false;
        }
        read_unlock(&GlobalSMBSeslock);
        if ((rc == 0) && CIFS_I(inode)->write_behind_rc)
@@ -583,9 +583,9 @@ int cifs_closedir(struct inode *inode, struct file *file)
                pTcon = cifs_sb->tcon;
                cFYI(1, ("Freeing private data in close dir"));
-                if ((pCFileStruct->srch_inf.endOfSearch == FALSE) &&
+                if (!pCFileStruct->srch_inf.endOfSearch &&
-                   (pCFileStruct->invalidHandle == FALSE)) {
+                    !pCFileStruct->invalidHandle) {
-                        pCFileStruct->invalidHandle = TRUE;
+                        pCFileStruct->invalidHandle = true;
                        rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
                        cFYI(1, ("Closing uncompleted readdir with rc %d",
                                 rc));
@@ -637,12 +637,12 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
        __u32 numLock = 0;
        __u32 numUnlock = 0;
        __u64 length;
-        int wait_flag = FALSE;
+        bool wait_flag = false;
        struct cifs_sb_info *cifs_sb;
        struct cifsTconInfo *pTcon;
        __u16 netfid;
        __u8 lockType = LOCKING_ANDX_LARGE_FILES;
-        int posix_locking;
+        bool posix_locking;
        length = 1 + pfLock->fl_end - pfLock->fl_start;
        rc = -EACCES;
@@ -659,7 +659,7 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
                cFYI(1, ("Flock"));
        if (pfLock->fl_flags & FL_SLEEP) {
                cFYI(1, ("Blocking lock"));
-                wait_flag = TRUE;
+                wait_flag = true;
        }
        if (pfLock->fl_flags & FL_ACCESS)
                cFYI(1, ("Process suspended by mandatory locking - "
@@ -794,7 +794,7 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
                                        stored_rc = CIFSSMBLock(xid, pTcon,
                                                        netfid,
                                                        li->length, li->offset,
-                                                        1, 0, li->type, FALSE);
+                                                        1, 0, li->type, false);
                                        if (stored_rc)
                                                rc = stored_rc;
@@ -866,7 +866,7 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,
                                   filemap_fdatawait from here so tell
                                   reopen_file not to flush data to server
                                   now */
-                                rc = cifs_reopen_file(file, FALSE);
+                                rc = cifs_reopen_file(file, false);
                                if (rc != 0)
                                        break;
                        }
@@ -966,7 +966,7 @@ static ssize_t cifs_write(struct file *file, const char *write_data,
                                   filemap_fdatawait from here so tell
                                   reopen_file not to flush data to
                                   server now */
-                                rc = cifs_reopen_file(file, FALSE);
+                                rc = cifs_reopen_file(file, false);
                                if (rc != 0)
                                        break;
                        }
@@ -1093,7 +1093,7 @@ refind_writable:
                        read_unlock(&GlobalSMBSeslock);
                        /* Had to unlock since following call can block */
-                        rc = cifs_reopen_file(open_file->pfile, FALSE);
+                        rc = cifs_reopen_file(open_file->pfile, false);
                        if (!rc) {
                                if (!open_file->closePend)
                                        return open_file;
@@ -1608,7 +1608,7 @@ ssize_t cifs_user_read(struct file *file, char __user *read_data,
                        int buf_type = CIFS_NO_BUFFER;
                        if ((open_file->invalidHandle) &&
                            (!open_file->closePend)) {
-                                rc = cifs_reopen_file(file, TRUE);
+                                rc = cifs_reopen_file(file, true);
                                if (rc != 0)
                                        break;
                        }
@@ -1693,7 +1693,7 @@ static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
                while (rc == -EAGAIN) {
                        if ((open_file->invalidHandle) &&
                            (!open_file->closePend)) {
-                                rc = cifs_reopen_file(file, TRUE);
+                                rc = cifs_reopen_file(file, true);
                                if (rc != 0)
                                        break;
                        }
@@ -1850,7 +1850,7 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
                while (rc == -EAGAIN) {
                        if ((open_file->invalidHandle) &&
                            (!open_file->closePend)) {
-                                rc = cifs_reopen_file(file, TRUE);
+                                rc = cifs_reopen_file(file, true);
                                if (rc != 0)
                                        break;
                        }
@@ -2009,10 +2009,10 @@ static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
   refreshing the inode only on increases in the file size
   but this is tricky to do without racing with writebehind
   page caching in the current Linux kernel design */
-int is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
+bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
 {
        if (!cifsInode)
-                return 1;
+                return true;
        if (is_inode_writable(cifsInode)) {
                /* This inode is open for write at least once */
@@ -2022,15 +2022,15 @@ int is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
                        /* since no page cache to corrupt on directio
                        we can change size safely */
-                        return 1;
+                        return true;
                }
                if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
-                        return 1;
+                        return true;
-                return 0;
+                return false;
        } else
-                return 1;
+                return true;
 }
 static int cifs_prepare_write(struct file *file, struct page *page,
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index e1031b9e2c55..fcbdbb6ad7bf 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -281,7 +281,7 @@ static int decode_sfu_inode(struct inode *inode, __u64 size,
                            struct cifs_sb_info *cifs_sb, int xid)
 {
        int rc;
-        int oplock = FALSE;
+        int oplock = 0;
        __u16 netfid;
        struct cifsTconInfo *pTcon = cifs_sb->tcon;
        char buf[24];
@@ -389,7 +389,7 @@ int cifs_get_inode_info(struct inode **pinode,
        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
        const unsigned char *full_path = NULL;
        char *buf = NULL;
-        int adjustTZ = FALSE;
+        bool adjustTZ = false;
        bool is_dfs_referral = false;
        pTcon = cifs_sb->tcon;
@@ -425,7 +425,7 @@ try_again_CIFSSMBQPathInfo:
                                        pfindData, cifs_sb->local_nls,
                                        cifs_sb->mnt_cifs_flags &
                                          CIFS_MOUNT_MAP_SPECIAL_CHR);
-                        adjustTZ = TRUE;
+                        adjustTZ = true;
                }
        }
        /* dump_mem("\nQPathInfo return data",&findData, sizeof(findData)); */
@@ -703,7 +703,7 @@ psx_del_no_retry:
        } else if (rc == -ENOENT) {
                d_drop(direntry);
        } else if (rc == -ETXTBSY) {
-                int oplock = FALSE;
+                int oplock = 0;
                __u16 netfid;
                rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, DELETE,
@@ -736,7 +736,7 @@ psx_del_no_retry:
                                rc = -EOPNOTSUPP;
                        if (rc == -EOPNOTSUPP) {
-                                int oplock = FALSE;
+                                int oplock = 0;
                                __u16 netfid;
                        /*      rc = CIFSSMBSetAttrLegacy(xid, pTcon,
                                                          full_path,
@@ -774,7 +774,7 @@ psx_del_no_retry:
                                if (direntry->d_inode)
                                        drop_nlink(direntry->d_inode);
                        } else if (rc == -ETXTBSY) {
-                                int oplock = FALSE;
+                                int oplock = 0;
                                __u16 netfid;
                                rc = CIFSSMBOpen(xid, pTcon, full_path,
@@ -974,8 +974,8 @@ mkdir_get_info:
                  * 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->fs->umask;
                if (pTcon->unix_ext) {
-                        mode &= ~current->fs->umask;
                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
                                CIFSSMBUnixSetPerms(xid, pTcon, full_path,
                                                    mode,
@@ -994,9 +994,16 @@ mkdir_get_info:
                                                    CIFS_MOUNT_MAP_SPECIAL_CHR);
                        }
                } else {
-                        /* BB to be implemented via Windows secrty descriptors
+                        if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
-                           eg CIFSSMBWinSetPerms(xid, pTcon, full_path, mode,
+                            (mode & S_IWUGO) == 0) {
-                                                 -1, -1, local_nls); */
+                                FILE_BASIC_INFO pInfo;
+                                memset(&pInfo, 0, sizeof(pInfo));
+                                pInfo.Attributes = cpu_to_le32(ATTR_READONLY);
+                                CIFSSMBSetTimes(xid, pTcon, full_path,
+                                                &pInfo, cifs_sb->local_nls,
+                                                cifs_sb->mnt_cifs_flags &
+                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
+                        }
                        if (direntry->d_inode) {
                                direntry->d_inode->i_mode = mode;
                                direntry->d_inode->i_mode |= S_IFDIR;
@@ -1149,7 +1156,7 @@ int cifs_rename(struct inode *source_inode, struct dentry *source_direntry,
                cFYI(1, ("rename rc %d", rc));
        if ((rc == -EIO) || (rc == -EEXIST)) {
-                int oplock = FALSE;
+                int oplock = 0;
                __u16 netfid;
                /* BB FIXME Is Generic Read correct for rename? */
@@ -1186,7 +1193,7 @@ int cifs_revalidate(struct dentry *direntry)
        struct cifsInodeInfo *cifsInode;
        loff_t local_size;
        struct timespec local_mtime;
-        int invalidate_inode = FALSE;
+        bool invalidate_inode = false;
        if (direntry->d_inode == NULL)
                return -ENOENT;
@@ -1268,7 +1275,7 @@ int cifs_revalidate(struct dentry *direntry)
                           only ones who could have modified the file and the
                           server copy is staler than ours */
                } else {
-                        invalidate_inode = TRUE;
+                        invalidate_inode = true;
                }
        }
@@ -1402,24 +1409,25 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
        int rc = -EACCES;
        struct cifsFileInfo *open_file = NULL;
        FILE_BASIC_INFO time_buf;
-        int set_time = FALSE;
+        bool set_time = false;
-        int set_dosattr = FALSE;
+        bool set_dosattr = false;
        __u64 mode = 0xFFFFFFFFFFFFFFFFULL;
        __u64 uid = 0xFFFFFFFFFFFFFFFFULL;
        __u64 gid = 0xFFFFFFFFFFFFFFFFULL;
        struct cifsInodeInfo *cifsInode;
+        struct inode *inode = direntry->d_inode;
        xid = GetXid();
        cFYI(1, ("setattr on file %s attrs->iavalid 0x%x",
                 direntry->d_name.name, attrs->ia_valid));
-        cifs_sb = CIFS_SB(direntry->d_inode->i_sb);
+        cifs_sb = CIFS_SB(inode->i_sb);
        pTcon = cifs_sb->tcon;
        if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) == 0) {
                /* check if we have permission to change attrs */
-                rc = inode_change_ok(direntry->d_inode, attrs);
+                rc = inode_change_ok(inode, attrs);
                if (rc < 0) {
                        FreeXid(xid);
                        return rc;
@@ -1432,7 +1440,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                FreeXid(xid);
                return -ENOMEM;
        }
-        cifsInode = CIFS_I(direntry->d_inode);
+        cifsInode = CIFS_I(inode);
        if ((attrs->ia_valid & ATTR_MTIME) || (attrs->ia_valid & ATTR_SIZE)) {
                /*
@@ -1443,9 +1451,9 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                   will be truncated anyway? Also, should we error out here if
                   the flush returns error?
                 */
-                rc = filemap_write_and_wait(direntry->d_inode->i_mapping);
+                rc = filemap_write_and_wait(inode->i_mapping);
                if (rc != 0) {
-                        CIFS_I(direntry->d_inode)->write_behind_rc = rc;
+                        cifsInode->write_behind_rc = rc;
                        rc = 0;
                }
        }
@@ -1464,7 +1472,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                        __u16 nfid = open_file->netfid;
                        __u32 npid = open_file->pid;
                        rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size,
-                                                nfid, npid, FALSE);
+                                                nfid, npid, false);
                        atomic_dec(&open_file->wrtPending);
                        cFYI(1, ("SetFSize for attrs rc = %d", rc));
                        if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
@@ -1484,14 +1492,14 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                           it was found or because there was an error setting
                           it by handle */
                        rc = CIFSSMBSetEOF(xid, pTcon, full_path,
-                                           attrs->ia_size, FALSE,
+                                           attrs->ia_size, false,
                                           cifs_sb->local_nls,
                                           cifs_sb->mnt_cifs_flags &
                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
                        cFYI(1, ("SetEOF by path (setattrs) rc = %d", rc));
                        if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
                                __u16 netfid;
-                                int oplock = FALSE;
+                                int oplock = 0;
                                rc = SMBLegacyOpen(xid, pTcon, full_path,
                                        FILE_OPEN,
@@ -1516,14 +1524,13 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                /* Server is ok setting allocation size implicitly - no need
                   to call:
-                CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size, TRUE,
+                CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size, true,
                         cifs_sb->local_nls);
                   */
                if (rc == 0) {
-                        rc = cifs_vmtruncate(direntry->d_inode, attrs->ia_size);
+                        rc = cifs_vmtruncate(inode, attrs->ia_size);
-                        cifs_truncate_page(direntry->d_inode->i_mapping,
+                        cifs_truncate_page(inode->i_mapping, inode->i_size);
-                                           direntry->d_inode->i_size);
                } else
                        goto cifs_setattr_exit;
        }
@@ -1557,14 +1564,14 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                rc = 0;
 #ifdef CONFIG_CIFS_EXPERIMENTAL
                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
-                        rc = mode_to_acl(direntry->d_inode, full_path, mode);
+                        rc = mode_to_acl(inode, full_path, mode);
                else if ((mode & S_IWUGO) == 0) {
 #else
                if ((mode & S_IWUGO) == 0) {
 #endif
                        /* not writeable */
                        if ((cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
-                                set_dosattr = TRUE;
+                                set_dosattr = true;
                                time_buf.Attributes =
                                        cpu_to_le32(cifsInode->cifsAttrs |
                                                    ATTR_READONLY);
@@ -1574,28 +1581,24 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                        not be able to write to it - so if any write
                        bit is enabled for user or group or other we
                        need to at least try to remove r/o dos attr */
-                        set_dosattr = TRUE;
+                        set_dosattr = true;
                        time_buf.Attributes = cpu_to_le32(cifsInode->cifsAttrs &
                                            (~ATTR_READONLY));
                        /* Windows ignores set to zero */
                        if (time_buf.Attributes == 0)
                                time_buf.Attributes |= cpu_to_le32(ATTR_NORMAL);
                }
-#ifdef CONFIG_CIFS_EXPERIMENTAL
-                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
-                        mode_to_acl(direntry->d_inode, full_path, mode);
-#endif
        }
        if (attrs->ia_valid & ATTR_ATIME) {
-                set_time = TRUE;
+                set_time = true;
                time_buf.LastAccessTime =
                    cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
        } else
                time_buf.LastAccessTime = 0;
        if (attrs->ia_valid & ATTR_MTIME) {
-                set_time = TRUE;
+                set_time = true;
                time_buf.LastWriteTime =
                    cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
        } else
@@ -1606,7 +1609,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
           server times */
        if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
-                set_time = TRUE;
+                set_time = true;
                /* Although Samba throws this field away
                it may be useful to Windows - but we do
                not want to set ctime unless some other
@@ -1630,7 +1633,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                        rc = -EOPNOTSUPP;
                if (rc == -EOPNOTSUPP) {
-                        int oplock = FALSE;
+                        int oplock = 0;
                        __u16 netfid;
                        cFYI(1, ("calling SetFileInfo since SetPathInfo for "
@@ -1669,7 +1672,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
        /* do not need local check to inode_check_ok since the server does
           that */
        if (!rc)
-                rc = inode_setattr(direntry->d_inode, attrs);
+                rc = inode_setattr(inode, attrs);
 cifs_setattr_exit:
        kfree(full_path);
        FreeXid(xid);
diff --git a/fs/cifs/link.c b/fs/cifs/link.c
index d4e7ec93285f..1c2c3ce5020b 100644
--- a/fs/cifs/link.c
+++ b/fs/cifs/link.c
@@ -230,7 +230,7 @@ cifs_readlink(struct dentry *direntry, char __user *pBuffer, int buflen)
        struct inode *inode = direntry->d_inode;
        int rc = -EACCES;
        int xid;
-        int oplock = FALSE;
+        int oplock = 0;
        struct cifs_sb_info *cifs_sb;
        struct cifsTconInfo *pTcon;
        char *full_path = NULL;
diff --git a/fs/cifs/misc.c b/fs/cifs/misc.c
index 2a42d9fedbb2..1d69b8014e0b 100644
--- a/fs/cifs/misc.c
+++ b/fs/cifs/misc.c
@@ -496,7 +496,8 @@ checkSMB(struct smb_hdr *smb, __u16 mid, unsigned int length)
        }
        return 0;
 }
-int
+bool
 is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
 {
        struct smb_com_lock_req *pSMB = (struct smb_com_lock_req *)buf;
@@ -522,17 +523,17 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
                                pnotify->Action));  /* BB removeme BB */
                        /*   cifs_dump_mem("Rcvd notify Data: ",buf,
                                sizeof(struct smb_hdr)+60); */
-                        return TRUE;
+                        return true;
                }
                if (pSMBr->hdr.Status.CifsError) {
                        cFYI(1, ("notify err 0x%d",
                                pSMBr->hdr.Status.CifsError));
-                        return TRUE;
+                        return true;
                }
-                return FALSE;
+                return false;
        }
        if (pSMB->hdr.Command != SMB_COM_LOCKING_ANDX)
-                return FALSE;
+                return false;
        if (pSMB->hdr.Flags & SMBFLG_RESPONSE) {
                /* no sense logging error on invalid handle on oplock
                   break - harmless race between close request and oplock
@@ -541,21 +542,21 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
                if ((NT_STATUS_INVALID_HANDLE) ==
                   le32_to_cpu(pSMB->hdr.Status.CifsError)) {
                        cFYI(1, ("invalid handle on oplock break"));
-                        return TRUE;
+                        return true;
                } else if (ERRbadfid ==
                   le16_to_cpu(pSMB->hdr.Status.DosError.Error)) {
-                        return TRUE;
+                        return true;
                } else {
-                        return FALSE; /* on valid oplock brk we get "request" */
+                        return false; /* on valid oplock brk we get "request" */
                }
        }
        if (pSMB->hdr.WordCount != 8)
-                return FALSE;
+                return false;
        cFYI(1, ("oplock type 0x%d level 0x%d",
                 pSMB->LockType, pSMB->OplockLevel));
        if (!(pSMB->LockType & LOCKING_ANDX_OPLOCK_RELEASE))
-                return FALSE;
+                return false;
        /* look up tcon based on tid & uid */
        read_lock(&GlobalSMBSeslock);
@@ -573,11 +574,11 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
                                            ("file id match, oplock break"));
                                        pCifsInode =
                                                CIFS_I(netfile->pInode);
-                                        pCifsInode->clientCanCacheAll = FALSE;
+                                        pCifsInode->clientCanCacheAll = false;
                                        if (pSMB->OplockLevel == 0)
                                                pCifsInode->clientCanCacheRead
-                                                        = FALSE;
+                                                        = false;
-                                        pCifsInode->oplockPending = TRUE;
+                                        pCifsInode->oplockPending = true;
                                        AllocOplockQEntry(netfile->pInode,
                                                          netfile->netfid,
                                                          tcon);
@@ -585,17 +586,17 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
                                            ("about to wake up oplock thread"));
                                        if (oplockThread)
                                            wake_up_process(oplockThread);
-                                        return TRUE;
+                                        return true;
                                }
                        }
                        read_unlock(&GlobalSMBSeslock);
                        cFYI(1, ("No matching file for oplock break"));
-                        return TRUE;
+                        return true;
                }
        }
        read_unlock(&GlobalSMBSeslock);
        cFYI(1, ("Can not process oplock break for non-existent connection"));
-        return TRUE;
+        return true;
 }
 void
diff --git a/fs/cifs/netmisc.c b/fs/cifs/netmisc.c
index 3b5a5ce882b6..00f4cff400b3 100644
--- a/fs/cifs/netmisc.c
+++ b/fs/cifs/netmisc.c
@@ -132,47 +132,17 @@ static const struct smb_to_posix_error mapping_table_ERRHRD[] = {
        {0, 0}
 };
-/* if the mount helper is missing we need to reverse the 1st slash
-   from '/' to backslash in order to format the UNC properly for
-   ip address parsing and for tree connect (unless the user
-   remembered to put the UNC name in properly). Fortunately we do
-   not have to call this twice (we check for IPv4 addresses
-   first, so it is already converted by the time we
-   try IPv6 addresses */
-static int canonicalize_unc(char *cp)
-{
-        int i;
-        for (i = 0; i <= 46 /* INET6_ADDRSTRLEN */ ; i++) {
-                if (cp[i] == 0)
-                        break;
-                if (cp[i] == '\\')
-                        break;
-                if (cp[i] == '/') {
-                        cFYI(DBG2, ("change slash to \\ in malformed UNC"));
-                        cp[i] = '\\';
-                        return 1;
-                }
-        }
-        return 0;
-}
 /* Convert string containing dotted ip address to binary form */
 /* returns 0 if invalid address */
 int
-cifs_inet_pton(int address_family, char *cp, void *dst)
+cifs_inet_pton(const int address_family, const char *cp, void *dst)
 {
        int ret = 0;
        /* calculate length by finding first slash or NULL */
        if (address_family == AF_INET) {
                ret = in4_pton(cp, -1 /* len */, dst, '\\', NULL);
-                if (ret == 0) {
-                        if (canonicalize_unc(cp))
-                                ret = in4_pton(cp, -1, dst, '\\', NULL);
-                }
        } else if (address_family == AF_INET6) {
                ret = in6_pton(cp, -1 /* len */, dst , '\\', NULL);
        }
diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c
index 32b445edc882..34ec32100c72 100644
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -447,8 +447,8 @@ static int initiate_cifs_search(const int xid, struct file *file)
        if (file->private_data == NULL)
                return -ENOMEM;
        cifsFile = file->private_data;
-        cifsFile->invalidHandle = TRUE;
+        cifsFile->invalidHandle = true;
-        cifsFile->srch_inf.endOfSearch = FALSE;
+        cifsFile->srch_inf.endOfSearch = false;
        cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
        if (cifs_sb == NULL)
@@ -485,7 +485,7 @@ ffirst_retry:
                cifs_sb->mnt_cifs_flags &
                        CIFS_MOUNT_MAP_SPECIAL_CHR, CIFS_DIR_SEP(cifs_sb));
        if (rc == 0)
-                cifsFile->invalidHandle = FALSE;
+                cifsFile->invalidHandle = false;
        if ((rc == -EOPNOTSUPP) &&
                (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
                cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
@@ -670,7 +670,7 @@ static int find_cifs_entry(const int xid, struct cifsTconInfo *pTcon,
           (index_to_find < first_entry_in_buffer)) {
                /* close and restart search */
                cFYI(1, ("search backing up - close and restart search"));
-                cifsFile->invalidHandle = TRUE;
+                cifsFile->invalidHandle = true;
                CIFSFindClose(xid, pTcon, cifsFile->netfid);
                kfree(cifsFile->search_resume_name);
                cifsFile->search_resume_name = NULL;
@@ -692,7 +692,7 @@ static int find_cifs_entry(const int xid, struct cifsTconInfo *pTcon,
        }
        while ((index_to_find >= cifsFile->srch_inf.index_of_last_entry) &&
-              (rc == 0) && (cifsFile->srch_inf.endOfSearch == FALSE)) {
+              (rc == 0) && !cifsFile->srch_inf.endOfSearch) {
                cFYI(1, ("calling findnext2"));
                rc = CIFSFindNext(xid, pTcon, cifsFile->netfid,
                                  &cifsFile->srch_inf);
@@ -1038,7 +1038,7 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
                                break;
                        }
                } /* else {
-                        cifsFile->invalidHandle = TRUE;
+                        cifsFile->invalidHandle = true;
                        CIFSFindClose(xid, pTcon, cifsFile->netfid);
                }
                kfree(cifsFile->search_resume_name);
diff --git a/fs/cifs/smbencrypt.c b/fs/cifs/smbencrypt.c
index 58bbfd992cc0..ff3232fa1015 100644
--- a/fs/cifs/smbencrypt.c
+++ b/fs/cifs/smbencrypt.c
@@ -35,11 +35,11 @@
 #include "cifs_debug.h"
 #include "cifsencrypt.h"
-#ifndef FALSE
+#ifndef false
-#define FALSE 0
+#define false 0
 #endif
-#ifndef TRUE
+#ifndef true
-#define TRUE 1
+#define true 1
 #endif
 /* following came from the other byteorder.h to avoid include conflicts */
diff --git a/fs/cifs/xattr.c b/fs/cifs/xattr.c
index 8cd6a445b017..e9527eedc639 100644
--- a/fs/cifs/xattr.c
+++ b/fs/cifs/xattr.c
@@ -264,7 +264,7 @@ ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,
 #ifdef CONFIG_CIFS_EXPERIMENTAL
                else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
                        __u16 fid;
-                        int oplock = FALSE;
+                        int oplock = 0;
                        struct cifs_ntsd *pacl = NULL;
                        __u32 buflen = 0;
                        if (experimEnabled)
author	David S. Miller <davem@davemloft.net>	2008-05-15 03:34:44 -0400
committer	David S. Miller <davem@davemloft.net>	2008-05-15 03:34:44 -0400
commit	63fe46da9c380b3f2bbdf3765044649517cc717c (patch)
tree	9478c1aca1d692b408955aea20c9cd9a37e589c0 /fs/cifs
parent	99dd1a2b8347ac2ae802300b7862f6f7bcf17139 (diff)
parent	066b2118976e6e7cc50eed39e2747c75343a23c4 (diff)