Merge branch 'upstream-davem' of master.kernel.org:/pub/scm/linux/kernel/git/jgarzik...
[linux-2.6] / 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/wait.h>
26 #include <linux/net.h>
27 #include <linux/delay.h>
28 #include <asm/uaccess.h>
29 #include <asm/processor.h>
30 #include <linux/mempool.h>
31 #include "cifspdu.h"
32 #include "cifsglob.h"
33 #include "cifsproto.h"
34 #include "cifs_debug.h"
35
36 extern mempool_t *cifs_mid_poolp;
37 extern struct kmem_cache *cifs_oplock_cachep;
38
39 static struct mid_q_entry *
40 AllocMidQEntry(const struct smb_hdr *smb_buffer, struct cifsSesInfo *ses)
41 {
42         struct mid_q_entry *temp;
43
44         if (ses == NULL) {
45                 cERROR(1, ("Null session passed in to AllocMidQEntry"));
46                 return NULL;
47         }
48         if (ses->server == NULL) {
49                 cERROR(1, ("Null TCP session in AllocMidQEntry"));
50                 return NULL;
51         }
52
53         temp = (struct mid_q_entry *) mempool_alloc(cifs_mid_poolp,
54                                                     GFP_KERNEL | GFP_NOFS);
55         if (temp == NULL)
56                 return temp;
57         else {
58                 memset(temp, 0, sizeof(struct mid_q_entry));
59                 temp->mid = smb_buffer->Mid;    /* always LE */
60                 temp->pid = current->pid;
61                 temp->command = smb_buffer->Command;
62                 cFYI(1, ("For smb_command %d", temp->command));
63         /*      do_gettimeofday(&temp->when_sent);*/ /* easier to use jiffies */
64                 /* when mid allocated can be before when sent */
65                 temp->when_alloc = jiffies;
66                 temp->ses = ses;
67                 temp->tsk = current;
68         }
69
70         spin_lock(&GlobalMid_Lock);
71         list_add_tail(&temp->qhead, &ses->server->pending_mid_q);
72         atomic_inc(&midCount);
73         temp->midState = MID_REQUEST_ALLOCATED;
74         spin_unlock(&GlobalMid_Lock);
75         return temp;
76 }
77
78 static void
79 DeleteMidQEntry(struct mid_q_entry *midEntry)
80 {
81 #ifdef CONFIG_CIFS_STATS2
82         unsigned long now;
83 #endif
84         spin_lock(&GlobalMid_Lock);
85         midEntry->midState = MID_FREE;
86         list_del(&midEntry->qhead);
87         atomic_dec(&midCount);
88         spin_unlock(&GlobalMid_Lock);
89         if (midEntry->largeBuf)
90                 cifs_buf_release(midEntry->resp_buf);
91         else
92                 cifs_small_buf_release(midEntry->resp_buf);
93 #ifdef CONFIG_CIFS_STATS2
94         now = jiffies;
95         /* commands taking longer than one second are indications that
96            something is wrong, unless it is quite a slow link or server */
97         if ((now - midEntry->when_alloc) > HZ) {
98                 if ((cifsFYI & CIFS_TIMER) &&
99                    (midEntry->command != SMB_COM_LOCKING_ANDX)) {
100                         printk(KERN_DEBUG " CIFS slow rsp: cmd %d mid %d",
101                                midEntry->command, midEntry->mid);
102                         printk(" A: 0x%lx S: 0x%lx R: 0x%lx\n",
103                                now - midEntry->when_alloc,
104                                now - midEntry->when_sent,
105                                now - midEntry->when_received);
106                 }
107         }
108 #endif
109         mempool_free(midEntry, cifs_mid_poolp);
110 }
111
112 struct oplock_q_entry *
113 AllocOplockQEntry(struct inode *pinode, __u16 fid, struct cifsTconInfo *tcon)
114 {
115         struct oplock_q_entry *temp;
116         if ((pinode == NULL) || (tcon == NULL)) {
117                 cERROR(1, ("Null parms passed to AllocOplockQEntry"));
118                 return NULL;
119         }
120         temp = (struct oplock_q_entry *) kmem_cache_alloc(cifs_oplock_cachep,
121                                                        GFP_KERNEL);
122         if (temp == NULL)
123                 return temp;
124         else {
125                 temp->pinode = pinode;
126                 temp->tcon = tcon;
127                 temp->netfid = fid;
128                 spin_lock(&GlobalMid_Lock);
129                 list_add_tail(&temp->qhead, &GlobalOplock_Q);
130                 spin_unlock(&GlobalMid_Lock);
131         }
132         return temp;
133
134 }
135
136 void DeleteOplockQEntry(struct oplock_q_entry *oplockEntry)
137 {
138         spin_lock(&GlobalMid_Lock);
139     /* should we check if list empty first? */
140         list_del(&oplockEntry->qhead);
141         spin_unlock(&GlobalMid_Lock);
142         kmem_cache_free(cifs_oplock_cachep, oplockEntry);
143 }
144
145
146 void DeleteTconOplockQEntries(struct cifsTconInfo *tcon)
147 {
148         struct oplock_q_entry *temp;
149
150         if (tcon == NULL)
151                 return;
152
153         spin_lock(&GlobalMid_Lock);
154         list_for_each_entry(temp, &GlobalOplock_Q, qhead) {
155                 if ((temp->tcon) && (temp->tcon == tcon)) {
156                         list_del(&temp->qhead);
157                         kmem_cache_free(cifs_oplock_cachep, temp);
158                 }
159         }
160         spin_unlock(&GlobalMid_Lock);
161 }
162
163 int
164 smb_send(struct socket *ssocket, struct smb_hdr *smb_buffer,
165          unsigned int smb_buf_length, struct sockaddr *sin)
166 {
167         int rc = 0;
168         int i = 0;
169         struct msghdr smb_msg;
170         struct kvec iov;
171         unsigned len = smb_buf_length + 4;
172
173         if (ssocket == NULL)
174                 return -ENOTSOCK; /* BB eventually add reconnect code here */
175         iov.iov_base = smb_buffer;
176         iov.iov_len = len;
177
178         smb_msg.msg_name = sin;
179         smb_msg.msg_namelen = sizeof(struct sockaddr);
180         smb_msg.msg_control = NULL;
181         smb_msg.msg_controllen = 0;
182         smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL; /* BB add more flags?*/
183
184         /* smb header is converted in header_assemble. bcc and rest of SMB word
185            area, and byte area if necessary, is converted to littleendian in
186            cifssmb.c and RFC1001 len is converted to bigendian in smb_send
187            Flags2 is converted in SendReceive */
188
189         smb_buffer->smb_buf_length = cpu_to_be32(smb_buffer->smb_buf_length);
190         cFYI(1, ("Sending smb of length %d", smb_buf_length));
191         dump_smb(smb_buffer, len);
192
193         while (len > 0) {
194                 rc = kernel_sendmsg(ssocket, &smb_msg, &iov, 1, len);
195                 if ((rc == -ENOSPC) || (rc == -EAGAIN)) {
196                         i++;
197                 /* smaller timeout here than send2 since smaller size */
198                 /* Although it may not be required, this also is smaller
199                    oplock break time */
200                         if (i > 12) {
201                                 cERROR(1,
202                                    ("sends on sock %p stuck for 7 seconds",
203                                     ssocket));
204                                 rc = -EAGAIN;
205                                 break;
206                         }
207                         msleep(1 << i);
208                         continue;
209                 }
210                 if (rc < 0)
211                         break;
212                 else
213                         i = 0; /* reset i after each successful send */
214                 iov.iov_base += rc;
215                 iov.iov_len -= rc;
216                 len -= rc;
217         }
218
219         if (rc < 0) {
220                 cERROR(1, ("Error %d sending data on socket to server", rc));
221         } else {
222                 rc = 0;
223         }
224
225         /* Don't want to modify the buffer as a
226            side effect of this call. */
227         smb_buffer->smb_buf_length = smb_buf_length;
228
229         return rc;
230 }
231
232 static int
233 smb_send2(struct socket *ssocket, struct kvec *iov, int n_vec,
234           struct sockaddr *sin)
235 {
236         int rc = 0;
237         int i = 0;
238         struct msghdr smb_msg;
239         struct smb_hdr *smb_buffer = iov[0].iov_base;
240         unsigned int len = iov[0].iov_len;
241         unsigned int total_len;
242         int first_vec = 0;
243         unsigned int smb_buf_length = smb_buffer->smb_buf_length;
244
245         if (ssocket == NULL)
246                 return -ENOTSOCK; /* BB eventually add reconnect code here */
247
248         smb_msg.msg_name = sin;
249         smb_msg.msg_namelen = sizeof(struct sockaddr);
250         smb_msg.msg_control = NULL;
251         smb_msg.msg_controllen = 0;
252         smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL; /* BB add more flags?*/
253
254         /* smb header is converted in header_assemble. bcc and rest of SMB word
255            area, and byte area if necessary, is converted to littleendian in
256            cifssmb.c and RFC1001 len is converted to bigendian in smb_send
257            Flags2 is converted in SendReceive */
258
259
260         total_len = 0;
261         for (i = 0; i < n_vec; i++)
262                 total_len += iov[i].iov_len;
263
264         smb_buffer->smb_buf_length = cpu_to_be32(smb_buffer->smb_buf_length);
265         cFYI(1, ("Sending smb:  total_len %d", total_len));
266         dump_smb(smb_buffer, len);
267
268         i = 0;
269         while (total_len) {
270                 rc = kernel_sendmsg(ssocket, &smb_msg, &iov[first_vec],
271                                     n_vec - first_vec, total_len);
272                 if ((rc == -ENOSPC) || (rc == -EAGAIN)) {
273                         i++;
274                         if (i >= 14) {
275                                 cERROR(1,
276                                    ("sends on sock %p stuck for 15 seconds",
277                                     ssocket));
278                                 rc = -EAGAIN;
279                                 break;
280                         }
281                         msleep(1 << i);
282                         continue;
283                 }
284                 if (rc < 0)
285                         break;
286
287                 if (rc >= total_len) {
288                         WARN_ON(rc > total_len);
289                         break;
290                 }
291                 if (rc == 0) {
292                         /* should never happen, letting socket clear before
293                            retrying is our only obvious option here */
294                         cERROR(1, ("tcp sent no data"));
295                         msleep(500);
296                         continue;
297                 }
298                 total_len -= rc;
299                 /* the line below resets i */
300                 for (i = first_vec; i < n_vec; i++) {
301                         if (iov[i].iov_len) {
302                                 if (rc > iov[i].iov_len) {
303                                         rc -= iov[i].iov_len;
304                                         iov[i].iov_len = 0;
305                                 } else {
306                                         iov[i].iov_base += rc;
307                                         iov[i].iov_len -= rc;
308                                         first_vec = i;
309                                         break;
310                                 }
311                         }
312                 }
313                 i = 0; /* in case we get ENOSPC on the next send */
314         }
315
316         if (rc < 0) {
317                 cERROR(1, ("Error %d sending data on socket to server", rc));
318         } else
319                 rc = 0;
320
321         /* Don't want to modify the buffer as a
322            side effect of this call. */
323         smb_buffer->smb_buf_length = smb_buf_length;
324
325         return rc;
326 }
327
328 static int wait_for_free_request(struct cifsSesInfo *ses, const int long_op)
329 {
330         if (long_op == CIFS_ASYNC_OP) {
331                 /* oplock breaks must not be held up */
332                 atomic_inc(&ses->server->inFlight);
333         } else {
334                 spin_lock(&GlobalMid_Lock);
335                 while (1) {
336                         if (atomic_read(&ses->server->inFlight) >=
337                                         cifs_max_pending){
338                                 spin_unlock(&GlobalMid_Lock);
339 #ifdef CONFIG_CIFS_STATS2
340                                 atomic_inc(&ses->server->num_waiters);
341 #endif
342                                 wait_event(ses->server->request_q,
343                                         atomic_read(&ses->server->inFlight)
344                                          < cifs_max_pending);
345 #ifdef CONFIG_CIFS_STATS2
346                                 atomic_dec(&ses->server->num_waiters);
347 #endif
348                                 spin_lock(&GlobalMid_Lock);
349                         } else {
350                                 if (ses->server->tcpStatus == CifsExiting) {
351                                         spin_unlock(&GlobalMid_Lock);
352                                         return -ENOENT;
353                                 }
354
355                                 /* can not count locking commands against total
356                                    as they are allowed to block on server */
357
358                                 /* update # of requests on the wire to server */
359                                 if (long_op != CIFS_BLOCKING_OP)
360                                         atomic_inc(&ses->server->inFlight);
361                                 spin_unlock(&GlobalMid_Lock);
362                                 break;
363                         }
364                 }
365         }
366         return 0;
367 }
368
369 static int allocate_mid(struct cifsSesInfo *ses, struct smb_hdr *in_buf,
370                         struct mid_q_entry **ppmidQ)
371 {
372         if (ses->server->tcpStatus == CifsExiting) {
373                 return -ENOENT;
374         } else if (ses->server->tcpStatus == CifsNeedReconnect) {
375                 cFYI(1, ("tcp session dead - return to caller to retry"));
376                 return -EAGAIN;
377         } else if (ses->status != CifsGood) {
378                 /* check if SMB session is bad because we are setting it up */
379                 if ((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
380                         (in_buf->Command != SMB_COM_NEGOTIATE))
381                         return -EAGAIN;
382                 /* else ok - we are setting up session */
383         }
384         *ppmidQ = AllocMidQEntry(in_buf, ses);
385         if (*ppmidQ == NULL)
386                 return -ENOMEM;
387         return 0;
388 }
389
390 static int wait_for_response(struct cifsSesInfo *ses,
391                         struct mid_q_entry *midQ,
392                         unsigned long timeout,
393                         unsigned long time_to_wait)
394 {
395         unsigned long curr_timeout;
396
397         for (;;) {
398                 curr_timeout = timeout + jiffies;
399                 wait_event(ses->server->response_q,
400                         (!(midQ->midState == MID_REQUEST_SUBMITTED)) ||
401                         time_after(jiffies, curr_timeout) ||
402                         ((ses->server->tcpStatus != CifsGood) &&
403                          (ses->server->tcpStatus != CifsNew)));
404
405                 if (time_after(jiffies, curr_timeout) &&
406                         (midQ->midState == MID_REQUEST_SUBMITTED) &&
407                         ((ses->server->tcpStatus == CifsGood) ||
408                          (ses->server->tcpStatus == CifsNew))) {
409
410                         unsigned long lrt;
411
412                         /* We timed out. Is the server still
413                            sending replies ? */
414                         spin_lock(&GlobalMid_Lock);
415                         lrt = ses->server->lstrp;
416                         spin_unlock(&GlobalMid_Lock);
417
418                         /* Calculate time_to_wait past last receive time.
419                          Although we prefer not to time out if the
420                          server is still responding - we will time
421                          out if the server takes more than 15 (or 45
422                          or 180) seconds to respond to this request
423                          and has not responded to any request from
424                          other threads on the client within 10 seconds */
425                         lrt += time_to_wait;
426                         if (time_after(jiffies, lrt)) {
427                                 /* No replies for time_to_wait. */
428                                 cERROR(1, ("server not responding"));
429                                 return -1;
430                         }
431                 } else {
432                         return 0;
433                 }
434         }
435 }
436
437
438 /*
439  *
440  * Send an SMB Request.  No response info (other than return code)
441  * needs to be parsed.
442  *
443  * flags indicate the type of request buffer and how long to wait
444  * and whether to log NT STATUS code (error) before mapping it to POSIX error
445  *
446  */
447 int
448 SendReceiveNoRsp(const unsigned int xid, struct cifsSesInfo *ses,
449                 struct smb_hdr *in_buf, int flags)
450 {
451         int rc;
452         struct kvec iov[1];
453         int resp_buf_type;
454
455         iov[0].iov_base = (char *)in_buf;
456         iov[0].iov_len = in_buf->smb_buf_length + 4;
457         flags |= CIFS_NO_RESP;
458         rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags);
459         cFYI(DBG2, ("SendRcvNoRsp flags %d rc %d", flags, rc));
460
461         return rc;
462 }
463
464 int
465 SendReceive2(const unsigned int xid, struct cifsSesInfo *ses,
466              struct kvec *iov, int n_vec, int *pRespBufType /* ret */,
467              const int flags)
468 {
469         int rc = 0;
470         int long_op;
471         unsigned int receive_len;
472         unsigned long timeout;
473         struct mid_q_entry *midQ;
474         struct smb_hdr *in_buf = iov[0].iov_base;
475
476         long_op = flags & CIFS_TIMEOUT_MASK;
477
478         *pRespBufType = CIFS_NO_BUFFER;  /* no response buf yet */
479
480         if ((ses == NULL) || (ses->server == NULL)) {
481                 cifs_small_buf_release(in_buf);
482                 cERROR(1, ("Null session"));
483                 return -EIO;
484         }
485
486         if (ses->server->tcpStatus == CifsExiting) {
487                 cifs_small_buf_release(in_buf);
488                 return -ENOENT;
489         }
490
491         /* Ensure that we do not send more than 50 overlapping requests
492            to the same server. We may make this configurable later or
493            use ses->maxReq */
494
495         rc = wait_for_free_request(ses, long_op);
496         if (rc) {
497                 cifs_small_buf_release(in_buf);
498                 return rc;
499         }
500
501         /* make sure that we sign in the same order that we send on this socket
502            and avoid races inside tcp sendmsg code that could cause corruption
503            of smb data */
504
505         down(&ses->server->tcpSem);
506
507         rc = allocate_mid(ses, in_buf, &midQ);
508         if (rc) {
509                 up(&ses->server->tcpSem);
510                 cifs_small_buf_release(in_buf);
511                 /* Update # of requests on wire to server */
512                 atomic_dec(&ses->server->inFlight);
513                 wake_up(&ses->server->request_q);
514                 return rc;
515         }
516         rc = cifs_sign_smb2(iov, n_vec, ses->server, &midQ->sequence_number);
517
518         midQ->midState = MID_REQUEST_SUBMITTED;
519 #ifdef CONFIG_CIFS_STATS2
520         atomic_inc(&ses->server->inSend);
521 #endif
522         rc = smb_send2(ses->server->ssocket, iov, n_vec,
523                       (struct sockaddr *) &(ses->server->addr.sockAddr));
524 #ifdef CONFIG_CIFS_STATS2
525         atomic_dec(&ses->server->inSend);
526         midQ->when_sent = jiffies;
527 #endif
528
529         up(&ses->server->tcpSem);
530         cifs_small_buf_release(in_buf);
531
532         if (rc < 0)
533                 goto out;
534
535         if (long_op == CIFS_STD_OP)
536                 timeout = 15 * HZ;
537         else if (long_op == CIFS_VLONG_OP) /* e.g. slow writes past EOF */
538                 timeout = 180 * HZ;
539         else if (long_op == CIFS_LONG_OP)
540                 timeout = 45 * HZ; /* should be greater than
541                         servers oplock break timeout (about 43 seconds) */
542         else if (long_op == CIFS_ASYNC_OP)
543                 goto out;
544         else if (long_op == CIFS_BLOCKING_OP)
545                 timeout = 0x7FFFFFFF; /*  large, but not so large as to wrap */
546         else {
547                 cERROR(1, ("unknown timeout flag %d", long_op));
548                 rc = -EIO;
549                 goto out;
550         }
551
552         /* wait for 15 seconds or until woken up due to response arriving or
553            due to last connection to this server being unmounted */
554         if (signal_pending(current)) {
555                 /* if signal pending do not hold up user for full smb timeout
556                 but we still give response a chance to complete */
557                 timeout = 2 * HZ;
558         }
559
560         /* No user interrupts in wait - wreaks havoc with performance */
561         wait_for_response(ses, midQ, timeout, 10 * HZ);
562
563         spin_lock(&GlobalMid_Lock);
564         if (midQ->resp_buf) {
565                 spin_unlock(&GlobalMid_Lock);
566                 receive_len = midQ->resp_buf->smb_buf_length;
567         } else {
568                 cERROR(1, ("No response to cmd %d mid %d",
569                         midQ->command, midQ->mid));
570                 if (midQ->midState == MID_REQUEST_SUBMITTED) {
571                         if (ses->server->tcpStatus == CifsExiting)
572                                 rc = -EHOSTDOWN;
573                         else {
574                                 ses->server->tcpStatus = CifsNeedReconnect;
575                                 midQ->midState = MID_RETRY_NEEDED;
576                         }
577                 }
578
579                 if (rc != -EHOSTDOWN) {
580                         if (midQ->midState == MID_RETRY_NEEDED) {
581                                 rc = -EAGAIN;
582                                 cFYI(1, ("marking request for retry"));
583                         } else {
584                                 rc = -EIO;
585                         }
586                 }
587                 spin_unlock(&GlobalMid_Lock);
588                 DeleteMidQEntry(midQ);
589                 /* Update # of requests on wire to server */
590                 atomic_dec(&ses->server->inFlight);
591                 wake_up(&ses->server->request_q);
592                 return rc;
593         }
594
595         if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
596                 cERROR(1, ("Frame too large received.  Length: %d  Xid: %d",
597                         receive_len, xid));
598                 rc = -EIO;
599         } else {                /* rcvd frame is ok */
600                 if (midQ->resp_buf &&
601                         (midQ->midState == MID_RESPONSE_RECEIVED)) {
602
603                         iov[0].iov_base = (char *)midQ->resp_buf;
604                         if (midQ->largeBuf)
605                                 *pRespBufType = CIFS_LARGE_BUFFER;
606                         else
607                                 *pRespBufType = CIFS_SMALL_BUFFER;
608                         iov[0].iov_len = receive_len + 4;
609
610                         dump_smb(midQ->resp_buf, 80);
611                         /* convert the length into a more usable form */
612                         if ((receive_len > 24) &&
613                            (ses->server->secMode & (SECMODE_SIGN_REQUIRED |
614                                         SECMODE_SIGN_ENABLED))) {
615                                 rc = cifs_verify_signature(midQ->resp_buf,
616                                                 &ses->server->mac_signing_key,
617                                                 midQ->sequence_number+1);
618                                 if (rc) {
619                                         cERROR(1, ("Unexpected SMB signature"));
620                                         /* BB FIXME add code to kill session */
621                                 }
622                         }
623
624                         /* BB special case reconnect tid and uid here? */
625                         rc = map_smb_to_linux_error(midQ->resp_buf,
626                                                 flags & CIFS_LOG_ERROR);
627
628                         /* convert ByteCount if necessary */
629                         if (receive_len >= sizeof(struct smb_hdr) - 4
630                             /* do not count RFC1001 header */  +
631                             (2 * midQ->resp_buf->WordCount) + 2 /* bcc */ )
632                                 BCC(midQ->resp_buf) =
633                                         le16_to_cpu(BCC_LE(midQ->resp_buf));
634                         if ((flags & CIFS_NO_RESP) == 0)
635                                 midQ->resp_buf = NULL;  /* mark it so buf will
636                                                            not be freed by
637                                                            DeleteMidQEntry */
638                 } else {
639                         rc = -EIO;
640                         cFYI(1, ("Bad MID state?"));
641                 }
642         }
643
644 out:
645         DeleteMidQEntry(midQ);
646         atomic_dec(&ses->server->inFlight);
647         wake_up(&ses->server->request_q);
648
649         return rc;
650 }
651
652 int
653 SendReceive(const unsigned int xid, struct cifsSesInfo *ses,
654             struct smb_hdr *in_buf, struct smb_hdr *out_buf,
655             int *pbytes_returned, const int long_op)
656 {
657         int rc = 0;
658         unsigned int receive_len;
659         unsigned long timeout;
660         struct mid_q_entry *midQ;
661
662         if (ses == NULL) {
663                 cERROR(1, ("Null smb session"));
664                 return -EIO;
665         }
666         if (ses->server == NULL) {
667                 cERROR(1, ("Null tcp session"));
668                 return -EIO;
669         }
670
671         if (ses->server->tcpStatus == CifsExiting)
672                 return -ENOENT;
673
674         /* Ensure that we do not send more than 50 overlapping requests
675            to the same server. We may make this configurable later or
676            use ses->maxReq */
677
678         rc = wait_for_free_request(ses, long_op);
679         if (rc)
680                 return rc;
681
682         /* make sure that we sign in the same order that we send on this socket
683            and avoid races inside tcp sendmsg code that could cause corruption
684            of smb data */
685
686         down(&ses->server->tcpSem);
687
688         rc = allocate_mid(ses, in_buf, &midQ);
689         if (rc) {
690                 up(&ses->server->tcpSem);
691                 /* Update # of requests on wire to server */
692                 atomic_dec(&ses->server->inFlight);
693                 wake_up(&ses->server->request_q);
694                 return rc;
695         }
696
697         if (in_buf->smb_buf_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
698                 cERROR(1, ("Illegal length, greater than maximum frame, %d",
699                         in_buf->smb_buf_length));
700                 DeleteMidQEntry(midQ);
701                 up(&ses->server->tcpSem);
702                 /* Update # of requests on wire to server */
703                 atomic_dec(&ses->server->inFlight);
704                 wake_up(&ses->server->request_q);
705                 return -EIO;
706         }
707
708         rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
709
710         midQ->midState = MID_REQUEST_SUBMITTED;
711 #ifdef CONFIG_CIFS_STATS2
712         atomic_inc(&ses->server->inSend);
713 #endif
714         rc = smb_send(ses->server->ssocket, in_buf, in_buf->smb_buf_length,
715                       (struct sockaddr *) &(ses->server->addr.sockAddr));
716 #ifdef CONFIG_CIFS_STATS2
717         atomic_dec(&ses->server->inSend);
718         midQ->when_sent = jiffies;
719 #endif
720         up(&ses->server->tcpSem);
721
722         if (rc < 0)
723                 goto out;
724
725         if (long_op == CIFS_STD_OP)
726                 timeout = 15 * HZ;
727         /* wait for 15 seconds or until woken up due to response arriving or
728            due to last connection to this server being unmounted */
729         else if (long_op == CIFS_ASYNC_OP)
730                 goto out;
731         else if (long_op == CIFS_VLONG_OP) /* writes past EOF can be slow */
732                 timeout = 180 * HZ;
733         else if (long_op == CIFS_LONG_OP)
734                 timeout = 45 * HZ; /* should be greater than
735                         servers oplock break timeout (about 43 seconds) */
736         else if (long_op == CIFS_BLOCKING_OP)
737                 timeout = 0x7FFFFFFF; /* large but no so large as to wrap */
738         else {
739                 cERROR(1, ("unknown timeout flag %d", long_op));
740                 rc = -EIO;
741                 goto out;
742         }
743
744         if (signal_pending(current)) {
745                 /* if signal pending do not hold up user for full smb timeout
746                 but we still give response a chance to complete */
747                 timeout = 2 * HZ;
748         }
749
750         /* No user interrupts in wait - wreaks havoc with performance */
751         wait_for_response(ses, midQ, timeout, 10 * HZ);
752
753         spin_lock(&GlobalMid_Lock);
754         if (midQ->resp_buf) {
755                 spin_unlock(&GlobalMid_Lock);
756                 receive_len = midQ->resp_buf->smb_buf_length;
757         } else {
758                 cERROR(1, ("No response for cmd %d mid %d",
759                           midQ->command, midQ->mid));
760                 if (midQ->midState == MID_REQUEST_SUBMITTED) {
761                         if (ses->server->tcpStatus == CifsExiting)
762                                 rc = -EHOSTDOWN;
763                         else {
764                                 ses->server->tcpStatus = CifsNeedReconnect;
765                                 midQ->midState = MID_RETRY_NEEDED;
766                         }
767                 }
768
769                 if (rc != -EHOSTDOWN) {
770                         if (midQ->midState == MID_RETRY_NEEDED) {
771                                 rc = -EAGAIN;
772                                 cFYI(1, ("marking request for retry"));
773                         } else {
774                                 rc = -EIO;
775                         }
776                 }
777                 spin_unlock(&GlobalMid_Lock);
778                 DeleteMidQEntry(midQ);
779                 /* Update # of requests on wire to server */
780                 atomic_dec(&ses->server->inFlight);
781                 wake_up(&ses->server->request_q);
782                 return rc;
783         }
784
785         if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
786                 cERROR(1, ("Frame too large received.  Length: %d  Xid: %d",
787                         receive_len, xid));
788                 rc = -EIO;
789         } else {                /* rcvd frame is ok */
790
791                 if (midQ->resp_buf && out_buf
792                     && (midQ->midState == MID_RESPONSE_RECEIVED)) {
793                         out_buf->smb_buf_length = receive_len;
794                         memcpy((char *)out_buf + 4,
795                                (char *)midQ->resp_buf + 4,
796                                receive_len);
797
798                         dump_smb(out_buf, 92);
799                         /* convert the length into a more usable form */
800                         if ((receive_len > 24) &&
801                            (ses->server->secMode & (SECMODE_SIGN_REQUIRED |
802                                         SECMODE_SIGN_ENABLED))) {
803                                 rc = cifs_verify_signature(out_buf,
804                                                 &ses->server->mac_signing_key,
805                                                 midQ->sequence_number+1);
806                                 if (rc) {
807                                         cERROR(1, ("Unexpected SMB signature"));
808                                         /* BB FIXME add code to kill session */
809                                 }
810                         }
811
812                         *pbytes_returned = out_buf->smb_buf_length;
813
814                         /* BB special case reconnect tid and uid here? */
815                         rc = map_smb_to_linux_error(out_buf, 0 /* no log */ );
816
817                         /* convert ByteCount if necessary */
818                         if (receive_len >= sizeof(struct smb_hdr) - 4
819                             /* do not count RFC1001 header */  +
820                             (2 * out_buf->WordCount) + 2 /* bcc */ )
821                                 BCC(out_buf) = le16_to_cpu(BCC_LE(out_buf));
822                 } else {
823                         rc = -EIO;
824                         cERROR(1, ("Bad MID state?"));
825                 }
826         }
827
828 out:
829         DeleteMidQEntry(midQ);
830         atomic_dec(&ses->server->inFlight);
831         wake_up(&ses->server->request_q);
832
833         return rc;
834 }
835
836 /* Send an NT_CANCEL SMB to cause the POSIX blocking lock to return. */
837
838 static int
839 send_nt_cancel(struct cifsTconInfo *tcon, struct smb_hdr *in_buf,
840                 struct mid_q_entry *midQ)
841 {
842         int rc = 0;
843         struct cifsSesInfo *ses = tcon->ses;
844         __u16 mid = in_buf->Mid;
845
846         header_assemble(in_buf, SMB_COM_NT_CANCEL, tcon, 0);
847         in_buf->Mid = mid;
848         down(&ses->server->tcpSem);
849         rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
850         if (rc) {
851                 up(&ses->server->tcpSem);
852                 return rc;
853         }
854         rc = smb_send(ses->server->ssocket, in_buf, in_buf->smb_buf_length,
855               (struct sockaddr *) &(ses->server->addr.sockAddr));
856         up(&ses->server->tcpSem);
857         return rc;
858 }
859
860 /* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
861    blocking lock to return. */
862
863 static int
864 send_lock_cancel(const unsigned int xid, struct cifsTconInfo *tcon,
865                         struct smb_hdr *in_buf,
866                         struct smb_hdr *out_buf)
867 {
868         int bytes_returned;
869         struct cifsSesInfo *ses = tcon->ses;
870         LOCK_REQ *pSMB = (LOCK_REQ *)in_buf;
871
872         /* We just modify the current in_buf to change
873            the type of lock from LOCKING_ANDX_SHARED_LOCK
874            or LOCKING_ANDX_EXCLUSIVE_LOCK to
875            LOCKING_ANDX_CANCEL_LOCK. */
876
877         pSMB->LockType = LOCKING_ANDX_CANCEL_LOCK|LOCKING_ANDX_LARGE_FILES;
878         pSMB->Timeout = 0;
879         pSMB->hdr.Mid = GetNextMid(ses->server);
880
881         return SendReceive(xid, ses, in_buf, out_buf,
882                         &bytes_returned, CIFS_STD_OP);
883 }
884
885 int
886 SendReceiveBlockingLock(const unsigned int xid, struct cifsTconInfo *tcon,
887             struct smb_hdr *in_buf, struct smb_hdr *out_buf,
888             int *pbytes_returned)
889 {
890         int rc = 0;
891         int rstart = 0;
892         unsigned int receive_len;
893         struct mid_q_entry *midQ;
894         struct cifsSesInfo *ses;
895
896         if (tcon == NULL || tcon->ses == NULL) {
897                 cERROR(1, ("Null smb session"));
898                 return -EIO;
899         }
900         ses = tcon->ses;
901
902         if (ses->server == NULL) {
903                 cERROR(1, ("Null tcp session"));
904                 return -EIO;
905         }
906
907         if (ses->server->tcpStatus == CifsExiting)
908                 return -ENOENT;
909
910         /* Ensure that we do not send more than 50 overlapping requests
911            to the same server. We may make this configurable later or
912            use ses->maxReq */
913
914         rc = wait_for_free_request(ses, CIFS_BLOCKING_OP);
915         if (rc)
916                 return rc;
917
918         /* make sure that we sign in the same order that we send on this socket
919            and avoid races inside tcp sendmsg code that could cause corruption
920            of smb data */
921
922         down(&ses->server->tcpSem);
923
924         rc = allocate_mid(ses, in_buf, &midQ);
925         if (rc) {
926                 up(&ses->server->tcpSem);
927                 return rc;
928         }
929
930         if (in_buf->smb_buf_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
931                 up(&ses->server->tcpSem);
932                 cERROR(1, ("Illegal length, greater than maximum frame, %d",
933                         in_buf->smb_buf_length));
934                 DeleteMidQEntry(midQ);
935                 return -EIO;
936         }
937
938         rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
939
940         midQ->midState = MID_REQUEST_SUBMITTED;
941 #ifdef CONFIG_CIFS_STATS2
942         atomic_inc(&ses->server->inSend);
943 #endif
944         rc = smb_send(ses->server->ssocket, in_buf, in_buf->smb_buf_length,
945                       (struct sockaddr *) &(ses->server->addr.sockAddr));
946 #ifdef CONFIG_CIFS_STATS2
947         atomic_dec(&ses->server->inSend);
948         midQ->when_sent = jiffies;
949 #endif
950         up(&ses->server->tcpSem);
951
952         if (rc < 0) {
953                 DeleteMidQEntry(midQ);
954                 return rc;
955         }
956
957         /* Wait for a reply - allow signals to interrupt. */
958         rc = wait_event_interruptible(ses->server->response_q,
959                 (!(midQ->midState == MID_REQUEST_SUBMITTED)) ||
960                 ((ses->server->tcpStatus != CifsGood) &&
961                  (ses->server->tcpStatus != CifsNew)));
962
963         /* Were we interrupted by a signal ? */
964         if ((rc == -ERESTARTSYS) &&
965                 (midQ->midState == MID_REQUEST_SUBMITTED) &&
966                 ((ses->server->tcpStatus == CifsGood) ||
967                  (ses->server->tcpStatus == CifsNew))) {
968
969                 if (in_buf->Command == SMB_COM_TRANSACTION2) {
970                         /* POSIX lock. We send a NT_CANCEL SMB to cause the
971                            blocking lock to return. */
972
973                         rc = send_nt_cancel(tcon, in_buf, midQ);
974                         if (rc) {
975                                 DeleteMidQEntry(midQ);
976                                 return rc;
977                         }
978                 } else {
979                         /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
980                            to cause the blocking lock to return. */
981
982                         rc = send_lock_cancel(xid, tcon, in_buf, out_buf);
983
984                         /* If we get -ENOLCK back the lock may have
985                            already been removed. Don't exit in this case. */
986                         if (rc && rc != -ENOLCK) {
987                                 DeleteMidQEntry(midQ);
988                                 return rc;
989                         }
990                 }
991
992                 /* Wait 5 seconds for the response. */
993                 if (wait_for_response(ses, midQ, 5 * HZ, 5 * HZ) == 0) {
994                         /* We got the response - restart system call. */
995                         rstart = 1;
996                 }
997         }
998
999         spin_lock(&GlobalMid_Lock);
1000         if (midQ->resp_buf) {
1001                 spin_unlock(&GlobalMid_Lock);
1002                 receive_len = midQ->resp_buf->smb_buf_length;
1003         } else {
1004                 cERROR(1, ("No response for cmd %d mid %d",
1005                           midQ->command, midQ->mid));
1006                 if (midQ->midState == MID_REQUEST_SUBMITTED) {
1007                         if (ses->server->tcpStatus == CifsExiting)
1008                                 rc = -EHOSTDOWN;
1009                         else {
1010                                 ses->server->tcpStatus = CifsNeedReconnect;
1011                                 midQ->midState = MID_RETRY_NEEDED;
1012                         }
1013                 }
1014
1015                 if (rc != -EHOSTDOWN) {
1016                         if (midQ->midState == MID_RETRY_NEEDED) {
1017                                 rc = -EAGAIN;
1018                                 cFYI(1, ("marking request for retry"));
1019                         } else {
1020                                 rc = -EIO;
1021                         }
1022                 }
1023                 spin_unlock(&GlobalMid_Lock);
1024                 DeleteMidQEntry(midQ);
1025                 return rc;
1026         }
1027
1028         if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
1029                 cERROR(1, ("Frame too large received.  Length: %d  Xid: %d",
1030                         receive_len, xid));
1031                 rc = -EIO;
1032         } else {                /* rcvd frame is ok */
1033
1034                 if (midQ->resp_buf && out_buf
1035                     && (midQ->midState == MID_RESPONSE_RECEIVED)) {
1036                         out_buf->smb_buf_length = receive_len;
1037                         memcpy((char *)out_buf + 4,
1038                                (char *)midQ->resp_buf + 4,
1039                                receive_len);
1040
1041                         dump_smb(out_buf, 92);
1042                         /* convert the length into a more usable form */
1043                         if ((receive_len > 24) &&
1044                            (ses->server->secMode & (SECMODE_SIGN_REQUIRED |
1045                                         SECMODE_SIGN_ENABLED))) {
1046                                 rc = cifs_verify_signature(out_buf,
1047                                                 &ses->server->mac_signing_key,
1048                                                 midQ->sequence_number+1);
1049                                 if (rc) {
1050                                         cERROR(1, ("Unexpected SMB signature"));
1051                                         /* BB FIXME add code to kill session */
1052                                 }
1053                         }
1054
1055                         *pbytes_returned = out_buf->smb_buf_length;
1056
1057                         /* BB special case reconnect tid and uid here? */
1058                         rc = map_smb_to_linux_error(out_buf, 0 /* no log */ );
1059
1060                         /* convert ByteCount if necessary */
1061                         if (receive_len >= sizeof(struct smb_hdr) - 4
1062                             /* do not count RFC1001 header */  +
1063                             (2 * out_buf->WordCount) + 2 /* bcc */ )
1064                                 BCC(out_buf) = le16_to_cpu(BCC_LE(out_buf));
1065                 } else {
1066                         rc = -EIO;
1067                         cERROR(1, ("Bad MID state?"));
1068                 }
1069         }
1070         DeleteMidQEntry(midQ);
1071         if (rstart && rc == -EACCES)
1072                 return -ERESTARTSYS;
1073         return rc;
1074 }