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 smb_hdr
*in_buf
,
346 mid_callback_t
*callback
, void *cbdata
)
349 struct mid_q_entry
*mid
;
351 rc
= wait_for_free_request(server
, CIFS_ASYNC_OP
);
355 /* enable signing if server requires it */
356 if (server
->secMode
& (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
))
357 in_buf
->Flags2
|= SMBFLG2_SECURITY_SIGNATURE
;
359 mutex_lock(&server
->srv_mutex
);
360 mid
= AllocMidQEntry(in_buf
, server
);
362 mutex_unlock(&server
->srv_mutex
);
366 /* put it on the pending_mid_q */
367 spin_lock(&GlobalMid_Lock
);
368 list_add_tail(&mid
->qhead
, &server
->pending_mid_q
);
369 spin_unlock(&GlobalMid_Lock
);
371 rc
= cifs_sign_smb(in_buf
, server
, &mid
->sequence_number
);
373 mutex_unlock(&server
->srv_mutex
);
377 mid
->callback
= callback
;
378 mid
->callback_data
= cbdata
;
379 mid
->midState
= MID_REQUEST_SUBMITTED
;
380 #ifdef CONFIG_CIFS_STATS2
381 atomic_inc(&server
->inSend
);
383 rc
= smb_send(server
, in_buf
, be32_to_cpu(in_buf
->smb_buf_length
));
384 #ifdef CONFIG_CIFS_STATS2
385 atomic_dec(&server
->inSend
);
386 mid
->when_sent
= jiffies
;
388 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 cifsSesInfo
*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 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 /* ensure that it's no longer on the pending_mid_q */
436 list_del_init(&mid
->qhead
);
438 switch (mid
->midState
) {
439 case MID_RESPONSE_RECEIVED
:
440 spin_unlock(&GlobalMid_Lock
);
442 case MID_REQUEST_SUBMITTED
:
443 /* socket is going down, reject all calls */
444 if (server
->tcpStatus
== CifsExiting
) {
445 cERROR(1, "%s: canceling mid=%d cmd=0x%x state=%d",
446 __func__
, mid
->mid
, mid
->command
, mid
->midState
);
450 case MID_RETRY_NEEDED
:
453 case MID_RESPONSE_MALFORMED
:
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
= cpu_to_be32(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
, 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 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
);
575 cifs_small_buf_release(in_buf
);
579 if (long_op
== CIFS_ASYNC_OP
) {
580 cifs_small_buf_release(in_buf
);
584 rc
= wait_for_response(ses
->server
, midQ
);
586 send_nt_cancel(ses
->server
, in_buf
, midQ
);
587 spin_lock(&GlobalMid_Lock
);
588 if (midQ
->midState
== MID_REQUEST_SUBMITTED
) {
589 midQ
->callback
= DeleteMidQEntry
;
590 spin_unlock(&GlobalMid_Lock
);
591 cifs_small_buf_release(in_buf
);
592 atomic_dec(&ses
->server
->inFlight
);
593 wake_up(&ses
->server
->request_q
);
596 spin_unlock(&GlobalMid_Lock
);
599 cifs_small_buf_release(in_buf
);
601 rc
= sync_mid_result(midQ
, ses
->server
);
603 atomic_dec(&ses
->server
->inFlight
);
604 wake_up(&ses
->server
->request_q
);
608 receive_len
= be32_to_cpu(midQ
->resp_buf
->smb_buf_length
);
610 if (receive_len
> CIFSMaxBufSize
+ MAX_CIFS_HDR_SIZE
) {
611 cERROR(1, "Frame too large received. Length: %d Xid: %d",
617 /* rcvd frame is ok */
619 if (midQ
->resp_buf
&&
620 (midQ
->midState
== MID_RESPONSE_RECEIVED
)) {
622 iov
[0].iov_base
= (char *)midQ
->resp_buf
;
624 *pRespBufType
= CIFS_LARGE_BUFFER
;
626 *pRespBufType
= CIFS_SMALL_BUFFER
;
627 iov
[0].iov_len
= receive_len
+ 4;
629 dump_smb(midQ
->resp_buf
, 80);
630 /* convert the length into a more usable form */
631 if ((receive_len
> 24) &&
632 (ses
->server
->secMode
& (SECMODE_SIGN_REQUIRED
|
633 SECMODE_SIGN_ENABLED
))) {
634 rc
= cifs_verify_signature(midQ
->resp_buf
,
636 midQ
->sequence_number
+1);
638 cERROR(1, "Unexpected SMB signature");
639 /* BB FIXME add code to kill session */
643 /* BB special case reconnect tid and uid here? */
644 rc
= map_smb_to_linux_error(midQ
->resp_buf
,
645 flags
& CIFS_LOG_ERROR
);
647 /* convert ByteCount if necessary */
648 if (receive_len
>= sizeof(struct smb_hdr
) - 4
649 /* do not count RFC1001 header */ +
650 (2 * midQ
->resp_buf
->WordCount
) + 2 /* bcc */ )
651 put_bcc(get_bcc_le(midQ
->resp_buf
), midQ
->resp_buf
);
652 if ((flags
& CIFS_NO_RESP
) == 0)
653 midQ
->resp_buf
= NULL
; /* mark it so buf will
658 cFYI(1, "Bad MID state?");
663 atomic_dec(&ses
->server
->inFlight
);
664 wake_up(&ses
->server
->request_q
);
670 SendReceive(const unsigned int xid
, struct cifsSesInfo
*ses
,
671 struct smb_hdr
*in_buf
, struct smb_hdr
*out_buf
,
672 int *pbytes_returned
, const int long_op
)
675 unsigned int receive_len
;
676 struct mid_q_entry
*midQ
;
679 cERROR(1, "Null smb session");
682 if (ses
->server
== NULL
) {
683 cERROR(1, "Null tcp session");
687 if (ses
->server
->tcpStatus
== CifsExiting
)
690 /* Ensure that we do not send more than 50 overlapping requests
691 to the same server. We may make this configurable later or
694 if (be32_to_cpu(in_buf
->smb_buf_length
) > CIFSMaxBufSize
+
695 MAX_CIFS_HDR_SIZE
- 4) {
696 cERROR(1, "Illegal length, greater than maximum frame, %d",
697 be32_to_cpu(in_buf
->smb_buf_length
));
701 rc
= wait_for_free_request(ses
->server
, long_op
);
705 /* make sure that we sign in the same order that we send on this socket
706 and avoid races inside tcp sendmsg code that could cause corruption
709 mutex_lock(&ses
->server
->srv_mutex
);
711 rc
= allocate_mid(ses
, in_buf
, &midQ
);
713 mutex_unlock(&ses
->server
->srv_mutex
);
714 /* Update # of requests on wire to server */
715 atomic_dec(&ses
->server
->inFlight
);
716 wake_up(&ses
->server
->request_q
);
720 rc
= cifs_sign_smb(in_buf
, ses
->server
, &midQ
->sequence_number
);
722 mutex_unlock(&ses
->server
->srv_mutex
);
726 midQ
->midState
= MID_REQUEST_SUBMITTED
;
727 #ifdef CONFIG_CIFS_STATS2
728 atomic_inc(&ses
->server
->inSend
);
730 rc
= smb_send(ses
->server
, in_buf
, be32_to_cpu(in_buf
->smb_buf_length
));
731 #ifdef CONFIG_CIFS_STATS2
732 atomic_dec(&ses
->server
->inSend
);
733 midQ
->when_sent
= jiffies
;
735 mutex_unlock(&ses
->server
->srv_mutex
);
740 if (long_op
== CIFS_ASYNC_OP
)
743 rc
= wait_for_response(ses
->server
, midQ
);
745 send_nt_cancel(ses
->server
, in_buf
, midQ
);
746 spin_lock(&GlobalMid_Lock
);
747 if (midQ
->midState
== MID_REQUEST_SUBMITTED
) {
748 /* no longer considered to be "in-flight" */
749 midQ
->callback
= DeleteMidQEntry
;
750 spin_unlock(&GlobalMid_Lock
);
751 atomic_dec(&ses
->server
->inFlight
);
752 wake_up(&ses
->server
->request_q
);
755 spin_unlock(&GlobalMid_Lock
);
758 rc
= sync_mid_result(midQ
, ses
->server
);
760 atomic_dec(&ses
->server
->inFlight
);
761 wake_up(&ses
->server
->request_q
);
765 receive_len
= be32_to_cpu(midQ
->resp_buf
->smb_buf_length
);
767 if (receive_len
> CIFSMaxBufSize
+ MAX_CIFS_HDR_SIZE
) {
768 cERROR(1, "Frame too large received. Length: %d Xid: %d",
774 /* rcvd frame is ok */
776 if (midQ
->resp_buf
&& out_buf
777 && (midQ
->midState
== MID_RESPONSE_RECEIVED
)) {
778 out_buf
->smb_buf_length
= cpu_to_be32(receive_len
);
779 memcpy((char *)out_buf
+ 4,
780 (char *)midQ
->resp_buf
+ 4,
783 dump_smb(out_buf
, 92);
784 /* convert the length into a more usable form */
785 if ((receive_len
> 24) &&
786 (ses
->server
->secMode
& (SECMODE_SIGN_REQUIRED
|
787 SECMODE_SIGN_ENABLED
))) {
788 rc
= cifs_verify_signature(out_buf
,
790 midQ
->sequence_number
+1);
792 cERROR(1, "Unexpected SMB signature");
793 /* BB FIXME add code to kill session */
797 *pbytes_returned
= be32_to_cpu(out_buf
->smb_buf_length
);
799 /* BB special case reconnect tid and uid here? */
800 rc
= map_smb_to_linux_error(out_buf
, 0 /* no log */ );
802 /* convert ByteCount if necessary */
803 if (receive_len
>= sizeof(struct smb_hdr
) - 4
804 /* do not count RFC1001 header */ +
805 (2 * out_buf
->WordCount
) + 2 /* bcc */ )
806 put_bcc(get_bcc_le(midQ
->resp_buf
), midQ
->resp_buf
);
809 cERROR(1, "Bad MID state?");
814 atomic_dec(&ses
->server
->inFlight
);
815 wake_up(&ses
->server
->request_q
);
820 /* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
821 blocking lock to return. */
824 send_lock_cancel(const unsigned int xid
, struct cifsTconInfo
*tcon
,
825 struct smb_hdr
*in_buf
,
826 struct smb_hdr
*out_buf
)
829 struct cifsSesInfo
*ses
= tcon
->ses
;
830 LOCK_REQ
*pSMB
= (LOCK_REQ
*)in_buf
;
832 /* We just modify the current in_buf to change
833 the type of lock from LOCKING_ANDX_SHARED_LOCK
834 or LOCKING_ANDX_EXCLUSIVE_LOCK to
835 LOCKING_ANDX_CANCEL_LOCK. */
837 pSMB
->LockType
= LOCKING_ANDX_CANCEL_LOCK
|LOCKING_ANDX_LARGE_FILES
;
839 pSMB
->hdr
.Mid
= GetNextMid(ses
->server
);
841 return SendReceive(xid
, ses
, in_buf
, out_buf
,
846 SendReceiveBlockingLock(const unsigned int xid
, struct cifsTconInfo
*tcon
,
847 struct smb_hdr
*in_buf
, struct smb_hdr
*out_buf
,
848 int *pbytes_returned
)
852 unsigned int receive_len
;
853 struct mid_q_entry
*midQ
;
854 struct cifsSesInfo
*ses
;
856 if (tcon
== NULL
|| tcon
->ses
== NULL
) {
857 cERROR(1, "Null smb session");
862 if (ses
->server
== NULL
) {
863 cERROR(1, "Null tcp session");
867 if (ses
->server
->tcpStatus
== CifsExiting
)
870 /* Ensure that we do not send more than 50 overlapping requests
871 to the same server. We may make this configurable later or
874 if (be32_to_cpu(in_buf
->smb_buf_length
) > CIFSMaxBufSize
+
875 MAX_CIFS_HDR_SIZE
- 4) {
876 cERROR(1, "Illegal length, greater than maximum frame, %d",
877 be32_to_cpu(in_buf
->smb_buf_length
));
881 rc
= wait_for_free_request(ses
->server
, CIFS_BLOCKING_OP
);
885 /* make sure that we sign in the same order that we send on this socket
886 and avoid races inside tcp sendmsg code that could cause corruption
889 mutex_lock(&ses
->server
->srv_mutex
);
891 rc
= allocate_mid(ses
, in_buf
, &midQ
);
893 mutex_unlock(&ses
->server
->srv_mutex
);
897 rc
= cifs_sign_smb(in_buf
, ses
->server
, &midQ
->sequence_number
);
900 mutex_unlock(&ses
->server
->srv_mutex
);
904 midQ
->midState
= MID_REQUEST_SUBMITTED
;
905 #ifdef CONFIG_CIFS_STATS2
906 atomic_inc(&ses
->server
->inSend
);
908 rc
= smb_send(ses
->server
, in_buf
, be32_to_cpu(in_buf
->smb_buf_length
));
909 #ifdef CONFIG_CIFS_STATS2
910 atomic_dec(&ses
->server
->inSend
);
911 midQ
->when_sent
= jiffies
;
913 mutex_unlock(&ses
->server
->srv_mutex
);
920 /* Wait for a reply - allow signals to interrupt. */
921 rc
= wait_event_interruptible(ses
->server
->response_q
,
922 (!(midQ
->midState
== MID_REQUEST_SUBMITTED
)) ||
923 ((ses
->server
->tcpStatus
!= CifsGood
) &&
924 (ses
->server
->tcpStatus
!= CifsNew
)));
926 /* Were we interrupted by a signal ? */
927 if ((rc
== -ERESTARTSYS
) &&
928 (midQ
->midState
== MID_REQUEST_SUBMITTED
) &&
929 ((ses
->server
->tcpStatus
== CifsGood
) ||
930 (ses
->server
->tcpStatus
== CifsNew
))) {
932 if (in_buf
->Command
== SMB_COM_TRANSACTION2
) {
933 /* POSIX lock. We send a NT_CANCEL SMB to cause the
934 blocking lock to return. */
935 rc
= send_nt_cancel(ses
->server
, in_buf
, midQ
);
941 /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
942 to cause the blocking lock to return. */
944 rc
= send_lock_cancel(xid
, tcon
, in_buf
, out_buf
);
946 /* If we get -ENOLCK back the lock may have
947 already been removed. Don't exit in this case. */
948 if (rc
&& rc
!= -ENOLCK
) {
954 rc
= wait_for_response(ses
->server
, midQ
);
956 send_nt_cancel(ses
->server
, in_buf
, midQ
);
957 spin_lock(&GlobalMid_Lock
);
958 if (midQ
->midState
== MID_REQUEST_SUBMITTED
) {
959 /* no longer considered to be "in-flight" */
960 midQ
->callback
= DeleteMidQEntry
;
961 spin_unlock(&GlobalMid_Lock
);
964 spin_unlock(&GlobalMid_Lock
);
967 /* We got the response - restart system call. */
971 rc
= sync_mid_result(midQ
, ses
->server
);
975 receive_len
= be32_to_cpu(midQ
->resp_buf
->smb_buf_length
);
976 if (receive_len
> CIFSMaxBufSize
+ MAX_CIFS_HDR_SIZE
) {
977 cERROR(1, "Frame too large received. Length: %d Xid: %d",
983 /* rcvd frame is ok */
985 if ((out_buf
== NULL
) || (midQ
->midState
!= MID_RESPONSE_RECEIVED
)) {
987 cERROR(1, "Bad MID state?");
991 out_buf
->smb_buf_length
= cpu_to_be32(receive_len
);
992 memcpy((char *)out_buf
+ 4,
993 (char *)midQ
->resp_buf
+ 4,
996 dump_smb(out_buf
, 92);
997 /* convert the length into a more usable form */
998 if ((receive_len
> 24) &&
999 (ses
->server
->secMode
& (SECMODE_SIGN_REQUIRED
|
1000 SECMODE_SIGN_ENABLED
))) {
1001 rc
= cifs_verify_signature(out_buf
,
1003 midQ
->sequence_number
+1);
1005 cERROR(1, "Unexpected SMB signature");
1006 /* BB FIXME add code to kill session */
1010 *pbytes_returned
= be32_to_cpu(out_buf
->smb_buf_length
);
1012 /* BB special case reconnect tid and uid here? */
1013 rc
= map_smb_to_linux_error(out_buf
, 0 /* no log */ );
1015 /* convert ByteCount if necessary */
1016 if (receive_len
>= sizeof(struct smb_hdr
) - 4
1017 /* do not count RFC1001 header */ +
1018 (2 * out_buf
->WordCount
) + 2 /* bcc */ )
1019 put_bcc(get_bcc_le(out_buf
), out_buf
);
1023 if (rstart
&& rc
== -EACCES
)
1024 return -ERESTARTSYS
;