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