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