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