fs/cifs/connect.c

   1 /*
   2  *   fs/cifs/connect.c
   3  *
   4  *   Copyright (C) International Business Machines  Corp., 2002,2011
   5  *   Author(s): Steve French ([email protected])
   6  *
   7  *   This library is free software; you can redistribute it and/or modify
   8  *   it under the terms of the GNU Lesser General Public License as published
   9  *   by the Free Software Foundation; either version 2.1 of the License, or
  10  *   (at your option) any later version.
  11  *
  12  *   This library is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  15  *   the GNU Lesser General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU Lesser General Public License
  18  *   along with this library; if not, write to the Free Software
  19  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20  */
  21 #include <linux/fs.h>
  22 #include <linux/net.h>
  23 #include <linux/string.h>
  24 #include <linux/sched/signal.h>
  25 #include <linux/list.h>
  26 #include <linux/wait.h>
  27 #include <linux/slab.h>
  28 #include <linux/pagemap.h>
  29 #include <linux/ctype.h>
  30 #include <linux/utsname.h>
  31 #include <linux/mempool.h>
  32 #include <linux/delay.h>
  33 #include <linux/completion.h>
  34 #include <linux/kthread.h>
  35 #include <linux/pagevec.h>
  36 #include <linux/freezer.h>
  37 #include <linux/namei.h>
  38 #include <linux/uuid.h>
  39 #include <linux/uaccess.h>
  40 #include <asm/processor.h>
  41 #include <linux/inet.h>
  42 #include <linux/module.h>
  43 #include <keys/user-type.h>
  44 #include <net/ipv6.h>
  45 #include <linux/parser.h>
  46 #include <linux/bvec.h>
  47 #include "cifspdu.h"
  48 #include "cifsglob.h"
  49 #include "cifsproto.h"
  50 #include "cifs_unicode.h"
  51 #include "cifs_debug.h"
  52 #include "cifs_fs_sb.h"
  53 #include "ntlmssp.h"
  54 #include "nterr.h"
  55 #include "rfc1002pdu.h"
  56 #include "fscache.h"
  57 #include "smb2proto.h"
  58 #include "smbdirect.h"
  59 #include "dns_resolve.h"
  60 #include "cifsfs.h"
  61 #ifdef CONFIG_CIFS_DFS_UPCALL
  62 #include "dfs_cache.h"
  63 #endif
  64
  65 extern mempool_t *cifs_req_poolp;
  66 extern bool disable_legacy_dialects;
  67
  68 /* FIXME: should these be tunable? */
  69 #define TLINK_ERROR_EXPIRE      (1 * HZ)
  70 #define TLINK_IDLE_EXPIRE       (600 * HZ)
  71
  72 enum {
  73         /* Mount options that take no arguments */
  74         Opt_user_xattr, Opt_nouser_xattr,
  75         Opt_forceuid, Opt_noforceuid,
  76         Opt_forcegid, Opt_noforcegid,
  77         Opt_noblocksend, Opt_noautotune,
  78         Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
  79         Opt_mapposix, Opt_nomapposix,
  80         Opt_mapchars, Opt_nomapchars, Opt_sfu,
  81         Opt_nosfu, Opt_nodfs, Opt_posixpaths,
  82         Opt_noposixpaths, Opt_nounix, Opt_unix,
  83         Opt_nocase,
  84         Opt_brl, Opt_nobrl,
  85         Opt_handlecache, Opt_nohandlecache,
  86         Opt_forcemandatorylock, Opt_setuidfromacl, Opt_setuids,
  87         Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
  88         Opt_nohard, Opt_nosoft,
  89         Opt_nointr, Opt_intr,
  90         Opt_nostrictsync, Opt_strictsync,
  91         Opt_serverino, Opt_noserverino,
  92         Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
  93         Opt_acl, Opt_noacl, Opt_locallease,
  94         Opt_sign, Opt_seal, Opt_noac,
  95         Opt_fsc, Opt_mfsymlinks,
  96         Opt_multiuser, Opt_sloppy, Opt_nosharesock,
  97         Opt_persistent, Opt_nopersistent,
  98         Opt_resilient, Opt_noresilient,
  99         Opt_domainauto, Opt_rdma, Opt_modesid,
 100         Opt_compress,
 101
 102         /* Mount options which take numeric value */
 103         Opt_backupuid, Opt_backupgid, Opt_uid,
 104         Opt_cruid, Opt_gid, Opt_file_mode,
 105         Opt_dirmode, Opt_port,
 106         Opt_blocksize, Opt_rsize, Opt_wsize, Opt_actimeo,
 107         Opt_echo_interval, Opt_max_credits, Opt_handletimeout,
 108         Opt_snapshot,
 109
 110         /* Mount options which take string value */
 111         Opt_user, Opt_pass, Opt_ip,
 112         Opt_domain, Opt_srcaddr, Opt_iocharset,
 113         Opt_netbiosname, Opt_servern,
 114         Opt_ver, Opt_vers, Opt_sec, Opt_cache,
 115
 116         /* Mount options to be ignored */
 117         Opt_ignore,
 118
 119         /* Options which could be blank */
 120         Opt_blank_pass,
 121         Opt_blank_user,
 122         Opt_blank_ip,
 123
 124         Opt_err
 125 };
 126
 127 static const match_table_t cifs_mount_option_tokens = {
 128
 129         { Opt_user_xattr, "user_xattr" },
 130         { Opt_nouser_xattr, "nouser_xattr" },
 131         { Opt_forceuid, "forceuid" },
 132         { Opt_noforceuid, "noforceuid" },
 133         { Opt_forcegid, "forcegid" },
 134         { Opt_noforcegid, "noforcegid" },
 135         { Opt_noblocksend, "noblocksend" },
 136         { Opt_noautotune, "noautotune" },
 137         { Opt_hard, "hard" },
 138         { Opt_soft, "soft" },
 139         { Opt_perm, "perm" },
 140         { Opt_noperm, "noperm" },
 141         { Opt_mapchars, "mapchars" }, /* SFU style */
 142         { Opt_nomapchars, "nomapchars" },
 143         { Opt_mapposix, "mapposix" }, /* SFM style */
 144         { Opt_nomapposix, "nomapposix" },
 145         { Opt_sfu, "sfu" },
 146         { Opt_nosfu, "nosfu" },
 147         { Opt_nodfs, "nodfs" },
 148         { Opt_posixpaths, "posixpaths" },
 149         { Opt_noposixpaths, "noposixpaths" },
 150         { Opt_nounix, "nounix" },
 151         { Opt_nounix, "nolinux" },
 152         { Opt_nounix, "noposix" },
 153         { Opt_unix, "unix" },
 154         { Opt_unix, "linux" },
 155         { Opt_unix, "posix" },
 156         { Opt_nocase, "nocase" },
 157         { Opt_nocase, "ignorecase" },
 158         { Opt_brl, "brl" },
 159         { Opt_nobrl, "nobrl" },
 160         { Opt_handlecache, "handlecache" },
 161         { Opt_nohandlecache, "nohandlecache" },
 162         { Opt_nobrl, "nolock" },
 163         { Opt_forcemandatorylock, "forcemandatorylock" },
 164         { Opt_forcemandatorylock, "forcemand" },
 165         { Opt_setuids, "setuids" },
 166         { Opt_nosetuids, "nosetuids" },
 167         { Opt_setuidfromacl, "idsfromsid" },
 168         { Opt_dynperm, "dynperm" },
 169         { Opt_nodynperm, "nodynperm" },
 170         { Opt_nohard, "nohard" },
 171         { Opt_nosoft, "nosoft" },
 172         { Opt_nointr, "nointr" },
 173         { Opt_intr, "intr" },
 174         { Opt_nostrictsync, "nostrictsync" },
 175         { Opt_strictsync, "strictsync" },
 176         { Opt_serverino, "serverino" },
 177         { Opt_noserverino, "noserverino" },
 178         { Opt_rwpidforward, "rwpidforward" },
 179         { Opt_modesid, "modefromsid" },
 180         { Opt_cifsacl, "cifsacl" },
 181         { Opt_nocifsacl, "nocifsacl" },
 182         { Opt_acl, "acl" },
 183         { Opt_noacl, "noacl" },
 184         { Opt_locallease, "locallease" },
 185         { Opt_sign, "sign" },
 186         { Opt_seal, "seal" },
 187         { Opt_noac, "noac" },
 188         { Opt_fsc, "fsc" },
 189         { Opt_mfsymlinks, "mfsymlinks" },
 190         { Opt_multiuser, "multiuser" },
 191         { Opt_sloppy, "sloppy" },
 192         { Opt_nosharesock, "nosharesock" },
 193         { Opt_persistent, "persistenthandles"},
 194         { Opt_nopersistent, "nopersistenthandles"},
 195         { Opt_resilient, "resilienthandles"},
 196         { Opt_noresilient, "noresilienthandles"},
 197         { Opt_domainauto, "domainauto"},
 198         { Opt_rdma, "rdma"},
 199
 200         { Opt_backupuid, "backupuid=%s" },
 201         { Opt_backupgid, "backupgid=%s" },
 202         { Opt_uid, "uid=%s" },
 203         { Opt_cruid, "cruid=%s" },
 204         { Opt_gid, "gid=%s" },
 205         { Opt_file_mode, "file_mode=%s" },
 206         { Opt_dirmode, "dirmode=%s" },
 207         { Opt_dirmode, "dir_mode=%s" },
 208         { Opt_port, "port=%s" },
 209         { Opt_blocksize, "bsize=%s" },
 210         { Opt_rsize, "rsize=%s" },
 211         { Opt_wsize, "wsize=%s" },
 212         { Opt_actimeo, "actimeo=%s" },
 213         { Opt_handletimeout, "handletimeout=%s" },
 214         { Opt_echo_interval, "echo_interval=%s" },
 215         { Opt_max_credits, "max_credits=%s" },
 216         { Opt_snapshot, "snapshot=%s" },
 217         { Opt_compress, "compress=%s" },
 218
 219         { Opt_blank_user, "user=" },
 220         { Opt_blank_user, "username=" },
 221         { Opt_user, "user=%s" },
 222         { Opt_user, "username=%s" },
 223         { Opt_blank_pass, "pass=" },
 224         { Opt_blank_pass, "password=" },
 225         { Opt_pass, "pass=%s" },
 226         { Opt_pass, "password=%s" },
 227         { Opt_blank_ip, "ip=" },
 228         { Opt_blank_ip, "addr=" },
 229         { Opt_ip, "ip=%s" },
 230         { Opt_ip, "addr=%s" },
 231         { Opt_ignore, "unc=%s" },
 232         { Opt_ignore, "target=%s" },
 233         { Opt_ignore, "path=%s" },
 234         { Opt_domain, "dom=%s" },
 235         { Opt_domain, "domain=%s" },
 236         { Opt_domain, "workgroup=%s" },
 237         { Opt_srcaddr, "srcaddr=%s" },
 238         { Opt_ignore, "prefixpath=%s" },
 239         { Opt_iocharset, "iocharset=%s" },
 240         { Opt_netbiosname, "netbiosname=%s" },
 241         { Opt_servern, "servern=%s" },
 242         { Opt_ver, "ver=%s" },
 243         { Opt_vers, "vers=%s" },
 244         { Opt_sec, "sec=%s" },
 245         { Opt_cache, "cache=%s" },
 246
 247         { Opt_ignore, "cred" },
 248         { Opt_ignore, "credentials" },
 249         { Opt_ignore, "cred=%s" },
 250         { Opt_ignore, "credentials=%s" },
 251         { Opt_ignore, "guest" },
 252         { Opt_ignore, "rw" },
 253         { Opt_ignore, "ro" },
 254         { Opt_ignore, "suid" },
 255         { Opt_ignore, "nosuid" },
 256         { Opt_ignore, "exec" },
 257         { Opt_ignore, "noexec" },
 258         { Opt_ignore, "nodev" },
 259         { Opt_ignore, "noauto" },
 260         { Opt_ignore, "dev" },
 261         { Opt_ignore, "mand" },
 262         { Opt_ignore, "nomand" },
 263         { Opt_ignore, "relatime" },
 264         { Opt_ignore, "_netdev" },
 265
 266         { Opt_err, NULL }
 267 };
 268
 269 enum {
 270         Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
 271         Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
 272         Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
 273         Opt_sec_ntlmv2i, Opt_sec_lanman,
 274         Opt_sec_none,
 275
 276         Opt_sec_err
 277 };
 278
 279 static const match_table_t cifs_secflavor_tokens = {
 280         { Opt_sec_krb5, "krb5" },
 281         { Opt_sec_krb5i, "krb5i" },
 282         { Opt_sec_krb5p, "krb5p" },
 283         { Opt_sec_ntlmsspi, "ntlmsspi" },
 284         { Opt_sec_ntlmssp, "ntlmssp" },
 285         { Opt_ntlm, "ntlm" },
 286         { Opt_sec_ntlmi, "ntlmi" },
 287         { Opt_sec_ntlmv2, "nontlm" },
 288         { Opt_sec_ntlmv2, "ntlmv2" },
 289         { Opt_sec_ntlmv2i, "ntlmv2i" },
 290         { Opt_sec_lanman, "lanman" },
 291         { Opt_sec_none, "none" },
 292
 293         { Opt_sec_err, NULL }
 294 };
 295
 296 /* cache flavors */
 297 enum {
 298         Opt_cache_loose,
 299         Opt_cache_strict,
 300         Opt_cache_none,
 301         Opt_cache_err
 302 };
 303
 304 static const match_table_t cifs_cacheflavor_tokens = {
 305         { Opt_cache_loose, "loose" },
 306         { Opt_cache_strict, "strict" },
 307         { Opt_cache_none, "none" },
 308         { Opt_cache_err, NULL }
 309 };
 310
 311 static const match_table_t cifs_smb_version_tokens = {
 312         { Smb_1, SMB1_VERSION_STRING },
 313         { Smb_20, SMB20_VERSION_STRING},
 314         { Smb_21, SMB21_VERSION_STRING },
 315         { Smb_30, SMB30_VERSION_STRING },
 316         { Smb_302, SMB302_VERSION_STRING },
 317         { Smb_302, ALT_SMB302_VERSION_STRING },
 318         { Smb_311, SMB311_VERSION_STRING },
 319         { Smb_311, ALT_SMB311_VERSION_STRING },
 320         { Smb_3any, SMB3ANY_VERSION_STRING },
 321         { Smb_default, SMBDEFAULT_VERSION_STRING },
 322         { Smb_version_err, NULL }
 323 };
 324
 325 static int ip_connect(struct TCP_Server_Info *server);
 326 static int generic_ip_connect(struct TCP_Server_Info *server);
 327 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
 328 static void cifs_prune_tlinks(struct work_struct *work);
 329 static char *extract_hostname(const char *unc);
 330
 331 /*
 332  * Resolve hostname and set ip addr in tcp ses. Useful for hostnames that may
 333  * get their ip addresses changed at some point.
 334  *
 335  * This should be called with server->srv_mutex held.
 336  */
 337 #ifdef CONFIG_CIFS_DFS_UPCALL
 338 static int reconn_set_ipaddr(struct TCP_Server_Info *server)
 339 {
 340         int rc;
 341         int len;
 342         char *unc, *ipaddr = NULL;
 343
 344         if (!server->hostname)
 345                 return -EINVAL;
 346
 347         len = strlen(server->hostname) + 3;
 348
 349         unc = kmalloc(len, GFP_KERNEL);
 350         if (!unc) {
 351                 cifs_dbg(FYI, "%s: failed to create UNC path\n", __func__);
 352                 return -ENOMEM;
 353         }
 354         scnprintf(unc, len, "\\\\%s", server->hostname);
 355
 356         rc = dns_resolve_server_name_to_ip(unc, &ipaddr);
 357         kfree(unc);
 358
 359         if (rc < 0) {
 360                 cifs_dbg(FYI, "%s: failed to resolve server part of %s to IP: %d\n",
 361                          __func__, server->hostname, rc);
 362                 return rc;
 363         }
 364
 365         rc = cifs_convert_address((struct sockaddr *)&server->dstaddr, ipaddr,
 366                                   strlen(ipaddr));
 367         kfree(ipaddr);
 368
 369         return !rc ? -1 : 0;
 370 }
 371 #else
 372 static inline int reconn_set_ipaddr(struct TCP_Server_Info *server)
 373 {
 374         return 0;
 375 }
 376 #endif
 377
 378 #ifdef CONFIG_CIFS_DFS_UPCALL
 379 struct super_cb_data {
 380         struct TCP_Server_Info *server;
 381         struct cifs_sb_info *cifs_sb;
 382 };
 383
 384 /* These functions must be called with server->srv_mutex held */
 385
 386 static void super_cb(struct super_block *sb, void *arg)
 387 {
 388         struct super_cb_data *d = arg;
 389         struct cifs_sb_info *cifs_sb;
 390         struct cifs_tcon *tcon;
 391
 392         if (d->cifs_sb)
 393                 return;
 394
 395         cifs_sb = CIFS_SB(sb);
 396         tcon = cifs_sb_master_tcon(cifs_sb);
 397         if (tcon->ses->server == d->server)
 398                 d->cifs_sb = cifs_sb;
 399 }
 400
 401 static inline struct cifs_sb_info *
 402 find_super_by_tcp(struct TCP_Server_Info *server)
 403 {
 404         struct super_cb_data d = {
 405                 .server = server,
 406                 .cifs_sb = NULL,
 407         };
 408
 409         iterate_supers_type(&cifs_fs_type, super_cb, &d);
 410         return d.cifs_sb ? d.cifs_sb : ERR_PTR(-ENOENT);
 411 }
 412
 413 static void reconn_inval_dfs_target(struct TCP_Server_Info *server,
 414                                     struct cifs_sb_info *cifs_sb,
 415                                     struct dfs_cache_tgt_list *tgt_list,
 416                                     struct dfs_cache_tgt_iterator **tgt_it)
 417 {
 418         const char *name;
 419
 420         if (!cifs_sb || !cifs_sb->origin_fullpath || !tgt_list ||
 421             !server->nr_targets)
 422                 return;
 423
 424         if (!*tgt_it) {
 425                 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
 426         } else {
 427                 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
 428                 if (!*tgt_it)
 429                         *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
 430         }
 431
 432         cifs_dbg(FYI, "%s: UNC: %s\n", __func__, cifs_sb->origin_fullpath);
 433
 434         name = dfs_cache_get_tgt_name(*tgt_it);
 435
 436         kfree(server->hostname);
 437
 438         server->hostname = extract_hostname(name);
 439         if (IS_ERR(server->hostname)) {
 440                 cifs_dbg(FYI,
 441                          "%s: failed to extract hostname from target: %ld\n",
 442                          __func__, PTR_ERR(server->hostname));
 443         }
 444 }
 445
 446 static inline int reconn_setup_dfs_targets(struct cifs_sb_info *cifs_sb,
 447                                            struct dfs_cache_tgt_list *tl,
 448                                            struct dfs_cache_tgt_iterator **it)
 449 {
 450         if (!cifs_sb->origin_fullpath)
 451                 return -EOPNOTSUPP;
 452         return dfs_cache_noreq_find(cifs_sb->origin_fullpath + 1, NULL, tl);
 453 }
 454 #endif
 455
 456 /*
 457  * cifs tcp session reconnection
 458  *
 459  * mark tcp session as reconnecting so temporarily locked
 460  * mark all smb sessions as reconnecting for tcp session
 461  * reconnect tcp session
 462  * wake up waiters on reconnection? - (not needed currently)
 463  */
 464 int
 465 cifs_reconnect(struct TCP_Server_Info *server)
 466 {
 467         int rc = 0;
 468         struct list_head *tmp, *tmp2;
 469         struct cifs_ses *ses;
 470         struct cifs_tcon *tcon;
 471         struct mid_q_entry *mid_entry;
 472         struct list_head retry_list;
 473 #ifdef CONFIG_CIFS_DFS_UPCALL
 474         struct cifs_sb_info *cifs_sb = NULL;
 475         struct dfs_cache_tgt_list tgt_list = {0};
 476         struct dfs_cache_tgt_iterator *tgt_it = NULL;
 477 #endif
 478
 479         spin_lock(&GlobalMid_Lock);
 480         server->nr_targets = 1;
 481 #ifdef CONFIG_CIFS_DFS_UPCALL
 482         spin_unlock(&GlobalMid_Lock);
 483         cifs_sb = find_super_by_tcp(server);
 484         if (IS_ERR(cifs_sb)) {
 485                 rc = PTR_ERR(cifs_sb);
 486                 cifs_dbg(FYI, "%s: will not do DFS failover: rc = %d\n",
 487                          __func__, rc);
 488                 cifs_sb = NULL;
 489         } else {
 490                 rc = reconn_setup_dfs_targets(cifs_sb, &tgt_list, &tgt_it);
 491                 if (rc && (rc != -EOPNOTSUPP)) {
 492                         cifs_dbg(VFS, "%s: no target servers for DFS failover\n",
 493                                  __func__);
 494                 } else {
 495                         server->nr_targets = dfs_cache_get_nr_tgts(&tgt_list);
 496                 }
 497         }
 498         cifs_dbg(FYI, "%s: will retry %d target(s)\n", __func__,
 499                  server->nr_targets);
 500         spin_lock(&GlobalMid_Lock);
 501 #endif
 502         if (server->tcpStatus == CifsExiting) {
 503                 /* the demux thread will exit normally
 504                 next time through the loop */
 505                 spin_unlock(&GlobalMid_Lock);
 506                 return rc;
 507         } else
 508                 server->tcpStatus = CifsNeedReconnect;
 509         spin_unlock(&GlobalMid_Lock);
 510         server->maxBuf = 0;
 511         server->max_read = 0;
 512
 513         cifs_dbg(FYI, "Mark tcp session as need reconnect\n");
 514         trace_smb3_reconnect(server->CurrentMid, server->hostname);
 515
 516         /* before reconnecting the tcp session, mark the smb session (uid)
 517                 and the tid bad so they are not used until reconnected */
 518         cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
 519                  __func__);
 520         spin_lock(&cifs_tcp_ses_lock);
 521         list_for_each(tmp, &server->smb_ses_list) {
 522                 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
 523                 ses->need_reconnect = true;
 524                 list_for_each(tmp2, &ses->tcon_list) {
 525                         tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
 526                         tcon->need_reconnect = true;
 527                 }
 528                 if (ses->tcon_ipc)
 529                         ses->tcon_ipc->need_reconnect = true;
 530         }
 531         spin_unlock(&cifs_tcp_ses_lock);
 532
 533         /* do not want to be sending data on a socket we are freeing */
 534         cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
 535         mutex_lock(&server->srv_mutex);
 536         if (server->ssocket) {
 537                 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
 538                          server->ssocket->state, server->ssocket->flags);
 539                 kernel_sock_shutdown(server->ssocket, SHUT_WR);
 540                 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
 541                          server->ssocket->state, server->ssocket->flags);
 542                 sock_release(server->ssocket);
 543                 server->ssocket = NULL;
 544         }
 545         server->sequence_number = 0;
 546         server->session_estab = false;
 547         kfree(server->session_key.response);
 548         server->session_key.response = NULL;
 549         server->session_key.len = 0;
 550         server->lstrp = jiffies;
 551
 552         /* mark submitted MIDs for retry and issue callback */
 553         INIT_LIST_HEAD(&retry_list);
 554         cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
 555         spin_lock(&GlobalMid_Lock);
 556         list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 557                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 558                 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
 559                         mid_entry->mid_state = MID_RETRY_NEEDED;
 560                 list_move(&mid_entry->qhead, &retry_list);
 561         }
 562         spin_unlock(&GlobalMid_Lock);
 563         mutex_unlock(&server->srv_mutex);
 564
 565         cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
 566         list_for_each_safe(tmp, tmp2, &retry_list) {
 567                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 568                 list_del_init(&mid_entry->qhead);
 569                 mid_entry->callback(mid_entry);
 570         }
 571
 572         if (cifs_rdma_enabled(server)) {
 573                 mutex_lock(&server->srv_mutex);
 574                 smbd_destroy(server);
 575                 mutex_unlock(&server->srv_mutex);
 576         }
 577
 578         do {
 579                 try_to_freeze();
 580
 581                 mutex_lock(&server->srv_mutex);
 582                 /*
 583                  * Set up next DFS target server (if any) for reconnect. If DFS
 584                  * feature is disabled, then we will retry last server we
 585                  * connected to before.
 586                  */
 587                 if (cifs_rdma_enabled(server))
 588                         rc = smbd_reconnect(server);
 589                 else
 590                         rc = generic_ip_connect(server);
 591                 if (rc) {
 592                         cifs_dbg(FYI, "reconnect error %d\n", rc);
 593 #ifdef CONFIG_CIFS_DFS_UPCALL
 594                         reconn_inval_dfs_target(server, cifs_sb, &tgt_list,
 595                                                 &tgt_it);
 596 #endif
 597                         rc = reconn_set_ipaddr(server);
 598                         if (rc) {
 599                                 cifs_dbg(FYI, "%s: failed to resolve hostname: %d\n",
 600                                          __func__, rc);
 601                         }
 602                         mutex_unlock(&server->srv_mutex);
 603                         msleep(3000);
 604                 } else {
 605                         atomic_inc(&tcpSesReconnectCount);
 606                         set_credits(server, 1);
 607                         spin_lock(&GlobalMid_Lock);
 608                         if (server->tcpStatus != CifsExiting)
 609                                 server->tcpStatus = CifsNeedNegotiate;
 610                         spin_unlock(&GlobalMid_Lock);
 611                         mutex_unlock(&server->srv_mutex);
 612                 }
 613         } while (server->tcpStatus == CifsNeedReconnect);
 614
 615 #ifdef CONFIG_CIFS_DFS_UPCALL
 616         if (tgt_it) {
 617                 rc = dfs_cache_noreq_update_tgthint(cifs_sb->origin_fullpath + 1,
 618                                                     tgt_it);
 619                 if (rc) {
 620                         cifs_dbg(VFS, "%s: failed to update DFS target hint: rc = %d\n",
 621                                  __func__, rc);
 622                 }
 623                 rc = dfs_cache_update_vol(cifs_sb->origin_fullpath, server);
 624                 if (rc) {
 625                         cifs_dbg(VFS, "%s: failed to update vol info in DFS cache: rc = %d\n",
 626                                  __func__, rc);
 627                 }
 628                 dfs_cache_free_tgts(&tgt_list);
 629         }
 630 #endif
 631         if (server->tcpStatus == CifsNeedNegotiate)
 632                 mod_delayed_work(cifsiod_wq, &server->echo, 0);
 633
 634         return rc;
 635 }
 636
 637 static void
 638 cifs_echo_request(struct work_struct *work)
 639 {
 640         int rc;
 641         struct TCP_Server_Info *server = container_of(work,
 642                                         struct TCP_Server_Info, echo.work);
 643         unsigned long echo_interval;
 644
 645         /*
 646          * If we need to renegotiate, set echo interval to zero to
 647          * immediately call echo service where we can renegotiate.
 648          */
 649         if (server->tcpStatus == CifsNeedNegotiate)
 650                 echo_interval = 0;
 651         else
 652                 echo_interval = server->echo_interval;
 653
 654         /*
 655          * We cannot send an echo if it is disabled.
 656          * Also, no need to ping if we got a response recently.
 657          */
 658
 659         if (server->tcpStatus == CifsNeedReconnect ||
 660             server->tcpStatus == CifsExiting ||
 661             server->tcpStatus == CifsNew ||
 662             (server->ops->can_echo && !server->ops->can_echo(server)) ||
 663             time_before(jiffies, server->lstrp + echo_interval - HZ))
 664                 goto requeue_echo;
 665
 666         rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
 667         if (rc)
 668                 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
 669                          server->hostname);
 670
 671 requeue_echo:
 672         queue_delayed_work(cifsiod_wq, &server->echo, server->echo_interval);
 673 }
 674
 675 static bool
 676 allocate_buffers(struct TCP_Server_Info *server)
 677 {
 678         if (!server->bigbuf) {
 679                 server->bigbuf = (char *)cifs_buf_get();
 680                 if (!server->bigbuf) {
 681                         cifs_dbg(VFS, "No memory for large SMB response\n");
 682                         msleep(3000);
 683                         /* retry will check if exiting */
 684                         return false;
 685                 }
 686         } else if (server->large_buf) {
 687                 /* we are reusing a dirty large buf, clear its start */
 688                 memset(server->bigbuf, 0, HEADER_SIZE(server));
 689         }
 690
 691         if (!server->smallbuf) {
 692                 server->smallbuf = (char *)cifs_small_buf_get();
 693                 if (!server->smallbuf) {
 694                         cifs_dbg(VFS, "No memory for SMB response\n");
 695                         msleep(1000);
 696                         /* retry will check if exiting */
 697                         return false;
 698                 }
 699                 /* beginning of smb buffer is cleared in our buf_get */
 700         } else {
 701                 /* if existing small buf clear beginning */
 702                 memset(server->smallbuf, 0, HEADER_SIZE(server));
 703         }
 704
 705         return true;
 706 }
 707
 708 static bool
 709 server_unresponsive(struct TCP_Server_Info *server)
 710 {
 711         /*
 712          * We need to wait 3 echo intervals to make sure we handle such
 713          * situations right:
 714          * 1s  client sends a normal SMB request
 715          * 3s  client gets a response
 716          * 30s echo workqueue job pops, and decides we got a response recently
 717          *     and don't need to send another
 718          * ...
 719          * 65s kernel_recvmsg times out, and we see that we haven't gotten
 720          *     a response in >60s.
 721          */
 722         if ((server->tcpStatus == CifsGood ||
 723             server->tcpStatus == CifsNeedNegotiate) &&
 724             time_after(jiffies, server->lstrp + 3 * server->echo_interval)) {
 725                 cifs_dbg(VFS, "Server %s has not responded in %lu seconds. Reconnecting...\n",
 726                          server->hostname, (3 * server->echo_interval) / HZ);
 727                 cifs_reconnect(server);
 728                 wake_up(&server->response_q);
 729                 return true;
 730         }
 731
 732         return false;
 733 }
 734
 735 static inline bool
 736 zero_credits(struct TCP_Server_Info *server)
 737 {
 738         int val;
 739
 740         spin_lock(&server->req_lock);
 741         val = server->credits + server->echo_credits + server->oplock_credits;
 742         if (server->in_flight == 0 && val == 0) {
 743                 spin_unlock(&server->req_lock);
 744                 return true;
 745         }
 746         spin_unlock(&server->req_lock);
 747         return false;
 748 }
 749
 750 static int
 751 cifs_readv_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg)
 752 {
 753         int length = 0;
 754         int total_read;
 755
 756         smb_msg->msg_control = NULL;
 757         smb_msg->msg_controllen = 0;
 758
 759         for (total_read = 0; msg_data_left(smb_msg); total_read += length) {
 760                 try_to_freeze();
 761
 762                 /* reconnect if no credits and no requests in flight */
 763                 if (zero_credits(server)) {
 764                         cifs_reconnect(server);
 765                         return -ECONNABORTED;
 766                 }
 767
 768                 if (server_unresponsive(server))
 769                         return -ECONNABORTED;
 770                 if (cifs_rdma_enabled(server) && server->smbd_conn)
 771                         length = smbd_recv(server->smbd_conn, smb_msg);
 772                 else
 773                         length = sock_recvmsg(server->ssocket, smb_msg, 0);
 774
 775                 if (server->tcpStatus == CifsExiting)
 776                         return -ESHUTDOWN;
 777
 778                 if (server->tcpStatus == CifsNeedReconnect) {
 779                         cifs_reconnect(server);
 780                         return -ECONNABORTED;
 781                 }
 782
 783                 if (length == -ERESTARTSYS ||
 784                     length == -EAGAIN ||
 785                     length == -EINTR) {
 786                         /*
 787                          * Minimum sleep to prevent looping, allowing socket
 788                          * to clear and app threads to set tcpStatus
 789                          * CifsNeedReconnect if server hung.
 790                          */
 791                         usleep_range(1000, 2000);
 792                         length = 0;
 793                         continue;
 794                 }
 795
 796                 if (length <= 0) {
 797                         cifs_dbg(FYI, "Received no data or error: %d\n", length);
 798                         cifs_reconnect(server);
 799                         return -ECONNABORTED;
 800                 }
 801         }
 802         return total_read;
 803 }
 804
 805 int
 806 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
 807                       unsigned int to_read)
 808 {
 809         struct msghdr smb_msg;
 810         struct kvec iov = {.iov_base = buf, .iov_len = to_read};
 811         iov_iter_kvec(&smb_msg.msg_iter, READ, &iov, 1, to_read);
 812
 813         return cifs_readv_from_socket(server, &smb_msg);
 814 }
 815
 816 int
 817 cifs_read_page_from_socket(struct TCP_Server_Info *server, struct page *page,
 818         unsigned int page_offset, unsigned int to_read)
 819 {
 820         struct msghdr smb_msg;
 821         struct bio_vec bv = {
 822                 .bv_page = page, .bv_len = to_read, .bv_offset = page_offset};
 823         iov_iter_bvec(&smb_msg.msg_iter, READ, &bv, 1, to_read);
 824         return cifs_readv_from_socket(server, &smb_msg);
 825 }
 826
 827 static bool
 828 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
 829 {
 830         /*
 831          * The first byte big endian of the length field,
 832          * is actually not part of the length but the type
 833          * with the most common, zero, as regular data.
 834          */
 835         switch (type) {
 836         case RFC1002_SESSION_MESSAGE:
 837                 /* Regular SMB response */
 838                 return true;
 839         case RFC1002_SESSION_KEEP_ALIVE:
 840                 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
 841                 break;
 842         case RFC1002_POSITIVE_SESSION_RESPONSE:
 843                 cifs_dbg(FYI, "RFC 1002 positive session response\n");
 844                 break;
 845         case RFC1002_NEGATIVE_SESSION_RESPONSE:
 846                 /*
 847                  * We get this from Windows 98 instead of an error on
 848                  * SMB negprot response.
 849                  */
 850                 cifs_dbg(FYI, "RFC 1002 negative session response\n");
 851                 /* give server a second to clean up */
 852                 msleep(1000);
 853                 /*
 854                  * Always try 445 first on reconnect since we get NACK
 855                  * on some if we ever connected to port 139 (the NACK
 856                  * is since we do not begin with RFC1001 session
 857                  * initialize frame).
 858                  */
 859                 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
 860                 cifs_reconnect(server);
 861                 wake_up(&server->response_q);
 862                 break;
 863         default:
 864                 cifs_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
 865                 cifs_reconnect(server);
 866         }
 867
 868         return false;
 869 }
 870
 871 void
 872 dequeue_mid(struct mid_q_entry *mid, bool malformed)
 873 {
 874 #ifdef CONFIG_CIFS_STATS2
 875         mid->when_received = jiffies;
 876 #endif
 877         spin_lock(&GlobalMid_Lock);
 878         if (!malformed)
 879                 mid->mid_state = MID_RESPONSE_RECEIVED;
 880         else
 881                 mid->mid_state = MID_RESPONSE_MALFORMED;
 882         /*
 883          * Trying to handle/dequeue a mid after the send_recv()
 884          * function has finished processing it is a bug.
 885          */
 886         if (mid->mid_flags & MID_DELETED)
 887                 printk_once(KERN_WARNING
 888                             "trying to dequeue a deleted mid\n");
 889         else
 890                 list_del_init(&mid->qhead);
 891         spin_unlock(&GlobalMid_Lock);
 892 }
 893
 894 static void
 895 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
 896            char *buf, int malformed)
 897 {
 898         if (server->ops->check_trans2 &&
 899             server->ops->check_trans2(mid, server, buf, malformed))
 900                 return;
 901         mid->resp_buf = buf;
 902         mid->large_buf = server->large_buf;
 903         /* Was previous buf put in mpx struct for multi-rsp? */
 904         if (!mid->multiRsp) {
 905                 /* smb buffer will be freed by user thread */
 906                 if (server->large_buf)
 907                         server->bigbuf = NULL;
 908                 else
 909                         server->smallbuf = NULL;
 910         }
 911         dequeue_mid(mid, malformed);
 912 }
 913
 914 static void clean_demultiplex_info(struct TCP_Server_Info *server)
 915 {
 916         int length;
 917
 918         /* take it off the list, if it's not already */
 919         spin_lock(&cifs_tcp_ses_lock);
 920         list_del_init(&server->tcp_ses_list);
 921         spin_unlock(&cifs_tcp_ses_lock);
 922
 923         spin_lock(&GlobalMid_Lock);
 924         server->tcpStatus = CifsExiting;
 925         spin_unlock(&GlobalMid_Lock);
 926         wake_up_all(&server->response_q);
 927
 928         /* check if we have blocked requests that need to free */
 929         spin_lock(&server->req_lock);
 930         if (server->credits <= 0)
 931                 server->credits = 1;
 932         spin_unlock(&server->req_lock);
 933         /*
 934          * Although there should not be any requests blocked on this queue it
 935          * can not hurt to be paranoid and try to wake up requests that may
 936          * haven been blocked when more than 50 at time were on the wire to the
 937          * same server - they now will see the session is in exit state and get
 938          * out of SendReceive.
 939          */
 940         wake_up_all(&server->request_q);
 941         /* give those requests time to exit */
 942         msleep(125);
 943         if (cifs_rdma_enabled(server))
 944                 smbd_destroy(server);
 945         if (server->ssocket) {
 946                 sock_release(server->ssocket);
 947                 server->ssocket = NULL;
 948         }
 949
 950         if (!list_empty(&server->pending_mid_q)) {
 951                 struct list_head dispose_list;
 952                 struct mid_q_entry *mid_entry;
 953                 struct list_head *tmp, *tmp2;
 954
 955                 INIT_LIST_HEAD(&dispose_list);
 956                 spin_lock(&GlobalMid_Lock);
 957                 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 958                         mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 959                         cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
 960                         mid_entry->mid_state = MID_SHUTDOWN;
 961                         list_move(&mid_entry->qhead, &dispose_list);
 962                 }
 963                 spin_unlock(&GlobalMid_Lock);
 964
 965                 /* now walk dispose list and issue callbacks */
 966                 list_for_each_safe(tmp, tmp2, &dispose_list) {
 967                         mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 968                         cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
 969                         list_del_init(&mid_entry->qhead);
 970                         mid_entry->callback(mid_entry);
 971                 }
 972                 /* 1/8th of sec is more than enough time for them to exit */
 973                 msleep(125);
 974         }
 975
 976         if (!list_empty(&server->pending_mid_q)) {
 977                 /*
 978                  * mpx threads have not exited yet give them at least the smb
 979                  * send timeout time for long ops.
 980                  *
 981                  * Due to delays on oplock break requests, we need to wait at
 982                  * least 45 seconds before giving up on a request getting a
 983                  * response and going ahead and killing cifsd.
 984                  */
 985                 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
 986                 msleep(46000);
 987                 /*
 988                  * If threads still have not exited they are probably never
 989                  * coming home not much else we can do but free the memory.
 990                  */
 991         }
 992
 993         kfree(server->hostname);
 994         kfree(server);
 995
 996         length = atomic_dec_return(&tcpSesAllocCount);
 997         if (length > 0)
 998                 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
 999 }
1000
1001 static int
1002 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1003 {
1004         int length;
1005         char *buf = server->smallbuf;
1006         unsigned int pdu_length = server->pdu_size;
1007
1008         /* make sure this will fit in a large buffer */
1009         if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) -
1010                 server->vals->header_preamble_size) {
1011                 cifs_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
1012                 cifs_reconnect(server);
1013                 wake_up(&server->response_q);
1014                 return -ECONNABORTED;
1015         }
1016
1017         /* switch to large buffer if too big for a small one */
1018         if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
1019                 server->large_buf = true;
1020                 memcpy(server->bigbuf, buf, server->total_read);
1021                 buf = server->bigbuf;
1022         }
1023
1024         /* now read the rest */
1025         length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
1026                                        pdu_length - HEADER_SIZE(server) + 1
1027                                        + server->vals->header_preamble_size);
1028
1029         if (length < 0)
1030                 return length;
1031         server->total_read += length;
1032
1033         dump_smb(buf, server->total_read);
1034
1035         return cifs_handle_standard(server, mid);
1036 }
1037
1038 int
1039 cifs_handle_standard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1040 {
1041         char *buf = server->large_buf ? server->bigbuf : server->smallbuf;
1042         int length;
1043
1044         /*
1045          * We know that we received enough to get to the MID as we
1046          * checked the pdu_length earlier. Now check to see
1047          * if the rest of the header is OK. We borrow the length
1048          * var for the rest of the loop to avoid a new stack var.
1049          *
1050          * 48 bytes is enough to display the header and a little bit
1051          * into the payload for debugging purposes.
1052          */
1053         length = server->ops->check_message(buf, server->total_read, server);
1054         if (length != 0)
1055                 cifs_dump_mem("Bad SMB: ", buf,
1056                         min_t(unsigned int, server->total_read, 48));
1057
1058         if (server->ops->is_session_expired &&
1059             server->ops->is_session_expired(buf)) {
1060                 cifs_reconnect(server);
1061                 wake_up(&server->response_q);
1062                 return -1;
1063         }
1064
1065         if (server->ops->is_status_pending &&
1066             server->ops->is_status_pending(buf, server))
1067                 return -1;
1068
1069         if (!mid)
1070                 return length;
1071
1072         handle_mid(mid, server, buf, length);
1073         return 0;
1074 }
1075
1076 static void
1077 smb2_add_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)
1078 {
1079         struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buffer;
1080
1081         /*
1082          * SMB1 does not use credits.
1083          */
1084         if (server->vals->header_preamble_size)
1085                 return;
1086
1087         if (shdr->CreditRequest) {
1088                 spin_lock(&server->req_lock);
1089                 server->credits += le16_to_cpu(shdr->CreditRequest);
1090                 spin_unlock(&server->req_lock);
1091                 wake_up(&server->request_q);
1092         }
1093 }
1094
1095
1096 static int
1097 cifs_demultiplex_thread(void *p)
1098 {
1099         int i, num_mids, length;
1100         struct TCP_Server_Info *server = p;
1101         unsigned int pdu_length;
1102         unsigned int next_offset;
1103         char *buf = NULL;
1104         struct task_struct *task_to_wake = NULL;
1105         struct mid_q_entry *mids[MAX_COMPOUND];
1106         char *bufs[MAX_COMPOUND];
1107
1108         current->flags |= PF_MEMALLOC;
1109         cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
1110
1111         length = atomic_inc_return(&tcpSesAllocCount);
1112         if (length > 1)
1113                 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
1114
1115         set_freezable();
1116         while (server->tcpStatus != CifsExiting) {
1117                 if (try_to_freeze())
1118                         continue;
1119
1120                 if (!allocate_buffers(server))
1121                         continue;
1122
1123                 server->large_buf = false;
1124                 buf = server->smallbuf;
1125                 pdu_length = 4; /* enough to get RFC1001 header */
1126
1127                 length = cifs_read_from_socket(server, buf, pdu_length);
1128                 if (length < 0)
1129                         continue;
1130
1131                 if (server->vals->header_preamble_size == 0)
1132                         server->total_read = 0;
1133                 else
1134                         server->total_read = length;
1135
1136                 /*
1137                  * The right amount was read from socket - 4 bytes,
1138                  * so we can now interpret the length field.
1139                  */
1140                 pdu_length = get_rfc1002_length(buf);
1141
1142                 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
1143                 if (!is_smb_response(server, buf[0]))
1144                         continue;
1145 next_pdu:
1146                 server->pdu_size = pdu_length;
1147
1148                 /* make sure we have enough to get to the MID */
1149                 if (server->pdu_size < HEADER_SIZE(server) - 1 -
1150                     server->vals->header_preamble_size) {
1151                         cifs_dbg(VFS, "SMB response too short (%u bytes)\n",
1152                                  server->pdu_size);
1153                         cifs_reconnect(server);
1154                         wake_up(&server->response_q);
1155                         continue;
1156                 }
1157
1158                 /* read down to the MID */
1159                 length = cifs_read_from_socket(server,
1160                              buf + server->vals->header_preamble_size,
1161                              HEADER_SIZE(server) - 1
1162                              - server->vals->header_preamble_size);
1163                 if (length < 0)
1164                         continue;
1165                 server->total_read += length;
1166
1167                 if (server->ops->next_header) {
1168                         next_offset = server->ops->next_header(buf);
1169                         if (next_offset)
1170                                 server->pdu_size = next_offset;
1171                 }
1172
1173                 memset(mids, 0, sizeof(mids));
1174                 memset(bufs, 0, sizeof(bufs));
1175                 num_mids = 0;
1176
1177                 if (server->ops->is_transform_hdr &&
1178                     server->ops->receive_transform &&
1179                     server->ops->is_transform_hdr(buf)) {
1180                         length = server->ops->receive_transform(server,
1181                                                                 mids,
1182                                                                 bufs,
1183                                                                 &num_mids);
1184                 } else {
1185                         mids[0] = server->ops->find_mid(server, buf);
1186                         bufs[0] = buf;
1187                         num_mids = 1;
1188
1189                         if (!mids[0] || !mids[0]->receive)
1190                                 length = standard_receive3(server, mids[0]);
1191                         else
1192                                 length = mids[0]->receive(server, mids[0]);
1193                 }
1194
1195                 if (length < 0) {
1196                         for (i = 0; i < num_mids; i++)
1197                                 if (mids[i])
1198                                         cifs_mid_q_entry_release(mids[i]);
1199                         continue;
1200                 }
1201
1202                 server->lstrp = jiffies;
1203
1204                 for (i = 0; i < num_mids; i++) {
1205                         if (mids[i] != NULL) {
1206                                 mids[i]->resp_buf_size = server->pdu_size;
1207                                 if ((mids[i]->mid_flags & MID_WAIT_CANCELLED) &&
1208                                     mids[i]->mid_state == MID_RESPONSE_RECEIVED &&
1209                                     server->ops->handle_cancelled_mid)
1210                                         server->ops->handle_cancelled_mid(
1211                                                         mids[i]->resp_buf,
1212                                                         server);
1213
1214                                 if (!mids[i]->multiRsp || mids[i]->multiEnd)
1215                                         mids[i]->callback(mids[i]);
1216
1217                                 cifs_mid_q_entry_release(mids[i]);
1218                         } else if (server->ops->is_oplock_break &&
1219                                    server->ops->is_oplock_break(bufs[i],
1220                                                                 server)) {
1221                                 smb2_add_credits_from_hdr(bufs[i], server);
1222                                 cifs_dbg(FYI, "Received oplock break\n");
1223                         } else {
1224                                 cifs_dbg(VFS, "No task to wake, unknown frame "
1225                                          "received! NumMids %d\n",
1226                                          atomic_read(&midCount));
1227                                 cifs_dump_mem("Received Data is: ", bufs[i],
1228                                               HEADER_SIZE(server));
1229                                 smb2_add_credits_from_hdr(bufs[i], server);
1230 #ifdef CONFIG_CIFS_DEBUG2
1231                                 if (server->ops->dump_detail)
1232                                         server->ops->dump_detail(bufs[i],
1233                                                                  server);
1234                                 cifs_dump_mids(server);
1235 #endif /* CIFS_DEBUG2 */
1236                         }
1237                 }
1238
1239                 if (pdu_length > server->pdu_size) {
1240                         if (!allocate_buffers(server))
1241                                 continue;
1242                         pdu_length -= server->pdu_size;
1243                         server->total_read = 0;
1244                         server->large_buf = false;
1245                         buf = server->smallbuf;
1246                         goto next_pdu;
1247                 }
1248         } /* end while !EXITING */
1249
1250         /* buffer usually freed in free_mid - need to free it here on exit */
1251         cifs_buf_release(server->bigbuf);
1252         if (server->smallbuf) /* no sense logging a debug message if NULL */
1253                 cifs_small_buf_release(server->smallbuf);
1254
1255         task_to_wake = xchg(&server->tsk, NULL);
1256         clean_demultiplex_info(server);
1257
1258         /* if server->tsk was NULL then wait for a signal before exiting */
1259         if (!task_to_wake) {
1260                 set_current_state(TASK_INTERRUPTIBLE);
1261                 while (!signal_pending(current)) {
1262                         schedule();
1263                         set_current_state(TASK_INTERRUPTIBLE);
1264                 }
1265                 set_current_state(TASK_RUNNING);
1266         }
1267
1268         module_put_and_exit(0);
1269 }
1270
1271 /* extract the host portion of the UNC string */
1272 static char *
1273 extract_hostname(const char *unc)
1274 {
1275         const char *src;
1276         char *dst, *delim;
1277         unsigned int len;
1278
1279         /* skip double chars at beginning of string */
1280         /* BB: check validity of these bytes? */
1281         if (strlen(unc) < 3)
1282                 return ERR_PTR(-EINVAL);
1283         for (src = unc; *src && *src == '\\'; src++)
1284                 ;
1285         if (!*src)
1286                 return ERR_PTR(-EINVAL);
1287
1288         /* delimiter between hostname and sharename is always '\\' now */
1289         delim = strchr(src, '\\');
1290         if (!delim)
1291                 return ERR_PTR(-EINVAL);
1292
1293         len = delim - src;
1294         dst = kmalloc((len + 1), GFP_KERNEL);
1295         if (dst == NULL)
1296                 return ERR_PTR(-ENOMEM);
1297
1298         memcpy(dst, src, len);
1299         dst[len] = '\0';
1300
1301         return dst;
1302 }
1303
1304 static int get_option_ul(substring_t args[], unsigned long *option)
1305 {
1306         int rc;
1307         char *string;
1308
1309         string = match_strdup(args);
1310         if (string == NULL)
1311                 return -ENOMEM;
1312         rc = kstrtoul(string, 0, option);
1313         kfree(string);
1314
1315         return rc;
1316 }
1317
1318 static int get_option_uid(substring_t args[], kuid_t *result)
1319 {
1320         unsigned long value;
1321         kuid_t uid;
1322         int rc;
1323
1324         rc = get_option_ul(args, &value);
1325         if (rc)
1326                 return rc;
1327
1328         uid = make_kuid(current_user_ns(), value);
1329         if (!uid_valid(uid))
1330                 return -EINVAL;
1331
1332         *result = uid;
1333         return 0;
1334 }
1335
1336 static int get_option_gid(substring_t args[], kgid_t *result)
1337 {
1338         unsigned long value;
1339         kgid_t gid;
1340         int rc;
1341
1342         rc = get_option_ul(args, &value);
1343         if (rc)
1344                 return rc;
1345
1346         gid = make_kgid(current_user_ns(), value);
1347         if (!gid_valid(gid))
1348                 return -EINVAL;
1349
1350         *result = gid;
1351         return 0;
1352 }
1353
1354 static int cifs_parse_security_flavors(char *value,
1355                                        struct smb_vol *vol)
1356 {
1357
1358         substring_t args[MAX_OPT_ARGS];
1359
1360         /*
1361          * With mount options, the last one should win. Reset any existing
1362          * settings back to default.
1363          */
1364         vol->sectype = Unspecified;
1365         vol->sign = false;
1366
1367         switch (match_token(value, cifs_secflavor_tokens, args)) {
1368         case Opt_sec_krb5p:
1369                 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
1370                 return 1;
1371         case Opt_sec_krb5i:
1372                 vol->sign = true;
1373                 /* Fallthrough */
1374         case Opt_sec_krb5:
1375                 vol->sectype = Kerberos;
1376                 break;
1377         case Opt_sec_ntlmsspi:
1378                 vol->sign = true;
1379                 /* Fallthrough */
1380         case Opt_sec_ntlmssp:
1381                 vol->sectype = RawNTLMSSP;
1382                 break;
1383         case Opt_sec_ntlmi:
1384                 vol->sign = true;
1385                 /* Fallthrough */
1386         case Opt_ntlm:
1387                 vol->sectype = NTLM;
1388                 break;
1389         case Opt_sec_ntlmv2i:
1390                 vol->sign = true;
1391                 /* Fallthrough */
1392         case Opt_sec_ntlmv2:
1393                 vol->sectype = NTLMv2;
1394                 break;
1395 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1396         case Opt_sec_lanman:
1397                 vol->sectype = LANMAN;
1398                 break;
1399 #endif
1400         case Opt_sec_none:
1401                 vol->nullauth = 1;
1402                 break;
1403         default:
1404                 cifs_dbg(VFS, "bad security option: %s\n", value);
1405                 return 1;
1406         }
1407
1408         return 0;
1409 }
1410
1411 static int
1412 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1413 {
1414         substring_t args[MAX_OPT_ARGS];
1415
1416         switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1417         case Opt_cache_loose:
1418                 vol->direct_io = false;
1419                 vol->strict_io = false;
1420                 break;
1421         case Opt_cache_strict:
1422                 vol->direct_io = false;
1423                 vol->strict_io = true;
1424                 break;
1425         case Opt_cache_none:
1426                 vol->direct_io = true;
1427                 vol->strict_io = false;
1428                 break;
1429         default:
1430                 cifs_dbg(VFS, "bad cache= option: %s\n", value);
1431                 return 1;
1432         }
1433         return 0;
1434 }
1435
1436 static int
1437 cifs_parse_smb_version(char *value, struct smb_vol *vol, bool is_smb3)
1438 {
1439         substring_t args[MAX_OPT_ARGS];
1440
1441         switch (match_token(value, cifs_smb_version_tokens, args)) {
1442 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1443         case Smb_1:
1444                 if (disable_legacy_dialects) {
1445                         cifs_dbg(VFS, "mount with legacy dialect disabled\n");
1446                         return 1;
1447                 }
1448                 if (is_smb3) {
1449                         cifs_dbg(VFS, "vers=1.0 (cifs) not permitted when mounting with smb3\n");
1450                         return 1;
1451                 }
1452                 vol->ops = &smb1_operations;
1453                 vol->vals = &smb1_values;
1454                 break;
1455         case Smb_20:
1456                 if (disable_legacy_dialects) {
1457                         cifs_dbg(VFS, "mount with legacy dialect disabled\n");
1458                         return 1;
1459                 }
1460                 if (is_smb3) {
1461                         cifs_dbg(VFS, "vers=2.0 not permitted when mounting with smb3\n");
1462                         return 1;
1463                 }
1464                 vol->ops = &smb20_operations;
1465                 vol->vals = &smb20_values;
1466                 break;
1467 #else
1468         case Smb_1:
1469                 cifs_dbg(VFS, "vers=1.0 (cifs) mount not permitted when legacy dialects disabled\n");
1470                 return 1;
1471         case Smb_20:
1472                 cifs_dbg(VFS, "vers=2.0 mount not permitted when legacy dialects disabled\n");
1473                 return 1;
1474 #endif /* CIFS_ALLOW_INSECURE_LEGACY */
1475         case Smb_21:
1476                 vol->ops = &smb21_operations;
1477                 vol->vals = &smb21_values;
1478                 break;
1479         case Smb_30:
1480                 vol->ops = &smb30_operations;
1481                 vol->vals = &smb30_values;
1482                 break;
1483         case Smb_302:
1484                 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1485                 vol->vals = &smb302_values;
1486                 break;
1487         case Smb_311:
1488                 vol->ops = &smb311_operations;
1489                 vol->vals = &smb311_values;
1490                 break;
1491         case Smb_3any:
1492                 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1493                 vol->vals = &smb3any_values;
1494                 break;
1495         case Smb_default:
1496                 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1497                 vol->vals = &smbdefault_values;
1498                 break;
1499         default:
1500                 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
1501                 return 1;
1502         }
1503         return 0;
1504 }
1505
1506 /*
1507  * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1508  * fields with the result. Returns 0 on success and an error otherwise.
1509  */
1510 static int
1511 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1512 {
1513         char *pos;
1514         const char *delims = "/\\";
1515         size_t len;
1516
1517         if (unlikely(!devname || !*devname)) {
1518                 cifs_dbg(VFS, "Device name not specified.\n");
1519                 return -EINVAL;
1520         }
1521
1522         /* make sure we have a valid UNC double delimiter prefix */
1523         len = strspn(devname, delims);
1524         if (len != 2)
1525                 return -EINVAL;
1526
1527         /* find delimiter between host and sharename */
1528         pos = strpbrk(devname + 2, delims);
1529         if (!pos)
1530                 return -EINVAL;
1531
1532         /* skip past delimiter */
1533         ++pos;
1534
1535         /* now go until next delimiter or end of string */
1536         len = strcspn(pos, delims);
1537
1538         /* move "pos" up to delimiter or NULL */
1539         pos += len;
1540         vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1541         if (!vol->UNC)
1542                 return -ENOMEM;
1543
1544         convert_delimiter(vol->UNC, '\\');
1545
1546         /* skip any delimiter */
1547         if (*pos == '/' || *pos == '\\')
1548                 pos++;
1549
1550         /* If pos is NULL then no prepath */
1551         if (!*pos)
1552                 return 0;
1553
1554         vol->prepath = kstrdup(pos, GFP_KERNEL);
1555         if (!vol->prepath)
1556                 return -ENOMEM;
1557
1558         return 0;
1559 }
1560
1561 static int
1562 cifs_parse_mount_options(const char *mountdata, const char *devname,
1563                          struct smb_vol *vol, bool is_smb3)
1564 {
1565         char *data, *end;
1566         char *mountdata_copy = NULL, *options;
1567         unsigned int  temp_len, i, j;
1568         char separator[2];
1569         short int override_uid = -1;
1570         short int override_gid = -1;
1571         bool uid_specified = false;
1572         bool gid_specified = false;
1573         bool sloppy = false;
1574         char *invalid = NULL;
1575         char *nodename = utsname()->nodename;
1576         char *string = NULL;
1577         char *tmp_end, *value;
1578         char delim;
1579         bool got_ip = false;
1580         bool got_version = false;
1581         unsigned short port = 0;
1582         struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1583
1584         separator[0] = ',';
1585         separator[1] = 0;
1586         delim = separator[0];
1587
1588         /* ensure we always start with zeroed-out smb_vol */
1589         memset(vol, 0, sizeof(*vol));
1590
1591         /*
1592          * does not have to be perfect mapping since field is
1593          * informational, only used for servers that do not support
1594          * port 445 and it can be overridden at mount time
1595          */
1596         memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1597         for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1598                 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1599
1600         vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1601         /* null target name indicates to use *SMBSERVR default called name
1602            if we end up sending RFC1001 session initialize */
1603         vol->target_rfc1001_name[0] = 0;
1604         vol->cred_uid = current_uid();
1605         vol->linux_uid = current_uid();
1606         vol->linux_gid = current_gid();
1607         vol->bsize = 1024 * 1024; /* can improve cp performance significantly */
1608         /*
1609          * default to SFM style remapping of seven reserved characters
1610          * unless user overrides it or we negotiate CIFS POSIX where
1611          * it is unnecessary.  Can not simultaneously use more than one mapping
1612          * since then readdir could list files that open could not open
1613          */
1614         vol->remap = true;
1615
1616         /* default to only allowing write access to owner of the mount */
1617         vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1618
1619         /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1620         /* default is always to request posix paths. */
1621         vol->posix_paths = 1;
1622         /* default to using server inode numbers where available */
1623         vol->server_ino = 1;
1624
1625         /* default is to use strict cifs caching semantics */
1626         vol->strict_io = true;
1627
1628         vol->actimeo = CIFS_DEF_ACTIMEO;
1629
1630         /* Most clients set timeout to 0, allows server to use its default */
1631         vol->handle_timeout = 0; /* See MS-SMB2 spec section 2.2.14.2.12 */
1632
1633         /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1634         vol->ops = &smb30_operations;
1635         vol->vals = &smbdefault_values;
1636
1637         vol->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1638
1639         if (!mountdata)
1640                 goto cifs_parse_mount_err;
1641
1642         mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1643         if (!mountdata_copy)
1644                 goto cifs_parse_mount_err;
1645
1646         options = mountdata_copy;
1647         end = options + strlen(options);
1648
1649         if (strncmp(options, "sep=", 4) == 0) {
1650                 if (options[4] != 0) {
1651                         separator[0] = options[4];
1652                         options += 5;
1653                 } else {
1654                         cifs_dbg(FYI, "Null separator not allowed\n");
1655                 }
1656         }
1657         vol->backupuid_specified = false; /* no backup intent for a user */
1658         vol->backupgid_specified = false; /* no backup intent for a group */
1659
1660         switch (cifs_parse_devname(devname, vol)) {
1661         case 0:
1662                 break;
1663         case -ENOMEM:
1664                 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1665                 goto cifs_parse_mount_err;
1666         case -EINVAL:
1667                 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1668                 goto cifs_parse_mount_err;
1669         default:
1670                 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1671                 goto cifs_parse_mount_err;
1672         }
1673
1674         while ((data = strsep(&options, separator)) != NULL) {
1675                 substring_t args[MAX_OPT_ARGS];
1676                 unsigned long option;
1677                 int token;
1678
1679                 if (!*data)
1680                         continue;
1681
1682                 token = match_token(data, cifs_mount_option_tokens, args);
1683
1684                 switch (token) {
1685
1686                 /* Ingnore the following */
1687                 case Opt_ignore:
1688                         break;
1689
1690                 /* Boolean values */
1691                 case Opt_user_xattr:
1692                         vol->no_xattr = 0;
1693                         break;
1694                 case Opt_nouser_xattr:
1695                         vol->no_xattr = 1;
1696                         break;
1697                 case Opt_forceuid:
1698                         override_uid = 1;
1699                         break;
1700                 case Opt_noforceuid:
1701                         override_uid = 0;
1702                         break;
1703                 case Opt_forcegid:
1704                         override_gid = 1;
1705                         break;
1706                 case Opt_noforcegid:
1707                         override_gid = 0;
1708                         break;
1709                 case Opt_noblocksend:
1710                         vol->noblocksnd = 1;
1711                         break;
1712                 case Opt_noautotune:
1713                         vol->noautotune = 1;
1714                         break;
1715                 case Opt_hard:
1716                         vol->retry = 1;
1717                         break;
1718                 case Opt_soft:
1719                         vol->retry = 0;
1720                         break;
1721                 case Opt_perm:
1722                         vol->noperm = 0;
1723                         break;
1724                 case Opt_noperm:
1725                         vol->noperm = 1;
1726                         break;
1727                 case Opt_mapchars:
1728                         vol->sfu_remap = true;
1729                         vol->remap = false; /* disable SFM mapping */
1730                         break;
1731                 case Opt_nomapchars:
1732                         vol->sfu_remap = false;
1733                         break;
1734                 case Opt_mapposix:
1735                         vol->remap = true;
1736                         vol->sfu_remap = false; /* disable SFU mapping */
1737                         break;
1738                 case Opt_nomapposix:
1739                         vol->remap = false;
1740                         break;
1741                 case Opt_sfu:
1742                         vol->sfu_emul = 1;
1743                         break;
1744                 case Opt_nosfu:
1745                         vol->sfu_emul = 0;
1746                         break;
1747                 case Opt_nodfs:
1748                         vol->nodfs = 1;
1749                         break;
1750                 case Opt_posixpaths:
1751                         vol->posix_paths = 1;
1752                         break;
1753                 case Opt_noposixpaths:
1754                         vol->posix_paths = 0;
1755                         break;
1756                 case Opt_nounix:
1757                         if (vol->linux_ext)
1758                                 cifs_dbg(VFS,
1759                                         "conflicting unix mount options\n");
1760                         vol->no_linux_ext = 1;
1761                         break;
1762                 case Opt_unix:
1763                         if (vol->no_linux_ext)
1764                                 cifs_dbg(VFS,
1765                                         "conflicting unix mount options\n");
1766                         vol->linux_ext = 1;
1767                         break;
1768                 case Opt_nocase:
1769                         vol->nocase = 1;
1770                         break;
1771                 case Opt_brl:
1772                         vol->nobrl =  0;
1773                         break;
1774                 case Opt_nobrl:
1775                         vol->nobrl =  1;
1776                         /*
1777                          * turn off mandatory locking in mode
1778                          * if remote locking is turned off since the
1779                          * local vfs will do advisory
1780                          */
1781                         if (vol->file_mode ==
1782                                 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1783                                 vol->file_mode = S_IALLUGO;
1784                         break;
1785                 case Opt_nohandlecache:
1786                         vol->nohandlecache = 1;
1787                         break;
1788                 case Opt_handlecache:
1789                         vol->nohandlecache = 0;
1790                         break;
1791                 case Opt_forcemandatorylock:
1792                         vol->mand_lock = 1;
1793                         break;
1794                 case Opt_setuids:
1795                         vol->setuids = 1;
1796                         break;
1797                 case Opt_nosetuids:
1798                         vol->setuids = 0;
1799                         break;
1800                 case Opt_setuidfromacl:
1801                         vol->setuidfromacl = 1;
1802                         break;
1803                 case Opt_dynperm:
1804                         vol->dynperm = true;
1805                         break;
1806                 case Opt_nodynperm:
1807                         vol->dynperm = false;
1808                         break;
1809                 case Opt_nohard:
1810                         vol->retry = 0;
1811                         break;
1812                 case Opt_nosoft:
1813                         vol->retry = 1;
1814                         break;
1815                 case Opt_nointr:
1816                         vol->intr = 0;
1817                         break;
1818                 case Opt_intr:
1819                         vol->intr = 1;
1820                         break;
1821                 case Opt_nostrictsync:
1822                         vol->nostrictsync = 1;
1823                         break;
1824                 case Opt_strictsync:
1825                         vol->nostrictsync = 0;
1826                         break;
1827                 case Opt_serverino:
1828                         vol->server_ino = 1;
1829                         break;
1830                 case Opt_noserverino:
1831                         vol->server_ino = 0;
1832                         break;
1833                 case Opt_rwpidforward:
1834                         vol->rwpidforward = 1;
1835                         break;
1836                 case Opt_modesid:
1837                         vol->mode_ace = 1;
1838                         break;
1839                 case Opt_cifsacl:
1840                         vol->cifs_acl = 1;
1841                         break;
1842                 case Opt_nocifsacl:
1843                         vol->cifs_acl = 0;
1844                         break;
1845                 case Opt_acl:
1846                         vol->no_psx_acl = 0;
1847                         break;
1848                 case Opt_noacl:
1849                         vol->no_psx_acl = 1;
1850                         break;
1851                 case Opt_locallease:
1852                         vol->local_lease = 1;
1853                         break;
1854                 case Opt_sign:
1855                         vol->sign = true;
1856                         break;
1857                 case Opt_seal:
1858                         /* we do not do the following in secFlags because seal
1859                          * is a per tree connection (mount) not a per socket
1860                          * or per-smb connection option in the protocol
1861                          * vol->secFlg |= CIFSSEC_MUST_SEAL;
1862                          */
1863                         vol->seal = 1;
1864                         break;
1865                 case Opt_noac:
1866                         pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1867                         break;
1868                 case Opt_fsc:
1869 #ifndef CONFIG_CIFS_FSCACHE
1870                         cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1871                         goto cifs_parse_mount_err;
1872 #endif
1873                         vol->fsc = true;
1874                         break;
1875                 case Opt_mfsymlinks:
1876                         vol->mfsymlinks = true;
1877                         break;
1878                 case Opt_multiuser:
1879                         vol->multiuser = true;
1880                         break;
1881                 case Opt_sloppy:
1882                         sloppy = true;
1883                         break;
1884                 case Opt_nosharesock:
1885                         vol->nosharesock = true;
1886                         break;
1887                 case Opt_nopersistent:
1888                         vol->nopersistent = true;
1889                         if (vol->persistent) {
1890                                 cifs_dbg(VFS,
1891                                   "persistenthandles mount options conflict\n");
1892                                 goto cifs_parse_mount_err;
1893                         }
1894                         break;
1895                 case Opt_persistent:
1896                         vol->persistent = true;
1897                         if ((vol->nopersistent) || (vol->resilient)) {
1898                                 cifs_dbg(VFS,
1899                                   "persistenthandles mount options conflict\n");
1900                                 goto cifs_parse_mount_err;
1901                         }
1902                         break;
1903                 case Opt_resilient:
1904                         vol->resilient = true;
1905                         if (vol->persistent) {
1906                                 cifs_dbg(VFS,
1907                                   "persistenthandles mount options conflict\n");
1908                                 goto cifs_parse_mount_err;
1909                         }
1910                         break;
1911                 case Opt_noresilient:
1912                         vol->resilient = false; /* already the default */
1913                         break;
1914                 case Opt_domainauto:
1915                         vol->domainauto = true;
1916                         break;
1917                 case Opt_rdma:
1918                         vol->rdma = true;
1919                         break;
1920                 case Opt_compress:
1921                         vol->compression = UNKNOWN_TYPE;
1922                         cifs_dbg(VFS,
1923                                 "SMB3 compression support is experimental\n");
1924                         break;
1925
1926                 /* Numeric Values */
1927                 case Opt_backupuid:
1928                         if (get_option_uid(args, &vol->backupuid)) {
1929                                 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1930                                          __func__);
1931                                 goto cifs_parse_mount_err;
1932                         }
1933                         vol->backupuid_specified = true;
1934                         break;
1935                 case Opt_backupgid:
1936                         if (get_option_gid(args, &vol->backupgid)) {
1937                                 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1938                                          __func__);
1939                                 goto cifs_parse_mount_err;
1940                         }
1941                         vol->backupgid_specified = true;
1942                         break;
1943                 case Opt_uid:
1944                         if (get_option_uid(args, &vol->linux_uid)) {
1945                                 cifs_dbg(VFS, "%s: Invalid uid value\n",
1946                                          __func__);
1947                                 goto cifs_parse_mount_err;
1948                         }
1949                         uid_specified = true;
1950                         break;
1951                 case Opt_cruid:
1952                         if (get_option_uid(args, &vol->cred_uid)) {
1953                                 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1954                                          __func__);
1955                                 goto cifs_parse_mount_err;
1956                         }
1957                         break;
1958                 case Opt_gid:
1959                         if (get_option_gid(args, &vol->linux_gid)) {
1960                                 cifs_dbg(VFS, "%s: Invalid gid value\n",
1961                                          __func__);
1962                                 goto cifs_parse_mount_err;
1963                         }
1964                         gid_specified = true;
1965                         break;
1966                 case Opt_file_mode:
1967                         if (get_option_ul(args, &option)) {
1968                                 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1969                                          __func__);
1970                                 goto cifs_parse_mount_err;
1971                         }
1972                         vol->file_mode = option;
1973                         break;
1974                 case Opt_dirmode:
1975                         if (get_option_ul(args, &option)) {
1976                                 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1977                                          __func__);
1978                                 goto cifs_parse_mount_err;
1979                         }
1980                         vol->dir_mode = option;
1981                         break;
1982                 case Opt_port:
1983                         if (get_option_ul(args, &option) ||
1984                             option > USHRT_MAX) {
1985                                 cifs_dbg(VFS, "%s: Invalid port value\n",
1986                                          __func__);
1987                                 goto cifs_parse_mount_err;
1988                         }
1989                         port = (unsigned short)option;
1990                         break;
1991                 case Opt_blocksize:
1992                         if (get_option_ul(args, &option)) {
1993                                 cifs_dbg(VFS, "%s: Invalid blocksize value\n",
1994                                         __func__);
1995                                 goto cifs_parse_mount_err;
1996                         }
1997                         /*
1998                          * inode blocksize realistically should never need to be
1999                          * less than 16K or greater than 16M and default is 1MB.
2000                          * Note that small inode block sizes (e.g. 64K) can lead
2001                          * to very poor performance of common tools like cp and scp
2002                          */
2003                         if ((option < CIFS_MAX_MSGSIZE) ||
2004                            (option > (4 * SMB3_DEFAULT_IOSIZE))) {
2005                                 cifs_dbg(VFS, "%s: Invalid blocksize\n",
2006                                         __func__);
2007                                 goto cifs_parse_mount_err;
2008                         }
2009                         vol->bsize = option;
2010                         break;
2011                 case Opt_rsize:
2012                         if (get_option_ul(args, &option)) {
2013                                 cifs_dbg(VFS, "%s: Invalid rsize value\n",
2014                                          __func__);
2015                                 goto cifs_parse_mount_err;
2016                         }
2017                         vol->rsize = option;
2018                         break;
2019                 case Opt_wsize:
2020                         if (get_option_ul(args, &option)) {
2021                                 cifs_dbg(VFS, "%s: Invalid wsize value\n",
2022                                          __func__);
2023                                 goto cifs_parse_mount_err;
2024                         }
2025                         vol->wsize = option;
2026                         break;
2027                 case Opt_actimeo:
2028                         if (get_option_ul(args, &option)) {
2029                                 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
2030                                          __func__);
2031                                 goto cifs_parse_mount_err;
2032                         }
2033                         vol->actimeo = HZ * option;
2034                         if (vol->actimeo > CIFS_MAX_ACTIMEO) {
2035                                 cifs_dbg(VFS, "attribute cache timeout too large\n");
2036                                 goto cifs_parse_mount_err;
2037                         }
2038                         break;
2039                 case Opt_handletimeout:
2040                         if (get_option_ul(args, &option)) {
2041                                 cifs_dbg(VFS, "%s: Invalid handletimeout value\n",
2042                                          __func__);
2043                                 goto cifs_parse_mount_err;
2044                         }
2045                         vol->handle_timeout = option;
2046                         if (vol->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) {
2047                                 cifs_dbg(VFS, "Invalid handle cache timeout, longer than 16 minutes\n");
2048                                 goto cifs_parse_mount_err;
2049                         }
2050                         break;
2051                 case Opt_echo_interval:
2052                         if (get_option_ul(args, &option)) {
2053                                 cifs_dbg(VFS, "%s: Invalid echo interval value\n",
2054                                          __func__);
2055                                 goto cifs_parse_mount_err;
2056                         }
2057                         vol->echo_interval = option;
2058                         break;
2059                 case Opt_snapshot:
2060                         if (get_option_ul(args, &option)) {
2061                                 cifs_dbg(VFS, "%s: Invalid snapshot time\n",
2062                                          __func__);
2063                                 goto cifs_parse_mount_err;
2064                         }
2065                         vol->snapshot_time = option;
2066                         break;
2067                 case Opt_max_credits:
2068                         if (get_option_ul(args, &option) || (option < 20) ||
2069                             (option > 60000)) {
2070                                 cifs_dbg(VFS, "%s: Invalid max_credits value\n",
2071                                          __func__);
2072                                 goto cifs_parse_mount_err;
2073                         }
2074                         vol->max_credits = option;
2075                         break;
2076
2077                 /* String Arguments */
2078
2079                 case Opt_blank_user:
2080                         /* null user, ie. anonymous authentication */
2081                         vol->nullauth = 1;
2082                         vol->username = NULL;
2083                         break;
2084                 case Opt_user:
2085                         string = match_strdup(args);
2086                         if (string == NULL)
2087                                 goto out_nomem;
2088
2089                         if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
2090                                                         CIFS_MAX_USERNAME_LEN) {
2091                                 pr_warn("CIFS: username too long\n");
2092                                 goto cifs_parse_mount_err;
2093                         }
2094
2095                         kfree(vol->username);
2096                         vol->username = kstrdup(string, GFP_KERNEL);
2097                         if (!vol->username)
2098                                 goto cifs_parse_mount_err;
2099                         break;
2100                 case Opt_blank_pass:
2101                         /* passwords have to be handled differently
2102                          * to allow the character used for deliminator
2103                          * to be passed within them
2104                          */
2105
2106                         /*
2107                          * Check if this is a case where the  password
2108                          * starts with a delimiter
2109                          */
2110                         tmp_end = strchr(data, '=');
2111                         tmp_end++;
2112                         if (!(tmp_end < end && tmp_end[1] == delim)) {
2113                                 /* No it is not. Set the password to NULL */
2114                                 kzfree(vol->password);
2115                                 vol->password = NULL;
2116                                 break;
2117                         }
2118                         /* Fallthrough - to Opt_pass below.*/
2119                 case Opt_pass:
2120                         /* Obtain the value string */
2121                         value = strchr(data, '=');
2122                         value++;
2123
2124                         /* Set tmp_end to end of the string */
2125                         tmp_end = (char *) value + strlen(value);
2126
2127                         /* Check if following character is the deliminator
2128                          * If yes, we have encountered a double deliminator
2129                          * reset the NULL character to the deliminator
2130                          */
2131                         if (tmp_end < end && tmp_end[1] == delim) {
2132                                 tmp_end[0] = delim;
2133
2134                                 /* Keep iterating until we get to a single
2135                                  * deliminator OR the end
2136                                  */
2137                                 while ((tmp_end = strchr(tmp_end, delim))
2138                                         != NULL && (tmp_end[1] == delim)) {
2139                                                 tmp_end = (char *) &tmp_end[2];
2140                                 }
2141
2142                                 /* Reset var options to point to next element */
2143                                 if (tmp_end) {
2144                                         tmp_end[0] = '\0';
2145                                         options = (char *) &tmp_end[1];
2146                                 } else
2147                                         /* Reached the end of the mount option
2148                                          * string */
2149                                         options = end;
2150                         }
2151
2152                         kzfree(vol->password);
2153                         /* Now build new password string */
2154                         temp_len = strlen(value);
2155                         vol->password = kzalloc(temp_len+1, GFP_KERNEL);
2156                         if (vol->password == NULL) {
2157                                 pr_warn("CIFS: no memory for password\n");
2158                                 goto cifs_parse_mount_err;
2159                         }
2160
2161                         for (i = 0, j = 0; i < temp_len; i++, j++) {
2162                                 vol->password[j] = value[i];
2163                                 if ((value[i] == delim) &&
2164                                      value[i+1] == delim)
2165                                         /* skip the second deliminator */
2166                                         i++;
2167                         }
2168                         vol->password[j] = '\0';
2169                         break;
2170                 case Opt_blank_ip:
2171                         /* FIXME: should this be an error instead? */
2172                         got_ip = false;
2173                         break;
2174                 case Opt_ip:
2175                         string = match_strdup(args);
2176                         if (string == NULL)
2177                                 goto out_nomem;
2178
2179                         if (!cifs_convert_address(dstaddr, string,
2180                                         strlen(string))) {
2181                                 pr_err("CIFS: bad ip= option (%s).\n", string);
2182                                 goto cifs_parse_mount_err;
2183                         }
2184                         got_ip = true;
2185                         break;
2186                 case Opt_domain:
2187                         string = match_strdup(args);
2188                         if (string == NULL)
2189                                 goto out_nomem;
2190
2191                         if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
2192                                         == CIFS_MAX_DOMAINNAME_LEN) {
2193                                 pr_warn("CIFS: domain name too long\n");
2194                                 goto cifs_parse_mount_err;
2195                         }
2196
2197                         kfree(vol->domainname);
2198                         vol->domainname = kstrdup(string, GFP_KERNEL);
2199                         if (!vol->domainname) {
2200                                 pr_warn("CIFS: no memory for domainname\n");
2201                                 goto cifs_parse_mount_err;
2202                         }
2203                         cifs_dbg(FYI, "Domain name set\n");
2204                         break;
2205                 case Opt_srcaddr:
2206                         string = match_strdup(args);
2207                         if (string == NULL)
2208                                 goto out_nomem;
2209
2210                         if (!cifs_convert_address(
2211                                         (struct sockaddr *)&vol->srcaddr,
2212                                         string, strlen(string))) {
2213                                 pr_warn("CIFS: Could not parse srcaddr: %s\n",
2214                                         string);
2215                                 goto cifs_parse_mount_err;
2216                         }
2217                         break;
2218                 case Opt_iocharset:
2219                         string = match_strdup(args);
2220                         if (string == NULL)
2221                                 goto out_nomem;
2222
2223                         if (strnlen(string, 1024) >= 65) {
2224                                 pr_warn("CIFS: iocharset name too long.\n");
2225                                 goto cifs_parse_mount_err;
2226                         }
2227
2228                          if (strncasecmp(string, "default", 7) != 0) {
2229                                 kfree(vol->iocharset);
2230                                 vol->iocharset = kstrdup(string,
2231                                                          GFP_KERNEL);
2232                                 if (!vol->iocharset) {
2233                                         pr_warn("CIFS: no memory for charset\n");
2234                                         goto cifs_parse_mount_err;
2235                                 }
2236                         }
2237                         /* if iocharset not set then load_nls_default
2238                          * is used by caller
2239                          */
2240                          cifs_dbg(FYI, "iocharset set to %s\n", string);
2241                         break;
2242                 case Opt_netbiosname:
2243                         string = match_strdup(args);
2244                         if (string == NULL)
2245                                 goto out_nomem;
2246
2247                         memset(vol->source_rfc1001_name, 0x20,
2248                                 RFC1001_NAME_LEN);
2249                         /*
2250                          * FIXME: are there cases in which a comma can
2251                          * be valid in workstation netbios name (and
2252                          * need special handling)?
2253                          */
2254                         for (i = 0; i < RFC1001_NAME_LEN; i++) {
2255                                 /* don't ucase netbiosname for user */
2256                                 if (string[i] == 0)
2257                                         break;
2258                                 vol->source_rfc1001_name[i] = string[i];
2259                         }
2260                         /* The string has 16th byte zero still from
2261                          * set at top of the function
2262                          */
2263                         if (i == RFC1001_NAME_LEN && string[i] != 0)
2264                                 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
2265                         break;
2266                 case Opt_servern:
2267                         /* servernetbiosname specified override *SMBSERVER */
2268                         string = match_strdup(args);
2269                         if (string == NULL)
2270                                 goto out_nomem;
2271
2272                         /* last byte, type, is 0x20 for servr type */
2273                         memset(vol->target_rfc1001_name, 0x20,
2274                                 RFC1001_NAME_LEN_WITH_NULL);
2275
2276                         /* BB are there cases in which a comma can be
2277                            valid in this workstation netbios name
2278                            (and need special handling)? */
2279
2280                         /* user or mount helper must uppercase the
2281                            netbios name */
2282                         for (i = 0; i < 15; i++) {
2283                                 if (string[i] == 0)
2284                                         break;
2285                                 vol->target_rfc1001_name[i] = string[i];
2286                         }
2287                         /* The string has 16th byte zero still from
2288                            set at top of the function  */
2289                         if (i == RFC1001_NAME_LEN && string[i] != 0)
2290                                 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
2291                         break;
2292                 case Opt_ver:
2293                         /* version of mount userspace tools, not dialect */
2294                         string = match_strdup(args);
2295                         if (string == NULL)
2296                                 goto out_nomem;
2297
2298                         /* If interface changes in mount.cifs bump to new ver */
2299                         if (strncasecmp(string, "1", 1) == 0) {
2300                                 if (strlen(string) > 1) {
2301                                         pr_warn("Bad mount helper ver=%s. Did "
2302                                                 "you want SMB1 (CIFS) dialect "
2303                                                 "and mean to type vers=1.0 "
2304                                                 "instead?\n", string);
2305                                         goto cifs_parse_mount_err;
2306                                 }
2307                                 /* This is the default */
2308                                 break;
2309                         }
2310                         /* For all other value, error */
2311                         pr_warn("CIFS: Invalid mount helper version specified\n");
2312                         goto cifs_parse_mount_err;
2313                 case Opt_vers:
2314                         /* protocol version (dialect) */
2315                         string = match_strdup(args);
2316                         if (string == NULL)
2317                                 goto out_nomem;
2318
2319                         if (cifs_parse_smb_version(string, vol, is_smb3) != 0)
2320                                 goto cifs_parse_mount_err;
2321                         got_version = true;
2322                         break;
2323                 case Opt_sec:
2324                         string = match_strdup(args);
2325                         if (string == NULL)
2326                                 goto out_nomem;
2327
2328                         if (cifs_parse_security_flavors(string, vol) != 0)
2329                                 goto cifs_parse_mount_err;
2330                         break;
2331                 case Opt_cache:
2332                         string = match_strdup(args);
2333                         if (string == NULL)
2334                                 goto out_nomem;
2335
2336                         if (cifs_parse_cache_flavor(string, vol) != 0)
2337                                 goto cifs_parse_mount_err;
2338                         break;
2339                 default:
2340                         /*
2341                          * An option we don't recognize. Save it off for later
2342                          * if we haven't already found one
2343                          */
2344                         if (!invalid)
2345                                 invalid = data;
2346                         break;
2347                 }
2348                 /* Free up any allocated string */
2349                 kfree(string);
2350                 string = NULL;
2351         }
2352
2353         if (!sloppy && invalid) {
2354                 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
2355                 goto cifs_parse_mount_err;
2356         }
2357
2358         if (vol->rdma && vol->vals->protocol_id < SMB30_PROT_ID) {
2359                 cifs_dbg(VFS, "SMB Direct requires Version >=3.0\n");
2360                 goto cifs_parse_mount_err;
2361         }
2362
2363 #ifndef CONFIG_KEYS
2364         /* Muliuser mounts require CONFIG_KEYS support */
2365         if (vol->multiuser) {
2366                 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
2367                 goto cifs_parse_mount_err;
2368         }
2369 #endif
2370         if (!vol->UNC) {
2371                 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
2372                 goto cifs_parse_mount_err;
2373         }
2374
2375         /* make sure UNC has a share name */
2376         if (!strchr(vol->UNC + 3, '\\')) {
2377                 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
2378                 goto cifs_parse_mount_err;
2379         }
2380
2381         if (!got_ip) {
2382                 int len;
2383                 const char *slash;
2384
2385                 /* No ip= option specified? Try to get it from UNC */
2386                 /* Use the address part of the UNC. */
2387                 slash = strchr(&vol->UNC[2], '\\');
2388                 len = slash - &vol->UNC[2];
2389                 if (!cifs_convert_address(dstaddr, &vol->UNC[2], len)) {
2390                         pr_err("Unable to determine destination address.\n");
2391                         goto cifs_parse_mount_err;
2392                 }
2393         }
2394
2395         /* set the port that we got earlier */
2396         cifs_set_port(dstaddr, port);
2397
2398         if (uid_specified)
2399                 vol->override_uid = override_uid;
2400         else if (override_uid == 1)
2401                 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
2402
2403         if (gid_specified)
2404                 vol->override_gid = override_gid;
2405         else if (override_gid == 1)
2406                 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
2407
2408         if (got_version == false)
2409                 pr_warn("No dialect specified on mount. Default has changed to "
2410                         "a more secure dialect, SMB2.1 or later (e.g. SMB3), from CIFS "
2411                         "(SMB1). To use the less secure SMB1 dialect to access "
2412                         "old servers which do not support SMB3 (or SMB2.1) specify vers=1.0"
2413                         " on mount.\n");
2414
2415         kfree(mountdata_copy);
2416         return 0;
2417
2418 out_nomem:
2419         pr_warn("Could not allocate temporary buffer\n");
2420 cifs_parse_mount_err:
2421         kfree(string);
2422         kfree(mountdata_copy);
2423         return 1;
2424 }
2425
2426 /** Returns true if srcaddr isn't specified and rhs isn't
2427  * specified, or if srcaddr is specified and
2428  * matches the IP address of the rhs argument.
2429  */
2430 static bool
2431 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
2432 {
2433         switch (srcaddr->sa_family) {
2434         case AF_UNSPEC:
2435                 return (rhs->sa_family == AF_UNSPEC);
2436         case AF_INET: {
2437                 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
2438                 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
2439                 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
2440         }
2441         case AF_INET6: {
2442                 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
2443                 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
2444                 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
2445         }
2446         default:
2447                 WARN_ON(1);
2448                 return false; /* don't expect to be here */
2449         }
2450 }
2451
2452 /*
2453  * If no port is specified in addr structure, we try to match with 445 port
2454  * and if it fails - with 139 ports. It should be called only if address
2455  * families of server and addr are equal.
2456  */
2457 static bool
2458 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
2459 {
2460         __be16 port, *sport;
2461
2462         /* SMBDirect manages its own ports, don't match it here */
2463         if (server->rdma)
2464                 return true;
2465
2466         switch (addr->sa_family) {
2467         case AF_INET:
2468                 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
2469                 port = ((struct sockaddr_in *) addr)->sin_port;
2470                 break;
2471         case AF_INET6:
2472                 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
2473                 port = ((struct sockaddr_in6 *) addr)->sin6_port;
2474                 break;
2475         default:
2476                 WARN_ON(1);
2477                 return false;
2478         }
2479
2480         if (!port) {
2481                 port = htons(CIFS_PORT);
2482                 if (port == *sport)
2483                         return true;
2484
2485                 port = htons(RFC1001_PORT);
2486         }
2487
2488         return port == *sport;
2489 }
2490
2491 static bool
2492 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
2493               struct sockaddr *srcaddr)
2494 {
2495         switch (addr->sa_family) {
2496         case AF_INET: {
2497                 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2498                 struct sockaddr_in *srv_addr4 =
2499                                         (struct sockaddr_in *)&server->dstaddr;
2500
2501                 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2502                         return false;
2503                 break;
2504         }
2505         case AF_INET6: {
2506                 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2507                 struct sockaddr_in6 *srv_addr6 =
2508                                         (struct sockaddr_in6 *)&server->dstaddr;
2509
2510                 if (!ipv6_addr_equal(&addr6->sin6_addr,
2511                                      &srv_addr6->sin6_addr))
2512                         return false;
2513                 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2514                         return false;
2515                 break;
2516         }
2517         default:
2518                 WARN_ON(1);
2519                 return false; /* don't expect to be here */
2520         }
2521
2522         if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2523                 return false;
2524
2525         return true;
2526 }
2527
2528 static bool
2529 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2530 {
2531         /*
2532          * The select_sectype function should either return the vol->sectype
2533          * that was specified, or "Unspecified" if that sectype was not
2534          * compatible with the given NEGOTIATE request.
2535          */
2536         if (server->ops->select_sectype(server, vol->sectype)
2537              == Unspecified)
2538                 return false;
2539
2540         /*
2541          * Now check if signing mode is acceptable. No need to check
2542          * global_secflags at this point since if MUST_SIGN is set then
2543          * the server->sign had better be too.
2544          */
2545         if (vol->sign && !server->sign)
2546                 return false;
2547
2548         return true;
2549 }
2550
2551 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2552 {
2553         struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2554
2555         if (vol->nosharesock)
2556                 return 0;
2557
2558         /* If multidialect negotiation see if existing sessions match one */
2559         if (strcmp(vol->vals->version_string, SMB3ANY_VERSION_STRING) == 0) {
2560                 if (server->vals->protocol_id < SMB30_PROT_ID)
2561                         return 0;
2562         } else if (strcmp(vol->vals->version_string,
2563                    SMBDEFAULT_VERSION_STRING) == 0) {
2564                 if (server->vals->protocol_id < SMB21_PROT_ID)
2565                         return 0;
2566         } else if ((server->vals != vol->vals) || (server->ops != vol->ops))
2567                 return 0;
2568
2569         if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2570                 return 0;
2571
2572         if (!match_address(server, addr,
2573                            (struct sockaddr *)&vol->srcaddr))
2574                 return 0;
2575
2576         if (!match_port(server, addr))
2577                 return 0;
2578
2579         if (!match_security(server, vol))
2580                 return 0;
2581
2582         if (server->echo_interval != vol->echo_interval * HZ)
2583                 return 0;
2584
2585         if (server->rdma != vol->rdma)
2586                 return 0;
2587
2588         return 1;
2589 }
2590
2591 struct TCP_Server_Info *
2592 cifs_find_tcp_session(struct smb_vol *vol)
2593 {
2594         struct TCP_Server_Info *server;
2595
2596         spin_lock(&cifs_tcp_ses_lock);
2597         list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2598                 if (!match_server(server, vol))
2599                         continue;
2600
2601                 ++server->srv_count;
2602                 spin_unlock(&cifs_tcp_ses_lock);
2603                 cifs_dbg(FYI, "Existing tcp session with server found\n");
2604                 return server;
2605         }
2606         spin_unlock(&cifs_tcp_ses_lock);
2607         return NULL;
2608 }
2609
2610 void
2611 cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
2612 {
2613         struct task_struct *task;
2614
2615         spin_lock(&cifs_tcp_ses_lock);
2616         if (--server->srv_count > 0) {
2617                 spin_unlock(&cifs_tcp_ses_lock);
2618                 return;
2619         }
2620
2621         put_net(cifs_net_ns(server));
2622
2623         list_del_init(&server->tcp_ses_list);
2624         spin_unlock(&cifs_tcp_ses_lock);
2625
2626         cancel_delayed_work_sync(&server->echo);
2627
2628         if (from_reconnect)
2629                 /*
2630                  * Avoid deadlock here: reconnect work calls
2631                  * cifs_put_tcp_session() at its end. Need to be sure
2632                  * that reconnect work does nothing with server pointer after
2633                  * that step.
2634                  */
2635                 cancel_delayed_work(&server->reconnect);
2636         else
2637                 cancel_delayed_work_sync(&server->reconnect);
2638
2639         spin_lock(&GlobalMid_Lock);
2640         server->tcpStatus = CifsExiting;
2641         spin_unlock(&GlobalMid_Lock);
2642
2643         cifs_crypto_secmech_release(server);
2644         cifs_fscache_release_client_cookie(server);
2645
2646         kfree(server->session_key.response);
2647         server->session_key.response = NULL;
2648         server->session_key.len = 0;
2649
2650         task = xchg(&server->tsk, NULL);
2651         if (task)
2652                 send_sig(SIGKILL, task, 1);
2653 }
2654
2655 static struct TCP_Server_Info *
2656 cifs_get_tcp_session(struct smb_vol *volume_info)
2657 {
2658         struct TCP_Server_Info *tcp_ses = NULL;
2659         int rc;
2660
2661         cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2662
2663         /* see if we already have a matching tcp_ses */
2664         tcp_ses = cifs_find_tcp_session(volume_info);
2665         if (tcp_ses)
2666                 return tcp_ses;
2667
2668         tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2669         if (!tcp_ses) {
2670                 rc = -ENOMEM;
2671                 goto out_err;
2672         }
2673
2674         tcp_ses->ops = volume_info->ops;
2675         tcp_ses->vals = volume_info->vals;
2676         cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2677         tcp_ses->hostname = extract_hostname(volume_info->UNC);
2678         if (IS_ERR(tcp_ses->hostname)) {
2679                 rc = PTR_ERR(tcp_ses->hostname);
2680                 goto out_err_crypto_release;
2681         }
2682
2683         tcp_ses->noblocksnd = volume_info->noblocksnd;
2684         tcp_ses->noautotune = volume_info->noautotune;
2685         tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2686         tcp_ses->rdma = volume_info->rdma;
2687         tcp_ses->in_flight = 0;
2688         tcp_ses->credits = 1;
2689         init_waitqueue_head(&tcp_ses->response_q);
2690         init_waitqueue_head(&tcp_ses->request_q);
2691         INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2692         mutex_init(&tcp_ses->srv_mutex);
2693         memcpy(tcp_ses->workstation_RFC1001_name,
2694                 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2695         memcpy(tcp_ses->server_RFC1001_name,
2696                 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2697         tcp_ses->session_estab = false;
2698         tcp_ses->sequence_number = 0;
2699         tcp_ses->reconnect_instance = 1;
2700         tcp_ses->lstrp = jiffies;
2701         tcp_ses->compress_algorithm = cpu_to_le16(volume_info->compression);
2702         spin_lock_init(&tcp_ses->req_lock);
2703         INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2704         INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2705         INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2706         INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
2707         mutex_init(&tcp_ses->reconnect_mutex);
2708         memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2709                sizeof(tcp_ses->srcaddr));
2710         memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2711                 sizeof(tcp_ses->dstaddr));
2712         generate_random_uuid(tcp_ses->client_guid);
2713         /*
2714          * at this point we are the only ones with the pointer
2715          * to the struct since the kernel thread not created yet
2716          * no need to spinlock this init of tcpStatus or srv_count
2717          */
2718         tcp_ses->tcpStatus = CifsNew;
2719         ++tcp_ses->srv_count;
2720
2721         if (volume_info->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
2722                 volume_info->echo_interval <= SMB_ECHO_INTERVAL_MAX)
2723                 tcp_ses->echo_interval = volume_info->echo_interval * HZ;
2724         else
2725                 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
2726         if (tcp_ses->rdma) {
2727 #ifndef CONFIG_CIFS_SMB_DIRECT
2728                 cifs_dbg(VFS, "CONFIG_CIFS_SMB_DIRECT is not enabled\n");
2729                 rc = -ENOENT;
2730                 goto out_err_crypto_release;
2731 #endif
2732                 tcp_ses->smbd_conn = smbd_get_connection(
2733                         tcp_ses, (struct sockaddr *)&volume_info->dstaddr);
2734                 if (tcp_ses->smbd_conn) {
2735                         cifs_dbg(VFS, "RDMA transport established\n");
2736                         rc = 0;
2737                         goto smbd_connected;
2738                 } else {
2739                         rc = -ENOENT;
2740                         goto out_err_crypto_release;
2741                 }
2742         }
2743         rc = ip_connect(tcp_ses);
2744         if (rc < 0) {
2745                 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2746                 goto out_err_crypto_release;
2747         }
2748 smbd_connected:
2749         /*
2750          * since we're in a cifs function already, we know that
2751          * this will succeed. No need for try_module_get().
2752          */
2753         __module_get(THIS_MODULE);
2754         tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2755                                   tcp_ses, "cifsd");
2756         if (IS_ERR(tcp_ses->tsk)) {
2757                 rc = PTR_ERR(tcp_ses->tsk);
2758                 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2759                 module_put(THIS_MODULE);
2760                 goto out_err_crypto_release;
2761         }
2762         tcp_ses->tcpStatus = CifsNeedNegotiate;
2763
2764         tcp_ses->nr_targets = 1;
2765
2766         /* thread spawned, put it on the list */
2767         spin_lock(&cifs_tcp_ses_lock);
2768         list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2769         spin_unlock(&cifs_tcp_ses_lock);
2770
2771         cifs_fscache_get_client_cookie(tcp_ses);
2772
2773         /* queue echo request delayed work */
2774         queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
2775
2776         return tcp_ses;
2777
2778 out_err_crypto_release:
2779         cifs_crypto_secmech_release(tcp_ses);
2780
2781         put_net(cifs_net_ns(tcp_ses));
2782
2783 out_err:
2784         if (tcp_ses) {
2785                 if (!IS_ERR(tcp_ses->hostname))
2786                         kfree(tcp_ses->hostname);
2787                 if (tcp_ses->ssocket)
2788                         sock_release(tcp_ses->ssocket);
2789                 kfree(tcp_ses);
2790         }
2791         return ERR_PTR(rc);
2792 }
2793
2794 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2795 {
2796         if (vol->sectype != Unspecified &&
2797             vol->sectype != ses->sectype)
2798                 return 0;
2799
2800         switch (ses->sectype) {
2801         case Kerberos:
2802                 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2803                         return 0;
2804                 break;
2805         default:
2806                 /* NULL username means anonymous session */
2807                 if (ses->user_name == NULL) {
2808                         if (!vol->nullauth)
2809                                 return 0;
2810                         break;
2811                 }
2812
2813                 /* anything else takes username/password */
2814                 if (strncmp(ses->user_name,
2815                             vol->username ? vol->username : "",
2816                             CIFS_MAX_USERNAME_LEN))
2817                         return 0;
2818                 if ((vol->username && strlen(vol->username) != 0) &&
2819                     ses->password != NULL &&
2820                     strncmp(ses->password,
2821                             vol->password ? vol->password : "",
2822                             CIFS_MAX_PASSWORD_LEN))
2823                         return 0;
2824         }
2825         return 1;
2826 }
2827
2828 /**
2829  * cifs_setup_ipc - helper to setup the IPC tcon for the session
2830  *
2831  * A new IPC connection is made and stored in the session
2832  * tcon_ipc. The IPC tcon has the same lifetime as the session.
2833  */
2834 static int
2835 cifs_setup_ipc(struct cifs_ses *ses, struct smb_vol *volume_info)
2836 {
2837         int rc = 0, xid;
2838         struct cifs_tcon *tcon;
2839         struct nls_table *nls_codepage;
2840         char unc[SERVER_NAME_LENGTH + sizeof("//x/IPC$")] = {0};
2841         bool seal = false;
2842
2843         /*
2844          * If the mount request that resulted in the creation of the
2845          * session requires encryption, force IPC to be encrypted too.
2846          */
2847         if (volume_info->seal) {
2848                 if (ses->server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION)
2849                         seal = true;
2850                 else {
2851                         cifs_dbg(VFS,
2852                                  "IPC: server doesn't support encryption\n");
2853                         return -EOPNOTSUPP;
2854                 }
2855         }
2856
2857         tcon = tconInfoAlloc();
2858         if (tcon == NULL)
2859                 return -ENOMEM;
2860
2861         scnprintf(unc, sizeof(unc), "\\\\%s\\IPC$", ses->server->hostname);
2862
2863         /* cannot fail */
2864         nls_codepage = load_nls_default();
2865
2866         xid = get_xid();
2867         tcon->ses = ses;
2868         tcon->ipc = true;
2869         tcon->seal = seal;
2870         rc = ses->server->ops->tree_connect(xid, ses, unc, tcon, nls_codepage);
2871         free_xid(xid);
2872
2873         if (rc) {
2874                 cifs_dbg(VFS, "failed to connect to IPC (rc=%d)\n", rc);
2875                 tconInfoFree(tcon);
2876                 goto out;
2877         }
2878
2879         cifs_dbg(FYI, "IPC tcon rc = %d ipc tid = %d\n", rc, tcon->tid);
2880
2881         ses->tcon_ipc = tcon;
2882 out:
2883         unload_nls(nls_codepage);
2884         return rc;
2885 }
2886
2887 /**
2888  * cifs_free_ipc - helper to release the session IPC tcon
2889  *
2890  * Needs to be called everytime a session is destroyed
2891  */
2892 static int
2893 cifs_free_ipc(struct cifs_ses *ses)
2894 {
2895         int rc = 0, xid;
2896         struct cifs_tcon *tcon = ses->tcon_ipc;
2897
2898         if (tcon == NULL)
2899                 return 0;
2900
2901         if (ses->server->ops->tree_disconnect) {
2902                 xid = get_xid();
2903                 rc = ses->server->ops->tree_disconnect(xid, tcon);
2904                 free_xid(xid);
2905         }
2906
2907         if (rc)
2908                 cifs_dbg(FYI, "failed to disconnect IPC tcon (rc=%d)\n", rc);
2909
2910         tconInfoFree(tcon);
2911         ses->tcon_ipc = NULL;
2912         return rc;
2913 }
2914
2915 static struct cifs_ses *
2916 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2917 {
2918         struct cifs_ses *ses;
2919
2920         spin_lock(&cifs_tcp_ses_lock);
2921         list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2922                 if (ses->status == CifsExiting)
2923                         continue;
2924                 if (!match_session(ses, vol))
2925                         continue;
2926                 ++ses->ses_count;
2927                 spin_unlock(&cifs_tcp_ses_lock);
2928                 return ses;
2929         }
2930         spin_unlock(&cifs_tcp_ses_lock);
2931         return NULL;
2932 }
2933
2934 void cifs_put_smb_ses(struct cifs_ses *ses)
2935 {
2936         unsigned int rc, xid;
2937         struct TCP_Server_Info *server = ses->server;
2938
2939         cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
2940
2941         spin_lock(&cifs_tcp_ses_lock);
2942         if (ses->status == CifsExiting) {
2943                 spin_unlock(&cifs_tcp_ses_lock);
2944                 return;
2945         }
2946         if (--ses->ses_count > 0) {
2947                 spin_unlock(&cifs_tcp_ses_lock);
2948                 return;
2949         }
2950         if (ses->status == CifsGood)
2951                 ses->status = CifsExiting;
2952         spin_unlock(&cifs_tcp_ses_lock);
2953
2954         cifs_free_ipc(ses);
2955
2956         if (ses->status == CifsExiting && server->ops->logoff) {
2957                 xid = get_xid();
2958                 rc = server->ops->logoff(xid, ses);
2959                 if (rc)
2960                         cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2961                                 __func__, rc);
2962                 _free_xid(xid);
2963         }
2964
2965         spin_lock(&cifs_tcp_ses_lock);
2966         list_del_init(&ses->smb_ses_list);
2967         spin_unlock(&cifs_tcp_ses_lock);
2968
2969         sesInfoFree(ses);
2970         cifs_put_tcp_session(server, 0);
2971 }
2972
2973 #ifdef CONFIG_KEYS
2974
2975 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2976 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2977
2978 /* Populate username and pw fields from keyring if possible */
2979 static int
2980 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2981 {
2982         int rc = 0;
2983         const char *delim, *payload;
2984         char *desc;
2985         ssize_t len;
2986         struct key *key;
2987         struct TCP_Server_Info *server = ses->server;
2988         struct sockaddr_in *sa;
2989         struct sockaddr_in6 *sa6;
2990         const struct user_key_payload *upayload;
2991
2992         desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2993         if (!desc)
2994                 return -ENOMEM;
2995
2996         /* try to find an address key first */
2997         switch (server->dstaddr.ss_family) {
2998         case AF_INET:
2999                 sa = (struct sockaddr_in *)&server->dstaddr;
3000                 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
3001                 break;
3002         case AF_INET6:
3003                 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
3004                 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
3005                 break;
3006         default:
3007                 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
3008                          server->dstaddr.ss_family);
3009                 rc = -EINVAL;
3010                 goto out_err;
3011         }
3012
3013         cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
3014         key = request_key(&key_type_logon, desc, "");
3015         if (IS_ERR(key)) {
3016                 if (!ses->domainName) {
3017                         cifs_dbg(FYI, "domainName is NULL\n");
3018                         rc = PTR_ERR(key);
3019                         goto out_err;
3020                 }
3021
3022                 /* didn't work, try to find a domain key */
3023                 sprintf(desc, "cifs:d:%s", ses->domainName);
3024                 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
3025                 key = request_key(&key_type_logon, desc, "");
3026                 if (IS_ERR(key)) {
3027                         rc = PTR_ERR(key);
3028                         goto out_err;
3029                 }
3030         }
3031
3032         down_read(&key->sem);
3033         upayload = user_key_payload_locked(key);
3034         if (IS_ERR_OR_NULL(upayload)) {
3035                 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
3036                 goto out_key_put;
3037         }
3038
3039         /* find first : in payload */
3040         payload = upayload->data;
3041         delim = strnchr(payload, upayload->datalen, ':');
3042         cifs_dbg(FYI, "payload=%s\n", payload);
3043         if (!delim) {
3044                 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
3045                          upayload->datalen);
3046                 rc = -EINVAL;
3047                 goto out_key_put;
3048         }
3049
3050         len = delim - payload;
3051         if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
3052                 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
3053                          len);
3054                 rc = -EINVAL;
3055                 goto out_key_put;
3056         }
3057
3058         vol->username = kstrndup(payload, len, GFP_KERNEL);
3059         if (!vol->username) {
3060                 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
3061                          len);
3062                 rc = -ENOMEM;
3063                 goto out_key_put;
3064         }
3065         cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
3066
3067         len = key->datalen - (len + 1);
3068         if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
3069                 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
3070                 rc = -EINVAL;
3071                 kfree(vol->username);
3072                 vol->username = NULL;
3073                 goto out_key_put;
3074         }
3075
3076         ++delim;
3077         vol->password = kstrndup(delim, len, GFP_KERNEL);
3078         if (!vol->password) {
3079                 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
3080                          len);
3081                 rc = -ENOMEM;
3082                 kfree(vol->username);
3083                 vol->username = NULL;
3084                 goto out_key_put;
3085         }
3086
3087 out_key_put:
3088         up_read(&key->sem);
3089         key_put(key);
3090 out_err:
3091         kfree(desc);
3092         cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
3093         return rc;
3094 }
3095 #else /* ! CONFIG_KEYS */
3096 static inline int
3097 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
3098                    struct cifs_ses *ses __attribute__((unused)))
3099 {
3100         return -ENOSYS;
3101 }
3102 #endif /* CONFIG_KEYS */
3103
3104 /**
3105  * cifs_get_smb_ses - get a session matching @volume_info data from @server
3106  *
3107  * This function assumes it is being called from cifs_mount() where we
3108  * already got a server reference (server refcount +1). See
3109  * cifs_get_tcon() for refcount explanations.
3110  */
3111 struct cifs_ses *
3112 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
3113 {
3114         int rc = -ENOMEM;
3115         unsigned int xid;
3116         struct cifs_ses *ses;
3117         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3118         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3119
3120         xid = get_xid();
3121
3122         ses = cifs_find_smb_ses(server, volume_info);
3123         if (ses) {
3124                 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
3125                          ses->status);
3126
3127                 mutex_lock(&ses->session_mutex);
3128                 rc = cifs_negotiate_protocol(xid, ses);
3129                 if (rc) {
3130                         mutex_unlock(&ses->session_mutex);
3131                         /* problem -- put our ses reference */
3132                         cifs_put_smb_ses(ses);
3133                         free_xid(xid);
3134                         return ERR_PTR(rc);
3135                 }
3136                 if (ses->need_reconnect) {
3137                         cifs_dbg(FYI, "Session needs reconnect\n");
3138                         rc = cifs_setup_session(xid, ses,
3139                                                 volume_info->local_nls);
3140                         if (rc) {
3141                                 mutex_unlock(&ses->session_mutex);
3142                                 /* problem -- put our reference */
3143                                 cifs_put_smb_ses(ses);
3144                                 free_xid(xid);
3145                                 return ERR_PTR(rc);
3146                         }
3147                 }
3148                 mutex_unlock(&ses->session_mutex);
3149
3150                 /* existing SMB ses has a server reference already */
3151                 cifs_put_tcp_session(server, 0);
3152                 free_xid(xid);
3153                 return ses;
3154         }
3155
3156         cifs_dbg(FYI, "Existing smb sess not found\n");
3157         ses = sesInfoAlloc();
3158         if (ses == NULL)
3159                 goto get_ses_fail;
3160
3161         /* new SMB session uses our server ref */
3162         ses->server = server;
3163         if (server->dstaddr.ss_family == AF_INET6)
3164                 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
3165         else
3166                 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
3167
3168         if (volume_info->username) {
3169                 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
3170                 if (!ses->user_name)
3171                         goto get_ses_fail;
3172         }
3173
3174         /* volume_info->password freed at unmount */
3175         if (volume_info->password) {
3176                 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
3177                 if (!ses->password)
3178                         goto get_ses_fail;
3179         }
3180         if (volume_info->domainname) {
3181                 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
3182                 if (!ses->domainName)
3183                         goto get_ses_fail;
3184         }
3185         if (volume_info->domainauto)
3186                 ses->domainAuto = volume_info->domainauto;
3187         ses->cred_uid = volume_info->cred_uid;
3188         ses->linux_uid = volume_info->linux_uid;
3189
3190         ses->sectype = volume_info->sectype;
3191         ses->sign = volume_info->sign;
3192
3193         mutex_lock(&ses->session_mutex);
3194         rc = cifs_negotiate_protocol(xid, ses);
3195         if (!rc)
3196                 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
3197         mutex_unlock(&ses->session_mutex);
3198         if (rc)
3199                 goto get_ses_fail;
3200
3201         /* success, put it on the list */
3202         spin_lock(&cifs_tcp_ses_lock);
3203         list_add(&ses->smb_ses_list, &server->smb_ses_list);
3204         spin_unlock(&cifs_tcp_ses_lock);
3205
3206         free_xid(xid);
3207
3208         cifs_setup_ipc(ses, volume_info);
3209
3210         return ses;
3211
3212 get_ses_fail:
3213         sesInfoFree(ses);
3214         free_xid(xid);
3215         return ERR_PTR(rc);
3216 }
3217
3218 static int match_tcon(struct cifs_tcon *tcon, struct smb_vol *volume_info)
3219 {
3220         if (tcon->tidStatus == CifsExiting)
3221                 return 0;
3222         if (strncmp(tcon->treeName, volume_info->UNC, MAX_TREE_SIZE))
3223                 return 0;
3224         if (tcon->seal != volume_info->seal)
3225                 return 0;
3226         if (tcon->snapshot_time != volume_info->snapshot_time)
3227                 return 0;
3228         if (tcon->handle_timeout != volume_info->handle_timeout)
3229                 return 0;
3230         return 1;
3231 }
3232
3233 static struct cifs_tcon *
3234 cifs_find_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
3235 {
3236         struct list_head *tmp;
3237         struct cifs_tcon *tcon;
3238
3239         spin_lock(&cifs_tcp_ses_lock);
3240         list_for_each(tmp, &ses->tcon_list) {
3241                 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
3242                 if (!match_tcon(tcon, volume_info))
3243                         continue;
3244                 ++tcon->tc_count;
3245                 spin_unlock(&cifs_tcp_ses_lock);
3246                 return tcon;
3247         }
3248         spin_unlock(&cifs_tcp_ses_lock);
3249         return NULL;
3250 }
3251
3252 void
3253 cifs_put_tcon(struct cifs_tcon *tcon)
3254 {
3255         unsigned int xid;
3256         struct cifs_ses *ses;
3257
3258         /*
3259          * IPC tcon share the lifetime of their session and are
3260          * destroyed in the session put function
3261          */
3262         if (tcon == NULL || tcon->ipc)
3263                 return;
3264
3265         ses = tcon->ses;
3266         cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
3267         spin_lock(&cifs_tcp_ses_lock);
3268         if (--tcon->tc_count > 0) {
3269                 spin_unlock(&cifs_tcp_ses_lock);
3270                 return;
3271         }
3272
3273         list_del_init(&tcon->tcon_list);
3274         spin_unlock(&cifs_tcp_ses_lock);
3275
3276         xid = get_xid();
3277         if (ses->server->ops->tree_disconnect)
3278                 ses->server->ops->tree_disconnect(xid, tcon);
3279         _free_xid(xid);
3280
3281         cifs_fscache_release_super_cookie(tcon);
3282         tconInfoFree(tcon);
3283         cifs_put_smb_ses(ses);
3284 }
3285
3286 /**
3287  * cifs_get_tcon - get a tcon matching @volume_info data from @ses
3288  *
3289  * - tcon refcount is the number of mount points using the tcon.
3290  * - ses refcount is the number of tcon using the session.
3291  *
3292  * 1. This function assumes it is being called from cifs_mount() where
3293  *    we already got a session reference (ses refcount +1).
3294  *
3295  * 2. Since we're in the context of adding a mount point, the end
3296  *    result should be either:
3297  *
3298  * a) a new tcon already allocated with refcount=1 (1 mount point) and
3299  *    its session refcount incremented (1 new tcon). This +1 was
3300  *    already done in (1).
3301  *
3302  * b) an existing tcon with refcount+1 (add a mount point to it) and
3303  *    identical ses refcount (no new tcon). Because of (1) we need to
3304  *    decrement the ses refcount.
3305  */
3306 static struct cifs_tcon *
3307 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
3308 {
3309         int rc, xid;
3310         struct cifs_tcon *tcon;
3311
3312         tcon = cifs_find_tcon(ses, volume_info);
3313         if (tcon) {
3314                 /*
3315                  * tcon has refcount already incremented but we need to
3316                  * decrement extra ses reference gotten by caller (case b)
3317                  */
3318                 cifs_dbg(FYI, "Found match on UNC path\n");
3319                 cifs_put_smb_ses(ses);
3320                 return tcon;
3321         }
3322
3323         if (!ses->server->ops->tree_connect) {
3324                 rc = -ENOSYS;
3325                 goto out_fail;
3326         }
3327
3328         tcon = tconInfoAlloc();
3329         if (tcon == NULL) {
3330                 rc = -ENOMEM;
3331                 goto out_fail;
3332         }
3333
3334         if (volume_info->snapshot_time) {
3335                 if (ses->server->vals->protocol_id == 0) {
3336                         cifs_dbg(VFS,
3337                              "Use SMB2 or later for snapshot mount option\n");
3338                         rc = -EOPNOTSUPP;
3339                         goto out_fail;
3340                 } else
3341                         tcon->snapshot_time = volume_info->snapshot_time;
3342         }
3343
3344         if (volume_info->handle_timeout) {
3345                 if (ses->server->vals->protocol_id == 0) {
3346                         cifs_dbg(VFS,
3347                              "Use SMB2.1 or later for handle timeout option\n");
3348                         rc = -EOPNOTSUPP;
3349                         goto out_fail;
3350                 } else
3351                         tcon->handle_timeout = volume_info->handle_timeout;
3352         }
3353
3354         tcon->ses = ses;
3355         if (volume_info->password) {
3356                 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
3357                 if (!tcon->password) {
3358                         rc = -ENOMEM;
3359                         goto out_fail;
3360                 }
3361         }
3362
3363         if (volume_info->seal) {
3364                 if (ses->server->vals->protocol_id == 0) {
3365                         cifs_dbg(VFS,
3366                                  "SMB3 or later required for encryption\n");
3367                         rc = -EOPNOTSUPP;
3368                         goto out_fail;
3369                 } else if (tcon->ses->server->capabilities &
3370                                         SMB2_GLOBAL_CAP_ENCRYPTION)
3371                         tcon->seal = true;
3372                 else {
3373                         cifs_dbg(VFS, "Encryption is not supported on share\n");
3374                         rc = -EOPNOTSUPP;
3375                         goto out_fail;
3376                 }
3377         }
3378
3379         if (volume_info->linux_ext) {
3380                 if (ses->server->posix_ext_supported) {
3381                         tcon->posix_extensions = true;
3382                         printk_once(KERN_WARNING
3383                                 "SMB3.11 POSIX Extensions are experimental\n");
3384                 } else {
3385                         cifs_dbg(VFS, "Server does not support mounting with posix SMB3.11 extensions.\n");
3386                         rc = -EOPNOTSUPP;
3387                         goto out_fail;
3388                 }
3389         }
3390
3391         /*
3392          * BB Do we need to wrap session_mutex around this TCon call and Unix
3393          * SetFS as we do on SessSetup and reconnect?
3394          */
3395         xid = get_xid();
3396         rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
3397                                             volume_info->local_nls);
3398         free_xid(xid);
3399         cifs_dbg(FYI, "Tcon rc = %d\n", rc);
3400         if (rc)
3401                 goto out_fail;
3402
3403         tcon->use_persistent = false;
3404         /* check if SMB2 or later, CIFS does not support persistent handles */
3405         if (volume_info->persistent) {
3406                 if (ses->server->vals->protocol_id == 0) {
3407                         cifs_dbg(VFS,
3408                              "SMB3 or later required for persistent handles\n");
3409                         rc = -EOPNOTSUPP;
3410                         goto out_fail;
3411                 } else if (ses->server->capabilities &
3412                            SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3413                         tcon->use_persistent = true;
3414                 else /* persistent handles requested but not supported */ {
3415                         cifs_dbg(VFS,
3416                                 "Persistent handles not supported on share\n");
3417                         rc = -EOPNOTSUPP;
3418                         goto out_fail;
3419                 }
3420         } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
3421              && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3422              && (volume_info->nopersistent == false)) {
3423                 cifs_dbg(FYI, "enabling persistent handles\n");
3424                 tcon->use_persistent = true;
3425         } else if (volume_info->resilient) {
3426                 if (ses->server->vals->protocol_id == 0) {
3427                         cifs_dbg(VFS,
3428                              "SMB2.1 or later required for resilient handles\n");
3429                         rc = -EOPNOTSUPP;
3430                         goto out_fail;
3431                 }
3432                 tcon->use_resilient = true;
3433         }
3434
3435         /*
3436          * We can have only one retry value for a connection to a share so for
3437          * resources mounted more than once to the same server share the last
3438          * value passed in for the retry flag is used.
3439          */
3440         tcon->retry = volume_info->retry;
3441         tcon->nocase = volume_info->nocase;
3442         tcon->nohandlecache = volume_info->nohandlecache;
3443         tcon->local_lease = volume_info->local_lease;
3444         INIT_LIST_HEAD(&tcon->pending_opens);
3445
3446         spin_lock(&cifs_tcp_ses_lock);
3447         list_add(&tcon->tcon_list, &ses->tcon_list);
3448         spin_unlock(&cifs_tcp_ses_lock);
3449
3450         cifs_fscache_get_super_cookie(tcon);
3451
3452         return tcon;
3453
3454 out_fail:
3455         tconInfoFree(tcon);
3456         return ERR_PTR(rc);
3457 }
3458
3459 void
3460 cifs_put_tlink(struct tcon_link *tlink)
3461 {
3462         if (!tlink || IS_ERR(tlink))
3463                 return;
3464
3465         if (!atomic_dec_and_test(&tlink->tl_count) ||
3466             test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
3467                 tlink->tl_time = jiffies;
3468                 return;
3469         }
3470
3471         if (!IS_ERR(tlink_tcon(tlink)))
3472                 cifs_put_tcon(tlink_tcon(tlink));
3473         kfree(tlink);
3474         return;
3475 }
3476
3477 static int
3478 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3479 {
3480         struct cifs_sb_info *old = CIFS_SB(sb);
3481         struct cifs_sb_info *new = mnt_data->cifs_sb;
3482         unsigned int oldflags = old->mnt_cifs_flags & CIFS_MOUNT_MASK;
3483         unsigned int newflags = new->mnt_cifs_flags & CIFS_MOUNT_MASK;
3484
3485         if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
3486                 return 0;
3487
3488         if (old->mnt_cifs_serverino_autodisabled)
3489                 newflags &= ~CIFS_MOUNT_SERVER_INUM;
3490
3491         if (oldflags != newflags)
3492                 return 0;
3493
3494         /*
3495          * We want to share sb only if we don't specify an r/wsize or
3496          * specified r/wsize is greater than or equal to existing one.
3497          */
3498         if (new->wsize && new->wsize < old->wsize)
3499                 return 0;
3500
3501         if (new->rsize && new->rsize < old->rsize)
3502                 return 0;
3503
3504         if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
3505                 return 0;
3506
3507         if (old->mnt_file_mode != new->mnt_file_mode ||
3508             old->mnt_dir_mode != new->mnt_dir_mode)
3509                 return 0;
3510
3511         if (strcmp(old->local_nls->charset, new->local_nls->charset))
3512                 return 0;
3513
3514         if (old->actimeo != new->actimeo)
3515                 return 0;
3516
3517         return 1;
3518 }
3519
3520 static int
3521 match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3522 {
3523         struct cifs_sb_info *old = CIFS_SB(sb);
3524         struct cifs_sb_info *new = mnt_data->cifs_sb;
3525         bool old_set = old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH;
3526         bool new_set = new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH;
3527
3528         if (old_set && new_set && !strcmp(new->prepath, old->prepath))
3529                 return 1;
3530         else if (!old_set && !new_set)
3531                 return 1;
3532
3533         return 0;
3534 }
3535
3536 int
3537 cifs_match_super(struct super_block *sb, void *data)
3538 {
3539         struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
3540         struct smb_vol *volume_info;
3541         struct cifs_sb_info *cifs_sb;
3542         struct TCP_Server_Info *tcp_srv;
3543         struct cifs_ses *ses;
3544         struct cifs_tcon *tcon;
3545         struct tcon_link *tlink;
3546         int rc = 0;
3547
3548         spin_lock(&cifs_tcp_ses_lock);
3549         cifs_sb = CIFS_SB(sb);
3550         tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3551         if (IS_ERR(tlink)) {
3552                 spin_unlock(&cifs_tcp_ses_lock);
3553                 return rc;
3554         }
3555         tcon = tlink_tcon(tlink);
3556         ses = tcon->ses;
3557         tcp_srv = ses->server;
3558
3559         volume_info = mnt_data->vol;
3560
3561         if (!match_server(tcp_srv, volume_info) ||
3562             !match_session(ses, volume_info) ||
3563             !match_tcon(tcon, volume_info) ||
3564             !match_prepath(sb, mnt_data)) {
3565                 rc = 0;
3566                 goto out;
3567         }
3568
3569         rc = compare_mount_options(sb, mnt_data);
3570 out:
3571         spin_unlock(&cifs_tcp_ses_lock);
3572         cifs_put_tlink(tlink);
3573         return rc;
3574 }
3575
3576 #ifdef CONFIG_DEBUG_LOCK_ALLOC
3577 static struct lock_class_key cifs_key[2];
3578 static struct lock_class_key cifs_slock_key[2];
3579
3580 static inline void
3581 cifs_reclassify_socket4(struct socket *sock)
3582 {
3583         struct sock *sk = sock->sk;
3584         BUG_ON(!sock_allow_reclassification(sk));
3585         sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
3586                 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
3587 }
3588
3589 static inline void
3590 cifs_reclassify_socket6(struct socket *sock)
3591 {
3592         struct sock *sk = sock->sk;
3593         BUG_ON(!sock_allow_reclassification(sk));
3594         sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
3595                 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
3596 }
3597 #else
3598 static inline void
3599 cifs_reclassify_socket4(struct socket *sock)
3600 {
3601 }
3602
3603 static inline void
3604 cifs_reclassify_socket6(struct socket *sock)
3605 {
3606 }
3607 #endif
3608
3609 /* See RFC1001 section 14 on representation of Netbios names */
3610 static void rfc1002mangle(char *target, char *source, unsigned int length)
3611 {
3612         unsigned int i, j;
3613
3614         for (i = 0, j = 0; i < (length); i++) {
3615                 /* mask a nibble at a time and encode */
3616                 target[j] = 'A' + (0x0F & (source[i] >> 4));
3617                 target[j+1] = 'A' + (0x0F & source[i]);
3618                 j += 2;
3619         }
3620
3621 }
3622
3623 static int
3624 bind_socket(struct TCP_Server_Info *server)
3625 {
3626         int rc = 0;
3627         if (server->srcaddr.ss_family != AF_UNSPEC) {
3628                 /* Bind to the specified local IP address */
3629                 struct socket *socket = server->ssocket;
3630                 rc = socket->ops->bind(socket,
3631                                        (struct sockaddr *) &server->srcaddr,
3632                                        sizeof(server->srcaddr));
3633                 if (rc < 0) {
3634                         struct sockaddr_in *saddr4;
3635                         struct sockaddr_in6 *saddr6;
3636                         saddr4 = (struct sockaddr_in *)&server->srcaddr;
3637                         saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
3638                         if (saddr6->sin6_family == AF_INET6)
3639                                 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
3640                                          &saddr6->sin6_addr, rc);
3641                         else
3642                                 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
3643                                          &saddr4->sin_addr.s_addr, rc);
3644                 }
3645         }
3646         return rc;
3647 }
3648
3649 static int
3650 ip_rfc1001_connect(struct TCP_Server_Info *server)
3651 {
3652         int rc = 0;
3653         /*
3654          * some servers require RFC1001 sessinit before sending
3655          * negprot - BB check reconnection in case where second
3656          * sessinit is sent but no second negprot
3657          */
3658         struct rfc1002_session_packet *ses_init_buf;
3659         struct smb_hdr *smb_buf;
3660         ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
3661                                GFP_KERNEL);
3662         if (ses_init_buf) {
3663                 ses_init_buf->trailer.session_req.called_len = 32;
3664
3665                 if (server->server_RFC1001_name[0] != 0)
3666                         rfc1002mangle(ses_init_buf->trailer.
3667                                       session_req.called_name,
3668                                       server->server_RFC1001_name,
3669                                       RFC1001_NAME_LEN_WITH_NULL);
3670                 else
3671                         rfc1002mangle(ses_init_buf->trailer.
3672                                       session_req.called_name,
3673                                       DEFAULT_CIFS_CALLED_NAME,
3674                                       RFC1001_NAME_LEN_WITH_NULL);
3675
3676                 ses_init_buf->trailer.session_req.calling_len = 32;
3677
3678                 /*
3679                  * calling name ends in null (byte 16) from old smb
3680                  * convention.
3681                  */
3682                 if (server->workstation_RFC1001_name[0] != 0)
3683                         rfc1002mangle(ses_init_buf->trailer.
3684                                       session_req.calling_name,
3685                                       server->workstation_RFC1001_name,
3686                                       RFC1001_NAME_LEN_WITH_NULL);
3687                 else
3688                         rfc1002mangle(ses_init_buf->trailer.
3689                                       session_req.calling_name,
3690                                       "LINUX_CIFS_CLNT",
3691                                       RFC1001_NAME_LEN_WITH_NULL);
3692
3693                 ses_init_buf->trailer.session_req.scope1 = 0;
3694                 ses_init_buf->trailer.session_req.scope2 = 0;
3695                 smb_buf = (struct smb_hdr *)ses_init_buf;
3696
3697                 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3698                 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3699                 rc = smb_send(server, smb_buf, 0x44);
3700                 kfree(ses_init_buf);
3701                 /*
3702                  * RFC1001 layer in at least one server
3703                  * requires very short break before negprot
3704                  * presumably because not expecting negprot
3705                  * to follow so fast.  This is a simple
3706                  * solution that works without
3707                  * complicating the code and causes no
3708                  * significant slowing down on mount
3709                  * for everyone else
3710                  */
3711                 usleep_range(1000, 2000);
3712         }
3713         /*
3714          * else the negprot may still work without this
3715          * even though malloc failed
3716          */
3717
3718         return rc;
3719 }
3720
3721 static int
3722 generic_ip_connect(struct TCP_Server_Info *server)
3723 {
3724         int rc = 0;
3725         __be16 sport;
3726         int slen, sfamily;
3727         struct socket *socket = server->ssocket;
3728         struct sockaddr *saddr;
3729
3730         saddr = (struct sockaddr *) &server->dstaddr;
3731
3732         if (server->dstaddr.ss_family == AF_INET6) {
3733                 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3734                 slen = sizeof(struct sockaddr_in6);
3735                 sfamily = AF_INET6;
3736         } else {
3737                 sport = ((struct sockaddr_in *) saddr)->sin_port;
3738                 slen = sizeof(struct sockaddr_in);
3739                 sfamily = AF_INET;
3740         }
3741
3742         if (socket == NULL) {
3743                 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3744                                    IPPROTO_TCP, &socket, 1);
3745                 if (rc < 0) {
3746                         cifs_dbg(VFS, "Error %d creating socket\n", rc);
3747                         server->ssocket = NULL;
3748                         return rc;
3749                 }
3750
3751                 /* BB other socket options to set KEEPALIVE, NODELAY? */
3752                 cifs_dbg(FYI, "Socket created\n");
3753                 server->ssocket = socket;
3754                 socket->sk->sk_allocation = GFP_NOFS;
3755                 if (sfamily == AF_INET6)
3756                         cifs_reclassify_socket6(socket);
3757                 else
3758                         cifs_reclassify_socket4(socket);
3759         }
3760
3761         rc = bind_socket(server);
3762         if (rc < 0)
3763                 return rc;
3764
3765         /*
3766          * Eventually check for other socket options to change from
3767          * the default. sock_setsockopt not used because it expects
3768          * user space buffer
3769          */
3770         socket->sk->sk_rcvtimeo = 7 * HZ;
3771         socket->sk->sk_sndtimeo = 5 * HZ;
3772
3773         /* make the bufsizes depend on wsize/rsize and max requests */
3774         if (server->noautotune) {
3775                 if (socket->sk->sk_sndbuf < (200 * 1024))
3776                         socket->sk->sk_sndbuf = 200 * 1024;
3777                 if (socket->sk->sk_rcvbuf < (140 * 1024))
3778                         socket->sk->sk_rcvbuf = 140 * 1024;
3779         }
3780
3781         if (server->tcp_nodelay) {
3782                 int val = 1;
3783                 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3784                                 (char *)&val, sizeof(val));
3785                 if (rc)
3786                         cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3787                                  rc);
3788         }
3789
3790         cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3791                  socket->sk->sk_sndbuf,
3792                  socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3793
3794         rc = socket->ops->connect(socket, saddr, slen, 0);
3795         if (rc < 0) {
3796                 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3797                 sock_release(socket);
3798                 server->ssocket = NULL;
3799                 return rc;
3800         }
3801
3802         if (sport == htons(RFC1001_PORT))
3803                 rc = ip_rfc1001_connect(server);
3804
3805         return rc;
3806 }
3807
3808 static int
3809 ip_connect(struct TCP_Server_Info *server)
3810 {
3811         __be16 *sport;
3812         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3813         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3814
3815         if (server->dstaddr.ss_family == AF_INET6)
3816                 sport = &addr6->sin6_port;
3817         else
3818                 sport = &addr->sin_port;
3819
3820         if (*sport == 0) {
3821                 int rc;
3822
3823                 /* try with 445 port at first */
3824                 *sport = htons(CIFS_PORT);
3825
3826                 rc = generic_ip_connect(server);
3827                 if (rc >= 0)
3828                         return rc;
3829
3830                 /* if it failed, try with 139 port */
3831                 *sport = htons(RFC1001_PORT);
3832         }
3833
3834         return generic_ip_connect(server);
3835 }
3836
3837 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3838                           struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3839 {
3840         /* if we are reconnecting then should we check to see if
3841          * any requested capabilities changed locally e.g. via
3842          * remount but we can not do much about it here
3843          * if they have (even if we could detect it by the following)
3844          * Perhaps we could add a backpointer to array of sb from tcon
3845          * or if we change to make all sb to same share the same
3846          * sb as NFS - then we only have one backpointer to sb.
3847          * What if we wanted to mount the server share twice once with
3848          * and once without posixacls or posix paths? */
3849         __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3850
3851         if (vol_info && vol_info->no_linux_ext) {
3852                 tcon->fsUnixInfo.Capability = 0;
3853                 tcon->unix_ext = 0; /* Unix Extensions disabled */
3854                 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3855                 return;
3856         } else if (vol_info)
3857                 tcon->unix_ext = 1; /* Unix Extensions supported */
3858
3859         if (tcon->unix_ext == 0) {
3860                 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3861                 return;
3862         }
3863
3864         if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3865                 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3866                 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3867                 /* check for reconnect case in which we do not
3868                    want to change the mount behavior if we can avoid it */
3869                 if (vol_info == NULL) {
3870                         /* turn off POSIX ACL and PATHNAMES if not set
3871                            originally at mount time */
3872                         if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3873                                 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3874                         if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3875                                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3876                                         cifs_dbg(VFS, "POSIXPATH support change\n");
3877                                 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3878                         } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3879                                 cifs_dbg(VFS, "possible reconnect error\n");
3880                                 cifs_dbg(VFS, "server disabled POSIX path support\n");
3881                         }
3882                 }
3883
3884                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3885                         cifs_dbg(VFS, "per-share encryption not supported yet\n");
3886
3887                 cap &= CIFS_UNIX_CAP_MASK;
3888                 if (vol_info && vol_info->no_psx_acl)
3889                         cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3890                 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3891                         cifs_dbg(FYI, "negotiated posix acl support\n");
3892                         if (cifs_sb)
3893                                 cifs_sb->mnt_cifs_flags |=
3894                                         CIFS_MOUNT_POSIXACL;
3895                 }
3896
3897                 if (vol_info && vol_info->posix_paths == 0)
3898                         cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3899                 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3900                         cifs_dbg(FYI, "negotiate posix pathnames\n");
3901                         if (cifs_sb)
3902                                 cifs_sb->mnt_cifs_flags |=
3903                                         CIFS_MOUNT_POSIX_PATHS;
3904                 }
3905
3906                 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3907 #ifdef CONFIG_CIFS_DEBUG2
3908                 if (cap & CIFS_UNIX_FCNTL_CAP)
3909                         cifs_dbg(FYI, "FCNTL cap\n");
3910                 if (cap & CIFS_UNIX_EXTATTR_CAP)
3911                         cifs_dbg(FYI, "EXTATTR cap\n");
3912                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3913                         cifs_dbg(FYI, "POSIX path cap\n");
3914                 if (cap & CIFS_UNIX_XATTR_CAP)
3915                         cifs_dbg(FYI, "XATTR cap\n");
3916                 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3917                         cifs_dbg(FYI, "POSIX ACL cap\n");
3918                 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3919                         cifs_dbg(FYI, "very large read cap\n");
3920                 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3921                         cifs_dbg(FYI, "very large write cap\n");
3922                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3923                         cifs_dbg(FYI, "transport encryption cap\n");
3924                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3925                         cifs_dbg(FYI, "mandatory transport encryption cap\n");
3926 #endif /* CIFS_DEBUG2 */
3927                 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3928                         if (vol_info == NULL) {
3929                                 cifs_dbg(FYI, "resetting capabilities failed\n");
3930                         } else
3931                                 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");
3932
3933                 }
3934         }
3935 }
3936
3937 int cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3938                         struct cifs_sb_info *cifs_sb)
3939 {
3940         INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3941
3942         spin_lock_init(&cifs_sb->tlink_tree_lock);
3943         cifs_sb->tlink_tree = RB_ROOT;
3944
3945         cifs_sb->bsize = pvolume_info->bsize;
3946         /*
3947          * Temporarily set r/wsize for matching superblock. If we end up using
3948          * new sb then client will later negotiate it downward if needed.
3949          */
3950         cifs_sb->rsize = pvolume_info->rsize;
3951         cifs_sb->wsize = pvolume_info->wsize;
3952
3953         cifs_sb->mnt_uid = pvolume_info->linux_uid;
3954         cifs_sb->mnt_gid = pvolume_info->linux_gid;
3955         cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3956         cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3957         cifs_dbg(FYI, "file mode: 0x%hx  dir mode: 0x%hx\n",
3958                  cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3959
3960         cifs_sb->actimeo = pvolume_info->actimeo;
3961         cifs_sb->local_nls = pvolume_info->local_nls;
3962
3963         if (pvolume_info->nodfs)
3964                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_DFS;
3965         if (pvolume_info->noperm)
3966                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3967         if (pvolume_info->setuids)
3968                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3969         if (pvolume_info->setuidfromacl)
3970                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
3971         if (pvolume_info->server_ino)
3972                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3973         if (pvolume_info->remap)
3974                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3975         if (pvolume_info->sfu_remap)
3976                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3977         if (pvolume_info->no_xattr)
3978                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3979         if (pvolume_info->sfu_emul)
3980                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3981         if (pvolume_info->nobrl)
3982                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3983         if (pvolume_info->nohandlecache)
3984                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE;
3985         if (pvolume_info->nostrictsync)
3986                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3987         if (pvolume_info->mand_lock)
3988                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3989         if (pvolume_info->rwpidforward)
3990                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3991         if (pvolume_info->mode_ace)
3992                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MODE_FROM_SID;
3993         if (pvolume_info->cifs_acl)
3994                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3995         if (pvolume_info->backupuid_specified) {
3996                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3997                 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3998         }
3999         if (pvolume_info->backupgid_specified) {
4000                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
4001                 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
4002         }
4003         if (pvolume_info->override_uid)
4004                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
4005         if (pvolume_info->override_gid)
4006                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
4007         if (pvolume_info->dynperm)
4008                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
4009         if (pvolume_info->fsc)
4010                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
4011         if (pvolume_info->multiuser)
4012                 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
4013                                             CIFS_MOUNT_NO_PERM);
4014         if (pvolume_info->strict_io)
4015                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
4016         if (pvolume_info->direct_io) {
4017                 cifs_dbg(FYI, "mounting share using direct i/o\n");
4018                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
4019         }
4020         if (pvolume_info->mfsymlinks) {
4021                 if (pvolume_info->sfu_emul) {
4022                         /*
4023                          * Our SFU ("Services for Unix" emulation does not allow
4024                          * creating symlinks but does allow reading existing SFU
4025                          * symlinks (it does allow both creating and reading SFU
4026                          * style mknod and FIFOs though). When "mfsymlinks" and
4027                          * "sfu" are both enabled at the same time, it allows
4028                          * reading both types of symlinks, but will only create
4029                          * them with mfsymlinks format. This allows better
4030                          * Apple compatibility (probably better for Samba too)
4031                          * while still recognizing old Windows style symlinks.
4032                          */
4033                         cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
4034                 }
4035                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
4036         }
4037
4038         if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
4039                 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
4040
4041         if (pvolume_info->prepath) {
4042                 cifs_sb->prepath = kstrdup(pvolume_info->prepath, GFP_KERNEL);
4043                 if (cifs_sb->prepath == NULL)
4044                         return -ENOMEM;
4045         }
4046
4047         return 0;
4048 }
4049
4050 void
4051 cifs_cleanup_volume_info_contents(struct smb_vol *volume_info)
4052 {
4053         kfree(volume_info->username);
4054         kzfree(volume_info->password);
4055         kfree(volume_info->UNC);
4056         kfree(volume_info->domainname);
4057         kfree(volume_info->iocharset);
4058         kfree(volume_info->prepath);
4059 }
4060
4061 void
4062 cifs_cleanup_volume_info(struct smb_vol *volume_info)
4063 {
4064         if (!volume_info)
4065                 return;
4066         cifs_cleanup_volume_info_contents(volume_info);
4067         kfree(volume_info);
4068 }
4069
4070 /* Release all succeed connections */
4071 static inline void mount_put_conns(struct cifs_sb_info *cifs_sb,
4072                                    unsigned int xid,
4073                                    struct TCP_Server_Info *server,
4074                                    struct cifs_ses *ses, struct cifs_tcon *tcon)
4075 {
4076         int rc = 0;
4077
4078         if (tcon)
4079                 cifs_put_tcon(tcon);
4080         else if (ses)
4081                 cifs_put_smb_ses(ses);
4082         else if (server)
4083                 cifs_put_tcp_session(server, 0);
4084         cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
4085         free_xid(xid);
4086 }
4087
4088 /* Get connections for tcp, ses and tcon */
4089 static int mount_get_conns(struct smb_vol *vol, struct cifs_sb_info *cifs_sb,
4090                            unsigned int *xid,
4091                            struct TCP_Server_Info **nserver,
4092                            struct cifs_ses **nses, struct cifs_tcon **ntcon)
4093 {
4094         int rc = 0;
4095         struct TCP_Server_Info *server;
4096         struct cifs_ses *ses;
4097         struct cifs_tcon *tcon;
4098
4099         *nserver = NULL;
4100         *nses = NULL;
4101         *ntcon = NULL;
4102
4103         *xid = get_xid();
4104
4105         /* get a reference to a tcp session */
4106         server = cifs_get_tcp_session(vol);
4107         if (IS_ERR(server)) {
4108                 rc = PTR_ERR(server);
4109                 return rc;
4110         }
4111
4112         *nserver = server;
4113
4114         if ((vol->max_credits < 20) || (vol->max_credits > 60000))
4115                 server->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
4116         else
4117                 server->max_credits = vol->max_credits;
4118
4119         /* get a reference to a SMB session */
4120         ses = cifs_get_smb_ses(server, vol);
4121         if (IS_ERR(ses)) {
4122                 rc = PTR_ERR(ses);
4123                 return rc;
4124         }
4125
4126         *nses = ses;
4127
4128         if ((vol->persistent == true) && (!(ses->server->capabilities &
4129                                             SMB2_GLOBAL_CAP_PERSISTENT_HANDLES))) {
4130                 cifs_dbg(VFS, "persistent handles not supported by server\n");
4131                 return -EOPNOTSUPP;
4132         }
4133
4134         /* search for existing tcon to this server share */
4135         tcon = cifs_get_tcon(ses, vol);
4136         if (IS_ERR(tcon)) {
4137                 rc = PTR_ERR(tcon);
4138                 return rc;
4139         }
4140
4141         *ntcon = tcon;
4142
4143         /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
4144         if (tcon->posix_extensions)
4145                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
4146
4147         /* tell server which Unix caps we support */
4148         if (cap_unix(tcon->ses)) {
4149                 /*
4150                  * reset of caps checks mount to see if unix extensions disabled
4151                  * for just this mount.
4152                  */
4153                 reset_cifs_unix_caps(*xid, tcon, cifs_sb, vol);
4154                 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
4155                     (le64_to_cpu(tcon->fsUnixInfo.Capability) &
4156                      CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP))
4157                         return -EACCES;
4158         } else
4159                 tcon->unix_ext = 0; /* server does not support them */
4160
4161         /* do not care if a following call succeed - informational */
4162         if (!tcon->pipe && server->ops->qfs_tcon)
4163                 server->ops->qfs_tcon(*xid, tcon);
4164
4165         cifs_sb->wsize = server->ops->negotiate_wsize(tcon, vol);
4166         cifs_sb->rsize = server->ops->negotiate_rsize(tcon, vol);
4167
4168         return 0;
4169 }
4170
4171 static int mount_setup_tlink(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses,
4172                              struct cifs_tcon *tcon)
4173 {
4174         struct tcon_link *tlink;
4175
4176         /* hang the tcon off of the superblock */
4177         tlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4178         if (tlink == NULL)
4179                 return -ENOMEM;
4180
4181         tlink->tl_uid = ses->linux_uid;
4182         tlink->tl_tcon = tcon;
4183         tlink->tl_time = jiffies;
4184         set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
4185         set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4186
4187         cifs_sb->master_tlink = tlink;
4188         spin_lock(&cifs_sb->tlink_tree_lock);
4189         tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4190         spin_unlock(&cifs_sb->tlink_tree_lock);
4191
4192         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4193                                 TLINK_IDLE_EXPIRE);
4194         return 0;
4195 }
4196
4197 #ifdef CONFIG_CIFS_DFS_UPCALL
4198 /*
4199  * cifs_build_path_to_root returns full path to root when we do not have an
4200  * exiting connection (tcon)
4201  */
4202 static char *
4203 build_unc_path_to_root(const struct smb_vol *vol,
4204                        const struct cifs_sb_info *cifs_sb, bool useppath)
4205 {
4206         char *full_path, *pos;
4207         unsigned int pplen = useppath && vol->prepath ?
4208                 strlen(vol->prepath) + 1 : 0;
4209         unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
4210
4211         full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
4212         if (full_path == NULL)
4213                 return ERR_PTR(-ENOMEM);
4214
4215         strncpy(full_path, vol->UNC, unc_len);
4216         pos = full_path + unc_len;
4217
4218         if (pplen) {
4219                 *pos = CIFS_DIR_SEP(cifs_sb);
4220                 strncpy(pos + 1, vol->prepath, pplen);
4221                 pos += pplen;
4222         }
4223
4224         *pos = '\0'; /* add trailing null */
4225         convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
4226         cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
4227         return full_path;
4228 }
4229
4230 /**
4231  * expand_dfs_referral - Perform a dfs referral query and update the cifs_sb
4232  *
4233  *
4234  * If a referral is found, cifs_sb->mountdata will be (re-)allocated
4235  * to a string containing updated options for the submount.  Otherwise it
4236  * will be left untouched.
4237  *
4238  * Returns the rc from get_dfs_path to the caller, which can be used to
4239  * determine whether there were referrals.
4240  */
4241 static int
4242 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
4243                     struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
4244                     int check_prefix)
4245 {
4246         int rc;
4247         struct dfs_info3_param referral = {0};
4248         char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
4249
4250         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
4251                 return -EREMOTE;
4252
4253         full_path = build_unc_path_to_root(volume_info, cifs_sb, true);
4254         if (IS_ERR(full_path))
4255                 return PTR_ERR(full_path);
4256
4257         /* For DFS paths, skip the first '\' of the UNC */
4258         ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
4259
4260         rc = dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb),
4261                             ref_path, &referral, NULL);
4262         if (!rc) {
4263                 char *fake_devname = NULL;
4264
4265                 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
4266                                                    full_path + 1, &referral,
4267                                                    &fake_devname);
4268                 free_dfs_info_param(&referral);
4269
4270                 if (IS_ERR(mdata)) {
4271                         rc = PTR_ERR(mdata);
4272                         mdata = NULL;
4273                 } else {
4274                         cifs_cleanup_volume_info_contents(volume_info);
4275                         rc = cifs_setup_volume_info(volume_info, mdata,
4276                                                     fake_devname, false);
4277                 }
4278                 kfree(fake_devname);
4279                 kfree(cifs_sb->mountdata);
4280                 cifs_sb->mountdata = mdata;
4281         }
4282         kfree(full_path);
4283         return rc;
4284 }
4285
4286 static inline int get_next_dfs_tgt(const char *path,
4287                                    struct dfs_cache_tgt_list *tgt_list,
4288                                    struct dfs_cache_tgt_iterator **tgt_it)
4289 {
4290         if (!*tgt_it)
4291                 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
4292         else
4293                 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
4294         return !*tgt_it ? -EHOSTDOWN : 0;
4295 }
4296
4297 static int update_vol_info(const struct dfs_cache_tgt_iterator *tgt_it,
4298                            struct smb_vol *fake_vol, struct smb_vol *vol)
4299 {
4300         const char *tgt = dfs_cache_get_tgt_name(tgt_it);
4301         int len = strlen(tgt) + 2;
4302         char *new_unc;
4303
4304         new_unc = kmalloc(len, GFP_KERNEL);
4305         if (!new_unc)
4306                 return -ENOMEM;
4307         scnprintf(new_unc, len, "\\%s", tgt);
4308
4309         kfree(vol->UNC);
4310         vol->UNC = new_unc;
4311
4312         if (fake_vol->prepath) {
4313                 kfree(vol->prepath);
4314                 vol->prepath = fake_vol->prepath;
4315                 fake_vol->prepath = NULL;
4316         }
4317         memcpy(&vol->dstaddr, &fake_vol->dstaddr, sizeof(vol->dstaddr));
4318
4319         return 0;
4320 }
4321
4322 static int setup_dfs_tgt_conn(const char *path,
4323                               const struct dfs_cache_tgt_iterator *tgt_it,
4324                               struct cifs_sb_info *cifs_sb,
4325                               struct smb_vol *vol,
4326                               unsigned int *xid,
4327                               struct TCP_Server_Info **server,
4328                               struct cifs_ses **ses,
4329                               struct cifs_tcon **tcon)
4330 {
4331         int rc;
4332         struct dfs_info3_param ref = {0};
4333         char *mdata = NULL, *fake_devname = NULL;
4334         struct smb_vol fake_vol = {0};
4335
4336         cifs_dbg(FYI, "%s: dfs path: %s\n", __func__, path);
4337
4338         rc = dfs_cache_get_tgt_referral(path, tgt_it, &ref);
4339         if (rc)
4340                 return rc;
4341
4342         mdata = cifs_compose_mount_options(cifs_sb->mountdata, path, &ref,
4343                                            &fake_devname);
4344         free_dfs_info_param(&ref);
4345
4346         if (IS_ERR(mdata)) {
4347                 rc = PTR_ERR(mdata);
4348                 mdata = NULL;
4349         } else {
4350                 cifs_dbg(FYI, "%s: fake_devname: %s\n", __func__, fake_devname);
4351                 rc = cifs_setup_volume_info(&fake_vol, mdata, fake_devname,
4352                                             false);
4353         }
4354         kfree(mdata);
4355         kfree(fake_devname);
4356
4357         if (!rc) {
4358                 /*
4359                  * We use a 'fake_vol' here because we need pass it down to the
4360                  * mount_{get,put} functions to test connection against new DFS
4361                  * targets.
4362                  */
4363                 mount_put_conns(cifs_sb, *xid, *server, *ses, *tcon);
4364                 rc = mount_get_conns(&fake_vol, cifs_sb, xid, server, ses,
4365                                      tcon);
4366                 if (!rc) {
4367                         /*
4368                          * We were able to connect to new target server.
4369                          * Update current volume info with new target server.
4370                          */
4371                         rc = update_vol_info(tgt_it, &fake_vol, vol);
4372                 }
4373         }
4374         cifs_cleanup_volume_info_contents(&fake_vol);
4375         return rc;
4376 }
4377
4378 static int mount_do_dfs_failover(const char *path,
4379                                  struct cifs_sb_info *cifs_sb,
4380                                  struct smb_vol *vol,
4381                                  struct cifs_ses *root_ses,
4382                                  unsigned int *xid,
4383                                  struct TCP_Server_Info **server,
4384                                  struct cifs_ses **ses,
4385                                  struct cifs_tcon **tcon)
4386 {
4387         int rc;
4388         struct dfs_cache_tgt_list tgt_list;
4389         struct dfs_cache_tgt_iterator *tgt_it = NULL;
4390
4391         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
4392                 return -EOPNOTSUPP;
4393
4394         rc = dfs_cache_noreq_find(path, NULL, &tgt_list);
4395         if (rc)
4396                 return rc;
4397
4398         for (;;) {
4399                 /* Get next DFS target server - if any */
4400                 rc = get_next_dfs_tgt(path, &tgt_list, &tgt_it);
4401                 if (rc)
4402                         break;
4403                 /* Connect to next DFS target */
4404                 rc = setup_dfs_tgt_conn(path, tgt_it, cifs_sb, vol, xid, server,
4405                                         ses, tcon);
4406                 if (!rc || rc == -EACCES || rc == -EOPNOTSUPP)
4407                         break;
4408         }
4409         if (!rc) {
4410                 /*
4411                  * Update DFS target hint in DFS referral cache with the target
4412                  * server we successfully reconnected to.
4413                  */
4414                 rc = dfs_cache_update_tgthint(*xid, root_ses ? root_ses : *ses,
4415                                               cifs_sb->local_nls,
4416                                               cifs_remap(cifs_sb), path,
4417                                               tgt_it);
4418         }
4419         dfs_cache_free_tgts(&tgt_list);
4420         return rc;
4421 }
4422 #endif
4423
4424 int
4425 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
4426                         const char *devname, bool is_smb3)
4427 {
4428         int rc = 0;
4429
4430         if (cifs_parse_mount_options(mount_data, devname, volume_info, is_smb3))
4431                 return -EINVAL;
4432
4433         if (volume_info->nullauth) {
4434                 cifs_dbg(FYI, "Anonymous login\n");
4435                 kfree(volume_info->username);
4436                 volume_info->username = NULL;
4437         } else if (volume_info->username) {
4438                 /* BB fixme parse for domain name here */
4439                 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
4440         } else {
4441                 cifs_dbg(VFS, "No username specified\n");
4442         /* In userspace mount helper we can get user name from alternate
4443            locations such as env variables and files on disk */
4444                 return -EINVAL;
4445         }
4446
4447         /* this is needed for ASCII cp to Unicode converts */
4448         if (volume_info->iocharset == NULL) {
4449                 /* load_nls_default cannot return null */
4450                 volume_info->local_nls = load_nls_default();
4451         } else {
4452                 volume_info->local_nls = load_nls(volume_info->iocharset);
4453                 if (volume_info->local_nls == NULL) {
4454                         cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
4455                                  volume_info->iocharset);
4456                         return -ELIBACC;
4457                 }
4458         }
4459
4460         return rc;
4461 }
4462
4463 struct smb_vol *
4464 cifs_get_volume_info(char *mount_data, const char *devname, bool is_smb3)
4465 {
4466         int rc;
4467         struct smb_vol *volume_info;
4468
4469         volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
4470         if (!volume_info)
4471                 return ERR_PTR(-ENOMEM);
4472
4473         rc = cifs_setup_volume_info(volume_info, mount_data, devname, is_smb3);
4474         if (rc) {
4475                 cifs_cleanup_volume_info(volume_info);
4476                 volume_info = ERR_PTR(rc);
4477         }
4478
4479         return volume_info;
4480 }
4481
4482 static int
4483 cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
4484                                         unsigned int xid,
4485                                         struct cifs_tcon *tcon,
4486                                         struct cifs_sb_info *cifs_sb,
4487                                         char *full_path,
4488                                         int added_treename)
4489 {
4490         int rc;
4491         char *s;
4492         char sep, tmp;
4493         int skip = added_treename ? 1 : 0;
4494
4495         sep = CIFS_DIR_SEP(cifs_sb);
4496         s = full_path;
4497
4498         rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
4499         while (rc == 0) {
4500                 /* skip separators */
4501                 while (*s == sep)
4502                         s++;
4503                 if (!*s)
4504                         break;
4505                 /* next separator */
4506                 while (*s && *s != sep)
4507                         s++;
4508                 /*
4509                  * if the treename is added, we then have to skip the first
4510                  * part within the separators
4511                  */
4512                 if (skip) {
4513                         skip = 0;
4514                         continue;
4515                 }
4516                 /*
4517                  * temporarily null-terminate the path at the end of
4518                  * the current component
4519                  */
4520                 tmp = *s;
4521                 *s = 0;
4522                 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
4523                                                      full_path);
4524                 *s = tmp;
4525         }
4526         return rc;
4527 }
4528
4529 /*
4530  * Check if path is remote (e.g. a DFS share). Return -EREMOTE if it is,
4531  * otherwise 0.
4532  */
4533 static int is_path_remote(struct cifs_sb_info *cifs_sb, struct smb_vol *vol,
4534                           const unsigned int xid,
4535                           struct TCP_Server_Info *server,
4536                           struct cifs_tcon *tcon)
4537 {
4538         int rc;
4539         char *full_path;
4540
4541         if (!server->ops->is_path_accessible)
4542                 return -EOPNOTSUPP;
4543
4544         /*
4545          * cifs_build_path_to_root works only when we have a valid tcon
4546          */
4547         full_path = cifs_build_path_to_root(vol, cifs_sb, tcon,
4548                                             tcon->Flags & SMB_SHARE_IS_IN_DFS);
4549         if (full_path == NULL)
4550                 return -ENOMEM;
4551
4552         cifs_dbg(FYI, "%s: full_path: %s\n", __func__, full_path);
4553
4554         rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
4555                                              full_path);
4556         if (rc != 0 && rc != -EREMOTE) {
4557                 kfree(full_path);
4558                 return rc;
4559         }
4560
4561         if (rc != -EREMOTE) {
4562                 rc = cifs_are_all_path_components_accessible(server, xid, tcon,
4563                         cifs_sb, full_path, tcon->Flags & SMB_SHARE_IS_IN_DFS);
4564                 if (rc != 0) {
4565                         cifs_dbg(VFS, "cannot query dirs between root and final path, "
4566                                  "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
4567                         cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
4568                         rc = 0;
4569                 }
4570         }
4571
4572         kfree(full_path);
4573         return rc;
4574 }
4575
4576 #ifdef CONFIG_CIFS_DFS_UPCALL
4577 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *vol)
4578 {
4579         int rc = 0;
4580         unsigned int xid;
4581         struct cifs_ses *ses;
4582         struct cifs_tcon *root_tcon = NULL;
4583         struct cifs_tcon *tcon = NULL;
4584         struct TCP_Server_Info *server;
4585         char *root_path = NULL, *full_path = NULL;
4586         char *old_mountdata, *origin_mountdata = NULL;
4587         int count;
4588
4589         rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4590         if (!rc && tcon) {
4591                 /* If not a standalone DFS root, then check if path is remote */
4592                 rc = dfs_cache_find(xid, ses, cifs_sb->local_nls,
4593                                     cifs_remap(cifs_sb), vol->UNC + 1, NULL,
4594                                     NULL);
4595                 if (rc) {
4596                         rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
4597                         if (!rc)
4598                                 goto out;
4599                         if (rc != -EREMOTE)
4600                                 goto error;
4601                 }
4602         }
4603         /*
4604          * If first DFS target server went offline and we failed to connect it,
4605          * server and ses pointers are NULL at this point, though we still have
4606          * chance to get a cached DFS referral in expand_dfs_referral() and
4607          * retry next target available in it.
4608          *
4609          * If a NULL ses ptr is passed to dfs_cache_find(), a lookup will be
4610          * performed against DFS path and *no* requests will be sent to server
4611          * for any new DFS referrals. Hence it's safe to skip checking whether
4612          * server or ses ptr is NULL.
4613          */
4614         if (rc == -EACCES || rc == -EOPNOTSUPP)
4615                 goto error;
4616
4617         root_path = build_unc_path_to_root(vol, cifs_sb, false);
4618         if (IS_ERR(root_path)) {
4619                 rc = PTR_ERR(root_path);
4620                 root_path = NULL;
4621                 goto error;
4622         }
4623
4624         full_path = build_unc_path_to_root(vol, cifs_sb, true);
4625         if (IS_ERR(full_path)) {
4626                 rc = PTR_ERR(full_path);
4627                 full_path = NULL;
4628                 goto error;
4629         }
4630         /*
4631          * Perform an unconditional check for whether there are DFS
4632          * referrals for this path without prefix, to provide support
4633          * for DFS referrals from w2k8 servers which don't seem to respond
4634          * with PATH_NOT_COVERED to requests that include the prefix.
4635          * Chase the referral if found, otherwise continue normally.
4636          */
4637         old_mountdata = cifs_sb->mountdata;
4638         (void)expand_dfs_referral(xid, ses, vol, cifs_sb, false);
4639
4640         if (cifs_sb->mountdata == NULL) {
4641                 rc = -ENOENT;
4642                 goto error;
4643         }
4644
4645         /* Save DFS root volume information for DFS refresh worker */
4646         origin_mountdata = kstrndup(cifs_sb->mountdata,
4647                                     strlen(cifs_sb->mountdata), GFP_KERNEL);
4648         if (!origin_mountdata) {
4649                 rc = -ENOMEM;
4650                 goto error;
4651         }
4652
4653         if (cifs_sb->mountdata != old_mountdata) {
4654                 /* If we were redirected, reconnect to new target server */
4655                 mount_put_conns(cifs_sb, xid, server, ses, tcon);
4656                 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4657         }
4658         if (rc) {
4659                 if (rc == -EACCES || rc == -EOPNOTSUPP)
4660                         goto error;
4661                 /* Perform DFS failover to any other DFS targets */
4662                 rc = mount_do_dfs_failover(root_path + 1, cifs_sb, vol, NULL,
4663                                            &xid, &server, &ses, &tcon);
4664                 if (rc)
4665                         goto error;
4666         }
4667
4668         kfree(root_path);
4669         root_path = build_unc_path_to_root(vol, cifs_sb, false);
4670         if (IS_ERR(root_path)) {
4671                 rc = PTR_ERR(root_path);
4672                 root_path = NULL;
4673                 goto error;
4674         }
4675         /* Cache out resolved root server */
4676         (void)dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb),
4677                              root_path + 1, NULL, NULL);
4678         /*
4679          * Save root tcon for additional DFS requests to update or create a new
4680          * DFS cache entry, or even perform DFS failover.
4681          */
4682         spin_lock(&cifs_tcp_ses_lock);
4683         tcon->tc_count++;
4684         tcon->dfs_path = root_path;
4685         root_path = NULL;
4686         tcon->remap = cifs_remap(cifs_sb);
4687         spin_unlock(&cifs_tcp_ses_lock);
4688
4689         root_tcon = tcon;
4690
4691         for (count = 1; ;) {
4692                 if (!rc && tcon) {
4693                         rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
4694                         if (!rc || rc != -EREMOTE)
4695                                 break;
4696                 }
4697                 /*
4698                  * BB: when we implement proper loop detection,
4699                  *     we will remove this check. But now we need it
4700                  *     to prevent an indefinite loop if 'DFS tree' is
4701                  *     misconfigured (i.e. has loops).
4702                  */
4703                 if (count++ > MAX_NESTED_LINKS) {
4704                         rc = -ELOOP;
4705                         break;
4706                 }
4707
4708                 kfree(full_path);
4709                 full_path = build_unc_path_to_root(vol, cifs_sb, true);
4710                 if (IS_ERR(full_path)) {
4711                         rc = PTR_ERR(full_path);
4712                         full_path = NULL;
4713                         break;
4714                 }
4715
4716                 old_mountdata = cifs_sb->mountdata;
4717                 rc = expand_dfs_referral(xid, root_tcon->ses, vol, cifs_sb,
4718                                          true);
4719                 if (rc)
4720                         break;
4721
4722                 if (cifs_sb->mountdata != old_mountdata) {
4723                         mount_put_conns(cifs_sb, xid, server, ses, tcon);
4724                         rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses,
4725                                              &tcon);
4726                 }
4727                 if (rc) {
4728                         if (rc == -EACCES || rc == -EOPNOTSUPP)
4729                                 break;
4730                         /* Perform DFS failover to any other DFS targets */
4731                         rc = mount_do_dfs_failover(full_path + 1, cifs_sb, vol,
4732                                                    root_tcon->ses, &xid,
4733                                                    &server, &ses, &tcon);
4734                         if (rc == -EACCES || rc == -EOPNOTSUPP || !server ||
4735                             !ses)
4736                                 goto error;
4737                 }
4738         }
4739         cifs_put_tcon(root_tcon);
4740
4741         if (rc)
4742                 goto error;
4743
4744         spin_lock(&cifs_tcp_ses_lock);
4745         if (!tcon->dfs_path) {
4746                 /* Save full path in new tcon to do failover when reconnecting tcons */
4747                 tcon->dfs_path = full_path;
4748                 full_path = NULL;
4749                 tcon->remap = cifs_remap(cifs_sb);
4750         }
4751         cifs_sb->origin_fullpath = kstrndup(tcon->dfs_path,
4752                                             strlen(tcon->dfs_path),
4753                                             GFP_ATOMIC);
4754         if (!cifs_sb->origin_fullpath) {
4755                 spin_unlock(&cifs_tcp_ses_lock);
4756                 rc = -ENOMEM;
4757                 goto error;
4758         }
4759         spin_unlock(&cifs_tcp_ses_lock);
4760
4761         rc = dfs_cache_add_vol(origin_mountdata, vol, cifs_sb->origin_fullpath);
4762         if (rc) {
4763                 kfree(cifs_sb->origin_fullpath);
4764                 goto error;
4765         }
4766         /*
4767          * After reconnecting to a different server, unique ids won't
4768          * match anymore, so we disable serverino. This prevents
4769          * dentry revalidation to think the dentry are stale (ESTALE).
4770          */
4771         cifs_autodisable_serverino(cifs_sb);
4772 out:
4773         free_xid(xid);
4774         return mount_setup_tlink(cifs_sb, ses, tcon);
4775
4776 error:
4777         kfree(full_path);
4778         kfree(root_path);
4779         kfree(origin_mountdata);
4780         mount_put_conns(cifs_sb, xid, server, ses, tcon);
4781         return rc;
4782 }
4783 #else
4784 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *vol)
4785 {
4786         int rc = 0;
4787         unsigned int xid;
4788         struct cifs_ses *ses;
4789         struct cifs_tcon *tcon;
4790         struct TCP_Server_Info *server;
4791
4792         rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4793         if (rc)
4794                 goto error;
4795
4796         if (tcon) {
4797                 rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
4798                 if (rc == -EREMOTE)
4799                         rc = -EOPNOTSUPP;
4800                 if (rc)
4801                         goto error;
4802         }
4803
4804         free_xid(xid);
4805
4806         return mount_setup_tlink(cifs_sb, ses, tcon);
4807
4808 error:
4809         mount_put_conns(cifs_sb, xid, server, ses, tcon);
4810         return rc;
4811 }
4812 #endif
4813
4814 /*
4815  * Issue a TREE_CONNECT request.
4816  */
4817 int
4818 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
4819          const char *tree, struct cifs_tcon *tcon,
4820          const struct nls_table *nls_codepage)
4821 {
4822         struct smb_hdr *smb_buffer;
4823         struct smb_hdr *smb_buffer_response;
4824         TCONX_REQ *pSMB;
4825         TCONX_RSP *pSMBr;
4826         unsigned char *bcc_ptr;
4827         int rc = 0;
4828         int length;
4829         __u16 bytes_left, count;
4830
4831         if (ses == NULL)
4832                 return -EIO;
4833
4834         smb_buffer = cifs_buf_get();
4835         if (smb_buffer == NULL)
4836                 return -ENOMEM;
4837
4838         smb_buffer_response = smb_buffer;
4839
4840         header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
4841                         NULL /*no tid */ , 4 /*wct */ );
4842
4843         smb_buffer->Mid = get_next_mid(ses->server);
4844         smb_buffer->Uid = ses->Suid;
4845         pSMB = (TCONX_REQ *) smb_buffer;
4846         pSMBr = (TCONX_RSP *) smb_buffer_response;
4847
4848         pSMB->AndXCommand = 0xFF;
4849         pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
4850         bcc_ptr = &pSMB->Password[0];
4851         if (tcon->pipe || (ses->server->sec_mode & SECMODE_USER)) {
4852                 pSMB->PasswordLength = cpu_to_le16(1);  /* minimum */
4853                 *bcc_ptr = 0; /* password is null byte */
4854                 bcc_ptr++;              /* skip password */
4855                 /* already aligned so no need to do it below */
4856         } else {
4857                 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
4858                 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
4859                    specified as required (when that support is added to
4860                    the vfs in the future) as only NTLM or the much
4861                    weaker LANMAN (which we do not send by default) is accepted
4862                    by Samba (not sure whether other servers allow
4863                    NTLMv2 password here) */
4864 #ifdef CONFIG_CIFS_WEAK_PW_HASH
4865                 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
4866                     (ses->sectype == LANMAN))
4867                         calc_lanman_hash(tcon->password, ses->server->cryptkey,
4868                                          ses->server->sec_mode &
4869                                             SECMODE_PW_ENCRYPT ? true : false,
4870                                          bcc_ptr);
4871                 else
4872 #endif /* CIFS_WEAK_PW_HASH */
4873                 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
4874                                         bcc_ptr, nls_codepage);
4875                 if (rc) {
4876                         cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
4877                                  __func__, rc);
4878                         cifs_buf_release(smb_buffer);
4879                         return rc;
4880                 }
4881
4882                 bcc_ptr += CIFS_AUTH_RESP_SIZE;
4883                 if (ses->capabilities & CAP_UNICODE) {
4884                         /* must align unicode strings */
4885                         *bcc_ptr = 0; /* null byte password */
4886                         bcc_ptr++;
4887                 }
4888         }
4889
4890         if (ses->server->sign)
4891                 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
4892
4893         if (ses->capabilities & CAP_STATUS32) {
4894                 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
4895         }
4896         if (ses->capabilities & CAP_DFS) {
4897                 smb_buffer->Flags2 |= SMBFLG2_DFS;
4898         }
4899         if (ses->capabilities & CAP_UNICODE) {
4900                 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
4901                 length =
4902                     cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
4903                         6 /* max utf8 char length in bytes */ *
4904                         (/* server len*/ + 256 /* share len */), nls_codepage);
4905                 bcc_ptr += 2 * length;  /* convert num 16 bit words to bytes */
4906                 bcc_ptr += 2;   /* skip trailing null */
4907         } else {                /* ASCII */
4908                 strcpy(bcc_ptr, tree);
4909                 bcc_ptr += strlen(tree) + 1;
4910         }
4911         strcpy(bcc_ptr, "?????");
4912         bcc_ptr += strlen("?????");
4913         bcc_ptr += 1;
4914         count = bcc_ptr - &pSMB->Password[0];
4915         pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
4916                                         pSMB->hdr.smb_buf_length) + count);
4917         pSMB->ByteCount = cpu_to_le16(count);
4918
4919         rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
4920                          0);
4921
4922         /* above now done in SendReceive */
4923         if (rc == 0) {
4924                 bool is_unicode;
4925
4926                 tcon->tidStatus = CifsGood;
4927                 tcon->need_reconnect = false;
4928                 tcon->tid = smb_buffer_response->Tid;
4929                 bcc_ptr = pByteArea(smb_buffer_response);
4930                 bytes_left = get_bcc(smb_buffer_response);
4931                 length = strnlen(bcc_ptr, bytes_left - 2);
4932                 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
4933                         is_unicode = true;
4934                 else
4935                         is_unicode = false;
4936
4937
4938                 /* skip service field (NB: this field is always ASCII) */
4939                 if (length == 3) {
4940                         if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
4941                             (bcc_ptr[2] == 'C')) {
4942                                 cifs_dbg(FYI, "IPC connection\n");
4943                                 tcon->ipc = true;
4944                                 tcon->pipe = true;
4945                         }
4946                 } else if (length == 2) {
4947                         if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
4948                                 /* the most common case */
4949                                 cifs_dbg(FYI, "disk share connection\n");
4950                         }
4951                 }
4952                 bcc_ptr += length + 1;
4953                 bytes_left -= (length + 1);
4954                 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
4955
4956                 /* mostly informational -- no need to fail on error here */
4957                 kfree(tcon->nativeFileSystem);
4958                 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
4959                                                       bytes_left, is_unicode,
4960                                                       nls_codepage);
4961
4962                 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
4963
4964                 if ((smb_buffer_response->WordCount == 3) ||
4965                          (smb_buffer_response->WordCount == 7))
4966                         /* field is in same location */
4967                         tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
4968                 else
4969                         tcon->Flags = 0;
4970                 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
4971         }
4972
4973         cifs_buf_release(smb_buffer);
4974         return rc;
4975 }
4976
4977 static void delayed_free(struct rcu_head *p)
4978 {
4979         struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
4980         unload_nls(sbi->local_nls);
4981         kfree(sbi);
4982 }
4983
4984 void
4985 cifs_umount(struct cifs_sb_info *cifs_sb)
4986 {
4987         struct rb_root *root = &cifs_sb->tlink_tree;
4988         struct rb_node *node;
4989         struct tcon_link *tlink;
4990
4991         cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
4992
4993         spin_lock(&cifs_sb->tlink_tree_lock);
4994         while ((node = rb_first(root))) {
4995                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4996                 cifs_get_tlink(tlink);
4997                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4998                 rb_erase(node, root);
4999
5000                 spin_unlock(&cifs_sb->tlink_tree_lock);
5001                 cifs_put_tlink(tlink);
5002                 spin_lock(&cifs_sb->tlink_tree_lock);
5003         }
5004         spin_unlock(&cifs_sb->tlink_tree_lock);
5005
5006         kfree(cifs_sb->mountdata);
5007         kfree(cifs_sb->prepath);
5008 #ifdef CONFIG_CIFS_DFS_UPCALL
5009         dfs_cache_del_vol(cifs_sb->origin_fullpath);
5010         kfree(cifs_sb->origin_fullpath);
5011 #endif
5012         call_rcu(&cifs_sb->rcu, delayed_free);
5013 }
5014
5015 int
5016 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
5017 {
5018         int rc = 0;
5019         struct TCP_Server_Info *server = ses->server;
5020
5021         if (!server->ops->need_neg || !server->ops->negotiate)
5022                 return -ENOSYS;
5023
5024         /* only send once per connect */
5025         if (!server->ops->need_neg(server))
5026                 return 0;
5027
5028         rc = server->ops->negotiate(xid, ses);
5029         if (rc == 0) {
5030                 spin_lock(&GlobalMid_Lock);
5031                 if (server->tcpStatus == CifsNeedNegotiate)
5032                         server->tcpStatus = CifsGood;
5033                 else
5034                         rc = -EHOSTDOWN;
5035                 spin_unlock(&GlobalMid_Lock);
5036         }
5037
5038         return rc;
5039 }
5040
5041 int
5042 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
5043                    struct nls_table *nls_info)
5044 {
5045         int rc = -ENOSYS;
5046         struct TCP_Server_Info *server = ses->server;
5047
5048         ses->capabilities = server->capabilities;
5049         if (linuxExtEnabled == 0)
5050                 ses->capabilities &= (~server->vals->cap_unix);
5051
5052         cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
5053                  server->sec_mode, server->capabilities, server->timeAdj);
5054
5055         if (ses->auth_key.response) {
5056                 cifs_dbg(FYI, "Free previous auth_key.response = %p\n",
5057                          ses->auth_key.response);
5058                 kfree(ses->auth_key.response);
5059                 ses->auth_key.response = NULL;
5060                 ses->auth_key.len = 0;
5061         }
5062
5063         if (server->ops->sess_setup)
5064                 rc = server->ops->sess_setup(xid, ses, nls_info);
5065
5066         if (rc)
5067                 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
5068
5069         return rc;
5070 }
5071
5072 static int
5073 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
5074 {
5075         vol->sectype = ses->sectype;
5076
5077         /* krb5 is special, since we don't need username or pw */
5078         if (vol->sectype == Kerberos)
5079                 return 0;
5080
5081         return cifs_set_cifscreds(vol, ses);
5082 }
5083
5084 static struct cifs_tcon *
5085 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
5086 {
5087         int rc;
5088         struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
5089         struct cifs_ses *ses;
5090         struct cifs_tcon *tcon = NULL;
5091         struct smb_vol *vol_info;
5092
5093         vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
5094         if (vol_info == NULL)
5095                 return ERR_PTR(-ENOMEM);
5096
5097         vol_info->local_nls = cifs_sb->local_nls;
5098         vol_info->linux_uid = fsuid;
5099         vol_info->cred_uid = fsuid;
5100         vol_info->UNC = master_tcon->treeName;
5101         vol_info->retry = master_tcon->retry;
5102         vol_info->nocase = master_tcon->nocase;
5103         vol_info->nohandlecache = master_tcon->nohandlecache;
5104         vol_info->local_lease = master_tcon->local_lease;
5105         vol_info->no_linux_ext = !master_tcon->unix_ext;
5106         vol_info->sectype = master_tcon->ses->sectype;
5107         vol_info->sign = master_tcon->ses->sign;
5108
5109         rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
5110         if (rc) {
5111                 tcon = ERR_PTR(rc);
5112                 goto out;
5113         }
5114
5115         /* get a reference for the same TCP session */
5116         spin_lock(&cifs_tcp_ses_lock);
5117         ++master_tcon->ses->server->srv_count;
5118         spin_unlock(&cifs_tcp_ses_lock);
5119
5120         ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
5121         if (IS_ERR(ses)) {
5122                 tcon = (struct cifs_tcon *)ses;
5123                 cifs_put_tcp_session(master_tcon->ses->server, 0);
5124                 goto out;
5125         }
5126
5127         tcon = cifs_get_tcon(ses, vol_info);
5128         if (IS_ERR(tcon)) {
5129                 cifs_put_smb_ses(ses);
5130                 goto out;
5131         }
5132
5133         /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
5134         if (tcon->posix_extensions)
5135                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
5136
5137         if (cap_unix(ses))
5138                 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
5139
5140 out:
5141         kfree(vol_info->username);
5142         kzfree(vol_info->password);
5143         kfree(vol_info);
5144
5145         return tcon;
5146 }
5147
5148 struct cifs_tcon *
5149 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
5150 {
5151         return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
5152 }
5153
5154 /* find and return a tlink with given uid */
5155 static struct tcon_link *
5156 tlink_rb_search(struct rb_root *root, kuid_t uid)
5157 {
5158         struct rb_node *node = root->rb_node;
5159         struct tcon_link *tlink;
5160
5161         while (node) {
5162                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
5163
5164                 if (uid_gt(tlink->tl_uid, uid))
5165                         node = node->rb_left;
5166                 else if (uid_lt(tlink->tl_uid, uid))
5167                         node = node->rb_right;
5168                 else
5169                         return tlink;
5170         }
5171         return NULL;
5172 }
5173
5174 /* insert a tcon_link into the tree */
5175 static void
5176 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
5177 {
5178         struct rb_node **new = &(root->rb_node), *parent = NULL;
5179         struct tcon_link *tlink;
5180
5181         while (*new) {
5182                 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
5183                 parent = *new;
5184
5185                 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
5186                         new = &((*new)->rb_left);
5187                 else
5188                         new = &((*new)->rb_right);
5189         }
5190
5191         rb_link_node(&new_tlink->tl_rbnode, parent, new);
5192         rb_insert_color(&new_tlink->tl_rbnode, root);
5193 }
5194
5195 /*
5196  * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
5197  * current task.
5198  *
5199  * If the superblock doesn't refer to a multiuser mount, then just return
5200  * the master tcon for the mount.
5201  *
5202  * First, search the rbtree for an existing tcon for this fsuid. If one
5203  * exists, then check to see if it's pending construction. If it is then wait
5204  * for construction to complete. Once it's no longer pending, check to see if
5205  * it failed and either return an error or retry construction, depending on
5206  * the timeout.
5207  *
5208  * If one doesn't exist then insert a new tcon_link struct into the tree and
5209  * try to construct a new one.
5210  */
5211 struct tcon_link *
5212 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
5213 {
5214         int ret;
5215         kuid_t fsuid = current_fsuid();
5216         struct tcon_link *tlink, *newtlink;
5217
5218         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
5219                 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
5220
5221         spin_lock(&cifs_sb->tlink_tree_lock);
5222         tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
5223         if (tlink)
5224                 cifs_get_tlink(tlink);
5225         spin_unlock(&cifs_sb->tlink_tree_lock);
5226
5227         if (tlink == NULL) {
5228                 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
5229                 if (newtlink == NULL)
5230                         return ERR_PTR(-ENOMEM);
5231                 newtlink->tl_uid = fsuid;
5232                 newtlink->tl_tcon = ERR_PTR(-EACCES);
5233                 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
5234                 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
5235                 cifs_get_tlink(newtlink);
5236
5237                 spin_lock(&cifs_sb->tlink_tree_lock);
5238                 /* was one inserted after previous search? */
5239                 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
5240                 if (tlink) {
5241                         cifs_get_tlink(tlink);
5242                         spin_unlock(&cifs_sb->tlink_tree_lock);
5243                         kfree(newtlink);
5244                         goto wait_for_construction;
5245                 }
5246                 tlink = newtlink;
5247                 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
5248                 spin_unlock(&cifs_sb->tlink_tree_lock);
5249         } else {
5250 wait_for_construction:
5251                 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
5252                                   TASK_INTERRUPTIBLE);
5253                 if (ret) {
5254                         cifs_put_tlink(tlink);
5255                         return ERR_PTR(-ERESTARTSYS);
5256                 }
5257
5258                 /* if it's good, return it */
5259                 if (!IS_ERR(tlink->tl_tcon))
5260                         return tlink;
5261
5262                 /* return error if we tried this already recently */
5263                 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
5264                         cifs_put_tlink(tlink);
5265                         return ERR_PTR(-EACCES);
5266                 }
5267
5268                 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
5269                         goto wait_for_construction;
5270         }
5271
5272         tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
5273         clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
5274         wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
5275
5276         if (IS_ERR(tlink->tl_tcon)) {
5277                 cifs_put_tlink(tlink);
5278                 return ERR_PTR(-EACCES);
5279         }
5280
5281         return tlink;
5282 }
5283
5284 /*
5285  * periodic workqueue job that scans tcon_tree for a superblock and closes
5286  * out tcons.
5287  */
5288 static void
5289 cifs_prune_tlinks(struct work_struct *work)
5290 {
5291         struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
5292                                                     prune_tlinks.work);
5293         struct rb_root *root = &cifs_sb->tlink_tree;
5294         struct rb_node *node;
5295         struct rb_node *tmp;
5296         struct tcon_link *tlink;
5297
5298         /*
5299          * Because we drop the spinlock in the loop in order to put the tlink
5300          * it's not guarded against removal of links from the tree. The only
5301          * places that remove entries from the tree are this function and
5302          * umounts. Because this function is non-reentrant and is canceled
5303          * before umount can proceed, this is safe.
5304          */
5305         spin_lock(&cifs_sb->tlink_tree_lock);
5306         node = rb_first(root);
5307         while (node != NULL) {
5308                 tmp = node;
5309                 node = rb_next(tmp);
5310                 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
5311
5312                 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
5313                     atomic_read(&tlink->tl_count) != 0 ||
5314                     time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
5315                         continue;
5316
5317                 cifs_get_tlink(tlink);
5318                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
5319                 rb_erase(tmp, root);
5320
5321                 spin_unlock(&cifs_sb->tlink_tree_lock);
5322                 cifs_put_tlink(tlink);
5323                 spin_lock(&cifs_sb->tlink_tree_lock);
5324         }
5325         spin_unlock(&cifs_sb->tlink_tree_lock);
5326
5327         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
5328                                 TLINK_IDLE_EXPIRE);
5329 }