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 <linux/tcp.h>
  31 #include <linux/bvec.h>
  32 #include <linux/highmem.h>
  33 #include <linux/uaccess.h>
  34 #include <asm/processor.h>
  35 #include <linux/mempool.h>
  36 #include <linux/signal.h>
  37 #include "cifspdu.h"
  38 #include "cifsglob.h"
  39 #include "cifsproto.h"
  40 #include "cifs_debug.h"
  41 #include "smb2proto.h"
  42 #include "smbdirect.h"
  43
  44 /* Max number of iovectors we can use off the stack when sending requests. */
  45 #define CIFS_MAX_IOV_SIZE 8
  46
  47 void
  48 cifs_wake_up_task(struct mid_q_entry *mid)
  49 {
  50         wake_up_process(mid->callback_data);
  51 }
  52
  53 struct mid_q_entry *
  54 AllocMidQEntry(const struct smb_hdr *smb_buffer, struct TCP_Server_Info *server)
  55 {
  56         struct mid_q_entry *temp;
  57
  58         if (server == NULL) {
  59                 cifs_dbg(VFS, "Null TCP session in AllocMidQEntry\n");
  60                 return NULL;
  61         }
  62
  63         temp = mempool_alloc(cifs_mid_poolp, GFP_NOFS);
  64         memset(temp, 0, sizeof(struct mid_q_entry));
  65         kref_init(&temp->refcount);
  66         temp->mid = get_mid(smb_buffer);
  67         temp->pid = current->pid;
  68         temp->command = cpu_to_le16(smb_buffer->Command);
  69         cifs_dbg(FYI, "For smb_command %d\n", smb_buffer->Command);
  70         /*      do_gettimeofday(&temp->when_sent);*/ /* easier to use jiffies */
  71         /* when mid allocated can be before when sent */
  72         temp->when_alloc = jiffies;
  73         temp->server = server;
  74
  75         /*
  76          * The default is for the mid to be synchronous, so the
  77          * default callback just wakes up the current task.
  78          */
  79         temp->callback = cifs_wake_up_task;
  80         temp->callback_data = current;
  81
  82         atomic_inc(&midCount);
  83         temp->mid_state = MID_REQUEST_ALLOCATED;
  84         return temp;
  85 }
  86
  87 static void _cifs_mid_q_entry_release(struct kref *refcount)
  88 {
  89         struct mid_q_entry *mid = container_of(refcount, struct mid_q_entry,
  90                                                refcount);
  91
  92         mempool_free(mid, cifs_mid_poolp);
  93 }
  94
  95 void cifs_mid_q_entry_release(struct mid_q_entry *midEntry)
  96 {
  97         spin_lock(&GlobalMid_Lock);
  98         kref_put(&midEntry->refcount, _cifs_mid_q_entry_release);
  99         spin_unlock(&GlobalMid_Lock);
 100 }
 101
 102 void
 103 DeleteMidQEntry(struct mid_q_entry *midEntry)
 104 {
 105 #ifdef CONFIG_CIFS_STATS2
 106         __le16 command = midEntry->server->vals->lock_cmd;
 107         unsigned long now;
 108 #endif
 109         midEntry->mid_state = MID_FREE;
 110         atomic_dec(&midCount);
 111         if (midEntry->large_buf)
 112                 cifs_buf_release(midEntry->resp_buf);
 113         else
 114                 cifs_small_buf_release(midEntry->resp_buf);
 115 #ifdef CONFIG_CIFS_STATS2
 116         now = jiffies;
 117         /*
 118          * commands taking longer than one second (default) can be indications
 119          * that something is wrong, unless it is quite a slow link or a very
 120          * busy server. Note that this calc is unlikely or impossible to wrap
 121          * as long as slow_rsp_threshold is not set way above recommended max
 122          * value (32767 ie 9 hours) and is generally harmless even if wrong
 123          * since only affects debug counters - so leaving the calc as simple
 124          * comparison rather than doing multiple conversions and overflow
 125          * checks
 126          */
 127         if ((slow_rsp_threshold != 0) &&
 128             time_after(now, midEntry->when_alloc + (slow_rsp_threshold * HZ)) &&
 129             (midEntry->command != command)) {
 130                 /*
 131                  * smb2slowcmd[NUMBER_OF_SMB2_COMMANDS] counts by command
 132                  * NB: le16_to_cpu returns unsigned so can not be negative below
 133                  */
 134                 if (le16_to_cpu(midEntry->command) < NUMBER_OF_SMB2_COMMANDS)
 135                         cifs_stats_inc(&midEntry->server->smb2slowcmd[le16_to_cpu(midEntry->command)]);
 136
 137                 trace_smb3_slow_rsp(le16_to_cpu(midEntry->command),
 138                                midEntry->mid, midEntry->pid,
 139                                midEntry->when_sent, midEntry->when_received);
 140                 if (cifsFYI & CIFS_TIMER) {
 141                         pr_debug(" CIFS slow rsp: cmd %d mid %llu",
 142                                midEntry->command, midEntry->mid);
 143                         cifs_info(" A: 0x%lx S: 0x%lx R: 0x%lx\n",
 144                                now - midEntry->when_alloc,
 145                                now - midEntry->when_sent,
 146                                now - midEntry->when_received);
 147                 }
 148         }
 149 #endif
 150         cifs_mid_q_entry_release(midEntry);
 151 }
 152
 153 void
 154 cifs_delete_mid(struct mid_q_entry *mid)
 155 {
 156         spin_lock(&GlobalMid_Lock);
 157         list_del_init(&mid->qhead);
 158         mid->mid_flags |= MID_DELETED;
 159         spin_unlock(&GlobalMid_Lock);
 160
 161         DeleteMidQEntry(mid);
 162 }
 163
 164 /*
 165  * smb_send_kvec - send an array of kvecs to the server
 166  * @server:     Server to send the data to
 167  * @smb_msg:    Message to send
 168  * @sent:       amount of data sent on socket is stored here
 169  *
 170  * Our basic "send data to server" function. Should be called with srv_mutex
 171  * held. The caller is responsible for handling the results.
 172  */
 173 static int
 174 smb_send_kvec(struct TCP_Server_Info *server, struct msghdr *smb_msg,
 175               size_t *sent)
 176 {
 177         int rc = 0;
 178         int retries = 0;
 179         struct socket *ssocket = server->ssocket;
 180
 181         *sent = 0;
 182
 183         smb_msg->msg_name = (struct sockaddr *) &server->dstaddr;
 184         smb_msg->msg_namelen = sizeof(struct sockaddr);
 185         smb_msg->msg_control = NULL;
 186         smb_msg->msg_controllen = 0;
 187         if (server->noblocksnd)
 188                 smb_msg->msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL;
 189         else
 190                 smb_msg->msg_flags = MSG_NOSIGNAL;
 191
 192         while (msg_data_left(smb_msg)) {
 193                 /*
 194                  * If blocking send, we try 3 times, since each can block
 195                  * for 5 seconds. For nonblocking  we have to try more
 196                  * but wait increasing amounts of time allowing time for
 197                  * socket to clear.  The overall time we wait in either
 198                  * case to send on the socket is about 15 seconds.
 199                  * Similarly we wait for 15 seconds for a response from
 200                  * the server in SendReceive[2] for the server to send
 201                  * a response back for most types of requests (except
 202                  * SMB Write past end of file which can be slow, and
 203                  * blocking lock operations). NFS waits slightly longer
 204                  * than CIFS, but this can make it take longer for
 205                  * nonresponsive servers to be detected and 15 seconds
 206                  * is more than enough time for modern networks to
 207                  * send a packet.  In most cases if we fail to send
 208                  * after the retries we will kill the socket and
 209                  * reconnect which may clear the network problem.
 210                  */
 211                 rc = sock_sendmsg(ssocket, smb_msg);
 212                 if (rc == -EAGAIN) {
 213                         retries++;
 214                         if (retries >= 14 ||
 215                             (!server->noblocksnd && (retries > 2))) {
 216                                 cifs_dbg(VFS, "sends on sock %p stuck for 15 seconds\n",
 217                                          ssocket);
 218                                 return -EAGAIN;
 219                         }
 220                         msleep(1 << retries);
 221                         continue;
 222                 }
 223
 224                 if (rc < 0)
 225                         return rc;
 226
 227                 if (rc == 0) {
 228                         /* should never happen, letting socket clear before
 229                            retrying is our only obvious option here */
 230                         cifs_dbg(VFS, "tcp sent no data\n");
 231                         msleep(500);
 232                         continue;
 233                 }
 234
 235                 /* send was at least partially successful */
 236                 *sent += rc;
 237                 retries = 0; /* in case we get ENOSPC on the next send */
 238         }
 239         return 0;
 240 }
 241
 242 unsigned long
 243 smb_rqst_len(struct TCP_Server_Info *server, struct smb_rqst *rqst)
 244 {
 245         unsigned int i;
 246         struct kvec *iov;
 247         int nvec;
 248         unsigned long buflen = 0;
 249
 250         if (server->vals->header_preamble_size == 0 &&
 251             rqst->rq_nvec >= 2 && rqst->rq_iov[0].iov_len == 4) {
 252                 iov = &rqst->rq_iov[1];
 253                 nvec = rqst->rq_nvec - 1;
 254         } else {
 255                 iov = rqst->rq_iov;
 256                 nvec = rqst->rq_nvec;
 257         }
 258
 259         /* total up iov array first */
 260         for (i = 0; i < nvec; i++)
 261                 buflen += iov[i].iov_len;
 262
 263         /*
 264          * Add in the page array if there is one. The caller needs to make
 265          * sure rq_offset and rq_tailsz are set correctly. If a buffer of
 266          * multiple pages ends at page boundary, rq_tailsz needs to be set to
 267          * PAGE_SIZE.
 268          */
 269         if (rqst->rq_npages) {
 270                 if (rqst->rq_npages == 1)
 271                         buflen += rqst->rq_tailsz;
 272                 else {
 273                         /*
 274                          * If there is more than one page, calculate the
 275                          * buffer length based on rq_offset and rq_tailsz
 276                          */
 277                         buflen += rqst->rq_pagesz * (rqst->rq_npages - 1) -
 278                                         rqst->rq_offset;
 279                         buflen += rqst->rq_tailsz;
 280                 }
 281         }
 282
 283         return buflen;
 284 }
 285
 286 static int
 287 __smb_send_rqst(struct TCP_Server_Info *server, int num_rqst,
 288                 struct smb_rqst *rqst)
 289 {
 290         int rc = 0;
 291         struct kvec *iov;
 292         int n_vec;
 293         unsigned int send_length = 0;
 294         unsigned int i, j;
 295         sigset_t mask, oldmask;
 296         size_t total_len = 0, sent, size;
 297         struct socket *ssocket = server->ssocket;
 298         struct msghdr smb_msg;
 299         int val = 1;
 300         __be32 rfc1002_marker;
 301
 302         if (cifs_rdma_enabled(server) && server->smbd_conn) {
 303                 rc = smbd_send(server, rqst);
 304                 goto smbd_done;
 305         }
 306
 307         if (ssocket == NULL)
 308                 return -EAGAIN;
 309
 310         if (signal_pending(current)) {
 311                 cifs_dbg(FYI, "signal is pending before sending any data\n");
 312                 return -EINTR;
 313         }
 314
 315         /* cork the socket */
 316         kernel_setsockopt(ssocket, SOL_TCP, TCP_CORK,
 317                                 (char *)&val, sizeof(val));
 318
 319         for (j = 0; j < num_rqst; j++)
 320                 send_length += smb_rqst_len(server, &rqst[j]);
 321         rfc1002_marker = cpu_to_be32(send_length);
 322
 323         /*
 324          * We should not allow signals to interrupt the network send because
 325          * any partial send will cause session reconnects thus increasing
 326          * latency of system calls and overload a server with unnecessary
 327          * requests.
 328          */
 329
 330         sigfillset(&mask);
 331         sigprocmask(SIG_BLOCK, &mask, &oldmask);
 332
 333         /* Generate a rfc1002 marker for SMB2+ */
 334         if (server->vals->header_preamble_size == 0) {
 335                 struct kvec hiov = {
 336                         .iov_base = &rfc1002_marker,
 337                         .iov_len  = 4
 338                 };
 339                 iov_iter_kvec(&smb_msg.msg_iter, WRITE, &hiov, 1, 4);
 340                 rc = smb_send_kvec(server, &smb_msg, &sent);
 341                 if (rc < 0)
 342                         goto unmask;
 343
 344                 total_len += sent;
 345                 send_length += 4;
 346         }
 347
 348         cifs_dbg(FYI, "Sending smb: smb_len=%u\n", send_length);
 349
 350         for (j = 0; j < num_rqst; j++) {
 351                 iov = rqst[j].rq_iov;
 352                 n_vec = rqst[j].rq_nvec;
 353
 354                 size = 0;
 355                 for (i = 0; i < n_vec; i++) {
 356                         dump_smb(iov[i].iov_base, iov[i].iov_len);
 357                         size += iov[i].iov_len;
 358                 }
 359
 360                 iov_iter_kvec(&smb_msg.msg_iter, WRITE, iov, n_vec, size);
 361
 362                 rc = smb_send_kvec(server, &smb_msg, &sent);
 363                 if (rc < 0)
 364                         goto unmask;
 365
 366                 total_len += sent;
 367
 368                 /* now walk the page array and send each page in it */
 369                 for (i = 0; i < rqst[j].rq_npages; i++) {
 370                         struct bio_vec bvec;
 371
 372                         bvec.bv_page = rqst[j].rq_pages[i];
 373                         rqst_page_get_length(&rqst[j], i, &bvec.bv_len,
 374                                              &bvec.bv_offset);
 375
 376                         iov_iter_bvec(&smb_msg.msg_iter, WRITE,
 377                                       &bvec, 1, bvec.bv_len);
 378                         rc = smb_send_kvec(server, &smb_msg, &sent);
 379                         if (rc < 0)
 380                                 break;
 381
 382                         total_len += sent;
 383                 }
 384         }
 385
 386 unmask:
 387         sigprocmask(SIG_SETMASK, &oldmask, NULL);
 388
 389         /*
 390          * If signal is pending but we have already sent the whole packet to
 391          * the server we need to return success status to allow a corresponding
 392          * mid entry to be kept in the pending requests queue thus allowing
 393          * to handle responses from the server by the client.
 394          *
 395          * If only part of the packet has been sent there is no need to hide
 396          * interrupt because the session will be reconnected anyway, so there
 397          * won't be any response from the server to handle.
 398          */
 399
 400         if (signal_pending(current) && (total_len != send_length)) {
 401                 cifs_dbg(FYI, "signal is pending after attempt to send\n");
 402                 rc = -EINTR;
 403         }
 404
 405         /* uncork it */
 406         val = 0;
 407         kernel_setsockopt(ssocket, SOL_TCP, TCP_CORK,
 408                                 (char *)&val, sizeof(val));
 409
 410         if ((total_len > 0) && (total_len != send_length)) {
 411                 cifs_dbg(FYI, "partial send (wanted=%u sent=%zu): terminating session\n",
 412                          send_length, total_len);
 413                 /*
 414                  * If we have only sent part of an SMB then the next SMB could
 415                  * be taken as the remainder of this one. We need to kill the
 416                  * socket so the server throws away the partial SMB
 417                  */
 418                 server->tcpStatus = CifsNeedReconnect;
 419                 trace_smb3_partial_send_reconnect(server->CurrentMid,
 420                                                   server->hostname);
 421         }
 422 smbd_done:
 423         if (rc < 0 && rc != -EINTR)
 424                 cifs_dbg(VFS, "Error %d sending data on socket to server\n",
 425                          rc);
 426         else if (rc > 0)
 427                 rc = 0;
 428
 429         return rc;
 430 }
 431
 432 static int
 433 smb_send_rqst(struct TCP_Server_Info *server, int num_rqst,
 434               struct smb_rqst *rqst, int flags)
 435 {
 436         struct kvec iov;
 437         struct smb2_transform_hdr tr_hdr;
 438         struct smb_rqst cur_rqst[MAX_COMPOUND];
 439         int rc;
 440
 441         if (!(flags & CIFS_TRANSFORM_REQ))
 442                 return __smb_send_rqst(server, num_rqst, rqst);
 443
 444         if (num_rqst > MAX_COMPOUND - 1)
 445                 return -ENOMEM;
 446
 447         memset(&cur_rqst[0], 0, sizeof(cur_rqst));
 448         memset(&iov, 0, sizeof(iov));
 449         memset(&tr_hdr, 0, sizeof(tr_hdr));
 450
 451         iov.iov_base = &tr_hdr;
 452         iov.iov_len = sizeof(tr_hdr);
 453         cur_rqst[0].rq_iov = &iov;
 454         cur_rqst[0].rq_nvec = 1;
 455
 456         if (!server->ops->init_transform_rq) {
 457                 cifs_dbg(VFS, "Encryption requested but transform callback "
 458                          "is missing\n");
 459                 return -EIO;
 460         }
 461
 462         rc = server->ops->init_transform_rq(server, num_rqst + 1,
 463                                             &cur_rqst[0], rqst);
 464         if (rc)
 465                 return rc;
 466
 467         rc = __smb_send_rqst(server, num_rqst + 1, &cur_rqst[0]);
 468         smb3_free_compound_rqst(num_rqst, &cur_rqst[1]);
 469         return rc;
 470 }
 471
 472 int
 473 smb_send(struct TCP_Server_Info *server, struct smb_hdr *smb_buffer,
 474          unsigned int smb_buf_length)
 475 {
 476         struct kvec iov[2];
 477         struct smb_rqst rqst = { .rq_iov = iov,
 478                                  .rq_nvec = 2 };
 479
 480         iov[0].iov_base = smb_buffer;
 481         iov[0].iov_len = 4;
 482         iov[1].iov_base = (char *)smb_buffer + 4;
 483         iov[1].iov_len = smb_buf_length;
 484
 485         return __smb_send_rqst(server, 1, &rqst);
 486 }
 487
 488 static int
 489 wait_for_free_credits(struct TCP_Server_Info *server, const int flags,
 490                       unsigned int *instance)
 491 {
 492         int rc;
 493         int *credits;
 494         int optype;
 495
 496         optype = flags & CIFS_OP_MASK;
 497
 498         *instance = 0;
 499
 500         credits = server->ops->get_credits_field(server, optype);
 501         /* Since an echo is already inflight, no need to wait to send another */
 502         if (*credits <= 0 && optype == CIFS_ECHO_OP)
 503                 return -EAGAIN;
 504
 505         spin_lock(&server->req_lock);
 506         if ((flags & CIFS_TIMEOUT_MASK) == CIFS_ASYNC_OP) {
 507                 /* oplock breaks must not be held up */
 508                 server->in_flight++;
 509                 *credits -= 1;
 510                 *instance = server->reconnect_instance;
 511                 spin_unlock(&server->req_lock);
 512                 return 0;
 513         }
 514
 515         while (1) {
 516                 if (*credits <= 0) {
 517                         spin_unlock(&server->req_lock);
 518                         cifs_num_waiters_inc(server);
 519                         rc = wait_event_killable(server->request_q,
 520                                                  has_credits(server, credits));
 521                         cifs_num_waiters_dec(server);
 522                         if (rc)
 523                                 return rc;
 524                         spin_lock(&server->req_lock);
 525                 } else {
 526                         if (server->tcpStatus == CifsExiting) {
 527                                 spin_unlock(&server->req_lock);
 528                                 return -ENOENT;
 529                         }
 530
 531                         /*
 532                          * Can not count locking commands against total
 533                          * as they are allowed to block on server.
 534                          */
 535
 536                         /* update # of requests on the wire to server */
 537                         if ((flags & CIFS_TIMEOUT_MASK) != CIFS_BLOCKING_OP) {
 538                                 *credits -= 1;
 539                                 server->in_flight++;
 540                                 *instance = server->reconnect_instance;
 541                         }
 542                         spin_unlock(&server->req_lock);
 543                         break;
 544                 }
 545         }
 546         return 0;
 547 }
 548
 549 static int
 550 wait_for_free_request(struct TCP_Server_Info *server, const int flags,
 551                       unsigned int *instance)
 552 {
 553         return wait_for_free_credits(server, flags, instance);
 554 }
 555
 556 int
 557 cifs_wait_mtu_credits(struct TCP_Server_Info *server, unsigned int size,
 558                       unsigned int *num, struct cifs_credits *credits)
 559 {
 560         *num = size;
 561         credits->value = 0;
 562         credits->instance = server->reconnect_instance;
 563         return 0;
 564 }
 565
 566 static int allocate_mid(struct cifs_ses *ses, struct smb_hdr *in_buf,
 567                         struct mid_q_entry **ppmidQ)
 568 {
 569         if (ses->server->tcpStatus == CifsExiting) {
 570                 return -ENOENT;
 571         }
 572
 573         if (ses->server->tcpStatus == CifsNeedReconnect) {
 574                 cifs_dbg(FYI, "tcp session dead - return to caller to retry\n");
 575                 return -EAGAIN;
 576         }
 577
 578         if (ses->status == CifsNew) {
 579                 if ((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
 580                         (in_buf->Command != SMB_COM_NEGOTIATE))
 581                         return -EAGAIN;
 582                 /* else ok - we are setting up session */
 583         }
 584
 585         if (ses->status == CifsExiting) {
 586                 /* check if SMB session is bad because we are setting it up */
 587                 if (in_buf->Command != SMB_COM_LOGOFF_ANDX)
 588                         return -EAGAIN;
 589                 /* else ok - we are shutting down session */
 590         }
 591
 592         *ppmidQ = AllocMidQEntry(in_buf, ses->server);
 593         if (*ppmidQ == NULL)
 594                 return -ENOMEM;
 595         spin_lock(&GlobalMid_Lock);
 596         list_add_tail(&(*ppmidQ)->qhead, &ses->server->pending_mid_q);
 597         spin_unlock(&GlobalMid_Lock);
 598         return 0;
 599 }
 600
 601 static int
 602 wait_for_response(struct TCP_Server_Info *server, struct mid_q_entry *midQ)
 603 {
 604         int error;
 605
 606         error = wait_event_freezekillable_unsafe(server->response_q,
 607                                     midQ->mid_state != MID_REQUEST_SUBMITTED);
 608         if (error < 0)
 609                 return -ERESTARTSYS;
 610
 611         return 0;
 612 }
 613
 614 struct mid_q_entry *
 615 cifs_setup_async_request(struct TCP_Server_Info *server, struct smb_rqst *rqst)
 616 {
 617         int rc;
 618         struct smb_hdr *hdr = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
 619         struct mid_q_entry *mid;
 620
 621         if (rqst->rq_iov[0].iov_len != 4 ||
 622             rqst->rq_iov[0].iov_base + 4 != rqst->rq_iov[1].iov_base)
 623                 return ERR_PTR(-EIO);
 624
 625         /* enable signing if server requires it */
 626         if (server->sign)
 627                 hdr->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
 628
 629         mid = AllocMidQEntry(hdr, server);
 630         if (mid == NULL)
 631                 return ERR_PTR(-ENOMEM);
 632
 633         rc = cifs_sign_rqst(rqst, server, &mid->sequence_number);
 634         if (rc) {
 635                 DeleteMidQEntry(mid);
 636                 return ERR_PTR(rc);
 637         }
 638
 639         return mid;
 640 }
 641
 642 /*
 643  * Send a SMB request and set the callback function in the mid to handle
 644  * the result. Caller is responsible for dealing with timeouts.
 645  */
 646 int
 647 cifs_call_async(struct TCP_Server_Info *server, struct smb_rqst *rqst,
 648                 mid_receive_t *receive, mid_callback_t *callback,
 649                 mid_handle_t *handle, void *cbdata, const int flags,
 650                 const struct cifs_credits *exist_credits)
 651 {
 652         int rc;
 653         struct mid_q_entry *mid;
 654         struct cifs_credits credits = { .value = 0, .instance = 0 };
 655         unsigned int instance;
 656         int optype;
 657
 658         optype = flags & CIFS_OP_MASK;
 659
 660         if ((flags & CIFS_HAS_CREDITS) == 0) {
 661                 rc = wait_for_free_request(server, flags, &instance);
 662                 if (rc)
 663                         return rc;
 664                 credits.value = 1;
 665                 credits.instance = instance;
 666         } else
 667                 instance = exist_credits->instance;
 668
 669         mutex_lock(&server->srv_mutex);
 670
 671         /*
 672          * We can't use credits obtained from the previous session to send this
 673          * request. Check if there were reconnects after we obtained credits and
 674          * return -EAGAIN in such cases to let callers handle it.
 675          */
 676         if (instance != server->reconnect_instance) {
 677                 mutex_unlock(&server->srv_mutex);
 678                 add_credits_and_wake_if(server, &credits, optype);
 679                 return -EAGAIN;
 680         }
 681
 682         mid = server->ops->setup_async_request(server, rqst);
 683         if (IS_ERR(mid)) {
 684                 mutex_unlock(&server->srv_mutex);
 685                 add_credits_and_wake_if(server, &credits, optype);
 686                 return PTR_ERR(mid);
 687         }
 688
 689         mid->receive = receive;
 690         mid->callback = callback;
 691         mid->callback_data = cbdata;
 692         mid->handle = handle;
 693         mid->mid_state = MID_REQUEST_SUBMITTED;
 694
 695         /* put it on the pending_mid_q */
 696         spin_lock(&GlobalMid_Lock);
 697         list_add_tail(&mid->qhead, &server->pending_mid_q);
 698         spin_unlock(&GlobalMid_Lock);
 699
 700         /*
 701          * Need to store the time in mid before calling I/O. For call_async,
 702          * I/O response may come back and free the mid entry on another thread.
 703          */
 704         cifs_save_when_sent(mid);
 705         cifs_in_send_inc(server);
 706         rc = smb_send_rqst(server, 1, rqst, flags);
 707         cifs_in_send_dec(server);
 708
 709         if (rc < 0) {
 710                 revert_current_mid(server, mid->credits);
 711                 server->sequence_number -= 2;
 712                 cifs_delete_mid(mid);
 713         }
 714
 715         mutex_unlock(&server->srv_mutex);
 716
 717         if (rc == 0)
 718                 return 0;
 719
 720         add_credits_and_wake_if(server, &credits, optype);
 721         return rc;
 722 }
 723
 724 /*
 725  *
 726  * Send an SMB Request.  No response info (other than return code)
 727  * needs to be parsed.
 728  *
 729  * flags indicate the type of request buffer and how long to wait
 730  * and whether to log NT STATUS code (error) before mapping it to POSIX error
 731  *
 732  */
 733 int
 734 SendReceiveNoRsp(const unsigned int xid, struct cifs_ses *ses,
 735                  char *in_buf, int flags)
 736 {
 737         int rc;
 738         struct kvec iov[1];
 739         struct kvec rsp_iov;
 740         int resp_buf_type;
 741
 742         iov[0].iov_base = in_buf;
 743         iov[0].iov_len = get_rfc1002_length(in_buf) + 4;
 744         flags |= CIFS_NO_RESP;
 745         rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags, &rsp_iov);
 746         cifs_dbg(NOISY, "SendRcvNoRsp flags %d rc %d\n", flags, rc);
 747
 748         return rc;
 749 }
 750
 751 static int
 752 cifs_sync_mid_result(struct mid_q_entry *mid, struct TCP_Server_Info *server)
 753 {
 754         int rc = 0;
 755
 756         cifs_dbg(FYI, "%s: cmd=%d mid=%llu state=%d\n",
 757                  __func__, le16_to_cpu(mid->command), mid->mid, mid->mid_state);
 758
 759         spin_lock(&GlobalMid_Lock);
 760         switch (mid->mid_state) {
 761         case MID_RESPONSE_RECEIVED:
 762                 spin_unlock(&GlobalMid_Lock);
 763                 return rc;
 764         case MID_RETRY_NEEDED:
 765                 rc = -EAGAIN;
 766                 break;
 767         case MID_RESPONSE_MALFORMED:
 768                 rc = -EIO;
 769                 break;
 770         case MID_SHUTDOWN:
 771                 rc = -EHOSTDOWN;
 772                 break;
 773         default:
 774                 list_del_init(&mid->qhead);
 775                 cifs_dbg(VFS, "%s: invalid mid state mid=%llu state=%d\n",
 776                          __func__, mid->mid, mid->mid_state);
 777                 rc = -EIO;
 778         }
 779         spin_unlock(&GlobalMid_Lock);
 780
 781         DeleteMidQEntry(mid);
 782         return rc;
 783 }
 784
 785 static inline int
 786 send_cancel(struct TCP_Server_Info *server, struct smb_rqst *rqst,
 787             struct mid_q_entry *mid)
 788 {
 789         return server->ops->send_cancel ?
 790                                 server->ops->send_cancel(server, rqst, mid) : 0;
 791 }
 792
 793 int
 794 cifs_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,
 795                    bool log_error)
 796 {
 797         unsigned int len = get_rfc1002_length(mid->resp_buf) + 4;
 798
 799         dump_smb(mid->resp_buf, min_t(u32, 92, len));
 800
 801         /* convert the length into a more usable form */
 802         if (server->sign) {
 803                 struct kvec iov[2];
 804                 int rc = 0;
 805                 struct smb_rqst rqst = { .rq_iov = iov,
 806                                          .rq_nvec = 2 };
 807
 808                 iov[0].iov_base = mid->resp_buf;
 809                 iov[0].iov_len = 4;
 810                 iov[1].iov_base = (char *)mid->resp_buf + 4;
 811                 iov[1].iov_len = len - 4;
 812                 /* FIXME: add code to kill session */
 813                 rc = cifs_verify_signature(&rqst, server,
 814                                            mid->sequence_number);
 815                 if (rc)
 816                         cifs_dbg(VFS, "SMB signature verification returned error = %d\n",
 817                                  rc);
 818         }
 819
 820         /* BB special case reconnect tid and uid here? */
 821         return map_smb_to_linux_error(mid->resp_buf, log_error);
 822 }
 823
 824 struct mid_q_entry *
 825 cifs_setup_request(struct cifs_ses *ses, struct smb_rqst *rqst)
 826 {
 827         int rc;
 828         struct smb_hdr *hdr = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
 829         struct mid_q_entry *mid;
 830
 831         if (rqst->rq_iov[0].iov_len != 4 ||
 832             rqst->rq_iov[0].iov_base + 4 != rqst->rq_iov[1].iov_base)
 833                 return ERR_PTR(-EIO);
 834
 835         rc = allocate_mid(ses, hdr, &mid);
 836         if (rc)
 837                 return ERR_PTR(rc);
 838         rc = cifs_sign_rqst(rqst, ses->server, &mid->sequence_number);
 839         if (rc) {
 840                 cifs_delete_mid(mid);
 841                 return ERR_PTR(rc);
 842         }
 843         return mid;
 844 }
 845
 846 static void
 847 cifs_compound_callback(struct mid_q_entry *mid)
 848 {
 849         struct TCP_Server_Info *server = mid->server;
 850         struct cifs_credits credits;
 851
 852         credits.value = server->ops->get_credits(mid);
 853         credits.instance = server->reconnect_instance;
 854
 855         add_credits(server, &credits, mid->optype);
 856 }
 857
 858 static void
 859 cifs_compound_last_callback(struct mid_q_entry *mid)
 860 {
 861         cifs_compound_callback(mid);
 862         cifs_wake_up_task(mid);
 863 }
 864
 865 static void
 866 cifs_cancelled_callback(struct mid_q_entry *mid)
 867 {
 868         cifs_compound_callback(mid);
 869         DeleteMidQEntry(mid);
 870 }
 871
 872 int
 873 compound_send_recv(const unsigned int xid, struct cifs_ses *ses,
 874                    const int flags, const int num_rqst, struct smb_rqst *rqst,
 875                    int *resp_buf_type, struct kvec *resp_iov)
 876 {
 877         int i, j, optype, rc = 0;
 878         struct mid_q_entry *midQ[MAX_COMPOUND];
 879         bool cancelled_mid[MAX_COMPOUND] = {false};
 880         struct cifs_credits credits[MAX_COMPOUND] = {
 881                 { .value = 0, .instance = 0 }
 882         };
 883         unsigned int instance;
 884         unsigned int first_instance = 0;
 885         char *buf;
 886
 887         optype = flags & CIFS_OP_MASK;
 888
 889         for (i = 0; i < num_rqst; i++)
 890                 resp_buf_type[i] = CIFS_NO_BUFFER;  /* no response buf yet */
 891
 892         if ((ses == NULL) || (ses->server == NULL)) {
 893                 cifs_dbg(VFS, "Null session\n");
 894                 return -EIO;
 895         }
 896
 897         if (ses->server->tcpStatus == CifsExiting)
 898                 return -ENOENT;
 899
 900         spin_lock(&ses->server->req_lock);
 901         if (ses->server->credits < num_rqst) {
 902                 /*
 903                  * Return immediately if not too many requests in flight since
 904                  * we will likely be stuck on waiting for credits.
 905                  */
 906                 if (ses->server->in_flight < num_rqst - ses->server->credits) {
 907                         spin_unlock(&ses->server->req_lock);
 908                         return -ENOTSUPP;
 909                 }
 910         } else {
 911                 /* enough credits to send the whole compounded request */
 912                 ses->server->credits -= num_rqst;
 913                 ses->server->in_flight += num_rqst;
 914                 first_instance = ses->server->reconnect_instance;
 915         }
 916         spin_unlock(&ses->server->req_lock);
 917
 918         if (first_instance) {
 919                 cifs_dbg(FYI, "Acquired %d credits at once\n", num_rqst);
 920                 for (i = 0; i < num_rqst; i++) {
 921                         credits[i].value = 1;
 922                         credits[i].instance = first_instance;
 923                 }
 924                 goto setup_rqsts;
 925         }
 926
 927         /*
 928          * There are not enough credits to send the whole compound request but
 929          * there are requests in flight that may bring credits from the server.
 930          * This approach still leaves the possibility to be stuck waiting for
 931          * credits if the server doesn't grant credits to the outstanding
 932          * requests. This should be fixed by returning immediately and letting
 933          * a caller fallback to sequential commands instead of compounding.
 934          * Ensure we obtain 1 credit per request in the compound chain.
 935          */
 936         for (i = 0; i < num_rqst; i++) {
 937                 rc = wait_for_free_request(ses->server, flags, &instance);
 938
 939                 if (rc == 0) {
 940                         credits[i].value = 1;
 941                         credits[i].instance = instance;
 942                         /*
 943                          * All parts of the compound chain must get credits from
 944                          * the same session, otherwise we may end up using more
 945                          * credits than the server granted. If there were
 946                          * reconnects in between, return -EAGAIN and let callers
 947                          * handle it.
 948                          */
 949                         if (i == 0)
 950                                 first_instance = instance;
 951                         else if (first_instance != instance) {
 952                                 i++;
 953                                 rc = -EAGAIN;
 954                         }
 955                 }
 956
 957                 if (rc) {
 958                         /*
 959                          * We haven't sent an SMB packet to the server yet but
 960                          * we already obtained credits for i requests in the
 961                          * compound chain - need to return those credits back
 962                          * for future use. Note that we need to call add_credits
 963                          * multiple times to match the way we obtained credits
 964                          * in the first place and to account for in flight
 965                          * requests correctly.
 966                          */
 967                         for (j = 0; j < i; j++)
 968                                 add_credits(ses->server, &credits[j], optype);
 969                         return rc;
 970                 }
 971         }
 972
 973 setup_rqsts:
 974         /*
 975          * Make sure that we sign in the same order that we send on this socket
 976          * and avoid races inside tcp sendmsg code that could cause corruption
 977          * of smb data.
 978          */
 979
 980         mutex_lock(&ses->server->srv_mutex);
 981
 982         /*
 983          * All the parts of the compound chain belong obtained credits from the
 984          * same session (see the appropriate checks above). In the same time
 985          * there might be reconnects after those checks but before we acquired
 986          * the srv_mutex. We can not use credits obtained from the previous
 987          * session to send this request. Check if there were reconnects after
 988          * we obtained credits and return -EAGAIN in such cases to let callers
 989          * handle it.
 990          */
 991         if (first_instance != ses->server->reconnect_instance) {
 992                 mutex_unlock(&ses->server->srv_mutex);
 993                 for (j = 0; j < num_rqst; j++)
 994                         add_credits(ses->server, &credits[j], optype);
 995                 return -EAGAIN;
 996         }
 997
 998         for (i = 0; i < num_rqst; i++) {
 999                 midQ[i] = ses->server->ops->setup_request(ses, &rqst[i]);
1000                 if (IS_ERR(midQ[i])) {
1001                         revert_current_mid(ses->server, i);
1002                         for (j = 0; j < i; j++)
1003                                 cifs_delete_mid(midQ[j]);
1004                         mutex_unlock(&ses->server->srv_mutex);
1005
1006                         /* Update # of requests on wire to server */
1007                         for (j = 0; j < num_rqst; j++)
1008                                 add_credits(ses->server, &credits[j], optype);
1009                         return PTR_ERR(midQ[i]);
1010                 }
1011
1012                 midQ[i]->mid_state = MID_REQUEST_SUBMITTED;
1013                 midQ[i]->optype = optype;
1014                 /*
1015                  * Invoke callback for every part of the compound chain
1016                  * to calculate credits properly. Wake up this thread only when
1017                  * the last element is received.
1018                  */
1019                 if (i < num_rqst - 1)
1020                         midQ[i]->callback = cifs_compound_callback;
1021                 else
1022                         midQ[i]->callback = cifs_compound_last_callback;
1023         }
1024         cifs_in_send_inc(ses->server);
1025         rc = smb_send_rqst(ses->server, num_rqst, rqst, flags);
1026         cifs_in_send_dec(ses->server);
1027
1028         for (i = 0; i < num_rqst; i++)
1029                 cifs_save_when_sent(midQ[i]);
1030
1031         if (rc < 0) {
1032                 revert_current_mid(ses->server, num_rqst);
1033                 ses->server->sequence_number -= 2;
1034         }
1035
1036         mutex_unlock(&ses->server->srv_mutex);
1037
1038         if (rc < 0) {
1039                 /* Sending failed for some reason - return credits back */
1040                 for (i = 0; i < num_rqst; i++)
1041                         add_credits(ses->server, &credits[i], optype);
1042                 goto out;
1043         }
1044
1045         /*
1046          * At this point the request is passed to the network stack - we assume
1047          * that any credits taken from the server structure on the client have
1048          * been spent and we can't return them back. Once we receive responses
1049          * we will collect credits granted by the server in the mid callbacks
1050          * and add those credits to the server structure.
1051          */
1052
1053         /*
1054          * Compounding is never used during session establish.
1055          */
1056         if ((ses->status == CifsNew) || (optype & CIFS_NEG_OP))
1057                 smb311_update_preauth_hash(ses, rqst[0].rq_iov,
1058                                            rqst[0].rq_nvec);
1059
1060         if ((flags & CIFS_TIMEOUT_MASK) == CIFS_ASYNC_OP)
1061                 goto out;
1062
1063         for (i = 0; i < num_rqst; i++) {
1064                 rc = wait_for_response(ses->server, midQ[i]);
1065                 if (rc != 0)
1066                         break;
1067         }
1068         if (rc != 0) {
1069                 for (; i < num_rqst; i++) {
1070                         cifs_dbg(VFS, "Cancelling wait for mid %llu cmd: %d\n",
1071                                  midQ[i]->mid, le16_to_cpu(midQ[i]->command));
1072                         send_cancel(ses->server, &rqst[i], midQ[i]);
1073                         spin_lock(&GlobalMid_Lock);
1074                         if (midQ[i]->mid_state == MID_REQUEST_SUBMITTED) {
1075                                 midQ[i]->mid_flags |= MID_WAIT_CANCELLED;
1076                                 midQ[i]->callback = cifs_cancelled_callback;
1077                                 cancelled_mid[i] = true;
1078                                 credits[i].value = 0;
1079                         }
1080                         spin_unlock(&GlobalMid_Lock);
1081                 }
1082         }
1083
1084         for (i = 0; i < num_rqst; i++) {
1085                 if (rc < 0)
1086                         goto out;
1087
1088                 rc = cifs_sync_mid_result(midQ[i], ses->server);
1089                 if (rc != 0) {
1090                         /* mark this mid as cancelled to not free it below */
1091                         cancelled_mid[i] = true;
1092                         goto out;
1093                 }
1094
1095                 if (!midQ[i]->resp_buf ||
1096                     midQ[i]->mid_state != MID_RESPONSE_RECEIVED) {
1097                         rc = -EIO;
1098                         cifs_dbg(FYI, "Bad MID state?\n");
1099                         goto out;
1100                 }
1101
1102                 buf = (char *)midQ[i]->resp_buf;
1103                 resp_iov[i].iov_base = buf;
1104                 resp_iov[i].iov_len = midQ[i]->resp_buf_size +
1105                         ses->server->vals->header_preamble_size;
1106
1107                 if (midQ[i]->large_buf)
1108                         resp_buf_type[i] = CIFS_LARGE_BUFFER;
1109                 else
1110                         resp_buf_type[i] = CIFS_SMALL_BUFFER;
1111
1112                 rc = ses->server->ops->check_receive(midQ[i], ses->server,
1113                                                      flags & CIFS_LOG_ERROR);
1114
1115                 /* mark it so buf will not be freed by cifs_delete_mid */
1116                 if ((flags & CIFS_NO_RESP) == 0)
1117                         midQ[i]->resp_buf = NULL;
1118
1119         }
1120
1121         /*
1122          * Compounding is never used during session establish.
1123          */
1124         if ((ses->status == CifsNew) || (optype & CIFS_NEG_OP)) {
1125                 struct kvec iov = {
1126                         .iov_base = resp_iov[0].iov_base,
1127                         .iov_len = resp_iov[0].iov_len
1128                 };
1129                 smb311_update_preauth_hash(ses, &iov, 1);
1130         }
1131
1132 out:
1133         /*
1134          * This will dequeue all mids. After this it is important that the
1135          * demultiplex_thread will not process any of these mids any futher.
1136          * This is prevented above by using a noop callback that will not
1137          * wake this thread except for the very last PDU.
1138          */
1139         for (i = 0; i < num_rqst; i++) {
1140                 if (!cancelled_mid[i])
1141                         cifs_delete_mid(midQ[i]);
1142         }
1143
1144         return rc;
1145 }
1146
1147 int
1148 cifs_send_recv(const unsigned int xid, struct cifs_ses *ses,
1149                struct smb_rqst *rqst, int *resp_buf_type, const int flags,
1150                struct kvec *resp_iov)
1151 {
1152         return compound_send_recv(xid, ses, flags, 1, rqst, resp_buf_type,
1153                                   resp_iov);
1154 }
1155
1156 int
1157 SendReceive2(const unsigned int xid, struct cifs_ses *ses,
1158              struct kvec *iov, int n_vec, int *resp_buf_type /* ret */,
1159              const int flags, struct kvec *resp_iov)
1160 {
1161         struct smb_rqst rqst;
1162         struct kvec s_iov[CIFS_MAX_IOV_SIZE], *new_iov;
1163         int rc;
1164
1165         if (n_vec + 1 > CIFS_MAX_IOV_SIZE) {
1166                 new_iov = kmalloc_array(n_vec + 1, sizeof(struct kvec),
1167                                         GFP_KERNEL);
1168                 if (!new_iov) {
1169                         /* otherwise cifs_send_recv below sets resp_buf_type */
1170                         *resp_buf_type = CIFS_NO_BUFFER;
1171                         return -ENOMEM;
1172                 }
1173         } else
1174                 new_iov = s_iov;
1175
1176         /* 1st iov is a RFC1001 length followed by the rest of the packet */
1177         memcpy(new_iov + 1, iov, (sizeof(struct kvec) * n_vec));
1178
1179         new_iov[0].iov_base = new_iov[1].iov_base;
1180         new_iov[0].iov_len = 4;
1181         new_iov[1].iov_base += 4;
1182         new_iov[1].iov_len -= 4;
1183
1184         memset(&rqst, 0, sizeof(struct smb_rqst));
1185         rqst.rq_iov = new_iov;
1186         rqst.rq_nvec = n_vec + 1;
1187
1188         rc = cifs_send_recv(xid, ses, &rqst, resp_buf_type, flags, resp_iov);
1189         if (n_vec + 1 > CIFS_MAX_IOV_SIZE)
1190                 kfree(new_iov);
1191         return rc;
1192 }
1193
1194 int
1195 SendReceive(const unsigned int xid, struct cifs_ses *ses,
1196             struct smb_hdr *in_buf, struct smb_hdr *out_buf,
1197             int *pbytes_returned, const int flags)
1198 {
1199         int rc = 0;
1200         struct mid_q_entry *midQ;
1201         unsigned int len = be32_to_cpu(in_buf->smb_buf_length);
1202         struct kvec iov = { .iov_base = in_buf, .iov_len = len };
1203         struct smb_rqst rqst = { .rq_iov = &iov, .rq_nvec = 1 };
1204         struct cifs_credits credits = { .value = 1, .instance = 0 };
1205
1206         if (ses == NULL) {
1207                 cifs_dbg(VFS, "Null smb session\n");
1208                 return -EIO;
1209         }
1210         if (ses->server == NULL) {
1211                 cifs_dbg(VFS, "Null tcp session\n");
1212                 return -EIO;
1213         }
1214
1215         if (ses->server->tcpStatus == CifsExiting)
1216                 return -ENOENT;
1217
1218         /* Ensure that we do not send more than 50 overlapping requests
1219            to the same server. We may make this configurable later or
1220            use ses->maxReq */
1221
1222         if (len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
1223                 cifs_dbg(VFS, "Illegal length, greater than maximum frame, %d\n",
1224                          len);
1225                 return -EIO;
1226         }
1227
1228         rc = wait_for_free_request(ses->server, flags, &credits.instance);
1229         if (rc)
1230                 return rc;
1231
1232         /* make sure that we sign in the same order that we send on this socket
1233            and avoid races inside tcp sendmsg code that could cause corruption
1234            of smb data */
1235
1236         mutex_lock(&ses->server->srv_mutex);
1237
1238         rc = allocate_mid(ses, in_buf, &midQ);
1239         if (rc) {
1240                 mutex_unlock(&ses->server->srv_mutex);
1241                 /* Update # of requests on wire to server */
1242                 add_credits(ses->server, &credits, 0);
1243                 return rc;
1244         }
1245
1246         rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
1247         if (rc) {
1248                 mutex_unlock(&ses->server->srv_mutex);
1249                 goto out;
1250         }
1251
1252         midQ->mid_state = MID_REQUEST_SUBMITTED;
1253
1254         cifs_in_send_inc(ses->server);
1255         rc = smb_send(ses->server, in_buf, len);
1256         cifs_in_send_dec(ses->server);
1257         cifs_save_when_sent(midQ);
1258
1259         if (rc < 0)
1260                 ses->server->sequence_number -= 2;
1261
1262         mutex_unlock(&ses->server->srv_mutex);
1263
1264         if (rc < 0)
1265                 goto out;
1266
1267         if ((flags & CIFS_TIMEOUT_MASK) == CIFS_ASYNC_OP)
1268                 goto out;
1269
1270         rc = wait_for_response(ses->server, midQ);
1271         if (rc != 0) {
1272                 send_cancel(ses->server, &rqst, midQ);
1273                 spin_lock(&GlobalMid_Lock);
1274                 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
1275                         /* no longer considered to be "in-flight" */
1276                         midQ->callback = DeleteMidQEntry;
1277                         spin_unlock(&GlobalMid_Lock);
1278                         add_credits(ses->server, &credits, 0);
1279                         return rc;
1280                 }
1281                 spin_unlock(&GlobalMid_Lock);
1282         }
1283
1284         rc = cifs_sync_mid_result(midQ, ses->server);
1285         if (rc != 0) {
1286                 add_credits(ses->server, &credits, 0);
1287                 return rc;
1288         }
1289
1290         if (!midQ->resp_buf || !out_buf ||
1291             midQ->mid_state != MID_RESPONSE_RECEIVED) {
1292                 rc = -EIO;
1293                 cifs_dbg(VFS, "Bad MID state?\n");
1294                 goto out;
1295         }
1296
1297         *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
1298         memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
1299         rc = cifs_check_receive(midQ, ses->server, 0);
1300 out:
1301         cifs_delete_mid(midQ);
1302         add_credits(ses->server, &credits, 0);
1303
1304         return rc;
1305 }
1306
1307 /* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
1308    blocking lock to return. */
1309
1310 static int
1311 send_lock_cancel(const unsigned int xid, struct cifs_tcon *tcon,
1312                         struct smb_hdr *in_buf,
1313                         struct smb_hdr *out_buf)
1314 {
1315         int bytes_returned;
1316         struct cifs_ses *ses = tcon->ses;
1317         LOCK_REQ *pSMB = (LOCK_REQ *)in_buf;
1318
1319         /* We just modify the current in_buf to change
1320            the type of lock from LOCKING_ANDX_SHARED_LOCK
1321            or LOCKING_ANDX_EXCLUSIVE_LOCK to
1322            LOCKING_ANDX_CANCEL_LOCK. */
1323
1324         pSMB->LockType = LOCKING_ANDX_CANCEL_LOCK|LOCKING_ANDX_LARGE_FILES;
1325         pSMB->Timeout = 0;
1326         pSMB->hdr.Mid = get_next_mid(ses->server);
1327
1328         return SendReceive(xid, ses, in_buf, out_buf,
1329                         &bytes_returned, 0);
1330 }
1331
1332 int
1333 SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
1334             struct smb_hdr *in_buf, struct smb_hdr *out_buf,
1335             int *pbytes_returned)
1336 {
1337         int rc = 0;
1338         int rstart = 0;
1339         struct mid_q_entry *midQ;
1340         struct cifs_ses *ses;
1341         unsigned int len = be32_to_cpu(in_buf->smb_buf_length);
1342         struct kvec iov = { .iov_base = in_buf, .iov_len = len };
1343         struct smb_rqst rqst = { .rq_iov = &iov, .rq_nvec = 1 };
1344         unsigned int instance;
1345
1346         if (tcon == NULL || tcon->ses == NULL) {
1347                 cifs_dbg(VFS, "Null smb session\n");
1348                 return -EIO;
1349         }
1350         ses = tcon->ses;
1351
1352         if (ses->server == NULL) {
1353                 cifs_dbg(VFS, "Null tcp session\n");
1354                 return -EIO;
1355         }
1356
1357         if (ses->server->tcpStatus == CifsExiting)
1358                 return -ENOENT;
1359
1360         /* Ensure that we do not send more than 50 overlapping requests
1361            to the same server. We may make this configurable later or
1362            use ses->maxReq */
1363
1364         if (len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
1365                 cifs_dbg(VFS, "Illegal length, greater than maximum frame, %d\n",
1366                          len);
1367                 return -EIO;
1368         }
1369
1370         rc = wait_for_free_request(ses->server, CIFS_BLOCKING_OP, &instance);
1371         if (rc)
1372                 return rc;
1373
1374         /* make sure that we sign in the same order that we send on this socket
1375            and avoid races inside tcp sendmsg code that could cause corruption
1376            of smb data */
1377
1378         mutex_lock(&ses->server->srv_mutex);
1379
1380         rc = allocate_mid(ses, in_buf, &midQ);
1381         if (rc) {
1382                 mutex_unlock(&ses->server->srv_mutex);
1383                 return rc;
1384         }
1385
1386         rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
1387         if (rc) {
1388                 cifs_delete_mid(midQ);
1389                 mutex_unlock(&ses->server->srv_mutex);
1390                 return rc;
1391         }
1392
1393         midQ->mid_state = MID_REQUEST_SUBMITTED;
1394         cifs_in_send_inc(ses->server);
1395         rc = smb_send(ses->server, in_buf, len);
1396         cifs_in_send_dec(ses->server);
1397         cifs_save_when_sent(midQ);
1398
1399         if (rc < 0)
1400                 ses->server->sequence_number -= 2;
1401
1402         mutex_unlock(&ses->server->srv_mutex);
1403
1404         if (rc < 0) {
1405                 cifs_delete_mid(midQ);
1406                 return rc;
1407         }
1408
1409         /* Wait for a reply - allow signals to interrupt. */
1410         rc = wait_event_interruptible(ses->server->response_q,
1411                 (!(midQ->mid_state == MID_REQUEST_SUBMITTED)) ||
1412                 ((ses->server->tcpStatus != CifsGood) &&
1413                  (ses->server->tcpStatus != CifsNew)));
1414
1415         /* Were we interrupted by a signal ? */
1416         if ((rc == -ERESTARTSYS) &&
1417                 (midQ->mid_state == MID_REQUEST_SUBMITTED) &&
1418                 ((ses->server->tcpStatus == CifsGood) ||
1419                  (ses->server->tcpStatus == CifsNew))) {
1420
1421                 if (in_buf->Command == SMB_COM_TRANSACTION2) {
1422                         /* POSIX lock. We send a NT_CANCEL SMB to cause the
1423                            blocking lock to return. */
1424                         rc = send_cancel(ses->server, &rqst, midQ);
1425                         if (rc) {
1426                                 cifs_delete_mid(midQ);
1427                                 return rc;
1428                         }
1429                 } else {
1430                         /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
1431                            to cause the blocking lock to return. */
1432
1433                         rc = send_lock_cancel(xid, tcon, in_buf, out_buf);
1434
1435                         /* If we get -ENOLCK back the lock may have
1436                            already been removed. Don't exit in this case. */
1437                         if (rc && rc != -ENOLCK) {
1438                                 cifs_delete_mid(midQ);
1439                                 return rc;
1440                         }
1441                 }
1442
1443                 rc = wait_for_response(ses->server, midQ);
1444                 if (rc) {
1445                         send_cancel(ses->server, &rqst, midQ);
1446                         spin_lock(&GlobalMid_Lock);
1447                         if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
1448                                 /* no longer considered to be "in-flight" */
1449                                 midQ->callback = DeleteMidQEntry;
1450                                 spin_unlock(&GlobalMid_Lock);
1451                                 return rc;
1452                         }
1453                         spin_unlock(&GlobalMid_Lock);
1454                 }
1455
1456                 /* We got the response - restart system call. */
1457                 rstart = 1;
1458         }
1459
1460         rc = cifs_sync_mid_result(midQ, ses->server);
1461         if (rc != 0)
1462                 return rc;
1463
1464         /* rcvd frame is ok */
1465         if (out_buf == NULL || midQ->mid_state != MID_RESPONSE_RECEIVED) {
1466                 rc = -EIO;
1467                 cifs_dbg(VFS, "Bad MID state?\n");
1468                 goto out;
1469         }
1470
1471         *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
1472         memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
1473         rc = cifs_check_receive(midQ, ses->server, 0);
1474 out:
1475         cifs_delete_mid(midQ);
1476         if (rstart && rc == -EACCES)
1477                 return -ERESTARTSYS;
1478         return rc;
1479 }