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