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