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 <asm/uaccess.h>
  30 #include <asm/processor.h>
  31 #include <linux/mempool.h>
  32 #include "cifspdu.h"
  33 #include "cifsglob.h"
  34 #include "cifsproto.h"
  35 #include "cifs_debug.h"
  36
  37 extern mempool_t *cifs_mid_poolp;
  38
  39 static void
  40 wake_up_task(struct mid_q_entry *mid)
  41 {
  42         wake_up_process(mid->callback_data);
  43 }
  44
  45 struct mid_q_entry *
  46 AllocMidQEntry(const struct smb_hdr *smb_buffer, struct TCP_Server_Info *server)
  47 {
  48         struct mid_q_entry *temp;
  49
  50         if (server == NULL) {
  51                 cERROR(1, "Null TCP session in AllocMidQEntry");
  52                 return NULL;
  53         }
  54
  55         temp = mempool_alloc(cifs_mid_poolp, GFP_NOFS);
  56         if (temp == NULL)
  57                 return temp;
  58         else {
  59                 memset(temp, 0, sizeof(struct mid_q_entry));
  60                 temp->mid = smb_buffer->Mid;    /* always LE */
  61                 temp->pid = current->pid;
  62                 temp->command = smb_buffer->Command;
  63                 cFYI(1, "For smb_command %d", temp->command);
  64         /*      do_gettimeofday(&temp->when_sent);*/ /* easier to use jiffies */
  65                 /* when mid allocated can be before when sent */
  66                 temp->when_alloc = jiffies;
  67
  68                 /*
  69                  * The default is for the mid to be synchronous, so the
  70                  * default callback just wakes up the current task.
  71                  */
  72                 temp->callback = wake_up_task;
  73                 temp->callback_data = current;
  74         }
  75
  76         atomic_inc(&midCount);
  77         temp->midState = MID_REQUEST_ALLOCATED;
  78         return temp;
  79 }
  80
  81 void
  82 DeleteMidQEntry(struct mid_q_entry *midEntry)
  83 {
  84 #ifdef CONFIG_CIFS_STATS2
  85         unsigned long now;
  86 #endif
  87         midEntry->midState = MID_FREE;
  88         atomic_dec(&midCount);
  89         if (midEntry->largeBuf)
  90                 cifs_buf_release(midEntry->resp_buf);
  91         else
  92                 cifs_small_buf_release(midEntry->resp_buf);
  93 #ifdef CONFIG_CIFS_STATS2
  94         now = jiffies;
  95         /* commands taking longer than one second are indications that
  96            something is wrong, unless it is quite a slow link or server */
  97         if ((now - midEntry->when_alloc) > HZ) {
  98                 if ((cifsFYI & CIFS_TIMER) &&
  99                    (midEntry->command != SMB_COM_LOCKING_ANDX)) {
 100                         printk(KERN_DEBUG " CIFS slow rsp: cmd %d mid %d",
 101                                midEntry->command, midEntry->mid);
 102                         printk(" A: 0x%lx S: 0x%lx R: 0x%lx\n",
 103                                now - midEntry->when_alloc,
 104                                now - midEntry->when_sent,
 105                                now - midEntry->when_received);
 106                 }
 107         }
 108 #endif
 109         mempool_free(midEntry, cifs_mid_poolp);
 110 }
 111
 112 static void
 113 delete_mid(struct mid_q_entry *mid)
 114 {
 115         spin_lock(&GlobalMid_Lock);
 116         list_del(&mid->qhead);
 117         spin_unlock(&GlobalMid_Lock);
 118
 119         DeleteMidQEntry(mid);
 120 }
 121
 122 static int
 123 smb_sendv(struct TCP_Server_Info *server, struct kvec *iov, int n_vec)
 124 {
 125         int rc = 0;
 126         int i = 0;
 127         struct msghdr smb_msg;
 128         struct smb_hdr *smb_buffer = iov[0].iov_base;
 129         unsigned int len = iov[0].iov_len;
 130         unsigned int total_len;
 131         int first_vec = 0;
 132         unsigned int smb_buf_length = be32_to_cpu(smb_buffer->smb_buf_length);
 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(smb_buffer, 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                         /* if blocking send we try 3 times, since each can block
 161                            for 5 seconds. For nonblocking  we have to try more
 162                            but wait increasing amounts of time allowing time for
 163                            socket to clear.  The overall time we wait in either
 164                            case to send on the socket is about 15 seconds.
 165                            Similarly we wait for 15 seconds for
 166                            a response from the server in SendReceive[2]
 167                            for the server to send a response back for
 168                            most types of requests (except SMB Write
 169                            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         /* Don't want to modify the buffer as a
 238            side effect of this call. */
 239         smb_buffer->smb_buf_length = cpu_to_be32(smb_buf_length);
 240
 241         return rc;
 242 }
 243
 244 int
 245 smb_send(struct TCP_Server_Info *server, struct smb_hdr *smb_buffer,
 246          unsigned int smb_buf_length)
 247 {
 248         struct kvec iov;
 249
 250         iov.iov_base = smb_buffer;
 251         iov.iov_len = smb_buf_length + 4;
 252
 253         return smb_sendv(server, &iov, 1);
 254 }
 255
 256 static int wait_for_free_request(struct TCP_Server_Info *server,
 257                                  const int long_op)
 258 {
 259         if (long_op == CIFS_ASYNC_OP) {
 260                 /* oplock breaks must not be held up */
 261                 atomic_inc(&server->inFlight);
 262                 return 0;
 263         }
 264
 265         spin_lock(&GlobalMid_Lock);
 266         while (1) {
 267                 if (atomic_read(&server->inFlight) >= cifs_max_pending) {
 268                         spin_unlock(&GlobalMid_Lock);
 269 #ifdef CONFIG_CIFS_STATS2
 270                         atomic_inc(&server->num_waiters);
 271 #endif
 272                         wait_event(server->request_q,
 273                                    atomic_read(&server->inFlight)
 274                                      < cifs_max_pending);
 275 #ifdef CONFIG_CIFS_STATS2
 276                         atomic_dec(&server->num_waiters);
 277 #endif
 278                         spin_lock(&GlobalMid_Lock);
 279                 } else {
 280                         if (server->tcpStatus == CifsExiting) {
 281                                 spin_unlock(&GlobalMid_Lock);
 282                                 return -ENOENT;
 283                         }
 284
 285                         /* can not count locking commands against total
 286                            as they are allowed to block on server */
 287
 288                         /* update # of requests on the wire to server */
 289                         if (long_op != CIFS_BLOCKING_OP)
 290                                 atomic_inc(&server->inFlight);
 291                         spin_unlock(&GlobalMid_Lock);
 292                         break;
 293                 }
 294         }
 295         return 0;
 296 }
 297
 298 static int allocate_mid(struct cifsSesInfo *ses, struct smb_hdr *in_buf,
 299                         struct mid_q_entry **ppmidQ)
 300 {
 301         if (ses->server->tcpStatus == CifsExiting) {
 302                 return -ENOENT;
 303         }
 304
 305         if (ses->server->tcpStatus == CifsNeedReconnect) {
 306                 cFYI(1, "tcp session dead - return to caller to retry");
 307                 return -EAGAIN;
 308         }
 309
 310         if (ses->status != CifsGood) {
 311                 /* check if SMB session is bad because we are setting it up */
 312                 if ((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
 313                         (in_buf->Command != SMB_COM_NEGOTIATE))
 314                         return -EAGAIN;
 315                 /* else ok - we are setting up session */
 316         }
 317         *ppmidQ = AllocMidQEntry(in_buf, ses->server);
 318         if (*ppmidQ == NULL)
 319                 return -ENOMEM;
 320         spin_lock(&GlobalMid_Lock);
 321         list_add_tail(&(*ppmidQ)->qhead, &ses->server->pending_mid_q);
 322         spin_unlock(&GlobalMid_Lock);
 323         return 0;
 324 }
 325
 326 static int
 327 wait_for_response(struct TCP_Server_Info *server, struct mid_q_entry *midQ)
 328 {
 329         int error;
 330
 331         error = wait_event_killable(server->response_q,
 332                                     midQ->midState != MID_REQUEST_SUBMITTED);
 333         if (error < 0)
 334                 return -ERESTARTSYS;
 335
 336         return 0;
 337 }
 338
 339
 340 /*
 341  * Send a SMB request and set the callback function in the mid to handle
 342  * the result. Caller is responsible for dealing with timeouts.
 343  */
 344 int
 345 cifs_call_async(struct TCP_Server_Info *server, struct smb_hdr *in_buf,
 346                 mid_callback_t *callback, void *cbdata)
 347 {
 348         int rc;
 349         struct mid_q_entry *mid;
 350
 351         rc = wait_for_free_request(server, CIFS_ASYNC_OP);
 352         if (rc)
 353                 return rc;
 354
 355         /* enable signing if server requires it */
 356         if (server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
 357                 in_buf->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
 358
 359         mutex_lock(&server->srv_mutex);
 360         mid = AllocMidQEntry(in_buf, server);
 361         if (mid == NULL) {
 362                 mutex_unlock(&server->srv_mutex);
 363                 return -ENOMEM;
 364         }
 365
 366         /* put it on the pending_mid_q */
 367         spin_lock(&GlobalMid_Lock);
 368         list_add_tail(&mid->qhead, &server->pending_mid_q);
 369         spin_unlock(&GlobalMid_Lock);
 370
 371         rc = cifs_sign_smb(in_buf, server, &mid->sequence_number);
 372         if (rc) {
 373                 mutex_unlock(&server->srv_mutex);
 374                 goto out_err;
 375         }
 376
 377         mid->callback = callback;
 378         mid->callback_data = cbdata;
 379         mid->midState = MID_REQUEST_SUBMITTED;
 380 #ifdef CONFIG_CIFS_STATS2
 381         atomic_inc(&server->inSend);
 382 #endif
 383         rc = smb_send(server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
 384 #ifdef CONFIG_CIFS_STATS2
 385         atomic_dec(&server->inSend);
 386         mid->when_sent = jiffies;
 387 #endif
 388         mutex_unlock(&server->srv_mutex);
 389         if (rc)
 390                 goto out_err;
 391
 392         return rc;
 393 out_err:
 394         delete_mid(mid);
 395         atomic_dec(&server->inFlight);
 396         wake_up(&server->request_q);
 397         return rc;
 398 }
 399
 400 /*
 401  *
 402  * Send an SMB Request.  No response info (other than return code)
 403  * needs to be parsed.
 404  *
 405  * flags indicate the type of request buffer and how long to wait
 406  * and whether to log NT STATUS code (error) before mapping it to POSIX error
 407  *
 408  */
 409 int
 410 SendReceiveNoRsp(const unsigned int xid, struct cifsSesInfo *ses,
 411                 struct smb_hdr *in_buf, int flags)
 412 {
 413         int rc;
 414         struct kvec iov[1];
 415         int resp_buf_type;
 416
 417         iov[0].iov_base = (char *)in_buf;
 418         iov[0].iov_len = be32_to_cpu(in_buf->smb_buf_length) + 4;
 419         flags |= CIFS_NO_RESP;
 420         rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags);
 421         cFYI(DBG2, "SendRcvNoRsp flags %d rc %d", flags, rc);
 422
 423         return rc;
 424 }
 425
 426 static int
 427 sync_mid_result(struct mid_q_entry *mid, struct TCP_Server_Info *server)
 428 {
 429         int rc = 0;
 430
 431         cFYI(1, "%s: cmd=%d mid=%d state=%d", __func__, mid->command,
 432                 mid->mid, mid->midState);
 433
 434         spin_lock(&GlobalMid_Lock);
 435         /* ensure that it's no longer on the pending_mid_q */
 436         list_del_init(&mid->qhead);
 437
 438         switch (mid->midState) {
 439         case MID_RESPONSE_RECEIVED:
 440                 spin_unlock(&GlobalMid_Lock);
 441                 return rc;
 442         case MID_REQUEST_SUBMITTED:
 443                 /* socket is going down, reject all calls */
 444                 if (server->tcpStatus == CifsExiting) {
 445                         cERROR(1, "%s: canceling mid=%d cmd=0x%x state=%d",
 446                                __func__, mid->mid, mid->command, mid->midState);
 447                         rc = -EHOSTDOWN;
 448                         break;
 449                 }
 450         case MID_RETRY_NEEDED:
 451                 rc = -EAGAIN;
 452                 break;
 453         case MID_RESPONSE_MALFORMED:
 454                 rc = -EIO;
 455                 break;
 456         default:
 457                 cERROR(1, "%s: invalid mid state mid=%d state=%d", __func__,
 458                         mid->mid, mid->midState);
 459                 rc = -EIO;
 460         }
 461         spin_unlock(&GlobalMid_Lock);
 462
 463         DeleteMidQEntry(mid);
 464         return rc;
 465 }
 466
 467 /*
 468  * An NT cancel request header looks just like the original request except:
 469  *
 470  * The Command is SMB_COM_NT_CANCEL
 471  * The WordCount is zeroed out
 472  * The ByteCount is zeroed out
 473  *
 474  * This function mangles an existing request buffer into a
 475  * SMB_COM_NT_CANCEL request and then sends it.
 476  */
 477 static int
 478 send_nt_cancel(struct TCP_Server_Info *server, struct smb_hdr *in_buf,
 479                 struct mid_q_entry *mid)
 480 {
 481         int rc = 0;
 482
 483         /* -4 for RFC1001 length and +2 for BCC field */
 484         in_buf->smb_buf_length = cpu_to_be32(sizeof(struct smb_hdr) - 4  + 2);
 485         in_buf->Command = SMB_COM_NT_CANCEL;
 486         in_buf->WordCount = 0;
 487         put_bcc(0, in_buf);
 488
 489         mutex_lock(&server->srv_mutex);
 490         rc = cifs_sign_smb(in_buf, server, &mid->sequence_number);
 491         if (rc) {
 492                 mutex_unlock(&server->srv_mutex);
 493                 return rc;
 494         }
 495         rc = smb_send(server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
 496         mutex_unlock(&server->srv_mutex);
 497
 498         cFYI(1, "issued NT_CANCEL for mid %u, rc = %d",
 499                 in_buf->Mid, rc);
 500
 501         return rc;
 502 }
 503
 504 int
 505 SendReceive2(const unsigned int xid, struct cifsSesInfo *ses,
 506              struct kvec *iov, int n_vec, int *pRespBufType /* ret */,
 507              const int flags)
 508 {
 509         int rc = 0;
 510         int long_op;
 511         unsigned int receive_len;
 512         struct mid_q_entry *midQ;
 513         struct smb_hdr *in_buf = iov[0].iov_base;
 514
 515         long_op = flags & CIFS_TIMEOUT_MASK;
 516
 517         *pRespBufType = CIFS_NO_BUFFER;  /* no response buf yet */
 518
 519         if ((ses == NULL) || (ses->server == NULL)) {
 520                 cifs_small_buf_release(in_buf);
 521                 cERROR(1, "Null session");
 522                 return -EIO;
 523         }
 524
 525         if (ses->server->tcpStatus == CifsExiting) {
 526                 cifs_small_buf_release(in_buf);
 527                 return -ENOENT;
 528         }
 529
 530         /* Ensure that we do not send more than 50 overlapping requests
 531            to the same server. We may make this configurable later or
 532            use ses->maxReq */
 533
 534         rc = wait_for_free_request(ses->server, long_op);
 535         if (rc) {
 536                 cifs_small_buf_release(in_buf);
 537                 return rc;
 538         }
 539
 540         /* make sure that we sign in the same order that we send on this socket
 541            and avoid races inside tcp sendmsg code that could cause corruption
 542            of smb data */
 543
 544         mutex_lock(&ses->server->srv_mutex);
 545
 546         rc = allocate_mid(ses, in_buf, &midQ);
 547         if (rc) {
 548                 mutex_unlock(&ses->server->srv_mutex);
 549                 cifs_small_buf_release(in_buf);
 550                 /* Update # of requests on wire to server */
 551                 atomic_dec(&ses->server->inFlight);
 552                 wake_up(&ses->server->request_q);
 553                 return rc;
 554         }
 555         rc = cifs_sign_smb2(iov, n_vec, ses->server, &midQ->sequence_number);
 556         if (rc) {
 557                 mutex_unlock(&ses->server->srv_mutex);
 558                 cifs_small_buf_release(in_buf);
 559                 goto out;
 560         }
 561
 562         midQ->midState = MID_REQUEST_SUBMITTED;
 563 #ifdef CONFIG_CIFS_STATS2
 564         atomic_inc(&ses->server->inSend);
 565 #endif
 566         rc = smb_sendv(ses->server, iov, n_vec);
 567 #ifdef CONFIG_CIFS_STATS2
 568         atomic_dec(&ses->server->inSend);
 569         midQ->when_sent = jiffies;
 570 #endif
 571
 572         mutex_unlock(&ses->server->srv_mutex);
 573
 574         if (rc < 0) {
 575                 cifs_small_buf_release(in_buf);
 576                 goto out;
 577         }
 578
 579         if (long_op == CIFS_ASYNC_OP) {
 580                 cifs_small_buf_release(in_buf);
 581                 goto out;
 582         }
 583
 584         rc = wait_for_response(ses->server, midQ);
 585         if (rc != 0) {
 586                 send_nt_cancel(ses->server, in_buf, midQ);
 587                 spin_lock(&GlobalMid_Lock);
 588                 if (midQ->midState == MID_REQUEST_SUBMITTED) {
 589                         midQ->callback = DeleteMidQEntry;
 590                         spin_unlock(&GlobalMid_Lock);
 591                         cifs_small_buf_release(in_buf);
 592                         atomic_dec(&ses->server->inFlight);
 593                         wake_up(&ses->server->request_q);
 594                         return rc;
 595                 }
 596                 spin_unlock(&GlobalMid_Lock);
 597         }
 598
 599         cifs_small_buf_release(in_buf);
 600
 601         rc = sync_mid_result(midQ, ses->server);
 602         if (rc != 0) {
 603                 atomic_dec(&ses->server->inFlight);
 604                 wake_up(&ses->server->request_q);
 605                 return rc;
 606         }
 607
 608         receive_len = be32_to_cpu(midQ->resp_buf->smb_buf_length);
 609
 610         if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
 611                 cERROR(1, "Frame too large received.  Length: %d  Xid: %d",
 612                         receive_len, xid);
 613                 rc = -EIO;
 614                 goto out;
 615         }
 616
 617         /* rcvd frame is ok */
 618
 619         if (midQ->resp_buf &&
 620             (midQ->midState == MID_RESPONSE_RECEIVED)) {
 621
 622                 iov[0].iov_base = (char *)midQ->resp_buf;
 623                 if (midQ->largeBuf)
 624                         *pRespBufType = CIFS_LARGE_BUFFER;
 625                 else
 626                         *pRespBufType = CIFS_SMALL_BUFFER;
 627                 iov[0].iov_len = receive_len + 4;
 628
 629                 dump_smb(midQ->resp_buf, 80);
 630                 /* convert the length into a more usable form */
 631                 if ((receive_len > 24) &&
 632                     (ses->server->secMode & (SECMODE_SIGN_REQUIRED |
 633                                              SECMODE_SIGN_ENABLED))) {
 634                         rc = cifs_verify_signature(midQ->resp_buf,
 635                                                 ses->server,
 636                                                 midQ->sequence_number+1);
 637                         if (rc) {
 638                                 cERROR(1, "Unexpected SMB signature");
 639                                 /* BB FIXME add code to kill session */
 640                         }
 641                 }
 642
 643                 /* BB special case reconnect tid and uid here? */
 644                 rc = map_smb_to_linux_error(midQ->resp_buf,
 645                                             flags & CIFS_LOG_ERROR);
 646
 647                 if ((flags & CIFS_NO_RESP) == 0)
 648                         midQ->resp_buf = NULL;  /* mark it so buf will
 649                                                    not be freed by
 650                                                    delete_mid */
 651         } else {
 652                 rc = -EIO;
 653                 cFYI(1, "Bad MID state?");
 654         }
 655
 656 out:
 657         delete_mid(midQ);
 658         atomic_dec(&ses->server->inFlight);
 659         wake_up(&ses->server->request_q);
 660
 661         return rc;
 662 }
 663
 664 int
 665 SendReceive(const unsigned int xid, struct cifsSesInfo *ses,
 666             struct smb_hdr *in_buf, struct smb_hdr *out_buf,
 667             int *pbytes_returned, const int long_op)
 668 {
 669         int rc = 0;
 670         unsigned int receive_len;
 671         struct mid_q_entry *midQ;
 672
 673         if (ses == NULL) {
 674                 cERROR(1, "Null smb session");
 675                 return -EIO;
 676         }
 677         if (ses->server == NULL) {
 678                 cERROR(1, "Null tcp session");
 679                 return -EIO;
 680         }
 681
 682         if (ses->server->tcpStatus == CifsExiting)
 683                 return -ENOENT;
 684
 685         /* Ensure that we do not send more than 50 overlapping requests
 686            to the same server. We may make this configurable later or
 687            use ses->maxReq */
 688
 689         if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
 690                         MAX_CIFS_HDR_SIZE - 4) {
 691                 cERROR(1, "Illegal length, greater than maximum frame, %d",
 692                            be32_to_cpu(in_buf->smb_buf_length));
 693                 return -EIO;
 694         }
 695
 696         rc = wait_for_free_request(ses->server, long_op);
 697         if (rc)
 698                 return rc;
 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         mutex_lock(&ses->server->srv_mutex);
 705
 706         rc = allocate_mid(ses, in_buf, &midQ);
 707         if (rc) {
 708                 mutex_unlock(&ses->server->srv_mutex);
 709                 /* Update # of requests on wire to server */
 710                 atomic_dec(&ses->server->inFlight);
 711                 wake_up(&ses->server->request_q);
 712                 return rc;
 713         }
 714
 715         rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
 716         if (rc) {
 717                 mutex_unlock(&ses->server->srv_mutex);
 718                 goto out;
 719         }
 720
 721         midQ->midState = MID_REQUEST_SUBMITTED;
 722 #ifdef CONFIG_CIFS_STATS2
 723         atomic_inc(&ses->server->inSend);
 724 #endif
 725         rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
 726 #ifdef CONFIG_CIFS_STATS2
 727         atomic_dec(&ses->server->inSend);
 728         midQ->when_sent = jiffies;
 729 #endif
 730         mutex_unlock(&ses->server->srv_mutex);
 731
 732         if (rc < 0)
 733                 goto out;
 734
 735         if (long_op == CIFS_ASYNC_OP)
 736                 goto out;
 737
 738         rc = wait_for_response(ses->server, midQ);
 739         if (rc != 0) {
 740                 send_nt_cancel(ses->server, in_buf, midQ);
 741                 spin_lock(&GlobalMid_Lock);
 742                 if (midQ->midState == MID_REQUEST_SUBMITTED) {
 743                         /* no longer considered to be "in-flight" */
 744                         midQ->callback = DeleteMidQEntry;
 745                         spin_unlock(&GlobalMid_Lock);
 746                         atomic_dec(&ses->server->inFlight);
 747                         wake_up(&ses->server->request_q);
 748                         return rc;
 749                 }
 750                 spin_unlock(&GlobalMid_Lock);
 751         }
 752
 753         rc = sync_mid_result(midQ, ses->server);
 754         if (rc != 0) {
 755                 atomic_dec(&ses->server->inFlight);
 756                 wake_up(&ses->server->request_q);
 757                 return rc;
 758         }
 759
 760         receive_len = be32_to_cpu(midQ->resp_buf->smb_buf_length);
 761
 762         if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
 763                 cERROR(1, "Frame too large received.  Length: %d  Xid: %d",
 764                         receive_len, xid);
 765                 rc = -EIO;
 766                 goto out;
 767         }
 768
 769         /* rcvd frame is ok */
 770
 771         if (midQ->resp_buf && out_buf
 772             && (midQ->midState == MID_RESPONSE_RECEIVED)) {
 773                 out_buf->smb_buf_length = cpu_to_be32(receive_len);
 774                 memcpy((char *)out_buf + 4,
 775                        (char *)midQ->resp_buf + 4,
 776                        receive_len);
 777
 778                 dump_smb(out_buf, 92);
 779                 /* convert the length into a more usable form */
 780                 if ((receive_len > 24) &&
 781                     (ses->server->secMode & (SECMODE_SIGN_REQUIRED |
 782                                              SECMODE_SIGN_ENABLED))) {
 783                         rc = cifs_verify_signature(out_buf,
 784                                                 ses->server,
 785                                                 midQ->sequence_number+1);
 786                         if (rc) {
 787                                 cERROR(1, "Unexpected SMB signature");
 788                                 /* BB FIXME add code to kill session */
 789                         }
 790                 }
 791
 792                 *pbytes_returned = be32_to_cpu(out_buf->smb_buf_length);
 793
 794                 /* BB special case reconnect tid and uid here? */
 795                 rc = map_smb_to_linux_error(out_buf, 0 /* no log */ );
 796         } else {
 797                 rc = -EIO;
 798                 cERROR(1, "Bad MID state?");
 799         }
 800
 801 out:
 802         delete_mid(midQ);
 803         atomic_dec(&ses->server->inFlight);
 804         wake_up(&ses->server->request_q);
 805
 806         return rc;
 807 }
 808
 809 /* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
 810    blocking lock to return. */
 811
 812 static int
 813 send_lock_cancel(const unsigned int xid, struct cifsTconInfo *tcon,
 814                         struct smb_hdr *in_buf,
 815                         struct smb_hdr *out_buf)
 816 {
 817         int bytes_returned;
 818         struct cifsSesInfo *ses = tcon->ses;
 819         LOCK_REQ *pSMB = (LOCK_REQ *)in_buf;
 820
 821         /* We just modify the current in_buf to change
 822            the type of lock from LOCKING_ANDX_SHARED_LOCK
 823            or LOCKING_ANDX_EXCLUSIVE_LOCK to
 824            LOCKING_ANDX_CANCEL_LOCK. */
 825
 826         pSMB->LockType = LOCKING_ANDX_CANCEL_LOCK|LOCKING_ANDX_LARGE_FILES;
 827         pSMB->Timeout = 0;
 828         pSMB->hdr.Mid = GetNextMid(ses->server);
 829
 830         return SendReceive(xid, ses, in_buf, out_buf,
 831                         &bytes_returned, 0);
 832 }
 833
 834 int
 835 SendReceiveBlockingLock(const unsigned int xid, struct cifsTconInfo *tcon,
 836             struct smb_hdr *in_buf, struct smb_hdr *out_buf,
 837             int *pbytes_returned)
 838 {
 839         int rc = 0;
 840         int rstart = 0;
 841         unsigned int receive_len;
 842         struct mid_q_entry *midQ;
 843         struct cifsSesInfo *ses;
 844
 845         if (tcon == NULL || tcon->ses == NULL) {
 846                 cERROR(1, "Null smb session");
 847                 return -EIO;
 848         }
 849         ses = tcon->ses;
 850
 851         if (ses->server == NULL) {
 852                 cERROR(1, "Null tcp session");
 853                 return -EIO;
 854         }
 855
 856         if (ses->server->tcpStatus == CifsExiting)
 857                 return -ENOENT;
 858
 859         /* Ensure that we do not send more than 50 overlapping requests
 860            to the same server. We may make this configurable later or
 861            use ses->maxReq */
 862
 863         if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
 864                         MAX_CIFS_HDR_SIZE - 4) {
 865                 cERROR(1, "Illegal length, greater than maximum frame, %d",
 866                            be32_to_cpu(in_buf->smb_buf_length));
 867                 return -EIO;
 868         }
 869
 870         rc = wait_for_free_request(ses->server, CIFS_BLOCKING_OP);
 871         if (rc)
 872                 return rc;
 873
 874         /* make sure that we sign in the same order that we send on this socket
 875            and avoid races inside tcp sendmsg code that could cause corruption
 876            of smb data */
 877
 878         mutex_lock(&ses->server->srv_mutex);
 879
 880         rc = allocate_mid(ses, in_buf, &midQ);
 881         if (rc) {
 882                 mutex_unlock(&ses->server->srv_mutex);
 883                 return rc;
 884         }
 885
 886         rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
 887         if (rc) {
 888                 delete_mid(midQ);
 889                 mutex_unlock(&ses->server->srv_mutex);
 890                 return rc;
 891         }
 892
 893         midQ->midState = MID_REQUEST_SUBMITTED;
 894 #ifdef CONFIG_CIFS_STATS2
 895         atomic_inc(&ses->server->inSend);
 896 #endif
 897         rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
 898 #ifdef CONFIG_CIFS_STATS2
 899         atomic_dec(&ses->server->inSend);
 900         midQ->when_sent = jiffies;
 901 #endif
 902         mutex_unlock(&ses->server->srv_mutex);
 903
 904         if (rc < 0) {
 905                 delete_mid(midQ);
 906                 return rc;
 907         }
 908
 909         /* Wait for a reply - allow signals to interrupt. */
 910         rc = wait_event_interruptible(ses->server->response_q,
 911                 (!(midQ->midState == MID_REQUEST_SUBMITTED)) ||
 912                 ((ses->server->tcpStatus != CifsGood) &&
 913                  (ses->server->tcpStatus != CifsNew)));
 914
 915         /* Were we interrupted by a signal ? */
 916         if ((rc == -ERESTARTSYS) &&
 917                 (midQ->midState == MID_REQUEST_SUBMITTED) &&
 918                 ((ses->server->tcpStatus == CifsGood) ||
 919                  (ses->server->tcpStatus == CifsNew))) {
 920
 921                 if (in_buf->Command == SMB_COM_TRANSACTION2) {
 922                         /* POSIX lock. We send a NT_CANCEL SMB to cause the
 923                            blocking lock to return. */
 924                         rc = send_nt_cancel(ses->server, in_buf, midQ);
 925                         if (rc) {
 926                                 delete_mid(midQ);
 927                                 return rc;
 928                         }
 929                 } else {
 930                         /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
 931                            to cause the blocking lock to return. */
 932
 933                         rc = send_lock_cancel(xid, tcon, in_buf, out_buf);
 934
 935                         /* If we get -ENOLCK back the lock may have
 936                            already been removed. Don't exit in this case. */
 937                         if (rc && rc != -ENOLCK) {
 938                                 delete_mid(midQ);
 939                                 return rc;
 940                         }
 941                 }
 942
 943                 rc = wait_for_response(ses->server, midQ);
 944                 if (rc) {
 945                         send_nt_cancel(ses->server, in_buf, midQ);
 946                         spin_lock(&GlobalMid_Lock);
 947                         if (midQ->midState == MID_REQUEST_SUBMITTED) {
 948                                 /* no longer considered to be "in-flight" */
 949                                 midQ->callback = DeleteMidQEntry;
 950                                 spin_unlock(&GlobalMid_Lock);
 951                                 return rc;
 952                         }
 953                         spin_unlock(&GlobalMid_Lock);
 954                 }
 955
 956                 /* We got the response - restart system call. */
 957                 rstart = 1;
 958         }
 959
 960         rc = sync_mid_result(midQ, ses->server);
 961         if (rc != 0)
 962                 return rc;
 963
 964         receive_len = be32_to_cpu(midQ->resp_buf->smb_buf_length);
 965         if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
 966                 cERROR(1, "Frame too large received.  Length: %d  Xid: %d",
 967                         receive_len, xid);
 968                 rc = -EIO;
 969                 goto out;
 970         }
 971
 972         /* rcvd frame is ok */
 973
 974         if ((out_buf == NULL) || (midQ->midState != MID_RESPONSE_RECEIVED)) {
 975                 rc = -EIO;
 976                 cERROR(1, "Bad MID state?");
 977                 goto out;
 978         }
 979
 980         out_buf->smb_buf_length = cpu_to_be32(receive_len);
 981         memcpy((char *)out_buf + 4,
 982                (char *)midQ->resp_buf + 4,
 983                receive_len);
 984
 985         dump_smb(out_buf, 92);
 986         /* convert the length into a more usable form */
 987         if ((receive_len > 24) &&
 988             (ses->server->secMode & (SECMODE_SIGN_REQUIRED |
 989                                      SECMODE_SIGN_ENABLED))) {
 990                 rc = cifs_verify_signature(out_buf,
 991                                            ses->server,
 992                                            midQ->sequence_number+1);
 993                 if (rc) {
 994                         cERROR(1, "Unexpected SMB signature");
 995                         /* BB FIXME add code to kill session */
 996                 }
 997         }
 998
 999         *pbytes_returned = be32_to_cpu(out_buf->smb_buf_length);
1000
1001         /* BB special case reconnect tid and uid here? */
1002         rc = map_smb_to_linux_error(out_buf, 0 /* no log */ );
1003
1004 out:
1005         delete_mid(midQ);
1006         if (rstart && rc == -EACCES)
1007                 return -ERESTARTSYS;
1008         return rc;
1009 }