fs/cifs/connect.c

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