cifs: fix writeback race with file that is growing
[linux-3.10.git] / fs / cifs / transport.c
1 /*
2  *   fs/cifs/transport.c
3  *
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.
7  *
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.
12  *
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.
17  *
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
21  */
22
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"
39
40 void
41 cifs_wake_up_task(struct mid_q_entry *mid)
42 {
43         wake_up_process(mid->callback_data);
44 }
45
46 struct mid_q_entry *
47 AllocMidQEntry(const struct smb_hdr *smb_buffer, struct TCP_Server_Info *server)
48 {
49         struct mid_q_entry *temp;
50
51         if (server == NULL) {
52                 cERROR(1, "Null TCP session in AllocMidQEntry");
53                 return NULL;
54         }
55
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                 cFYI(1, "For smb_command %d", smb_buffer->Command);
65         /*      do_gettimeofday(&temp->when_sent);*/ /* easier to use jiffies */
66                 /* when mid allocated can be before when sent */
67                 temp->when_alloc = jiffies;
68                 temp->server = server;
69
70                 /*
71                  * The default is for the mid to be synchronous, so the
72                  * default callback just wakes up the current task.
73                  */
74                 temp->callback = cifs_wake_up_task;
75                 temp->callback_data = current;
76         }
77
78         atomic_inc(&midCount);
79         temp->mid_state = MID_REQUEST_ALLOCATED;
80         return temp;
81 }
82
83 void
84 DeleteMidQEntry(struct mid_q_entry *midEntry)
85 {
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);
108                 }
109         }
110 #endif
111         mempool_free(midEntry, cifs_mid_poolp);
112 }
113
114 void
115 cifs_delete_mid(struct mid_q_entry *mid)
116 {
117         spin_lock(&GlobalMid_Lock);
118         list_del(&mid->qhead);
119         spin_unlock(&GlobalMid_Lock);
120
121         DeleteMidQEntry(mid);
122 }
123
124 /*
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
130  *
131  * Our basic "send data to server" function. Should be called with srv_mutex
132  * held. The caller is responsible for handling the results.
133  */
134 static int
135 smb_send_kvec(struct TCP_Server_Info *server, struct kvec *iov, size_t n_vec,
136                 size_t *sent)
137 {
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;
144
145         *sent = 0;
146
147         if (ssocket == NULL)
148                 return -ENOTSOCK; /* BB eventually add reconnect code here */
149
150         smb_msg.msg_name = (struct sockaddr *) &server->dstaddr;
151         smb_msg.msg_namelen = sizeof(struct sockaddr);
152         smb_msg.msg_control = NULL;
153         smb_msg.msg_controllen = 0;
154         if (server->noblocksnd)
155                 smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL;
156         else
157                 smb_msg.msg_flags = MSG_NOSIGNAL;
158
159         remaining = 0;
160         for (i = 0; i < n_vec; i++)
161                 remaining += iov[i].iov_len;
162
163         i = 0;
164         while (remaining) {
165                 /*
166                  * If blocking send, we try 3 times, since each can block
167                  * for 5 seconds. For nonblocking  we have to try more
168                  * but wait increasing amounts of time allowing time for
169                  * socket to clear.  The overall time we wait in either
170                  * case to send on the socket is about 15 seconds.
171                  * Similarly we wait for 15 seconds for a response from
172                  * the server in SendReceive[2] for the server to send
173                  * a response back for most types of requests (except
174                  * SMB Write past end of file which can be slow, and
175                  * blocking lock operations). NFS waits slightly longer
176                  * than CIFS, but this can make it take longer for
177                  * nonresponsive servers to be detected and 15 seconds
178                  * is more than enough time for modern networks to
179                  * send a packet.  In most cases if we fail to send
180                  * after the retries we will kill the socket and
181                  * reconnect which may clear the network problem.
182                  */
183                 rc = kernel_sendmsg(ssocket, &smb_msg, &iov[first_vec],
184                                     n_vec - first_vec, remaining);
185                 if (rc == -ENOSPC || rc == -EAGAIN) {
186                         /*
187                          * Catch if a low level driver returns -ENOSPC. This
188                          * WARN_ON will be removed by 3.10 if no one reports
189                          * seeing this.
190                          */
191                         WARN_ON_ONCE(rc == -ENOSPC);
192                         i++;
193                         if (i >= 14 || (!server->noblocksnd && (i > 2))) {
194                                 cERROR(1, "sends on sock %p stuck for 15 "
195                                           "seconds", ssocket);
196                                 rc = -EAGAIN;
197                                 break;
198                         }
199                         msleep(1 << i);
200                         continue;
201                 }
202
203                 if (rc < 0)
204                         break;
205
206                 /* send was at least partially successful */
207                 *sent += rc;
208
209                 if (rc == remaining) {
210                         remaining = 0;
211                         break;
212                 }
213
214                 if (rc > remaining) {
215                         cERROR(1, "sent %d requested %d", rc, remaining);
216                         break;
217                 }
218
219                 if (rc == 0) {
220                         /* should never happen, letting socket clear before
221                            retrying is our only obvious option here */
222                         cERROR(1, "tcp sent no data");
223                         msleep(500);
224                         continue;
225                 }
226
227                 remaining -= rc;
228
229                 /* the line below resets i */
230                 for (i = first_vec; i < n_vec; i++) {
231                         if (iov[i].iov_len) {
232                                 if (rc > iov[i].iov_len) {
233                                         rc -= iov[i].iov_len;
234                                         iov[i].iov_len = 0;
235                                 } else {
236                                         iov[i].iov_base += rc;
237                                         iov[i].iov_len -= rc;
238                                         first_vec = i;
239                                         break;
240                                 }
241                         }
242                 }
243
244                 i = 0; /* in case we get ENOSPC on the next send */
245                 rc = 0;
246         }
247         return rc;
248 }
249
250 /**
251  * rqst_page_to_kvec - Turn a slot in the smb_rqst page array into a kvec
252  * @rqst: pointer to smb_rqst
253  * @idx: index into the array of the page
254  * @iov: pointer to struct kvec that will hold the result
255  *
256  * Helper function to convert a slot in the rqst->rq_pages array into a kvec.
257  * The page will be kmapped and the address placed into iov_base. The length
258  * will then be adjusted according to the ptailoff.
259  */
260 void
261 cifs_rqst_page_to_kvec(struct smb_rqst *rqst, unsigned int idx,
262                         struct kvec *iov)
263 {
264         /*
265          * FIXME: We could avoid this kmap altogether if we used
266          * kernel_sendpage instead of kernel_sendmsg. That will only
267          * work if signing is disabled though as sendpage inlines the
268          * page directly into the fraglist. If userspace modifies the
269          * page after we calculate the signature, then the server will
270          * reject it and may break the connection. kernel_sendmsg does
271          * an extra copy of the data and avoids that issue.
272          */
273         iov->iov_base = kmap(rqst->rq_pages[idx]);
274
275         /* if last page, don't send beyond this offset into page */
276         if (idx == (rqst->rq_npages - 1))
277                 iov->iov_len = rqst->rq_tailsz;
278         else
279                 iov->iov_len = rqst->rq_pagesz;
280 }
281
282 static int
283 smb_send_rqst(struct TCP_Server_Info *server, struct smb_rqst *rqst)
284 {
285         int rc;
286         struct kvec *iov = rqst->rq_iov;
287         int n_vec = rqst->rq_nvec;
288         unsigned int smb_buf_length = get_rfc1002_length(iov[0].iov_base);
289         unsigned int i;
290         size_t total_len = 0, sent;
291         struct socket *ssocket = server->ssocket;
292         int val = 1;
293
294         cFYI(1, "Sending smb: smb_len=%u", smb_buf_length);
295         dump_smb(iov[0].iov_base, iov[0].iov_len);
296
297         /* cork the socket */
298         kernel_setsockopt(ssocket, SOL_TCP, TCP_CORK,
299                                 (char *)&val, sizeof(val));
300
301         rc = smb_send_kvec(server, iov, n_vec, &sent);
302         if (rc < 0)
303                 goto uncork;
304
305         total_len += sent;
306
307         /* now walk the page array and send each page in it */
308         for (i = 0; i < rqst->rq_npages; i++) {
309                 struct kvec p_iov;
310
311                 cifs_rqst_page_to_kvec(rqst, i, &p_iov);
312                 rc = smb_send_kvec(server, &p_iov, 1, &sent);
313                 kunmap(rqst->rq_pages[i]);
314                 if (rc < 0)
315                         break;
316
317                 total_len += sent;
318         }
319
320 uncork:
321         /* uncork it */
322         val = 0;
323         kernel_setsockopt(ssocket, SOL_TCP, TCP_CORK,
324                                 (char *)&val, sizeof(val));
325
326         if ((total_len > 0) && (total_len != smb_buf_length + 4)) {
327                 cFYI(1, "partial send (wanted=%u sent=%zu): terminating "
328                         "session", smb_buf_length + 4, total_len);
329                 /*
330                  * If we have only sent part of an SMB then the next SMB could
331                  * be taken as the remainder of this one. We need to kill the
332                  * socket so the server throws away the partial SMB
333                  */
334                 server->tcpStatus = CifsNeedReconnect;
335         }
336
337         if (rc < 0 && rc != -EINTR)
338                 cERROR(1, "Error %d sending data on socket to server", rc);
339         else
340                 rc = 0;
341
342         return rc;
343 }
344
345 static int
346 smb_sendv(struct TCP_Server_Info *server, struct kvec *iov, int n_vec)
347 {
348         struct smb_rqst rqst = { .rq_iov = iov,
349                                  .rq_nvec = n_vec };
350
351         return smb_send_rqst(server, &rqst);
352 }
353
354 int
355 smb_send(struct TCP_Server_Info *server, struct smb_hdr *smb_buffer,
356          unsigned int smb_buf_length)
357 {
358         struct kvec iov;
359
360         iov.iov_base = smb_buffer;
361         iov.iov_len = smb_buf_length + 4;
362
363         return smb_sendv(server, &iov, 1);
364 }
365
366 static int
367 wait_for_free_credits(struct TCP_Server_Info *server, const int timeout,
368                       int *credits)
369 {
370         int rc;
371
372         spin_lock(&server->req_lock);
373         if (timeout == CIFS_ASYNC_OP) {
374                 /* oplock breaks must not be held up */
375                 server->in_flight++;
376                 *credits -= 1;
377                 spin_unlock(&server->req_lock);
378                 return 0;
379         }
380
381         while (1) {
382                 if (*credits <= 0) {
383                         spin_unlock(&server->req_lock);
384                         cifs_num_waiters_inc(server);
385                         rc = wait_event_killable(server->request_q,
386                                                  has_credits(server, credits));
387                         cifs_num_waiters_dec(server);
388                         if (rc)
389                                 return rc;
390                         spin_lock(&server->req_lock);
391                 } else {
392                         if (server->tcpStatus == CifsExiting) {
393                                 spin_unlock(&server->req_lock);
394                                 return -ENOENT;
395                         }
396
397                         /*
398                          * Can not count locking commands against total
399                          * as they are allowed to block on server.
400                          */
401
402                         /* update # of requests on the wire to server */
403                         if (timeout != CIFS_BLOCKING_OP) {
404                                 *credits -= 1;
405                                 server->in_flight++;
406                         }
407                         spin_unlock(&server->req_lock);
408                         break;
409                 }
410         }
411         return 0;
412 }
413
414 static int
415 wait_for_free_request(struct TCP_Server_Info *server, const int timeout,
416                       const int optype)
417 {
418         return wait_for_free_credits(server, timeout,
419                                 server->ops->get_credits_field(server, optype));
420 }
421
422 static int allocate_mid(struct cifs_ses *ses, struct smb_hdr *in_buf,
423                         struct mid_q_entry **ppmidQ)
424 {
425         if (ses->server->tcpStatus == CifsExiting) {
426                 return -ENOENT;
427         }
428
429         if (ses->server->tcpStatus == CifsNeedReconnect) {
430                 cFYI(1, "tcp session dead - return to caller to retry");
431                 return -EAGAIN;
432         }
433
434         if (ses->status != CifsGood) {
435                 /* check if SMB session is bad because we are setting it up */
436                 if ((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
437                         (in_buf->Command != SMB_COM_NEGOTIATE))
438                         return -EAGAIN;
439                 /* else ok - we are setting up session */
440         }
441         *ppmidQ = AllocMidQEntry(in_buf, ses->server);
442         if (*ppmidQ == NULL)
443                 return -ENOMEM;
444         spin_lock(&GlobalMid_Lock);
445         list_add_tail(&(*ppmidQ)->qhead, &ses->server->pending_mid_q);
446         spin_unlock(&GlobalMid_Lock);
447         return 0;
448 }
449
450 static int
451 wait_for_response(struct TCP_Server_Info *server, struct mid_q_entry *midQ)
452 {
453         int error;
454
455         error = wait_event_freezekillable(server->response_q,
456                                     midQ->mid_state != MID_REQUEST_SUBMITTED);
457         if (error < 0)
458                 return -ERESTARTSYS;
459
460         return 0;
461 }
462
463 struct mid_q_entry *
464 cifs_setup_async_request(struct TCP_Server_Info *server, struct smb_rqst *rqst)
465 {
466         int rc;
467         struct smb_hdr *hdr = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
468         struct mid_q_entry *mid;
469
470         /* enable signing if server requires it */
471         if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
472                 hdr->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
473
474         mid = AllocMidQEntry(hdr, server);
475         if (mid == NULL)
476                 return ERR_PTR(-ENOMEM);
477
478         rc = cifs_sign_rqst(rqst, server, &mid->sequence_number);
479         if (rc) {
480                 DeleteMidQEntry(mid);
481                 return ERR_PTR(rc);
482         }
483
484         return mid;
485 }
486
487 /*
488  * Send a SMB request and set the callback function in the mid to handle
489  * the result. Caller is responsible for dealing with timeouts.
490  */
491 int
492 cifs_call_async(struct TCP_Server_Info *server, struct smb_rqst *rqst,
493                 mid_receive_t *receive, mid_callback_t *callback,
494                 void *cbdata, const int flags)
495 {
496         int rc, timeout, optype;
497         struct mid_q_entry *mid;
498
499         timeout = flags & CIFS_TIMEOUT_MASK;
500         optype = flags & CIFS_OP_MASK;
501
502         rc = wait_for_free_request(server, timeout, optype);
503         if (rc)
504                 return rc;
505
506         mutex_lock(&server->srv_mutex);
507         mid = server->ops->setup_async_request(server, rqst);
508         if (IS_ERR(mid)) {
509                 mutex_unlock(&server->srv_mutex);
510                 add_credits(server, 1, optype);
511                 wake_up(&server->request_q);
512                 return PTR_ERR(mid);
513         }
514
515         mid->receive = receive;
516         mid->callback = callback;
517         mid->callback_data = cbdata;
518         mid->mid_state = MID_REQUEST_SUBMITTED;
519
520         /* put it on the pending_mid_q */
521         spin_lock(&GlobalMid_Lock);
522         list_add_tail(&mid->qhead, &server->pending_mid_q);
523         spin_unlock(&GlobalMid_Lock);
524
525
526         cifs_in_send_inc(server);
527         rc = smb_send_rqst(server, rqst);
528         cifs_in_send_dec(server);
529         cifs_save_when_sent(mid);
530         mutex_unlock(&server->srv_mutex);
531
532         if (rc == 0)
533                 return 0;
534
535         cifs_delete_mid(mid);
536         add_credits(server, 1, optype);
537         wake_up(&server->request_q);
538         return rc;
539 }
540
541 /*
542  *
543  * Send an SMB Request.  No response info (other than return code)
544  * needs to be parsed.
545  *
546  * flags indicate the type of request buffer and how long to wait
547  * and whether to log NT STATUS code (error) before mapping it to POSIX error
548  *
549  */
550 int
551 SendReceiveNoRsp(const unsigned int xid, struct cifs_ses *ses,
552                  char *in_buf, int flags)
553 {
554         int rc;
555         struct kvec iov[1];
556         int resp_buf_type;
557
558         iov[0].iov_base = in_buf;
559         iov[0].iov_len = get_rfc1002_length(in_buf) + 4;
560         flags |= CIFS_NO_RESP;
561         rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags);
562         cFYI(DBG2, "SendRcvNoRsp flags %d rc %d", flags, rc);
563
564         return rc;
565 }
566
567 static int
568 cifs_sync_mid_result(struct mid_q_entry *mid, struct TCP_Server_Info *server)
569 {
570         int rc = 0;
571
572         cFYI(1, "%s: cmd=%d mid=%llu state=%d", __func__,
573              le16_to_cpu(mid->command), mid->mid, mid->mid_state);
574
575         spin_lock(&GlobalMid_Lock);
576         switch (mid->mid_state) {
577         case MID_RESPONSE_RECEIVED:
578                 spin_unlock(&GlobalMid_Lock);
579                 return rc;
580         case MID_RETRY_NEEDED:
581                 rc = -EAGAIN;
582                 break;
583         case MID_RESPONSE_MALFORMED:
584                 rc = -EIO;
585                 break;
586         case MID_SHUTDOWN:
587                 rc = -EHOSTDOWN;
588                 break;
589         default:
590                 list_del_init(&mid->qhead);
591                 cERROR(1, "%s: invalid mid state mid=%llu state=%d", __func__,
592                        mid->mid, mid->mid_state);
593                 rc = -EIO;
594         }
595         spin_unlock(&GlobalMid_Lock);
596
597         DeleteMidQEntry(mid);
598         return rc;
599 }
600
601 static inline int
602 send_cancel(struct TCP_Server_Info *server, void *buf, struct mid_q_entry *mid)
603 {
604         return server->ops->send_cancel ?
605                                 server->ops->send_cancel(server, buf, mid) : 0;
606 }
607
608 int
609 cifs_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,
610                    bool log_error)
611 {
612         unsigned int len = get_rfc1002_length(mid->resp_buf) + 4;
613
614         dump_smb(mid->resp_buf, min_t(u32, 92, len));
615
616         /* convert the length into a more usable form */
617         if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
618                 struct kvec iov;
619                 int rc = 0;
620                 struct smb_rqst rqst = { .rq_iov = &iov,
621                                          .rq_nvec = 1 };
622
623                 iov.iov_base = mid->resp_buf;
624                 iov.iov_len = len;
625                 /* FIXME: add code to kill session */
626                 rc = cifs_verify_signature(&rqst, server,
627                                            mid->sequence_number + 1);
628                 if (rc)
629                         cERROR(1, "SMB signature verification returned error = "
630                                "%d", rc);
631         }
632
633         /* BB special case reconnect tid and uid here? */
634         return map_smb_to_linux_error(mid->resp_buf, log_error);
635 }
636
637 struct mid_q_entry *
638 cifs_setup_request(struct cifs_ses *ses, struct smb_rqst *rqst)
639 {
640         int rc;
641         struct smb_hdr *hdr = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
642         struct mid_q_entry *mid;
643
644         rc = allocate_mid(ses, hdr, &mid);
645         if (rc)
646                 return ERR_PTR(rc);
647         rc = cifs_sign_rqst(rqst, ses->server, &mid->sequence_number);
648         if (rc) {
649                 cifs_delete_mid(mid);
650                 return ERR_PTR(rc);
651         }
652         return mid;
653 }
654
655 int
656 SendReceive2(const unsigned int xid, struct cifs_ses *ses,
657              struct kvec *iov, int n_vec, int *resp_buf_type /* ret */,
658              const int flags)
659 {
660         int rc = 0;
661         int timeout, optype;
662         struct mid_q_entry *midQ;
663         char *buf = iov[0].iov_base;
664         unsigned int credits = 1;
665         struct smb_rqst rqst = { .rq_iov = iov,
666                                  .rq_nvec = n_vec };
667
668         timeout = flags & CIFS_TIMEOUT_MASK;
669         optype = flags & CIFS_OP_MASK;
670
671         *resp_buf_type = CIFS_NO_BUFFER;  /* no response buf yet */
672
673         if ((ses == NULL) || (ses->server == NULL)) {
674                 cifs_small_buf_release(buf);
675                 cERROR(1, "Null session");
676                 return -EIO;
677         }
678
679         if (ses->server->tcpStatus == CifsExiting) {
680                 cifs_small_buf_release(buf);
681                 return -ENOENT;
682         }
683
684         /*
685          * Ensure that we do not send more than 50 overlapping requests
686          * to the same server. We may make this configurable later or
687          * use ses->maxReq.
688          */
689
690         rc = wait_for_free_request(ses->server, timeout, optype);
691         if (rc) {
692                 cifs_small_buf_release(buf);
693                 return rc;
694         }
695
696         /*
697          * Make sure that we sign in the same order that we send on this socket
698          * and avoid races inside tcp sendmsg code that could cause corruption
699          * of smb data.
700          */
701
702         mutex_lock(&ses->server->srv_mutex);
703
704         midQ = ses->server->ops->setup_request(ses, &rqst);
705         if (IS_ERR(midQ)) {
706                 mutex_unlock(&ses->server->srv_mutex);
707                 cifs_small_buf_release(buf);
708                 /* Update # of requests on wire to server */
709                 add_credits(ses->server, 1, optype);
710                 return PTR_ERR(midQ);
711         }
712
713         midQ->mid_state = MID_REQUEST_SUBMITTED;
714         cifs_in_send_inc(ses->server);
715         rc = smb_sendv(ses->server, iov, n_vec);
716         cifs_in_send_dec(ses->server);
717         cifs_save_when_sent(midQ);
718
719         mutex_unlock(&ses->server->srv_mutex);
720
721         if (rc < 0) {
722                 cifs_small_buf_release(buf);
723                 goto out;
724         }
725
726         if (timeout == CIFS_ASYNC_OP) {
727                 cifs_small_buf_release(buf);
728                 goto out;
729         }
730
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;
741                 }
742                 spin_unlock(&GlobalMid_Lock);
743         }
744
745         cifs_small_buf_release(buf);
746
747         rc = cifs_sync_mid_result(midQ, ses->server);
748         if (rc != 0) {
749                 add_credits(ses->server, 1, optype);
750                 return rc;
751         }
752
753         if (!midQ->resp_buf || midQ->mid_state != MID_RESPONSE_RECEIVED) {
754                 rc = -EIO;
755                 cFYI(1, "Bad MID state?");
756                 goto out;
757         }
758
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;
766
767         credits = ses->server->ops->get_credits(midQ);
768
769         rc = ses->server->ops->check_receive(midQ, ses->server,
770                                              flags & CIFS_LOG_ERROR);
771
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);
778
779         return rc;
780 }
781
782 int
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)
786 {
787         int rc = 0;
788         struct mid_q_entry *midQ;
789
790         if (ses == NULL) {
791                 cERROR(1, "Null smb session");
792                 return -EIO;
793         }
794         if (ses->server == NULL) {
795                 cERROR(1, "Null tcp session");
796                 return -EIO;
797         }
798
799         if (ses->server->tcpStatus == CifsExiting)
800                 return -ENOENT;
801
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 */
805
806         if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
807                         MAX_CIFS_HDR_SIZE - 4) {
808                 cERROR(1, "Illegal length, greater than maximum frame, %d",
809                            be32_to_cpu(in_buf->smb_buf_length));
810                 return -EIO;
811         }
812
813         rc = wait_for_free_request(ses->server, timeout, 0);
814         if (rc)
815                 return rc;
816
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 */
820
821         mutex_lock(&ses->server->srv_mutex);
822
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;
829         }
830
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;
835         }
836
837         midQ->mid_state = MID_REQUEST_SUBMITTED;
838
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);
843         mutex_unlock(&ses->server->srv_mutex);
844
845         if (rc < 0)
846                 goto out;
847
848         if (timeout == CIFS_ASYNC_OP)
849                 goto out;
850
851         rc = wait_for_response(ses->server, midQ);
852         if (rc != 0) {
853                 send_cancel(ses->server, in_buf, midQ);
854                 spin_lock(&GlobalMid_Lock);
855                 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
856                         /* no longer considered to be "in-flight" */
857                         midQ->callback = DeleteMidQEntry;
858                         spin_unlock(&GlobalMid_Lock);
859                         add_credits(ses->server, 1, 0);
860                         return rc;
861                 }
862                 spin_unlock(&GlobalMid_Lock);
863         }
864
865         rc = cifs_sync_mid_result(midQ, ses->server);
866         if (rc != 0) {
867                 add_credits(ses->server, 1, 0);
868                 return rc;
869         }
870
871         if (!midQ->resp_buf || !out_buf ||
872             midQ->mid_state != MID_RESPONSE_RECEIVED) {
873                 rc = -EIO;
874                 cERROR(1, "Bad MID state?");
875                 goto out;
876         }
877
878         *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
879         memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
880         rc = cifs_check_receive(midQ, ses->server, 0);
881 out:
882         cifs_delete_mid(midQ);
883         add_credits(ses->server, 1, 0);
884
885         return rc;
886 }
887
888 /* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
889    blocking lock to return. */
890
891 static int
892 send_lock_cancel(const unsigned int xid, struct cifs_tcon *tcon,
893                         struct smb_hdr *in_buf,
894                         struct smb_hdr *out_buf)
895 {
896         int bytes_returned;
897         struct cifs_ses *ses = tcon->ses;
898         LOCK_REQ *pSMB = (LOCK_REQ *)in_buf;
899
900         /* We just modify the current in_buf to change
901            the type of lock from LOCKING_ANDX_SHARED_LOCK
902            or LOCKING_ANDX_EXCLUSIVE_LOCK to
903            LOCKING_ANDX_CANCEL_LOCK. */
904
905         pSMB->LockType = LOCKING_ANDX_CANCEL_LOCK|LOCKING_ANDX_LARGE_FILES;
906         pSMB->Timeout = 0;
907         pSMB->hdr.Mid = get_next_mid(ses->server);
908
909         return SendReceive(xid, ses, in_buf, out_buf,
910                         &bytes_returned, 0);
911 }
912
913 int
914 SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
915             struct smb_hdr *in_buf, struct smb_hdr *out_buf,
916             int *pbytes_returned)
917 {
918         int rc = 0;
919         int rstart = 0;
920         struct mid_q_entry *midQ;
921         struct cifs_ses *ses;
922
923         if (tcon == NULL || tcon->ses == NULL) {
924                 cERROR(1, "Null smb session");
925                 return -EIO;
926         }
927         ses = tcon->ses;
928
929         if (ses->server == NULL) {
930                 cERROR(1, "Null tcp session");
931                 return -EIO;
932         }
933
934         if (ses->server->tcpStatus == CifsExiting)
935                 return -ENOENT;
936
937         /* Ensure that we do not send more than 50 overlapping requests
938            to the same server. We may make this configurable later or
939            use ses->maxReq */
940
941         if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
942                         MAX_CIFS_HDR_SIZE - 4) {
943                 cERROR(1, "Illegal length, greater than maximum frame, %d",
944                            be32_to_cpu(in_buf->smb_buf_length));
945                 return -EIO;
946         }
947
948         rc = wait_for_free_request(ses->server, CIFS_BLOCKING_OP, 0);
949         if (rc)
950                 return rc;
951
952         /* make sure that we sign in the same order that we send on this socket
953            and avoid races inside tcp sendmsg code that could cause corruption
954            of smb data */
955
956         mutex_lock(&ses->server->srv_mutex);
957
958         rc = allocate_mid(ses, in_buf, &midQ);
959         if (rc) {
960                 mutex_unlock(&ses->server->srv_mutex);
961                 return rc;
962         }
963
964         rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
965         if (rc) {
966                 cifs_delete_mid(midQ);
967                 mutex_unlock(&ses->server->srv_mutex);
968                 return rc;
969         }
970
971         midQ->mid_state = MID_REQUEST_SUBMITTED;
972         cifs_in_send_inc(ses->server);
973         rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
974         cifs_in_send_dec(ses->server);
975         cifs_save_when_sent(midQ);
976         mutex_unlock(&ses->server->srv_mutex);
977
978         if (rc < 0) {
979                 cifs_delete_mid(midQ);
980                 return rc;
981         }
982
983         /* Wait for a reply - allow signals to interrupt. */
984         rc = wait_event_interruptible(ses->server->response_q,
985                 (!(midQ->mid_state == MID_REQUEST_SUBMITTED)) ||
986                 ((ses->server->tcpStatus != CifsGood) &&
987                  (ses->server->tcpStatus != CifsNew)));
988
989         /* Were we interrupted by a signal ? */
990         if ((rc == -ERESTARTSYS) &&
991                 (midQ->mid_state == MID_REQUEST_SUBMITTED) &&
992                 ((ses->server->tcpStatus == CifsGood) ||
993                  (ses->server->tcpStatus == CifsNew))) {
994
995                 if (in_buf->Command == SMB_COM_TRANSACTION2) {
996                         /* POSIX lock. We send a NT_CANCEL SMB to cause the
997                            blocking lock to return. */
998                         rc = send_cancel(ses->server, in_buf, midQ);
999                         if (rc) {
1000                                 cifs_delete_mid(midQ);
1001                                 return rc;
1002                         }
1003                 } else {
1004                         /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
1005                            to cause the blocking lock to return. */
1006
1007                         rc = send_lock_cancel(xid, tcon, in_buf, out_buf);
1008
1009                         /* If we get -ENOLCK back the lock may have
1010                            already been removed. Don't exit in this case. */
1011                         if (rc && rc != -ENOLCK) {
1012                                 cifs_delete_mid(midQ);
1013                                 return rc;
1014                         }
1015                 }
1016
1017                 rc = wait_for_response(ses->server, midQ);
1018                 if (rc) {
1019                         send_cancel(ses->server, in_buf, midQ);
1020                         spin_lock(&GlobalMid_Lock);
1021                         if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
1022                                 /* no longer considered to be "in-flight" */
1023                                 midQ->callback = DeleteMidQEntry;
1024                                 spin_unlock(&GlobalMid_Lock);
1025                                 return rc;
1026                         }
1027                         spin_unlock(&GlobalMid_Lock);
1028                 }
1029
1030                 /* We got the response - restart system call. */
1031                 rstart = 1;
1032         }
1033
1034         rc = cifs_sync_mid_result(midQ, ses->server);
1035         if (rc != 0)
1036                 return rc;
1037
1038         /* rcvd frame is ok */
1039         if (out_buf == NULL || midQ->mid_state != MID_RESPONSE_RECEIVED) {
1040                 rc = -EIO;
1041                 cERROR(1, "Bad MID state?");
1042                 goto out;
1043         }
1044
1045         *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
1046         memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
1047         rc = cifs_check_receive(midQ, ses->server, 0);
1048 out:
1049         cifs_delete_mid(midQ);
1050         if (rstart && rc == -EACCES)
1051                 return -ERESTARTSYS;
1052         return rc;
1053 }