fs/cifs/connect.c

   1 /*
   2  *   fs/cifs/connect.c
   3  *
   4  *   Copyright (C) International Business Machines  Corp., 2002,2011
   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/sched/mm.h>
  25 #include <linux/sched/signal.h>
  26 #include <linux/list.h>
  27 #include <linux/wait.h>
  28 #include <linux/slab.h>
  29 #include <linux/pagemap.h>
  30 #include <linux/ctype.h>
  31 #include <linux/utsname.h>
  32 #include <linux/mempool.h>
  33 #include <linux/delay.h>
  34 #include <linux/completion.h>
  35 #include <linux/kthread.h>
  36 #include <linux/pagevec.h>
  37 #include <linux/freezer.h>
  38 #include <linux/namei.h>
  39 #include <linux/uuid.h>
  40 #include <linux/uaccess.h>
  41 #include <asm/processor.h>
  42 #include <linux/inet.h>
  43 #include <linux/module.h>
  44 #include <keys/user-type.h>
  45 #include <net/ipv6.h>
  46 #include <linux/parser.h>
  47 #include <linux/bvec.h>
  48 #include "cifspdu.h"
  49 #include "cifsglob.h"
  50 #include "cifsproto.h"
  51 #include "cifs_unicode.h"
  52 #include "cifs_debug.h"
  53 #include "cifs_fs_sb.h"
  54 #include "ntlmssp.h"
  55 #include "nterr.h"
  56 #include "rfc1002pdu.h"
  57 #include "fscache.h"
  58 #include "smb2proto.h"
  59 #include "smbdirect.h"
  60 #include "dns_resolve.h"
  61 #ifdef CONFIG_CIFS_DFS_UPCALL
  62 #include "dfs_cache.h"
  63 #endif
  64 #include "fs_context.h"
  65 #ifdef CONFIG_CIFS_SWN_UPCALL
  66 #include "cifs_swn.h"
  67 #endif
  68
  69 extern mempool_t *cifs_req_poolp;
  70 extern bool disable_legacy_dialects;
  71
  72 /* FIXME: should these be tunable? */
  73 #define TLINK_ERROR_EXPIRE      (1 * HZ)
  74 #define TLINK_IDLE_EXPIRE       (600 * HZ)
  75
  76 /* Drop the connection to not overload the server */
  77 #define NUM_STATUS_IO_TIMEOUT   5
  78
  79 static int ip_connect(struct TCP_Server_Info *server);
  80 static int generic_ip_connect(struct TCP_Server_Info *server);
  81 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
  82 static void cifs_prune_tlinks(struct work_struct *work);
  83
  84 /*
  85  * Resolve hostname and set ip addr in tcp ses. Useful for hostnames that may
  86  * get their ip addresses changed at some point.
  87  *
  88  * This should be called with server->srv_mutex held.
  89  */
  90 #ifdef CONFIG_CIFS_DFS_UPCALL
  91 static int reconn_set_ipaddr_from_hostname(struct TCP_Server_Info *server)
  92 {
  93         int rc;
  94         int len;
  95         char *unc, *ipaddr = NULL;
  96
  97         if (!server->hostname)
  98                 return -EINVAL;
  99
 100         len = strlen(server->hostname) + 3;
 101
 102         unc = kmalloc(len, GFP_KERNEL);
 103         if (!unc) {
 104                 cifs_dbg(FYI, "%s: failed to create UNC path\n", __func__);
 105                 return -ENOMEM;
 106         }
 107         scnprintf(unc, len, "\\\\%s", server->hostname);
 108
 109         rc = dns_resolve_server_name_to_ip(unc, &ipaddr);
 110         kfree(unc);
 111
 112         if (rc < 0) {
 113                 cifs_dbg(FYI, "%s: failed to resolve server part of %s to IP: %d\n",
 114                          __func__, server->hostname, rc);
 115                 return rc;
 116         }
 117
 118         spin_lock(&cifs_tcp_ses_lock);
 119         rc = cifs_convert_address((struct sockaddr *)&server->dstaddr, ipaddr,
 120                                   strlen(ipaddr));
 121         spin_unlock(&cifs_tcp_ses_lock);
 122         kfree(ipaddr);
 123
 124         return !rc ? -1 : 0;
 125 }
 126
 127 /* These functions must be called with server->srv_mutex held */
 128 static void reconn_set_next_dfs_target(struct TCP_Server_Info *server,
 129                                        struct cifs_sb_info *cifs_sb,
 130                                        struct dfs_cache_tgt_list *tgt_list,
 131                                        struct dfs_cache_tgt_iterator **tgt_it)
 132 {
 133         const char *name;
 134         int rc;
 135
 136         if (!cifs_sb || !cifs_sb->origin_fullpath)
 137                 return;
 138
 139         if (!*tgt_it) {
 140                 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
 141         } else {
 142                 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
 143                 if (!*tgt_it)
 144                         *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
 145         }
 146
 147         cifs_dbg(FYI, "%s: UNC: %s\n", __func__, cifs_sb->origin_fullpath);
 148
 149         name = dfs_cache_get_tgt_name(*tgt_it);
 150
 151         kfree(server->hostname);
 152
 153         server->hostname = extract_hostname(name);
 154         if (IS_ERR(server->hostname)) {
 155                 cifs_dbg(FYI,
 156                          "%s: failed to extract hostname from target: %ld\n",
 157                          __func__, PTR_ERR(server->hostname));
 158                 return;
 159         }
 160
 161         rc = reconn_set_ipaddr_from_hostname(server);
 162         if (rc) {
 163                 cifs_dbg(FYI, "%s: failed to resolve hostname: %d\n",
 164                          __func__, rc);
 165         }
 166 }
 167
 168 static inline int reconn_setup_dfs_targets(struct cifs_sb_info *cifs_sb,
 169                                            struct dfs_cache_tgt_list *tl)
 170 {
 171         if (!cifs_sb->origin_fullpath)
 172                 return -EOPNOTSUPP;
 173         return dfs_cache_noreq_find(cifs_sb->origin_fullpath + 1, NULL, tl);
 174 }
 175 #endif
 176
 177 /*
 178  * cifs tcp session reconnection
 179  *
 180  * mark tcp session as reconnecting so temporarily locked
 181  * mark all smb sessions as reconnecting for tcp session
 182  * reconnect tcp session
 183  * wake up waiters on reconnection? - (not needed currently)
 184  */
 185 int
 186 cifs_reconnect(struct TCP_Server_Info *server)
 187 {
 188         int rc = 0;
 189         struct list_head *tmp, *tmp2;
 190         struct cifs_ses *ses;
 191         struct cifs_tcon *tcon;
 192         struct mid_q_entry *mid_entry;
 193         struct list_head retry_list;
 194 #ifdef CONFIG_CIFS_DFS_UPCALL
 195         struct super_block *sb = NULL;
 196         struct cifs_sb_info *cifs_sb = NULL;
 197         struct dfs_cache_tgt_list tgt_list = {0};
 198         struct dfs_cache_tgt_iterator *tgt_it = NULL;
 199 #endif
 200
 201         spin_lock(&GlobalMid_Lock);
 202         server->nr_targets = 1;
 203 #ifdef CONFIG_CIFS_DFS_UPCALL
 204         spin_unlock(&GlobalMid_Lock);
 205         sb = cifs_get_tcp_super(server);
 206         if (IS_ERR(sb)) {
 207                 rc = PTR_ERR(sb);
 208                 cifs_dbg(FYI, "%s: will not do DFS failover: rc = %d\n",
 209                          __func__, rc);
 210                 sb = NULL;
 211         } else {
 212                 cifs_sb = CIFS_SB(sb);
 213                 rc = reconn_setup_dfs_targets(cifs_sb, &tgt_list);
 214                 if (rc) {
 215                         cifs_sb = NULL;
 216                         if (rc != -EOPNOTSUPP) {
 217                                 cifs_server_dbg(VFS, "%s: no target servers for DFS failover\n",
 218                                                 __func__);
 219                         }
 220                 } else {
 221                         server->nr_targets = dfs_cache_get_nr_tgts(&tgt_list);
 222                 }
 223         }
 224         cifs_dbg(FYI, "%s: will retry %d target(s)\n", __func__,
 225                  server->nr_targets);
 226         spin_lock(&GlobalMid_Lock);
 227 #endif
 228         if (server->tcpStatus == CifsExiting) {
 229                 /* the demux thread will exit normally
 230                 next time through the loop */
 231                 spin_unlock(&GlobalMid_Lock);
 232 #ifdef CONFIG_CIFS_DFS_UPCALL
 233                 dfs_cache_free_tgts(&tgt_list);
 234                 cifs_put_tcp_super(sb);
 235 #endif
 236                 wake_up(&server->response_q);
 237                 return rc;
 238         } else
 239                 server->tcpStatus = CifsNeedReconnect;
 240         spin_unlock(&GlobalMid_Lock);
 241         server->maxBuf = 0;
 242         server->max_read = 0;
 243
 244         cifs_dbg(FYI, "Mark tcp session as need reconnect\n");
 245         trace_smb3_reconnect(server->CurrentMid, server->conn_id, server->hostname);
 246
 247         /* before reconnecting the tcp session, mark the smb session (uid)
 248                 and the tid bad so they are not used until reconnected */
 249         cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
 250                  __func__);
 251         spin_lock(&cifs_tcp_ses_lock);
 252         list_for_each(tmp, &server->smb_ses_list) {
 253                 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
 254                 ses->need_reconnect = true;
 255                 list_for_each(tmp2, &ses->tcon_list) {
 256                         tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
 257                         tcon->need_reconnect = true;
 258                 }
 259                 if (ses->tcon_ipc)
 260                         ses->tcon_ipc->need_reconnect = true;
 261         }
 262         spin_unlock(&cifs_tcp_ses_lock);
 263
 264         /* do not want to be sending data on a socket we are freeing */
 265         cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
 266         mutex_lock(&server->srv_mutex);
 267         if (server->ssocket) {
 268                 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
 269                          server->ssocket->state, server->ssocket->flags);
 270                 kernel_sock_shutdown(server->ssocket, SHUT_WR);
 271                 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
 272                          server->ssocket->state, server->ssocket->flags);
 273                 sock_release(server->ssocket);
 274                 server->ssocket = NULL;
 275         }
 276         server->sequence_number = 0;
 277         server->session_estab = false;
 278         kfree(server->session_key.response);
 279         server->session_key.response = NULL;
 280         server->session_key.len = 0;
 281         server->lstrp = jiffies;
 282
 283         /* mark submitted MIDs for retry and issue callback */
 284         INIT_LIST_HEAD(&retry_list);
 285         cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
 286         spin_lock(&GlobalMid_Lock);
 287         list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 288                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 289                 kref_get(&mid_entry->refcount);
 290                 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
 291                         mid_entry->mid_state = MID_RETRY_NEEDED;
 292                 list_move(&mid_entry->qhead, &retry_list);
 293                 mid_entry->mid_flags |= MID_DELETED;
 294         }
 295         spin_unlock(&GlobalMid_Lock);
 296         mutex_unlock(&server->srv_mutex);
 297
 298         cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
 299         list_for_each_safe(tmp, tmp2, &retry_list) {
 300                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 301                 list_del_init(&mid_entry->qhead);
 302                 mid_entry->callback(mid_entry);
 303                 cifs_mid_q_entry_release(mid_entry);
 304         }
 305
 306         if (cifs_rdma_enabled(server)) {
 307                 mutex_lock(&server->srv_mutex);
 308                 smbd_destroy(server);
 309                 mutex_unlock(&server->srv_mutex);
 310         }
 311
 312         do {
 313                 try_to_freeze();
 314
 315                 mutex_lock(&server->srv_mutex);
 316
 317 #ifdef CONFIG_CIFS_SWN_UPCALL
 318                 if (server->use_swn_dstaddr) {
 319                         server->dstaddr = server->swn_dstaddr;
 320                 } else {
 321 #endif
 322
 323 #ifdef CONFIG_CIFS_DFS_UPCALL
 324                         /*
 325                          * Set up next DFS target server (if any) for reconnect. If DFS
 326                          * feature is disabled, then we will retry last server we
 327                          * connected to before.
 328                          */
 329                         reconn_set_next_dfs_target(server, cifs_sb, &tgt_list, &tgt_it);
 330 #endif
 331
 332 #ifdef CONFIG_CIFS_SWN_UPCALL
 333                 }
 334 #endif
 335
 336                 if (cifs_rdma_enabled(server))
 337                         rc = smbd_reconnect(server);
 338                 else
 339                         rc = generic_ip_connect(server);
 340                 if (rc) {
 341                         cifs_dbg(FYI, "reconnect error %d\n", rc);
 342                         mutex_unlock(&server->srv_mutex);
 343                         msleep(3000);
 344                 } else {
 345                         atomic_inc(&tcpSesReconnectCount);
 346                         set_credits(server, 1);
 347                         spin_lock(&GlobalMid_Lock);
 348                         if (server->tcpStatus != CifsExiting)
 349                                 server->tcpStatus = CifsNeedNegotiate;
 350                         spin_unlock(&GlobalMid_Lock);
 351 #ifdef CONFIG_CIFS_SWN_UPCALL
 352                         server->use_swn_dstaddr = false;
 353 #endif
 354                         mutex_unlock(&server->srv_mutex);
 355                 }
 356         } while (server->tcpStatus == CifsNeedReconnect);
 357
 358 #ifdef CONFIG_CIFS_DFS_UPCALL
 359         if (tgt_it) {
 360                 rc = dfs_cache_noreq_update_tgthint(cifs_sb->origin_fullpath + 1,
 361                                                     tgt_it);
 362                 if (rc) {
 363                         cifs_server_dbg(VFS, "%s: failed to update DFS target hint: rc = %d\n",
 364                                  __func__, rc);
 365                 }
 366                 rc = dfs_cache_update_vol(cifs_sb->origin_fullpath, server);
 367                 if (rc) {
 368                         cifs_server_dbg(VFS, "%s: failed to update vol info in DFS cache: rc = %d\n",
 369                                  __func__, rc);
 370                 }
 371                 dfs_cache_free_tgts(&tgt_list);
 372
 373         }
 374
 375         cifs_put_tcp_super(sb);
 376 #endif
 377         if (server->tcpStatus == CifsNeedNegotiate)
 378                 mod_delayed_work(cifsiod_wq, &server->echo, 0);
 379
 380         wake_up(&server->response_q);
 381         return rc;
 382 }
 383
 384 static void
 385 cifs_echo_request(struct work_struct *work)
 386 {
 387         int rc;
 388         struct TCP_Server_Info *server = container_of(work,
 389                                         struct TCP_Server_Info, echo.work);
 390         unsigned long echo_interval;
 391
 392         /*
 393          * If we need to renegotiate, set echo interval to zero to
 394          * immediately call echo service where we can renegotiate.
 395          */
 396         if (server->tcpStatus == CifsNeedNegotiate)
 397                 echo_interval = 0;
 398         else
 399                 echo_interval = server->echo_interval;
 400
 401         /*
 402          * We cannot send an echo if it is disabled.
 403          * Also, no need to ping if we got a response recently.
 404          */
 405
 406         if (server->tcpStatus == CifsNeedReconnect ||
 407             server->tcpStatus == CifsExiting ||
 408             server->tcpStatus == CifsNew ||
 409             (server->ops->can_echo && !server->ops->can_echo(server)) ||
 410             time_before(jiffies, server->lstrp + echo_interval - HZ))
 411                 goto requeue_echo;
 412
 413         rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
 414         if (rc)
 415                 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
 416                          server->hostname);
 417
 418 #ifdef CONFIG_CIFS_SWN_UPCALL
 419         /* Check witness registrations */
 420         cifs_swn_check();
 421 #endif
 422
 423 requeue_echo:
 424         queue_delayed_work(cifsiod_wq, &server->echo, server->echo_interval);
 425 }
 426
 427 static bool
 428 allocate_buffers(struct TCP_Server_Info *server)
 429 {
 430         if (!server->bigbuf) {
 431                 server->bigbuf = (char *)cifs_buf_get();
 432                 if (!server->bigbuf) {
 433                         cifs_server_dbg(VFS, "No memory for large SMB response\n");
 434                         msleep(3000);
 435                         /* retry will check if exiting */
 436                         return false;
 437                 }
 438         } else if (server->large_buf) {
 439                 /* we are reusing a dirty large buf, clear its start */
 440                 memset(server->bigbuf, 0, HEADER_SIZE(server));
 441         }
 442
 443         if (!server->smallbuf) {
 444                 server->smallbuf = (char *)cifs_small_buf_get();
 445                 if (!server->smallbuf) {
 446                         cifs_server_dbg(VFS, "No memory for SMB response\n");
 447                         msleep(1000);
 448                         /* retry will check if exiting */
 449                         return false;
 450                 }
 451                 /* beginning of smb buffer is cleared in our buf_get */
 452         } else {
 453                 /* if existing small buf clear beginning */
 454                 memset(server->smallbuf, 0, HEADER_SIZE(server));
 455         }
 456
 457         return true;
 458 }
 459
 460 static bool
 461 server_unresponsive(struct TCP_Server_Info *server)
 462 {
 463         /*
 464          * We need to wait 3 echo intervals to make sure we handle such
 465          * situations right:
 466          * 1s  client sends a normal SMB request
 467          * 2s  client gets a response
 468          * 30s echo workqueue job pops, and decides we got a response recently
 469          *     and don't need to send another
 470          * ...
 471          * 65s kernel_recvmsg times out, and we see that we haven't gotten
 472          *     a response in >60s.
 473          */
 474         if ((server->tcpStatus == CifsGood ||
 475             server->tcpStatus == CifsNeedNegotiate) &&
 476             time_after(jiffies, server->lstrp + 3 * server->echo_interval)) {
 477                 cifs_server_dbg(VFS, "has not responded in %lu seconds. Reconnecting...\n",
 478                          (3 * server->echo_interval) / HZ);
 479                 cifs_reconnect(server);
 480                 return true;
 481         }
 482
 483         return false;
 484 }
 485
 486 static inline bool
 487 zero_credits(struct TCP_Server_Info *server)
 488 {
 489         int val;
 490
 491         spin_lock(&server->req_lock);
 492         val = server->credits + server->echo_credits + server->oplock_credits;
 493         if (server->in_flight == 0 && val == 0) {
 494                 spin_unlock(&server->req_lock);
 495                 return true;
 496         }
 497         spin_unlock(&server->req_lock);
 498         return false;
 499 }
 500
 501 static int
 502 cifs_readv_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg)
 503 {
 504         int length = 0;
 505         int total_read;
 506
 507         smb_msg->msg_control = NULL;
 508         smb_msg->msg_controllen = 0;
 509
 510         for (total_read = 0; msg_data_left(smb_msg); total_read += length) {
 511                 try_to_freeze();
 512
 513                 /* reconnect if no credits and no requests in flight */
 514                 if (zero_credits(server)) {
 515                         cifs_reconnect(server);
 516                         return -ECONNABORTED;
 517                 }
 518
 519                 if (server_unresponsive(server))
 520                         return -ECONNABORTED;
 521                 if (cifs_rdma_enabled(server) && server->smbd_conn)
 522                         length = smbd_recv(server->smbd_conn, smb_msg);
 523                 else
 524                         length = sock_recvmsg(server->ssocket, smb_msg, 0);
 525
 526                 if (server->tcpStatus == CifsExiting)
 527                         return -ESHUTDOWN;
 528
 529                 if (server->tcpStatus == CifsNeedReconnect) {
 530                         cifs_reconnect(server);
 531                         return -ECONNABORTED;
 532                 }
 533
 534                 if (length == -ERESTARTSYS ||
 535                     length == -EAGAIN ||
 536                     length == -EINTR) {
 537                         /*
 538                          * Minimum sleep to prevent looping, allowing socket
 539                          * to clear and app threads to set tcpStatus
 540                          * CifsNeedReconnect if server hung.
 541                          */
 542                         usleep_range(1000, 2000);
 543                         length = 0;
 544                         continue;
 545                 }
 546
 547                 if (length <= 0) {
 548                         cifs_dbg(FYI, "Received no data or error: %d\n", length);
 549                         cifs_reconnect(server);
 550                         return -ECONNABORTED;
 551                 }
 552         }
 553         return total_read;
 554 }
 555
 556 int
 557 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
 558                       unsigned int to_read)
 559 {
 560         struct msghdr smb_msg;
 561         struct kvec iov = {.iov_base = buf, .iov_len = to_read};
 562         iov_iter_kvec(&smb_msg.msg_iter, READ, &iov, 1, to_read);
 563
 564         return cifs_readv_from_socket(server, &smb_msg);
 565 }
 566
 567 ssize_t
 568 cifs_discard_from_socket(struct TCP_Server_Info *server, size_t to_read)
 569 {
 570         struct msghdr smb_msg;
 571
 572         /*
 573          *  iov_iter_discard already sets smb_msg.type and count and iov_offset
 574          *  and cifs_readv_from_socket sets msg_control and msg_controllen
 575          *  so little to initialize in struct msghdr
 576          */
 577         smb_msg.msg_name = NULL;
 578         smb_msg.msg_namelen = 0;
 579         iov_iter_discard(&smb_msg.msg_iter, READ, to_read);
 580
 581         return cifs_readv_from_socket(server, &smb_msg);
 582 }
 583
 584 int
 585 cifs_read_page_from_socket(struct TCP_Server_Info *server, struct page *page,
 586         unsigned int page_offset, unsigned int to_read)
 587 {
 588         struct msghdr smb_msg;
 589         struct bio_vec bv = {
 590                 .bv_page = page, .bv_len = to_read, .bv_offset = page_offset};
 591         iov_iter_bvec(&smb_msg.msg_iter, READ, &bv, 1, to_read);
 592         return cifs_readv_from_socket(server, &smb_msg);
 593 }
 594
 595 static bool
 596 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
 597 {
 598         /*
 599          * The first byte big endian of the length field,
 600          * is actually not part of the length but the type
 601          * with the most common, zero, as regular data.
 602          */
 603         switch (type) {
 604         case RFC1002_SESSION_MESSAGE:
 605                 /* Regular SMB response */
 606                 return true;
 607         case RFC1002_SESSION_KEEP_ALIVE:
 608                 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
 609                 break;
 610         case RFC1002_POSITIVE_SESSION_RESPONSE:
 611                 cifs_dbg(FYI, "RFC 1002 positive session response\n");
 612                 break;
 613         case RFC1002_NEGATIVE_SESSION_RESPONSE:
 614                 /*
 615                  * We get this from Windows 98 instead of an error on
 616                  * SMB negprot response.
 617                  */
 618                 cifs_dbg(FYI, "RFC 1002 negative session response\n");
 619                 /* give server a second to clean up */
 620                 msleep(1000);
 621                 /*
 622                  * Always try 445 first on reconnect since we get NACK
 623                  * on some if we ever connected to port 139 (the NACK
 624                  * is since we do not begin with RFC1001 session
 625                  * initialize frame).
 626                  */
 627                 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
 628                 cifs_reconnect(server);
 629                 break;
 630         default:
 631                 cifs_server_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
 632                 cifs_reconnect(server);
 633         }
 634
 635         return false;
 636 }
 637
 638 void
 639 dequeue_mid(struct mid_q_entry *mid, bool malformed)
 640 {
 641 #ifdef CONFIG_CIFS_STATS2
 642         mid->when_received = jiffies;
 643 #endif
 644         spin_lock(&GlobalMid_Lock);
 645         if (!malformed)
 646                 mid->mid_state = MID_RESPONSE_RECEIVED;
 647         else
 648                 mid->mid_state = MID_RESPONSE_MALFORMED;
 649         /*
 650          * Trying to handle/dequeue a mid after the send_recv()
 651          * function has finished processing it is a bug.
 652          */
 653         if (mid->mid_flags & MID_DELETED)
 654                 pr_warn_once("trying to dequeue a deleted mid\n");
 655         else {
 656                 list_del_init(&mid->qhead);
 657                 mid->mid_flags |= MID_DELETED;
 658         }
 659         spin_unlock(&GlobalMid_Lock);
 660 }
 661
 662 static unsigned int
 663 smb2_get_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)
 664 {
 665         struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buffer;
 666
 667         /*
 668          * SMB1 does not use credits.
 669          */
 670         if (server->vals->header_preamble_size)
 671                 return 0;
 672
 673         return le16_to_cpu(shdr->CreditRequest);
 674 }
 675
 676 static void
 677 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
 678            char *buf, int malformed)
 679 {
 680         if (server->ops->check_trans2 &&
 681             server->ops->check_trans2(mid, server, buf, malformed))
 682                 return;
 683         mid->credits_received = smb2_get_credits_from_hdr(buf, server);
 684         mid->resp_buf = buf;
 685         mid->large_buf = server->large_buf;
 686         /* Was previous buf put in mpx struct for multi-rsp? */
 687         if (!mid->multiRsp) {
 688                 /* smb buffer will be freed by user thread */
 689                 if (server->large_buf)
 690                         server->bigbuf = NULL;
 691                 else
 692                         server->smallbuf = NULL;
 693         }
 694         dequeue_mid(mid, malformed);
 695 }
 696
 697 static void clean_demultiplex_info(struct TCP_Server_Info *server)
 698 {
 699         int length;
 700
 701         /* take it off the list, if it's not already */
 702         spin_lock(&cifs_tcp_ses_lock);
 703         list_del_init(&server->tcp_ses_list);
 704         spin_unlock(&cifs_tcp_ses_lock);
 705
 706         cancel_delayed_work_sync(&server->echo);
 707
 708         spin_lock(&GlobalMid_Lock);
 709         server->tcpStatus = CifsExiting;
 710         spin_unlock(&GlobalMid_Lock);
 711         wake_up_all(&server->response_q);
 712
 713         /* check if we have blocked requests that need to free */
 714         spin_lock(&server->req_lock);
 715         if (server->credits <= 0)
 716                 server->credits = 1;
 717         spin_unlock(&server->req_lock);
 718         /*
 719          * Although there should not be any requests blocked on this queue it
 720          * can not hurt to be paranoid and try to wake up requests that may
 721          * haven been blocked when more than 50 at time were on the wire to the
 722          * same server - they now will see the session is in exit state and get
 723          * out of SendReceive.
 724          */
 725         wake_up_all(&server->request_q);
 726         /* give those requests time to exit */
 727         msleep(125);
 728         if (cifs_rdma_enabled(server))
 729                 smbd_destroy(server);
 730         if (server->ssocket) {
 731                 sock_release(server->ssocket);
 732                 server->ssocket = NULL;
 733         }
 734
 735         if (!list_empty(&server->pending_mid_q)) {
 736                 struct list_head dispose_list;
 737                 struct mid_q_entry *mid_entry;
 738                 struct list_head *tmp, *tmp2;
 739
 740                 INIT_LIST_HEAD(&dispose_list);
 741                 spin_lock(&GlobalMid_Lock);
 742                 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 743                         mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 744                         cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
 745                         kref_get(&mid_entry->refcount);
 746                         mid_entry->mid_state = MID_SHUTDOWN;
 747                         list_move(&mid_entry->qhead, &dispose_list);
 748                         mid_entry->mid_flags |= MID_DELETED;
 749                 }
 750                 spin_unlock(&GlobalMid_Lock);
 751
 752                 /* now walk dispose list and issue callbacks */
 753                 list_for_each_safe(tmp, tmp2, &dispose_list) {
 754                         mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 755                         cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
 756                         list_del_init(&mid_entry->qhead);
 757                         mid_entry->callback(mid_entry);
 758                         cifs_mid_q_entry_release(mid_entry);
 759                 }
 760                 /* 1/8th of sec is more than enough time for them to exit */
 761                 msleep(125);
 762         }
 763
 764         if (!list_empty(&server->pending_mid_q)) {
 765                 /*
 766                  * mpx threads have not exited yet give them at least the smb
 767                  * send timeout time for long ops.
 768                  *
 769                  * Due to delays on oplock break requests, we need to wait at
 770                  * least 45 seconds before giving up on a request getting a
 771                  * response and going ahead and killing cifsd.
 772                  */
 773                 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
 774                 msleep(46000);
 775                 /*
 776                  * If threads still have not exited they are probably never
 777                  * coming home not much else we can do but free the memory.
 778                  */
 779         }
 780
 781         kfree(server->hostname);
 782         kfree(server);
 783
 784         length = atomic_dec_return(&tcpSesAllocCount);
 785         if (length > 0)
 786                 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
 787 }
 788
 789 static int
 790 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
 791 {
 792         int length;
 793         char *buf = server->smallbuf;
 794         unsigned int pdu_length = server->pdu_size;
 795
 796         /* make sure this will fit in a large buffer */
 797         if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) -
 798                 server->vals->header_preamble_size) {
 799                 cifs_server_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
 800                 cifs_reconnect(server);
 801                 return -ECONNABORTED;
 802         }
 803
 804         /* switch to large buffer if too big for a small one */
 805         if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
 806                 server->large_buf = true;
 807                 memcpy(server->bigbuf, buf, server->total_read);
 808                 buf = server->bigbuf;
 809         }
 810
 811         /* now read the rest */
 812         length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
 813                                        pdu_length - HEADER_SIZE(server) + 1
 814                                        + server->vals->header_preamble_size);
 815
 816         if (length < 0)
 817                 return length;
 818         server->total_read += length;
 819
 820         dump_smb(buf, server->total_read);
 821
 822         return cifs_handle_standard(server, mid);
 823 }
 824
 825 int
 826 cifs_handle_standard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
 827 {
 828         char *buf = server->large_buf ? server->bigbuf : server->smallbuf;
 829         int length;
 830
 831         /*
 832          * We know that we received enough to get to the MID as we
 833          * checked the pdu_length earlier. Now check to see
 834          * if the rest of the header is OK. We borrow the length
 835          * var for the rest of the loop to avoid a new stack var.
 836          *
 837          * 48 bytes is enough to display the header and a little bit
 838          * into the payload for debugging purposes.
 839          */
 840         length = server->ops->check_message(buf, server->total_read, server);
 841         if (length != 0)
 842                 cifs_dump_mem("Bad SMB: ", buf,
 843                         min_t(unsigned int, server->total_read, 48));
 844
 845         if (server->ops->is_session_expired &&
 846             server->ops->is_session_expired(buf)) {
 847                 cifs_reconnect(server);
 848                 return -1;
 849         }
 850
 851         if (server->ops->is_status_pending &&
 852             server->ops->is_status_pending(buf, server))
 853                 return -1;
 854
 855         if (!mid)
 856                 return length;
 857
 858         handle_mid(mid, server, buf, length);
 859         return 0;
 860 }
 861
 862 static void
 863 smb2_add_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)
 864 {
 865         struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buffer;
 866         int scredits, in_flight;
 867
 868         /*
 869          * SMB1 does not use credits.
 870          */
 871         if (server->vals->header_preamble_size)
 872                 return;
 873
 874         if (shdr->CreditRequest) {
 875                 spin_lock(&server->req_lock);
 876                 server->credits += le16_to_cpu(shdr->CreditRequest);
 877                 scredits = server->credits;
 878                 in_flight = server->in_flight;
 879                 spin_unlock(&server->req_lock);
 880                 wake_up(&server->request_q);
 881
 882                 trace_smb3_add_credits(server->CurrentMid,
 883                                 server->conn_id, server->hostname, scredits,
 884                                 le16_to_cpu(shdr->CreditRequest), in_flight);
 885                 cifs_server_dbg(FYI, "%s: added %u credits total=%d\n",
 886                                 __func__, le16_to_cpu(shdr->CreditRequest),
 887                                 scredits);
 888         }
 889 }
 890
 891
 892 static int
 893 cifs_demultiplex_thread(void *p)
 894 {
 895         int i, num_mids, length;
 896         struct TCP_Server_Info *server = p;
 897         unsigned int pdu_length;
 898         unsigned int next_offset;
 899         char *buf = NULL;
 900         struct task_struct *task_to_wake = NULL;
 901         struct mid_q_entry *mids[MAX_COMPOUND];
 902         char *bufs[MAX_COMPOUND];
 903         unsigned int noreclaim_flag, num_io_timeout = 0;
 904
 905         noreclaim_flag = memalloc_noreclaim_save();
 906         cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
 907
 908         length = atomic_inc_return(&tcpSesAllocCount);
 909         if (length > 1)
 910                 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
 911
 912         set_freezable();
 913         allow_kernel_signal(SIGKILL);
 914         while (server->tcpStatus != CifsExiting) {
 915                 if (try_to_freeze())
 916                         continue;
 917
 918                 if (!allocate_buffers(server))
 919                         continue;
 920
 921                 server->large_buf = false;
 922                 buf = server->smallbuf;
 923                 pdu_length = 4; /* enough to get RFC1001 header */
 924
 925                 length = cifs_read_from_socket(server, buf, pdu_length);
 926                 if (length < 0)
 927                         continue;
 928
 929                 if (server->vals->header_preamble_size == 0)
 930                         server->total_read = 0;
 931                 else
 932                         server->total_read = length;
 933
 934                 /*
 935                  * The right amount was read from socket - 4 bytes,
 936                  * so we can now interpret the length field.
 937                  */
 938                 pdu_length = get_rfc1002_length(buf);
 939
 940                 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
 941                 if (!is_smb_response(server, buf[0]))
 942                         continue;
 943 next_pdu:
 944                 server->pdu_size = pdu_length;
 945
 946                 /* make sure we have enough to get to the MID */
 947                 if (server->pdu_size < HEADER_SIZE(server) - 1 -
 948                     server->vals->header_preamble_size) {
 949                         cifs_server_dbg(VFS, "SMB response too short (%u bytes)\n",
 950                                  server->pdu_size);
 951                         cifs_reconnect(server);
 952                         continue;
 953                 }
 954
 955                 /* read down to the MID */
 956                 length = cifs_read_from_socket(server,
 957                              buf + server->vals->header_preamble_size,
 958                              HEADER_SIZE(server) - 1
 959                              - server->vals->header_preamble_size);
 960                 if (length < 0)
 961                         continue;
 962                 server->total_read += length;
 963
 964                 if (server->ops->next_header) {
 965                         next_offset = server->ops->next_header(buf);
 966                         if (next_offset)
 967                                 server->pdu_size = next_offset;
 968                 }
 969
 970                 memset(mids, 0, sizeof(mids));
 971                 memset(bufs, 0, sizeof(bufs));
 972                 num_mids = 0;
 973
 974                 if (server->ops->is_transform_hdr &&
 975                     server->ops->receive_transform &&
 976                     server->ops->is_transform_hdr(buf)) {
 977                         length = server->ops->receive_transform(server,
 978                                                                 mids,
 979                                                                 bufs,
 980                                                                 &num_mids);
 981                 } else {
 982                         mids[0] = server->ops->find_mid(server, buf);
 983                         bufs[0] = buf;
 984                         num_mids = 1;
 985
 986                         if (!mids[0] || !mids[0]->receive)
 987                                 length = standard_receive3(server, mids[0]);
 988                         else
 989                                 length = mids[0]->receive(server, mids[0]);
 990                 }
 991
 992                 if (length < 0) {
 993                         for (i = 0; i < num_mids; i++)
 994                                 if (mids[i])
 995                                         cifs_mid_q_entry_release(mids[i]);
 996                         continue;
 997                 }
 998
 999                 if (server->ops->is_status_io_timeout &&
1000                     server->ops->is_status_io_timeout(buf)) {
1001                         num_io_timeout++;
1002                         if (num_io_timeout > NUM_STATUS_IO_TIMEOUT) {
1003                                 cifs_reconnect(server);
1004                                 num_io_timeout = 0;
1005                                 continue;
1006                         }
1007                 }
1008
1009                 server->lstrp = jiffies;
1010
1011                 for (i = 0; i < num_mids; i++) {
1012                         if (mids[i] != NULL) {
1013                                 mids[i]->resp_buf_size = server->pdu_size;
1014
1015                                 if (bufs[i] && server->ops->is_network_name_deleted)
1016                                         server->ops->is_network_name_deleted(bufs[i],
1017                                                                         server);
1018
1019                                 if (!mids[i]->multiRsp || mids[i]->multiEnd)
1020                                         mids[i]->callback(mids[i]);
1021
1022                                 cifs_mid_q_entry_release(mids[i]);
1023                         } else if (server->ops->is_oplock_break &&
1024                                    server->ops->is_oplock_break(bufs[i],
1025                                                                 server)) {
1026                                 smb2_add_credits_from_hdr(bufs[i], server);
1027                                 cifs_dbg(FYI, "Received oplock break\n");
1028                         } else {
1029                                 cifs_server_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n",
1030                                                 atomic_read(&midCount));
1031                                 cifs_dump_mem("Received Data is: ", bufs[i],
1032                                               HEADER_SIZE(server));
1033                                 smb2_add_credits_from_hdr(bufs[i], server);
1034 #ifdef CONFIG_CIFS_DEBUG2
1035                                 if (server->ops->dump_detail)
1036                                         server->ops->dump_detail(bufs[i],
1037                                                                  server);
1038                                 cifs_dump_mids(server);
1039 #endif /* CIFS_DEBUG2 */
1040                         }
1041                 }
1042
1043                 if (pdu_length > server->pdu_size) {
1044                         if (!allocate_buffers(server))
1045                                 continue;
1046                         pdu_length -= server->pdu_size;
1047                         server->total_read = 0;
1048                         server->large_buf = false;
1049                         buf = server->smallbuf;
1050                         goto next_pdu;
1051                 }
1052         } /* end while !EXITING */
1053
1054         /* buffer usually freed in free_mid - need to free it here on exit */
1055         cifs_buf_release(server->bigbuf);
1056         if (server->smallbuf) /* no sense logging a debug message if NULL */
1057                 cifs_small_buf_release(server->smallbuf);
1058
1059         task_to_wake = xchg(&server->tsk, NULL);
1060         clean_demultiplex_info(server);
1061
1062         /* if server->tsk was NULL then wait for a signal before exiting */
1063         if (!task_to_wake) {
1064                 set_current_state(TASK_INTERRUPTIBLE);
1065                 while (!signal_pending(current)) {
1066                         schedule();
1067                         set_current_state(TASK_INTERRUPTIBLE);
1068                 }
1069                 set_current_state(TASK_RUNNING);
1070         }
1071
1072         memalloc_noreclaim_restore(noreclaim_flag);
1073         module_put_and_exit(0);
1074 }
1075
1076 /**
1077  * Returns true if srcaddr isn't specified and rhs isn't specified, or
1078  * if srcaddr is specified and matches the IP address of the rhs argument
1079  */
1080 bool
1081 cifs_match_ipaddr(struct sockaddr *srcaddr, struct sockaddr *rhs)
1082 {
1083         switch (srcaddr->sa_family) {
1084         case AF_UNSPEC:
1085                 return (rhs->sa_family == AF_UNSPEC);
1086         case AF_INET: {
1087                 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1088                 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1089                 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1090         }
1091         case AF_INET6: {
1092                 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1093                 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
1094                 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1095         }
1096         default:
1097                 WARN_ON(1);
1098                 return false; /* don't expect to be here */
1099         }
1100 }
1101
1102 /*
1103  * If no port is specified in addr structure, we try to match with 445 port
1104  * and if it fails - with 139 ports. It should be called only if address
1105  * families of server and addr are equal.
1106  */
1107 static bool
1108 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1109 {
1110         __be16 port, *sport;
1111
1112         /* SMBDirect manages its own ports, don't match it here */
1113         if (server->rdma)
1114                 return true;
1115
1116         switch (addr->sa_family) {
1117         case AF_INET:
1118                 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1119                 port = ((struct sockaddr_in *) addr)->sin_port;
1120                 break;
1121         case AF_INET6:
1122                 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1123                 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1124                 break;
1125         default:
1126                 WARN_ON(1);
1127                 return false;
1128         }
1129
1130         if (!port) {
1131                 port = htons(CIFS_PORT);
1132                 if (port == *sport)
1133                         return true;
1134
1135                 port = htons(RFC1001_PORT);
1136         }
1137
1138         return port == *sport;
1139 }
1140
1141 static bool
1142 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1143               struct sockaddr *srcaddr)
1144 {
1145         switch (addr->sa_family) {
1146         case AF_INET: {
1147                 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1148                 struct sockaddr_in *srv_addr4 =
1149                                         (struct sockaddr_in *)&server->dstaddr;
1150
1151                 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1152                         return false;
1153                 break;
1154         }
1155         case AF_INET6: {
1156                 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1157                 struct sockaddr_in6 *srv_addr6 =
1158                                         (struct sockaddr_in6 *)&server->dstaddr;
1159
1160                 if (!ipv6_addr_equal(&addr6->sin6_addr,
1161                                      &srv_addr6->sin6_addr))
1162                         return false;
1163                 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1164                         return false;
1165                 break;
1166         }
1167         default:
1168                 WARN_ON(1);
1169                 return false; /* don't expect to be here */
1170         }
1171
1172         if (!cifs_match_ipaddr(srcaddr, (struct sockaddr *)&server->srcaddr))
1173                 return false;
1174
1175         return true;
1176 }
1177
1178 static bool
1179 match_security(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)
1180 {
1181         /*
1182          * The select_sectype function should either return the ctx->sectype
1183          * that was specified, or "Unspecified" if that sectype was not
1184          * compatible with the given NEGOTIATE request.
1185          */
1186         if (server->ops->select_sectype(server, ctx->sectype)
1187              == Unspecified)
1188                 return false;
1189
1190         /*
1191          * Now check if signing mode is acceptable. No need to check
1192          * global_secflags at this point since if MUST_SIGN is set then
1193          * the server->sign had better be too.
1194          */
1195         if (ctx->sign && !server->sign)
1196                 return false;
1197
1198         return true;
1199 }
1200
1201 static int match_server(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)
1202 {
1203         struct sockaddr *addr = (struct sockaddr *)&ctx->dstaddr;
1204
1205         if (ctx->nosharesock)
1206                 return 0;
1207
1208         /* If multidialect negotiation see if existing sessions match one */
1209         if (strcmp(ctx->vals->version_string, SMB3ANY_VERSION_STRING) == 0) {
1210                 if (server->vals->protocol_id < SMB30_PROT_ID)
1211                         return 0;
1212         } else if (strcmp(ctx->vals->version_string,
1213                    SMBDEFAULT_VERSION_STRING) == 0) {
1214                 if (server->vals->protocol_id < SMB21_PROT_ID)
1215                         return 0;
1216         } else if ((server->vals != ctx->vals) || (server->ops != ctx->ops))
1217                 return 0;
1218
1219         if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
1220                 return 0;
1221
1222         if (!match_address(server, addr,
1223                            (struct sockaddr *)&ctx->srcaddr))
1224                 return 0;
1225
1226         if (!match_port(server, addr))
1227                 return 0;
1228
1229         if (!match_security(server, ctx))
1230                 return 0;
1231
1232         if (server->echo_interval != ctx->echo_interval * HZ)
1233                 return 0;
1234
1235         if (server->rdma != ctx->rdma)
1236                 return 0;
1237
1238         if (server->ignore_signature != ctx->ignore_signature)
1239                 return 0;
1240
1241         if (server->min_offload != ctx->min_offload)
1242                 return 0;
1243
1244         return 1;
1245 }
1246
1247 struct TCP_Server_Info *
1248 cifs_find_tcp_session(struct smb3_fs_context *ctx)
1249 {
1250         struct TCP_Server_Info *server;
1251
1252         spin_lock(&cifs_tcp_ses_lock);
1253         list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
1254                 /*
1255                  * Skip ses channels since they're only handled in lower layers
1256                  * (e.g. cifs_send_recv).
1257                  */
1258                 if (server->is_channel || !match_server(server, ctx))
1259                         continue;
1260
1261                 ++server->srv_count;
1262                 spin_unlock(&cifs_tcp_ses_lock);
1263                 cifs_dbg(FYI, "Existing tcp session with server found\n");
1264                 return server;
1265         }
1266         spin_unlock(&cifs_tcp_ses_lock);
1267         return NULL;
1268 }
1269
1270 void
1271 cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
1272 {
1273         struct task_struct *task;
1274
1275         spin_lock(&cifs_tcp_ses_lock);
1276         if (--server->srv_count > 0) {
1277                 spin_unlock(&cifs_tcp_ses_lock);
1278                 return;
1279         }
1280
1281         put_net(cifs_net_ns(server));
1282
1283         list_del_init(&server->tcp_ses_list);
1284         spin_unlock(&cifs_tcp_ses_lock);
1285
1286         cancel_delayed_work_sync(&server->echo);
1287
1288         if (from_reconnect)
1289                 /*
1290                  * Avoid deadlock here: reconnect work calls
1291                  * cifs_put_tcp_session() at its end. Need to be sure
1292                  * that reconnect work does nothing with server pointer after
1293                  * that step.
1294                  */
1295                 cancel_delayed_work(&server->reconnect);
1296         else
1297                 cancel_delayed_work_sync(&server->reconnect);
1298
1299         spin_lock(&GlobalMid_Lock);
1300         server->tcpStatus = CifsExiting;
1301         spin_unlock(&GlobalMid_Lock);
1302
1303         cifs_crypto_secmech_release(server);
1304         cifs_fscache_release_client_cookie(server);
1305
1306         kfree(server->session_key.response);
1307         server->session_key.response = NULL;
1308         server->session_key.len = 0;
1309
1310         task = xchg(&server->tsk, NULL);
1311         if (task)
1312                 send_sig(SIGKILL, task, 1);
1313 }
1314
1315 struct TCP_Server_Info *
1316 cifs_get_tcp_session(struct smb3_fs_context *ctx)
1317 {
1318         struct TCP_Server_Info *tcp_ses = NULL;
1319         int rc;
1320
1321         cifs_dbg(FYI, "UNC: %s\n", ctx->UNC);
1322
1323         /* see if we already have a matching tcp_ses */
1324         tcp_ses = cifs_find_tcp_session(ctx);
1325         if (tcp_ses)
1326                 return tcp_ses;
1327
1328         tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1329         if (!tcp_ses) {
1330                 rc = -ENOMEM;
1331                 goto out_err;
1332         }
1333
1334         tcp_ses->ops = ctx->ops;
1335         tcp_ses->vals = ctx->vals;
1336         cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
1337         tcp_ses->hostname = extract_hostname(ctx->UNC);
1338         if (IS_ERR(tcp_ses->hostname)) {
1339                 rc = PTR_ERR(tcp_ses->hostname);
1340                 goto out_err_crypto_release;
1341         }
1342
1343         tcp_ses->conn_id = atomic_inc_return(&tcpSesNextId);
1344         tcp_ses->noblockcnt = ctx->rootfs;
1345         tcp_ses->noblocksnd = ctx->noblocksnd || ctx->rootfs;
1346         tcp_ses->noautotune = ctx->noautotune;
1347         tcp_ses->tcp_nodelay = ctx->sockopt_tcp_nodelay;
1348         tcp_ses->rdma = ctx->rdma;
1349         tcp_ses->in_flight = 0;
1350         tcp_ses->max_in_flight = 0;
1351         tcp_ses->credits = 1;
1352         init_waitqueue_head(&tcp_ses->response_q);
1353         init_waitqueue_head(&tcp_ses->request_q);
1354         INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1355         mutex_init(&tcp_ses->srv_mutex);
1356         memcpy(tcp_ses->workstation_RFC1001_name,
1357                 ctx->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1358         memcpy(tcp_ses->server_RFC1001_name,
1359                 ctx->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1360         tcp_ses->session_estab = false;
1361         tcp_ses->sequence_number = 0;
1362         tcp_ses->reconnect_instance = 1;
1363         tcp_ses->lstrp = jiffies;
1364         tcp_ses->compress_algorithm = cpu_to_le16(ctx->compression);
1365         spin_lock_init(&tcp_ses->req_lock);
1366         INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1367         INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1368         INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
1369         INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
1370         mutex_init(&tcp_ses->reconnect_mutex);
1371         memcpy(&tcp_ses->srcaddr, &ctx->srcaddr,
1372                sizeof(tcp_ses->srcaddr));
1373         memcpy(&tcp_ses->dstaddr, &ctx->dstaddr,
1374                 sizeof(tcp_ses->dstaddr));
1375         if (ctx->use_client_guid)
1376                 memcpy(tcp_ses->client_guid, ctx->client_guid,
1377                        SMB2_CLIENT_GUID_SIZE);
1378         else
1379                 generate_random_uuid(tcp_ses->client_guid);
1380         /*
1381          * at this point we are the only ones with the pointer
1382          * to the struct since the kernel thread not created yet
1383          * no need to spinlock this init of tcpStatus or srv_count
1384          */
1385         tcp_ses->tcpStatus = CifsNew;
1386         ++tcp_ses->srv_count;
1387
1388         if (ctx->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
1389                 ctx->echo_interval <= SMB_ECHO_INTERVAL_MAX)
1390                 tcp_ses->echo_interval = ctx->echo_interval * HZ;
1391         else
1392                 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
1393         if (tcp_ses->rdma) {
1394 #ifndef CONFIG_CIFS_SMB_DIRECT
1395                 cifs_dbg(VFS, "CONFIG_CIFS_SMB_DIRECT is not enabled\n");
1396                 rc = -ENOENT;
1397                 goto out_err_crypto_release;
1398 #endif
1399                 tcp_ses->smbd_conn = smbd_get_connection(
1400                         tcp_ses, (struct sockaddr *)&ctx->dstaddr);
1401                 if (tcp_ses->smbd_conn) {
1402                         cifs_dbg(VFS, "RDMA transport established\n");
1403                         rc = 0;
1404                         goto smbd_connected;
1405                 } else {
1406                         rc = -ENOENT;
1407                         goto out_err_crypto_release;
1408                 }
1409         }
1410         rc = ip_connect(tcp_ses);
1411         if (rc < 0) {
1412                 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
1413                 goto out_err_crypto_release;
1414         }
1415 smbd_connected:
1416         /*
1417          * since we're in a cifs function already, we know that
1418          * this will succeed. No need for try_module_get().
1419          */
1420         __module_get(THIS_MODULE);
1421         tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
1422                                   tcp_ses, "cifsd");
1423         if (IS_ERR(tcp_ses->tsk)) {
1424                 rc = PTR_ERR(tcp_ses->tsk);
1425                 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
1426                 module_put(THIS_MODULE);
1427                 goto out_err_crypto_release;
1428         }
1429         tcp_ses->min_offload = ctx->min_offload;
1430         tcp_ses->tcpStatus = CifsNeedNegotiate;
1431
1432         tcp_ses->nr_targets = 1;
1433         tcp_ses->ignore_signature = ctx->ignore_signature;
1434         /* thread spawned, put it on the list */
1435         spin_lock(&cifs_tcp_ses_lock);
1436         list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1437         spin_unlock(&cifs_tcp_ses_lock);
1438
1439         cifs_fscache_get_client_cookie(tcp_ses);
1440
1441         /* queue echo request delayed work */
1442         queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
1443
1444         return tcp_ses;
1445
1446 out_err_crypto_release:
1447         cifs_crypto_secmech_release(tcp_ses);
1448
1449         put_net(cifs_net_ns(tcp_ses));
1450
1451 out_err:
1452         if (tcp_ses) {
1453                 if (!IS_ERR(tcp_ses->hostname))
1454                         kfree(tcp_ses->hostname);
1455                 if (tcp_ses->ssocket)
1456                         sock_release(tcp_ses->ssocket);
1457                 kfree(tcp_ses);
1458         }
1459         return ERR_PTR(rc);
1460 }
1461
1462 static int match_session(struct cifs_ses *ses, struct smb3_fs_context *ctx)
1463 {
1464         if (ctx->sectype != Unspecified &&
1465             ctx->sectype != ses->sectype)
1466                 return 0;
1467
1468         /*
1469          * If an existing session is limited to less channels than
1470          * requested, it should not be reused
1471          */
1472         if (ses->chan_max < ctx->max_channels)
1473                 return 0;
1474
1475         switch (ses->sectype) {
1476         case Kerberos:
1477                 if (!uid_eq(ctx->cred_uid, ses->cred_uid))
1478                         return 0;
1479                 break;
1480         default:
1481                 /* NULL username means anonymous session */
1482                 if (ses->user_name == NULL) {
1483                         if (!ctx->nullauth)
1484                                 return 0;
1485                         break;
1486                 }
1487
1488                 /* anything else takes username/password */
1489                 if (strncmp(ses->user_name,
1490                             ctx->username ? ctx->username : "",
1491                             CIFS_MAX_USERNAME_LEN))
1492                         return 0;
1493                 if ((ctx->username && strlen(ctx->username) != 0) &&
1494                     ses->password != NULL &&
1495                     strncmp(ses->password,
1496                             ctx->password ? ctx->password : "",
1497                             CIFS_MAX_PASSWORD_LEN))
1498                         return 0;
1499         }
1500         return 1;
1501 }
1502
1503 /**
1504  * cifs_setup_ipc - helper to setup the IPC tcon for the session
1505  *
1506  * A new IPC connection is made and stored in the session
1507  * tcon_ipc. The IPC tcon has the same lifetime as the session.
1508  */
1509 static int
1510 cifs_setup_ipc(struct cifs_ses *ses, struct smb3_fs_context *ctx)
1511 {
1512         int rc = 0, xid;
1513         struct cifs_tcon *tcon;
1514         char unc[SERVER_NAME_LENGTH + sizeof("//x/IPC$")] = {0};
1515         bool seal = false;
1516         struct TCP_Server_Info *server = ses->server;
1517
1518         /*
1519          * If the mount request that resulted in the creation of the
1520          * session requires encryption, force IPC to be encrypted too.
1521          */
1522         if (ctx->seal) {
1523                 if (server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION)
1524                         seal = true;
1525                 else {
1526                         cifs_server_dbg(VFS,
1527                                  "IPC: server doesn't support encryption\n");
1528                         return -EOPNOTSUPP;
1529                 }
1530         }
1531
1532         tcon = tconInfoAlloc();
1533         if (tcon == NULL)
1534                 return -ENOMEM;
1535
1536         scnprintf(unc, sizeof(unc), "\\\\%s\\IPC$", server->hostname);
1537
1538         xid = get_xid();
1539         tcon->ses = ses;
1540         tcon->ipc = true;
1541         tcon->seal = seal;
1542         rc = server->ops->tree_connect(xid, ses, unc, tcon, ctx->local_nls);
1543         free_xid(xid);
1544
1545         if (rc) {
1546                 cifs_server_dbg(VFS, "failed to connect to IPC (rc=%d)\n", rc);
1547                 tconInfoFree(tcon);
1548                 goto out;
1549         }
1550
1551         cifs_dbg(FYI, "IPC tcon rc = %d ipc tid = %d\n", rc, tcon->tid);
1552
1553         ses->tcon_ipc = tcon;
1554 out:
1555         return rc;
1556 }
1557
1558 /**
1559  * cifs_free_ipc - helper to release the session IPC tcon
1560  *
1561  * Needs to be called everytime a session is destroyed
1562  */
1563 static int
1564 cifs_free_ipc(struct cifs_ses *ses)
1565 {
1566         int rc = 0, xid;
1567         struct cifs_tcon *tcon = ses->tcon_ipc;
1568
1569         if (tcon == NULL)
1570                 return 0;
1571
1572         if (ses->server->ops->tree_disconnect) {
1573                 xid = get_xid();
1574                 rc = ses->server->ops->tree_disconnect(xid, tcon);
1575                 free_xid(xid);
1576         }
1577
1578         if (rc)
1579                 cifs_dbg(FYI, "failed to disconnect IPC tcon (rc=%d)\n", rc);
1580
1581         tconInfoFree(tcon);
1582         ses->tcon_ipc = NULL;
1583         return rc;
1584 }
1585
1586 static struct cifs_ses *
1587 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)
1588 {
1589         struct cifs_ses *ses;
1590
1591         spin_lock(&cifs_tcp_ses_lock);
1592         list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
1593                 if (ses->status == CifsExiting)
1594                         continue;
1595                 if (!match_session(ses, ctx))
1596                         continue;
1597                 ++ses->ses_count;
1598                 spin_unlock(&cifs_tcp_ses_lock);
1599                 return ses;
1600         }
1601         spin_unlock(&cifs_tcp_ses_lock);
1602         return NULL;
1603 }
1604
1605 void cifs_put_smb_ses(struct cifs_ses *ses)
1606 {
1607         unsigned int rc, xid;
1608         struct TCP_Server_Info *server = ses->server;
1609
1610         cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
1611
1612         spin_lock(&cifs_tcp_ses_lock);
1613         if (ses->status == CifsExiting) {
1614                 spin_unlock(&cifs_tcp_ses_lock);
1615                 return;
1616         }
1617         if (--ses->ses_count > 0) {
1618                 spin_unlock(&cifs_tcp_ses_lock);
1619                 return;
1620         }
1621         if (ses->status == CifsGood)
1622                 ses->status = CifsExiting;
1623         spin_unlock(&cifs_tcp_ses_lock);
1624
1625         cifs_free_ipc(ses);
1626
1627         if (ses->status == CifsExiting && server->ops->logoff) {
1628                 xid = get_xid();
1629                 rc = server->ops->logoff(xid, ses);
1630                 if (rc)
1631                         cifs_server_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
1632                                 __func__, rc);
1633                 _free_xid(xid);
1634         }
1635
1636         spin_lock(&cifs_tcp_ses_lock);
1637         list_del_init(&ses->smb_ses_list);
1638         spin_unlock(&cifs_tcp_ses_lock);
1639
1640         /* close any extra channels */
1641         if (ses->chan_count > 1) {
1642                 int i;
1643
1644                 for (i = 1; i < ses->chan_count; i++)
1645                         cifs_put_tcp_session(ses->chans[i].server, 0);
1646         }
1647
1648         sesInfoFree(ses);
1649         cifs_put_tcp_session(server, 0);
1650 }
1651
1652 #ifdef CONFIG_KEYS
1653
1654 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
1655 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
1656
1657 /* Populate username and pw fields from keyring if possible */
1658 static int
1659 cifs_set_cifscreds(struct smb3_fs_context *ctx, struct cifs_ses *ses)
1660 {
1661         int rc = 0;
1662         int is_domain = 0;
1663         const char *delim, *payload;
1664         char *desc;
1665         ssize_t len;
1666         struct key *key;
1667         struct TCP_Server_Info *server = ses->server;
1668         struct sockaddr_in *sa;
1669         struct sockaddr_in6 *sa6;
1670         const struct user_key_payload *upayload;
1671
1672         desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
1673         if (!desc)
1674                 return -ENOMEM;
1675
1676         /* try to find an address key first */
1677         switch (server->dstaddr.ss_family) {
1678         case AF_INET:
1679                 sa = (struct sockaddr_in *)&server->dstaddr;
1680                 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
1681                 break;
1682         case AF_INET6:
1683                 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
1684                 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
1685                 break;
1686         default:
1687                 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
1688                          server->dstaddr.ss_family);
1689                 rc = -EINVAL;
1690                 goto out_err;
1691         }
1692
1693         cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
1694         key = request_key(&key_type_logon, desc, "");
1695         if (IS_ERR(key)) {
1696                 if (!ses->domainName) {
1697                         cifs_dbg(FYI, "domainName is NULL\n");
1698                         rc = PTR_ERR(key);
1699                         goto out_err;
1700                 }
1701
1702                 /* didn't work, try to find a domain key */
1703                 sprintf(desc, "cifs:d:%s", ses->domainName);
1704                 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
1705                 key = request_key(&key_type_logon, desc, "");
1706                 if (IS_ERR(key)) {
1707                         rc = PTR_ERR(key);
1708                         goto out_err;
1709                 }
1710                 is_domain = 1;
1711         }
1712
1713         down_read(&key->sem);
1714         upayload = user_key_payload_locked(key);
1715         if (IS_ERR_OR_NULL(upayload)) {
1716                 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
1717                 goto out_key_put;
1718         }
1719
1720         /* find first : in payload */
1721         payload = upayload->data;
1722         delim = strnchr(payload, upayload->datalen, ':');
1723         cifs_dbg(FYI, "payload=%s\n", payload);
1724         if (!delim) {
1725                 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
1726                          upayload->datalen);
1727                 rc = -EINVAL;
1728                 goto out_key_put;
1729         }
1730
1731         len = delim - payload;
1732         if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
1733                 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
1734                          len);
1735                 rc = -EINVAL;
1736                 goto out_key_put;
1737         }
1738
1739         ctx->username = kstrndup(payload, len, GFP_KERNEL);
1740         if (!ctx->username) {
1741                 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
1742                          len);
1743                 rc = -ENOMEM;
1744                 goto out_key_put;
1745         }
1746         cifs_dbg(FYI, "%s: username=%s\n", __func__, ctx->username);
1747
1748         len = key->datalen - (len + 1);
1749         if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
1750                 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
1751                 rc = -EINVAL;
1752                 kfree(ctx->username);
1753                 ctx->username = NULL;
1754                 goto out_key_put;
1755         }
1756
1757         ++delim;
1758         ctx->password = kstrndup(delim, len, GFP_KERNEL);
1759         if (!ctx->password) {
1760                 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
1761                          len);
1762                 rc = -ENOMEM;
1763                 kfree(ctx->username);
1764                 ctx->username = NULL;
1765                 goto out_key_put;
1766         }
1767
1768         /*
1769          * If we have a domain key then we must set the domainName in the
1770          * for the request.
1771          */
1772         if (is_domain && ses->domainName) {
1773                 ctx->domainname = kstrndup(ses->domainName,
1774                                            strlen(ses->domainName),
1775                                            GFP_KERNEL);
1776                 if (!ctx->domainname) {
1777                         cifs_dbg(FYI, "Unable to allocate %zd bytes for domain\n",
1778                                  len);
1779                         rc = -ENOMEM;
1780                         kfree(ctx->username);
1781                         ctx->username = NULL;
1782                         kfree_sensitive(ctx->password);
1783                         ctx->password = NULL;
1784                         goto out_key_put;
1785                 }
1786         }
1787
1788 out_key_put:
1789         up_read(&key->sem);
1790         key_put(key);
1791 out_err:
1792         kfree(desc);
1793         cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
1794         return rc;
1795 }
1796 #else /* ! CONFIG_KEYS */
1797 static inline int
1798 cifs_set_cifscreds(struct smb3_fs_context *ctx __attribute__((unused)),
1799                    struct cifs_ses *ses __attribute__((unused)))
1800 {
1801         return -ENOSYS;
1802 }
1803 #endif /* CONFIG_KEYS */
1804
1805 /**
1806  * cifs_get_smb_ses - get a session matching @ctx data from @server
1807  *
1808  * This function assumes it is being called from cifs_mount() where we
1809  * already got a server reference (server refcount +1). See
1810  * cifs_get_tcon() for refcount explanations.
1811  */
1812 struct cifs_ses *
1813 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)
1814 {
1815         int rc = -ENOMEM;
1816         unsigned int xid;
1817         struct cifs_ses *ses;
1818         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1819         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
1820
1821         xid = get_xid();
1822
1823         ses = cifs_find_smb_ses(server, ctx);
1824         if (ses) {
1825                 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
1826                          ses->status);
1827
1828                 mutex_lock(&ses->session_mutex);
1829                 rc = cifs_negotiate_protocol(xid, ses);
1830                 if (rc) {
1831                         mutex_unlock(&ses->session_mutex);
1832                         /* problem -- put our ses reference */
1833                         cifs_put_smb_ses(ses);
1834                         free_xid(xid);
1835                         return ERR_PTR(rc);
1836                 }
1837                 if (ses->need_reconnect) {
1838                         cifs_dbg(FYI, "Session needs reconnect\n");
1839                         rc = cifs_setup_session(xid, ses,
1840                                                 ctx->local_nls);
1841                         if (rc) {
1842                                 mutex_unlock(&ses->session_mutex);
1843                                 /* problem -- put our reference */
1844                                 cifs_put_smb_ses(ses);
1845                                 free_xid(xid);
1846                                 return ERR_PTR(rc);
1847                         }
1848                 }
1849                 mutex_unlock(&ses->session_mutex);
1850
1851                 /* existing SMB ses has a server reference already */
1852                 cifs_put_tcp_session(server, 0);
1853                 free_xid(xid);
1854                 return ses;
1855         }
1856
1857         cifs_dbg(FYI, "Existing smb sess not found\n");
1858         ses = sesInfoAlloc();
1859         if (ses == NULL)
1860                 goto get_ses_fail;
1861
1862         /* new SMB session uses our server ref */
1863         ses->server = server;
1864         if (server->dstaddr.ss_family == AF_INET6)
1865                 sprintf(ses->ip_addr, "%pI6", &addr6->sin6_addr);
1866         else
1867                 sprintf(ses->ip_addr, "%pI4", &addr->sin_addr);
1868
1869         if (ctx->username) {
1870                 ses->user_name = kstrdup(ctx->username, GFP_KERNEL);
1871                 if (!ses->user_name)
1872                         goto get_ses_fail;
1873         }
1874
1875         /* ctx->password freed at unmount */
1876         if (ctx->password) {
1877                 ses->password = kstrdup(ctx->password, GFP_KERNEL);
1878                 if (!ses->password)
1879                         goto get_ses_fail;
1880         }
1881         if (ctx->domainname) {
1882                 ses->domainName = kstrdup(ctx->domainname, GFP_KERNEL);
1883                 if (!ses->domainName)
1884                         goto get_ses_fail;
1885         }
1886         if (ctx->domainauto)
1887                 ses->domainAuto = ctx->domainauto;
1888         ses->cred_uid = ctx->cred_uid;
1889         ses->linux_uid = ctx->linux_uid;
1890
1891         ses->sectype = ctx->sectype;
1892         ses->sign = ctx->sign;
1893         mutex_lock(&ses->session_mutex);
1894
1895         /* add server as first channel */
1896         ses->chans[0].server = server;
1897         ses->chan_count = 1;
1898         ses->chan_max = ctx->multichannel ? ctx->max_channels:1;
1899
1900         rc = cifs_negotiate_protocol(xid, ses);
1901         if (!rc)
1902                 rc = cifs_setup_session(xid, ses, ctx->local_nls);
1903
1904         /* each channel uses a different signing key */
1905         memcpy(ses->chans[0].signkey, ses->smb3signingkey,
1906                sizeof(ses->smb3signingkey));
1907
1908         mutex_unlock(&ses->session_mutex);
1909         if (rc)
1910                 goto get_ses_fail;
1911
1912         /* success, put it on the list and add it as first channel */
1913         spin_lock(&cifs_tcp_ses_lock);
1914         list_add(&ses->smb_ses_list, &server->smb_ses_list);
1915         spin_unlock(&cifs_tcp_ses_lock);
1916
1917         free_xid(xid);
1918
1919         cifs_setup_ipc(ses, ctx);
1920
1921         return ses;
1922
1923 get_ses_fail:
1924         sesInfoFree(ses);
1925         free_xid(xid);
1926         return ERR_PTR(rc);
1927 }
1928
1929 static int match_tcon(struct cifs_tcon *tcon, struct smb3_fs_context *ctx)
1930 {
1931         if (tcon->tidStatus == CifsExiting)
1932                 return 0;
1933         if (strncmp(tcon->treeName, ctx->UNC, MAX_TREE_SIZE))
1934                 return 0;
1935         if (tcon->seal != ctx->seal)
1936                 return 0;
1937         if (tcon->snapshot_time != ctx->snapshot_time)
1938                 return 0;
1939         if (tcon->handle_timeout != ctx->handle_timeout)
1940                 return 0;
1941         if (tcon->no_lease != ctx->no_lease)
1942                 return 0;
1943         if (tcon->nodelete != ctx->nodelete)
1944                 return 0;
1945         return 1;
1946 }
1947
1948 static struct cifs_tcon *
1949 cifs_find_tcon(struct cifs_ses *ses, struct smb3_fs_context *ctx)
1950 {
1951         struct list_head *tmp;
1952         struct cifs_tcon *tcon;
1953
1954         spin_lock(&cifs_tcp_ses_lock);
1955         list_for_each(tmp, &ses->tcon_list) {
1956                 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
1957 #ifdef CONFIG_CIFS_DFS_UPCALL
1958                 if (tcon->dfs_path)
1959                         continue;
1960 #endif
1961                 if (!match_tcon(tcon, ctx))
1962                         continue;
1963                 ++tcon->tc_count;
1964                 spin_unlock(&cifs_tcp_ses_lock);
1965                 return tcon;
1966         }
1967         spin_unlock(&cifs_tcp_ses_lock);
1968         return NULL;
1969 }
1970
1971 void
1972 cifs_put_tcon(struct cifs_tcon *tcon)
1973 {
1974         unsigned int xid;
1975         struct cifs_ses *ses;
1976
1977         /*
1978          * IPC tcon share the lifetime of their session and are
1979          * destroyed in the session put function
1980          */
1981         if (tcon == NULL || tcon->ipc)
1982                 return;
1983
1984         ses = tcon->ses;
1985         cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
1986         spin_lock(&cifs_tcp_ses_lock);
1987         if (--tcon->tc_count > 0) {
1988                 spin_unlock(&cifs_tcp_ses_lock);
1989                 return;
1990         }
1991
1992 #ifdef CONFIG_CIFS_SWN_UPCALL
1993         if (tcon->use_witness) {
1994                 int rc;
1995
1996                 rc = cifs_swn_unregister(tcon);
1997                 if (rc < 0) {
1998                         cifs_dbg(VFS, "%s: Failed to unregister for witness notifications: %d\n",
1999                                         __func__, rc);
2000                 }
2001         }
2002 #endif
2003
2004         list_del_init(&tcon->tcon_list);
2005         spin_unlock(&cifs_tcp_ses_lock);
2006
2007         xid = get_xid();
2008         if (ses->server->ops->tree_disconnect)
2009                 ses->server->ops->tree_disconnect(xid, tcon);
2010         _free_xid(xid);
2011
2012         cifs_fscache_release_super_cookie(tcon);
2013         tconInfoFree(tcon);
2014         cifs_put_smb_ses(ses);
2015 }
2016
2017 /**
2018  * cifs_get_tcon - get a tcon matching @ctx data from @ses
2019  *
2020  * - tcon refcount is the number of mount points using the tcon.
2021  * - ses refcount is the number of tcon using the session.
2022  *
2023  * 1. This function assumes it is being called from cifs_mount() where
2024  *    we already got a session reference (ses refcount +1).
2025  *
2026  * 2. Since we're in the context of adding a mount point, the end
2027  *    result should be either:
2028  *
2029  * a) a new tcon already allocated with refcount=1 (1 mount point) and
2030  *    its session refcount incremented (1 new tcon). This +1 was
2031  *    already done in (1).
2032  *
2033  * b) an existing tcon with refcount+1 (add a mount point to it) and
2034  *    identical ses refcount (no new tcon). Because of (1) we need to
2035  *    decrement the ses refcount.
2036  */
2037 static struct cifs_tcon *
2038 cifs_get_tcon(struct cifs_ses *ses, struct smb3_fs_context *ctx)
2039 {
2040         int rc, xid;
2041         struct cifs_tcon *tcon;
2042
2043         tcon = cifs_find_tcon(ses, ctx);
2044         if (tcon) {
2045                 /*
2046                  * tcon has refcount already incremented but we need to
2047                  * decrement extra ses reference gotten by caller (case b)
2048                  */
2049                 cifs_dbg(FYI, "Found match on UNC path\n");
2050                 cifs_put_smb_ses(ses);
2051                 return tcon;
2052         }
2053
2054         if (!ses->server->ops->tree_connect) {
2055                 rc = -ENOSYS;
2056                 goto out_fail;
2057         }
2058
2059         tcon = tconInfoAlloc();
2060         if (tcon == NULL) {
2061                 rc = -ENOMEM;
2062                 goto out_fail;
2063         }
2064
2065         if (ctx->snapshot_time) {
2066                 if (ses->server->vals->protocol_id == 0) {
2067                         cifs_dbg(VFS,
2068                              "Use SMB2 or later for snapshot mount option\n");
2069                         rc = -EOPNOTSUPP;
2070                         goto out_fail;
2071                 } else
2072                         tcon->snapshot_time = ctx->snapshot_time;
2073         }
2074
2075         if (ctx->handle_timeout) {
2076                 if (ses->server->vals->protocol_id == 0) {
2077                         cifs_dbg(VFS,
2078                              "Use SMB2.1 or later for handle timeout option\n");
2079                         rc = -EOPNOTSUPP;
2080                         goto out_fail;
2081                 } else
2082                         tcon->handle_timeout = ctx->handle_timeout;
2083         }
2084
2085         tcon->ses = ses;
2086         if (ctx->password) {
2087                 tcon->password = kstrdup(ctx->password, GFP_KERNEL);
2088                 if (!tcon->password) {
2089                         rc = -ENOMEM;
2090                         goto out_fail;
2091                 }
2092         }
2093
2094         if (ctx->seal) {
2095                 if (ses->server->vals->protocol_id == 0) {
2096                         cifs_dbg(VFS,
2097                                  "SMB3 or later required for encryption\n");
2098                         rc = -EOPNOTSUPP;
2099                         goto out_fail;
2100                 } else if (tcon->ses->server->capabilities &
2101                                         SMB2_GLOBAL_CAP_ENCRYPTION)
2102                         tcon->seal = true;
2103                 else {
2104                         cifs_dbg(VFS, "Encryption is not supported on share\n");
2105                         rc = -EOPNOTSUPP;
2106                         goto out_fail;
2107                 }
2108         }
2109
2110         if (ctx->linux_ext) {
2111                 if (ses->server->posix_ext_supported) {
2112                         tcon->posix_extensions = true;
2113                         pr_warn_once("SMB3.11 POSIX Extensions are experimental\n");
2114                 } else {
2115                         cifs_dbg(VFS, "Server does not support mounting with posix SMB3.11 extensions\n");
2116                         rc = -EOPNOTSUPP;
2117                         goto out_fail;
2118                 }
2119         }
2120
2121         /*
2122          * BB Do we need to wrap session_mutex around this TCon call and Unix
2123          * SetFS as we do on SessSetup and reconnect?
2124          */
2125         xid = get_xid();
2126         rc = ses->server->ops->tree_connect(xid, ses, ctx->UNC, tcon,
2127                                             ctx->local_nls);
2128         free_xid(xid);
2129         cifs_dbg(FYI, "Tcon rc = %d\n", rc);
2130         if (rc)
2131                 goto out_fail;
2132
2133         tcon->use_persistent = false;
2134         /* check if SMB2 or later, CIFS does not support persistent handles */
2135         if (ctx->persistent) {
2136                 if (ses->server->vals->protocol_id == 0) {
2137                         cifs_dbg(VFS,
2138                              "SMB3 or later required for persistent handles\n");
2139                         rc = -EOPNOTSUPP;
2140                         goto out_fail;
2141                 } else if (ses->server->capabilities &
2142                            SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2143                         tcon->use_persistent = true;
2144                 else /* persistent handles requested but not supported */ {
2145                         cifs_dbg(VFS,
2146                                 "Persistent handles not supported on share\n");
2147                         rc = -EOPNOTSUPP;
2148                         goto out_fail;
2149                 }
2150         } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
2151              && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2152              && (ctx->nopersistent == false)) {
2153                 cifs_dbg(FYI, "enabling persistent handles\n");
2154                 tcon->use_persistent = true;
2155         } else if (ctx->resilient) {
2156                 if (ses->server->vals->protocol_id == 0) {
2157                         cifs_dbg(VFS,
2158                              "SMB2.1 or later required for resilient handles\n");
2159                         rc = -EOPNOTSUPP;
2160                         goto out_fail;
2161                 }
2162                 tcon->use_resilient = true;
2163         }
2164 #ifdef CONFIG_CIFS_SWN_UPCALL
2165         tcon->use_witness = false;
2166         if (ctx->witness) {
2167                 if (ses->server->vals->protocol_id >= SMB30_PROT_ID) {
2168                         if (tcon->capabilities & SMB2_SHARE_CAP_CLUSTER) {
2169                                 /*
2170                                  * Set witness in use flag in first place
2171                                  * to retry registration in the echo task
2172                                  */
2173                                 tcon->use_witness = true;
2174                                 /* And try to register immediately */
2175                                 rc = cifs_swn_register(tcon);
2176                                 if (rc < 0) {
2177                                         cifs_dbg(VFS, "Failed to register for witness notifications: %d\n", rc);
2178                                         goto out_fail;
2179                                 }
2180                         } else {
2181                                 /* TODO: try to extend for non-cluster uses (eg multichannel) */
2182                                 cifs_dbg(VFS, "witness requested on mount but no CLUSTER capability on share\n");
2183                                 rc = -EOPNOTSUPP;
2184                                 goto out_fail;
2185                         }
2186                 } else {
2187                         cifs_dbg(VFS, "SMB3 or later required for witness option\n");
2188                         rc = -EOPNOTSUPP;
2189                         goto out_fail;
2190                 }
2191         }
2192 #endif
2193
2194         /* If the user really knows what they are doing they can override */
2195         if (tcon->share_flags & SMB2_SHAREFLAG_NO_CACHING) {
2196                 if (ctx->cache_ro)
2197                         cifs_dbg(VFS, "cache=ro requested on mount but NO_CACHING flag set on share\n");
2198                 else if (ctx->cache_rw)
2199                         cifs_dbg(VFS, "cache=singleclient requested on mount but NO_CACHING flag set on share\n");
2200         }
2201
2202         if (ctx->no_lease) {
2203                 if (ses->server->vals->protocol_id == 0) {
2204                         cifs_dbg(VFS,
2205                                 "SMB2 or later required for nolease option\n");
2206                         rc = -EOPNOTSUPP;
2207                         goto out_fail;
2208                 } else
2209                         tcon->no_lease = ctx->no_lease;
2210         }
2211
2212         /*
2213          * We can have only one retry value for a connection to a share so for
2214          * resources mounted more than once to the same server share the last
2215          * value passed in for the retry flag is used.
2216          */
2217         tcon->retry = ctx->retry;
2218         tcon->nocase = ctx->nocase;
2219         if (ses->server->capabilities & SMB2_GLOBAL_CAP_DIRECTORY_LEASING)
2220                 tcon->nohandlecache = ctx->nohandlecache;
2221         else
2222                 tcon->nohandlecache = true;
2223         tcon->nodelete = ctx->nodelete;
2224         tcon->local_lease = ctx->local_lease;
2225         INIT_LIST_HEAD(&tcon->pending_opens);
2226
2227         spin_lock(&cifs_tcp_ses_lock);
2228         list_add(&tcon->tcon_list, &ses->tcon_list);
2229         spin_unlock(&cifs_tcp_ses_lock);
2230
2231         cifs_fscache_get_super_cookie(tcon);
2232
2233         return tcon;
2234
2235 out_fail:
2236         tconInfoFree(tcon);
2237         return ERR_PTR(rc);
2238 }
2239
2240 void
2241 cifs_put_tlink(struct tcon_link *tlink)
2242 {
2243         if (!tlink || IS_ERR(tlink))
2244                 return;
2245
2246         if (!atomic_dec_and_test(&tlink->tl_count) ||
2247             test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2248                 tlink->tl_time = jiffies;
2249                 return;
2250         }
2251
2252         if (!IS_ERR(tlink_tcon(tlink)))
2253                 cifs_put_tcon(tlink_tcon(tlink));
2254         kfree(tlink);
2255         return;
2256 }
2257
2258 static int
2259 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2260 {
2261         struct cifs_sb_info *old = CIFS_SB(sb);
2262         struct cifs_sb_info *new = mnt_data->cifs_sb;
2263         unsigned int oldflags = old->mnt_cifs_flags & CIFS_MOUNT_MASK;
2264         unsigned int newflags = new->mnt_cifs_flags & CIFS_MOUNT_MASK;
2265
2266         if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2267                 return 0;
2268
2269         if (old->mnt_cifs_serverino_autodisabled)
2270                 newflags &= ~CIFS_MOUNT_SERVER_INUM;
2271
2272         if (oldflags != newflags)
2273                 return 0;
2274
2275         /*
2276          * We want to share sb only if we don't specify an r/wsize or
2277          * specified r/wsize is greater than or equal to existing one.
2278          */
2279         if (new->ctx->wsize && new->ctx->wsize < old->ctx->wsize)
2280                 return 0;
2281
2282         if (new->ctx->rsize && new->ctx->rsize < old->ctx->rsize)
2283                 return 0;
2284
2285         if (!uid_eq(old->ctx->linux_uid, new->ctx->linux_uid) ||
2286             !gid_eq(old->ctx->linux_gid, new->ctx->linux_gid))
2287                 return 0;
2288
2289         if (old->ctx->file_mode != new->ctx->file_mode ||
2290             old->ctx->dir_mode != new->ctx->dir_mode)
2291                 return 0;
2292
2293         if (strcmp(old->local_nls->charset, new->local_nls->charset))
2294                 return 0;
2295
2296         if (old->ctx->acregmax != new->ctx->acregmax)
2297                 return 0;
2298         if (old->ctx->acdirmax != new->ctx->acdirmax)
2299                 return 0;
2300
2301         return 1;
2302 }
2303
2304 static int
2305 match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2306 {
2307         struct cifs_sb_info *old = CIFS_SB(sb);
2308         struct cifs_sb_info *new = mnt_data->cifs_sb;
2309         bool old_set = (old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) &&
2310                 old->prepath;
2311         bool new_set = (new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) &&
2312                 new->prepath;
2313
2314         if (old_set && new_set && !strcmp(new->prepath, old->prepath))
2315                 return 1;
2316         else if (!old_set && !new_set)
2317                 return 1;
2318
2319         return 0;
2320 }
2321
2322 int
2323 cifs_match_super(struct super_block *sb, void *data)
2324 {
2325         struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2326         struct smb3_fs_context *ctx;
2327         struct cifs_sb_info *cifs_sb;
2328         struct TCP_Server_Info *tcp_srv;
2329         struct cifs_ses *ses;
2330         struct cifs_tcon *tcon;
2331         struct tcon_link *tlink;
2332         int rc = 0;
2333
2334         spin_lock(&cifs_tcp_ses_lock);
2335         cifs_sb = CIFS_SB(sb);
2336         tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2337         if (IS_ERR(tlink)) {
2338                 spin_unlock(&cifs_tcp_ses_lock);
2339                 return rc;
2340         }
2341         tcon = tlink_tcon(tlink);
2342         ses = tcon->ses;
2343         tcp_srv = ses->server;
2344
2345         ctx = mnt_data->ctx;
2346
2347         if (!match_server(tcp_srv, ctx) ||
2348             !match_session(ses, ctx) ||
2349             !match_tcon(tcon, ctx) ||
2350             !match_prepath(sb, mnt_data)) {
2351                 rc = 0;
2352                 goto out;
2353         }
2354
2355         rc = compare_mount_options(sb, mnt_data);
2356 out:
2357         spin_unlock(&cifs_tcp_ses_lock);
2358         cifs_put_tlink(tlink);
2359         return rc;
2360 }
2361
2362 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2363 static struct lock_class_key cifs_key[2];
2364 static struct lock_class_key cifs_slock_key[2];
2365
2366 static inline void
2367 cifs_reclassify_socket4(struct socket *sock)
2368 {
2369         struct sock *sk = sock->sk;
2370         BUG_ON(!sock_allow_reclassification(sk));
2371         sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2372                 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2373 }
2374
2375 static inline void
2376 cifs_reclassify_socket6(struct socket *sock)
2377 {
2378         struct sock *sk = sock->sk;
2379         BUG_ON(!sock_allow_reclassification(sk));
2380         sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2381                 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2382 }
2383 #else
2384 static inline void
2385 cifs_reclassify_socket4(struct socket *sock)
2386 {
2387 }
2388
2389 static inline void
2390 cifs_reclassify_socket6(struct socket *sock)
2391 {
2392 }
2393 #endif
2394
2395 /* See RFC1001 section 14 on representation of Netbios names */
2396 static void rfc1002mangle(char *target, char *source, unsigned int length)
2397 {
2398         unsigned int i, j;
2399
2400         for (i = 0, j = 0; i < (length); i++) {
2401                 /* mask a nibble at a time and encode */
2402                 target[j] = 'A' + (0x0F & (source[i] >> 4));
2403                 target[j+1] = 'A' + (0x0F & source[i]);
2404                 j += 2;
2405         }
2406
2407 }
2408
2409 static int
2410 bind_socket(struct TCP_Server_Info *server)
2411 {
2412         int rc = 0;
2413         if (server->srcaddr.ss_family != AF_UNSPEC) {
2414                 /* Bind to the specified local IP address */
2415                 struct socket *socket = server->ssocket;
2416                 rc = socket->ops->bind(socket,
2417                                        (struct sockaddr *) &server->srcaddr,
2418                                        sizeof(server->srcaddr));
2419                 if (rc < 0) {
2420                         struct sockaddr_in *saddr4;
2421                         struct sockaddr_in6 *saddr6;
2422                         saddr4 = (struct sockaddr_in *)&server->srcaddr;
2423                         saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2424                         if (saddr6->sin6_family == AF_INET6)
2425                                 cifs_server_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
2426                                          &saddr6->sin6_addr, rc);
2427                         else
2428                                 cifs_server_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
2429                                          &saddr4->sin_addr.s_addr, rc);
2430                 }
2431         }
2432         return rc;
2433 }
2434
2435 static int
2436 ip_rfc1001_connect(struct TCP_Server_Info *server)
2437 {
2438         int rc = 0;
2439         /*
2440          * some servers require RFC1001 sessinit before sending
2441          * negprot - BB check reconnection in case where second
2442          * sessinit is sent but no second negprot
2443          */
2444         struct rfc1002_session_packet *ses_init_buf;
2445         struct smb_hdr *smb_buf;
2446         ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2447                                GFP_KERNEL);
2448         if (ses_init_buf) {
2449                 ses_init_buf->trailer.session_req.called_len = 32;
2450
2451                 if (server->server_RFC1001_name[0] != 0)
2452                         rfc1002mangle(ses_init_buf->trailer.
2453                                       session_req.called_name,
2454                                       server->server_RFC1001_name,
2455                                       RFC1001_NAME_LEN_WITH_NULL);
2456                 else
2457                         rfc1002mangle(ses_init_buf->trailer.
2458                                       session_req.called_name,
2459                                       DEFAULT_CIFS_CALLED_NAME,
2460                                       RFC1001_NAME_LEN_WITH_NULL);
2461
2462                 ses_init_buf->trailer.session_req.calling_len = 32;
2463
2464                 /*
2465                  * calling name ends in null (byte 16) from old smb
2466                  * convention.
2467                  */
2468                 if (server->workstation_RFC1001_name[0] != 0)
2469                         rfc1002mangle(ses_init_buf->trailer.
2470                                       session_req.calling_name,
2471                                       server->workstation_RFC1001_name,
2472                                       RFC1001_NAME_LEN_WITH_NULL);
2473                 else
2474                         rfc1002mangle(ses_init_buf->trailer.
2475                                       session_req.calling_name,
2476                                       "LINUX_CIFS_CLNT",
2477                                       RFC1001_NAME_LEN_WITH_NULL);
2478
2479                 ses_init_buf->trailer.session_req.scope1 = 0;
2480                 ses_init_buf->trailer.session_req.scope2 = 0;
2481                 smb_buf = (struct smb_hdr *)ses_init_buf;
2482
2483                 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2484                 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
2485                 rc = smb_send(server, smb_buf, 0x44);
2486                 kfree(ses_init_buf);
2487                 /*
2488                  * RFC1001 layer in at least one server
2489                  * requires very short break before negprot
2490                  * presumably because not expecting negprot
2491                  * to follow so fast.  This is a simple
2492                  * solution that works without
2493                  * complicating the code and causes no
2494                  * significant slowing down on mount
2495                  * for everyone else
2496                  */
2497                 usleep_range(1000, 2000);
2498         }
2499         /*
2500          * else the negprot may still work without this
2501          * even though malloc failed
2502          */
2503
2504         return rc;
2505 }
2506
2507 static int
2508 generic_ip_connect(struct TCP_Server_Info *server)
2509 {
2510         int rc = 0;
2511         __be16 sport;
2512         int slen, sfamily;
2513         struct socket *socket = server->ssocket;
2514         struct sockaddr *saddr;
2515
2516         saddr = (struct sockaddr *) &server->dstaddr;
2517
2518         if (server->dstaddr.ss_family == AF_INET6) {
2519                 struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)&server->dstaddr;
2520
2521                 sport = ipv6->sin6_port;
2522                 slen = sizeof(struct sockaddr_in6);
2523                 sfamily = AF_INET6;
2524                 cifs_dbg(FYI, "%s: connecting to [%pI6]:%d\n", __func__, &ipv6->sin6_addr,
2525                                 ntohs(sport));
2526         } else {
2527                 struct sockaddr_in *ipv4 = (struct sockaddr_in *)&server->dstaddr;
2528
2529                 sport = ipv4->sin_port;
2530                 slen = sizeof(struct sockaddr_in);
2531                 sfamily = AF_INET;
2532                 cifs_dbg(FYI, "%s: connecting to %pI4:%d\n", __func__, &ipv4->sin_addr,
2533                                 ntohs(sport));
2534         }
2535
2536         if (socket == NULL) {
2537                 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2538                                    IPPROTO_TCP, &socket, 1);
2539                 if (rc < 0) {
2540                         cifs_server_dbg(VFS, "Error %d creating socket\n", rc);
2541                         server->ssocket = NULL;
2542                         return rc;
2543                 }
2544
2545                 /* BB other socket options to set KEEPALIVE, NODELAY? */
2546                 cifs_dbg(FYI, "Socket created\n");
2547                 server->ssocket = socket;
2548                 socket->sk->sk_allocation = GFP_NOFS;
2549                 if (sfamily == AF_INET6)
2550                         cifs_reclassify_socket6(socket);
2551                 else
2552                         cifs_reclassify_socket4(socket);
2553         }
2554
2555         rc = bind_socket(server);
2556         if (rc < 0)
2557                 return rc;
2558
2559         /*
2560          * Eventually check for other socket options to change from
2561          * the default. sock_setsockopt not used because it expects
2562          * user space buffer
2563          */
2564         socket->sk->sk_rcvtimeo = 7 * HZ;
2565         socket->sk->sk_sndtimeo = 5 * HZ;
2566
2567         /* make the bufsizes depend on wsize/rsize and max requests */
2568         if (server->noautotune) {
2569                 if (socket->sk->sk_sndbuf < (200 * 1024))
2570                         socket->sk->sk_sndbuf = 200 * 1024;
2571                 if (socket->sk->sk_rcvbuf < (140 * 1024))
2572                         socket->sk->sk_rcvbuf = 140 * 1024;
2573         }
2574
2575         if (server->tcp_nodelay)
2576                 tcp_sock_set_nodelay(socket->sk);
2577
2578         cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
2579                  socket->sk->sk_sndbuf,
2580                  socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2581
2582         rc = socket->ops->connect(socket, saddr, slen,
2583                                   server->noblockcnt ? O_NONBLOCK : 0);
2584         /*
2585          * When mounting SMB root file systems, we do not want to block in
2586          * connect. Otherwise bail out and then let cifs_reconnect() perform
2587          * reconnect failover - if possible.
2588          */
2589         if (server->noblockcnt && rc == -EINPROGRESS)
2590                 rc = 0;
2591         if (rc < 0) {
2592                 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
2593                 sock_release(socket);
2594                 server->ssocket = NULL;
2595                 return rc;
2596         }
2597
2598         if (sport == htons(RFC1001_PORT))
2599                 rc = ip_rfc1001_connect(server);
2600
2601         return rc;
2602 }
2603
2604 static int
2605 ip_connect(struct TCP_Server_Info *server)
2606 {
2607         __be16 *sport;
2608         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2609         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2610
2611         if (server->dstaddr.ss_family == AF_INET6)
2612                 sport = &addr6->sin6_port;
2613         else
2614                 sport = &addr->sin_port;
2615
2616         if (*sport == 0) {
2617                 int rc;
2618
2619                 /* try with 445 port at first */
2620                 *sport = htons(CIFS_PORT);
2621
2622                 rc = generic_ip_connect(server);
2623                 if (rc >= 0)
2624                         return rc;
2625
2626                 /* if it failed, try with 139 port */
2627                 *sport = htons(RFC1001_PORT);
2628         }
2629
2630         return generic_ip_connect(server);
2631 }
2632
2633 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
2634                           struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx)
2635 {
2636         /*
2637          * If we are reconnecting then should we check to see if
2638          * any requested capabilities changed locally e.g. via
2639          * remount but we can not do much about it here
2640          * if they have (even if we could detect it by the following)
2641          * Perhaps we could add a backpointer to array of sb from tcon
2642          * or if we change to make all sb to same share the same
2643          * sb as NFS - then we only have one backpointer to sb.
2644          * What if we wanted to mount the server share twice once with
2645          * and once without posixacls or posix paths?
2646          */
2647         __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2648
2649         if (ctx && ctx->no_linux_ext) {
2650                 tcon->fsUnixInfo.Capability = 0;
2651                 tcon->unix_ext = 0; /* Unix Extensions disabled */
2652                 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
2653                 return;
2654         } else if (ctx)
2655                 tcon->unix_ext = 1; /* Unix Extensions supported */
2656
2657         if (!tcon->unix_ext) {
2658                 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
2659                 return;
2660         }
2661
2662         if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
2663                 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2664                 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
2665                 /*
2666                  * check for reconnect case in which we do not
2667                  * want to change the mount behavior if we can avoid it
2668                  */
2669                 if (ctx == NULL) {
2670                         /*
2671                          * turn off POSIX ACL and PATHNAMES if not set
2672                          * originally at mount time
2673                          */
2674                         if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2675                                 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2676                         if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2677                                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2678                                         cifs_dbg(VFS, "POSIXPATH support change\n");
2679                                 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2680                         } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2681                                 cifs_dbg(VFS, "possible reconnect error\n");
2682                                 cifs_dbg(VFS, "server disabled POSIX path support\n");
2683                         }
2684                 }
2685
2686                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2687                         cifs_dbg(VFS, "per-share encryption not supported yet\n");
2688
2689                 cap &= CIFS_UNIX_CAP_MASK;
2690                 if (ctx && ctx->no_psx_acl)
2691                         cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2692                 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
2693                         cifs_dbg(FYI, "negotiated posix acl support\n");
2694                         if (cifs_sb)
2695                                 cifs_sb->mnt_cifs_flags |=
2696                                         CIFS_MOUNT_POSIXACL;
2697                 }
2698
2699                 if (ctx && ctx->posix_paths == 0)
2700                         cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2701                 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2702                         cifs_dbg(FYI, "negotiate posix pathnames\n");
2703                         if (cifs_sb)
2704                                 cifs_sb->mnt_cifs_flags |=
2705                                         CIFS_MOUNT_POSIX_PATHS;
2706                 }
2707
2708                 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
2709 #ifdef CONFIG_CIFS_DEBUG2
2710                 if (cap & CIFS_UNIX_FCNTL_CAP)
2711                         cifs_dbg(FYI, "FCNTL cap\n");
2712                 if (cap & CIFS_UNIX_EXTATTR_CAP)
2713                         cifs_dbg(FYI, "EXTATTR cap\n");
2714                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2715                         cifs_dbg(FYI, "POSIX path cap\n");
2716                 if (cap & CIFS_UNIX_XATTR_CAP)
2717                         cifs_dbg(FYI, "XATTR cap\n");
2718                 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
2719                         cifs_dbg(FYI, "POSIX ACL cap\n");
2720                 if (cap & CIFS_UNIX_LARGE_READ_CAP)
2721                         cifs_dbg(FYI, "very large read cap\n");
2722                 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
2723                         cifs_dbg(FYI, "very large write cap\n");
2724                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
2725                         cifs_dbg(FYI, "transport encryption cap\n");
2726                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2727                         cifs_dbg(FYI, "mandatory transport encryption cap\n");
2728 #endif /* CIFS_DEBUG2 */
2729                 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
2730                         if (ctx == NULL)
2731                                 cifs_dbg(FYI, "resetting capabilities failed\n");
2732                         else
2733                                 cifs_dbg(VFS, "Negotiating Unix capabilities with the server failed. Consider mounting with the Unix Extensions disabled if problems are found by specifying the nounix mount option.\n");
2734
2735                 }
2736         }
2737 }
2738
2739 int cifs_setup_cifs_sb(struct cifs_sb_info *cifs_sb)
2740 {
2741         struct smb3_fs_context *ctx = cifs_sb->ctx;
2742
2743         INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2744
2745         spin_lock_init(&cifs_sb->tlink_tree_lock);
2746         cifs_sb->tlink_tree = RB_ROOT;
2747
2748         cifs_dbg(FYI, "file mode: %04ho  dir mode: %04ho\n",
2749                  ctx->file_mode, ctx->dir_mode);
2750
2751         /* this is needed for ASCII cp to Unicode converts */
2752         if (ctx->iocharset == NULL) {
2753                 /* load_nls_default cannot return null */
2754                 cifs_sb->local_nls = load_nls_default();
2755         } else {
2756                 cifs_sb->local_nls = load_nls(ctx->iocharset);
2757                 if (cifs_sb->local_nls == NULL) {
2758                         cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
2759                                  ctx->iocharset);
2760                         return -ELIBACC;
2761                 }
2762         }
2763         ctx->local_nls = cifs_sb->local_nls;
2764
2765         smb3_update_mnt_flags(cifs_sb);
2766
2767         if (ctx->direct_io)
2768                 cifs_dbg(FYI, "mounting share using direct i/o\n");
2769         if (ctx->cache_ro) {
2770                 cifs_dbg(VFS, "mounting share with read only caching. Ensure that the share will not be modified while in use.\n");
2771                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RO_CACHE;
2772         } else if (ctx->cache_rw) {
2773                 cifs_dbg(VFS, "mounting share in single client RW caching mode. Ensure that no other systems will be accessing the share.\n");
2774                 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_RO_CACHE |
2775                                             CIFS_MOUNT_RW_CACHE);
2776         }
2777
2778         if ((ctx->cifs_acl) && (ctx->dynperm))
2779                 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
2780
2781         if (ctx->prepath) {
2782                 cifs_sb->prepath = kstrdup(ctx->prepath, GFP_KERNEL);
2783                 if (cifs_sb->prepath == NULL)
2784                         return -ENOMEM;
2785                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
2786         }
2787
2788         return 0;
2789 }
2790
2791 /* Release all succeed connections */
2792 static inline void mount_put_conns(struct cifs_sb_info *cifs_sb,
2793                                    unsigned int xid,
2794                                    struct TCP_Server_Info *server,
2795                                    struct cifs_ses *ses, struct cifs_tcon *tcon)
2796 {
2797         int rc = 0;
2798
2799         if (tcon)
2800                 cifs_put_tcon(tcon);
2801         else if (ses)
2802                 cifs_put_smb_ses(ses);
2803         else if (server)
2804                 cifs_put_tcp_session(server, 0);
2805         cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
2806         free_xid(xid);
2807 }
2808
2809 /* Get connections for tcp, ses and tcon */
2810 static int mount_get_conns(struct smb3_fs_context *ctx, struct cifs_sb_info *cifs_sb,
2811                            unsigned int *xid,
2812                            struct TCP_Server_Info **nserver,
2813                            struct cifs_ses **nses, struct cifs_tcon **ntcon)
2814 {
2815         int rc = 0;
2816         struct TCP_Server_Info *server;
2817         struct cifs_ses *ses;
2818         struct cifs_tcon *tcon;
2819
2820         *nserver = NULL;
2821         *nses = NULL;
2822         *ntcon = NULL;
2823
2824         *xid = get_xid();
2825
2826         /* get a reference to a tcp session */
2827         server = cifs_get_tcp_session(ctx);
2828         if (IS_ERR(server)) {
2829                 rc = PTR_ERR(server);
2830                 return rc;
2831         }
2832
2833         *nserver = server;
2834
2835         if ((ctx->max_credits < 20) || (ctx->max_credits > 60000))
2836                 server->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
2837         else
2838                 server->max_credits = ctx->max_credits;
2839
2840         /* get a reference to a SMB session */
2841         ses = cifs_get_smb_ses(server, ctx);
2842         if (IS_ERR(ses)) {
2843                 rc = PTR_ERR(ses);
2844                 return rc;
2845         }
2846
2847         *nses = ses;
2848
2849         if ((ctx->persistent == true) && (!(ses->server->capabilities &
2850                                             SMB2_GLOBAL_CAP_PERSISTENT_HANDLES))) {
2851                 cifs_server_dbg(VFS, "persistent handles not supported by server\n");
2852                 return -EOPNOTSUPP;
2853         }
2854
2855         /* search for existing tcon to this server share */
2856         tcon = cifs_get_tcon(ses, ctx);
2857         if (IS_ERR(tcon)) {
2858                 rc = PTR_ERR(tcon);
2859                 return rc;
2860         }
2861
2862         *ntcon = tcon;
2863
2864         /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
2865         if (tcon->posix_extensions)
2866                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
2867
2868         /* tell server which Unix caps we support */
2869         if (cap_unix(tcon->ses)) {
2870                 /*
2871                  * reset of caps checks mount to see if unix extensions disabled
2872                  * for just this mount.
2873                  */
2874                 reset_cifs_unix_caps(*xid, tcon, cifs_sb, ctx);
2875                 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
2876                     (le64_to_cpu(tcon->fsUnixInfo.Capability) &
2877                      CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP))
2878                         return -EACCES;
2879         } else
2880                 tcon->unix_ext = 0; /* server does not support them */
2881
2882         /* do not care if a following call succeed - informational */
2883         if (!tcon->pipe && server->ops->qfs_tcon) {
2884                 server->ops->qfs_tcon(*xid, tcon, cifs_sb);
2885                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE) {
2886                         if (tcon->fsDevInfo.DeviceCharacteristics &
2887                             cpu_to_le32(FILE_READ_ONLY_DEVICE))
2888                                 cifs_dbg(VFS, "mounted to read only share\n");
2889                         else if ((cifs_sb->mnt_cifs_flags &
2890                                   CIFS_MOUNT_RW_CACHE) == 0)
2891                                 cifs_dbg(VFS, "read only mount of RW share\n");
2892                         /* no need to log a RW mount of a typical RW share */
2893                 }
2894         }
2895
2896         /*
2897          * Clamp the rsize/wsize mount arguments if they are too big for the server
2898          * and set the rsize/wsize to the negotiated values if not passed in by
2899          * the user on mount
2900          */
2901         if ((cifs_sb->ctx->wsize == 0) ||
2902             (cifs_sb->ctx->wsize > server->ops->negotiate_wsize(tcon, ctx)))
2903                 cifs_sb->ctx->wsize = server->ops->negotiate_wsize(tcon, ctx);
2904         if ((cifs_sb->ctx->rsize == 0) ||
2905             (cifs_sb->ctx->rsize > server->ops->negotiate_rsize(tcon, ctx)))
2906                 cifs_sb->ctx->rsize = server->ops->negotiate_rsize(tcon, ctx);
2907
2908         return 0;
2909 }
2910
2911 static int mount_setup_tlink(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses,
2912                              struct cifs_tcon *tcon)
2913 {
2914         struct tcon_link *tlink;
2915
2916         /* hang the tcon off of the superblock */
2917         tlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
2918         if (tlink == NULL)
2919                 return -ENOMEM;
2920
2921         tlink->tl_uid = ses->linux_uid;
2922         tlink->tl_tcon = tcon;
2923         tlink->tl_time = jiffies;
2924         set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
2925         set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
2926
2927         cifs_sb->master_tlink = tlink;
2928         spin_lock(&cifs_sb->tlink_tree_lock);
2929         tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
2930         spin_unlock(&cifs_sb->tlink_tree_lock);
2931
2932         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
2933                                 TLINK_IDLE_EXPIRE);
2934         return 0;
2935 }
2936
2937 #ifdef CONFIG_CIFS_DFS_UPCALL
2938 /*
2939  * cifs_build_path_to_root returns full path to root when we do not have an
2940  * existing connection (tcon)
2941  */
2942 static char *
2943 build_unc_path_to_root(const struct smb3_fs_context *ctx,
2944                        const struct cifs_sb_info *cifs_sb, bool useppath)
2945 {
2946         char *full_path, *pos;
2947         unsigned int pplen = useppath && ctx->prepath ?
2948                 strlen(ctx->prepath) + 1 : 0;
2949         unsigned int unc_len = strnlen(ctx->UNC, MAX_TREE_SIZE + 1);
2950
2951         if (unc_len > MAX_TREE_SIZE)
2952                 return ERR_PTR(-EINVAL);
2953
2954         full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
2955         if (full_path == NULL)
2956                 return ERR_PTR(-ENOMEM);
2957
2958         memcpy(full_path, ctx->UNC, unc_len);
2959         pos = full_path + unc_len;
2960
2961         if (pplen) {
2962                 *pos = CIFS_DIR_SEP(cifs_sb);
2963                 memcpy(pos + 1, ctx->prepath, pplen);
2964                 pos += pplen;
2965         }
2966
2967         *pos = '\0'; /* add trailing null */
2968         convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
2969         cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
2970         return full_path;
2971 }
2972
2973 /**
2974  * expand_dfs_referral - Perform a dfs referral query and update the cifs_sb
2975  *
2976  * If a referral is found, cifs_sb->ctx->mount_options will be (re-)allocated
2977  * to a string containing updated options for the submount.  Otherwise it
2978  * will be left untouched.
2979  *
2980  * Returns the rc from get_dfs_path to the caller, which can be used to
2981  * determine whether there were referrals.
2982  */
2983 static int
2984 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
2985                     struct smb3_fs_context *ctx, struct cifs_sb_info *cifs_sb,
2986                     char *ref_path)
2987 {
2988         int rc;
2989         struct dfs_info3_param referral = {0};
2990         char *full_path = NULL, *mdata = NULL;
2991
2992         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
2993                 return -EREMOTE;
2994
2995         full_path = build_unc_path_to_root(ctx, cifs_sb, true);
2996         if (IS_ERR(full_path))
2997                 return PTR_ERR(full_path);
2998
2999         rc = dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb),
3000                             ref_path, &referral, NULL);
3001         if (!rc) {
3002                 char *fake_devname = NULL;
3003
3004                 mdata = cifs_compose_mount_options(cifs_sb->ctx->mount_options,
3005                                                    full_path + 1, &referral,
3006                                                    &fake_devname);
3007                 free_dfs_info_param(&referral);
3008
3009                 if (IS_ERR(mdata)) {
3010                         rc = PTR_ERR(mdata);
3011                         mdata = NULL;
3012                 } else {
3013                         /*
3014                          * We can not clear out the whole structure since we
3015                          * no longer have an explicit function to parse
3016                          * a mount-string. Instead we need to clear out the
3017                          * individual fields that are no longer valid.
3018                          */
3019                         kfree(ctx->prepath);
3020                         ctx->prepath = NULL;
3021                         rc = cifs_setup_volume_info(ctx, mdata, fake_devname);
3022                 }
3023                 kfree(fake_devname);
3024                 kfree(cifs_sb->ctx->mount_options);
3025                 cifs_sb->ctx->mount_options = mdata;
3026         }
3027         kfree(full_path);
3028         return rc;
3029 }
3030
3031 static inline int get_next_dfs_tgt(const char *path,
3032                                    struct dfs_cache_tgt_list *tgt_list,
3033                                    struct dfs_cache_tgt_iterator **tgt_it)
3034 {
3035         if (!*tgt_it)
3036                 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
3037         else
3038                 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
3039         return !*tgt_it ? -EHOSTDOWN : 0;
3040 }
3041
3042 static int update_vol_info(const struct dfs_cache_tgt_iterator *tgt_it,
3043                            struct smb3_fs_context *fake_ctx, struct smb3_fs_context *ctx)
3044 {
3045         const char *tgt = dfs_cache_get_tgt_name(tgt_it);
3046         int len = strlen(tgt) + 2;
3047         char *new_unc;
3048
3049         new_unc = kmalloc(len, GFP_KERNEL);
3050         if (!new_unc)
3051                 return -ENOMEM;
3052         scnprintf(new_unc, len, "\\%s", tgt);
3053
3054         kfree(ctx->UNC);
3055         ctx->UNC = new_unc;
3056
3057         if (fake_ctx->prepath) {
3058                 kfree(ctx->prepath);
3059                 ctx->prepath = fake_ctx->prepath;
3060                 fake_ctx->prepath = NULL;
3061         }
3062         memcpy(&ctx->dstaddr, &fake_ctx->dstaddr, sizeof(ctx->dstaddr));
3063
3064         return 0;
3065 }
3066
3067 static int do_dfs_failover(const char *path, const char *full_path, struct cifs_sb_info *cifs_sb,
3068                            struct smb3_fs_context *ctx, struct cifs_ses *root_ses,
3069                            unsigned int *xid, struct TCP_Server_Info **server,
3070                            struct cifs_ses **ses, struct cifs_tcon **tcon)
3071 {
3072         int rc;
3073         struct dfs_cache_tgt_list tgt_list = {0};
3074         struct dfs_cache_tgt_iterator *tgt_it = NULL;
3075         struct smb3_fs_context tmp_ctx = {NULL};
3076
3077         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
3078                 return -EOPNOTSUPP;
3079
3080         cifs_dbg(FYI, "%s: path=%s full_path=%s\n", __func__, path, full_path);
3081
3082         rc = dfs_cache_noreq_find(path, NULL, &tgt_list);
3083         if (rc)
3084                 return rc;
3085         /*
3086          * We use a 'tmp_ctx' here because we need pass it down to the mount_{get,put} functions to
3087          * test connection against new DFS targets.
3088          */
3089         rc = smb3_fs_context_dup(&tmp_ctx, ctx);
3090         if (rc)
3091                 goto out;
3092
3093         for (;;) {
3094                 struct dfs_info3_param ref = {0};
3095                 char *fake_devname = NULL, *mdata = NULL;
3096
3097                 /* Get next DFS target server - if any */
3098                 rc = get_next_dfs_tgt(path, &tgt_list, &tgt_it);
3099                 if (rc)
3100                         break;
3101
3102                 rc = dfs_cache_get_tgt_referral(path, tgt_it, &ref);
3103                 if (rc)
3104                         break;
3105
3106                 cifs_dbg(FYI, "%s: old ctx: UNC=%s prepath=%s\n", __func__, tmp_ctx.UNC,
3107                          tmp_ctx.prepath);
3108
3109                 mdata = cifs_compose_mount_options(cifs_sb->ctx->mount_options, full_path + 1, &ref,
3110                                                    &fake_devname);
3111                 free_dfs_info_param(&ref);
3112
3113                 if (IS_ERR(mdata)) {
3114                         rc = PTR_ERR(mdata);
3115                         mdata = NULL;
3116                 } else
3117                         rc = cifs_setup_volume_info(&tmp_ctx, mdata, fake_devname);
3118
3119                 kfree(mdata);
3120                 kfree(fake_devname);
3121
3122                 if (rc)
3123                         break;
3124
3125                 cifs_dbg(FYI, "%s: new ctx: UNC=%s prepath=%s\n", __func__, tmp_ctx.UNC,
3126                          tmp_ctx.prepath);
3127
3128                 mount_put_conns(cifs_sb, *xid, *server, *ses, *tcon);
3129                 rc = mount_get_conns(&tmp_ctx, cifs_sb, xid, server, ses, tcon);
3130                 if (!rc || (*server && *ses)) {
3131                         /*
3132                          * We were able to connect to new target server. Update current context with
3133                          * new target server.
3134                          */
3135                         rc = update_vol_info(tgt_it, &tmp_ctx, ctx);
3136                         break;
3137                 }
3138         }
3139         if (!rc) {
3140                 cifs_dbg(FYI, "%s: final ctx: UNC=%s prepath=%s\n", __func__, tmp_ctx.UNC,
3141                          tmp_ctx.prepath);
3142                 /*
3143                  * Update DFS target hint in DFS referral cache with the target server we
3144                  * successfully reconnected to.
3145                  */
3146                 rc = dfs_cache_update_tgthint(*xid, root_ses ? root_ses : *ses, cifs_sb->local_nls,
3147                                               cifs_remap(cifs_sb), path, tgt_it);
3148         }
3149
3150 out:
3151         smb3_cleanup_fs_context_contents(&tmp_ctx);
3152         dfs_cache_free_tgts(&tgt_list);
3153         return rc;
3154 }
3155 #endif
3156
3157 /* TODO: all callers to this are broken. We are not parsing mount_options here
3158  * we should pass a clone of the original context?
3159  */
3160 int
3161 cifs_setup_volume_info(struct smb3_fs_context *ctx, const char *mntopts, const char *devname)
3162 {
3163         int rc = 0;
3164
3165         smb3_parse_devname(devname, ctx);
3166
3167         if (mntopts) {
3168                 char *ip;
3169
3170                 cifs_dbg(FYI, "%s: mntopts=%s\n", __func__, mntopts);
3171                 rc = smb3_parse_opt(mntopts, "ip", &ip);
3172                 if (!rc && !cifs_convert_address((struct sockaddr *)&ctx->dstaddr, ip,
3173                                                  strlen(ip))) {
3174                         cifs_dbg(VFS, "%s: failed to convert ip address\n", __func__);
3175                         return -EINVAL;
3176                 }
3177         }
3178
3179         if (ctx->nullauth) {
3180                 cifs_dbg(FYI, "Anonymous login\n");
3181                 kfree(ctx->username);
3182                 ctx->username = NULL;
3183         } else if (ctx->username) {
3184                 /* BB fixme parse for domain name here */
3185                 cifs_dbg(FYI, "Username: %s\n", ctx->username);
3186         } else {
3187                 cifs_dbg(VFS, "No username specified\n");
3188         /* In userspace mount helper we can get user name from alternate
3189            locations such as env variables and files on disk */
3190                 return -EINVAL;
3191         }
3192
3193         return rc;
3194 }
3195
3196 static int
3197 cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
3198                                         unsigned int xid,
3199                                         struct cifs_tcon *tcon,
3200                                         struct cifs_sb_info *cifs_sb,
3201                                         char *full_path,
3202                                         int added_treename)
3203 {
3204         int rc;
3205         char *s;
3206         char sep, tmp;
3207         int skip = added_treename ? 1 : 0;
3208
3209         sep = CIFS_DIR_SEP(cifs_sb);
3210         s = full_path;
3211
3212         rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
3213         while (rc == 0) {
3214                 /* skip separators */
3215                 while (*s == sep)
3216                         s++;
3217                 if (!*s)
3218                         break;
3219                 /* next separator */
3220                 while (*s && *s != sep)
3221                         s++;
3222                 /*
3223                  * if the treename is added, we then have to skip the first
3224                  * part within the separators
3225                  */
3226                 if (skip) {
3227                         skip = 0;
3228                         continue;
3229                 }
3230                 /*
3231                  * temporarily null-terminate the path at the end of
3232                  * the current component
3233                  */
3234                 tmp = *s;
3235                 *s = 0;
3236                 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3237                                                      full_path);
3238                 *s = tmp;
3239         }
3240         return rc;
3241 }
3242
3243 /*
3244  * Check if path is remote (e.g. a DFS share). Return -EREMOTE if it is,
3245  * otherwise 0.
3246  */
3247 static int is_path_remote(struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx,
3248                           const unsigned int xid,
3249                           struct TCP_Server_Info *server,
3250                           struct cifs_tcon *tcon)
3251 {
3252         int rc;
3253         char *full_path;
3254
3255         if (!server->ops->is_path_accessible)
3256                 return -EOPNOTSUPP;
3257
3258         /*
3259          * cifs_build_path_to_root works only when we have a valid tcon
3260          */
3261         full_path = cifs_build_path_to_root(ctx, cifs_sb, tcon,
3262                                             tcon->Flags & SMB_SHARE_IS_IN_DFS);
3263         if (full_path == NULL)
3264                 return -ENOMEM;
3265
3266         cifs_dbg(FYI, "%s: full_path: %s\n", __func__, full_path);
3267
3268         rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3269                                              full_path);
3270         if (rc != 0 && rc != -EREMOTE) {
3271                 kfree(full_path);
3272                 return rc;
3273         }
3274
3275         if (rc != -EREMOTE) {
3276                 rc = cifs_are_all_path_components_accessible(server, xid, tcon,
3277                         cifs_sb, full_path, tcon->Flags & SMB_SHARE_IS_IN_DFS);
3278                 if (rc != 0) {
3279                         cifs_server_dbg(VFS, "cannot query dirs between root and final path, enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
3280                         cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
3281                         rc = 0;
3282                 }
3283         }
3284
3285         kfree(full_path);
3286         return rc;
3287 }
3288
3289 #ifdef CONFIG_CIFS_DFS_UPCALL
3290 static void set_root_ses(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses,
3291                          struct cifs_ses **root_ses)
3292 {
3293         if (ses) {
3294                 spin_lock(&cifs_tcp_ses_lock);
3295                 ses->ses_count++;
3296                 if (ses->tcon_ipc)
3297                         ses->tcon_ipc->remap = cifs_remap(cifs_sb);
3298                 spin_unlock(&cifs_tcp_ses_lock);
3299         }
3300         *root_ses = ses;
3301 }
3302
3303 static void put_root_ses(struct cifs_ses *ses)
3304 {
3305         if (ses)
3306                 cifs_put_smb_ses(ses);
3307 }
3308
3309 /* Set up next dfs prefix path in @dfs_path */
3310 static int next_dfs_prepath(struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx,
3311                             const unsigned int xid, struct TCP_Server_Info *server,
3312                             struct cifs_tcon *tcon, char **dfs_path)
3313 {
3314         char *path, *npath;
3315         int added_treename = is_tcon_dfs(tcon);
3316         int rc;
3317
3318         path = cifs_build_path_to_root(ctx, cifs_sb, tcon, added_treename);
3319         if (!path)
3320                 return -ENOMEM;
3321
3322         rc = is_path_remote(cifs_sb, ctx, xid, server, tcon);
3323         if (rc == -EREMOTE) {
3324                 struct smb3_fs_context v = {NULL};
3325                 /* if @path contains a tree name, skip it in the prefix path */
3326                 if (added_treename) {
3327                         rc = smb3_parse_devname(path, &v);
3328                         if (rc)
3329                                 goto out;
3330                         npath = build_unc_path_to_root(&v, cifs_sb, true);
3331                         smb3_cleanup_fs_context_contents(&v);
3332                 } else {
3333                         v.UNC = ctx->UNC;
3334                         v.prepath = path + 1;
3335                         npath = build_unc_path_to_root(&v, cifs_sb, true);
3336                 }
3337
3338                 if (IS_ERR(npath)) {
3339                         rc = PTR_ERR(npath);
3340                         goto out;
3341                 }
3342
3343                 kfree(*dfs_path);
3344                 *dfs_path = npath;
3345                 rc = -EREMOTE;
3346         }
3347
3348 out:
3349         kfree(path);
3350         return rc;
3351 }
3352
3353 /* Check if resolved targets can handle any DFS referrals */
3354 static int is_referral_server(const char *ref_path, struct cifs_tcon *tcon, bool *ref_server)
3355 {
3356         int rc;
3357         struct dfs_info3_param ref = {0};
3358
3359         if (is_tcon_dfs(tcon)) {
3360                 *ref_server = true;
3361         } else {
3362                 cifs_dbg(FYI, "%s: ref_path=%s\n", __func__, ref_path);
3363
3364                 rc = dfs_cache_noreq_find(ref_path, &ref, NULL);
3365                 if (rc) {
3366                         cifs_dbg(VFS, "%s: dfs_cache_noreq_find: failed (rc=%d)\n", __func__, rc);
3367                         return rc;
3368                 }
3369                 cifs_dbg(FYI, "%s: ref.flags=0x%x\n", __func__, ref.flags);
3370                 /*
3371                  * Check if all targets are capable of handling DFS referrals as per
3372                  * MS-DFSC 2.2.4 RESP_GET_DFS_REFERRAL.
3373                  */
3374                 *ref_server = !!(ref.flags & DFSREF_REFERRAL_SERVER);
3375                 free_dfs_info_param(&ref);
3376         }
3377         return 0;
3378 }
3379
3380 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx)
3381 {
3382         int rc = 0;
3383         unsigned int xid;
3384         struct TCP_Server_Info *server = NULL;
3385         struct cifs_ses *ses = NULL, *root_ses = NULL;
3386         struct cifs_tcon *tcon = NULL;
3387         int count = 0;
3388         char *ref_path = NULL, *full_path = NULL;
3389         char *oldmnt = NULL;
3390         char *mntdata = NULL;
3391         bool ref_server = false;
3392
3393         rc = mount_get_conns(ctx, cifs_sb, &xid, &server, &ses, &tcon);
3394         /*
3395          * If called with 'nodfs' mount option, then skip DFS resolving.  Otherwise unconditionally
3396          * try to get an DFS referral (even cached) to determine whether it is an DFS mount.
3397          *
3398          * Skip prefix path to provide support for DFS referrals from w2k8 servers which don't seem
3399          * to respond with PATH_NOT_COVERED to requests that include the prefix.
3400          */
3401         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS) ||
3402             dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb), ctx->UNC + 1, NULL,
3403                            NULL)) {
3404                 if (rc)
3405                         goto error;
3406                 /* Check if it is fully accessible and then mount it */
3407                 rc = is_path_remote(cifs_sb, ctx, xid, server, tcon);
3408                 if (!rc)
3409                         goto out;
3410                 if (rc != -EREMOTE)
3411                         goto error;
3412         }
3413         /* Save mount options */
3414         mntdata = kstrndup(cifs_sb->ctx->mount_options,
3415                            strlen(cifs_sb->ctx->mount_options), GFP_KERNEL);
3416         if (!mntdata) {
3417                 rc = -ENOMEM;
3418                 goto error;
3419         }
3420         /* Get path of DFS root */
3421         ref_path = build_unc_path_to_root(ctx, cifs_sb, false);
3422         if (IS_ERR(ref_path)) {
3423                 rc = PTR_ERR(ref_path);
3424                 ref_path = NULL;
3425                 goto error;
3426         }
3427
3428         set_root_ses(cifs_sb, ses, &root_ses);
3429         do {
3430                 /* Save full path of last DFS path we used to resolve final target server */
3431                 kfree(full_path);
3432                 full_path = build_unc_path_to_root(ctx, cifs_sb, !!count);
3433                 if (IS_ERR(full_path)) {
3434                         rc = PTR_ERR(full_path);
3435                         full_path = NULL;
3436                         break;
3437                 }
3438                 /* Chase referral */
3439                 oldmnt = cifs_sb->ctx->mount_options;
3440                 rc = expand_dfs_referral(xid, root_ses, ctx, cifs_sb, ref_path + 1);
3441                 if (rc)
3442                         break;
3443                 /* Connect to new DFS target only if we were redirected */
3444                 if (oldmnt != cifs_sb->ctx->mount_options) {
3445                         mount_put_conns(cifs_sb, xid, server, ses, tcon);
3446                         rc = mount_get_conns(ctx, cifs_sb, &xid, &server, &ses, &tcon);
3447                 }
3448                 if (rc && !server && !ses) {
3449                         /* Failed to connect. Try to connect to other targets in the referral. */
3450                         rc = do_dfs_failover(ref_path + 1, full_path, cifs_sb, ctx, root_ses, &xid,
3451                                              &server, &ses, &tcon);
3452                 }
3453                 if (rc == -EACCES || rc == -EOPNOTSUPP || !server || !ses)
3454                         break;
3455                 if (!tcon)
3456                         continue;
3457
3458                 /* Make sure that requests go through new root servers */
3459                 rc = is_referral_server(ref_path + 1, tcon, &ref_server);
3460                 if (rc)
3461                         break;
3462                 if (ref_server) {
3463                         put_root_ses(root_ses);
3464                         set_root_ses(cifs_sb, ses, &root_ses);
3465                 }
3466
3467                 /* Get next dfs path and then continue chasing them if -EREMOTE */
3468                 rc = next_dfs_prepath(cifs_sb, ctx, xid, server, tcon, &ref_path);
3469                 /* Prevent recursion on broken link referrals */
3470                 if (rc == -EREMOTE && ++count > MAX_NESTED_LINKS)
3471                         rc = -ELOOP;
3472         } while (rc == -EREMOTE);
3473
3474         if (rc)
3475                 goto error;
3476         put_root_ses(root_ses);
3477         root_ses = NULL;
3478         kfree(ref_path);
3479         ref_path = NULL;
3480         /*
3481          * Store DFS full path in both superblock and tree connect structures.
3482          *
3483          * For DFS root mounts, the prefix path (cifs_sb->prepath) is preserved during reconnect so
3484          * only the root path is set in cifs_sb->origin_fullpath and tcon->dfs_path. And for DFS
3485          * links, the prefix path is included in both and may be changed during reconnect.  See
3486          * cifs_tree_connect().
3487          */
3488         cifs_sb->origin_fullpath = kstrndup(full_path, strlen(full_path), GFP_KERNEL);
3489         if (!cifs_sb->origin_fullpath) {
3490                 rc = -ENOMEM;
3491                 goto error;
3492         }
3493         spin_lock(&cifs_tcp_ses_lock);
3494         tcon->dfs_path = full_path;
3495         full_path = NULL;
3496         tcon->remap = cifs_remap(cifs_sb);
3497         spin_unlock(&cifs_tcp_ses_lock);
3498
3499         /* Add original context for DFS cache to be used when refreshing referrals */
3500         rc = dfs_cache_add_vol(mntdata, ctx, cifs_sb->origin_fullpath);
3501         if (rc)
3502                 goto error;
3503         /*
3504          * After reconnecting to a different server, unique ids won't
3505          * match anymore, so we disable serverino. This prevents
3506          * dentry revalidation to think the dentry are stale (ESTALE).
3507          */
3508         cifs_autodisable_serverino(cifs_sb);
3509         /*
3510          * Force the use of prefix path to support failover on DFS paths that
3511          * resolve to targets that have different prefix paths.
3512          */
3513         cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
3514         kfree(cifs_sb->prepath);
3515         cifs_sb->prepath = ctx->prepath;
3516         ctx->prepath = NULL;
3517
3518 out:
3519         free_xid(xid);
3520         cifs_try_adding_channels(cifs_sb, ses);
3521         return mount_setup_tlink(cifs_sb, ses, tcon);
3522
3523 error:
3524         kfree(ref_path);
3525         kfree(full_path);
3526         kfree(mntdata);
3527         kfree(cifs_sb->origin_fullpath);
3528         put_root_ses(root_ses);
3529         mount_put_conns(cifs_sb, xid, server, ses, tcon);
3530         return rc;
3531 }
3532 #else
3533 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx)
3534 {
3535         int rc = 0;
3536         unsigned int xid;
3537         struct cifs_ses *ses;
3538         struct cifs_tcon *tcon;
3539         struct TCP_Server_Info *server;
3540
3541         rc = mount_get_conns(ctx, cifs_sb, &xid, &server, &ses, &tcon);
3542         if (rc)
3543                 goto error;
3544
3545         if (tcon) {
3546                 rc = is_path_remote(cifs_sb, ctx, xid, server, tcon);
3547                 if (rc == -EREMOTE)
3548                         rc = -EOPNOTSUPP;
3549                 if (rc)
3550                         goto error;
3551         }
3552
3553         free_xid(xid);
3554
3555         return mount_setup_tlink(cifs_sb, ses, tcon);
3556
3557 error:
3558         mount_put_conns(cifs_sb, xid, server, ses, tcon);
3559         return rc;
3560 }
3561 #endif
3562
3563 /*
3564  * Issue a TREE_CONNECT request.
3565  */
3566 int
3567 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3568          const char *tree, struct cifs_tcon *tcon,
3569          const struct nls_table *nls_codepage)
3570 {
3571         struct smb_hdr *smb_buffer;
3572         struct smb_hdr *smb_buffer_response;
3573         TCONX_REQ *pSMB;
3574         TCONX_RSP *pSMBr;
3575         unsigned char *bcc_ptr;
3576         int rc = 0;
3577         int length;
3578         __u16 bytes_left, count;
3579
3580         if (ses == NULL)
3581                 return -EIO;
3582
3583         smb_buffer = cifs_buf_get();
3584         if (smb_buffer == NULL)
3585                 return -ENOMEM;
3586
3587         smb_buffer_response = smb_buffer;
3588
3589         header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3590                         NULL /*no tid */ , 4 /*wct */ );
3591
3592         smb_buffer->Mid = get_next_mid(ses->server);
3593         smb_buffer->Uid = ses->Suid;
3594         pSMB = (TCONX_REQ *) smb_buffer;
3595         pSMBr = (TCONX_RSP *) smb_buffer_response;
3596
3597         pSMB->AndXCommand = 0xFF;
3598         pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3599         bcc_ptr = &pSMB->Password[0];
3600         if (tcon->pipe || (ses->server->sec_mode & SECMODE_USER)) {
3601                 pSMB->PasswordLength = cpu_to_le16(1);  /* minimum */
3602                 *bcc_ptr = 0; /* password is null byte */
3603                 bcc_ptr++;              /* skip password */
3604                 /* already aligned so no need to do it below */
3605         } else {
3606                 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3607                 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3608                    specified as required (when that support is added to
3609                    the vfs in the future) as only NTLM or the much
3610                    weaker LANMAN (which we do not send by default) is accepted
3611                    by Samba (not sure whether other servers allow
3612                    NTLMv2 password here) */
3613 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3614                 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3615                     (ses->sectype == LANMAN))
3616                         calc_lanman_hash(tcon->password, ses->server->cryptkey,
3617                                          ses->server->sec_mode &
3618                                             SECMODE_PW_ENCRYPT ? true : false,
3619                                          bcc_ptr);
3620                 else
3621 #endif /* CIFS_WEAK_PW_HASH */
3622                 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3623                                         bcc_ptr, nls_codepage);
3624                 if (rc) {
3625                         cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
3626                                  __func__, rc);
3627                         cifs_buf_release(smb_buffer);
3628                         return rc;
3629                 }
3630
3631                 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3632                 if (ses->capabilities & CAP_UNICODE) {
3633                         /* must align unicode strings */
3634                         *bcc_ptr = 0; /* null byte password */
3635                         bcc_ptr++;
3636                 }
3637         }
3638
3639         if (ses->server->sign)
3640                 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3641
3642         if (ses->capabilities & CAP_STATUS32) {
3643                 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3644         }
3645         if (ses->capabilities & CAP_DFS) {
3646                 smb_buffer->Flags2 |= SMBFLG2_DFS;
3647         }
3648         if (ses->capabilities & CAP_UNICODE) {
3649                 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3650                 length =
3651                     cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3652                         6 /* max utf8 char length in bytes */ *
3653                         (/* server len*/ + 256 /* share len */), nls_codepage);
3654                 bcc_ptr += 2 * length;  /* convert num 16 bit words to bytes */
3655                 bcc_ptr += 2;   /* skip trailing null */
3656         } else {                /* ASCII */
3657                 strcpy(bcc_ptr, tree);
3658                 bcc_ptr += strlen(tree) + 1;
3659         }
3660         strcpy(bcc_ptr, "?????");
3661         bcc_ptr += strlen("?????");
3662         bcc_ptr += 1;
3663         count = bcc_ptr - &pSMB->Password[0];
3664         be32_add_cpu(&pSMB->hdr.smb_buf_length, count);
3665         pSMB->ByteCount = cpu_to_le16(count);
3666
3667         rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3668                          0);
3669
3670         /* above now done in SendReceive */
3671         if (rc == 0) {
3672                 bool is_unicode;
3673
3674                 tcon->tidStatus = CifsGood;
3675                 tcon->need_reconnect = false;
3676                 tcon->tid = smb_buffer_response->Tid;
3677                 bcc_ptr = pByteArea(smb_buffer_response);
3678                 bytes_left = get_bcc(smb_buffer_response);
3679                 length = strnlen(bcc_ptr, bytes_left - 2);
3680                 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3681                         is_unicode = true;
3682                 else
3683                         is_unicode = false;
3684
3685
3686                 /* skip service field (NB: this field is always ASCII) */
3687                 if (length == 3) {
3688                         if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3689                             (bcc_ptr[2] == 'C')) {
3690                                 cifs_dbg(FYI, "IPC connection\n");
3691                                 tcon->ipc = true;
3692                                 tcon->pipe = true;
3693                         }
3694                 } else if (length == 2) {
3695                         if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3696                                 /* the most common case */
3697                                 cifs_dbg(FYI, "disk share connection\n");
3698                         }
3699                 }
3700                 bcc_ptr += length + 1;
3701                 bytes_left -= (length + 1);
3702                 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
3703
3704                 /* mostly informational -- no need to fail on error here */
3705                 kfree(tcon->nativeFileSystem);
3706                 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3707                                                       bytes_left, is_unicode,
3708                                                       nls_codepage);
3709
3710                 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
3711
3712                 if ((smb_buffer_response->WordCount == 3) ||
3713                          (smb_buffer_response->WordCount == 7))
3714                         /* field is in same location */
3715                         tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3716                 else
3717                         tcon->Flags = 0;
3718                 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
3719         }
3720
3721         cifs_buf_release(smb_buffer);
3722         return rc;
3723 }
3724
3725 static void delayed_free(struct rcu_head *p)
3726 {
3727         struct cifs_sb_info *cifs_sb = container_of(p, struct cifs_sb_info, rcu);
3728
3729         unload_nls(cifs_sb->local_nls);
3730         smb3_cleanup_fs_context(cifs_sb->ctx);
3731         kfree(cifs_sb);
3732 }
3733
3734 void
3735 cifs_umount(struct cifs_sb_info *cifs_sb)
3736 {
3737         struct rb_root *root = &cifs_sb->tlink_tree;
3738         struct rb_node *node;
3739         struct tcon_link *tlink;
3740
3741         cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3742
3743         spin_lock(&cifs_sb->tlink_tree_lock);
3744         while ((node = rb_first(root))) {
3745                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3746                 cifs_get_tlink(tlink);
3747                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3748                 rb_erase(node, root);
3749
3750                 spin_unlock(&cifs_sb->tlink_tree_lock);
3751                 cifs_put_tlink(tlink);
3752                 spin_lock(&cifs_sb->tlink_tree_lock);
3753         }
3754         spin_unlock(&cifs_sb->tlink_tree_lock);
3755
3756         kfree(cifs_sb->prepath);
3757 #ifdef CONFIG_CIFS_DFS_UPCALL
3758         dfs_cache_del_vol(cifs_sb->origin_fullpath);
3759         kfree(cifs_sb->origin_fullpath);
3760 #endif
3761         call_rcu(&cifs_sb->rcu, delayed_free);
3762 }
3763
3764 int
3765 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
3766 {
3767         int rc = 0;
3768         struct TCP_Server_Info *server = cifs_ses_server(ses);
3769
3770         if (!server->ops->need_neg || !server->ops->negotiate)
3771                 return -ENOSYS;
3772
3773         /* only send once per connect */
3774         if (!server->ops->need_neg(server))
3775                 return 0;
3776
3777         rc = server->ops->negotiate(xid, ses);
3778         if (rc == 0) {
3779                 spin_lock(&GlobalMid_Lock);
3780                 if (server->tcpStatus == CifsNeedNegotiate)
3781                         server->tcpStatus = CifsGood;
3782                 else
3783                         rc = -EHOSTDOWN;
3784                 spin_unlock(&GlobalMid_Lock);
3785         }
3786
3787         return rc;
3788 }
3789
3790 int
3791 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3792                    struct nls_table *nls_info)
3793 {
3794         int rc = -ENOSYS;
3795         struct TCP_Server_Info *server = cifs_ses_server(ses);
3796
3797         if (!ses->binding) {
3798                 ses->capabilities = server->capabilities;
3799                 if (!linuxExtEnabled)
3800                         ses->capabilities &= (~server->vals->cap_unix);
3801
3802                 if (ses->auth_key.response) {
3803                         cifs_dbg(FYI, "Free previous auth_key.response = %p\n",
3804                                  ses->auth_key.response);
3805                         kfree(ses->auth_key.response);
3806                         ses->auth_key.response = NULL;
3807                         ses->auth_key.len = 0;
3808                 }
3809         }
3810
3811         cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
3812                  server->sec_mode, server->capabilities, server->timeAdj);
3813
3814         if (server->ops->sess_setup)
3815                 rc = server->ops->sess_setup(xid, ses, nls_info);
3816
3817         if (rc)
3818                 cifs_server_dbg(VFS, "Send error in SessSetup = %d\n", rc);
3819
3820         return rc;
3821 }
3822
3823 static int
3824 cifs_set_vol_auth(struct smb3_fs_context *ctx, struct cifs_ses *ses)
3825 {
3826         ctx->sectype = ses->sectype;
3827
3828         /* krb5 is special, since we don't need username or pw */
3829         if (ctx->sectype == Kerberos)
3830                 return 0;
3831
3832         return cifs_set_cifscreds(ctx, ses);
3833 }
3834
3835 static struct cifs_tcon *
3836 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
3837 {
3838         int rc;
3839         struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3840         struct cifs_ses *ses;
3841         struct cifs_tcon *tcon = NULL;
3842         struct smb3_fs_context *ctx;
3843
3844         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
3845         if (ctx == NULL)
3846                 return ERR_PTR(-ENOMEM);
3847
3848         ctx->local_nls = cifs_sb->local_nls;
3849         ctx->linux_uid = fsuid;
3850         ctx->cred_uid = fsuid;
3851         ctx->UNC = master_tcon->treeName;
3852         ctx->retry = master_tcon->retry;
3853         ctx->nocase = master_tcon->nocase;
3854         ctx->nohandlecache = master_tcon->nohandlecache;
3855         ctx->local_lease = master_tcon->local_lease;
3856         ctx->no_lease = master_tcon->no_lease;
3857         ctx->resilient = master_tcon->use_resilient;
3858         ctx->persistent = master_tcon->use_persistent;
3859         ctx->handle_timeout = master_tcon->handle_timeout;
3860         ctx->no_linux_ext = !master_tcon->unix_ext;
3861         ctx->linux_ext = master_tcon->posix_extensions;
3862         ctx->sectype = master_tcon->ses->sectype;
3863         ctx->sign = master_tcon->ses->sign;
3864         ctx->seal = master_tcon->seal;
3865 #ifdef CONFIG_CIFS_SWN_UPCALL
3866         ctx->witness = master_tcon->use_witness;
3867 #endif
3868
3869         rc = cifs_set_vol_auth(ctx, master_tcon->ses);
3870         if (rc) {
3871                 tcon = ERR_PTR(rc);
3872                 goto out;
3873         }
3874
3875         /* get a reference for the same TCP session */
3876         spin_lock(&cifs_tcp_ses_lock);
3877         ++master_tcon->ses->server->srv_count;
3878         spin_unlock(&cifs_tcp_ses_lock);
3879
3880         ses = cifs_get_smb_ses(master_tcon->ses->server, ctx);
3881         if (IS_ERR(ses)) {
3882                 tcon = (struct cifs_tcon *)ses;
3883                 cifs_put_tcp_session(master_tcon->ses->server, 0);
3884                 goto out;
3885         }
3886
3887         tcon = cifs_get_tcon(ses, ctx);
3888         if (IS_ERR(tcon)) {
3889                 cifs_put_smb_ses(ses);
3890                 goto out;
3891         }
3892
3893         if (cap_unix(ses))
3894                 reset_cifs_unix_caps(0, tcon, NULL, ctx);
3895
3896 out:
3897         kfree(ctx->username);
3898         kfree_sensitive(ctx->password);
3899         kfree(ctx);
3900
3901         return tcon;
3902 }
3903
3904 struct cifs_tcon *
3905 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3906 {
3907         return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3908 }
3909
3910 /* find and return a tlink with given uid */
3911 static struct tcon_link *
3912 tlink_rb_search(struct rb_root *root, kuid_t uid)
3913 {
3914         struct rb_node *node = root->rb_node;
3915         struct tcon_link *tlink;
3916
3917         while (node) {
3918                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3919
3920                 if (uid_gt(tlink->tl_uid, uid))
3921                         node = node->rb_left;
3922                 else if (uid_lt(tlink->tl_uid, uid))
3923                         node = node->rb_right;
3924                 else
3925                         return tlink;
3926         }
3927         return NULL;
3928 }
3929
3930 /* insert a tcon_link into the tree */
3931 static void
3932 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3933 {
3934         struct rb_node **new = &(root->rb_node), *parent = NULL;
3935         struct tcon_link *tlink;
3936
3937         while (*new) {
3938                 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3939                 parent = *new;
3940
3941                 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
3942                         new = &((*new)->rb_left);
3943                 else
3944                         new = &((*new)->rb_right);
3945         }
3946
3947         rb_link_node(&new_tlink->tl_rbnode, parent, new);
3948         rb_insert_color(&new_tlink->tl_rbnode, root);
3949 }
3950
3951 /*
3952  * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3953  * current task.
3954  *
3955  * If the superblock doesn't refer to a multiuser mount, then just return
3956  * the master tcon for the mount.
3957  *
3958  * First, search the rbtree for an existing tcon for this fsuid. If one
3959  * exists, then check to see if it's pending construction. If it is then wait
3960  * for construction to complete. Once it's no longer pending, check to see if
3961  * it failed and either return an error or retry construction, depending on
3962  * the timeout.
3963  *
3964  * If one doesn't exist then insert a new tcon_link struct into the tree and
3965  * try to construct a new one.
3966  */
3967 struct tcon_link *
3968 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3969 {
3970         int ret;
3971         kuid_t fsuid = current_fsuid();
3972         struct tcon_link *tlink, *newtlink;
3973
3974         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3975                 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3976
3977         spin_lock(&cifs_sb->tlink_tree_lock);
3978         tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3979         if (tlink)
3980                 cifs_get_tlink(tlink);
3981         spin_unlock(&cifs_sb->tlink_tree_lock);
3982
3983         if (tlink == NULL) {
3984                 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3985                 if (newtlink == NULL)
3986                         return ERR_PTR(-ENOMEM);
3987                 newtlink->tl_uid = fsuid;
3988                 newtlink->tl_tcon = ERR_PTR(-EACCES);
3989                 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3990                 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3991                 cifs_get_tlink(newtlink);
3992
3993                 spin_lock(&cifs_sb->tlink_tree_lock);
3994                 /* was one inserted after previous search? */
3995                 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3996                 if (tlink) {
3997                         cifs_get_tlink(tlink);
3998                         spin_unlock(&cifs_sb->tlink_tree_lock);
3999                         kfree(newtlink);
4000                         goto wait_for_construction;
4001                 }
4002                 tlink = newtlink;
4003                 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4004                 spin_unlock(&cifs_sb->tlink_tree_lock);
4005         } else {
4006 wait_for_construction:
4007                 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4008                                   TASK_INTERRUPTIBLE);
4009                 if (ret) {
4010                         cifs_put_tlink(tlink);
4011                         return ERR_PTR(-ERESTARTSYS);
4012                 }
4013
4014                 /* if it's good, return it */
4015                 if (!IS_ERR(tlink->tl_tcon))
4016                         return tlink;
4017
4018                 /* return error if we tried this already recently */
4019                 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4020                         cifs_put_tlink(tlink);
4021                         return ERR_PTR(-EACCES);
4022                 }
4023
4024                 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4025                         goto wait_for_construction;
4026         }
4027
4028         tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4029         clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4030         wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4031
4032         if (IS_ERR(tlink->tl_tcon)) {
4033                 cifs_put_tlink(tlink);
4034                 return ERR_PTR(-EACCES);
4035         }
4036
4037         return tlink;
4038 }
4039
4040 /*
4041  * periodic workqueue job that scans tcon_tree for a superblock and closes
4042  * out tcons.
4043  */
4044 static void
4045 cifs_prune_tlinks(struct work_struct *work)
4046 {
4047         struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4048                                                     prune_tlinks.work);
4049         struct rb_root *root = &cifs_sb->tlink_tree;
4050         struct rb_node *node;
4051         struct rb_node *tmp;
4052         struct tcon_link *tlink;
4053
4054         /*
4055          * Because we drop the spinlock in the loop in order to put the tlink
4056          * it's not guarded against removal of links from the tree. The only
4057          * places that remove entries from the tree are this function and
4058          * umounts. Because this function is non-reentrant and is canceled
4059          * before umount can proceed, this is safe.
4060          */
4061         spin_lock(&cifs_sb->tlink_tree_lock);
4062         node = rb_first(root);
4063         while (node != NULL) {
4064                 tmp = node;
4065                 node = rb_next(tmp);
4066                 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4067
4068                 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4069                     atomic_read(&tlink->tl_count) != 0 ||
4070                     time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4071                         continue;
4072
4073                 cifs_get_tlink(tlink);
4074                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4075                 rb_erase(tmp, root);
4076
4077                 spin_unlock(&cifs_sb->tlink_tree_lock);
4078                 cifs_put_tlink(tlink);
4079                 spin_lock(&cifs_sb->tlink_tree_lock);
4080         }
4081         spin_unlock(&cifs_sb->tlink_tree_lock);
4082
4083         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4084                                 TLINK_IDLE_EXPIRE);
4085 }
4086
4087 #ifdef CONFIG_CIFS_DFS_UPCALL
4088 int cifs_tree_connect(const unsigned int xid, struct cifs_tcon *tcon, const struct nls_table *nlsc)
4089 {
4090         int rc;
4091         struct TCP_Server_Info *server = tcon->ses->server;
4092         const struct smb_version_operations *ops = server->ops;
4093         struct dfs_cache_tgt_list tl;
4094         struct dfs_cache_tgt_iterator *it = NULL;
4095         char *tree;
4096         const char *tcp_host;
4097         size_t tcp_host_len;
4098         const char *dfs_host;
4099         size_t dfs_host_len;
4100         char *share = NULL, *prefix = NULL;
4101         struct dfs_info3_param ref = {0};
4102         bool isroot;
4103
4104         tree = kzalloc(MAX_TREE_SIZE, GFP_KERNEL);
4105         if (!tree)
4106                 return -ENOMEM;
4107
4108         if (!tcon->dfs_path) {
4109                 if (tcon->ipc) {
4110                         scnprintf(tree, MAX_TREE_SIZE, "\\\\%s\\IPC$", server->hostname);
4111                         rc = ops->tree_connect(xid, tcon->ses, tree, tcon, nlsc);
4112                 } else {
4113                         rc = ops->tree_connect(xid, tcon->ses, tcon->treeName, tcon, nlsc);
4114                 }
4115                 goto out;
4116         }
4117
4118         rc = dfs_cache_noreq_find(tcon->dfs_path + 1, &ref, &tl);
4119         if (rc)
4120                 goto out;
4121         isroot = ref.server_type == DFS_TYPE_ROOT;
4122         free_dfs_info_param(&ref);
4123
4124         extract_unc_hostname(server->hostname, &tcp_host, &tcp_host_len);
4125
4126         for (it = dfs_cache_get_tgt_iterator(&tl); it; it = dfs_cache_get_next_tgt(&tl, it)) {
4127                 bool target_match;
4128
4129                 kfree(share);
4130                 kfree(prefix);
4131                 share = NULL;
4132                 prefix = NULL;
4133
4134                 rc = dfs_cache_get_tgt_share(tcon->dfs_path + 1, it, &share, &prefix);
4135                 if (rc) {
4136                         cifs_dbg(VFS, "%s: failed to parse target share %d\n",
4137                                  __func__, rc);
4138                         continue;
4139                 }
4140
4141                 extract_unc_hostname(share, &dfs_host, &dfs_host_len);
4142
4143                 if (dfs_host_len != tcp_host_len
4144                     || strncasecmp(dfs_host, tcp_host, dfs_host_len) != 0) {
4145                         cifs_dbg(FYI, "%s: %.*s doesn't match %.*s\n", __func__, (int)dfs_host_len,
4146                                  dfs_host, (int)tcp_host_len, tcp_host);
4147
4148                         rc = match_target_ip(server, dfs_host, dfs_host_len, &target_match);
4149                         if (rc) {
4150                                 cifs_dbg(VFS, "%s: failed to match target ip: %d\n", __func__, rc);
4151                                 break;
4152                         }
4153
4154                         if (!target_match) {
4155                                 cifs_dbg(FYI, "%s: skipping target\n", __func__);
4156                                 continue;
4157                         }
4158                 }
4159
4160                 if (tcon->ipc) {
4161                         scnprintf(tree, MAX_TREE_SIZE, "\\\\%s\\IPC$", share);
4162                         rc = ops->tree_connect(xid, tcon->ses, tree, tcon, nlsc);
4163                 } else {
4164                         scnprintf(tree, MAX_TREE_SIZE, "\\%s", share);
4165                         rc = ops->tree_connect(xid, tcon->ses, tree, tcon, nlsc);
4166                         /* Only handle prefix paths of DFS link targets */
4167                         if (!rc && !isroot) {
4168                                 rc = update_super_prepath(tcon, prefix);
4169                                 break;
4170                         }
4171                 }
4172                 if (rc == -EREMOTE)
4173                         break;
4174         }
4175
4176         kfree(share);
4177         kfree(prefix);
4178
4179         if (!rc) {
4180                 if (it)
4181                         rc = dfs_cache_noreq_update_tgthint(tcon->dfs_path + 1, it);
4182                 else
4183                         rc = -ENOENT;
4184         }
4185         dfs_cache_free_tgts(&tl);
4186 out:
4187         kfree(tree);
4188         return rc;
4189 }
4190 #else
4191 int cifs_tree_connect(const unsigned int xid, struct cifs_tcon *tcon, const struct nls_table *nlsc)
4192 {
4193         const struct smb_version_operations *ops = tcon->ses->server->ops;
4194
4195         return ops->tree_connect(xid, tcon->ses, tcon->treeName, tcon, nlsc);
4196 }
4197 #endif