fs/cifs/connect.c

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