fs/cifs/connect.c

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