fs/cifs/connect.c

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