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 = smb_buffer->Mid;    /* always LE */
  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                         printk(KERN_DEBUG " CIFS slow rsp: cmd %d mid %llu",
 103                                midEntry->command, midEntry->mid);
 104                         printk(" 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 int
 274 smb_send_rqst(struct TCP_Server_Info *server, struct smb_rqst *rqst)
 275 {
 276         int rc;
 277         struct kvec *iov = rqst->rq_iov;
 278         int n_vec = rqst->rq_nvec;
 279         unsigned int smb_buf_length = get_rfc1002_length(iov[0].iov_base);
 280         unsigned int i;
 281         size_t total_len = 0, sent;
 282         struct socket *ssocket = server->ssocket;
 283         int val = 1;
 284
 285         if (ssocket == NULL)
 286                 return -ENOTSOCK;
 287
 288         cifs_dbg(FYI, "Sending smb: smb_len=%u\n", smb_buf_length);
 289         dump_smb(iov[0].iov_base, iov[0].iov_len);
 290
 291         /* cork the socket */
 292         kernel_setsockopt(ssocket, SOL_TCP, TCP_CORK,
 293                                 (char *)&val, sizeof(val));
 294
 295         rc = smb_send_kvec(server, iov, n_vec, &sent);
 296         if (rc < 0)
 297                 goto uncork;
 298
 299         total_len += sent;
 300
 301         /* now walk the page array and send each page in it */
 302         for (i = 0; i < rqst->rq_npages; i++) {
 303                 struct kvec p_iov;
 304
 305                 cifs_rqst_page_to_kvec(rqst, i, &p_iov);
 306                 rc = smb_send_kvec(server, &p_iov, 1, &sent);
 307                 kunmap(rqst->rq_pages[i]);
 308                 if (rc < 0)
 309                         break;
 310
 311                 total_len += sent;
 312         }
 313
 314 uncork:
 315         /* uncork it */
 316         val = 0;
 317         kernel_setsockopt(ssocket, SOL_TCP, TCP_CORK,
 318                                 (char *)&val, sizeof(val));
 319
 320         if ((total_len > 0) && (total_len != smb_buf_length + 4)) {
 321                 cifs_dbg(FYI, "partial send (wanted=%u sent=%zu): terminating session\n",
 322                          smb_buf_length + 4, total_len);
 323                 /*
 324                  * If we have only sent part of an SMB then the next SMB could
 325                  * be taken as the remainder of this one. We need to kill the
 326                  * socket so the server throws away the partial SMB
 327                  */
 328                 server->tcpStatus = CifsNeedReconnect;
 329         }
 330
 331         if (rc < 0 && rc != -EINTR)
 332                 cifs_dbg(VFS, "Error %d sending data on socket to server\n",
 333                          rc);
 334         else
 335                 rc = 0;
 336
 337         return rc;
 338 }
 339
 340 static int
 341 smb_sendv(struct TCP_Server_Info *server, struct kvec *iov, int n_vec)
 342 {
 343         struct smb_rqst rqst = { .rq_iov = iov,
 344                                  .rq_nvec = n_vec };
 345
 346         return smb_send_rqst(server, &rqst);
 347 }
 348
 349 int
 350 smb_send(struct TCP_Server_Info *server, struct smb_hdr *smb_buffer,
 351          unsigned int smb_buf_length)
 352 {
 353         struct kvec iov;
 354
 355         iov.iov_base = smb_buffer;
 356         iov.iov_len = smb_buf_length + 4;
 357
 358         return smb_sendv(server, &iov, 1);
 359 }
 360
 361 static int
 362 wait_for_free_credits(struct TCP_Server_Info *server, const int timeout,
 363                       int *credits)
 364 {
 365         int rc;
 366
 367         spin_lock(&server->req_lock);
 368         if (timeout == CIFS_ASYNC_OP) {
 369                 /* oplock breaks must not be held up */
 370                 server->in_flight++;
 371                 *credits -= 1;
 372                 spin_unlock(&server->req_lock);
 373                 return 0;
 374         }
 375
 376         while (1) {
 377                 if (*credits <= 0) {
 378                         spin_unlock(&server->req_lock);
 379                         cifs_num_waiters_inc(server);
 380                         rc = wait_event_killable(server->request_q,
 381                                                  has_credits(server, credits));
 382                         cifs_num_waiters_dec(server);
 383                         if (rc)
 384                                 return rc;
 385                         spin_lock(&server->req_lock);
 386                 } else {
 387                         if (server->tcpStatus == CifsExiting) {
 388                                 spin_unlock(&server->req_lock);
 389                                 return -ENOENT;
 390                         }
 391
 392                         /*
 393                          * Can not count locking commands against total
 394                          * as they are allowed to block on server.
 395                          */
 396
 397                         /* update # of requests on the wire to server */
 398                         if (timeout != CIFS_BLOCKING_OP) {
 399                                 *credits -= 1;
 400                                 server->in_flight++;
 401                         }
 402                         spin_unlock(&server->req_lock);
 403                         break;
 404                 }
 405         }
 406         return 0;
 407 }
 408
 409 static int
 410 wait_for_free_request(struct TCP_Server_Info *server, const int timeout,
 411                       const int optype)
 412 {
 413         return wait_for_free_credits(server, timeout,
 414                                 server->ops->get_credits_field(server, optype));
 415 }
 416
 417 static int allocate_mid(struct cifs_ses *ses, struct smb_hdr *in_buf,
 418                         struct mid_q_entry **ppmidQ)
 419 {
 420         if (ses->server->tcpStatus == CifsExiting) {
 421                 return -ENOENT;
 422         }
 423
 424         if (ses->server->tcpStatus == CifsNeedReconnect) {
 425                 cifs_dbg(FYI, "tcp session dead - return to caller to retry\n");
 426                 return -EAGAIN;
 427         }
 428
 429         if (ses->status != CifsGood) {
 430                 /* check if SMB session is bad because we are setting it up */
 431                 if ((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
 432                         (in_buf->Command != SMB_COM_NEGOTIATE))
 433                         return -EAGAIN;
 434                 /* else ok - we are setting up session */
 435         }
 436         *ppmidQ = AllocMidQEntry(in_buf, ses->server);
 437         if (*ppmidQ == NULL)
 438                 return -ENOMEM;
 439         spin_lock(&GlobalMid_Lock);
 440         list_add_tail(&(*ppmidQ)->qhead, &ses->server->pending_mid_q);
 441         spin_unlock(&GlobalMid_Lock);
 442         return 0;
 443 }
 444
 445 static int
 446 wait_for_response(struct TCP_Server_Info *server, struct mid_q_entry *midQ)
 447 {
 448         int error;
 449
 450         error = wait_event_freezekillable(server->response_q,
 451                                     midQ->mid_state != MID_REQUEST_SUBMITTED);
 452         if (error < 0)
 453                 return -ERESTARTSYS;
 454
 455         return 0;
 456 }
 457
 458 struct mid_q_entry *
 459 cifs_setup_async_request(struct TCP_Server_Info *server, struct smb_rqst *rqst)
 460 {
 461         int rc;
 462         struct smb_hdr *hdr = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
 463         struct mid_q_entry *mid;
 464
 465         /* enable signing if server requires it */
 466         if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
 467                 hdr->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
 468
 469         mid = AllocMidQEntry(hdr, server);
 470         if (mid == NULL)
 471                 return ERR_PTR(-ENOMEM);
 472
 473         rc = cifs_sign_rqst(rqst, server, &mid->sequence_number);
 474         if (rc) {
 475                 DeleteMidQEntry(mid);
 476                 return ERR_PTR(rc);
 477         }
 478
 479         return mid;
 480 }
 481
 482 /*
 483  * Send a SMB request and set the callback function in the mid to handle
 484  * the result. Caller is responsible for dealing with timeouts.
 485  */
 486 int
 487 cifs_call_async(struct TCP_Server_Info *server, struct smb_rqst *rqst,
 488                 mid_receive_t *receive, mid_callback_t *callback,
 489                 void *cbdata, const int flags)
 490 {
 491         int rc, timeout, optype;
 492         struct mid_q_entry *mid;
 493
 494         timeout = flags & CIFS_TIMEOUT_MASK;
 495         optype = flags & CIFS_OP_MASK;
 496
 497         rc = wait_for_free_request(server, timeout, optype);
 498         if (rc)
 499                 return rc;
 500
 501         mutex_lock(&server->srv_mutex);
 502         mid = server->ops->setup_async_request(server, rqst);
 503         if (IS_ERR(mid)) {
 504                 mutex_unlock(&server->srv_mutex);
 505                 add_credits(server, 1, optype);
 506                 wake_up(&server->request_q);
 507                 return PTR_ERR(mid);
 508         }
 509
 510         mid->receive = receive;
 511         mid->callback = callback;
 512         mid->callback_data = cbdata;
 513         mid->mid_state = MID_REQUEST_SUBMITTED;
 514
 515         /* put it on the pending_mid_q */
 516         spin_lock(&GlobalMid_Lock);
 517         list_add_tail(&mid->qhead, &server->pending_mid_q);
 518         spin_unlock(&GlobalMid_Lock);
 519
 520
 521         cifs_in_send_inc(server);
 522         rc = smb_send_rqst(server, rqst);
 523         cifs_in_send_dec(server);
 524         cifs_save_when_sent(mid);
 525         mutex_unlock(&server->srv_mutex);
 526
 527         if (rc == 0)
 528                 return 0;
 529
 530         cifs_delete_mid(mid);
 531         add_credits(server, 1, optype);
 532         wake_up(&server->request_q);
 533         return rc;
 534 }
 535
 536 /*
 537  *
 538  * Send an SMB Request.  No response info (other than return code)
 539  * needs to be parsed.
 540  *
 541  * flags indicate the type of request buffer and how long to wait
 542  * and whether to log NT STATUS code (error) before mapping it to POSIX error
 543  *
 544  */
 545 int
 546 SendReceiveNoRsp(const unsigned int xid, struct cifs_ses *ses,
 547                  char *in_buf, int flags)
 548 {
 549         int rc;
 550         struct kvec iov[1];
 551         int resp_buf_type;
 552
 553         iov[0].iov_base = in_buf;
 554         iov[0].iov_len = get_rfc1002_length(in_buf) + 4;
 555         flags |= CIFS_NO_RESP;
 556         rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags);
 557         cifs_dbg(NOISY, "SendRcvNoRsp flags %d rc %d\n", flags, rc);
 558
 559         return rc;
 560 }
 561
 562 static int
 563 cifs_sync_mid_result(struct mid_q_entry *mid, struct TCP_Server_Info *server)
 564 {
 565         int rc = 0;
 566
 567         cifs_dbg(FYI, "%s: cmd=%d mid=%llu state=%d\n",
 568                  __func__, le16_to_cpu(mid->command), mid->mid, mid->mid_state);
 569
 570         spin_lock(&GlobalMid_Lock);
 571         switch (mid->mid_state) {
 572         case MID_RESPONSE_RECEIVED:
 573                 spin_unlock(&GlobalMid_Lock);
 574                 return rc;
 575         case MID_RETRY_NEEDED:
 576                 rc = -EAGAIN;
 577                 break;
 578         case MID_RESPONSE_MALFORMED:
 579                 rc = -EIO;
 580                 break;
 581         case MID_SHUTDOWN:
 582                 rc = -EHOSTDOWN;
 583                 break;
 584         default:
 585                 list_del_init(&mid->qhead);
 586                 cifs_dbg(VFS, "%s: invalid mid state mid=%llu state=%d\n",
 587                          __func__, mid->mid, mid->mid_state);
 588                 rc = -EIO;
 589         }
 590         spin_unlock(&GlobalMid_Lock);
 591
 592         DeleteMidQEntry(mid);
 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->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
 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 + 1);
 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         mutex_unlock(&ses->server->srv_mutex);
 715
 716         if (rc < 0) {
 717                 cifs_small_buf_release(buf);
 718                 goto out;
 719         }
 720
 721         if (timeout == CIFS_ASYNC_OP) {
 722                 cifs_small_buf_release(buf);
 723                 goto out;
 724         }
 725
 726         rc = wait_for_response(ses->server, midQ);
 727         if (rc != 0) {
 728                 send_cancel(ses->server, buf, midQ);
 729                 spin_lock(&GlobalMid_Lock);
 730                 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
 731                         midQ->callback = DeleteMidQEntry;
 732                         spin_unlock(&GlobalMid_Lock);
 733                         cifs_small_buf_release(buf);
 734                         add_credits(ses->server, 1, optype);
 735                         return rc;
 736                 }
 737                 spin_unlock(&GlobalMid_Lock);
 738         }
 739
 740         cifs_small_buf_release(buf);
 741
 742         rc = cifs_sync_mid_result(midQ, ses->server);
 743         if (rc != 0) {
 744                 add_credits(ses->server, 1, optype);
 745                 return rc;
 746         }
 747
 748         if (!midQ->resp_buf || midQ->mid_state != MID_RESPONSE_RECEIVED) {
 749                 rc = -EIO;
 750                 cifs_dbg(FYI, "Bad MID state?\n");
 751                 goto out;
 752         }
 753
 754         buf = (char *)midQ->resp_buf;
 755         iov[0].iov_base = buf;
 756         iov[0].iov_len = get_rfc1002_length(buf) + 4;
 757         if (midQ->large_buf)
 758                 *resp_buf_type = CIFS_LARGE_BUFFER;
 759         else
 760                 *resp_buf_type = CIFS_SMALL_BUFFER;
 761
 762         credits = ses->server->ops->get_credits(midQ);
 763
 764         rc = ses->server->ops->check_receive(midQ, ses->server,
 765                                              flags & CIFS_LOG_ERROR);
 766
 767         /* mark it so buf will not be freed by cifs_delete_mid */
 768         if ((flags & CIFS_NO_RESP) == 0)
 769                 midQ->resp_buf = NULL;
 770 out:
 771         cifs_delete_mid(midQ);
 772         add_credits(ses->server, credits, optype);
 773
 774         return rc;
 775 }
 776
 777 int
 778 SendReceive(const unsigned int xid, struct cifs_ses *ses,
 779             struct smb_hdr *in_buf, struct smb_hdr *out_buf,
 780             int *pbytes_returned, const int timeout)
 781 {
 782         int rc = 0;
 783         struct mid_q_entry *midQ;
 784
 785         if (ses == NULL) {
 786                 cifs_dbg(VFS, "Null smb session\n");
 787                 return -EIO;
 788         }
 789         if (ses->server == NULL) {
 790                 cifs_dbg(VFS, "Null tcp session\n");
 791                 return -EIO;
 792         }
 793
 794         if (ses->server->tcpStatus == CifsExiting)
 795                 return -ENOENT;
 796
 797         /* Ensure that we do not send more than 50 overlapping requests
 798            to the same server. We may make this configurable later or
 799            use ses->maxReq */
 800
 801         if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
 802                         MAX_CIFS_HDR_SIZE - 4) {
 803                 cifs_dbg(VFS, "Illegal length, greater than maximum frame, %d\n",
 804                          be32_to_cpu(in_buf->smb_buf_length));
 805                 return -EIO;
 806         }
 807
 808         rc = wait_for_free_request(ses->server, timeout, 0);
 809         if (rc)
 810                 return rc;
 811
 812         /* make sure that we sign in the same order that we send on this socket
 813            and avoid races inside tcp sendmsg code that could cause corruption
 814            of smb data */
 815
 816         mutex_lock(&ses->server->srv_mutex);
 817
 818         rc = allocate_mid(ses, in_buf, &midQ);
 819         if (rc) {
 820                 mutex_unlock(&ses->server->srv_mutex);
 821                 /* Update # of requests on wire to server */
 822                 add_credits(ses->server, 1, 0);
 823                 return rc;
 824         }
 825
 826         rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
 827         if (rc) {
 828                 mutex_unlock(&ses->server->srv_mutex);
 829                 goto out;
 830         }
 831
 832         midQ->mid_state = MID_REQUEST_SUBMITTED;
 833
 834         cifs_in_send_inc(ses->server);
 835         rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
 836         cifs_in_send_dec(ses->server);
 837         cifs_save_when_sent(midQ);
 838         mutex_unlock(&ses->server->srv_mutex);
 839
 840         if (rc < 0)
 841                 goto out;
 842
 843         if (timeout == CIFS_ASYNC_OP)
 844                 goto out;
 845
 846         rc = wait_for_response(ses->server, midQ);
 847         if (rc != 0) {
 848                 send_cancel(ses->server, in_buf, midQ);
 849                 spin_lock(&GlobalMid_Lock);
 850                 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
 851                         /* no longer considered to be "in-flight" */
 852                         midQ->callback = DeleteMidQEntry;
 853                         spin_unlock(&GlobalMid_Lock);
 854                         add_credits(ses->server, 1, 0);
 855                         return rc;
 856                 }
 857                 spin_unlock(&GlobalMid_Lock);
 858         }
 859
 860         rc = cifs_sync_mid_result(midQ, ses->server);
 861         if (rc != 0) {
 862                 add_credits(ses->server, 1, 0);
 863                 return rc;
 864         }
 865
 866         if (!midQ->resp_buf || !out_buf ||
 867             midQ->mid_state != MID_RESPONSE_RECEIVED) {
 868                 rc = -EIO;
 869                 cifs_dbg(VFS, "Bad MID state?\n");
 870                 goto out;
 871         }
 872
 873         *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
 874         memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
 875         rc = cifs_check_receive(midQ, ses->server, 0);
 876 out:
 877         cifs_delete_mid(midQ);
 878         add_credits(ses->server, 1, 0);
 879
 880         return rc;
 881 }
 882
 883 /* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
 884    blocking lock to return. */
 885
 886 static int
 887 send_lock_cancel(const unsigned int xid, struct cifs_tcon *tcon,
 888                         struct smb_hdr *in_buf,
 889                         struct smb_hdr *out_buf)
 890 {
 891         int bytes_returned;
 892         struct cifs_ses *ses = tcon->ses;
 893         LOCK_REQ *pSMB = (LOCK_REQ *)in_buf;
 894
 895         /* We just modify the current in_buf to change
 896            the type of lock from LOCKING_ANDX_SHARED_LOCK
 897            or LOCKING_ANDX_EXCLUSIVE_LOCK to
 898            LOCKING_ANDX_CANCEL_LOCK. */
 899
 900         pSMB->LockType = LOCKING_ANDX_CANCEL_LOCK|LOCKING_ANDX_LARGE_FILES;
 901         pSMB->Timeout = 0;
 902         pSMB->hdr.Mid = get_next_mid(ses->server);
 903
 904         return SendReceive(xid, ses, in_buf, out_buf,
 905                         &bytes_returned, 0);
 906 }
 907
 908 int
 909 SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
 910             struct smb_hdr *in_buf, struct smb_hdr *out_buf,
 911             int *pbytes_returned)
 912 {
 913         int rc = 0;
 914         int rstart = 0;
 915         struct mid_q_entry *midQ;
 916         struct cifs_ses *ses;
 917
 918         if (tcon == NULL || tcon->ses == NULL) {
 919                 cifs_dbg(VFS, "Null smb session\n");
 920                 return -EIO;
 921         }
 922         ses = tcon->ses;
 923
 924         if (ses->server == NULL) {
 925                 cifs_dbg(VFS, "Null tcp session\n");
 926                 return -EIO;
 927         }
 928
 929         if (ses->server->tcpStatus == CifsExiting)
 930                 return -ENOENT;
 931
 932         /* Ensure that we do not send more than 50 overlapping requests
 933            to the same server. We may make this configurable later or
 934            use ses->maxReq */
 935
 936         if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
 937                         MAX_CIFS_HDR_SIZE - 4) {
 938                 cifs_dbg(VFS, "Illegal length, greater than maximum frame, %d\n",
 939                          be32_to_cpu(in_buf->smb_buf_length));
 940                 return -EIO;
 941         }
 942
 943         rc = wait_for_free_request(ses->server, CIFS_BLOCKING_OP, 0);
 944         if (rc)
 945                 return rc;
 946
 947         /* make sure that we sign in the same order that we send on this socket
 948            and avoid races inside tcp sendmsg code that could cause corruption
 949            of smb data */
 950
 951         mutex_lock(&ses->server->srv_mutex);
 952
 953         rc = allocate_mid(ses, in_buf, &midQ);
 954         if (rc) {
 955                 mutex_unlock(&ses->server->srv_mutex);
 956                 return rc;
 957         }
 958
 959         rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
 960         if (rc) {
 961                 cifs_delete_mid(midQ);
 962                 mutex_unlock(&ses->server->srv_mutex);
 963                 return rc;
 964         }
 965
 966         midQ->mid_state = MID_REQUEST_SUBMITTED;
 967         cifs_in_send_inc(ses->server);
 968         rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
 969         cifs_in_send_dec(ses->server);
 970         cifs_save_when_sent(midQ);
 971         mutex_unlock(&ses->server->srv_mutex);
 972
 973         if (rc < 0) {
 974                 cifs_delete_mid(midQ);
 975                 return rc;
 976         }
 977
 978         /* Wait for a reply - allow signals to interrupt. */
 979         rc = wait_event_interruptible(ses->server->response_q,
 980                 (!(midQ->mid_state == MID_REQUEST_SUBMITTED)) ||
 981                 ((ses->server->tcpStatus != CifsGood) &&
 982                  (ses->server->tcpStatus != CifsNew)));
 983
 984         /* Were we interrupted by a signal ? */
 985         if ((rc == -ERESTARTSYS) &&
 986                 (midQ->mid_state == MID_REQUEST_SUBMITTED) &&
 987                 ((ses->server->tcpStatus == CifsGood) ||
 988                  (ses->server->tcpStatus == CifsNew))) {
 989
 990                 if (in_buf->Command == SMB_COM_TRANSACTION2) {
 991                         /* POSIX lock. We send a NT_CANCEL SMB to cause the
 992                            blocking lock to return. */
 993                         rc = send_cancel(ses->server, in_buf, midQ);
 994                         if (rc) {
 995                                 cifs_delete_mid(midQ);
 996                                 return rc;
 997                         }
 998                 } else {
 999                         /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
1000                            to cause the blocking lock to return. */
1001
1002                         rc = send_lock_cancel(xid, tcon, in_buf, out_buf);
1003
1004                         /* If we get -ENOLCK back the lock may have
1005                            already been removed. Don't exit in this case. */
1006                         if (rc && rc != -ENOLCK) {
1007                                 cifs_delete_mid(midQ);
1008                                 return rc;
1009                         }
1010                 }
1011
1012                 rc = wait_for_response(ses->server, midQ);
1013                 if (rc) {
1014                         send_cancel(ses->server, in_buf, midQ);
1015                         spin_lock(&GlobalMid_Lock);
1016                         if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
1017                                 /* no longer considered to be "in-flight" */
1018                                 midQ->callback = DeleteMidQEntry;
1019                                 spin_unlock(&GlobalMid_Lock);
1020                                 return rc;
1021                         }
1022                         spin_unlock(&GlobalMid_Lock);
1023                 }
1024
1025                 /* We got the response - restart system call. */
1026                 rstart = 1;
1027         }
1028
1029         rc = cifs_sync_mid_result(midQ, ses->server);
1030         if (rc != 0)
1031                 return rc;
1032
1033         /* rcvd frame is ok */
1034         if (out_buf == NULL || midQ->mid_state != MID_RESPONSE_RECEIVED) {
1035                 rc = -EIO;
1036                 cifs_dbg(VFS, "Bad MID state?\n");
1037                 goto out;
1038         }
1039
1040         *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
1041         memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
1042         rc = cifs_check_receive(midQ, ses->server, 0);
1043 out:
1044         cifs_delete_mid(midQ);
1045         if (rstart && rc == -EACCES)
1046                 return -ERESTARTSYS;
1047         return rc;
1048 }