4 * Copyright (C) International Business Machines Corp., 2002,2008
5 * Author(s): Steve French (sfrench@us.ibm.com)
6 * Jeremy Allison (jra@samba.org) 2006.
8 * This library is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published
10 * by the Free Software Foundation; either version 2.1 of the License, or
11 * (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
16 * the GNU Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with this library; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include <linux/list.h>
25 #include <linux/gfp.h>
26 #include <linux/wait.h>
27 #include <linux/net.h>
28 #include <linux/delay.h>
29 #include <asm/uaccess.h>
30 #include <asm/processor.h>
31 #include <linux/mempool.h>
34 #include "cifsproto.h"
35 #include "cifs_debug.h"
37 extern mempool_t *cifs_mid_poolp;
40 wake_up_task(struct mid_q_entry *mid)
42 wake_up_process(mid->callback_data);
46 AllocMidQEntry(const struct smb_hdr *smb_buffer, struct TCP_Server_Info *server)
48 struct mid_q_entry *temp;
51 cERROR(1, "Null TCP session in AllocMidQEntry");
55 temp = mempool_alloc(cifs_mid_poolp, GFP_NOFS);
59 memset(temp, 0, sizeof(struct mid_q_entry));
60 temp->mid = smb_buffer->Mid; /* always LE */
61 temp->pid = current->pid;
62 temp->command = smb_buffer->Command;
63 cFYI(1, "For smb_command %d", temp->command);
64 /* do_gettimeofday(&temp->when_sent);*/ /* easier to use jiffies */
65 /* when mid allocated can be before when sent */
66 temp->when_alloc = jiffies;
69 * The default is for the mid to be synchronous, so the
70 * default callback just wakes up the current task.
72 temp->callback = wake_up_task;
73 temp->callback_data = current;
76 atomic_inc(&midCount);
77 temp->midState = MID_REQUEST_ALLOCATED;
82 DeleteMidQEntry(struct mid_q_entry *midEntry)
84 #ifdef CONFIG_CIFS_STATS2
87 midEntry->midState = MID_FREE;
88 atomic_dec(&midCount);
89 if (midEntry->largeBuf)
90 cifs_buf_release(midEntry->resp_buf);
92 cifs_small_buf_release(midEntry->resp_buf);
93 #ifdef CONFIG_CIFS_STATS2
95 /* commands taking longer than one second are indications that
96 something is wrong, unless it is quite a slow link or server */
97 if ((now - midEntry->when_alloc) > HZ) {
98 if ((cifsFYI & CIFS_TIMER) &&
99 (midEntry->command != SMB_COM_LOCKING_ANDX)) {
100 printk(KERN_DEBUG " CIFS slow rsp: cmd %d mid %d",
101 midEntry->command, midEntry->mid);
102 printk(" A: 0x%lx S: 0x%lx R: 0x%lx\n",
103 now - midEntry->when_alloc,
104 now - midEntry->when_sent,
105 now - midEntry->when_received);
109 mempool_free(midEntry, cifs_mid_poolp);
113 delete_mid(struct mid_q_entry *mid)
115 spin_lock(&GlobalMid_Lock);
116 list_del(&mid->qhead);
117 spin_unlock(&GlobalMid_Lock);
119 DeleteMidQEntry(mid);
123 smb_sendv(struct TCP_Server_Info *server, struct kvec *iov, int n_vec)
127 struct msghdr smb_msg;
128 struct smb_hdr *smb_buffer = iov[0].iov_base;
129 unsigned int len = iov[0].iov_len;
130 unsigned int total_len;
132 unsigned int smb_buf_length = smb_buffer->smb_buf_length;
133 struct socket *ssocket = server->ssocket;
136 return -ENOTSOCK; /* BB eventually add reconnect code here */
138 smb_msg.msg_name = (struct sockaddr *) &server->dstaddr;
139 smb_msg.msg_namelen = sizeof(struct sockaddr);
140 smb_msg.msg_control = NULL;
141 smb_msg.msg_controllen = 0;
142 if (server->noblocksnd)
143 smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL;
145 smb_msg.msg_flags = MSG_NOSIGNAL;
147 /* smb header is converted in header_assemble. bcc and rest of SMB word
148 area, and byte area if necessary, is converted to littleendian in
149 cifssmb.c and RFC1001 len is converted to bigendian in smb_send
150 Flags2 is converted in SendReceive */
154 for (i = 0; i < n_vec; i++)
155 total_len += iov[i].iov_len;
157 smb_buffer->smb_buf_length = cpu_to_be32(smb_buffer->smb_buf_length);
158 cFYI(1, "Sending smb: total_len %d", total_len);
159 dump_smb(smb_buffer, len);
163 rc = kernel_sendmsg(ssocket, &smb_msg, &iov[first_vec],
164 n_vec - first_vec, total_len);
165 if ((rc == -ENOSPC) || (rc == -EAGAIN)) {
167 /* if blocking send we try 3 times, since each can block
168 for 5 seconds. For nonblocking we have to try more
169 but wait increasing amounts of time allowing time for
170 socket to clear. The overall time we wait in either
171 case to send on the socket is about 15 seconds.
172 Similarly we wait for 15 seconds for
173 a response from the server in SendReceive[2]
174 for the server to send a response back for
175 most types of requests (except SMB Write
176 past end of file which can be slow, and
177 blocking lock operations). NFS waits slightly longer
178 than CIFS, but this can make it take longer for
179 nonresponsive servers to be detected and 15 seconds
180 is more than enough time for modern networks to
181 send a packet. In most cases if we fail to send
182 after the retries we will kill the socket and
183 reconnect which may clear the network problem.
185 if ((i >= 14) || (!server->noblocksnd && (i > 2))) {
186 cERROR(1, "sends on sock %p stuck for 15 seconds",
197 if (rc == total_len) {
200 } else if (rc > total_len) {
201 cERROR(1, "sent %d requested %d", rc, total_len);
205 /* should never happen, letting socket clear before
206 retrying is our only obvious option here */
207 cERROR(1, "tcp sent no data");
212 /* the line below resets i */
213 for (i = first_vec; i < n_vec; i++) {
214 if (iov[i].iov_len) {
215 if (rc > iov[i].iov_len) {
216 rc -= iov[i].iov_len;
219 iov[i].iov_base += rc;
220 iov[i].iov_len -= rc;
226 i = 0; /* in case we get ENOSPC on the next send */
229 if ((total_len > 0) && (total_len != smb_buf_length + 4)) {
230 cFYI(1, "partial send (%d remaining), terminating session",
232 /* If we have only sent part of an SMB then the next SMB
233 could be taken as the remainder of this one. We need
234 to kill the socket so the server throws away the partial
236 server->tcpStatus = CifsNeedReconnect;
240 cERROR(1, "Error %d sending data on socket to server", rc);
244 /* Don't want to modify the buffer as a
245 side effect of this call. */
246 smb_buffer->smb_buf_length = smb_buf_length;
252 smb_send(struct TCP_Server_Info *server, struct smb_hdr *smb_buffer,
253 unsigned int smb_buf_length)
257 iov.iov_base = smb_buffer;
258 iov.iov_len = smb_buf_length + 4;
260 return smb_sendv(server, &iov, 1);
263 static int wait_for_free_request(struct TCP_Server_Info *server,
266 if (long_op == CIFS_ASYNC_OP) {
267 /* oplock breaks must not be held up */
268 atomic_inc(&server->inFlight);
272 spin_lock(&GlobalMid_Lock);
274 if (atomic_read(&server->inFlight) >= cifs_max_pending) {
275 spin_unlock(&GlobalMid_Lock);
276 #ifdef CONFIG_CIFS_STATS2
277 atomic_inc(&server->num_waiters);
279 wait_event(server->request_q,
280 atomic_read(&server->inFlight)
282 #ifdef CONFIG_CIFS_STATS2
283 atomic_dec(&server->num_waiters);
285 spin_lock(&GlobalMid_Lock);
287 if (server->tcpStatus == CifsExiting) {
288 spin_unlock(&GlobalMid_Lock);
292 /* can not count locking commands against total
293 as they are allowed to block on server */
295 /* update # of requests on the wire to server */
296 if (long_op != CIFS_BLOCKING_OP)
297 atomic_inc(&server->inFlight);
298 spin_unlock(&GlobalMid_Lock);
305 static int allocate_mid(struct cifsSesInfo *ses, struct smb_hdr *in_buf,
306 struct mid_q_entry **ppmidQ)
308 if (ses->server->tcpStatus == CifsExiting) {
312 if (ses->server->tcpStatus == CifsNeedReconnect) {
313 cFYI(1, "tcp session dead - return to caller to retry");
317 if (ses->status != CifsGood) {
318 /* check if SMB session is bad because we are setting it up */
319 if ((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
320 (in_buf->Command != SMB_COM_NEGOTIATE))
322 /* else ok - we are setting up session */
324 *ppmidQ = AllocMidQEntry(in_buf, ses->server);
327 spin_lock(&GlobalMid_Lock);
328 list_add_tail(&(*ppmidQ)->qhead, &ses->server->pending_mid_q);
329 spin_unlock(&GlobalMid_Lock);
334 wait_for_response(struct TCP_Server_Info *server, struct mid_q_entry *midQ)
338 error = wait_event_killable(server->response_q,
339 midQ->midState != MID_REQUEST_SUBMITTED);
348 * Send a SMB request and set the callback function in the mid to handle
349 * the result. Caller is responsible for dealing with timeouts.
352 cifs_call_async(struct TCP_Server_Info *server, struct smb_hdr *in_buf,
353 mid_callback_t *callback, void *cbdata)
356 struct mid_q_entry *mid;
358 rc = wait_for_free_request(server, CIFS_ASYNC_OP);
362 mutex_lock(&server->srv_mutex);
363 mid = AllocMidQEntry(in_buf, server);
365 mutex_unlock(&server->srv_mutex);
369 /* put it on the pending_mid_q */
370 spin_lock(&GlobalMid_Lock);
371 list_add_tail(&mid->qhead, &server->pending_mid_q);
372 spin_unlock(&GlobalMid_Lock);
374 rc = cifs_sign_smb(in_buf, server, &mid->sequence_number);
376 mutex_unlock(&server->srv_mutex);
380 mid->callback = callback;
381 mid->callback_data = cbdata;
382 mid->midState = MID_REQUEST_SUBMITTED;
383 #ifdef CONFIG_CIFS_STATS2
384 atomic_inc(&server->inSend);
386 rc = smb_send(server, in_buf, in_buf->smb_buf_length);
387 #ifdef CONFIG_CIFS_STATS2
388 atomic_dec(&server->inSend);
389 mid->when_sent = jiffies;
391 mutex_unlock(&server->srv_mutex);
398 atomic_dec(&server->inFlight);
399 wake_up(&server->request_q);
405 * Send an SMB Request. No response info (other than return code)
406 * needs to be parsed.
408 * flags indicate the type of request buffer and how long to wait
409 * and whether to log NT STATUS code (error) before mapping it to POSIX error
413 SendReceiveNoRsp(const unsigned int xid, struct cifsSesInfo *ses,
414 struct smb_hdr *in_buf, int flags)
420 iov[0].iov_base = (char *)in_buf;
421 iov[0].iov_len = in_buf->smb_buf_length + 4;
422 flags |= CIFS_NO_RESP;
423 rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags);
424 cFYI(DBG2, "SendRcvNoRsp flags %d rc %d", flags, rc);
430 sync_mid_result(struct mid_q_entry *mid, struct TCP_Server_Info *server)
434 cFYI(1, "%s: cmd=%d mid=%d state=%d", __func__, mid->command,
435 mid->mid, mid->midState);
437 spin_lock(&GlobalMid_Lock);
438 /* ensure that it's no longer on the pending_mid_q */
439 list_del_init(&mid->qhead);
441 switch (mid->midState) {
442 case MID_RESPONSE_RECEIVED:
443 spin_unlock(&GlobalMid_Lock);
445 case MID_REQUEST_SUBMITTED:
446 /* socket is going down, reject all calls */
447 if (server->tcpStatus == CifsExiting) {
448 cERROR(1, "%s: canceling mid=%d cmd=0x%x state=%d",
449 __func__, mid->mid, mid->command, mid->midState);
453 case MID_RETRY_NEEDED:
457 cERROR(1, "%s: invalid mid state mid=%d state=%d", __func__,
458 mid->mid, mid->midState);
461 spin_unlock(&GlobalMid_Lock);
463 DeleteMidQEntry(mid);
468 * An NT cancel request header looks just like the original request except:
470 * The Command is SMB_COM_NT_CANCEL
471 * The WordCount is zeroed out
472 * The ByteCount is zeroed out
474 * This function mangles an existing request buffer into a
475 * SMB_COM_NT_CANCEL request and then sends it.
478 send_nt_cancel(struct TCP_Server_Info *server, struct smb_hdr *in_buf,
479 struct mid_q_entry *mid)
483 /* -4 for RFC1001 length and +2 for BCC field */
484 in_buf->smb_buf_length = sizeof(struct smb_hdr) - 4 + 2;
485 in_buf->Command = SMB_COM_NT_CANCEL;
486 in_buf->WordCount = 0;
487 put_bcc_le(0, in_buf);
489 mutex_lock(&server->srv_mutex);
490 rc = cifs_sign_smb(in_buf, server, &mid->sequence_number);
492 mutex_unlock(&server->srv_mutex);
495 rc = smb_send(server, in_buf, in_buf->smb_buf_length);
496 mutex_unlock(&server->srv_mutex);
498 cFYI(1, "issued NT_CANCEL for mid %u, rc = %d",
505 SendReceive2(const unsigned int xid, struct cifsSesInfo *ses,
506 struct kvec *iov, int n_vec, int *pRespBufType /* ret */,
511 unsigned int receive_len;
512 struct mid_q_entry *midQ;
513 struct smb_hdr *in_buf = iov[0].iov_base;
515 long_op = flags & CIFS_TIMEOUT_MASK;
517 *pRespBufType = CIFS_NO_BUFFER; /* no response buf yet */
519 if ((ses == NULL) || (ses->server == NULL)) {
520 cifs_small_buf_release(in_buf);
521 cERROR(1, "Null session");
525 if (ses->server->tcpStatus == CifsExiting) {
526 cifs_small_buf_release(in_buf);
530 /* Ensure that we do not send more than 50 overlapping requests
531 to the same server. We may make this configurable later or
534 rc = wait_for_free_request(ses->server, long_op);
536 cifs_small_buf_release(in_buf);
540 /* make sure that we sign in the same order that we send on this socket
541 and avoid races inside tcp sendmsg code that could cause corruption
544 mutex_lock(&ses->server->srv_mutex);
546 rc = allocate_mid(ses, in_buf, &midQ);
548 mutex_unlock(&ses->server->srv_mutex);
549 cifs_small_buf_release(in_buf);
550 /* Update # of requests on wire to server */
551 atomic_dec(&ses->server->inFlight);
552 wake_up(&ses->server->request_q);
555 rc = cifs_sign_smb2(iov, n_vec, ses->server, &midQ->sequence_number);
557 mutex_unlock(&ses->server->srv_mutex);
558 cifs_small_buf_release(in_buf);
562 midQ->midState = MID_REQUEST_SUBMITTED;
563 #ifdef CONFIG_CIFS_STATS2
564 atomic_inc(&ses->server->inSend);
566 rc = smb_sendv(ses->server, iov, n_vec);
567 #ifdef CONFIG_CIFS_STATS2
568 atomic_dec(&ses->server->inSend);
569 midQ->when_sent = jiffies;
572 mutex_unlock(&ses->server->srv_mutex);
573 cifs_small_buf_release(in_buf);
578 if (long_op == CIFS_ASYNC_OP)
581 rc = wait_for_response(ses->server, midQ);
583 spin_lock(&GlobalMid_Lock);
584 if (midQ->midState == MID_REQUEST_SUBMITTED) {
585 midQ->callback = DeleteMidQEntry;
586 spin_unlock(&GlobalMid_Lock);
587 atomic_dec(&ses->server->inFlight);
588 wake_up(&ses->server->request_q);
591 spin_unlock(&GlobalMid_Lock);
594 rc = sync_mid_result(midQ, ses->server);
596 atomic_dec(&ses->server->inFlight);
597 wake_up(&ses->server->request_q);
601 receive_len = midQ->resp_buf->smb_buf_length;
603 if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
604 cERROR(1, "Frame too large received. Length: %d Xid: %d",
610 /* rcvd frame is ok */
612 if (midQ->resp_buf &&
613 (midQ->midState == MID_RESPONSE_RECEIVED)) {
615 iov[0].iov_base = (char *)midQ->resp_buf;
617 *pRespBufType = CIFS_LARGE_BUFFER;
619 *pRespBufType = CIFS_SMALL_BUFFER;
620 iov[0].iov_len = receive_len + 4;
622 dump_smb(midQ->resp_buf, 80);
623 /* convert the length into a more usable form */
624 if ((receive_len > 24) &&
625 (ses->server->secMode & (SECMODE_SIGN_REQUIRED |
626 SECMODE_SIGN_ENABLED))) {
627 rc = cifs_verify_signature(midQ->resp_buf,
629 midQ->sequence_number+1);
631 cERROR(1, "Unexpected SMB signature");
632 /* BB FIXME add code to kill session */
636 /* BB special case reconnect tid and uid here? */
637 rc = map_smb_to_linux_error(midQ->resp_buf,
638 flags & CIFS_LOG_ERROR);
640 /* convert ByteCount if necessary */
641 if (receive_len >= sizeof(struct smb_hdr) - 4
642 /* do not count RFC1001 header */ +
643 (2 * midQ->resp_buf->WordCount) + 2 /* bcc */ )
644 put_bcc(get_bcc_le(midQ->resp_buf), midQ->resp_buf);
645 if ((flags & CIFS_NO_RESP) == 0)
646 midQ->resp_buf = NULL; /* mark it so buf will
651 cFYI(1, "Bad MID state?");
656 atomic_dec(&ses->server->inFlight);
657 wake_up(&ses->server->request_q);
663 SendReceive(const unsigned int xid, struct cifsSesInfo *ses,
664 struct smb_hdr *in_buf, struct smb_hdr *out_buf,
665 int *pbytes_returned, const int long_op)
668 unsigned int receive_len;
669 struct mid_q_entry *midQ;
672 cERROR(1, "Null smb session");
675 if (ses->server == NULL) {
676 cERROR(1, "Null tcp session");
680 if (ses->server->tcpStatus == CifsExiting)
683 /* Ensure that we do not send more than 50 overlapping requests
684 to the same server. We may make this configurable later or
687 if (in_buf->smb_buf_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
688 cERROR(1, "Illegal length, greater than maximum frame, %d",
689 in_buf->smb_buf_length);
693 rc = wait_for_free_request(ses->server, long_op);
697 /* make sure that we sign in the same order that we send on this socket
698 and avoid races inside tcp sendmsg code that could cause corruption
701 mutex_lock(&ses->server->srv_mutex);
703 rc = allocate_mid(ses, in_buf, &midQ);
705 mutex_unlock(&ses->server->srv_mutex);
706 /* Update # of requests on wire to server */
707 atomic_dec(&ses->server->inFlight);
708 wake_up(&ses->server->request_q);
712 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
714 mutex_unlock(&ses->server->srv_mutex);
718 midQ->midState = MID_REQUEST_SUBMITTED;
719 #ifdef CONFIG_CIFS_STATS2
720 atomic_inc(&ses->server->inSend);
722 rc = smb_send(ses->server, in_buf, in_buf->smb_buf_length);
723 #ifdef CONFIG_CIFS_STATS2
724 atomic_dec(&ses->server->inSend);
725 midQ->when_sent = jiffies;
727 mutex_unlock(&ses->server->srv_mutex);
732 if (long_op == CIFS_ASYNC_OP)
735 rc = wait_for_response(ses->server, midQ);
737 spin_lock(&GlobalMid_Lock);
738 if (midQ->midState == MID_REQUEST_SUBMITTED) {
739 /* no longer considered to be "in-flight" */
740 midQ->callback = DeleteMidQEntry;
741 spin_unlock(&GlobalMid_Lock);
742 atomic_dec(&ses->server->inFlight);
743 wake_up(&ses->server->request_q);
746 spin_unlock(&GlobalMid_Lock);
749 rc = sync_mid_result(midQ, ses->server);
751 atomic_dec(&ses->server->inFlight);
752 wake_up(&ses->server->request_q);
756 receive_len = midQ->resp_buf->smb_buf_length;
758 if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
759 cERROR(1, "Frame too large received. Length: %d Xid: %d",
765 /* rcvd frame is ok */
767 if (midQ->resp_buf && out_buf
768 && (midQ->midState == MID_RESPONSE_RECEIVED)) {
769 out_buf->smb_buf_length = receive_len;
770 memcpy((char *)out_buf + 4,
771 (char *)midQ->resp_buf + 4,
774 dump_smb(out_buf, 92);
775 /* convert the length into a more usable form */
776 if ((receive_len > 24) &&
777 (ses->server->secMode & (SECMODE_SIGN_REQUIRED |
778 SECMODE_SIGN_ENABLED))) {
779 rc = cifs_verify_signature(out_buf,
781 midQ->sequence_number+1);
783 cERROR(1, "Unexpected SMB signature");
784 /* BB FIXME add code to kill session */
788 *pbytes_returned = out_buf->smb_buf_length;
790 /* BB special case reconnect tid and uid here? */
791 rc = map_smb_to_linux_error(out_buf, 0 /* no log */ );
793 /* convert ByteCount if necessary */
794 if (receive_len >= sizeof(struct smb_hdr) - 4
795 /* do not count RFC1001 header */ +
796 (2 * out_buf->WordCount) + 2 /* bcc */ )
797 put_bcc(get_bcc_le(midQ->resp_buf), midQ->resp_buf);
800 cERROR(1, "Bad MID state?");
805 atomic_dec(&ses->server->inFlight);
806 wake_up(&ses->server->request_q);
811 /* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
812 blocking lock to return. */
815 send_lock_cancel(const unsigned int xid, struct cifsTconInfo *tcon,
816 struct smb_hdr *in_buf,
817 struct smb_hdr *out_buf)
820 struct cifsSesInfo *ses = tcon->ses;
821 LOCK_REQ *pSMB = (LOCK_REQ *)in_buf;
823 /* We just modify the current in_buf to change
824 the type of lock from LOCKING_ANDX_SHARED_LOCK
825 or LOCKING_ANDX_EXCLUSIVE_LOCK to
826 LOCKING_ANDX_CANCEL_LOCK. */
828 pSMB->LockType = LOCKING_ANDX_CANCEL_LOCK|LOCKING_ANDX_LARGE_FILES;
830 pSMB->hdr.Mid = GetNextMid(ses->server);
832 return SendReceive(xid, ses, in_buf, out_buf,
837 SendReceiveBlockingLock(const unsigned int xid, struct cifsTconInfo *tcon,
838 struct smb_hdr *in_buf, struct smb_hdr *out_buf,
839 int *pbytes_returned)
843 unsigned int receive_len;
844 struct mid_q_entry *midQ;
845 struct cifsSesInfo *ses;
847 if (tcon == NULL || tcon->ses == NULL) {
848 cERROR(1, "Null smb session");
853 if (ses->server == NULL) {
854 cERROR(1, "Null tcp session");
858 if (ses->server->tcpStatus == CifsExiting)
861 /* Ensure that we do not send more than 50 overlapping requests
862 to the same server. We may make this configurable later or
865 if (in_buf->smb_buf_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
866 cERROR(1, "Illegal length, greater than maximum frame, %d",
867 in_buf->smb_buf_length);
871 rc = wait_for_free_request(ses->server, CIFS_BLOCKING_OP);
875 /* make sure that we sign in the same order that we send on this socket
876 and avoid races inside tcp sendmsg code that could cause corruption
879 mutex_lock(&ses->server->srv_mutex);
881 rc = allocate_mid(ses, in_buf, &midQ);
883 mutex_unlock(&ses->server->srv_mutex);
887 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
890 mutex_unlock(&ses->server->srv_mutex);
894 midQ->midState = MID_REQUEST_SUBMITTED;
895 #ifdef CONFIG_CIFS_STATS2
896 atomic_inc(&ses->server->inSend);
898 rc = smb_send(ses->server, in_buf, in_buf->smb_buf_length);
899 #ifdef CONFIG_CIFS_STATS2
900 atomic_dec(&ses->server->inSend);
901 midQ->when_sent = jiffies;
903 mutex_unlock(&ses->server->srv_mutex);
910 /* Wait for a reply - allow signals to interrupt. */
911 rc = wait_event_interruptible(ses->server->response_q,
912 (!(midQ->midState == MID_REQUEST_SUBMITTED)) ||
913 ((ses->server->tcpStatus != CifsGood) &&
914 (ses->server->tcpStatus != CifsNew)));
916 /* Were we interrupted by a signal ? */
917 if ((rc == -ERESTARTSYS) &&
918 (midQ->midState == MID_REQUEST_SUBMITTED) &&
919 ((ses->server->tcpStatus == CifsGood) ||
920 (ses->server->tcpStatus == CifsNew))) {
922 if (in_buf->Command == SMB_COM_TRANSACTION2) {
923 /* POSIX lock. We send a NT_CANCEL SMB to cause the
924 blocking lock to return. */
925 rc = send_nt_cancel(ses->server, in_buf, midQ);
931 /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
932 to cause the blocking lock to return. */
934 rc = send_lock_cancel(xid, tcon, in_buf, out_buf);
936 /* If we get -ENOLCK back the lock may have
937 already been removed. Don't exit in this case. */
938 if (rc && rc != -ENOLCK) {
944 rc = wait_for_response(ses->server, midQ);
946 spin_lock(&GlobalMid_Lock);
947 if (midQ->midState == MID_REQUEST_SUBMITTED) {
948 /* no longer considered to be "in-flight" */
949 midQ->callback = DeleteMidQEntry;
950 spin_unlock(&GlobalMid_Lock);
953 spin_unlock(&GlobalMid_Lock);
956 /* We got the response - restart system call. */
960 rc = sync_mid_result(midQ, ses->server);
964 receive_len = midQ->resp_buf->smb_buf_length;
965 if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
966 cERROR(1, "Frame too large received. Length: %d Xid: %d",
972 /* rcvd frame is ok */
974 if ((out_buf == NULL) || (midQ->midState != MID_RESPONSE_RECEIVED)) {
976 cERROR(1, "Bad MID state?");
980 out_buf->smb_buf_length = receive_len;
981 memcpy((char *)out_buf + 4,
982 (char *)midQ->resp_buf + 4,
985 dump_smb(out_buf, 92);
986 /* convert the length into a more usable form */
987 if ((receive_len > 24) &&
988 (ses->server->secMode & (SECMODE_SIGN_REQUIRED |
989 SECMODE_SIGN_ENABLED))) {
990 rc = cifs_verify_signature(out_buf,
992 midQ->sequence_number+1);
994 cERROR(1, "Unexpected SMB signature");
995 /* BB FIXME add code to kill session */
999 *pbytes_returned = out_buf->smb_buf_length;
1001 /* BB special case reconnect tid and uid here? */
1002 rc = map_smb_to_linux_error(out_buf, 0 /* no log */ );
1004 /* convert ByteCount if necessary */
1005 if (receive_len >= sizeof(struct smb_hdr) - 4
1006 /* do not count RFC1001 header */ +
1007 (2 * out_buf->WordCount) + 2 /* bcc */ )
1008 put_bcc(get_bcc_le(out_buf), out_buf);
1012 if (rstart && rc == -EACCES)
1013 return -ERESTARTSYS;