fs/cifs/connect.c

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