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
= be32_to_cpu(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
;
148 for (i
= 0; i
< n_vec
; i
++)
149 total_len
+= iov
[i
].iov_len
;
151 cFYI(1, "Sending smb: total_len %d", total_len
);
152 dump_smb(smb_buffer
, len
);
156 rc
= kernel_sendmsg(ssocket
, &smb_msg
, &iov
[first_vec
],
157 n_vec
- first_vec
, total_len
);
158 if ((rc
== -ENOSPC
) || (rc
== -EAGAIN
)) {
160 /* if blocking send we try 3 times, since each can block
161 for 5 seconds. For nonblocking we have to try more
162 but wait increasing amounts of time allowing time for
163 socket to clear. The overall time we wait in either
164 case to send on the socket is about 15 seconds.
165 Similarly we wait for 15 seconds for
166 a response from the server in SendReceive[2]
167 for the server to send a response back for
168 most types of requests (except SMB Write
169 past end of file which can be slow, and
170 blocking lock operations). NFS waits slightly longer
171 than CIFS, but this can make it take longer for
172 nonresponsive servers to be detected and 15 seconds
173 is more than enough time for modern networks to
174 send a packet. In most cases if we fail to send
175 after the retries we will kill the socket and
176 reconnect which may clear the network problem.
178 if ((i
>= 14) || (!server
->noblocksnd
&& (i
> 2))) {
179 cERROR(1, "sends on sock %p stuck for 15 seconds",
190 if (rc
== total_len
) {
193 } else if (rc
> total_len
) {
194 cERROR(1, "sent %d requested %d", rc
, total_len
);
198 /* should never happen, letting socket clear before
199 retrying is our only obvious option here */
200 cERROR(1, "tcp sent no data");
205 /* the line below resets i */
206 for (i
= first_vec
; i
< n_vec
; i
++) {
207 if (iov
[i
].iov_len
) {
208 if (rc
> iov
[i
].iov_len
) {
209 rc
-= iov
[i
].iov_len
;
212 iov
[i
].iov_base
+= rc
;
213 iov
[i
].iov_len
-= rc
;
219 i
= 0; /* in case we get ENOSPC on the next send */
222 if ((total_len
> 0) && (total_len
!= smb_buf_length
+ 4)) {
223 cFYI(1, "partial send (%d remaining), terminating session",
225 /* If we have only sent part of an SMB then the next SMB
226 could be taken as the remainder of this one. We need
227 to kill the socket so the server throws away the partial
229 server
->tcpStatus
= CifsNeedReconnect
;
232 if (rc
< 0 && rc
!= -EINTR
)
233 cERROR(1, "Error %d sending data on socket to server", rc
);
237 /* Don't want to modify the buffer as a
238 side effect of this call. */
239 smb_buffer
->smb_buf_length
= 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);
256 static int wait_for_free_request(struct TCP_Server_Info
*server
,
259 if (long_op
== CIFS_ASYNC_OP
) {
260 /* oplock breaks must not be held up */
261 atomic_inc(&server
->inFlight
);
265 spin_lock(&GlobalMid_Lock
);
267 if (atomic_read(&server
->inFlight
) >= cifs_max_pending
) {
268 spin_unlock(&GlobalMid_Lock
);
269 #ifdef CONFIG_CIFS_STATS2
270 atomic_inc(&server
->num_waiters
);
272 wait_event(server
->request_q
,
273 atomic_read(&server
->inFlight
)
275 #ifdef CONFIG_CIFS_STATS2
276 atomic_dec(&server
->num_waiters
);
278 spin_lock(&GlobalMid_Lock
);
280 if (server
->tcpStatus
== CifsExiting
) {
281 spin_unlock(&GlobalMid_Lock
);
285 /* can not count locking commands against total
286 as they are allowed to block on server */
288 /* update # of requests on the wire to server */
289 if (long_op
!= CIFS_BLOCKING_OP
)
290 atomic_inc(&server
->inFlight
);
291 spin_unlock(&GlobalMid_Lock
);
298 static int allocate_mid(struct cifsSesInfo
*ses
, struct smb_hdr
*in_buf
,
299 struct mid_q_entry
**ppmidQ
)
301 if (ses
->server
->tcpStatus
== CifsExiting
) {
305 if (ses
->server
->tcpStatus
== CifsNeedReconnect
) {
306 cFYI(1, "tcp session dead - return to caller to retry");
310 if (ses
->status
!= CifsGood
) {
311 /* check if SMB session is bad because we are setting it up */
312 if ((in_buf
->Command
!= SMB_COM_SESSION_SETUP_ANDX
) &&
313 (in_buf
->Command
!= SMB_COM_NEGOTIATE
))
315 /* else ok - we are setting up session */
317 *ppmidQ
= AllocMidQEntry(in_buf
, ses
->server
);
320 spin_lock(&GlobalMid_Lock
);
321 list_add_tail(&(*ppmidQ
)->qhead
, &ses
->server
->pending_mid_q
);
322 spin_unlock(&GlobalMid_Lock
);
327 wait_for_response(struct TCP_Server_Info
*server
, struct mid_q_entry
*midQ
)
331 error
= wait_event_killable(server
->response_q
,
332 midQ
->midState
!= MID_REQUEST_SUBMITTED
);
341 * Send a SMB request and set the callback function in the mid to handle
342 * the result. Caller is responsible for dealing with timeouts.
345 cifs_call_async(struct TCP_Server_Info
*server
, struct kvec
*iov
,
346 unsigned int nvec
, mid_callback_t
*callback
, void *cbdata
,
350 struct mid_q_entry
*mid
;
351 struct smb_hdr
*hdr
= (struct smb_hdr
*)iov
[0].iov_base
;
353 rc
= wait_for_free_request(server
, ignore_pend
? CIFS_ASYNC_OP
: 0);
357 /* enable signing if server requires it */
358 if (server
->secMode
& (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
))
359 hdr
->Flags2
|= SMBFLG2_SECURITY_SIGNATURE
;
361 mutex_lock(&server
->srv_mutex
);
362 mid
= AllocMidQEntry(hdr
, server
);
364 mutex_unlock(&server
->srv_mutex
);
368 /* put it on the pending_mid_q */
369 spin_lock(&GlobalMid_Lock
);
370 list_add_tail(&mid
->qhead
, &server
->pending_mid_q
);
371 spin_unlock(&GlobalMid_Lock
);
373 rc
= cifs_sign_smb2(iov
, nvec
, server
, &mid
->sequence_number
);
375 mutex_unlock(&server
->srv_mutex
);
379 mid
->callback
= callback
;
380 mid
->callback_data
= cbdata
;
381 mid
->midState
= MID_REQUEST_SUBMITTED
;
382 #ifdef CONFIG_CIFS_STATS2
383 atomic_inc(&server
->inSend
);
385 rc
= smb_sendv(server
, iov
, nvec
);
386 #ifdef CONFIG_CIFS_STATS2
387 atomic_dec(&server
->inSend
);
388 mid
->when_sent
= jiffies
;
390 mutex_unlock(&server
->srv_mutex
);
397 atomic_dec(&server
->inFlight
);
398 wake_up(&server
->request_q
);
404 * Send an SMB Request. No response info (other than return code)
405 * needs to be parsed.
407 * flags indicate the type of request buffer and how long to wait
408 * and whether to log NT STATUS code (error) before mapping it to POSIX error
412 SendReceiveNoRsp(const unsigned int xid
, struct cifsSesInfo
*ses
,
413 struct smb_hdr
*in_buf
, int flags
)
419 iov
[0].iov_base
= (char *)in_buf
;
420 iov
[0].iov_len
= be32_to_cpu(in_buf
->smb_buf_length
) + 4;
421 flags
|= CIFS_NO_RESP
;
422 rc
= SendReceive2(xid
, ses
, iov
, 1, &resp_buf_type
, flags
);
423 cFYI(DBG2
, "SendRcvNoRsp flags %d rc %d", flags
, rc
);
429 sync_mid_result(struct mid_q_entry
*mid
, struct TCP_Server_Info
*server
)
433 cFYI(1, "%s: cmd=%d mid=%d state=%d", __func__
, mid
->command
,
434 mid
->mid
, mid
->midState
);
436 spin_lock(&GlobalMid_Lock
);
437 /* ensure that it's no longer on the pending_mid_q */
438 list_del_init(&mid
->qhead
);
440 switch (mid
->midState
) {
441 case MID_RESPONSE_RECEIVED
:
442 spin_unlock(&GlobalMid_Lock
);
444 case MID_REQUEST_SUBMITTED
:
445 /* socket is going down, reject all calls */
446 if (server
->tcpStatus
== CifsExiting
) {
447 cERROR(1, "%s: canceling mid=%d cmd=0x%x state=%d",
448 __func__
, mid
->mid
, mid
->command
, mid
->midState
);
452 case MID_RETRY_NEEDED
:
455 case MID_RESPONSE_MALFORMED
:
459 cERROR(1, "%s: invalid mid state mid=%d state=%d", __func__
,
460 mid
->mid
, mid
->midState
);
463 spin_unlock(&GlobalMid_Lock
);
465 DeleteMidQEntry(mid
);
470 * An NT cancel request header looks just like the original request except:
472 * The Command is SMB_COM_NT_CANCEL
473 * The WordCount is zeroed out
474 * The ByteCount is zeroed out
476 * This function mangles an existing request buffer into a
477 * SMB_COM_NT_CANCEL request and then sends it.
480 send_nt_cancel(struct TCP_Server_Info
*server
, struct smb_hdr
*in_buf
,
481 struct mid_q_entry
*mid
)
485 /* -4 for RFC1001 length and +2 for BCC field */
486 in_buf
->smb_buf_length
= cpu_to_be32(sizeof(struct smb_hdr
) - 4 + 2);
487 in_buf
->Command
= SMB_COM_NT_CANCEL
;
488 in_buf
->WordCount
= 0;
491 mutex_lock(&server
->srv_mutex
);
492 rc
= cifs_sign_smb(in_buf
, server
, &mid
->sequence_number
);
494 mutex_unlock(&server
->srv_mutex
);
497 rc
= smb_send(server
, in_buf
, be32_to_cpu(in_buf
->smb_buf_length
));
498 mutex_unlock(&server
->srv_mutex
);
500 cFYI(1, "issued NT_CANCEL for mid %u, rc = %d",
507 cifs_check_receive(struct mid_q_entry
*mid
, struct TCP_Server_Info
*server
,
510 dump_smb(mid
->resp_buf
,
511 min_t(u32
, 92, be32_to_cpu(mid
->resp_buf
->smb_buf_length
)));
513 /* convert the length into a more usable form */
514 if (server
->secMode
& (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
)) {
515 /* FIXME: add code to kill session */
516 if (cifs_verify_signature(mid
->resp_buf
, server
,
517 mid
->sequence_number
+ 1) != 0)
518 cERROR(1, "Unexpected SMB signature");
521 /* BB special case reconnect tid and uid here? */
522 return map_smb_to_linux_error(mid
->resp_buf
, log_error
);
526 SendReceive2(const unsigned int xid
, struct cifsSesInfo
*ses
,
527 struct kvec
*iov
, int n_vec
, int *pRespBufType
/* ret */,
532 struct mid_q_entry
*midQ
;
533 struct smb_hdr
*in_buf
= iov
[0].iov_base
;
535 long_op
= flags
& CIFS_TIMEOUT_MASK
;
537 *pRespBufType
= CIFS_NO_BUFFER
; /* no response buf yet */
539 if ((ses
== NULL
) || (ses
->server
== NULL
)) {
540 cifs_small_buf_release(in_buf
);
541 cERROR(1, "Null session");
545 if (ses
->server
->tcpStatus
== CifsExiting
) {
546 cifs_small_buf_release(in_buf
);
550 /* Ensure that we do not send more than 50 overlapping requests
551 to the same server. We may make this configurable later or
554 rc
= wait_for_free_request(ses
->server
, long_op
);
556 cifs_small_buf_release(in_buf
);
560 /* make sure that we sign in the same order that we send on this socket
561 and avoid races inside tcp sendmsg code that could cause corruption
564 mutex_lock(&ses
->server
->srv_mutex
);
566 rc
= allocate_mid(ses
, in_buf
, &midQ
);
568 mutex_unlock(&ses
->server
->srv_mutex
);
569 cifs_small_buf_release(in_buf
);
570 /* Update # of requests on wire to server */
571 atomic_dec(&ses
->server
->inFlight
);
572 wake_up(&ses
->server
->request_q
);
575 rc
= cifs_sign_smb2(iov
, n_vec
, ses
->server
, &midQ
->sequence_number
);
577 mutex_unlock(&ses
->server
->srv_mutex
);
578 cifs_small_buf_release(in_buf
);
582 midQ
->midState
= MID_REQUEST_SUBMITTED
;
583 #ifdef CONFIG_CIFS_STATS2
584 atomic_inc(&ses
->server
->inSend
);
586 rc
= smb_sendv(ses
->server
, iov
, n_vec
);
587 #ifdef CONFIG_CIFS_STATS2
588 atomic_dec(&ses
->server
->inSend
);
589 midQ
->when_sent
= jiffies
;
592 mutex_unlock(&ses
->server
->srv_mutex
);
595 cifs_small_buf_release(in_buf
);
599 if (long_op
== CIFS_ASYNC_OP
) {
600 cifs_small_buf_release(in_buf
);
604 rc
= wait_for_response(ses
->server
, midQ
);
606 send_nt_cancel(ses
->server
, in_buf
, midQ
);
607 spin_lock(&GlobalMid_Lock
);
608 if (midQ
->midState
== MID_REQUEST_SUBMITTED
) {
609 midQ
->callback
= DeleteMidQEntry
;
610 spin_unlock(&GlobalMid_Lock
);
611 cifs_small_buf_release(in_buf
);
612 atomic_dec(&ses
->server
->inFlight
);
613 wake_up(&ses
->server
->request_q
);
616 spin_unlock(&GlobalMid_Lock
);
619 cifs_small_buf_release(in_buf
);
621 rc
= sync_mid_result(midQ
, ses
->server
);
623 atomic_dec(&ses
->server
->inFlight
);
624 wake_up(&ses
->server
->request_q
);
628 if (!midQ
->resp_buf
|| midQ
->midState
!= MID_RESPONSE_RECEIVED
) {
630 cFYI(1, "Bad MID state?");
634 iov
[0].iov_base
= (char *)midQ
->resp_buf
;
635 iov
[0].iov_len
= be32_to_cpu(midQ
->resp_buf
->smb_buf_length
) + 4;
637 *pRespBufType
= CIFS_LARGE_BUFFER
;
639 *pRespBufType
= CIFS_SMALL_BUFFER
;
641 rc
= cifs_check_receive(midQ
, ses
->server
, flags
& CIFS_LOG_ERROR
);
643 /* mark it so buf will not be freed by delete_mid */
644 if ((flags
& CIFS_NO_RESP
) == 0)
645 midQ
->resp_buf
= NULL
;
648 atomic_dec(&ses
->server
->inFlight
);
649 wake_up(&ses
->server
->request_q
);
655 SendReceive(const unsigned int xid
, struct cifsSesInfo
*ses
,
656 struct smb_hdr
*in_buf
, struct smb_hdr
*out_buf
,
657 int *pbytes_returned
, const int long_op
)
660 struct mid_q_entry
*midQ
;
663 cERROR(1, "Null smb session");
666 if (ses
->server
== NULL
) {
667 cERROR(1, "Null tcp session");
671 if (ses
->server
->tcpStatus
== CifsExiting
)
674 /* Ensure that we do not send more than 50 overlapping requests
675 to the same server. We may make this configurable later or
678 if (be32_to_cpu(in_buf
->smb_buf_length
) > CIFSMaxBufSize
+
679 MAX_CIFS_HDR_SIZE
- 4) {
680 cERROR(1, "Illegal length, greater than maximum frame, %d",
681 be32_to_cpu(in_buf
->smb_buf_length
));
685 rc
= wait_for_free_request(ses
->server
, long_op
);
689 /* make sure that we sign in the same order that we send on this socket
690 and avoid races inside tcp sendmsg code that could cause corruption
693 mutex_lock(&ses
->server
->srv_mutex
);
695 rc
= allocate_mid(ses
, in_buf
, &midQ
);
697 mutex_unlock(&ses
->server
->srv_mutex
);
698 /* Update # of requests on wire to server */
699 atomic_dec(&ses
->server
->inFlight
);
700 wake_up(&ses
->server
->request_q
);
704 rc
= cifs_sign_smb(in_buf
, ses
->server
, &midQ
->sequence_number
);
706 mutex_unlock(&ses
->server
->srv_mutex
);
710 midQ
->midState
= MID_REQUEST_SUBMITTED
;
711 #ifdef CONFIG_CIFS_STATS2
712 atomic_inc(&ses
->server
->inSend
);
714 rc
= smb_send(ses
->server
, in_buf
, be32_to_cpu(in_buf
->smb_buf_length
));
715 #ifdef CONFIG_CIFS_STATS2
716 atomic_dec(&ses
->server
->inSend
);
717 midQ
->when_sent
= jiffies
;
719 mutex_unlock(&ses
->server
->srv_mutex
);
724 if (long_op
== CIFS_ASYNC_OP
)
727 rc
= wait_for_response(ses
->server
, midQ
);
729 send_nt_cancel(ses
->server
, in_buf
, midQ
);
730 spin_lock(&GlobalMid_Lock
);
731 if (midQ
->midState
== MID_REQUEST_SUBMITTED
) {
732 /* no longer considered to be "in-flight" */
733 midQ
->callback
= DeleteMidQEntry
;
734 spin_unlock(&GlobalMid_Lock
);
735 atomic_dec(&ses
->server
->inFlight
);
736 wake_up(&ses
->server
->request_q
);
739 spin_unlock(&GlobalMid_Lock
);
742 rc
= sync_mid_result(midQ
, ses
->server
);
744 atomic_dec(&ses
->server
->inFlight
);
745 wake_up(&ses
->server
->request_q
);
749 if (!midQ
->resp_buf
|| !out_buf
||
750 midQ
->midState
!= MID_RESPONSE_RECEIVED
) {
752 cERROR(1, "Bad MID state?");
756 *pbytes_returned
= be32_to_cpu(midQ
->resp_buf
->smb_buf_length
);
757 memcpy(out_buf
, midQ
->resp_buf
, *pbytes_returned
+ 4);
758 rc
= cifs_check_receive(midQ
, ses
->server
, 0);
761 atomic_dec(&ses
->server
->inFlight
);
762 wake_up(&ses
->server
->request_q
);
767 /* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
768 blocking lock to return. */
771 send_lock_cancel(const unsigned int xid
, struct cifsTconInfo
*tcon
,
772 struct smb_hdr
*in_buf
,
773 struct smb_hdr
*out_buf
)
776 struct cifsSesInfo
*ses
= tcon
->ses
;
777 LOCK_REQ
*pSMB
= (LOCK_REQ
*)in_buf
;
779 /* We just modify the current in_buf to change
780 the type of lock from LOCKING_ANDX_SHARED_LOCK
781 or LOCKING_ANDX_EXCLUSIVE_LOCK to
782 LOCKING_ANDX_CANCEL_LOCK. */
784 pSMB
->LockType
= LOCKING_ANDX_CANCEL_LOCK
|LOCKING_ANDX_LARGE_FILES
;
786 pSMB
->hdr
.Mid
= GetNextMid(ses
->server
);
788 return SendReceive(xid
, ses
, in_buf
, out_buf
,
793 SendReceiveBlockingLock(const unsigned int xid
, struct cifsTconInfo
*tcon
,
794 struct smb_hdr
*in_buf
, struct smb_hdr
*out_buf
,
795 int *pbytes_returned
)
799 struct mid_q_entry
*midQ
;
800 struct cifsSesInfo
*ses
;
802 if (tcon
== NULL
|| tcon
->ses
== NULL
) {
803 cERROR(1, "Null smb session");
808 if (ses
->server
== NULL
) {
809 cERROR(1, "Null tcp session");
813 if (ses
->server
->tcpStatus
== CifsExiting
)
816 /* Ensure that we do not send more than 50 overlapping requests
817 to the same server. We may make this configurable later or
820 if (be32_to_cpu(in_buf
->smb_buf_length
) > CIFSMaxBufSize
+
821 MAX_CIFS_HDR_SIZE
- 4) {
822 cERROR(1, "Illegal length, greater than maximum frame, %d",
823 be32_to_cpu(in_buf
->smb_buf_length
));
827 rc
= wait_for_free_request(ses
->server
, CIFS_BLOCKING_OP
);
831 /* make sure that we sign in the same order that we send on this socket
832 and avoid races inside tcp sendmsg code that could cause corruption
835 mutex_lock(&ses
->server
->srv_mutex
);
837 rc
= allocate_mid(ses
, in_buf
, &midQ
);
839 mutex_unlock(&ses
->server
->srv_mutex
);
843 rc
= cifs_sign_smb(in_buf
, ses
->server
, &midQ
->sequence_number
);
846 mutex_unlock(&ses
->server
->srv_mutex
);
850 midQ
->midState
= MID_REQUEST_SUBMITTED
;
851 #ifdef CONFIG_CIFS_STATS2
852 atomic_inc(&ses
->server
->inSend
);
854 rc
= smb_send(ses
->server
, in_buf
, be32_to_cpu(in_buf
->smb_buf_length
));
855 #ifdef CONFIG_CIFS_STATS2
856 atomic_dec(&ses
->server
->inSend
);
857 midQ
->when_sent
= jiffies
;
859 mutex_unlock(&ses
->server
->srv_mutex
);
866 /* Wait for a reply - allow signals to interrupt. */
867 rc
= wait_event_interruptible(ses
->server
->response_q
,
868 (!(midQ
->midState
== MID_REQUEST_SUBMITTED
)) ||
869 ((ses
->server
->tcpStatus
!= CifsGood
) &&
870 (ses
->server
->tcpStatus
!= CifsNew
)));
872 /* Were we interrupted by a signal ? */
873 if ((rc
== -ERESTARTSYS
) &&
874 (midQ
->midState
== MID_REQUEST_SUBMITTED
) &&
875 ((ses
->server
->tcpStatus
== CifsGood
) ||
876 (ses
->server
->tcpStatus
== CifsNew
))) {
878 if (in_buf
->Command
== SMB_COM_TRANSACTION2
) {
879 /* POSIX lock. We send a NT_CANCEL SMB to cause the
880 blocking lock to return. */
881 rc
= send_nt_cancel(ses
->server
, in_buf
, midQ
);
887 /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
888 to cause the blocking lock to return. */
890 rc
= send_lock_cancel(xid
, tcon
, in_buf
, out_buf
);
892 /* If we get -ENOLCK back the lock may have
893 already been removed. Don't exit in this case. */
894 if (rc
&& rc
!= -ENOLCK
) {
900 rc
= wait_for_response(ses
->server
, midQ
);
902 send_nt_cancel(ses
->server
, in_buf
, midQ
);
903 spin_lock(&GlobalMid_Lock
);
904 if (midQ
->midState
== MID_REQUEST_SUBMITTED
) {
905 /* no longer considered to be "in-flight" */
906 midQ
->callback
= DeleteMidQEntry
;
907 spin_unlock(&GlobalMid_Lock
);
910 spin_unlock(&GlobalMid_Lock
);
913 /* We got the response - restart system call. */
917 rc
= sync_mid_result(midQ
, ses
->server
);
921 /* rcvd frame is ok */
922 if (out_buf
== NULL
|| midQ
->midState
!= MID_RESPONSE_RECEIVED
) {
924 cERROR(1, "Bad MID state?");
928 *pbytes_returned
= be32_to_cpu(midQ
->resp_buf
->smb_buf_length
);
929 memcpy(out_buf
, midQ
->resp_buf
, *pbytes_returned
+ 4);
930 rc
= cifs_check_receive(midQ
, ses
->server
, 0);
933 if (rstart
&& rc
== -EACCES
)