fs/cifs/connect.c

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