fs/cifs/connect.c

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