fs/cifs/connect.c

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