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