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