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