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