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