tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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
36extern mempool_t *cifs_mid_poolp;
37extern struct kmem_cache *cifs_oplock_cachep;
38
39static struct mid_q_entry *
40AllocMidQEntry(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
78static void
79DeleteMidQEntry(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
112struct oplock_q_entry *
113AllocOplockQEntry(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
136void 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
145int
146smb_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
214static int
215smb_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
309static 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
350static 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
372static 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
419int
420SendReceive2(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
589out:
590 DeleteMidQEntry(midQ);
591 atomic_dec(&ses->server->inFlight);
592 wake_up(&ses->server->request_q);
593
594 return rc;
595}
596
597int
598SendReceive(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
766out:
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
776static int
777send_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
801static int
802send_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
823int
824SendReceiveBlockingLock(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}