fs/cifs/connect.c

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