]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - fs/cifs/transport.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[CIFS] ipv6 support no longer experimental
[mirror_ubuntu-bionic-kernel.git] / fs / cifs / transport.c
CommitLineData
1da177e4
LT		 1/*
2 * fs/cifs/transport.c
3 *
b8643e1b 4 * Copyright (C) International Business Machines Corp., 2002,2005
1da177e4 5 * Author(s): Steve French (sfrench@us.ibm.com)
14a441a2
SF		 6 * Jeremy Allison (jra@samba.org) 2006.
7 *
1da177e4
LT		 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;
e18b890b 37extern struct kmem_cache *cifs_oplock_cachep;
1da177e4
LT		 38
39static struct mid_q_entry *
7ee1af76 40AllocMidQEntry(const struct smb_hdr *smb_buffer, struct cifsSesInfo *ses)
1da177e4
LT		 41{
42 struct mid_q_entry *temp;
43
44 if (ses == NULL) {
275cde1a 45 cERROR(1, ("Null session passed in to AllocMidQEntry"));
1da177e4
LT		 46 return NULL;
47 }
48 if (ses->server == NULL) {
49 cERROR(1, ("Null TCP session in AllocMidQEntry"));
50 return NULL;
51 }
52
d6e04ae6 53 temp = (struct mid_q_entry *) mempool_alloc(cifs_mid_poolp,
e94b1766 54 GFP_KERNEL | GFP_NOFS);
1da177e4
LT		 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));
1047abc1
SF		 63 /* do_gettimeofday(&temp->when_sent);*/ /* easier to use jiffies */
64 /* when mid allocated can be before when sent */
65 temp->when_alloc = jiffies;
1da177e4
LT		 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{
1047abc1
SF		 81#ifdef CONFIG_CIFS_STATS2
82 unsigned long now;
83#endif
1da177e4
LT		 84 spin_lock(&GlobalMid_Lock);
85 midEntry->midState = MID_FREE;
86 list_del(&midEntry->qhead);
87 atomic_dec(&midCount);
88 spin_unlock(&GlobalMid_Lock);
b8643e1b
SF		 89 if(midEntry->largeBuf)
90 cifs_buf_release(midEntry->resp_buf);
91 else
92 cifs_small_buf_release(midEntry->resp_buf);
1047abc1
SF		 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
1da177e4
LT		 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,
e94b1766 121 GFP_KERNEL);
1da177e4
LT		 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);
3e84469d 172 cFYI(1, ("Sending smb of length %d", smb_buf_length));
1da177e4
LT		 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++;
3e84469d
SF		 179 /* smaller timeout here than send2 since smaller size */
180 /* Although it may not be required, this also is smaller
181 oplock break time */
68058e75 182 if(i > 12) {
1da177e4 183 cERROR(1,
68058e75 184 ("sends on sock %p stuck for 7 seconds",
1da177e4
LT		 185 ssocket));
186 rc = -EAGAIN;
187 break;
188 }
68058e75 189 msleep(1 << i);
1da177e4
LT		 190 continue;
191 }
192 if (rc < 0)
193 break;
5e1253b5
SF		 194 else
195 i = 0; /* reset i after each successful send */
1da177e4
LT		 196 iov.iov_base += rc;
197 iov.iov_len -= rc;
198 len -= rc;
199 }
200
201 if (rc < 0) {
3e84469d 202 cERROR(1,("Error %d sending data on socket to server", rc));
1da177e4
LT		 203 } else {
204 rc = 0;
205 }
206
7ee1af76
JA		 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
1da177e4
LT		 211 return rc;
212}
213
d6e04ae6 214static int
3e84469d
SF		 215smb_send2(struct socket *ssocket, struct kvec *iov, int n_vec,
216 struct sockaddr *sin)
1da177e4
LT		 217{
218 int rc = 0;
219 int i = 0;
220 struct msghdr smb_msg;
3e84469d
SF		 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;
7ee1af76 225 unsigned int smb_buf_length = smb_buffer->smb_buf_length;
d6e04ae6 226
1da177e4
LT		 227 if(ssocket == NULL)
228 return -ENOTSOCK; /* BB eventually add reconnect code here */
3e84469d 229
1da177e4
LT		 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
3e84469d
SF		 241
242 total_len = 0;
243 for (i = 0; i < n_vec; i++)
244 total_len += iov[i].iov_len;
245
1da177e4 246 smb_buffer->smb_buf_length = cpu_to_be32(smb_buffer->smb_buf_length);
3e84469d 247 cFYI(1, ("Sending smb: total_len %d", total_len));
1da177e4
LT		 248 dump_smb(smb_buffer, len);
249
3e84469d
SF		 250 while (total_len) {
251 rc = kernel_sendmsg(ssocket, &smb_msg, &iov[first_vec],
252 n_vec - first_vec, total_len);
1da177e4
LT		 253 if ((rc == -ENOSPC) || (rc == -EAGAIN)) {
254 i++;
68058e75 255 if(i >= 14) {
1da177e4 256 cERROR(1,
68058e75 257 ("sends on sock %p stuck for 15 seconds",
1da177e4
LT		 258 ssocket));
259 rc = -EAGAIN;
260 break;
261 }
68058e75 262 msleep(1 << i);
1da177e4
LT		 263 continue;
264 }
265 if (rc < 0)
266 break;
3e84469d
SF		 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 */
04c08816 275 cERROR(1,("tcp sent no data"));
3e84469d
SF		 276 msleep(500);
277 continue;
d6e04ae6 278 }
3e84469d 279 total_len -= rc;
68058e75 280 /* the line below resets i */
3e84469d
SF		 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 }
d6e04ae6 293 }
5e1253b5 294 i = 0; /* in case we get ENOSPC on the next send */
1da177e4
LT		 295 }
296
297 if (rc < 0) {
3e84469d
SF		 298 cERROR(1,("Error %d sending data on socket to server", rc));
299 } else
1da177e4 300 rc = 0;
1da177e4 301
7ee1af76
JA		 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
1da177e4
LT		 306 return rc;
307}
308
7ee1af76 309static int wait_for_free_request(struct cifsSesInfo *ses, const int long_op)
1da177e4 310{
1da177e4
LT		 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) {
d6e04ae6
SF		 317 if(atomic_read(&ses->server->inFlight) >=
318 cifs_max_pending){
1da177e4 319 spin_unlock(&GlobalMid_Lock);
131afd0b
SF		 320#ifdef CONFIG_CIFS_STATS2
321 atomic_inc(&ses->server->num_waiters);
322#endif
1da177e4
LT		 323 wait_event(ses->server->request_q,
324 atomic_read(&ses->server->inFlight)
325 < cifs_max_pending);
131afd0b
SF		 326#ifdef CONFIG_CIFS_STATS2
327 atomic_dec(&ses->server->num_waiters);
328#endif
1da177e4
LT		 329 spin_lock(&GlobalMid_Lock);
330 } else {
331 if(ses->server->tcpStatus == CifsExiting) {
332 spin_unlock(&GlobalMid_Lock);
333 return -ENOENT;
334 }
335
7ee1af76
JA		 336 /* can not count locking commands against total since
337 they are allowed to block on server */
1da177e4 338
1da177e4 339 /* update # of requests on the wire to server */
7ee1af76 340 if (long_op < 3)
1da177e4 341 atomic_inc(&ses->server->inFlight);
1da177e4
LT		 342 spin_unlock(&GlobalMid_Lock);
343 break;
344 }
345 }
346 }
7ee1af76
JA		 347 return 0;
348}
1da177e4 349
7ee1af76
JA		 350static int allocate_mid(struct cifsSesInfo *ses, struct smb_hdr *in_buf,
351 struct mid_q_entry **ppmidQ)
352{
1da177e4 353 if (ses->server->tcpStatus == CifsExiting) {
7ee1af76 354 return -ENOENT;
1da177e4
LT		 355 } else if (ses->server->tcpStatus == CifsNeedReconnect) {
356 cFYI(1,("tcp session dead - return to caller to retry"));
7ee1af76 357 return -EAGAIN;
1da177e4
LT		 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)) {
7ee1af76 362 return -EAGAIN;
1da177e4
LT		 363 } /* else ok - we are setting up session */
364 }
7ee1af76
JA		 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) {
1da177e4 461 up(&ses->server->tcpSem);
4b8f930f 462 cifs_small_buf_release(in_buf);
7ee1af76
JA		 463 /* Update # of requests on wire to server */
464 atomic_dec(&ses->server->inFlight);
465 wake_up(&ses->server->request_q);
466 return rc;
1da177e4
LT		 467 }
468
84afc29b 469 rc = cifs_sign_smb2(iov, n_vec, ses->server, &midQ->sequence_number);
1da177e4
LT		 470
471 midQ->midState = MID_REQUEST_SUBMITTED;
131afd0b
SF		 472#ifdef CONFIG_CIFS_STATS2
473 atomic_inc(&ses->server->inSend);
474#endif
3e84469d 475 rc = smb_send2(ses->server->ssocket, iov, n_vec,
d6e04ae6 476 (struct sockaddr *) &(ses->server->addr.sockAddr));
131afd0b
SF		 477#ifdef CONFIG_CIFS_STATS2
478 atomic_dec(&ses->server->inSend);
1047abc1 479 midQ->when_sent = jiffies;
131afd0b 480#endif
7ee1af76
JA		 481
482 up(&ses->server->tcpSem);
483 cifs_small_buf_release(in_buf);
484
485 if(rc < 0)
486 goto out;
4b8f930f 487
d6e04ae6 488 if (long_op == -1)
7ee1af76 489 goto out;
d6e04ae6 490 else if (long_op == 2) /* writes past end of file can take loong time */
37c0eb46 491 timeout = 180 * HZ;
d6e04ae6
SF		 492 else if (long_op == 1)
493 timeout = 45 * HZ; /* should be greater than
494 servers oplock break timeout (about 43 seconds) */
7ee1af76 495 else
d6e04ae6 496 timeout = 15 * HZ;
7ee1af76 497
d6e04ae6
SF		 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
8a236264 502 but we still give response a chance to complete */
d6e04ae6
SF		 503 timeout = 2 * HZ;
504 }
505
506 /* No user interrupts in wait - wreaks havoc with performance */
7ee1af76 507 wait_for_response(ses, midQ, timeout, 10 * HZ);
d6e04ae6
SF		 508
509 spin_lock(&GlobalMid_Lock);
510 if (midQ->resp_buf) {
511 spin_unlock(&GlobalMid_Lock);
70ca734a 512 receive_len = midQ->resp_buf->smb_buf_length;
d6e04ae6 513 } else {
37c0eb46
SF		 514 cERROR(1,("No response to cmd %d mid %d",
515 midQ->command, midQ->mid));
d6e04ae6
SF		 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);
7ee1af76
JA		 535 /* Update # of requests on wire to server */
536 atomic_dec(&ses->server->inFlight);
537 wake_up(&ses->server->request_q);
d6e04ae6
SF		 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 */
d6e04ae6
SF		 546 if (midQ->resp_buf &&
547 (midQ->midState == MID_RESPONSE_RECEIVED)) {
84afc29b 548
ec637e3f
SF		 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;
d6e04ae6 555
ec637e3f 556 dump_smb(midQ->resp_buf, 80);
d6e04ae6
SF		 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))) {
ec637e3f 561 rc = cifs_verify_signature(midQ->resp_buf,
d6e04ae6
SF		 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
d6e04ae6 570 /* BB special case reconnect tid and uid here? */
6ab16d24 571 /* BB special case Errbadpassword and pwdexpired here */
ec637e3f 572 rc = map_smb_to_linux_error(midQ->resp_buf);
d6e04ae6
SF		 573
574 /* convert ByteCount if necessary */
575 if (receive_len >=
576 sizeof (struct smb_hdr) -
577 4 /* do not count RFC1001 header */ +
ec637e3f
SF		 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 */
d6e04ae6
SF		 583 } else {
584 rc = -EIO;
ab2f218f 585 cFYI(1,("Bad MID state?"));
d6e04ae6
SF		 586 }
587 }
1da177e4 588
7ee1af76 589out:
7ee1af76
JA		 590 DeleteMidQEntry(midQ);
591 atomic_dec(&ses->server->inFlight);
592 wake_up(&ses->server->request_q);
1da177e4 593
d6e04ae6
SF		 594 return rc;
595}
1da177e4
LT		 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
31ca3bc3
SF		 616 if(ses->server->tcpStatus == CifsExiting)
617 return -ENOENT;
618
1da177e4
LT		 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 */
1da177e4 622
7ee1af76
JA		 623 rc = wait_for_free_request(ses, long_op);
624 if (rc)
625 return rc;
626
1da177e4
LT		 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
7ee1af76
JA		 633 rc = allocate_mid(ses, in_buf, &midQ);
634 if (rc) {
1da177e4 635 up(&ses->server->tcpSem);
7ee1af76
JA		 636 /* Update # of requests on wire to server */
637 atomic_dec(&ses->server->inFlight);
638 wake_up(&ses->server->request_q);
639 return rc;
1da177e4
LT		 640 }
641
642 if (in_buf->smb_buf_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
26a21b98 643 cERROR(1, ("Illegal length, greater than maximum frame, %d",
1da177e4
LT		 644 in_buf->smb_buf_length));
645 DeleteMidQEntry(midQ);
7ee1af76
JA		 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);
1da177e4
LT		 650 return -EIO;
651 }
652
ad009ac9 653 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
1da177e4
LT		 654
655 midQ->midState = MID_REQUEST_SUBMITTED;
131afd0b
SF		 656#ifdef CONFIG_CIFS_STATS2
657 atomic_inc(&ses->server->inSend);
658#endif
1da177e4
LT		 659 rc = smb_send(ses->server->ssocket, in_buf, in_buf->smb_buf_length,
660 (struct sockaddr *) &(ses->server->addr.sockAddr));
131afd0b
SF		 661#ifdef CONFIG_CIFS_STATS2
662 atomic_dec(&ses->server->inSend);
1047abc1 663 midQ->when_sent = jiffies;
131afd0b 664#endif
7ee1af76
JA		 665 up(&ses->server->tcpSem);
666
667 if(rc < 0)
668 goto out;
669
1da177e4 670 if (long_op == -1)
7ee1af76 671 goto out;
275cde1a 672 else if (long_op == 2) /* writes past end of file can take loong time */
37c0eb46 673 timeout = 180 * HZ;
1da177e4
LT		 674 else if (long_op == 1)
675 timeout = 45 * HZ; /* should be greater than
676 servers oplock break timeout (about 43 seconds) */
7ee1af76 677 else
1da177e4
LT		 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
8a236264 683 but we still give response a chance to complete */
1da177e4
LT		 684 timeout = 2 * HZ;
685 }
686
687 /* No user interrupts in wait - wreaks havoc with performance */
7ee1af76 688 wait_for_response(ses, midQ, timeout, 10 * HZ);
1da177e4
LT		 689
690 spin_lock(&GlobalMid_Lock);
691 if (midQ->resp_buf) {
692 spin_unlock(&GlobalMid_Lock);
70ca734a 693 receive_len = midQ->resp_buf->smb_buf_length;
1da177e4 694 } else {
37c0eb46
SF		 695 cERROR(1,("No response for cmd %d mid %d",
696 midQ->command, midQ->mid));
1da177e4
LT		 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);
7ee1af76
JA		 716 /* Update # of requests on wire to server */
717 atomic_dec(&ses->server->inFlight);
718 wake_up(&ses->server->request_q);
1da177e4
LT		 719 return rc;
720 }
721
722 if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
ad009ac9 723 cERROR(1, ("Frame too large received. Length: %d Xid: %d",
1da177e4
LT		 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) &&
ad009ac9
SF		 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) {
275cde1a
SF		 744 cERROR(1,("Unexpected SMB signature"));
745 /* BB FIXME add code to kill session */
ad009ac9 746 }
1da177e4
LT		 747 }
748
749 *pbytes_returned = out_buf->smb_buf_length;
750
ad009ac9 751 /* BB special case reconnect tid and uid here? */
1da177e4
LT		 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 */ )
0f2b27c4 759 BCC(out_buf) = le16_to_cpu(BCC_LE(out_buf));
1da177e4
LT		 760 } else {
761 rc = -EIO;
ec637e3f 762 cERROR(1,("Bad MID state?"));
1da177e4
LT		 763 }
764 }
7ee1af76
JA		 765
766out:
1da177e4 767 DeleteMidQEntry(midQ);
7ee1af76
JA		 768 atomic_dec(&ses->server->inFlight);
769 wake_up(&ses->server->request_q);
1da177e4 770
7ee1af76
JA		 771 return rc;
772}
1da177e4 773
7ee1af76
JA		 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);
1da177e4 795 return rc;
7ee1af76
JA		 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);
1da177e4 877
7ee1af76
JA		 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
1da177e4 888 up(&ses->server->tcpSem);
7ee1af76
JA		 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;
1da177e4 964 }
7ee1af76
JA		 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);
1da177e4 997
7ee1af76
JA		 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;
1da177e4
LT		 1012 return rc;
1013}
ubuntu-bionic-kernel mirror