fs/cifs/connect.c

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