Merge branch 'for-linus' of master.kernel.org:/pub/scm/linux/kernel/git/dtor/input
[linux-2.6] / fs / cifs / transport.c
1 /*
2  *   fs/cifs/transport.c
3  *
4  *   Copyright (C) International Business Machines  Corp., 2002,2005
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 since
337                                    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         }
369         return 0;
370 }
371
372 static int wait_for_response(struct cifsSesInfo *ses, 
373                         struct mid_q_entry *midQ,
374                         unsigned long timeout,
375                         unsigned long time_to_wait)
376 {
377         unsigned long curr_timeout;
378
379         for (;;) {
380                 curr_timeout = timeout + jiffies;
381                 wait_event(ses->server->response_q,
382                         (!(midQ->midState == MID_REQUEST_SUBMITTED)) || 
383                         time_after(jiffies, curr_timeout) || 
384                         ((ses->server->tcpStatus != CifsGood) &&
385                          (ses->server->tcpStatus != CifsNew)));
386
387                 if (time_after(jiffies, curr_timeout) &&
388                         (midQ->midState == MID_REQUEST_SUBMITTED) &&
389                         ((ses->server->tcpStatus == CifsGood) ||
390                          (ses->server->tcpStatus == CifsNew))) {
391
392                         unsigned long lrt;
393
394                         /* We timed out. Is the server still
395                            sending replies ? */
396                         spin_lock(&GlobalMid_Lock);
397                         lrt = ses->server->lstrp;
398                         spin_unlock(&GlobalMid_Lock);
399
400                         /* Calculate time_to_wait past last receive time.
401                          Although we prefer not to time out if the 
402                          server is still responding - we will time
403                          out if the server takes more than 15 (or 45 
404                          or 180) seconds to respond to this request
405                          and has not responded to any request from 
406                          other threads on the client within 10 seconds */
407                         lrt += time_to_wait;
408                         if (time_after(jiffies, lrt)) {
409                                 /* No replies for time_to_wait. */
410                                 cERROR(1,("server not responding"));
411                                 return -1;
412                         }
413                 } else {
414                         return 0;
415                 }
416         }
417 }
418
419 int
420 SendReceive2(const unsigned int xid, struct cifsSesInfo *ses, 
421              struct kvec *iov, int n_vec, int * pRespBufType /* ret */, 
422              const int long_op)
423 {
424         int rc = 0;
425         unsigned int receive_len;
426         unsigned long timeout;
427         struct mid_q_entry *midQ;
428         struct smb_hdr *in_buf = iov[0].iov_base;
429         
430         *pRespBufType = CIFS_NO_BUFFER;  /* no response buf yet */
431
432         if ((ses == NULL) || (ses->server == NULL)) {
433                 cifs_small_buf_release(in_buf);
434                 cERROR(1,("Null session"));
435                 return -EIO;
436         }
437
438         if(ses->server->tcpStatus == CifsExiting) {
439                 cifs_small_buf_release(in_buf);
440                 return -ENOENT;
441         }
442
443         /* Ensure that we do not send more than 50 overlapping requests 
444            to the same server. We may make this configurable later or
445            use ses->maxReq */
446
447         rc = wait_for_free_request(ses, long_op);
448         if (rc) {
449                 cifs_small_buf_release(in_buf);
450                 return rc;
451         }
452
453         /* make sure that we sign in the same order that we send on this socket 
454            and avoid races inside tcp sendmsg code that could cause corruption
455            of smb data */
456
457         down(&ses->server->tcpSem); 
458
459         rc = allocate_mid(ses, in_buf, &midQ);
460         if (rc) {
461                 up(&ses->server->tcpSem);
462                 cifs_small_buf_release(in_buf);
463                 /* Update # of requests on wire to server */
464                 atomic_dec(&ses->server->inFlight); 
465                 wake_up(&ses->server->request_q);
466                 return rc;
467         }
468
469         rc = cifs_sign_smb2(iov, n_vec, ses->server, &midQ->sequence_number);
470
471         midQ->midState = MID_REQUEST_SUBMITTED;
472 #ifdef CONFIG_CIFS_STATS2
473         atomic_inc(&ses->server->inSend);
474 #endif
475         rc = smb_send2(ses->server->ssocket, iov, n_vec,
476                       (struct sockaddr *) &(ses->server->addr.sockAddr));
477 #ifdef CONFIG_CIFS_STATS2
478         atomic_dec(&ses->server->inSend);
479         midQ->when_sent = jiffies;
480 #endif
481
482         up(&ses->server->tcpSem);
483         cifs_small_buf_release(in_buf);
484
485         if(rc < 0)
486                 goto out;
487
488         if (long_op == -1)
489                 goto out;
490         else if (long_op == 2) /* writes past end of file can take loong time */
491                 timeout = 180 * HZ;
492         else if (long_op == 1)
493                 timeout = 45 * HZ; /* should be greater than 
494                         servers oplock break timeout (about 43 seconds) */
495         else
496                 timeout = 15 * HZ;
497
498         /* wait for 15 seconds or until woken up due to response arriving or 
499            due to last connection to this server being unmounted */
500         if (signal_pending(current)) {
501                 /* if signal pending do not hold up user for full smb timeout
502                 but we still give response a chance to complete */
503                 timeout = 2 * HZ;
504         }   
505
506         /* No user interrupts in wait - wreaks havoc with performance */
507         wait_for_response(ses, midQ, timeout, 10 * HZ);
508
509         spin_lock(&GlobalMid_Lock);
510         if (midQ->resp_buf) {
511                 spin_unlock(&GlobalMid_Lock);
512                 receive_len = midQ->resp_buf->smb_buf_length;
513         } else {
514                 cERROR(1,("No response to cmd %d mid %d",
515                         midQ->command, midQ->mid));
516                 if(midQ->midState == MID_REQUEST_SUBMITTED) {
517                         if(ses->server->tcpStatus == CifsExiting)
518                                 rc = -EHOSTDOWN;
519                         else {
520                                 ses->server->tcpStatus = CifsNeedReconnect;
521                                 midQ->midState = MID_RETRY_NEEDED;
522                         }
523                 }
524
525                 if (rc != -EHOSTDOWN) {
526                         if(midQ->midState == MID_RETRY_NEEDED) {
527                                 rc = -EAGAIN;
528                                 cFYI(1,("marking request for retry"));
529                         } else {
530                                 rc = -EIO;
531                         }
532                 }
533                 spin_unlock(&GlobalMid_Lock);
534                 DeleteMidQEntry(midQ);
535                 /* Update # of requests on wire to server */
536                 atomic_dec(&ses->server->inFlight); 
537                 wake_up(&ses->server->request_q);
538                 return rc;
539         }
540   
541         if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
542                 cERROR(1, ("Frame too large received.  Length: %d  Xid: %d",
543                         receive_len, xid));
544                 rc = -EIO;
545         } else {                /* rcvd frame is ok */
546                 if (midQ->resp_buf && 
547                         (midQ->midState == MID_RESPONSE_RECEIVED)) {
548
549                         iov[0].iov_base = (char *)midQ->resp_buf;
550                         if(midQ->largeBuf)
551                                 *pRespBufType = CIFS_LARGE_BUFFER;
552                         else
553                                 *pRespBufType = CIFS_SMALL_BUFFER;
554                         iov[0].iov_len = receive_len + 4;
555
556                         dump_smb(midQ->resp_buf, 80);
557                         /* convert the length into a more usable form */
558                         if((receive_len > 24) &&
559                            (ses->server->secMode & (SECMODE_SIGN_REQUIRED |
560                                         SECMODE_SIGN_ENABLED))) {
561                                 rc = cifs_verify_signature(midQ->resp_buf,
562                                                 ses->server->mac_signing_key,
563                                                 midQ->sequence_number+1);
564                                 if(rc) {
565                                         cERROR(1,("Unexpected SMB signature"));
566                                         /* BB FIXME add code to kill session */
567                                 }
568                         }
569
570                         /* BB special case reconnect tid and uid here? */
571                         /* BB special case Errbadpassword and pwdexpired here */
572                         rc = map_smb_to_linux_error(midQ->resp_buf);
573
574                         /* convert ByteCount if necessary */
575                         if (receive_len >=
576                             sizeof (struct smb_hdr) -
577                             4 /* do not count RFC1001 header */  +
578                             (2 * midQ->resp_buf->WordCount) + 2 /* bcc */ )
579                                 BCC(midQ->resp_buf) = 
580                                         le16_to_cpu(BCC_LE(midQ->resp_buf));
581                         midQ->resp_buf = NULL;  /* mark it so will not be freed
582                                                 by DeleteMidQEntry */
583                 } else {
584                         rc = -EIO;
585                         cFYI(1,("Bad MID state?"));
586                 }
587         }
588
589 out:
590         DeleteMidQEntry(midQ);
591         atomic_dec(&ses->server->inFlight); 
592         wake_up(&ses->server->request_q);
593
594         return rc;
595 }
596
597 int
598 SendReceive(const unsigned int xid, struct cifsSesInfo *ses,
599             struct smb_hdr *in_buf, struct smb_hdr *out_buf,
600             int *pbytes_returned, const int long_op)
601 {
602         int rc = 0;
603         unsigned int receive_len;
604         unsigned long timeout;
605         struct mid_q_entry *midQ;
606
607         if (ses == NULL) {
608                 cERROR(1,("Null smb session"));
609                 return -EIO;
610         }
611         if(ses->server == NULL) {
612                 cERROR(1,("Null tcp session"));
613                 return -EIO;
614         }
615
616         if(ses->server->tcpStatus == CifsExiting)
617                 return -ENOENT;
618
619         /* Ensure that we do not send more than 50 overlapping requests 
620            to the same server. We may make this configurable later or
621            use ses->maxReq */
622
623         rc = wait_for_free_request(ses, long_op);
624         if (rc)
625                 return rc;
626
627         /* make sure that we sign in the same order that we send on this socket 
628            and avoid races inside tcp sendmsg code that could cause corruption
629            of smb data */
630
631         down(&ses->server->tcpSem); 
632
633         rc = allocate_mid(ses, in_buf, &midQ);
634         if (rc) {
635                 up(&ses->server->tcpSem);
636                 /* Update # of requests on wire to server */
637                 atomic_dec(&ses->server->inFlight); 
638                 wake_up(&ses->server->request_q);
639                 return rc;
640         }
641
642         if (in_buf->smb_buf_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
643                 cERROR(1, ("Illegal length, greater than maximum frame, %d",
644                         in_buf->smb_buf_length));
645                 DeleteMidQEntry(midQ);
646                 up(&ses->server->tcpSem);
647                 /* Update # of requests on wire to server */
648                 atomic_dec(&ses->server->inFlight); 
649                 wake_up(&ses->server->request_q);
650                 return -EIO;
651         }
652
653         rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
654
655         midQ->midState = MID_REQUEST_SUBMITTED;
656 #ifdef CONFIG_CIFS_STATS2
657         atomic_inc(&ses->server->inSend);
658 #endif
659         rc = smb_send(ses->server->ssocket, in_buf, in_buf->smb_buf_length,
660                       (struct sockaddr *) &(ses->server->addr.sockAddr));
661 #ifdef CONFIG_CIFS_STATS2
662         atomic_dec(&ses->server->inSend);
663         midQ->when_sent = jiffies;
664 #endif
665         up(&ses->server->tcpSem);
666
667         if(rc < 0)
668                 goto out;
669
670         if (long_op == -1)
671                 goto out;
672         else if (long_op == 2) /* writes past end of file can take loong time */
673                 timeout = 180 * HZ;
674         else if (long_op == 1)
675                 timeout = 45 * HZ; /* should be greater than 
676                         servers oplock break timeout (about 43 seconds) */
677         else
678                 timeout = 15 * HZ;
679         /* wait for 15 seconds or until woken up due to response arriving or 
680            due to last connection to this server being unmounted */
681         if (signal_pending(current)) {
682                 /* if signal pending do not hold up user for full smb timeout
683                 but we still give response a chance to complete */
684                 timeout = 2 * HZ;
685         }   
686
687         /* No user interrupts in wait - wreaks havoc with performance */
688         wait_for_response(ses, midQ, timeout, 10 * HZ);
689
690         spin_lock(&GlobalMid_Lock);
691         if (midQ->resp_buf) {
692                 spin_unlock(&GlobalMid_Lock);
693                 receive_len = midQ->resp_buf->smb_buf_length;
694         } else {
695                 cERROR(1,("No response for cmd %d mid %d",
696                           midQ->command, midQ->mid));
697                 if(midQ->midState == MID_REQUEST_SUBMITTED) {
698                         if(ses->server->tcpStatus == CifsExiting)
699                                 rc = -EHOSTDOWN;
700                         else {
701                                 ses->server->tcpStatus = CifsNeedReconnect;
702                                 midQ->midState = MID_RETRY_NEEDED;
703                         }
704                 }
705
706                 if (rc != -EHOSTDOWN) {
707                         if(midQ->midState == MID_RETRY_NEEDED) {
708                                 rc = -EAGAIN;
709                                 cFYI(1,("marking request for retry"));
710                         } else {
711                                 rc = -EIO;
712                         }
713                 }
714                 spin_unlock(&GlobalMid_Lock);
715                 DeleteMidQEntry(midQ);
716                 /* Update # of requests on wire to server */
717                 atomic_dec(&ses->server->inFlight); 
718                 wake_up(&ses->server->request_q);
719                 return rc;
720         }
721   
722         if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
723                 cERROR(1, ("Frame too large received.  Length: %d  Xid: %d",
724                         receive_len, xid));
725                 rc = -EIO;
726         } else {                /* rcvd frame is ok */
727
728                 if (midQ->resp_buf && out_buf
729                     && (midQ->midState == MID_RESPONSE_RECEIVED)) {
730                         out_buf->smb_buf_length = receive_len;
731                         memcpy((char *)out_buf + 4,
732                                (char *)midQ->resp_buf + 4,
733                                receive_len);
734
735                         dump_smb(out_buf, 92);
736                         /* convert the length into a more usable form */
737                         if((receive_len > 24) &&
738                            (ses->server->secMode & (SECMODE_SIGN_REQUIRED |
739                                         SECMODE_SIGN_ENABLED))) {
740                                 rc = cifs_verify_signature(out_buf,
741                                                 ses->server->mac_signing_key,
742                                                 midQ->sequence_number+1);
743                                 if(rc) {
744                                         cERROR(1,("Unexpected SMB signature"));
745                                         /* BB FIXME add code to kill session */
746                                 }
747                         }
748
749                         *pbytes_returned = out_buf->smb_buf_length;
750
751                         /* BB special case reconnect tid and uid here? */
752                         rc = map_smb_to_linux_error(out_buf);
753
754                         /* convert ByteCount if necessary */
755                         if (receive_len >=
756                             sizeof (struct smb_hdr) -
757                             4 /* do not count RFC1001 header */  +
758                             (2 * out_buf->WordCount) + 2 /* bcc */ )
759                                 BCC(out_buf) = le16_to_cpu(BCC_LE(out_buf));
760                 } else {
761                         rc = -EIO;
762                         cERROR(1,("Bad MID state?"));
763                 }
764         }
765
766 out:
767         DeleteMidQEntry(midQ);
768         atomic_dec(&ses->server->inFlight); 
769         wake_up(&ses->server->request_q);
770
771         return rc;
772 }
773
774 /* Send an NT_CANCEL SMB to cause the POSIX blocking lock to return. */
775
776 static int
777 send_nt_cancel(struct cifsTconInfo *tcon, struct smb_hdr *in_buf,
778                 struct mid_q_entry *midQ)
779 {
780         int rc = 0;
781         struct cifsSesInfo *ses = tcon->ses;
782         __u16 mid = in_buf->Mid;
783
784         header_assemble(in_buf, SMB_COM_NT_CANCEL, tcon, 0);
785         in_buf->Mid = mid;
786         down(&ses->server->tcpSem); 
787         rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
788         if (rc) {
789                 up(&ses->server->tcpSem);
790                 return rc;
791         }
792         rc = smb_send(ses->server->ssocket, in_buf, in_buf->smb_buf_length,
793               (struct sockaddr *) &(ses->server->addr.sockAddr));
794         up(&ses->server->tcpSem);
795         return rc;
796 }
797
798 /* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
799    blocking lock to return. */
800
801 static int
802 send_lock_cancel(const unsigned int xid, struct cifsTconInfo *tcon,
803                         struct smb_hdr *in_buf,
804                         struct smb_hdr *out_buf)
805 {
806         int bytes_returned;
807         struct cifsSesInfo *ses = tcon->ses;
808         LOCK_REQ *pSMB = (LOCK_REQ *)in_buf;
809
810         /* We just modify the current in_buf to change
811            the type of lock from LOCKING_ANDX_SHARED_LOCK
812            or LOCKING_ANDX_EXCLUSIVE_LOCK to
813            LOCKING_ANDX_CANCEL_LOCK. */
814
815         pSMB->LockType = LOCKING_ANDX_CANCEL_LOCK|LOCKING_ANDX_LARGE_FILES;
816         pSMB->Timeout = 0;
817         pSMB->hdr.Mid = GetNextMid(ses->server);
818
819         return SendReceive(xid, ses, in_buf, out_buf,
820                         &bytes_returned, 0);
821 }
822
823 int
824 SendReceiveBlockingLock(const unsigned int xid, struct cifsTconInfo *tcon,
825             struct smb_hdr *in_buf, struct smb_hdr *out_buf,
826             int *pbytes_returned)
827 {
828         int rc = 0;
829         int rstart = 0;
830         unsigned int receive_len;
831         struct mid_q_entry *midQ;
832         struct cifsSesInfo *ses;
833
834         if (tcon == NULL || tcon->ses == NULL) {
835                 cERROR(1,("Null smb session"));
836                 return -EIO;
837         }
838         ses = tcon->ses;
839
840         if(ses->server == NULL) {
841                 cERROR(1,("Null tcp session"));
842                 return -EIO;
843         }
844
845         if(ses->server->tcpStatus == CifsExiting)
846                 return -ENOENT;
847
848         /* Ensure that we do not send more than 50 overlapping requests 
849            to the same server. We may make this configurable later or
850            use ses->maxReq */
851
852         rc = wait_for_free_request(ses, 3);
853         if (rc)
854                 return rc;
855
856         /* make sure that we sign in the same order that we send on this socket 
857            and avoid races inside tcp sendmsg code that could cause corruption
858            of smb data */
859
860         down(&ses->server->tcpSem); 
861
862         rc = allocate_mid(ses, in_buf, &midQ);
863         if (rc) {
864                 up(&ses->server->tcpSem);
865                 return rc;
866         }
867
868         if (in_buf->smb_buf_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
869                 up(&ses->server->tcpSem);
870                 cERROR(1, ("Illegal length, greater than maximum frame, %d",
871                         in_buf->smb_buf_length));
872                 DeleteMidQEntry(midQ);
873                 return -EIO;
874         }
875
876         rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
877
878         midQ->midState = MID_REQUEST_SUBMITTED;
879 #ifdef CONFIG_CIFS_STATS2
880         atomic_inc(&ses->server->inSend);
881 #endif
882         rc = smb_send(ses->server->ssocket, in_buf, in_buf->smb_buf_length,
883                       (struct sockaddr *) &(ses->server->addr.sockAddr));
884 #ifdef CONFIG_CIFS_STATS2
885         atomic_dec(&ses->server->inSend);
886         midQ->when_sent = jiffies;
887 #endif
888         up(&ses->server->tcpSem);
889
890         if(rc < 0) {
891                 DeleteMidQEntry(midQ);
892                 return rc;
893         }
894
895         /* Wait for a reply - allow signals to interrupt. */
896         rc = wait_event_interruptible(ses->server->response_q,
897                 (!(midQ->midState == MID_REQUEST_SUBMITTED)) || 
898                 ((ses->server->tcpStatus != CifsGood) &&
899                  (ses->server->tcpStatus != CifsNew)));
900
901         /* Were we interrupted by a signal ? */
902         if ((rc == -ERESTARTSYS) &&
903                 (midQ->midState == MID_REQUEST_SUBMITTED) &&
904                 ((ses->server->tcpStatus == CifsGood) ||
905                  (ses->server->tcpStatus == CifsNew))) {
906
907                 if (in_buf->Command == SMB_COM_TRANSACTION2) {
908                         /* POSIX lock. We send a NT_CANCEL SMB to cause the
909                            blocking lock to return. */
910
911                         rc = send_nt_cancel(tcon, in_buf, midQ);
912                         if (rc) {
913                                 DeleteMidQEntry(midQ);
914                                 return rc;
915                         }
916                 } else {
917                         /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
918                            to cause the blocking lock to return. */
919
920                         rc = send_lock_cancel(xid, tcon, in_buf, out_buf);
921
922                         /* If we get -ENOLCK back the lock may have
923                            already been removed. Don't exit in this case. */
924                         if (rc && rc != -ENOLCK) {
925                                 DeleteMidQEntry(midQ);
926                                 return rc;
927                         }
928                 }
929
930                 /* Wait 5 seconds for the response. */
931                 if (wait_for_response(ses, midQ, 5 * HZ, 5 * HZ)==0) {
932                         /* We got the response - restart system call. */
933                         rstart = 1;
934                 }
935         }
936
937         spin_lock(&GlobalMid_Lock);
938         if (midQ->resp_buf) {
939                 spin_unlock(&GlobalMid_Lock);
940                 receive_len = midQ->resp_buf->smb_buf_length;
941         } else {
942                 cERROR(1,("No response for cmd %d mid %d",
943                           midQ->command, midQ->mid));
944                 if(midQ->midState == MID_REQUEST_SUBMITTED) {
945                         if(ses->server->tcpStatus == CifsExiting)
946                                 rc = -EHOSTDOWN;
947                         else {
948                                 ses->server->tcpStatus = CifsNeedReconnect;
949                                 midQ->midState = MID_RETRY_NEEDED;
950                         }
951                 }
952
953                 if (rc != -EHOSTDOWN) {
954                         if(midQ->midState == MID_RETRY_NEEDED) {
955                                 rc = -EAGAIN;
956                                 cFYI(1,("marking request for retry"));
957                         } else {
958                                 rc = -EIO;
959                         }
960                 }
961                 spin_unlock(&GlobalMid_Lock);
962                 DeleteMidQEntry(midQ);
963                 return rc;
964         }
965   
966         if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
967                 cERROR(1, ("Frame too large received.  Length: %d  Xid: %d",
968                         receive_len, xid));
969                 rc = -EIO;
970         } else {                /* rcvd frame is ok */
971
972                 if (midQ->resp_buf && out_buf
973                     && (midQ->midState == MID_RESPONSE_RECEIVED)) {
974                         out_buf->smb_buf_length = receive_len;
975                         memcpy((char *)out_buf + 4,
976                                (char *)midQ->resp_buf + 4,
977                                receive_len);
978
979                         dump_smb(out_buf, 92);
980                         /* convert the length into a more usable form */
981                         if((receive_len > 24) &&
982                            (ses->server->secMode & (SECMODE_SIGN_REQUIRED |
983                                         SECMODE_SIGN_ENABLED))) {
984                                 rc = cifs_verify_signature(out_buf,
985                                                 ses->server->mac_signing_key,
986                                                 midQ->sequence_number+1);
987                                 if(rc) {
988                                         cERROR(1,("Unexpected SMB signature"));
989                                         /* BB FIXME add code to kill session */
990                                 }
991                         }
992
993                         *pbytes_returned = out_buf->smb_buf_length;
994
995                         /* BB special case reconnect tid and uid here? */
996                         rc = map_smb_to_linux_error(out_buf);
997
998                         /* convert ByteCount if necessary */
999                         if (receive_len >=
1000                             sizeof (struct smb_hdr) -
1001                             4 /* do not count RFC1001 header */  +
1002                             (2 * out_buf->WordCount) + 2 /* bcc */ )
1003                                 BCC(out_buf) = le16_to_cpu(BCC_LE(out_buf));
1004                 } else {
1005                         rc = -EIO;
1006                         cERROR(1,("Bad MID state?"));
1007                 }
1008         }
1009         DeleteMidQEntry(midQ);
1010         if (rstart && rc == -EACCES)
1011                 return -ERESTARTSYS;
1012         return rc;
1013 }