fs/cifs/connect.c

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