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 <asm/uaccess.h>
  31 #include <asm/processor.h>
  32 #include <linux/mempool.h>
  33 #include "cifspdu.h"
  34 #include "cifsglob.h"
  35 #include "cifsproto.h"
  36 #include "cifs_debug.h"
  37
  38 extern mempool_t *cifs_mid_poolp;
  39
  40 static void
  41 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                 cERROR(1, "Null TCP session in AllocMidQEntry");
  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                 cFYI(1, "For smb_command %d", 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
  69                 /*
  70                  * The default is for the mid to be synchronous, so the
  71                  * default callback just wakes up the current task.
  72                  */
  73                 temp->callback = wake_up_task;
  74                 temp->callback_data = current;
  75         }
  76
  77         atomic_inc(&midCount);
  78         temp->mid_state = MID_REQUEST_ALLOCATED;
  79         return temp;
  80 }
  81
  82 void
  83 DeleteMidQEntry(struct mid_q_entry *midEntry)
  84 {
  85 #ifdef CONFIG_CIFS_STATS2
  86         unsigned long now;
  87 #endif
  88         midEntry->mid_state = MID_FREE;
  89         atomic_dec(&midCount);
  90         if (midEntry->large_buf)
  91                 cifs_buf_release(midEntry->resp_buf);
  92         else
  93                 cifs_small_buf_release(midEntry->resp_buf);
  94 #ifdef CONFIG_CIFS_STATS2
  95         now = jiffies;
  96         /* commands taking longer than one second are indications that
  97            something is wrong, unless it is quite a slow link or server */
  98         if ((now - midEntry->when_alloc) > HZ) {
  99                 if ((cifsFYI & CIFS_TIMER) &&
 100                     (midEntry->command != cpu_to_le16(SMB_COM_LOCKING_ANDX))) {
 101                         printk(KERN_DEBUG " CIFS slow rsp: cmd %d mid %llu",
 102                                midEntry->command, midEntry->mid);
 103                         printk(" A: 0x%lx S: 0x%lx R: 0x%lx\n",
 104                                now - midEntry->when_alloc,
 105                                now - midEntry->when_sent,
 106                                now - midEntry->when_received);
 107                 }
 108         }
 109 #endif
 110         mempool_free(midEntry, cifs_mid_poolp);
 111 }
 112
 113 static void
 114 delete_mid(struct mid_q_entry *mid)
 115 {
 116         spin_lock(&GlobalMid_Lock);
 117         list_del(&mid->qhead);
 118         spin_unlock(&GlobalMid_Lock);
 119
 120         DeleteMidQEntry(mid);
 121 }
 122
 123 static int
 124 smb_sendv(struct TCP_Server_Info *server, struct kvec *iov, int n_vec)
 125 {
 126         int rc = 0;
 127         int i = 0;
 128         struct msghdr smb_msg;
 129         unsigned int len = iov[0].iov_len;
 130         unsigned int total_len;
 131         int first_vec = 0;
 132         unsigned int smb_buf_length = get_rfc1002_length(iov[0].iov_base);
 133         struct socket *ssocket = server->ssocket;
 134
 135         if (ssocket == NULL)
 136                 return -ENOTSOCK; /* BB eventually add reconnect code here */
 137
 138         smb_msg.msg_name = (struct sockaddr *) &server->dstaddr;
 139         smb_msg.msg_namelen = sizeof(struct sockaddr);
 140         smb_msg.msg_control = NULL;
 141         smb_msg.msg_controllen = 0;
 142         if (server->noblocksnd)
 143                 smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL;
 144         else
 145                 smb_msg.msg_flags = MSG_NOSIGNAL;
 146
 147         total_len = 0;
 148         for (i = 0; i < n_vec; i++)
 149                 total_len += iov[i].iov_len;
 150
 151         cFYI(1, "Sending smb:  total_len %d", total_len);
 152         dump_smb(iov[0].iov_base, len);
 153
 154         i = 0;
 155         while (total_len) {
 156                 rc = kernel_sendmsg(ssocket, &smb_msg, &iov[first_vec],
 157                                     n_vec - first_vec, total_len);
 158                 if ((rc == -ENOSPC) || (rc == -EAGAIN)) {
 159                         i++;
 160                         /*
 161                          * If blocking send we try 3 times, since each can block
 162                          * for 5 seconds. For nonblocking  we have to try more
 163                          * but wait increasing amounts of time allowing time for
 164                          * socket to clear.  The overall time we wait in either
 165                          * case to send on the socket is about 15 seconds.
 166                          * Similarly we wait for 15 seconds for a response from
 167                          * the server in SendReceive[2] for the server to send
 168                          * a response back for most types of requests (except
 169                          * SMB Write past end of file which can be slow, and
 170                          * blocking lock operations). NFS waits slightly longer
 171                          * than CIFS, but this can make it take longer for
 172                          * nonresponsive servers to be detected and 15 seconds
 173                          * is more than enough time for modern networks to
 174                          * send a packet.  In most cases if we fail to send
 175                          * after the retries we will kill the socket and
 176                          * reconnect which may clear the network problem.
 177                          */
 178                         if ((i >= 14) || (!server->noblocksnd && (i > 2))) {
 179                                 cERROR(1, "sends on sock %p stuck for 15 seconds",
 180                                     ssocket);
 181                                 rc = -EAGAIN;
 182                                 break;
 183                         }
 184                         msleep(1 << i);
 185                         continue;
 186                 }
 187                 if (rc < 0)
 188                         break;
 189
 190                 if (rc == total_len) {
 191                         total_len = 0;
 192                         break;
 193                 } else if (rc > total_len) {
 194                         cERROR(1, "sent %d requested %d", rc, total_len);
 195                         break;
 196                 }
 197                 if (rc == 0) {
 198                         /* should never happen, letting socket clear before
 199                            retrying is our only obvious option here */
 200                         cERROR(1, "tcp sent no data");
 201                         msleep(500);
 202                         continue;
 203                 }
 204                 total_len -= rc;
 205                 /* the line below resets i */
 206                 for (i = first_vec; i < n_vec; i++) {
 207                         if (iov[i].iov_len) {
 208                                 if (rc > iov[i].iov_len) {
 209                                         rc -= iov[i].iov_len;
 210                                         iov[i].iov_len = 0;
 211                                 } else {
 212                                         iov[i].iov_base += rc;
 213                                         iov[i].iov_len -= rc;
 214                                         first_vec = i;
 215                                         break;
 216                                 }
 217                         }
 218                 }
 219                 i = 0; /* in case we get ENOSPC on the next send */
 220         }
 221
 222         if ((total_len > 0) && (total_len != smb_buf_length + 4)) {
 223                 cFYI(1, "partial send (%d remaining), terminating session",
 224                         total_len);
 225                 /* If we have only sent part of an SMB then the next SMB
 226                    could be taken as the remainder of this one.  We need
 227                    to kill the socket so the server throws away the partial
 228                    SMB */
 229                 server->tcpStatus = CifsNeedReconnect;
 230         }
 231
 232         if (rc < 0 && rc != -EINTR)
 233                 cERROR(1, "Error %d sending data on socket to server", rc);
 234         else
 235                 rc = 0;
 236
 237         return rc;
 238 }
 239
 240 int
 241 smb_send(struct TCP_Server_Info *server, struct smb_hdr *smb_buffer,
 242          unsigned int smb_buf_length)
 243 {
 244         struct kvec iov;
 245
 246         iov.iov_base = smb_buffer;
 247         iov.iov_len = smb_buf_length + 4;
 248
 249         return smb_sendv(server, &iov, 1);
 250 }
 251
 252 static int
 253 wait_for_free_credits(struct TCP_Server_Info *server, const int timeout,
 254                       int *credits)
 255 {
 256         int rc;
 257
 258         spin_lock(&server->req_lock);
 259         if (timeout == CIFS_ASYNC_OP) {
 260                 /* oplock breaks must not be held up */
 261                 server->in_flight++;
 262                 *credits -= 1;
 263                 spin_unlock(&server->req_lock);
 264                 return 0;
 265         }
 266
 267         while (1) {
 268                 if (*credits <= 0) {
 269                         spin_unlock(&server->req_lock);
 270                         cifs_num_waiters_inc(server);
 271                         rc = wait_event_killable(server->request_q,
 272                                                  has_credits(server, credits));
 273                         cifs_num_waiters_dec(server);
 274                         if (rc)
 275                                 return rc;
 276                         spin_lock(&server->req_lock);
 277                 } else {
 278                         if (server->tcpStatus == CifsExiting) {
 279                                 spin_unlock(&server->req_lock);
 280                                 return -ENOENT;
 281                         }
 282
 283                         /*
 284                          * Can not count locking commands against total
 285                          * as they are allowed to block on server.
 286                          */
 287
 288                         /* update # of requests on the wire to server */
 289                         if (timeout != CIFS_BLOCKING_OP) {
 290                                 *credits -= 1;
 291                                 server->in_flight++;
 292                         }
 293                         spin_unlock(&server->req_lock);
 294                         break;
 295                 }
 296         }
 297         return 0;
 298 }
 299
 300 static int
 301 wait_for_free_request(struct TCP_Server_Info *server, const int timeout,
 302                       const int optype)
 303 {
 304         return wait_for_free_credits(server, timeout,
 305                                 server->ops->get_credits_field(server, optype));
 306 }
 307
 308 static int allocate_mid(struct cifs_ses *ses, struct smb_hdr *in_buf,
 309                         struct mid_q_entry **ppmidQ)
 310 {
 311         if (ses->server->tcpStatus == CifsExiting) {
 312                 return -ENOENT;
 313         }
 314
 315         if (ses->server->tcpStatus == CifsNeedReconnect) {
 316                 cFYI(1, "tcp session dead - return to caller to retry");
 317                 return -EAGAIN;
 318         }
 319
 320         if (ses->status != CifsGood) {
 321                 /* check if SMB session is bad because we are setting it up */
 322                 if ((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
 323                         (in_buf->Command != SMB_COM_NEGOTIATE))
 324                         return -EAGAIN;
 325                 /* else ok - we are setting up session */
 326         }
 327         *ppmidQ = AllocMidQEntry(in_buf, ses->server);
 328         if (*ppmidQ == NULL)
 329                 return -ENOMEM;
 330         spin_lock(&GlobalMid_Lock);
 331         list_add_tail(&(*ppmidQ)->qhead, &ses->server->pending_mid_q);
 332         spin_unlock(&GlobalMid_Lock);
 333         return 0;
 334 }
 335
 336 static int
 337 wait_for_response(struct TCP_Server_Info *server, struct mid_q_entry *midQ)
 338 {
 339         int error;
 340
 341         error = wait_event_freezekillable(server->response_q,
 342                                     midQ->mid_state != MID_REQUEST_SUBMITTED);
 343         if (error < 0)
 344                 return -ERESTARTSYS;
 345
 346         return 0;
 347 }
 348
 349 static int
 350 cifs_setup_async_request(struct TCP_Server_Info *server, struct kvec *iov,
 351                          unsigned int nvec, struct mid_q_entry **ret_mid)
 352 {
 353         int rc;
 354         struct smb_hdr *hdr = (struct smb_hdr *)iov[0].iov_base;
 355         struct mid_q_entry *mid;
 356
 357         /* enable signing if server requires it */
 358         if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
 359                 hdr->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
 360
 361         mid = AllocMidQEntry(hdr, server);
 362         if (mid == NULL)
 363                 return -ENOMEM;
 364
 365         rc = cifs_sign_smbv(iov, nvec, server, &mid->sequence_number);
 366         if (rc) {
 367                 DeleteMidQEntry(mid);
 368                 return rc;
 369         }
 370
 371         *ret_mid = mid;
 372         return 0;
 373 }
 374
 375 /*
 376  * Send a SMB request and set the callback function in the mid to handle
 377  * the result. Caller is responsible for dealing with timeouts.
 378  */
 379 int
 380 cifs_call_async(struct TCP_Server_Info *server, struct kvec *iov,
 381                 unsigned int nvec, mid_receive_t *receive,
 382                 mid_callback_t *callback, void *cbdata, const int flags)
 383 {
 384         int rc, timeout, optype;
 385         struct mid_q_entry *mid;
 386
 387         timeout = flags & CIFS_TIMEOUT_MASK;
 388         optype = flags & CIFS_OP_MASK;
 389
 390         rc = wait_for_free_request(server, timeout, optype);
 391         if (rc)
 392                 return rc;
 393
 394         mutex_lock(&server->srv_mutex);
 395         rc = cifs_setup_async_request(server, iov, nvec, &mid);
 396         if (rc) {
 397                 mutex_unlock(&server->srv_mutex);
 398                 add_credits(server, 1, optype);
 399                 wake_up(&server->request_q);
 400                 return rc;
 401         }
 402
 403         mid->receive = receive;
 404         mid->callback = callback;
 405         mid->callback_data = cbdata;
 406         mid->mid_state = MID_REQUEST_SUBMITTED;
 407
 408         /* put it on the pending_mid_q */
 409         spin_lock(&GlobalMid_Lock);
 410         list_add_tail(&mid->qhead, &server->pending_mid_q);
 411         spin_unlock(&GlobalMid_Lock);
 412
 413
 414         cifs_in_send_inc(server);
 415         rc = smb_sendv(server, iov, nvec);
 416         cifs_in_send_dec(server);
 417         cifs_save_when_sent(mid);
 418         mutex_unlock(&server->srv_mutex);
 419
 420         if (rc == 0)
 421                 return 0;
 422
 423         delete_mid(mid);
 424         add_credits(server, 1, optype);
 425         wake_up(&server->request_q);
 426         return rc;
 427 }
 428
 429 /*
 430  *
 431  * Send an SMB Request.  No response info (other than return code)
 432  * needs to be parsed.
 433  *
 434  * flags indicate the type of request buffer and how long to wait
 435  * and whether to log NT STATUS code (error) before mapping it to POSIX error
 436  *
 437  */
 438 int
 439 SendReceiveNoRsp(const unsigned int xid, struct cifs_ses *ses,
 440                  char *in_buf, int flags)
 441 {
 442         int rc;
 443         struct kvec iov[1];
 444         int resp_buf_type;
 445
 446         iov[0].iov_base = in_buf;
 447         iov[0].iov_len = get_rfc1002_length(in_buf) + 4;
 448         flags |= CIFS_NO_RESP;
 449         rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags);
 450         cFYI(DBG2, "SendRcvNoRsp flags %d rc %d", flags, rc);
 451
 452         return rc;
 453 }
 454
 455 static int
 456 cifs_sync_mid_result(struct mid_q_entry *mid, struct TCP_Server_Info *server)
 457 {
 458         int rc = 0;
 459
 460         cFYI(1, "%s: cmd=%d mid=%llu state=%d", __func__,
 461              le16_to_cpu(mid->command), mid->mid, mid->mid_state);
 462
 463         spin_lock(&GlobalMid_Lock);
 464         switch (mid->mid_state) {
 465         case MID_RESPONSE_RECEIVED:
 466                 spin_unlock(&GlobalMid_Lock);
 467                 return rc;
 468         case MID_RETRY_NEEDED:
 469                 rc = -EAGAIN;
 470                 break;
 471         case MID_RESPONSE_MALFORMED:
 472                 rc = -EIO;
 473                 break;
 474         case MID_SHUTDOWN:
 475                 rc = -EHOSTDOWN;
 476                 break;
 477         default:
 478                 list_del_init(&mid->qhead);
 479                 cERROR(1, "%s: invalid mid state mid=%llu state=%d", __func__,
 480                        mid->mid, mid->mid_state);
 481                 rc = -EIO;
 482         }
 483         spin_unlock(&GlobalMid_Lock);
 484
 485         DeleteMidQEntry(mid);
 486         return rc;
 487 }
 488
 489 static inline int
 490 send_cancel(struct TCP_Server_Info *server, void *buf, struct mid_q_entry *mid)
 491 {
 492         return server->ops->send_cancel ?
 493                                 server->ops->send_cancel(server, buf, mid) : 0;
 494 }
 495
 496 int
 497 cifs_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,
 498                    bool log_error)
 499 {
 500         unsigned int len = get_rfc1002_length(mid->resp_buf) + 4;
 501
 502         dump_smb(mid->resp_buf, min_t(u32, 92, len));
 503
 504         /* convert the length into a more usable form */
 505         if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
 506                 struct kvec iov;
 507
 508                 iov.iov_base = mid->resp_buf;
 509                 iov.iov_len = len;
 510                 /* FIXME: add code to kill session */
 511                 if (cifs_verify_signature(&iov, 1, server,
 512                                           mid->sequence_number + 1) != 0)
 513                         cERROR(1, "Unexpected SMB signature");
 514         }
 515
 516         /* BB special case reconnect tid and uid here? */
 517         return map_smb_to_linux_error(mid->resp_buf, log_error);
 518 }
 519
 520 int
 521 cifs_setup_request(struct cifs_ses *ses, struct kvec *iov,
 522                    unsigned int nvec, struct mid_q_entry **ret_mid)
 523 {
 524         int rc;
 525         struct smb_hdr *hdr = (struct smb_hdr *)iov[0].iov_base;
 526         struct mid_q_entry *mid;
 527
 528         rc = allocate_mid(ses, hdr, &mid);
 529         if (rc)
 530                 return rc;
 531         rc = cifs_sign_smbv(iov, nvec, ses->server, &mid->sequence_number);
 532         if (rc)
 533                 delete_mid(mid);
 534         *ret_mid = mid;
 535         return rc;
 536 }
 537
 538 int
 539 SendReceive2(const unsigned int xid, struct cifs_ses *ses,
 540              struct kvec *iov, int n_vec, int *resp_buf_type /* ret */,
 541              const int flags)
 542 {
 543         int rc = 0;
 544         int timeout, optype;
 545         struct mid_q_entry *midQ;
 546         char *buf = iov[0].iov_base;
 547         unsigned int credits = 1;
 548
 549         timeout = flags & CIFS_TIMEOUT_MASK;
 550         optype = flags & CIFS_OP_MASK;
 551
 552         *resp_buf_type = CIFS_NO_BUFFER;  /* no response buf yet */
 553
 554         if ((ses == NULL) || (ses->server == NULL)) {
 555                 cifs_small_buf_release(buf);
 556                 cERROR(1, "Null session");
 557                 return -EIO;
 558         }
 559
 560         if (ses->server->tcpStatus == CifsExiting) {
 561                 cifs_small_buf_release(buf);
 562                 return -ENOENT;
 563         }
 564
 565         /*
 566          * Ensure that we do not send more than 50 overlapping requests
 567          * to the same server. We may make this configurable later or
 568          * use ses->maxReq.
 569          */
 570
 571         rc = wait_for_free_request(ses->server, timeout, optype);
 572         if (rc) {
 573                 cifs_small_buf_release(buf);
 574                 return rc;
 575         }
 576
 577         /*
 578          * Make sure that we sign in the same order that we send on this socket
 579          * and avoid races inside tcp sendmsg code that could cause corruption
 580          * of smb data.
 581          */
 582
 583         mutex_lock(&ses->server->srv_mutex);
 584
 585         rc = ses->server->ops->setup_request(ses, iov, n_vec, &midQ);
 586         if (rc) {
 587                 mutex_unlock(&ses->server->srv_mutex);
 588                 cifs_small_buf_release(buf);
 589                 /* Update # of requests on wire to server */
 590                 add_credits(ses->server, 1, optype);
 591                 return rc;
 592         }
 593
 594         midQ->mid_state = MID_REQUEST_SUBMITTED;
 595         cifs_in_send_inc(ses->server);
 596         rc = smb_sendv(ses->server, iov, n_vec);
 597         cifs_in_send_dec(ses->server);
 598         cifs_save_when_sent(midQ);
 599
 600         mutex_unlock(&ses->server->srv_mutex);
 601
 602         if (rc < 0) {
 603                 cifs_small_buf_release(buf);
 604                 goto out;
 605         }
 606
 607         if (timeout == CIFS_ASYNC_OP) {
 608                 cifs_small_buf_release(buf);
 609                 goto out;
 610         }
 611
 612         rc = wait_for_response(ses->server, midQ);
 613         if (rc != 0) {
 614                 send_cancel(ses->server, buf, midQ);
 615                 spin_lock(&GlobalMid_Lock);
 616                 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
 617                         midQ->callback = DeleteMidQEntry;
 618                         spin_unlock(&GlobalMid_Lock);
 619                         cifs_small_buf_release(buf);
 620                         add_credits(ses->server, 1, optype);
 621                         return rc;
 622                 }
 623                 spin_unlock(&GlobalMid_Lock);
 624         }
 625
 626         cifs_small_buf_release(buf);
 627
 628         rc = cifs_sync_mid_result(midQ, ses->server);
 629         if (rc != 0) {
 630                 add_credits(ses->server, 1, optype);
 631                 return rc;
 632         }
 633
 634         if (!midQ->resp_buf || midQ->mid_state != MID_RESPONSE_RECEIVED) {
 635                 rc = -EIO;
 636                 cFYI(1, "Bad MID state?");
 637                 goto out;
 638         }
 639
 640         buf = (char *)midQ->resp_buf;
 641         iov[0].iov_base = buf;
 642         iov[0].iov_len = get_rfc1002_length(buf) + 4;
 643         if (midQ->large_buf)
 644                 *resp_buf_type = CIFS_LARGE_BUFFER;
 645         else
 646                 *resp_buf_type = CIFS_SMALL_BUFFER;
 647
 648         credits = ses->server->ops->get_credits(midQ);
 649
 650         rc = ses->server->ops->check_receive(midQ, ses->server,
 651                                              flags & CIFS_LOG_ERROR);
 652
 653         /* mark it so buf will not be freed by delete_mid */
 654         if ((flags & CIFS_NO_RESP) == 0)
 655                 midQ->resp_buf = NULL;
 656 out:
 657         delete_mid(midQ);
 658         add_credits(ses->server, credits, optype);
 659
 660         return rc;
 661 }
 662
 663 int
 664 SendReceive(const unsigned int xid, struct cifs_ses *ses,
 665             struct smb_hdr *in_buf, struct smb_hdr *out_buf,
 666             int *pbytes_returned, const int timeout)
 667 {
 668         int rc = 0;
 669         struct mid_q_entry *midQ;
 670
 671         if (ses == NULL) {
 672                 cERROR(1, "Null smb session");
 673                 return -EIO;
 674         }
 675         if (ses->server == NULL) {
 676                 cERROR(1, "Null tcp session");
 677                 return -EIO;
 678         }
 679
 680         if (ses->server->tcpStatus == CifsExiting)
 681                 return -ENOENT;
 682
 683         /* Ensure that we do not send more than 50 overlapping requests
 684            to the same server. We may make this configurable later or
 685            use ses->maxReq */
 686
 687         if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
 688                         MAX_CIFS_HDR_SIZE - 4) {
 689                 cERROR(1, "Illegal length, greater than maximum frame, %d",
 690                            be32_to_cpu(in_buf->smb_buf_length));
 691                 return -EIO;
 692         }
 693
 694         rc = wait_for_free_request(ses->server, timeout, 0);
 695         if (rc)
 696                 return rc;
 697
 698         /* make sure that we sign in the same order that we send on this socket
 699            and avoid races inside tcp sendmsg code that could cause corruption
 700            of smb data */
 701
 702         mutex_lock(&ses->server->srv_mutex);
 703
 704         rc = allocate_mid(ses, in_buf, &midQ);
 705         if (rc) {
 706                 mutex_unlock(&ses->server->srv_mutex);
 707                 /* Update # of requests on wire to server */
 708                 add_credits(ses->server, 1, 0);
 709                 return rc;
 710         }
 711
 712         rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
 713         if (rc) {
 714                 mutex_unlock(&ses->server->srv_mutex);
 715                 goto out;
 716         }
 717
 718         midQ->mid_state = MID_REQUEST_SUBMITTED;
 719
 720         cifs_in_send_inc(ses->server);
 721         rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
 722         cifs_in_send_dec(ses->server);
 723         cifs_save_when_sent(midQ);
 724         mutex_unlock(&ses->server->srv_mutex);
 725
 726         if (rc < 0)
 727                 goto out;
 728
 729         if (timeout == CIFS_ASYNC_OP)
 730                 goto out;
 731
 732         rc = wait_for_response(ses->server, midQ);
 733         if (rc != 0) {
 734                 send_cancel(ses->server, in_buf, midQ);
 735                 spin_lock(&GlobalMid_Lock);
 736                 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
 737                         /* no longer considered to be "in-flight" */
 738                         midQ->callback = DeleteMidQEntry;
 739                         spin_unlock(&GlobalMid_Lock);
 740                         add_credits(ses->server, 1, 0);
 741                         return rc;
 742                 }
 743                 spin_unlock(&GlobalMid_Lock);
 744         }
 745
 746         rc = cifs_sync_mid_result(midQ, ses->server);
 747         if (rc != 0) {
 748                 add_credits(ses->server, 1, 0);
 749                 return rc;
 750         }
 751
 752         if (!midQ->resp_buf || !out_buf ||
 753             midQ->mid_state != MID_RESPONSE_RECEIVED) {
 754                 rc = -EIO;
 755                 cERROR(1, "Bad MID state?");
 756                 goto out;
 757         }
 758
 759         *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
 760         memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
 761         rc = cifs_check_receive(midQ, ses->server, 0);
 762 out:
 763         delete_mid(midQ);
 764         add_credits(ses->server, 1, 0);
 765
 766         return rc;
 767 }
 768
 769 /* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
 770    blocking lock to return. */
 771
 772 static int
 773 send_lock_cancel(const unsigned int xid, struct cifs_tcon *tcon,
 774                         struct smb_hdr *in_buf,
 775                         struct smb_hdr *out_buf)
 776 {
 777         int bytes_returned;
 778         struct cifs_ses *ses = tcon->ses;
 779         LOCK_REQ *pSMB = (LOCK_REQ *)in_buf;
 780
 781         /* We just modify the current in_buf to change
 782            the type of lock from LOCKING_ANDX_SHARED_LOCK
 783            or LOCKING_ANDX_EXCLUSIVE_LOCK to
 784            LOCKING_ANDX_CANCEL_LOCK. */
 785
 786         pSMB->LockType = LOCKING_ANDX_CANCEL_LOCK|LOCKING_ANDX_LARGE_FILES;
 787         pSMB->Timeout = 0;
 788         pSMB->hdr.Mid = get_next_mid(ses->server);
 789
 790         return SendReceive(xid, ses, in_buf, out_buf,
 791                         &bytes_returned, 0);
 792 }
 793
 794 int
 795 SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
 796             struct smb_hdr *in_buf, struct smb_hdr *out_buf,
 797             int *pbytes_returned)
 798 {
 799         int rc = 0;
 800         int rstart = 0;
 801         struct mid_q_entry *midQ;
 802         struct cifs_ses *ses;
 803
 804         if (tcon == NULL || tcon->ses == NULL) {
 805                 cERROR(1, "Null smb session");
 806                 return -EIO;
 807         }
 808         ses = tcon->ses;
 809
 810         if (ses->server == NULL) {
 811                 cERROR(1, "Null tcp session");
 812                 return -EIO;
 813         }
 814
 815         if (ses->server->tcpStatus == CifsExiting)
 816                 return -ENOENT;
 817
 818         /* Ensure that we do not send more than 50 overlapping requests
 819            to the same server. We may make this configurable later or
 820            use ses->maxReq */
 821
 822         if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
 823                         MAX_CIFS_HDR_SIZE - 4) {
 824                 cERROR(1, "Illegal length, greater than maximum frame, %d",
 825                            be32_to_cpu(in_buf->smb_buf_length));
 826                 return -EIO;
 827         }
 828
 829         rc = wait_for_free_request(ses->server, CIFS_BLOCKING_OP, 0);
 830         if (rc)
 831                 return rc;
 832
 833         /* make sure that we sign in the same order that we send on this socket
 834            and avoid races inside tcp sendmsg code that could cause corruption
 835            of smb data */
 836
 837         mutex_lock(&ses->server->srv_mutex);
 838
 839         rc = allocate_mid(ses, in_buf, &midQ);
 840         if (rc) {
 841                 mutex_unlock(&ses->server->srv_mutex);
 842                 return rc;
 843         }
 844
 845         rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
 846         if (rc) {
 847                 delete_mid(midQ);
 848                 mutex_unlock(&ses->server->srv_mutex);
 849                 return rc;
 850         }
 851
 852         midQ->mid_state = MID_REQUEST_SUBMITTED;
 853         cifs_in_send_inc(ses->server);
 854         rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
 855         cifs_in_send_dec(ses->server);
 856         cifs_save_when_sent(midQ);
 857         mutex_unlock(&ses->server->srv_mutex);
 858
 859         if (rc < 0) {
 860                 delete_mid(midQ);
 861                 return rc;
 862         }
 863
 864         /* Wait for a reply - allow signals to interrupt. */
 865         rc = wait_event_interruptible(ses->server->response_q,
 866                 (!(midQ->mid_state == MID_REQUEST_SUBMITTED)) ||
 867                 ((ses->server->tcpStatus != CifsGood) &&
 868                  (ses->server->tcpStatus != CifsNew)));
 869
 870         /* Were we interrupted by a signal ? */
 871         if ((rc == -ERESTARTSYS) &&
 872                 (midQ->mid_state == MID_REQUEST_SUBMITTED) &&
 873                 ((ses->server->tcpStatus == CifsGood) ||
 874                  (ses->server->tcpStatus == CifsNew))) {
 875
 876                 if (in_buf->Command == SMB_COM_TRANSACTION2) {
 877                         /* POSIX lock. We send a NT_CANCEL SMB to cause the
 878                            blocking lock to return. */
 879                         rc = send_cancel(ses->server, in_buf, midQ);
 880                         if (rc) {
 881                                 delete_mid(midQ);
 882                                 return rc;
 883                         }
 884                 } else {
 885                         /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
 886                            to cause the blocking lock to return. */
 887
 888                         rc = send_lock_cancel(xid, tcon, in_buf, out_buf);
 889
 890                         /* If we get -ENOLCK back the lock may have
 891                            already been removed. Don't exit in this case. */
 892                         if (rc && rc != -ENOLCK) {
 893                                 delete_mid(midQ);
 894                                 return rc;
 895                         }
 896                 }
 897
 898                 rc = wait_for_response(ses->server, midQ);
 899                 if (rc) {
 900                         send_cancel(ses->server, in_buf, midQ);
 901                         spin_lock(&GlobalMid_Lock);
 902                         if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
 903                                 /* no longer considered to be "in-flight" */
 904                                 midQ->callback = DeleteMidQEntry;
 905                                 spin_unlock(&GlobalMid_Lock);
 906                                 return rc;
 907                         }
 908                         spin_unlock(&GlobalMid_Lock);
 909                 }
 910
 911                 /* We got the response - restart system call. */
 912                 rstart = 1;
 913         }
 914
 915         rc = cifs_sync_mid_result(midQ, ses->server);
 916         if (rc != 0)
 917                 return rc;
 918
 919         /* rcvd frame is ok */
 920         if (out_buf == NULL || midQ->mid_state != MID_RESPONSE_RECEIVED) {
 921                 rc = -EIO;
 922                 cERROR(1, "Bad MID state?");
 923                 goto out;
 924         }
 925
 926         *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
 927         memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
 928         rc = cifs_check_receive(midQ, ses->server, 0);
 929 out:
 930         delete_mid(midQ);
 931         if (rstart && rc == -EACCES)
 932                 return -ERESTARTSYS;
 933         return rc;
 934 }