fs/cifs/connect.c

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