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
= cpu_to_le16(smb_buffer
->Command
);
64 cFYI(1, "For smb_command %d", smb_buffer
->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
->mid_state
= MID_REQUEST_ALLOCATED
;
83 DeleteMidQEntry(struct mid_q_entry
*midEntry
)
85 #ifdef CONFIG_CIFS_STATS2
88 midEntry
->mid_state
= MID_FREE
;
89 atomic_dec(&midCount
);
90 if (midEntry
->large_buf
)
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
!= cpu_to_le16(SMB_COM_LOCKING_ANDX
))) {
101 printk(KERN_DEBUG
" CIFS slow rsp: cmd %d mid %llu",
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 __be32
*buf_len
= (__be32
*)(iov
[0].iov_base
);
130 unsigned int len
= iov
[0].iov_len
;
131 unsigned int total_len
;
133 unsigned int smb_buf_length
= get_rfc1002_length(iov
[0].iov_base
);
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(iov
[0].iov_base
, len
);
157 rc
= kernel_sendmsg(ssocket
, &smb_msg
, &iov
[first_vec
],
158 n_vec
- first_vec
, total_len
);
159 if ((rc
== -ENOSPC
) || (rc
== -EAGAIN
)) {
162 * If blocking send we try 3 times, since each can block
163 * for 5 seconds. For nonblocking we have to try more
164 * but wait increasing amounts of time allowing time for
165 * socket to clear. The overall time we wait in either
166 * case to send on the socket is about 15 seconds.
167 * Similarly we wait for 15 seconds for a response from
168 * the server in SendReceive[2] for the server to send
169 * a response back for most types of requests (except
170 * SMB Write 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 side effect of this call. */
239 *buf_len
= cpu_to_be32(smb_buf_length
);
245 smb_send(struct TCP_Server_Info
*server
, struct smb_hdr
*smb_buffer
,
246 unsigned int smb_buf_length
)
250 iov
.iov_base
= smb_buffer
;
251 iov
.iov_len
= smb_buf_length
+ 4;
253 return smb_sendv(server
, &iov
, 1);
257 wait_for_free_credits(struct TCP_Server_Info
*server
, const int optype
,
262 spin_lock(&server
->req_lock
);
263 if (optype
== CIFS_ASYNC_OP
) {
264 /* oplock breaks must not be held up */
267 spin_unlock(&server
->req_lock
);
273 spin_unlock(&server
->req_lock
);
274 cifs_num_waiters_inc(server
);
275 rc
= wait_event_killable(server
->request_q
,
276 has_credits(server
, credits
));
277 cifs_num_waiters_dec(server
);
280 spin_lock(&server
->req_lock
);
282 if (server
->tcpStatus
== CifsExiting
) {
283 spin_unlock(&server
->req_lock
);
288 * Can not count locking commands against total
289 * as they are allowed to block on server.
292 /* update # of requests on the wire to server */
293 if (optype
!= CIFS_BLOCKING_OP
) {
297 spin_unlock(&server
->req_lock
);
305 wait_for_free_request(struct TCP_Server_Info
*server
, const int optype
)
307 return wait_for_free_credits(server
, optype
,
308 server
->ops
->get_credits_field(server
));
311 static int allocate_mid(struct cifs_ses
*ses
, struct smb_hdr
*in_buf
,
312 struct mid_q_entry
**ppmidQ
)
314 if (ses
->server
->tcpStatus
== CifsExiting
) {
318 if (ses
->server
->tcpStatus
== CifsNeedReconnect
) {
319 cFYI(1, "tcp session dead - return to caller to retry");
323 if (ses
->status
!= CifsGood
) {
324 /* check if SMB session is bad because we are setting it up */
325 if ((in_buf
->Command
!= SMB_COM_SESSION_SETUP_ANDX
) &&
326 (in_buf
->Command
!= SMB_COM_NEGOTIATE
))
328 /* else ok - we are setting up session */
330 *ppmidQ
= AllocMidQEntry(in_buf
, ses
->server
);
333 spin_lock(&GlobalMid_Lock
);
334 list_add_tail(&(*ppmidQ
)->qhead
, &ses
->server
->pending_mid_q
);
335 spin_unlock(&GlobalMid_Lock
);
340 wait_for_response(struct TCP_Server_Info
*server
, struct mid_q_entry
*midQ
)
344 error
= wait_event_freezekillable(server
->response_q
,
345 midQ
->mid_state
!= MID_REQUEST_SUBMITTED
);
353 cifs_setup_async_request(struct TCP_Server_Info
*server
, struct kvec
*iov
,
354 unsigned int nvec
, struct mid_q_entry
**ret_mid
)
357 struct smb_hdr
*hdr
= (struct smb_hdr
*)iov
[0].iov_base
;
358 struct mid_q_entry
*mid
;
360 /* enable signing if server requires it */
361 if (server
->sec_mode
& (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
))
362 hdr
->Flags2
|= SMBFLG2_SECURITY_SIGNATURE
;
364 mid
= AllocMidQEntry(hdr
, server
);
368 rc
= cifs_sign_smb2(iov
, nvec
, server
, &mid
->sequence_number
);
370 DeleteMidQEntry(mid
);
379 * Send a SMB request and set the callback function in the mid to handle
380 * the result. Caller is responsible for dealing with timeouts.
383 cifs_call_async(struct TCP_Server_Info
*server
, struct kvec
*iov
,
384 unsigned int nvec
, mid_receive_t
*receive
,
385 mid_callback_t
*callback
, void *cbdata
, bool ignore_pend
)
388 struct mid_q_entry
*mid
;
390 rc
= wait_for_free_request(server
, ignore_pend
? CIFS_ASYNC_OP
: 0);
394 mutex_lock(&server
->srv_mutex
);
395 rc
= cifs_setup_async_request(server
, iov
, nvec
, &mid
);
397 mutex_unlock(&server
->srv_mutex
);
398 add_credits(server
, 1);
399 wake_up(&server
->request_q
);
403 mid
->receive
= receive
;
404 mid
->callback
= callback
;
405 mid
->callback_data
= cbdata
;
406 mid
->mid_state
= MID_REQUEST_SUBMITTED
;
408 /* put it on the pending_mid_q */
409 spin_lock(&GlobalMid_Lock
);
410 list_add_tail(&mid
->qhead
, &server
->pending_mid_q
);
411 spin_unlock(&GlobalMid_Lock
);
414 cifs_in_send_inc(server
);
415 rc
= smb_sendv(server
, iov
, nvec
);
416 cifs_in_send_dec(server
);
417 cifs_save_when_sent(mid
);
418 mutex_unlock(&server
->srv_mutex
);
424 add_credits(server
, 1);
425 wake_up(&server
->request_q
);
431 * Send an SMB Request. No response info (other than return code)
432 * needs to be parsed.
434 * flags indicate the type of request buffer and how long to wait
435 * and whether to log NT STATUS code (error) before mapping it to POSIX error
439 SendReceiveNoRsp(const unsigned int xid
, struct cifs_ses
*ses
,
440 char *in_buf
, int flags
)
446 iov
[0].iov_base
= in_buf
;
447 iov
[0].iov_len
= get_rfc1002_length(in_buf
) + 4;
448 flags
|= CIFS_NO_RESP
;
449 rc
= SendReceive2(xid
, ses
, iov
, 1, &resp_buf_type
, flags
);
450 cFYI(DBG2
, "SendRcvNoRsp flags %d rc %d", flags
, rc
);
456 cifs_sync_mid_result(struct mid_q_entry
*mid
, struct TCP_Server_Info
*server
)
460 cFYI(1, "%s: cmd=%d mid=%llu state=%d", __func__
,
461 le16_to_cpu(mid
->command
), mid
->mid
, mid
->mid_state
);
463 spin_lock(&GlobalMid_Lock
);
464 switch (mid
->mid_state
) {
465 case MID_RESPONSE_RECEIVED
:
466 spin_unlock(&GlobalMid_Lock
);
468 case MID_RETRY_NEEDED
:
471 case MID_RESPONSE_MALFORMED
:
478 list_del_init(&mid
->qhead
);
479 cERROR(1, "%s: invalid mid state mid=%llu state=%d", __func__
,
480 mid
->mid
, mid
->mid_state
);
483 spin_unlock(&GlobalMid_Lock
);
485 DeleteMidQEntry(mid
);
490 send_cancel(struct TCP_Server_Info
*server
, void *buf
, struct mid_q_entry
*mid
)
492 return server
->ops
->send_cancel
?
493 server
->ops
->send_cancel(server
, buf
, mid
) : 0;
497 cifs_check_receive(struct mid_q_entry
*mid
, struct TCP_Server_Info
*server
,
500 unsigned int len
= get_rfc1002_length(mid
->resp_buf
) + 4;
502 dump_smb(mid
->resp_buf
, min_t(u32
, 92, len
));
504 /* convert the length into a more usable form */
505 if (server
->sec_mode
& (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
)) {
508 iov
.iov_base
= mid
->resp_buf
;
510 /* FIXME: add code to kill session */
511 if (cifs_verify_signature(&iov
, 1, server
,
512 mid
->sequence_number
+ 1) != 0)
513 cERROR(1, "Unexpected SMB signature");
516 /* BB special case reconnect tid and uid here? */
517 return map_smb_to_linux_error(mid
->resp_buf
, log_error
);
521 cifs_setup_request(struct cifs_ses
*ses
, struct kvec
*iov
,
522 unsigned int nvec
, struct mid_q_entry
**ret_mid
)
525 struct smb_hdr
*hdr
= (struct smb_hdr
*)iov
[0].iov_base
;
526 struct mid_q_entry
*mid
;
528 rc
= allocate_mid(ses
, hdr
, &mid
);
531 rc
= cifs_sign_smb2(iov
, nvec
, ses
->server
, &mid
->sequence_number
);
539 SendReceive2(const unsigned int xid
, struct cifs_ses
*ses
,
540 struct kvec
*iov
, int n_vec
, int *pRespBufType
/* ret */,
545 struct mid_q_entry
*midQ
;
546 char *buf
= iov
[0].iov_base
;
548 long_op
= flags
& CIFS_TIMEOUT_MASK
;
550 *pRespBufType
= CIFS_NO_BUFFER
; /* no response buf yet */
552 if ((ses
== NULL
) || (ses
->server
== NULL
)) {
553 cifs_small_buf_release(buf
);
554 cERROR(1, "Null session");
558 if (ses
->server
->tcpStatus
== CifsExiting
) {
559 cifs_small_buf_release(buf
);
564 * Ensure that we do not send more than 50 overlapping requests
565 * to the same server. We may make this configurable later or
569 rc
= wait_for_free_request(ses
->server
, long_op
);
571 cifs_small_buf_release(buf
);
576 * Make sure that we sign in the same order that we send on this socket
577 * and avoid races inside tcp sendmsg code that could cause corruption
581 mutex_lock(&ses
->server
->srv_mutex
);
583 rc
= ses
->server
->ops
->setup_request(ses
, iov
, n_vec
, &midQ
);
585 mutex_unlock(&ses
->server
->srv_mutex
);
586 cifs_small_buf_release(buf
);
587 /* Update # of requests on wire to server */
588 add_credits(ses
->server
, 1);
592 midQ
->mid_state
= MID_REQUEST_SUBMITTED
;
593 cifs_in_send_inc(ses
->server
);
594 rc
= smb_sendv(ses
->server
, iov
, n_vec
);
595 cifs_in_send_dec(ses
->server
);
596 cifs_save_when_sent(midQ
);
598 mutex_unlock(&ses
->server
->srv_mutex
);
601 cifs_small_buf_release(buf
);
605 if (long_op
== CIFS_ASYNC_OP
) {
606 cifs_small_buf_release(buf
);
610 rc
= wait_for_response(ses
->server
, midQ
);
612 send_cancel(ses
->server
, buf
, midQ
);
613 spin_lock(&GlobalMid_Lock
);
614 if (midQ
->mid_state
== MID_REQUEST_SUBMITTED
) {
615 midQ
->callback
= DeleteMidQEntry
;
616 spin_unlock(&GlobalMid_Lock
);
617 cifs_small_buf_release(buf
);
618 add_credits(ses
->server
, 1);
621 spin_unlock(&GlobalMid_Lock
);
624 cifs_small_buf_release(buf
);
626 rc
= cifs_sync_mid_result(midQ
, ses
->server
);
628 add_credits(ses
->server
, 1);
632 if (!midQ
->resp_buf
|| midQ
->mid_state
!= MID_RESPONSE_RECEIVED
) {
634 cFYI(1, "Bad MID state?");
638 buf
= (char *)midQ
->resp_buf
;
639 iov
[0].iov_base
= buf
;
640 iov
[0].iov_len
= get_rfc1002_length(buf
) + 4;
642 *pRespBufType
= CIFS_LARGE_BUFFER
;
644 *pRespBufType
= CIFS_SMALL_BUFFER
;
646 rc
= ses
->server
->ops
->check_receive(midQ
, ses
->server
,
647 flags
& CIFS_LOG_ERROR
);
649 /* mark it so buf will not be freed by delete_mid */
650 if ((flags
& CIFS_NO_RESP
) == 0)
651 midQ
->resp_buf
= NULL
;
654 add_credits(ses
->server
, 1);
660 SendReceive(const unsigned int xid
, struct cifs_ses
*ses
,
661 struct smb_hdr
*in_buf
, struct smb_hdr
*out_buf
,
662 int *pbytes_returned
, const int long_op
)
665 struct mid_q_entry
*midQ
;
668 cERROR(1, "Null smb session");
671 if (ses
->server
== NULL
) {
672 cERROR(1, "Null tcp session");
676 if (ses
->server
->tcpStatus
== CifsExiting
)
679 /* Ensure that we do not send more than 50 overlapping requests
680 to the same server. We may make this configurable later or
683 if (be32_to_cpu(in_buf
->smb_buf_length
) > CIFSMaxBufSize
+
684 MAX_CIFS_HDR_SIZE
- 4) {
685 cERROR(1, "Illegal length, greater than maximum frame, %d",
686 be32_to_cpu(in_buf
->smb_buf_length
));
690 rc
= wait_for_free_request(ses
->server
, long_op
);
694 /* make sure that we sign in the same order that we send on this socket
695 and avoid races inside tcp sendmsg code that could cause corruption
698 mutex_lock(&ses
->server
->srv_mutex
);
700 rc
= allocate_mid(ses
, in_buf
, &midQ
);
702 mutex_unlock(&ses
->server
->srv_mutex
);
703 /* Update # of requests on wire to server */
704 add_credits(ses
->server
, 1);
708 rc
= cifs_sign_smb(in_buf
, ses
->server
, &midQ
->sequence_number
);
710 mutex_unlock(&ses
->server
->srv_mutex
);
714 midQ
->mid_state
= MID_REQUEST_SUBMITTED
;
716 cifs_in_send_inc(ses
->server
);
717 rc
= smb_send(ses
->server
, in_buf
, be32_to_cpu(in_buf
->smb_buf_length
));
718 cifs_in_send_dec(ses
->server
);
719 cifs_save_when_sent(midQ
);
720 mutex_unlock(&ses
->server
->srv_mutex
);
725 if (long_op
== CIFS_ASYNC_OP
)
728 rc
= wait_for_response(ses
->server
, midQ
);
730 send_cancel(ses
->server
, in_buf
, midQ
);
731 spin_lock(&GlobalMid_Lock
);
732 if (midQ
->mid_state
== MID_REQUEST_SUBMITTED
) {
733 /* no longer considered to be "in-flight" */
734 midQ
->callback
= DeleteMidQEntry
;
735 spin_unlock(&GlobalMid_Lock
);
736 add_credits(ses
->server
, 1);
739 spin_unlock(&GlobalMid_Lock
);
742 rc
= cifs_sync_mid_result(midQ
, ses
->server
);
744 add_credits(ses
->server
, 1);
748 if (!midQ
->resp_buf
|| !out_buf
||
749 midQ
->mid_state
!= MID_RESPONSE_RECEIVED
) {
751 cERROR(1, "Bad MID state?");
755 *pbytes_returned
= get_rfc1002_length(midQ
->resp_buf
);
756 memcpy(out_buf
, midQ
->resp_buf
, *pbytes_returned
+ 4);
757 rc
= cifs_check_receive(midQ
, ses
->server
, 0);
760 add_credits(ses
->server
, 1);
765 /* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
766 blocking lock to return. */
769 send_lock_cancel(const unsigned int xid
, struct cifs_tcon
*tcon
,
770 struct smb_hdr
*in_buf
,
771 struct smb_hdr
*out_buf
)
774 struct cifs_ses
*ses
= tcon
->ses
;
775 LOCK_REQ
*pSMB
= (LOCK_REQ
*)in_buf
;
777 /* We just modify the current in_buf to change
778 the type of lock from LOCKING_ANDX_SHARED_LOCK
779 or LOCKING_ANDX_EXCLUSIVE_LOCK to
780 LOCKING_ANDX_CANCEL_LOCK. */
782 pSMB
->LockType
= LOCKING_ANDX_CANCEL_LOCK
|LOCKING_ANDX_LARGE_FILES
;
784 pSMB
->hdr
.Mid
= get_next_mid(ses
->server
);
786 return SendReceive(xid
, ses
, in_buf
, out_buf
,
791 SendReceiveBlockingLock(const unsigned int xid
, struct cifs_tcon
*tcon
,
792 struct smb_hdr
*in_buf
, struct smb_hdr
*out_buf
,
793 int *pbytes_returned
)
797 struct mid_q_entry
*midQ
;
798 struct cifs_ses
*ses
;
800 if (tcon
== NULL
|| tcon
->ses
== NULL
) {
801 cERROR(1, "Null smb session");
806 if (ses
->server
== NULL
) {
807 cERROR(1, "Null tcp session");
811 if (ses
->server
->tcpStatus
== CifsExiting
)
814 /* Ensure that we do not send more than 50 overlapping requests
815 to the same server. We may make this configurable later or
818 if (be32_to_cpu(in_buf
->smb_buf_length
) > CIFSMaxBufSize
+
819 MAX_CIFS_HDR_SIZE
- 4) {
820 cERROR(1, "Illegal length, greater than maximum frame, %d",
821 be32_to_cpu(in_buf
->smb_buf_length
));
825 rc
= wait_for_free_request(ses
->server
, CIFS_BLOCKING_OP
);
829 /* make sure that we sign in the same order that we send on this socket
830 and avoid races inside tcp sendmsg code that could cause corruption
833 mutex_lock(&ses
->server
->srv_mutex
);
835 rc
= allocate_mid(ses
, in_buf
, &midQ
);
837 mutex_unlock(&ses
->server
->srv_mutex
);
841 rc
= cifs_sign_smb(in_buf
, ses
->server
, &midQ
->sequence_number
);
844 mutex_unlock(&ses
->server
->srv_mutex
);
848 midQ
->mid_state
= MID_REQUEST_SUBMITTED
;
849 cifs_in_send_inc(ses
->server
);
850 rc
= smb_send(ses
->server
, in_buf
, be32_to_cpu(in_buf
->smb_buf_length
));
851 cifs_in_send_dec(ses
->server
);
852 cifs_save_when_sent(midQ
);
853 mutex_unlock(&ses
->server
->srv_mutex
);
860 /* Wait for a reply - allow signals to interrupt. */
861 rc
= wait_event_interruptible(ses
->server
->response_q
,
862 (!(midQ
->mid_state
== MID_REQUEST_SUBMITTED
)) ||
863 ((ses
->server
->tcpStatus
!= CifsGood
) &&
864 (ses
->server
->tcpStatus
!= CifsNew
)));
866 /* Were we interrupted by a signal ? */
867 if ((rc
== -ERESTARTSYS
) &&
868 (midQ
->mid_state
== MID_REQUEST_SUBMITTED
) &&
869 ((ses
->server
->tcpStatus
== CifsGood
) ||
870 (ses
->server
->tcpStatus
== CifsNew
))) {
872 if (in_buf
->Command
== SMB_COM_TRANSACTION2
) {
873 /* POSIX lock. We send a NT_CANCEL SMB to cause the
874 blocking lock to return. */
875 rc
= send_cancel(ses
->server
, in_buf
, midQ
);
881 /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
882 to cause the blocking lock to return. */
884 rc
= send_lock_cancel(xid
, tcon
, in_buf
, out_buf
);
886 /* If we get -ENOLCK back the lock may have
887 already been removed. Don't exit in this case. */
888 if (rc
&& rc
!= -ENOLCK
) {
894 rc
= wait_for_response(ses
->server
, midQ
);
896 send_cancel(ses
->server
, in_buf
, midQ
);
897 spin_lock(&GlobalMid_Lock
);
898 if (midQ
->mid_state
== MID_REQUEST_SUBMITTED
) {
899 /* no longer considered to be "in-flight" */
900 midQ
->callback
= DeleteMidQEntry
;
901 spin_unlock(&GlobalMid_Lock
);
904 spin_unlock(&GlobalMid_Lock
);
907 /* We got the response - restart system call. */
911 rc
= cifs_sync_mid_result(midQ
, ses
->server
);
915 /* rcvd frame is ok */
916 if (out_buf
== NULL
|| midQ
->mid_state
!= MID_RESPONSE_RECEIVED
) {
918 cERROR(1, "Bad MID state?");
922 *pbytes_returned
= get_rfc1002_length(midQ
->resp_buf
);
923 memcpy(out_buf
, midQ
->resp_buf
, *pbytes_returned
+ 4);
924 rc
= cifs_check_receive(midQ
, ses
->server
, 0);
927 if (rstart
&& rc
== -EACCES
)