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