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