fs/cifs/connect.c

   1 /*
   2  *   fs/cifs/connect.c
   3  *
   4  *   Copyright (C) International Business Machines  Corp., 2002,2009
   5  *   Author(s): Steve French (sfrench@us.ibm.com)
   6  *
   7  *   This library is free software; you can redistribute it and/or modify
   8  *   it under the terms of the GNU Lesser General Public License as published
   9  *   by the Free Software Foundation; either version 2.1 of the License, or
  10  *   (at your option) any later version.
  11  *
  12  *   This library is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  15  *   the GNU Lesser General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU Lesser General Public License
  18  *   along with this library; if not, write to the Free Software
  19  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20  */
  21 #include <linux/fs.h>
  22 #include <linux/net.h>
  23 #include <linux/string.h>
  24 #include <linux/list.h>
  25 #include <linux/wait.h>
  26 #include <linux/slab.h>
  27 #include <linux/pagemap.h>
  28 #include <linux/ctype.h>
  29 #include <linux/utsname.h>
  30 #include <linux/mempool.h>
  31 #include <linux/delay.h>
  32 #include <linux/completion.h>
  33 #include <linux/kthread.h>
  34 #include <linux/pagevec.h>
  35 #include <linux/freezer.h>
  36 #include <linux/namei.h>
  37 #include <asm/uaccess.h>
  38 #include <asm/processor.h>
  39 #include <linux/inet.h>
  40 #include <net/ipv6.h>
  41 #include "cifspdu.h"
  42 #include "cifsglob.h"
  43 #include "cifsproto.h"
  44 #include "cifs_unicode.h"
  45 #include "cifs_debug.h"
  46 #include "cifs_fs_sb.h"
  47 #include "ntlmssp.h"
  48 #include "nterr.h"
  49 #include "rfc1002pdu.h"
  50 #include "fscache.h"
  51
  52 #define CIFS_PORT 445
  53 #define RFC1001_PORT 139
  54
  55 /* SMB echo "timeout" -- FIXME: tunable? */
  56 #define SMB_ECHO_INTERVAL (60 * HZ)
  57
  58 extern mempool_t *cifs_req_poolp;
  59
  60 struct smb_vol {
  61         char *username;
  62         char *password;
  63         char *domainname;
  64         char *UNC;
  65         char *UNCip;
  66         char *iocharset;  /* local code page for mapping to and from Unicode */
  67         char source_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* clnt nb name */
  68         char target_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* srvr nb name */
  69         uid_t cred_uid;
  70         uid_t linux_uid;
  71         gid_t linux_gid;
  72         mode_t file_mode;
  73         mode_t dir_mode;
  74         unsigned secFlg;
  75         bool retry:1;
  76         bool intr:1;
  77         bool setuids:1;
  78         bool override_uid:1;
  79         bool override_gid:1;
  80         bool dynperm:1;
  81         bool noperm:1;
  82         bool no_psx_acl:1; /* set if posix acl support should be disabled */
  83         bool cifs_acl:1;
  84         bool no_xattr:1;   /* set if xattr (EA) support should be disabled*/
  85         bool server_ino:1; /* use inode numbers from server ie UniqueId */
  86         bool direct_io:1;
  87         bool strict_io:1; /* strict cache behavior */
  88         bool remap:1;      /* set to remap seven reserved chars in filenames */
  89         bool posix_paths:1; /* unset to not ask for posix pathnames. */
  90         bool no_linux_ext:1;
  91         bool sfu_emul:1;
  92         bool nullauth:1;   /* attempt to authenticate with null user */
  93         bool nocase:1;     /* request case insensitive filenames */
  94         bool nobrl:1;      /* disable sending byte range locks to srv */
  95         bool mand_lock:1;  /* send mandatory not posix byte range lock reqs */
  96         bool seal:1;       /* request transport encryption on share */
  97         bool nodfs:1;      /* Do not request DFS, even if available */
  98         bool local_lease:1; /* check leases only on local system, not remote */
  99         bool noblocksnd:1;
 100         bool noautotune:1;
 101         bool nostrictsync:1; /* do not force expensive SMBflush on every sync */
 102         bool fsc:1;     /* enable fscache */
 103         bool mfsymlinks:1; /* use Minshall+French Symlinks */
 104         bool multiuser:1;
 105         unsigned int rsize;
 106         unsigned int wsize;
 107         bool sockopt_tcp_nodelay:1;
 108         unsigned short int port;
 109         unsigned long actimeo; /* attribute cache timeout (jiffies) */
 110         char *prepath;
 111         struct sockaddr_storage srcaddr; /* allow binding to a local IP */
 112         struct nls_table *local_nls;
 113 };
 114
 115 /* FIXME: should these be tunable? */
 116 #define TLINK_ERROR_EXPIRE      (1 * HZ)
 117 #define TLINK_IDLE_EXPIRE       (600 * HZ)
 118
 119 static int ip_connect(struct TCP_Server_Info *server);
 120 static int generic_ip_connect(struct TCP_Server_Info *server);
 121 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
 122 static void cifs_prune_tlinks(struct work_struct *work);
 123
 124 /*
 125  * cifs tcp session reconnection
 126  *
 127  * mark tcp session as reconnecting so temporarily locked
 128  * mark all smb sessions as reconnecting for tcp session
 129  * reconnect tcp session
 130  * wake up waiters on reconnection? - (not needed currently)
 131  */
 132 static int
 133 cifs_reconnect(struct TCP_Server_Info *server)
 134 {
 135         int rc = 0;
 136         struct list_head *tmp, *tmp2;
 137         struct cifsSesInfo *ses;
 138         struct cifsTconInfo *tcon;
 139         struct mid_q_entry *mid_entry;
 140
 141         spin_lock(&GlobalMid_Lock);
 142         if (server->tcpStatus == CifsExiting) {
 143                 /* the demux thread will exit normally
 144                 next time through the loop */
 145                 spin_unlock(&GlobalMid_Lock);
 146                 return rc;
 147         } else
 148                 server->tcpStatus = CifsNeedReconnect;
 149         spin_unlock(&GlobalMid_Lock);
 150         server->maxBuf = 0;
 151
 152         cFYI(1, "Reconnecting tcp session");
 153
 154         /* before reconnecting the tcp session, mark the smb session (uid)
 155                 and the tid bad so they are not used until reconnected */
 156         cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
 157         spin_lock(&cifs_tcp_ses_lock);
 158         list_for_each(tmp, &server->smb_ses_list) {
 159                 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
 160                 ses->need_reconnect = true;
 161                 ses->ipc_tid = 0;
 162                 list_for_each(tmp2, &ses->tcon_list) {
 163                         tcon = list_entry(tmp2, struct cifsTconInfo, tcon_list);
 164                         tcon->need_reconnect = true;
 165                 }
 166         }
 167         spin_unlock(&cifs_tcp_ses_lock);
 168
 169         /* do not want to be sending data on a socket we are freeing */
 170         cFYI(1, "%s: tearing down socket", __func__);
 171         mutex_lock(&server->srv_mutex);
 172         if (server->ssocket) {
 173                 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
 174                         server->ssocket->flags);
 175                 kernel_sock_shutdown(server->ssocket, SHUT_WR);
 176                 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
 177                         server->ssocket->state,
 178                         server->ssocket->flags);
 179                 sock_release(server->ssocket);
 180                 server->ssocket = NULL;
 181         }
 182         server->sequence_number = 0;
 183         server->session_estab = false;
 184         kfree(server->session_key.response);
 185         server->session_key.response = NULL;
 186         server->session_key.len = 0;
 187         server->lstrp = jiffies;
 188         mutex_unlock(&server->srv_mutex);
 189
 190         /* mark submitted MIDs for retry and issue callback */
 191         cFYI(1, "%s: issuing mid callbacks", __func__);
 192         spin_lock(&GlobalMid_Lock);
 193         list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 194                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 195                 if (mid_entry->midState == MID_REQUEST_SUBMITTED)
 196                         mid_entry->midState = MID_RETRY_NEEDED;
 197                 list_del_init(&mid_entry->qhead);
 198                 mid_entry->callback(mid_entry);
 199         }
 200         spin_unlock(&GlobalMid_Lock);
 201
 202         while (server->tcpStatus == CifsNeedReconnect) {
 203                 try_to_freeze();
 204
 205                 /* we should try only the port we connected to before */
 206                 rc = generic_ip_connect(server);
 207                 if (rc) {
 208                         cFYI(1, "reconnect error %d", rc);
 209                         msleep(3000);
 210                 } else {
 211                         atomic_inc(&tcpSesReconnectCount);
 212                         spin_lock(&GlobalMid_Lock);
 213                         if (server->tcpStatus != CifsExiting)
 214                                 server->tcpStatus = CifsNeedNegotiate;
 215                         spin_unlock(&GlobalMid_Lock);
 216                 }
 217         }
 218
 219         return rc;
 220 }
 221
 222 /*
 223         return codes:
 224                 0       not a transact2, or all data present
 225                 >0      transact2 with that much data missing
 226                 -EINVAL = invalid transact2
 227
 228  */
 229 static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
 230 {
 231         struct smb_t2_rsp *pSMBt;
 232         int remaining;
 233         __u16 total_data_size, data_in_this_rsp;
 234
 235         if (pSMB->Command != SMB_COM_TRANSACTION2)
 236                 return 0;
 237
 238         /* check for plausible wct, bcc and t2 data and parm sizes */
 239         /* check for parm and data offset going beyond end of smb */
 240         if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
 241                 cFYI(1, "invalid transact2 word count");
 242                 return -EINVAL;
 243         }
 244
 245         pSMBt = (struct smb_t2_rsp *)pSMB;
 246
 247         total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
 248         data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
 249
 250         if (total_data_size == data_in_this_rsp)
 251                 return 0;
 252         else if (total_data_size < data_in_this_rsp) {
 253                 cFYI(1, "total data %d smaller than data in frame %d",
 254                         total_data_size, data_in_this_rsp);
 255                 return -EINVAL;
 256         }
 257
 258         remaining = total_data_size - data_in_this_rsp;
 259
 260         cFYI(1, "missing %d bytes from transact2, check next response",
 261                 remaining);
 262         if (total_data_size > maxBufSize) {
 263                 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
 264                         total_data_size, maxBufSize);
 265                 return -EINVAL;
 266         }
 267         return remaining;
 268 }
 269
 270 static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
 271 {
 272         struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
 273         struct smb_t2_rsp *pSMBt  = (struct smb_t2_rsp *)pTargetSMB;
 274         char *data_area_of_target;
 275         char *data_area_of_buf2;
 276         int remaining;
 277         __u16 byte_count, total_data_size, total_in_buf, total_in_buf2;
 278
 279         total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
 280
 281         if (total_data_size !=
 282             get_unaligned_le16(&pSMB2->t2_rsp.TotalDataCount))
 283                 cFYI(1, "total data size of primary and secondary t2 differ");
 284
 285         total_in_buf = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
 286
 287         remaining = total_data_size - total_in_buf;
 288
 289         if (remaining < 0)
 290                 return -EINVAL;
 291
 292         if (remaining == 0) /* nothing to do, ignore */
 293                 return 0;
 294
 295         total_in_buf2 = get_unaligned_le16(&pSMB2->t2_rsp.DataCount);
 296         if (remaining < total_in_buf2) {
 297                 cFYI(1, "transact2 2nd response contains too much data");
 298         }
 299
 300         /* find end of first SMB data area */
 301         data_area_of_target = (char *)&pSMBt->hdr.Protocol +
 302                                 get_unaligned_le16(&pSMBt->t2_rsp.DataOffset);
 303         /* validate target area */
 304
 305         data_area_of_buf2 = (char *)&pSMB2->hdr.Protocol +
 306                                 get_unaligned_le16(&pSMB2->t2_rsp.DataOffset);
 307
 308         data_area_of_target += total_in_buf;
 309
 310         /* copy second buffer into end of first buffer */
 311         memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
 312         total_in_buf += total_in_buf2;
 313         put_unaligned_le16(total_in_buf, &pSMBt->t2_rsp.DataCount);
 314         byte_count = get_bcc_le(pTargetSMB);
 315         byte_count += total_in_buf2;
 316         put_bcc_le(byte_count, pTargetSMB);
 317
 318         byte_count = pTargetSMB->smb_buf_length;
 319         byte_count += total_in_buf2;
 320
 321         /* BB also add check that we are not beyond maximum buffer size */
 322
 323         pTargetSMB->smb_buf_length = byte_count;
 324
 325         if (remaining == total_in_buf2) {
 326                 cFYI(1, "found the last secondary response");
 327                 return 0; /* we are done */
 328         } else /* more responses to go */
 329                 return 1;
 330 }
 331
 332 static void
 333 cifs_echo_request(struct work_struct *work)
 334 {
 335         int rc;
 336         struct TCP_Server_Info *server = container_of(work,
 337                                         struct TCP_Server_Info, echo.work);
 338
 339         /*
 340          * We cannot send an echo until the NEGOTIATE_PROTOCOL request is
 341          * done, which is indicated by maxBuf != 0. Also, no need to ping if
 342          * we got a response recently
 343          */
 344         if (server->maxBuf == 0 ||
 345             time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
 346                 goto requeue_echo;
 347
 348         rc = CIFSSMBEcho(server);
 349         if (rc)
 350                 cFYI(1, "Unable to send echo request to server: %s",
 351                         server->hostname);
 352
 353 requeue_echo:
 354         queue_delayed_work(system_nrt_wq, &server->echo, SMB_ECHO_INTERVAL);
 355 }
 356
 357 static int
 358 cifs_demultiplex_thread(struct TCP_Server_Info *server)
 359 {
 360         int length;
 361         unsigned int pdu_length, total_read;
 362         struct smb_hdr *smb_buffer = NULL;
 363         struct smb_hdr *bigbuf = NULL;
 364         struct smb_hdr *smallbuf = NULL;
 365         struct msghdr smb_msg;
 366         struct kvec iov;
 367         struct socket *csocket = server->ssocket;
 368         struct list_head *tmp, *tmp2;
 369         struct task_struct *task_to_wake = NULL;
 370         struct mid_q_entry *mid_entry;
 371         char temp;
 372         bool isLargeBuf = false;
 373         bool isMultiRsp;
 374         int reconnect;
 375
 376         current->flags |= PF_MEMALLOC;
 377         cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
 378
 379         length = atomic_inc_return(&tcpSesAllocCount);
 380         if (length > 1)
 381                 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
 382                                 GFP_KERNEL);
 383
 384         set_freezable();
 385         while (server->tcpStatus != CifsExiting) {
 386                 if (try_to_freeze())
 387                         continue;
 388                 if (bigbuf == NULL) {
 389                         bigbuf = cifs_buf_get();
 390                         if (!bigbuf) {
 391                                 cERROR(1, "No memory for large SMB response");
 392                                 msleep(3000);
 393                                 /* retry will check if exiting */
 394                                 continue;
 395                         }
 396                 } else if (isLargeBuf) {
 397                         /* we are reusing a dirty large buf, clear its start */
 398                         memset(bigbuf, 0, sizeof(struct smb_hdr));
 399                 }
 400
 401                 if (smallbuf == NULL) {
 402                         smallbuf = cifs_small_buf_get();
 403                         if (!smallbuf) {
 404                                 cERROR(1, "No memory for SMB response");
 405                                 msleep(1000);
 406                                 /* retry will check if exiting */
 407                                 continue;
 408                         }
 409                         /* beginning of smb buffer is cleared in our buf_get */
 410                 } else /* if existing small buf clear beginning */
 411                         memset(smallbuf, 0, sizeof(struct smb_hdr));
 412
 413                 isLargeBuf = false;
 414                 isMultiRsp = false;
 415                 smb_buffer = smallbuf;
 416                 iov.iov_base = smb_buffer;
 417                 iov.iov_len = 4;
 418                 smb_msg.msg_control = NULL;
 419                 smb_msg.msg_controllen = 0;
 420                 pdu_length = 4; /* enough to get RFC1001 header */
 421
 422 incomplete_rcv:
 423                 if (echo_retries > 0 && server->tcpStatus == CifsGood &&
 424                     time_after(jiffies, server->lstrp +
 425                                         (echo_retries * SMB_ECHO_INTERVAL))) {
 426                         cERROR(1, "Server %s has not responded in %d seconds. "
 427                                   "Reconnecting...", server->hostname,
 428                                   (echo_retries * SMB_ECHO_INTERVAL / HZ));
 429                         cifs_reconnect(server);
 430                         csocket = server->ssocket;
 431                         wake_up(&server->response_q);
 432                         continue;
 433                 }
 434
 435                 length =
 436                     kernel_recvmsg(csocket, &smb_msg,
 437                                 &iov, 1, pdu_length, 0 /* BB other flags? */);
 438
 439                 if (server->tcpStatus == CifsExiting) {
 440                         break;
 441                 } else if (server->tcpStatus == CifsNeedReconnect) {
 442                         cFYI(1, "Reconnect after server stopped responding");
 443                         cifs_reconnect(server);
 444                         cFYI(1, "call to reconnect done");
 445                         csocket = server->ssocket;
 446                         continue;
 447                 } else if (length == -ERESTARTSYS ||
 448                            length == -EAGAIN ||
 449                            length == -EINTR) {
 450                         msleep(1); /* minimum sleep to prevent looping
 451                                 allowing socket to clear and app threads to set
 452                                 tcpStatus CifsNeedReconnect if server hung */
 453                         if (pdu_length < 4) {
 454                                 iov.iov_base = (4 - pdu_length) +
 455                                                         (char *)smb_buffer;
 456                                 iov.iov_len = pdu_length;
 457                                 smb_msg.msg_control = NULL;
 458                                 smb_msg.msg_controllen = 0;
 459                                 goto incomplete_rcv;
 460                         } else
 461                                 continue;
 462                 } else if (length <= 0) {
 463                         cFYI(1, "Reconnect after unexpected peek error %d",
 464                                 length);
 465                         cifs_reconnect(server);
 466                         csocket = server->ssocket;
 467                         wake_up(&server->response_q);
 468                         continue;
 469                 } else if (length < pdu_length) {
 470                         cFYI(1, "requested %d bytes but only got %d bytes",
 471                                   pdu_length, length);
 472                         pdu_length -= length;
 473                         msleep(1);
 474                         goto incomplete_rcv;
 475                 }
 476
 477                 /* The right amount was read from socket - 4 bytes */
 478                 /* so we can now interpret the length field */
 479
 480                 /* the first byte big endian of the length field,
 481                 is actually not part of the length but the type
 482                 with the most common, zero, as regular data */
 483                 temp = *((char *) smb_buffer);
 484
 485                 /* Note that FC 1001 length is big endian on the wire,
 486                 but we convert it here so it is always manipulated
 487                 as host byte order */
 488                 pdu_length = be32_to_cpu((__force __be32)smb_buffer->smb_buf_length);
 489                 smb_buffer->smb_buf_length = pdu_length;
 490
 491                 cFYI(1, "rfc1002 length 0x%x", pdu_length+4);
 492
 493                 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
 494                         continue;
 495                 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
 496                         cFYI(1, "Good RFC 1002 session rsp");
 497                         continue;
 498                 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
 499                         /* we get this from Windows 98 instead of
 500                            an error on SMB negprot response */
 501                         cFYI(1, "Negative RFC1002 Session Response Error 0x%x)",
 502                                 pdu_length);
 503                         /* give server a second to clean up  */
 504                         msleep(1000);
 505                         /* always try 445 first on reconnect since we get NACK
 506                          * on some if we ever connected to port 139 (the NACK
 507                          * is since we do not begin with RFC1001 session
 508                          * initialize frame)
 509                          */
 510                         cifs_set_port((struct sockaddr *)
 511                                         &server->dstaddr, CIFS_PORT);
 512                         cifs_reconnect(server);
 513                         csocket = server->ssocket;
 514                         wake_up(&server->response_q);
 515                         continue;
 516                 } else if (temp != (char) 0) {
 517                         cERROR(1, "Unknown RFC 1002 frame");
 518                         cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
 519                                       length);
 520                         cifs_reconnect(server);
 521                         csocket = server->ssocket;
 522                         continue;
 523                 }
 524
 525                 /* else we have an SMB response */
 526                 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
 527                             (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
 528                         cERROR(1, "Invalid size SMB length %d pdu_length %d",
 529                                         length, pdu_length+4);
 530                         cifs_reconnect(server);
 531                         csocket = server->ssocket;
 532                         wake_up(&server->response_q);
 533                         continue;
 534                 }
 535
 536                 /* else length ok */
 537                 reconnect = 0;
 538
 539                 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
 540                         isLargeBuf = true;
 541                         memcpy(bigbuf, smallbuf, 4);
 542                         smb_buffer = bigbuf;
 543                 }
 544                 length = 0;
 545                 iov.iov_base = 4 + (char *)smb_buffer;
 546                 iov.iov_len = pdu_length;
 547                 for (total_read = 0; total_read < pdu_length;
 548                      total_read += length) {
 549                         length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
 550                                                 pdu_length - total_read, 0);
 551                         if (server->tcpStatus == CifsExiting) {
 552                                 /* then will exit */
 553                                 reconnect = 2;
 554                                 break;
 555                         } else if (server->tcpStatus == CifsNeedReconnect) {
 556                                 cifs_reconnect(server);
 557                                 csocket = server->ssocket;
 558                                 /* Reconnect wakes up rspns q */
 559                                 /* Now we will reread sock */
 560                                 reconnect = 1;
 561                                 break;
 562                         } else if (length == -ERESTARTSYS ||
 563                                    length == -EAGAIN ||
 564                                    length == -EINTR) {
 565                                 msleep(1); /* minimum sleep to prevent looping,
 566                                               allowing socket to clear and app
 567                                               threads to set tcpStatus
 568                                               CifsNeedReconnect if server hung*/
 569                                 length = 0;
 570                                 continue;
 571                         } else if (length <= 0) {
 572                                 cERROR(1, "Received no data, expecting %d",
 573                                               pdu_length - total_read);
 574                                 cifs_reconnect(server);
 575                                 csocket = server->ssocket;
 576                                 reconnect = 1;
 577                                 break;
 578                         }
 579                 }
 580                 if (reconnect == 2)
 581                         break;
 582                 else if (reconnect == 1)
 583                         continue;
 584
 585                 total_read += 4; /* account for rfc1002 hdr */
 586
 587                 dump_smb(smb_buffer, total_read);
 588
 589                 /*
 590                  * We know that we received enough to get to the MID as we
 591                  * checked the pdu_length earlier. Now check to see
 592                  * if the rest of the header is OK. We borrow the length
 593                  * var for the rest of the loop to avoid a new stack var.
 594                  *
 595                  * 48 bytes is enough to display the header and a little bit
 596                  * into the payload for debugging purposes.
 597                  */
 598                 length = checkSMB(smb_buffer, smb_buffer->Mid, total_read);
 599                 if (length != 0)
 600                         cifs_dump_mem("Bad SMB: ", smb_buffer,
 601                                         min_t(unsigned int, total_read, 48));
 602
 603                 mid_entry = NULL;
 604                 server->lstrp = jiffies;
 605
 606                 spin_lock(&GlobalMid_Lock);
 607                 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 608                         mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 609
 610                         if ((mid_entry->mid == smb_buffer->Mid) &&
 611                             (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
 612                             (mid_entry->command == smb_buffer->Command)) {
 613                                 if (length == 0 &&
 614                                    check2ndT2(smb_buffer, server->maxBuf) > 0) {
 615                                         /* We have a multipart transact2 resp */
 616                                         isMultiRsp = true;
 617                                         if (mid_entry->resp_buf) {
 618                                                 /* merge response - fix up 1st*/
 619                                                 if (coalesce_t2(smb_buffer,
 620                                                         mid_entry->resp_buf)) {
 621                                                         mid_entry->multiRsp =
 622                                                                  true;
 623                                                         break;
 624                                                 } else {
 625                                                         /* all parts received */
 626                                                         mid_entry->multiEnd =
 627                                                                  true;
 628                                                         goto multi_t2_fnd;
 629                                                 }
 630                                         } else {
 631                                                 if (!isLargeBuf) {
 632                                                         cERROR(1, "1st trans2 resp needs bigbuf");
 633                                         /* BB maybe we can fix this up,  switch
 634                                            to already allocated large buffer? */
 635                                                 } else {
 636                                                         /* Have first buffer */
 637                                                         mid_entry->resp_buf =
 638                                                                  smb_buffer;
 639                                                         mid_entry->largeBuf =
 640                                                                  true;
 641                                                         bigbuf = NULL;
 642                                                 }
 643                                         }
 644                                         break;
 645                                 }
 646                                 mid_entry->resp_buf = smb_buffer;
 647                                 mid_entry->largeBuf = isLargeBuf;
 648 multi_t2_fnd:
 649                                 if (length == 0)
 650                                         mid_entry->midState =
 651                                                         MID_RESPONSE_RECEIVED;
 652                                 else
 653                                         mid_entry->midState =
 654                                                         MID_RESPONSE_MALFORMED;
 655 #ifdef CONFIG_CIFS_STATS2
 656                                 mid_entry->when_received = jiffies;
 657 #endif
 658                                 list_del_init(&mid_entry->qhead);
 659                                 mid_entry->callback(mid_entry);
 660                                 break;
 661                         }
 662                         mid_entry = NULL;
 663                 }
 664                 spin_unlock(&GlobalMid_Lock);
 665
 666                 if (mid_entry != NULL) {
 667                         /* Was previous buf put in mpx struct for multi-rsp? */
 668                         if (!isMultiRsp) {
 669                                 /* smb buffer will be freed by user thread */
 670                                 if (isLargeBuf)
 671                                         bigbuf = NULL;
 672                                 else
 673                                         smallbuf = NULL;
 674                         }
 675                 } else if (length != 0) {
 676                         /* response sanity checks failed */
 677                         continue;
 678                 } else if (!is_valid_oplock_break(smb_buffer, server) &&
 679                            !isMultiRsp) {
 680                         cERROR(1, "No task to wake, unknown frame received! "
 681                                    "NumMids %d", atomic_read(&midCount));
 682                         cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
 683                                       sizeof(struct smb_hdr));
 684 #ifdef CONFIG_CIFS_DEBUG2
 685                         cifs_dump_detail(smb_buffer);
 686                         cifs_dump_mids(server);
 687 #endif /* CIFS_DEBUG2 */
 688
 689                 }
 690         } /* end while !EXITING */
 691
 692         /* take it off the list, if it's not already */
 693         spin_lock(&cifs_tcp_ses_lock);
 694         list_del_init(&server->tcp_ses_list);
 695         spin_unlock(&cifs_tcp_ses_lock);
 696
 697         spin_lock(&GlobalMid_Lock);
 698         server->tcpStatus = CifsExiting;
 699         spin_unlock(&GlobalMid_Lock);
 700         wake_up_all(&server->response_q);
 701
 702         /* check if we have blocked requests that need to free */
 703         /* Note that cifs_max_pending is normally 50, but
 704         can be set at module install time to as little as two */
 705         spin_lock(&GlobalMid_Lock);
 706         if (atomic_read(&server->inFlight) >= cifs_max_pending)
 707                 atomic_set(&server->inFlight, cifs_max_pending - 1);
 708         /* We do not want to set the max_pending too low or we
 709         could end up with the counter going negative */
 710         spin_unlock(&GlobalMid_Lock);
 711         /* Although there should not be any requests blocked on
 712         this queue it can not hurt to be paranoid and try to wake up requests
 713         that may haven been blocked when more than 50 at time were on the wire
 714         to the same server - they now will see the session is in exit state
 715         and get out of SendReceive.  */
 716         wake_up_all(&server->request_q);
 717         /* give those requests time to exit */
 718         msleep(125);
 719
 720         if (server->ssocket) {
 721                 sock_release(csocket);
 722                 server->ssocket = NULL;
 723         }
 724         /* buffer usuallly freed in free_mid - need to free it here on exit */
 725         cifs_buf_release(bigbuf);
 726         if (smallbuf) /* no sense logging a debug message if NULL */
 727                 cifs_small_buf_release(smallbuf);
 728
 729         if (!list_empty(&server->pending_mid_q)) {
 730                 spin_lock(&GlobalMid_Lock);
 731                 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 732                         mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 733                         cFYI(1, "Clearing Mid 0x%x - issuing callback",
 734                                          mid_entry->mid);
 735                         list_del_init(&mid_entry->qhead);
 736                         mid_entry->callback(mid_entry);
 737                 }
 738                 spin_unlock(&GlobalMid_Lock);
 739                 /* 1/8th of sec is more than enough time for them to exit */
 740                 msleep(125);
 741         }
 742
 743         if (!list_empty(&server->pending_mid_q)) {
 744                 /* mpx threads have not exited yet give them
 745                 at least the smb send timeout time for long ops */
 746                 /* due to delays on oplock break requests, we need
 747                 to wait at least 45 seconds before giving up
 748                 on a request getting a response and going ahead
 749                 and killing cifsd */
 750                 cFYI(1, "Wait for exit from demultiplex thread");
 751                 msleep(46000);
 752                 /* if threads still have not exited they are probably never
 753                 coming home not much else we can do but free the memory */
 754         }
 755
 756         kfree(server->hostname);
 757         task_to_wake = xchg(&server->tsk, NULL);
 758         kfree(server);
 759
 760         length = atomic_dec_return(&tcpSesAllocCount);
 761         if (length  > 0)
 762                 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
 763                                 GFP_KERNEL);
 764
 765         /* if server->tsk was NULL then wait for a signal before exiting */
 766         if (!task_to_wake) {
 767                 set_current_state(TASK_INTERRUPTIBLE);
 768                 while (!signal_pending(current)) {
 769                         schedule();
 770                         set_current_state(TASK_INTERRUPTIBLE);
 771                 }
 772                 set_current_state(TASK_RUNNING);
 773         }
 774
 775         module_put_and_exit(0);
 776 }
 777
 778 /* extract the host portion of the UNC string */
 779 static char *
 780 extract_hostname(const char *unc)
 781 {
 782         const char *src;
 783         char *dst, *delim;
 784         unsigned int len;
 785
 786         /* skip double chars at beginning of string */
 787         /* BB: check validity of these bytes? */
 788         src = unc + 2;
 789
 790         /* delimiter between hostname and sharename is always '\\' now */
 791         delim = strchr(src, '\\');
 792         if (!delim)
 793                 return ERR_PTR(-EINVAL);
 794
 795         len = delim - src;
 796         dst = kmalloc((len + 1), GFP_KERNEL);
 797         if (dst == NULL)
 798                 return ERR_PTR(-ENOMEM);
 799
 800         memcpy(dst, src, len);
 801         dst[len] = '\0';
 802
 803         return dst;
 804 }
 805
 806 static int
 807 cifs_parse_mount_options(char *options, const char *devname,
 808                          struct smb_vol *vol)
 809 {
 810         char *value, *data, *end;
 811         unsigned int  temp_len, i, j;
 812         char separator[2];
 813         short int override_uid = -1;
 814         short int override_gid = -1;
 815         bool uid_specified = false;
 816         bool gid_specified = false;
 817         char *nodename = utsname()->nodename;
 818
 819         separator[0] = ',';
 820         separator[1] = 0;
 821
 822         /*
 823          * does not have to be perfect mapping since field is
 824          * informational, only used for servers that do not support
 825          * port 445 and it can be overridden at mount time
 826          */
 827         memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
 828         for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
 829                 vol->source_rfc1001_name[i] = toupper(nodename[i]);
 830
 831         vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
 832         /* null target name indicates to use *SMBSERVR default called name
 833            if we end up sending RFC1001 session initialize */
 834         vol->target_rfc1001_name[0] = 0;
 835         vol->cred_uid = current_uid();
 836         vol->linux_uid = current_uid();
 837         vol->linux_gid = current_gid();
 838
 839         /* default to only allowing write access to owner of the mount */
 840         vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
 841
 842         /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
 843         /* default is always to request posix paths. */
 844         vol->posix_paths = 1;
 845         /* default to using server inode numbers where available */
 846         vol->server_ino = 1;
 847
 848         vol->actimeo = CIFS_DEF_ACTIMEO;
 849
 850         if (!options)
 851                 return 1;
 852
 853         end = options + strlen(options);
 854         if (strncmp(options, "sep=", 4) == 0) {
 855                 if (options[4] != 0) {
 856                         separator[0] = options[4];
 857                         options += 5;
 858                 } else {
 859                         cFYI(1, "Null separator not allowed");
 860                 }
 861         }
 862
 863         while ((data = strsep(&options, separator)) != NULL) {
 864                 if (!*data)
 865                         continue;
 866                 if ((value = strchr(data, '=')) != NULL)
 867                         *value++ = '\0';
 868
 869                 /* Have to parse this before we parse for "user" */
 870                 if (strnicmp(data, "user_xattr", 10) == 0) {
 871                         vol->no_xattr = 0;
 872                 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
 873                         vol->no_xattr = 1;
 874                 } else if (strnicmp(data, "user", 4) == 0) {
 875                         if (!value) {
 876                                 printk(KERN_WARNING
 877                                        "CIFS: invalid or missing username\n");
 878                                 return 1;       /* needs_arg; */
 879                         } else if (!*value) {
 880                                 /* null user, ie anonymous, authentication */
 881                                 vol->nullauth = 1;
 882                         }
 883                         if (strnlen(value, MAX_USERNAME_SIZE) <
 884                                                 MAX_USERNAME_SIZE) {
 885                                 vol->username = value;
 886                         } else {
 887                                 printk(KERN_WARNING "CIFS: username too long\n");
 888                                 return 1;
 889                         }
 890                 } else if (strnicmp(data, "pass", 4) == 0) {
 891                         if (!value) {
 892                                 vol->password = NULL;
 893                                 continue;
 894                         } else if (value[0] == 0) {
 895                                 /* check if string begins with double comma
 896                                    since that would mean the password really
 897                                    does start with a comma, and would not
 898                                    indicate an empty string */
 899                                 if (value[1] != separator[0]) {
 900                                         vol->password = NULL;
 901                                         continue;
 902                                 }
 903                         }
 904                         temp_len = strlen(value);
 905                         /* removed password length check, NTLM passwords
 906                                 can be arbitrarily long */
 907
 908                         /* if comma in password, the string will be
 909                         prematurely null terminated.  Commas in password are
 910                         specified across the cifs mount interface by a double
 911                         comma ie ,, and a comma used as in other cases ie ','
 912                         as a parameter delimiter/separator is single and due
 913                         to the strsep above is temporarily zeroed. */
 914
 915                         /* NB: password legally can have multiple commas and
 916                         the only illegal character in a password is null */
 917
 918                         if ((value[temp_len] == 0) &&
 919                             (value + temp_len < end) &&
 920                             (value[temp_len+1] == separator[0])) {
 921                                 /* reinsert comma */
 922                                 value[temp_len] = separator[0];
 923                                 temp_len += 2;  /* move after second comma */
 924                                 while (value[temp_len] != 0)  {
 925                                         if (value[temp_len] == separator[0]) {
 926                                                 if (value[temp_len+1] ==
 927                                                      separator[0]) {
 928                                                 /* skip second comma */
 929                                                         temp_len++;
 930                                                 } else {
 931                                                 /* single comma indicating start
 932                                                          of next parm */
 933                                                         break;
 934                                                 }
 935                                         }
 936                                         temp_len++;
 937                                 }
 938                                 if (value[temp_len] == 0) {
 939                                         options = NULL;
 940                                 } else {
 941                                         value[temp_len] = 0;
 942                                         /* point option to start of next parm */
 943                                         options = value + temp_len + 1;
 944                                 }
 945                                 /* go from value to value + temp_len condensing
 946                                 double commas to singles. Note that this ends up
 947                                 allocating a few bytes too many, which is ok */
 948                                 vol->password = kzalloc(temp_len, GFP_KERNEL);
 949                                 if (vol->password == NULL) {
 950                                         printk(KERN_WARNING "CIFS: no memory "
 951                                                             "for password\n");
 952                                         return 1;
 953                                 }
 954                                 for (i = 0, j = 0; i < temp_len; i++, j++) {
 955                                         vol->password[j] = value[i];
 956                                         if (value[i] == separator[0]
 957                                                 && value[i+1] == separator[0]) {
 958                                                 /* skip second comma */
 959                                                 i++;
 960                                         }
 961                                 }
 962                                 vol->password[j] = 0;
 963                         } else {
 964                                 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
 965                                 if (vol->password == NULL) {
 966                                         printk(KERN_WARNING "CIFS: no memory "
 967                                                             "for password\n");
 968                                         return 1;
 969                                 }
 970                                 strcpy(vol->password, value);
 971                         }
 972                 } else if (!strnicmp(data, "ip", 2) ||
 973                            !strnicmp(data, "addr", 4)) {
 974                         if (!value || !*value) {
 975                                 vol->UNCip = NULL;
 976                         } else if (strnlen(value, INET6_ADDRSTRLEN) <
 977                                                         INET6_ADDRSTRLEN) {
 978                                 vol->UNCip = value;
 979                         } else {
 980                                 printk(KERN_WARNING "CIFS: ip address "
 981                                                     "too long\n");
 982                                 return 1;
 983                         }
 984                 } else if (strnicmp(data, "sec", 3) == 0) {
 985                         if (!value || !*value) {
 986                                 cERROR(1, "no security value specified");
 987                                 continue;
 988                         } else if (strnicmp(value, "krb5i", 5) == 0) {
 989                                 vol->secFlg |= CIFSSEC_MAY_KRB5 |
 990                                         CIFSSEC_MUST_SIGN;
 991                         } else if (strnicmp(value, "krb5p", 5) == 0) {
 992                                 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
 993                                         CIFSSEC_MAY_KRB5; */
 994                                 cERROR(1, "Krb5 cifs privacy not supported");
 995                                 return 1;
 996                         } else if (strnicmp(value, "krb5", 4) == 0) {
 997                                 vol->secFlg |= CIFSSEC_MAY_KRB5;
 998                         } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
 999                                 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
1000                                         CIFSSEC_MUST_SIGN;
1001                         } else if (strnicmp(value, "ntlmssp", 7) == 0) {
1002                                 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1003                         } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
1004                                 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
1005                                         CIFSSEC_MUST_SIGN;
1006                         } else if (strnicmp(value, "ntlmv2", 6) == 0) {
1007                                 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1008                         } else if (strnicmp(value, "ntlmi", 5) == 0) {
1009                                 vol->secFlg |= CIFSSEC_MAY_NTLM |
1010                                         CIFSSEC_MUST_SIGN;
1011                         } else if (strnicmp(value, "ntlm", 4) == 0) {
1012                                 /* ntlm is default so can be turned off too */
1013                                 vol->secFlg |= CIFSSEC_MAY_NTLM;
1014                         } else if (strnicmp(value, "nontlm", 6) == 0) {
1015                                 /* BB is there a better way to do this? */
1016                                 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1017 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1018                         } else if (strnicmp(value, "lanman", 6) == 0) {
1019                                 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1020 #endif
1021                         } else if (strnicmp(value, "none", 4) == 0) {
1022                                 vol->nullauth = 1;
1023                         } else {
1024                                 cERROR(1, "bad security option: %s", value);
1025                                 return 1;
1026                         }
1027                 } else if ((strnicmp(data, "unc", 3) == 0)
1028                            || (strnicmp(data, "target", 6) == 0)
1029                            || (strnicmp(data, "path", 4) == 0)) {
1030                         if (!value || !*value) {
1031                                 printk(KERN_WARNING "CIFS: invalid path to "
1032                                                     "network resource\n");
1033                                 return 1;       /* needs_arg; */
1034                         }
1035                         if ((temp_len = strnlen(value, 300)) < 300) {
1036                                 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1037                                 if (vol->UNC == NULL)
1038                                         return 1;
1039                                 strcpy(vol->UNC, value);
1040                                 if (strncmp(vol->UNC, "//", 2) == 0) {
1041                                         vol->UNC[0] = '\\';
1042                                         vol->UNC[1] = '\\';
1043                                 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1044                                         printk(KERN_WARNING
1045                                                "CIFS: UNC Path does not begin "
1046                                                "with // or \\\\ \n");
1047                                         return 1;
1048                                 }
1049                         } else {
1050                                 printk(KERN_WARNING "CIFS: UNC name too long\n");
1051                                 return 1;
1052                         }
1053                 } else if ((strnicmp(data, "domain", 3) == 0)
1054                            || (strnicmp(data, "workgroup", 5) == 0)) {
1055                         if (!value || !*value) {
1056                                 printk(KERN_WARNING "CIFS: invalid domain name\n");
1057                                 return 1;       /* needs_arg; */
1058                         }
1059                         /* BB are there cases in which a comma can be valid in
1060                         a domain name and need special handling? */
1061                         if (strnlen(value, 256) < 256) {
1062                                 vol->domainname = value;
1063                                 cFYI(1, "Domain name set");
1064                         } else {
1065                                 printk(KERN_WARNING "CIFS: domain name too "
1066                                                     "long\n");
1067                                 return 1;
1068                         }
1069                 } else if (strnicmp(data, "srcaddr", 7) == 0) {
1070                         vol->srcaddr.ss_family = AF_UNSPEC;
1071
1072                         if (!value || !*value) {
1073                                 printk(KERN_WARNING "CIFS: srcaddr value"
1074                                        " not specified.\n");
1075                                 return 1;       /* needs_arg; */
1076                         }
1077                         i = cifs_convert_address((struct sockaddr *)&vol->srcaddr,
1078                                                  value, strlen(value));
1079                         if (i == 0) {
1080                                 printk(KERN_WARNING "CIFS:  Could not parse"
1081                                        " srcaddr: %s\n",
1082                                        value);
1083                                 return 1;
1084                         }
1085                 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1086                         if (!value || !*value) {
1087                                 printk(KERN_WARNING
1088                                         "CIFS: invalid path prefix\n");
1089                                 return 1;       /* needs_argument */
1090                         }
1091                         if ((temp_len = strnlen(value, 1024)) < 1024) {
1092                                 if (value[0] != '/')
1093                                         temp_len++;  /* missing leading slash */
1094                                 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1095                                 if (vol->prepath == NULL)
1096                                         return 1;
1097                                 if (value[0] != '/') {
1098                                         vol->prepath[0] = '/';
1099                                         strcpy(vol->prepath+1, value);
1100                                 } else
1101                                         strcpy(vol->prepath, value);
1102                                 cFYI(1, "prefix path %s", vol->prepath);
1103                         } else {
1104                                 printk(KERN_WARNING "CIFS: prefix too long\n");
1105                                 return 1;
1106                         }
1107                 } else if (strnicmp(data, "iocharset", 9) == 0) {
1108                         if (!value || !*value) {
1109                                 printk(KERN_WARNING "CIFS: invalid iocharset "
1110                                                     "specified\n");
1111                                 return 1;       /* needs_arg; */
1112                         }
1113                         if (strnlen(value, 65) < 65) {
1114                                 if (strnicmp(value, "default", 7))
1115                                         vol->iocharset = value;
1116                                 /* if iocharset not set then load_nls_default
1117                                    is used by caller */
1118                                 cFYI(1, "iocharset set to %s", value);
1119                         } else {
1120                                 printk(KERN_WARNING "CIFS: iocharset name "
1121                                                     "too long.\n");
1122                                 return 1;
1123                         }
1124                 } else if (!strnicmp(data, "uid", 3) && value && *value) {
1125                         vol->linux_uid = simple_strtoul(value, &value, 0);
1126                         uid_specified = true;
1127                 } else if (!strnicmp(data, "cruid", 5) && value && *value) {
1128                         vol->cred_uid = simple_strtoul(value, &value, 0);
1129                 } else if (!strnicmp(data, "forceuid", 8)) {
1130                         override_uid = 1;
1131                 } else if (!strnicmp(data, "noforceuid", 10)) {
1132                         override_uid = 0;
1133                 } else if (!strnicmp(data, "gid", 3) && value && *value) {
1134                         vol->linux_gid = simple_strtoul(value, &value, 0);
1135                         gid_specified = true;
1136                 } else if (!strnicmp(data, "forcegid", 8)) {
1137                         override_gid = 1;
1138                 } else if (!strnicmp(data, "noforcegid", 10)) {
1139                         override_gid = 0;
1140                 } else if (strnicmp(data, "file_mode", 4) == 0) {
1141                         if (value && *value) {
1142                                 vol->file_mode =
1143                                         simple_strtoul(value, &value, 0);
1144                         }
1145                 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1146                         if (value && *value) {
1147                                 vol->dir_mode =
1148                                         simple_strtoul(value, &value, 0);
1149                         }
1150                 } else if (strnicmp(data, "dirmode", 4) == 0) {
1151                         if (value && *value) {
1152                                 vol->dir_mode =
1153                                         simple_strtoul(value, &value, 0);
1154                         }
1155                 } else if (strnicmp(data, "port", 4) == 0) {
1156                         if (value && *value) {
1157                                 vol->port =
1158                                         simple_strtoul(value, &value, 0);
1159                         }
1160                 } else if (strnicmp(data, "rsize", 5) == 0) {
1161                         if (value && *value) {
1162                                 vol->rsize =
1163                                         simple_strtoul(value, &value, 0);
1164                         }
1165                 } else if (strnicmp(data, "wsize", 5) == 0) {
1166                         if (value && *value) {
1167                                 vol->wsize =
1168                                         simple_strtoul(value, &value, 0);
1169                         }
1170                 } else if (strnicmp(data, "sockopt", 5) == 0) {
1171                         if (!value || !*value) {
1172                                 cERROR(1, "no socket option specified");
1173                                 continue;
1174                         } else if (strnicmp(value, "TCP_NODELAY", 11) == 0) {
1175                                 vol->sockopt_tcp_nodelay = 1;
1176                         }
1177                 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1178                         if (!value || !*value || (*value == ' ')) {
1179                                 cFYI(1, "invalid (empty) netbiosname");
1180                         } else {
1181                                 memset(vol->source_rfc1001_name, 0x20,
1182                                         RFC1001_NAME_LEN);
1183                                 /*
1184                                  * FIXME: are there cases in which a comma can
1185                                  * be valid in workstation netbios name (and
1186                                  * need special handling)?
1187                                  */
1188                                 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1189                                         /* don't ucase netbiosname for user */
1190                                         if (value[i] == 0)
1191                                                 break;
1192                                         vol->source_rfc1001_name[i] = value[i];
1193                                 }
1194                                 /* The string has 16th byte zero still from
1195                                 set at top of the function  */
1196                                 if (i == RFC1001_NAME_LEN && value[i] != 0)
1197                                         printk(KERN_WARNING "CIFS: netbiosname"
1198                                                 " longer than 15 truncated.\n");
1199                         }
1200                 } else if (strnicmp(data, "servern", 7) == 0) {
1201                         /* servernetbiosname specified override *SMBSERVER */
1202                         if (!value || !*value || (*value == ' ')) {
1203                                 cFYI(1, "empty server netbiosname specified");
1204                         } else {
1205                                 /* last byte, type, is 0x20 for servr type */
1206                                 memset(vol->target_rfc1001_name, 0x20,
1207                                         RFC1001_NAME_LEN_WITH_NULL);
1208
1209                                 for (i = 0; i < 15; i++) {
1210                                 /* BB are there cases in which a comma can be
1211                                    valid in this workstation netbios name
1212                                    (and need special handling)? */
1213
1214                                 /* user or mount helper must uppercase
1215                                    the netbiosname */
1216                                         if (value[i] == 0)
1217                                                 break;
1218                                         else
1219                                                 vol->target_rfc1001_name[i] =
1220                                                                 value[i];
1221                                 }
1222                                 /* The string has 16th byte zero still from
1223                                    set at top of the function  */
1224                                 if (i == RFC1001_NAME_LEN && value[i] != 0)
1225                                         printk(KERN_WARNING "CIFS: server net"
1226                                         "biosname longer than 15 truncated.\n");
1227                         }
1228                 } else if (strnicmp(data, "actimeo", 7) == 0) {
1229                         if (value && *value) {
1230                                 vol->actimeo = HZ * simple_strtoul(value,
1231                                                                    &value, 0);
1232                                 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1233                                         cERROR(1, "CIFS: attribute cache"
1234                                                         "timeout too large");
1235                                         return 1;
1236                                 }
1237                         }
1238                 } else if (strnicmp(data, "credentials", 4) == 0) {
1239                         /* ignore */
1240                 } else if (strnicmp(data, "version", 3) == 0) {
1241                         /* ignore */
1242                 } else if (strnicmp(data, "guest", 5) == 0) {
1243                         /* ignore */
1244                 } else if (strnicmp(data, "rw", 2) == 0) {
1245                         /* ignore */
1246                 } else if (strnicmp(data, "ro", 2) == 0) {
1247                         /* ignore */
1248                 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1249                         vol->noblocksnd = 1;
1250                 } else if (strnicmp(data, "noautotune", 10) == 0) {
1251                         vol->noautotune = 1;
1252                 } else if ((strnicmp(data, "suid", 4) == 0) ||
1253                                    (strnicmp(data, "nosuid", 6) == 0) ||
1254                                    (strnicmp(data, "exec", 4) == 0) ||
1255                                    (strnicmp(data, "noexec", 6) == 0) ||
1256                                    (strnicmp(data, "nodev", 5) == 0) ||
1257                                    (strnicmp(data, "noauto", 6) == 0) ||
1258                                    (strnicmp(data, "dev", 3) == 0)) {
1259                         /*  The mount tool or mount.cifs helper (if present)
1260                             uses these opts to set flags, and the flags are read
1261                             by the kernel vfs layer before we get here (ie
1262                             before read super) so there is no point trying to
1263                             parse these options again and set anything and it
1264                             is ok to just ignore them */
1265                         continue;
1266                 } else if (strnicmp(data, "hard", 4) == 0) {
1267                         vol->retry = 1;
1268                 } else if (strnicmp(data, "soft", 4) == 0) {
1269                         vol->retry = 0;
1270                 } else if (strnicmp(data, "perm", 4) == 0) {
1271                         vol->noperm = 0;
1272                 } else if (strnicmp(data, "noperm", 6) == 0) {
1273                         vol->noperm = 1;
1274                 } else if (strnicmp(data, "mapchars", 8) == 0) {
1275                         vol->remap = 1;
1276                 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1277                         vol->remap = 0;
1278                 } else if (strnicmp(data, "sfu", 3) == 0) {
1279                         vol->sfu_emul = 1;
1280                 } else if (strnicmp(data, "nosfu", 5) == 0) {
1281                         vol->sfu_emul = 0;
1282                 } else if (strnicmp(data, "nodfs", 5) == 0) {
1283                         vol->nodfs = 1;
1284                 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1285                         vol->posix_paths = 1;
1286                 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1287                         vol->posix_paths = 0;
1288                 } else if (strnicmp(data, "nounix", 6) == 0) {
1289                         vol->no_linux_ext = 1;
1290                 } else if (strnicmp(data, "nolinux", 7) == 0) {
1291                         vol->no_linux_ext = 1;
1292                 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1293                            (strnicmp(data, "ignorecase", 10)  == 0)) {
1294                         vol->nocase = 1;
1295                 } else if (strnicmp(data, "mand", 4) == 0) {
1296                         /* ignore */
1297                 } else if (strnicmp(data, "nomand", 6) == 0) {
1298                         /* ignore */
1299                 } else if (strnicmp(data, "_netdev", 7) == 0) {
1300                         /* ignore */
1301                 } else if (strnicmp(data, "brl", 3) == 0) {
1302                         vol->nobrl =  0;
1303                 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1304                            (strnicmp(data, "nolock", 6) == 0)) {
1305                         vol->nobrl =  1;
1306                         /* turn off mandatory locking in mode
1307                         if remote locking is turned off since the
1308                         local vfs will do advisory */
1309                         if (vol->file_mode ==
1310                                 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1311                                 vol->file_mode = S_IALLUGO;
1312                 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1313                         /* will take the shorter form "forcemand" as well */
1314                         /* This mount option will force use of mandatory
1315                           (DOS/Windows style) byte range locks, instead of
1316                           using posix advisory byte range locks, even if the
1317                           Unix extensions are available and posix locks would
1318                           be supported otherwise. If Unix extensions are not
1319                           negotiated this has no effect since mandatory locks
1320                           would be used (mandatory locks is all that those
1321                           those servers support) */
1322                         vol->mand_lock = 1;
1323                 } else if (strnicmp(data, "setuids", 7) == 0) {
1324                         vol->setuids = 1;
1325                 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1326                         vol->setuids = 0;
1327                 } else if (strnicmp(data, "dynperm", 7) == 0) {
1328                         vol->dynperm = true;
1329                 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1330                         vol->dynperm = false;
1331                 } else if (strnicmp(data, "nohard", 6) == 0) {
1332                         vol->retry = 0;
1333                 } else if (strnicmp(data, "nosoft", 6) == 0) {
1334                         vol->retry = 1;
1335                 } else if (strnicmp(data, "nointr", 6) == 0) {
1336                         vol->intr = 0;
1337                 } else if (strnicmp(data, "intr", 4) == 0) {
1338                         vol->intr = 1;
1339                 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1340                         vol->nostrictsync = 1;
1341                 } else if (strnicmp(data, "strictsync", 10) == 0) {
1342                         vol->nostrictsync = 0;
1343                 } else if (strnicmp(data, "serverino", 7) == 0) {
1344                         vol->server_ino = 1;
1345                 } else if (strnicmp(data, "noserverino", 9) == 0) {
1346                         vol->server_ino = 0;
1347                 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1348                         vol->cifs_acl = 1;
1349                 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1350                         vol->cifs_acl = 0;
1351                 } else if (strnicmp(data, "acl", 3) == 0) {
1352                         vol->no_psx_acl = 0;
1353                 } else if (strnicmp(data, "noacl", 5) == 0) {
1354                         vol->no_psx_acl = 1;
1355                 } else if (strnicmp(data, "locallease", 6) == 0) {
1356                         vol->local_lease = 1;
1357                 } else if (strnicmp(data, "sign", 4) == 0) {
1358                         vol->secFlg |= CIFSSEC_MUST_SIGN;
1359                 } else if (strnicmp(data, "seal", 4) == 0) {
1360                         /* we do not do the following in secFlags because seal
1361                            is a per tree connection (mount) not a per socket
1362                            or per-smb connection option in the protocol */
1363                         /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1364                         vol->seal = 1;
1365                 } else if (strnicmp(data, "direct", 6) == 0) {
1366                         vol->direct_io = 1;
1367                 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1368                         vol->direct_io = 1;
1369                 } else if (strnicmp(data, "strictcache", 11) == 0) {
1370                         vol->strict_io = 1;
1371                 } else if (strnicmp(data, "noac", 4) == 0) {
1372                         printk(KERN_WARNING "CIFS: Mount option noac not "
1373                                 "supported. Instead set "
1374                                 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1375                 } else if (strnicmp(data, "fsc", 3) == 0) {
1376 #ifndef CONFIG_CIFS_FSCACHE
1377                         cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE"
1378                                   "kernel config option set");
1379                         return 1;
1380 #endif
1381                         vol->fsc = true;
1382                 } else if (strnicmp(data, "mfsymlinks", 10) == 0) {
1383                         vol->mfsymlinks = true;
1384                 } else if (strnicmp(data, "multiuser", 8) == 0) {
1385                         vol->multiuser = true;
1386                 } else
1387                         printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1388                                                 data);
1389         }
1390         if (vol->UNC == NULL) {
1391                 if (devname == NULL) {
1392                         printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1393                                                 "target\n");
1394                         return 1;
1395                 }
1396                 if ((temp_len = strnlen(devname, 300)) < 300) {
1397                         vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1398                         if (vol->UNC == NULL)
1399                                 return 1;
1400                         strcpy(vol->UNC, devname);
1401                         if (strncmp(vol->UNC, "//", 2) == 0) {
1402                                 vol->UNC[0] = '\\';
1403                                 vol->UNC[1] = '\\';
1404                         } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1405                                 printk(KERN_WARNING "CIFS: UNC Path does not "
1406                                                     "begin with // or \\\\ \n");
1407                                 return 1;
1408                         }
1409                         value = strpbrk(vol->UNC+2, "/\\");
1410                         if (value)
1411                                 *value = '\\';
1412                 } else {
1413                         printk(KERN_WARNING "CIFS: UNC name too long\n");
1414                         return 1;
1415                 }
1416         }
1417
1418         if (vol->multiuser && !(vol->secFlg & CIFSSEC_MAY_KRB5)) {
1419                 cERROR(1, "Multiuser mounts currently require krb5 "
1420                           "authentication!");
1421                 return 1;
1422         }
1423
1424         if (vol->UNCip == NULL)
1425                 vol->UNCip = &vol->UNC[2];
1426
1427         if (uid_specified)
1428                 vol->override_uid = override_uid;
1429         else if (override_uid == 1)
1430                 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1431                                    "specified with no uid= option.\n");
1432
1433         if (gid_specified)
1434                 vol->override_gid = override_gid;
1435         else if (override_gid == 1)
1436                 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1437                                    "specified with no gid= option.\n");
1438
1439         return 0;
1440 }
1441
1442 /** Returns true if srcaddr isn't specified and rhs isn't
1443  * specified, or if srcaddr is specified and
1444  * matches the IP address of the rhs argument.
1445  */
1446 static bool
1447 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1448 {
1449         switch (srcaddr->sa_family) {
1450         case AF_UNSPEC:
1451                 return (rhs->sa_family == AF_UNSPEC);
1452         case AF_INET: {
1453                 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1454                 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1455                 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1456         }
1457         case AF_INET6: {
1458                 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1459                 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1460                 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1461         }
1462         default:
1463                 WARN_ON(1);
1464                 return false; /* don't expect to be here */
1465         }
1466 }
1467
1468 /*
1469  * If no port is specified in addr structure, we try to match with 445 port
1470  * and if it fails - with 139 ports. It should be called only if address
1471  * families of server and addr are equal.
1472  */
1473 static bool
1474 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1475 {
1476         __be16 port, *sport;
1477
1478         switch (addr->sa_family) {
1479         case AF_INET:
1480                 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1481                 port = ((struct sockaddr_in *) addr)->sin_port;
1482                 break;
1483         case AF_INET6:
1484                 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1485                 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1486                 break;
1487         default:
1488                 WARN_ON(1);
1489                 return false;
1490         }
1491
1492         if (!port) {
1493                 port = htons(CIFS_PORT);
1494                 if (port == *sport)
1495                         return true;
1496
1497                 port = htons(RFC1001_PORT);
1498         }
1499
1500         return port == *sport;
1501 }
1502
1503 static bool
1504 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1505               struct sockaddr *srcaddr)
1506 {
1507         switch (addr->sa_family) {
1508         case AF_INET: {
1509                 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1510                 struct sockaddr_in *srv_addr4 =
1511                                         (struct sockaddr_in *)&server->dstaddr;
1512
1513                 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1514                         return false;
1515                 break;
1516         }
1517         case AF_INET6: {
1518                 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1519                 struct sockaddr_in6 *srv_addr6 =
1520                                         (struct sockaddr_in6 *)&server->dstaddr;
1521
1522                 if (!ipv6_addr_equal(&addr6->sin6_addr,
1523                                      &srv_addr6->sin6_addr))
1524                         return false;
1525                 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1526                         return false;
1527                 break;
1528         }
1529         default:
1530                 WARN_ON(1);
1531                 return false; /* don't expect to be here */
1532         }
1533
1534         if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1535                 return false;
1536
1537         return true;
1538 }
1539
1540 static bool
1541 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1542 {
1543         unsigned int secFlags;
1544
1545         if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1546                 secFlags = vol->secFlg;
1547         else
1548                 secFlags = global_secflags | vol->secFlg;
1549
1550         switch (server->secType) {
1551         case LANMAN:
1552                 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1553                         return false;
1554                 break;
1555         case NTLMv2:
1556                 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1557                         return false;
1558                 break;
1559         case NTLM:
1560                 if (!(secFlags & CIFSSEC_MAY_NTLM))
1561                         return false;
1562                 break;
1563         case Kerberos:
1564                 if (!(secFlags & CIFSSEC_MAY_KRB5))
1565                         return false;
1566                 break;
1567         case RawNTLMSSP:
1568                 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
1569                         return false;
1570                 break;
1571         default:
1572                 /* shouldn't happen */
1573                 return false;
1574         }
1575
1576         /* now check if signing mode is acceptable */
1577         if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
1578             (server->secMode & SECMODE_SIGN_REQUIRED))
1579                         return false;
1580         else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
1581                  (server->secMode &
1582                   (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
1583                         return false;
1584
1585         return true;
1586 }
1587
1588 static struct TCP_Server_Info *
1589 cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
1590 {
1591         struct TCP_Server_Info *server;
1592
1593         spin_lock(&cifs_tcp_ses_lock);
1594         list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
1595                 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
1596                         continue;
1597
1598                 if (!match_address(server, addr,
1599                                    (struct sockaddr *)&vol->srcaddr))
1600                         continue;
1601
1602                 if (!match_port(server, addr))
1603                         continue;
1604
1605                 if (!match_security(server, vol))
1606                         continue;
1607
1608                 ++server->srv_count;
1609                 spin_unlock(&cifs_tcp_ses_lock);
1610                 cFYI(1, "Existing tcp session with server found");
1611                 return server;
1612         }
1613         spin_unlock(&cifs_tcp_ses_lock);
1614         return NULL;
1615 }
1616
1617 static void
1618 cifs_put_tcp_session(struct TCP_Server_Info *server)
1619 {
1620         struct task_struct *task;
1621
1622         spin_lock(&cifs_tcp_ses_lock);
1623         if (--server->srv_count > 0) {
1624                 spin_unlock(&cifs_tcp_ses_lock);
1625                 return;
1626         }
1627
1628         put_net(cifs_net_ns(server));
1629
1630         list_del_init(&server->tcp_ses_list);
1631         spin_unlock(&cifs_tcp_ses_lock);
1632
1633         cancel_delayed_work_sync(&server->echo);
1634
1635         spin_lock(&GlobalMid_Lock);
1636         server->tcpStatus = CifsExiting;
1637         spin_unlock(&GlobalMid_Lock);
1638
1639         cifs_crypto_shash_release(server);
1640         cifs_fscache_release_client_cookie(server);
1641
1642         kfree(server->session_key.response);
1643         server->session_key.response = NULL;
1644         server->session_key.len = 0;
1645
1646         task = xchg(&server->tsk, NULL);
1647         if (task)
1648                 force_sig(SIGKILL, task);
1649 }
1650
1651 static struct TCP_Server_Info *
1652 cifs_get_tcp_session(struct smb_vol *volume_info)
1653 {
1654         struct TCP_Server_Info *tcp_ses = NULL;
1655         struct sockaddr_storage addr;
1656         struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1657         struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1658         int rc;
1659
1660         memset(&addr, 0, sizeof(struct sockaddr_storage));
1661
1662         cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
1663
1664         if (volume_info->UNCip && volume_info->UNC) {
1665                 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
1666                                         volume_info->UNCip,
1667                                         strlen(volume_info->UNCip),
1668                                         volume_info->port);
1669                 if (!rc) {
1670                         /* we failed translating address */
1671                         rc = -EINVAL;
1672                         goto out_err;
1673                 }
1674         } else if (volume_info->UNCip) {
1675                 /* BB using ip addr as tcp_ses name to connect to the
1676                    DFS root below */
1677                 cERROR(1, "Connecting to DFS root not implemented yet");
1678                 rc = -EINVAL;
1679                 goto out_err;
1680         } else /* which tcp_sess DFS root would we conect to */ {
1681                 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1682                         "unc=//192.168.1.100/public) specified");
1683                 rc = -EINVAL;
1684                 goto out_err;
1685         }
1686
1687         /* see if we already have a matching tcp_ses */
1688         tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
1689         if (tcp_ses)
1690                 return tcp_ses;
1691
1692         tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1693         if (!tcp_ses) {
1694                 rc = -ENOMEM;
1695                 goto out_err;
1696         }
1697
1698         rc = cifs_crypto_shash_allocate(tcp_ses);
1699         if (rc) {
1700                 cERROR(1, "could not setup hash structures rc %d", rc);
1701                 goto out_err;
1702         }
1703
1704         cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
1705         tcp_ses->hostname = extract_hostname(volume_info->UNC);
1706         if (IS_ERR(tcp_ses->hostname)) {
1707                 rc = PTR_ERR(tcp_ses->hostname);
1708                 goto out_err_crypto_release;
1709         }
1710
1711         tcp_ses->noblocksnd = volume_info->noblocksnd;
1712         tcp_ses->noautotune = volume_info->noautotune;
1713         tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
1714         atomic_set(&tcp_ses->inFlight, 0);
1715         init_waitqueue_head(&tcp_ses->response_q);
1716         init_waitqueue_head(&tcp_ses->request_q);
1717         INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1718         mutex_init(&tcp_ses->srv_mutex);
1719         memcpy(tcp_ses->workstation_RFC1001_name,
1720                 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1721         memcpy(tcp_ses->server_RFC1001_name,
1722                 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1723         tcp_ses->session_estab = false;
1724         tcp_ses->sequence_number = 0;
1725         tcp_ses->lstrp = jiffies;
1726         INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1727         INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1728         INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
1729
1730         /*
1731          * at this point we are the only ones with the pointer
1732          * to the struct since the kernel thread not created yet
1733          * no need to spinlock this init of tcpStatus or srv_count
1734          */
1735         tcp_ses->tcpStatus = CifsNew;
1736         memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
1737                sizeof(tcp_ses->srcaddr));
1738         ++tcp_ses->srv_count;
1739
1740         if (addr.ss_family == AF_INET6) {
1741                 cFYI(1, "attempting ipv6 connect");
1742                 /* BB should we allow ipv6 on port 139? */
1743                 /* other OS never observed in Wild doing 139 with v6 */
1744                 memcpy(&tcp_ses->dstaddr, sin_server6,
1745                        sizeof(struct sockaddr_in6));
1746         } else
1747                 memcpy(&tcp_ses->dstaddr, sin_server,
1748                        sizeof(struct sockaddr_in));
1749
1750         rc = ip_connect(tcp_ses);
1751         if (rc < 0) {
1752                 cERROR(1, "Error connecting to socket. Aborting operation");
1753                 goto out_err_crypto_release;
1754         }
1755
1756         /*
1757          * since we're in a cifs function already, we know that
1758          * this will succeed. No need for try_module_get().
1759          */
1760         __module_get(THIS_MODULE);
1761         tcp_ses->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread,
1762                                   tcp_ses, "cifsd");
1763         if (IS_ERR(tcp_ses->tsk)) {
1764                 rc = PTR_ERR(tcp_ses->tsk);
1765                 cERROR(1, "error %d create cifsd thread", rc);
1766                 module_put(THIS_MODULE);
1767                 goto out_err_crypto_release;
1768         }
1769         tcp_ses->tcpStatus = CifsNeedNegotiate;
1770
1771         /* thread spawned, put it on the list */
1772         spin_lock(&cifs_tcp_ses_lock);
1773         list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1774         spin_unlock(&cifs_tcp_ses_lock);
1775
1776         cifs_fscache_get_client_cookie(tcp_ses);
1777
1778         /* queue echo request delayed work */
1779         queue_delayed_work(system_nrt_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
1780
1781         return tcp_ses;
1782
1783 out_err_crypto_release:
1784         cifs_crypto_shash_release(tcp_ses);
1785
1786         put_net(cifs_net_ns(tcp_ses));
1787
1788 out_err:
1789         if (tcp_ses) {
1790                 if (!IS_ERR(tcp_ses->hostname))
1791                         kfree(tcp_ses->hostname);
1792                 if (tcp_ses->ssocket)
1793                         sock_release(tcp_ses->ssocket);
1794                 kfree(tcp_ses);
1795         }
1796         return ERR_PTR(rc);
1797 }
1798
1799 static struct cifsSesInfo *
1800 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
1801 {
1802         struct cifsSesInfo *ses;
1803
1804         spin_lock(&cifs_tcp_ses_lock);
1805         list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
1806                 switch (server->secType) {
1807                 case Kerberos:
1808                         if (vol->cred_uid != ses->cred_uid)
1809                                 continue;
1810                         break;
1811                 default:
1812                         /* anything else takes username/password */
1813                         if (ses->user_name == NULL)
1814                                 continue;
1815                         if (strncmp(ses->user_name, vol->username,
1816                                     MAX_USERNAME_SIZE))
1817                                 continue;
1818                         if (strlen(vol->username) != 0 &&
1819                             ses->password != NULL &&
1820                             strncmp(ses->password,
1821                                     vol->password ? vol->password : "",
1822                                     MAX_PASSWORD_SIZE))
1823                                 continue;
1824                 }
1825                 ++ses->ses_count;
1826                 spin_unlock(&cifs_tcp_ses_lock);
1827                 return ses;
1828         }
1829         spin_unlock(&cifs_tcp_ses_lock);
1830         return NULL;
1831 }
1832
1833 static void
1834 cifs_put_smb_ses(struct cifsSesInfo *ses)
1835 {
1836         int xid;
1837         struct TCP_Server_Info *server = ses->server;
1838
1839         cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
1840         spin_lock(&cifs_tcp_ses_lock);
1841         if (--ses->ses_count > 0) {
1842                 spin_unlock(&cifs_tcp_ses_lock);
1843                 return;
1844         }
1845
1846         list_del_init(&ses->smb_ses_list);
1847         spin_unlock(&cifs_tcp_ses_lock);
1848
1849         if (ses->status == CifsGood) {
1850                 xid = GetXid();
1851                 CIFSSMBLogoff(xid, ses);
1852                 _FreeXid(xid);
1853         }
1854         sesInfoFree(ses);
1855         cifs_put_tcp_session(server);
1856 }
1857
1858 static bool warned_on_ntlm;  /* globals init to false automatically */
1859
1860 static struct cifsSesInfo *
1861 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
1862 {
1863         int rc = -ENOMEM, xid;
1864         struct cifsSesInfo *ses;
1865         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1866         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
1867
1868         xid = GetXid();
1869
1870         ses = cifs_find_smb_ses(server, volume_info);
1871         if (ses) {
1872                 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
1873
1874                 mutex_lock(&ses->session_mutex);
1875                 rc = cifs_negotiate_protocol(xid, ses);
1876                 if (rc) {
1877                         mutex_unlock(&ses->session_mutex);
1878                         /* problem -- put our ses reference */
1879                         cifs_put_smb_ses(ses);
1880                         FreeXid(xid);
1881                         return ERR_PTR(rc);
1882                 }
1883                 if (ses->need_reconnect) {
1884                         cFYI(1, "Session needs reconnect");
1885                         rc = cifs_setup_session(xid, ses,
1886                                                 volume_info->local_nls);
1887                         if (rc) {
1888                                 mutex_unlock(&ses->session_mutex);
1889                                 /* problem -- put our reference */
1890                                 cifs_put_smb_ses(ses);
1891                                 FreeXid(xid);
1892                                 return ERR_PTR(rc);
1893                         }
1894                 }
1895                 mutex_unlock(&ses->session_mutex);
1896
1897                 /* existing SMB ses has a server reference already */
1898                 cifs_put_tcp_session(server);
1899                 FreeXid(xid);
1900                 return ses;
1901         }
1902
1903         cFYI(1, "Existing smb sess not found");
1904         ses = sesInfoAlloc();
1905         if (ses == NULL)
1906                 goto get_ses_fail;
1907
1908         /* new SMB session uses our server ref */
1909         ses->server = server;
1910         if (server->dstaddr.ss_family == AF_INET6)
1911                 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
1912         else
1913                 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
1914
1915         if (volume_info->username) {
1916                 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
1917                 if (!ses->user_name)
1918                         goto get_ses_fail;
1919         }
1920
1921         /* volume_info->password freed at unmount */
1922         if (volume_info->password) {
1923                 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
1924                 if (!ses->password)
1925                         goto get_ses_fail;
1926         }
1927         if (volume_info->domainname) {
1928                 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
1929                 if (!ses->domainName)
1930                         goto get_ses_fail;
1931         }
1932         ses->cred_uid = volume_info->cred_uid;
1933         ses->linux_uid = volume_info->linux_uid;
1934
1935         /* ntlmv2 is much stronger than ntlm security, and has been broadly
1936         supported for many years, time to update default security mechanism */
1937         if ((volume_info->secFlg == 0) && warned_on_ntlm == false) {
1938                 warned_on_ntlm = true;
1939                 cERROR(1, "default security mechanism requested.  The default "
1940                         "security mechanism will be upgraded from ntlm to "
1941                         "ntlmv2 in kernel release 2.6.41");
1942         }
1943         ses->overrideSecFlg = volume_info->secFlg;
1944
1945         mutex_lock(&ses->session_mutex);
1946         rc = cifs_negotiate_protocol(xid, ses);
1947         if (!rc)
1948                 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
1949         mutex_unlock(&ses->session_mutex);
1950         if (rc)
1951                 goto get_ses_fail;
1952
1953         /* success, put it on the list */
1954         spin_lock(&cifs_tcp_ses_lock);
1955         list_add(&ses->smb_ses_list, &server->smb_ses_list);
1956         spin_unlock(&cifs_tcp_ses_lock);
1957
1958         FreeXid(xid);
1959         return ses;
1960
1961 get_ses_fail:
1962         sesInfoFree(ses);
1963         FreeXid(xid);
1964         return ERR_PTR(rc);
1965 }
1966
1967 static struct cifsTconInfo *
1968 cifs_find_tcon(struct cifsSesInfo *ses, const char *unc)
1969 {
1970         struct list_head *tmp;
1971         struct cifsTconInfo *tcon;
1972
1973         spin_lock(&cifs_tcp_ses_lock);
1974         list_for_each(tmp, &ses->tcon_list) {
1975                 tcon = list_entry(tmp, struct cifsTconInfo, tcon_list);
1976                 if (tcon->tidStatus == CifsExiting)
1977                         continue;
1978                 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
1979                         continue;
1980
1981                 ++tcon->tc_count;
1982                 spin_unlock(&cifs_tcp_ses_lock);
1983                 return tcon;
1984         }
1985         spin_unlock(&cifs_tcp_ses_lock);
1986         return NULL;
1987 }
1988
1989 static void
1990 cifs_put_tcon(struct cifsTconInfo *tcon)
1991 {
1992         int xid;
1993         struct cifsSesInfo *ses = tcon->ses;
1994
1995         cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
1996         spin_lock(&cifs_tcp_ses_lock);
1997         if (--tcon->tc_count > 0) {
1998                 spin_unlock(&cifs_tcp_ses_lock);
1999                 return;
2000         }
2001
2002         list_del_init(&tcon->tcon_list);
2003         spin_unlock(&cifs_tcp_ses_lock);
2004
2005         xid = GetXid();
2006         CIFSSMBTDis(xid, tcon);
2007         _FreeXid(xid);
2008
2009         cifs_fscache_release_super_cookie(tcon);
2010         tconInfoFree(tcon);
2011         cifs_put_smb_ses(ses);
2012 }
2013
2014 static struct cifsTconInfo *
2015 cifs_get_tcon(struct cifsSesInfo *ses, struct smb_vol *volume_info)
2016 {
2017         int rc, xid;
2018         struct cifsTconInfo *tcon;
2019
2020         tcon = cifs_find_tcon(ses, volume_info->UNC);
2021         if (tcon) {
2022                 cFYI(1, "Found match on UNC path");
2023                 /* existing tcon already has a reference */
2024                 cifs_put_smb_ses(ses);
2025                 if (tcon->seal != volume_info->seal)
2026                         cERROR(1, "transport encryption setting "
2027                                    "conflicts with existing tid");
2028                 return tcon;
2029         }
2030
2031         tcon = tconInfoAlloc();
2032         if (tcon == NULL) {
2033                 rc = -ENOMEM;
2034                 goto out_fail;
2035         }
2036
2037         tcon->ses = ses;
2038         if (volume_info->password) {
2039                 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2040                 if (!tcon->password) {
2041                         rc = -ENOMEM;
2042                         goto out_fail;
2043                 }
2044         }
2045
2046         if (strchr(volume_info->UNC + 3, '\\') == NULL
2047             && strchr(volume_info->UNC + 3, '/') == NULL) {
2048                 cERROR(1, "Missing share name");
2049                 rc = -ENODEV;
2050                 goto out_fail;
2051         }
2052
2053         /* BB Do we need to wrap session_mutex around
2054          * this TCon call and Unix SetFS as
2055          * we do on SessSetup and reconnect? */
2056         xid = GetXid();
2057         rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2058         FreeXid(xid);
2059         cFYI(1, "CIFS Tcon rc = %d", rc);
2060         if (rc)
2061                 goto out_fail;
2062
2063         if (volume_info->nodfs) {
2064                 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2065                 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2066         }
2067         tcon->seal = volume_info->seal;
2068         /* we can have only one retry value for a connection
2069            to a share so for resources mounted more than once
2070            to the same server share the last value passed in
2071            for the retry flag is used */
2072         tcon->retry = volume_info->retry;
2073         tcon->nocase = volume_info->nocase;
2074         tcon->local_lease = volume_info->local_lease;
2075
2076         spin_lock(&cifs_tcp_ses_lock);
2077         list_add(&tcon->tcon_list, &ses->tcon_list);
2078         spin_unlock(&cifs_tcp_ses_lock);
2079
2080         cifs_fscache_get_super_cookie(tcon);
2081
2082         return tcon;
2083
2084 out_fail:
2085         tconInfoFree(tcon);
2086         return ERR_PTR(rc);
2087 }
2088
2089 void
2090 cifs_put_tlink(struct tcon_link *tlink)
2091 {
2092         if (!tlink || IS_ERR(tlink))
2093                 return;
2094
2095         if (!atomic_dec_and_test(&tlink->tl_count) ||
2096             test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2097                 tlink->tl_time = jiffies;
2098                 return;
2099         }
2100
2101         if (!IS_ERR(tlink_tcon(tlink)))
2102                 cifs_put_tcon(tlink_tcon(tlink));
2103         kfree(tlink);
2104         return;
2105 }
2106
2107 int
2108 get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
2109              const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
2110              struct dfs_info3_param **preferrals, int remap)
2111 {
2112         char *temp_unc;
2113         int rc = 0;
2114
2115         *pnum_referrals = 0;
2116         *preferrals = NULL;
2117
2118         if (pSesInfo->ipc_tid == 0) {
2119                 temp_unc = kmalloc(2 /* for slashes */ +
2120                         strnlen(pSesInfo->serverName,
2121                                 SERVER_NAME_LEN_WITH_NULL * 2)
2122                                  + 1 + 4 /* slash IPC$ */  + 2,
2123                                 GFP_KERNEL);
2124                 if (temp_unc == NULL)
2125                         return -ENOMEM;
2126                 temp_unc[0] = '\\';
2127                 temp_unc[1] = '\\';
2128                 strcpy(temp_unc + 2, pSesInfo->serverName);
2129                 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2130                 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
2131                 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
2132                 kfree(temp_unc);
2133         }
2134         if (rc == 0)
2135                 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
2136                                      pnum_referrals, nls_codepage, remap);
2137         /* BB map targetUNCs to dfs_info3 structures, here or
2138                 in CIFSGetDFSRefer BB */
2139
2140         return rc;
2141 }
2142
2143 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2144 static struct lock_class_key cifs_key[2];
2145 static struct lock_class_key cifs_slock_key[2];
2146
2147 static inline void
2148 cifs_reclassify_socket4(struct socket *sock)
2149 {
2150         struct sock *sk = sock->sk;
2151         BUG_ON(sock_owned_by_user(sk));
2152         sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2153                 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2154 }
2155
2156 static inline void
2157 cifs_reclassify_socket6(struct socket *sock)
2158 {
2159         struct sock *sk = sock->sk;
2160         BUG_ON(sock_owned_by_user(sk));
2161         sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2162                 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2163 }
2164 #else
2165 static inline void
2166 cifs_reclassify_socket4(struct socket *sock)
2167 {
2168 }
2169
2170 static inline void
2171 cifs_reclassify_socket6(struct socket *sock)
2172 {
2173 }
2174 #endif
2175
2176 /* See RFC1001 section 14 on representation of Netbios names */
2177 static void rfc1002mangle(char *target, char *source, unsigned int length)
2178 {
2179         unsigned int i, j;
2180
2181         for (i = 0, j = 0; i < (length); i++) {
2182                 /* mask a nibble at a time and encode */
2183                 target[j] = 'A' + (0x0F & (source[i] >> 4));
2184                 target[j+1] = 'A' + (0x0F & source[i]);
2185                 j += 2;
2186         }
2187
2188 }
2189
2190 static int
2191 bind_socket(struct TCP_Server_Info *server)
2192 {
2193         int rc = 0;
2194         if (server->srcaddr.ss_family != AF_UNSPEC) {
2195                 /* Bind to the specified local IP address */
2196                 struct socket *socket = server->ssocket;
2197                 rc = socket->ops->bind(socket,
2198                                        (struct sockaddr *) &server->srcaddr,
2199                                        sizeof(server->srcaddr));
2200                 if (rc < 0) {
2201                         struct sockaddr_in *saddr4;
2202                         struct sockaddr_in6 *saddr6;
2203                         saddr4 = (struct sockaddr_in *)&server->srcaddr;
2204                         saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2205                         if (saddr6->sin6_family == AF_INET6)
2206                                 cERROR(1, "cifs: "
2207                                        "Failed to bind to: %pI6c, error: %d\n",
2208                                        &saddr6->sin6_addr, rc);
2209                         else
2210                                 cERROR(1, "cifs: "
2211                                        "Failed to bind to: %pI4, error: %d\n",
2212                                        &saddr4->sin_addr.s_addr, rc);
2213                 }
2214         }
2215         return rc;
2216 }
2217
2218 static int
2219 ip_rfc1001_connect(struct TCP_Server_Info *server)
2220 {
2221         int rc = 0;
2222         /*
2223          * some servers require RFC1001 sessinit before sending
2224          * negprot - BB check reconnection in case where second
2225          * sessinit is sent but no second negprot
2226          */
2227         struct rfc1002_session_packet *ses_init_buf;
2228         struct smb_hdr *smb_buf;
2229         ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2230                                GFP_KERNEL);
2231         if (ses_init_buf) {
2232                 ses_init_buf->trailer.session_req.called_len = 32;
2233
2234                 if (server->server_RFC1001_name &&
2235                     server->server_RFC1001_name[0] != 0)
2236                         rfc1002mangle(ses_init_buf->trailer.
2237                                       session_req.called_name,
2238                                       server->server_RFC1001_name,
2239                                       RFC1001_NAME_LEN_WITH_NULL);
2240                 else
2241                         rfc1002mangle(ses_init_buf->trailer.
2242                                       session_req.called_name,
2243                                       DEFAULT_CIFS_CALLED_NAME,
2244                                       RFC1001_NAME_LEN_WITH_NULL);
2245
2246                 ses_init_buf->trailer.session_req.calling_len = 32;
2247
2248                 /*
2249                  * calling name ends in null (byte 16) from old smb
2250                  * convention.
2251                  */
2252                 if (server->workstation_RFC1001_name &&
2253                     server->workstation_RFC1001_name[0] != 0)
2254                         rfc1002mangle(ses_init_buf->trailer.
2255                                       session_req.calling_name,
2256                                       server->workstation_RFC1001_name,
2257                                       RFC1001_NAME_LEN_WITH_NULL);
2258                 else
2259                         rfc1002mangle(ses_init_buf->trailer.
2260                                       session_req.calling_name,
2261                                       "LINUX_CIFS_CLNT",
2262                                       RFC1001_NAME_LEN_WITH_NULL);
2263
2264                 ses_init_buf->trailer.session_req.scope1 = 0;
2265                 ses_init_buf->trailer.session_req.scope2 = 0;
2266                 smb_buf = (struct smb_hdr *)ses_init_buf;
2267
2268                 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2269                 smb_buf->smb_buf_length = 0x81000044;
2270                 rc = smb_send(server, smb_buf, 0x44);
2271                 kfree(ses_init_buf);
2272                 /*
2273                  * RFC1001 layer in at least one server
2274                  * requires very short break before negprot
2275                  * presumably because not expecting negprot
2276                  * to follow so fast.  This is a simple
2277                  * solution that works without
2278                  * complicating the code and causes no
2279                  * significant slowing down on mount
2280                  * for everyone else
2281                  */
2282                 usleep_range(1000, 2000);
2283         }
2284         /*
2285          * else the negprot may still work without this
2286          * even though malloc failed
2287          */
2288
2289         return rc;
2290 }
2291
2292 static int
2293 generic_ip_connect(struct TCP_Server_Info *server)
2294 {
2295         int rc = 0;
2296         __be16 sport;
2297         int slen, sfamily;
2298         struct socket *socket = server->ssocket;
2299         struct sockaddr *saddr;
2300
2301         saddr = (struct sockaddr *) &server->dstaddr;
2302
2303         if (server->dstaddr.ss_family == AF_INET6) {
2304                 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2305                 slen = sizeof(struct sockaddr_in6);
2306                 sfamily = AF_INET6;
2307         } else {
2308                 sport = ((struct sockaddr_in *) saddr)->sin_port;
2309                 slen = sizeof(struct sockaddr_in);
2310                 sfamily = AF_INET;
2311         }
2312
2313         if (socket == NULL) {
2314                 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2315                                    IPPROTO_TCP, &socket, 1);
2316                 if (rc < 0) {
2317                         cERROR(1, "Error %d creating socket", rc);
2318                         server->ssocket = NULL;
2319                         return rc;
2320                 }
2321
2322                 /* BB other socket options to set KEEPALIVE, NODELAY? */
2323                 cFYI(1, "Socket created");
2324                 server->ssocket = socket;
2325                 socket->sk->sk_allocation = GFP_NOFS;
2326                 if (sfamily == AF_INET6)
2327                         cifs_reclassify_socket6(socket);
2328                 else
2329                         cifs_reclassify_socket4(socket);
2330         }
2331
2332         rc = bind_socket(server);
2333         if (rc < 0)
2334                 return rc;
2335
2336         rc = socket->ops->connect(socket, saddr, slen, 0);
2337         if (rc < 0) {
2338                 cFYI(1, "Error %d connecting to server", rc);
2339                 sock_release(socket);
2340                 server->ssocket = NULL;
2341                 return rc;
2342         }
2343
2344         /*
2345          * Eventually check for other socket options to change from
2346          * the default. sock_setsockopt not used because it expects
2347          * user space buffer
2348          */
2349         socket->sk->sk_rcvtimeo = 7 * HZ;
2350         socket->sk->sk_sndtimeo = 5 * HZ;
2351
2352         /* make the bufsizes depend on wsize/rsize and max requests */
2353         if (server->noautotune) {
2354                 if (socket->sk->sk_sndbuf < (200 * 1024))
2355                         socket->sk->sk_sndbuf = 200 * 1024;
2356                 if (socket->sk->sk_rcvbuf < (140 * 1024))
2357                         socket->sk->sk_rcvbuf = 140 * 1024;
2358         }
2359
2360         if (server->tcp_nodelay) {
2361                 int val = 1;
2362                 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2363                                 (char *)&val, sizeof(val));
2364                 if (rc)
2365                         cFYI(1, "set TCP_NODELAY socket option error %d", rc);
2366         }
2367
2368          cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2369                  socket->sk->sk_sndbuf,
2370                  socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2371
2372         if (sport == htons(RFC1001_PORT))
2373                 rc = ip_rfc1001_connect(server);
2374
2375         return rc;
2376 }
2377
2378 static int
2379 ip_connect(struct TCP_Server_Info *server)
2380 {
2381         __be16 *sport;
2382         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2383         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2384
2385         if (server->dstaddr.ss_family == AF_INET6)
2386                 sport = &addr6->sin6_port;
2387         else
2388                 sport = &addr->sin_port;
2389
2390         if (*sport == 0) {
2391                 int rc;
2392
2393                 /* try with 445 port at first */
2394                 *sport = htons(CIFS_PORT);
2395
2396                 rc = generic_ip_connect(server);
2397                 if (rc >= 0)
2398                         return rc;
2399
2400                 /* if it failed, try with 139 port */
2401                 *sport = htons(RFC1001_PORT);
2402         }
2403
2404         return generic_ip_connect(server);
2405 }
2406
2407 void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
2408                           struct super_block *sb, struct smb_vol *vol_info)
2409 {
2410         /* if we are reconnecting then should we check to see if
2411          * any requested capabilities changed locally e.g. via
2412          * remount but we can not do much about it here
2413          * if they have (even if we could detect it by the following)
2414          * Perhaps we could add a backpointer to array of sb from tcon
2415          * or if we change to make all sb to same share the same
2416          * sb as NFS - then we only have one backpointer to sb.
2417          * What if we wanted to mount the server share twice once with
2418          * and once without posixacls or posix paths? */
2419         __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2420
2421         if (vol_info && vol_info->no_linux_ext) {
2422                 tcon->fsUnixInfo.Capability = 0;
2423                 tcon->unix_ext = 0; /* Unix Extensions disabled */
2424                 cFYI(1, "Linux protocol extensions disabled");
2425                 return;
2426         } else if (vol_info)
2427                 tcon->unix_ext = 1; /* Unix Extensions supported */
2428
2429         if (tcon->unix_ext == 0) {
2430                 cFYI(1, "Unix extensions disabled so not set on reconnect");
2431                 return;
2432         }
2433
2434         if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
2435                 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2436
2437                 /* check for reconnect case in which we do not
2438                    want to change the mount behavior if we can avoid it */
2439                 if (vol_info == NULL) {
2440                         /* turn off POSIX ACL and PATHNAMES if not set
2441                            originally at mount time */
2442                         if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2443                                 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2444                         if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2445                                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2446                                         cERROR(1, "POSIXPATH support change");
2447                                 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2448                         } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2449                                 cERROR(1, "possible reconnect error");
2450                                 cERROR(1, "server disabled POSIX path support");
2451                         }
2452                 }
2453
2454                 cap &= CIFS_UNIX_CAP_MASK;
2455                 if (vol_info && vol_info->no_psx_acl)
2456                         cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2457                 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
2458                         cFYI(1, "negotiated posix acl support");
2459                         if (sb)
2460                                 sb->s_flags |= MS_POSIXACL;
2461                 }
2462
2463                 if (vol_info && vol_info->posix_paths == 0)
2464                         cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2465                 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2466                         cFYI(1, "negotiate posix pathnames");
2467                         if (sb)
2468                                 CIFS_SB(sb)->mnt_cifs_flags |=
2469                                         CIFS_MOUNT_POSIX_PATHS;
2470                 }
2471
2472                 /* We might be setting the path sep back to a different
2473                 form if we are reconnecting and the server switched its
2474                 posix path capability for this share */
2475                 if (sb && (CIFS_SB(sb)->prepathlen > 0))
2476                         CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
2477
2478                 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
2479                         if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2480                                 CIFS_SB(sb)->rsize = 127 * 1024;
2481                                 cFYI(DBG2, "larger reads not supported by srv");
2482                         }
2483                 }
2484
2485
2486                 cFYI(1, "Negotiate caps 0x%x", (int)cap);
2487 #ifdef CONFIG_CIFS_DEBUG2
2488                 if (cap & CIFS_UNIX_FCNTL_CAP)
2489                         cFYI(1, "FCNTL cap");
2490                 if (cap & CIFS_UNIX_EXTATTR_CAP)
2491                         cFYI(1, "EXTATTR cap");
2492                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2493                         cFYI(1, "POSIX path cap");
2494                 if (cap & CIFS_UNIX_XATTR_CAP)
2495                         cFYI(1, "XATTR cap");
2496                 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
2497                         cFYI(1, "POSIX ACL cap");
2498                 if (cap & CIFS_UNIX_LARGE_READ_CAP)
2499                         cFYI(1, "very large read cap");
2500                 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
2501                         cFYI(1, "very large write cap");
2502 #endif /* CIFS_DEBUG2 */
2503                 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
2504                         if (vol_info == NULL) {
2505                                 cFYI(1, "resetting capabilities failed");
2506                         } else
2507                                 cERROR(1, "Negotiating Unix capabilities "
2508                                            "with the server failed.  Consider "
2509                                            "mounting with the Unix Extensions\n"
2510                                            "disabled, if problems are found, "
2511                                            "by specifying the nounix mount "
2512                                            "option.");
2513
2514                 }
2515         }
2516 }
2517
2518 static void
2519 convert_delimiter(char *path, char delim)
2520 {
2521         int i;
2522         char old_delim;
2523
2524         if (path == NULL)
2525                 return;
2526
2527         if (delim == '/')
2528                 old_delim = '\\';
2529         else
2530                 old_delim = '/';
2531
2532         for (i = 0; path[i] != '\0'; i++) {
2533                 if (path[i] == old_delim)
2534                         path[i] = delim;
2535         }
2536 }
2537
2538 static void setup_cifs_sb(struct smb_vol *pvolume_info,
2539                           struct cifs_sb_info *cifs_sb)
2540 {
2541         INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2542
2543         if (pvolume_info->rsize > CIFSMaxBufSize) {
2544                 cERROR(1, "rsize %d too large, using MaxBufSize",
2545                         pvolume_info->rsize);
2546                 cifs_sb->rsize = CIFSMaxBufSize;
2547         } else if ((pvolume_info->rsize) &&
2548                         (pvolume_info->rsize <= CIFSMaxBufSize))
2549                 cifs_sb->rsize = pvolume_info->rsize;
2550         else /* default */
2551                 cifs_sb->rsize = CIFSMaxBufSize;
2552
2553         if (pvolume_info->wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2554                 cERROR(1, "wsize %d too large, using 4096 instead",
2555                           pvolume_info->wsize);
2556                 cifs_sb->wsize = 4096;
2557         } else if (pvolume_info->wsize)
2558                 cifs_sb->wsize = pvolume_info->wsize;
2559         else
2560                 cifs_sb->wsize = min_t(const int,
2561                                         PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2562                                         127*1024);
2563                 /* old default of CIFSMaxBufSize was too small now
2564                    that SMB Write2 can send multiple pages in kvec.
2565                    RFC1001 does not describe what happens when frame
2566                    bigger than 128K is sent so use that as max in
2567                    conjunction with 52K kvec constraint on arch with 4K
2568                    page size  */
2569
2570         if (cifs_sb->rsize < 2048) {
2571                 cifs_sb->rsize = 2048;
2572                 /* Windows ME may prefer this */
2573                 cFYI(1, "readsize set to minimum: 2048");
2574         }
2575         /* calculate prepath */
2576         cifs_sb->prepath = pvolume_info->prepath;
2577         if (cifs_sb->prepath) {
2578                 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2579                 /* we can not convert the / to \ in the path
2580                 separators in the prefixpath yet because we do not
2581                 know (until reset_cifs_unix_caps is called later)
2582                 whether POSIX PATH CAP is available. We normalize
2583                 the / to \ after reset_cifs_unix_caps is called */
2584                 pvolume_info->prepath = NULL;
2585         } else
2586                 cifs_sb->prepathlen = 0;
2587         cifs_sb->mnt_uid = pvolume_info->linux_uid;
2588         cifs_sb->mnt_gid = pvolume_info->linux_gid;
2589         cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2590         cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
2591         cFYI(1, "file mode: 0x%x  dir mode: 0x%x",
2592                 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
2593
2594         cifs_sb->actimeo = pvolume_info->actimeo;
2595
2596         if (pvolume_info->noperm)
2597                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2598         if (pvolume_info->setuids)
2599                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2600         if (pvolume_info->server_ino)
2601                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2602         if (pvolume_info->remap)
2603                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2604         if (pvolume_info->no_xattr)
2605                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2606         if (pvolume_info->sfu_emul)
2607                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2608         if (pvolume_info->nobrl)
2609                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2610         if (pvolume_info->nostrictsync)
2611                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
2612         if (pvolume_info->mand_lock)
2613                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
2614         if (pvolume_info->cifs_acl)
2615                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2616         if (pvolume_info->override_uid)
2617                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2618         if (pvolume_info->override_gid)
2619                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2620         if (pvolume_info->dynperm)
2621                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2622         if (pvolume_info->fsc)
2623                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
2624         if (pvolume_info->multiuser)
2625                 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
2626                                             CIFS_MOUNT_NO_PERM);
2627         if (pvolume_info->strict_io)
2628                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
2629         if (pvolume_info->direct_io) {
2630                 cFYI(1, "mounting share using direct i/o");
2631                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2632         }
2633         if (pvolume_info->mfsymlinks) {
2634                 if (pvolume_info->sfu_emul) {
2635                         cERROR(1,  "mount option mfsymlinks ignored if sfu "
2636                                    "mount option is used");
2637                 } else {
2638                         cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
2639                 }
2640         }
2641
2642         if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
2643                 cERROR(1, "mount option dynperm ignored if cifsacl "
2644                            "mount option supported");
2645 }
2646
2647 static int
2648 is_path_accessible(int xid, struct cifsTconInfo *tcon,
2649                    struct cifs_sb_info *cifs_sb, const char *full_path)
2650 {
2651         int rc;
2652         FILE_ALL_INFO *pfile_info;
2653
2654         pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2655         if (pfile_info == NULL)
2656                 return -ENOMEM;
2657
2658         rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2659                               0 /* not legacy */, cifs_sb->local_nls,
2660                               cifs_sb->mnt_cifs_flags &
2661                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
2662         kfree(pfile_info);
2663         return rc;
2664 }
2665
2666 static void
2667 cleanup_volume_info(struct smb_vol **pvolume_info)
2668 {
2669         struct smb_vol *volume_info;
2670
2671         if (!pvolume_info || !*pvolume_info)
2672                 return;
2673
2674         volume_info = *pvolume_info;
2675         kzfree(volume_info->password);
2676         kfree(volume_info->UNC);
2677         kfree(volume_info->prepath);
2678         kfree(volume_info);
2679         *pvolume_info = NULL;
2680         return;
2681 }
2682
2683 #ifdef CONFIG_CIFS_DFS_UPCALL
2684 /* build_path_to_root returns full path to root when
2685  * we do not have an exiting connection (tcon) */
2686 static char *
2687 build_unc_path_to_root(const struct smb_vol *volume_info,
2688                 const struct cifs_sb_info *cifs_sb)
2689 {
2690         char *full_path;
2691
2692         int unc_len = strnlen(volume_info->UNC, MAX_TREE_SIZE + 1);
2693         full_path = kmalloc(unc_len + cifs_sb->prepathlen + 1, GFP_KERNEL);
2694         if (full_path == NULL)
2695                 return ERR_PTR(-ENOMEM);
2696
2697         strncpy(full_path, volume_info->UNC, unc_len);
2698         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
2699                 int i;
2700                 for (i = 0; i < unc_len; i++) {
2701                         if (full_path[i] == '\\')
2702                                 full_path[i] = '/';
2703                 }
2704         }
2705
2706         if (cifs_sb->prepathlen)
2707                 strncpy(full_path + unc_len, cifs_sb->prepath,
2708                                 cifs_sb->prepathlen);
2709
2710         full_path[unc_len + cifs_sb->prepathlen] = 0; /* add trailing null */
2711         return full_path;
2712 }
2713 #endif
2714
2715 int
2716 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
2717                 char *mount_data_global, const char *devname)
2718 {
2719         int rc;
2720         int xid;
2721         struct smb_vol *volume_info;
2722         struct cifsSesInfo *pSesInfo;
2723         struct cifsTconInfo *tcon;
2724         struct TCP_Server_Info *srvTcp;
2725         char   *full_path;
2726         char *mount_data = mount_data_global;
2727         struct tcon_link *tlink;
2728 #ifdef CONFIG_CIFS_DFS_UPCALL
2729         struct dfs_info3_param *referrals = NULL;
2730         unsigned int num_referrals = 0;
2731         int referral_walks_count = 0;
2732 try_mount_again:
2733 #endif
2734         rc = 0;
2735         tcon = NULL;
2736         pSesInfo = NULL;
2737         srvTcp = NULL;
2738         full_path = NULL;
2739         tlink = NULL;
2740
2741         xid = GetXid();
2742
2743         volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
2744         if (!volume_info) {
2745                 rc = -ENOMEM;
2746                 goto out;
2747         }
2748
2749         if (cifs_parse_mount_options(mount_data, devname, volume_info)) {
2750                 rc = -EINVAL;
2751                 goto out;
2752         }
2753
2754         if (volume_info->nullauth) {
2755                 cFYI(1, "null user");
2756                 volume_info->username = "";
2757         } else if (volume_info->username) {
2758                 /* BB fixme parse for domain name here */
2759                 cFYI(1, "Username: %s", volume_info->username);
2760         } else {
2761                 cifserror("No username specified");
2762         /* In userspace mount helper we can get user name from alternate
2763            locations such as env variables and files on disk */
2764                 rc = -EINVAL;
2765                 goto out;
2766         }
2767
2768         /* this is needed for ASCII cp to Unicode converts */
2769         if (volume_info->iocharset == NULL) {
2770                 /* load_nls_default cannot return null */
2771                 volume_info->local_nls = load_nls_default();
2772         } else {
2773                 volume_info->local_nls = load_nls(volume_info->iocharset);
2774                 if (volume_info->local_nls == NULL) {
2775                         cERROR(1, "CIFS mount error: iocharset %s not found",
2776                                  volume_info->iocharset);
2777                         rc = -ELIBACC;
2778                         goto out;
2779                 }
2780         }
2781         cifs_sb->local_nls = volume_info->local_nls;
2782
2783         /* get a reference to a tcp session */
2784         srvTcp = cifs_get_tcp_session(volume_info);
2785         if (IS_ERR(srvTcp)) {
2786                 rc = PTR_ERR(srvTcp);
2787                 goto out;
2788         }
2789
2790         /* get a reference to a SMB session */
2791         pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
2792         if (IS_ERR(pSesInfo)) {
2793                 rc = PTR_ERR(pSesInfo);
2794                 pSesInfo = NULL;
2795                 goto mount_fail_check;
2796         }
2797
2798         setup_cifs_sb(volume_info, cifs_sb);
2799         if (pSesInfo->capabilities & CAP_LARGE_FILES)
2800                 sb->s_maxbytes = MAX_LFS_FILESIZE;
2801         else
2802                 sb->s_maxbytes = MAX_NON_LFS;
2803
2804         /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2805         sb->s_time_gran = 100;
2806
2807         /* search for existing tcon to this server share */
2808         tcon = cifs_get_tcon(pSesInfo, volume_info);
2809         if (IS_ERR(tcon)) {
2810                 rc = PTR_ERR(tcon);
2811                 tcon = NULL;
2812                 goto remote_path_check;
2813         }
2814
2815         /* do not care if following two calls succeed - informational */
2816         if (!tcon->ipc) {
2817                 CIFSSMBQFSDeviceInfo(xid, tcon);
2818                 CIFSSMBQFSAttributeInfo(xid, tcon);
2819         }
2820
2821         /* tell server which Unix caps we support */
2822         if (tcon->ses->capabilities & CAP_UNIX)
2823                 /* reset of caps checks mount to see if unix extensions
2824                    disabled for just this mount */
2825                 reset_cifs_unix_caps(xid, tcon, sb, volume_info);
2826         else
2827                 tcon->unix_ext = 0; /* server does not support them */
2828
2829         /* convert forward to back slashes in prepath here if needed */
2830         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2831                 convert_delimiter(cifs_sb->prepath, CIFS_DIR_SEP(cifs_sb));
2832
2833         if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2834                 cifs_sb->rsize = 1024 * 127;
2835                 cFYI(DBG2, "no very large read support, rsize now 127K");
2836         }
2837         if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2838                 cifs_sb->wsize = min(cifs_sb->wsize,
2839                                (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2840         if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2841                 cifs_sb->rsize = min(cifs_sb->rsize,
2842                                (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2843
2844 remote_path_check:
2845         /* check if a whole path (including prepath) is not remote */
2846         if (!rc && tcon) {
2847                 /* build_path_to_root works only when we have a valid tcon */
2848                 full_path = cifs_build_path_to_root(cifs_sb, tcon);
2849                 if (full_path == NULL) {
2850                         rc = -ENOMEM;
2851                         goto mount_fail_check;
2852                 }
2853                 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
2854                 if (rc != 0 && rc != -EREMOTE) {
2855                         kfree(full_path);
2856                         goto mount_fail_check;
2857                 }
2858                 kfree(full_path);
2859         }
2860
2861         /* get referral if needed */
2862         if (rc == -EREMOTE) {
2863 #ifdef CONFIG_CIFS_DFS_UPCALL
2864                 if (referral_walks_count > MAX_NESTED_LINKS) {
2865                         /*
2866                          * BB: when we implement proper loop detection,
2867                          *     we will remove this check. But now we need it
2868                          *     to prevent an indefinite loop if 'DFS tree' is
2869                          *     misconfigured (i.e. has loops).
2870                          */
2871                         rc = -ELOOP;
2872                         goto mount_fail_check;
2873                 }
2874                 /* convert forward to back slashes in prepath here if needed */
2875                 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2876                         convert_delimiter(cifs_sb->prepath,
2877                                         CIFS_DIR_SEP(cifs_sb));
2878                 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2879                 if (IS_ERR(full_path)) {
2880                         rc = PTR_ERR(full_path);
2881                         goto mount_fail_check;
2882                 }
2883
2884                 cFYI(1, "Getting referral for: %s", full_path);
2885                 rc = get_dfs_path(xid, pSesInfo , full_path + 1,
2886                         cifs_sb->local_nls, &num_referrals, &referrals,
2887                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2888                 if (!rc && num_referrals > 0) {
2889                         char *fake_devname = NULL;
2890
2891                         if (mount_data != mount_data_global)
2892                                 kfree(mount_data);
2893
2894                         mount_data = cifs_compose_mount_options(
2895                                         cifs_sb->mountdata, full_path + 1,
2896                                         referrals, &fake_devname);
2897
2898                         free_dfs_info_array(referrals, num_referrals);
2899                         kfree(fake_devname);
2900                         kfree(full_path);
2901
2902                         if (IS_ERR(mount_data)) {
2903                                 rc = PTR_ERR(mount_data);
2904                                 mount_data = NULL;
2905                                 goto mount_fail_check;
2906                         }
2907
2908                         if (tcon)
2909                                 cifs_put_tcon(tcon);
2910                         else if (pSesInfo)
2911                                 cifs_put_smb_ses(pSesInfo);
2912
2913                         cleanup_volume_info(&volume_info);
2914                         referral_walks_count++;
2915                         FreeXid(xid);
2916                         goto try_mount_again;
2917                 }
2918 #else /* No DFS support, return error on mount */
2919                 rc = -EOPNOTSUPP;
2920 #endif
2921         }
2922
2923         if (rc)
2924                 goto mount_fail_check;
2925
2926         /* now, hang the tcon off of the superblock */
2927         tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
2928         if (tlink == NULL) {
2929                 rc = -ENOMEM;
2930                 goto mount_fail_check;
2931         }
2932
2933         tlink->tl_uid = pSesInfo->linux_uid;
2934         tlink->tl_tcon = tcon;
2935         tlink->tl_time = jiffies;
2936         set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
2937         set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
2938
2939         cifs_sb->master_tlink = tlink;
2940         spin_lock(&cifs_sb->tlink_tree_lock);
2941         tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
2942         spin_unlock(&cifs_sb->tlink_tree_lock);
2943
2944         queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
2945                                 TLINK_IDLE_EXPIRE);
2946
2947 mount_fail_check:
2948         /* on error free sesinfo and tcon struct if needed */
2949         if (rc) {
2950                 if (mount_data != mount_data_global)
2951                         kfree(mount_data);
2952                 /* If find_unc succeeded then rc == 0 so we can not end */
2953                 /* up accidentally freeing someone elses tcon struct */
2954                 if (tcon)
2955                         cifs_put_tcon(tcon);
2956                 else if (pSesInfo)
2957                         cifs_put_smb_ses(pSesInfo);
2958                 else
2959                         cifs_put_tcp_session(srvTcp);
2960                 goto out;
2961         }
2962
2963         /* volume_info->password is freed above when existing session found
2964         (in which case it is not needed anymore) but when new sesion is created
2965         the password ptr is put in the new session structure (in which case the
2966         password will be freed at unmount time) */
2967 out:
2968         /* zero out password before freeing */
2969         cleanup_volume_info(&volume_info);
2970         FreeXid(xid);
2971         return rc;
2972 }
2973
2974 int
2975 CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
2976          const char *tree, struct cifsTconInfo *tcon,
2977          const struct nls_table *nls_codepage)
2978 {
2979         struct smb_hdr *smb_buffer;
2980         struct smb_hdr *smb_buffer_response;
2981         TCONX_REQ *pSMB;
2982         TCONX_RSP *pSMBr;
2983         unsigned char *bcc_ptr;
2984         int rc = 0;
2985         int length;
2986         __u16 bytes_left, count;
2987
2988         if (ses == NULL)
2989                 return -EIO;
2990
2991         smb_buffer = cifs_buf_get();
2992         if (smb_buffer == NULL)
2993                 return -ENOMEM;
2994
2995         smb_buffer_response = smb_buffer;
2996
2997         header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
2998                         NULL /*no tid */ , 4 /*wct */ );
2999
3000         smb_buffer->Mid = GetNextMid(ses->server);
3001         smb_buffer->Uid = ses->Suid;
3002         pSMB = (TCONX_REQ *) smb_buffer;
3003         pSMBr = (TCONX_RSP *) smb_buffer_response;
3004
3005         pSMB->AndXCommand = 0xFF;
3006         pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3007         bcc_ptr = &pSMB->Password[0];
3008         if ((ses->server->secMode) & SECMODE_USER) {
3009                 pSMB->PasswordLength = cpu_to_le16(1);  /* minimum */
3010                 *bcc_ptr = 0; /* password is null byte */
3011                 bcc_ptr++;              /* skip password */
3012                 /* already aligned so no need to do it below */
3013         } else {
3014                 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3015                 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3016                    specified as required (when that support is added to
3017                    the vfs in the future) as only NTLM or the much
3018                    weaker LANMAN (which we do not send by default) is accepted
3019                    by Samba (not sure whether other servers allow
3020                    NTLMv2 password here) */
3021 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3022                 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3023                     (ses->server->secType == LANMAN))
3024                         calc_lanman_hash(tcon->password, ses->server->cryptkey,
3025                                          ses->server->secMode &
3026                                             SECMODE_PW_ENCRYPT ? true : false,
3027                                          bcc_ptr);
3028                 else
3029 #endif /* CIFS_WEAK_PW_HASH */
3030                 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3031                                         bcc_ptr);
3032
3033                 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3034                 if (ses->capabilities & CAP_UNICODE) {
3035                         /* must align unicode strings */
3036                         *bcc_ptr = 0; /* null byte password */
3037                         bcc_ptr++;
3038                 }
3039         }
3040
3041         if (ses->server->secMode &
3042                         (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3043                 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3044
3045         if (ses->capabilities & CAP_STATUS32) {
3046                 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3047         }
3048         if (ses->capabilities & CAP_DFS) {
3049                 smb_buffer->Flags2 |= SMBFLG2_DFS;
3050         }
3051         if (ses->capabilities & CAP_UNICODE) {
3052                 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3053                 length =
3054                     cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3055                         6 /* max utf8 char length in bytes */ *
3056                         (/* server len*/ + 256 /* share len */), nls_codepage);
3057                 bcc_ptr += 2 * length;  /* convert num 16 bit words to bytes */
3058                 bcc_ptr += 2;   /* skip trailing null */
3059         } else {                /* ASCII */
3060                 strcpy(bcc_ptr, tree);
3061                 bcc_ptr += strlen(tree) + 1;
3062         }
3063         strcpy(bcc_ptr, "?????");
3064         bcc_ptr += strlen("?????");
3065         bcc_ptr += 1;
3066         count = bcc_ptr - &pSMB->Password[0];
3067         pSMB->hdr.smb_buf_length += count;
3068         pSMB->ByteCount = cpu_to_le16(count);
3069
3070         rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3071                          0);
3072
3073         /* above now done in SendReceive */
3074         if ((rc == 0) && (tcon != NULL)) {
3075                 bool is_unicode;
3076
3077                 tcon->tidStatus = CifsGood;
3078                 tcon->need_reconnect = false;
3079                 tcon->tid = smb_buffer_response->Tid;
3080                 bcc_ptr = pByteArea(smb_buffer_response);
3081                 bytes_left = get_bcc(smb_buffer_response);
3082                 length = strnlen(bcc_ptr, bytes_left - 2);
3083                 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3084                         is_unicode = true;
3085                 else
3086                         is_unicode = false;
3087
3088
3089                 /* skip service field (NB: this field is always ASCII) */
3090                 if (length == 3) {
3091                         if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3092                             (bcc_ptr[2] == 'C')) {
3093                                 cFYI(1, "IPC connection");
3094                                 tcon->ipc = 1;
3095                         }
3096                 } else if (length == 2) {
3097                         if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3098                                 /* the most common case */
3099                                 cFYI(1, "disk share connection");
3100                         }
3101                 }
3102                 bcc_ptr += length + 1;
3103                 bytes_left -= (length + 1);
3104                 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3105
3106                 /* mostly informational -- no need to fail on error here */
3107                 kfree(tcon->nativeFileSystem);
3108                 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
3109                                                       bytes_left, is_unicode,
3110                                                       nls_codepage);
3111
3112                 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
3113
3114                 if ((smb_buffer_response->WordCount == 3) ||
3115                          (smb_buffer_response->WordCount == 7))
3116                         /* field is in same location */
3117                         tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3118                 else
3119                         tcon->Flags = 0;
3120                 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
3121         } else if ((rc == 0) && tcon == NULL) {
3122                 /* all we need to save for IPC$ connection */
3123                 ses->ipc_tid = smb_buffer_response->Tid;
3124         }
3125
3126         cifs_buf_release(smb_buffer);
3127         return rc;
3128 }
3129
3130 int
3131 cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3132 {
3133         struct rb_root *root = &cifs_sb->tlink_tree;
3134         struct rb_node *node;
3135         struct tcon_link *tlink;
3136         char *tmp;
3137
3138         cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3139
3140         spin_lock(&cifs_sb->tlink_tree_lock);
3141         while ((node = rb_first(root))) {
3142                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3143                 cifs_get_tlink(tlink);
3144                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3145                 rb_erase(node, root);
3146
3147                 spin_unlock(&cifs_sb->tlink_tree_lock);
3148                 cifs_put_tlink(tlink);
3149                 spin_lock(&cifs_sb->tlink_tree_lock);
3150         }
3151         spin_unlock(&cifs_sb->tlink_tree_lock);
3152
3153         tmp = cifs_sb->prepath;
3154         cifs_sb->prepathlen = 0;
3155         cifs_sb->prepath = NULL;
3156         kfree(tmp);
3157
3158         return 0;
3159 }
3160
3161 int cifs_negotiate_protocol(unsigned int xid, struct cifsSesInfo *ses)
3162 {
3163         int rc = 0;
3164         struct TCP_Server_Info *server = ses->server;
3165
3166         /* only send once per connect */
3167         if (server->maxBuf != 0)
3168                 return 0;
3169
3170         rc = CIFSSMBNegotiate(xid, ses);
3171         if (rc == -EAGAIN) {
3172                 /* retry only once on 1st time connection */
3173                 rc = CIFSSMBNegotiate(xid, ses);
3174                 if (rc == -EAGAIN)
3175                         rc = -EHOSTDOWN;
3176         }
3177         if (rc == 0) {
3178                 spin_lock(&GlobalMid_Lock);
3179                 if (server->tcpStatus != CifsExiting)
3180                         server->tcpStatus = CifsGood;
3181                 else
3182                         rc = -EHOSTDOWN;
3183                 spin_unlock(&GlobalMid_Lock);
3184
3185         }
3186
3187         return rc;
3188 }
3189
3190
3191 int cifs_setup_session(unsigned int xid, struct cifsSesInfo *ses,
3192                         struct nls_table *nls_info)
3193 {
3194         int rc = 0;
3195         struct TCP_Server_Info *server = ses->server;
3196
3197         ses->flags = 0;
3198         ses->capabilities = server->capabilities;
3199         if (linuxExtEnabled == 0)
3200                 ses->capabilities &= (~CAP_UNIX);
3201
3202         cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3203                  server->secMode, server->capabilities, server->timeAdj);
3204
3205         rc = CIFS_SessSetup(xid, ses, nls_info);
3206         if (rc) {
3207                 cERROR(1, "Send error in SessSetup = %d", rc);
3208         } else {
3209                 mutex_lock(&ses->server->srv_mutex);
3210                 if (!server->session_estab) {
3211                         server->session_key.response = ses->auth_key.response;
3212                         server->session_key.len = ses->auth_key.len;
3213                         server->sequence_number = 0x2;
3214                         server->session_estab = true;
3215                         ses->auth_key.response = NULL;
3216                 }
3217                 mutex_unlock(&server->srv_mutex);
3218
3219                 cFYI(1, "CIFS Session Established successfully");
3220                 spin_lock(&GlobalMid_Lock);
3221                 ses->status = CifsGood;
3222                 ses->need_reconnect = false;
3223                 spin_unlock(&GlobalMid_Lock);
3224         }
3225
3226         kfree(ses->auth_key.response);
3227         ses->auth_key.response = NULL;
3228         ses->auth_key.len = 0;
3229         kfree(ses->ntlmssp);
3230         ses->ntlmssp = NULL;
3231
3232         return rc;
3233 }
3234
3235 static struct cifsTconInfo *
3236 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3237 {
3238         struct cifsTconInfo *master_tcon = cifs_sb_master_tcon(cifs_sb);
3239         struct cifsSesInfo *ses;
3240         struct cifsTconInfo *tcon = NULL;
3241         struct smb_vol *vol_info;
3242         char username[MAX_USERNAME_SIZE + 1];
3243
3244         vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3245         if (vol_info == NULL) {
3246                 tcon = ERR_PTR(-ENOMEM);
3247                 goto out;
3248         }
3249
3250         snprintf(username, MAX_USERNAME_SIZE, "krb50x%x", fsuid);
3251         vol_info->username = username;
3252         vol_info->local_nls = cifs_sb->local_nls;
3253         vol_info->linux_uid = fsuid;
3254         vol_info->cred_uid = fsuid;
3255         vol_info->UNC = master_tcon->treeName;
3256         vol_info->retry = master_tcon->retry;
3257         vol_info->nocase = master_tcon->nocase;
3258         vol_info->local_lease = master_tcon->local_lease;
3259         vol_info->no_linux_ext = !master_tcon->unix_ext;
3260
3261         /* FIXME: allow for other secFlg settings */
3262         vol_info->secFlg = CIFSSEC_MUST_KRB5;
3263
3264         /* get a reference for the same TCP session */
3265         spin_lock(&cifs_tcp_ses_lock);
3266         ++master_tcon->ses->server->srv_count;
3267         spin_unlock(&cifs_tcp_ses_lock);
3268
3269         ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3270         if (IS_ERR(ses)) {
3271                 tcon = (struct cifsTconInfo *)ses;
3272                 cifs_put_tcp_session(master_tcon->ses->server);
3273                 goto out;
3274         }
3275
3276         tcon = cifs_get_tcon(ses, vol_info);
3277         if (IS_ERR(tcon)) {
3278                 cifs_put_smb_ses(ses);
3279                 goto out;
3280         }
3281
3282         if (ses->capabilities & CAP_UNIX)
3283                 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3284 out:
3285         kfree(vol_info);
3286
3287         return tcon;
3288 }
3289
3290 static inline struct tcon_link *
3291 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
3292 {
3293         return cifs_sb->master_tlink;
3294 }
3295
3296 struct cifsTconInfo *
3297 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3298 {
3299         return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3300 }
3301
3302 static int
3303 cifs_sb_tcon_pending_wait(void *unused)
3304 {
3305         schedule();
3306         return signal_pending(current) ? -ERESTARTSYS : 0;
3307 }
3308
3309 /* find and return a tlink with given uid */
3310 static struct tcon_link *
3311 tlink_rb_search(struct rb_root *root, uid_t uid)
3312 {
3313         struct rb_node *node = root->rb_node;
3314         struct tcon_link *tlink;
3315
3316         while (node) {
3317                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3318
3319                 if (tlink->tl_uid > uid)
3320                         node = node->rb_left;
3321                 else if (tlink->tl_uid < uid)
3322                         node = node->rb_right;
3323                 else
3324                         return tlink;
3325         }
3326         return NULL;
3327 }
3328
3329 /* insert a tcon_link into the tree */
3330 static void
3331 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3332 {
3333         struct rb_node **new = &(root->rb_node), *parent = NULL;
3334         struct tcon_link *tlink;
3335
3336         while (*new) {
3337                 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3338                 parent = *new;
3339
3340                 if (tlink->tl_uid > new_tlink->tl_uid)
3341                         new = &((*new)->rb_left);
3342                 else
3343                         new = &((*new)->rb_right);
3344         }
3345
3346         rb_link_node(&new_tlink->tl_rbnode, parent, new);
3347         rb_insert_color(&new_tlink->tl_rbnode, root);
3348 }
3349
3350 /*
3351  * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3352  * current task.
3353  *
3354  * If the superblock doesn't refer to a multiuser mount, then just return
3355  * the master tcon for the mount.
3356  *
3357  * First, search the rbtree for an existing tcon for this fsuid. If one
3358  * exists, then check to see if it's pending construction. If it is then wait
3359  * for construction to complete. Once it's no longer pending, check to see if
3360  * it failed and either return an error or retry construction, depending on
3361  * the timeout.
3362  *
3363  * If one doesn't exist then insert a new tcon_link struct into the tree and
3364  * try to construct a new one.
3365  */
3366 struct tcon_link *
3367 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3368 {
3369         int ret;
3370         uid_t fsuid = current_fsuid();
3371         struct tcon_link *tlink, *newtlink;
3372
3373         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3374                 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3375
3376         spin_lock(&cifs_sb->tlink_tree_lock);
3377         tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3378         if (tlink)
3379                 cifs_get_tlink(tlink);
3380         spin_unlock(&cifs_sb->tlink_tree_lock);
3381
3382         if (tlink == NULL) {
3383                 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3384                 if (newtlink == NULL)
3385                         return ERR_PTR(-ENOMEM);
3386                 newtlink->tl_uid = fsuid;
3387                 newtlink->tl_tcon = ERR_PTR(-EACCES);
3388                 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3389                 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3390                 cifs_get_tlink(newtlink);
3391
3392                 spin_lock(&cifs_sb->tlink_tree_lock);
3393                 /* was one inserted after previous search? */
3394                 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3395                 if (tlink) {
3396                         cifs_get_tlink(tlink);
3397                         spin_unlock(&cifs_sb->tlink_tree_lock);
3398                         kfree(newtlink);
3399                         goto wait_for_construction;
3400                 }
3401                 tlink = newtlink;
3402                 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3403                 spin_unlock(&cifs_sb->tlink_tree_lock);
3404         } else {
3405 wait_for_construction:
3406                 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
3407                                   cifs_sb_tcon_pending_wait,
3408                                   TASK_INTERRUPTIBLE);
3409                 if (ret) {
3410                         cifs_put_tlink(tlink);
3411                         return ERR_PTR(ret);
3412                 }
3413
3414                 /* if it's good, return it */
3415                 if (!IS_ERR(tlink->tl_tcon))
3416                         return tlink;
3417
3418                 /* return error if we tried this already recently */
3419                 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
3420                         cifs_put_tlink(tlink);
3421                         return ERR_PTR(-EACCES);
3422                 }
3423
3424                 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
3425                         goto wait_for_construction;
3426         }
3427
3428         tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
3429         clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
3430         wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
3431
3432         if (IS_ERR(tlink->tl_tcon)) {
3433                 cifs_put_tlink(tlink);
3434                 return ERR_PTR(-EACCES);
3435         }
3436
3437         return tlink;
3438 }
3439
3440 /*
3441  * periodic workqueue job that scans tcon_tree for a superblock and closes
3442  * out tcons.
3443  */
3444 static void
3445 cifs_prune_tlinks(struct work_struct *work)
3446 {
3447         struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
3448                                                     prune_tlinks.work);
3449         struct rb_root *root = &cifs_sb->tlink_tree;
3450         struct rb_node *node = rb_first(root);
3451         struct rb_node *tmp;
3452         struct tcon_link *tlink;
3453
3454         /*
3455          * Because we drop the spinlock in the loop in order to put the tlink
3456          * it's not guarded against removal of links from the tree. The only
3457          * places that remove entries from the tree are this function and
3458          * umounts. Because this function is non-reentrant and is canceled
3459          * before umount can proceed, this is safe.
3460          */
3461         spin_lock(&cifs_sb->tlink_tree_lock);
3462         node = rb_first(root);
3463         while (node != NULL) {
3464                 tmp = node;
3465                 node = rb_next(tmp);
3466                 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
3467
3468                 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
3469                     atomic_read(&tlink->tl_count) != 0 ||
3470                     time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
3471                         continue;
3472
3473                 cifs_get_tlink(tlink);
3474                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3475                 rb_erase(tmp, root);
3476
3477                 spin_unlock(&cifs_sb->tlink_tree_lock);
3478                 cifs_put_tlink(tlink);
3479                 spin_lock(&cifs_sb->tlink_tree_lock);
3480         }
3481         spin_unlock(&cifs_sb->tlink_tree_lock);
3482
3483         queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
3484                                 TLINK_IDLE_EXPIRE);
3485 }