Patched in Tegra support.

1 files changed, 168 insertions, 101 deletions

diff --git a/fs/cifs/misc.c b/fs/cifs/misc.c
index 3a00c0d0cea..7c169339259 100644
--- a/fs/cifs/misc.c
+++ b/fs/cifs/misc.c
@@ -29,9 +29,6 @@
 #include "smberr.h"
 #include "nterr.h"
 #include "cifs_unicode.h"
-#ifdef CONFIG_CIFS_SMB2
-#include "smb2pdu.h"
-#endif
 
 extern mempool_t *cifs_sm_req_poolp;
 extern mempool_t *cifs_req_poolp;
@@ -43,7 +40,7 @@ extern mempool_t *cifs_req_poolp;
    since the cifs fs was mounted */
 
 unsigned int
-_get_xid(void)
+_GetXid(void)
 {
         unsigned int xid;
 
@@ -61,7 +58,7 @@ _get_xid(void)
 }
 
 void
-_free_xid(unsigned int xid)
+_FreeXid(unsigned int xid)
 {
         spin_lock(&GlobalMid_Lock);
         /* if (GlobalTotalActiveXid == 0)
@@ -146,27 +143,17 @@ struct smb_hdr *
 cifs_buf_get(void)
 {
         struct smb_hdr *ret_buf = NULL;
-        size_t buf_size = sizeof(struct smb_hdr);
-
-#ifdef CONFIG_CIFS_SMB2
-        /*
-         * SMB2 header is bigger than CIFS one - no problems to clean some
-         * more bytes for CIFS.
-         */
-        buf_size = sizeof(struct smb2_hdr);
-#endif
-        /*
-         * We could use negotiated size instead of max_msgsize -
-         * but it may be more efficient to always alloc same size
-         * albeit slightly larger than necessary and maxbuffersize
-         * defaults to this and can not be bigger.
-         */
+
+/* We could use negotiated size instead of max_msgsize -
+   but it may be more efficient to always alloc same size
+   albeit slightly larger than necessary and maxbuffersize
+   defaults to this and can not be bigger */
         ret_buf = mempool_alloc(cifs_req_poolp, GFP_NOFS);
 
         /* clear the first few header bytes */
         /* for most paths, more is cleared in header_assemble */
         if (ret_buf) {
-                memset(ret_buf, 0, buf_size + 3);
+                memset(ret_buf, 0, sizeof(struct smb_hdr) + 3);
                 atomic_inc(&bufAllocCount);
 #ifdef CONFIG_CIFS_STATS2
                 atomic_inc(&totBufAllocCount);
@@ -225,6 +212,85 @@ cifs_small_buf_release(void *buf_to_free)
         return;
 }
 
+/*
+        Find a free multiplex id (SMB mid). Otherwise there could be
+        mid collisions which might cause problems, demultiplexing the
+        wrong response to this request. Multiplex ids could collide if
+        one of a series requests takes much longer than the others, or
+        if a very large number of long lived requests (byte range
+        locks or FindNotify requests) are pending.  No more than
+        64K-1 requests can be outstanding at one time.  If no
+        mids are available, return zero.  A future optimization
+        could make the combination of mids and uid the key we use
+        to demultiplex on (rather than mid alone).
+        In addition to the above check, the cifs demultiplex
+        code already used the command code as a secondary
+        check of the frame and if signing is negotiated the
+        response would be discarded if the mid were the same
+        but the signature was wrong.  Since the mid is not put in the
+        pending queue until later (when it is about to be dispatched)
+        we do have to limit the number of outstanding requests
+        to somewhat less than 64K-1 although it is hard to imagine
+        so many threads being in the vfs at one time.
+*/
+__u16 GetNextMid(struct TCP_Server_Info *server)
+{
+        __u16 mid = 0;
+        __u16 last_mid;
+        bool collision;
+
+        spin_lock(&GlobalMid_Lock);
+        last_mid = server->CurrentMid; /* we do not want to loop forever */
+        server->CurrentMid++;
+        /* This nested loop looks more expensive than it is.
+        In practice the list of pending requests is short,
+        fewer than 50, and the mids are likely to be unique
+        on the first pass through the loop unless some request
+        takes longer than the 64 thousand requests before it
+        (and it would also have to have been a request that
+         did not time out) */
+        while (server->CurrentMid != last_mid) {
+                struct mid_q_entry *mid_entry;
+                unsigned int num_mids;
+
+                collision = false;
+                if (server->CurrentMid == 0)
+                        server->CurrentMid++;
+
+                num_mids = 0;
+                list_for_each_entry(mid_entry, &server->pending_mid_q, qhead) {
+                        ++num_mids;
+                        if (mid_entry->mid == server->CurrentMid &&
+                            mid_entry->midState == MID_REQUEST_SUBMITTED) {
+                                /* This mid is in use, try a different one */
+                                collision = true;
+                                break;
+                        }
+                }
+
+                /*
+                 * if we have more than 32k mids in the list, then something
+                 * is very wrong. Possibly a local user is trying to DoS the
+                 * box by issuing long-running calls and SIGKILL'ing them. If
+                 * we get to 2^16 mids then we're in big trouble as this
+                 * function could loop forever.
+                 *
+                 * Go ahead and assign out the mid in this situation, but force
+                 * an eventual reconnect to clean out the pending_mid_q.
+                 */
+                if (num_mids > 32768)
+                        server->tcpStatus = CifsNeedReconnect;
+
+                if (!collision) {
+                        mid = server->CurrentMid;
+                        break;
+                }
+                server->CurrentMid++;
+        }
+        spin_unlock(&GlobalMid_Lock);
+        return mid;
+}
+
 /* NB: MID can not be set if treeCon not passed in, in that
    case it is responsbility of caller to set the mid */
 void
@@ -232,6 +298,8 @@ header_assemble(struct smb_hdr *buffer, char smb_command /* command */ ,
                 const struct cifs_tcon *treeCon, int word_count
                 /* length of fixed section (word count) in two byte units  */)
 {
+        struct list_head *temp_item;
+        struct cifs_ses *ses;
         char *temp = (char *) buffer;
 
         memset(temp, 0, 256); /* bigger than MAX_CIFS_HDR_SIZE */
@@ -260,7 +328,52 @@ header_assemble(struct smb_hdr *buffer, char smb_command /* command */ ,
 
                         /* Uid is not converted */
                         buffer->Uid = treeCon->ses->Suid;
-                        buffer->Mid = get_next_mid(treeCon->ses->server);
+                        buffer->Mid = GetNextMid(treeCon->ses->server);
+                        if (multiuser_mount != 0) {
+                /* For the multiuser case, there are few obvious technically  */
+                /* possible mechanisms to match the local linux user (uid)    */
+                /* to a valid remote smb user (smb_uid):                      */
+                /*      1) Query Winbind (or other local pam/nss daemon       */
+                /*        for userid/password/logon_domain or credential      */
+                /*      2) Query Winbind for uid to sid to username mapping   */
+                /*         and see if we have a matching password for existing*/
+                /*         session for that user perhas getting password by   */
+                /*         adding a new pam_cifs module that stores passwords */
+                /*         so that the cifs vfs can get at that for all logged*/
+                /*         on users                                           */
+                /*      3) (Which is the mechanism we have chosen)            */
+                /*         Search through sessions to the same server for a   */
+                /*         a match on the uid that was passed in on mount     */
+                /*         with the current processes uid (or euid?) and use  */
+                /*         that smb uid.   If no existing smb session for     */
+                /*         that uid found, use the default smb session ie     */
+                /*         the smb session for the volume mounted which is    */
+                /*         the same as would be used if the multiuser mount   */
+                /*         flag were disabled.  */
+
+                /*  BB Add support for establishing new tCon and SMB Session  */
+                /*      with userid/password pairs found on the smb session   */
+                /*      for other target tcp/ip addresses               BB    */
+                                if (current_fsuid() != treeCon->ses->linux_uid) {
+                                        cFYI(1, "Multiuser mode and UID "
+                                                 "did not match tcon uid");
+                                        spin_lock(&cifs_tcp_ses_lock);
+                                        list_for_each(temp_item, &treeCon->ses->server->smb_ses_list) {
+                                                ses = list_entry(temp_item, struct cifs_ses, smb_ses_list);
+                                                if (ses->linux_uid == current_fsuid()) {
+                                                        if (ses->server == treeCon->ses->server) {
+                                                                cFYI(1, "found matching uid substitute right smb_uid");
+                                                                buffer->Uid = ses->Suid;
+                                                                break;
+                                                        } else {
+                                /* BB eventually call cifs_setup_session here */
+                                                                cFYI(1, "local UID found but no smb sess with this server exists");
+                                                        }
+                                                }
+                                        }
+                                        spin_unlock(&cifs_tcp_ses_lock);
+                                }
+                        }
                 }
                 if (treeCon->Flags & SMB_SHARE_IS_IN_DFS)
                         buffer->Flags2 |= SMBFLG2_DFS;
@@ -307,24 +420,19 @@ check_smb_hdr(struct smb_hdr *smb, __u16 mid)
 }
 
 int
-checkSMB(char *buf, unsigned int total_read)
+checkSMB(struct smb_hdr *smb, __u16 mid, unsigned int length)
 {
-        struct smb_hdr *smb = (struct smb_hdr *)buf;
-        __u16 mid = smb->Mid;
-        __u32 rfclen = be32_to_cpu(smb->smb_buf_length);
+        __u32 len = be32_to_cpu(smb->smb_buf_length);
         __u32 clc_len;  /* calculated length */
-        cFYI(0, "checkSMB Length: 0x%x, smb_buf_length: 0x%x",
-                total_read, rfclen);
+        cFYI(0, "checkSMB Length: 0x%x, smb_buf_length: 0x%x", length, len);
 
-        /* is this frame too small to even get to a BCC? */
-        if (total_read < 2 + sizeof(struct smb_hdr)) {
-                if ((total_read >= sizeof(struct smb_hdr) - 1)
+        if (length < 2 + sizeof(struct smb_hdr)) {
+                if ((length >= sizeof(struct smb_hdr) - 1)
                             && (smb->Status.CifsError != 0)) {
-                        /* it's an error return */
                         smb->WordCount = 0;
                         /* some error cases do not return wct and bcc */
                         return 0;
-                } else if ((total_read == sizeof(struct smb_hdr) + 1) &&
+                } else if ((length == sizeof(struct smb_hdr) + 1) &&
                                 (smb->WordCount == 0)) {
                         char *tmp = (char *)smb;
                         /* Need to work around a bug in two servers here */
@@ -344,35 +452,39 @@ checkSMB(char *buf, unsigned int total_read)
                 } else {
                         cERROR(1, "Length less than smb header size");
                 }
-                return -EIO;
+                return 1;
+        }
+        if (len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
+                cERROR(1, "smb length greater than MaxBufSize, mid=%d",
+                                   smb->Mid);
+                return 1;
         }
 
-        /* otherwise, there is enough to get to the BCC */
         if (check_smb_hdr(smb, mid))
-                return -EIO;
+                return 1;
         clc_len = smbCalcSize(smb);
 
-        if (4 + rfclen != total_read) {
+        if (4 + len != length) {
                 cERROR(1, "Length read does not match RFC1001 length %d",
-                                rfclen);
-                return -EIO;
+                           len);
+                return 1;
         }
 
-        if (4 + rfclen != clc_len) {
+        if (4 + len != clc_len) {
                 /* check if bcc wrapped around for large read responses */
-                if ((rfclen > 64 * 1024) && (rfclen > clc_len)) {
+                if ((len > 64 * 1024) && (len > clc_len)) {
                         /* check if lengths match mod 64K */
-                        if (((4 + rfclen) & 0xFFFF) == (clc_len & 0xFFFF))
+                        if (((4 + len) & 0xFFFF) == (clc_len & 0xFFFF))
                                 return 0; /* bcc wrapped */
                 }
                 cFYI(1, "Calculated size %u vs length %u mismatch for mid=%u",
-                                clc_len, 4 + rfclen, smb->Mid);
+                                clc_len, 4 + len, smb->Mid);
 
-                if (4 + rfclen < clc_len) {
+                if (4 + len < clc_len) {
                         cERROR(1, "RFC1001 size %u smaller than SMB for mid=%u",
-                                        rfclen, smb->Mid);
-                        return -EIO;
-                } else if (rfclen > clc_len + 512) {
+                                        len, smb->Mid);
+                        return 1;
+                } else if (len > clc_len + 512) {
                         /*
                          * Some servers (Windows XP in particular) send more
                          * data than the lengths in the SMB packet would
@@ -383,17 +495,16 @@ checkSMB(char *buf, unsigned int total_read)
                          * data to 512 bytes.
                          */
                         cERROR(1, "RFC1001 size %u more than 512 bytes larger "
-                                  "than SMB for mid=%u", rfclen, smb->Mid);
-                        return -EIO;
+                                  "than SMB for mid=%u", len, smb->Mid);
+                        return 1;
                 }
         }
         return 0;
 }
 
 bool
-is_valid_oplock_break(char *buffer, struct TCP_Server_Info *srv)
+is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
 {
-        struct smb_hdr *buf = (struct smb_hdr *)buffer;
         struct smb_com_lock_req *pSMB = (struct smb_com_lock_req *)buf;
         struct list_head *tmp, *tmp1, *tmp2;
         struct cifs_ses *ses;
@@ -461,12 +572,12 @@ is_valid_oplock_break(char *buffer, struct TCP_Server_Info *srv)
                         if (tcon->tid != buf->Tid)
                                 continue;
 
-                        cifs_stats_inc(&tcon->stats.cifs_stats.num_oplock_brks);
+                        cifs_stats_inc(&tcon->num_oplock_brks);
                         spin_lock(&cifs_file_list_lock);
                         list_for_each(tmp2, &tcon->openFileList) {
                                 netfile = list_entry(tmp2, struct cifsFileInfo,
                                                      tlist);
-                                if (pSMB->Fid != netfile->fid.netfid)
+                                if (pSMB->Fid != netfile->netfid)
                                         continue;
 
                                 cFYI(1, "file id match, oplock break");
@@ -474,7 +585,7 @@ is_valid_oplock_break(char *buffer, struct TCP_Server_Info *srv)
 
                                 cifs_set_oplock_level(pCifsInode,
                                         pSMB->OplockLevel ? OPLOCK_READ : 0);
-                                queue_work(cifsiod_wq,
+                                queue_work(system_nrt_wq,
                                            &netfile->oplock_break);
                                 netfile->oplock_break_cancelled = false;
 
@@ -494,15 +605,16 @@ is_valid_oplock_break(char *buffer, struct TCP_Server_Info *srv)
 }
 
 void
-dump_smb(void *buf, int smb_buf_length)
+dump_smb(struct smb_hdr *smb_buf, int smb_buf_length)
 {
         int i, j;
         char debug_line[17];
-        unsigned char *buffer = buf;
+        unsigned char *buffer;
 
         if (traceSMB == 0)
                 return;
 
+        buffer = (unsigned char *) smb_buf;
         for (i = 0, j = 0; i < smb_buf_length; i++, j++) {
                 if (i % 8 == 0) {
                         /* have reached the beginning of line */
@@ -564,48 +676,3 @@ void cifs_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock)
                 cinode->clientCanCacheRead = false;
         }
 }
-
-bool
-backup_cred(struct cifs_sb_info *cifs_sb)
-{
-        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID) {
-                if (cifs_sb->mnt_backupuid == current_fsuid())
-                        return true;
-        }
-        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID) {
-                if (in_group_p(cifs_sb->mnt_backupgid))
-                        return true;
-        }
-
-        return false;
-}
-
-void
-cifs_del_pending_open(struct cifs_pending_open *open)
-{
-        spin_lock(&cifs_file_list_lock);
-        list_del(&open->olist);
-        spin_unlock(&cifs_file_list_lock);
-}
-
-void
-cifs_add_pending_open_locked(struct cifs_fid *fid, struct tcon_link *tlink,
-                             struct cifs_pending_open *open)
-{
-#ifdef CONFIG_CIFS_SMB2
-        memcpy(open->lease_key, fid->lease_key, SMB2_LEASE_KEY_SIZE);
-#endif
-        open->oplock = CIFS_OPLOCK_NO_CHANGE;
-        open->tlink = tlink;
-        fid->pending_open = open;
-        list_add_tail(&open->olist, &tlink_tcon(tlink)->pending_opens);
-}
-
-void
-cifs_add_pending_open(struct cifs_fid *fid, struct tcon_link *tlink,
-                      struct cifs_pending_open *open)
-{
-        spin_lock(&cifs_file_list_lock);
-        cifs_add_pending_open_locked(fid, tlink, open);
-        spin_unlock(&cifs_file_list_lock);
-}