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/wait.h>
26 #include <linux/net.h>
27 #include <linux/delay.h>
28 #include <asm/uaccess.h>
29 #include <asm/processor.h>
30 #include <linux/mempool.h>
33 #include "cifsproto.h"
34 #include "cifs_debug.h"
36 extern mempool_t *cifs_mid_poolp;
37 extern struct kmem_cache *cifs_oplock_cachep;
39 static struct mid_q_entry *
40 AllocMidQEntry(const struct smb_hdr *smb_buffer, struct TCP_Server_Info *server)
42 struct mid_q_entry *temp;
45 cERROR(1, ("Null TCP session in AllocMidQEntry"));
49 temp = mempool_alloc(cifs_mid_poolp, GFP_NOFS);
53 memset(temp, 0, sizeof(struct mid_q_entry));
54 temp->mid = smb_buffer->Mid; /* always LE */
55 temp->pid = current->pid;
56 temp->command = smb_buffer->Command;
57 cFYI(1, ("For smb_command %d", temp->command));
58 /* do_gettimeofday(&temp->when_sent);*/ /* easier to use jiffies */
59 /* when mid allocated can be before when sent */
60 temp->when_alloc = jiffies;
64 spin_lock(&GlobalMid_Lock);
65 list_add_tail(&temp->qhead, &server->pending_mid_q);
66 atomic_inc(&midCount);
67 temp->midState = MID_REQUEST_ALLOCATED;
68 spin_unlock(&GlobalMid_Lock);
73 DeleteMidQEntry(struct mid_q_entry *midEntry)
75 #ifdef CONFIG_CIFS_STATS2
78 spin_lock(&GlobalMid_Lock);
79 midEntry->midState = MID_FREE;
80 list_del(&midEntry->qhead);
81 atomic_dec(&midCount);
82 spin_unlock(&GlobalMid_Lock);
83 if (midEntry->largeBuf)
84 cifs_buf_release(midEntry->resp_buf);
86 cifs_small_buf_release(midEntry->resp_buf);
87 #ifdef CONFIG_CIFS_STATS2
89 /* commands taking longer than one second are indications that
90 something is wrong, unless it is quite a slow link or server */
91 if ((now - midEntry->when_alloc) > HZ) {
92 if ((cifsFYI & CIFS_TIMER) &&
93 (midEntry->command != SMB_COM_LOCKING_ANDX)) {
94 printk(KERN_DEBUG " CIFS slow rsp: cmd %d mid %d",
95 midEntry->command, midEntry->mid);
96 printk(" A: 0x%lx S: 0x%lx R: 0x%lx\n",
97 now - midEntry->when_alloc,
98 now - midEntry->when_sent,
99 now - midEntry->when_received);
103 mempool_free(midEntry, cifs_mid_poolp);
106 struct oplock_q_entry *
107 AllocOplockQEntry(struct inode *pinode, __u16 fid, struct cifsTconInfo *tcon)
109 struct oplock_q_entry *temp;
110 if ((pinode == NULL) || (tcon == NULL)) {
111 cERROR(1, ("Null parms passed to AllocOplockQEntry"));
114 temp = (struct oplock_q_entry *) kmem_cache_alloc(cifs_oplock_cachep,
119 temp->pinode = pinode;
122 spin_lock(&GlobalMid_Lock);
123 list_add_tail(&temp->qhead, &GlobalOplock_Q);
124 spin_unlock(&GlobalMid_Lock);
130 void DeleteOplockQEntry(struct oplock_q_entry *oplockEntry)
132 spin_lock(&GlobalMid_Lock);
133 /* should we check if list empty first? */
134 list_del(&oplockEntry->qhead);
135 spin_unlock(&GlobalMid_Lock);
136 kmem_cache_free(cifs_oplock_cachep, oplockEntry);
140 void DeleteTconOplockQEntries(struct cifsTconInfo *tcon)
142 struct oplock_q_entry *temp;
147 spin_lock(&GlobalMid_Lock);
148 list_for_each_entry(temp, &GlobalOplock_Q, qhead) {
149 if ((temp->tcon) && (temp->tcon == tcon)) {
150 list_del(&temp->qhead);
151 kmem_cache_free(cifs_oplock_cachep, temp);
154 spin_unlock(&GlobalMid_Lock);
158 smb_send(struct socket *ssocket, struct smb_hdr *smb_buffer,
159 unsigned int smb_buf_length, struct sockaddr *sin, bool noblocksnd)
163 struct msghdr smb_msg;
165 unsigned len = smb_buf_length + 4;
168 return -ENOTSOCK; /* BB eventually add reconnect code here */
169 iov.iov_base = smb_buffer;
172 smb_msg.msg_name = sin;
173 smb_msg.msg_namelen = sizeof(struct sockaddr);
174 smb_msg.msg_control = NULL;
175 smb_msg.msg_controllen = 0;
177 smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL;
179 smb_msg.msg_flags = MSG_NOSIGNAL;
181 /* smb header is converted in header_assemble. bcc and rest of SMB word
182 area, and byte area if necessary, is converted to littleendian in
183 cifssmb.c and RFC1001 len is converted to bigendian in smb_send
184 Flags2 is converted in SendReceive */
186 smb_buffer->smb_buf_length = cpu_to_be32(smb_buffer->smb_buf_length);
187 cFYI(1, ("Sending smb of length %d", smb_buf_length));
188 dump_smb(smb_buffer, len);
191 rc = kernel_sendmsg(ssocket, &smb_msg, &iov, 1, len);
192 if ((rc == -ENOSPC) || (rc == -EAGAIN)) {
194 /* smaller timeout here than send2 since smaller size */
195 /* Although it may not be required, this also is smaller
199 ("sends on sock %p stuck for 7 seconds",
210 i = 0; /* reset i after each successful send */
217 cERROR(1, ("Error %d sending data on socket to server", rc));
222 /* Don't want to modify the buffer as a
223 side effect of this call. */
224 smb_buffer->smb_buf_length = smb_buf_length;
230 smb_send2(struct TCP_Server_Info *server, struct kvec *iov, int n_vec,
231 struct sockaddr *sin, bool noblocksnd)
235 struct msghdr smb_msg;
236 struct smb_hdr *smb_buffer = iov[0].iov_base;
237 unsigned int len = iov[0].iov_len;
238 unsigned int total_len;
240 unsigned int smb_buf_length = smb_buffer->smb_buf_length;
241 struct socket *ssocket = server->ssocket;
244 return -ENOTSOCK; /* BB eventually add reconnect code here */
246 smb_msg.msg_name = sin;
247 smb_msg.msg_namelen = sizeof(struct sockaddr);
248 smb_msg.msg_control = NULL;
249 smb_msg.msg_controllen = 0;
251 smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL;
253 smb_msg.msg_flags = MSG_NOSIGNAL;
255 /* smb header is converted in header_assemble. bcc and rest of SMB word
256 area, and byte area if necessary, is converted to littleendian in
257 cifssmb.c and RFC1001 len is converted to bigendian in smb_send
258 Flags2 is converted in SendReceive */
262 for (i = 0; i < n_vec; i++)
263 total_len += iov[i].iov_len;
265 smb_buffer->smb_buf_length = cpu_to_be32(smb_buffer->smb_buf_length);
266 cFYI(1, ("Sending smb: total_len %d", total_len));
267 dump_smb(smb_buffer, len);
271 rc = kernel_sendmsg(ssocket, &smb_msg, &iov[first_vec],
272 n_vec - first_vec, total_len);
273 if ((rc == -ENOSPC) || (rc == -EAGAIN)) {
277 ("sends on sock %p stuck for 15 seconds",
288 if (rc == total_len) {
291 } else if (rc > total_len) {
292 cERROR(1, ("sent %d requested %d", rc, total_len));
296 /* should never happen, letting socket clear before
297 retrying is our only obvious option here */
298 cERROR(1, ("tcp sent no data"));
303 /* the line below resets i */
304 for (i = first_vec; i < n_vec; i++) {
305 if (iov[i].iov_len) {
306 if (rc > iov[i].iov_len) {
307 rc -= iov[i].iov_len;
310 iov[i].iov_base += rc;
311 iov[i].iov_len -= rc;
317 i = 0; /* in case we get ENOSPC on the next send */
320 if ((total_len > 0) && (total_len != smb_buf_length + 4)) {
321 cFYI(1, ("partial send (%d remaining), terminating session",
323 /* If we have only sent part of an SMB then the next SMB
324 could be taken as the remainder of this one. We need
325 to kill the socket so the server throws away the partial
327 server->tcpStatus = CifsNeedReconnect;
331 cERROR(1, ("Error %d sending data on socket to server", rc));
335 /* Don't want to modify the buffer as a
336 side effect of this call. */
337 smb_buffer->smb_buf_length = smb_buf_length;
342 static int wait_for_free_request(struct cifsSesInfo *ses, const int long_op)
344 if (long_op == CIFS_ASYNC_OP) {
345 /* oplock breaks must not be held up */
346 atomic_inc(&ses->server->inFlight);
350 spin_lock(&GlobalMid_Lock);
352 if (atomic_read(&ses->server->inFlight) >=
354 spin_unlock(&GlobalMid_Lock);
355 #ifdef CONFIG_CIFS_STATS2
356 atomic_inc(&ses->server->num_waiters);
358 wait_event(ses->server->request_q,
359 atomic_read(&ses->server->inFlight)
361 #ifdef CONFIG_CIFS_STATS2
362 atomic_dec(&ses->server->num_waiters);
364 spin_lock(&GlobalMid_Lock);
366 if (ses->server->tcpStatus == CifsExiting) {
367 spin_unlock(&GlobalMid_Lock);
371 /* can not count locking commands against total
372 as they are allowed to block on server */
374 /* update # of requests on the wire to server */
375 if (long_op != CIFS_BLOCKING_OP)
376 atomic_inc(&ses->server->inFlight);
377 spin_unlock(&GlobalMid_Lock);
384 static int allocate_mid(struct cifsSesInfo *ses, struct smb_hdr *in_buf,
385 struct mid_q_entry **ppmidQ)
387 if (ses->server->tcpStatus == CifsExiting) {
391 if (ses->server->tcpStatus == CifsNeedReconnect) {
392 cFYI(1, ("tcp session dead - return to caller to retry"));
396 if (ses->status != CifsGood) {
397 /* check if SMB session is bad because we are setting it up */
398 if ((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
399 (in_buf->Command != SMB_COM_NEGOTIATE))
401 /* else ok - we are setting up session */
403 *ppmidQ = AllocMidQEntry(in_buf, ses->server);
409 static int wait_for_response(struct cifsSesInfo *ses,
410 struct mid_q_entry *midQ,
411 unsigned long timeout,
412 unsigned long time_to_wait)
414 unsigned long curr_timeout;
417 curr_timeout = timeout + jiffies;
418 wait_event_timeout(ses->server->response_q,
419 midQ->midState != MID_REQUEST_SUBMITTED, timeout);
421 if (time_after(jiffies, curr_timeout) &&
422 (midQ->midState == MID_REQUEST_SUBMITTED) &&
423 ((ses->server->tcpStatus == CifsGood) ||
424 (ses->server->tcpStatus == CifsNew))) {
428 /* We timed out. Is the server still
430 spin_lock(&GlobalMid_Lock);
431 lrt = ses->server->lstrp;
432 spin_unlock(&GlobalMid_Lock);
434 /* Calculate time_to_wait past last receive time.
435 Although we prefer not to time out if the
436 server is still responding - we will time
437 out if the server takes more than 15 (or 45
438 or 180) seconds to respond to this request
439 and has not responded to any request from
440 other threads on the client within 10 seconds */
442 if (time_after(jiffies, lrt)) {
443 /* No replies for time_to_wait. */
444 cERROR(1, ("server not responding"));
456 * Send an SMB Request. No response info (other than return code)
457 * needs to be parsed.
459 * flags indicate the type of request buffer and how long to wait
460 * and whether to log NT STATUS code (error) before mapping it to POSIX error
464 SendReceiveNoRsp(const unsigned int xid, struct cifsSesInfo *ses,
465 struct smb_hdr *in_buf, int flags)
471 iov[0].iov_base = (char *)in_buf;
472 iov[0].iov_len = in_buf->smb_buf_length + 4;
473 flags |= CIFS_NO_RESP;
474 rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags);
475 cFYI(DBG2, ("SendRcvNoRsp flags %d rc %d", flags, rc));
481 SendReceive2(const unsigned int xid, struct cifsSesInfo *ses,
482 struct kvec *iov, int n_vec, int *pRespBufType /* ret */,
487 unsigned int receive_len;
488 unsigned long timeout;
489 struct mid_q_entry *midQ;
490 struct smb_hdr *in_buf = iov[0].iov_base;
492 long_op = flags & CIFS_TIMEOUT_MASK;
494 *pRespBufType = CIFS_NO_BUFFER; /* no response buf yet */
496 if ((ses == NULL) || (ses->server == NULL)) {
497 cifs_small_buf_release(in_buf);
498 cERROR(1, ("Null session"));
502 if (ses->server->tcpStatus == CifsExiting) {
503 cifs_small_buf_release(in_buf);
507 /* Ensure that we do not send more than 50 overlapping requests
508 to the same server. We may make this configurable later or
511 rc = wait_for_free_request(ses, long_op);
513 cifs_small_buf_release(in_buf);
517 /* make sure that we sign in the same order that we send on this socket
518 and avoid races inside tcp sendmsg code that could cause corruption
521 mutex_lock(&ses->server->srv_mutex);
523 rc = allocate_mid(ses, in_buf, &midQ);
525 mutex_unlock(&ses->server->srv_mutex);
526 cifs_small_buf_release(in_buf);
527 /* Update # of requests on wire to server */
528 atomic_dec(&ses->server->inFlight);
529 wake_up(&ses->server->request_q);
532 rc = cifs_sign_smb2(iov, n_vec, ses->server, &midQ->sequence_number);
534 mutex_unlock(&ses->server->srv_mutex);
535 cifs_small_buf_release(in_buf);
539 midQ->midState = MID_REQUEST_SUBMITTED;
540 #ifdef CONFIG_CIFS_STATS2
541 atomic_inc(&ses->server->inSend);
543 rc = smb_send2(ses->server, iov, n_vec,
544 (struct sockaddr *) &(ses->server->addr.sockAddr),
545 ses->server->noblocksnd);
546 #ifdef CONFIG_CIFS_STATS2
547 atomic_dec(&ses->server->inSend);
548 midQ->when_sent = jiffies;
551 mutex_unlock(&ses->server->srv_mutex);
552 cifs_small_buf_release(in_buf);
557 if (long_op == CIFS_STD_OP)
559 else if (long_op == CIFS_VLONG_OP) /* e.g. slow writes past EOF */
561 else if (long_op == CIFS_LONG_OP)
562 timeout = 45 * HZ; /* should be greater than
563 servers oplock break timeout (about 43 seconds) */
564 else if (long_op == CIFS_ASYNC_OP)
566 else if (long_op == CIFS_BLOCKING_OP)
567 timeout = 0x7FFFFFFF; /* large, but not so large as to wrap */
569 cERROR(1, ("unknown timeout flag %d", long_op));
574 /* wait for 15 seconds or until woken up due to response arriving or
575 due to last connection to this server being unmounted */
576 if (signal_pending(current)) {
577 /* if signal pending do not hold up user for full smb timeout
578 but we still give response a chance to complete */
582 /* No user interrupts in wait - wreaks havoc with performance */
583 wait_for_response(ses, midQ, timeout, 10 * HZ);
585 spin_lock(&GlobalMid_Lock);
587 if (midQ->resp_buf == NULL) {
588 cERROR(1, ("No response to cmd %d mid %d",
589 midQ->command, midQ->mid));
590 if (midQ->midState == MID_REQUEST_SUBMITTED) {
591 if (ses->server->tcpStatus == CifsExiting)
594 ses->server->tcpStatus = CifsNeedReconnect;
595 midQ->midState = MID_RETRY_NEEDED;
599 if (rc != -EHOSTDOWN) {
600 if (midQ->midState == MID_RETRY_NEEDED) {
602 cFYI(1, ("marking request for retry"));
607 spin_unlock(&GlobalMid_Lock);
608 DeleteMidQEntry(midQ);
609 /* Update # of requests on wire to server */
610 atomic_dec(&ses->server->inFlight);
611 wake_up(&ses->server->request_q);
615 spin_unlock(&GlobalMid_Lock);
616 receive_len = midQ->resp_buf->smb_buf_length;
618 if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
619 cERROR(1, ("Frame too large received. Length: %d Xid: %d",
622 } else { /* rcvd frame is ok */
623 if (midQ->resp_buf &&
624 (midQ->midState == MID_RESPONSE_RECEIVED)) {
626 iov[0].iov_base = (char *)midQ->resp_buf;
628 *pRespBufType = CIFS_LARGE_BUFFER;
630 *pRespBufType = CIFS_SMALL_BUFFER;
631 iov[0].iov_len = receive_len + 4;
633 dump_smb(midQ->resp_buf, 80);
634 /* convert the length into a more usable form */
635 if ((receive_len > 24) &&
636 (ses->server->secMode & (SECMODE_SIGN_REQUIRED |
637 SECMODE_SIGN_ENABLED))) {
638 rc = cifs_verify_signature(midQ->resp_buf,
639 &ses->server->mac_signing_key,
640 midQ->sequence_number+1);
642 cERROR(1, ("Unexpected SMB signature"));
643 /* BB FIXME add code to kill session */
647 /* BB special case reconnect tid and uid here? */
648 rc = map_smb_to_linux_error(midQ->resp_buf,
649 flags & CIFS_LOG_ERROR);
651 /* convert ByteCount if necessary */
652 if (receive_len >= sizeof(struct smb_hdr) - 4
653 /* do not count RFC1001 header */ +
654 (2 * midQ->resp_buf->WordCount) + 2 /* bcc */ )
655 BCC(midQ->resp_buf) =
656 le16_to_cpu(BCC_LE(midQ->resp_buf));
657 if ((flags & CIFS_NO_RESP) == 0)
658 midQ->resp_buf = NULL; /* mark it so buf will
663 cFYI(1, ("Bad MID state?"));
668 DeleteMidQEntry(midQ);
669 atomic_dec(&ses->server->inFlight);
670 wake_up(&ses->server->request_q);
676 SendReceive(const unsigned int xid, struct cifsSesInfo *ses,
677 struct smb_hdr *in_buf, struct smb_hdr *out_buf,
678 int *pbytes_returned, const int long_op)
681 unsigned int receive_len;
682 unsigned long timeout;
683 struct mid_q_entry *midQ;
686 cERROR(1, ("Null smb session"));
689 if (ses->server == NULL) {
690 cERROR(1, ("Null tcp session"));
694 if (ses->server->tcpStatus == CifsExiting)
697 /* Ensure that we do not send more than 50 overlapping requests
698 to the same server. We may make this configurable later or
701 if (in_buf->smb_buf_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
702 cERROR(1, ("Illegal length, greater than maximum frame, %d",
703 in_buf->smb_buf_length));
707 rc = wait_for_free_request(ses, long_op);
711 /* make sure that we sign in the same order that we send on this socket
712 and avoid races inside tcp sendmsg code that could cause corruption
715 mutex_lock(&ses->server->srv_mutex);
717 rc = allocate_mid(ses, in_buf, &midQ);
719 mutex_unlock(&ses->server->srv_mutex);
720 /* Update # of requests on wire to server */
721 atomic_dec(&ses->server->inFlight);
722 wake_up(&ses->server->request_q);
726 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
728 mutex_unlock(&ses->server->srv_mutex);
732 midQ->midState = MID_REQUEST_SUBMITTED;
733 #ifdef CONFIG_CIFS_STATS2
734 atomic_inc(&ses->server->inSend);
736 rc = smb_send(ses->server->ssocket, in_buf, in_buf->smb_buf_length,
737 (struct sockaddr *) &(ses->server->addr.sockAddr),
738 ses->server->noblocksnd);
739 #ifdef CONFIG_CIFS_STATS2
740 atomic_dec(&ses->server->inSend);
741 midQ->when_sent = jiffies;
743 mutex_unlock(&ses->server->srv_mutex);
748 if (long_op == CIFS_STD_OP)
750 /* wait for 15 seconds or until woken up due to response arriving or
751 due to last connection to this server being unmounted */
752 else if (long_op == CIFS_ASYNC_OP)
754 else if (long_op == CIFS_VLONG_OP) /* writes past EOF can be slow */
756 else if (long_op == CIFS_LONG_OP)
757 timeout = 45 * HZ; /* should be greater than
758 servers oplock break timeout (about 43 seconds) */
759 else if (long_op == CIFS_BLOCKING_OP)
760 timeout = 0x7FFFFFFF; /* large but no so large as to wrap */
762 cERROR(1, ("unknown timeout flag %d", long_op));
767 if (signal_pending(current)) {
768 /* if signal pending do not hold up user for full smb timeout
769 but we still give response a chance to complete */
773 /* No user interrupts in wait - wreaks havoc with performance */
774 wait_for_response(ses, midQ, timeout, 10 * HZ);
776 spin_lock(&GlobalMid_Lock);
777 if (midQ->resp_buf == NULL) {
778 cERROR(1, ("No response for cmd %d mid %d",
779 midQ->command, midQ->mid));
780 if (midQ->midState == MID_REQUEST_SUBMITTED) {
781 if (ses->server->tcpStatus == CifsExiting)
784 ses->server->tcpStatus = CifsNeedReconnect;
785 midQ->midState = MID_RETRY_NEEDED;
789 if (rc != -EHOSTDOWN) {
790 if (midQ->midState == MID_RETRY_NEEDED) {
792 cFYI(1, ("marking request for retry"));
797 spin_unlock(&GlobalMid_Lock);
798 DeleteMidQEntry(midQ);
799 /* Update # of requests on wire to server */
800 atomic_dec(&ses->server->inFlight);
801 wake_up(&ses->server->request_q);
805 spin_unlock(&GlobalMid_Lock);
806 receive_len = midQ->resp_buf->smb_buf_length;
808 if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
809 cERROR(1, ("Frame too large received. Length: %d Xid: %d",
812 } else { /* rcvd frame is ok */
814 if (midQ->resp_buf && out_buf
815 && (midQ->midState == MID_RESPONSE_RECEIVED)) {
816 out_buf->smb_buf_length = receive_len;
817 memcpy((char *)out_buf + 4,
818 (char *)midQ->resp_buf + 4,
821 dump_smb(out_buf, 92);
822 /* convert the length into a more usable form */
823 if ((receive_len > 24) &&
824 (ses->server->secMode & (SECMODE_SIGN_REQUIRED |
825 SECMODE_SIGN_ENABLED))) {
826 rc = cifs_verify_signature(out_buf,
827 &ses->server->mac_signing_key,
828 midQ->sequence_number+1);
830 cERROR(1, ("Unexpected SMB signature"));
831 /* BB FIXME add code to kill session */
835 *pbytes_returned = out_buf->smb_buf_length;
837 /* BB special case reconnect tid and uid here? */
838 rc = map_smb_to_linux_error(out_buf, 0 /* no log */ );
840 /* convert ByteCount if necessary */
841 if (receive_len >= sizeof(struct smb_hdr) - 4
842 /* do not count RFC1001 header */ +
843 (2 * out_buf->WordCount) + 2 /* bcc */ )
844 BCC(out_buf) = le16_to_cpu(BCC_LE(out_buf));
847 cERROR(1, ("Bad MID state?"));
852 DeleteMidQEntry(midQ);
853 atomic_dec(&ses->server->inFlight);
854 wake_up(&ses->server->request_q);
859 /* Send an NT_CANCEL SMB to cause the POSIX blocking lock to return. */
862 send_nt_cancel(struct cifsTconInfo *tcon, struct smb_hdr *in_buf,
863 struct mid_q_entry *midQ)
866 struct cifsSesInfo *ses = tcon->ses;
867 __u16 mid = in_buf->Mid;
869 header_assemble(in_buf, SMB_COM_NT_CANCEL, tcon, 0);
871 mutex_lock(&ses->server->srv_mutex);
872 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
874 mutex_unlock(&ses->server->srv_mutex);
877 rc = smb_send(ses->server->ssocket, in_buf, in_buf->smb_buf_length,
878 (struct sockaddr *) &(ses->server->addr.sockAddr),
879 ses->server->noblocksnd);
880 mutex_unlock(&ses->server->srv_mutex);
884 /* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
885 blocking lock to return. */
888 send_lock_cancel(const unsigned int xid, struct cifsTconInfo *tcon,
889 struct smb_hdr *in_buf,
890 struct smb_hdr *out_buf)
893 struct cifsSesInfo *ses = tcon->ses;
894 LOCK_REQ *pSMB = (LOCK_REQ *)in_buf;
896 /* We just modify the current in_buf to change
897 the type of lock from LOCKING_ANDX_SHARED_LOCK
898 or LOCKING_ANDX_EXCLUSIVE_LOCK to
899 LOCKING_ANDX_CANCEL_LOCK. */
901 pSMB->LockType = LOCKING_ANDX_CANCEL_LOCK|LOCKING_ANDX_LARGE_FILES;
903 pSMB->hdr.Mid = GetNextMid(ses->server);
905 return SendReceive(xid, ses, in_buf, out_buf,
906 &bytes_returned, CIFS_STD_OP);
910 SendReceiveBlockingLock(const unsigned int xid, struct cifsTconInfo *tcon,
911 struct smb_hdr *in_buf, struct smb_hdr *out_buf,
912 int *pbytes_returned)
916 unsigned int receive_len;
917 struct mid_q_entry *midQ;
918 struct cifsSesInfo *ses;
920 if (tcon == NULL || tcon->ses == NULL) {
921 cERROR(1, ("Null smb session"));
926 if (ses->server == NULL) {
927 cERROR(1, ("Null tcp session"));
931 if (ses->server->tcpStatus == CifsExiting)
934 /* Ensure that we do not send more than 50 overlapping requests
935 to the same server. We may make this configurable later or
938 if (in_buf->smb_buf_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
939 cERROR(1, ("Illegal length, greater than maximum frame, %d",
940 in_buf->smb_buf_length));
944 rc = wait_for_free_request(ses, CIFS_BLOCKING_OP);
948 /* make sure that we sign in the same order that we send on this socket
949 and avoid races inside tcp sendmsg code that could cause corruption
952 mutex_lock(&ses->server->srv_mutex);
954 rc = allocate_mid(ses, in_buf, &midQ);
956 mutex_unlock(&ses->server->srv_mutex);
960 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
962 DeleteMidQEntry(midQ);
963 mutex_unlock(&ses->server->srv_mutex);
967 midQ->midState = MID_REQUEST_SUBMITTED;
968 #ifdef CONFIG_CIFS_STATS2
969 atomic_inc(&ses->server->inSend);
971 rc = smb_send(ses->server->ssocket, in_buf, in_buf->smb_buf_length,
972 (struct sockaddr *) &(ses->server->addr.sockAddr),
973 ses->server->noblocksnd);
974 #ifdef CONFIG_CIFS_STATS2
975 atomic_dec(&ses->server->inSend);
976 midQ->when_sent = jiffies;
978 mutex_unlock(&ses->server->srv_mutex);
981 DeleteMidQEntry(midQ);
985 /* Wait for a reply - allow signals to interrupt. */
986 rc = wait_event_interruptible(ses->server->response_q,
987 (!(midQ->midState == MID_REQUEST_SUBMITTED)) ||
988 ((ses->server->tcpStatus != CifsGood) &&
989 (ses->server->tcpStatus != CifsNew)));
991 /* Were we interrupted by a signal ? */
992 if ((rc == -ERESTARTSYS) &&
993 (midQ->midState == MID_REQUEST_SUBMITTED) &&
994 ((ses->server->tcpStatus == CifsGood) ||
995 (ses->server->tcpStatus == CifsNew))) {
997 if (in_buf->Command == SMB_COM_TRANSACTION2) {
998 /* POSIX lock. We send a NT_CANCEL SMB to cause the
999 blocking lock to return. */
1001 rc = send_nt_cancel(tcon, in_buf, midQ);
1003 DeleteMidQEntry(midQ);
1007 /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
1008 to cause the blocking lock to return. */
1010 rc = send_lock_cancel(xid, tcon, in_buf, out_buf);
1012 /* If we get -ENOLCK back the lock may have
1013 already been removed. Don't exit in this case. */
1014 if (rc && rc != -ENOLCK) {
1015 DeleteMidQEntry(midQ);
1020 /* Wait 5 seconds for the response. */
1021 if (wait_for_response(ses, midQ, 5 * HZ, 5 * HZ) == 0) {
1022 /* We got the response - restart system call. */
1027 spin_lock(&GlobalMid_Lock);
1028 if (midQ->resp_buf) {
1029 spin_unlock(&GlobalMid_Lock);
1030 receive_len = midQ->resp_buf->smb_buf_length;
1032 cERROR(1, ("No response for cmd %d mid %d",
1033 midQ->command, midQ->mid));
1034 if (midQ->midState == MID_REQUEST_SUBMITTED) {
1035 if (ses->server->tcpStatus == CifsExiting)
1038 ses->server->tcpStatus = CifsNeedReconnect;
1039 midQ->midState = MID_RETRY_NEEDED;
1043 if (rc != -EHOSTDOWN) {
1044 if (midQ->midState == MID_RETRY_NEEDED) {
1046 cFYI(1, ("marking request for retry"));
1051 spin_unlock(&GlobalMid_Lock);
1052 DeleteMidQEntry(midQ);
1056 if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
1057 cERROR(1, ("Frame too large received. Length: %d Xid: %d",
1060 } else { /* rcvd frame is ok */
1062 if (midQ->resp_buf && out_buf
1063 && (midQ->midState == MID_RESPONSE_RECEIVED)) {
1064 out_buf->smb_buf_length = receive_len;
1065 memcpy((char *)out_buf + 4,
1066 (char *)midQ->resp_buf + 4,
1069 dump_smb(out_buf, 92);
1070 /* convert the length into a more usable form */
1071 if ((receive_len > 24) &&
1072 (ses->server->secMode & (SECMODE_SIGN_REQUIRED |
1073 SECMODE_SIGN_ENABLED))) {
1074 rc = cifs_verify_signature(out_buf,
1075 &ses->server->mac_signing_key,
1076 midQ->sequence_number+1);
1078 cERROR(1, ("Unexpected SMB signature"));
1079 /* BB FIXME add code to kill session */
1083 *pbytes_returned = out_buf->smb_buf_length;
1085 /* BB special case reconnect tid and uid here? */
1086 rc = map_smb_to_linux_error(out_buf, 0 /* no log */ );
1088 /* convert ByteCount if necessary */
1089 if (receive_len >= sizeof(struct smb_hdr) - 4
1090 /* do not count RFC1001 header */ +
1091 (2 * out_buf->WordCount) + 2 /* bcc */ )
1092 BCC(out_buf) = le16_to_cpu(BCC_LE(out_buf));
1095 cERROR(1, ("Bad MID state?"));
1098 DeleteMidQEntry(midQ);
1099 if (rstart && rc == -EACCES)
1100 return -ERESTARTSYS;