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