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 = -ENOMEM;
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         cifs_dbg(FYI, "Existing smb sess not found\n");
2645         ses = sesInfoAlloc();
2646         if (ses == NULL)
2647                 goto get_ses_fail;
2648
2649         /* new SMB session uses our server ref */
2650         ses->server = server;
2651         if (server->dstaddr.ss_family == AF_INET6)
2652                 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2653         else
2654                 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2655
2656         if (volume_info->username) {
2657                 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2658                 if (!ses->user_name)
2659                         goto get_ses_fail;
2660         }
2661
2662         /* volume_info->password freed at unmount */
2663         if (volume_info->password) {
2664                 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2665                 if (!ses->password)
2666                         goto get_ses_fail;
2667         }
2668         if (volume_info->domainname) {
2669                 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2670                 if (!ses->domainName)
2671                         goto get_ses_fail;
2672         }
2673         ses->cred_uid = volume_info->cred_uid;
2674         ses->linux_uid = volume_info->linux_uid;
2675
2676         ses->sectype = volume_info->sectype;
2677         ses->sign = volume_info->sign;
2678
2679         mutex_lock(&ses->session_mutex);
2680         rc = cifs_negotiate_protocol(xid, ses);
2681         if (!rc)
2682                 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2683         mutex_unlock(&ses->session_mutex);
2684         if (rc)
2685                 goto get_ses_fail;
2686
2687         /* success, put it on the list */
2688         spin_lock(&cifs_tcp_ses_lock);
2689         list_add(&ses->smb_ses_list, &server->smb_ses_list);
2690         spin_unlock(&cifs_tcp_ses_lock);
2691
2692         free_xid(xid);
2693         return ses;
2694
2695 get_ses_fail:
2696         sesInfoFree(ses);
2697         free_xid(xid);
2698         return ERR_PTR(rc);
2699 }
2700
2701 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2702 {
2703         if (tcon->tidStatus == CifsExiting)
2704                 return 0;
2705         if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2706                 return 0;
2707         return 1;
2708 }
2709
2710 static struct cifs_tcon *
2711 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2712 {
2713         struct list_head *tmp;
2714         struct cifs_tcon *tcon;
2715
2716         spin_lock(&cifs_tcp_ses_lock);
2717         list_for_each(tmp, &ses->tcon_list) {
2718                 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2719                 if (!match_tcon(tcon, unc))
2720                         continue;
2721                 ++tcon->tc_count;
2722                 spin_unlock(&cifs_tcp_ses_lock);
2723                 return tcon;
2724         }
2725         spin_unlock(&cifs_tcp_ses_lock);
2726         return NULL;
2727 }
2728
2729 void
2730 cifs_put_tcon(struct cifs_tcon *tcon)
2731 {
2732         unsigned int xid;
2733         struct cifs_ses *ses = tcon->ses;
2734
2735         cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2736         spin_lock(&cifs_tcp_ses_lock);
2737         if (--tcon->tc_count > 0) {
2738                 spin_unlock(&cifs_tcp_ses_lock);
2739                 return;
2740         }
2741
2742         list_del_init(&tcon->tcon_list);
2743         spin_unlock(&cifs_tcp_ses_lock);
2744
2745         xid = get_xid();
2746         if (ses->server->ops->tree_disconnect)
2747                 ses->server->ops->tree_disconnect(xid, tcon);
2748         _free_xid(xid);
2749
2750         cifs_fscache_release_super_cookie(tcon);
2751         tconInfoFree(tcon);
2752         cifs_put_smb_ses(ses);
2753 }
2754
2755 static struct cifs_tcon *
2756 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2757 {
2758         int rc, xid;
2759         struct cifs_tcon *tcon;
2760
2761         tcon = cifs_find_tcon(ses, volume_info->UNC);
2762         if (tcon) {
2763                 cifs_dbg(FYI, "Found match on UNC path\n");
2764                 /* existing tcon already has a reference */
2765                 cifs_put_smb_ses(ses);
2766                 if (tcon->seal != volume_info->seal)
2767                         cifs_dbg(VFS, "transport encryption setting conflicts with existing tid\n");
2768                 return tcon;
2769         }
2770
2771         if (!ses->server->ops->tree_connect) {
2772                 rc = -ENOSYS;
2773                 goto out_fail;
2774         }
2775
2776         tcon = tconInfoAlloc();
2777         if (tcon == NULL) {
2778                 rc = -ENOMEM;
2779                 goto out_fail;
2780         }
2781
2782         tcon->ses = ses;
2783         if (volume_info->password) {
2784                 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2785                 if (!tcon->password) {
2786                         rc = -ENOMEM;
2787                         goto out_fail;
2788                 }
2789         }
2790
2791         /*
2792          * BB Do we need to wrap session_mutex around this TCon call and Unix
2793          * SetFS as we do on SessSetup and reconnect?
2794          */
2795         xid = get_xid();
2796         rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2797                                             volume_info->local_nls);
2798         free_xid(xid);
2799         cifs_dbg(FYI, "Tcon rc = %d\n", rc);
2800         if (rc)
2801                 goto out_fail;
2802
2803         if (volume_info->nodfs) {
2804                 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2805                 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
2806         }
2807         tcon->seal = volume_info->seal;
2808         tcon->use_persistent = false;
2809         /* check if SMB2 or later, CIFS does not support persistent handles */
2810         if (volume_info->persistent) {
2811                 if (ses->server->vals->protocol_id == 0) {
2812                         cifs_dbg(VFS,
2813                              "SMB3 or later required for persistent handles\n");
2814                         rc = -EOPNOTSUPP;
2815                         goto out_fail;
2816 #ifdef CONFIG_CIFS_SMB2
2817                 } else if (ses->server->capabilities &
2818                            SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2819                         tcon->use_persistent = true;
2820                 else /* persistent handles requested but not supported */ {
2821                         cifs_dbg(VFS,
2822                                 "Persistent handles not supported on share\n");
2823                         rc = -EOPNOTSUPP;
2824                         goto out_fail;
2825 #endif /* CONFIG_CIFS_SMB2 */
2826                 }
2827 #ifdef CONFIG_CIFS_SMB2
2828         } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
2829              && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2830              && (volume_info->nopersistent == false)) {
2831                 cifs_dbg(FYI, "enabling persistent handles\n");
2832                 tcon->use_persistent = true;
2833 #endif /* CONFIG_CIFS_SMB2 */
2834         } else if (volume_info->resilient) {
2835                 if (ses->server->vals->protocol_id == 0) {
2836                         cifs_dbg(VFS,
2837                              "SMB2.1 or later required for resilient handles\n");
2838                         rc = -EOPNOTSUPP;
2839                         goto out_fail;
2840                 }
2841                 tcon->use_resilient = true;
2842         }
2843
2844         /*
2845          * We can have only one retry value for a connection to a share so for
2846          * resources mounted more than once to the same server share the last
2847          * value passed in for the retry flag is used.
2848          */
2849         tcon->retry = volume_info->retry;
2850         tcon->nocase = volume_info->nocase;
2851         tcon->local_lease = volume_info->local_lease;
2852         INIT_LIST_HEAD(&tcon->pending_opens);
2853
2854         spin_lock(&cifs_tcp_ses_lock);
2855         list_add(&tcon->tcon_list, &ses->tcon_list);
2856         spin_unlock(&cifs_tcp_ses_lock);
2857
2858         cifs_fscache_get_super_cookie(tcon);
2859
2860         return tcon;
2861
2862 out_fail:
2863         tconInfoFree(tcon);
2864         return ERR_PTR(rc);
2865 }
2866
2867 void
2868 cifs_put_tlink(struct tcon_link *tlink)
2869 {
2870         if (!tlink || IS_ERR(tlink))
2871                 return;
2872
2873         if (!atomic_dec_and_test(&tlink->tl_count) ||
2874             test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2875                 tlink->tl_time = jiffies;
2876                 return;
2877         }
2878
2879         if (!IS_ERR(tlink_tcon(tlink)))
2880                 cifs_put_tcon(tlink_tcon(tlink));
2881         kfree(tlink);
2882         return;
2883 }
2884
2885 static inline struct tcon_link *
2886 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2887 {
2888         return cifs_sb->master_tlink;
2889 }
2890
2891 static int
2892 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2893 {
2894         struct cifs_sb_info *old = CIFS_SB(sb);
2895         struct cifs_sb_info *new = mnt_data->cifs_sb;
2896
2897         if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2898                 return 0;
2899
2900         if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2901             (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2902                 return 0;
2903
2904         /*
2905          * We want to share sb only if we don't specify an r/wsize or
2906          * specified r/wsize is greater than or equal to existing one.
2907          */
2908         if (new->wsize && new->wsize < old->wsize)
2909                 return 0;
2910
2911         if (new->rsize && new->rsize < old->rsize)
2912                 return 0;
2913
2914         if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
2915                 return 0;
2916
2917         if (old->mnt_file_mode != new->mnt_file_mode ||
2918             old->mnt_dir_mode != new->mnt_dir_mode)
2919                 return 0;
2920
2921         if (strcmp(old->local_nls->charset, new->local_nls->charset))
2922                 return 0;
2923
2924         if (old->actimeo != new->actimeo)
2925                 return 0;
2926
2927         return 1;
2928 }
2929
2930 static int
2931 match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2932 {
2933         struct cifs_sb_info *old = CIFS_SB(sb);
2934         struct cifs_sb_info *new = mnt_data->cifs_sb;
2935         bool old_set = (old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) &&
2936                 old->prepath;
2937         bool new_set = (new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) &&
2938                 new->prepath;
2939
2940         if (old_set && new_set && !strcmp(new->prepath, old->prepath))
2941                 return 1;
2942         else if (!old_set && !new_set)
2943                 return 1;
2944
2945         return 0;
2946 }
2947
2948 int
2949 cifs_match_super(struct super_block *sb, void *data)
2950 {
2951         struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2952         struct smb_vol *volume_info;
2953         struct cifs_sb_info *cifs_sb;
2954         struct TCP_Server_Info *tcp_srv;
2955         struct cifs_ses *ses;
2956         struct cifs_tcon *tcon;
2957         struct tcon_link *tlink;
2958         int rc = 0;
2959
2960         spin_lock(&cifs_tcp_ses_lock);
2961         cifs_sb = CIFS_SB(sb);
2962         tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2963         if (tlink == NULL) {
2964                 /* can not match superblock if tlink were ever null */
2965                 spin_unlock(&cifs_tcp_ses_lock);
2966                 return 0;
2967         }
2968         tcon = tlink_tcon(tlink);
2969         ses = tcon->ses;
2970         tcp_srv = ses->server;
2971
2972         volume_info = mnt_data->vol;
2973
2974         if (!match_server(tcp_srv, volume_info) ||
2975             !match_session(ses, volume_info) ||
2976             !match_tcon(tcon, volume_info->UNC) ||
2977             !match_prepath(sb, mnt_data)) {
2978                 rc = 0;
2979                 goto out;
2980         }
2981
2982         rc = compare_mount_options(sb, mnt_data);
2983 out:
2984         spin_unlock(&cifs_tcp_ses_lock);
2985         cifs_put_tlink(tlink);
2986         return rc;
2987 }
2988
2989 int
2990 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2991              const struct nls_table *nls_codepage, unsigned int *num_referrals,
2992              struct dfs_info3_param **referrals, int remap)
2993 {
2994         char *temp_unc;
2995         int rc = 0;
2996
2997         if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2998                 return -ENOSYS;
2999
3000         *num_referrals = 0;
3001         *referrals = NULL;
3002
3003         if (ses->ipc_tid == 0) {
3004                 temp_unc = kmalloc(2 /* for slashes */ +
3005                         strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
3006                                 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
3007                 if (temp_unc == NULL)
3008                         return -ENOMEM;
3009                 temp_unc[0] = '\\';
3010                 temp_unc[1] = '\\';
3011                 strcpy(temp_unc + 2, ses->serverName);
3012                 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
3013                 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
3014                                                     nls_codepage);
3015                 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
3016                 kfree(temp_unc);
3017         }
3018         if (rc == 0)
3019                 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
3020                                                      referrals, num_referrals,
3021                                                      nls_codepage, remap);
3022         /*
3023          * BB - map targetUNCs to dfs_info3 structures, here or in
3024          * ses->server->ops->get_dfs_refer.
3025          */
3026
3027         return rc;
3028 }
3029
3030 #ifdef CONFIG_DEBUG_LOCK_ALLOC
3031 static struct lock_class_key cifs_key[2];
3032 static struct lock_class_key cifs_slock_key[2];
3033
3034 static inline void
3035 cifs_reclassify_socket4(struct socket *sock)
3036 {
3037         struct sock *sk = sock->sk;
3038         BUG_ON(!sock_allow_reclassification(sk));
3039         sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
3040                 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
3041 }
3042
3043 static inline void
3044 cifs_reclassify_socket6(struct socket *sock)
3045 {
3046         struct sock *sk = sock->sk;
3047         BUG_ON(!sock_allow_reclassification(sk));
3048         sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
3049                 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
3050 }
3051 #else
3052 static inline void
3053 cifs_reclassify_socket4(struct socket *sock)
3054 {
3055 }
3056
3057 static inline void
3058 cifs_reclassify_socket6(struct socket *sock)
3059 {
3060 }
3061 #endif
3062
3063 /* See RFC1001 section 14 on representation of Netbios names */
3064 static void rfc1002mangle(char *target, char *source, unsigned int length)
3065 {
3066         unsigned int i, j;
3067
3068         for (i = 0, j = 0; i < (length); i++) {
3069                 /* mask a nibble at a time and encode */
3070                 target[j] = 'A' + (0x0F & (source[i] >> 4));
3071                 target[j+1] = 'A' + (0x0F & source[i]);
3072                 j += 2;
3073         }
3074
3075 }
3076
3077 static int
3078 bind_socket(struct TCP_Server_Info *server)
3079 {
3080         int rc = 0;
3081         if (server->srcaddr.ss_family != AF_UNSPEC) {
3082                 /* Bind to the specified local IP address */
3083                 struct socket *socket = server->ssocket;
3084                 rc = socket->ops->bind(socket,
3085                                        (struct sockaddr *) &server->srcaddr,
3086                                        sizeof(server->srcaddr));
3087                 if (rc < 0) {
3088                         struct sockaddr_in *saddr4;
3089                         struct sockaddr_in6 *saddr6;
3090                         saddr4 = (struct sockaddr_in *)&server->srcaddr;
3091                         saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
3092                         if (saddr6->sin6_family == AF_INET6)
3093                                 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
3094                                          &saddr6->sin6_addr, rc);
3095                         else
3096                                 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
3097                                          &saddr4->sin_addr.s_addr, rc);
3098                 }
3099         }
3100         return rc;
3101 }
3102
3103 static int
3104 ip_rfc1001_connect(struct TCP_Server_Info *server)
3105 {
3106         int rc = 0;
3107         /*
3108          * some servers require RFC1001 sessinit before sending
3109          * negprot - BB check reconnection in case where second
3110          * sessinit is sent but no second negprot
3111          */
3112         struct rfc1002_session_packet *ses_init_buf;
3113         struct smb_hdr *smb_buf;
3114         ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
3115                                GFP_KERNEL);
3116         if (ses_init_buf) {
3117                 ses_init_buf->trailer.session_req.called_len = 32;
3118
3119                 if (server->server_RFC1001_name[0] != 0)
3120                         rfc1002mangle(ses_init_buf->trailer.
3121                                       session_req.called_name,
3122                                       server->server_RFC1001_name,
3123                                       RFC1001_NAME_LEN_WITH_NULL);
3124                 else
3125                         rfc1002mangle(ses_init_buf->trailer.
3126                                       session_req.called_name,
3127                                       DEFAULT_CIFS_CALLED_NAME,
3128                                       RFC1001_NAME_LEN_WITH_NULL);
3129
3130                 ses_init_buf->trailer.session_req.calling_len = 32;
3131
3132                 /*
3133                  * calling name ends in null (byte 16) from old smb
3134                  * convention.
3135                  */
3136                 if (server->workstation_RFC1001_name[0] != 0)
3137                         rfc1002mangle(ses_init_buf->trailer.
3138                                       session_req.calling_name,
3139                                       server->workstation_RFC1001_name,
3140                                       RFC1001_NAME_LEN_WITH_NULL);
3141                 else
3142                         rfc1002mangle(ses_init_buf->trailer.
3143                                       session_req.calling_name,
3144                                       "LINUX_CIFS_CLNT",
3145                                       RFC1001_NAME_LEN_WITH_NULL);
3146
3147                 ses_init_buf->trailer.session_req.scope1 = 0;
3148                 ses_init_buf->trailer.session_req.scope2 = 0;
3149                 smb_buf = (struct smb_hdr *)ses_init_buf;
3150
3151                 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3152                 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3153                 rc = smb_send(server, smb_buf, 0x44);
3154                 kfree(ses_init_buf);
3155                 /*
3156                  * RFC1001 layer in at least one server
3157                  * requires very short break before negprot
3158                  * presumably because not expecting negprot
3159                  * to follow so fast.  This is a simple
3160                  * solution that works without
3161                  * complicating the code and causes no
3162                  * significant slowing down on mount
3163                  * for everyone else
3164                  */
3165                 usleep_range(1000, 2000);
3166         }
3167         /*
3168          * else the negprot may still work without this
3169          * even though malloc failed
3170          */
3171
3172         return rc;
3173 }
3174
3175 static int
3176 generic_ip_connect(struct TCP_Server_Info *server)
3177 {
3178         int rc = 0;
3179         __be16 sport;
3180         int slen, sfamily;
3181         struct socket *socket = server->ssocket;
3182         struct sockaddr *saddr;
3183
3184         saddr = (struct sockaddr *) &server->dstaddr;
3185
3186         if (server->dstaddr.ss_family == AF_INET6) {
3187                 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3188                 slen = sizeof(struct sockaddr_in6);
3189                 sfamily = AF_INET6;
3190         } else {
3191                 sport = ((struct sockaddr_in *) saddr)->sin_port;
3192                 slen = sizeof(struct sockaddr_in);
3193                 sfamily = AF_INET;
3194         }
3195
3196         if (socket == NULL) {
3197                 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3198                                    IPPROTO_TCP, &socket, 1);
3199                 if (rc < 0) {
3200                         cifs_dbg(VFS, "Error %d creating socket\n", rc);
3201                         server->ssocket = NULL;
3202                         return rc;
3203                 }
3204
3205                 /* BB other socket options to set KEEPALIVE, NODELAY? */
3206                 cifs_dbg(FYI, "Socket created\n");
3207                 server->ssocket = socket;
3208                 socket->sk->sk_allocation = GFP_NOFS;
3209                 if (sfamily == AF_INET6)
3210                         cifs_reclassify_socket6(socket);
3211                 else
3212                         cifs_reclassify_socket4(socket);
3213         }
3214
3215         rc = bind_socket(server);
3216         if (rc < 0)
3217                 return rc;
3218
3219         /*
3220          * Eventually check for other socket options to change from
3221          * the default. sock_setsockopt not used because it expects
3222          * user space buffer
3223          */
3224         socket->sk->sk_rcvtimeo = 7 * HZ;
3225         socket->sk->sk_sndtimeo = 5 * HZ;
3226
3227         /* make the bufsizes depend on wsize/rsize and max requests */
3228         if (server->noautotune) {
3229                 if (socket->sk->sk_sndbuf < (200 * 1024))
3230                         socket->sk->sk_sndbuf = 200 * 1024;
3231                 if (socket->sk->sk_rcvbuf < (140 * 1024))
3232                         socket->sk->sk_rcvbuf = 140 * 1024;
3233         }
3234
3235         if (server->tcp_nodelay) {
3236                 int val = 1;
3237                 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3238                                 (char *)&val, sizeof(val));
3239                 if (rc)
3240                         cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3241                                  rc);
3242         }
3243
3244         cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3245                  socket->sk->sk_sndbuf,
3246                  socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3247
3248         rc = socket->ops->connect(socket, saddr, slen, 0);
3249         if (rc < 0) {
3250                 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3251                 sock_release(socket);
3252                 server->ssocket = NULL;
3253                 return rc;
3254         }
3255
3256         if (sport == htons(RFC1001_PORT))
3257                 rc = ip_rfc1001_connect(server);
3258
3259         return rc;
3260 }
3261
3262 static int
3263 ip_connect(struct TCP_Server_Info *server)
3264 {
3265         __be16 *sport;
3266         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3267         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3268
3269         if (server->dstaddr.ss_family == AF_INET6)
3270                 sport = &addr6->sin6_port;
3271         else
3272                 sport = &addr->sin_port;
3273
3274         if (*sport == 0) {
3275                 int rc;
3276
3277                 /* try with 445 port at first */
3278                 *sport = htons(CIFS_PORT);
3279
3280                 rc = generic_ip_connect(server);
3281                 if (rc >= 0)
3282                         return rc;
3283
3284                 /* if it failed, try with 139 port */
3285                 *sport = htons(RFC1001_PORT);
3286         }
3287
3288         return generic_ip_connect(server);
3289 }
3290
3291 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3292                           struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3293 {
3294         /* if we are reconnecting then should we check to see if
3295          * any requested capabilities changed locally e.g. via
3296          * remount but we can not do much about it here
3297          * if they have (even if we could detect it by the following)
3298          * Perhaps we could add a backpointer to array of sb from tcon
3299          * or if we change to make all sb to same share the same
3300          * sb as NFS - then we only have one backpointer to sb.
3301          * What if we wanted to mount the server share twice once with
3302          * and once without posixacls or posix paths? */
3303         __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3304
3305         if (vol_info && vol_info->no_linux_ext) {
3306                 tcon->fsUnixInfo.Capability = 0;
3307                 tcon->unix_ext = 0; /* Unix Extensions disabled */
3308                 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3309                 return;
3310         } else if (vol_info)
3311                 tcon->unix_ext = 1; /* Unix Extensions supported */
3312
3313         if (tcon->unix_ext == 0) {
3314                 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3315                 return;
3316         }
3317
3318         if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3319                 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3320                 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3321                 /* check for reconnect case in which we do not
3322                    want to change the mount behavior if we can avoid it */
3323                 if (vol_info == NULL) {
3324                         /* turn off POSIX ACL and PATHNAMES if not set
3325                            originally at mount time */
3326                         if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3327                                 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3328                         if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3329                                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3330                                         cifs_dbg(VFS, "POSIXPATH support change\n");
3331                                 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3332                         } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3333                                 cifs_dbg(VFS, "possible reconnect error\n");
3334                                 cifs_dbg(VFS, "server disabled POSIX path support\n");
3335                         }
3336                 }
3337
3338                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3339                         cifs_dbg(VFS, "per-share encryption not supported yet\n");
3340
3341                 cap &= CIFS_UNIX_CAP_MASK;
3342                 if (vol_info && vol_info->no_psx_acl)
3343                         cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3344                 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3345                         cifs_dbg(FYI, "negotiated posix acl support\n");
3346                         if (cifs_sb)
3347                                 cifs_sb->mnt_cifs_flags |=
3348                                         CIFS_MOUNT_POSIXACL;
3349                 }
3350
3351                 if (vol_info && vol_info->posix_paths == 0)
3352                         cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3353                 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3354                         cifs_dbg(FYI, "negotiate posix pathnames\n");
3355                         if (cifs_sb)
3356                                 cifs_sb->mnt_cifs_flags |=
3357                                         CIFS_MOUNT_POSIX_PATHS;
3358                 }
3359
3360                 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3361 #ifdef CONFIG_CIFS_DEBUG2
3362                 if (cap & CIFS_UNIX_FCNTL_CAP)
3363                         cifs_dbg(FYI, "FCNTL cap\n");
3364                 if (cap & CIFS_UNIX_EXTATTR_CAP)
3365                         cifs_dbg(FYI, "EXTATTR cap\n");
3366                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3367                         cifs_dbg(FYI, "POSIX path cap\n");
3368                 if (cap & CIFS_UNIX_XATTR_CAP)
3369                         cifs_dbg(FYI, "XATTR cap\n");
3370                 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3371                         cifs_dbg(FYI, "POSIX ACL cap\n");
3372                 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3373                         cifs_dbg(FYI, "very large read cap\n");
3374                 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3375                         cifs_dbg(FYI, "very large write cap\n");
3376                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3377                         cifs_dbg(FYI, "transport encryption cap\n");
3378                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3379                         cifs_dbg(FYI, "mandatory transport encryption cap\n");
3380 #endif /* CIFS_DEBUG2 */
3381                 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3382                         if (vol_info == NULL) {
3383                                 cifs_dbg(FYI, "resetting capabilities failed\n");
3384                         } else
3385                                 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");
3386
3387                 }
3388         }
3389 }
3390
3391 int cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3392                         struct cifs_sb_info *cifs_sb)
3393 {
3394         INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3395
3396         spin_lock_init(&cifs_sb->tlink_tree_lock);
3397         cifs_sb->tlink_tree = RB_ROOT;
3398
3399         /*
3400          * Temporarily set r/wsize for matching superblock. If we end up using
3401          * new sb then client will later negotiate it downward if needed.
3402          */
3403         cifs_sb->rsize = pvolume_info->rsize;
3404         cifs_sb->wsize = pvolume_info->wsize;
3405
3406         cifs_sb->mnt_uid = pvolume_info->linux_uid;
3407         cifs_sb->mnt_gid = pvolume_info->linux_gid;
3408         cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3409         cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3410         cifs_dbg(FYI, "file mode: %04ho  dir mode: %04ho\n",
3411                  cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3412
3413         cifs_sb->actimeo = pvolume_info->actimeo;
3414         cifs_sb->local_nls = pvolume_info->local_nls;
3415
3416         if (pvolume_info->noperm)
3417                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3418         if (pvolume_info->setuids)
3419                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3420         if (pvolume_info->setuidfromacl)
3421                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
3422         if (pvolume_info->server_ino)
3423                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3424         if (pvolume_info->remap)
3425                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3426         if (pvolume_info->sfu_remap)
3427                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3428         if (pvolume_info->no_xattr)
3429                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3430         if (pvolume_info->sfu_emul)
3431                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3432         if (pvolume_info->nobrl)
3433                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3434         if (pvolume_info->nostrictsync)
3435                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3436         if (pvolume_info->mand_lock)
3437                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3438         if (pvolume_info->rwpidforward)
3439                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3440         if (pvolume_info->cifs_acl)
3441                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3442         if (pvolume_info->backupuid_specified) {
3443                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3444                 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3445         }
3446         if (pvolume_info->backupgid_specified) {
3447                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3448                 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3449         }
3450         if (pvolume_info->override_uid)
3451                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3452         if (pvolume_info->override_gid)
3453                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3454         if (pvolume_info->dynperm)
3455                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3456         if (pvolume_info->fsc)
3457                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3458         if (pvolume_info->multiuser)
3459                 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3460                                             CIFS_MOUNT_NO_PERM);
3461         if (pvolume_info->strict_io)
3462                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3463         if (pvolume_info->direct_io) {
3464                 cifs_dbg(FYI, "mounting share using direct i/o\n");
3465                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3466         }
3467         if (pvolume_info->mfsymlinks) {
3468                 if (pvolume_info->sfu_emul) {
3469                         /*
3470                          * Our SFU ("Services for Unix" emulation does not allow
3471                          * creating symlinks but does allow reading existing SFU
3472                          * symlinks (it does allow both creating and reading SFU
3473                          * style mknod and FIFOs though). When "mfsymlinks" and
3474                          * "sfu" are both enabled at the same time, it allows
3475                          * reading both types of symlinks, but will only create
3476                          * them with mfsymlinks format. This allows better
3477                          * Apple compatibility (probably better for Samba too)
3478                          * while still recognizing old Windows style symlinks.
3479                          */
3480                         cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
3481                 }
3482                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3483         }
3484
3485         if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3486                 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
3487
3488         if (pvolume_info->prepath) {
3489                 cifs_sb->prepath = kstrdup(pvolume_info->prepath, GFP_KERNEL);
3490                 if (cifs_sb->prepath == NULL)
3491                         return -ENOMEM;
3492         }
3493
3494         return 0;
3495 }
3496
3497 static void
3498 cleanup_volume_info_contents(struct smb_vol *volume_info)
3499 {
3500         kfree(volume_info->username);
3501         kzfree(volume_info->password);
3502         kfree(volume_info->UNC);
3503         kfree(volume_info->domainname);
3504         kfree(volume_info->iocharset);
3505         kfree(volume_info->prepath);
3506 }
3507
3508 void
3509 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3510 {
3511         if (!volume_info)
3512                 return;
3513         cleanup_volume_info_contents(volume_info);
3514         kfree(volume_info);
3515 }
3516
3517
3518 #ifdef CONFIG_CIFS_DFS_UPCALL
3519 /*
3520  * cifs_build_path_to_root returns full path to root when we do not have an
3521  * exiting connection (tcon)
3522  */
3523 static char *
3524 build_unc_path_to_root(const struct smb_vol *vol,
3525                 const struct cifs_sb_info *cifs_sb)
3526 {
3527         char *full_path, *pos;
3528         unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
3529         unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3530
3531         full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3532         if (full_path == NULL)
3533                 return ERR_PTR(-ENOMEM);
3534
3535         strncpy(full_path, vol->UNC, unc_len);
3536         pos = full_path + unc_len;
3537
3538         if (pplen) {
3539                 *pos = CIFS_DIR_SEP(cifs_sb);
3540                 strncpy(pos + 1, vol->prepath, pplen);
3541                 pos += pplen;
3542         }
3543
3544         *pos = '\0'; /* add trailing null */
3545         convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3546         cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
3547         return full_path;
3548 }
3549
3550 /*
3551  * Perform a dfs referral query for a share and (optionally) prefix
3552  *
3553  * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3554  * to a string containing updated options for the submount.  Otherwise it
3555  * will be left untouched.
3556  *
3557  * Returns the rc from get_dfs_path to the caller, which can be used to
3558  * determine whether there were referrals.
3559  */
3560 static int
3561 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
3562                     struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3563                     int check_prefix)
3564 {
3565         int rc;
3566         unsigned int num_referrals = 0;
3567         struct dfs_info3_param *referrals = NULL;
3568         char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3569
3570         full_path = build_unc_path_to_root(volume_info, cifs_sb);
3571         if (IS_ERR(full_path))
3572                 return PTR_ERR(full_path);
3573
3574         /* For DFS paths, skip the first '\' of the UNC */
3575         ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3576
3577         rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
3578                           &num_referrals, &referrals, cifs_remap(cifs_sb));
3579
3580         if (!rc && num_referrals > 0) {
3581                 char *fake_devname = NULL;
3582
3583                 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3584                                                    full_path + 1, referrals,
3585                                                    &fake_devname);
3586
3587                 free_dfs_info_array(referrals, num_referrals);
3588
3589                 if (IS_ERR(mdata)) {
3590                         rc = PTR_ERR(mdata);
3591                         mdata = NULL;
3592                 } else {
3593                         cleanup_volume_info_contents(volume_info);
3594                         rc = cifs_setup_volume_info(volume_info, mdata,
3595                                                         fake_devname);
3596                 }
3597                 kfree(fake_devname);
3598                 kfree(cifs_sb->mountdata);
3599                 cifs_sb->mountdata = mdata;
3600         }
3601         kfree(full_path);
3602         return rc;
3603 }
3604 #endif
3605
3606 static int
3607 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3608                         const char *devname)
3609 {
3610         int rc = 0;
3611
3612         if (cifs_parse_mount_options(mount_data, devname, volume_info))
3613                 return -EINVAL;
3614
3615         if (volume_info->nullauth) {
3616                 cifs_dbg(FYI, "Anonymous login\n");
3617                 kfree(volume_info->username);
3618                 volume_info->username = NULL;
3619         } else if (volume_info->username) {
3620                 /* BB fixme parse for domain name here */
3621                 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
3622         } else {
3623                 cifs_dbg(VFS, "No username specified\n");
3624         /* In userspace mount helper we can get user name from alternate
3625            locations such as env variables and files on disk */
3626                 return -EINVAL;
3627         }
3628
3629         /* this is needed for ASCII cp to Unicode converts */
3630         if (volume_info->iocharset == NULL) {
3631                 /* load_nls_default cannot return null */
3632                 volume_info->local_nls = load_nls_default();
3633         } else {
3634                 volume_info->local_nls = load_nls(volume_info->iocharset);
3635                 if (volume_info->local_nls == NULL) {
3636                         cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
3637                                  volume_info->iocharset);
3638                         return -ELIBACC;
3639                 }
3640         }
3641
3642         return rc;
3643 }
3644
3645 struct smb_vol *
3646 cifs_get_volume_info(char *mount_data, const char *devname)
3647 {
3648         int rc;
3649         struct smb_vol *volume_info;
3650
3651         volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
3652         if (!volume_info)
3653                 return ERR_PTR(-ENOMEM);
3654
3655         rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3656         if (rc) {
3657                 cifs_cleanup_volume_info(volume_info);
3658                 volume_info = ERR_PTR(rc);
3659         }
3660
3661         return volume_info;
3662 }
3663
3664 static int
3665 cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
3666                                         unsigned int xid,
3667                                         struct cifs_tcon *tcon,
3668                                         struct cifs_sb_info *cifs_sb,
3669                                         char *full_path)
3670 {
3671         int rc;
3672         char *s;
3673         char sep, tmp;
3674
3675         sep = CIFS_DIR_SEP(cifs_sb);
3676         s = full_path;
3677
3678         rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
3679         while (rc == 0) {
3680                 /* skip separators */
3681                 while (*s == sep)
3682                         s++;
3683                 if (!*s)
3684                         break;
3685                 /* next separator */
3686                 while (*s && *s != sep)
3687                         s++;
3688
3689                 /*
3690                  * temporarily null-terminate the path at the end of
3691                  * the current component
3692                  */
3693                 tmp = *s;
3694                 *s = 0;
3695                 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3696                                                      full_path);
3697                 *s = tmp;
3698         }
3699         return rc;
3700 }
3701
3702 int
3703 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3704 {
3705         int rc;
3706         unsigned int xid;
3707         struct cifs_ses *ses;
3708         struct cifs_tcon *tcon;
3709         struct TCP_Server_Info *server;
3710         char   *full_path;
3711         struct tcon_link *tlink;
3712 #ifdef CONFIG_CIFS_DFS_UPCALL
3713         int referral_walks_count = 0;
3714 #endif
3715
3716         rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs");
3717         if (rc)
3718                 return rc;
3719
3720 #ifdef CONFIG_CIFS_DFS_UPCALL
3721 try_mount_again:
3722         /* cleanup activities if we're chasing a referral */
3723         if (referral_walks_count) {
3724                 if (tcon)
3725                         cifs_put_tcon(tcon);
3726                 else if (ses)
3727                         cifs_put_smb_ses(ses);
3728
3729                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
3730
3731                 free_xid(xid);
3732         }
3733 #endif
3734         rc = 0;
3735         tcon = NULL;
3736         ses = NULL;
3737         server = NULL;
3738         full_path = NULL;
3739         tlink = NULL;
3740
3741         xid = get_xid();
3742
3743         /* get a reference to a tcp session */
3744         server = cifs_get_tcp_session(volume_info);
3745         if (IS_ERR(server)) {
3746                 rc = PTR_ERR(server);
3747                 bdi_destroy(&cifs_sb->bdi);
3748                 goto out;
3749         }
3750         if ((volume_info->max_credits < 20) ||
3751              (volume_info->max_credits > 60000))
3752                 server->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
3753         else
3754                 server->max_credits = volume_info->max_credits;
3755         /* get a reference to a SMB session */
3756         ses = cifs_get_smb_ses(server, volume_info);
3757         if (IS_ERR(ses)) {
3758                 rc = PTR_ERR(ses);
3759                 ses = NULL;
3760                 goto mount_fail_check;
3761         }
3762
3763 #ifdef CONFIG_CIFS_SMB2
3764         if ((volume_info->persistent == true) && ((ses->server->capabilities &
3765                 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES) == 0)) {
3766                 cifs_dbg(VFS, "persistent handles not supported by server\n");
3767                 rc = -EOPNOTSUPP;
3768                 goto mount_fail_check;
3769         }
3770 #endif /* CONFIG_CIFS_SMB2*/
3771
3772         /* search for existing tcon to this server share */
3773         tcon = cifs_get_tcon(ses, volume_info);
3774         if (IS_ERR(tcon)) {
3775                 rc = PTR_ERR(tcon);
3776                 tcon = NULL;
3777                 goto remote_path_check;
3778         }
3779
3780         /* tell server which Unix caps we support */
3781         if (cap_unix(tcon->ses)) {
3782                 /* reset of caps checks mount to see if unix extensions
3783                    disabled for just this mount */
3784                 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3785                 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3786                     (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3787                      CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3788                         rc = -EACCES;
3789                         goto mount_fail_check;
3790                 }
3791         } else
3792                 tcon->unix_ext = 0; /* server does not support them */
3793
3794         /* do not care if a following call succeed - informational */
3795         if (!tcon->ipc && server->ops->qfs_tcon)
3796                 server->ops->qfs_tcon(xid, tcon);
3797
3798         cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3799         cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
3800
3801         /* tune readahead according to rsize */
3802         cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_SIZE;
3803
3804 remote_path_check:
3805 #ifdef CONFIG_CIFS_DFS_UPCALL
3806         /*
3807          * Perform an unconditional check for whether there are DFS
3808          * referrals for this path without prefix, to provide support
3809          * for DFS referrals from w2k8 servers which don't seem to respond
3810          * with PATH_NOT_COVERED to requests that include the prefix.
3811          * Chase the referral if found, otherwise continue normally.
3812          */
3813         if (referral_walks_count == 0) {
3814                 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3815                                                 false);
3816                 if (!refrc) {
3817                         referral_walks_count++;
3818                         goto try_mount_again;
3819                 }
3820         }
3821 #endif
3822
3823         /* check if a whole path is not remote */
3824         if (!rc && tcon) {
3825                 if (!server->ops->is_path_accessible) {
3826                         rc = -ENOSYS;
3827                         goto mount_fail_check;
3828                 }
3829                 /*
3830                  * cifs_build_path_to_root works only when we have a valid tcon
3831                  */
3832                 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3833                 if (full_path == NULL) {
3834                         rc = -ENOMEM;
3835                         goto mount_fail_check;
3836                 }
3837                 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3838                                                      full_path);
3839                 if (rc != 0 && rc != -EREMOTE) {
3840                         kfree(full_path);
3841                         goto mount_fail_check;
3842                 }
3843
3844                 if (rc != -EREMOTE) {
3845                         rc = cifs_are_all_path_components_accessible(server,
3846                                                              xid, tcon, cifs_sb,
3847                                                              full_path);
3848                         if (rc != 0) {
3849                                 cifs_dbg(VFS, "cannot query dirs between root and final path, "
3850                                          "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
3851                                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
3852                                 rc = 0;
3853                         }
3854                 }
3855                 kfree(full_path);
3856         }
3857
3858         /* get referral if needed */
3859         if (rc == -EREMOTE) {
3860 #ifdef CONFIG_CIFS_DFS_UPCALL
3861                 if (referral_walks_count > MAX_NESTED_LINKS) {
3862                         /*
3863                          * BB: when we implement proper loop detection,
3864                          *     we will remove this check. But now we need it
3865                          *     to prevent an indefinite loop if 'DFS tree' is
3866                          *     misconfigured (i.e. has loops).
3867                          */
3868                         rc = -ELOOP;
3869                         goto mount_fail_check;
3870                 }
3871
3872                 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
3873
3874                 if (!rc) {
3875                         referral_walks_count++;
3876                         goto try_mount_again;
3877                 }
3878                 goto mount_fail_check;
3879 #else /* No DFS support, return error on mount */
3880                 rc = -EOPNOTSUPP;
3881 #endif
3882         }
3883
3884         if (rc)
3885                 goto mount_fail_check;
3886
3887         /* now, hang the tcon off of the superblock */
3888         tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3889         if (tlink == NULL) {
3890                 rc = -ENOMEM;
3891                 goto mount_fail_check;
3892         }
3893
3894         tlink->tl_uid = ses->linux_uid;
3895         tlink->tl_tcon = tcon;
3896         tlink->tl_time = jiffies;
3897         set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3898         set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3899
3900         cifs_sb->master_tlink = tlink;
3901         spin_lock(&cifs_sb->tlink_tree_lock);
3902         tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3903         spin_unlock(&cifs_sb->tlink_tree_lock);
3904
3905         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3906                                 TLINK_IDLE_EXPIRE);
3907
3908 mount_fail_check:
3909         /* on error free sesinfo and tcon struct if needed */
3910         if (rc) {
3911                 /* If find_unc succeeded then rc == 0 so we can not end */
3912                 /* up accidentally freeing someone elses tcon struct */
3913                 if (tcon)
3914                         cifs_put_tcon(tcon);
3915                 else if (ses)
3916                         cifs_put_smb_ses(ses);
3917                 else
3918                         cifs_put_tcp_session(server, 0);
3919                 bdi_destroy(&cifs_sb->bdi);
3920         }
3921
3922 out:
3923         free_xid(xid);
3924         return rc;
3925 }
3926
3927 /*
3928  * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3929  * pointer may be NULL.
3930  */
3931 int
3932 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3933          const char *tree, struct cifs_tcon *tcon,
3934          const struct nls_table *nls_codepage)
3935 {
3936         struct smb_hdr *smb_buffer;
3937         struct smb_hdr *smb_buffer_response;
3938         TCONX_REQ *pSMB;
3939         TCONX_RSP *pSMBr;
3940         unsigned char *bcc_ptr;
3941         int rc = 0;
3942         int length;
3943         __u16 bytes_left, count;
3944
3945         if (ses == NULL)
3946                 return -EIO;
3947
3948         smb_buffer = cifs_buf_get();
3949         if (smb_buffer == NULL)
3950                 return -ENOMEM;
3951
3952         smb_buffer_response = smb_buffer;
3953
3954         header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3955                         NULL /*no tid */ , 4 /*wct */ );
3956
3957         smb_buffer->Mid = get_next_mid(ses->server);
3958         smb_buffer->Uid = ses->Suid;
3959         pSMB = (TCONX_REQ *) smb_buffer;
3960         pSMBr = (TCONX_RSP *) smb_buffer_response;
3961
3962         pSMB->AndXCommand = 0xFF;
3963         pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3964         bcc_ptr = &pSMB->Password[0];
3965         if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3966                 pSMB->PasswordLength = cpu_to_le16(1);  /* minimum */
3967                 *bcc_ptr = 0; /* password is null byte */
3968                 bcc_ptr++;              /* skip password */
3969                 /* already aligned so no need to do it below */
3970         } else {
3971                 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3972                 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3973                    specified as required (when that support is added to
3974                    the vfs in the future) as only NTLM or the much
3975                    weaker LANMAN (which we do not send by default) is accepted
3976                    by Samba (not sure whether other servers allow
3977                    NTLMv2 password here) */
3978 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3979                 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3980                     (ses->sectype == LANMAN))
3981                         calc_lanman_hash(tcon->password, ses->server->cryptkey,
3982                                          ses->server->sec_mode &
3983                                             SECMODE_PW_ENCRYPT ? true : false,
3984                                          bcc_ptr);
3985                 else
3986 #endif /* CIFS_WEAK_PW_HASH */
3987                 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3988                                         bcc_ptr, nls_codepage);
3989                 if (rc) {
3990                         cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
3991                                  __func__, rc);
3992                         cifs_buf_release(smb_buffer);
3993                         return rc;
3994                 }
3995
3996                 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3997                 if (ses->capabilities & CAP_UNICODE) {
3998                         /* must align unicode strings */
3999                         *bcc_ptr = 0; /* null byte password */
4000                         bcc_ptr++;
4001                 }
4002         }
4003
4004         if (ses->server->sign)
4005                 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
4006
4007         if (ses->capabilities & CAP_STATUS32) {
4008                 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
4009         }
4010         if (ses->capabilities & CAP_DFS) {
4011                 smb_buffer->Flags2 |= SMBFLG2_DFS;
4012         }
4013         if (ses->capabilities & CAP_UNICODE) {
4014                 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
4015                 length =
4016                     cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
4017                         6 /* max utf8 char length in bytes */ *
4018                         (/* server len*/ + 256 /* share len */), nls_codepage);
4019                 bcc_ptr += 2 * length;  /* convert num 16 bit words to bytes */
4020                 bcc_ptr += 2;   /* skip trailing null */
4021         } else {                /* ASCII */
4022                 strcpy(bcc_ptr, tree);
4023                 bcc_ptr += strlen(tree) + 1;
4024         }
4025         strcpy(bcc_ptr, "?????");
4026         bcc_ptr += strlen("?????");
4027         bcc_ptr += 1;
4028         count = bcc_ptr - &pSMB->Password[0];
4029         pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
4030                                         pSMB->hdr.smb_buf_length) + count);
4031         pSMB->ByteCount = cpu_to_le16(count);
4032
4033         rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
4034                          0);
4035
4036         /* above now done in SendReceive */
4037         if ((rc == 0) && (tcon != NULL)) {
4038                 bool is_unicode;
4039
4040                 tcon->tidStatus = CifsGood;
4041                 tcon->need_reconnect = false;
4042                 tcon->tid = smb_buffer_response->Tid;
4043                 bcc_ptr = pByteArea(smb_buffer_response);
4044                 bytes_left = get_bcc(smb_buffer_response);
4045                 length = strnlen(bcc_ptr, bytes_left - 2);
4046                 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
4047                         is_unicode = true;
4048                 else
4049                         is_unicode = false;
4050
4051
4052                 /* skip service field (NB: this field is always ASCII) */
4053                 if (length == 3) {
4054                         if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
4055                             (bcc_ptr[2] == 'C')) {
4056                                 cifs_dbg(FYI, "IPC connection\n");
4057                                 tcon->ipc = 1;
4058                         }
4059                 } else if (length == 2) {
4060                         if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
4061                                 /* the most common case */
4062                                 cifs_dbg(FYI, "disk share connection\n");
4063                         }
4064                 }
4065                 bcc_ptr += length + 1;
4066                 bytes_left -= (length + 1);
4067                 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
4068
4069                 /* mostly informational -- no need to fail on error here */
4070                 kfree(tcon->nativeFileSystem);
4071                 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
4072                                                       bytes_left, is_unicode,
4073                                                       nls_codepage);
4074
4075                 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
4076
4077                 if ((smb_buffer_response->WordCount == 3) ||
4078                          (smb_buffer_response->WordCount == 7))
4079                         /* field is in same location */
4080                         tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
4081                 else
4082                         tcon->Flags = 0;
4083                 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
4084         } else if ((rc == 0) && tcon == NULL) {
4085                 /* all we need to save for IPC$ connection */
4086                 ses->ipc_tid = smb_buffer_response->Tid;
4087         }
4088
4089         cifs_buf_release(smb_buffer);
4090         return rc;
4091 }
4092
4093 static void delayed_free(struct rcu_head *p)
4094 {
4095         struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
4096         unload_nls(sbi->local_nls);
4097         kfree(sbi);
4098 }
4099
4100 void
4101 cifs_umount(struct cifs_sb_info *cifs_sb)
4102 {
4103         struct rb_root *root = &cifs_sb->tlink_tree;
4104         struct rb_node *node;
4105         struct tcon_link *tlink;
4106
4107         cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
4108
4109         spin_lock(&cifs_sb->tlink_tree_lock);
4110         while ((node = rb_first(root))) {
4111                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4112                 cifs_get_tlink(tlink);
4113                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4114                 rb_erase(node, root);
4115
4116                 spin_unlock(&cifs_sb->tlink_tree_lock);
4117                 cifs_put_tlink(tlink);
4118                 spin_lock(&cifs_sb->tlink_tree_lock);
4119         }
4120         spin_unlock(&cifs_sb->tlink_tree_lock);
4121
4122         bdi_destroy(&cifs_sb->bdi);
4123         kfree(cifs_sb->mountdata);
4124         kfree(cifs_sb->prepath);
4125         call_rcu(&cifs_sb->rcu, delayed_free);
4126 }
4127
4128 int
4129 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
4130 {
4131         int rc = 0;
4132         struct TCP_Server_Info *server = ses->server;
4133
4134         if (!server->ops->need_neg || !server->ops->negotiate)
4135                 return -ENOSYS;
4136
4137         /* only send once per connect */
4138         if (!server->ops->need_neg(server))
4139                 return 0;
4140
4141         set_credits(server, 1);
4142
4143         rc = server->ops->negotiate(xid, ses);
4144         if (rc == 0) {
4145                 spin_lock(&GlobalMid_Lock);
4146                 if (server->tcpStatus == CifsNeedNegotiate)
4147                         server->tcpStatus = CifsGood;
4148                 else
4149                         rc = -EHOSTDOWN;
4150                 spin_unlock(&GlobalMid_Lock);
4151         }
4152
4153         return rc;
4154 }
4155
4156 int
4157 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
4158                    struct nls_table *nls_info)
4159 {
4160         int rc = -ENOSYS;
4161         struct TCP_Server_Info *server = ses->server;
4162
4163         ses->capabilities = server->capabilities;
4164         if (linuxExtEnabled == 0)
4165                 ses->capabilities &= (~server->vals->cap_unix);
4166
4167         cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
4168                  server->sec_mode, server->capabilities, server->timeAdj);
4169
4170         if (ses->auth_key.response) {
4171                 cifs_dbg(VFS, "Free previous auth_key.response = %p\n",
4172                          ses->auth_key.response);
4173                 kfree(ses->auth_key.response);
4174                 ses->auth_key.response = NULL;
4175                 ses->auth_key.len = 0;
4176         }
4177
4178         if (server->ops->sess_setup)
4179                 rc = server->ops->sess_setup(xid, ses, nls_info);
4180
4181         if (rc)
4182                 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
4183
4184         return rc;
4185 }
4186
4187 static int
4188 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4189 {
4190         vol->sectype = ses->sectype;
4191
4192         /* krb5 is special, since we don't need username or pw */
4193         if (vol->sectype == Kerberos)
4194                 return 0;
4195
4196         return cifs_set_cifscreds(vol, ses);
4197 }
4198
4199 static struct cifs_tcon *
4200 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
4201 {
4202         int rc;
4203         struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4204         struct cifs_ses *ses;
4205         struct cifs_tcon *tcon = NULL;
4206         struct smb_vol *vol_info;
4207
4208         vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
4209         if (vol_info == NULL)
4210                 return ERR_PTR(-ENOMEM);
4211
4212         vol_info->local_nls = cifs_sb->local_nls;
4213         vol_info->linux_uid = fsuid;
4214         vol_info->cred_uid = fsuid;
4215         vol_info->UNC = master_tcon->treeName;
4216         vol_info->retry = master_tcon->retry;
4217         vol_info->nocase = master_tcon->nocase;
4218         vol_info->local_lease = master_tcon->local_lease;
4219         vol_info->resilient = master_tcon->use_resilient;
4220         vol_info->persistent = master_tcon->use_persistent;
4221         vol_info->no_linux_ext = !master_tcon->unix_ext;
4222         vol_info->sectype = master_tcon->ses->sectype;
4223         vol_info->sign = master_tcon->ses->sign;
4224         vol_info->seal = master_tcon->seal;
4225
4226         rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4227         if (rc) {
4228                 tcon = ERR_PTR(rc);
4229                 goto out;
4230         }
4231
4232         /* get a reference for the same TCP session */
4233         spin_lock(&cifs_tcp_ses_lock);
4234         ++master_tcon->ses->server->srv_count;
4235         spin_unlock(&cifs_tcp_ses_lock);
4236
4237         ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4238         if (IS_ERR(ses)) {
4239                 tcon = (struct cifs_tcon *)ses;
4240                 cifs_put_tcp_session(master_tcon->ses->server, 0);
4241                 goto out;
4242         }
4243
4244         tcon = cifs_get_tcon(ses, vol_info);
4245         if (IS_ERR(tcon)) {
4246                 cifs_put_smb_ses(ses);
4247                 goto out;
4248         }
4249
4250         if (cap_unix(ses))
4251                 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4252 out:
4253         kfree(vol_info->username);
4254         kzfree(vol_info->password);
4255         kfree(vol_info);
4256
4257         return tcon;
4258 }
4259
4260 struct cifs_tcon *
4261 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4262 {
4263         return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4264 }
4265
4266 /* find and return a tlink with given uid */
4267 static struct tcon_link *
4268 tlink_rb_search(struct rb_root *root, kuid_t uid)
4269 {
4270         struct rb_node *node = root->rb_node;
4271         struct tcon_link *tlink;
4272
4273         while (node) {
4274                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4275
4276                 if (uid_gt(tlink->tl_uid, uid))
4277                         node = node->rb_left;
4278                 else if (uid_lt(tlink->tl_uid, uid))
4279                         node = node->rb_right;
4280                 else
4281                         return tlink;
4282         }
4283         return NULL;
4284 }
4285
4286 /* insert a tcon_link into the tree */
4287 static void
4288 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4289 {
4290         struct rb_node **new = &(root->rb_node), *parent = NULL;
4291         struct tcon_link *tlink;
4292
4293         while (*new) {
4294                 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4295                 parent = *new;
4296
4297                 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
4298                         new = &((*new)->rb_left);
4299                 else
4300                         new = &((*new)->rb_right);
4301         }
4302
4303         rb_link_node(&new_tlink->tl_rbnode, parent, new);
4304         rb_insert_color(&new_tlink->tl_rbnode, root);
4305 }
4306
4307 /*
4308  * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4309  * current task.
4310  *
4311  * If the superblock doesn't refer to a multiuser mount, then just return
4312  * the master tcon for the mount.
4313  *
4314  * First, search the rbtree for an existing tcon for this fsuid. If one
4315  * exists, then check to see if it's pending construction. If it is then wait
4316  * for construction to complete. Once it's no longer pending, check to see if
4317  * it failed and either return an error or retry construction, depending on
4318  * the timeout.
4319  *
4320  * If one doesn't exist then insert a new tcon_link struct into the tree and
4321  * try to construct a new one.
4322  */
4323 struct tcon_link *
4324 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4325 {
4326         int ret;
4327         kuid_t fsuid = current_fsuid();
4328         struct tcon_link *tlink, *newtlink;
4329
4330         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4331                 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4332
4333         spin_lock(&cifs_sb->tlink_tree_lock);
4334         tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4335         if (tlink)
4336                 cifs_get_tlink(tlink);
4337         spin_unlock(&cifs_sb->tlink_tree_lock);
4338
4339         if (tlink == NULL) {
4340                 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4341                 if (newtlink == NULL)
4342                         return ERR_PTR(-ENOMEM);
4343                 newtlink->tl_uid = fsuid;
4344                 newtlink->tl_tcon = ERR_PTR(-EACCES);
4345                 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4346                 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4347                 cifs_get_tlink(newtlink);
4348
4349                 spin_lock(&cifs_sb->tlink_tree_lock);
4350                 /* was one inserted after previous search? */
4351                 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4352                 if (tlink) {
4353                         cifs_get_tlink(tlink);
4354                         spin_unlock(&cifs_sb->tlink_tree_lock);
4355                         kfree(newtlink);
4356                         goto wait_for_construction;
4357                 }
4358                 tlink = newtlink;
4359                 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4360                 spin_unlock(&cifs_sb->tlink_tree_lock);
4361         } else {
4362 wait_for_construction:
4363                 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4364                                   TASK_INTERRUPTIBLE);
4365                 if (ret) {
4366                         cifs_put_tlink(tlink);
4367                         return ERR_PTR(-ERESTARTSYS);
4368                 }
4369
4370                 /* if it's good, return it */
4371                 if (!IS_ERR(tlink->tl_tcon))
4372                         return tlink;
4373
4374                 /* return error if we tried this already recently */
4375                 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4376                         cifs_put_tlink(tlink);
4377                         return ERR_PTR(-EACCES);
4378                 }
4379
4380                 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4381                         goto wait_for_construction;
4382         }
4383
4384         tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4385         clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4386         wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4387
4388         if (IS_ERR(tlink->tl_tcon)) {
4389                 cifs_put_tlink(tlink);
4390                 return ERR_PTR(-EACCES);
4391         }
4392
4393         return tlink;
4394 }
4395
4396 /*
4397  * periodic workqueue job that scans tcon_tree for a superblock and closes
4398  * out tcons.
4399  */
4400 static void
4401 cifs_prune_tlinks(struct work_struct *work)
4402 {
4403         struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4404                                                     prune_tlinks.work);
4405         struct rb_root *root = &cifs_sb->tlink_tree;
4406         struct rb_node *node = rb_first(root);
4407         struct rb_node *tmp;
4408         struct tcon_link *tlink;
4409
4410         /*
4411          * Because we drop the spinlock in the loop in order to put the tlink
4412          * it's not guarded against removal of links from the tree. The only
4413          * places that remove entries from the tree are this function and
4414          * umounts. Because this function is non-reentrant and is canceled
4415          * before umount can proceed, this is safe.
4416          */
4417         spin_lock(&cifs_sb->tlink_tree_lock);
4418         node = rb_first(root);
4419         while (node != NULL) {
4420                 tmp = node;
4421                 node = rb_next(tmp);
4422                 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4423
4424                 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4425                     atomic_read(&tlink->tl_count) != 0 ||
4426                     time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4427                         continue;
4428
4429                 cifs_get_tlink(tlink);
4430                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4431                 rb_erase(tmp, root);
4432
4433                 spin_unlock(&cifs_sb->tlink_tree_lock);
4434                 cifs_put_tlink(tlink);
4435                 spin_lock(&cifs_sb->tlink_tree_lock);
4436         }
4437         spin_unlock(&cifs_sb->tlink_tree_lock);
4438
4439         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4440                                 TLINK_IDLE_EXPIRE);
4441 }