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         int *val;
 414
 415         val = server->ops->get_credits_field(server, optype);
 416         /* Since an echo is already inflight, no need to wait to send another */
 417         if (*val <= 0 && optype == CIFS_ECHO_OP)
 418                 return -EAGAIN;
 419         return wait_for_free_credits(server, timeout, val);
 420 }
 421
 422 static int allocate_mid(struct cifs_ses *ses, struct smb_hdr *in_buf,
 423                         struct mid_q_entry **ppmidQ)
 424 {
 425         if (ses->server->tcpStatus == CifsExiting) {
 426                 return -ENOENT;
 427         }
 428
 429         if (ses->server->tcpStatus == CifsNeedReconnect) {
 430                 cifs_dbg(FYI, "tcp session dead - return to caller to retry\n");
 431                 return -EAGAIN;
 432         }
 433
 434         if (ses->status != CifsGood) {
 435                 /* check if SMB session is bad because we are setting it up */
 436                 if ((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
 437                         (in_buf->Command != SMB_COM_NEGOTIATE))
 438                         return -EAGAIN;
 439                 /* else ok - we are setting up session */
 440         }
 441         *ppmidQ = AllocMidQEntry(in_buf, ses->server);
 442         if (*ppmidQ == NULL)
 443                 return -ENOMEM;
 444         spin_lock(&GlobalMid_Lock);
 445         list_add_tail(&(*ppmidQ)->qhead, &ses->server->pending_mid_q);
 446         spin_unlock(&GlobalMid_Lock);
 447         return 0;
 448 }
 449
 450 static int
 451 wait_for_response(struct TCP_Server_Info *server, struct mid_q_entry *midQ)
 452 {
 453         int error;
 454
 455         error = wait_event_freezekillable_unsafe(server->response_q,
 456                                     midQ->mid_state != MID_REQUEST_SUBMITTED);
 457         if (error < 0)
 458                 return -ERESTARTSYS;
 459
 460         return 0;
 461 }
 462
 463 struct mid_q_entry *
 464 cifs_setup_async_request(struct TCP_Server_Info *server, struct smb_rqst *rqst)
 465 {
 466         int rc;
 467         struct smb_hdr *hdr = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
 468         struct mid_q_entry *mid;
 469
 470         /* enable signing if server requires it */
 471         if (server->sign)
 472                 hdr->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
 473
 474         mid = AllocMidQEntry(hdr, server);
 475         if (mid == NULL)
 476                 return ERR_PTR(-ENOMEM);
 477
 478         rc = cifs_sign_rqst(rqst, server, &mid->sequence_number);
 479         if (rc) {
 480                 DeleteMidQEntry(mid);
 481                 return ERR_PTR(rc);
 482         }
 483
 484         return mid;
 485 }
 486
 487 /*
 488  * Send a SMB request and set the callback function in the mid to handle
 489  * the result. Caller is responsible for dealing with timeouts.
 490  */
 491 int
 492 cifs_call_async(struct TCP_Server_Info *server, struct smb_rqst *rqst,
 493                 mid_receive_t *receive, mid_callback_t *callback,
 494                 void *cbdata, const int flags)
 495 {
 496         int rc, timeout, optype;
 497         struct mid_q_entry *mid;
 498
 499         timeout = flags & CIFS_TIMEOUT_MASK;
 500         optype = flags & CIFS_OP_MASK;
 501
 502         rc = wait_for_free_request(server, timeout, optype);
 503         if (rc)
 504                 return rc;
 505
 506         mutex_lock(&server->srv_mutex);
 507         mid = server->ops->setup_async_request(server, rqst);
 508         if (IS_ERR(mid)) {
 509                 mutex_unlock(&server->srv_mutex);
 510                 add_credits(server, 1, optype);
 511                 wake_up(&server->request_q);
 512                 return PTR_ERR(mid);
 513         }
 514
 515         mid->receive = receive;
 516         mid->callback = callback;
 517         mid->callback_data = cbdata;
 518         mid->mid_state = MID_REQUEST_SUBMITTED;
 519
 520         /* put it on the pending_mid_q */
 521         spin_lock(&GlobalMid_Lock);
 522         list_add_tail(&mid->qhead, &server->pending_mid_q);
 523         spin_unlock(&GlobalMid_Lock);
 524
 525
 526         cifs_in_send_inc(server);
 527         rc = smb_send_rqst(server, rqst);
 528         cifs_in_send_dec(server);
 529         cifs_save_when_sent(mid);
 530
 531         if (rc < 0)
 532                 server->sequence_number -= 2;
 533         mutex_unlock(&server->srv_mutex);
 534
 535         if (rc == 0)
 536                 return 0;
 537
 538         cifs_delete_mid(mid);
 539         add_credits(server, 1, optype);
 540         wake_up(&server->request_q);
 541         return rc;
 542 }
 543
 544 /*
 545  *
 546  * Send an SMB Request.  No response info (other than return code)
 547  * needs to be parsed.
 548  *
 549  * flags indicate the type of request buffer and how long to wait
 550  * and whether to log NT STATUS code (error) before mapping it to POSIX error
 551  *
 552  */
 553 int
 554 SendReceiveNoRsp(const unsigned int xid, struct cifs_ses *ses,
 555                  char *in_buf, int flags)
 556 {
 557         int rc;
 558         struct kvec iov[1];
 559         int resp_buf_type;
 560
 561         iov[0].iov_base = in_buf;
 562         iov[0].iov_len = get_rfc1002_length(in_buf) + 4;
 563         flags |= CIFS_NO_RESP;
 564         rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags);
 565         cifs_dbg(NOISY, "SendRcvNoRsp flags %d rc %d\n", flags, rc);
 566
 567         return rc;
 568 }
 569
 570 static int
 571 cifs_sync_mid_result(struct mid_q_entry *mid, struct TCP_Server_Info *server)
 572 {
 573         int rc = 0;
 574
 575         cifs_dbg(FYI, "%s: cmd=%d mid=%llu state=%d\n",
 576                  __func__, le16_to_cpu(mid->command), mid->mid, mid->mid_state);
 577
 578         spin_lock(&GlobalMid_Lock);
 579         switch (mid->mid_state) {
 580         case MID_RESPONSE_RECEIVED:
 581                 spin_unlock(&GlobalMid_Lock);
 582                 return rc;
 583         case MID_RETRY_NEEDED:
 584                 rc = -EAGAIN;
 585                 break;
 586         case MID_RESPONSE_MALFORMED:
 587                 rc = -EIO;
 588                 break;
 589         case MID_SHUTDOWN:
 590                 rc = -EHOSTDOWN;
 591                 break;
 592         default:
 593                 list_del_init(&mid->qhead);
 594                 cifs_dbg(VFS, "%s: invalid mid state mid=%llu state=%d\n",
 595                          __func__, mid->mid, mid->mid_state);
 596                 rc = -EIO;
 597         }
 598         spin_unlock(&GlobalMid_Lock);
 599
 600         DeleteMidQEntry(mid);
 601         return rc;
 602 }
 603
 604 static inline int
 605 send_cancel(struct TCP_Server_Info *server, void *buf, struct mid_q_entry *mid)
 606 {
 607         return server->ops->send_cancel ?
 608                                 server->ops->send_cancel(server, buf, mid) : 0;
 609 }
 610
 611 int
 612 cifs_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,
 613                    bool log_error)
 614 {
 615         unsigned int len = get_rfc1002_length(mid->resp_buf) + 4;
 616
 617         dump_smb(mid->resp_buf, min_t(u32, 92, len));
 618
 619         /* convert the length into a more usable form */
 620         if (server->sign) {
 621                 struct kvec iov;
 622                 int rc = 0;
 623                 struct smb_rqst rqst = { .rq_iov = &iov,
 624                                          .rq_nvec = 1 };
 625
 626                 iov.iov_base = mid->resp_buf;
 627                 iov.iov_len = len;
 628                 /* FIXME: add code to kill session */
 629                 rc = cifs_verify_signature(&rqst, server,
 630                                            mid->sequence_number);
 631                 if (rc)
 632                         cifs_dbg(VFS, "SMB signature verification returned error = %d\n",
 633                                  rc);
 634         }
 635
 636         /* BB special case reconnect tid and uid here? */
 637         return map_smb_to_linux_error(mid->resp_buf, log_error);
 638 }
 639
 640 struct mid_q_entry *
 641 cifs_setup_request(struct cifs_ses *ses, struct smb_rqst *rqst)
 642 {
 643         int rc;
 644         struct smb_hdr *hdr = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
 645         struct mid_q_entry *mid;
 646
 647         rc = allocate_mid(ses, hdr, &mid);
 648         if (rc)
 649                 return ERR_PTR(rc);
 650         rc = cifs_sign_rqst(rqst, ses->server, &mid->sequence_number);
 651         if (rc) {
 652                 cifs_delete_mid(mid);
 653                 return ERR_PTR(rc);
 654         }
 655         return mid;
 656 }
 657
 658 int
 659 SendReceive2(const unsigned int xid, struct cifs_ses *ses,
 660              struct kvec *iov, int n_vec, int *resp_buf_type /* ret */,
 661              const int flags)
 662 {
 663         int rc = 0;
 664         int timeout, optype;
 665         struct mid_q_entry *midQ;
 666         char *buf = iov[0].iov_base;
 667         unsigned int credits = 1;
 668         struct smb_rqst rqst = { .rq_iov = iov,
 669                                  .rq_nvec = n_vec };
 670
 671         timeout = flags & CIFS_TIMEOUT_MASK;
 672         optype = flags & CIFS_OP_MASK;
 673
 674         *resp_buf_type = CIFS_NO_BUFFER;  /* no response buf yet */
 675
 676         if ((ses == NULL) || (ses->server == NULL)) {
 677                 cifs_small_buf_release(buf);
 678                 cifs_dbg(VFS, "Null session\n");
 679                 return -EIO;
 680         }
 681
 682         if (ses->server->tcpStatus == CifsExiting) {
 683                 cifs_small_buf_release(buf);
 684                 return -ENOENT;
 685         }
 686
 687         /*
 688          * Ensure that we do not send more than 50 overlapping requests
 689          * to the same server. We may make this configurable later or
 690          * use ses->maxReq.
 691          */
 692
 693         rc = wait_for_free_request(ses->server, timeout, optype);
 694         if (rc) {
 695                 cifs_small_buf_release(buf);
 696                 return rc;
 697         }
 698
 699         /*
 700          * Make sure that we sign in the same order that we send on this socket
 701          * and avoid races inside tcp sendmsg code that could cause corruption
 702          * of smb data.
 703          */
 704
 705         mutex_lock(&ses->server->srv_mutex);
 706
 707         midQ = ses->server->ops->setup_request(ses, &rqst);
 708         if (IS_ERR(midQ)) {
 709                 mutex_unlock(&ses->server->srv_mutex);
 710                 cifs_small_buf_release(buf);
 711                 /* Update # of requests on wire to server */
 712                 add_credits(ses->server, 1, optype);
 713                 return PTR_ERR(midQ);
 714         }
 715
 716         midQ->mid_state = MID_REQUEST_SUBMITTED;
 717         cifs_in_send_inc(ses->server);
 718         rc = smb_sendv(ses->server, iov, n_vec);
 719         cifs_in_send_dec(ses->server);
 720         cifs_save_when_sent(midQ);
 721
 722         if (rc < 0)
 723                 ses->server->sequence_number -= 2;
 724         mutex_unlock(&ses->server->srv_mutex);
 725
 726         if (rc < 0) {
 727                 cifs_small_buf_release(buf);
 728                 goto out;
 729         }
 730
 731         if (timeout == CIFS_ASYNC_OP) {
 732                 cifs_small_buf_release(buf);
 733                 goto out;
 734         }
 735
 736         rc = wait_for_response(ses->server, midQ);
 737         if (rc != 0) {
 738                 send_cancel(ses->server, buf, midQ);
 739                 spin_lock(&GlobalMid_Lock);
 740                 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
 741                         midQ->callback = DeleteMidQEntry;
 742                         spin_unlock(&GlobalMid_Lock);
 743                         cifs_small_buf_release(buf);
 744                         add_credits(ses->server, 1, optype);
 745                         return rc;
 746                 }
 747                 spin_unlock(&GlobalMid_Lock);
 748         }
 749
 750         cifs_small_buf_release(buf);
 751
 752         rc = cifs_sync_mid_result(midQ, ses->server);
 753         if (rc != 0) {
 754                 add_credits(ses->server, 1, optype);
 755                 return rc;
 756         }
 757
 758         if (!midQ->resp_buf || midQ->mid_state != MID_RESPONSE_RECEIVED) {
 759                 rc = -EIO;
 760                 cifs_dbg(FYI, "Bad MID state?\n");
 761                 goto out;
 762         }
 763
 764         buf = (char *)midQ->resp_buf;
 765         iov[0].iov_base = buf;
 766         iov[0].iov_len = get_rfc1002_length(buf) + 4;
 767         if (midQ->large_buf)
 768                 *resp_buf_type = CIFS_LARGE_BUFFER;
 769         else
 770                 *resp_buf_type = CIFS_SMALL_BUFFER;
 771
 772         credits = ses->server->ops->get_credits(midQ);
 773
 774         rc = ses->server->ops->check_receive(midQ, ses->server,
 775                                              flags & CIFS_LOG_ERROR);
 776
 777         /* mark it so buf will not be freed by cifs_delete_mid */
 778         if ((flags & CIFS_NO_RESP) == 0)
 779                 midQ->resp_buf = NULL;
 780 out:
 781         cifs_delete_mid(midQ);
 782         add_credits(ses->server, credits, optype);
 783
 784         return rc;
 785 }
 786
 787 int
 788 SendReceive(const unsigned int xid, struct cifs_ses *ses,
 789             struct smb_hdr *in_buf, struct smb_hdr *out_buf,
 790             int *pbytes_returned, const int timeout)
 791 {
 792         int rc = 0;
 793         struct mid_q_entry *midQ;
 794
 795         if (ses == NULL) {
 796                 cifs_dbg(VFS, "Null smb session\n");
 797                 return -EIO;
 798         }
 799         if (ses->server == NULL) {
 800                 cifs_dbg(VFS, "Null tcp session\n");
 801                 return -EIO;
 802         }
 803
 804         if (ses->server->tcpStatus == CifsExiting)
 805                 return -ENOENT;
 806
 807         /* Ensure that we do not send more than 50 overlapping requests
 808            to the same server. We may make this configurable later or
 809            use ses->maxReq */
 810
 811         if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
 812                         MAX_CIFS_HDR_SIZE - 4) {
 813                 cifs_dbg(VFS, "Illegal length, greater than maximum frame, %d\n",
 814                          be32_to_cpu(in_buf->smb_buf_length));
 815                 return -EIO;
 816         }
 817
 818         rc = wait_for_free_request(ses->server, timeout, 0);
 819         if (rc)
 820                 return rc;
 821
 822         /* make sure that we sign in the same order that we send on this socket
 823            and avoid races inside tcp sendmsg code that could cause corruption
 824            of smb data */
 825
 826         mutex_lock(&ses->server->srv_mutex);
 827
 828         rc = allocate_mid(ses, in_buf, &midQ);
 829         if (rc) {
 830                 mutex_unlock(&ses->server->srv_mutex);
 831                 /* Update # of requests on wire to server */
 832                 add_credits(ses->server, 1, 0);
 833                 return rc;
 834         }
 835
 836         rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
 837         if (rc) {
 838                 mutex_unlock(&ses->server->srv_mutex);
 839                 goto out;
 840         }
 841
 842         midQ->mid_state = MID_REQUEST_SUBMITTED;
 843
 844         cifs_in_send_inc(ses->server);
 845         rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
 846         cifs_in_send_dec(ses->server);
 847         cifs_save_when_sent(midQ);
 848
 849         if (rc < 0)
 850                 ses->server->sequence_number -= 2;
 851
 852         mutex_unlock(&ses->server->srv_mutex);
 853
 854         if (rc < 0)
 855                 goto out;
 856
 857         if (timeout == CIFS_ASYNC_OP)
 858                 goto out;
 859
 860         rc = wait_for_response(ses->server, midQ);
 861         if (rc != 0) {
 862                 send_cancel(ses->server, in_buf, midQ);
 863                 spin_lock(&GlobalMid_Lock);
 864                 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
 865                         /* no longer considered to be "in-flight" */
 866                         midQ->callback = DeleteMidQEntry;
 867                         spin_unlock(&GlobalMid_Lock);
 868                         add_credits(ses->server, 1, 0);
 869                         return rc;
 870                 }
 871                 spin_unlock(&GlobalMid_Lock);
 872         }
 873
 874         rc = cifs_sync_mid_result(midQ, ses->server);
 875         if (rc != 0) {
 876                 add_credits(ses->server, 1, 0);
 877                 return rc;
 878         }
 879
 880         if (!midQ->resp_buf || !out_buf ||
 881             midQ->mid_state != MID_RESPONSE_RECEIVED) {
 882                 rc = -EIO;
 883                 cifs_dbg(VFS, "Bad MID state?\n");
 884                 goto out;
 885         }
 886
 887         *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
 888         memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
 889         rc = cifs_check_receive(midQ, ses->server, 0);
 890 out:
 891         cifs_delete_mid(midQ);
 892         add_credits(ses->server, 1, 0);
 893
 894         return rc;
 895 }
 896
 897 /* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
 898    blocking lock to return. */
 899
 900 static int
 901 send_lock_cancel(const unsigned int xid, struct cifs_tcon *tcon,
 902                         struct smb_hdr *in_buf,
 903                         struct smb_hdr *out_buf)
 904 {
 905         int bytes_returned;
 906         struct cifs_ses *ses = tcon->ses;
 907         LOCK_REQ *pSMB = (LOCK_REQ *)in_buf;
 908
 909         /* We just modify the current in_buf to change
 910            the type of lock from LOCKING_ANDX_SHARED_LOCK
 911            or LOCKING_ANDX_EXCLUSIVE_LOCK to
 912            LOCKING_ANDX_CANCEL_LOCK. */
 913
 914         pSMB->LockType = LOCKING_ANDX_CANCEL_LOCK|LOCKING_ANDX_LARGE_FILES;
 915         pSMB->Timeout = 0;
 916         pSMB->hdr.Mid = get_next_mid(ses->server);
 917
 918         return SendReceive(xid, ses, in_buf, out_buf,
 919                         &bytes_returned, 0);
 920 }
 921
 922 int
 923 SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
 924             struct smb_hdr *in_buf, struct smb_hdr *out_buf,
 925             int *pbytes_returned)
 926 {
 927         int rc = 0;
 928         int rstart = 0;
 929         struct mid_q_entry *midQ;
 930         struct cifs_ses *ses;
 931
 932         if (tcon == NULL || tcon->ses == NULL) {
 933                 cifs_dbg(VFS, "Null smb session\n");
 934                 return -EIO;
 935         }
 936         ses = tcon->ses;
 937
 938         if (ses->server == NULL) {
 939                 cifs_dbg(VFS, "Null tcp session\n");
 940                 return -EIO;
 941         }
 942
 943         if (ses->server->tcpStatus == CifsExiting)
 944                 return -ENOENT;
 945
 946         /* Ensure that we do not send more than 50 overlapping requests
 947            to the same server. We may make this configurable later or
 948            use ses->maxReq */
 949
 950         if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
 951                         MAX_CIFS_HDR_SIZE - 4) {
 952                 cifs_dbg(VFS, "Illegal length, greater than maximum frame, %d\n",
 953                          be32_to_cpu(in_buf->smb_buf_length));
 954                 return -EIO;
 955         }
 956
 957         rc = wait_for_free_request(ses->server, CIFS_BLOCKING_OP, 0);
 958         if (rc)
 959                 return rc;
 960
 961         /* make sure that we sign in the same order that we send on this socket
 962            and avoid races inside tcp sendmsg code that could cause corruption
 963            of smb data */
 964
 965         mutex_lock(&ses->server->srv_mutex);
 966
 967         rc = allocate_mid(ses, in_buf, &midQ);
 968         if (rc) {
 969                 mutex_unlock(&ses->server->srv_mutex);
 970                 return rc;
 971         }
 972
 973         rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
 974         if (rc) {
 975                 cifs_delete_mid(midQ);
 976                 mutex_unlock(&ses->server->srv_mutex);
 977                 return rc;
 978         }
 979
 980         midQ->mid_state = MID_REQUEST_SUBMITTED;
 981         cifs_in_send_inc(ses->server);
 982         rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
 983         cifs_in_send_dec(ses->server);
 984         cifs_save_when_sent(midQ);
 985
 986         if (rc < 0)
 987                 ses->server->sequence_number -= 2;
 988
 989         mutex_unlock(&ses->server->srv_mutex);
 990
 991         if (rc < 0) {
 992                 cifs_delete_mid(midQ);
 993                 return rc;
 994         }
 995
 996         /* Wait for a reply - allow signals to interrupt. */
 997         rc = wait_event_interruptible(ses->server->response_q,
 998                 (!(midQ->mid_state == MID_REQUEST_SUBMITTED)) ||
 999                 ((ses->server->tcpStatus != CifsGood) &&
1000                  (ses->server->tcpStatus != CifsNew)));
1001
1002         /* Were we interrupted by a signal ? */
1003         if ((rc == -ERESTARTSYS) &&
1004                 (midQ->mid_state == MID_REQUEST_SUBMITTED) &&
1005                 ((ses->server->tcpStatus == CifsGood) ||
1006                  (ses->server->tcpStatus == CifsNew))) {
1007
1008                 if (in_buf->Command == SMB_COM_TRANSACTION2) {
1009                         /* POSIX lock. We send a NT_CANCEL SMB to cause the
1010                            blocking lock to return. */
1011                         rc = send_cancel(ses->server, in_buf, midQ);
1012                         if (rc) {
1013                                 cifs_delete_mid(midQ);
1014                                 return rc;
1015                         }
1016                 } else {
1017                         /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
1018                            to cause the blocking lock to return. */
1019
1020                         rc = send_lock_cancel(xid, tcon, in_buf, out_buf);
1021
1022                         /* If we get -ENOLCK back the lock may have
1023                            already been removed. Don't exit in this case. */
1024                         if (rc && rc != -ENOLCK) {
1025                                 cifs_delete_mid(midQ);
1026                                 return rc;
1027                         }
1028                 }
1029
1030                 rc = wait_for_response(ses->server, midQ);
1031                 if (rc) {
1032                         send_cancel(ses->server, in_buf, midQ);
1033                         spin_lock(&GlobalMid_Lock);
1034                         if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
1035                                 /* no longer considered to be "in-flight" */
1036                                 midQ->callback = DeleteMidQEntry;
1037                                 spin_unlock(&GlobalMid_Lock);
1038                                 return rc;
1039                         }
1040                         spin_unlock(&GlobalMid_Lock);
1041                 }
1042
1043                 /* We got the response - restart system call. */
1044                 rstart = 1;
1045         }
1046
1047         rc = cifs_sync_mid_result(midQ, ses->server);
1048         if (rc != 0)
1049                 return rc;
1050
1051         /* rcvd frame is ok */
1052         if (out_buf == NULL || midQ->mid_state != MID_RESPONSE_RECEIVED) {
1053                 rc = -EIO;
1054                 cifs_dbg(VFS, "Bad MID state?\n");
1055                 goto out;
1056         }
1057
1058         *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
1059         memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
1060         rc = cifs_check_receive(midQ, ses->server, 0);
1061 out:
1062         cifs_delete_mid(midQ);
1063         if (rstart && rc == -EACCES)
1064                 return -ERESTARTSYS;
1065         return rc;
1066 }