fs/cifs/connect.c

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