projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] slab: remove SLAB_KERNEL
[linux-2.6-block.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;
37extern kmem_cache_t *cifs_oplock_cachep;
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
502 but we still give response a change to complete */
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:
1da177e4 590
7ee1af76
JA		 591 DeleteMidQEntry(midQ);
592 atomic_dec(&ses->server->inFlight);
593 wake_up(&ses->server->request_q);
1da177e4 594
d6e04ae6
SF		 595 return rc;
596}
1da177e4
LT		 597
598int
599SendReceive(const unsigned int xid, struct cifsSesInfo *ses,
600 struct smb_hdr *in_buf, struct smb_hdr *out_buf,
601 int *pbytes_returned, const int long_op)
602{
603 int rc = 0;
604 unsigned int receive_len;
605 unsigned long timeout;
606 struct mid_q_entry *midQ;
607
608 if (ses == NULL) {
609 cERROR(1,("Null smb session"));
610 return -EIO;
611 }
612 if(ses->server == NULL) {
613 cERROR(1,("Null tcp session"));
614 return -EIO;
615 }
616
31ca3bc3
SF		 617 if(ses->server->tcpStatus == CifsExiting)
618 return -ENOENT;
619
1da177e4
LT		 620 /* Ensure that we do not send more than 50 overlapping requests
621 to the same server. We may make this configurable later or
622 use ses->maxReq */
1da177e4 623
7ee1af76
JA		 624 rc = wait_for_free_request(ses, long_op);
625 if (rc)
626 return rc;
627
1da177e4
LT		 628 /* make sure that we sign in the same order that we send on this socket
629 and avoid races inside tcp sendmsg code that could cause corruption
630 of smb data */
631
632 down(&ses->server->tcpSem);
633
7ee1af76
JA		 634 rc = allocate_mid(ses, in_buf, &midQ);
635 if (rc) {
1da177e4 636 up(&ses->server->tcpSem);
7ee1af76
JA		 637 /* Update # of requests on wire to server */
638 atomic_dec(&ses->server->inFlight);
639 wake_up(&ses->server->request_q);
640 return rc;
1da177e4
LT		 641 }
642
643 if (in_buf->smb_buf_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
26a21b98 644 cERROR(1, ("Illegal length, greater than maximum frame, %d",
1da177e4
LT		 645 in_buf->smb_buf_length));
646 DeleteMidQEntry(midQ);
7ee1af76
JA		 647 up(&ses->server->tcpSem);
648 /* Update # of requests on wire to server */
649 atomic_dec(&ses->server->inFlight);
650 wake_up(&ses->server->request_q);
1da177e4
LT		 651 return -EIO;
652 }
653
ad009ac9 654 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
1da177e4
LT		 655
656 midQ->midState = MID_REQUEST_SUBMITTED;
131afd0b
SF		 657#ifdef CONFIG_CIFS_STATS2
658 atomic_inc(&ses->server->inSend);
659#endif
1da177e4
LT		 660 rc = smb_send(ses->server->ssocket, in_buf, in_buf->smb_buf_length,
661 (struct sockaddr *) &(ses->server->addr.sockAddr));
131afd0b
SF		 662#ifdef CONFIG_CIFS_STATS2
663 atomic_dec(&ses->server->inSend);
1047abc1 664 midQ->when_sent = jiffies;
131afd0b 665#endif
7ee1af76
JA		 666 up(&ses->server->tcpSem);
667
668 if(rc < 0)
669 goto out;
670
1da177e4 671 if (long_op == -1)
7ee1af76 672 goto out;
275cde1a 673 else if (long_op == 2) /* writes past end of file can take loong time */
37c0eb46 674 timeout = 180 * HZ;
1da177e4
LT		 675 else if (long_op == 1)
676 timeout = 45 * HZ; /* should be greater than
677 servers oplock break timeout (about 43 seconds) */
7ee1af76 678 else
1da177e4
LT		 679 timeout = 15 * HZ;
680 /* wait for 15 seconds or until woken up due to response arriving or
681 due to last connection to this server being unmounted */
682 if (signal_pending(current)) {
683 /* if signal pending do not hold up user for full smb timeout
684 but we still give response a change to complete */
685 timeout = 2 * HZ;
686 }
687
688 /* No user interrupts in wait - wreaks havoc with performance */
7ee1af76 689 wait_for_response(ses, midQ, timeout, 10 * HZ);
1da177e4
LT		 690
691 spin_lock(&GlobalMid_Lock);
692 if (midQ->resp_buf) {
693 spin_unlock(&GlobalMid_Lock);
70ca734a 694 receive_len = midQ->resp_buf->smb_buf_length;
1da177e4 695 } else {
37c0eb46
SF		 696 cERROR(1,("No response for cmd %d mid %d",
697 midQ->command, midQ->mid));
1da177e4
LT		 698 if(midQ->midState == MID_REQUEST_SUBMITTED) {
699 if(ses->server->tcpStatus == CifsExiting)
700 rc = -EHOSTDOWN;
701 else {
702 ses->server->tcpStatus = CifsNeedReconnect;
703 midQ->midState = MID_RETRY_NEEDED;
704 }
705 }
706
707 if (rc != -EHOSTDOWN) {
708 if(midQ->midState == MID_RETRY_NEEDED) {
709 rc = -EAGAIN;
710 cFYI(1,("marking request for retry"));
711 } else {
712 rc = -EIO;
713 }
714 }
715 spin_unlock(&GlobalMid_Lock);
716 DeleteMidQEntry(midQ);
7ee1af76
JA		 717 /* Update # of requests on wire to server */
718 atomic_dec(&ses->server->inFlight);
719 wake_up(&ses->server->request_q);
1da177e4
LT		 720 return rc;
721 }
722
723 if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
ad009ac9 724 cERROR(1, ("Frame too large received. Length: %d Xid: %d",
1da177e4
LT		 725 receive_len, xid));
726 rc = -EIO;
727 } else { /* rcvd frame is ok */
728
729 if (midQ->resp_buf && out_buf
730 && (midQ->midState == MID_RESPONSE_RECEIVED)) {
731 out_buf->smb_buf_length = receive_len;
732 memcpy((char *)out_buf + 4,
733 (char *)midQ->resp_buf + 4,
734 receive_len);
735
736 dump_smb(out_buf, 92);
737 /* convert the length into a more usable form */
738 if((receive_len > 24) &&
ad009ac9
SF		 739 (ses->server->secMode & (SECMODE_SIGN_REQUIRED |
740 SECMODE_SIGN_ENABLED))) {
741 rc = cifs_verify_signature(out_buf,
742 ses->server->mac_signing_key,
743 midQ->sequence_number+1);
744 if(rc) {
275cde1a
SF		 745 cERROR(1,("Unexpected SMB signature"));
746 /* BB FIXME add code to kill session */
ad009ac9 747 }
1da177e4
LT		 748 }
749
750 *pbytes_returned = out_buf->smb_buf_length;
751
ad009ac9 752 /* BB special case reconnect tid and uid here? */
1da177e4
LT		 753 rc = map_smb_to_linux_error(out_buf);
754
755 /* convert ByteCount if necessary */
756 if (receive_len >=
757 sizeof (struct smb_hdr) -
758 4 /* do not count RFC1001 header */ +
759 (2 * out_buf->WordCount) + 2 /* bcc */ )
0f2b27c4 760 BCC(out_buf) = le16_to_cpu(BCC_LE(out_buf));
1da177e4
LT		 761 } else {
762 rc = -EIO;
ec637e3f 763 cERROR(1,("Bad MID state?"));
1da177e4
LT		 764 }
765 }
7ee1af76
JA		 766
767out:
768
1da177e4 769 DeleteMidQEntry(midQ);
7ee1af76
JA		 770 atomic_dec(&ses->server->inFlight);
771 wake_up(&ses->server->request_q);
1da177e4 772
7ee1af76
JA		 773 return rc;
774}
1da177e4 775
7ee1af76
JA		 776/* Send an NT_CANCEL SMB to cause the POSIX blocking lock to return. */
777
778static int
779send_nt_cancel(struct cifsTconInfo *tcon, struct smb_hdr *in_buf,
780 struct mid_q_entry *midQ)
781{
782 int rc = 0;
783 struct cifsSesInfo *ses = tcon->ses;
784 __u16 mid = in_buf->Mid;
785
786 header_assemble(in_buf, SMB_COM_NT_CANCEL, tcon, 0);
787 in_buf->Mid = mid;
788 down(&ses->server->tcpSem);
789 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
790 if (rc) {
791 up(&ses->server->tcpSem);
792 return rc;
793 }
794 rc = smb_send(ses->server->ssocket, in_buf, in_buf->smb_buf_length,
795 (struct sockaddr *) &(ses->server->addr.sockAddr));
796 up(&ses->server->tcpSem);
1da177e4 797 return rc;
7ee1af76
JA		 798}
799
800/* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
801 blocking lock to return. */
802
803static int
804send_lock_cancel(const unsigned int xid, struct cifsTconInfo *tcon,
805 struct smb_hdr *in_buf,
806 struct smb_hdr *out_buf)
807{
808 int bytes_returned;
809 struct cifsSesInfo *ses = tcon->ses;
810 LOCK_REQ *pSMB = (LOCK_REQ *)in_buf;
811
812 /* We just modify the current in_buf to change
813 the type of lock from LOCKING_ANDX_SHARED_LOCK
814 or LOCKING_ANDX_EXCLUSIVE_LOCK to
815 LOCKING_ANDX_CANCEL_LOCK. */
816
817 pSMB->LockType = LOCKING_ANDX_CANCEL_LOCK|LOCKING_ANDX_LARGE_FILES;
818 pSMB->Timeout = 0;
819 pSMB->hdr.Mid = GetNextMid(ses->server);
820
821 return SendReceive(xid, ses, in_buf, out_buf,
822 &bytes_returned, 0);
823}
824
825int
826SendReceiveBlockingLock(const unsigned int xid, struct cifsTconInfo *tcon,
827 struct smb_hdr *in_buf, struct smb_hdr *out_buf,
828 int *pbytes_returned)
829{
830 int rc = 0;
831 int rstart = 0;
832 unsigned int receive_len;
833 struct mid_q_entry *midQ;
834 struct cifsSesInfo *ses;
835
836 if (tcon == NULL || tcon->ses == NULL) {
837 cERROR(1,("Null smb session"));
838 return -EIO;
839 }
840 ses = tcon->ses;
841
842 if(ses->server == NULL) {
843 cERROR(1,("Null tcp session"));
844 return -EIO;
845 }
846
847 if(ses->server->tcpStatus == CifsExiting)
848 return -ENOENT;
849
850 /* Ensure that we do not send more than 50 overlapping requests
851 to the same server. We may make this configurable later or
852 use ses->maxReq */
853
854 rc = wait_for_free_request(ses, 3);
855 if (rc)
856 return rc;
857
858 /* make sure that we sign in the same order that we send on this socket
859 and avoid races inside tcp sendmsg code that could cause corruption
860 of smb data */
861
862 down(&ses->server->tcpSem);
863
864 rc = allocate_mid(ses, in_buf, &midQ);
865 if (rc) {
866 up(&ses->server->tcpSem);
867 return rc;
868 }
869
870 if (in_buf->smb_buf_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
871 up(&ses->server->tcpSem);
872 cERROR(1, ("Illegal length, greater than maximum frame, %d",
873 in_buf->smb_buf_length));
874 DeleteMidQEntry(midQ);
875 return -EIO;
876 }
877
878 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
1da177e4 879
7ee1af76
JA		 880 midQ->midState = MID_REQUEST_SUBMITTED;
881#ifdef CONFIG_CIFS_STATS2
882 atomic_inc(&ses->server->inSend);
883#endif
884 rc = smb_send(ses->server->ssocket, in_buf, in_buf->smb_buf_length,
885 (struct sockaddr *) &(ses->server->addr.sockAddr));
886#ifdef CONFIG_CIFS_STATS2
887 atomic_dec(&ses->server->inSend);
888 midQ->when_sent = jiffies;
889#endif
1da177e4 890 up(&ses->server->tcpSem);
7ee1af76
JA		 891
892 if(rc < 0) {
893 DeleteMidQEntry(midQ);
894 return rc;
895 }
896
897 /* Wait for a reply - allow signals to interrupt. */
898 rc = wait_event_interruptible(ses->server->response_q,
899 (!(midQ->midState == MID_REQUEST_SUBMITTED)) ||
900 ((ses->server->tcpStatus != CifsGood) &&
901 (ses->server->tcpStatus != CifsNew)));
902
903 /* Were we interrupted by a signal ? */
904 if ((rc == -ERESTARTSYS) &&
905 (midQ->midState == MID_REQUEST_SUBMITTED) &&
906 ((ses->server->tcpStatus == CifsGood) ||
907 (ses->server->tcpStatus == CifsNew))) {
908
909 if (in_buf->Command == SMB_COM_TRANSACTION2) {
910 /* POSIX lock. We send a NT_CANCEL SMB to cause the
911 blocking lock to return. */
912
913 rc = send_nt_cancel(tcon, in_buf, midQ);
914 if (rc) {
915 DeleteMidQEntry(midQ);
916 return rc;
917 }
918 } else {
919 /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
920 to cause the blocking lock to return. */
921
922 rc = send_lock_cancel(xid, tcon, in_buf, out_buf);
923
924 /* If we get -ENOLCK back the lock may have
925 already been removed. Don't exit in this case. */
926 if (rc && rc != -ENOLCK) {
927 DeleteMidQEntry(midQ);
928 return rc;
929 }
930 }
931
932 /* Wait 5 seconds for the response. */
933 if (wait_for_response(ses, midQ, 5 * HZ, 5 * HZ)==0) {
934 /* We got the response - restart system call. */
935 rstart = 1;
936 }
937 }
938
939 spin_lock(&GlobalMid_Lock);
940 if (midQ->resp_buf) {
941 spin_unlock(&GlobalMid_Lock);
942 receive_len = midQ->resp_buf->smb_buf_length;
943 } else {
944 cERROR(1,("No response for cmd %d mid %d",
945 midQ->command, midQ->mid));
946 if(midQ->midState == MID_REQUEST_SUBMITTED) {
947 if(ses->server->tcpStatus == CifsExiting)
948 rc = -EHOSTDOWN;
949 else {
950 ses->server->tcpStatus = CifsNeedReconnect;
951 midQ->midState = MID_RETRY_NEEDED;
952 }
953 }
954
955 if (rc != -EHOSTDOWN) {
956 if(midQ->midState == MID_RETRY_NEEDED) {
957 rc = -EAGAIN;
958 cFYI(1,("marking request for retry"));
959 } else {
960 rc = -EIO;
961 }
962 }
963 spin_unlock(&GlobalMid_Lock);
964 DeleteMidQEntry(midQ);
965 return rc;
1da177e4 966 }
7ee1af76
JA		 967
968 if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
969 cERROR(1, ("Frame too large received. Length: %d Xid: %d",
970 receive_len, xid));
971 rc = -EIO;
972 } else { /* rcvd frame is ok */
973
974 if (midQ->resp_buf && out_buf
975 && (midQ->midState == MID_RESPONSE_RECEIVED)) {
976 out_buf->smb_buf_length = receive_len;
977 memcpy((char *)out_buf + 4,
978 (char *)midQ->resp_buf + 4,
979 receive_len);
980
981 dump_smb(out_buf, 92);
982 /* convert the length into a more usable form */
983 if((receive_len > 24) &&
984 (ses->server->secMode & (SECMODE_SIGN_REQUIRED |
985 SECMODE_SIGN_ENABLED))) {
986 rc = cifs_verify_signature(out_buf,
987 ses->server->mac_signing_key,
988 midQ->sequence_number+1);
989 if(rc) {
990 cERROR(1,("Unexpected SMB signature"));
991 /* BB FIXME add code to kill session */
992 }
993 }
994
995 *pbytes_returned = out_buf->smb_buf_length;
996
997 /* BB special case reconnect tid and uid here? */
998 rc = map_smb_to_linux_error(out_buf);
1da177e4 999
7ee1af76
JA		 1000 /* convert ByteCount if necessary */
1001 if (receive_len >=
1002 sizeof (struct smb_hdr) -
1003 4 /* do not count RFC1001 header */ +
1004 (2 * out_buf->WordCount) + 2 /* bcc */ )
1005 BCC(out_buf) = le16_to_cpu(BCC_LE(out_buf));
1006 } else {
1007 rc = -EIO;
1008 cERROR(1,("Bad MID state?"));
1009 }
1010 }
1011 DeleteMidQEntry(midQ);
1012 if (rstart && rc == -EACCES)
1013 return -ERESTARTSYS;
1da177e4
LT		 1014 return rc;
1015}
Linux 6.x block layer and io_uring tree(s)