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