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