12 files changed, 610 insertions, 591 deletions
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index 9b95d4637fcc..ef10c3717fb5 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -16,7 +16,7 @@
 *
 *   You should have received a copy of the GNU Lesser General Public License
 *   along with this library; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 #include <linux/fs.h>
 #include <linux/net.h>
@@ -93,20 +93,20 @@ struct smb_vol {
        unsigned int wsize;
        unsigned int sockopt;
        unsigned short int port;
-        char * prepath;
+        char *prepath;
 };
-static int ipv4_connect(struct sockaddr_in *psin_server, 
+static int ipv4_connect(struct sockaddr_in *psin_server,
                        struct socket **csocket,
-                        char * netb_name,
+                        char *netb_name,
-                        char * server_netb_name);
+                        char *server_netb_name);
-static int ipv6_connect(struct sockaddr_in6 *psin_server, 
+static int ipv6_connect(struct sockaddr_in6 *psin_server,
                        struct socket **csocket);
-        /* 
+        /*
         * cifs tcp session reconnection
-         * 
+         *
         * mark tcp session as reconnecting so temporarily locked
         * mark all smb sessions as reconnecting for tcp session
         * reconnect tcp session
@@ -120,11 +120,11 @@ cifs_reconnect(struct TCP_Server_Info *server)
        struct list_head *tmp;
        struct cifsSesInfo *ses;
        struct cifsTconInfo *tcon;
-        struct mid_q_entry * mid_entry;
+        struct mid_q_entry *mid_entry;
        
        spin_lock(&GlobalMid_Lock);
-        if( kthread_should_stop() ) {
+        if ( kthread_should_stop() ) {
-                /* the demux thread will exit normally 
+                /* the demux thread will exit normally
                next time through the loop */
                spin_unlock(&GlobalMid_Lock);
                return rc;
@@ -150,18 +150,18 @@ 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 */
-        down(&server->tcpSem); 
+        down(&server->tcpSem);
-        if(server->ssocket) {
+        if (server->ssocket) {
                cFYI(1, ("State: 0x%x Flags: 0x%lx", server->ssocket->state,
                        server->ssocket->flags));
-                server->ssocket->ops->shutdown(server->ssocket,SEND_SHUTDOWN);
+                server->ssocket->ops->shutdown(server->ssocket, SEND_SHUTDOWN);
-                cFYI(1, ("Post shutdown state: 0x%x Flags: 0x%lx", 
+                cFYI(1, ("Post shutdown state: 0x%x Flags: 0x%lx",
                        server->ssocket->state,
                        server->ssocket->flags));
                sock_release(server->ssocket);
@@ -173,8 +173,8 @@ cifs_reconnect(struct TCP_Server_Info *server)
                mid_entry = list_entry(tmp, struct
                                        mid_q_entry,
                                        qhead);
-                if(mid_entry) {
+                if (mid_entry) {
-                        if(mid_entry->midState == MID_REQUEST_SUBMITTED) {
+                        if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
                                /* Mark other intransit requests as needing
                                   retry so we do not immediately mark the
                                   session bad again (ie after we reconnect
@@ -184,29 +184,29 @@ cifs_reconnect(struct TCP_Server_Info *server)
                }
        }
        spin_unlock(&GlobalMid_Lock);
-        up(&server->tcpSem); 
+        up(&server->tcpSem);
-        while ( (!kthread_should_stop()) && (server->tcpStatus != CifsGood))
+        while ( (!kthread_should_stop()) && (server->tcpStatus != CifsGood)) {
-        {
                try_to_freeze();
-                if(server->protocolType == IPV6) {
+                if (server->protocolType == IPV6) {
-                        rc = ipv6_connect(&server->addr.sockAddr6,&server->ssocket);
+                        rc = ipv6_connect(&server->addr.sockAddr6,
+                                          &server->ssocket);
                } else {
-                        rc = ipv4_connect(&server->addr.sockAddr, 
+                        rc = ipv4_connect(&server->addr.sockAddr,
                                        &server->ssocket,
                                        server->workstation_RFC1001_name,
                                        server->server_RFC1001_name);
                }
-                if(rc) {
+                if (rc) {
-                        cFYI(1, ("reconnect error %d",rc));
+                        cFYI(1, ("reconnect error %d", rc));
                        msleep(3000);
                } 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);                   
+                        spin_unlock(&GlobalMid_Lock);
        /*              atomic_set(&server->inFlight,0);*/
                        wake_up(&server->response_q);
                }
@@ -214,26 +214,26 @@ cifs_reconnect(struct TCP_Server_Info *server)
        return rc;
 }
-/* 
+/*
        return codes:
                0       not a transact2, or all data present
                >0      transact2 with that much data missing
                -EINVAL = invalid transact2
 */
-static int check2ndT2(struct smb_hdr * pSMB, unsigned int maxBufSize)
+static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
 {
-        struct smb_t2_rsp * pSMBt;
+        struct smb_t2_rsp *pSMBt;
-        int total_data_size;
+        int total_data_size;
        int data_in_this_rsp;
        int remaining;
-        if(pSMB->Command != SMB_COM_TRANSACTION2)
+        if (pSMB->Command != SMB_COM_TRANSACTION2)
                return 0;
-        /* check for plausible wct, bcc and t2 data and parm sizes */
+        /* check for plausible wct, bcc and t2 data and parm sizes */
-        /* check for parm and data offset going beyond end of smb */
+        /* check for parm and data offset going beyond end of smb */
-        if(pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
+        if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
                cFYI(1, ("invalid transact2 word count"));
                return -EINVAL;
        }
@@ -245,25 +245,25 @@ static int check2ndT2(struct smb_hdr * pSMB, unsigned int maxBufSize)
        remaining = total_data_size - data_in_this_rsp;
-        if(remaining == 0)
+        if (remaining == 0)
                return 0;
-        else if(remaining < 0) {
+        else if (remaining < 0) {
                cFYI(1, ("total data %d smaller than data in frame %d",
                        total_data_size, data_in_this_rsp));
                return -EINVAL;
        } else {
                cFYI(1, ("missing %d bytes from transact2, check next response",
                        remaining));
-                if(total_data_size > maxBufSize) {
+                if (total_data_size > maxBufSize) {
-                        cERROR(1,("TotalDataSize %d is over maximum buffer %d",
+                        cERROR(1, ("TotalDataSize %d is over maximum buffer %d",
-                                total_data_size,maxBufSize));
+                                total_data_size, maxBufSize));
-                        return -EINVAL; 
+                        return -EINVAL;
                }
                return remaining;
        }
 }
-static int coalesce_t2(struct smb_hdr * psecond, struct smb_hdr *pTargetSMB)
+static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
 {
        struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
        struct smb_t2_rsp *pSMBt  = (struct smb_t2_rsp *)pTargetSMB;
@@ -271,43 +271,43 @@ static int coalesce_t2(struct smb_hdr * psecond, struct smb_hdr *pTargetSMB)
        int total_in_buf;
        int remaining;
        int total_in_buf2;
-        char * data_area_of_target;
+        char *data_area_of_target;
-        char * data_area_of_buf2;
+        char *data_area_of_buf2;
        __u16 byte_count;
        total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
-        if(total_data_size != le16_to_cpu(pSMB2->t2_rsp.TotalDataCount)) {
+        if (total_data_size != le16_to_cpu(pSMB2->t2_rsp.TotalDataCount)) {
-                cFYI(1,("total data sizes of primary and secondary t2 differ"));
+                cFYI(1, ("total data sizes of primary and secondary t2 differ"));
        }
        total_in_buf = le16_to_cpu(pSMBt->t2_rsp.DataCount);
        remaining = total_data_size - total_in_buf;
        
-        if(remaining < 0)
+        if (remaining < 0)
                return -EINVAL;
-        if(remaining == 0) /* nothing to do, ignore */
+        if (remaining == 0) /* nothing to do, ignore */
                return 0;
        
        total_in_buf2 = le16_to_cpu(pSMB2->t2_rsp.DataCount);
-        if(remaining < total_in_buf2) {
+        if (remaining < total_in_buf2) {
                cFYI(1, ("transact2 2nd response contains too much data"));
        }
        /* find end of first SMB data area */
-        data_area_of_target = (char *)&pSMBt->hdr.Protocol + 
+        data_area_of_target = (char *)&pSMBt->hdr.Protocol +
                                le16_to_cpu(pSMBt->t2_rsp.DataOffset);
        /* validate target area */
        data_area_of_buf2 = (char *) &pSMB2->hdr.Protocol +
-                                        le16_to_cpu(pSMB2->t2_rsp.DataOffset);
+                                        le16_to_cpu(pSMB2->t2_rsp.DataOffset);
        data_area_of_target += total_in_buf;
        /* copy second buffer into end of first buffer */
-        memcpy(data_area_of_target,data_area_of_buf2,total_in_buf2);
+        memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
        total_in_buf += total_in_buf2;
        pSMBt->t2_rsp.DataCount = cpu_to_le16(total_in_buf);
        byte_count = le16_to_cpu(BCC_LE(pTargetSMB));
@@ -321,7 +321,7 @@ static int coalesce_t2(struct smb_hdr * psecond, struct smb_hdr *pTargetSMB)
                
        pTargetSMB->smb_buf_length = byte_count;
-        if(remaining == total_in_buf2) {
+        if (remaining == total_in_buf2) {
                cFYI(1, ("found the last secondary response"));
                return 0; /* we are done */
        } else /* more responses to go */
@@ -352,12 +352,12 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
        current->flags |= PF_MEMALLOC;
        server->tsk = current;  /* save process info to wake at shutdown */
        cFYI(1, ("Demultiplex PID: %d", current->pid));
-        write_lock(&GlobalSMBSeslock); 
+        write_lock(&GlobalSMBSeslock);
        atomic_inc(&tcpSesAllocCount);
        length = tcpSesAllocCount.counter;
        write_unlock(&GlobalSMBSeslock);
        complete(&cifsd_complete);
-        if(length  > 1) {
+        if (length  > 1) {
                mempool_resize(cifs_req_poolp,
                        length + cifs_min_rcv,
                        GFP_KERNEL);
@@ -452,7 +452,7 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
                with the most common, zero, as regular data */
                temp = *((char *) smb_buffer);
-                /* Note that FC 1001 length is big endian on the wire, 
+                /* Note that FC 1001 length is big endian on the wire,
                but we convert it here so it is always manipulated
                as host byte order */
                pdu_length = ntohl(smb_buffer->smb_buf_length);
@@ -461,17 +461,17 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
                cFYI(1, ("rfc1002 length 0x%x", pdu_length+4));
                if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
-                        continue; 
+                        continue;
                } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
                        cFYI(1, ("Good RFC 1002 session rsp"));
                        continue;
                } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
-                        /* we get this from Windows 98 instead of 
+                        /* we get this from Windows 98 instead of
                           an error on SMB negprot response */
-                        cFYI(1,("Negative RFC1002 Session Response Error 0x%x)",
+                        cFYI(1, ("Negative RFC1002 Session Response Error 0x%x)",
                                pdu_length));
-                        if(server->tcpStatus == CifsNew) {
+                        if (server->tcpStatus == CifsNew) {
-                                /* if nack on negprot (rather than 
+                                /* if nack on negprot (rather than
                                ret of smb negprot error) reconnecting
                                not going to help, ret error to mount */
                                break;
@@ -481,10 +481,10 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
                                msleep(1000);
                                /* always try 445 first on reconnect
                                since we get NACK on some if we ever
-                                connected to port 139 (the NACK is 
+                                connected to port 139 (the NACK is
                                since we do not begin with RFC1001
                                session initialize frame) */
-                                server->addr.sockAddr.sin_port = 
+                                server->addr.sockAddr.sin_port =
                                        htons(CIFS_PORT);
                                cifs_reconnect(server);
                                csocket = server->ssocket;
@@ -492,7 +492,7 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
                                continue;
                        }
                } else if (temp != (char) 0) {
-                        cERROR(1,("Unknown RFC 1002 frame"));
+                        cERROR(1, ("Unknown RFC 1002 frame"));
                        cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
                                      length);
                        cifs_reconnect(server);
@@ -501,7 +501,7 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
                }
                /* else we have an SMB response */
-                if((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
+                if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
                            (pdu_length < sizeof (struct smb_hdr) - 1 - 4)) {
                        cERROR(1, ("Invalid size SMB length %d pdu_length %d",
                                        length, pdu_length+4));
@@ -509,12 +509,12 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
                        csocket = server->ssocket;
                        wake_up(&server->response_q);
                        continue;
-                } 
+                }
                /* else length ok */
                reconnect = 0;
-                if(pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
+                if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
                        isLargeBuf = TRUE;
                        memcpy(bigbuf, smallbuf, 4);
                        smb_buffer = bigbuf;
@@ -522,11 +522,11 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
                length = 0;
                iov.iov_base = 4 + (char *)smb_buffer;
                iov.iov_len = pdu_length;
-                for (total_read = 0; total_read < pdu_length; 
+                for (total_read = 0; total_read < pdu_length;
                     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;
@@ -534,19 +534,19 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
                        } else if (server->tcpStatus == CifsNeedReconnect) {
                                cifs_reconnect(server);
                                csocket = server->ssocket;
-                                /* Reconnect wakes up rspns q */
+                                /* Reconnect wakes up rspns q */
                                /* Now we will reread sock */
                                reconnect = 1;
                                break;
-                        } else if ((length == -ERESTARTSYS) || 
+                        } else if ((length == -ERESTARTSYS) ||
                                   (length == -EAGAIN)) {
                                msleep(1); /* minimum sleep to prevent looping,
-                                              allowing socket to clear and app 
+                                              allowing socket to clear and app
                                              threads to set tcpStatus
                                              CifsNeedReconnect if server hung*/
                                continue;
                        } else if (length <= 0) {
-                                cERROR(1,("Received no data, expecting %d",
+                                cERROR(1, ("Received no data, expecting %d",
                                              pdu_length - total_read));
                                cifs_reconnect(server);
                                csocket = server->ssocket;
@@ -554,9 +554,9 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
                                break;
                        }
                }
-                if(reconnect == 2)
+                if (reconnect == 2)
                        break;
-                else if(reconnect == 1)
+                else if (reconnect == 1)
                        continue;
                length += 4; /* account for rfc1002 hdr */
@@ -577,12 +577,12 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
                        if ((mid_entry->mid == smb_buffer->Mid) && 
                            (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
                            (mid_entry->command == smb_buffer->Command)) {
-                                if(check2ndT2(smb_buffer,server->maxBuf) > 0) {
+                                if (check2ndT2(smb_buffer,server->maxBuf) > 0) {
                                        /* We have a multipart transact2 resp */
                                        isMultiRsp = TRUE;
-                                        if(mid_entry->resp_buf) {
+                                        if (mid_entry->resp_buf) {
                                                /* merge response - fix up 1st*/
-                                                if(coalesce_t2(smb_buffer, 
+                                                if (coalesce_t2(smb_buffer, 
                                                        mid_entry->resp_buf)) {
                                                        mid_entry->multiRsp = 1;
                                                        break;
@@ -592,7 +592,7 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
                                                        goto multi_t2_fnd; 
                                                }
                                        } else {
-                                                if(!isLargeBuf) {
+                                                if (!isLargeBuf) {
                                                        cERROR(1,("1st trans2 resp needs bigbuf"));
                                        /* BB maybe we can fix this up,  switch
                                           to already allocated large buffer? */
@@ -607,7 +607,7 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
                                        break;
                                } 
                                mid_entry->resp_buf = smb_buffer;
-                                if(isLargeBuf)
+                                if (isLargeBuf)
                                        mid_entry->largeBuf = 1;
                                else
                                        mid_entry->largeBuf = 0;
@@ -627,9 +627,9 @@ multi_t2_fnd:
                spin_unlock(&GlobalMid_Lock);
                if (task_to_wake) {
                        /* Was previous buf put in mpx struct for multi-rsp? */
-                        if(!isMultiRsp) {
+                        if (!isMultiRsp) {
                                /* smb buffer will be freed by user thread */
-                                if(isLargeBuf) {
+                                if (isLargeBuf) {
                                        bigbuf = NULL;
                                } else
                                        smallbuf = NULL;
@@ -654,7 +654,7 @@ multi_t2_fnd:
        /* 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 */
-        if(atomic_read(&server->inFlight) >= cifs_max_pending)
+        if (atomic_read(&server->inFlight) >= cifs_max_pending)
                atomic_set(&server->inFlight, cifs_max_pending - 1);
        /* We do not want to set the max_pending too low or we
        could end up with the counter going negative */
@@ -668,7 +668,7 @@ multi_t2_fnd:
        /* give those requests time to exit */
        msleep(125);
        
-        if(server->ssocket) {
+        if (server->ssocket) {
                sock_release(csocket);
                server->ssocket = NULL;
        }
@@ -711,7 +711,7 @@ 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);
                                }
                        }
@@ -753,7 +753,7 @@ multi_t2_fnd:
        write_unlock(&GlobalSMBSeslock);
        kfree(server);
-        if(length  > 0) {
+        if (length  > 0) {
                mempool_resize(cifs_req_poolp,
                        length + cifs_min_rcv,
                        GFP_KERNEL);
@@ -804,8 +804,8 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
        if (!options)
                return 1;
-        if(strncmp(options,"sep=",4) == 0) {
+        if (strncmp(options,"sep=",4) == 0) {
-                if(options[4] != 0) {
+                if (options[4] != 0) {
                        separator[0] = options[4];
                        options += 5;
                } else {
@@ -828,7 +828,7 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
                                printk(KERN_WARNING
                                       "CIFS: invalid or missing username\n");
                                return 1;       /* needs_arg; */
-                        } else if(!*value) {
+                        } else if (!*value) {
                                /* null user, ie anonymous, authentication */
                                vol->nullauth = 1;
                        }
@@ -842,12 +842,12 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
                        if (!value) {
                                vol->password = NULL;
                                continue;
-                        } else if(value[0] == 0) {
+                        } else if (value[0] == 0) {
                                /* check if string begins with double comma
                                   since that would mean the password really
                                   does start with a comma, and would not
                                   indicate an empty string */
-                                if(value[1] != separator[0]) {
+                                if (value[1] != separator[0]) {
                                        vol->password = NULL;
                                        continue;
                                }
@@ -885,7 +885,7 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
                                        }
                                        temp_len++;
                                }
-                                if(value[temp_len] == 0) {
+                                if (value[temp_len] == 0) {
                                        options = NULL;
                                } else {
                                        value[temp_len] = 0;
@@ -896,13 +896,13 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
                                double commas to singles. Note that this ends up
                                allocating a few bytes too many, which is ok */
                                vol->password = kzalloc(temp_len, GFP_KERNEL);
-                                if(vol->password == NULL) {
+                                if (vol->password == NULL) {
                                        printk("CIFS: no memory for pass\n");
                                        return 1;
                                }
                                for(i=0,j=0;i<temp_len;i++,j++) {
                                        vol->password[j] = value[i];
-                                        if(value[i] == separator[0]
+                                        if (value[i] == separator[0]
                                                && value[i+1] == separator[0]) {
                                                /* skip second comma */
                                                i++;
@@ -911,7 +911,7 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
                                vol->password[j] = 0;
                        } else {
                                vol->password = kzalloc(temp_len+1, GFP_KERNEL);
-                                if(vol->password == NULL) {
+                                if (vol->password == NULL) {
                                        printk("CIFS: no memory for pass\n");
                                        return 1;
                                }
@@ -1089,7 +1089,7 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
                        }
                } else if (strnicmp(data, "netbiosname", 4) == 0) {
                        if (!value || !*value || (*value == ' ')) {
-                                cFYI(1,("invalid (empty) netbiosname specified"));
+                                cFYI(1, ("invalid (empty) netbiosname specified"));
                        } else {
                                memset(vol->source_rfc1001_name,0x20,15);
                                for(i=0;i<15;i++) {
@@ -1187,7 +1187,7 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
                        /* turn off mandatory locking in mode
                        if remote locking is turned off since the
                        local vfs will do advisory */
-                        if(vol->file_mode == (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
+                        if (vol->file_mode == (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
                                vol->file_mode = S_IALLUGO;
                } else if (strnicmp(data, "setuids", 7) == 0) {
                        vol->setuids = 1;
@@ -1257,7 +1257,7 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
                        return 1;
                }
        }
-        if(vol->UNCip == NULL)
+        if (vol->UNCip == NULL)
                vol->UNCip = &vol->UNC[2];
        return 0;
@@ -1276,7 +1276,7 @@ cifs_find_tcp_session(struct in_addr * target_ip_addr,
        list_for_each(tmp, &GlobalSMBSessionList) {
                ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
                if (ses->server) {
-                        if((target_ip_addr && 
+                        if ((target_ip_addr && 
                                (ses->server->addr.sockAddr.sin_addr.s_addr
                                  == target_ip_addr->s_addr)) || (target_ip6_addr
                                && memcmp(&ses->server->addr.sockAddr6.sin6_addr,
@@ -1319,7 +1319,7 @@ find_unc(__be32 new_target_ip_addr, char *uncName, char *userName)
        /* BB lock tcon, server and tcp session and increment use count here? */
                                        /* found a match on the TCP session */
                                        /* BB check if reconnection needed */
-                                        cFYI(1,("IP match, old UNC: %s new: %s",
+                                        cFYI(1, ("IP match, old UNC: %s new: %s",
                                              tcon->treeName, uncName));
                                        if (strncmp
                                            (tcon->treeName, uncName,
@@ -1423,7 +1423,7 @@ ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
        int connected = 0;
        __be16 orig_port = 0;
-        if(*csocket == NULL) {
+        if (*csocket == NULL) {
                rc = sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, csocket);
                if (rc < 0) {
                        cERROR(1, ("Error %d creating socket",rc));
@@ -1437,7 +1437,7 @@ ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
        }
        psin_server->sin_family = AF_INET;
-        if(psin_server->sin_port) { /* user overrode default port */
+        if (psin_server->sin_port) { /* user overrode default port */
                rc = (*csocket)->ops->connect(*csocket,
                                (struct sockaddr *) psin_server,
                                sizeof (struct sockaddr_in),0);
@@ -1445,13 +1445,13 @@ ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
                        connected = 1;
        } 
-        if(!connected) {
+        if (!connected) {
                /* save original port so we can retry user specified port  
                        later if fall back ports fail this time  */
                orig_port = psin_server->sin_port;
                /* do not retry on the same port we just failed on */
-                if(psin_server->sin_port != htons(CIFS_PORT)) {
+                if (psin_server->sin_port != htons(CIFS_PORT)) {
                        psin_server->sin_port = htons(CIFS_PORT);
                        rc = (*csocket)->ops->connect(*csocket,
@@ -1472,9 +1472,9 @@ ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
        /* give up here - unless we want to retry on different
                protocol families some day */
        if (!connected) {
-                if(orig_port)
+                if (orig_port)
                        psin_server->sin_port = orig_port;
-                cFYI(1,("Error %d connecting to server via ipv4",rc));
+                cFYI(1, ("Error %d connecting to server via ipv4",rc));
                sock_release(*csocket);
                *csocket = NULL;
                return rc;
@@ -1482,26 +1482,26 @@ ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
        /* Eventually check for other socket options to change from 
                the default. sock_setsockopt not used because it expects 
                user space buffer */
-         cFYI(1,("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",(*csocket)->sk->sk_sndbuf,
+         cFYI(1, ("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",(*csocket)->sk->sk_sndbuf,
                 (*csocket)->sk->sk_rcvbuf, (*csocket)->sk->sk_rcvtimeo));
        (*csocket)->sk->sk_rcvtimeo = 7 * HZ;
        /* make the bufsizes depend on wsize/rsize and max requests */
-        if((*csocket)->sk->sk_sndbuf < (200 * 1024))
+        if ((*csocket)->sk->sk_sndbuf < (200 * 1024))
                (*csocket)->sk->sk_sndbuf = 200 * 1024;
-        if((*csocket)->sk->sk_rcvbuf < (140 * 1024))
+        if ((*csocket)->sk->sk_rcvbuf < (140 * 1024))
                (*csocket)->sk->sk_rcvbuf = 140 * 1024;
        /* send RFC1001 sessinit */
-        if(psin_server->sin_port == htons(RFC1001_PORT)) {
+        if (psin_server->sin_port == htons(RFC1001_PORT)) {
                /* some servers require RFC1001 sessinit before sending
                negprot - BB check reconnection in case where second 
                sessinit is sent but no second negprot */
                struct rfc1002_session_packet * ses_init_buf;
                struct smb_hdr * smb_buf;
                ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet), GFP_KERNEL);
-                if(ses_init_buf) {
+                if (ses_init_buf) {
                        ses_init_buf->trailer.session_req.called_len = 32;
-                        if(target_name && (target_name[0] != 0)) {
+                        if (target_name && (target_name[0] != 0)) {
                                rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
                                        target_name, 16);
                        } else {
@@ -1512,7 +1512,7 @@ ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket,
                        ses_init_buf->trailer.session_req.calling_len = 32;
                        /* calling name ends in null (byte 16) from old smb
                        convention. */
-                        if(netbios_name && (netbios_name[0] !=0)) {
+                        if (netbios_name && (netbios_name[0] !=0)) {
                                rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
                                        netbios_name,16);
                        } else {
@@ -1551,7 +1551,7 @@ ipv6_connect(struct sockaddr_in6 *psin_server, struct socket **csocket)
        int connected = 0;
        __be16 orig_port = 0;
-        if(*csocket == NULL) {
+        if (*csocket == NULL) {
                rc = sock_create_kern(PF_INET6, SOCK_STREAM, IPPROTO_TCP, csocket);
                if (rc < 0) {
                        cERROR(1, ("Error %d creating ipv6 socket",rc));
@@ -1559,14 +1559,14 @@ ipv6_connect(struct sockaddr_in6 *psin_server, struct socket **csocket)
                        return rc;
                } else {
                /* BB other socket options to set KEEPALIVE, NODELAY? */
-                         cFYI(1,("ipv6 Socket created"));
+                         cFYI(1, ("ipv6 Socket created"));
                        (*csocket)->sk->sk_allocation = GFP_NOFS;
                }
        }
        psin_server->sin6_family = AF_INET6;
-        if(psin_server->sin6_port) { /* user overrode default port */
+        if (psin_server->sin6_port) { /* user overrode default port */
                rc = (*csocket)->ops->connect(*csocket,
                                (struct sockaddr *) psin_server,
                                sizeof (struct sockaddr_in6),0);
@@ -1574,13 +1574,13 @@ ipv6_connect(struct sockaddr_in6 *psin_server, struct socket **csocket)
                        connected = 1;
        } 
-        if(!connected) {
+        if (!connected) {
                /* save original port so we can retry user specified port  
                        later if fall back ports fail this time  */
                orig_port = psin_server->sin6_port;
                /* do not retry on the same port we just failed on */
-                if(psin_server->sin6_port != htons(CIFS_PORT)) {
+                if (psin_server->sin6_port != htons(CIFS_PORT)) {
                        psin_server->sin6_port = htons(CIFS_PORT);
                        rc = (*csocket)->ops->connect(*csocket,
@@ -1601,9 +1601,9 @@ ipv6_connect(struct sockaddr_in6 *psin_server, struct socket **csocket)
        /* give up here - unless we want to retry on different
                protocol families some day */
        if (!connected) {
-                if(orig_port)
+                if (orig_port)
                        psin_server->sin6_port = orig_port;
-                cFYI(1,("Error %d connecting to server via ipv6",rc));
+                cFYI(1, ("Error %d connecting to server via ipv6",rc));
                sock_release(*csocket);
                *csocket = NULL;
                return rc;
@@ -1631,12 +1631,12 @@ void reset_cifs_unix_caps(int xid, struct cifsTconInfo * tcon,
        __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
           
         
-        if(!CIFSSMBQFSUnixInfo(xid, tcon)) {
+        if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
                __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
                
                /* check for reconnect case in which we do not
                   want to change the mount behavior if we can avoid it */
-                if(vol_info == NULL) {
+                if (vol_info == NULL) {
                        /* turn off POSIX ACL and PATHNAMES if not set 
                           originally at mount time */
                        if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
@@ -1653,15 +1653,15 @@ void reset_cifs_unix_caps(int xid, struct cifsTconInfo * tcon,
                if (vol_info && vol_info->no_psx_acl)
                        cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
                else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
-                        cFYI(1,("negotiated posix acl support"));
+                        cFYI(1, ("negotiated posix acl support"));
-                        if(sb)
+                        if (sb)
                                sb->s_flags |= MS_POSIXACL;
                }
                if (vol_info && vol_info->posix_paths == 0)
                        cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
                else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
-                        cFYI(1,("negotiate posix pathnames"));
+                        cFYI(1, ("negotiate posix pathnames"));
                        if (sb)
                                CIFS_SB(sb)->mnt_cifs_flags |= 
                                        CIFS_MOUNT_POSIX_PATHS;
@@ -1677,31 +1677,31 @@ void reset_cifs_unix_caps(int xid, struct cifsTconInfo * tcon,
                        if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
                                CIFS_SB(sb)->rsize = 127 * 1024;
 #ifdef CONFIG_CIFS_DEBUG2
-                                cFYI(1,("larger reads not supported by srv"));
+                                cFYI(1, ("larger reads not supported by srv"));
 #endif
                        }
                }
                
        
-                cFYI(1,("Negotiate caps 0x%x",(int)cap));
+                cFYI(1, ("Negotiate caps 0x%x",(int)cap));
 #ifdef CONFIG_CIFS_DEBUG2
                if (cap & CIFS_UNIX_FCNTL_CAP)
-                        cFYI(1,("FCNTL cap"));
+                        cFYI(1, ("FCNTL cap"));
                if (cap & CIFS_UNIX_EXTATTR_CAP)
-                        cFYI(1,("EXTATTR cap"));
+                        cFYI(1, ("EXTATTR cap"));
                if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
-                        cFYI(1,("POSIX path cap"));
+                        cFYI(1, ("POSIX path cap"));
                if (cap & CIFS_UNIX_XATTR_CAP)
-                        cFYI(1,("XATTR cap"));
+                        cFYI(1, ("XATTR cap"));
                if (cap & CIFS_UNIX_POSIX_ACL_CAP)
-                        cFYI(1,("POSIX ACL cap"));
+                        cFYI(1, ("POSIX ACL cap"));
                if (cap & CIFS_UNIX_LARGE_READ_CAP)
-                        cFYI(1,("very large read cap"));
+                        cFYI(1, ("very large read cap"));
                if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
-                        cFYI(1,("very large write cap"));
+                        cFYI(1, ("very large write cap"));
 #endif /* CIFS_DEBUG2 */
                if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
-                        cFYI(1,("setting capabilities failed"));
+                        cFYI(1, ("setting capabilities failed"));
                }
        }
 }
@@ -1736,7 +1736,7 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
        }
        if (volume_info.nullauth) {
-                cFYI(1,("null user"));
+                cFYI(1, ("null user"));
                volume_info.username = NULL;
        } else if (volume_info.username) {
                /* BB fixme parse for domain name here */
@@ -1755,16 +1755,16 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
        if (volume_info.UNCip && volume_info.UNC) {
                rc = cifs_inet_pton(AF_INET, volume_info.UNCip,&sin_server.sin_addr.s_addr);
-                if(rc <= 0) {
+                if (rc <= 0) {
                        /* not ipv4 address, try ipv6 */
                        rc = cifs_inet_pton(AF_INET6,volume_info.UNCip,&sin_server6.sin6_addr.in6_u); 
-                        if(rc > 0)
+                        if (rc > 0)
                                address_type = AF_INET6;
                } else {
                        address_type = AF_INET;
                }
       
-                if(rc <= 0) {
+                if (rc <= 0) {
                        /* we failed translating address */
                        kfree(volume_info.UNC);
                        kfree(volume_info.password);
@@ -1795,12 +1795,12 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
        }
        /* this is needed for ASCII cp to Unicode converts */
-        if(volume_info.iocharset == NULL) {
+        if (volume_info.iocharset == NULL) {
                cifs_sb->local_nls = load_nls_default();
        /* load_nls_default can not return null */
        } else {
                cifs_sb->local_nls = load_nls(volume_info.iocharset);
-                if(cifs_sb->local_nls == NULL) {
+                if (cifs_sb->local_nls == NULL) {
                        cERROR(1,("CIFS mount error: iocharset %s not found",volume_info.iocharset));
                        kfree(volume_info.UNC);
                        kfree(volume_info.password);
@@ -1810,12 +1810,12 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                }
        }
-        if(address_type == AF_INET)
+        if (address_type == AF_INET)
                existingCifsSes = cifs_find_tcp_session(&sin_server.sin_addr,
                        NULL /* no ipv6 addr */,
                        volume_info.username, &srvTcp);
-        else if(address_type == AF_INET6) {
+        else if (address_type == AF_INET6) {
-                cFYI(1,("looking for ipv6 address"));
+                cFYI(1, ("looking for ipv6 address"));
                existingCifsSes = cifs_find_tcp_session(NULL /* no ipv4 addr */,
                        &sin_server6.sin6_addr,
                        volume_info.username, &srvTcp);
@@ -1836,7 +1836,7 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                else
                        sin_server.sin_port = 0;
                if (address_type == AF_INET6) {
-                        cFYI(1,("attempting ipv6 connect"));
+                        cFYI(1, ("attempting ipv6 connect"));
                        /* BB should we allow ipv6 on port 139? */
                        /* other OS never observed in Wild doing 139 with v6 */
                        rc = ipv6_connect(&sin_server6,&csocket);
@@ -2091,7 +2091,7 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                                   send_sig call */
                                force_sig(SIGKILL,srvTcp->tsk);
                                tsk = srvTcp->tsk;
-                                if(tsk)
+                                if (tsk)
                                        kthread_stop(tsk);
                        }
                }
@@ -2133,7 +2133,7 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                /* tell server which Unix caps we support */
                if (tcon->ses->capabilities & CAP_UNIX)
                        reset_cifs_unix_caps(xid, tcon, sb, &volume_info);
-                else if(cifs_sb->rsize > (1024 * 127)) {
+                else if (cifs_sb->rsize > (1024 * 127)) {
                        cifs_sb->rsize = 1024 * 127;
 #ifdef CONFIG_CIFS_DEBUG2
                        cFYI(1, ("no very large read support, rsize 127K"));
@@ -2200,7 +2200,7 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
        pSMB->req_no_secext.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
        pSMB->req_no_secext.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
-        if(ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
+        if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
                smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
        capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
@@ -2330,10 +2330,10 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
 /* We look for obvious messed up bcc or strings in response so we do not go off
   the end since (at least) WIN2K and Windows XP have a major bug in not null
   terminating last Unicode string in response  */
-                                if(ses->serverOS)
+                                if (ses->serverOS)
                                        kfree(ses->serverOS);
                                ses->serverOS = kzalloc(2 * (len + 1), GFP_KERNEL);
-                                if(ses->serverOS == NULL)
+                                if (ses->serverOS == NULL)
                                        goto sesssetup_nomem;
                                cifs_strfromUCS_le(ses->serverOS,
                                           (__le16 *)bcc_ptr, len,nls_codepage);
@@ -2346,14 +2346,14 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
                                                         remaining_words-1);
                                        kfree(ses->serverNOS);
                                        ses->serverNOS = kzalloc(2 * (len + 1),GFP_KERNEL);
-                                        if(ses->serverNOS == NULL)
+                                        if (ses->serverNOS == NULL)
                                                goto sesssetup_nomem;
                                        cifs_strfromUCS_le(ses->serverNOS,
                                                           (__le16 *)bcc_ptr,len,nls_codepage);
                                        bcc_ptr += 2 * (len + 1);
                                        ses->serverNOS[2 * len] = 0;
                                        ses->serverNOS[1 + (2 * len)] = 0;
-                                        if(strncmp(ses->serverNOS,
+                                        if (strncmp(ses->serverNOS,
                                                "NT LAN Manager 4",16) == 0) {
                                                cFYI(1, ("NT4 server"));
                                                ses->flags |= CIFS_SES_NT4;
@@ -2362,11 +2362,11 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
                                        if (remaining_words > 0) {
                                                len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);
          /* last string is not always null terminated (for e.g. for Windows XP & 2000) */
-                                                if(ses->serverDomain)
+                                                if (ses->serverDomain)
                                                        kfree(ses->serverDomain);
                                                ses->serverDomain =
                                                    kzalloc(2*(len+1),GFP_KERNEL);
-                                                if(ses->serverDomain == NULL)
+                                                if (ses->serverDomain == NULL)
                                                        goto sesssetup_nomem;
                                                cifs_strfromUCS_le(ses->serverDomain,
                                                     (__le16 *)bcc_ptr,len,nls_codepage);
@@ -2375,7 +2375,7 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
                                                ses->serverDomain[1+(2*len)] = 0;
                                        } /* else no more room so create dummy domain string */
                                        else {
-                                                if(ses->serverDomain)
+                                                if (ses->serverDomain)
                                                        kfree(ses->serverDomain);
                                                ses->serverDomain = 
                                                        kzalloc(2, GFP_KERNEL);
@@ -2398,7 +2398,7 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
                                            <= BCC(smb_buffer_response)) {
                                        kfree(ses->serverOS);
                                        ses->serverOS = kzalloc(len + 1,GFP_KERNEL);
-                                        if(ses->serverOS == NULL)
+                                        if (ses->serverOS == NULL)
                                                goto sesssetup_nomem;
                                        strncpy(ses->serverOS,bcc_ptr, len);
@@ -2409,7 +2409,7 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
                                        len = strnlen(bcc_ptr, 1024);
                                        kfree(ses->serverNOS);
                                        ses->serverNOS = kzalloc(len + 1,GFP_KERNEL);
-                                        if(ses->serverNOS == NULL)
+                                        if (ses->serverNOS == NULL)
                                                goto sesssetup_nomem;
                                        strncpy(ses->serverNOS, bcc_ptr, len);
                                        bcc_ptr += len;
@@ -2417,10 +2417,10 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
                                        bcc_ptr++;
                                        len = strnlen(bcc_ptr, 1024);
-                                        if(ses->serverDomain)
+                                        if (ses->serverDomain)
                                                kfree(ses->serverDomain);
                                        ses->serverDomain = kzalloc(len + 1,GFP_KERNEL);
-                                        if(ses->serverDomain == NULL)
+                                        if (ses->serverDomain == NULL)
                                                goto sesssetup_nomem;
                                        strncpy(ses->serverDomain, bcc_ptr, len);
                                        bcc_ptr += len;
@@ -2472,7 +2472,7 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
        __u16 count;
        cFYI(1, ("In NTLMSSP sesssetup (negotiate)"));
-        if(ses == NULL)
+        if (ses == NULL)
                return -EINVAL;
        domain = ses->domainName;
        *pNTLMv2_flag = FALSE;
@@ -2496,7 +2496,7 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
        pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
        pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
-        if(ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
+        if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
                smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
        capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
@@ -2524,9 +2524,9 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
            NTLMSSP_REQUEST_TARGET | NTLMSSP_NEGOTIATE_NTLM |
            NTLMSSP_NEGOTIATE_56 |
            /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN | */ NTLMSSP_NEGOTIATE_128;
-        if(sign_CIFS_PDUs)
+        if (sign_CIFS_PDUs)
                negotiate_flags |= NTLMSSP_NEGOTIATE_SIGN;
-/*      if(ntlmv2_support)
+/*      if (ntlmv2_support)
                negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;*/
        /* setup pointers to domain name and workstation name */
        bcc_ptr += SecurityBlobLength;
@@ -2626,11 +2626,11 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
                                memcpy(ses->server->cryptKey,
                                       SecurityBlob2->Challenge,
                                       CIFS_CRYPTO_KEY_SIZE);
-                                if(SecurityBlob2->NegotiateFlags & 
+                                if (SecurityBlob2->NegotiateFlags & 
                                        cpu_to_le32(NTLMSSP_NEGOTIATE_NTLMV2))
                                        *pNTLMv2_flag = TRUE;
-                                if((SecurityBlob2->NegotiateFlags & 
+                                if ((SecurityBlob2->NegotiateFlags & 
                                        cpu_to_le32(NTLMSSP_NEGOTIATE_ALWAYS_SIGN)) 
                                        || (sign_CIFS_PDUs > 1))
                                                ses->server->secMode |= 
@@ -2657,7 +2657,7 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
 /* We look for obvious messed up bcc or strings in response so we do not go off
   the end since (at least) WIN2K and Windows XP have a major bug in not null
   terminating last Unicode string in response  */
-                                        if(ses->serverOS)
+                                        if (ses->serverOS)
                                                kfree(ses->serverOS);
                                        ses->serverOS =
                                            kzalloc(2 * (len + 1), GFP_KERNEL);
@@ -2729,7 +2729,7 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
                                        if (((long) bcc_ptr + len) - (long)
                                            pByteArea(smb_buffer_response)
                                            <= BCC(smb_buffer_response)) {
-                                                if(ses->serverOS)
+                                                if (ses->serverOS)
                                                        kfree(ses->serverOS);
                                                ses->serverOS =
                                                    kzalloc(len + 1,
@@ -2806,7 +2806,7 @@ CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
        __u16 count;
        cFYI(1, ("In NTLMSSPSessSetup (Authenticate)"));
-        if(ses == NULL)
+        if (ses == NULL)
                return -EINVAL;
        user = ses->userName;
        domain = ses->domainName;
@@ -2831,7 +2831,7 @@ CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
        pSMB->req.hdr.Uid = ses->Suid;
-        if(ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
+        if (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
                smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
        capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
@@ -2859,9 +2859,9 @@ CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
            NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_REQUEST_TARGET |
            NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_TARGET_INFO |
            0x80000000 | NTLMSSP_NEGOTIATE_128;
-        if(sign_CIFS_PDUs)
+        if (sign_CIFS_PDUs)
                negotiate_flags |= /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN |*/ NTLMSSP_NEGOTIATE_SIGN;
-        if(ntlmv2_flag)
+        if (ntlmv2_flag)
                negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;
 /* setup pointers to domain name and workstation name */
@@ -3018,7 +3018,7 @@ CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
                    le16_to_cpu(pSMBr->resp.SecurityBlobLength);
                if (action & GUEST_LOGIN)
                        cFYI(1, (" Guest login"));      /* BB do we want to set anything in SesInfo struct ? */
-/*        if(SecurityBlob2->MessageType != NtLm??){                               
+/*        if (SecurityBlob2->MessageType != NtLm??){                               
                 cFYI("Unexpected message type on auth response is %d ")); 
        } */
                if (ses) {
@@ -3057,7 +3057,7 @@ CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
 /* We look for obvious messed up bcc or strings in response so we do not go off
  the end since (at least) WIN2K and Windows XP have a major bug in not null
  terminating last Unicode string in response  */
-                                        if(ses->serverOS)
+                                        if (ses->serverOS)
                                                kfree(ses->serverOS);
                                        ses->serverOS =
                                            kzalloc(2 * (len + 1), GFP_KERNEL);
@@ -3091,7 +3091,7 @@ CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
                                                if (remaining_words > 0) {
                                                        len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words); 
     /* last string not always null terminated (e.g. for Windows XP & 2000) */
-                                                        if(ses->serverDomain)
+                                                        if (ses->serverDomain)
                                                                kfree(ses->serverDomain);
                                                        ses->serverDomain =
                                                            kzalloc(2 *
@@ -3119,12 +3119,12 @@ CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
                                                            = 0;
                                                } /* else no more room so create dummy domain string */
                                                else {
-                                                        if(ses->serverDomain)
+                                                        if (ses->serverDomain)
                                                                kfree(ses->serverDomain);
                                                        ses->serverDomain = kzalloc(2,GFP_KERNEL);
                                                }
                                        } else {  /* no room so create dummy domain and NOS string */
-                                                if(ses->serverDomain)
+                                                if (ses->serverDomain)
                                                        kfree(ses->serverDomain);
                                                ses->serverDomain = kzalloc(2, GFP_KERNEL);
                                                kfree(ses->serverNOS);
@@ -3135,7 +3135,7 @@ CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
                                        if (((long) bcc_ptr + len) - 
                        (long) pByteArea(smb_buffer_response) 
                            <= BCC(smb_buffer_response)) {
-                                                if(ses->serverOS)
+                                                if (ses->serverOS)
                                                        kfree(ses->serverOS);
                                                ses->serverOS = kzalloc(len + 1,GFP_KERNEL);
                                                strncpy(ses->serverOS,bcc_ptr, len);
@@ -3153,7 +3153,7 @@ CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
                                                bcc_ptr++;
                                                len = strnlen(bcc_ptr, 1024);
-                                                if(ses->serverDomain)
+                                                if (ses->serverDomain)
                                                        kfree(ses->serverDomain);
                                                ses->serverDomain = kzalloc(len+1,GFP_KERNEL);
                                                strncpy(ses->serverDomain, bcc_ptr, len);
@@ -3219,7 +3219,7 @@ CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
        pSMB->AndXCommand = 0xFF;
        pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
        bcc_ptr = &pSMB->Password[0];
-        if((ses->server->secMode) & SECMODE_USER) {
+        if ((ses->server->secMode) & SECMODE_USER) {
                pSMB->PasswordLength = cpu_to_le16(1);  /* minimum */
                *bcc_ptr = 0; /* password is null byte */
                bcc_ptr++;              /* skip password */
@@ -3233,7 +3233,7 @@ CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
                   by Samba (not sure whether other servers allow
                   NTLMv2 password here) */
 #ifdef CONFIG_CIFS_WEAK_PW_HASH
-                if((extended_security & CIFSSEC_MAY_LANMAN) && 
+                if ((extended_security & CIFSSEC_MAY_LANMAN) && 
                        (ses->server->secType == LANMAN))
                        calc_lanman_hash(ses, bcc_ptr);
                else
@@ -3243,14 +3243,14 @@ CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
                             bcc_ptr);
                bcc_ptr += CIFS_SESS_KEY_SIZE;
-                if(ses->capabilities & CAP_UNICODE) {
+                if (ses->capabilities & CAP_UNICODE) {
                        /* must align unicode strings */
                        *bcc_ptr = 0; /* null byte password */
                        bcc_ptr++;
                }
        }
-        if(ses->server->secMode & 
+        if (ses->server->secMode & 
                        (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
                smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
@@ -3321,7 +3321,7 @@ CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
                        }
                        /* else do not bother copying these informational fields */
                }
-                if((smb_buffer_response->WordCount == 3) ||
+                if ((smb_buffer_response->WordCount == 3) ||
                         (smb_buffer_response->WordCount == 7))
                        /* field is in same location */
                        tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
@@ -3401,16 +3401,16 @@ int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
        int first_time = 0;
        /* what if server changes its buffer size after dropping the session? */
-        if(pSesInfo->server->maxBuf == 0) /* no need to send on reconnect */ {
+        if (pSesInfo->server->maxBuf == 0) /* no need to send on reconnect */ {
                rc = CIFSSMBNegotiate(xid, pSesInfo);
-                if(rc == -EAGAIN) /* retry only once on 1st time connection */ {
+                if (rc == -EAGAIN) /* retry only once on 1st time connection */ {
                        rc = CIFSSMBNegotiate(xid, pSesInfo);
-                        if(rc == -EAGAIN) 
+                        if (rc == -EAGAIN) 
                                rc = -EHOSTDOWN;
                }
-                if(rc == 0) {
+                if (rc == 0) {
                        spin_lock(&GlobalMid_Lock);
-                        if(pSesInfo->server->tcpStatus != CifsExiting)
+                        if (pSesInfo->server->tcpStatus != CifsExiting)
                                pSesInfo->server->tcpStatus = CifsGood;
                        else
                                rc = -EHOSTDOWN;
@@ -3422,14 +3422,14 @@ int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
        if (!rc) {
                pSesInfo->flags = 0;
                pSesInfo->capabilities = pSesInfo->server->capabilities;
-                if(linuxExtEnabled == 0)
+                if (linuxExtEnabled == 0)
                        pSesInfo->capabilities &= (~CAP_UNIX);
        /*      pSesInfo->sequence_number = 0;*/
-                cFYI(1,("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
+                cFYI(1, ("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
                        pSesInfo->server->secMode,
                        pSesInfo->server->capabilities,
                        pSesInfo->server->timeAdj));
-                if(experimEnabled < 2)
+                if (experimEnabled < 2)
                        rc = CIFS_SessSetup(xid, pSesInfo,
                                            first_time, nls_info);
                else if (extended_security
@@ -3446,18 +3446,18 @@ int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
                                                &ntlmv2_flag,
                                                nls_info);
                        if (!rc) {
-                                if(ntlmv2_flag) {
+                                if (ntlmv2_flag) {
                                        char * v2_response;
                                        cFYI(1, ("more secure NTLM ver2 hash"));
-                                        if(CalcNTLMv2_partial_mac_key(pSesInfo, 
+                                        if (CalcNTLMv2_partial_mac_key(pSesInfo, 
                                                nls_info)) {
                                                rc = -ENOMEM;
                                                goto ss_err_exit;
                                        } else
                                                v2_response = kmalloc(16 + 64 /* blob */, GFP_KERNEL);
-                                        if(v2_response) {
+                                        if (v2_response) {
                                                CalcNTLMv2_response(pSesInfo,v2_response);
-                                /*              if(first_time)
+                                /*              if (first_time)
                                                        cifs_calculate_ntlmv2_mac_key(
                                                          pSesInfo->server->mac_signing_key, 
                                                          response, ntlm_session_key, */
@@ -3473,7 +3473,7 @@ int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
                                                pSesInfo->server->cryptKey,
                                                ntlm_session_key);
-                                        if(first_time)
+                                        if (first_time)
                                                cifs_calculate_mac_key(
                                                        &pSesInfo->server->mac_signing_key,
                                                        ntlm_session_key,
@@ -3493,7 +3493,7 @@ int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
                                pSesInfo->server->cryptKey,
                                ntlm_session_key);
-                        if(first_time)          
+                        if (first_time)
                                cifs_calculate_mac_key(
                                        &pSesInfo->server->mac_signing_key,
                                        ntlm_session_key, pSesInfo->password);
@@ -3502,7 +3502,7 @@ int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
                                ntlm_session_key, nls_info);
                }
                if (rc) {
-                        cERROR(1,("Send error in SessSetup = %d",rc));
+                        cERROR(1, ("Send error in SessSetup = %d", rc));
                } else {
                        cFYI(1, ("CIFS Session Established successfully"));
                        pSesInfo->status = CifsGood;
diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c
index 8e86aaceb68a..38706e8496a3 100644
--- a/fs/cifs/dir.c
+++ b/fs/cifs/dir.c
@@ -135,10 +135,10 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
        struct cifs_sb_info *cifs_sb;
        struct cifsTconInfo *pTcon;
        char *full_path = NULL;
-        FILE_ALL_INFO * buf = NULL;
+        FILE_ALL_INFO *buf = NULL;
        struct inode *newinode = NULL;
-        struct cifsFileInfo * pCifsFile = NULL;
+        struct cifsFileInfo *pCifsFile = NULL;
-        struct cifsInodeInfo * pCifsInode;
+        struct cifsInodeInfo *pCifsInode;
        int disposition = FILE_OVERWRITE_IF;
        int write_only = FALSE;
@@ -323,7 +323,7 @@ int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode,
        struct cifs_sb_info *cifs_sb;
        struct cifsTconInfo *pTcon;
        char *full_path = NULL;
-        struct inode * newinode = NULL;
+        struct inode *newinode = NULL;
        if (!old_valid_dev(device_number))
                return -EINVAL;
diff --git a/fs/cifs/export.c b/fs/cifs/export.c
index 1d716392c3aa..5a08effda0ae 100644
--- a/fs/cifs/export.c
+++ b/fs/cifs/export.c
@@ -5,7 +5,7 @@
 *   Author(s): Steve French (sfrench@us.ibm.com)
 *
 *   Common Internet FileSystem (CIFS) client
- * 
+ *
 *   Operations related to support for exporting files via NFSD
 *
 *   This library is free software; you can redistribute it and/or modify
@@ -23,7 +23,7 @@
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
- /* 
+ /*
  * See Documentation/filesystems/Exporting
  * and examples in fs/exportfs
  */
@@ -34,19 +34,19 @@
 
 static struct dentry *cifs_get_parent(struct dentry *dentry)
 {
-        /* BB need to add code here eventually to enable export via NFSD */
+        /* BB need to add code here eventually to enable export via NFSD */
-        return ERR_PTR(-EACCES);
+        return ERR_PTR(-EACCES);
 }
 
 struct export_operations cifs_export_ops = {
-        .get_parent = cifs_get_parent,
+        .get_parent = cifs_get_parent,
-/*      Following five export operations are unneeded so far and can default */         
+/*      Following five export operations are unneeded so far and can default:
-/*      .get_dentry =
+        .get_dentry =
-        .get_name =
+        .get_name =
-        .find_exported_dentry =
+        .find_exported_dentry =
-        .decode_fh = 
+        .decode_fh =
-        .encode_fs =  */
+        .encode_fs =  */
- };
+};
 
 #endif /* EXPERIMENTAL */
 
diff --git a/fs/cifs/fcntl.c b/fs/cifs/fcntl.c
index 8e375bb4b379..995474c90885 100644
--- a/fs/cifs/fcntl.c
+++ b/fs/cifs/fcntl.c
@@ -66,7 +66,7 @@ static __u32 convert_to_cifs_notify_flags(unsigned long fcntl_notify_flags)
        return cifs_ntfy_flags;
 }
-int cifs_dir_notify(struct file * file, unsigned long arg)
+int cifs_dir_notify(struct file *file, unsigned long arg)
 {
        int xid;
        int rc = -EINVAL;
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 5f1b707188f8..7d6fb6f3adeb 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -2,8 +2,8 @@
 *   fs/cifs/file.c
 *
 *   vfs operations that deal with files
- * 
+ *
- *   Copyright (C) International Business Machines  Corp., 2002,2003
+ *   Copyright (C) International Business Machines  Corp., 2002,2007
 *   Author(s): Steve French (sfrench@us.ibm.com)
 *              Jeremy Allison (jra@samba.org)
 *
@@ -45,7 +45,7 @@ static inline struct cifsFileInfo *cifs_init_private(
 {
        memset(private_data, 0, sizeof(struct cifsFileInfo));
        private_data->netfid = netfid;
-        private_data->pid = current->tgid;      
+        private_data->pid = current->tgid;
        init_MUTEX(&private_data->fh_sem);
        mutex_init(&private_data->lock_mutex);
        INIT_LIST_HEAD(&private_data->llist);
@@ -57,7 +57,7 @@ static inline struct cifsFileInfo *cifs_init_private(
        does not tell us which handle the write is for so there can
        be a close (overlapping with write) of the filehandle that
        cifs_writepages chose to use */
-        atomic_set(&private_data->wrtPending,0); 
+        atomic_set(&private_data->wrtPending, 0);
        return private_data;
 }
@@ -105,7 +105,7 @@ static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
           in the list so we do not have to walk the
           list to search for one in prepare_write */
        if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
-                list_add_tail(&pCifsFile->flist, 
+                list_add_tail(&pCifsFile->flist,
                              &pCifsInode->openFileList);
        } else {
                list_add(&pCifsFile->flist,
@@ -218,9 +218,9 @@ int cifs_open(struct inode *inode, struct file *file)
 /*********************************************************************
 *  open flag mapping table:
- *  
+ *
 *      POSIX Flag            CIFS Disposition
- *      ----------            ---------------- 
+ *      ----------            ----------------
 *      O_CREAT               FILE_OPEN_IF
 *      O_CREAT | O_EXCL      FILE_CREATE
 *      O_CREAT | O_TRUNC     FILE_OVERWRITE_IF
@@ -228,12 +228,12 @@ int cifs_open(struct inode *inode, struct file *file)
 *      none of the above     FILE_OPEN
 *
 *      Note that there is not a direct match between disposition
- *      FILE_SUPERSEDE (ie create whether or not file exists although 
+ *      FILE_SUPERSEDE (ie create whether or not file exists although
 *      O_CREAT | O_TRUNC is similar but truncates the existing
 *      file rather than creating a new file as FILE_SUPERSEDE does
 *      (which uses the attributes / metadata passed in on open call)
 *?
- *?  O_SYNC is a reasonable match to CIFS writethrough flag  
+ *?  O_SYNC is a reasonable match to CIFS writethrough flag
 *?  and the read write flags match reasonably.  O_LARGEFILE
 *?  is irrelevant because largefile support is always used
 *?  by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
@@ -253,8 +253,8 @@ int cifs_open(struct inode *inode, struct file *file)
           and calling get_inode_info with returned buf (at least helps
           non-Unix server case) */
-        /* BB we can not do this if this is the second open of a file 
+        /* BB we can not do this if this is the second open of a file
-           and the first handle has writebehind data, we might be 
+           and the first handle has writebehind data, we might be
           able to simply do a filemap_fdatawrite/filemap_fdatawait first */
        buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
        if (!buf) {
@@ -263,7 +263,7 @@ int cifs_open(struct inode *inode, struct file *file)
        }
        if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
-                rc = CIFSSMBOpen(xid, pTcon, full_path, disposition, 
+                rc = CIFSSMBOpen(xid, pTcon, full_path, disposition,
                         desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
                         cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
                                 & CIFS_MOUNT_MAP_SPECIAL_CHR);
@@ -300,7 +300,7 @@ int cifs_open(struct inode *inode, struct file *file)
                write_unlock(&GlobalSMBSeslock);
        }
-        if (oplock & CIFS_CREATE_ACTION) {           
+        if (oplock & CIFS_CREATE_ACTION) {
                /* time to set mode which we can not set earlier due to
                   problems creating new read-only files */
                if (cifs_sb->tcon->ses->capabilities & CAP_UNIX) {
@@ -308,7 +308,7 @@ int cifs_open(struct inode *inode, struct file *file)
                                            inode->i_mode,
                                            (__u64)-1, (__u64)-1, 0 /* dev */,
                                            cifs_sb->local_nls,
-                                            cifs_sb->mnt_cifs_flags & 
+                                            cifs_sb->mnt_cifs_flags &
                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
                } else {
                        /* BB implement via Windows security descriptors eg
@@ -345,7 +345,7 @@ static int cifs_reopen_file(struct file *file, int can_flush)
        struct cifsTconInfo *pTcon;
        struct cifsFileInfo *pCifsFile;
        struct cifsInodeInfo *pCifsInode;
-        struct inode * inode;
+        struct inode *inode;
        char *full_path = NULL;
        int desiredAccess;
        int disposition = FILE_OPEN;
@@ -372,7 +372,7 @@ static int cifs_reopen_file(struct file *file, int can_flush)
        }
        inode = file->f_path.dentry->d_inode;
-        if(inode == NULL) {
+        if (inode == NULL) {
                cERROR(1, ("inode not valid"));
                dump_stack();
                rc = -EBADF;
@@ -396,7 +396,7 @@ reopen_error_exit:
        }
        cFYI(1, ("inode = 0x%p file flags 0x%x for %s",
-                 inode, file->f_flags,full_path));
+                 inode, file->f_flags, full_path));
        desiredAccess = cifs_convert_flags(file->f_flags);
        if (oplockEnabled)
@@ -405,14 +405,14 @@ reopen_error_exit:
                oplock = FALSE;
        /* Can not refresh inode by passing in file_info buf to be returned
-           by SMBOpen and then calling get_inode_info with returned buf 
+           by SMBOpen and then calling get_inode_info with returned buf
-           since file might have write behind data that needs to be flushed 
+           since file might have write behind data that needs to be flushed
           and server version of file size can be stale. If we knew for sure
           that inode was not dirty locally we could do this */
        rc = CIFSSMBOpen(xid, pTcon, full_path, disposition, desiredAccess,
                         CREATE_NOT_DIR, &netfid, &oplock, NULL,
-                         cifs_sb->local_nls, cifs_sb->mnt_cifs_flags & 
+                         cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
                                CIFS_MOUNT_MAP_SPECIAL_CHR);
        if (rc) {
                up(&pCifsFile->fh_sem);
@@ -486,22 +486,22 @@ int cifs_close(struct inode *inode, struct file *file)
                           already closed */
                        if (pTcon->tidStatus != CifsNeedReconnect) {
                                int timeout = 2;
-                                while((atomic_read(&pSMBFile->wrtPending) != 0)
+                                while ((atomic_read(&pSMBFile->wrtPending) != 0)
                                         && (timeout < 1000) ) {
                                        /* Give write a better chance to get to
                                        server ahead of the close.  We do not
                                        want to add a wait_q here as it would
                                        increase the memory utilization as
                                        the struct would be in each open file,
-                                        but this should give enough time to 
+                                        but this should give enough time to
                                        clear the socket */
 #ifdef CONFIG_CIFS_DEBUG2
-                                        cFYI(1,("close delay, write pending"));
+                                        cFYI(1, ("close delay, write pending"));
 #endif /* DEBUG2 */
                                        msleep(timeout);
                                        timeout *= 4;
                                }
-                                if(atomic_read(&pSMBFile->wrtPending))
+                                if (atomic_read(&pSMBFile->wrtPending))
                                        cERROR(1,("close with pending writes"));
                                rc = CIFSSMBClose(xid, pTcon,
                                                  pSMBFile->netfid);
@@ -534,7 +534,7 @@ int cifs_close(struct inode *inode, struct file *file)
                CIFS_I(inode)->clientCanCacheRead = FALSE;
                CIFS_I(inode)->clientCanCacheAll  = FALSE;
        }
-        if ((rc ==0) && CIFS_I(inode)->write_behind_rc)
+        if ((rc == 0) && CIFS_I(inode)->write_behind_rc)
                rc = CIFS_I(inode)->write_behind_rc;
        FreeXid(xid);
        return rc;
@@ -554,7 +554,8 @@ int cifs_closedir(struct inode *inode, struct file *file)
        if (pCFileStruct) {
                struct cifsTconInfo *pTcon;
-                struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
+                struct cifs_sb_info *cifs_sb =
+                        CIFS_SB(file->f_path.dentry->d_sb);
                pTcon = cifs_sb->tcon;
@@ -572,7 +573,7 @@ int cifs_closedir(struct inode *inode, struct file *file)
                if (ptmp) {
                        cFYI(1, ("closedir free smb buf in srch struct"));
                        pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
-                        if(pCFileStruct->srch_inf.smallBuf)
+                        if (pCFileStruct->srch_inf.smallBuf)
                                cifs_small_buf_release(ptmp);
                        else
                                cifs_buf_release(ptmp);
@@ -594,7 +595,8 @@ int cifs_closedir(struct inode *inode, struct file *file)
 static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
                                __u64 offset, __u8 lockType)
 {
-        struct cifsLockInfo *li = kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
+        struct cifsLockInfo *li =
+                kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
        if (li == NULL)
                return -ENOMEM;
        li->offset = offset;
@@ -625,8 +627,8 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
        cFYI(1, ("Lock parm: 0x%x flockflags: "
                 "0x%x flocktype: 0x%x start: %lld end: %lld",
-                cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
+                cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
-                pfLock->fl_end));
+                pfLock->fl_end));
        if (pfLock->fl_flags & FL_POSIX)
                cFYI(1, ("Posix"));
@@ -641,7 +643,7 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
                         "not implemented yet"));
        if (pfLock->fl_flags & FL_LEASE)
                cFYI(1, ("Lease on file - not implemented yet"));
-        if (pfLock->fl_flags & 
+        if (pfLock->fl_flags &
            (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
                cFYI(1, ("Unknown lock flags 0x%x", pfLock->fl_flags));
@@ -683,9 +685,9 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
        account for negative length which we can not accept over the
        wire */
        if (IS_GETLK(cmd)) {
-                if(posix_locking) {
+                if (posix_locking) {
                        int posix_lock_type;
-                        if(lockType & LOCKING_ANDX_SHARED_LOCK)
+                        if (lockType & LOCKING_ANDX_SHARED_LOCK)
                                posix_lock_type = CIFS_RDLCK;
                        else
                                posix_lock_type = CIFS_WRLCK;
@@ -700,7 +702,7 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
                rc = CIFSSMBLock(xid, pTcon, netfid, length, pfLock->fl_start,
                                 0, 1, lockType, 0 /* wait flag */ );
                if (rc == 0) {
-                        rc = CIFSSMBLock(xid, pTcon, netfid, length, 
+                        rc = CIFSSMBLock(xid, pTcon, netfid, length,
                                         pfLock->fl_start, 1 /* numUnlock */ ,
                                         0 /* numLock */ , lockType,
                                         0 /* wait flag */ );
@@ -729,22 +731,24 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
        if (posix_locking) {
                int posix_lock_type;
-                if(lockType & LOCKING_ANDX_SHARED_LOCK)
+                if (lockType & LOCKING_ANDX_SHARED_LOCK)
                        posix_lock_type = CIFS_RDLCK;
                else
                        posix_lock_type = CIFS_WRLCK;
                
-                if(numUnlock == 1)
+                if (numUnlock == 1)
                        posix_lock_type = CIFS_UNLCK;
                rc = CIFSSMBPosixLock(xid, pTcon, netfid, 0 /* set */,
                                      length, pfLock,
                                      posix_lock_type, wait_flag);
        } else {
-                struct cifsFileInfo *fid = (struct cifsFileInfo *)file->private_data;
+                struct cifsFileInfo *fid =
+                        (struct cifsFileInfo *)file->private_data;
                if (numLock) {
-                        rc = CIFSSMBLock(xid, pTcon, netfid, length, pfLock->fl_start,
+                        rc = CIFSSMBLock(xid, pTcon, netfid, length,
+                                        pfLock->fl_start,
                                        0, numLock, lockType, wait_flag);
                        if (rc == 0) {
@@ -763,7 +767,8 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
                        list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
                                if (pfLock->fl_start <= li->offset &&
                                                length >= li->length) {
-                                        stored_rc = CIFSSMBLock(xid, pTcon, netfid,
+                                        stored_rc = CIFSSMBLock(xid, pTcon,
+                                                        netfid,
                                                        li->length, li->offset,
                                                        1, 0, li->type, FALSE);
                                        if (stored_rc)
@@ -824,7 +829,7 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,
                           and blocked, and the file has been freed on us while
                           we blocked so return what we managed to write */
                                return total_written;
-                        } 
+                        }
                        if (open_file->closePend) {
                                FreeXid(xid);
                                if (total_written)
@@ -867,8 +872,8 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,
        /* since the write may have blocked check these pointers again */
        if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
                struct inode *inode = file->f_path.dentry->d_inode;
-/* Do not update local mtime - server will set its actual value on write                
+/* Do not update local mtime - server will set its actual value on write
- *              inode->i_ctime = inode->i_mtime = 
+ *              inode->i_ctime = inode->i_mtime =
 *                      current_fs_time(inode->i_sb);*/
                if (total_written > 0) {
                        spin_lock(&inode->i_lock);
@@ -877,7 +882,7 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,
                                        *poffset);
                        spin_unlock(&inode->i_lock);
                }
-                mark_inode_dirty_sync(file->f_path.dentry->d_inode);    
+                mark_inode_dirty_sync(file->f_path.dentry->d_inode);
        }
        FreeXid(xid);
        return total_written;
@@ -898,7 +903,7 @@ static ssize_t cifs_write(struct file *file, const char *write_data,
        pTcon = cifs_sb->tcon;
-        cFYI(1,("write %zd bytes to offset %lld of %s", write_size,
+        cFYI(1, ("write %zd bytes to offset %lld of %s", write_size,
           *poffset, file->f_path.dentry->d_name.name));
        if (file->private_data == NULL)
@@ -921,10 +926,10 @@ static ssize_t cifs_write(struct file *file, const char *write_data,
                                FreeXid(xid);
                        /* if we have gotten here we have written some data
                           and blocked, and the file has been freed on us
-                           while we blocked so return what we managed to 
+                           while we blocked so return what we managed to
                           write */
                                return total_written;
-                        } 
+                        }
                        if (open_file->closePend) {
                                FreeXid(xid);
                                if (total_written)
@@ -935,14 +940,14 @@ static ssize_t cifs_write(struct file *file, const char *write_data,
                        if (open_file->invalidHandle) {
                                /* we could deadlock if we called
                                   filemap_fdatawait from here so tell
-                                   reopen_file not to flush data to 
+                                   reopen_file not to flush data to
                                   server now */
                                rc = cifs_reopen_file(file, FALSE);
                                if (rc != 0)
                                        break;
                        }
-                        if(experimEnabled || (pTcon->ses->server &&
+                        if (experimEnabled || (pTcon->ses->server &&
-                                ((pTcon->ses->server->secMode & 
+                                ((pTcon->ses->server->secMode &
                                (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
                                == 0))) {
                                struct kvec iov[2];
@@ -976,7 +981,7 @@ static ssize_t cifs_write(struct file *file, const char *write_data,
                        }
                } else
                        *poffset += bytes_written;
-                long_op = FALSE; /* subsequent writes fast - 
+                long_op = FALSE; /* subsequent writes fast -
                                    15 seconds is plenty */
        }
@@ -1009,8 +1014,8 @@ struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
        the VFS or MM) should not happen but we had reports of on oops (due to
        it being zero) during stress testcases so we need to check for it */
-        if(cifs_inode == NULL) {
+        if (cifs_inode == NULL) {
-                cERROR(1,("Null inode passed to cifs_writeable_file"));
+                cERROR(1, ("Null inode passed to cifs_writeable_file"));
                dump_stack();
                return NULL;
        }
@@ -1024,13 +1029,13 @@ struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
                     (open_file->pfile->f_flags & O_WRONLY))) {
                        atomic_inc(&open_file->wrtPending);
                        read_unlock(&GlobalSMBSeslock);
-                        if((open_file->invalidHandle) && 
+                        if ((open_file->invalidHandle) &&
                           (!open_file->closePend) /* BB fixme -since the second clause can not be true remove it BB */) {
                                rc = cifs_reopen_file(open_file->pfile, FALSE);
                                /* if it fails, try another handle - might be */
                                /* dangerous to hold up writepages with retry */
-                                if(rc) {
+                                if (rc) {
-                                        cFYI(1,("failed on reopen file in wp"));
+                                        cFYI(1, ("failed on reopen file in wp"));
                                        read_lock(&GlobalSMBSeslock);
                                        /* can not use this handle, no write
                                        pending on this one after all */
@@ -1082,7 +1087,7 @@ static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
        /* check to make sure that we are not extending the file */
        if (mapping->host->i_size - offset < (loff_t)to)
-                to = (unsigned)(mapping->host->i_size - offset); 
+                to = (unsigned)(mapping->host->i_size - offset);
        open_file = find_writable_file(CIFS_I(mapping->host));
        if (open_file) {
@@ -1116,8 +1121,8 @@ static int cifs_writepages(struct address_space *mapping,
        int done = 0;
        pgoff_t end;
        pgoff_t index;
-        int range_whole = 0;
+        int range_whole = 0;
-        struct kvec * iov;
+        struct kvec *iov;
        int len;
        int n_iov = 0;
        pgoff_t next;
@@ -1139,14 +1144,14 @@ static int cifs_writepages(struct address_space *mapping,
        if (cifs_sb->wsize < PAGE_CACHE_SIZE)
                return generic_writepages(mapping, wbc);
-        if((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
+        if ((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
-                if(cifs_sb->tcon->ses->server->secMode &
+                if (cifs_sb->tcon->ses->server->secMode &
-                          (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
+                                (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
-                        if(!experimEnabled) 
+                        if (!experimEnabled)
                                return generic_writepages(mapping, wbc);
        iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
-        if(iov == NULL)
+        if (iov == NULL)
                return generic_writepages(mapping, wbc);
@@ -1295,8 +1300,8 @@ retry:
                                success rc but too little data written? */
                                /* BB investigate retry logic on temporary
                                server crash cases and how recovery works
-                                when page marked as error */ 
+                                when page marked as error */
-                                if(rc)
+                                if (rc)
                                        SetPageError(page);
                                kunmap(page);
                                unlock_page(page);
@@ -1326,7 +1331,7 @@ retry:
        return rc;
 }
-static int cifs_writepage(struct page* page, struct writeback_control *wbc)
+static int cifs_writepage(struct page *page, struct writeback_control *wbc)
 {
        int rc = -EFAULT;
        int xid;
@@ -1334,7 +1339,7 @@ static int cifs_writepage(struct page* page, struct writeback_control *wbc)
        xid = GetXid();
 /* BB add check for wbc flags */
        page_cache_get(page);
-        if (!PageUptodate(page)) {
+        if (!PageUptodate(page)) {
                cFYI(1, ("ppw - page not up to date"));
        }
@@ -1348,7 +1353,7 @@ static int cifs_writepage(struct page* page, struct writeback_control *wbc)
         * Just unlocking the page will cause the radix tree tag-bits
         * to fail to update with the state of the page correctly.
         */
-        set_page_writeback(page);               
+        set_page_writeback(page);
        rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
        SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
        unlock_page(page);
@@ -1368,7 +1373,7 @@ static int cifs_commit_write(struct file *file, struct page *page,
        char *page_data;
        xid = GetXid();
-        cFYI(1, ("commit write for page %p up to position %lld for %d", 
+        cFYI(1, ("commit write for page %p up to position %lld for %d",
                 page, position, to));
        spin_lock(&inode->i_lock);
        if (position > inode->i_size) {
@@ -1396,7 +1401,7 @@ static int cifs_commit_write(struct file *file, struct page *page,
                        rc = 0;
                /* else if (rc < 0) should we set writebehind rc? */
                kunmap(page);
-        } else {        
+        } else {
                set_page_dirty(page);
        }
@@ -1412,7 +1417,7 @@ int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
        xid = GetXid();
-        cFYI(1, ("Sync file - name: %s datasync: 0x%x", 
+        cFYI(1, ("Sync file - name: %s datasync: 0x%x",
                dentry->d_name.name, datasync));
        
        rc = filemap_fdatawrite(inode->i_mapping);
@@ -1438,7 +1443,7 @@ int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
        if (!inode)
                return; */
-/*      fill in rpages then 
+/*      fill in rpages then
        result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
 /*      cFYI(1, ("rpages is %d for sync page of Index %ld", rpages, index));
@@ -1456,7 +1461,7 @@ int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
 */
 int cifs_flush(struct file *file, fl_owner_t id)
 {
-        struct inode * inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
        int rc = 0;
        /* Rather than do the steps manually:
@@ -1472,7 +1477,7 @@ int cifs_flush(struct file *file, fl_owner_t id)
        if (!rc) /* reset wb rc if we were able to write out dirty pages */
                CIFS_I(inode)->write_behind_rc = 0;
                
-        cFYI(1, ("Flush inode %p file %p rc %d",inode,file,rc));
+        cFYI(1, ("Flush inode %p file %p rc %d", inode, file, rc));
        return rc;
 }
@@ -1508,13 +1513,13 @@ ssize_t cifs_user_read(struct file *file, char __user *read_data,
        for (total_read = 0, current_offset = read_data;
             read_size > total_read;
             total_read += bytes_read, current_offset += bytes_read) {
-                current_read_size = min_t(const int, read_size - total_read, 
+                current_read_size = min_t(const int, read_size - total_read,
                                          cifs_sb->rsize);
                rc = -EAGAIN;
                smb_read_data = NULL;
                while (rc == -EAGAIN) {
                        int buf_type = CIFS_NO_BUFFER;
-                        if ((open_file->invalidHandle) && 
+                        if ((open_file->invalidHandle) &&
                            (!open_file->closePend)) {
                                rc = cifs_reopen_file(file, TRUE);
                                if (rc != 0)
@@ -1535,9 +1540,9 @@ ssize_t cifs_user_read(struct file *file, char __user *read_data,
                                        rc = -EFAULT;
                                }
-                                if(buf_type == CIFS_SMALL_BUFFER)
+                                if (buf_type == CIFS_SMALL_BUFFER)
                                        cifs_small_buf_release(smb_read_data);
-                                else if(buf_type == CIFS_LARGE_BUFFER)
+                                else if (buf_type == CIFS_LARGE_BUFFER)
                                        cifs_buf_release(smb_read_data);
                                smb_read_data = NULL;
                        }
@@ -1586,21 +1591,21 @@ static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
        if ((file->f_flags & O_ACCMODE) == O_WRONLY)
                cFYI(1, ("attempting read on write only file instance"));
-        for (total_read = 0, current_offset = read_data; 
+        for (total_read = 0, current_offset = read_data;
             read_size > total_read;
             total_read += bytes_read, current_offset += bytes_read) {
                current_read_size = min_t(const int, read_size - total_read,
                                          cifs_sb->rsize);
                /* For windows me and 9x we do not want to request more
                than it negotiated since it will refuse the read then */
-                if((pTcon->ses) && 
+                if ((pTcon->ses) &&
                        !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
                        current_read_size = min_t(const int, current_read_size,
                                        pTcon->ses->server->maxBuf - 128);
                }
                rc = -EAGAIN;
                while (rc == -EAGAIN) {
-                        if ((open_file->invalidHandle) && 
+                        if ((open_file->invalidHandle) &&
                            (!open_file->closePend)) {
                                rc = cifs_reopen_file(file, TRUE);
                                if (rc != 0)
@@ -1646,7 +1651,7 @@ int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
 }
-static void cifs_copy_cache_pages(struct address_space *mapping, 
+static void cifs_copy_cache_pages(struct address_space *mapping,
        struct list_head *pages, int bytes_read, char *data,
        struct pagevec *plru_pvec)
 {
@@ -1669,12 +1674,12 @@ static void cifs_copy_cache_pages(struct address_space *mapping,
                        continue;
                }
-                target = kmap_atomic(page,KM_USER0);
+                target = kmap_atomic(page, KM_USER0);
                if (PAGE_CACHE_SIZE > bytes_read) {
                        memcpy(target, data, bytes_read);
                        /* zero the tail end of this partial page */
-                        memset(target + bytes_read, 0, 
+                        memset(target + bytes_read, 0,
                               PAGE_CACHE_SIZE - bytes_read);
                        bytes_read = 0;
                } else {
@@ -1703,7 +1708,7 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
        struct cifs_sb_info *cifs_sb;
        struct cifsTconInfo *pTcon;
        int bytes_read = 0;
-        unsigned int read_size,i;
+        unsigned int read_size, i;
        char *smb_read_data = NULL;
        struct smb_com_read_rsp *pSMBr;
        struct pagevec lru_pvec;
@@ -1721,8 +1726,8 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
        pagevec_init(&lru_pvec, 0);
 #ifdef CONFIG_CIFS_DEBUG2
-                cFYI(1,("rpages: num pages %d", num_pages));
+                cFYI(1, ("rpages: num pages %d", num_pages));
-#endif  
+#endif
        for (i = 0; i < num_pages; ) {
                unsigned contig_pages;
                struct page *tmp_page;
@@ -1736,14 +1741,14 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
                /* count adjacent pages that we will read into */
                contig_pages = 0;
-                expected_index = 
+                expected_index =
                        list_entry(page_list->prev, struct page, lru)->index;
-                list_for_each_entry_reverse(tmp_page,page_list,lru) {
+                list_for_each_entry_reverse(tmp_page, page_list, lru) {
                        if (tmp_page->index == expected_index) {
                                contig_pages++;
                                expected_index++;
                        } else
-                                break; 
+                                break;
                }
                if (contig_pages + i >  num_pages)
                        contig_pages = num_pages - i;
@@ -1756,12 +1761,12 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
                read_size = min_t(const unsigned int, read_size,
                                  cifs_sb->rsize & PAGE_CACHE_MASK);
 #ifdef CONFIG_CIFS_DEBUG2
-                cFYI(1,("rpages: read size 0x%x  contiguous pages %d",
+                cFYI(1, ("rpages: read size 0x%x  contiguous pages %d",
                                read_size, contig_pages));
-#endif          
+#endif
                rc = -EAGAIN;
                while (rc == -EAGAIN) {
-                        if ((open_file->invalidHandle) && 
+                        if ((open_file->invalidHandle) &&
                            (!open_file->closePend)) {
                                rc = cifs_reopen_file(file, TRUE);
                                if (rc != 0)
@@ -1774,11 +1779,11 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
                                         &bytes_read, &smb_read_data,
                                         &buf_type);
                        /* BB more RC checks ? */
-                        if (rc== -EAGAIN) {
+                        if (rc == -EAGAIN) {
                                if (smb_read_data) {
-                                        if(buf_type == CIFS_SMALL_BUFFER)
+                                        if (buf_type == CIFS_SMALL_BUFFER)
                                                cifs_small_buf_release(smb_read_data);
-                                        else if(buf_type == CIFS_LARGE_BUFFER)
+                                        else if (buf_type == CIFS_LARGE_BUFFER)
                                                cifs_buf_release(smb_read_data);
                                        smb_read_data = NULL;
                                }
@@ -1799,10 +1804,10 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
                        if ((int)(bytes_read & PAGE_CACHE_MASK) != bytes_read) {
                                i++; /* account for partial page */
-                                /* server copy of file can have smaller size 
+                                /* server copy of file can have smaller size
                                   than client */
-                                /* BB do we need to verify this common case ? 
+                                /* BB do we need to verify this common case ?
-                                   this case is ok - if we are at server EOF 
+                                   this case is ok - if we are at server EOF
                                   we will hit it on next read */
                                /* break; */
@@ -1811,14 +1816,14 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
                        cFYI(1, ("No bytes read (%d) at offset %lld . "
                                 "Cleaning remaining pages from readahead list",
                                 bytes_read, offset));
-                        /* BB turn off caching and do new lookup on 
+                        /* BB turn off caching and do new lookup on
                           file size at server? */
                        break;
                }
                if (smb_read_data) {
-                        if(buf_type == CIFS_SMALL_BUFFER)
+                        if (buf_type == CIFS_SMALL_BUFFER)
                                cifs_small_buf_release(smb_read_data);
-                        else if(buf_type == CIFS_LARGE_BUFFER)
+                        else if (buf_type == CIFS_LARGE_BUFFER)
                                cifs_buf_release(smb_read_data);
                        smb_read_data = NULL;
                }
@@ -1829,12 +1834,12 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
 /* need to free smb_read_data buf before exit */
        if (smb_read_data) {
-                if(buf_type == CIFS_SMALL_BUFFER)
+                if (buf_type == CIFS_SMALL_BUFFER)
                        cifs_small_buf_release(smb_read_data);
-                else if(buf_type == CIFS_LARGE_BUFFER)
+                else if (buf_type == CIFS_LARGE_BUFFER)
                        cifs_buf_release(smb_read_data);
                smb_read_data = NULL;
-        } 
+        }
        FreeXid(xid);
        return rc;
@@ -1849,26 +1854,26 @@ static int cifs_readpage_worker(struct file *file, struct page *page,
        page_cache_get(page);
        read_data = kmap(page);
        /* for reads over a certain size could initiate async read ahead */
-                                                                                                                           
        rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
-                                                                                                                           
        if (rc < 0)
                goto io_error;
        else
-                cFYI(1, ("Bytes read %d",rc));
+                cFYI(1, ("Bytes read %d", rc));
-                                                                                                                           
        file->f_path.dentry->d_inode->i_atime =
                current_fs_time(file->f_path.dentry->d_inode->i_sb);
-                                                                                                                           
        if (PAGE_CACHE_SIZE > rc)
                memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
        flush_dcache_page(page);
        SetPageUptodate(page);
        rc = 0;
-                                                                                                                           
 io_error:
-        kunmap(page);
+        kunmap(page);
        page_cache_release(page);
        return rc;
 }
@@ -1886,7 +1891,7 @@ static int cifs_readpage(struct file *file, struct page *page)
                return -EBADF;
        }
-        cFYI(1, ("readpage %p at offset %d 0x%x\n", 
+        cFYI(1, ("readpage %p at offset %d 0x%x\n",
                 page, (int)offset, (int)offset));
        rc = cifs_readpage_worker(file, page, &offset);
@@ -1900,7 +1905,7 @@ static int cifs_readpage(struct file *file, struct page *page)
 /* We do not want to update the file size from server for inodes
   open for write - to avoid races with writepage extending
   the file - in the future we could consider allowing
-   refreshing the inode only on increases in the file size 
+   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)
@@ -1910,7 +1915,7 @@ int is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
        if (cifsInode)
                open_file =  find_writable_file(cifsInode);
 
-        if(open_file) {
+        if (open_file) {
                struct cifs_sb_info *cifs_sb;
                /* there is not actually a write pending so let
@@ -1920,12 +1925,12 @@ int is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
                cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
                if ( cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO ) {
-                        /* since no page cache to corrupt on directio 
+                        /* since no page cache to corrupt on directio
                        we can change size safely */
                        return 1;
                }
-                if(i_size_read(&cifsInode->vfs_inode) < end_of_file)
+                if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
                        return 1;
                return 0;
@@ -1940,7 +1945,7 @@ static int cifs_prepare_write(struct file *file, struct page *page,
        loff_t i_size;
        loff_t offset;
-        cFYI(1, ("prepare write for page %p from %d to %d",page,from,to));
+        cFYI(1, ("prepare write for page %p from %d to %d", page, from, to));
        if (PageUptodate(page))
                return 0;
@@ -1979,8 +1984,8 @@ static int cifs_prepare_write(struct file *file, struct page *page,
                   this will be written out by commit_write so is fine */
        }
-        /* we do not need to pass errors back 
+        /* we do not need to pass errors back
-           e.g. if we do not have read access to the file 
+           e.g. if we do not have read access to the file
           because cifs_commit_write will do the right thing.  -- shaggy */
        return 0;
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index f0ff12b3f398..d8ae20f1a47a 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -57,14 +57,14 @@ int cifs_get_inode_info_unix(struct inode **pinode,
                        if (tmp_path == NULL) {
                                return -ENOMEM;
                        }
-                        /* have to skip first of the double backslash of
+                        /* have to skip first of the double backslash of
                           UNC name */
                        strncpy(tmp_path, pTcon->treeName, MAX_TREE_SIZE);
                        strncat(tmp_path, search_path, MAX_PATHCONF);
                        rc = connect_to_dfs_path(xid, pTcon->ses,
                                                 /* treename + */ tmp_path,
-                                                 cifs_sb->local_nls, 
+                                                 cifs_sb->local_nls,
-                                                 cifs_sb->mnt_cifs_flags & 
+                                                 cifs_sb->mnt_cifs_flags &
                                                    CIFS_MOUNT_MAP_SPECIAL_CHR);
                        kfree(tmp_path);
@@ -81,7 +81,7 @@ int cifs_get_inode_info_unix(struct inode **pinode,
                /* get new inode */
                if (*pinode == NULL) {
                        *pinode = new_inode(sb);
-                        if (*pinode == NULL) 
+                        if (*pinode == NULL)
                                return -ENOMEM;
                        /* Is an i_ino of zero legal? */
                        /* Are there sanity checks we can use to ensure that
@@ -103,7 +103,7 @@ int cifs_get_inode_info_unix(struct inode **pinode,
                cifsInfo->time = jiffies;
                cFYI(1, ("New time %ld", cifsInfo->time));
                /* this is ok to set on every inode revalidate */
-                atomic_set(&cifsInfo->inUse,1);
+                atomic_set(&cifsInfo->inUse, 1);
                inode->i_atime =
                    cifs_NTtimeToUnix(le64_to_cpu(findData.LastAccessTime));
@@ -114,8 +114,8 @@ int cifs_get_inode_info_unix(struct inode **pinode,
                    cifs_NTtimeToUnix(le64_to_cpu(findData.LastStatusChange));
                inode->i_mode = le64_to_cpu(findData.Permissions);
                /* since we set the inode type below we need to mask off
-                   to avoid strange results if bits set above */
+                   to avoid strange results if bits set above */
-                        inode->i_mode &= ~S_IFMT;
+                        inode->i_mode &= ~S_IFMT;
                if (type == UNIX_FILE) {
                        inode->i_mode |= S_IFREG;
                } else if (type == UNIX_SYMLINK) {
@@ -137,7 +137,7 @@ int cifs_get_inode_info_unix(struct inode **pinode,
                } else {
                        /* safest to call it a file if we do not know */
                        inode->i_mode |= S_IFREG;
-                        cFYI(1,("unknown type %d",type));
+                        cFYI(1, ("unknown type %d", type));
                }
                
                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
@@ -183,17 +183,17 @@ int cifs_get_inode_info_unix(struct inode **pinode,
                        inode->i_op = &cifs_file_inode_ops;
                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
                                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
-                                        inode->i_fop = 
+                                        inode->i_fop =
                                                &cifs_file_direct_nobrl_ops;
                                else
                                        inode->i_fop = &cifs_file_direct_ops;
                        } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
                                inode->i_fop = &cifs_file_nobrl_ops;
-                        else /* not direct, send byte range locks */ 
+                        else /* not direct, send byte range locks */
                                inode->i_fop = &cifs_file_ops;
                        /* check if server can support readpages */
-                        if (pTcon->ses->server->maxBuf < 
+                        if (pTcon->ses->server->maxBuf <
                            PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
                                inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
                        else
@@ -215,7 +215,7 @@ int cifs_get_inode_info_unix(struct inode **pinode,
        return rc;
 }
-static int decode_sfu_inode(struct inode * inode, __u64 size,
+static int decode_sfu_inode(struct inode *inode, __u64 size,
                            const unsigned char *path,
                            struct cifs_sb_info *cifs_sb, int xid)
 {
@@ -225,7 +225,7 @@ static int decode_sfu_inode(struct inode * inode, __u64 size,
        struct cifsTconInfo *pTcon = cifs_sb->tcon;
        char buf[24];
        unsigned int bytes_read;
-        char * pbuf;
+        char *pbuf;
        pbuf = buf;
@@ -241,16 +241,16 @@ static int decode_sfu_inode(struct inode * inode, __u64 size,
                         cifs_sb->local_nls,
                         cifs_sb->mnt_cifs_flags &
                                CIFS_MOUNT_MAP_SPECIAL_CHR);
-        if (rc==0) {
+        if (rc == 0) {
                int buf_type = CIFS_NO_BUFFER;
                        /* Read header */
                rc = CIFSSMBRead(xid, pTcon,
-                                 netfid,
+                                 netfid,
                                 24 /* length */, 0 /* offset */,
                                 &bytes_read, &pbuf, &buf_type);
                if ((rc == 0) && (bytes_read >= 8)) {
                        if (memcmp("IntxBLK", pbuf, 8) == 0) {
-                                cFYI(1,("Block device"));
+                                cFYI(1, ("Block device"));
                                inode->i_mode |= S_IFBLK;
                                if (bytes_read == 24) {
                                        /* we have enough to decode dev num */
@@ -261,7 +261,7 @@ static int decode_sfu_inode(struct inode * inode, __u64 size,
                                        inode->i_rdev = MKDEV(mjr, mnr);
                                }
                        } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
-                                cFYI(1,("Char device"));
+                                cFYI(1, ("Char device"));
                                inode->i_mode |= S_IFCHR;
                                if (bytes_read == 24) {
                                        /* we have enough to decode dev num */
@@ -270,18 +270,18 @@ static int decode_sfu_inode(struct inode * inode, __u64 size,
                                        mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
                                        mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
                                        inode->i_rdev = MKDEV(mjr, mnr);
-                                }
+                                }
                        } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
-                                cFYI(1,("Symlink"));
+                                cFYI(1, ("Symlink"));
                                inode->i_mode |= S_IFLNK;
                        } else {
                                inode->i_mode |= S_IFREG; /* file? */
-                                rc = -EOPNOTSUPP; 
+                                rc = -EOPNOTSUPP;
                        }
                } else {
                        inode->i_mode |= S_IFREG; /* then it is a file */
-                        rc = -EOPNOTSUPP; /* or some unknown SFU type */        
+                        rc = -EOPNOTSUPP; /* or some unknown SFU type */
-                }               
+                }
                CIFSSMBClose(xid, pTcon, netfid);
        }
        return rc;
@@ -290,7 +290,7 @@ static int decode_sfu_inode(struct inode * inode, __u64 size,
 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID)  /* SETFILEBITS valid bits */
-static int get_sfu_uid_mode(struct inode * inode,
+static int get_sfu_uid_mode(struct inode *inode,
                        const unsigned char *path,
                        struct cifs_sb_info *cifs_sb, int xid)
 {
@@ -301,15 +301,15 @@ static int get_sfu_uid_mode(struct inode * inode,
        rc = CIFSSMBQueryEA(xid, cifs_sb->tcon, path, "SETFILEBITS",
                        ea_value, 4 /* size of buf */, cifs_sb->local_nls,
-                        cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
+                cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
        if (rc < 0)
                return (int)rc;
        else if (rc > 3) {
                mode = le32_to_cpu(*((__le32 *)ea_value));
-                inode->i_mode &= ~SFBITS_MASK; 
+                inode->i_mode &= ~SFBITS_MASK;
-                cFYI(1,("special bits 0%o org mode 0%o", mode, inode->i_mode));
+                cFYI(1, ("special bits 0%o org mode 0%o", mode, inode->i_mode));
                inode->i_mode = (mode &  SFBITS_MASK) | inode->i_mode;
-                cFYI(1,("special mode bits 0%o", mode));
+                cFYI(1, ("special mode bits 0%o", mode));
                return 0;
        } else {
                return 0;
@@ -334,11 +334,11 @@ int cifs_get_inode_info(struct inode **pinode,
        int adjustTZ = FALSE;
        pTcon = cifs_sb->tcon;
-        cFYI(1,("Getting info on %s", search_path));
+        cFYI(1, ("Getting info on %s", search_path));
        if ((pfindData == NULL) && (*pinode != NULL)) {
                if (CIFS_I(*pinode)->clientCanCacheRead) {
-                        cFYI(1,("No need to revalidate cached inode sizes"));
+                        cFYI(1, ("No need to revalidate cached inode sizes"));
                        return rc;
                }
        }
@@ -359,7 +359,7 @@ int cifs_get_inode_info(struct inode **pinode,
                failed at least once - set flag in tcon or mount */
                if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
                        rc = SMBQueryInformation(xid, pTcon, search_path,
-                                        pfindData, cifs_sb->local_nls, 
+                                        pfindData, cifs_sb->local_nls,
                                        cifs_sb->mnt_cifs_flags &
                                          CIFS_MOUNT_MAP_SPECIAL_CHR);
                        adjustTZ = TRUE;
@@ -384,8 +384,8 @@ int cifs_get_inode_info(struct inode **pinode,
                        strncat(tmp_path, search_path, MAX_PATHCONF);
                        rc = connect_to_dfs_path(xid, pTcon->ses,
                                                 /* treename + */ tmp_path,
-                                                 cifs_sb->local_nls, 
+                                                 cifs_sb->local_nls,
-                                                 cifs_sb->mnt_cifs_flags & 
+                                                 cifs_sb->mnt_cifs_flags &
                                                   CIFS_MOUNT_MAP_SPECIAL_CHR);
                        kfree(tmp_path);
                        /* BB fix up inode etc. */
@@ -419,17 +419,17 @@ int cifs_get_inode_info(struct inode **pinode,
                           there Windows server or network appliances for which
                           IndexNumber field is not guaranteed unique? */
-                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM){
+                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
                                int rc1 = 0;
                                __u64 inode_num;
-                                rc1 = CIFSGetSrvInodeNumber(xid, pTcon, 
+                                rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
-                                        search_path, &inode_num, 
+                                        search_path, &inode_num,
                                        cifs_sb->local_nls,
                                        cifs_sb->mnt_cifs_flags &
                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
                                if (rc1) {
-                                        cFYI(1,("GetSrvInodeNum rc %d", rc1));
+                                        cFYI(1, ("GetSrvInodeNum rc %d", rc1));
                                        /* BB EOPNOSUPP disable SERVER_INUM? */
                                } else /* do we need cast or hash to ino? */
                                        (*pinode)->i_ino = inode_num;
@@ -463,7 +463,7 @@ int cifs_get_inode_info(struct inode **pinode,
                cFYI(0, ("Attributes came in as 0x%x", attr));
                if (adjustTZ && (pTcon->ses) && (pTcon->ses->server)) {
                        inode->i_ctime.tv_sec += pTcon->ses->server->timeAdj;
-                        inode->i_mtime.tv_sec += pTcon->ses->server->timeAdj;
+                        inode->i_mtime.tv_sec += pTcon->ses->server->timeAdj;
                }
                /* set default mode. will override for dirs below */
@@ -471,8 +471,9 @@ int cifs_get_inode_info(struct inode **pinode,
                        /* new inode, can safely set these fields */
                        inode->i_mode = cifs_sb->mnt_file_mode;
                else /* since we set the inode type below we need to mask off
-                     to avoid strange results if type changes and both get orred in */ 
+                     to avoid strange results if type changes and both
-                        inode->i_mode &= ~S_IFMT; 
+                     get orred in */
+                        inode->i_mode &= ~S_IFMT;
 /*              if (attr & ATTR_REPARSE)  */
                /* We no longer handle these as symlinks because we could not
                   follow them due to the absolute path with drive letter */
@@ -490,13 +491,13 @@ int cifs_get_inode_info(struct inode **pinode,
 /* BB Finish for SFU style symlinks and devices */
                } else if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) &&
                           (cifsInfo->cifsAttrs & ATTR_SYSTEM)) {
-                        if (decode_sfu_inode(inode, 
+                        if (decode_sfu_inode(inode,
                                         le64_to_cpu(pfindData->EndOfFile),
                                         search_path,
                                         cifs_sb, xid)) {
-                                cFYI(1,("Unrecognized sfu inode type"));
+                                cFYI(1, ("Unrecognized sfu inode type"));
                        }
-                        cFYI(1,("sfu mode 0%o",inode->i_mode));
+                        cFYI(1, ("sfu mode 0%o", inode->i_mode));
                } else {
                        inode->i_mode |= S_IFREG;
                        /* treat the dos attribute of read-only as read-only
@@ -517,7 +518,7 @@ int cifs_get_inode_info(struct inode **pinode,
                if (is_size_safe_to_change(cifsInfo, le64_to_cpu(pfindData->EndOfFile))) {
                        /* can not safely shrink the file size here if the
                           client is writing to it due to potential races */
-                        i_size_write(inode,le64_to_cpu(pfindData->EndOfFile));
+                        i_size_write(inode, le64_to_cpu(pfindData->EndOfFile));
                        /* 512 bytes (2**9) is the fake blocksize that must be
                           used for this calculation */
@@ -528,7 +529,7 @@ int cifs_get_inode_info(struct inode **pinode,
                inode->i_nlink = le32_to_cpu(pfindData->NumberOfLinks);
-                /* BB fill in uid and gid here? with help from winbind? 
+                /* BB fill in uid and gid here? with help from winbind?
                   or retrieve from NTFS stream extended attribute */
                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
                        /* fill in uid, gid, mode from server ACL */
@@ -540,7 +541,7 @@ int cifs_get_inode_info(struct inode **pinode,
                        inode->i_gid = cifs_sb->mnt_gid;
                        /* set so we do not keep refreshing these fields with
                           bad data after user has changed them in memory */
-                        atomic_set(&cifsInfo->inUse,1);
+                        atomic_set(&cifsInfo->inUse, 1);
                }
                if (S_ISREG(inode->i_mode)) {
@@ -557,7 +558,7 @@ int cifs_get_inode_info(struct inode **pinode,
                        else /* not direct, send byte range locks */
                                inode->i_fop = &cifs_file_ops;
-                        if (pTcon->ses->server->maxBuf < 
+                        if (pTcon->ses->server->maxBuf <
                             PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
                                inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
                        else
@@ -587,9 +588,9 @@ void cifs_read_inode(struct inode *inode)
        cifs_sb = CIFS_SB(inode->i_sb);
        xid = GetXid();
        if (cifs_sb->tcon->ses->capabilities & CAP_UNIX)
-                cifs_get_inode_info_unix(&inode, "", inode->i_sb,xid);
+                cifs_get_inode_info_unix(&inode, "", inode->i_sb, xid);
        else
-                cifs_get_inode_info(&inode, "", NULL, inode->i_sb,xid);
+                cifs_get_inode_info(&inode, "", NULL, inode->i_sb, xid);
        /* can not call macro FreeXid here since in a void func */
        _FreeXid(xid);
 }
@@ -638,12 +639,12 @@ int cifs_unlink(struct inode *inode, struct dentry *direntry)
                rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, DELETE,
                                 CREATE_NOT_DIR | CREATE_DELETE_ON_CLOSE,
                                 &netfid, &oplock, NULL, cifs_sb->local_nls,
-                                 cifs_sb->mnt_cifs_flags & 
+                                 cifs_sb->mnt_cifs_flags &
                                        CIFS_MOUNT_MAP_SPECIAL_CHR);
-                if (rc==0) {
+                if (rc == 0) {
                        CIFSSMBRenameOpenFile(xid, pTcon, netfid, NULL,
-                                              cifs_sb->local_nls, 
+                                              cifs_sb->local_nls,
-                                              cifs_sb->mnt_cifs_flags & 
+                                              cifs_sb->mnt_cifs_flags &
                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
                        CIFSSMBClose(xid, pTcon, netfid);
                        if (direntry->d_inode)
@@ -659,7 +660,7 @@ int cifs_unlink(struct inode *inode, struct dentry *direntry)
                                rc = CIFSSMBSetTimes(xid, pTcon, full_path,
                                                     pinfo_buf,
                                                     cifs_sb->local_nls,
-                                                     cifs_sb->mnt_cifs_flags & 
+                                                     cifs_sb->mnt_cifs_flags &
                                                        CIFS_MOUNT_MAP_SPECIAL_CHR);
                        else
                                rc = -EOPNOTSUPP;
@@ -670,7 +671,7 @@ int cifs_unlink(struct inode *inode, struct dentry *direntry)
                        /*      rc = CIFSSMBSetAttrLegacy(xid, pTcon,
                                                          full_path,
                                                          (__u16)ATTR_NORMAL,
-                                                          cifs_sb->local_nls); 
+                                                          cifs_sb->local_nls);
                           For some strange reason it seems that NT4 eats the
                           old setattr call without actually setting the
                           attributes so on to the third attempted workaround
@@ -683,9 +684,9 @@ int cifs_unlink(struct inode *inode, struct dentry *direntry)
                                                 FILE_WRITE_ATTRIBUTES, 0,
                                                 &netfid, &oplock, NULL,
                                                 cifs_sb->local_nls,
-                                                 cifs_sb->mnt_cifs_flags & 
+                                                 cifs_sb->mnt_cifs_flags &
                                                    CIFS_MOUNT_MAP_SPECIAL_CHR);
-                                if (rc==0) {
+                                if (rc == 0) {
                                        rc = CIFSSMBSetFileTimes(xid, pTcon,
                                                                 pinfo_buf,
                                                                 netfid);
@@ -694,10 +695,10 @@ int cifs_unlink(struct inode *inode, struct dentry *direntry)
                        }
                        kfree(pinfo_buf);
                }
-                if (rc==0) {
+                if (rc == 0) {
-                        rc = CIFSSMBDelFile(xid, pTcon, full_path, 
+                        rc = CIFSSMBDelFile(xid, pTcon, full_path,
-                                            cifs_sb->local_nls, 
+                                            cifs_sb->local_nls,
-                                            cifs_sb->mnt_cifs_flags & 
+                                            cifs_sb->mnt_cifs_flags &
                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
                        if (!rc) {
                                if (direntry->d_inode)
@@ -711,10 +712,10 @@ int cifs_unlink(struct inode *inode, struct dentry *direntry)
                                                 CREATE_NOT_DIR |
                                                 CREATE_DELETE_ON_CLOSE,
                                                 &netfid, &oplock, NULL,
-                                                 cifs_sb->local_nls, 
+                                                 cifs_sb->local_nls,
-                                                 cifs_sb->mnt_cifs_flags & 
+                                                 cifs_sb->mnt_cifs_flags &
                                                    CIFS_MOUNT_MAP_SPECIAL_CHR);
-                                if (rc==0) {
+                                if (rc == 0) {
                                        CIFSSMBRenameOpenFile(xid, pTcon,
                                                netfid, NULL,
                                                cifs_sb->local_nls,
@@ -773,8 +774,8 @@ static void posix_fill_in_inode(struct inode *tmp_inode,
        tmp_inode->i_mode = le64_to_cpu(pData->Permissions);
        /* since we set the inode type below we need to mask off type
-           to avoid strange results if bits above were corrupt */
+           to avoid strange results if bits above were corrupt */
-        tmp_inode->i_mode &= ~S_IFMT;
+        tmp_inode->i_mode &= ~S_IFMT;
        if (type == UNIX_FILE) {
                *pobject_type = DT_REG;
                tmp_inode->i_mode |= S_IFREG;
@@ -804,11 +805,11 @@ static void posix_fill_in_inode(struct inode *tmp_inode,
                /* safest to just call it a file */
                *pobject_type = DT_REG;
                tmp_inode->i_mode |= S_IFREG;
-                cFYI(1,("unknown inode type %d",type)); 
+                cFYI(1, ("unknown inode type %d", type));
        }
 #ifdef CONFIG_CIFS_DEBUG2
-        cFYI(1,("object type: %d", type));
+        cFYI(1, ("object type: %d", type));
 #endif
        tmp_inode->i_uid = le64_to_cpu(pData->Uid);
        tmp_inode->i_gid = le64_to_cpu(pData->Gid);
@@ -816,7 +817,7 @@ static void posix_fill_in_inode(struct inode *tmp_inode,
        spin_lock(&tmp_inode->i_lock);
        if (is_size_safe_to_change(cifsInfo, end_of_file)) {
-                /* can not safely change the file size here if the 
+                /* can not safely change the file size here if the
                client is writing to it due to potential races */
                i_size_write(tmp_inode, end_of_file);
@@ -830,27 +831,28 @@ static void posix_fill_in_inode(struct inode *tmp_inode,
                cFYI(1, ("File inode"));
                tmp_inode->i_op = &cifs_file_inode_ops;
-                if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
+                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
-                        if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
+                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
                                tmp_inode->i_fop = &cifs_file_direct_nobrl_ops;
                        else
                                tmp_inode->i_fop = &cifs_file_direct_ops;
                
-                } else if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
+                } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
                        tmp_inode->i_fop = &cifs_file_nobrl_ops;
                else
                        tmp_inode->i_fop = &cifs_file_ops;
-                if((cifs_sb->tcon) && (cifs_sb->tcon->ses) &&
+                if ((cifs_sb->tcon) && (cifs_sb->tcon->ses) &&
-                   (cifs_sb->tcon->ses->server->maxBuf < 
+                   (cifs_sb->tcon->ses->server->maxBuf <
                        PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE))
                        tmp_inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
                else
                        tmp_inode->i_data.a_ops = &cifs_addr_ops;
-                if(isNewInode)
+                if (isNewInode)
-                        return; /* No sense invalidating pages for new inode since we
+                        return; /* No sense invalidating pages for new inode
-                                           have not started caching readahead file data yet */
+                                   since we we have not started caching
+                                   readahead file data yet */
                if (timespec_equal(&tmp_inode->i_mtime, &local_mtime) &&
                        (local_size == tmp_inode->i_size)) {
@@ -869,10 +871,10 @@ static void posix_fill_in_inode(struct inode *tmp_inode,
                tmp_inode->i_op = &cifs_symlink_inode_ops;
 /* tmp_inode->i_fop = *//* do not need to set to anything */
        } else {
-                cFYI(1, ("Special inode")); 
+                cFYI(1, ("Special inode"));
                init_special_inode(tmp_inode, tmp_inode->i_mode,
                                   tmp_inode->i_rdev);
-        }       
+        }
 }
 int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
@@ -897,21 +899,21 @@ int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
                return -ENOMEM;
        }
        
-        if((pTcon->ses->capabilities & CAP_UNIX) && 
+        if ((pTcon->ses->capabilities & CAP_UNIX) &&
-                (CIFS_UNIX_POSIX_PATH_OPS_CAP & 
+                (CIFS_UNIX_POSIX_PATH_OPS_CAP &
                        le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
                u32 oplock = 0;
-                FILE_UNIX_BASIC_INFO * pInfo = 
+                FILE_UNIX_BASIC_INFO * pInfo =
                        kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
-                if(pInfo == NULL) {
+                if (pInfo == NULL) {
                        rc = -ENOMEM;
                        goto mkdir_out;
                }
                        
                rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
                                mode, NULL /* netfid */, pInfo, &oplock,
-                                full_path, cifs_sb->local_nls, 
+                                full_path, cifs_sb->local_nls,
-                                cifs_sb->mnt_cifs_flags & 
+                                cifs_sb->mnt_cifs_flags &
                                        CIFS_MOUNT_MAP_SPECIAL_CHR);
                if (rc) {
                        cFYI(1, ("posix mkdir returned 0x%x", rc));
@@ -919,8 +921,9 @@ int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
                } else {
                        int obj_type;
                        if (pInfo->Type == -1) /* no return info - go query */
-                                goto mkdir_get_info; 
+                                goto mkdir_get_info;
-/*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need to set uid/gid */
+/*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
+        to set uid/gid */
                        inc_nlink(inode);
                        if (pTcon->nocase)
                                direntry->d_op = &cifs_ci_dentry_ops;
@@ -937,7 +940,7 @@ int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
                                newinode->i_ino =
                                        (unsigned long)pInfo->UniqueId;
                        } /* note ino incremented to unique num in new_inode */
-                        if(inode->i_sb->s_flags & MS_NOATIME)
+                        if (inode->i_sb->s_flags & MS_NOATIME)
                                newinode->i_flags |= S_NOATIME | S_NOCMTIME;
                        newinode->i_nlink = 2;
@@ -949,17 +952,17 @@ int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
                        posix_fill_in_inode(direntry->d_inode,
                                        pInfo, &obj_type, 1 /* NewInode */);
 #ifdef CONFIG_CIFS_DEBUG2
-                        cFYI(1,("instantiated dentry %p %s to inode %p",
+                        cFYI(1, ("instantiated dentry %p %s to inode %p",
                                direntry, direntry->d_name.name, newinode));
-                        if(newinode->i_nlink != 2)
+                        if (newinode->i_nlink != 2)
-                                cFYI(1,("unexpected number of links %d",
+                                cFYI(1, ("unexpected number of links %d",
                                        newinode->i_nlink));
 #endif
                }
                kfree(pInfo);
                goto mkdir_out;
-        }       
+        }
        
        /* BB add setting the equivalent of mode via CreateX w/ACLs */
        rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
@@ -968,14 +971,14 @@ int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
                cFYI(1, ("cifs_mkdir returned 0x%x", rc));
                d_drop(direntry);
        } else {
-mkdir_get_info:         
+mkdir_get_info:
                inc_nlink(inode);
                if (pTcon->ses->capabilities & CAP_UNIX)
                        rc = cifs_get_inode_info_unix(&newinode, full_path,
-                                                      inode->i_sb,xid);
+                                                      inode->i_sb, xid);
                else
                        rc = cifs_get_inode_info(&newinode, full_path, NULL,
-                                                 inode->i_sb,xid);
+                                                 inode->i_sb, xid);
                if (pTcon->nocase)
                        direntry->d_op = &cifs_ci_dentry_ops;
@@ -983,9 +986,9 @@ mkdir_get_info:
                        direntry->d_op = &cifs_dentry_ops;
                d_instantiate(direntry, newinode);
                 /* setting nlink not necessary except in cases where we
-                  * failed to get it from the server or was set bogus */ 
+                  * 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; 
+                                direntry->d_inode->i_nlink = 2;
                if (cifs_sb->tcon->ses->capabilities & CAP_UNIX) {
                        mode &= ~current->fs->umask;
                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
@@ -1002,27 +1005,27 @@ mkdir_get_info:
                                                    mode, (__u64)-1,
                                                    (__u64)-1, 0 /* dev_t */,
                                                    cifs_sb->local_nls,
-                                                    cifs_sb->mnt_cifs_flags & 
+                                                    cifs_sb->mnt_cifs_flags &
                                                    CIFS_MOUNT_MAP_SPECIAL_CHR);
                        }
                } else {
                        /* BB to be implemented via Windows secrty descriptors
                           eg CIFSSMBWinSetPerms(xid, pTcon, full_path, mode,
                                                 -1, -1, local_nls); */
-                        if(direntry->d_inode) {
+                        if (direntry->d_inode) {
                                direntry->d_inode->i_mode = mode;
                                direntry->d_inode->i_mode |= S_IFDIR;
-                                if(cifs_sb->mnt_cifs_flags & 
+                                if (cifs_sb->mnt_cifs_flags &
                                     CIFS_MOUNT_SET_UID) {
-                                        direntry->d_inode->i_uid = 
+                                        direntry->d_inode->i_uid =
                                                current->fsuid;
-                                        direntry->d_inode->i_gid = 
+                                        direntry->d_inode->i_gid =
                                                current->fsgid;
                                }
                        }
                }
        }
-mkdir_out:      
+mkdir_out:
        kfree(full_path);
        FreeXid(xid);
        return rc;
@@ -1056,7 +1059,7 @@ int cifs_rmdir(struct inode *inode, struct dentry *direntry)
        if (!rc) {
                drop_nlink(inode);
                spin_lock(&direntry->d_inode->i_lock);
-                i_size_write(direntry->d_inode,0);
+                i_size_write(direntry->d_inode, 0);
                clear_nlink(direntry->d_inode);
                spin_unlock(&direntry->d_inode->i_lock);
        }
@@ -1121,7 +1124,7 @@ int cifs_rename(struct inode *source_inode, struct dentry *source_direntry,
                        info_buf_target = info_buf_source + 1;
                        if (pTcon->ses->capabilities & CAP_UNIX)
                                rc = CIFSSMBUnixQPathInfo(xid, pTcon, fromName,
-                                        info_buf_source, 
+                                        info_buf_source,
                                        cifs_sb_source->local_nls,
                                        cifs_sb_source->mnt_cifs_flags &
                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
@@ -1171,12 +1174,12 @@ int cifs_rename(struct inode *source_inode, struct dentry *source_direntry,
                   might not right be right access to request */
                rc = CIFSSMBOpen(xid, pTcon, fromName, FILE_OPEN, GENERIC_READ,
                                 CREATE_NOT_DIR, &netfid, &oplock, NULL,
-                                 cifs_sb_source->local_nls, 
+                                 cifs_sb_source->local_nls,
-                                 cifs_sb_source->mnt_cifs_flags & 
+                                 cifs_sb_source->mnt_cifs_flags &
                                        CIFS_MOUNT_MAP_SPECIAL_CHR);
-                if (rc==0) {
+                if (rc == 0) {
                        rc = CIFSSMBRenameOpenFile(xid, pTcon, netfid, toName,
-                                              cifs_sb_source->local_nls, 
+                                              cifs_sb_source->local_nls,
                                              cifs_sb_source->mnt_cifs_flags &
                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
                        CIFSSMBClose(xid, pTcon, netfid);
@@ -1249,7 +1252,7 @@ int cifs_revalidate(struct dentry *direntry)
        if (cifs_sb->tcon->ses->capabilities & CAP_UNIX) {
                rc = cifs_get_inode_info_unix(&direntry->d_inode, full_path,
-                                              direntry->d_sb,xid);
+                                              direntry->d_sb, xid);
                if (rc) {
                        cFYI(1, ("error on getting revalidate info %d", rc));
 /*                      if (rc != -ENOENT)
@@ -1258,7 +1261,7 @@ int cifs_revalidate(struct dentry *direntry)
                }
        } else {
                rc = cifs_get_inode_info(&direntry->d_inode, full_path, NULL,
-                                         direntry->d_sb,xid);
+                                         direntry->d_sb, xid);
                if (rc) {
                        cFYI(1, ("error on getting revalidate info %d", rc));
 /*                      if (rc != -ENOENT)
@@ -1271,7 +1274,7 @@ int cifs_revalidate(struct dentry *direntry)
        /* if not oplocked, we invalidate inode pages if mtime or file size
           had changed on server */
-        if (timespec_equal(&local_mtime,&direntry->d_inode->i_mtime) && 
+        if (timespec_equal(&local_mtime, &direntry->d_inode->i_mtime) &&
            (local_size == direntry->d_inode->i_size)) {
                cFYI(1, ("cifs_revalidate - inode unchanged"));
        } else {
@@ -1298,7 +1301,7 @@ int cifs_revalidate(struct dentry *direntry)
        if (invalidate_inode) {
        /* shrink_dcache not necessary now that cifs dentry ops
        are exported for negative dentries */
-/*              if(S_ISDIR(direntry->d_inode->i_mode)) 
+/*              if (S_ISDIR(direntry->d_inode->i_mode))
                        shrink_dcache_parent(direntry); */
                if (S_ISREG(direntry->d_inode->i_mode)) {
                        if (direntry->d_inode->i_mapping)
@@ -1351,7 +1354,7 @@ static int cifs_truncate_page(struct address_space *mapping, loff_t from)
        return rc;
 }
-static int cifs_vmtruncate(struct inode * inode, loff_t offset)
+static int cifs_vmtruncate(struct inode *inode, loff_t offset)
 {
        struct address_space *mapping = inode->i_mapping;
        unsigned long limit;
@@ -1424,7 +1427,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
        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);
-                if(rc < 0) {
+                if (rc < 0) {
                        FreeXid(xid);
                        return rc;
                } else
@@ -1459,16 +1462,16 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                        rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size,
                                                nfid, npid, FALSE);
                        atomic_dec(&open_file->wrtPending);
-                        cFYI(1,("SetFSize for attrs rc = %d", rc));
+                        cFYI(1, ("SetFSize for attrs rc = %d", rc));
-                        if((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
+                        if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
                                int bytes_written;
                                rc = CIFSSMBWrite(xid, pTcon,
                                                  nfid, 0, attrs->ia_size,
                                                  &bytes_written, NULL, NULL,
                                                  1 /* 45 seconds */);
-                                cFYI(1,("Wrt seteof rc %d", rc));
+                                cFYI(1, ("Wrt seteof rc %d", rc));
                        }
-                } else 
+                } else
                        rc = -EINVAL;
                if (rc != 0) {
@@ -1478,11 +1481,11 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                           it by handle */
                        rc = CIFSSMBSetEOF(xid, pTcon, full_path,
                                           attrs->ia_size, FALSE,
-                                           cifs_sb->local_nls, 
+                                           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)) {
+                        if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
                                __u16 netfid;
                                int oplock = FALSE;
@@ -1493,14 +1496,14 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                                        NULL, cifs_sb->local_nls,
                                        cifs_sb->mnt_cifs_flags &
                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
-                                if (rc==0) {
+                                if (rc == 0) {
                                        int bytes_written;
                                        rc = CIFSSMBWrite(xid, pTcon,
                                                        netfid, 0,
                                                        attrs->ia_size,
                                                        &bytes_written, NULL,
                                                        NULL, 1 /* 45 sec */);
-                                        cFYI(1,("wrt seteof rc %d",rc));
+                                        cFYI(1, ("wrt seteof rc %d", rc));
                                        CIFSSMBClose(xid, pTcon, netfid);
                                }
@@ -1517,7 +1520,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                        rc = cifs_vmtruncate(direntry->d_inode, attrs->ia_size);
                        cifs_truncate_page(direntry->d_inode->i_mapping,
                                           direntry->d_inode->i_size);
-                } else 
+                } else
                        goto cifs_setattr_exit;
        }
        if (attrs->ia_valid & ATTR_UID) {
@@ -1539,7 +1542,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
            && (attrs->ia_valid & (ATTR_MODE | ATTR_GID | ATTR_UID)))
                rc = CIFSSMBUnixSetPerms(xid, pTcon, full_path, mode, uid, gid,
                                         0 /* dev_t */, cifs_sb->local_nls,
-                                         cifs_sb->mnt_cifs_flags & 
+                                         cifs_sb->mnt_cifs_flags &
                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
        else if (attrs->ia_valid & ATTR_MODE) {
                rc = 0;
@@ -1559,7 +1562,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                        time_buf.Attributes = cpu_to_le32(cifsInode->cifsAttrs &
                                            (~ATTR_READONLY));
                        /* Windows ignores set to zero */
-                        if(time_buf.Attributes == 0)
+                        if (time_buf.Attributes == 0)
                                time_buf.Attributes |= cpu_to_le32(ATTR_NORMAL);
                }
                /* BB to be implemented -
@@ -1624,7 +1627,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                                         NULL, cifs_sb->local_nls,
                                         cifs_sb->mnt_cifs_flags &
                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
-                        if (rc==0) {
+                        if (rc == 0) {
                                rc = CIFSSMBSetFileTimes(xid, pTcon, &time_buf,
                                                         netfid);
                                CIFSSMBClose(xid, pTcon, netfid);
@@ -1634,7 +1637,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                           granularity */
                        /* rc = CIFSSMBSetTimesLegacy(xid, pTcon, full_path,
-                                        &time_buf, cifs_sb->local_nls); */
+                                        &time_buf, cifs_sb->local_nls); */
                        }
                }
                /* Even if error on time set, no sense failing the call if
@@ -1642,7 +1645,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                and this check ensures that we are not being called from
                sys_utimes in which case we ought to fail the call back to
                the user when the server rejects the call */
-                if((rc) && (attrs->ia_valid &
+                if ((rc) && (attrs->ia_valid &
                         (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
                        rc = 0;
        }
diff --git a/fs/cifs/ioctl.c b/fs/cifs/ioctl.c
index a414f1775ae0..d24fe6880a04 100644
--- a/fs/cifs/ioctl.c
+++ b/fs/cifs/ioctl.c
@@ -3,7 +3,7 @@
 *
 *   vfs operations that deal with io control
 *
- *   Copyright (C) International Business Machines  Corp., 2005
+ *   Copyright (C) International Business Machines  Corp., 2005,2007
 *   Author(s): Steve French (sfrench@us.ibm.com)
 *
 *   This library is free software; you can redistribute it and/or modify
@@ -30,7 +30,7 @@
 #define CIFS_IOC_CHECKUMOUNT _IO(0xCF, 2)
-int cifs_ioctl (struct inode * inode, struct file * filep,
+int cifs_ioctl (struct inode *inode, struct file *filep,
                unsigned int command, unsigned long arg)
 {
        int rc = -ENOTTY; /* strange error - but the precedent */
diff --git a/fs/cifs/link.c b/fs/cifs/link.c
index 6baea85d726e..41f657ced7ec 100644
--- a/fs/cifs/link.c
+++ b/fs/cifs/link.c
@@ -50,32 +50,32 @@ cifs_hardlink(struct dentry *old_file, struct inode *inode,
        fromName = build_path_from_dentry(old_file);
        toName = build_path_from_dentry(direntry);
-        if((fromName == NULL) || (toName == NULL)) {
+        if ((fromName == NULL) || (toName == NULL)) {
                rc = -ENOMEM;
                goto cifs_hl_exit;
        }
        if (cifs_sb_target->tcon->ses->capabilities & CAP_UNIX)
                rc = CIFSUnixCreateHardLink(xid, pTcon, fromName, toName,
-                                            cifs_sb_target->local_nls, 
+                                            cifs_sb_target->local_nls,
                                            cifs_sb_target->mnt_cifs_flags &
                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
        else {
                rc = CIFSCreateHardLink(xid, pTcon, fromName, toName,
-                                        cifs_sb_target->local_nls, 
+                                        cifs_sb_target->local_nls,
                                        cifs_sb_target->mnt_cifs_flags &
                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
-                if((rc == -EIO) || (rc == -EINVAL))
+                if ((rc == -EIO) || (rc == -EINVAL))
-                        rc = -EOPNOTSUPP;  
+                        rc = -EOPNOTSUPP;
        }
        d_drop(direntry);       /* force new lookup from server of target */
        /* if source file is cached (oplocked) revalidate will not go to server
           until the file is closed or oplock broken so update nlinks locally */
-        if(old_file->d_inode) {
+        if (old_file->d_inode) {
                cifsInode = CIFS_I(old_file->d_inode);
-                if(rc == 0) {
+                if (rc == 0) {
                        old_file->d_inode->i_nlink++;
 /* BB should we make this contingent on superblock flag NOATIME? */
 /*                      old_file->d_inode->i_ctime = CURRENT_TIME;*/
@@ -84,14 +84,14 @@ cifs_hardlink(struct dentry *old_file, struct inode *inode,
                        to set the parent dir cifs inode time to zero
                        to force revalidate (faster) for it too? */
                }
-                /* if not oplocked will force revalidate to get info 
+                /* if not oplocked will force revalidate to get info
                   on source file from srv */
                cifsInode->time = 0;
-                /* Will update parent dir timestamps from srv within a second.
+                /* Will update parent dir timestamps from srv within a second.
                   Would it really be worth it to set the parent dir (cifs
                   inode) time field to zero to force revalidate on parent
-                   directory faster ie 
+                   directory faster ie
                        CIFS_I(inode)->time = 0;  */
        }
@@ -109,7 +109,7 @@ cifs_follow_link(struct dentry *direntry, struct nameidata *nd)
        int rc = -EACCES;
        int xid;
        char *full_path = NULL;
-        char * target_path = ERR_PTR(-ENOMEM);
+        char *target_path = ERR_PTR(-ENOMEM);
        struct cifs_sb_info *cifs_sb;
        struct cifsTconInfo *pTcon;
@@ -129,7 +129,8 @@ cifs_follow_link(struct dentry *direntry, struct nameidata *nd)
                goto out;
        }
-/* BB add read reparse point symlink code and Unix extensions symlink code here BB */
+        /* BB add read reparse point symlink code and Unix extensions
+           symlink code here BB */
        if (pTcon->ses->capabilities & CAP_UNIX)
                rc = CIFSSMBUnixQuerySymLink(xid, pTcon, full_path,
                                             target_path,
@@ -176,7 +177,7 @@ cifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname)
        full_path = build_path_from_dentry(direntry);
-        if(full_path == NULL) {
+        if (full_path == NULL) {
                FreeXid(xid);
                return -ENOMEM;
        }
@@ -189,15 +190,16 @@ cifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname)
                rc = CIFSUnixCreateSymLink(xid, pTcon, full_path, symname,
                                           cifs_sb->local_nls);
        /* else
-           rc = CIFSCreateReparseSymLink(xid, pTcon, fromName, toName,cifs_sb_target->local_nls); */
+           rc = CIFSCreateReparseSymLink(xid, pTcon, fromName, toName,
+                                        cifs_sb_target->local_nls); */
        if (rc == 0) {
                if (pTcon->ses->capabilities & CAP_UNIX)
                        rc = cifs_get_inode_info_unix(&newinode, full_path,
-                                                      inode->i_sb,xid);
+                                                      inode->i_sb, xid);
                else
                        rc = cifs_get_inode_info(&newinode, full_path, NULL,
-                                                 inode->i_sb,xid);
+                                                 inode->i_sb, xid);
                if (rc != 0) {
                        cFYI(1, ("Create symlink ok, getinodeinfo fail rc = %d",
@@ -226,9 +228,9 @@ cifs_readlink(struct dentry *direntry, char __user *pBuffer, int buflen)
        struct cifs_sb_info *cifs_sb;
        struct cifsTconInfo *pTcon;
        char *full_path = NULL;
-        char *tmp_path =  NULL;
+        char *tmp_path = NULL;
-        char * tmpbuffer;
+        char *tmpbuffer;
-        unsigned char * referrals = NULL;
+        unsigned char *referrals = NULL;
        int num_referrals = 0;
        int len;
        __u16 fid;
@@ -237,13 +239,13 @@ cifs_readlink(struct dentry *direntry, char __user *pBuffer, int buflen)
        cifs_sb = CIFS_SB(inode->i_sb);
        pTcon = cifs_sb->tcon;
-/* BB would it be safe against deadlock to grab this sem 
+/* BB would it be safe against deadlock to grab this sem
      even though rename itself grabs the sem and calls lookup? */
 /*       mutex_lock(&inode->i_sb->s_vfs_rename_mutex);*/
        full_path = build_path_from_dentry(direntry);
 /*       mutex_unlock(&inode->i_sb->s_vfs_rename_mutex);*/
-        if(full_path == NULL) {
+        if (full_path == NULL) {
                FreeXid(xid);
                return -ENOMEM;
        }
@@ -251,70 +253,77 @@ cifs_readlink(struct dentry *direntry, char __user *pBuffer, int buflen)
        cFYI(1,
             ("Full path: %s inode = 0x%p pBuffer = 0x%p buflen = %d",
              full_path, inode, pBuffer, buflen));
-        if(buflen > PATH_MAX)
+        if (buflen > PATH_MAX)
                len = PATH_MAX;
        else
                len = buflen;
-        tmpbuffer = kmalloc(len,GFP_KERNEL);   
+        tmpbuffer = kmalloc(len, GFP_KERNEL);
-        if(tmpbuffer == NULL) {
+        if (tmpbuffer == NULL) {
                kfree(full_path);
                FreeXid(xid);
                return -ENOMEM;
        }
-/* BB add read reparse point symlink code and Unix extensions symlink code here BB */
+/* BB add read reparse point symlink code and
+        Unix extensions symlink code here BB */
        if (cifs_sb->tcon->ses->capabilities & CAP_UNIX)
                rc = CIFSSMBUnixQuerySymLink(xid, pTcon, full_path,
                                tmpbuffer,
                                len - 1,
                                cifs_sb->local_nls);
        else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
-                cERROR(1,("SFU style symlinks not implemented yet"));
+                cERROR(1, ("SFU style symlinks not implemented yet"));
                /* add open and read as in fs/cifs/inode.c */
        
        } else {
                rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, GENERIC_READ,
-                                OPEN_REPARSE_POINT,&fid, &oplock, NULL, 
+                                OPEN_REPARSE_POINT, &fid, &oplock, NULL,
-                                cifs_sb->local_nls, 
+                                cifs_sb->local_nls,
-                                cifs_sb->mnt_cifs_flags & 
+                                cifs_sb->mnt_cifs_flags &
                                        CIFS_MOUNT_MAP_SPECIAL_CHR);
-                if(!rc) {
+                if (!rc) {
                        rc = CIFSSMBQueryReparseLinkInfo(xid, pTcon, full_path,
                                tmpbuffer,
-                                len - 1, 
+                                len - 1,
                                fid,
                                cifs_sb->local_nls);
-                        if(CIFSSMBClose(xid, pTcon, fid)) {
+                        if (CIFSSMBClose(xid, pTcon, fid)) {
                                cFYI(1,("Error closing junction point (open for ioctl)"));
                        }
-                        if(rc == -EIO) {
+                        if (rc == -EIO) {
                                /* Query if DFS Junction */
                                tmp_path =
                                        kmalloc(MAX_TREE_SIZE + MAX_PATHCONF + 1,
                                                GFP_KERNEL);
                                if (tmp_path) {
-                                        strncpy(tmp_path, pTcon->treeName, MAX_TREE_SIZE);
+                                        strncpy(tmp_path, pTcon->treeName,
-                                        strncat(tmp_path, full_path, MAX_PATHCONF);
+                                                MAX_TREE_SIZE);
-                                        rc = get_dfs_path(xid, pTcon->ses, tmp_path,
+                                        strncat(tmp_path, full_path,
+                                                MAX_PATHCONF);
+                                        rc = get_dfs_path(xid, pTcon->ses,
+                                                tmp_path,
                                                cifs_sb->local_nls,
                                                &num_referrals, &referrals,
                                                cifs_sb->mnt_cifs_flags &
                                                    CIFS_MOUNT_MAP_SPECIAL_CHR);
-                                        cFYI(1,("Get DFS for %s rc = %d ",tmp_path, rc));
+                                        cFYI(1, ("Get DFS for %s rc = %d ",
-                                        if((num_referrals == 0) && (rc == 0))
+                                                tmp_path, rc));
+                                        if ((num_referrals == 0) && (rc == 0))
                                                rc = -EACCES;
                                        else {
-                                                cFYI(1,("num referral: %d",num_referrals));
+                                                cFYI(1, ("num referral: %d",
-                                                if(referrals) {
+                                                        num_referrals));
-                                                        cFYI(1,("referral string: %s",referrals));
+                                                if (referrals) {
-                                                        strncpy(tmpbuffer, referrals, len-1);                            
+                                                        cFYI(1,("referral string: %s", referrals));
+                                                        strncpy(tmpbuffer, referrals, len-1);
                                                }
                                        }
                                        kfree(referrals);
                                        kfree(tmp_path);
 }
-                                /* BB add code like else decode referrals then memcpy to
+                                /* BB add code like else decode referrals
-                                  tmpbuffer and free referrals string array BB */
+                                then memcpy to tmpbuffer and free referrals
+                                string array BB */
                        }
                }
        }
diff --git a/fs/cifs/md4.c b/fs/cifs/md4.c
index 46d62c9dda0f..b828a2e7d667 100644
--- a/fs/cifs/md4.c
+++ b/fs/cifs/md4.c
@@ -1,4 +1,4 @@
-/* 
+/*
   Unix SMB/Netbios implementation.
   Version 1.9.
   a implementation of MD4 designed for use in the SMB authentication protocol
@@ -170,7 +170,7 @@ mdfour(unsigned char *out, unsigned char *in, int n)
        while (n > 64) {
                copy64(M, in);
-                mdfour64(M,&A,&B, &C, &D);
+                mdfour64(M, &A, &B, &C, &D);
                in += 64;
                n -= 64;
        }
diff --git a/fs/cifs/md5.c b/fs/cifs/md5.c
index ccebf9b7eb86..e5c3e1212697 100644
--- a/fs/cifs/md5.c
+++ b/fs/cifs/md5.c
@@ -15,9 +15,9 @@
 * will fill a supplied 16-byte array with the digest.
 */
-/* This code slightly modified to fit into Samba by 
+/* This code slightly modified to fit into Samba by
-   abartlet@samba.org Jun 2001 
+   abartlet@samba.org Jun 2001
-   and to fit the cifs vfs by 
+   and to fit the cifs vfs by
   Steve French sfrench@us.ibm.com */
 #include <linux/string.h>
@@ -106,7 +106,7 @@ MD5Update(struct MD5Context *ctx, unsigned char const *buf, unsigned len)
 }
 /*
- * Final wrapup - pad to 64-byte boundary with the bit pattern 
+ * Final wrapup - pad to 64-byte boundary with the bit pattern
 * 1 0* (64-bit count of bits processed, MSB-first)
 */
 void
diff --git a/fs/cifs/misc.c b/fs/cifs/misc.c
index 0211e0651b50..7590fd3d958c 100644
--- a/fs/cifs/misc.c
+++ b/fs/cifs/misc.c
@@ -16,7 +16,7 @@
 *
 *   You should have received a copy of the GNU Lesser General Public License
 *   along with this library; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 #include <linux/slab.h>
@@ -32,12 +32,12 @@
 extern mempool_t *cifs_sm_req_poolp;
 extern mempool_t *cifs_req_poolp;
-extern struct task_struct * oplockThread;
+extern struct task_struct *oplockThread;
-/* The xid serves as a useful identifier for each incoming vfs request, 
+/* The xid serves as a useful identifier for each incoming vfs request,
-   in a similar way to the mid which is useful to track each sent smb, 
+   in a similar way to the mid which is useful to track each sent smb,
-   and CurrentXid can also provide a running counter (although it 
+   and CurrentXid can also provide a running counter (although it
-   will eventually wrap past zero) of the total vfs operations handled 
+   will eventually wrap past zero) of the total vfs operations handled
   since the cifs fs was mounted */
 unsigned int
@@ -50,7 +50,7 @@ _GetXid(void)
        if (GlobalTotalActiveXid > GlobalMaxActiveXid)
                GlobalMaxActiveXid = GlobalTotalActiveXid;      /* keep high water mark for number of simultaneous vfs ops in our filesystem */
        if (GlobalTotalActiveXid > 65000)
-                cFYI(1,("warning: more than 65000 requests active"));
+                cFYI(1, ("warning: more than 65000 requests active"));
        xid = GlobalCurrentXid++;
        spin_unlock(&GlobalMid_Lock);
        return xid;
@@ -144,9 +144,9 @@ cifs_buf_get(void)
 {
        struct smb_hdr *ret_buf = NULL;
-/* We could use negotiated size instead of max_msgsize - 
+/* We could use negotiated size instead of max_msgsize -
-   but it may be more efficient to always alloc same size 
+   but it may be more efficient to always alloc same size
-   albeit slightly larger than necessary and maxbuffersize 
+   albeit slightly larger than necessary and maxbuffersize
   defaults to this and can not be bigger */
        ret_buf =
            (struct smb_hdr *) mempool_alloc(cifs_req_poolp, GFP_KERNEL | GFP_NOFS);
@@ -172,7 +172,7 @@ cifs_buf_release(void *buf_to_free)
                /* cFYI(1, ("Null buffer passed to cifs_buf_release"));*/
                return;
        }
-        mempool_free(buf_to_free,cifs_req_poolp);
+        mempool_free(buf_to_free, cifs_req_poolp);
        atomic_dec(&bufAllocCount);
        return;
@@ -183,9 +183,9 @@ cifs_small_buf_get(void)
 {
        struct smb_hdr *ret_buf = NULL;
-/* We could use negotiated size instead of max_msgsize - 
+/* We could use negotiated size instead of max_msgsize -
-   but it may be more efficient to always alloc same size 
+   but it may be more efficient to always alloc same size
-   albeit slightly larger than necessary and maxbuffersize 
+   albeit slightly larger than necessary and maxbuffersize
   defaults to this and can not be bigger */
        ret_buf =
            (struct smb_hdr *) mempool_alloc(cifs_sm_req_poolp, GFP_KERNEL | GFP_NOFS);
@@ -209,30 +209,30 @@ cifs_small_buf_release(void *buf_to_free)
                cFYI(1, ("Null buffer passed to cifs_small_buf_release"));
                return;
        }
-        mempool_free(buf_to_free,cifs_sm_req_poolp);
+        mempool_free(buf_to_free, cifs_sm_req_poolp);
        atomic_dec(&smBufAllocCount);
        return;
 }
-/* 
+/*
        Find a free multiplex id (SMB mid). Otherwise there could be
        mid collisions which might cause problems, demultiplexing the
        wrong response to this request. Multiplex ids could collide if
        one of a series requests takes much longer than the others, or
        if a very large number of long lived requests (byte range
        locks or FindNotify requests) are pending.  No more than
-        64K-1 requests can be outstanding at one time.  If no 
+        64K-1 requests can be outstanding at one time.  If no
        mids are available, return zero.  A future optimization
        could make the combination of mids and uid the key we use
-        to demultiplex on (rather than mid alone).  
+        to demultiplex on (rather than mid alone).
        In addition to the above check, the cifs demultiplex
        code already used the command code as a secondary
        check of the frame and if signing is negotiated the
        response would be discarded if the mid were the same
        but the signature was wrong.  Since the mid is not put in the
        pending queue until later (when it is about to be dispatched)
-        we do have to limit the number of outstanding requests 
+        we do have to limit the number of outstanding requests
        to somewhat less than 64K-1 although it is hard to imagine
        so many threads being in the vfs at one time.
 */
@@ -240,7 +240,7 @@ __u16 GetNextMid(struct TCP_Server_Info *server)
 {
        __u16 mid = 0;
        __u16 last_mid;
-        int   collision;  
+        int   collision;
        if (server == NULL)
                return mid;
@@ -249,13 +249,13 @@ __u16 GetNextMid(struct TCP_Server_Info *server)
        last_mid = server->CurrentMid; /* we do not want to loop forever */
        server->CurrentMid++;
        /* This nested loop looks more expensive than it is.
-        In practice the list of pending requests is short, 
+        In practice the list of pending requests is short,
        fewer than 50, and the mids are likely to be unique
        on the first pass through the loop unless some request
        takes longer than the 64 thousand requests before it
        (and it would also have to have been a request that
         did not time out) */
-        while(server->CurrentMid != last_mid) {
+        while (server->CurrentMid != last_mid) {
                struct list_head *tmp;
                struct mid_q_entry *mid_entry;
@@ -290,11 +290,11 @@ header_assemble(struct smb_hdr *buffer, char smb_command /* command */ ,
                const struct cifsTconInfo *treeCon, int word_count
                /* length of fixed section (word count) in two byte units  */)
 {
-        struct list_head* temp_item;
+        struct list_head *temp_item;
-        struct cifsSesInfo * ses;
+        struct cifsSesInfo *ses;
        char *temp = (char *) buffer;
-        memset(temp,0,256); /* bigger than MAX_CIFS_HDR_SIZE */
+        memset(temp, 0, 256); /* bigger than MAX_CIFS_HDR_SIZE */
        buffer->smb_buf_length =
            (2 * word_count) + sizeof (struct smb_hdr) -
@@ -348,7 +348,7 @@ header_assemble(struct smb_hdr *buffer, char smb_command /* command */ ,
                /*         flag were disabled.  */
                /*  BB Add support for establishing new tCon and SMB Session  */
-                /*      with userid/password pairs found on the smb session   */ 
+                /*      with userid/password pairs found on the smb session   */
                /*      for other target tcp/ip addresses               BB    */
                                if (current->fsuid != treeCon->ses->linux_uid) {
                                        cFYI(1,("Multiuser mode and UID did not match tcon uid"));
@@ -357,12 +357,12 @@ header_assemble(struct smb_hdr *buffer, char smb_command /* command */ ,
                                                ses = list_entry(temp_item, struct cifsSesInfo, cifsSessionList);
                                                if (ses->linux_uid == current->fsuid) {
                                                        if (ses->server == treeCon->ses->server) {
-                                                                cFYI(1,("found matching uid substitute right smb_uid"));  
+                                                                cFYI(1, ("found matching uid substitute right smb_uid"));
                                                                buffer->Uid = ses->Suid;
                                                                break;
                                                        } else {
-                                                                /* BB eventually call cifs_setup_session here */
+                                /* BB eventually call cifs_setup_session here */
-                                                                cFYI(1,("local UID found but smb sess with this server does not exist"));  
+                                                                cFYI(1, ("local UID found but no smb sess with this server exists"));
                                                        }
                                                }
                                        }
@@ -388,18 +388,18 @@ header_assemble(struct smb_hdr *buffer, char smb_command /* command */ ,
 static int
 checkSMBhdr(struct smb_hdr *smb, __u16 mid)
 {
-        /* Make sure that this really is an SMB, that it is a response, 
+        /* Make sure that this really is an SMB, that it is a response,
           and that the message ids match */
-        if ((*(__le32 *) smb->Protocol == cpu_to_le32(0x424d53ff)) && 
+        if ((*(__le32 *) smb->Protocol == cpu_to_le32(0x424d53ff)) &&
-                (mid == smb->Mid)) {    
+                (mid == smb->Mid)) {
                if (smb->Flags & SMBFLG_RESPONSE)
-                        return 0;                    
+                        return 0;
-                else {        
+                else {
                /* only one valid case where server sends us request */
                        if (smb->Command == SMB_COM_LOCKING_ANDX)
                                return 0;
                        else
-                                cERROR(1, ("Rcvd Request not response"));         
+                                cERROR(1, ("Received Request not response"));
                }
        } else { /* bad signature or mid */
                if (*(__le32 *) smb->Protocol != cpu_to_le32(0x424d53ff))
@@ -426,9 +426,9 @@ checkSMB(struct smb_hdr *smb, __u16 mid, unsigned int length)
                        smb->WordCount = 0;
                        /* some error cases do not return wct and bcc */
                        return 0;
-                } else if ((length == sizeof(struct smb_hdr) + 1) && 
+                } else if ((length == sizeof(struct smb_hdr) + 1) &&
                                (smb->WordCount == 0)) {
-                        char * tmp = (char *)smb;
+                        char *tmp = (char *)smb;
                        /* Need to work around a bug in two servers here */
                        /* First, check if the part of bcc they sent was zero */
                        if (tmp[sizeof(struct smb_hdr)] == 0) {
@@ -442,7 +442,7 @@ checkSMB(struct smb_hdr *smb, __u16 mid, unsigned int length)
                                tmp[sizeof(struct smb_hdr)+1] = 0;
                                return 0;
                        }
-                        cERROR(1,("rcvd invalid byte count (bcc)"));
+                        cERROR(1, ("rcvd invalid byte count (bcc)"));
                } else {
                        cERROR(1, ("Length less than smb header size"));
                }
@@ -468,15 +468,15 @@ checkSMB(struct smb_hdr *smb, __u16 mid, unsigned int length)
                if ((len > 64 * 1024) && (len > clc_len)) {
                        /* check if lengths match mod 64K */
                        if (((4 + len) & 0xFFFF) == (clc_len & 0xFFFF))
-                                return 0; /* bcc wrapped */                     
+                                return 0; /* bcc wrapped */
                }
                cFYI(1, ("Calculated size %d vs length %d mismatch for mid %d",
                                clc_len, 4 + len, smb->Mid));
                /* Windows XP can return a few bytes too much, presumably
-                an illegal pad, at the end of byte range lock responses 
+                an illegal pad, at the end of byte range lock responses
                so we allow for that three byte pad, as long as actual
                received length is as long or longer than calculated length */
-                /* We have now had to extend this more, since there is a 
+                /* We have now had to extend this more, since there is a
                case in which it needs to be bigger still to handle a
                malformed response to transact2 findfirst from WinXP when
                access denied is returned and thus bcc and wct are zero
@@ -495,37 +495,38 @@ checkSMB(struct smb_hdr *smb, __u16 mid, unsigned int length)
 }
 int
 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;
+        struct smb_com_lock_req *pSMB = (struct smb_com_lock_req *)buf;
        struct list_head *tmp;
        struct list_head *tmp1;
        struct cifsTconInfo *tcon;
        struct cifsFileInfo *netfile;
-        cFYI(1,("Checking for oplock break or dnotify response"));
+        cFYI(1, ("Checking for oplock break or dnotify response"));
        if ((pSMB->hdr.Command == SMB_COM_NT_TRANSACT) &&
           (pSMB->hdr.Flags & SMBFLG_RESPONSE)) {
-                struct smb_com_transaction_change_notify_rsp * pSMBr =
+                struct smb_com_transaction_change_notify_rsp *pSMBr =
                        (struct smb_com_transaction_change_notify_rsp *)buf;
-                struct file_notify_information * pnotify;
+                struct file_notify_information *pnotify;
                __u32 data_offset = 0;
                if (pSMBr->ByteCount > sizeof(struct file_notify_information)) {
                        data_offset = le32_to_cpu(pSMBr->DataOffset);
                        pnotify = (struct file_notify_information *)
                                ((char *)&pSMBr->hdr.Protocol + data_offset);
-                        cFYI(1,("dnotify on %s Action: 0x%x",pnotify->FileName,
+                        cFYI(1,("dnotify on %s Action: 0x%x", pnotify->FileName,
                                pnotify->Action));  /* BB removeme BB */
-                     /*   cifs_dump_mem("Rcvd notify Data: ",buf,
+                        /*   cifs_dump_mem("Rcvd notify Data: ",buf,
                                sizeof(struct smb_hdr)+60); */
                        return TRUE;
                }
                if (pSMBr->hdr.Status.CifsError) {
-                        cFYI(1,("notify err 0x%d",pSMBr->hdr.Status.CifsError));
+                        cFYI(1, ("notify err 0x%d",
+                                pSMBr->hdr.Status.CifsError));
                        return TRUE;
                }
                return FALSE;
-        }  
+        }
        if (pSMB->hdr.Command != SMB_COM_LOCKING_ANDX)
                return FALSE;
        if (pSMB->hdr.Flags & SMBFLG_RESPONSE) {
@@ -533,13 +534,13 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
                   break - harmless race between close request and oplock
                   break response is expected from time to time writing out
                   large dirty files cached on the client */
-                if ((NT_STATUS_INVALID_HANDLE) == 
+                if ((NT_STATUS_INVALID_HANDLE) ==
-                   le32_to_cpu(pSMB->hdr.Status.CifsError)) { 
+                   le32_to_cpu(pSMB->hdr.Status.CifsError)) {
-                        cFYI(1,("invalid handle on oplock break"));
+                        cFYI(1, ("invalid handle on oplock break"));
                        return TRUE;
-                } else if (ERRbadfid == 
+                } 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" */
                }
@@ -547,9 +548,10 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
        if (pSMB->hdr.WordCount != 8)
                return FALSE;
-        cFYI(1,(" oplock type 0x%d level 0x%d",pSMB->LockType,pSMB->OplockLevel));
+        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);
@@ -557,14 +559,14 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
                tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
                if ((tcon->tid == buf->Tid) && (srv == tcon->ses->server)) {
                        cifs_stats_inc(&tcon->num_oplock_brks);
-                        list_for_each(tmp1,&tcon->openFileList){
+                        list_for_each(tmp1, &tcon->openFileList) {
-                                netfile = list_entry(tmp1,struct cifsFileInfo,
+                                netfile = list_entry(tmp1, struct cifsFileInfo,
                                                     tlist);
                                if (pSMB->Fid == netfile->netfid) {
                                        struct cifsInodeInfo *pCifsInode;
                                        read_unlock(&GlobalSMBSeslock);
                                        cFYI(1,("file id match, oplock break"));
-                                        pCifsInode = 
+                                        pCifsInode =
                                                CIFS_I(netfile->pInode);
                                        pCifsInode->clientCanCacheAll = FALSE;
                                        if (pSMB->OplockLevel == 0)
@@ -581,12 +583,12 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
                                }
                        }
                        read_unlock(&GlobalSMBSeslock);
-                        cFYI(1,("No matching file for oplock break"));
+                        cFYI(1, ("No matching file for oplock break"));
                        return TRUE;
                }
        }
        read_unlock(&GlobalSMBSeslock);
-        cFYI(1,("Can not process oplock break for non-existent connection"));
+        cFYI(1, ("Can not process oplock break for non-existent connection"));
        return TRUE;
 }
@@ -643,13 +645,13 @@ dump_smb(struct smb_hdr *smb_buf, int smb_buf_length)
   only legal in POSIX-like OS (if they are present in the string). Path
   names are little endian 16 bit Unicode on the wire */
 int
-cifs_convertUCSpath(char *target, const __le16 * source, int maxlen,
+cifs_convertUCSpath(char *target, const __le16 *source, int maxlen,
-                    const struct nls_table * cp)
+                    const struct nls_table *cp)
 {
-        int i,j,len;
+        int i, j, len;
        __u16 src_char;
-        for(i = 0, j = 0; i < maxlen; i++) {
+        for (i = 0, j = 0; i < maxlen; i++) {
                src_char = le16_to_cpu(source[i]);
                switch (src_char) {
                        case 0:
@@ -678,8 +680,8 @@ cifs_convertUCSpath(char *target, const __le16 * source, int maxlen,
                        case UNI_LESSTHAN:
                                target[j] = '<';
                                break;
-                        default: 
+                        default:
-                                len = cp->uni2char(src_char, &target[j], 
+                                len = cp->uni2char(src_char, &target[j],
                                                NLS_MAX_CHARSET_SIZE);
                                if (len > 0) {
                                        j += len;
@@ -703,10 +705,10 @@ cUCS_out:
   only legal in POSIX-like OS (if they are present in the string). Path
   names are little endian 16 bit Unicode on the wire */
 int
-cifsConvertToUCS(__le16 * target, const char *source, int maxlen, 
+cifsConvertToUCS(__le16 *target, const char *source, int maxlen,
-                 const struct nls_table * cp, int mapChars)
+                 const struct nls_table *cp, int mapChars)
 {
-        int i,j,charlen;
+        int i, j, charlen;
        int len_remaining = maxlen;
        char src_char;
        __u16 temp;
@@ -714,7 +716,7 @@ cifsConvertToUCS(__le16 * target, const char *source, int maxlen,
        if (!mapChars)
                return cifs_strtoUCS(target, source, PATH_MAX, cp);
-        for(i = 0, j = 0; i < maxlen; j++) {
+        for (i = 0, j = 0; i < maxlen; j++) {
                src_char = source[i];
                switch (src_char) {
                        case 0:
@@ -737,7 +739,7 @@ cifsConvertToUCS(__le16 * target, const char *source, int maxlen,
                                break;
                        case '|':
                                target[j] = cpu_to_le16(UNI_PIPE);
-                                break;                  
+                                break;
                        /* BB We can not handle remapping slash until
                           all the calls to build_path_from_dentry
                           are modified, as they use slash as separator BB */
@@ -758,7 +760,7 @@ cifsConvertToUCS(__le16 * target, const char *source, int maxlen,
                                /* character may take more than one byte in the
                                   the source string, but will take exactly two
                                   bytes in the target string */
-                                i+= charlen;
+                                i += charlen;
                                continue;
                }
                i++; /* move to next char in source string */
diff --git a/fs/cifs/netmisc.c b/fs/cifs/netmisc.c
index 96c343247ea6..40ed5c9caad3 100644
--- a/fs/cifs/netmisc.c
+++ b/fs/cifs/netmisc.c
@@ -145,7 +145,7 @@ cifs_inet_pton(int address_family, char *cp, void *dst)
                ret = in6_pton(cp, -1 /* len */, dst , '\\', NULL);
        }
 #ifdef CONFIG_CIFS_DEBUG2
-        cFYI(1,("address conversion returned %d for %s", ret, cp));
+        cFYI(1, ("address conversion returned %d for %s", ret, cp));
 #endif
        if (ret > 0)
                ret = 1;