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                 if (!match_server(server, vol))
2716                         continue;
2717
2718                 ++server->srv_count;
2719                 spin_unlock(&cifs_tcp_ses_lock);
2720                 cifs_dbg(FYI, "Existing tcp session with server found\n");
2721                 return server;
2722         }
2723         spin_unlock(&cifs_tcp_ses_lock);
2724         return NULL;
2725 }
2726
2727 void
2728 cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
2729 {
2730         struct task_struct *task;
2731
2732         spin_lock(&cifs_tcp_ses_lock);
2733         if (--server->srv_count > 0) {
2734                 spin_unlock(&cifs_tcp_ses_lock);
2735                 return;
2736         }
2737
2738         put_net(cifs_net_ns(server));
2739
2740         list_del_init(&server->tcp_ses_list);
2741         spin_unlock(&cifs_tcp_ses_lock);
2742
2743         cancel_delayed_work_sync(&server->echo);
2744
2745         if (from_reconnect)
2746                 /*
2747                  * Avoid deadlock here: reconnect work calls
2748                  * cifs_put_tcp_session() at its end. Need to be sure
2749                  * that reconnect work does nothing with server pointer after
2750                  * that step.
2751                  */
2752                 cancel_delayed_work(&server->reconnect);
2753         else
2754                 cancel_delayed_work_sync(&server->reconnect);
2755
2756         spin_lock(&GlobalMid_Lock);
2757         server->tcpStatus = CifsExiting;
2758         spin_unlock(&GlobalMid_Lock);
2759
2760         cifs_crypto_secmech_release(server);
2761         cifs_fscache_release_client_cookie(server);
2762
2763         kfree(server->session_key.response);
2764         server->session_key.response = NULL;
2765         server->session_key.len = 0;
2766
2767         task = xchg(&server->tsk, NULL);
2768         if (task)
2769                 send_sig(SIGKILL, task, 1);
2770 }
2771
2772 struct TCP_Server_Info *
2773 cifs_get_tcp_session(struct smb_vol *volume_info)
2774 {
2775         struct TCP_Server_Info *tcp_ses = NULL;
2776         int rc;
2777
2778         cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2779
2780         /* see if we already have a matching tcp_ses */
2781         tcp_ses = cifs_find_tcp_session(volume_info);
2782         if (tcp_ses)
2783                 return tcp_ses;
2784
2785         tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2786         if (!tcp_ses) {
2787                 rc = -ENOMEM;
2788                 goto out_err;
2789         }
2790
2791         tcp_ses->ops = volume_info->ops;
2792         tcp_ses->vals = volume_info->vals;
2793         cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2794         tcp_ses->hostname = extract_hostname(volume_info->UNC);
2795         if (IS_ERR(tcp_ses->hostname)) {
2796                 rc = PTR_ERR(tcp_ses->hostname);
2797                 goto out_err_crypto_release;
2798         }
2799
2800         tcp_ses->noblockcnt = volume_info->rootfs;
2801         tcp_ses->noblocksnd = volume_info->noblocksnd || volume_info->rootfs;
2802         tcp_ses->noautotune = volume_info->noautotune;
2803         tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2804         tcp_ses->rdma = volume_info->rdma;
2805         tcp_ses->in_flight = 0;
2806         tcp_ses->max_in_flight = 0;
2807         tcp_ses->credits = 1;
2808         init_waitqueue_head(&tcp_ses->response_q);
2809         init_waitqueue_head(&tcp_ses->request_q);
2810         INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2811         mutex_init(&tcp_ses->srv_mutex);
2812         memcpy(tcp_ses->workstation_RFC1001_name,
2813                 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2814         memcpy(tcp_ses->server_RFC1001_name,
2815                 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2816         tcp_ses->session_estab = false;
2817         tcp_ses->sequence_number = 0;
2818         tcp_ses->reconnect_instance = 1;
2819         tcp_ses->lstrp = jiffies;
2820         tcp_ses->compress_algorithm = cpu_to_le16(volume_info->compression);
2821         spin_lock_init(&tcp_ses->req_lock);
2822         INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2823         INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2824         INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2825         INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
2826         mutex_init(&tcp_ses->reconnect_mutex);
2827         memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2828                sizeof(tcp_ses->srcaddr));
2829         memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2830                 sizeof(tcp_ses->dstaddr));
2831         if (volume_info->use_client_guid)
2832                 memcpy(tcp_ses->client_guid, volume_info->client_guid,
2833                        SMB2_CLIENT_GUID_SIZE);
2834         else
2835                 generate_random_uuid(tcp_ses->client_guid);
2836         /*
2837          * at this point we are the only ones with the pointer
2838          * to the struct since the kernel thread not created yet
2839          * no need to spinlock this init of tcpStatus or srv_count
2840          */
2841         tcp_ses->tcpStatus = CifsNew;
2842         ++tcp_ses->srv_count;
2843
2844         if (volume_info->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
2845                 volume_info->echo_interval <= SMB_ECHO_INTERVAL_MAX)
2846                 tcp_ses->echo_interval = volume_info->echo_interval * HZ;
2847         else
2848                 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
2849         if (tcp_ses->rdma) {
2850 #ifndef CONFIG_CIFS_SMB_DIRECT
2851                 cifs_dbg(VFS, "CONFIG_CIFS_SMB_DIRECT is not enabled\n");
2852                 rc = -ENOENT;
2853                 goto out_err_crypto_release;
2854 #endif
2855                 tcp_ses->smbd_conn = smbd_get_connection(
2856                         tcp_ses, (struct sockaddr *)&volume_info->dstaddr);
2857                 if (tcp_ses->smbd_conn) {
2858                         cifs_dbg(VFS, "RDMA transport established\n");
2859                         rc = 0;
2860                         goto smbd_connected;
2861                 } else {
2862                         rc = -ENOENT;
2863                         goto out_err_crypto_release;
2864                 }
2865         }
2866         rc = ip_connect(tcp_ses);
2867         if (rc < 0) {
2868                 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2869                 goto out_err_crypto_release;
2870         }
2871 smbd_connected:
2872         /*
2873          * since we're in a cifs function already, we know that
2874          * this will succeed. No need for try_module_get().
2875          */
2876         __module_get(THIS_MODULE);
2877         tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2878                                   tcp_ses, "cifsd");
2879         if (IS_ERR(tcp_ses->tsk)) {
2880                 rc = PTR_ERR(tcp_ses->tsk);
2881                 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2882                 module_put(THIS_MODULE);
2883                 goto out_err_crypto_release;
2884         }
2885         tcp_ses->min_offload = volume_info->min_offload;
2886         tcp_ses->tcpStatus = CifsNeedNegotiate;
2887
2888         tcp_ses->nr_targets = 1;
2889         tcp_ses->ignore_signature = volume_info->ignore_signature;
2890         /* thread spawned, put it on the list */
2891         spin_lock(&cifs_tcp_ses_lock);
2892         list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2893         spin_unlock(&cifs_tcp_ses_lock);
2894
2895         cifs_fscache_get_client_cookie(tcp_ses);
2896
2897         /* queue echo request delayed work */
2898         queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
2899
2900         return tcp_ses;
2901
2902 out_err_crypto_release:
2903         cifs_crypto_secmech_release(tcp_ses);
2904
2905         put_net(cifs_net_ns(tcp_ses));
2906
2907 out_err:
2908         if (tcp_ses) {
2909                 if (!IS_ERR(tcp_ses->hostname))
2910                         kfree(tcp_ses->hostname);
2911                 if (tcp_ses->ssocket)
2912                         sock_release(tcp_ses->ssocket);
2913                 kfree(tcp_ses);
2914         }
2915         return ERR_PTR(rc);
2916 }
2917
2918 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2919 {
2920         if (vol->sectype != Unspecified &&
2921             vol->sectype != ses->sectype)
2922                 return 0;
2923
2924         /*
2925          * If an existing session is limited to less channels than
2926          * requested, it should not be reused
2927          */
2928         if (ses->chan_max < vol->max_channels)
2929                 return 0;
2930
2931         switch (ses->sectype) {
2932         case Kerberos:
2933                 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2934                         return 0;
2935                 break;
2936         default:
2937                 /* NULL username means anonymous session */
2938                 if (ses->user_name == NULL) {
2939                         if (!vol->nullauth)
2940                                 return 0;
2941                         break;
2942                 }
2943
2944                 /* anything else takes username/password */
2945                 if (strncmp(ses->user_name,
2946                             vol->username ? vol->username : "",
2947                             CIFS_MAX_USERNAME_LEN))
2948                         return 0;
2949                 if ((vol->username && strlen(vol->username) != 0) &&
2950                     ses->password != NULL &&
2951                     strncmp(ses->password,
2952                             vol->password ? vol->password : "",
2953                             CIFS_MAX_PASSWORD_LEN))
2954                         return 0;
2955         }
2956         return 1;
2957 }
2958
2959 /**
2960  * cifs_setup_ipc - helper to setup the IPC tcon for the session
2961  *
2962  * A new IPC connection is made and stored in the session
2963  * tcon_ipc. The IPC tcon has the same lifetime as the session.
2964  */
2965 static int
2966 cifs_setup_ipc(struct cifs_ses *ses, struct smb_vol *volume_info)
2967 {
2968         int rc = 0, xid;
2969         struct cifs_tcon *tcon;
2970         struct nls_table *nls_codepage;
2971         char unc[SERVER_NAME_LENGTH + sizeof("//x/IPC$")] = {0};
2972         bool seal = false;
2973         struct TCP_Server_Info *server = ses->server;
2974
2975         /*
2976          * If the mount request that resulted in the creation of the
2977          * session requires encryption, force IPC to be encrypted too.
2978          */
2979         if (volume_info->seal) {
2980                 if (server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION)
2981                         seal = true;
2982                 else {
2983                         cifs_server_dbg(VFS,
2984                                  "IPC: server doesn't support encryption\n");
2985                         return -EOPNOTSUPP;
2986                 }
2987         }
2988
2989         tcon = tconInfoAlloc();
2990         if (tcon == NULL)
2991                 return -ENOMEM;
2992
2993         scnprintf(unc, sizeof(unc), "\\\\%s\\IPC$", server->hostname);
2994
2995         /* cannot fail */
2996         nls_codepage = load_nls_default();
2997
2998         xid = get_xid();
2999         tcon->ses = ses;
3000         tcon->ipc = true;
3001         tcon->seal = seal;
3002         rc = server->ops->tree_connect(xid, ses, unc, tcon, nls_codepage);
3003         free_xid(xid);
3004
3005         if (rc) {
3006                 cifs_server_dbg(VFS, "failed to connect to IPC (rc=%d)\n", rc);
3007                 tconInfoFree(tcon);
3008                 goto out;
3009         }
3010
3011         cifs_dbg(FYI, "IPC tcon rc = %d ipc tid = %d\n", rc, tcon->tid);
3012
3013         ses->tcon_ipc = tcon;
3014 out:
3015         unload_nls(nls_codepage);
3016         return rc;
3017 }
3018
3019 /**
3020  * cifs_free_ipc - helper to release the session IPC tcon
3021  *
3022  * Needs to be called everytime a session is destroyed
3023  */
3024 static int
3025 cifs_free_ipc(struct cifs_ses *ses)
3026 {
3027         int rc = 0, xid;
3028         struct cifs_tcon *tcon = ses->tcon_ipc;
3029
3030         if (tcon == NULL)
3031                 return 0;
3032
3033         if (ses->server->ops->tree_disconnect) {
3034                 xid = get_xid();
3035                 rc = ses->server->ops->tree_disconnect(xid, tcon);
3036                 free_xid(xid);
3037         }
3038
3039         if (rc)
3040                 cifs_dbg(FYI, "failed to disconnect IPC tcon (rc=%d)\n", rc);
3041
3042         tconInfoFree(tcon);
3043         ses->tcon_ipc = NULL;
3044         return rc;
3045 }
3046
3047 static struct cifs_ses *
3048 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
3049 {
3050         struct cifs_ses *ses;
3051
3052         spin_lock(&cifs_tcp_ses_lock);
3053         list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
3054                 if (ses->status == CifsExiting)
3055                         continue;
3056                 if (!match_session(ses, vol))
3057                         continue;
3058                 ++ses->ses_count;
3059                 spin_unlock(&cifs_tcp_ses_lock);
3060                 return ses;
3061         }
3062         spin_unlock(&cifs_tcp_ses_lock);
3063         return NULL;
3064 }
3065
3066 void cifs_put_smb_ses(struct cifs_ses *ses)
3067 {
3068         unsigned int rc, xid;
3069         struct TCP_Server_Info *server = ses->server;
3070
3071         cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
3072
3073         spin_lock(&cifs_tcp_ses_lock);
3074         if (ses->status == CifsExiting) {
3075                 spin_unlock(&cifs_tcp_ses_lock);
3076                 return;
3077         }
3078         if (--ses->ses_count > 0) {
3079                 spin_unlock(&cifs_tcp_ses_lock);
3080                 return;
3081         }
3082         if (ses->status == CifsGood)
3083                 ses->status = CifsExiting;
3084         spin_unlock(&cifs_tcp_ses_lock);
3085
3086         cifs_free_ipc(ses);
3087
3088         if (ses->status == CifsExiting && server->ops->logoff) {
3089                 xid = get_xid();
3090                 rc = server->ops->logoff(xid, ses);
3091                 if (rc)
3092                         cifs_server_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
3093                                 __func__, rc);
3094                 _free_xid(xid);
3095         }
3096
3097         spin_lock(&cifs_tcp_ses_lock);
3098         list_del_init(&ses->smb_ses_list);
3099         spin_unlock(&cifs_tcp_ses_lock);
3100
3101         /* close any extra channels */
3102         if (ses->chan_count > 1) {
3103                 int i;
3104
3105                 for (i = 1; i < ses->chan_count; i++)
3106                         cifs_put_tcp_session(ses->chans[i].server, 0);
3107         }
3108
3109         sesInfoFree(ses);
3110         cifs_put_tcp_session(server, 0);
3111 }
3112
3113 #ifdef CONFIG_KEYS
3114
3115 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
3116 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
3117
3118 /* Populate username and pw fields from keyring if possible */
3119 static int
3120 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
3121 {
3122         int rc = 0;
3123         int is_domain = 0;
3124         const char *delim, *payload;
3125         char *desc;
3126         ssize_t len;
3127         struct key *key;
3128         struct TCP_Server_Info *server = ses->server;
3129         struct sockaddr_in *sa;
3130         struct sockaddr_in6 *sa6;
3131         const struct user_key_payload *upayload;
3132
3133         desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
3134         if (!desc)
3135                 return -ENOMEM;
3136
3137         /* try to find an address key first */
3138         switch (server->dstaddr.ss_family) {
3139         case AF_INET:
3140                 sa = (struct sockaddr_in *)&server->dstaddr;
3141                 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
3142                 break;
3143         case AF_INET6:
3144                 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
3145                 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
3146                 break;
3147         default:
3148                 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
3149                          server->dstaddr.ss_family);
3150                 rc = -EINVAL;
3151                 goto out_err;
3152         }
3153
3154         cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
3155         key = request_key(&key_type_logon, desc, "");
3156         if (IS_ERR(key)) {
3157                 if (!ses->domainName) {
3158                         cifs_dbg(FYI, "domainName is NULL\n");
3159                         rc = PTR_ERR(key);
3160                         goto out_err;
3161                 }
3162
3163                 /* didn't work, try to find a domain key */
3164                 sprintf(desc, "cifs:d:%s", ses->domainName);
3165                 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
3166                 key = request_key(&key_type_logon, desc, "");
3167                 if (IS_ERR(key)) {
3168                         rc = PTR_ERR(key);
3169                         goto out_err;
3170                 }
3171                 is_domain = 1;
3172         }
3173
3174         down_read(&key->sem);
3175         upayload = user_key_payload_locked(key);
3176         if (IS_ERR_OR_NULL(upayload)) {
3177                 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
3178                 goto out_key_put;
3179         }
3180
3181         /* find first : in payload */
3182         payload = upayload->data;
3183         delim = strnchr(payload, upayload->datalen, ':');
3184         cifs_dbg(FYI, "payload=%s\n", payload);
3185         if (!delim) {
3186                 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
3187                          upayload->datalen);
3188                 rc = -EINVAL;
3189                 goto out_key_put;
3190         }
3191
3192         len = delim - payload;
3193         if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
3194                 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
3195                          len);
3196                 rc = -EINVAL;
3197                 goto out_key_put;
3198         }
3199
3200         vol->username = kstrndup(payload, len, GFP_KERNEL);
3201         if (!vol->username) {
3202                 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
3203                          len);
3204                 rc = -ENOMEM;
3205                 goto out_key_put;
3206         }
3207         cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
3208
3209         len = key->datalen - (len + 1);
3210         if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
3211                 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
3212                 rc = -EINVAL;
3213                 kfree(vol->username);
3214                 vol->username = NULL;
3215                 goto out_key_put;
3216         }
3217
3218         ++delim;
3219         vol->password = kstrndup(delim, len, GFP_KERNEL);
3220         if (!vol->password) {
3221                 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
3222                          len);
3223                 rc = -ENOMEM;
3224                 kfree(vol->username);
3225                 vol->username = NULL;
3226                 goto out_key_put;
3227         }
3228
3229         /*
3230          * If we have a domain key then we must set the domainName in the
3231          * for the request.
3232          */
3233         if (is_domain && ses->domainName) {
3234                 vol->domainname = kstrndup(ses->domainName,
3235                                            strlen(ses->domainName),
3236                                            GFP_KERNEL);
3237                 if (!vol->domainname) {
3238                         cifs_dbg(FYI, "Unable to allocate %zd bytes for "
3239                                  "domain\n", len);
3240                         rc = -ENOMEM;
3241                         kfree(vol->username);
3242                         vol->username = NULL;
3243                         kzfree(vol->password);
3244                         vol->password = NULL;
3245                         goto out_key_put;
3246                 }
3247         }
3248
3249 out_key_put:
3250         up_read(&key->sem);
3251         key_put(key);
3252 out_err:
3253         kfree(desc);
3254         cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
3255         return rc;
3256 }
3257 #else /* ! CONFIG_KEYS */
3258 static inline int
3259 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
3260                    struct cifs_ses *ses __attribute__((unused)))
3261 {
3262         return -ENOSYS;
3263 }
3264 #endif /* CONFIG_KEYS */
3265
3266 /**
3267  * cifs_get_smb_ses - get a session matching @volume_info data from @server
3268  *
3269  * This function assumes it is being called from cifs_mount() where we
3270  * already got a server reference (server refcount +1). See
3271  * cifs_get_tcon() for refcount explanations.
3272  */
3273 struct cifs_ses *
3274 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
3275 {
3276         int rc = -ENOMEM;
3277         unsigned int xid;
3278         struct cifs_ses *ses;
3279         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3280         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3281
3282         xid = get_xid();
3283
3284         ses = cifs_find_smb_ses(server, volume_info);
3285         if (ses) {
3286                 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
3287                          ses->status);
3288
3289                 mutex_lock(&ses->session_mutex);
3290                 rc = cifs_negotiate_protocol(xid, ses);
3291                 if (rc) {
3292                         mutex_unlock(&ses->session_mutex);
3293                         /* problem -- put our ses reference */
3294                         cifs_put_smb_ses(ses);
3295                         free_xid(xid);
3296                         return ERR_PTR(rc);
3297                 }
3298                 if (ses->need_reconnect) {
3299                         cifs_dbg(FYI, "Session needs reconnect\n");
3300                         rc = cifs_setup_session(xid, ses,
3301                                                 volume_info->local_nls);
3302                         if (rc) {
3303                                 mutex_unlock(&ses->session_mutex);
3304                                 /* problem -- put our reference */
3305                                 cifs_put_smb_ses(ses);
3306                                 free_xid(xid);
3307                                 return ERR_PTR(rc);
3308                         }
3309                 }
3310                 mutex_unlock(&ses->session_mutex);
3311
3312                 /* existing SMB ses has a server reference already */
3313                 cifs_put_tcp_session(server, 0);
3314                 free_xid(xid);
3315                 return ses;
3316         }
3317
3318         cifs_dbg(FYI, "Existing smb sess not found\n");
3319         ses = sesInfoAlloc();
3320         if (ses == NULL)
3321                 goto get_ses_fail;
3322
3323         /* new SMB session uses our server ref */
3324         ses->server = server;
3325         if (server->dstaddr.ss_family == AF_INET6)
3326                 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
3327         else
3328                 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
3329
3330         if (volume_info->username) {
3331                 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
3332                 if (!ses->user_name)
3333                         goto get_ses_fail;
3334         }
3335
3336         /* volume_info->password freed at unmount */
3337         if (volume_info->password) {
3338                 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
3339                 if (!ses->password)
3340                         goto get_ses_fail;
3341         }
3342         if (volume_info->domainname) {
3343                 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
3344                 if (!ses->domainName)
3345                         goto get_ses_fail;
3346         }
3347         if (volume_info->domainauto)
3348                 ses->domainAuto = volume_info->domainauto;
3349         ses->cred_uid = volume_info->cred_uid;
3350         ses->linux_uid = volume_info->linux_uid;
3351
3352         ses->sectype = volume_info->sectype;
3353         ses->sign = volume_info->sign;
3354         mutex_lock(&ses->session_mutex);
3355
3356         /* add server as first channel */
3357         ses->chans[0].server = server;
3358         ses->chan_count = 1;
3359         ses->chan_max = volume_info->multichannel ? volume_info->max_channels:1;
3360
3361         rc = cifs_negotiate_protocol(xid, ses);
3362         if (!rc)
3363                 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
3364
3365         /* each channel uses a different signing key */
3366         memcpy(ses->chans[0].signkey, ses->smb3signingkey,
3367                sizeof(ses->smb3signingkey));
3368
3369         mutex_unlock(&ses->session_mutex);
3370         if (rc)
3371                 goto get_ses_fail;
3372
3373         /* success, put it on the list and add it as first channel */
3374         spin_lock(&cifs_tcp_ses_lock);
3375         list_add(&ses->smb_ses_list, &server->smb_ses_list);
3376         spin_unlock(&cifs_tcp_ses_lock);
3377
3378         free_xid(xid);
3379
3380         cifs_setup_ipc(ses, volume_info);
3381
3382         return ses;
3383
3384 get_ses_fail:
3385         sesInfoFree(ses);
3386         free_xid(xid);
3387         return ERR_PTR(rc);
3388 }
3389
3390 static int match_tcon(struct cifs_tcon *tcon, struct smb_vol *volume_info)
3391 {
3392         if (tcon->tidStatus == CifsExiting)
3393                 return 0;
3394         if (strncmp(tcon->treeName, volume_info->UNC, MAX_TREE_SIZE))
3395                 return 0;
3396         if (tcon->seal != volume_info->seal)
3397                 return 0;
3398         if (tcon->snapshot_time != volume_info->snapshot_time)
3399                 return 0;
3400         if (tcon->handle_timeout != volume_info->handle_timeout)
3401                 return 0;
3402         if (tcon->no_lease != volume_info->no_lease)
3403                 return 0;
3404         return 1;
3405 }
3406
3407 static struct cifs_tcon *
3408 cifs_find_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
3409 {
3410         struct list_head *tmp;
3411         struct cifs_tcon *tcon;
3412
3413         spin_lock(&cifs_tcp_ses_lock);
3414         list_for_each(tmp, &ses->tcon_list) {
3415                 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
3416                 if (!match_tcon(tcon, volume_info))
3417                         continue;
3418                 ++tcon->tc_count;
3419                 spin_unlock(&cifs_tcp_ses_lock);
3420                 return tcon;
3421         }
3422         spin_unlock(&cifs_tcp_ses_lock);
3423         return NULL;
3424 }
3425
3426 void
3427 cifs_put_tcon(struct cifs_tcon *tcon)
3428 {
3429         unsigned int xid;
3430         struct cifs_ses *ses;
3431
3432         /*
3433          * IPC tcon share the lifetime of their session and are
3434          * destroyed in the session put function
3435          */
3436         if (tcon == NULL || tcon->ipc)
3437                 return;
3438
3439         ses = tcon->ses;
3440         cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
3441         spin_lock(&cifs_tcp_ses_lock);
3442         if (--tcon->tc_count > 0) {
3443                 spin_unlock(&cifs_tcp_ses_lock);
3444                 return;
3445         }
3446
3447         list_del_init(&tcon->tcon_list);
3448         spin_unlock(&cifs_tcp_ses_lock);
3449
3450         xid = get_xid();
3451         if (ses->server->ops->tree_disconnect)
3452                 ses->server->ops->tree_disconnect(xid, tcon);
3453         _free_xid(xid);
3454
3455         cifs_fscache_release_super_cookie(tcon);
3456         tconInfoFree(tcon);
3457         cifs_put_smb_ses(ses);
3458 }
3459
3460 /**
3461  * cifs_get_tcon - get a tcon matching @volume_info data from @ses
3462  *
3463  * - tcon refcount is the number of mount points using the tcon.
3464  * - ses refcount is the number of tcon using the session.
3465  *
3466  * 1. This function assumes it is being called from cifs_mount() where
3467  *    we already got a session reference (ses refcount +1).
3468  *
3469  * 2. Since we're in the context of adding a mount point, the end
3470  *    result should be either:
3471  *
3472  * a) a new tcon already allocated with refcount=1 (1 mount point) and
3473  *    its session refcount incremented (1 new tcon). This +1 was
3474  *    already done in (1).
3475  *
3476  * b) an existing tcon with refcount+1 (add a mount point to it) and
3477  *    identical ses refcount (no new tcon). Because of (1) we need to
3478  *    decrement the ses refcount.
3479  */
3480 static struct cifs_tcon *
3481 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
3482 {
3483         int rc, xid;
3484         struct cifs_tcon *tcon;
3485
3486         tcon = cifs_find_tcon(ses, volume_info);
3487         if (tcon) {
3488                 /*
3489                  * tcon has refcount already incremented but we need to
3490                  * decrement extra ses reference gotten by caller (case b)
3491                  */
3492                 cifs_dbg(FYI, "Found match on UNC path\n");
3493                 cifs_put_smb_ses(ses);
3494                 return tcon;
3495         }
3496
3497         if (!ses->server->ops->tree_connect) {
3498                 rc = -ENOSYS;
3499                 goto out_fail;
3500         }
3501
3502         tcon = tconInfoAlloc();
3503         if (tcon == NULL) {
3504                 rc = -ENOMEM;
3505                 goto out_fail;
3506         }
3507
3508         if (volume_info->snapshot_time) {
3509                 if (ses->server->vals->protocol_id == 0) {
3510                         cifs_dbg(VFS,
3511                              "Use SMB2 or later for snapshot mount option\n");
3512                         rc = -EOPNOTSUPP;
3513                         goto out_fail;
3514                 } else
3515                         tcon->snapshot_time = volume_info->snapshot_time;
3516         }
3517
3518         if (volume_info->handle_timeout) {
3519                 if (ses->server->vals->protocol_id == 0) {
3520                         cifs_dbg(VFS,
3521                              "Use SMB2.1 or later for handle timeout option\n");
3522                         rc = -EOPNOTSUPP;
3523                         goto out_fail;
3524                 } else
3525                         tcon->handle_timeout = volume_info->handle_timeout;
3526         }
3527
3528         tcon->ses = ses;
3529         if (volume_info->password) {
3530                 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
3531                 if (!tcon->password) {
3532                         rc = -ENOMEM;
3533                         goto out_fail;
3534                 }
3535         }
3536
3537         if (volume_info->seal) {
3538                 if (ses->server->vals->protocol_id == 0) {
3539                         cifs_dbg(VFS,
3540                                  "SMB3 or later required for encryption\n");
3541                         rc = -EOPNOTSUPP;
3542                         goto out_fail;
3543                 } else if (tcon->ses->server->capabilities &
3544                                         SMB2_GLOBAL_CAP_ENCRYPTION)
3545                         tcon->seal = true;
3546                 else {
3547                         cifs_dbg(VFS, "Encryption is not supported on share\n");
3548                         rc = -EOPNOTSUPP;
3549                         goto out_fail;
3550                 }
3551         }
3552
3553         if (volume_info->linux_ext) {
3554                 if (ses->server->posix_ext_supported) {
3555                         tcon->posix_extensions = true;
3556                         printk_once(KERN_WARNING
3557                                 "SMB3.11 POSIX Extensions are experimental\n");
3558                 } else {
3559                         cifs_dbg(VFS, "Server does not support mounting with posix SMB3.11 extensions.\n");
3560                         rc = -EOPNOTSUPP;
3561                         goto out_fail;
3562                 }
3563         }
3564
3565         /*
3566          * BB Do we need to wrap session_mutex around this TCon call and Unix
3567          * SetFS as we do on SessSetup and reconnect?
3568          */
3569         xid = get_xid();
3570         rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
3571                                             volume_info->local_nls);
3572         free_xid(xid);
3573         cifs_dbg(FYI, "Tcon rc = %d\n", rc);
3574         if (rc)
3575                 goto out_fail;
3576
3577         tcon->use_persistent = false;
3578         /* check if SMB2 or later, CIFS does not support persistent handles */
3579         if (volume_info->persistent) {
3580                 if (ses->server->vals->protocol_id == 0) {
3581                         cifs_dbg(VFS,
3582                              "SMB3 or later required for persistent handles\n");
3583                         rc = -EOPNOTSUPP;
3584                         goto out_fail;
3585                 } else if (ses->server->capabilities &
3586                            SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3587                         tcon->use_persistent = true;
3588                 else /* persistent handles requested but not supported */ {
3589                         cifs_dbg(VFS,
3590                                 "Persistent handles not supported on share\n");
3591                         rc = -EOPNOTSUPP;
3592                         goto out_fail;
3593                 }
3594         } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
3595              && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3596              && (volume_info->nopersistent == false)) {
3597                 cifs_dbg(FYI, "enabling persistent handles\n");
3598                 tcon->use_persistent = true;
3599         } else if (volume_info->resilient) {
3600                 if (ses->server->vals->protocol_id == 0) {
3601                         cifs_dbg(VFS,
3602                              "SMB2.1 or later required for resilient handles\n");
3603                         rc = -EOPNOTSUPP;
3604                         goto out_fail;
3605                 }
3606                 tcon->use_resilient = true;
3607         }
3608
3609         /* If the user really knows what they are doing they can override */
3610         if (tcon->share_flags & SMB2_SHAREFLAG_NO_CACHING) {
3611                 if (volume_info->cache_ro)
3612                         cifs_dbg(VFS, "cache=ro requested on mount but NO_CACHING flag set on share\n");
3613                 else if (volume_info->cache_rw)
3614                         cifs_dbg(VFS, "cache=singleclient requested on mount but NO_CACHING flag set on share\n");
3615         }
3616
3617         /*
3618          * We can have only one retry value for a connection to a share so for
3619          * resources mounted more than once to the same server share the last
3620          * value passed in for the retry flag is used.
3621          */
3622         tcon->retry = volume_info->retry;
3623         tcon->nocase = volume_info->nocase;
3624         tcon->nohandlecache = volume_info->nohandlecache;
3625         tcon->local_lease = volume_info->local_lease;
3626         tcon->no_lease = volume_info->no_lease;
3627         INIT_LIST_HEAD(&tcon->pending_opens);
3628
3629         spin_lock(&cifs_tcp_ses_lock);
3630         list_add(&tcon->tcon_list, &ses->tcon_list);
3631         spin_unlock(&cifs_tcp_ses_lock);
3632
3633         cifs_fscache_get_super_cookie(tcon);
3634
3635         return tcon;
3636
3637 out_fail:
3638         tconInfoFree(tcon);
3639         return ERR_PTR(rc);
3640 }
3641
3642 void
3643 cifs_put_tlink(struct tcon_link *tlink)
3644 {
3645         if (!tlink || IS_ERR(tlink))
3646                 return;
3647
3648         if (!atomic_dec_and_test(&tlink->tl_count) ||
3649             test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
3650                 tlink->tl_time = jiffies;
3651                 return;
3652         }
3653
3654         if (!IS_ERR(tlink_tcon(tlink)))
3655                 cifs_put_tcon(tlink_tcon(tlink));
3656         kfree(tlink);
3657         return;
3658 }
3659
3660 static int
3661 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3662 {
3663         struct cifs_sb_info *old = CIFS_SB(sb);
3664         struct cifs_sb_info *new = mnt_data->cifs_sb;
3665         unsigned int oldflags = old->mnt_cifs_flags & CIFS_MOUNT_MASK;
3666         unsigned int newflags = new->mnt_cifs_flags & CIFS_MOUNT_MASK;
3667
3668         if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
3669                 return 0;
3670
3671         if (old->mnt_cifs_serverino_autodisabled)
3672                 newflags &= ~CIFS_MOUNT_SERVER_INUM;
3673
3674         if (oldflags != newflags)
3675                 return 0;
3676
3677         /*
3678          * We want to share sb only if we don't specify an r/wsize or
3679          * specified r/wsize is greater than or equal to existing one.
3680          */
3681         if (new->wsize && new->wsize < old->wsize)
3682                 return 0;
3683
3684         if (new->rsize && new->rsize < old->rsize)
3685                 return 0;
3686
3687         if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
3688                 return 0;
3689
3690         if (old->mnt_file_mode != new->mnt_file_mode ||
3691             old->mnt_dir_mode != new->mnt_dir_mode)
3692                 return 0;
3693
3694         if (strcmp(old->local_nls->charset, new->local_nls->charset))
3695                 return 0;
3696
3697         if (old->actimeo != new->actimeo)
3698                 return 0;
3699
3700         return 1;
3701 }
3702
3703 static int
3704 match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3705 {
3706         struct cifs_sb_info *old = CIFS_SB(sb);
3707         struct cifs_sb_info *new = mnt_data->cifs_sb;
3708         bool old_set = old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH;
3709         bool new_set = new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH;
3710
3711         if (old_set && new_set && !strcmp(new->prepath, old->prepath))
3712                 return 1;
3713         else if (!old_set && !new_set)
3714                 return 1;
3715
3716         return 0;
3717 }
3718
3719 int
3720 cifs_match_super(struct super_block *sb, void *data)
3721 {
3722         struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
3723         struct smb_vol *volume_info;
3724         struct cifs_sb_info *cifs_sb;
3725         struct TCP_Server_Info *tcp_srv;
3726         struct cifs_ses *ses;
3727         struct cifs_tcon *tcon;
3728         struct tcon_link *tlink;
3729         int rc = 0;
3730
3731         spin_lock(&cifs_tcp_ses_lock);
3732         cifs_sb = CIFS_SB(sb);
3733         tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3734         if (IS_ERR(tlink)) {
3735                 spin_unlock(&cifs_tcp_ses_lock);
3736                 return rc;
3737         }
3738         tcon = tlink_tcon(tlink);
3739         ses = tcon->ses;
3740         tcp_srv = ses->server;
3741
3742         volume_info = mnt_data->vol;
3743
3744         if (!match_server(tcp_srv, volume_info) ||
3745             !match_session(ses, volume_info) ||
3746             !match_tcon(tcon, volume_info) ||
3747             !match_prepath(sb, mnt_data)) {
3748                 rc = 0;
3749                 goto out;
3750         }
3751
3752         rc = compare_mount_options(sb, mnt_data);
3753 out:
3754         spin_unlock(&cifs_tcp_ses_lock);
3755         cifs_put_tlink(tlink);
3756         return rc;
3757 }
3758
3759 #ifdef CONFIG_DEBUG_LOCK_ALLOC
3760 static struct lock_class_key cifs_key[2];
3761 static struct lock_class_key cifs_slock_key[2];
3762
3763 static inline void
3764 cifs_reclassify_socket4(struct socket *sock)
3765 {
3766         struct sock *sk = sock->sk;
3767         BUG_ON(!sock_allow_reclassification(sk));
3768         sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
3769                 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
3770 }
3771
3772 static inline void
3773 cifs_reclassify_socket6(struct socket *sock)
3774 {
3775         struct sock *sk = sock->sk;
3776         BUG_ON(!sock_allow_reclassification(sk));
3777         sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
3778                 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
3779 }
3780 #else
3781 static inline void
3782 cifs_reclassify_socket4(struct socket *sock)
3783 {
3784 }
3785
3786 static inline void
3787 cifs_reclassify_socket6(struct socket *sock)
3788 {
3789 }
3790 #endif
3791
3792 /* See RFC1001 section 14 on representation of Netbios names */
3793 static void rfc1002mangle(char *target, char *source, unsigned int length)
3794 {
3795         unsigned int i, j;
3796
3797         for (i = 0, j = 0; i < (length); i++) {
3798                 /* mask a nibble at a time and encode */
3799                 target[j] = 'A' + (0x0F & (source[i] >> 4));
3800                 target[j+1] = 'A' + (0x0F & source[i]);
3801                 j += 2;
3802         }
3803
3804 }
3805
3806 static int
3807 bind_socket(struct TCP_Server_Info *server)
3808 {
3809         int rc = 0;
3810         if (server->srcaddr.ss_family != AF_UNSPEC) {
3811                 /* Bind to the specified local IP address */
3812                 struct socket *socket = server->ssocket;
3813                 rc = socket->ops->bind(socket,
3814                                        (struct sockaddr *) &server->srcaddr,
3815                                        sizeof(server->srcaddr));
3816                 if (rc < 0) {
3817                         struct sockaddr_in *saddr4;
3818                         struct sockaddr_in6 *saddr6;
3819                         saddr4 = (struct sockaddr_in *)&server->srcaddr;
3820                         saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
3821                         if (saddr6->sin6_family == AF_INET6)
3822                                 cifs_server_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
3823                                          &saddr6->sin6_addr, rc);
3824                         else
3825                                 cifs_server_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
3826                                          &saddr4->sin_addr.s_addr, rc);
3827                 }
3828         }
3829         return rc;
3830 }
3831
3832 static int
3833 ip_rfc1001_connect(struct TCP_Server_Info *server)
3834 {
3835         int rc = 0;
3836         /*
3837          * some servers require RFC1001 sessinit before sending
3838          * negprot - BB check reconnection in case where second
3839          * sessinit is sent but no second negprot
3840          */
3841         struct rfc1002_session_packet *ses_init_buf;
3842         struct smb_hdr *smb_buf;
3843         ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
3844                                GFP_KERNEL);
3845         if (ses_init_buf) {
3846                 ses_init_buf->trailer.session_req.called_len = 32;
3847
3848                 if (server->server_RFC1001_name[0] != 0)
3849                         rfc1002mangle(ses_init_buf->trailer.
3850                                       session_req.called_name,
3851                                       server->server_RFC1001_name,
3852                                       RFC1001_NAME_LEN_WITH_NULL);
3853                 else
3854                         rfc1002mangle(ses_init_buf->trailer.
3855                                       session_req.called_name,
3856                                       DEFAULT_CIFS_CALLED_NAME,
3857                                       RFC1001_NAME_LEN_WITH_NULL);
3858
3859                 ses_init_buf->trailer.session_req.calling_len = 32;
3860
3861                 /*
3862                  * calling name ends in null (byte 16) from old smb
3863                  * convention.
3864                  */
3865                 if (server->workstation_RFC1001_name[0] != 0)
3866                         rfc1002mangle(ses_init_buf->trailer.
3867                                       session_req.calling_name,
3868                                       server->workstation_RFC1001_name,
3869                                       RFC1001_NAME_LEN_WITH_NULL);
3870                 else
3871                         rfc1002mangle(ses_init_buf->trailer.
3872                                       session_req.calling_name,
3873                                       "LINUX_CIFS_CLNT",
3874                                       RFC1001_NAME_LEN_WITH_NULL);
3875
3876                 ses_init_buf->trailer.session_req.scope1 = 0;
3877                 ses_init_buf->trailer.session_req.scope2 = 0;
3878                 smb_buf = (struct smb_hdr *)ses_init_buf;
3879
3880                 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3881                 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3882                 rc = smb_send(server, smb_buf, 0x44);
3883                 kfree(ses_init_buf);
3884                 /*
3885                  * RFC1001 layer in at least one server
3886                  * requires very short break before negprot
3887                  * presumably because not expecting negprot
3888                  * to follow so fast.  This is a simple
3889                  * solution that works without
3890                  * complicating the code and causes no
3891                  * significant slowing down on mount
3892                  * for everyone else
3893                  */
3894                 usleep_range(1000, 2000);
3895         }
3896         /*
3897          * else the negprot may still work without this
3898          * even though malloc failed
3899          */
3900
3901         return rc;
3902 }
3903
3904 static int
3905 generic_ip_connect(struct TCP_Server_Info *server)
3906 {
3907         int rc = 0;
3908         __be16 sport;
3909         int slen, sfamily;
3910         struct socket *socket = server->ssocket;
3911         struct sockaddr *saddr;
3912
3913         saddr = (struct sockaddr *) &server->dstaddr;
3914
3915         if (server->dstaddr.ss_family == AF_INET6) {
3916                 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3917                 slen = sizeof(struct sockaddr_in6);
3918                 sfamily = AF_INET6;
3919         } else {
3920                 sport = ((struct sockaddr_in *) saddr)->sin_port;
3921                 slen = sizeof(struct sockaddr_in);
3922                 sfamily = AF_INET;
3923         }
3924
3925         if (socket == NULL) {
3926                 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3927                                    IPPROTO_TCP, &socket, 1);
3928                 if (rc < 0) {
3929                         cifs_server_dbg(VFS, "Error %d creating socket\n", rc);
3930                         server->ssocket = NULL;
3931                         return rc;
3932                 }
3933
3934                 /* BB other socket options to set KEEPALIVE, NODELAY? */
3935                 cifs_dbg(FYI, "Socket created\n");
3936                 server->ssocket = socket;
3937                 socket->sk->sk_allocation = GFP_NOFS;
3938                 if (sfamily == AF_INET6)
3939                         cifs_reclassify_socket6(socket);
3940                 else
3941                         cifs_reclassify_socket4(socket);
3942         }
3943
3944         rc = bind_socket(server);
3945         if (rc < 0)
3946                 return rc;
3947
3948         /*
3949          * Eventually check for other socket options to change from
3950          * the default. sock_setsockopt not used because it expects
3951          * user space buffer
3952          */
3953         socket->sk->sk_rcvtimeo = 7 * HZ;
3954         socket->sk->sk_sndtimeo = 5 * HZ;
3955
3956         /* make the bufsizes depend on wsize/rsize and max requests */
3957         if (server->noautotune) {
3958                 if (socket->sk->sk_sndbuf < (200 * 1024))
3959                         socket->sk->sk_sndbuf = 200 * 1024;
3960                 if (socket->sk->sk_rcvbuf < (140 * 1024))
3961                         socket->sk->sk_rcvbuf = 140 * 1024;
3962         }
3963
3964         if (server->tcp_nodelay) {
3965                 int val = 1;
3966                 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3967                                 (char *)&val, sizeof(val));
3968                 if (rc)
3969                         cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3970                                  rc);
3971         }
3972
3973         cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3974                  socket->sk->sk_sndbuf,
3975                  socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3976
3977         rc = socket->ops->connect(socket, saddr, slen,
3978                                   server->noblockcnt ? O_NONBLOCK : 0);
3979         /*
3980          * When mounting SMB root file systems, we do not want to block in
3981          * connect. Otherwise bail out and then let cifs_reconnect() perform
3982          * reconnect failover - if possible.
3983          */
3984         if (server->noblockcnt && rc == -EINPROGRESS)
3985                 rc = 0;
3986         if (rc < 0) {
3987                 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3988                 sock_release(socket);
3989                 server->ssocket = NULL;
3990                 return rc;
3991         }
3992
3993         if (sport == htons(RFC1001_PORT))
3994                 rc = ip_rfc1001_connect(server);
3995
3996         return rc;
3997 }
3998
3999 static int
4000 ip_connect(struct TCP_Server_Info *server)
4001 {
4002         __be16 *sport;
4003         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
4004         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
4005
4006         if (server->dstaddr.ss_family == AF_INET6)
4007                 sport = &addr6->sin6_port;
4008         else
4009                 sport = &addr->sin_port;
4010
4011         if (*sport == 0) {
4012                 int rc;
4013
4014                 /* try with 445 port at first */
4015                 *sport = htons(CIFS_PORT);
4016
4017                 rc = generic_ip_connect(server);
4018                 if (rc >= 0)
4019                         return rc;
4020
4021                 /* if it failed, try with 139 port */
4022                 *sport = htons(RFC1001_PORT);
4023         }
4024
4025         return generic_ip_connect(server);
4026 }
4027
4028 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
4029                           struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
4030 {
4031         /* if we are reconnecting then should we check to see if
4032          * any requested capabilities changed locally e.g. via
4033          * remount but we can not do much about it here
4034          * if they have (even if we could detect it by the following)
4035          * Perhaps we could add a backpointer to array of sb from tcon
4036          * or if we change to make all sb to same share the same
4037          * sb as NFS - then we only have one backpointer to sb.
4038          * What if we wanted to mount the server share twice once with
4039          * and once without posixacls or posix paths? */
4040         __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
4041
4042         if (vol_info && vol_info->no_linux_ext) {
4043                 tcon->fsUnixInfo.Capability = 0;
4044                 tcon->unix_ext = 0; /* Unix Extensions disabled */
4045                 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
4046                 return;
4047         } else if (vol_info)
4048                 tcon->unix_ext = 1; /* Unix Extensions supported */
4049
4050         if (tcon->unix_ext == 0) {
4051                 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
4052                 return;
4053         }
4054
4055         if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
4056                 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
4057                 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
4058                 /* check for reconnect case in which we do not
4059                    want to change the mount behavior if we can avoid it */
4060                 if (vol_info == NULL) {
4061                         /* turn off POSIX ACL and PATHNAMES if not set
4062                            originally at mount time */
4063                         if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
4064                                 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
4065                         if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
4066                                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
4067                                         cifs_dbg(VFS, "POSIXPATH support change\n");
4068                                 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
4069                         } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
4070                                 cifs_dbg(VFS, "possible reconnect error\n");
4071                                 cifs_dbg(VFS, "server disabled POSIX path support\n");
4072                         }
4073                 }
4074
4075                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
4076                         cifs_dbg(VFS, "per-share encryption not supported yet\n");
4077
4078                 cap &= CIFS_UNIX_CAP_MASK;
4079                 if (vol_info && vol_info->no_psx_acl)
4080                         cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
4081                 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
4082                         cifs_dbg(FYI, "negotiated posix acl support\n");
4083                         if (cifs_sb)
4084                                 cifs_sb->mnt_cifs_flags |=
4085                                         CIFS_MOUNT_POSIXACL;
4086                 }
4087
4088                 if (vol_info && vol_info->posix_paths == 0)
4089                         cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
4090                 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
4091                         cifs_dbg(FYI, "negotiate posix pathnames\n");
4092                         if (cifs_sb)
4093                                 cifs_sb->mnt_cifs_flags |=
4094                                         CIFS_MOUNT_POSIX_PATHS;
4095                 }
4096
4097                 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
4098 #ifdef CONFIG_CIFS_DEBUG2
4099                 if (cap & CIFS_UNIX_FCNTL_CAP)
4100                         cifs_dbg(FYI, "FCNTL cap\n");
4101                 if (cap & CIFS_UNIX_EXTATTR_CAP)
4102                         cifs_dbg(FYI, "EXTATTR cap\n");
4103                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
4104                         cifs_dbg(FYI, "POSIX path cap\n");
4105                 if (cap & CIFS_UNIX_XATTR_CAP)
4106                         cifs_dbg(FYI, "XATTR cap\n");
4107                 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
4108                         cifs_dbg(FYI, "POSIX ACL cap\n");
4109                 if (cap & CIFS_UNIX_LARGE_READ_CAP)
4110                         cifs_dbg(FYI, "very large read cap\n");
4111                 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
4112                         cifs_dbg(FYI, "very large write cap\n");
4113                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
4114                         cifs_dbg(FYI, "transport encryption cap\n");
4115                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
4116                         cifs_dbg(FYI, "mandatory transport encryption cap\n");
4117 #endif /* CIFS_DEBUG2 */
4118                 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
4119                         if (vol_info == NULL) {
4120                                 cifs_dbg(FYI, "resetting capabilities failed\n");
4121                         } else
4122                                 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");
4123
4124                 }
4125         }
4126 }
4127
4128 int cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
4129                         struct cifs_sb_info *cifs_sb)
4130 {
4131         INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
4132
4133         spin_lock_init(&cifs_sb->tlink_tree_lock);
4134         cifs_sb->tlink_tree = RB_ROOT;
4135
4136         cifs_sb->bsize = pvolume_info->bsize;
4137         /*
4138          * Temporarily set r/wsize for matching superblock. If we end up using
4139          * new sb then client will later negotiate it downward if needed.
4140          */
4141         cifs_sb->rsize = pvolume_info->rsize;
4142         cifs_sb->wsize = pvolume_info->wsize;
4143
4144         cifs_sb->mnt_uid = pvolume_info->linux_uid;
4145         cifs_sb->mnt_gid = pvolume_info->linux_gid;
4146         cifs_sb->mnt_file_mode = pvolume_info->file_mode;
4147         cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
4148         cifs_dbg(FYI, "file mode: 0x%hx  dir mode: 0x%hx\n",
4149                  cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
4150
4151         cifs_sb->actimeo = pvolume_info->actimeo;
4152         cifs_sb->local_nls = pvolume_info->local_nls;
4153
4154         if (pvolume_info->nodfs)
4155                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_DFS;
4156         if (pvolume_info->noperm)
4157                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
4158         if (pvolume_info->setuids)
4159                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
4160         if (pvolume_info->setuidfromacl)
4161                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
4162         if (pvolume_info->server_ino)
4163                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
4164         if (pvolume_info->remap)
4165                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
4166         if (pvolume_info->sfu_remap)
4167                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
4168         if (pvolume_info->no_xattr)
4169                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
4170         if (pvolume_info->sfu_emul)
4171                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
4172         if (pvolume_info->nobrl)
4173                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
4174         if (pvolume_info->nohandlecache)
4175                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE;
4176         if (pvolume_info->nostrictsync)
4177                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
4178         if (pvolume_info->mand_lock)
4179                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
4180         if (pvolume_info->rwpidforward)
4181                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
4182         if (pvolume_info->mode_ace)
4183                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MODE_FROM_SID;
4184         if (pvolume_info->cifs_acl)
4185                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
4186         if (pvolume_info->backupuid_specified) {
4187                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
4188                 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
4189         }
4190         if (pvolume_info->backupgid_specified) {
4191                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
4192                 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
4193         }
4194         if (pvolume_info->override_uid)
4195                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
4196         if (pvolume_info->override_gid)
4197                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
4198         if (pvolume_info->dynperm)
4199                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
4200         if (pvolume_info->fsc)
4201                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
4202         if (pvolume_info->multiuser)
4203                 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
4204                                             CIFS_MOUNT_NO_PERM);
4205         if (pvolume_info->strict_io)
4206                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
4207         if (pvolume_info->direct_io) {
4208                 cifs_dbg(FYI, "mounting share using direct i/o\n");
4209                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
4210         }
4211         if (pvolume_info->cache_ro) {
4212                 cifs_dbg(VFS, "mounting share with read only caching. Ensure that the share will not be modified while in use.\n");
4213                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RO_CACHE;
4214         } else if (pvolume_info->cache_rw) {
4215                 cifs_dbg(VFS, "mounting share in single client RW caching mode. Ensure that no other systems will be accessing the share.\n");
4216                 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_RO_CACHE |
4217                                             CIFS_MOUNT_RW_CACHE);
4218         }
4219         if (pvolume_info->mfsymlinks) {
4220                 if (pvolume_info->sfu_emul) {
4221                         /*
4222                          * Our SFU ("Services for Unix" emulation does not allow
4223                          * creating symlinks but does allow reading existing SFU
4224                          * symlinks (it does allow both creating and reading SFU
4225                          * style mknod and FIFOs though). When "mfsymlinks" and
4226                          * "sfu" are both enabled at the same time, it allows
4227                          * reading both types of symlinks, but will only create
4228                          * them with mfsymlinks format. This allows better
4229                          * Apple compatibility (probably better for Samba too)
4230                          * while still recognizing old Windows style symlinks.
4231                          */
4232                         cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
4233                 }
4234                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
4235         }
4236
4237         if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
4238                 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
4239
4240         if (pvolume_info->prepath) {
4241                 cifs_sb->prepath = kstrdup(pvolume_info->prepath, GFP_KERNEL);
4242                 if (cifs_sb->prepath == NULL)
4243                         return -ENOMEM;
4244         }
4245
4246         return 0;
4247 }
4248
4249 void
4250 cifs_cleanup_volume_info_contents(struct smb_vol *volume_info)
4251 {
4252         kfree(volume_info->username);
4253         kzfree(volume_info->password);
4254         kfree(volume_info->UNC);
4255         kfree(volume_info->domainname);
4256         kfree(volume_info->iocharset);
4257         kfree(volume_info->prepath);
4258 }
4259
4260 void
4261 cifs_cleanup_volume_info(struct smb_vol *volume_info)
4262 {
4263         if (!volume_info)
4264                 return;
4265         cifs_cleanup_volume_info_contents(volume_info);
4266         kfree(volume_info);
4267 }
4268
4269 /* Release all succeed connections */
4270 static inline void mount_put_conns(struct cifs_sb_info *cifs_sb,
4271                                    unsigned int xid,
4272                                    struct TCP_Server_Info *server,
4273                                    struct cifs_ses *ses, struct cifs_tcon *tcon)
4274 {
4275         int rc = 0;
4276
4277         if (tcon)
4278                 cifs_put_tcon(tcon);
4279         else if (ses)
4280                 cifs_put_smb_ses(ses);
4281         else if (server)
4282                 cifs_put_tcp_session(server, 0);
4283         cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
4284         free_xid(xid);
4285 }
4286
4287 /* Get connections for tcp, ses and tcon */
4288 static int mount_get_conns(struct smb_vol *vol, struct cifs_sb_info *cifs_sb,
4289                            unsigned int *xid,
4290                            struct TCP_Server_Info **nserver,
4291                            struct cifs_ses **nses, struct cifs_tcon **ntcon)
4292 {
4293         int rc = 0;
4294         struct TCP_Server_Info *server;
4295         struct cifs_ses *ses;
4296         struct cifs_tcon *tcon;
4297
4298         *nserver = NULL;
4299         *nses = NULL;
4300         *ntcon = NULL;
4301
4302         *xid = get_xid();
4303
4304         /* get a reference to a tcp session */
4305         server = cifs_get_tcp_session(vol);
4306         if (IS_ERR(server)) {
4307                 rc = PTR_ERR(server);
4308                 return rc;
4309         }
4310
4311         *nserver = server;
4312
4313         if ((vol->max_credits < 20) || (vol->max_credits > 60000))
4314                 server->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
4315         else
4316                 server->max_credits = vol->max_credits;
4317
4318         /* get a reference to a SMB session */
4319         ses = cifs_get_smb_ses(server, vol);
4320         if (IS_ERR(ses)) {
4321                 rc = PTR_ERR(ses);
4322                 return rc;
4323         }
4324
4325         *nses = ses;
4326
4327         if ((vol->persistent == true) && (!(ses->server->capabilities &
4328                                             SMB2_GLOBAL_CAP_PERSISTENT_HANDLES))) {
4329                 cifs_server_dbg(VFS, "persistent handles not supported by server\n");
4330                 return -EOPNOTSUPP;
4331         }
4332
4333         /* search for existing tcon to this server share */
4334         tcon = cifs_get_tcon(ses, vol);
4335         if (IS_ERR(tcon)) {
4336                 rc = PTR_ERR(tcon);
4337                 return rc;
4338         }
4339
4340         *ntcon = tcon;
4341
4342         /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
4343         if (tcon->posix_extensions)
4344                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
4345
4346         /* tell server which Unix caps we support */
4347         if (cap_unix(tcon->ses)) {
4348                 /*
4349                  * reset of caps checks mount to see if unix extensions disabled
4350                  * for just this mount.
4351                  */
4352                 reset_cifs_unix_caps(*xid, tcon, cifs_sb, vol);
4353                 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
4354                     (le64_to_cpu(tcon->fsUnixInfo.Capability) &
4355                      CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP))
4356                         return -EACCES;
4357         } else
4358                 tcon->unix_ext = 0; /* server does not support them */
4359
4360         /* do not care if a following call succeed - informational */
4361         if (!tcon->pipe && server->ops->qfs_tcon) {
4362                 server->ops->qfs_tcon(*xid, tcon);
4363                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE) {
4364                         if (tcon->fsDevInfo.DeviceCharacteristics &
4365                             cpu_to_le32(FILE_READ_ONLY_DEVICE))
4366                                 cifs_dbg(VFS, "mounted to read only share\n");
4367                         else if ((cifs_sb->mnt_cifs_flags &
4368                                   CIFS_MOUNT_RW_CACHE) == 0)
4369                                 cifs_dbg(VFS, "read only mount of RW share\n");
4370                         /* no need to log a RW mount of a typical RW share */
4371                 }
4372         }
4373
4374         cifs_sb->wsize = server->ops->negotiate_wsize(tcon, vol);
4375         cifs_sb->rsize = server->ops->negotiate_rsize(tcon, vol);
4376
4377         return 0;
4378 }
4379
4380 static int mount_setup_tlink(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses,
4381                              struct cifs_tcon *tcon)
4382 {
4383         struct tcon_link *tlink;
4384
4385         /* hang the tcon off of the superblock */
4386         tlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4387         if (tlink == NULL)
4388                 return -ENOMEM;
4389
4390         tlink->tl_uid = ses->linux_uid;
4391         tlink->tl_tcon = tcon;
4392         tlink->tl_time = jiffies;
4393         set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
4394         set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4395
4396         cifs_sb->master_tlink = tlink;
4397         spin_lock(&cifs_sb->tlink_tree_lock);
4398         tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4399         spin_unlock(&cifs_sb->tlink_tree_lock);
4400
4401         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4402                                 TLINK_IDLE_EXPIRE);
4403         return 0;
4404 }
4405
4406 #ifdef CONFIG_CIFS_DFS_UPCALL
4407 /*
4408  * cifs_build_path_to_root returns full path to root when we do not have an
4409  * exiting connection (tcon)
4410  */
4411 static char *
4412 build_unc_path_to_root(const struct smb_vol *vol,
4413                        const struct cifs_sb_info *cifs_sb, bool useppath)
4414 {
4415         char *full_path, *pos;
4416         unsigned int pplen = useppath && vol->prepath ?
4417                 strlen(vol->prepath) + 1 : 0;
4418         unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
4419
4420         if (unc_len > MAX_TREE_SIZE)
4421                 return ERR_PTR(-EINVAL);
4422
4423         full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
4424         if (full_path == NULL)
4425                 return ERR_PTR(-ENOMEM);
4426
4427         memcpy(full_path, vol->UNC, unc_len);
4428         pos = full_path + unc_len;
4429
4430         if (pplen) {
4431                 *pos = CIFS_DIR_SEP(cifs_sb);
4432                 memcpy(pos + 1, vol->prepath, pplen);
4433                 pos += pplen;
4434         }
4435
4436         *pos = '\0'; /* add trailing null */
4437         convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
4438         cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
4439         return full_path;
4440 }
4441
4442 /**
4443  * expand_dfs_referral - Perform a dfs referral query and update the cifs_sb
4444  *
4445  *
4446  * If a referral is found, cifs_sb->mountdata will be (re-)allocated
4447  * to a string containing updated options for the submount.  Otherwise it
4448  * will be left untouched.
4449  *
4450  * Returns the rc from get_dfs_path to the caller, which can be used to
4451  * determine whether there were referrals.
4452  */
4453 static int
4454 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
4455                     struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
4456                     int check_prefix)
4457 {
4458         int rc;
4459         struct dfs_info3_param referral = {0};
4460         char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
4461
4462         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
4463                 return -EREMOTE;
4464
4465         full_path = build_unc_path_to_root(volume_info, cifs_sb, true);
4466         if (IS_ERR(full_path))
4467                 return PTR_ERR(full_path);
4468
4469         /* For DFS paths, skip the first '\' of the UNC */
4470         ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
4471
4472         rc = dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb),
4473                             ref_path, &referral, NULL);
4474         if (!rc) {
4475                 char *fake_devname = NULL;
4476
4477                 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
4478                                                    full_path + 1, &referral,
4479                                                    &fake_devname);
4480                 free_dfs_info_param(&referral);
4481
4482                 if (IS_ERR(mdata)) {
4483                         rc = PTR_ERR(mdata);
4484                         mdata = NULL;
4485                 } else {
4486                         cifs_cleanup_volume_info_contents(volume_info);
4487                         rc = cifs_setup_volume_info(volume_info, mdata,
4488                                                     fake_devname, false);
4489                 }
4490                 kfree(fake_devname);
4491                 kfree(cifs_sb->mountdata);
4492                 cifs_sb->mountdata = mdata;
4493         }
4494         kfree(full_path);
4495         return rc;
4496 }
4497
4498 static inline int get_next_dfs_tgt(const char *path,
4499                                    struct dfs_cache_tgt_list *tgt_list,
4500                                    struct dfs_cache_tgt_iterator **tgt_it)
4501 {
4502         if (!*tgt_it)
4503                 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
4504         else
4505                 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
4506         return !*tgt_it ? -EHOSTDOWN : 0;
4507 }
4508
4509 static int update_vol_info(const struct dfs_cache_tgt_iterator *tgt_it,
4510                            struct smb_vol *fake_vol, struct smb_vol *vol)
4511 {
4512         const char *tgt = dfs_cache_get_tgt_name(tgt_it);
4513         int len = strlen(tgt) + 2;
4514         char *new_unc;
4515
4516         new_unc = kmalloc(len, GFP_KERNEL);
4517         if (!new_unc)
4518                 return -ENOMEM;
4519         scnprintf(new_unc, len, "\\%s", tgt);
4520
4521         kfree(vol->UNC);
4522         vol->UNC = new_unc;
4523
4524         if (fake_vol->prepath) {
4525                 kfree(vol->prepath);
4526                 vol->prepath = fake_vol->prepath;
4527                 fake_vol->prepath = NULL;
4528         }
4529         memcpy(&vol->dstaddr, &fake_vol->dstaddr, sizeof(vol->dstaddr));
4530
4531         return 0;
4532 }
4533
4534 static int setup_dfs_tgt_conn(const char *path,
4535                               const struct dfs_cache_tgt_iterator *tgt_it,
4536                               struct cifs_sb_info *cifs_sb,
4537                               struct smb_vol *vol,
4538                               unsigned int *xid,
4539                               struct TCP_Server_Info **server,
4540                               struct cifs_ses **ses,
4541                               struct cifs_tcon **tcon)
4542 {
4543         int rc;
4544         struct dfs_info3_param ref = {0};
4545         char *mdata = NULL, *fake_devname = NULL;
4546         struct smb_vol fake_vol = {NULL};
4547
4548         cifs_dbg(FYI, "%s: dfs path: %s\n", __func__, path);
4549
4550         rc = dfs_cache_get_tgt_referral(path, tgt_it, &ref);
4551         if (rc)
4552                 return rc;
4553
4554         mdata = cifs_compose_mount_options(cifs_sb->mountdata, path, &ref,
4555                                            &fake_devname);
4556         free_dfs_info_param(&ref);
4557
4558         if (IS_ERR(mdata)) {
4559                 rc = PTR_ERR(mdata);
4560                 mdata = NULL;
4561         } else {
4562                 cifs_dbg(FYI, "%s: fake_devname: %s\n", __func__, fake_devname);
4563                 rc = cifs_setup_volume_info(&fake_vol, mdata, fake_devname,
4564                                             false);
4565         }
4566         kfree(mdata);
4567         kfree(fake_devname);
4568
4569         if (!rc) {
4570                 /*
4571                  * We use a 'fake_vol' here because we need pass it down to the
4572                  * mount_{get,put} functions to test connection against new DFS
4573                  * targets.
4574                  */
4575                 mount_put_conns(cifs_sb, *xid, *server, *ses, *tcon);
4576                 rc = mount_get_conns(&fake_vol, cifs_sb, xid, server, ses,
4577                                      tcon);
4578                 if (!rc) {
4579                         /*
4580                          * We were able to connect to new target server.
4581                          * Update current volume info with new target server.
4582                          */
4583                         rc = update_vol_info(tgt_it, &fake_vol, vol);
4584                 }
4585         }
4586         cifs_cleanup_volume_info_contents(&fake_vol);
4587         return rc;
4588 }
4589
4590 static int mount_do_dfs_failover(const char *path,
4591                                  struct cifs_sb_info *cifs_sb,
4592                                  struct smb_vol *vol,
4593                                  struct cifs_ses *root_ses,
4594                                  unsigned int *xid,
4595                                  struct TCP_Server_Info **server,
4596                                  struct cifs_ses **ses,
4597                                  struct cifs_tcon **tcon)
4598 {
4599         int rc;
4600         struct dfs_cache_tgt_list tgt_list;
4601         struct dfs_cache_tgt_iterator *tgt_it = NULL;
4602
4603         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
4604                 return -EOPNOTSUPP;
4605
4606         rc = dfs_cache_noreq_find(path, NULL, &tgt_list);
4607         if (rc)
4608                 return rc;
4609
4610         for (;;) {
4611                 /* Get next DFS target server - if any */
4612                 rc = get_next_dfs_tgt(path, &tgt_list, &tgt_it);
4613                 if (rc)
4614                         break;
4615                 /* Connect to next DFS target */
4616                 rc = setup_dfs_tgt_conn(path, tgt_it, cifs_sb, vol, xid, server,
4617                                         ses, tcon);
4618                 if (!rc || rc == -EACCES || rc == -EOPNOTSUPP)
4619                         break;
4620         }
4621         if (!rc) {
4622                 /*
4623                  * Update DFS target hint in DFS referral cache with the target
4624                  * server we successfully reconnected to.
4625                  */
4626                 rc = dfs_cache_update_tgthint(*xid, root_ses ? root_ses : *ses,
4627                                               cifs_sb->local_nls,
4628                                               cifs_remap(cifs_sb), path,
4629                                               tgt_it);
4630         }
4631         dfs_cache_free_tgts(&tgt_list);
4632         return rc;
4633 }
4634 #endif
4635
4636 int
4637 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
4638                         const char *devname, bool is_smb3)
4639 {
4640         int rc = 0;
4641
4642         if (cifs_parse_mount_options(mount_data, devname, volume_info, is_smb3))
4643                 return -EINVAL;
4644
4645         if (volume_info->nullauth) {
4646                 cifs_dbg(FYI, "Anonymous login\n");
4647                 kfree(volume_info->username);
4648                 volume_info->username = NULL;
4649         } else if (volume_info->username) {
4650                 /* BB fixme parse for domain name here */
4651                 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
4652         } else {
4653                 cifs_dbg(VFS, "No username specified\n");
4654         /* In userspace mount helper we can get user name from alternate
4655            locations such as env variables and files on disk */
4656                 return -EINVAL;
4657         }
4658
4659         /* this is needed for ASCII cp to Unicode converts */
4660         if (volume_info->iocharset == NULL) {
4661                 /* load_nls_default cannot return null */
4662                 volume_info->local_nls = load_nls_default();
4663         } else {
4664                 volume_info->local_nls = load_nls(volume_info->iocharset);
4665                 if (volume_info->local_nls == NULL) {
4666                         cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
4667                                  volume_info->iocharset);
4668                         return -ELIBACC;
4669                 }
4670         }
4671
4672         return rc;
4673 }
4674
4675 struct smb_vol *
4676 cifs_get_volume_info(char *mount_data, const char *devname, bool is_smb3)
4677 {
4678         int rc;
4679         struct smb_vol *volume_info;
4680
4681         volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
4682         if (!volume_info)
4683                 return ERR_PTR(-ENOMEM);
4684
4685         rc = cifs_setup_volume_info(volume_info, mount_data, devname, is_smb3);
4686         if (rc) {
4687                 cifs_cleanup_volume_info(volume_info);
4688                 volume_info = ERR_PTR(rc);
4689         }
4690
4691         return volume_info;
4692 }
4693
4694 static int
4695 cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
4696                                         unsigned int xid,
4697                                         struct cifs_tcon *tcon,
4698                                         struct cifs_sb_info *cifs_sb,
4699                                         char *full_path,
4700                                         int added_treename)
4701 {
4702         int rc;
4703         char *s;
4704         char sep, tmp;
4705         int skip = added_treename ? 1 : 0;
4706
4707         sep = CIFS_DIR_SEP(cifs_sb);
4708         s = full_path;
4709
4710         rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
4711         while (rc == 0) {
4712                 /* skip separators */
4713                 while (*s == sep)
4714                         s++;
4715                 if (!*s)
4716                         break;
4717                 /* next separator */
4718                 while (*s && *s != sep)
4719                         s++;
4720                 /*
4721                  * if the treename is added, we then have to skip the first
4722                  * part within the separators
4723                  */
4724                 if (skip) {
4725                         skip = 0;
4726                         continue;
4727                 }
4728                 /*
4729                  * temporarily null-terminate the path at the end of
4730                  * the current component
4731                  */
4732                 tmp = *s;
4733                 *s = 0;
4734                 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
4735                                                      full_path);
4736                 *s = tmp;
4737         }
4738         return rc;
4739 }
4740
4741 /*
4742  * Check if path is remote (e.g. a DFS share). Return -EREMOTE if it is,
4743  * otherwise 0.
4744  */
4745 static int is_path_remote(struct cifs_sb_info *cifs_sb, struct smb_vol *vol,
4746                           const unsigned int xid,
4747                           struct TCP_Server_Info *server,
4748                           struct cifs_tcon *tcon)
4749 {
4750         int rc;
4751         char *full_path;
4752
4753         if (!server->ops->is_path_accessible)
4754                 return -EOPNOTSUPP;
4755
4756         /*
4757          * cifs_build_path_to_root works only when we have a valid tcon
4758          */
4759         full_path = cifs_build_path_to_root(vol, cifs_sb, tcon,
4760                                             tcon->Flags & SMB_SHARE_IS_IN_DFS);
4761         if (full_path == NULL)
4762                 return -ENOMEM;
4763
4764         cifs_dbg(FYI, "%s: full_path: %s\n", __func__, full_path);
4765
4766         rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
4767                                              full_path);
4768         if (rc != 0 && rc != -EREMOTE) {
4769                 kfree(full_path);
4770                 return rc;
4771         }
4772
4773         if (rc != -EREMOTE) {
4774                 rc = cifs_are_all_path_components_accessible(server, xid, tcon,
4775                         cifs_sb, full_path, tcon->Flags & SMB_SHARE_IS_IN_DFS);
4776                 if (rc != 0) {
4777                         cifs_server_dbg(VFS, "cannot query dirs between root and final path, "
4778                                  "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
4779                         cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
4780                         rc = 0;
4781                 }
4782         }
4783
4784         kfree(full_path);
4785         return rc;
4786 }
4787
4788 #ifdef CONFIG_CIFS_DFS_UPCALL
4789 static inline void set_root_tcon(struct cifs_sb_info *cifs_sb,
4790                                  struct cifs_tcon *tcon,
4791                                  struct cifs_tcon **root)
4792 {
4793         spin_lock(&cifs_tcp_ses_lock);
4794         tcon->tc_count++;
4795         tcon->remap = cifs_remap(cifs_sb);
4796         spin_unlock(&cifs_tcp_ses_lock);
4797         *root = tcon;
4798 }
4799
4800 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *vol)
4801 {
4802         int rc = 0;
4803         unsigned int xid;
4804         struct cifs_ses *ses;
4805         struct cifs_tcon *root_tcon = NULL;
4806         struct cifs_tcon *tcon = NULL;
4807         struct TCP_Server_Info *server;
4808         char *root_path = NULL, *full_path = NULL;
4809         char *old_mountdata, *origin_mountdata = NULL;
4810         int count;
4811
4812         rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4813         if (!rc && tcon) {
4814                 /* If not a standalone DFS root, then check if path is remote */
4815                 rc = dfs_cache_find(xid, ses, cifs_sb->local_nls,
4816                                     cifs_remap(cifs_sb), vol->UNC + 1, NULL,
4817                                     NULL);
4818                 if (rc) {
4819                         rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
4820                         if (!rc)
4821                                 goto out;
4822                         if (rc != -EREMOTE)
4823                                 goto error;
4824                 }
4825         }
4826         /*
4827          * If first DFS target server went offline and we failed to connect it,
4828          * server and ses pointers are NULL at this point, though we still have
4829          * chance to get a cached DFS referral in expand_dfs_referral() and
4830          * retry next target available in it.
4831          *
4832          * If a NULL ses ptr is passed to dfs_cache_find(), a lookup will be
4833          * performed against DFS path and *no* requests will be sent to server
4834          * for any new DFS referrals. Hence it's safe to skip checking whether
4835          * server or ses ptr is NULL.
4836          */
4837         if (rc == -EACCES || rc == -EOPNOTSUPP)
4838                 goto error;
4839
4840         root_path = build_unc_path_to_root(vol, cifs_sb, false);
4841         if (IS_ERR(root_path)) {
4842                 rc = PTR_ERR(root_path);
4843                 root_path = NULL;
4844                 goto error;
4845         }
4846
4847         full_path = build_unc_path_to_root(vol, cifs_sb, true);
4848         if (IS_ERR(full_path)) {
4849                 rc = PTR_ERR(full_path);
4850                 full_path = NULL;
4851                 goto error;
4852         }
4853         /*
4854          * Perform an unconditional check for whether there are DFS
4855          * referrals for this path without prefix, to provide support
4856          * for DFS referrals from w2k8 servers which don't seem to respond
4857          * with PATH_NOT_COVERED to requests that include the prefix.
4858          * Chase the referral if found, otherwise continue normally.
4859          */
4860         old_mountdata = cifs_sb->mountdata;
4861         (void)expand_dfs_referral(xid, ses, vol, cifs_sb, false);
4862
4863         if (cifs_sb->mountdata == NULL) {
4864                 rc = -ENOENT;
4865                 goto error;
4866         }
4867
4868         /* Save DFS root volume information for DFS refresh worker */
4869         origin_mountdata = kstrndup(cifs_sb->mountdata,
4870                                     strlen(cifs_sb->mountdata), GFP_KERNEL);
4871         if (!origin_mountdata) {
4872                 rc = -ENOMEM;
4873                 goto error;
4874         }
4875
4876         if (cifs_sb->mountdata != old_mountdata) {
4877                 /* If we were redirected, reconnect to new target server */
4878                 mount_put_conns(cifs_sb, xid, server, ses, tcon);
4879                 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4880         }
4881         if (rc) {
4882                 if (rc == -EACCES || rc == -EOPNOTSUPP)
4883                         goto error;
4884                 /* Perform DFS failover to any other DFS targets */
4885                 rc = mount_do_dfs_failover(root_path + 1, cifs_sb, vol, NULL,
4886                                            &xid, &server, &ses, &tcon);
4887                 if (rc)
4888                         goto error;
4889         }
4890
4891         kfree(root_path);
4892         root_path = build_unc_path_to_root(vol, cifs_sb, false);
4893         if (IS_ERR(root_path)) {
4894                 rc = PTR_ERR(root_path);
4895                 root_path = NULL;
4896                 goto error;
4897         }
4898         /* Cache out resolved root server */
4899         (void)dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb),
4900                              root_path + 1, NULL, NULL);
4901         kfree(root_path);
4902         root_path = NULL;
4903
4904         set_root_tcon(cifs_sb, tcon, &root_tcon);
4905
4906         for (count = 1; ;) {
4907                 if (!rc && tcon) {
4908                         rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
4909                         if (!rc || rc != -EREMOTE)
4910                                 break;
4911                 }
4912                 /*
4913                  * BB: when we implement proper loop detection,
4914                  *     we will remove this check. But now we need it
4915                  *     to prevent an indefinite loop if 'DFS tree' is
4916                  *     misconfigured (i.e. has loops).
4917                  */
4918                 if (count++ > MAX_NESTED_LINKS) {
4919                         rc = -ELOOP;
4920                         break;
4921                 }
4922
4923                 kfree(full_path);
4924                 full_path = build_unc_path_to_root(vol, cifs_sb, true);
4925                 if (IS_ERR(full_path)) {
4926                         rc = PTR_ERR(full_path);
4927                         full_path = NULL;
4928                         break;
4929                 }
4930
4931                 old_mountdata = cifs_sb->mountdata;
4932                 rc = expand_dfs_referral(xid, root_tcon->ses, vol, cifs_sb,
4933                                          true);
4934                 if (rc)
4935                         break;
4936
4937                 if (cifs_sb->mountdata != old_mountdata) {
4938                         mount_put_conns(cifs_sb, xid, server, ses, tcon);
4939                         rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses,
4940                                              &tcon);
4941                         /*
4942                          * Ensure that DFS referrals go through new root server.
4943                          */
4944                         if (!rc && tcon &&
4945                             (tcon->share_flags & (SHI1005_FLAGS_DFS |
4946                                                   SHI1005_FLAGS_DFS_ROOT))) {
4947                                 cifs_put_tcon(root_tcon);
4948                                 set_root_tcon(cifs_sb, tcon, &root_tcon);
4949                         }
4950                 }
4951                 if (rc) {
4952                         if (rc == -EACCES || rc == -EOPNOTSUPP)
4953                                 break;
4954                         /* Perform DFS failover to any other DFS targets */
4955                         rc = mount_do_dfs_failover(full_path + 1, cifs_sb, vol,
4956                                                    root_tcon->ses, &xid,
4957                                                    &server, &ses, &tcon);
4958                         if (rc == -EACCES || rc == -EOPNOTSUPP || !server ||
4959                             !ses)
4960                                 goto error;
4961                 }
4962         }
4963         cifs_put_tcon(root_tcon);
4964
4965         if (rc)
4966                 goto error;
4967
4968         spin_lock(&cifs_tcp_ses_lock);
4969         if (!tcon->dfs_path) {
4970                 /* Save full path in new tcon to do failover when reconnecting tcons */
4971                 tcon->dfs_path = full_path;
4972                 full_path = NULL;
4973                 tcon->remap = cifs_remap(cifs_sb);
4974         }
4975         cifs_sb->origin_fullpath = kstrndup(tcon->dfs_path,
4976                                             strlen(tcon->dfs_path),
4977                                             GFP_ATOMIC);
4978         if (!cifs_sb->origin_fullpath) {
4979                 spin_unlock(&cifs_tcp_ses_lock);
4980                 rc = -ENOMEM;
4981                 goto error;
4982         }
4983         spin_unlock(&cifs_tcp_ses_lock);
4984
4985         rc = dfs_cache_add_vol(origin_mountdata, vol, cifs_sb->origin_fullpath);
4986         if (rc) {
4987                 kfree(cifs_sb->origin_fullpath);
4988                 goto error;
4989         }
4990         /*
4991          * After reconnecting to a different server, unique ids won't
4992          * match anymore, so we disable serverino. This prevents
4993          * dentry revalidation to think the dentry are stale (ESTALE).
4994          */
4995         cifs_autodisable_serverino(cifs_sb);
4996 out:
4997         free_xid(xid);
4998         cifs_try_adding_channels(ses);
4999         return mount_setup_tlink(cifs_sb, ses, tcon);
5000
5001 error:
5002         kfree(full_path);
5003         kfree(root_path);
5004         kfree(origin_mountdata);
5005         mount_put_conns(cifs_sb, xid, server, ses, tcon);
5006         return rc;
5007 }
5008 #else
5009 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *vol)
5010 {
5011         int rc = 0;
5012         unsigned int xid;
5013         struct cifs_ses *ses;
5014         struct cifs_tcon *tcon;
5015         struct TCP_Server_Info *server;
5016
5017         rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
5018         if (rc)
5019                 goto error;
5020
5021         if (tcon) {
5022                 rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
5023                 if (rc == -EREMOTE)
5024                         rc = -EOPNOTSUPP;
5025                 if (rc)
5026                         goto error;
5027         }
5028
5029         free_xid(xid);
5030
5031         return mount_setup_tlink(cifs_sb, ses, tcon);
5032
5033 error:
5034         mount_put_conns(cifs_sb, xid, server, ses, tcon);
5035         return rc;
5036 }
5037 #endif
5038
5039 /*
5040  * Issue a TREE_CONNECT request.
5041  */
5042 int
5043 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
5044          const char *tree, struct cifs_tcon *tcon,
5045          const struct nls_table *nls_codepage)
5046 {
5047         struct smb_hdr *smb_buffer;
5048         struct smb_hdr *smb_buffer_response;
5049         TCONX_REQ *pSMB;
5050         TCONX_RSP *pSMBr;
5051         unsigned char *bcc_ptr;
5052         int rc = 0;
5053         int length;
5054         __u16 bytes_left, count;
5055
5056         if (ses == NULL)
5057                 return -EIO;
5058
5059         smb_buffer = cifs_buf_get();
5060         if (smb_buffer == NULL)
5061                 return -ENOMEM;
5062
5063         smb_buffer_response = smb_buffer;
5064
5065         header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
5066                         NULL /*no tid */ , 4 /*wct */ );
5067
5068         smb_buffer->Mid = get_next_mid(ses->server);
5069         smb_buffer->Uid = ses->Suid;
5070         pSMB = (TCONX_REQ *) smb_buffer;
5071         pSMBr = (TCONX_RSP *) smb_buffer_response;
5072
5073         pSMB->AndXCommand = 0xFF;
5074         pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
5075         bcc_ptr = &pSMB->Password[0];
5076         if (tcon->pipe || (ses->server->sec_mode & SECMODE_USER)) {
5077                 pSMB->PasswordLength = cpu_to_le16(1);  /* minimum */
5078                 *bcc_ptr = 0; /* password is null byte */
5079                 bcc_ptr++;              /* skip password */
5080                 /* already aligned so no need to do it below */
5081         } else {
5082                 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
5083                 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
5084                    specified as required (when that support is added to
5085                    the vfs in the future) as only NTLM or the much
5086                    weaker LANMAN (which we do not send by default) is accepted
5087                    by Samba (not sure whether other servers allow
5088                    NTLMv2 password here) */
5089 #ifdef CONFIG_CIFS_WEAK_PW_HASH
5090                 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
5091                     (ses->sectype == LANMAN))
5092                         calc_lanman_hash(tcon->password, ses->server->cryptkey,
5093                                          ses->server->sec_mode &
5094                                             SECMODE_PW_ENCRYPT ? true : false,
5095                                          bcc_ptr);
5096                 else
5097 #endif /* CIFS_WEAK_PW_HASH */
5098                 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
5099                                         bcc_ptr, nls_codepage);
5100                 if (rc) {
5101                         cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
5102                                  __func__, rc);
5103                         cifs_buf_release(smb_buffer);
5104                         return rc;
5105                 }
5106
5107                 bcc_ptr += CIFS_AUTH_RESP_SIZE;
5108                 if (ses->capabilities & CAP_UNICODE) {
5109                         /* must align unicode strings */
5110                         *bcc_ptr = 0; /* null byte password */
5111                         bcc_ptr++;
5112                 }
5113         }
5114
5115         if (ses->server->sign)
5116                 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
5117
5118         if (ses->capabilities & CAP_STATUS32) {
5119                 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
5120         }
5121         if (ses->capabilities & CAP_DFS) {
5122                 smb_buffer->Flags2 |= SMBFLG2_DFS;
5123         }
5124         if (ses->capabilities & CAP_UNICODE) {
5125                 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
5126                 length =
5127                     cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
5128                         6 /* max utf8 char length in bytes */ *
5129                         (/* server len*/ + 256 /* share len */), nls_codepage);
5130                 bcc_ptr += 2 * length;  /* convert num 16 bit words to bytes */
5131                 bcc_ptr += 2;   /* skip trailing null */
5132         } else {                /* ASCII */
5133                 strcpy(bcc_ptr, tree);
5134                 bcc_ptr += strlen(tree) + 1;
5135         }
5136         strcpy(bcc_ptr, "?????");
5137         bcc_ptr += strlen("?????");
5138         bcc_ptr += 1;
5139         count = bcc_ptr - &pSMB->Password[0];
5140         pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
5141                                         pSMB->hdr.smb_buf_length) + count);
5142         pSMB->ByteCount = cpu_to_le16(count);
5143
5144         rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
5145                          0);
5146
5147         /* above now done in SendReceive */
5148         if (rc == 0) {
5149                 bool is_unicode;
5150
5151                 tcon->tidStatus = CifsGood;
5152                 tcon->need_reconnect = false;
5153                 tcon->tid = smb_buffer_response->Tid;
5154                 bcc_ptr = pByteArea(smb_buffer_response);
5155                 bytes_left = get_bcc(smb_buffer_response);
5156                 length = strnlen(bcc_ptr, bytes_left - 2);
5157                 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
5158                         is_unicode = true;
5159                 else
5160                         is_unicode = false;
5161
5162
5163                 /* skip service field (NB: this field is always ASCII) */
5164                 if (length == 3) {
5165                         if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
5166                             (bcc_ptr[2] == 'C')) {
5167                                 cifs_dbg(FYI, "IPC connection\n");
5168                                 tcon->ipc = true;
5169                                 tcon->pipe = true;
5170                         }
5171                 } else if (length == 2) {
5172                         if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
5173                                 /* the most common case */
5174                                 cifs_dbg(FYI, "disk share connection\n");
5175                         }
5176                 }
5177                 bcc_ptr += length + 1;
5178                 bytes_left -= (length + 1);
5179                 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
5180
5181                 /* mostly informational -- no need to fail on error here */
5182                 kfree(tcon->nativeFileSystem);
5183                 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
5184                                                       bytes_left, is_unicode,
5185                                                       nls_codepage);
5186
5187                 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
5188
5189                 if ((smb_buffer_response->WordCount == 3) ||
5190                          (smb_buffer_response->WordCount == 7))
5191                         /* field is in same location */
5192                         tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
5193                 else
5194                         tcon->Flags = 0;
5195                 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
5196         }
5197
5198         cifs_buf_release(smb_buffer);
5199         return rc;
5200 }
5201
5202 static void delayed_free(struct rcu_head *p)
5203 {
5204         struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
5205         unload_nls(sbi->local_nls);
5206         kfree(sbi);
5207 }
5208
5209 void
5210 cifs_umount(struct cifs_sb_info *cifs_sb)
5211 {
5212         struct rb_root *root = &cifs_sb->tlink_tree;
5213         struct rb_node *node;
5214         struct tcon_link *tlink;
5215
5216         cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
5217
5218         spin_lock(&cifs_sb->tlink_tree_lock);
5219         while ((node = rb_first(root))) {
5220                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
5221                 cifs_get_tlink(tlink);
5222                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
5223                 rb_erase(node, root);
5224
5225                 spin_unlock(&cifs_sb->tlink_tree_lock);
5226                 cifs_put_tlink(tlink);
5227                 spin_lock(&cifs_sb->tlink_tree_lock);
5228         }
5229         spin_unlock(&cifs_sb->tlink_tree_lock);
5230
5231         kfree(cifs_sb->mountdata);
5232         kfree(cifs_sb->prepath);
5233 #ifdef CONFIG_CIFS_DFS_UPCALL
5234         dfs_cache_del_vol(cifs_sb->origin_fullpath);
5235         kfree(cifs_sb->origin_fullpath);
5236 #endif
5237         call_rcu(&cifs_sb->rcu, delayed_free);
5238 }
5239
5240 int
5241 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
5242 {
5243         int rc = 0;
5244         struct TCP_Server_Info *server = cifs_ses_server(ses);
5245
5246         if (!server->ops->need_neg || !server->ops->negotiate)
5247                 return -ENOSYS;
5248
5249         /* only send once per connect */
5250         if (!server->ops->need_neg(server))
5251                 return 0;
5252
5253         rc = server->ops->negotiate(xid, ses);
5254         if (rc == 0) {
5255                 spin_lock(&GlobalMid_Lock);
5256                 if (server->tcpStatus == CifsNeedNegotiate)
5257                         server->tcpStatus = CifsGood;
5258                 else
5259                         rc = -EHOSTDOWN;
5260                 spin_unlock(&GlobalMid_Lock);
5261         }
5262
5263         return rc;
5264 }
5265
5266 int
5267 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
5268                    struct nls_table *nls_info)
5269 {
5270         int rc = -ENOSYS;
5271         struct TCP_Server_Info *server = cifs_ses_server(ses);
5272
5273         if (!ses->binding) {
5274                 ses->capabilities = server->capabilities;
5275                 if (linuxExtEnabled == 0)
5276                         ses->capabilities &= (~server->vals->cap_unix);
5277
5278                 if (ses->auth_key.response) {
5279                         cifs_dbg(FYI, "Free previous auth_key.response = %p\n",
5280                                  ses->auth_key.response);
5281                         kfree(ses->auth_key.response);
5282                         ses->auth_key.response = NULL;
5283                         ses->auth_key.len = 0;
5284                 }
5285         }
5286
5287         cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
5288                  server->sec_mode, server->capabilities, server->timeAdj);
5289
5290         if (server->ops->sess_setup)
5291                 rc = server->ops->sess_setup(xid, ses, nls_info);
5292
5293         if (rc)
5294                 cifs_server_dbg(VFS, "Send error in SessSetup = %d\n", rc);
5295
5296         return rc;
5297 }
5298
5299 static int
5300 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
5301 {
5302         vol->sectype = ses->sectype;
5303
5304         /* krb5 is special, since we don't need username or pw */
5305         if (vol->sectype == Kerberos)
5306                 return 0;
5307
5308         return cifs_set_cifscreds(vol, ses);
5309 }
5310
5311 static struct cifs_tcon *
5312 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
5313 {
5314         int rc;
5315         struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
5316         struct cifs_ses *ses;
5317         struct cifs_tcon *tcon = NULL;
5318         struct smb_vol *vol_info;
5319
5320         vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
5321         if (vol_info == NULL)
5322                 return ERR_PTR(-ENOMEM);
5323
5324         vol_info->local_nls = cifs_sb->local_nls;
5325         vol_info->linux_uid = fsuid;
5326         vol_info->cred_uid = fsuid;
5327         vol_info->UNC = master_tcon->treeName;
5328         vol_info->retry = master_tcon->retry;
5329         vol_info->nocase = master_tcon->nocase;
5330         vol_info->nohandlecache = master_tcon->nohandlecache;
5331         vol_info->local_lease = master_tcon->local_lease;
5332         vol_info->no_linux_ext = !master_tcon->unix_ext;
5333         vol_info->sectype = master_tcon->ses->sectype;
5334         vol_info->sign = master_tcon->ses->sign;
5335
5336         rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
5337         if (rc) {
5338                 tcon = ERR_PTR(rc);
5339                 goto out;
5340         }
5341
5342         /* get a reference for the same TCP session */
5343         spin_lock(&cifs_tcp_ses_lock);
5344         ++master_tcon->ses->server->srv_count;
5345         spin_unlock(&cifs_tcp_ses_lock);
5346
5347         ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
5348         if (IS_ERR(ses)) {
5349                 tcon = (struct cifs_tcon *)ses;
5350                 cifs_put_tcp_session(master_tcon->ses->server, 0);
5351                 goto out;
5352         }
5353
5354         tcon = cifs_get_tcon(ses, vol_info);
5355         if (IS_ERR(tcon)) {
5356                 cifs_put_smb_ses(ses);
5357                 goto out;
5358         }
5359
5360         /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
5361         if (tcon->posix_extensions)
5362                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
5363
5364         if (cap_unix(ses))
5365                 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
5366
5367 out:
5368         kfree(vol_info->username);
5369         kzfree(vol_info->password);
5370         kfree(vol_info);
5371
5372         return tcon;
5373 }
5374
5375 struct cifs_tcon *
5376 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
5377 {
5378         return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
5379 }
5380
5381 /* find and return a tlink with given uid */
5382 static struct tcon_link *
5383 tlink_rb_search(struct rb_root *root, kuid_t uid)
5384 {
5385         struct rb_node *node = root->rb_node;
5386         struct tcon_link *tlink;
5387
5388         while (node) {
5389                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
5390
5391                 if (uid_gt(tlink->tl_uid, uid))
5392                         node = node->rb_left;
5393                 else if (uid_lt(tlink->tl_uid, uid))
5394                         node = node->rb_right;
5395                 else
5396                         return tlink;
5397         }
5398         return NULL;
5399 }
5400
5401 /* insert a tcon_link into the tree */
5402 static void
5403 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
5404 {
5405         struct rb_node **new = &(root->rb_node), *parent = NULL;
5406         struct tcon_link *tlink;
5407
5408         while (*new) {
5409                 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
5410                 parent = *new;
5411
5412                 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
5413                         new = &((*new)->rb_left);
5414                 else
5415                         new = &((*new)->rb_right);
5416         }
5417
5418         rb_link_node(&new_tlink->tl_rbnode, parent, new);
5419         rb_insert_color(&new_tlink->tl_rbnode, root);
5420 }
5421
5422 /*
5423  * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
5424  * current task.
5425  *
5426  * If the superblock doesn't refer to a multiuser mount, then just return
5427  * the master tcon for the mount.
5428  *
5429  * First, search the rbtree for an existing tcon for this fsuid. If one
5430  * exists, then check to see if it's pending construction. If it is then wait
5431  * for construction to complete. Once it's no longer pending, check to see if
5432  * it failed and either return an error or retry construction, depending on
5433  * the timeout.
5434  *
5435  * If one doesn't exist then insert a new tcon_link struct into the tree and
5436  * try to construct a new one.
5437  */
5438 struct tcon_link *
5439 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
5440 {
5441         int ret;
5442         kuid_t fsuid = current_fsuid();
5443         struct tcon_link *tlink, *newtlink;
5444
5445         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
5446                 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
5447
5448         spin_lock(&cifs_sb->tlink_tree_lock);
5449         tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
5450         if (tlink)
5451                 cifs_get_tlink(tlink);
5452         spin_unlock(&cifs_sb->tlink_tree_lock);
5453
5454         if (tlink == NULL) {
5455                 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
5456                 if (newtlink == NULL)
5457                         return ERR_PTR(-ENOMEM);
5458                 newtlink->tl_uid = fsuid;
5459                 newtlink->tl_tcon = ERR_PTR(-EACCES);
5460                 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
5461                 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
5462                 cifs_get_tlink(newtlink);
5463
5464                 spin_lock(&cifs_sb->tlink_tree_lock);
5465                 /* was one inserted after previous search? */
5466                 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
5467                 if (tlink) {
5468                         cifs_get_tlink(tlink);
5469                         spin_unlock(&cifs_sb->tlink_tree_lock);
5470                         kfree(newtlink);
5471                         goto wait_for_construction;
5472                 }
5473                 tlink = newtlink;
5474                 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
5475                 spin_unlock(&cifs_sb->tlink_tree_lock);
5476         } else {
5477 wait_for_construction:
5478                 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
5479                                   TASK_INTERRUPTIBLE);
5480                 if (ret) {
5481                         cifs_put_tlink(tlink);
5482                         return ERR_PTR(-ERESTARTSYS);
5483                 }
5484
5485                 /* if it's good, return it */
5486                 if (!IS_ERR(tlink->tl_tcon))
5487                         return tlink;
5488
5489                 /* return error if we tried this already recently */
5490                 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
5491                         cifs_put_tlink(tlink);
5492                         return ERR_PTR(-EACCES);
5493                 }
5494
5495                 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
5496                         goto wait_for_construction;
5497         }
5498
5499         tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
5500         clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
5501         wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
5502
5503         if (IS_ERR(tlink->tl_tcon)) {
5504                 cifs_put_tlink(tlink);
5505                 return ERR_PTR(-EACCES);
5506         }
5507
5508         return tlink;
5509 }
5510
5511 /*
5512  * periodic workqueue job that scans tcon_tree for a superblock and closes
5513  * out tcons.
5514  */
5515 static void
5516 cifs_prune_tlinks(struct work_struct *work)
5517 {
5518         struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
5519                                                     prune_tlinks.work);
5520         struct rb_root *root = &cifs_sb->tlink_tree;
5521         struct rb_node *node;
5522         struct rb_node *tmp;
5523         struct tcon_link *tlink;
5524
5525         /*
5526          * Because we drop the spinlock in the loop in order to put the tlink
5527          * it's not guarded against removal of links from the tree. The only
5528          * places that remove entries from the tree are this function and
5529          * umounts. Because this function is non-reentrant and is canceled
5530          * before umount can proceed, this is safe.
5531          */
5532         spin_lock(&cifs_sb->tlink_tree_lock);
5533         node = rb_first(root);
5534         while (node != NULL) {
5535                 tmp = node;
5536                 node = rb_next(tmp);
5537                 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
5538
5539                 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
5540                     atomic_read(&tlink->tl_count) != 0 ||
5541                     time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
5542                         continue;
5543
5544                 cifs_get_tlink(tlink);
5545                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
5546                 rb_erase(tmp, root);
5547
5548                 spin_unlock(&cifs_sb->tlink_tree_lock);
5549                 cifs_put_tlink(tlink);
5550                 spin_lock(&cifs_sb->tlink_tree_lock);
5551         }
5552         spin_unlock(&cifs_sb->tlink_tree_lock);
5553
5554         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
5555                                 TLINK_IDLE_EXPIRE);
5556 }