fs/cifs/connect.c

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