0cc9584f5889f051208a00bb346869d73f6ed1ba
[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 <asm/uaccess.h>
31 #include <asm/processor.h>
32 #include <linux/mempool.h>
33 #include "cifspdu.h"
34 #include "cifsglob.h"
35 #include "cifsproto.h"
36 #include "cifs_debug.h"
37
38 extern mempool_t *cifs_mid_poolp;
39
40 static void
41 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 = smb_buffer->Command;
64                 cFYI(1, "For smb_command %d", temp->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
69                 /*
70                  * The default is for the mid to be synchronous, so the
71                  * default callback just wakes up the current task.
72                  */
73                 temp->callback = wake_up_task;
74                 temp->callback_data = current;
75         }
76
77         atomic_inc(&midCount);
78         temp->midState = MID_REQUEST_ALLOCATED;
79         return temp;
80 }
81
82 void
83 DeleteMidQEntry(struct mid_q_entry *midEntry)
84 {
85 #ifdef CONFIG_CIFS_STATS2
86         unsigned long now;
87 #endif
88         midEntry->midState = MID_FREE;
89         atomic_dec(&midCount);
90         if (midEntry->largeBuf)
91                 cifs_buf_release(midEntry->resp_buf);
92         else
93                 cifs_small_buf_release(midEntry->resp_buf);
94 #ifdef CONFIG_CIFS_STATS2
95         now = jiffies;
96         /* commands taking longer than one second are indications that
97            something is wrong, unless it is quite a slow link or server */
98         if ((now - midEntry->when_alloc) > HZ) {
99                 if ((cifsFYI & CIFS_TIMER) &&
100                    (midEntry->command != SMB_COM_LOCKING_ANDX)) {
101                         printk(KERN_DEBUG " CIFS slow rsp: cmd %d mid %d",
102                                midEntry->command, midEntry->mid);
103                         printk(" A: 0x%lx S: 0x%lx R: 0x%lx\n",
104                                now - midEntry->when_alloc,
105                                now - midEntry->when_sent,
106                                now - midEntry->when_received);
107                 }
108         }
109 #endif
110         mempool_free(midEntry, cifs_mid_poolp);
111 }
112
113 static void
114 delete_mid(struct mid_q_entry *mid)
115 {
116         spin_lock(&GlobalMid_Lock);
117         list_del(&mid->qhead);
118         spin_unlock(&GlobalMid_Lock);
119
120         DeleteMidQEntry(mid);
121 }
122
123 static int
124 smb_sendv(struct TCP_Server_Info *server, struct kvec *iov, int n_vec)
125 {
126         int rc = 0;
127         int i = 0;
128         struct msghdr smb_msg;
129         struct smb_hdr *smb_buffer = iov[0].iov_base;
130         unsigned int len = iov[0].iov_len;
131         unsigned int total_len;
132         int first_vec = 0;
133         unsigned int smb_buf_length = be32_to_cpu(smb_buffer->smb_buf_length);
134         struct socket *ssocket = server->ssocket;
135
136         if (ssocket == NULL)
137                 return -ENOTSOCK; /* BB eventually add reconnect code here */
138
139         smb_msg.msg_name = (struct sockaddr *) &server->dstaddr;
140         smb_msg.msg_namelen = sizeof(struct sockaddr);
141         smb_msg.msg_control = NULL;
142         smb_msg.msg_controllen = 0;
143         if (server->noblocksnd)
144                 smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL;
145         else
146                 smb_msg.msg_flags = MSG_NOSIGNAL;
147
148         total_len = 0;
149         for (i = 0; i < n_vec; i++)
150                 total_len += iov[i].iov_len;
151
152         cFYI(1, "Sending smb:  total_len %d", total_len);
153         dump_smb(smb_buffer, len);
154
155         i = 0;
156         while (total_len) {
157                 rc = kernel_sendmsg(ssocket, &smb_msg, &iov[first_vec],
158                                     n_vec - first_vec, total_len);
159                 if ((rc == -ENOSPC) || (rc == -EAGAIN)) {
160                         i++;
161                         /* if blocking send we try 3 times, since each can block
162                            for 5 seconds. For nonblocking  we have to try more
163                            but wait increasing amounts of time allowing time for
164                            socket to clear.  The overall time we wait in either
165                            case to send on the socket is about 15 seconds.
166                            Similarly we wait for 15 seconds for
167                            a response from the server in SendReceive[2]
168                            for the server to send a response back for
169                            most types of requests (except SMB Write
170                            past end of file which can be slow, and
171                            blocking lock operations). NFS waits slightly longer
172                            than CIFS, but this can make it take longer for
173                            nonresponsive servers to be detected and 15 seconds
174                            is more than enough time for modern networks to
175                            send a packet.  In most cases if we fail to send
176                            after the retries we will kill the socket and
177                            reconnect which may clear the network problem.
178                         */
179                         if ((i >= 14) || (!server->noblocksnd && (i > 2))) {
180                                 cERROR(1, "sends on sock %p stuck for 15 seconds",
181                                     ssocket);
182                                 rc = -EAGAIN;
183                                 break;
184                         }
185                         msleep(1 << i);
186                         continue;
187                 }
188                 if (rc < 0)
189                         break;
190
191                 if (rc == total_len) {
192                         total_len = 0;
193                         break;
194                 } else if (rc > total_len) {
195                         cERROR(1, "sent %d requested %d", rc, total_len);
196                         break;
197                 }
198                 if (rc == 0) {
199                         /* should never happen, letting socket clear before
200                            retrying is our only obvious option here */
201                         cERROR(1, "tcp sent no data");
202                         msleep(500);
203                         continue;
204                 }
205                 total_len -= rc;
206                 /* the line below resets i */
207                 for (i = first_vec; i < n_vec; i++) {
208                         if (iov[i].iov_len) {
209                                 if (rc > iov[i].iov_len) {
210                                         rc -= iov[i].iov_len;
211                                         iov[i].iov_len = 0;
212                                 } else {
213                                         iov[i].iov_base += rc;
214                                         iov[i].iov_len -= rc;
215                                         first_vec = i;
216                                         break;
217                                 }
218                         }
219                 }
220                 i = 0; /* in case we get ENOSPC on the next send */
221         }
222
223         if ((total_len > 0) && (total_len != smb_buf_length + 4)) {
224                 cFYI(1, "partial send (%d remaining), terminating session",
225                         total_len);
226                 /* If we have only sent part of an SMB then the next SMB
227                    could be taken as the remainder of this one.  We need
228                    to kill the socket so the server throws away the partial
229                    SMB */
230                 server->tcpStatus = CifsNeedReconnect;
231         }
232
233         if (rc < 0 && rc != -EINTR)
234                 cERROR(1, "Error %d sending data on socket to server", rc);
235         else
236                 rc = 0;
237
238         /* Don't want to modify the buffer as a
239            side effect of this call. */
240         smb_buffer->smb_buf_length = cpu_to_be32(smb_buf_length);
241
242         return rc;
243 }
244
245 int
246 smb_send(struct TCP_Server_Info *server, struct smb_hdr *smb_buffer,
247          unsigned int smb_buf_length)
248 {
249         struct kvec iov;
250
251         iov.iov_base = smb_buffer;
252         iov.iov_len = smb_buf_length + 4;
253
254         return smb_sendv(server, &iov, 1);
255 }
256
257 static int wait_for_free_request(struct TCP_Server_Info *server,
258                                  const int long_op)
259 {
260         if (long_op == CIFS_ASYNC_OP) {
261                 /* oplock breaks must not be held up */
262                 atomic_inc(&server->inFlight);
263                 return 0;
264         }
265
266         spin_lock(&GlobalMid_Lock);
267         while (1) {
268                 if (atomic_read(&server->inFlight) >= cifs_max_pending) {
269                         spin_unlock(&GlobalMid_Lock);
270                         cifs_num_waiters_inc(server);
271                         wait_event(server->request_q,
272                                    atomic_read(&server->inFlight)
273                                      < cifs_max_pending);
274                         cifs_num_waiters_dec(server);
275                         spin_lock(&GlobalMid_Lock);
276                 } else {
277                         if (server->tcpStatus == CifsExiting) {
278                                 spin_unlock(&GlobalMid_Lock);
279                                 return -ENOENT;
280                         }
281
282                         /* can not count locking commands against total
283                            as they are allowed to block on server */
284
285                         /* update # of requests on the wire to server */
286                         if (long_op != CIFS_BLOCKING_OP)
287                                 atomic_inc(&server->inFlight);
288                         spin_unlock(&GlobalMid_Lock);
289                         break;
290                 }
291         }
292         return 0;
293 }
294
295 static int allocate_mid(struct cifs_ses *ses, struct smb_hdr *in_buf,
296                         struct mid_q_entry **ppmidQ)
297 {
298         if (ses->server->tcpStatus == CifsExiting) {
299                 return -ENOENT;
300         }
301
302         if (ses->server->tcpStatus == CifsNeedReconnect) {
303                 cFYI(1, "tcp session dead - return to caller to retry");
304                 return -EAGAIN;
305         }
306
307         if (ses->status != CifsGood) {
308                 /* check if SMB session is bad because we are setting it up */
309                 if ((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
310                         (in_buf->Command != SMB_COM_NEGOTIATE))
311                         return -EAGAIN;
312                 /* else ok - we are setting up session */
313         }
314         *ppmidQ = AllocMidQEntry(in_buf, ses->server);
315         if (*ppmidQ == NULL)
316                 return -ENOMEM;
317         spin_lock(&GlobalMid_Lock);
318         list_add_tail(&(*ppmidQ)->qhead, &ses->server->pending_mid_q);
319         spin_unlock(&GlobalMid_Lock);
320         return 0;
321 }
322
323 static int
324 wait_for_response(struct TCP_Server_Info *server, struct mid_q_entry *midQ)
325 {
326         int error;
327
328         error = wait_event_freezekillable(server->response_q,
329                                     midQ->midState != MID_REQUEST_SUBMITTED);
330         if (error < 0)
331                 return -ERESTARTSYS;
332
333         return 0;
334 }
335
336
337 /*
338  * Send a SMB request and set the callback function in the mid to handle
339  * the result. Caller is responsible for dealing with timeouts.
340  */
341 int
342 cifs_call_async(struct TCP_Server_Info *server, struct kvec *iov,
343                 unsigned int nvec, mid_receive_t *receive,
344                 mid_callback_t *callback, void *cbdata, bool ignore_pend)
345 {
346         int rc;
347         struct mid_q_entry *mid;
348         struct smb_hdr *hdr = (struct smb_hdr *)iov[0].iov_base;
349
350         rc = wait_for_free_request(server, ignore_pend ? CIFS_ASYNC_OP : 0);
351         if (rc)
352                 return rc;
353
354         /* enable signing if server requires it */
355         if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
356                 hdr->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
357
358         mutex_lock(&server->srv_mutex);
359         mid = AllocMidQEntry(hdr, server);
360         if (mid == NULL) {
361                 mutex_unlock(&server->srv_mutex);
362                 atomic_dec(&server->inFlight);
363                 wake_up(&server->request_q);
364                 return -ENOMEM;
365         }
366
367         /* put it on the pending_mid_q */
368         spin_lock(&GlobalMid_Lock);
369         list_add_tail(&mid->qhead, &server->pending_mid_q);
370         spin_unlock(&GlobalMid_Lock);
371
372         rc = cifs_sign_smb2(iov, nvec, server, &mid->sequence_number);
373         if (rc) {
374                 mutex_unlock(&server->srv_mutex);
375                 goto out_err;
376         }
377
378         mid->receive = receive;
379         mid->callback = callback;
380         mid->callback_data = cbdata;
381         mid->midState = MID_REQUEST_SUBMITTED;
382
383         cifs_in_send_inc(server);
384         rc = smb_sendv(server, iov, nvec);
385         cifs_in_send_dec(server);
386         cifs_save_when_sent(mid);
387         mutex_unlock(&server->srv_mutex);
388
389         if (rc)
390                 goto out_err;
391
392         return rc;
393 out_err:
394         delete_mid(mid);
395         atomic_dec(&server->inFlight);
396         wake_up(&server->request_q);
397         return rc;
398 }
399
400 /*
401  *
402  * Send an SMB Request.  No response info (other than return code)
403  * needs to be parsed.
404  *
405  * flags indicate the type of request buffer and how long to wait
406  * and whether to log NT STATUS code (error) before mapping it to POSIX error
407  *
408  */
409 int
410 SendReceiveNoRsp(const unsigned int xid, struct cifs_ses *ses,
411                 struct smb_hdr *in_buf, int flags)
412 {
413         int rc;
414         struct kvec iov[1];
415         int resp_buf_type;
416
417         iov[0].iov_base = (char *)in_buf;
418         iov[0].iov_len = be32_to_cpu(in_buf->smb_buf_length) + 4;
419         flags |= CIFS_NO_RESP;
420         rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags);
421         cFYI(DBG2, "SendRcvNoRsp flags %d rc %d", flags, rc);
422
423         return rc;
424 }
425
426 static int
427 cifs_sync_mid_result(struct mid_q_entry *mid, struct TCP_Server_Info *server)
428 {
429         int rc = 0;
430
431         cFYI(1, "%s: cmd=%d mid=%d state=%d", __func__, mid->command,
432                 mid->mid, mid->midState);
433
434         spin_lock(&GlobalMid_Lock);
435         switch (mid->midState) {
436         case MID_RESPONSE_RECEIVED:
437                 spin_unlock(&GlobalMid_Lock);
438                 return rc;
439         case MID_RETRY_NEEDED:
440                 rc = -EAGAIN;
441                 break;
442         case MID_RESPONSE_MALFORMED:
443                 rc = -EIO;
444                 break;
445         case MID_SHUTDOWN:
446                 rc = -EHOSTDOWN;
447                 break;
448         default:
449                 list_del_init(&mid->qhead);
450                 cERROR(1, "%s: invalid mid state mid=%d state=%d", __func__,
451                         mid->mid, mid->midState);
452                 rc = -EIO;
453         }
454         spin_unlock(&GlobalMid_Lock);
455
456         DeleteMidQEntry(mid);
457         return rc;
458 }
459
460 /*
461  * An NT cancel request header looks just like the original request except:
462  *
463  * The Command is SMB_COM_NT_CANCEL
464  * The WordCount is zeroed out
465  * The ByteCount is zeroed out
466  *
467  * This function mangles an existing request buffer into a
468  * SMB_COM_NT_CANCEL request and then sends it.
469  */
470 static int
471 send_nt_cancel(struct TCP_Server_Info *server, struct smb_hdr *in_buf,
472                 struct mid_q_entry *mid)
473 {
474         int rc = 0;
475
476         /* -4 for RFC1001 length and +2 for BCC field */
477         in_buf->smb_buf_length = cpu_to_be32(sizeof(struct smb_hdr) - 4  + 2);
478         in_buf->Command = SMB_COM_NT_CANCEL;
479         in_buf->WordCount = 0;
480         put_bcc(0, in_buf);
481
482         mutex_lock(&server->srv_mutex);
483         rc = cifs_sign_smb(in_buf, server, &mid->sequence_number);
484         if (rc) {
485                 mutex_unlock(&server->srv_mutex);
486                 return rc;
487         }
488         rc = smb_send(server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
489         mutex_unlock(&server->srv_mutex);
490
491         cFYI(1, "issued NT_CANCEL for mid %u, rc = %d",
492                 in_buf->Mid, rc);
493
494         return rc;
495 }
496
497 int
498 cifs_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,
499                    bool log_error)
500 {
501         unsigned int len = be32_to_cpu(mid->resp_buf->smb_buf_length) + 4;
502
503         dump_smb(mid->resp_buf, min_t(u32, 92, len));
504
505         /* convert the length into a more usable form */
506         if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
507                 struct kvec iov;
508
509                 iov.iov_base = mid->resp_buf;
510                 iov.iov_len = len;
511                 /* FIXME: add code to kill session */
512                 if (cifs_verify_signature(&iov, 1, server,
513                                           mid->sequence_number + 1) != 0)
514                         cERROR(1, "Unexpected SMB signature");
515         }
516
517         /* BB special case reconnect tid and uid here? */
518         return map_smb_to_linux_error(mid->resp_buf, log_error);
519 }
520
521 int
522 SendReceive2(const unsigned int xid, struct cifs_ses *ses,
523              struct kvec *iov, int n_vec, int *pRespBufType /* ret */,
524              const int flags)
525 {
526         int rc = 0;
527         int long_op;
528         struct mid_q_entry *midQ;
529         struct smb_hdr *in_buf = iov[0].iov_base;
530
531         long_op = flags & CIFS_TIMEOUT_MASK;
532
533         *pRespBufType = CIFS_NO_BUFFER;  /* no response buf yet */
534
535         if ((ses == NULL) || (ses->server == NULL)) {
536                 cifs_small_buf_release(in_buf);
537                 cERROR(1, "Null session");
538                 return -EIO;
539         }
540
541         if (ses->server->tcpStatus == CifsExiting) {
542                 cifs_small_buf_release(in_buf);
543                 return -ENOENT;
544         }
545
546         /* Ensure that we do not send more than 50 overlapping requests
547            to the same server. We may make this configurable later or
548            use ses->maxReq */
549
550         rc = wait_for_free_request(ses->server, long_op);
551         if (rc) {
552                 cifs_small_buf_release(in_buf);
553                 return rc;
554         }
555
556         /* make sure that we sign in the same order that we send on this socket
557            and avoid races inside tcp sendmsg code that could cause corruption
558            of smb data */
559
560         mutex_lock(&ses->server->srv_mutex);
561
562         rc = allocate_mid(ses, in_buf, &midQ);
563         if (rc) {
564                 mutex_unlock(&ses->server->srv_mutex);
565                 cifs_small_buf_release(in_buf);
566                 /* Update # of requests on wire to server */
567                 atomic_dec(&ses->server->inFlight);
568                 wake_up(&ses->server->request_q);
569                 return rc;
570         }
571         rc = cifs_sign_smb2(iov, n_vec, ses->server, &midQ->sequence_number);
572         if (rc) {
573                 mutex_unlock(&ses->server->srv_mutex);
574                 cifs_small_buf_release(in_buf);
575                 goto out;
576         }
577
578         midQ->midState = MID_REQUEST_SUBMITTED;
579         cifs_in_send_inc(ses->server);
580         rc = smb_sendv(ses->server, iov, n_vec);
581         cifs_in_send_dec(ses->server);
582         cifs_save_when_sent(midQ);
583
584         mutex_unlock(&ses->server->srv_mutex);
585
586         if (rc < 0) {
587                 cifs_small_buf_release(in_buf);
588                 goto out;
589         }
590
591         if (long_op == CIFS_ASYNC_OP) {
592                 cifs_small_buf_release(in_buf);
593                 goto out;
594         }
595
596         rc = wait_for_response(ses->server, midQ);
597         if (rc != 0) {
598                 send_nt_cancel(ses->server, in_buf, midQ);
599                 spin_lock(&GlobalMid_Lock);
600                 if (midQ->midState == MID_REQUEST_SUBMITTED) {
601                         midQ->callback = DeleteMidQEntry;
602                         spin_unlock(&GlobalMid_Lock);
603                         cifs_small_buf_release(in_buf);
604                         atomic_dec(&ses->server->inFlight);
605                         wake_up(&ses->server->request_q);
606                         return rc;
607                 }
608                 spin_unlock(&GlobalMid_Lock);
609         }
610
611         cifs_small_buf_release(in_buf);
612
613         rc = cifs_sync_mid_result(midQ, ses->server);
614         if (rc != 0) {
615                 atomic_dec(&ses->server->inFlight);
616                 wake_up(&ses->server->request_q);
617                 return rc;
618         }
619
620         if (!midQ->resp_buf || midQ->midState != MID_RESPONSE_RECEIVED) {
621                 rc = -EIO;
622                 cFYI(1, "Bad MID state?");
623                 goto out;
624         }
625
626         iov[0].iov_base = (char *)midQ->resp_buf;
627         iov[0].iov_len = be32_to_cpu(midQ->resp_buf->smb_buf_length) + 4;
628         if (midQ->largeBuf)
629                 *pRespBufType = CIFS_LARGE_BUFFER;
630         else
631                 *pRespBufType = CIFS_SMALL_BUFFER;
632
633         rc = cifs_check_receive(midQ, ses->server, flags & CIFS_LOG_ERROR);
634
635         /* mark it so buf will not be freed by delete_mid */
636         if ((flags & CIFS_NO_RESP) == 0)
637                 midQ->resp_buf = NULL;
638 out:
639         delete_mid(midQ);
640         atomic_dec(&ses->server->inFlight);
641         wake_up(&ses->server->request_q);
642
643         return rc;
644 }
645
646 int
647 SendReceive(const unsigned int xid, struct cifs_ses *ses,
648             struct smb_hdr *in_buf, struct smb_hdr *out_buf,
649             int *pbytes_returned, const int long_op)
650 {
651         int rc = 0;
652         struct mid_q_entry *midQ;
653
654         if (ses == NULL) {
655                 cERROR(1, "Null smb session");
656                 return -EIO;
657         }
658         if (ses->server == NULL) {
659                 cERROR(1, "Null tcp session");
660                 return -EIO;
661         }
662
663         if (ses->server->tcpStatus == CifsExiting)
664                 return -ENOENT;
665
666         /* Ensure that we do not send more than 50 overlapping requests
667            to the same server. We may make this configurable later or
668            use ses->maxReq */
669
670         if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
671                         MAX_CIFS_HDR_SIZE - 4) {
672                 cERROR(1, "Illegal length, greater than maximum frame, %d",
673                            be32_to_cpu(in_buf->smb_buf_length));
674                 return -EIO;
675         }
676
677         rc = wait_for_free_request(ses->server, long_op);
678         if (rc)
679                 return rc;
680
681         /* make sure that we sign in the same order that we send on this socket
682            and avoid races inside tcp sendmsg code that could cause corruption
683            of smb data */
684
685         mutex_lock(&ses->server->srv_mutex);
686
687         rc = allocate_mid(ses, in_buf, &midQ);
688         if (rc) {
689                 mutex_unlock(&ses->server->srv_mutex);
690                 /* Update # of requests on wire to server */
691                 atomic_dec(&ses->server->inFlight);
692                 wake_up(&ses->server->request_q);
693                 return rc;
694         }
695
696         rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
697         if (rc) {
698                 mutex_unlock(&ses->server->srv_mutex);
699                 goto out;
700         }
701
702         midQ->midState = MID_REQUEST_SUBMITTED;
703
704         cifs_in_send_inc(ses->server);
705         rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
706         cifs_in_send_dec(ses->server);
707         cifs_save_when_sent(midQ);
708         mutex_unlock(&ses->server->srv_mutex);
709
710         if (rc < 0)
711                 goto out;
712
713         if (long_op == CIFS_ASYNC_OP)
714                 goto out;
715
716         rc = wait_for_response(ses->server, midQ);
717         if (rc != 0) {
718                 send_nt_cancel(ses->server, in_buf, midQ);
719                 spin_lock(&GlobalMid_Lock);
720                 if (midQ->midState == MID_REQUEST_SUBMITTED) {
721                         /* no longer considered to be "in-flight" */
722                         midQ->callback = DeleteMidQEntry;
723                         spin_unlock(&GlobalMid_Lock);
724                         atomic_dec(&ses->server->inFlight);
725                         wake_up(&ses->server->request_q);
726                         return rc;
727                 }
728                 spin_unlock(&GlobalMid_Lock);
729         }
730
731         rc = cifs_sync_mid_result(midQ, ses->server);
732         if (rc != 0) {
733                 atomic_dec(&ses->server->inFlight);
734                 wake_up(&ses->server->request_q);
735                 return rc;
736         }
737
738         if (!midQ->resp_buf || !out_buf ||
739             midQ->midState != MID_RESPONSE_RECEIVED) {
740                 rc = -EIO;
741                 cERROR(1, "Bad MID state?");
742                 goto out;
743         }
744
745         *pbytes_returned = be32_to_cpu(midQ->resp_buf->smb_buf_length);
746         memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
747         rc = cifs_check_receive(midQ, ses->server, 0);
748 out:
749         delete_mid(midQ);
750         atomic_dec(&ses->server->inFlight);
751         wake_up(&ses->server->request_q);
752
753         return rc;
754 }
755
756 /* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
757    blocking lock to return. */
758
759 static int
760 send_lock_cancel(const unsigned int xid, struct cifs_tcon *tcon,
761                         struct smb_hdr *in_buf,
762                         struct smb_hdr *out_buf)
763 {
764         int bytes_returned;
765         struct cifs_ses *ses = tcon->ses;
766         LOCK_REQ *pSMB = (LOCK_REQ *)in_buf;
767
768         /* We just modify the current in_buf to change
769            the type of lock from LOCKING_ANDX_SHARED_LOCK
770            or LOCKING_ANDX_EXCLUSIVE_LOCK to
771            LOCKING_ANDX_CANCEL_LOCK. */
772
773         pSMB->LockType = LOCKING_ANDX_CANCEL_LOCK|LOCKING_ANDX_LARGE_FILES;
774         pSMB->Timeout = 0;
775         pSMB->hdr.Mid = GetNextMid(ses->server);
776
777         return SendReceive(xid, ses, in_buf, out_buf,
778                         &bytes_returned, 0);
779 }
780
781 int
782 SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
783             struct smb_hdr *in_buf, struct smb_hdr *out_buf,
784             int *pbytes_returned)
785 {
786         int rc = 0;
787         int rstart = 0;
788         struct mid_q_entry *midQ;
789         struct cifs_ses *ses;
790
791         if (tcon == NULL || tcon->ses == NULL) {
792                 cERROR(1, "Null smb session");
793                 return -EIO;
794         }
795         ses = tcon->ses;
796
797         if (ses->server == NULL) {
798                 cERROR(1, "Null tcp session");
799                 return -EIO;
800         }
801
802         if (ses->server->tcpStatus == CifsExiting)
803                 return -ENOENT;
804
805         /* Ensure that we do not send more than 50 overlapping requests
806            to the same server. We may make this configurable later or
807            use ses->maxReq */
808
809         if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
810                         MAX_CIFS_HDR_SIZE - 4) {
811                 cERROR(1, "Illegal length, greater than maximum frame, %d",
812                            be32_to_cpu(in_buf->smb_buf_length));
813                 return -EIO;
814         }
815
816         rc = wait_for_free_request(ses->server, CIFS_BLOCKING_OP);
817         if (rc)
818                 return rc;
819
820         /* make sure that we sign in the same order that we send on this socket
821            and avoid races inside tcp sendmsg code that could cause corruption
822            of smb data */
823
824         mutex_lock(&ses->server->srv_mutex);
825
826         rc = allocate_mid(ses, in_buf, &midQ);
827         if (rc) {
828                 mutex_unlock(&ses->server->srv_mutex);
829                 return rc;
830         }
831
832         rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
833         if (rc) {
834                 delete_mid(midQ);
835                 mutex_unlock(&ses->server->srv_mutex);
836                 return rc;
837         }
838
839         midQ->midState = MID_REQUEST_SUBMITTED;
840         cifs_in_send_inc(ses->server);
841         rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
842         cifs_in_send_dec(ses->server);
843         cifs_save_when_sent(midQ);
844         mutex_unlock(&ses->server->srv_mutex);
845
846         if (rc < 0) {
847                 delete_mid(midQ);
848                 return rc;
849         }
850
851         /* Wait for a reply - allow signals to interrupt. */
852         rc = wait_event_interruptible(ses->server->response_q,
853                 (!(midQ->midState == MID_REQUEST_SUBMITTED)) ||
854                 ((ses->server->tcpStatus != CifsGood) &&
855                  (ses->server->tcpStatus != CifsNew)));
856
857         /* Were we interrupted by a signal ? */
858         if ((rc == -ERESTARTSYS) &&
859                 (midQ->midState == MID_REQUEST_SUBMITTED) &&
860                 ((ses->server->tcpStatus == CifsGood) ||
861                  (ses->server->tcpStatus == CifsNew))) {
862
863                 if (in_buf->Command == SMB_COM_TRANSACTION2) {
864                         /* POSIX lock. We send a NT_CANCEL SMB to cause the
865                            blocking lock to return. */
866                         rc = send_nt_cancel(ses->server, in_buf, midQ);
867                         if (rc) {
868                                 delete_mid(midQ);
869                                 return rc;
870                         }
871                 } else {
872                         /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
873                            to cause the blocking lock to return. */
874
875                         rc = send_lock_cancel(xid, tcon, in_buf, out_buf);
876
877                         /* If we get -ENOLCK back the lock may have
878                            already been removed. Don't exit in this case. */
879                         if (rc && rc != -ENOLCK) {
880                                 delete_mid(midQ);
881                                 return rc;
882                         }
883                 }
884
885                 rc = wait_for_response(ses->server, midQ);
886                 if (rc) {
887                         send_nt_cancel(ses->server, in_buf, midQ);
888                         spin_lock(&GlobalMid_Lock);
889                         if (midQ->midState == MID_REQUEST_SUBMITTED) {
890                                 /* no longer considered to be "in-flight" */
891                                 midQ->callback = DeleteMidQEntry;
892                                 spin_unlock(&GlobalMid_Lock);
893                                 return rc;
894                         }
895                         spin_unlock(&GlobalMid_Lock);
896                 }
897
898                 /* We got the response - restart system call. */
899                 rstart = 1;
900         }
901
902         rc = cifs_sync_mid_result(midQ, ses->server);
903         if (rc != 0)
904                 return rc;
905
906         /* rcvd frame is ok */
907         if (out_buf == NULL || midQ->midState != MID_RESPONSE_RECEIVED) {
908                 rc = -EIO;
909                 cERROR(1, "Bad MID state?");
910                 goto out;
911         }
912
913         *pbytes_returned = be32_to_cpu(midQ->resp_buf->smb_buf_length);
914         memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
915         rc = cifs_check_receive(midQ, ses->server, 0);
916 out:
917         delete_mid(midQ);
918         if (rstart && rc == -EACCES)
919                 return -ERESTARTSYS;
920         return rc;
921 }