fs/cifs/connect.c

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