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