fs/cifs/connect.c

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