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