10 files changed, 80 insertions, 105 deletions

diff --git a/fs/cifs/asn1.c b/fs/cifs/asn1.c
index f50a88d58f78..2a01f3ef96a0 100644
--- a/fs/cifs/asn1.c
+++ b/fs/cifs/asn1.c
@@ -385,10 +385,9 @@ asn1_oid_decode(struct asn1_ctx *ctx,
         unsigned long *optr;
 
         size = eoc - ctx->pointer + 1;
-        *oid = kmalloc(size * sizeof (unsigned long), GFP_ATOMIC);
-        if (*oid == NULL) {
+        *oid = kmalloc(size * sizeof(unsigned long), GFP_ATOMIC);
+        if (*oid == NULL)
                 return 0;
-        }
 
         optr = *oid;
 
@@ -581,9 +580,8 @@ decode_negTokenInit(unsigned char *security_blob, int length,
                         return 0;
                 } else if ((cls != ASN1_UNI) || (con != ASN1_CON)
                            || (tag != ASN1_SEQ)) {
-                        cFYI(1,
-                             ("Exit 6 cls = %d con = %d tag = %d end = %p (%d)",
-                              cls, con, tag, end, *end));
+                        cFYI(1, ("cls = %d con = %d tag = %d end = %p (%d)",
+                                cls, con, tag, end, *end));
                 }
 
                 if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 2493cc4f9e7f..c7c3521aa7cd 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -240,9 +240,9 @@ static int cifs_permission(struct inode *inode, int mask, struct nameidata *nd)
 
         cifs_sb = CIFS_SB(inode->i_sb);
 
-        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
+        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
                 return 0;
-        } else /* file mode might have been restricted at mount time
+        else /* file mode might have been restricted at mount time
                 on the client (above and beyond ACL on servers) for
                 servers which do not support setting and viewing mode bits,
                 so allowing client to check permissions is useful */
@@ -716,7 +716,7 @@ static int
 cifs_init_inodecache(void)
 {
         cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
-                                              sizeof (struct cifsInodeInfo),
+                                              sizeof(struct cifsInodeInfo),
                                               0, (SLAB_RECLAIM_ACCOUNT|
                                                 SLAB_MEM_SPREAD),
                                               cifs_init_once);
@@ -816,8 +816,8 @@ static int
 cifs_init_mids(void)
 {
         cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
-                                sizeof (struct mid_q_entry), 0,
-                                SLAB_HWCACHE_ALIGN, NULL);
+                                            sizeof(struct mid_q_entry), 0,
+                                            SLAB_HWCACHE_ALIGN, NULL);
         if (cifs_mid_cachep == NULL)
                 return -ENOMEM;
 
@@ -829,8 +829,8 @@ cifs_init_mids(void)
         }
 
         cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
-                                sizeof (struct oplock_q_entry), 0,
-                                SLAB_HWCACHE_ALIGN, NULL);
+                                        sizeof(struct oplock_q_entry), 0,
+                                        SLAB_HWCACHE_ALIGN, NULL);
         if (cifs_oplock_cachep == NULL) {
                 mempool_destroy(cifs_mid_poolp);
                 kmem_cache_destroy(cifs_mid_cachep);
@@ -882,7 +882,8 @@ static int cifs_oplock_thread(void *dummyarg)
                                 the call */
                                 /* mutex_lock(&inode->i_mutex);*/
                                 if (S_ISREG(inode->i_mode)) {
-                                        rc = filemap_fdatawrite(inode->i_mapping);
+                                        rc =
+                                           filemap_fdatawrite(inode->i_mapping);
                                         if (CIFS_I(inode)->clientCanCacheRead
                                                                          == 0) {
                                                 filemap_fdatawait(inode->i_mapping);
@@ -907,8 +908,7 @@ static int cifs_oplock_thread(void *dummyarg)
                                             0 /* len */ , 0 /* offset */, 0,
                                             0, LOCKING_ANDX_OPLOCK_RELEASE,
                                             0 /* wait flag */);
-                                        cFYI(1, 
-                                              ("Oplock release rc = %d ", rc));
+                                        cFYI(1, ("Oplock release rc = %d", rc));
                                 }
                         } else
                                 spin_unlock(&GlobalMid_Lock);
diff --git a/fs/cifs/cifsfs.h b/fs/cifs/cifsfs.h
index a20de77a3856..dd64cecd923b 100644
--- a/fs/cifs/cifsfs.h
+++ b/fs/cifs/cifsfs.h
@@ -99,7 +99,7 @@ extern int 	cifs_setxattr(struct dentry *, const char *, const void *,
                         size_t, int);
 extern ssize_t  cifs_getxattr(struct dentry *, const char *, void *, size_t);
 extern ssize_t  cifs_listxattr(struct dentry *, char *, size_t);
-extern int cifs_ioctl (struct inode *inode, struct file *filep,
+extern int cifs_ioctl(struct inode *inode, struct file *filep,
                        unsigned int command, unsigned long arg);
 #define CIFS_VERSION   "1.50"
 #endif                          /* _CIFSFS_H */
diff --git a/fs/cifs/cifspdu.h b/fs/cifs/cifspdu.h
index 6a2056e58ceb..e975ce46115d 100644
--- a/fs/cifs/cifspdu.h
+++ b/fs/cifs/cifspdu.h
@@ -360,10 +360,10 @@ struct smb_hdr {
         __u8 WordCount;
 } __attribute__((packed));
 /* given a pointer to an smb_hdr retrieve the value of byte count */
-#define BCC(smb_var) ( *(__u16 *)((char *)smb_var + sizeof(struct smb_hdr) + (2* smb_var->WordCount) ) )
-#define BCC_LE(smb_var) ( *(__le16 *)((char *)smb_var + sizeof(struct smb_hdr) + (2* smb_var->WordCount) ) )
+#define BCC(smb_var) ( *(__u16 *)((char *)smb_var + sizeof(struct smb_hdr) + (2 * smb_var->WordCount)))
+#define BCC_LE(smb_var) ( *(__le16 *)((char *)smb_var + sizeof(struct smb_hdr) + (2 * smb_var->WordCount)))
 /* given a pointer to an smb_hdr retrieve the pointer to the byte area */
-#define pByteArea(smb_var) ((unsigned char *)smb_var + sizeof(struct smb_hdr) + (2* smb_var->WordCount) + 2 )
+#define pByteArea(smb_var) ((unsigned char *)smb_var + sizeof(struct smb_hdr) + (2 * smb_var->WordCount) + 2)
 
 /*
  * Computer Name Length (since Netbios name was length 16 with last byte 0x20)
diff --git a/fs/cifs/cifsproto.h b/fs/cifs/cifsproto.h
index 04a69dafedba..4ffae9d92910 100644
--- a/fs/cifs/cifsproto.h
+++ b/fs/cifs/cifsproto.h
@@ -304,7 +304,7 @@ extern int cifs_calculate_mac_key(struct mac_key *key, const char *rn,
                                  const char *pass);
 extern int CalcNTLMv2_partial_mac_key(struct cifsSesInfo *,
                         const struct nls_table *);
-extern void CalcNTLMv2_response(const struct cifsSesInfo *, char * );
+extern void CalcNTLMv2_response(const struct cifsSesInfo *, char *);
 extern void setup_ntlmv2_rsp(struct cifsSesInfo *, char *,
                              const struct nls_table *);
 #ifdef CONFIG_CIFS_WEAK_PW_HASH
diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c
index 4795143ff521..bb30455caabc 100644
--- a/fs/cifs/cifssmb.c
+++ b/fs/cifs/cifssmb.c
@@ -94,9 +94,8 @@ static void mark_open_files_invalid(struct cifsTconInfo *pTcon)
         write_lock(&GlobalSMBSeslock);
         list_for_each_safe(tmp, tmp1, &pTcon->openFileList) {
                 open_file = list_entry(tmp, struct cifsFileInfo, tlist);
-                if (open_file) {
+                if (open_file)
                         open_file->invalidHandle = TRUE;
-                }
         }
         write_unlock(&GlobalSMBSeslock);
         /* BB Add call to invalidate_inodes(sb) for all superblocks mounted
@@ -1112,7 +1111,7 @@ PsxCreat:
                 }
                 memcpy((char *) pRetData,
                         (char *)psx_rsp + sizeof(OPEN_PSX_RSP),
-                        sizeof (FILE_UNIX_BASIC_INFO));
+                        sizeof(FILE_UNIX_BASIC_INFO));
         }
 
 psx_create_err:
@@ -1193,9 +1192,9 @@ OldOpenRetry:
         }
         if (*pOplock & REQ_OPLOCK)
                 pSMB->OpenFlags = cpu_to_le16(REQ_OPLOCK);
-        else if (*pOplock & REQ_BATCHOPLOCK) {
+        else if (*pOplock & REQ_BATCHOPLOCK)
                 pSMB->OpenFlags = cpu_to_le16(REQ_BATCHOPLOCK);
-        }
+
         pSMB->OpenFlags |= cpu_to_le16(REQ_MORE_INFO);
         /* BB fixme add conversion for access_flags to bits 0 - 2 of mode */
         /* 0 = read
@@ -1310,9 +1309,8 @@ openRetry:
         }
         if (*pOplock & REQ_OPLOCK)
                 pSMB->OpenFlags = cpu_to_le32(REQ_OPLOCK);
-        else if (*pOplock & REQ_BATCHOPLOCK) {
+        else if (*pOplock & REQ_BATCHOPLOCK)
                 pSMB->OpenFlags = cpu_to_le32(REQ_BATCHOPLOCK);
-        }
         pSMB->DesiredAccess = cpu_to_le32(access_flags);
         pSMB->AllocationSize = 0;
         /* set file as system file if special file such
@@ -1446,11 +1444,11 @@ CIFSSMBRead(const int xid, struct cifsTconInfo *tcon, const int netfid,
                         *nbytes = 0;
                 } else {
                         pReadData = (char *) (&pSMBr->hdr.Protocol) +
-                            le16_to_cpu(pSMBr->DataOffset);
-/*                      if (rc = copy_to_user(buf, pReadData, data_length)) {
+                                        le16_to_cpu(pSMBr->DataOffset);
+/*                      if (rc = copy_to_user(buf, pReadData, data_length)) {
                                 cERROR(1,("Faulting on read rc = %d",rc));
                                 rc = -EFAULT;
-                        }*/ /* can not use copy_to_user when using page cache*/
+                        }*/ /* can not use copy_to_user when using page cache*/
                         if (*buf)
                                 memcpy(*buf, pReadData, data_length);
                 }
@@ -2538,7 +2536,7 @@ validate_ntransact(char *buf, char **ppparm, char **ppdata,
                 cFYI(1, ("data starts after end of smb"));
                 return -EINVAL;
         } else if (data_count + *ppdata > end_of_smb) {
-                cFYI(1,("data %p + count %d (%p) ends after end of smb %p start %p",
+                cFYI(1, ("data %p + count %d (%p) ends after end of smb %p start %p",
                         *ppdata, data_count, (data_count + *ppdata),
                         end_of_smb, pSMBr));
                 return -EINVAL;
@@ -2615,7 +2613,7 @@ CIFSSMBQueryReparseLinkInfo(const int xid, struct cifsTconInfo *tcon,
                                         reparse_buf->TargetNameOffset +
                                         reparse_buf->TargetNameLen) >
                                                 end_of_smb) {
-                                        cFYI(1,("reparse buf goes beyond SMB"));
+                                        cFYI(1, ("reparse buf beyond SMB"));
                                         rc = -EIO;
                                         goto qreparse_out;
                                 }
@@ -3883,12 +3881,10 @@ getDFSRetry:
         pSMB->hdr.Mid = GetNextMid(ses->server);
         pSMB->hdr.Tid = ses->ipc_tid;
         pSMB->hdr.Uid = ses->Suid;
-        if (ses->capabilities & CAP_STATUS32) {
+        if (ses->capabilities & CAP_STATUS32)
                 pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
-        }
-        if (ses->capabilities & CAP_DFS) {
+        if (ses->capabilities & CAP_DFS)
                 pSMB->hdr.Flags2 |= SMBFLG2_DFS;
-        }
 
         if (ses->capabilities & CAP_UNICODE) {
                 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
@@ -4265,7 +4261,7 @@ QFSAttributeRetry:
                              *) (((char *) &pSMBr->hdr.Protocol) +
                                  data_offset);
                         memcpy(&tcon->fsAttrInfo, response_data,
-                               sizeof (FILE_SYSTEM_ATTRIBUTE_INFO));
+                               sizeof(FILE_SYSTEM_ATTRIBUTE_INFO));
                 }
         }
         cifs_buf_release(pSMB);
@@ -4334,7 +4330,7 @@ QFSDeviceRetry:
                                 (((char *) &pSMBr->hdr.Protocol) +
                                  data_offset);
                         memcpy(&tcon->fsDevInfo, response_data,
-                               sizeof (FILE_SYSTEM_DEVICE_INFO));
+                               sizeof(FILE_SYSTEM_DEVICE_INFO));
                 }
         }
         cifs_buf_release(pSMB);
@@ -4402,7 +4398,7 @@ QFSUnixRetry:
                              *) (((char *) &pSMBr->hdr.Protocol) +
                                  data_offset);
                         memcpy(&tcon->fsUnixInfo, response_data,
-                               sizeof (FILE_SYSTEM_UNIX_INFO));
+                               sizeof(FILE_SYSTEM_UNIX_INFO));
                 }
         }
         cifs_buf_release(pSMB);
@@ -4612,7 +4608,7 @@ SetEOFRetry:
                 strncpy(pSMB->FileName, fileName, name_len);
         }
         params = 6 + name_len;
-        data_count = sizeof (struct file_end_of_file_info);
+        data_count = sizeof(struct file_end_of_file_info);
         pSMB->MaxParameterCount = cpu_to_le16(2);
         pSMB->MaxDataCount = cpu_to_le16(4100);
         pSMB->MaxSetupCount = 0;
@@ -4800,7 +4796,7 @@ CIFSSMBSetFileTimes(const int xid, struct cifsTconInfo *tcon,
 
         data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
 
-        count = sizeof (FILE_BASIC_INFO);
+        count = sizeof(FILE_BASIC_INFO);
         pSMB->MaxParameterCount = cpu_to_le16(2);
         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
         pSMB->SetupCount = 1;
@@ -4871,7 +4867,7 @@ SetTimesRetry:
         }
 
         params = 6 + name_len;
-        count = sizeof (FILE_BASIC_INFO);
+        count = sizeof(FILE_BASIC_INFO);
         pSMB->MaxParameterCount = cpu_to_le16(2);
         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
         pSMB->MaxSetupCount = 0;
@@ -4900,7 +4896,7 @@ SetTimesRetry:
                 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
         pSMB->Reserved4 = 0;
         pSMB->hdr.smb_buf_length += byte_count;
-        memcpy(data_offset, data, sizeof (FILE_BASIC_INFO));
+        memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
         pSMB->ByteCount = cpu_to_le16(byte_count);
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
@@ -5003,7 +4999,7 @@ setPermsRetry:
         }
 
         params = 6 + name_len;
-        count = sizeof (FILE_UNIX_BASIC_INFO);
+        count = sizeof(FILE_UNIX_BASIC_INFO);
         pSMB->MaxParameterCount = cpu_to_le16(2);
         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
         pSMB->MaxSetupCount = 0;
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index 8af993f8d0cc..3dd2d23e0649 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -124,7 +124,7 @@ cifs_reconnect(struct TCP_Server_Info *server)
         struct mid_q_entry *mid_entry;
 
         spin_lock(&GlobalMid_Lock);
-        if ( kthread_should_stop() ) {
+        if (kthread_should_stop()) {
                 /* the demux thread will exit normally
                 next time through the loop */
                 spin_unlock(&GlobalMid_Lock);
@@ -151,9 +151,8 @@ cifs_reconnect(struct TCP_Server_Info *server)
         }
         list_for_each(tmp, &GlobalTreeConnectionList) {
                 tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
-                if ((tcon) && (tcon->ses) && (tcon->ses->server == server)) {
+                if ((tcon) && (tcon->ses) && (tcon->ses->server == server))
                         tcon->tidStatus = CifsNeedReconnect;
-                }
         }
         read_unlock(&GlobalSMBSeslock);
         /* do not want to be sending data on a socket we are freeing */
@@ -187,7 +186,7 @@ cifs_reconnect(struct TCP_Server_Info *server)
         spin_unlock(&GlobalMid_Lock);
         up(&server->tcpSem);
 
-        while ( (!kthread_should_stop()) && (server->tcpStatus != CifsGood)) {
+        while ((!kthread_should_stop()) && (server->tcpStatus != CifsGood)) {
                 try_to_freeze();
                 if (server->protocolType == IPV6) {
                         rc = ipv6_connect(&server->addr.sockAddr6,
@@ -204,7 +203,7 @@ cifs_reconnect(struct TCP_Server_Info *server)
                 } else {
                         atomic_inc(&tcpSesReconnectCount);
                         spin_lock(&GlobalMid_Lock);
-                        if ( !kthread_should_stop() )
+                        if (!kthread_should_stop())
                                 server->tcpStatus = CifsGood;
                         server->sequence_number = 0;
                         spin_unlock(&GlobalMid_Lock);
@@ -358,11 +357,9 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
         length = tcpSesAllocCount.counter;
         write_unlock(&GlobalSMBSeslock);
         complete(&cifsd_complete);
-        if (length  > 1) {
-                mempool_resize(cifs_req_poolp,
-                        length + cifs_min_rcv,
-                        GFP_KERNEL);
-        }
+        if (length  > 1)
+                mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
+                                GFP_KERNEL);
 
         set_freezable();
         while (!kthread_should_stop()) {
@@ -378,7 +375,7 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
                         }
                 } else if (isLargeBuf) {
                         /* we are reusing a dirty large buf, clear its start */
-                        memset(bigbuf, 0, sizeof (struct smb_hdr));
+                        memset(bigbuf, 0, sizeof(struct smb_hdr));
                 }
 
                 if (smallbuf == NULL) {
@@ -391,7 +388,7 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
                         }
                         /* beginning of smb buffer is cleared in our buf_get */
                 } else /* if existing small buf clear beginning */
-                        memset(smallbuf, 0, sizeof (struct smb_hdr));
+                        memset(smallbuf, 0, sizeof(struct smb_hdr));
 
                 isLargeBuf = FALSE;
                 isMultiRsp = FALSE;
@@ -406,7 +403,7 @@ incomplete_rcv:
                     kernel_recvmsg(csocket, &smb_msg,
                                 &iov, 1, pdu_length, 0 /* BB other flags? */);
 
-                if ( kthread_should_stop() ) {
+                if (kthread_should_stop()) {
                         break;
                 } else if (server->tcpStatus == CifsNeedReconnect) {
                         cFYI(1, ("Reconnect after server stopped responding"));
@@ -505,7 +502,7 @@ incomplete_rcv:
 
                 /* else we have an SMB response */
                 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
-                            (pdu_length < sizeof (struct smb_hdr) - 1 - 4)) {
+                            (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
                         cERROR(1, ("Invalid size SMB length %d pdu_length %d",
                                         length, pdu_length+4));
                         cifs_reconnect(server);
@@ -529,7 +526,7 @@ incomplete_rcv:
                      total_read += length) {
                         length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
                                                 pdu_length - total_read, 0);
-                        if ( kthread_should_stop() ||
+                        if (kthread_should_stop() ||
                             (length == -EINTR)) {
                                 /* then will exit */
                                 reconnect = 2;
@@ -632,9 +629,9 @@ multi_t2_fnd:
                         /* Was previous buf put in mpx struct for multi-rsp? */
                         if (!isMultiRsp) {
                                 /* smb buffer will be freed by user thread */
-                                if (isLargeBuf) {
+                                if (isLargeBuf)
                                         bigbuf = NULL;
-                                } else
+                                else
                                         smallbuf = NULL;
                         }
                         wake_up_process(task_to_wake);
@@ -703,9 +700,8 @@ multi_t2_fnd:
                 list_for_each(tmp, &GlobalSMBSessionList) {
                         ses = list_entry(tmp, struct cifsSesInfo,
                                          cifsSessionList);
-                        if (ses->server == server) {
+                        if (ses->server == server)
                                 ses->status = CifsExiting;
-                        }
                 }
 
                 spin_lock(&GlobalMid_Lock);
@@ -715,9 +711,8 @@ multi_t2_fnd:
                                 cFYI(1, ("Clearing Mid 0x%x - waking up ",
                                          mid_entry->mid));
                                 task_to_wake = mid_entry->tsk;
-                                if (task_to_wake) {
+                                if (task_to_wake)
                                         wake_up_process(task_to_wake);
-                                }
                         }
                 }
                 spin_unlock(&GlobalMid_Lock);
@@ -750,18 +745,15 @@ multi_t2_fnd:
         list_for_each(tmp, &GlobalSMBSessionList) {
                 ses = list_entry(tmp, struct cifsSesInfo,
                                 cifsSessionList);
-                if (ses->server == server) {
+                if (ses->server == server)
                         ses->server = NULL;
-                }
         }
         write_unlock(&GlobalSMBSeslock);
 
         kfree(server);
-        if (length  > 0) {
-                mempool_resize(cifs_req_poolp,
-                        length + cifs_min_rcv,
-                        GFP_KERNEL);
-        }
+        if (length  > 0)
+                mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
+                                GFP_KERNEL);
 
         return 0;
 }
diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c
index 916df9431336..b5a9bfff5e50 100644
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -1067,7 +1067,7 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
                 for (i = 0; (i < num_to_fill) && (rc == 0); i++) {
                         if (current_entry == NULL) {
                                 /* evaluate whether this case is an error */
-                                cERROR(1,("past end of SMB num to fill %d i %d",
+                                cERROR(1, ("past SMB end,  num to fill %d i %d",
                                           num_to_fill, i));
                                 break;
                         }
diff --git a/fs/cifs/sess.c b/fs/cifs/sess.c
index 892be9b4d1f3..78797c0e076c 100644
--- a/fs/cifs/sess.c
+++ b/fs/cifs/sess.c
@@ -67,9 +67,8 @@ static __u32 cifs_ssetup_hdr(struct cifsSesInfo *ses, SESSION_SETUP_ANDX *pSMB)
                 pSMB->req.hdr.Flags2 |= SMBFLG2_DFS;
                 capabilities |= CAP_DFS;
         }
-        if (ses->capabilities & CAP_UNIX) {
+        if (ses->capabilities & CAP_UNIX)
                 capabilities |= CAP_UNIX;
-        }
 
         /* BB check whether to init vcnum BB */
         return capabilities;
@@ -203,14 +202,11 @@ static int decode_unicode_ssetup(char **pbcc_area, int bleft,
         if (len >= words_left)
                 return rc;
 
-        if (ses->serverOS)
-                kfree(ses->serverOS);
+        kfree(ses->serverOS);
         /* UTF-8 string will not grow more than four times as big as UCS-16 */
         ses->serverOS = kzalloc(4 * len, GFP_KERNEL);
-        if (ses->serverOS != NULL) {
-                cifs_strfromUCS_le(ses->serverOS, (__le16 *)data, len,
-                                   nls_cp);
-        }
+        if (ses->serverOS != NULL)
+                cifs_strfromUCS_le(ses->serverOS, (__le16 *)data, len, nls_cp);
         data += 2 * (len + 1);
         words_left -= len + 1;
 
@@ -220,8 +216,7 @@ static int decode_unicode_ssetup(char **pbcc_area, int bleft,
         if (len >= words_left)
                 return rc;
 
-        if (ses->serverNOS)
-                kfree(ses->serverNOS);
+        kfree(ses->serverNOS);
         ses->serverNOS = kzalloc(4 * len, GFP_KERNEL); /* BB this is wrong length FIXME BB */
         if (ses->serverNOS != NULL) {
                 cifs_strfromUCS_le(ses->serverNOS, (__le16 *)data, len,
@@ -240,8 +235,7 @@ static int decode_unicode_ssetup(char **pbcc_area, int bleft,
         if (len > words_left)
                 return rc;
 
-        if (ses->serverDomain)
-                kfree(ses->serverDomain);
+        kfree(ses->serverDomain);
         ses->serverDomain = kzalloc(2 * (len + 1), GFP_KERNEL); /* BB FIXME wrong length */
         if (ses->serverDomain != NULL) {
                 cifs_strfromUCS_le(ses->serverDomain, (__le16 *)data, len,
@@ -271,8 +265,7 @@ static int decode_ascii_ssetup(char **pbcc_area, int bleft,
         if (len >= bleft)
                 return rc;
 
-        if (ses->serverOS)
-                kfree(ses->serverOS);
+        kfree(ses->serverOS);
 
         ses->serverOS = kzalloc(len + 1, GFP_KERNEL);
         if (ses->serverOS)
@@ -289,8 +282,7 @@ static int decode_ascii_ssetup(char **pbcc_area, int bleft,
         if (len >= bleft)
                 return rc;
 
-        if (ses->serverNOS)
-                kfree(ses->serverNOS);
+        kfree(ses->serverNOS);
 
         ses->serverNOS = kzalloc(len + 1, GFP_KERNEL);
         if (ses->serverNOS)
@@ -479,7 +471,8 @@ CIFS_SessSetup(unsigned int xid, struct cifsSesInfo *ses, int first_time,
                 if (ses->capabilities & CAP_UNICODE) {
                         if (iov[0].iov_len % 2) {
                                 *bcc_ptr = 0;
-                        }       bcc_ptr++;
+                                bcc_ptr++;
+                        }
                         unicode_ssetup_strings(&bcc_ptr, ses, nls_cp);
                 } else
                         ascii_ssetup_strings(&bcc_ptr, ses, nls_cp);
diff --git a/fs/cifs/transport.c b/fs/cifs/transport.c
index 746bc9405db1..6684926bf3d2 100644
--- a/fs/cifs/transport.c
+++ b/fs/cifs/transport.c
@@ -55,7 +55,7 @@ AllocMidQEntry(const struct smb_hdr *smb_buffer, struct cifsSesInfo *ses)
         if (temp == NULL)
                 return temp;
         else {
-                memset(temp, 0, sizeof (struct mid_q_entry));
+                memset(temp, 0, sizeof(struct mid_q_entry));
                 temp->mid = smb_buffer->Mid;    /* always LE */
                 temp->pid = current->pid;
                 temp->command = smb_buffer->Command;
@@ -158,7 +158,7 @@ smb_send(struct socket *ssocket, struct smb_hdr *smb_buffer,
         iov.iov_len = len;
 
         smb_msg.msg_name = sin;
-        smb_msg.msg_namelen = sizeof (struct sockaddr);
+        smb_msg.msg_namelen = sizeof(struct sockaddr);
         smb_msg.msg_control = NULL;
         smb_msg.msg_controllen = 0;
         smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL; /* BB add more flags?*/
@@ -228,7 +228,7 @@ smb_send2(struct socket *ssocket, struct kvec *iov, int n_vec,
                 return -ENOTSOCK; /* BB eventually add reconnect code here */
 
         smb_msg.msg_name = sin;
-        smb_msg.msg_namelen = sizeof (struct sockaddr);
+        smb_msg.msg_namelen = sizeof(struct sockaddr);
         smb_msg.msg_control = NULL;
         smb_msg.msg_controllen = 0;
         smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL; /* BB add more flags?*/
@@ -363,9 +363,8 @@ static int allocate_mid(struct cifsSesInfo *ses, struct smb_hdr *in_buf,
                 } /* else ok - we are setting up session */
         }
         *ppmidQ = AllocMidQEntry(in_buf, ses);
-        if (*ppmidQ == NULL) {
+        if (*ppmidQ == NULL)
                 return -ENOMEM;
-        }
         return 0;
 }
 
@@ -572,9 +571,8 @@ SendReceive2(const unsigned int xid, struct cifsSesInfo *ses,
                         rc = map_smb_to_linux_error(midQ->resp_buf);
 
                         /* convert ByteCount if necessary */
-                        if (receive_len >=
-                            sizeof (struct smb_hdr) -
-                            4 /* do not count RFC1001 header */  +
+                        if (receive_len >= sizeof(struct smb_hdr) - 4
+                            /* do not count RFC1001 header */  +
                             (2 * midQ->resp_buf->WordCount) + 2 /* bcc */ )
                                 BCC(midQ->resp_buf) =
                                         le16_to_cpu(BCC_LE(midQ->resp_buf));
@@ -752,9 +750,8 @@ SendReceive(const unsigned int xid, struct cifsSesInfo *ses,
                         rc = map_smb_to_linux_error(out_buf);
 
                         /* convert ByteCount if necessary */
-                        if (receive_len >=
-                            sizeof (struct smb_hdr) -
-                            4 /* do not count RFC1001 header */  +
+                        if (receive_len >= sizeof(struct smb_hdr) - 4
+                            /* do not count RFC1001 header */  +
                             (2 * out_buf->WordCount) + 2 /* bcc */ )
                                 BCC(out_buf) = le16_to_cpu(BCC_LE(out_buf));
                 } else {
@@ -996,9 +993,8 @@ SendReceiveBlockingLock(const unsigned int xid, struct cifsTconInfo *tcon,
                         rc = map_smb_to_linux_error(out_buf);
 
                         /* convert ByteCount if necessary */
-                        if (receive_len >=
-                            sizeof (struct smb_hdr) -
-                            4 /* do not count RFC1001 header */  +
+                        if (receive_len >= sizeof(struct smb_hdr) - 4
+                            /* do not count RFC1001 header */  +
                             (2 * out_buf->WordCount) + 2 /* bcc */ )
                                 BCC(out_buf) = le16_to_cpu(BCC_LE(out_buf));
                 } else {