macvtap: fix a possible race between queue selection and changing queues
[linux/fpc-iii.git] / fs / cifs / transport.c
blobbfbf4700d160f8a4d54f7cc0446a35c4de8c747d
1 /*
2 * fs/cifs/transport.c
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
23 #include <linux/fs.h>
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 <linux/tcp.h>
31 #include <linux/highmem.h>
32 #include <asm/uaccess.h>
33 #include <asm/processor.h>
34 #include <linux/mempool.h>
35 #include "cifspdu.h"
36 #include "cifsglob.h"
37 #include "cifsproto.h"
38 #include "cifs_debug.h"
40 void
41 cifs_wake_up_task(struct mid_q_entry *mid)
43 wake_up_process(mid->callback_data);
46 struct mid_q_entry *
47 AllocMidQEntry(const struct smb_hdr *smb_buffer, struct TCP_Server_Info *server)
49 struct mid_q_entry *temp;
51 if (server == NULL) {
52 cifs_dbg(VFS, "Null TCP session in AllocMidQEntry\n");
53 return NULL;
56 temp = mempool_alloc(cifs_mid_poolp, GFP_NOFS);
57 if (temp == NULL)
58 return temp;
59 else {
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 cifs_dbg(FYI, "For smb_command %d\n", 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;
68 temp->server = server;
71 * The default is for the mid to be synchronous, so the
72 * default callback just wakes up the current task.
74 temp->callback = cifs_wake_up_task;
75 temp->callback_data = current;
78 atomic_inc(&midCount);
79 temp->mid_state = MID_REQUEST_ALLOCATED;
80 return temp;
83 void
84 DeleteMidQEntry(struct mid_q_entry *midEntry)
86 #ifdef CONFIG_CIFS_STATS2
87 __le16 command = midEntry->server->vals->lock_cmd;
88 unsigned long now;
89 #endif
90 midEntry->mid_state = MID_FREE;
91 atomic_dec(&midCount);
92 if (midEntry->large_buf)
93 cifs_buf_release(midEntry->resp_buf);
94 else
95 cifs_small_buf_release(midEntry->resp_buf);
96 #ifdef CONFIG_CIFS_STATS2
97 now = jiffies;
98 /* commands taking longer than one second are indications that
99 something is wrong, unless it is quite a slow link or server */
100 if ((now - midEntry->when_alloc) > HZ) {
101 if ((cifsFYI & CIFS_TIMER) && (midEntry->command != command)) {
102 printk(KERN_DEBUG " CIFS slow rsp: cmd %d mid %llu",
103 midEntry->command, midEntry->mid);
104 printk(" A: 0x%lx S: 0x%lx R: 0x%lx\n",
105 now - midEntry->when_alloc,
106 now - midEntry->when_sent,
107 now - midEntry->when_received);
110 #endif
111 mempool_free(midEntry, cifs_mid_poolp);
114 void
115 cifs_delete_mid(struct mid_q_entry *mid)
117 spin_lock(&GlobalMid_Lock);
118 list_del(&mid->qhead);
119 spin_unlock(&GlobalMid_Lock);
121 DeleteMidQEntry(mid);
125 * smb_send_kvec - send an array of kvecs to the server
126 * @server: Server to send the data to
127 * @iov: Pointer to array of kvecs
128 * @n_vec: length of kvec array
129 * @sent: amount of data sent on socket is stored here
131 * Our basic "send data to server" function. Should be called with srv_mutex
132 * held. The caller is responsible for handling the results.
134 static int
135 smb_send_kvec(struct TCP_Server_Info *server, struct kvec *iov, size_t n_vec,
136 size_t *sent)
138 int rc = 0;
139 int i = 0;
140 struct msghdr smb_msg;
141 unsigned int remaining;
142 size_t first_vec = 0;
143 struct socket *ssocket = server->ssocket;
145 *sent = 0;
147 smb_msg.msg_name = (struct sockaddr *) &server->dstaddr;
148 smb_msg.msg_namelen = sizeof(struct sockaddr);
149 smb_msg.msg_control = NULL;
150 smb_msg.msg_controllen = 0;
151 if (server->noblocksnd)
152 smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL;
153 else
154 smb_msg.msg_flags = MSG_NOSIGNAL;
156 remaining = 0;
157 for (i = 0; i < n_vec; i++)
158 remaining += iov[i].iov_len;
160 i = 0;
161 while (remaining) {
163 * If blocking send, we try 3 times, since each can block
164 * for 5 seconds. For nonblocking we have to try more
165 * but wait increasing amounts of time allowing time for
166 * socket to clear. The overall time we wait in either
167 * case to send on the socket is about 15 seconds.
168 * Similarly we wait for 15 seconds for a response from
169 * the server in SendReceive[2] for the server to send
170 * a response back for most types of requests (except
171 * SMB Write past end of file which can be slow, and
172 * blocking lock operations). NFS waits slightly longer
173 * than CIFS, but this can make it take longer for
174 * nonresponsive servers to be detected and 15 seconds
175 * is more than enough time for modern networks to
176 * send a packet. In most cases if we fail to send
177 * after the retries we will kill the socket and
178 * reconnect which may clear the network problem.
180 rc = kernel_sendmsg(ssocket, &smb_msg, &iov[first_vec],
181 n_vec - first_vec, remaining);
182 if (rc == -EAGAIN) {
183 i++;
184 if (i >= 14 || (!server->noblocksnd && (i > 2))) {
185 cifs_dbg(VFS, "sends on sock %p stuck for 15 seconds\n",
186 ssocket);
187 rc = -EAGAIN;
188 break;
190 msleep(1 << i);
191 continue;
194 if (rc < 0)
195 break;
197 /* send was at least partially successful */
198 *sent += rc;
200 if (rc == remaining) {
201 remaining = 0;
202 break;
205 if (rc > remaining) {
206 cifs_dbg(VFS, "sent %d requested %d\n", rc, remaining);
207 break;
210 if (rc == 0) {
211 /* should never happen, letting socket clear before
212 retrying is our only obvious option here */
213 cifs_dbg(VFS, "tcp sent no data\n");
214 msleep(500);
215 continue;
218 remaining -= rc;
220 /* the line below resets i */
221 for (i = first_vec; i < n_vec; i++) {
222 if (iov[i].iov_len) {
223 if (rc > iov[i].iov_len) {
224 rc -= iov[i].iov_len;
225 iov[i].iov_len = 0;
226 } else {
227 iov[i].iov_base += rc;
228 iov[i].iov_len -= rc;
229 first_vec = i;
230 break;
235 i = 0; /* in case we get ENOSPC on the next send */
236 rc = 0;
238 return rc;
242 * rqst_page_to_kvec - Turn a slot in the smb_rqst page array into a kvec
243 * @rqst: pointer to smb_rqst
244 * @idx: index into the array of the page
245 * @iov: pointer to struct kvec that will hold the result
247 * Helper function to convert a slot in the rqst->rq_pages array into a kvec.
248 * The page will be kmapped and the address placed into iov_base. The length
249 * will then be adjusted according to the ptailoff.
251 void
252 cifs_rqst_page_to_kvec(struct smb_rqst *rqst, unsigned int idx,
253 struct kvec *iov)
256 * FIXME: We could avoid this kmap altogether if we used
257 * kernel_sendpage instead of kernel_sendmsg. That will only
258 * work if signing is disabled though as sendpage inlines the
259 * page directly into the fraglist. If userspace modifies the
260 * page after we calculate the signature, then the server will
261 * reject it and may break the connection. kernel_sendmsg does
262 * an extra copy of the data and avoids that issue.
264 iov->iov_base = kmap(rqst->rq_pages[idx]);
266 /* if last page, don't send beyond this offset into page */
267 if (idx == (rqst->rq_npages - 1))
268 iov->iov_len = rqst->rq_tailsz;
269 else
270 iov->iov_len = rqst->rq_pagesz;
273 static int
274 smb_send_rqst(struct TCP_Server_Info *server, struct smb_rqst *rqst)
276 int rc;
277 struct kvec *iov = rqst->rq_iov;
278 int n_vec = rqst->rq_nvec;
279 unsigned int smb_buf_length = get_rfc1002_length(iov[0].iov_base);
280 unsigned int i;
281 size_t total_len = 0, sent;
282 struct socket *ssocket = server->ssocket;
283 int val = 1;
285 if (ssocket == NULL)
286 return -ENOTSOCK;
288 cifs_dbg(FYI, "Sending smb: smb_len=%u\n", smb_buf_length);
289 dump_smb(iov[0].iov_base, iov[0].iov_len);
291 /* cork the socket */
292 kernel_setsockopt(ssocket, SOL_TCP, TCP_CORK,
293 (char *)&val, sizeof(val));
295 rc = smb_send_kvec(server, iov, n_vec, &sent);
296 if (rc < 0)
297 goto uncork;
299 total_len += sent;
301 /* now walk the page array and send each page in it */
302 for (i = 0; i < rqst->rq_npages; i++) {
303 struct kvec p_iov;
305 cifs_rqst_page_to_kvec(rqst, i, &p_iov);
306 rc = smb_send_kvec(server, &p_iov, 1, &sent);
307 kunmap(rqst->rq_pages[i]);
308 if (rc < 0)
309 break;
311 total_len += sent;
314 uncork:
315 /* uncork it */
316 val = 0;
317 kernel_setsockopt(ssocket, SOL_TCP, TCP_CORK,
318 (char *)&val, sizeof(val));
320 if ((total_len > 0) && (total_len != smb_buf_length + 4)) {
321 cifs_dbg(FYI, "partial send (wanted=%u sent=%zu): terminating session\n",
322 smb_buf_length + 4, total_len);
324 * If we have only sent part of an SMB then the next SMB could
325 * be taken as the remainder of this one. We need to kill the
326 * socket so the server throws away the partial SMB
328 server->tcpStatus = CifsNeedReconnect;
331 if (rc < 0 && rc != -EINTR)
332 cifs_dbg(VFS, "Error %d sending data on socket to server\n",
333 rc);
334 else
335 rc = 0;
337 return rc;
340 static int
341 smb_sendv(struct TCP_Server_Info *server, struct kvec *iov, int n_vec)
343 struct smb_rqst rqst = { .rq_iov = iov,
344 .rq_nvec = n_vec };
346 return smb_send_rqst(server, &rqst);
350 smb_send(struct TCP_Server_Info *server, struct smb_hdr *smb_buffer,
351 unsigned int smb_buf_length)
353 struct kvec iov;
355 iov.iov_base = smb_buffer;
356 iov.iov_len = smb_buf_length + 4;
358 return smb_sendv(server, &iov, 1);
361 static int
362 wait_for_free_credits(struct TCP_Server_Info *server, const int timeout,
363 int *credits)
365 int rc;
367 spin_lock(&server->req_lock);
368 if (timeout == CIFS_ASYNC_OP) {
369 /* oplock breaks must not be held up */
370 server->in_flight++;
371 *credits -= 1;
372 spin_unlock(&server->req_lock);
373 return 0;
376 while (1) {
377 if (*credits <= 0) {
378 spin_unlock(&server->req_lock);
379 cifs_num_waiters_inc(server);
380 rc = wait_event_killable(server->request_q,
381 has_credits(server, credits));
382 cifs_num_waiters_dec(server);
383 if (rc)
384 return rc;
385 spin_lock(&server->req_lock);
386 } else {
387 if (server->tcpStatus == CifsExiting) {
388 spin_unlock(&server->req_lock);
389 return -ENOENT;
393 * Can not count locking commands against total
394 * as they are allowed to block on server.
397 /* update # of requests on the wire to server */
398 if (timeout != CIFS_BLOCKING_OP) {
399 *credits -= 1;
400 server->in_flight++;
402 spin_unlock(&server->req_lock);
403 break;
406 return 0;
409 static int
410 wait_for_free_request(struct TCP_Server_Info *server, const int timeout,
411 const int optype)
413 return wait_for_free_credits(server, timeout,
414 server->ops->get_credits_field(server, optype));
417 static int allocate_mid(struct cifs_ses *ses, struct smb_hdr *in_buf,
418 struct mid_q_entry **ppmidQ)
420 if (ses->server->tcpStatus == CifsExiting) {
421 return -ENOENT;
424 if (ses->server->tcpStatus == CifsNeedReconnect) {
425 cifs_dbg(FYI, "tcp session dead - return to caller to retry\n");
426 return -EAGAIN;
429 if (ses->status != CifsGood) {
430 /* check if SMB session is bad because we are setting it up */
431 if ((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
432 (in_buf->Command != SMB_COM_NEGOTIATE))
433 return -EAGAIN;
434 /* else ok - we are setting up session */
436 *ppmidQ = AllocMidQEntry(in_buf, ses->server);
437 if (*ppmidQ == NULL)
438 return -ENOMEM;
439 spin_lock(&GlobalMid_Lock);
440 list_add_tail(&(*ppmidQ)->qhead, &ses->server->pending_mid_q);
441 spin_unlock(&GlobalMid_Lock);
442 return 0;
445 static int
446 wait_for_response(struct TCP_Server_Info *server, struct mid_q_entry *midQ)
448 int error;
450 error = wait_event_freezekillable(server->response_q,
451 midQ->mid_state != MID_REQUEST_SUBMITTED);
452 if (error < 0)
453 return -ERESTARTSYS;
455 return 0;
458 struct mid_q_entry *
459 cifs_setup_async_request(struct TCP_Server_Info *server, struct smb_rqst *rqst)
461 int rc;
462 struct smb_hdr *hdr = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
463 struct mid_q_entry *mid;
465 /* enable signing if server requires it */
466 if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
467 hdr->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
469 mid = AllocMidQEntry(hdr, server);
470 if (mid == NULL)
471 return ERR_PTR(-ENOMEM);
473 rc = cifs_sign_rqst(rqst, server, &mid->sequence_number);
474 if (rc) {
475 DeleteMidQEntry(mid);
476 return ERR_PTR(rc);
479 return mid;
483 * Send a SMB request and set the callback function in the mid to handle
484 * the result. Caller is responsible for dealing with timeouts.
487 cifs_call_async(struct TCP_Server_Info *server, struct smb_rqst *rqst,
488 mid_receive_t *receive, mid_callback_t *callback,
489 void *cbdata, const int flags)
491 int rc, timeout, optype;
492 struct mid_q_entry *mid;
494 timeout = flags & CIFS_TIMEOUT_MASK;
495 optype = flags & CIFS_OP_MASK;
497 rc = wait_for_free_request(server, timeout, optype);
498 if (rc)
499 return rc;
501 mutex_lock(&server->srv_mutex);
502 mid = server->ops->setup_async_request(server, rqst);
503 if (IS_ERR(mid)) {
504 mutex_unlock(&server->srv_mutex);
505 add_credits(server, 1, optype);
506 wake_up(&server->request_q);
507 return PTR_ERR(mid);
510 mid->receive = receive;
511 mid->callback = callback;
512 mid->callback_data = cbdata;
513 mid->mid_state = MID_REQUEST_SUBMITTED;
515 /* put it on the pending_mid_q */
516 spin_lock(&GlobalMid_Lock);
517 list_add_tail(&mid->qhead, &server->pending_mid_q);
518 spin_unlock(&GlobalMid_Lock);
521 cifs_in_send_inc(server);
522 rc = smb_send_rqst(server, rqst);
523 cifs_in_send_dec(server);
524 cifs_save_when_sent(mid);
526 if (rc < 0)
527 server->sequence_number -= 2;
528 mutex_unlock(&server->srv_mutex);
530 if (rc == 0)
531 return 0;
533 cifs_delete_mid(mid);
534 add_credits(server, 1, optype);
535 wake_up(&server->request_q);
536 return rc;
541 * Send an SMB Request. No response info (other than return code)
542 * needs to be parsed.
544 * flags indicate the type of request buffer and how long to wait
545 * and whether to log NT STATUS code (error) before mapping it to POSIX error
549 SendReceiveNoRsp(const unsigned int xid, struct cifs_ses *ses,
550 char *in_buf, int flags)
552 int rc;
553 struct kvec iov[1];
554 int resp_buf_type;
556 iov[0].iov_base = in_buf;
557 iov[0].iov_len = get_rfc1002_length(in_buf) + 4;
558 flags |= CIFS_NO_RESP;
559 rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags);
560 cifs_dbg(NOISY, "SendRcvNoRsp flags %d rc %d\n", flags, rc);
562 return rc;
565 static int
566 cifs_sync_mid_result(struct mid_q_entry *mid, struct TCP_Server_Info *server)
568 int rc = 0;
570 cifs_dbg(FYI, "%s: cmd=%d mid=%llu state=%d\n",
571 __func__, le16_to_cpu(mid->command), mid->mid, mid->mid_state);
573 spin_lock(&GlobalMid_Lock);
574 switch (mid->mid_state) {
575 case MID_RESPONSE_RECEIVED:
576 spin_unlock(&GlobalMid_Lock);
577 return rc;
578 case MID_RETRY_NEEDED:
579 rc = -EAGAIN;
580 break;
581 case MID_RESPONSE_MALFORMED:
582 rc = -EIO;
583 break;
584 case MID_SHUTDOWN:
585 rc = -EHOSTDOWN;
586 break;
587 default:
588 list_del_init(&mid->qhead);
589 cifs_dbg(VFS, "%s: invalid mid state mid=%llu state=%d\n",
590 __func__, mid->mid, mid->mid_state);
591 rc = -EIO;
593 spin_unlock(&GlobalMid_Lock);
595 DeleteMidQEntry(mid);
596 return rc;
599 static inline int
600 send_cancel(struct TCP_Server_Info *server, void *buf, struct mid_q_entry *mid)
602 return server->ops->send_cancel ?
603 server->ops->send_cancel(server, buf, mid) : 0;
607 cifs_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,
608 bool log_error)
610 unsigned int len = get_rfc1002_length(mid->resp_buf) + 4;
612 dump_smb(mid->resp_buf, min_t(u32, 92, len));
614 /* convert the length into a more usable form */
615 if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
616 struct kvec iov;
617 int rc = 0;
618 struct smb_rqst rqst = { .rq_iov = &iov,
619 .rq_nvec = 1 };
621 iov.iov_base = mid->resp_buf;
622 iov.iov_len = len;
623 /* FIXME: add code to kill session */
624 rc = cifs_verify_signature(&rqst, server,
625 mid->sequence_number);
626 if (rc)
627 cifs_dbg(VFS, "SMB signature verification returned error = %d\n",
628 rc);
631 /* BB special case reconnect tid and uid here? */
632 return map_smb_to_linux_error(mid->resp_buf, log_error);
635 struct mid_q_entry *
636 cifs_setup_request(struct cifs_ses *ses, struct smb_rqst *rqst)
638 int rc;
639 struct smb_hdr *hdr = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
640 struct mid_q_entry *mid;
642 rc = allocate_mid(ses, hdr, &mid);
643 if (rc)
644 return ERR_PTR(rc);
645 rc = cifs_sign_rqst(rqst, ses->server, &mid->sequence_number);
646 if (rc) {
647 cifs_delete_mid(mid);
648 return ERR_PTR(rc);
650 return mid;
654 SendReceive2(const unsigned int xid, struct cifs_ses *ses,
655 struct kvec *iov, int n_vec, int *resp_buf_type /* ret */,
656 const int flags)
658 int rc = 0;
659 int timeout, optype;
660 struct mid_q_entry *midQ;
661 char *buf = iov[0].iov_base;
662 unsigned int credits = 1;
663 struct smb_rqst rqst = { .rq_iov = iov,
664 .rq_nvec = n_vec };
666 timeout = flags & CIFS_TIMEOUT_MASK;
667 optype = flags & CIFS_OP_MASK;
669 *resp_buf_type = CIFS_NO_BUFFER; /* no response buf yet */
671 if ((ses == NULL) || (ses->server == NULL)) {
672 cifs_small_buf_release(buf);
673 cifs_dbg(VFS, "Null session\n");
674 return -EIO;
677 if (ses->server->tcpStatus == CifsExiting) {
678 cifs_small_buf_release(buf);
679 return -ENOENT;
683 * Ensure that we do not send more than 50 overlapping requests
684 * to the same server. We may make this configurable later or
685 * use ses->maxReq.
688 rc = wait_for_free_request(ses->server, timeout, optype);
689 if (rc) {
690 cifs_small_buf_release(buf);
691 return rc;
695 * Make sure that we sign in the same order that we send on this socket
696 * and avoid races inside tcp sendmsg code that could cause corruption
697 * of smb data.
700 mutex_lock(&ses->server->srv_mutex);
702 midQ = ses->server->ops->setup_request(ses, &rqst);
703 if (IS_ERR(midQ)) {
704 mutex_unlock(&ses->server->srv_mutex);
705 cifs_small_buf_release(buf);
706 /* Update # of requests on wire to server */
707 add_credits(ses->server, 1, optype);
708 return PTR_ERR(midQ);
711 midQ->mid_state = MID_REQUEST_SUBMITTED;
712 cifs_in_send_inc(ses->server);
713 rc = smb_sendv(ses->server, iov, n_vec);
714 cifs_in_send_dec(ses->server);
715 cifs_save_when_sent(midQ);
717 if (rc < 0)
718 ses->server->sequence_number -= 2;
719 mutex_unlock(&ses->server->srv_mutex);
721 if (rc < 0) {
722 cifs_small_buf_release(buf);
723 goto out;
726 if (timeout == CIFS_ASYNC_OP) {
727 cifs_small_buf_release(buf);
728 goto out;
731 rc = wait_for_response(ses->server, midQ);
732 if (rc != 0) {
733 send_cancel(ses->server, buf, midQ);
734 spin_lock(&GlobalMid_Lock);
735 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
736 midQ->callback = DeleteMidQEntry;
737 spin_unlock(&GlobalMid_Lock);
738 cifs_small_buf_release(buf);
739 add_credits(ses->server, 1, optype);
740 return rc;
742 spin_unlock(&GlobalMid_Lock);
745 cifs_small_buf_release(buf);
747 rc = cifs_sync_mid_result(midQ, ses->server);
748 if (rc != 0) {
749 add_credits(ses->server, 1, optype);
750 return rc;
753 if (!midQ->resp_buf || midQ->mid_state != MID_RESPONSE_RECEIVED) {
754 rc = -EIO;
755 cifs_dbg(FYI, "Bad MID state?\n");
756 goto out;
759 buf = (char *)midQ->resp_buf;
760 iov[0].iov_base = buf;
761 iov[0].iov_len = get_rfc1002_length(buf) + 4;
762 if (midQ->large_buf)
763 *resp_buf_type = CIFS_LARGE_BUFFER;
764 else
765 *resp_buf_type = CIFS_SMALL_BUFFER;
767 credits = ses->server->ops->get_credits(midQ);
769 rc = ses->server->ops->check_receive(midQ, ses->server,
770 flags & CIFS_LOG_ERROR);
772 /* mark it so buf will not be freed by cifs_delete_mid */
773 if ((flags & CIFS_NO_RESP) == 0)
774 midQ->resp_buf = NULL;
775 out:
776 cifs_delete_mid(midQ);
777 add_credits(ses->server, credits, optype);
779 return rc;
783 SendReceive(const unsigned int xid, struct cifs_ses *ses,
784 struct smb_hdr *in_buf, struct smb_hdr *out_buf,
785 int *pbytes_returned, const int timeout)
787 int rc = 0;
788 struct mid_q_entry *midQ;
790 if (ses == NULL) {
791 cifs_dbg(VFS, "Null smb session\n");
792 return -EIO;
794 if (ses->server == NULL) {
795 cifs_dbg(VFS, "Null tcp session\n");
796 return -EIO;
799 if (ses->server->tcpStatus == CifsExiting)
800 return -ENOENT;
802 /* Ensure that we do not send more than 50 overlapping requests
803 to the same server. We may make this configurable later or
804 use ses->maxReq */
806 if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
807 MAX_CIFS_HDR_SIZE - 4) {
808 cifs_dbg(VFS, "Illegal length, greater than maximum frame, %d\n",
809 be32_to_cpu(in_buf->smb_buf_length));
810 return -EIO;
813 rc = wait_for_free_request(ses->server, timeout, 0);
814 if (rc)
815 return rc;
817 /* make sure that we sign in the same order that we send on this socket
818 and avoid races inside tcp sendmsg code that could cause corruption
819 of smb data */
821 mutex_lock(&ses->server->srv_mutex);
823 rc = allocate_mid(ses, in_buf, &midQ);
824 if (rc) {
825 mutex_unlock(&ses->server->srv_mutex);
826 /* Update # of requests on wire to server */
827 add_credits(ses->server, 1, 0);
828 return rc;
831 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
832 if (rc) {
833 mutex_unlock(&ses->server->srv_mutex);
834 goto out;
837 midQ->mid_state = MID_REQUEST_SUBMITTED;
839 cifs_in_send_inc(ses->server);
840 rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
841 cifs_in_send_dec(ses->server);
842 cifs_save_when_sent(midQ);
844 if (rc < 0)
845 ses->server->sequence_number -= 2;
847 mutex_unlock(&ses->server->srv_mutex);
849 if (rc < 0)
850 goto out;
852 if (timeout == CIFS_ASYNC_OP)
853 goto out;
855 rc = wait_for_response(ses->server, midQ);
856 if (rc != 0) {
857 send_cancel(ses->server, in_buf, midQ);
858 spin_lock(&GlobalMid_Lock);
859 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
860 /* no longer considered to be "in-flight" */
861 midQ->callback = DeleteMidQEntry;
862 spin_unlock(&GlobalMid_Lock);
863 add_credits(ses->server, 1, 0);
864 return rc;
866 spin_unlock(&GlobalMid_Lock);
869 rc = cifs_sync_mid_result(midQ, ses->server);
870 if (rc != 0) {
871 add_credits(ses->server, 1, 0);
872 return rc;
875 if (!midQ->resp_buf || !out_buf ||
876 midQ->mid_state != MID_RESPONSE_RECEIVED) {
877 rc = -EIO;
878 cifs_dbg(VFS, "Bad MID state?\n");
879 goto out;
882 *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
883 memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
884 rc = cifs_check_receive(midQ, ses->server, 0);
885 out:
886 cifs_delete_mid(midQ);
887 add_credits(ses->server, 1, 0);
889 return rc;
892 /* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
893 blocking lock to return. */
895 static int
896 send_lock_cancel(const unsigned int xid, struct cifs_tcon *tcon,
897 struct smb_hdr *in_buf,
898 struct smb_hdr *out_buf)
900 int bytes_returned;
901 struct cifs_ses *ses = tcon->ses;
902 LOCK_REQ *pSMB = (LOCK_REQ *)in_buf;
904 /* We just modify the current in_buf to change
905 the type of lock from LOCKING_ANDX_SHARED_LOCK
906 or LOCKING_ANDX_EXCLUSIVE_LOCK to
907 LOCKING_ANDX_CANCEL_LOCK. */
909 pSMB->LockType = LOCKING_ANDX_CANCEL_LOCK|LOCKING_ANDX_LARGE_FILES;
910 pSMB->Timeout = 0;
911 pSMB->hdr.Mid = get_next_mid(ses->server);
913 return SendReceive(xid, ses, in_buf, out_buf,
914 &bytes_returned, 0);
918 SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
919 struct smb_hdr *in_buf, struct smb_hdr *out_buf,
920 int *pbytes_returned)
922 int rc = 0;
923 int rstart = 0;
924 struct mid_q_entry *midQ;
925 struct cifs_ses *ses;
927 if (tcon == NULL || tcon->ses == NULL) {
928 cifs_dbg(VFS, "Null smb session\n");
929 return -EIO;
931 ses = tcon->ses;
933 if (ses->server == NULL) {
934 cifs_dbg(VFS, "Null tcp session\n");
935 return -EIO;
938 if (ses->server->tcpStatus == CifsExiting)
939 return -ENOENT;
941 /* Ensure that we do not send more than 50 overlapping requests
942 to the same server. We may make this configurable later or
943 use ses->maxReq */
945 if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
946 MAX_CIFS_HDR_SIZE - 4) {
947 cifs_dbg(VFS, "Illegal length, greater than maximum frame, %d\n",
948 be32_to_cpu(in_buf->smb_buf_length));
949 return -EIO;
952 rc = wait_for_free_request(ses->server, CIFS_BLOCKING_OP, 0);
953 if (rc)
954 return rc;
956 /* make sure that we sign in the same order that we send on this socket
957 and avoid races inside tcp sendmsg code that could cause corruption
958 of smb data */
960 mutex_lock(&ses->server->srv_mutex);
962 rc = allocate_mid(ses, in_buf, &midQ);
963 if (rc) {
964 mutex_unlock(&ses->server->srv_mutex);
965 return rc;
968 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
969 if (rc) {
970 cifs_delete_mid(midQ);
971 mutex_unlock(&ses->server->srv_mutex);
972 return rc;
975 midQ->mid_state = MID_REQUEST_SUBMITTED;
976 cifs_in_send_inc(ses->server);
977 rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
978 cifs_in_send_dec(ses->server);
979 cifs_save_when_sent(midQ);
981 if (rc < 0)
982 ses->server->sequence_number -= 2;
984 mutex_unlock(&ses->server->srv_mutex);
986 if (rc < 0) {
987 cifs_delete_mid(midQ);
988 return rc;
991 /* Wait for a reply - allow signals to interrupt. */
992 rc = wait_event_interruptible(ses->server->response_q,
993 (!(midQ->mid_state == MID_REQUEST_SUBMITTED)) ||
994 ((ses->server->tcpStatus != CifsGood) &&
995 (ses->server->tcpStatus != CifsNew)));
997 /* Were we interrupted by a signal ? */
998 if ((rc == -ERESTARTSYS) &&
999 (midQ->mid_state == MID_REQUEST_SUBMITTED) &&
1000 ((ses->server->tcpStatus == CifsGood) ||
1001 (ses->server->tcpStatus == CifsNew))) {
1003 if (in_buf->Command == SMB_COM_TRANSACTION2) {
1004 /* POSIX lock. We send a NT_CANCEL SMB to cause the
1005 blocking lock to return. */
1006 rc = send_cancel(ses->server, in_buf, midQ);
1007 if (rc) {
1008 cifs_delete_mid(midQ);
1009 return rc;
1011 } else {
1012 /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
1013 to cause the blocking lock to return. */
1015 rc = send_lock_cancel(xid, tcon, in_buf, out_buf);
1017 /* If we get -ENOLCK back the lock may have
1018 already been removed. Don't exit in this case. */
1019 if (rc && rc != -ENOLCK) {
1020 cifs_delete_mid(midQ);
1021 return rc;
1025 rc = wait_for_response(ses->server, midQ);
1026 if (rc) {
1027 send_cancel(ses->server, in_buf, midQ);
1028 spin_lock(&GlobalMid_Lock);
1029 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
1030 /* no longer considered to be "in-flight" */
1031 midQ->callback = DeleteMidQEntry;
1032 spin_unlock(&GlobalMid_Lock);
1033 return rc;
1035 spin_unlock(&GlobalMid_Lock);
1038 /* We got the response - restart system call. */
1039 rstart = 1;
1042 rc = cifs_sync_mid_result(midQ, ses->server);
1043 if (rc != 0)
1044 return rc;
1046 /* rcvd frame is ok */
1047 if (out_buf == NULL || midQ->mid_state != MID_RESPONSE_RECEIVED) {
1048 rc = -EIO;
1049 cifs_dbg(VFS, "Bad MID state?\n");
1050 goto out;
1053 *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
1054 memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
1055 rc = cifs_check_receive(midQ, ses->server, 0);
1056 out:
1057 cifs_delete_mid(midQ);
1058 if (rstart && rc == -EACCES)
1059 return -ERESTARTSYS;
1060 return rc;