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