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 <linux/freezer.h>
30 #include <asm/uaccess.h>
31 #include <asm/processor.h>
32 #include <linux/mempool.h>
35 #include "cifsproto.h"
36 #include "cifs_debug.h"
38 extern mempool_t *cifs_mid_poolp;
41 wake_up_task(struct mid_q_entry *mid)
43 wake_up_process(mid->callback_data);
47 AllocMidQEntry(const struct smb_hdr *smb_buffer, struct TCP_Server_Info *server)
49 struct mid_q_entry *temp;
52 cERROR(1, "Null TCP session in AllocMidQEntry");
56 temp = mempool_alloc(cifs_mid_poolp, GFP_NOFS);
60 memset(temp, 0, sizeof(struct mid_q_entry));
61 temp->mid = smb_buffer->Mid; /* always LE */
62 temp->pid = current->pid;
63 temp->command = smb_buffer->Command;
64 cFYI(1, "For smb_command %d", temp->command);
65 /* do_gettimeofday(&temp->when_sent);*/ /* easier to use jiffies */
66 /* when mid allocated can be before when sent */
67 temp->when_alloc = jiffies;
70 * The default is for the mid to be synchronous, so the
71 * default callback just wakes up the current task.
73 temp->callback = wake_up_task;
74 temp->callback_data = current;
77 atomic_inc(&midCount);
78 temp->midState = MID_REQUEST_ALLOCATED;
83 DeleteMidQEntry(struct mid_q_entry *midEntry)
85 #ifdef CONFIG_CIFS_STATS2
88 midEntry->midState = MID_FREE;
89 atomic_dec(&midCount);
90 if (midEntry->largeBuf)
91 cifs_buf_release(midEntry->resp_buf);
93 cifs_small_buf_release(midEntry->resp_buf);
94 #ifdef CONFIG_CIFS_STATS2
96 /* commands taking longer than one second are indications that
97 something is wrong, unless it is quite a slow link or server */
98 if ((now - midEntry->when_alloc) > HZ) {
99 if ((cifsFYI & CIFS_TIMER) &&
100 (midEntry->command != SMB_COM_LOCKING_ANDX)) {
101 printk(KERN_DEBUG " CIFS slow rsp: cmd %d mid %d",
102 midEntry->command, midEntry->mid);
103 printk(" A: 0x%lx S: 0x%lx R: 0x%lx\n",
104 now - midEntry->when_alloc,
105 now - midEntry->when_sent,
106 now - midEntry->when_received);
110 mempool_free(midEntry, cifs_mid_poolp);
114 delete_mid(struct mid_q_entry *mid)
116 spin_lock(&GlobalMid_Lock);
117 list_del(&mid->qhead);
118 spin_unlock(&GlobalMid_Lock);
120 DeleteMidQEntry(mid);
124 smb_sendv(struct TCP_Server_Info *server, struct kvec *iov, int n_vec)
128 struct msghdr smb_msg;
129 struct smb_hdr *smb_buffer = iov[0].iov_base;
130 unsigned int len = iov[0].iov_len;
131 unsigned int total_len;
133 unsigned int smb_buf_length = be32_to_cpu(smb_buffer->smb_buf_length);
134 struct socket *ssocket = server->ssocket;
137 return -ENOTSOCK; /* BB eventually add reconnect code here */
139 smb_msg.msg_name = (struct sockaddr *) &server->dstaddr;
140 smb_msg.msg_namelen = sizeof(struct sockaddr);
141 smb_msg.msg_control = NULL;
142 smb_msg.msg_controllen = 0;
143 if (server->noblocksnd)
144 smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL;
146 smb_msg.msg_flags = MSG_NOSIGNAL;
149 for (i = 0; i < n_vec; i++)
150 total_len += iov[i].iov_len;
152 cFYI(1, "Sending smb: total_len %d", total_len);
153 dump_smb(smb_buffer, len);
157 rc = kernel_sendmsg(ssocket, &smb_msg, &iov[first_vec],
158 n_vec - first_vec, total_len);
159 if ((rc == -ENOSPC) || (rc == -EAGAIN)) {
161 /* if blocking send we try 3 times, since each can block
162 for 5 seconds. For nonblocking we have to try more
163 but wait increasing amounts of time allowing time for
164 socket to clear. The overall time we wait in either
165 case to send on the socket is about 15 seconds.
166 Similarly we wait for 15 seconds for
167 a response from the server in SendReceive[2]
168 for the server to send a response back for
169 most types of requests (except SMB Write
170 past end of file which can be slow, and
171 blocking lock operations). NFS waits slightly longer
172 than CIFS, but this can make it take longer for
173 nonresponsive servers to be detected and 15 seconds
174 is more than enough time for modern networks to
175 send a packet. In most cases if we fail to send
176 after the retries we will kill the socket and
177 reconnect which may clear the network problem.
179 if ((i >= 14) || (!server->noblocksnd && (i > 2))) {
180 cERROR(1, "sends on sock %p stuck for 15 seconds",
191 if (rc == total_len) {
194 } else if (rc > total_len) {
195 cERROR(1, "sent %d requested %d", rc, total_len);
199 /* should never happen, letting socket clear before
200 retrying is our only obvious option here */
201 cERROR(1, "tcp sent no data");
206 /* the line below resets i */
207 for (i = first_vec; i < n_vec; i++) {
208 if (iov[i].iov_len) {
209 if (rc > iov[i].iov_len) {
210 rc -= iov[i].iov_len;
213 iov[i].iov_base += rc;
214 iov[i].iov_len -= rc;
220 i = 0; /* in case we get ENOSPC on the next send */
223 if ((total_len > 0) && (total_len != smb_buf_length + 4)) {
224 cFYI(1, "partial send (%d remaining), terminating session",
226 /* If we have only sent part of an SMB then the next SMB
227 could be taken as the remainder of this one. We need
228 to kill the socket so the server throws away the partial
230 server->tcpStatus = CifsNeedReconnect;
233 if (rc < 0 && rc != -EINTR)
234 cERROR(1, "Error %d sending data on socket to server", rc);
238 /* Don't want to modify the buffer as a
239 side effect of this call. */
240 smb_buffer->smb_buf_length = cpu_to_be32(smb_buf_length);
246 smb_send(struct TCP_Server_Info *server, struct smb_hdr *smb_buffer,
247 unsigned int smb_buf_length)
251 iov.iov_base = smb_buffer;
252 iov.iov_len = smb_buf_length + 4;
254 return smb_sendv(server, &iov, 1);
257 static int wait_for_free_request(struct TCP_Server_Info *server,
260 if (long_op == CIFS_ASYNC_OP) {
261 /* oplock breaks must not be held up */
262 atomic_inc(&server->inFlight);
266 spin_lock(&GlobalMid_Lock);
268 if (atomic_read(&server->inFlight) >= server->maxReq) {
269 spin_unlock(&GlobalMid_Lock);
270 cifs_num_waiters_inc(server);
271 wait_event(server->request_q,
272 atomic_read(&server->inFlight)
274 cifs_num_waiters_dec(server);
275 spin_lock(&GlobalMid_Lock);
277 if (server->tcpStatus == CifsExiting) {
278 spin_unlock(&GlobalMid_Lock);
282 /* can not count locking commands against total
283 as they are allowed to block on server */
285 /* update # of requests on the wire to server */
286 if (long_op != CIFS_BLOCKING_OP)
287 atomic_inc(&server->inFlight);
288 spin_unlock(&GlobalMid_Lock);
295 static int allocate_mid(struct cifs_ses *ses, struct smb_hdr *in_buf,
296 struct mid_q_entry **ppmidQ)
298 if (ses->server->tcpStatus == CifsExiting) {
302 if (ses->server->tcpStatus == CifsNeedReconnect) {
303 cFYI(1, "tcp session dead - return to caller to retry");
307 if (ses->status != CifsGood) {
308 /* check if SMB session is bad because we are setting it up */
309 if ((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
310 (in_buf->Command != SMB_COM_NEGOTIATE))
312 /* else ok - we are setting up session */
314 *ppmidQ = AllocMidQEntry(in_buf, ses->server);
317 spin_lock(&GlobalMid_Lock);
318 list_add_tail(&(*ppmidQ)->qhead, &ses->server->pending_mid_q);
319 spin_unlock(&GlobalMid_Lock);
324 wait_for_response(struct TCP_Server_Info *server, struct mid_q_entry *midQ)
328 error = wait_event_freezekillable(server->response_q,
329 midQ->midState != MID_REQUEST_SUBMITTED);
338 * Send a SMB request and set the callback function in the mid to handle
339 * the result. Caller is responsible for dealing with timeouts.
342 cifs_call_async(struct TCP_Server_Info *server, struct kvec *iov,
343 unsigned int nvec, mid_receive_t *receive,
344 mid_callback_t *callback, void *cbdata, bool ignore_pend)
347 struct mid_q_entry *mid;
348 struct smb_hdr *hdr = (struct smb_hdr *)iov[0].iov_base;
350 rc = wait_for_free_request(server, ignore_pend ? CIFS_ASYNC_OP : 0);
354 /* enable signing if server requires it */
355 if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
356 hdr->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
358 mutex_lock(&server->srv_mutex);
359 mid = AllocMidQEntry(hdr, server);
361 mutex_unlock(&server->srv_mutex);
362 atomic_dec(&server->inFlight);
363 wake_up(&server->request_q);
367 /* put it on the pending_mid_q */
368 spin_lock(&GlobalMid_Lock);
369 list_add_tail(&mid->qhead, &server->pending_mid_q);
370 spin_unlock(&GlobalMid_Lock);
372 rc = cifs_sign_smb2(iov, nvec, server, &mid->sequence_number);
374 mutex_unlock(&server->srv_mutex);
378 mid->receive = receive;
379 mid->callback = callback;
380 mid->callback_data = cbdata;
381 mid->midState = MID_REQUEST_SUBMITTED;
383 cifs_in_send_inc(server);
384 rc = smb_sendv(server, iov, nvec);
385 cifs_in_send_dec(server);
386 cifs_save_when_sent(mid);
387 mutex_unlock(&server->srv_mutex);
395 atomic_dec(&server->inFlight);
396 wake_up(&server->request_q);
402 * Send an SMB Request. No response info (other than return code)
403 * needs to be parsed.
405 * flags indicate the type of request buffer and how long to wait
406 * and whether to log NT STATUS code (error) before mapping it to POSIX error
410 SendReceiveNoRsp(const unsigned int xid, struct cifs_ses *ses,
411 struct smb_hdr *in_buf, int flags)
417 iov[0].iov_base = (char *)in_buf;
418 iov[0].iov_len = be32_to_cpu(in_buf->smb_buf_length) + 4;
419 flags |= CIFS_NO_RESP;
420 rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags);
421 cFYI(DBG2, "SendRcvNoRsp flags %d rc %d", flags, rc);
427 cifs_sync_mid_result(struct mid_q_entry *mid, struct TCP_Server_Info *server)
431 cFYI(1, "%s: cmd=%d mid=%d state=%d", __func__, mid->command,
432 mid->mid, mid->midState);
434 spin_lock(&GlobalMid_Lock);
435 switch (mid->midState) {
436 case MID_RESPONSE_RECEIVED:
437 spin_unlock(&GlobalMid_Lock);
439 case MID_RETRY_NEEDED:
442 case MID_RESPONSE_MALFORMED:
449 list_del_init(&mid->qhead);
450 cERROR(1, "%s: invalid mid state mid=%d state=%d", __func__,
451 mid->mid, mid->midState);
454 spin_unlock(&GlobalMid_Lock);
456 DeleteMidQEntry(mid);
461 * An NT cancel request header looks just like the original request except:
463 * The Command is SMB_COM_NT_CANCEL
464 * The WordCount is zeroed out
465 * The ByteCount is zeroed out
467 * This function mangles an existing request buffer into a
468 * SMB_COM_NT_CANCEL request and then sends it.
471 send_nt_cancel(struct TCP_Server_Info *server, struct smb_hdr *in_buf,
472 struct mid_q_entry *mid)
476 /* -4 for RFC1001 length and +2 for BCC field */
477 in_buf->smb_buf_length = cpu_to_be32(sizeof(struct smb_hdr) - 4 + 2);
478 in_buf->Command = SMB_COM_NT_CANCEL;
479 in_buf->WordCount = 0;
482 mutex_lock(&server->srv_mutex);
483 rc = cifs_sign_smb(in_buf, server, &mid->sequence_number);
485 mutex_unlock(&server->srv_mutex);
490 * The response to this call was already factored into the sequence
491 * number when the call went out, so we must adjust it back downward
492 * after signing here.
494 --server->sequence_number;
495 rc = smb_send(server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
496 mutex_unlock(&server->srv_mutex);
498 cFYI(1, "issued NT_CANCEL for mid %u, rc = %d",
505 cifs_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,
508 unsigned int len = be32_to_cpu(mid->resp_buf->smb_buf_length) + 4;
510 dump_smb(mid->resp_buf, min_t(u32, 92, len));
512 /* convert the length into a more usable form */
513 if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
516 iov.iov_base = mid->resp_buf;
518 /* FIXME: add code to kill session */
519 if (cifs_verify_signature(&iov, 1, server,
520 mid->sequence_number + 1) != 0)
521 cERROR(1, "Unexpected SMB signature");
524 /* BB special case reconnect tid and uid here? */
525 return map_smb_to_linux_error(mid->resp_buf, log_error);
529 SendReceive2(const unsigned int xid, struct cifs_ses *ses,
530 struct kvec *iov, int n_vec, int *pRespBufType /* ret */,
535 struct mid_q_entry *midQ;
536 struct smb_hdr *in_buf = iov[0].iov_base;
538 long_op = flags & CIFS_TIMEOUT_MASK;
540 *pRespBufType = CIFS_NO_BUFFER; /* no response buf yet */
542 if ((ses == NULL) || (ses->server == NULL)) {
543 cifs_small_buf_release(in_buf);
544 cERROR(1, "Null session");
548 if (ses->server->tcpStatus == CifsExiting) {
549 cifs_small_buf_release(in_buf);
553 /* Ensure that we do not send more than 50 overlapping requests
554 to the same server. We may make this configurable later or
557 rc = wait_for_free_request(ses->server, long_op);
559 cifs_small_buf_release(in_buf);
563 /* make sure that we sign in the same order that we send on this socket
564 and avoid races inside tcp sendmsg code that could cause corruption
567 mutex_lock(&ses->server->srv_mutex);
569 rc = allocate_mid(ses, in_buf, &midQ);
571 mutex_unlock(&ses->server->srv_mutex);
572 cifs_small_buf_release(in_buf);
573 /* Update # of requests on wire to server */
574 atomic_dec(&ses->server->inFlight);
575 wake_up(&ses->server->request_q);
578 rc = cifs_sign_smb2(iov, n_vec, ses->server, &midQ->sequence_number);
580 mutex_unlock(&ses->server->srv_mutex);
581 cifs_small_buf_release(in_buf);
585 midQ->midState = MID_REQUEST_SUBMITTED;
586 cifs_in_send_inc(ses->server);
587 rc = smb_sendv(ses->server, iov, n_vec);
588 cifs_in_send_dec(ses->server);
589 cifs_save_when_sent(midQ);
591 mutex_unlock(&ses->server->srv_mutex);
594 cifs_small_buf_release(in_buf);
598 if (long_op == CIFS_ASYNC_OP) {
599 cifs_small_buf_release(in_buf);
603 rc = wait_for_response(ses->server, midQ);
605 send_nt_cancel(ses->server, in_buf, midQ);
606 spin_lock(&GlobalMid_Lock);
607 if (midQ->midState == MID_REQUEST_SUBMITTED) {
608 midQ->callback = DeleteMidQEntry;
609 spin_unlock(&GlobalMid_Lock);
610 cifs_small_buf_release(in_buf);
611 atomic_dec(&ses->server->inFlight);
612 wake_up(&ses->server->request_q);
615 spin_unlock(&GlobalMid_Lock);
618 cifs_small_buf_release(in_buf);
620 rc = cifs_sync_mid_result(midQ, ses->server);
622 atomic_dec(&ses->server->inFlight);
623 wake_up(&ses->server->request_q);
627 if (!midQ->resp_buf || midQ->midState != MID_RESPONSE_RECEIVED) {
629 cFYI(1, "Bad MID state?");
633 iov[0].iov_base = (char *)midQ->resp_buf;
634 iov[0].iov_len = be32_to_cpu(midQ->resp_buf->smb_buf_length) + 4;
636 *pRespBufType = CIFS_LARGE_BUFFER;
638 *pRespBufType = CIFS_SMALL_BUFFER;
640 rc = cifs_check_receive(midQ, ses->server, flags & CIFS_LOG_ERROR);
642 /* mark it so buf will not be freed by delete_mid */
643 if ((flags & CIFS_NO_RESP) == 0)
644 midQ->resp_buf = NULL;
647 atomic_dec(&ses->server->inFlight);
648 wake_up(&ses->server->request_q);
654 SendReceive(const unsigned int xid, struct cifs_ses *ses,
655 struct smb_hdr *in_buf, struct smb_hdr *out_buf,
656 int *pbytes_returned, const int long_op)
659 struct mid_q_entry *midQ;
662 cERROR(1, "Null smb session");
665 if (ses->server == NULL) {
666 cERROR(1, "Null tcp session");
670 if (ses->server->tcpStatus == CifsExiting)
673 /* Ensure that we do not send more than 50 overlapping requests
674 to the same server. We may make this configurable later or
677 if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
678 MAX_CIFS_HDR_SIZE - 4) {
679 cERROR(1, "Illegal length, greater than maximum frame, %d",
680 be32_to_cpu(in_buf->smb_buf_length));
684 rc = wait_for_free_request(ses->server, long_op);
688 /* make sure that we sign in the same order that we send on this socket
689 and avoid races inside tcp sendmsg code that could cause corruption
692 mutex_lock(&ses->server->srv_mutex);
694 rc = allocate_mid(ses, in_buf, &midQ);
696 mutex_unlock(&ses->server->srv_mutex);
697 /* Update # of requests on wire to server */
698 atomic_dec(&ses->server->inFlight);
699 wake_up(&ses->server->request_q);
703 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
705 mutex_unlock(&ses->server->srv_mutex);
709 midQ->midState = MID_REQUEST_SUBMITTED;
711 cifs_in_send_inc(ses->server);
712 rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
713 cifs_in_send_dec(ses->server);
714 cifs_save_when_sent(midQ);
715 mutex_unlock(&ses->server->srv_mutex);
720 if (long_op == CIFS_ASYNC_OP)
723 rc = wait_for_response(ses->server, midQ);
725 send_nt_cancel(ses->server, in_buf, midQ);
726 spin_lock(&GlobalMid_Lock);
727 if (midQ->midState == MID_REQUEST_SUBMITTED) {
728 /* no longer considered to be "in-flight" */
729 midQ->callback = DeleteMidQEntry;
730 spin_unlock(&GlobalMid_Lock);
731 atomic_dec(&ses->server->inFlight);
732 wake_up(&ses->server->request_q);
735 spin_unlock(&GlobalMid_Lock);
738 rc = cifs_sync_mid_result(midQ, ses->server);
740 atomic_dec(&ses->server->inFlight);
741 wake_up(&ses->server->request_q);
745 if (!midQ->resp_buf || !out_buf ||
746 midQ->midState != MID_RESPONSE_RECEIVED) {
748 cERROR(1, "Bad MID state?");
752 *pbytes_returned = be32_to_cpu(midQ->resp_buf->smb_buf_length);
753 memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
754 rc = cifs_check_receive(midQ, ses->server, 0);
757 atomic_dec(&ses->server->inFlight);
758 wake_up(&ses->server->request_q);
763 /* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
764 blocking lock to return. */
767 send_lock_cancel(const unsigned int xid, struct cifs_tcon *tcon,
768 struct smb_hdr *in_buf,
769 struct smb_hdr *out_buf)
772 struct cifs_ses *ses = tcon->ses;
773 LOCK_REQ *pSMB = (LOCK_REQ *)in_buf;
775 /* We just modify the current in_buf to change
776 the type of lock from LOCKING_ANDX_SHARED_LOCK
777 or LOCKING_ANDX_EXCLUSIVE_LOCK to
778 LOCKING_ANDX_CANCEL_LOCK. */
780 pSMB->LockType = LOCKING_ANDX_CANCEL_LOCK|LOCKING_ANDX_LARGE_FILES;
782 pSMB->hdr.Mid = GetNextMid(ses->server);
784 return SendReceive(xid, ses, in_buf, out_buf,
789 SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
790 struct smb_hdr *in_buf, struct smb_hdr *out_buf,
791 int *pbytes_returned)
795 struct mid_q_entry *midQ;
796 struct cifs_ses *ses;
798 if (tcon == NULL || tcon->ses == NULL) {
799 cERROR(1, "Null smb session");
804 if (ses->server == NULL) {
805 cERROR(1, "Null tcp session");
809 if (ses->server->tcpStatus == CifsExiting)
812 /* Ensure that we do not send more than 50 overlapping requests
813 to the same server. We may make this configurable later or
816 if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
817 MAX_CIFS_HDR_SIZE - 4) {
818 cERROR(1, "Illegal length, greater than maximum frame, %d",
819 be32_to_cpu(in_buf->smb_buf_length));
823 rc = wait_for_free_request(ses->server, CIFS_BLOCKING_OP);
827 /* make sure that we sign in the same order that we send on this socket
828 and avoid races inside tcp sendmsg code that could cause corruption
831 mutex_lock(&ses->server->srv_mutex);
833 rc = allocate_mid(ses, in_buf, &midQ);
835 mutex_unlock(&ses->server->srv_mutex);
839 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
842 mutex_unlock(&ses->server->srv_mutex);
846 midQ->midState = MID_REQUEST_SUBMITTED;
847 cifs_in_send_inc(ses->server);
848 rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
849 cifs_in_send_dec(ses->server);
850 cifs_save_when_sent(midQ);
851 mutex_unlock(&ses->server->srv_mutex);
858 /* Wait for a reply - allow signals to interrupt. */
859 rc = wait_event_interruptible(ses->server->response_q,
860 (!(midQ->midState == MID_REQUEST_SUBMITTED)) ||
861 ((ses->server->tcpStatus != CifsGood) &&
862 (ses->server->tcpStatus != CifsNew)));
864 /* Were we interrupted by a signal ? */
865 if ((rc == -ERESTARTSYS) &&
866 (midQ->midState == MID_REQUEST_SUBMITTED) &&
867 ((ses->server->tcpStatus == CifsGood) ||
868 (ses->server->tcpStatus == CifsNew))) {
870 if (in_buf->Command == SMB_COM_TRANSACTION2) {
871 /* POSIX lock. We send a NT_CANCEL SMB to cause the
872 blocking lock to return. */
873 rc = send_nt_cancel(ses->server, in_buf, midQ);
879 /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
880 to cause the blocking lock to return. */
882 rc = send_lock_cancel(xid, tcon, in_buf, out_buf);
884 /* If we get -ENOLCK back the lock may have
885 already been removed. Don't exit in this case. */
886 if (rc && rc != -ENOLCK) {
892 rc = wait_for_response(ses->server, midQ);
894 send_nt_cancel(ses->server, in_buf, midQ);
895 spin_lock(&GlobalMid_Lock);
896 if (midQ->midState == MID_REQUEST_SUBMITTED) {
897 /* no longer considered to be "in-flight" */
898 midQ->callback = DeleteMidQEntry;
899 spin_unlock(&GlobalMid_Lock);
902 spin_unlock(&GlobalMid_Lock);
905 /* We got the response - restart system call. */
909 rc = cifs_sync_mid_result(midQ, ses->server);
913 /* rcvd frame is ok */
914 if (out_buf == NULL || midQ->midState != MID_RESPONSE_RECEIVED) {
916 cERROR(1, "Bad MID state?");
920 *pbytes_returned = be32_to_cpu(midQ->resp_buf->smb_buf_length);
921 memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
922 rc = cifs_check_receive(midQ, ses->server, 0);
925 if (rstart && rc == -EACCES)