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/gfp.h>
  26 #include <linux/wait.h>
  27 #include <linux/net.h>
  28 #include <linux/delay.h>
  29 #include <asm/uaccess.h>
  30 #include <asm/processor.h>
  31 #include <linux/mempool.h>
  32 #include "cifspdu.h"
  33 #include "cifsglob.h"
  34 #include "cifsproto.h"
  35 #include "cifs_debug.h"
  36
  37 extern mempool_t *cifs_mid_poolp;
  38
  39 static void
  40 wake_up_task(struct mid_q_entry *mid)
  41 {
  42         wake_up_process(mid->callback_data);
  43 }
  44
  45 struct mid_q_entry *
  46 AllocMidQEntry(const struct smb_hdr *smb_buffer, struct TCP_Server_Info *server)
  47 {
  48         struct mid_q_entry *temp;
  49
  50         if (server == NULL) {
  51                 cERROR(1, "Null TCP session in AllocMidQEntry");
  52                 return NULL;
  53         }
  54
  55         temp = mempool_alloc(cifs_mid_poolp, GFP_NOFS);
  56         if (temp == NULL)
  57                 return temp;
  58         else {
  59                 memset(temp, 0, sizeof(struct mid_q_entry));
  60                 temp->mid = smb_buffer->Mid;    /* always LE */
  61                 temp->pid = current->pid;
  62                 temp->command = smb_buffer->Command;
  63                 cFYI(1, "For smb_command %d", temp->command);
  64         /*      do_gettimeofday(&temp->when_sent);*/ /* easier to use jiffies */
  65                 /* when mid allocated can be before when sent */
  66                 temp->when_alloc = jiffies;
  67
  68                 /*
  69                  * The default is for the mid to be synchronous, so the
  70                  * default callback just wakes up the current task.
  71                  */
  72                 temp->callback = wake_up_task;
  73                 temp->callback_data = current;
  74         }
  75
  76         atomic_inc(&midCount);
  77         temp->midState = MID_REQUEST_ALLOCATED;
  78         return temp;
  79 }
  80
  81 void
  82 DeleteMidQEntry(struct mid_q_entry *midEntry)
  83 {
  84 #ifdef CONFIG_CIFS_STATS2
  85         unsigned long now;
  86 #endif
  87         midEntry->midState = MID_FREE;
  88         atomic_dec(&midCount);
  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 static void
 113 delete_mid(struct mid_q_entry *mid)
 114 {
 115         spin_lock(&GlobalMid_Lock);
 116         list_del(&mid->qhead);
 117         spin_unlock(&GlobalMid_Lock);
 118
 119         DeleteMidQEntry(mid);
 120 }
 121
 122 static int
 123 smb_sendv(struct TCP_Server_Info *server, struct kvec *iov, int n_vec)
 124 {
 125         int rc = 0;
 126         int i = 0;
 127         struct msghdr smb_msg;
 128         struct smb_hdr *smb_buffer = iov[0].iov_base;
 129         unsigned int len = iov[0].iov_len;
 130         unsigned int total_len;
 131         int first_vec = 0;
 132         unsigned int smb_buf_length = be32_to_cpu(smb_buffer->smb_buf_length);
 133         struct socket *ssocket = server->ssocket;
 134
 135         if (ssocket == NULL)
 136                 return -ENOTSOCK; /* BB eventually add reconnect code here */
 137
 138         smb_msg.msg_name = (struct sockaddr *) &server->dstaddr;
 139         smb_msg.msg_namelen = sizeof(struct sockaddr);
 140         smb_msg.msg_control = NULL;
 141         smb_msg.msg_controllen = 0;
 142         if (server->noblocksnd)
 143                 smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL;
 144         else
 145                 smb_msg.msg_flags = MSG_NOSIGNAL;
 146
 147         total_len = 0;
 148         for (i = 0; i < n_vec; i++)
 149                 total_len += iov[i].iov_len;
 150
 151         cFYI(1, "Sending smb:  total_len %d", total_len);
 152         dump_smb(smb_buffer, len);
 153
 154         i = 0;
 155         while (total_len) {
 156                 rc = kernel_sendmsg(ssocket, &smb_msg, &iov[first_vec],
 157                                     n_vec - first_vec, total_len);
 158                 if ((rc == -ENOSPC) || (rc == -EAGAIN)) {
 159                         i++;
 160                         /* if blocking send we try 3 times, since each can block
 161                            for 5 seconds. For nonblocking  we have to try more
 162                            but wait increasing amounts of time allowing time for
 163                            socket to clear.  The overall time we wait in either
 164                            case to send on the socket is about 15 seconds.
 165                            Similarly we wait for 15 seconds for
 166                            a response from the server in SendReceive[2]
 167                            for the server to send a response back for
 168                            most types of requests (except SMB Write
 169                            past end of file which can be slow, and
 170                            blocking lock operations). NFS waits slightly longer
 171                            than CIFS, but this can make it take longer for
 172                            nonresponsive servers to be detected and 15 seconds
 173                            is more than enough time for modern networks to
 174                            send a packet.  In most cases if we fail to send
 175                            after the retries we will kill the socket and
 176                            reconnect which may clear the network problem.
 177                         */
 178                         if ((i >= 14) || (!server->noblocksnd && (i > 2))) {
 179                                 cERROR(1, "sends on sock %p stuck for 15 seconds",
 180                                     ssocket);
 181                                 rc = -EAGAIN;
 182                                 break;
 183                         }
 184                         msleep(1 << i);
 185                         continue;
 186                 }
 187                 if (rc < 0)
 188                         break;
 189
 190                 if (rc == total_len) {
 191                         total_len = 0;
 192                         break;
 193                 } else if (rc > total_len) {
 194                         cERROR(1, "sent %d requested %d", rc, total_len);
 195                         break;
 196                 }
 197                 if (rc == 0) {
 198                         /* should never happen, letting socket clear before
 199                            retrying is our only obvious option here */
 200                         cERROR(1, "tcp sent no data");
 201                         msleep(500);
 202                         continue;
 203                 }
 204                 total_len -= rc;
 205                 /* the line below resets i */
 206                 for (i = first_vec; i < n_vec; i++) {
 207                         if (iov[i].iov_len) {
 208                                 if (rc > iov[i].iov_len) {
 209                                         rc -= iov[i].iov_len;
 210                                         iov[i].iov_len = 0;
 211                                 } else {
 212                                         iov[i].iov_base += rc;
 213                                         iov[i].iov_len -= rc;
 214                                         first_vec = i;
 215                                         break;
 216                                 }
 217                         }
 218                 }
 219                 i = 0; /* in case we get ENOSPC on the next send */
 220         }
 221
 222         if ((total_len > 0) && (total_len != smb_buf_length + 4)) {
 223                 cFYI(1, "partial send (%d remaining), terminating session",
 224                         total_len);
 225                 /* If we have only sent part of an SMB then the next SMB
 226                    could be taken as the remainder of this one.  We need
 227                    to kill the socket so the server throws away the partial
 228                    SMB */
 229                 server->tcpStatus = CifsNeedReconnect;
 230         }
 231
 232         if (rc < 0 && rc != -EINTR)
 233                 cERROR(1, "Error %d sending data on socket to server", rc);
 234         else
 235                 rc = 0;
 236
 237         /* Don't want to modify the buffer as a
 238            side effect of this call. */
 239         smb_buffer->smb_buf_length = cpu_to_be32(smb_buf_length);
 240
 241         return rc;
 242 }
 243
 244 int
 245 smb_send(struct TCP_Server_Info *server, struct smb_hdr *smb_buffer,
 246          unsigned int smb_buf_length)
 247 {
 248         struct kvec iov;
 249
 250         iov.iov_base = smb_buffer;
 251         iov.iov_len = smb_buf_length + 4;
 252
 253         return smb_sendv(server, &iov, 1);
 254 }
 255
 256 static int wait_for_free_request(struct TCP_Server_Info *server,
 257                                  const int long_op)
 258 {
 259         if (long_op == CIFS_ASYNC_OP) {
 260                 /* oplock breaks must not be held up */
 261                 atomic_inc(&server->inFlight);
 262                 return 0;
 263         }
 264
 265         spin_lock(&GlobalMid_Lock);
 266         while (1) {
 267                 if (atomic_read(&server->inFlight) >= cifs_max_pending) {
 268                         spin_unlock(&GlobalMid_Lock);
 269 #ifdef CONFIG_CIFS_STATS2
 270                         atomic_inc(&server->num_waiters);
 271 #endif
 272                         wait_event(server->request_q,
 273                                    atomic_read(&server->inFlight)
 274                                      < cifs_max_pending);
 275 #ifdef CONFIG_CIFS_STATS2
 276                         atomic_dec(&server->num_waiters);
 277 #endif
 278                         spin_lock(&GlobalMid_Lock);
 279                 } else {
 280                         if (server->tcpStatus == CifsExiting) {
 281                                 spin_unlock(&GlobalMid_Lock);
 282                                 return -ENOENT;
 283                         }
 284
 285                         /* can not count locking commands against total
 286                            as they are allowed to block on server */
 287
 288                         /* update # of requests on the wire to server */
 289                         if (long_op != CIFS_BLOCKING_OP)
 290                                 atomic_inc(&server->inFlight);
 291                         spin_unlock(&GlobalMid_Lock);
 292                         break;
 293                 }
 294         }
 295         return 0;
 296 }
 297
 298 static int allocate_mid(struct cifs_ses *ses, struct smb_hdr *in_buf,
 299                         struct mid_q_entry **ppmidQ)
 300 {
 301         if (ses->server->tcpStatus == CifsExiting) {
 302                 return -ENOENT;
 303         }
 304
 305         if (ses->server->tcpStatus == CifsNeedReconnect) {
 306                 cFYI(1, "tcp session dead - return to caller to retry");
 307                 return -EAGAIN;
 308         }
 309
 310         if (ses->status != CifsGood) {
 311                 /* check if SMB session is bad because we are setting it up */
 312                 if ((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
 313                         (in_buf->Command != SMB_COM_NEGOTIATE))
 314                         return -EAGAIN;
 315                 /* else ok - we are setting up session */
 316         }
 317         *ppmidQ = AllocMidQEntry(in_buf, ses->server);
 318         if (*ppmidQ == NULL)
 319                 return -ENOMEM;
 320         spin_lock(&GlobalMid_Lock);
 321         list_add_tail(&(*ppmidQ)->qhead, &ses->server->pending_mid_q);
 322         spin_unlock(&GlobalMid_Lock);
 323         return 0;
 324 }
 325
 326 static int
 327 wait_for_response(struct TCP_Server_Info *server, struct mid_q_entry *midQ)
 328 {
 329         int error;
 330
 331         error = wait_event_killable(server->response_q,
 332                                     midQ->midState != MID_REQUEST_SUBMITTED);
 333         if (error < 0)
 334                 return -ERESTARTSYS;
 335
 336         return 0;
 337 }
 338
 339
 340 /*
 341  * Send a SMB request and set the callback function in the mid to handle
 342  * the result. Caller is responsible for dealing with timeouts.
 343  */
 344 int
 345 cifs_call_async(struct TCP_Server_Info *server, struct kvec *iov,
 346                 unsigned int nvec, mid_callback_t *callback, void *cbdata,
 347                 bool ignore_pend)
 348 {
 349         int rc;
 350         struct mid_q_entry *mid;
 351         struct smb_hdr *hdr = (struct smb_hdr *)iov[0].iov_base;
 352
 353         rc = wait_for_free_request(server, ignore_pend ? CIFS_ASYNC_OP : 0);
 354         if (rc)
 355                 return rc;
 356
 357         /* enable signing if server requires it */
 358         if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
 359                 hdr->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
 360
 361         mutex_lock(&server->srv_mutex);
 362         mid = AllocMidQEntry(hdr, server);
 363         if (mid == NULL) {
 364                 mutex_unlock(&server->srv_mutex);
 365                 atomic_dec(&server->inFlight);
 366                 wake_up(&server->request_q);
 367                 return -ENOMEM;
 368         }
 369
 370         /* put it on the pending_mid_q */
 371         spin_lock(&GlobalMid_Lock);
 372         list_add_tail(&mid->qhead, &server->pending_mid_q);
 373         spin_unlock(&GlobalMid_Lock);
 374
 375         rc = cifs_sign_smb2(iov, nvec, server, &mid->sequence_number);
 376         if (rc) {
 377                 mutex_unlock(&server->srv_mutex);
 378                 goto out_err;
 379         }
 380
 381         mid->callback = callback;
 382         mid->callback_data = cbdata;
 383         mid->midState = MID_REQUEST_SUBMITTED;
 384 #ifdef CONFIG_CIFS_STATS2
 385         atomic_inc(&server->inSend);
 386 #endif
 387         rc = smb_sendv(server, iov, nvec);
 388 #ifdef CONFIG_CIFS_STATS2
 389         atomic_dec(&server->inSend);
 390         mid->when_sent = jiffies;
 391 #endif
 392         mutex_unlock(&server->srv_mutex);
 393         if (rc)
 394                 goto out_err;
 395
 396         return rc;
 397 out_err:
 398         delete_mid(mid);
 399         atomic_dec(&server->inFlight);
 400         wake_up(&server->request_q);
 401         return rc;
 402 }
 403
 404 /*
 405  *
 406  * Send an SMB Request.  No response info (other than return code)
 407  * needs to be parsed.
 408  *
 409  * flags indicate the type of request buffer and how long to wait
 410  * and whether to log NT STATUS code (error) before mapping it to POSIX error
 411  *
 412  */
 413 int
 414 SendReceiveNoRsp(const unsigned int xid, struct cifs_ses *ses,
 415                 struct smb_hdr *in_buf, int flags)
 416 {
 417         int rc;
 418         struct kvec iov[1];
 419         int resp_buf_type;
 420
 421         iov[0].iov_base = (char *)in_buf;
 422         iov[0].iov_len = be32_to_cpu(in_buf->smb_buf_length) + 4;
 423         flags |= CIFS_NO_RESP;
 424         rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags);
 425         cFYI(DBG2, "SendRcvNoRsp flags %d rc %d", flags, rc);
 426
 427         return rc;
 428 }
 429
 430 static int
 431 cifs_sync_mid_result(struct mid_q_entry *mid, struct TCP_Server_Info *server)
 432 {
 433         int rc = 0;
 434
 435         cFYI(1, "%s: cmd=%d mid=%d state=%d", __func__, mid->command,
 436                 mid->mid, mid->midState);
 437
 438         spin_lock(&GlobalMid_Lock);
 439         switch (mid->midState) {
 440         case MID_RESPONSE_RECEIVED:
 441                 spin_unlock(&GlobalMid_Lock);
 442                 return rc;
 443         case MID_RETRY_NEEDED:
 444                 rc = -EAGAIN;
 445                 break;
 446         case MID_RESPONSE_MALFORMED:
 447                 rc = -EIO;
 448                 break;
 449         case MID_SHUTDOWN:
 450                 rc = -EHOSTDOWN;
 451                 break;
 452         default:
 453                 list_del_init(&mid->qhead);
 454                 cERROR(1, "%s: invalid mid state mid=%d state=%d", __func__,
 455                         mid->mid, mid->midState);
 456                 rc = -EIO;
 457         }
 458         spin_unlock(&GlobalMid_Lock);
 459
 460         DeleteMidQEntry(mid);
 461         return rc;
 462 }
 463
 464 /*
 465  * An NT cancel request header looks just like the original request except:
 466  *
 467  * The Command is SMB_COM_NT_CANCEL
 468  * The WordCount is zeroed out
 469  * The ByteCount is zeroed out
 470  *
 471  * This function mangles an existing request buffer into a
 472  * SMB_COM_NT_CANCEL request and then sends it.
 473  */
 474 static int
 475 send_nt_cancel(struct TCP_Server_Info *server, struct smb_hdr *in_buf,
 476                 struct mid_q_entry *mid)
 477 {
 478         int rc = 0;
 479
 480         /* -4 for RFC1001 length and +2 for BCC field */
 481         in_buf->smb_buf_length = cpu_to_be32(sizeof(struct smb_hdr) - 4  + 2);
 482         in_buf->Command = SMB_COM_NT_CANCEL;
 483         in_buf->WordCount = 0;
 484         put_bcc(0, in_buf);
 485
 486         mutex_lock(&server->srv_mutex);
 487         rc = cifs_sign_smb(in_buf, server, &mid->sequence_number);
 488         if (rc) {
 489                 mutex_unlock(&server->srv_mutex);
 490                 return rc;
 491         }
 492         rc = smb_send(server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
 493         mutex_unlock(&server->srv_mutex);
 494
 495         cFYI(1, "issued NT_CANCEL for mid %u, rc = %d",
 496                 in_buf->Mid, rc);
 497
 498         return rc;
 499 }
 500
 501 int
 502 cifs_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,
 503                    bool log_error)
 504 {
 505         dump_smb(mid->resp_buf,
 506                  min_t(u32, 92, be32_to_cpu(mid->resp_buf->smb_buf_length)));
 507
 508         /* convert the length into a more usable form */
 509         if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
 510                 /* FIXME: add code to kill session */
 511                 if (cifs_verify_signature(mid->resp_buf, server,
 512                                           mid->sequence_number + 1) != 0)
 513                         cERROR(1, "Unexpected SMB signature");
 514         }
 515
 516         /* BB special case reconnect tid and uid here? */
 517         return map_smb_to_linux_error(mid->resp_buf, log_error);
 518 }
 519
 520 int
 521 SendReceive2(const unsigned int xid, struct cifs_ses *ses,
 522              struct kvec *iov, int n_vec, int *pRespBufType /* ret */,
 523              const int flags)
 524 {
 525         int rc = 0;
 526         int long_op;
 527         struct mid_q_entry *midQ;
 528         struct smb_hdr *in_buf = iov[0].iov_base;
 529
 530         long_op = flags & CIFS_TIMEOUT_MASK;
 531
 532         *pRespBufType = CIFS_NO_BUFFER;  /* no response buf yet */
 533
 534         if ((ses == NULL) || (ses->server == NULL)) {
 535                 cifs_small_buf_release(in_buf);
 536                 cERROR(1, "Null session");
 537                 return -EIO;
 538         }
 539
 540         if (ses->server->tcpStatus == CifsExiting) {
 541                 cifs_small_buf_release(in_buf);
 542                 return -ENOENT;
 543         }
 544
 545         /* Ensure that we do not send more than 50 overlapping requests
 546            to the same server. We may make this configurable later or
 547            use ses->maxReq */
 548
 549         rc = wait_for_free_request(ses->server, long_op);
 550         if (rc) {
 551                 cifs_small_buf_release(in_buf);
 552                 return rc;
 553         }
 554
 555         /* make sure that we sign in the same order that we send on this socket
 556            and avoid races inside tcp sendmsg code that could cause corruption
 557            of smb data */
 558
 559         mutex_lock(&ses->server->srv_mutex);
 560
 561         rc = allocate_mid(ses, in_buf, &midQ);
 562         if (rc) {
 563                 mutex_unlock(&ses->server->srv_mutex);
 564                 cifs_small_buf_release(in_buf);
 565                 /* Update # of requests on wire to server */
 566                 atomic_dec(&ses->server->inFlight);
 567                 wake_up(&ses->server->request_q);
 568                 return rc;
 569         }
 570         rc = cifs_sign_smb2(iov, n_vec, ses->server, &midQ->sequence_number);
 571         if (rc) {
 572                 mutex_unlock(&ses->server->srv_mutex);
 573                 cifs_small_buf_release(in_buf);
 574                 goto out;
 575         }
 576
 577         midQ->midState = MID_REQUEST_SUBMITTED;
 578 #ifdef CONFIG_CIFS_STATS2
 579         atomic_inc(&ses->server->inSend);
 580 #endif
 581         rc = smb_sendv(ses->server, iov, n_vec);
 582 #ifdef CONFIG_CIFS_STATS2
 583         atomic_dec(&ses->server->inSend);
 584         midQ->when_sent = jiffies;
 585 #endif
 586
 587         mutex_unlock(&ses->server->srv_mutex);
 588
 589         if (rc < 0) {
 590                 cifs_small_buf_release(in_buf);
 591                 goto out;
 592         }
 593
 594         if (long_op == CIFS_ASYNC_OP) {
 595                 cifs_small_buf_release(in_buf);
 596                 goto out;
 597         }
 598
 599         rc = wait_for_response(ses->server, midQ);
 600         if (rc != 0) {
 601                 send_nt_cancel(ses->server, in_buf, midQ);
 602                 spin_lock(&GlobalMid_Lock);
 603                 if (midQ->midState == MID_REQUEST_SUBMITTED) {
 604                         midQ->callback = DeleteMidQEntry;
 605                         spin_unlock(&GlobalMid_Lock);
 606                         cifs_small_buf_release(in_buf);
 607                         atomic_dec(&ses->server->inFlight);
 608                         wake_up(&ses->server->request_q);
 609                         return rc;
 610                 }
 611                 spin_unlock(&GlobalMid_Lock);
 612         }
 613
 614         cifs_small_buf_release(in_buf);
 615
 616         rc = cifs_sync_mid_result(midQ, ses->server);
 617         if (rc != 0) {
 618                 atomic_dec(&ses->server->inFlight);
 619                 wake_up(&ses->server->request_q);
 620                 return rc;
 621         }
 622
 623         if (!midQ->resp_buf || midQ->midState != MID_RESPONSE_RECEIVED) {
 624                 rc = -EIO;
 625                 cFYI(1, "Bad MID state?");
 626                 goto out;
 627         }
 628
 629         iov[0].iov_base = (char *)midQ->resp_buf;
 630         iov[0].iov_len = be32_to_cpu(midQ->resp_buf->smb_buf_length) + 4;
 631         if (midQ->largeBuf)
 632                 *pRespBufType = CIFS_LARGE_BUFFER;
 633         else
 634                 *pRespBufType = CIFS_SMALL_BUFFER;
 635
 636         rc = cifs_check_receive(midQ, ses->server, flags & CIFS_LOG_ERROR);
 637
 638         /* mark it so buf will not be freed by delete_mid */
 639         if ((flags & CIFS_NO_RESP) == 0)
 640                 midQ->resp_buf = NULL;
 641 out:
 642         delete_mid(midQ);
 643         atomic_dec(&ses->server->inFlight);
 644         wake_up(&ses->server->request_q);
 645
 646         return rc;
 647 }
 648
 649 int
 650 SendReceive(const unsigned int xid, struct cifs_ses *ses,
 651             struct smb_hdr *in_buf, struct smb_hdr *out_buf,
 652             int *pbytes_returned, const int long_op)
 653 {
 654         int rc = 0;
 655         struct mid_q_entry *midQ;
 656
 657         if (ses == NULL) {
 658                 cERROR(1, "Null smb session");
 659                 return -EIO;
 660         }
 661         if (ses->server == NULL) {
 662                 cERROR(1, "Null tcp session");
 663                 return -EIO;
 664         }
 665
 666         if (ses->server->tcpStatus == CifsExiting)
 667                 return -ENOENT;
 668
 669         /* Ensure that we do not send more than 50 overlapping requests
 670            to the same server. We may make this configurable later or
 671            use ses->maxReq */
 672
 673         if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
 674                         MAX_CIFS_HDR_SIZE - 4) {
 675                 cERROR(1, "Illegal length, greater than maximum frame, %d",
 676                            be32_to_cpu(in_buf->smb_buf_length));
 677                 return -EIO;
 678         }
 679
 680         rc = wait_for_free_request(ses->server, long_op);
 681         if (rc)
 682                 return rc;
 683
 684         /* make sure that we sign in the same order that we send on this socket
 685            and avoid races inside tcp sendmsg code that could cause corruption
 686            of smb data */
 687
 688         mutex_lock(&ses->server->srv_mutex);
 689
 690         rc = allocate_mid(ses, in_buf, &midQ);
 691         if (rc) {
 692                 mutex_unlock(&ses->server->srv_mutex);
 693                 /* Update # of requests on wire to server */
 694                 atomic_dec(&ses->server->inFlight);
 695                 wake_up(&ses->server->request_q);
 696                 return rc;
 697         }
 698
 699         rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
 700         if (rc) {
 701                 mutex_unlock(&ses->server->srv_mutex);
 702                 goto out;
 703         }
 704
 705         midQ->midState = MID_REQUEST_SUBMITTED;
 706 #ifdef CONFIG_CIFS_STATS2
 707         atomic_inc(&ses->server->inSend);
 708 #endif
 709         rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
 710 #ifdef CONFIG_CIFS_STATS2
 711         atomic_dec(&ses->server->inSend);
 712         midQ->when_sent = jiffies;
 713 #endif
 714         mutex_unlock(&ses->server->srv_mutex);
 715
 716         if (rc < 0)
 717                 goto out;
 718
 719         if (long_op == CIFS_ASYNC_OP)
 720                 goto out;
 721
 722         rc = wait_for_response(ses->server, midQ);
 723         if (rc != 0) {
 724                 send_nt_cancel(ses->server, in_buf, midQ);
 725                 spin_lock(&GlobalMid_Lock);
 726                 if (midQ->midState == MID_REQUEST_SUBMITTED) {
 727                         /* no longer considered to be "in-flight" */
 728                         midQ->callback = DeleteMidQEntry;
 729                         spin_unlock(&GlobalMid_Lock);
 730                         atomic_dec(&ses->server->inFlight);
 731                         wake_up(&ses->server->request_q);
 732                         return rc;
 733                 }
 734                 spin_unlock(&GlobalMid_Lock);
 735         }
 736
 737         rc = cifs_sync_mid_result(midQ, ses->server);
 738         if (rc != 0) {
 739                 atomic_dec(&ses->server->inFlight);
 740                 wake_up(&ses->server->request_q);
 741                 return rc;
 742         }
 743
 744         if (!midQ->resp_buf || !out_buf ||
 745             midQ->midState != MID_RESPONSE_RECEIVED) {
 746                 rc = -EIO;
 747                 cERROR(1, "Bad MID state?");
 748                 goto out;
 749         }
 750
 751         *pbytes_returned = be32_to_cpu(midQ->resp_buf->smb_buf_length);
 752         memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
 753         rc = cifs_check_receive(midQ, ses->server, 0);
 754 out:
 755         delete_mid(midQ);
 756         atomic_dec(&ses->server->inFlight);
 757         wake_up(&ses->server->request_q);
 758
 759         return rc;
 760 }
 761
 762 /* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
 763    blocking lock to return. */
 764
 765 static int
 766 send_lock_cancel(const unsigned int xid, struct cifs_tcon *tcon,
 767                         struct smb_hdr *in_buf,
 768                         struct smb_hdr *out_buf)
 769 {
 770         int bytes_returned;
 771         struct cifs_ses *ses = tcon->ses;
 772         LOCK_REQ *pSMB = (LOCK_REQ *)in_buf;
 773
 774         /* We just modify the current in_buf to change
 775            the type of lock from LOCKING_ANDX_SHARED_LOCK
 776            or LOCKING_ANDX_EXCLUSIVE_LOCK to
 777            LOCKING_ANDX_CANCEL_LOCK. */
 778
 779         pSMB->LockType = LOCKING_ANDX_CANCEL_LOCK|LOCKING_ANDX_LARGE_FILES;
 780         pSMB->Timeout = 0;
 781         pSMB->hdr.Mid = GetNextMid(ses->server);
 782
 783         return SendReceive(xid, ses, in_buf, out_buf,
 784                         &bytes_returned, 0);
 785 }
 786
 787 int
 788 SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
 789             struct smb_hdr *in_buf, struct smb_hdr *out_buf,
 790             int *pbytes_returned)
 791 {
 792         int rc = 0;
 793         int rstart = 0;
 794         struct mid_q_entry *midQ;
 795         struct cifs_ses *ses;
 796
 797         if (tcon == NULL || tcon->ses == NULL) {
 798                 cERROR(1, "Null smb session");
 799                 return -EIO;
 800         }
 801         ses = tcon->ses;
 802
 803         if (ses->server == NULL) {
 804                 cERROR(1, "Null tcp session");
 805                 return -EIO;
 806         }
 807
 808         if (ses->server->tcpStatus == CifsExiting)
 809                 return -ENOENT;
 810
 811         /* Ensure that we do not send more than 50 overlapping requests
 812            to the same server. We may make this configurable later or
 813            use ses->maxReq */
 814
 815         if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
 816                         MAX_CIFS_HDR_SIZE - 4) {
 817                 cERROR(1, "Illegal length, greater than maximum frame, %d",
 818                            be32_to_cpu(in_buf->smb_buf_length));
 819                 return -EIO;
 820         }
 821
 822         rc = wait_for_free_request(ses->server, CIFS_BLOCKING_OP);
 823         if (rc)
 824                 return rc;
 825
 826         /* make sure that we sign in the same order that we send on this socket
 827            and avoid races inside tcp sendmsg code that could cause corruption
 828            of smb data */
 829
 830         mutex_lock(&ses->server->srv_mutex);
 831
 832         rc = allocate_mid(ses, in_buf, &midQ);
 833         if (rc) {
 834                 mutex_unlock(&ses->server->srv_mutex);
 835                 return rc;
 836         }
 837
 838         rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
 839         if (rc) {
 840                 delete_mid(midQ);
 841                 mutex_unlock(&ses->server->srv_mutex);
 842                 return rc;
 843         }
 844
 845         midQ->midState = MID_REQUEST_SUBMITTED;
 846 #ifdef CONFIG_CIFS_STATS2
 847         atomic_inc(&ses->server->inSend);
 848 #endif
 849         rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
 850 #ifdef CONFIG_CIFS_STATS2
 851         atomic_dec(&ses->server->inSend);
 852         midQ->when_sent = jiffies;
 853 #endif
 854         mutex_unlock(&ses->server->srv_mutex);
 855
 856         if (rc < 0) {
 857                 delete_mid(midQ);
 858                 return rc;
 859         }
 860
 861         /* Wait for a reply - allow signals to interrupt. */
 862         rc = wait_event_interruptible(ses->server->response_q,
 863                 (!(midQ->midState == MID_REQUEST_SUBMITTED)) ||
 864                 ((ses->server->tcpStatus != CifsGood) &&
 865                  (ses->server->tcpStatus != CifsNew)));
 866
 867         /* Were we interrupted by a signal ? */
 868         if ((rc == -ERESTARTSYS) &&
 869                 (midQ->midState == MID_REQUEST_SUBMITTED) &&
 870                 ((ses->server->tcpStatus == CifsGood) ||
 871                  (ses->server->tcpStatus == CifsNew))) {
 872
 873                 if (in_buf->Command == SMB_COM_TRANSACTION2) {
 874                         /* POSIX lock. We send a NT_CANCEL SMB to cause the
 875                            blocking lock to return. */
 876                         rc = send_nt_cancel(ses->server, in_buf, midQ);
 877                         if (rc) {
 878                                 delete_mid(midQ);
 879                                 return rc;
 880                         }
 881                 } else {
 882                         /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
 883                            to cause the blocking lock to return. */
 884
 885                         rc = send_lock_cancel(xid, tcon, in_buf, out_buf);
 886
 887                         /* If we get -ENOLCK back the lock may have
 888                            already been removed. Don't exit in this case. */
 889                         if (rc && rc != -ENOLCK) {
 890                                 delete_mid(midQ);
 891                                 return rc;
 892                         }
 893                 }
 894
 895                 rc = wait_for_response(ses->server, midQ);
 896                 if (rc) {
 897                         send_nt_cancel(ses->server, in_buf, midQ);
 898                         spin_lock(&GlobalMid_Lock);
 899                         if (midQ->midState == MID_REQUEST_SUBMITTED) {
 900                                 /* no longer considered to be "in-flight" */
 901                                 midQ->callback = DeleteMidQEntry;
 902                                 spin_unlock(&GlobalMid_Lock);
 903                                 return rc;
 904                         }
 905                         spin_unlock(&GlobalMid_Lock);
 906                 }
 907
 908                 /* We got the response - restart system call. */
 909                 rstart = 1;
 910         }
 911
 912         rc = cifs_sync_mid_result(midQ, ses->server);
 913         if (rc != 0)
 914                 return rc;
 915
 916         /* rcvd frame is ok */
 917         if (out_buf == NULL || midQ->midState != MID_RESPONSE_RECEIVED) {
 918                 rc = -EIO;
 919                 cERROR(1, "Bad MID state?");
 920                 goto out;
 921         }
 922
 923         *pbytes_returned = be32_to_cpu(midQ->resp_buf->smb_buf_length);
 924         memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
 925         rc = cifs_check_receive(midQ, ses->server, 0);
 926 out:
 927         delete_mid(midQ);
 928         if (rstart && rc == -EACCES)
 929                 return -ERESTARTSYS;
 930         return rc;
 931 }