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