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         unsigned short port = 0;
1227         struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1228
1229         separator[0] = ',';
1230         separator[1] = 0;
1231         delim = separator[0];
1232
1233         /* ensure we always start with zeroed-out smb_vol */
1234         memset(vol, 0, sizeof(*vol));
1235
1236         /*
1237          * does not have to be perfect mapping since field is
1238          * informational, only used for servers that do not support
1239          * port 445 and it can be overridden at mount time
1240          */
1241         memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1242         for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1243                 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1244
1245         vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1246         /* null target name indicates to use *SMBSERVR default called name
1247            if we end up sending RFC1001 session initialize */
1248         vol->target_rfc1001_name[0] = 0;
1249         vol->cred_uid = current_uid();
1250         vol->linux_uid = current_uid();
1251         vol->linux_gid = current_gid();
1252
1253         /*
1254          * default to SFM style remapping of seven reserved characters
1255          * unless user overrides it or we negotiate CIFS POSIX where
1256          * it is unnecessary.  Can not simultaneously use more than one mapping
1257          * since then readdir could list files that open could not open
1258          */
1259         vol->remap = true;
1260
1261         /* default to only allowing write access to owner of the mount */
1262         vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1263
1264         /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1265         /* default is always to request posix paths. */
1266         vol->posix_paths = 1;
1267         /* default to using server inode numbers where available */
1268         vol->server_ino = 1;
1269
1270         /* default is to use strict cifs caching semantics */
1271         vol->strict_io = true;
1272
1273         vol->actimeo = CIFS_DEF_ACTIMEO;
1274
1275         /* FIXME: add autonegotiation for SMB3 or later rather than just SMB3 */
1276         vol->ops = &smb30_operations; /* both secure and accepted widely */
1277         vol->vals = &smb30_values;
1278
1279         vol->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1280
1281         if (!mountdata)
1282                 goto cifs_parse_mount_err;
1283
1284         mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1285         if (!mountdata_copy)
1286                 goto cifs_parse_mount_err;
1287
1288         options = mountdata_copy;
1289         end = options + strlen(options);
1290
1291         if (strncmp(options, "sep=", 4) == 0) {
1292                 if (options[4] != 0) {
1293                         separator[0] = options[4];
1294                         options += 5;
1295                 } else {
1296                         cifs_dbg(FYI, "Null separator not allowed\n");
1297                 }
1298         }
1299         vol->backupuid_specified = false; /* no backup intent for a user */
1300         vol->backupgid_specified = false; /* no backup intent for a group */
1301
1302         switch (cifs_parse_devname(devname, vol)) {
1303         case 0:
1304                 break;
1305         case -ENOMEM:
1306                 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1307                 goto cifs_parse_mount_err;
1308         case -EINVAL:
1309                 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1310                 goto cifs_parse_mount_err;
1311         default:
1312                 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1313                 goto cifs_parse_mount_err;
1314         }
1315
1316         while ((data = strsep(&options, separator)) != NULL) {
1317                 substring_t args[MAX_OPT_ARGS];
1318                 unsigned long option;
1319                 int token;
1320
1321                 if (!*data)
1322                         continue;
1323
1324                 token = match_token(data, cifs_mount_option_tokens, args);
1325
1326                 switch (token) {
1327
1328                 /* Ingnore the following */
1329                 case Opt_ignore:
1330                         break;
1331
1332                 /* Boolean values */
1333                 case Opt_user_xattr:
1334                         vol->no_xattr = 0;
1335                         break;
1336                 case Opt_nouser_xattr:
1337                         vol->no_xattr = 1;
1338                         break;
1339                 case Opt_forceuid:
1340                         override_uid = 1;
1341                         break;
1342                 case Opt_noforceuid:
1343                         override_uid = 0;
1344                         break;
1345                 case Opt_forcegid:
1346                         override_gid = 1;
1347                         break;
1348                 case Opt_noforcegid:
1349                         override_gid = 0;
1350                         break;
1351                 case Opt_noblocksend:
1352                         vol->noblocksnd = 1;
1353                         break;
1354                 case Opt_noautotune:
1355                         vol->noautotune = 1;
1356                         break;
1357                 case Opt_hard:
1358                         vol->retry = 1;
1359                         break;
1360                 case Opt_soft:
1361                         vol->retry = 0;
1362                         break;
1363                 case Opt_perm:
1364                         vol->noperm = 0;
1365                         break;
1366                 case Opt_noperm:
1367                         vol->noperm = 1;
1368                         break;
1369                 case Opt_mapchars:
1370                         vol->sfu_remap = true;
1371                         vol->remap = false; /* disable SFM mapping */
1372                         break;
1373                 case Opt_nomapchars:
1374                         vol->sfu_remap = false;
1375                         break;
1376                 case Opt_mapposix:
1377                         vol->remap = true;
1378                         vol->sfu_remap = false; /* disable SFU mapping */
1379                         break;
1380                 case Opt_nomapposix:
1381                         vol->remap = false;
1382                         break;
1383                 case Opt_sfu:
1384                         vol->sfu_emul = 1;
1385                         break;
1386                 case Opt_nosfu:
1387                         vol->sfu_emul = 0;
1388                         break;
1389                 case Opt_nodfs:
1390                         vol->nodfs = 1;
1391                         break;
1392                 case Opt_posixpaths:
1393                         vol->posix_paths = 1;
1394                         break;
1395                 case Opt_noposixpaths:
1396                         vol->posix_paths = 0;
1397                         break;
1398                 case Opt_nounix:
1399                         vol->no_linux_ext = 1;
1400                         break;
1401                 case Opt_nocase:
1402                         vol->nocase = 1;
1403                         break;
1404                 case Opt_brl:
1405                         vol->nobrl =  0;
1406                         break;
1407                 case Opt_nobrl:
1408                         vol->nobrl =  1;
1409                         /*
1410                          * turn off mandatory locking in mode
1411                          * if remote locking is turned off since the
1412                          * local vfs will do advisory
1413                          */
1414                         if (vol->file_mode ==
1415                                 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1416                                 vol->file_mode = S_IALLUGO;
1417                         break;
1418                 case Opt_forcemandatorylock:
1419                         vol->mand_lock = 1;
1420                         break;
1421                 case Opt_setuids:
1422                         vol->setuids = 1;
1423                         break;
1424                 case Opt_nosetuids:
1425                         vol->setuids = 0;
1426                         break;
1427                 case Opt_setuidfromacl:
1428                         vol->setuidfromacl = 1;
1429                         break;
1430                 case Opt_dynperm:
1431                         vol->dynperm = true;
1432                         break;
1433                 case Opt_nodynperm:
1434                         vol->dynperm = false;
1435                         break;
1436                 case Opt_nohard:
1437                         vol->retry = 0;
1438                         break;
1439                 case Opt_nosoft:
1440                         vol->retry = 1;
1441                         break;
1442                 case Opt_nointr:
1443                         vol->intr = 0;
1444                         break;
1445                 case Opt_intr:
1446                         vol->intr = 1;
1447                         break;
1448                 case Opt_nostrictsync:
1449                         vol->nostrictsync = 1;
1450                         break;
1451                 case Opt_strictsync:
1452                         vol->nostrictsync = 0;
1453                         break;
1454                 case Opt_serverino:
1455                         vol->server_ino = 1;
1456                         break;
1457                 case Opt_noserverino:
1458                         vol->server_ino = 0;
1459                         break;
1460                 case Opt_rwpidforward:
1461                         vol->rwpidforward = 1;
1462                         break;
1463                 case Opt_cifsacl:
1464                         vol->cifs_acl = 1;
1465                         break;
1466                 case Opt_nocifsacl:
1467                         vol->cifs_acl = 0;
1468                         break;
1469                 case Opt_acl:
1470                         vol->no_psx_acl = 0;
1471                         break;
1472                 case Opt_noacl:
1473                         vol->no_psx_acl = 1;
1474                         break;
1475                 case Opt_locallease:
1476                         vol->local_lease = 1;
1477                         break;
1478                 case Opt_sign:
1479                         vol->sign = true;
1480                         break;
1481                 case Opt_seal:
1482                         /* we do not do the following in secFlags because seal
1483                          * is a per tree connection (mount) not a per socket
1484                          * or per-smb connection option in the protocol
1485                          * vol->secFlg |= CIFSSEC_MUST_SEAL;
1486                          */
1487                         vol->seal = 1;
1488                         break;
1489                 case Opt_noac:
1490                         pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1491                         break;
1492                 case Opt_fsc:
1493 #ifndef CONFIG_CIFS_FSCACHE
1494                         cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1495                         goto cifs_parse_mount_err;
1496 #endif
1497                         vol->fsc = true;
1498                         break;
1499                 case Opt_mfsymlinks:
1500                         vol->mfsymlinks = true;
1501                         break;
1502                 case Opt_multiuser:
1503                         vol->multiuser = true;
1504                         break;
1505                 case Opt_sloppy:
1506                         sloppy = true;
1507                         break;
1508                 case Opt_nosharesock:
1509                         vol->nosharesock = true;
1510                         break;
1511                 case Opt_nopersistent:
1512                         vol->nopersistent = true;
1513                         if (vol->persistent) {
1514                                 cifs_dbg(VFS,
1515                                   "persistenthandles mount options conflict\n");
1516                                 goto cifs_parse_mount_err;
1517                         }
1518                         break;
1519                 case Opt_persistent:
1520                         vol->persistent = true;
1521                         if ((vol->nopersistent) || (vol->resilient)) {
1522                                 cifs_dbg(VFS,
1523                                   "persistenthandles mount options conflict\n");
1524                                 goto cifs_parse_mount_err;
1525                         }
1526                         break;
1527                 case Opt_resilient:
1528                         vol->resilient = true;
1529                         if (vol->persistent) {
1530                                 cifs_dbg(VFS,
1531                                   "persistenthandles mount options conflict\n");
1532                                 goto cifs_parse_mount_err;
1533                         }
1534                         break;
1535                 case Opt_noresilient:
1536                         vol->resilient = false; /* already the default */
1537                         break;
1538                 case Opt_domainauto:
1539                         vol->domainauto = true;
1540                         break;
1541
1542                 /* Numeric Values */
1543                 case Opt_backupuid:
1544                         if (get_option_uid(args, &vol->backupuid)) {
1545                                 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1546                                          __func__);
1547                                 goto cifs_parse_mount_err;
1548                         }
1549                         vol->backupuid_specified = true;
1550                         break;
1551                 case Opt_backupgid:
1552                         if (get_option_gid(args, &vol->backupgid)) {
1553                                 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1554                                          __func__);
1555                                 goto cifs_parse_mount_err;
1556                         }
1557                         vol->backupgid_specified = true;
1558                         break;
1559                 case Opt_uid:
1560                         if (get_option_uid(args, &vol->linux_uid)) {
1561                                 cifs_dbg(VFS, "%s: Invalid uid value\n",
1562                                          __func__);
1563                                 goto cifs_parse_mount_err;
1564                         }
1565                         uid_specified = true;
1566                         break;
1567                 case Opt_cruid:
1568                         if (get_option_uid(args, &vol->cred_uid)) {
1569                                 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1570                                          __func__);
1571                                 goto cifs_parse_mount_err;
1572                         }
1573                         break;
1574                 case Opt_gid:
1575                         if (get_option_gid(args, &vol->linux_gid)) {
1576                                 cifs_dbg(VFS, "%s: Invalid gid value\n",
1577                                          __func__);
1578                                 goto cifs_parse_mount_err;
1579                         }
1580                         gid_specified = true;
1581                         break;
1582                 case Opt_file_mode:
1583                         if (get_option_ul(args, &option)) {
1584                                 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1585                                          __func__);
1586                                 goto cifs_parse_mount_err;
1587                         }
1588                         vol->file_mode = option;
1589                         break;
1590                 case Opt_dirmode:
1591                         if (get_option_ul(args, &option)) {
1592                                 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1593                                          __func__);
1594                                 goto cifs_parse_mount_err;
1595                         }
1596                         vol->dir_mode = option;
1597                         break;
1598                 case Opt_port:
1599                         if (get_option_ul(args, &option) ||
1600                             option > USHRT_MAX) {
1601                                 cifs_dbg(VFS, "%s: Invalid port value\n",
1602                                          __func__);
1603                                 goto cifs_parse_mount_err;
1604                         }
1605                         port = (unsigned short)option;
1606                         break;
1607                 case Opt_rsize:
1608                         if (get_option_ul(args, &option)) {
1609                                 cifs_dbg(VFS, "%s: Invalid rsize value\n",
1610                                          __func__);
1611                                 goto cifs_parse_mount_err;
1612                         }
1613                         vol->rsize = option;
1614                         break;
1615                 case Opt_wsize:
1616                         if (get_option_ul(args, &option)) {
1617                                 cifs_dbg(VFS, "%s: Invalid wsize value\n",
1618                                          __func__);
1619                                 goto cifs_parse_mount_err;
1620                         }
1621                         vol->wsize = option;
1622                         break;
1623                 case Opt_actimeo:
1624                         if (get_option_ul(args, &option)) {
1625                                 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
1626                                          __func__);
1627                                 goto cifs_parse_mount_err;
1628                         }
1629                         vol->actimeo = HZ * option;
1630                         if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1631                                 cifs_dbg(VFS, "attribute cache timeout too large\n");
1632                                 goto cifs_parse_mount_err;
1633                         }
1634                         break;
1635                 case Opt_echo_interval:
1636                         if (get_option_ul(args, &option)) {
1637                                 cifs_dbg(VFS, "%s: Invalid echo interval value\n",
1638                                          __func__);
1639                                 goto cifs_parse_mount_err;
1640                         }
1641                         vol->echo_interval = option;
1642                         break;
1643                 case Opt_snapshot:
1644                         if (get_option_ul(args, &option)) {
1645                                 cifs_dbg(VFS, "%s: Invalid snapshot time\n",
1646                                          __func__);
1647                                 goto cifs_parse_mount_err;
1648                         }
1649                         vol->snapshot_time = option;
1650                         break;
1651                 case Opt_max_credits:
1652                         if (get_option_ul(args, &option) || (option < 20) ||
1653                             (option > 60000)) {
1654                                 cifs_dbg(VFS, "%s: Invalid max_credits value\n",
1655                                          __func__);
1656                                 goto cifs_parse_mount_err;
1657                         }
1658                         vol->max_credits = option;
1659                         break;
1660
1661                 /* String Arguments */
1662
1663                 case Opt_blank_user:
1664                         /* null user, ie. anonymous authentication */
1665                         vol->nullauth = 1;
1666                         vol->username = NULL;
1667                         break;
1668                 case Opt_user:
1669                         string = match_strdup(args);
1670                         if (string == NULL)
1671                                 goto out_nomem;
1672
1673                         if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
1674                                                         CIFS_MAX_USERNAME_LEN) {
1675                                 pr_warn("CIFS: username too long\n");
1676                                 goto cifs_parse_mount_err;
1677                         }
1678
1679                         kfree(vol->username);
1680                         vol->username = kstrdup(string, GFP_KERNEL);
1681                         if (!vol->username)
1682                                 goto cifs_parse_mount_err;
1683                         break;
1684                 case Opt_blank_pass:
1685                         /* passwords have to be handled differently
1686                          * to allow the character used for deliminator
1687                          * to be passed within them
1688                          */
1689
1690                         /*
1691                          * Check if this is a case where the  password
1692                          * starts with a delimiter
1693                          */
1694                         tmp_end = strchr(data, '=');
1695                         tmp_end++;
1696                         if (!(tmp_end < end && tmp_end[1] == delim)) {
1697                                 /* No it is not. Set the password to NULL */
1698                                 kfree(vol->password);
1699                                 vol->password = NULL;
1700                                 break;
1701                         }
1702                         /* Yes it is. Drop down to Opt_pass below.*/
1703                 case Opt_pass:
1704                         /* Obtain the value string */
1705                         value = strchr(data, '=');
1706                         value++;
1707
1708                         /* Set tmp_end to end of the string */
1709                         tmp_end = (char *) value + strlen(value);
1710
1711                         /* Check if following character is the deliminator
1712                          * If yes, we have encountered a double deliminator
1713                          * reset the NULL character to the deliminator
1714                          */
1715                         if (tmp_end < end && tmp_end[1] == delim) {
1716                                 tmp_end[0] = delim;
1717
1718                                 /* Keep iterating until we get to a single
1719                                  * deliminator OR the end
1720                                  */
1721                                 while ((tmp_end = strchr(tmp_end, delim))
1722                                         != NULL && (tmp_end[1] == delim)) {
1723                                                 tmp_end = (char *) &tmp_end[2];
1724                                 }
1725
1726                                 /* Reset var options to point to next element */
1727                                 if (tmp_end) {
1728                                         tmp_end[0] = '\0';
1729                                         options = (char *) &tmp_end[1];
1730                                 } else
1731                                         /* Reached the end of the mount option
1732                                          * string */
1733                                         options = end;
1734                         }
1735
1736                         kfree(vol->password);
1737                         /* Now build new password string */
1738                         temp_len = strlen(value);
1739                         vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1740                         if (vol->password == NULL) {
1741                                 pr_warn("CIFS: no memory for password\n");
1742                                 goto cifs_parse_mount_err;
1743                         }
1744
1745                         for (i = 0, j = 0; i < temp_len; i++, j++) {
1746                                 vol->password[j] = value[i];
1747                                 if ((value[i] == delim) &&
1748                                      value[i+1] == delim)
1749                                         /* skip the second deliminator */
1750                                         i++;
1751                         }
1752                         vol->password[j] = '\0';
1753                         break;
1754                 case Opt_blank_ip:
1755                         /* FIXME: should this be an error instead? */
1756                         got_ip = false;
1757                         break;
1758                 case Opt_ip:
1759                         string = match_strdup(args);
1760                         if (string == NULL)
1761                                 goto out_nomem;
1762
1763                         if (!cifs_convert_address(dstaddr, string,
1764                                         strlen(string))) {
1765                                 pr_err("CIFS: bad ip= option (%s).\n", string);
1766                                 goto cifs_parse_mount_err;
1767                         }
1768                         got_ip = true;
1769                         break;
1770                 case Opt_domain:
1771                         string = match_strdup(args);
1772                         if (string == NULL)
1773                                 goto out_nomem;
1774
1775                         if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
1776                                         == CIFS_MAX_DOMAINNAME_LEN) {
1777                                 pr_warn("CIFS: domain name too long\n");
1778                                 goto cifs_parse_mount_err;
1779                         }
1780
1781                         kfree(vol->domainname);
1782                         vol->domainname = kstrdup(string, GFP_KERNEL);
1783                         if (!vol->domainname) {
1784                                 pr_warn("CIFS: no memory for domainname\n");
1785                                 goto cifs_parse_mount_err;
1786                         }
1787                         cifs_dbg(FYI, "Domain name set\n");
1788                         break;
1789                 case Opt_srcaddr:
1790                         string = match_strdup(args);
1791                         if (string == NULL)
1792                                 goto out_nomem;
1793
1794                         if (!cifs_convert_address(
1795                                         (struct sockaddr *)&vol->srcaddr,
1796                                         string, strlen(string))) {
1797                                 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1798                                         string);
1799                                 goto cifs_parse_mount_err;
1800                         }
1801                         break;
1802                 case Opt_iocharset:
1803                         string = match_strdup(args);
1804                         if (string == NULL)
1805                                 goto out_nomem;
1806
1807                         if (strnlen(string, 1024) >= 65) {
1808                                 pr_warn("CIFS: iocharset name too long.\n");
1809                                 goto cifs_parse_mount_err;
1810                         }
1811
1812                          if (strncasecmp(string, "default", 7) != 0) {
1813                                 kfree(vol->iocharset);
1814                                 vol->iocharset = kstrdup(string,
1815                                                          GFP_KERNEL);
1816                                 if (!vol->iocharset) {
1817                                         pr_warn("CIFS: no memory for charset\n");
1818                                         goto cifs_parse_mount_err;
1819                                 }
1820                         }
1821                         /* if iocharset not set then load_nls_default
1822                          * is used by caller
1823                          */
1824                          cifs_dbg(FYI, "iocharset set to %s\n", string);
1825                         break;
1826                 case Opt_netbiosname:
1827                         string = match_strdup(args);
1828                         if (string == NULL)
1829                                 goto out_nomem;
1830
1831                         memset(vol->source_rfc1001_name, 0x20,
1832                                 RFC1001_NAME_LEN);
1833                         /*
1834                          * FIXME: are there cases in which a comma can
1835                          * be valid in workstation netbios name (and
1836                          * need special handling)?
1837                          */
1838                         for (i = 0; i < RFC1001_NAME_LEN; i++) {
1839                                 /* don't ucase netbiosname for user */
1840                                 if (string[i] == 0)
1841                                         break;
1842                                 vol->source_rfc1001_name[i] = string[i];
1843                         }
1844                         /* The string has 16th byte zero still from
1845                          * set at top of the function
1846                          */
1847                         if (i == RFC1001_NAME_LEN && string[i] != 0)
1848                                 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
1849                         break;
1850                 case Opt_servern:
1851                         /* servernetbiosname specified override *SMBSERVER */
1852                         string = match_strdup(args);
1853                         if (string == NULL)
1854                                 goto out_nomem;
1855
1856                         /* last byte, type, is 0x20 for servr type */
1857                         memset(vol->target_rfc1001_name, 0x20,
1858                                 RFC1001_NAME_LEN_WITH_NULL);
1859
1860                         /* BB are there cases in which a comma can be
1861                            valid in this workstation netbios name
1862                            (and need special handling)? */
1863
1864                         /* user or mount helper must uppercase the
1865                            netbios name */
1866                         for (i = 0; i < 15; i++) {
1867                                 if (string[i] == 0)
1868                                         break;
1869                                 vol->target_rfc1001_name[i] = string[i];
1870                         }
1871                         /* The string has 16th byte zero still from
1872                            set at top of the function  */
1873                         if (i == RFC1001_NAME_LEN && string[i] != 0)
1874                                 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
1875                         break;
1876                 case Opt_ver:
1877                         string = match_strdup(args);
1878                         if (string == NULL)
1879                                 goto out_nomem;
1880
1881                         if (strncasecmp(string, "1", 1) == 0) {
1882                                 /* This is the default */
1883                                 break;
1884                         }
1885                         /* For all other value, error */
1886                         pr_warn("CIFS: Invalid version specified\n");
1887                         goto cifs_parse_mount_err;
1888                 case Opt_vers:
1889                         string = match_strdup(args);
1890                         if (string == NULL)
1891                                 goto out_nomem;
1892
1893                         if (cifs_parse_smb_version(string, vol) != 0)
1894                                 goto cifs_parse_mount_err;
1895                         break;
1896                 case Opt_sec:
1897                         string = match_strdup(args);
1898                         if (string == NULL)
1899                                 goto out_nomem;
1900
1901                         if (cifs_parse_security_flavors(string, vol) != 0)
1902                                 goto cifs_parse_mount_err;
1903                         break;
1904                 case Opt_cache:
1905                         string = match_strdup(args);
1906                         if (string == NULL)
1907                                 goto out_nomem;
1908
1909                         if (cifs_parse_cache_flavor(string, vol) != 0)
1910                                 goto cifs_parse_mount_err;
1911                         break;
1912                 default:
1913                         /*
1914                          * An option we don't recognize. Save it off for later
1915                          * if we haven't already found one
1916                          */
1917                         if (!invalid)
1918                                 invalid = data;
1919                         break;
1920                 }
1921                 /* Free up any allocated string */
1922                 kfree(string);
1923                 string = NULL;
1924         }
1925
1926         if (!sloppy && invalid) {
1927                 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
1928                 goto cifs_parse_mount_err;
1929         }
1930
1931 #ifndef CONFIG_KEYS
1932         /* Muliuser mounts require CONFIG_KEYS support */
1933         if (vol->multiuser) {
1934                 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
1935                 goto cifs_parse_mount_err;
1936         }
1937 #endif
1938         if (!vol->UNC) {
1939                 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
1940                 goto cifs_parse_mount_err;
1941         }
1942
1943         /* make sure UNC has a share name */
1944         if (!strchr(vol->UNC + 3, '\\')) {
1945                 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
1946                 goto cifs_parse_mount_err;
1947         }
1948
1949         if (!got_ip) {
1950                 int len;
1951                 const char *slash;
1952
1953                 /* No ip= option specified? Try to get it from UNC */
1954                 /* Use the address part of the UNC. */
1955                 slash = strchr(&vol->UNC[2], '\\');
1956                 len = slash - &vol->UNC[2];
1957                 if (!cifs_convert_address(dstaddr, &vol->UNC[2], len)) {
1958                         pr_err("Unable to determine destination address.\n");
1959                         goto cifs_parse_mount_err;
1960                 }
1961         }
1962
1963         /* set the port that we got earlier */
1964         cifs_set_port(dstaddr, port);
1965
1966         if (uid_specified)
1967                 vol->override_uid = override_uid;
1968         else if (override_uid == 1)
1969                 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
1970
1971         if (gid_specified)
1972                 vol->override_gid = override_gid;
1973         else if (override_gid == 1)
1974                 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
1975
1976         kfree(mountdata_copy);
1977         return 0;
1978
1979 out_nomem:
1980         pr_warn("Could not allocate temporary buffer\n");
1981 cifs_parse_mount_err:
1982         kfree(string);
1983         kfree(mountdata_copy);
1984         return 1;
1985 }
1986
1987 /** Returns true if srcaddr isn't specified and rhs isn't
1988  * specified, or if srcaddr is specified and
1989  * matches the IP address of the rhs argument.
1990  */
1991 static bool
1992 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1993 {
1994         switch (srcaddr->sa_family) {
1995         case AF_UNSPEC:
1996                 return (rhs->sa_family == AF_UNSPEC);
1997         case AF_INET: {
1998                 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1999                 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
2000                 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
2001         }
2002         case AF_INET6: {
2003                 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
2004                 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
2005                 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
2006         }
2007         default:
2008                 WARN_ON(1);
2009                 return false; /* don't expect to be here */
2010         }
2011 }
2012
2013 /*
2014  * If no port is specified in addr structure, we try to match with 445 port
2015  * and if it fails - with 139 ports. It should be called only if address
2016  * families of server and addr are equal.
2017  */
2018 static bool
2019 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
2020 {
2021         __be16 port, *sport;
2022
2023         switch (addr->sa_family) {
2024         case AF_INET:
2025                 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
2026                 port = ((struct sockaddr_in *) addr)->sin_port;
2027                 break;
2028         case AF_INET6:
2029                 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
2030                 port = ((struct sockaddr_in6 *) addr)->sin6_port;
2031                 break;
2032         default:
2033                 WARN_ON(1);
2034                 return false;
2035         }
2036
2037         if (!port) {
2038                 port = htons(CIFS_PORT);
2039                 if (port == *sport)
2040                         return true;
2041
2042                 port = htons(RFC1001_PORT);
2043         }
2044
2045         return port == *sport;
2046 }
2047
2048 static bool
2049 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
2050               struct sockaddr *srcaddr)
2051 {
2052         switch (addr->sa_family) {
2053         case AF_INET: {
2054                 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2055                 struct sockaddr_in *srv_addr4 =
2056                                         (struct sockaddr_in *)&server->dstaddr;
2057
2058                 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2059                         return false;
2060                 break;
2061         }
2062         case AF_INET6: {
2063                 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2064                 struct sockaddr_in6 *srv_addr6 =
2065                                         (struct sockaddr_in6 *)&server->dstaddr;
2066
2067                 if (!ipv6_addr_equal(&addr6->sin6_addr,
2068                                      &srv_addr6->sin6_addr))
2069                         return false;
2070                 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2071                         return false;
2072                 break;
2073         }
2074         default:
2075                 WARN_ON(1);
2076                 return false; /* don't expect to be here */
2077         }
2078
2079         if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2080                 return false;
2081
2082         return true;
2083 }
2084
2085 static bool
2086 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2087 {
2088         /*
2089          * The select_sectype function should either return the vol->sectype
2090          * that was specified, or "Unspecified" if that sectype was not
2091          * compatible with the given NEGOTIATE request.
2092          */
2093         if (server->ops->select_sectype(server, vol->sectype)
2094              == Unspecified)
2095                 return false;
2096
2097         /*
2098          * Now check if signing mode is acceptable. No need to check
2099          * global_secflags at this point since if MUST_SIGN is set then
2100          * the server->sign had better be too.
2101          */
2102         if (vol->sign && !server->sign)
2103                 return false;
2104
2105         return true;
2106 }
2107
2108 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2109 {
2110         struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2111
2112         if (vol->nosharesock)
2113                 return 0;
2114
2115         if ((server->vals != vol->vals) || (server->ops != vol->ops))
2116                 return 0;
2117
2118         if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2119                 return 0;
2120
2121         if (!match_address(server, addr,
2122                            (struct sockaddr *)&vol->srcaddr))
2123                 return 0;
2124
2125         if (!match_port(server, addr))
2126                 return 0;
2127
2128         if (!match_security(server, vol))
2129                 return 0;
2130
2131         if (server->echo_interval != vol->echo_interval * HZ)
2132                 return 0;
2133
2134         return 1;
2135 }
2136
2137 static struct TCP_Server_Info *
2138 cifs_find_tcp_session(struct smb_vol *vol)
2139 {
2140         struct TCP_Server_Info *server;
2141
2142         spin_lock(&cifs_tcp_ses_lock);
2143         list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2144                 if (!match_server(server, vol))
2145                         continue;
2146
2147                 ++server->srv_count;
2148                 spin_unlock(&cifs_tcp_ses_lock);
2149                 cifs_dbg(FYI, "Existing tcp session with server found\n");
2150                 return server;
2151         }
2152         spin_unlock(&cifs_tcp_ses_lock);
2153         return NULL;
2154 }
2155
2156 void
2157 cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
2158 {
2159         struct task_struct *task;
2160
2161         spin_lock(&cifs_tcp_ses_lock);
2162         if (--server->srv_count > 0) {
2163                 spin_unlock(&cifs_tcp_ses_lock);
2164                 return;
2165         }
2166
2167         put_net(cifs_net_ns(server));
2168
2169         list_del_init(&server->tcp_ses_list);
2170         spin_unlock(&cifs_tcp_ses_lock);
2171
2172         cancel_delayed_work_sync(&server->echo);
2173
2174         if (from_reconnect)
2175                 /*
2176                  * Avoid deadlock here: reconnect work calls
2177                  * cifs_put_tcp_session() at its end. Need to be sure
2178                  * that reconnect work does nothing with server pointer after
2179                  * that step.
2180                  */
2181                 cancel_delayed_work(&server->reconnect);
2182         else
2183                 cancel_delayed_work_sync(&server->reconnect);
2184
2185         spin_lock(&GlobalMid_Lock);
2186         server->tcpStatus = CifsExiting;
2187         spin_unlock(&GlobalMid_Lock);
2188
2189         cifs_crypto_secmech_release(server);
2190         cifs_fscache_release_client_cookie(server);
2191
2192         kfree(server->session_key.response);
2193         server->session_key.response = NULL;
2194         server->session_key.len = 0;
2195
2196         task = xchg(&server->tsk, NULL);
2197         if (task)
2198                 force_sig(SIGKILL, task);
2199 }
2200
2201 static struct TCP_Server_Info *
2202 cifs_get_tcp_session(struct smb_vol *volume_info)
2203 {
2204         struct TCP_Server_Info *tcp_ses = NULL;
2205         int rc;
2206
2207         cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2208
2209         /* see if we already have a matching tcp_ses */
2210         tcp_ses = cifs_find_tcp_session(volume_info);
2211         if (tcp_ses)
2212                 return tcp_ses;
2213
2214         tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2215         if (!tcp_ses) {
2216                 rc = -ENOMEM;
2217                 goto out_err;
2218         }
2219
2220         tcp_ses->ops = volume_info->ops;
2221         tcp_ses->vals = volume_info->vals;
2222         cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2223         tcp_ses->hostname = extract_hostname(volume_info->UNC);
2224         if (IS_ERR(tcp_ses->hostname)) {
2225                 rc = PTR_ERR(tcp_ses->hostname);
2226                 goto out_err_crypto_release;
2227         }
2228
2229         tcp_ses->noblocksnd = volume_info->noblocksnd;
2230         tcp_ses->noautotune = volume_info->noautotune;
2231         tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2232         tcp_ses->in_flight = 0;
2233         tcp_ses->credits = 1;
2234         init_waitqueue_head(&tcp_ses->response_q);
2235         init_waitqueue_head(&tcp_ses->request_q);
2236         INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2237         mutex_init(&tcp_ses->srv_mutex);
2238         memcpy(tcp_ses->workstation_RFC1001_name,
2239                 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2240         memcpy(tcp_ses->server_RFC1001_name,
2241                 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2242         tcp_ses->session_estab = false;
2243         tcp_ses->sequence_number = 0;
2244         tcp_ses->lstrp = jiffies;
2245         spin_lock_init(&tcp_ses->req_lock);
2246         INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2247         INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2248         INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2249         INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
2250         mutex_init(&tcp_ses->reconnect_mutex);
2251         memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2252                sizeof(tcp_ses->srcaddr));
2253         memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2254                 sizeof(tcp_ses->dstaddr));
2255         generate_random_uuid(tcp_ses->client_guid);
2256         /*
2257          * at this point we are the only ones with the pointer
2258          * to the struct since the kernel thread not created yet
2259          * no need to spinlock this init of tcpStatus or srv_count
2260          */
2261         tcp_ses->tcpStatus = CifsNew;
2262         ++tcp_ses->srv_count;
2263
2264         if (volume_info->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
2265                 volume_info->echo_interval <= SMB_ECHO_INTERVAL_MAX)
2266                 tcp_ses->echo_interval = volume_info->echo_interval * HZ;
2267         else
2268                 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
2269
2270         rc = ip_connect(tcp_ses);
2271         if (rc < 0) {
2272                 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2273                 goto out_err_crypto_release;
2274         }
2275
2276         /*
2277          * since we're in a cifs function already, we know that
2278          * this will succeed. No need for try_module_get().
2279          */
2280         __module_get(THIS_MODULE);
2281         tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2282                                   tcp_ses, "cifsd");
2283         if (IS_ERR(tcp_ses->tsk)) {
2284                 rc = PTR_ERR(tcp_ses->tsk);
2285                 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2286                 module_put(THIS_MODULE);
2287                 goto out_err_crypto_release;
2288         }
2289         tcp_ses->tcpStatus = CifsNeedNegotiate;
2290
2291         /* thread spawned, put it on the list */
2292         spin_lock(&cifs_tcp_ses_lock);
2293         list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2294         spin_unlock(&cifs_tcp_ses_lock);
2295
2296         cifs_fscache_get_client_cookie(tcp_ses);
2297
2298         /* queue echo request delayed work */
2299         queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
2300
2301         return tcp_ses;
2302
2303 out_err_crypto_release:
2304         cifs_crypto_secmech_release(tcp_ses);
2305
2306         put_net(cifs_net_ns(tcp_ses));
2307
2308 out_err:
2309         if (tcp_ses) {
2310                 if (!IS_ERR(tcp_ses->hostname))
2311                         kfree(tcp_ses->hostname);
2312                 if (tcp_ses->ssocket)
2313                         sock_release(tcp_ses->ssocket);
2314                 kfree(tcp_ses);
2315         }
2316         return ERR_PTR(rc);
2317 }
2318
2319 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2320 {
2321         if (vol->sectype != Unspecified &&
2322             vol->sectype != ses->sectype)
2323                 return 0;
2324
2325         switch (ses->sectype) {
2326         case Kerberos:
2327                 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2328                         return 0;
2329                 break;
2330         default:
2331                 /* NULL username means anonymous session */
2332                 if (ses->user_name == NULL) {
2333                         if (!vol->nullauth)
2334                                 return 0;
2335                         break;
2336                 }
2337
2338                 /* anything else takes username/password */
2339                 if (strncmp(ses->user_name,
2340                             vol->username ? vol->username : "",
2341                             CIFS_MAX_USERNAME_LEN))
2342                         return 0;
2343                 if ((vol->username && strlen(vol->username) != 0) &&
2344                     ses->password != NULL &&
2345                     strncmp(ses->password,
2346                             vol->password ? vol->password : "",
2347                             CIFS_MAX_PASSWORD_LEN))
2348                         return 0;
2349         }
2350         return 1;
2351 }
2352
2353 static struct cifs_ses *
2354 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2355 {
2356         struct cifs_ses *ses;
2357
2358         spin_lock(&cifs_tcp_ses_lock);
2359         list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2360                 if (ses->status == CifsExiting)
2361                         continue;
2362                 if (!match_session(ses, vol))
2363                         continue;
2364                 ++ses->ses_count;
2365                 spin_unlock(&cifs_tcp_ses_lock);
2366                 return ses;
2367         }
2368         spin_unlock(&cifs_tcp_ses_lock);
2369         return NULL;
2370 }
2371
2372 static void
2373 cifs_put_smb_ses(struct cifs_ses *ses)
2374 {
2375         unsigned int rc, xid;
2376         struct TCP_Server_Info *server = ses->server;
2377
2378         cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
2379
2380         spin_lock(&cifs_tcp_ses_lock);
2381         if (ses->status == CifsExiting) {
2382                 spin_unlock(&cifs_tcp_ses_lock);
2383                 return;
2384         }
2385         if (--ses->ses_count > 0) {
2386                 spin_unlock(&cifs_tcp_ses_lock);
2387                 return;
2388         }
2389         if (ses->status == CifsGood)
2390                 ses->status = CifsExiting;
2391         spin_unlock(&cifs_tcp_ses_lock);
2392
2393         if (ses->status == CifsExiting && server->ops->logoff) {
2394                 xid = get_xid();
2395                 rc = server->ops->logoff(xid, ses);
2396                 if (rc)
2397                         cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2398                                 __func__, rc);
2399                 _free_xid(xid);
2400         }
2401
2402         spin_lock(&cifs_tcp_ses_lock);
2403         list_del_init(&ses->smb_ses_list);
2404         spin_unlock(&cifs_tcp_ses_lock);
2405
2406         sesInfoFree(ses);
2407         cifs_put_tcp_session(server, 0);
2408 }
2409
2410 #ifdef CONFIG_KEYS
2411
2412 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2413 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2414
2415 /* Populate username and pw fields from keyring if possible */
2416 static int
2417 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2418 {
2419         int rc = 0;
2420         const char *delim, *payload;
2421         char *desc;
2422         ssize_t len;
2423         struct key *key;
2424         struct TCP_Server_Info *server = ses->server;
2425         struct sockaddr_in *sa;
2426         struct sockaddr_in6 *sa6;
2427         const struct user_key_payload *upayload;
2428
2429         desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2430         if (!desc)
2431                 return -ENOMEM;
2432
2433         /* try to find an address key first */
2434         switch (server->dstaddr.ss_family) {
2435         case AF_INET:
2436                 sa = (struct sockaddr_in *)&server->dstaddr;
2437                 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2438                 break;
2439         case AF_INET6:
2440                 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2441                 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2442                 break;
2443         default:
2444                 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2445                          server->dstaddr.ss_family);
2446                 rc = -EINVAL;
2447                 goto out_err;
2448         }
2449
2450         cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2451         key = request_key(&key_type_logon, desc, "");
2452         if (IS_ERR(key)) {
2453                 if (!ses->domainName) {
2454                         cifs_dbg(FYI, "domainName is NULL\n");
2455                         rc = PTR_ERR(key);
2456                         goto out_err;
2457                 }
2458
2459                 /* didn't work, try to find a domain key */
2460                 sprintf(desc, "cifs:d:%s", ses->domainName);
2461                 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2462                 key = request_key(&key_type_logon, desc, "");
2463                 if (IS_ERR(key)) {
2464                         rc = PTR_ERR(key);
2465                         goto out_err;
2466                 }
2467         }
2468
2469         down_read(&key->sem);
2470         upayload = user_key_payload_locked(key);
2471         if (IS_ERR_OR_NULL(upayload)) {
2472                 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2473                 goto out_key_put;
2474         }
2475
2476         /* find first : in payload */
2477         payload = upayload->data;
2478         delim = strnchr(payload, upayload->datalen, ':');
2479         cifs_dbg(FYI, "payload=%s\n", payload);
2480         if (!delim) {
2481                 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2482                          upayload->datalen);
2483                 rc = -EINVAL;
2484                 goto out_key_put;
2485         }
2486
2487         len = delim - payload;
2488         if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
2489                 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2490                          len);
2491                 rc = -EINVAL;
2492                 goto out_key_put;
2493         }
2494
2495         vol->username = kstrndup(payload, len, GFP_KERNEL);
2496         if (!vol->username) {
2497                 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2498                          len);
2499                 rc = -ENOMEM;
2500                 goto out_key_put;
2501         }
2502         cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
2503
2504         len = key->datalen - (len + 1);
2505         if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
2506                 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
2507                 rc = -EINVAL;
2508                 kfree(vol->username);
2509                 vol->username = NULL;
2510                 goto out_key_put;
2511         }
2512
2513         ++delim;
2514         vol->password = kstrndup(delim, len, GFP_KERNEL);
2515         if (!vol->password) {
2516                 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2517                          len);
2518                 rc = -ENOMEM;
2519                 kfree(vol->username);
2520                 vol->username = NULL;
2521                 goto out_key_put;
2522         }
2523
2524 out_key_put:
2525         up_read(&key->sem);
2526         key_put(key);
2527 out_err:
2528         kfree(desc);
2529         cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
2530         return rc;
2531 }
2532 #else /* ! CONFIG_KEYS */
2533 static inline int
2534 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2535                    struct cifs_ses *ses __attribute__((unused)))
2536 {
2537         return -ENOSYS;
2538 }
2539 #endif /* CONFIG_KEYS */
2540
2541 static struct cifs_ses *
2542 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2543 {
2544         int rc = -ENOMEM;
2545         unsigned int xid;
2546         struct cifs_ses *ses;
2547         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2548         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2549
2550         xid = get_xid();
2551
2552         ses = cifs_find_smb_ses(server, volume_info);
2553         if (ses) {
2554                 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2555                          ses->status);
2556
2557                 mutex_lock(&ses->session_mutex);
2558                 rc = cifs_negotiate_protocol(xid, ses);
2559                 if (rc) {
2560                         mutex_unlock(&ses->session_mutex);
2561                         /* problem -- put our ses reference */
2562                         cifs_put_smb_ses(ses);
2563                         free_xid(xid);
2564                         return ERR_PTR(rc);
2565                 }
2566                 if (ses->need_reconnect) {
2567                         cifs_dbg(FYI, "Session needs reconnect\n");
2568                         rc = cifs_setup_session(xid, ses,
2569                                                 volume_info->local_nls);
2570                         if (rc) {
2571                                 mutex_unlock(&ses->session_mutex);
2572                                 /* problem -- put our reference */
2573                                 cifs_put_smb_ses(ses);
2574                                 free_xid(xid);
2575                                 return ERR_PTR(rc);
2576                         }
2577                 }
2578                 mutex_unlock(&ses->session_mutex);
2579
2580                 /* existing SMB ses has a server reference already */
2581                 cifs_put_tcp_session(server, 0);
2582                 free_xid(xid);
2583                 return ses;
2584         }
2585
2586         cifs_dbg(FYI, "Existing smb sess not found\n");
2587         ses = sesInfoAlloc();
2588         if (ses == NULL)
2589                 goto get_ses_fail;
2590
2591         /* new SMB session uses our server ref */
2592         ses->server = server;
2593         if (server->dstaddr.ss_family == AF_INET6)
2594                 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2595         else
2596                 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2597
2598         if (volume_info->username) {
2599                 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2600                 if (!ses->user_name)
2601                         goto get_ses_fail;
2602         }
2603
2604         /* volume_info->password freed at unmount */
2605         if (volume_info->password) {
2606                 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2607                 if (!ses->password)
2608                         goto get_ses_fail;
2609         }
2610         if (volume_info->domainname) {
2611                 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2612                 if (!ses->domainName)
2613                         goto get_ses_fail;
2614         }
2615         if (volume_info->domainauto)
2616                 ses->domainAuto = volume_info->domainauto;
2617         ses->cred_uid = volume_info->cred_uid;
2618         ses->linux_uid = volume_info->linux_uid;
2619
2620         ses->sectype = volume_info->sectype;
2621         ses->sign = volume_info->sign;
2622
2623         mutex_lock(&ses->session_mutex);
2624         rc = cifs_negotiate_protocol(xid, ses);
2625         if (!rc)
2626                 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2627         mutex_unlock(&ses->session_mutex);
2628         if (rc)
2629                 goto get_ses_fail;
2630
2631         /* success, put it on the list */
2632         spin_lock(&cifs_tcp_ses_lock);
2633         list_add(&ses->smb_ses_list, &server->smb_ses_list);
2634         spin_unlock(&cifs_tcp_ses_lock);
2635
2636         free_xid(xid);
2637         return ses;
2638
2639 get_ses_fail:
2640         sesInfoFree(ses);
2641         free_xid(xid);
2642         return ERR_PTR(rc);
2643 }
2644
2645 static int match_tcon(struct cifs_tcon *tcon, struct smb_vol *volume_info)
2646 {
2647         if (tcon->tidStatus == CifsExiting)
2648                 return 0;
2649         if (strncmp(tcon->treeName, volume_info->UNC, MAX_TREE_SIZE))
2650                 return 0;
2651         if (tcon->seal != volume_info->seal)
2652                 return 0;
2653         if (tcon->snapshot_time != volume_info->snapshot_time)
2654                 return 0;
2655         return 1;
2656 }
2657
2658 static struct cifs_tcon *
2659 cifs_find_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2660 {
2661         struct list_head *tmp;
2662         struct cifs_tcon *tcon;
2663
2664         spin_lock(&cifs_tcp_ses_lock);
2665         list_for_each(tmp, &ses->tcon_list) {
2666                 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2667                 if (!match_tcon(tcon, volume_info))
2668                         continue;
2669                 ++tcon->tc_count;
2670                 spin_unlock(&cifs_tcp_ses_lock);
2671                 return tcon;
2672         }
2673         spin_unlock(&cifs_tcp_ses_lock);
2674         return NULL;
2675 }
2676
2677 void
2678 cifs_put_tcon(struct cifs_tcon *tcon)
2679 {
2680         unsigned int xid;
2681         struct cifs_ses *ses = tcon->ses;
2682
2683         cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2684         spin_lock(&cifs_tcp_ses_lock);
2685         if (--tcon->tc_count > 0) {
2686                 spin_unlock(&cifs_tcp_ses_lock);
2687                 return;
2688         }
2689
2690         list_del_init(&tcon->tcon_list);
2691         spin_unlock(&cifs_tcp_ses_lock);
2692
2693         xid = get_xid();
2694         if (ses->server->ops->tree_disconnect)
2695                 ses->server->ops->tree_disconnect(xid, tcon);
2696         _free_xid(xid);
2697
2698         cifs_fscache_release_super_cookie(tcon);
2699         tconInfoFree(tcon);
2700         cifs_put_smb_ses(ses);
2701 }
2702
2703 static struct cifs_tcon *
2704 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2705 {
2706         int rc, xid;
2707         struct cifs_tcon *tcon;
2708
2709         tcon = cifs_find_tcon(ses, volume_info);
2710         if (tcon) {
2711                 cifs_dbg(FYI, "Found match on UNC path\n");
2712                 /* existing tcon already has a reference */
2713                 cifs_put_smb_ses(ses);
2714                 return tcon;
2715         }
2716
2717         if (!ses->server->ops->tree_connect) {
2718                 rc = -ENOSYS;
2719                 goto out_fail;
2720         }
2721
2722         tcon = tconInfoAlloc();
2723         if (tcon == NULL) {
2724                 rc = -ENOMEM;
2725                 goto out_fail;
2726         }
2727
2728         if (volume_info->snapshot_time) {
2729                 if (ses->server->vals->protocol_id == 0) {
2730                         cifs_dbg(VFS,
2731                              "Use SMB2 or later for snapshot mount option\n");
2732                         rc = -EOPNOTSUPP;
2733                         goto out_fail;
2734                 } else
2735                         tcon->snapshot_time = volume_info->snapshot_time;
2736         }
2737
2738         tcon->ses = ses;
2739         if (volume_info->password) {
2740                 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2741                 if (!tcon->password) {
2742                         rc = -ENOMEM;
2743                         goto out_fail;
2744                 }
2745         }
2746
2747         /*
2748          * BB Do we need to wrap session_mutex around this TCon call and Unix
2749          * SetFS as we do on SessSetup and reconnect?
2750          */
2751         xid = get_xid();
2752         rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2753                                             volume_info->local_nls);
2754         free_xid(xid);
2755         cifs_dbg(FYI, "Tcon rc = %d\n", rc);
2756         if (rc)
2757                 goto out_fail;
2758
2759         if (volume_info->nodfs) {
2760                 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2761                 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
2762         }
2763         tcon->use_persistent = false;
2764         /* check if SMB2 or later, CIFS does not support persistent handles */
2765         if (volume_info->persistent) {
2766                 if (ses->server->vals->protocol_id == 0) {
2767                         cifs_dbg(VFS,
2768                              "SMB3 or later required for persistent handles\n");
2769                         rc = -EOPNOTSUPP;
2770                         goto out_fail;
2771                 } else if (ses->server->capabilities &
2772                            SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2773                         tcon->use_persistent = true;
2774                 else /* persistent handles requested but not supported */ {
2775                         cifs_dbg(VFS,
2776                                 "Persistent handles not supported on share\n");
2777                         rc = -EOPNOTSUPP;
2778                         goto out_fail;
2779                 }
2780         } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
2781              && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2782              && (volume_info->nopersistent == false)) {
2783                 cifs_dbg(FYI, "enabling persistent handles\n");
2784                 tcon->use_persistent = true;
2785         } else if (volume_info->resilient) {
2786                 if (ses->server->vals->protocol_id == 0) {
2787                         cifs_dbg(VFS,
2788                              "SMB2.1 or later required for resilient handles\n");
2789                         rc = -EOPNOTSUPP;
2790                         goto out_fail;
2791                 }
2792                 tcon->use_resilient = true;
2793         }
2794
2795         if (volume_info->seal) {
2796                 if (ses->server->vals->protocol_id == 0) {
2797                         cifs_dbg(VFS,
2798                                  "SMB3 or later required for encryption\n");
2799                         rc = -EOPNOTSUPP;
2800                         goto out_fail;
2801                 } else if (tcon->ses->server->capabilities &
2802                                         SMB2_GLOBAL_CAP_ENCRYPTION)
2803                         tcon->seal = true;
2804                 else {
2805                         cifs_dbg(VFS, "Encryption is not supported on share\n");
2806                         rc = -EOPNOTSUPP;
2807                         goto out_fail;
2808                 }
2809         }
2810
2811         /*
2812          * We can have only one retry value for a connection to a share so for
2813          * resources mounted more than once to the same server share the last
2814          * value passed in for the retry flag is used.
2815          */
2816         tcon->retry = volume_info->retry;
2817         tcon->nocase = volume_info->nocase;
2818         tcon->local_lease = volume_info->local_lease;
2819         INIT_LIST_HEAD(&tcon->pending_opens);
2820
2821         spin_lock(&cifs_tcp_ses_lock);
2822         list_add(&tcon->tcon_list, &ses->tcon_list);
2823         spin_unlock(&cifs_tcp_ses_lock);
2824
2825         cifs_fscache_get_super_cookie(tcon);
2826
2827         return tcon;
2828
2829 out_fail:
2830         tconInfoFree(tcon);
2831         return ERR_PTR(rc);
2832 }
2833
2834 void
2835 cifs_put_tlink(struct tcon_link *tlink)
2836 {
2837         if (!tlink || IS_ERR(tlink))
2838                 return;
2839
2840         if (!atomic_dec_and_test(&tlink->tl_count) ||
2841             test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2842                 tlink->tl_time = jiffies;
2843                 return;
2844         }
2845
2846         if (!IS_ERR(tlink_tcon(tlink)))
2847                 cifs_put_tcon(tlink_tcon(tlink));
2848         kfree(tlink);
2849         return;
2850 }
2851
2852 static inline struct tcon_link *
2853 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2854 {
2855         return cifs_sb->master_tlink;
2856 }
2857
2858 static int
2859 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2860 {
2861         struct cifs_sb_info *old = CIFS_SB(sb);
2862         struct cifs_sb_info *new = mnt_data->cifs_sb;
2863
2864         if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2865                 return 0;
2866
2867         if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2868             (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2869                 return 0;
2870
2871         /*
2872          * We want to share sb only if we don't specify an r/wsize or
2873          * specified r/wsize is greater than or equal to existing one.
2874          */
2875         if (new->wsize && new->wsize < old->wsize)
2876                 return 0;
2877
2878         if (new->rsize && new->rsize < old->rsize)
2879                 return 0;
2880
2881         if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
2882                 return 0;
2883
2884         if (old->mnt_file_mode != new->mnt_file_mode ||
2885             old->mnt_dir_mode != new->mnt_dir_mode)
2886                 return 0;
2887
2888         if (strcmp(old->local_nls->charset, new->local_nls->charset))
2889                 return 0;
2890
2891         if (old->actimeo != new->actimeo)
2892                 return 0;
2893
2894         return 1;
2895 }
2896
2897 static int
2898 match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2899 {
2900         struct cifs_sb_info *old = CIFS_SB(sb);
2901         struct cifs_sb_info *new = mnt_data->cifs_sb;
2902         bool old_set = old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH;
2903         bool new_set = new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH;
2904
2905         if (old_set && new_set && !strcmp(new->prepath, old->prepath))
2906                 return 1;
2907         else if (!old_set && !new_set)
2908                 return 1;
2909
2910         return 0;
2911 }
2912
2913 int
2914 cifs_match_super(struct super_block *sb, void *data)
2915 {
2916         struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2917         struct smb_vol *volume_info;
2918         struct cifs_sb_info *cifs_sb;
2919         struct TCP_Server_Info *tcp_srv;
2920         struct cifs_ses *ses;
2921         struct cifs_tcon *tcon;
2922         struct tcon_link *tlink;
2923         int rc = 0;
2924
2925         spin_lock(&cifs_tcp_ses_lock);
2926         cifs_sb = CIFS_SB(sb);
2927         tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2928         if (IS_ERR(tlink)) {
2929                 spin_unlock(&cifs_tcp_ses_lock);
2930                 return rc;
2931         }
2932         tcon = tlink_tcon(tlink);
2933         ses = tcon->ses;
2934         tcp_srv = ses->server;
2935
2936         volume_info = mnt_data->vol;
2937
2938         if (!match_server(tcp_srv, volume_info) ||
2939             !match_session(ses, volume_info) ||
2940             !match_tcon(tcon, volume_info) ||
2941             !match_prepath(sb, mnt_data)) {
2942                 rc = 0;
2943                 goto out;
2944         }
2945
2946         rc = compare_mount_options(sb, mnt_data);
2947 out:
2948         spin_unlock(&cifs_tcp_ses_lock);
2949         cifs_put_tlink(tlink);
2950         return rc;
2951 }
2952
2953 int
2954 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2955              const struct nls_table *nls_codepage, unsigned int *num_referrals,
2956              struct dfs_info3_param **referrals, int remap)
2957 {
2958         char *temp_unc;
2959         int rc = 0;
2960
2961         if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2962                 return -ENOSYS;
2963
2964         *num_referrals = 0;
2965         *referrals = NULL;
2966
2967         if (ses->ipc_tid == 0) {
2968                 temp_unc = kmalloc(2 /* for slashes */ +
2969                         strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2970                                 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
2971                 if (temp_unc == NULL)
2972                         return -ENOMEM;
2973                 temp_unc[0] = '\\';
2974                 temp_unc[1] = '\\';
2975                 strcpy(temp_unc + 2, ses->serverName);
2976                 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2977                 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2978                                                     nls_codepage);
2979                 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
2980                 kfree(temp_unc);
2981         }
2982         if (rc == 0)
2983                 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2984                                                      referrals, num_referrals,
2985                                                      nls_codepage, remap);
2986         /*
2987          * BB - map targetUNCs to dfs_info3 structures, here or in
2988          * ses->server->ops->get_dfs_refer.
2989          */
2990
2991         return rc;
2992 }
2993
2994 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2995 static struct lock_class_key cifs_key[2];
2996 static struct lock_class_key cifs_slock_key[2];
2997
2998 static inline void
2999 cifs_reclassify_socket4(struct socket *sock)
3000 {
3001         struct sock *sk = sock->sk;
3002         BUG_ON(!sock_allow_reclassification(sk));
3003         sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
3004                 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
3005 }
3006
3007 static inline void
3008 cifs_reclassify_socket6(struct socket *sock)
3009 {
3010         struct sock *sk = sock->sk;
3011         BUG_ON(!sock_allow_reclassification(sk));
3012         sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
3013                 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
3014 }
3015 #else
3016 static inline void
3017 cifs_reclassify_socket4(struct socket *sock)
3018 {
3019 }
3020
3021 static inline void
3022 cifs_reclassify_socket6(struct socket *sock)
3023 {
3024 }
3025 #endif
3026
3027 /* See RFC1001 section 14 on representation of Netbios names */
3028 static void rfc1002mangle(char *target, char *source, unsigned int length)
3029 {
3030         unsigned int i, j;
3031
3032         for (i = 0, j = 0; i < (length); i++) {
3033                 /* mask a nibble at a time and encode */
3034                 target[j] = 'A' + (0x0F & (source[i] >> 4));
3035                 target[j+1] = 'A' + (0x0F & source[i]);
3036                 j += 2;
3037         }
3038
3039 }
3040
3041 static int
3042 bind_socket(struct TCP_Server_Info *server)
3043 {
3044         int rc = 0;
3045         if (server->srcaddr.ss_family != AF_UNSPEC) {
3046                 /* Bind to the specified local IP address */
3047                 struct socket *socket = server->ssocket;
3048                 rc = socket->ops->bind(socket,
3049                                        (struct sockaddr *) &server->srcaddr,
3050                                        sizeof(server->srcaddr));
3051                 if (rc < 0) {
3052                         struct sockaddr_in *saddr4;
3053                         struct sockaddr_in6 *saddr6;
3054                         saddr4 = (struct sockaddr_in *)&server->srcaddr;
3055                         saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
3056                         if (saddr6->sin6_family == AF_INET6)
3057                                 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
3058                                          &saddr6->sin6_addr, rc);
3059                         else
3060                                 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
3061                                          &saddr4->sin_addr.s_addr, rc);
3062                 }
3063         }
3064         return rc;
3065 }
3066
3067 static int
3068 ip_rfc1001_connect(struct TCP_Server_Info *server)
3069 {
3070         int rc = 0;
3071         /*
3072          * some servers require RFC1001 sessinit before sending
3073          * negprot - BB check reconnection in case where second
3074          * sessinit is sent but no second negprot
3075          */
3076         struct rfc1002_session_packet *ses_init_buf;
3077         struct smb_hdr *smb_buf;
3078         ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
3079                                GFP_KERNEL);
3080         if (ses_init_buf) {
3081                 ses_init_buf->trailer.session_req.called_len = 32;
3082
3083                 if (server->server_RFC1001_name[0] != 0)
3084                         rfc1002mangle(ses_init_buf->trailer.
3085                                       session_req.called_name,
3086                                       server->server_RFC1001_name,
3087                                       RFC1001_NAME_LEN_WITH_NULL);
3088                 else
3089                         rfc1002mangle(ses_init_buf->trailer.
3090                                       session_req.called_name,
3091                                       DEFAULT_CIFS_CALLED_NAME,
3092                                       RFC1001_NAME_LEN_WITH_NULL);
3093
3094                 ses_init_buf->trailer.session_req.calling_len = 32;
3095
3096                 /*
3097                  * calling name ends in null (byte 16) from old smb
3098                  * convention.
3099                  */
3100                 if (server->workstation_RFC1001_name[0] != 0)
3101                         rfc1002mangle(ses_init_buf->trailer.
3102                                       session_req.calling_name,
3103                                       server->workstation_RFC1001_name,
3104                                       RFC1001_NAME_LEN_WITH_NULL);
3105                 else
3106                         rfc1002mangle(ses_init_buf->trailer.
3107                                       session_req.calling_name,
3108                                       "LINUX_CIFS_CLNT",
3109                                       RFC1001_NAME_LEN_WITH_NULL);
3110
3111                 ses_init_buf->trailer.session_req.scope1 = 0;
3112                 ses_init_buf->trailer.session_req.scope2 = 0;
3113                 smb_buf = (struct smb_hdr *)ses_init_buf;
3114
3115                 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3116                 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3117                 rc = smb_send(server, smb_buf, 0x44);
3118                 kfree(ses_init_buf);
3119                 /*
3120                  * RFC1001 layer in at least one server
3121                  * requires very short break before negprot
3122                  * presumably because not expecting negprot
3123                  * to follow so fast.  This is a simple
3124                  * solution that works without
3125                  * complicating the code and causes no
3126                  * significant slowing down on mount
3127                  * for everyone else
3128                  */
3129                 usleep_range(1000, 2000);
3130         }
3131         /*
3132          * else the negprot may still work without this
3133          * even though malloc failed
3134          */
3135
3136         return rc;
3137 }
3138
3139 static int
3140 generic_ip_connect(struct TCP_Server_Info *server)
3141 {
3142         int rc = 0;
3143         __be16 sport;
3144         int slen, sfamily;
3145         struct socket *socket = server->ssocket;
3146         struct sockaddr *saddr;
3147
3148         saddr = (struct sockaddr *) &server->dstaddr;
3149
3150         if (server->dstaddr.ss_family == AF_INET6) {
3151                 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3152                 slen = sizeof(struct sockaddr_in6);
3153                 sfamily = AF_INET6;
3154         } else {
3155                 sport = ((struct sockaddr_in *) saddr)->sin_port;
3156                 slen = sizeof(struct sockaddr_in);
3157                 sfamily = AF_INET;
3158         }
3159
3160         if (socket == NULL) {
3161                 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3162                                    IPPROTO_TCP, &socket, 1);
3163                 if (rc < 0) {
3164                         cifs_dbg(VFS, "Error %d creating socket\n", rc);
3165                         server->ssocket = NULL;
3166                         return rc;
3167                 }
3168
3169                 /* BB other socket options to set KEEPALIVE, NODELAY? */
3170                 cifs_dbg(FYI, "Socket created\n");
3171                 server->ssocket = socket;
3172                 socket->sk->sk_allocation = GFP_NOFS;
3173                 if (sfamily == AF_INET6)
3174                         cifs_reclassify_socket6(socket);
3175                 else
3176                         cifs_reclassify_socket4(socket);
3177         }
3178
3179         rc = bind_socket(server);
3180         if (rc < 0)
3181                 return rc;
3182
3183         /*
3184          * Eventually check for other socket options to change from
3185          * the default. sock_setsockopt not used because it expects
3186          * user space buffer
3187          */
3188         socket->sk->sk_rcvtimeo = 7 * HZ;
3189         socket->sk->sk_sndtimeo = 5 * HZ;
3190
3191         /* make the bufsizes depend on wsize/rsize and max requests */
3192         if (server->noautotune) {
3193                 if (socket->sk->sk_sndbuf < (200 * 1024))
3194                         socket->sk->sk_sndbuf = 200 * 1024;
3195                 if (socket->sk->sk_rcvbuf < (140 * 1024))
3196                         socket->sk->sk_rcvbuf = 140 * 1024;
3197         }
3198
3199         if (server->tcp_nodelay) {
3200                 int val = 1;
3201                 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3202                                 (char *)&val, sizeof(val));
3203                 if (rc)
3204                         cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3205                                  rc);
3206         }
3207
3208         cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3209                  socket->sk->sk_sndbuf,
3210                  socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3211
3212         rc = socket->ops->connect(socket, saddr, slen, 0);
3213         if (rc < 0) {
3214                 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3215                 sock_release(socket);
3216                 server->ssocket = NULL;
3217                 return rc;
3218         }
3219
3220         if (sport == htons(RFC1001_PORT))
3221                 rc = ip_rfc1001_connect(server);
3222
3223         return rc;
3224 }
3225
3226 static int
3227 ip_connect(struct TCP_Server_Info *server)
3228 {
3229         __be16 *sport;
3230         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3231         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3232
3233         if (server->dstaddr.ss_family == AF_INET6)
3234                 sport = &addr6->sin6_port;
3235         else
3236                 sport = &addr->sin_port;
3237
3238         if (*sport == 0) {
3239                 int rc;
3240
3241                 /* try with 445 port at first */
3242                 *sport = htons(CIFS_PORT);
3243
3244                 rc = generic_ip_connect(server);
3245                 if (rc >= 0)
3246                         return rc;
3247
3248                 /* if it failed, try with 139 port */
3249                 *sport = htons(RFC1001_PORT);
3250         }
3251
3252         return generic_ip_connect(server);
3253 }
3254
3255 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3256                           struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3257 {
3258         /* if we are reconnecting then should we check to see if
3259          * any requested capabilities changed locally e.g. via
3260          * remount but we can not do much about it here
3261          * if they have (even if we could detect it by the following)
3262          * Perhaps we could add a backpointer to array of sb from tcon
3263          * or if we change to make all sb to same share the same
3264          * sb as NFS - then we only have one backpointer to sb.
3265          * What if we wanted to mount the server share twice once with
3266          * and once without posixacls or posix paths? */
3267         __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3268
3269         if (vol_info && vol_info->no_linux_ext) {
3270                 tcon->fsUnixInfo.Capability = 0;
3271                 tcon->unix_ext = 0; /* Unix Extensions disabled */
3272                 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3273                 return;
3274         } else if (vol_info)
3275                 tcon->unix_ext = 1; /* Unix Extensions supported */
3276
3277         if (tcon->unix_ext == 0) {
3278                 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3279                 return;
3280         }
3281
3282         if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3283                 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3284                 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3285                 /* check for reconnect case in which we do not
3286                    want to change the mount behavior if we can avoid it */
3287                 if (vol_info == NULL) {
3288                         /* turn off POSIX ACL and PATHNAMES if not set
3289                            originally at mount time */
3290                         if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3291                                 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3292                         if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3293                                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3294                                         cifs_dbg(VFS, "POSIXPATH support change\n");
3295                                 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3296                         } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3297                                 cifs_dbg(VFS, "possible reconnect error\n");
3298                                 cifs_dbg(VFS, "server disabled POSIX path support\n");
3299                         }
3300                 }
3301
3302                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3303                         cifs_dbg(VFS, "per-share encryption not supported yet\n");
3304
3305                 cap &= CIFS_UNIX_CAP_MASK;
3306                 if (vol_info && vol_info->no_psx_acl)
3307                         cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3308                 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3309                         cifs_dbg(FYI, "negotiated posix acl support\n");
3310                         if (cifs_sb)
3311                                 cifs_sb->mnt_cifs_flags |=
3312                                         CIFS_MOUNT_POSIXACL;
3313                 }
3314
3315                 if (vol_info && vol_info->posix_paths == 0)
3316                         cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3317                 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3318                         cifs_dbg(FYI, "negotiate posix pathnames\n");
3319                         if (cifs_sb)
3320                                 cifs_sb->mnt_cifs_flags |=
3321                                         CIFS_MOUNT_POSIX_PATHS;
3322                 }
3323
3324                 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3325 #ifdef CONFIG_CIFS_DEBUG2
3326                 if (cap & CIFS_UNIX_FCNTL_CAP)
3327                         cifs_dbg(FYI, "FCNTL cap\n");
3328                 if (cap & CIFS_UNIX_EXTATTR_CAP)
3329                         cifs_dbg(FYI, "EXTATTR cap\n");
3330                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3331                         cifs_dbg(FYI, "POSIX path cap\n");
3332                 if (cap & CIFS_UNIX_XATTR_CAP)
3333                         cifs_dbg(FYI, "XATTR cap\n");
3334                 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3335                         cifs_dbg(FYI, "POSIX ACL cap\n");
3336                 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3337                         cifs_dbg(FYI, "very large read cap\n");
3338                 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3339                         cifs_dbg(FYI, "very large write cap\n");
3340                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3341                         cifs_dbg(FYI, "transport encryption cap\n");
3342                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3343                         cifs_dbg(FYI, "mandatory transport encryption cap\n");
3344 #endif /* CIFS_DEBUG2 */
3345                 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3346                         if (vol_info == NULL) {
3347                                 cifs_dbg(FYI, "resetting capabilities failed\n");
3348                         } else
3349                                 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");
3350
3351                 }
3352         }
3353 }
3354
3355 int cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3356                         struct cifs_sb_info *cifs_sb)
3357 {
3358         INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3359
3360         spin_lock_init(&cifs_sb->tlink_tree_lock);
3361         cifs_sb->tlink_tree = RB_ROOT;
3362
3363         /*
3364          * Temporarily set r/wsize for matching superblock. If we end up using
3365          * new sb then client will later negotiate it downward if needed.
3366          */
3367         cifs_sb->rsize = pvolume_info->rsize;
3368         cifs_sb->wsize = pvolume_info->wsize;
3369
3370         cifs_sb->mnt_uid = pvolume_info->linux_uid;
3371         cifs_sb->mnt_gid = pvolume_info->linux_gid;
3372         cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3373         cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3374         cifs_dbg(FYI, "file mode: 0x%hx  dir mode: 0x%hx\n",
3375                  cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3376
3377         cifs_sb->actimeo = pvolume_info->actimeo;
3378         cifs_sb->local_nls = pvolume_info->local_nls;
3379
3380         if (pvolume_info->noperm)
3381                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3382         if (pvolume_info->setuids)
3383                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3384         if (pvolume_info->setuidfromacl)
3385                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
3386         if (pvolume_info->server_ino)
3387                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3388         if (pvolume_info->remap)
3389                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3390         if (pvolume_info->sfu_remap)
3391                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3392         if (pvolume_info->no_xattr)
3393                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3394         if (pvolume_info->sfu_emul)
3395                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3396         if (pvolume_info->nobrl)
3397                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3398         if (pvolume_info->nostrictsync)
3399                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3400         if (pvolume_info->mand_lock)
3401                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3402         if (pvolume_info->rwpidforward)
3403                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3404         if (pvolume_info->cifs_acl)
3405                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3406         if (pvolume_info->backupuid_specified) {
3407                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3408                 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3409         }
3410         if (pvolume_info->backupgid_specified) {
3411                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3412                 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3413         }
3414         if (pvolume_info->override_uid)
3415                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3416         if (pvolume_info->override_gid)
3417                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3418         if (pvolume_info->dynperm)
3419                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3420         if (pvolume_info->fsc)
3421                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3422         if (pvolume_info->multiuser)
3423                 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3424                                             CIFS_MOUNT_NO_PERM);
3425         if (pvolume_info->strict_io)
3426                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3427         if (pvolume_info->direct_io) {
3428                 cifs_dbg(FYI, "mounting share using direct i/o\n");
3429                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3430         }
3431         if (pvolume_info->mfsymlinks) {
3432                 if (pvolume_info->sfu_emul) {
3433                         /*
3434                          * Our SFU ("Services for Unix" emulation does not allow
3435                          * creating symlinks but does allow reading existing SFU
3436                          * symlinks (it does allow both creating and reading SFU
3437                          * style mknod and FIFOs though). When "mfsymlinks" and
3438                          * "sfu" are both enabled at the same time, it allows
3439                          * reading both types of symlinks, but will only create
3440                          * them with mfsymlinks format. This allows better
3441                          * Apple compatibility (probably better for Samba too)
3442                          * while still recognizing old Windows style symlinks.
3443                          */
3444                         cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
3445                 }
3446                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3447         }
3448
3449         if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3450                 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
3451
3452         if (pvolume_info->prepath) {
3453                 cifs_sb->prepath = kstrdup(pvolume_info->prepath, GFP_KERNEL);
3454                 if (cifs_sb->prepath == NULL)
3455                         return -ENOMEM;
3456         }
3457
3458         return 0;
3459 }
3460
3461 static void
3462 cleanup_volume_info_contents(struct smb_vol *volume_info)
3463 {
3464         kfree(volume_info->username);
3465         kzfree(volume_info->password);
3466         kfree(volume_info->UNC);
3467         kfree(volume_info->domainname);
3468         kfree(volume_info->iocharset);
3469         kfree(volume_info->prepath);
3470 }
3471
3472 void
3473 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3474 {
3475         if (!volume_info)
3476                 return;
3477         cleanup_volume_info_contents(volume_info);
3478         kfree(volume_info);
3479 }
3480
3481
3482 #ifdef CONFIG_CIFS_DFS_UPCALL
3483 /*
3484  * cifs_build_path_to_root returns full path to root when we do not have an
3485  * exiting connection (tcon)
3486  */
3487 static char *
3488 build_unc_path_to_root(const struct smb_vol *vol,
3489                 const struct cifs_sb_info *cifs_sb)
3490 {
3491         char *full_path, *pos;
3492         unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
3493         unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3494
3495         full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3496         if (full_path == NULL)
3497                 return ERR_PTR(-ENOMEM);
3498
3499         strncpy(full_path, vol->UNC, unc_len);
3500         pos = full_path + unc_len;
3501
3502         if (pplen) {
3503                 *pos = CIFS_DIR_SEP(cifs_sb);
3504                 strncpy(pos + 1, vol->prepath, pplen);
3505                 pos += pplen;
3506         }
3507
3508         *pos = '\0'; /* add trailing null */
3509         convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3510         cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
3511         return full_path;
3512 }
3513
3514 /*
3515  * Perform a dfs referral query for a share and (optionally) prefix
3516  *
3517  * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3518  * to a string containing updated options for the submount.  Otherwise it
3519  * will be left untouched.
3520  *
3521  * Returns the rc from get_dfs_path to the caller, which can be used to
3522  * determine whether there were referrals.
3523  */
3524 static int
3525 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
3526                     struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3527                     int check_prefix)
3528 {
3529         int rc;
3530         unsigned int num_referrals = 0;
3531         struct dfs_info3_param *referrals = NULL;
3532         char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3533
3534         full_path = build_unc_path_to_root(volume_info, cifs_sb);
3535         if (IS_ERR(full_path))
3536                 return PTR_ERR(full_path);
3537
3538         /* For DFS paths, skip the first '\' of the UNC */
3539         ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3540
3541         rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
3542                           &num_referrals, &referrals, cifs_remap(cifs_sb));
3543
3544         if (!rc && num_referrals > 0) {
3545                 char *fake_devname = NULL;
3546
3547                 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3548                                                    full_path + 1, referrals,
3549                                                    &fake_devname);
3550
3551                 free_dfs_info_array(referrals, num_referrals);
3552
3553                 if (IS_ERR(mdata)) {
3554                         rc = PTR_ERR(mdata);
3555                         mdata = NULL;
3556                 } else {
3557                         cleanup_volume_info_contents(volume_info);
3558                         rc = cifs_setup_volume_info(volume_info, mdata,
3559                                                         fake_devname);
3560                 }
3561                 kfree(fake_devname);
3562                 kfree(cifs_sb->mountdata);
3563                 cifs_sb->mountdata = mdata;
3564         }
3565         kfree(full_path);
3566         return rc;
3567 }
3568 #endif
3569
3570 static int
3571 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3572                         const char *devname)
3573 {
3574         int rc = 0;
3575
3576         if (cifs_parse_mount_options(mount_data, devname, volume_info))
3577                 return -EINVAL;
3578
3579         if (volume_info->nullauth) {
3580                 cifs_dbg(FYI, "Anonymous login\n");
3581                 kfree(volume_info->username);
3582                 volume_info->username = NULL;
3583         } else if (volume_info->username) {
3584                 /* BB fixme parse for domain name here */
3585                 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
3586         } else {
3587                 cifs_dbg(VFS, "No username specified\n");
3588         /* In userspace mount helper we can get user name from alternate
3589            locations such as env variables and files on disk */
3590                 return -EINVAL;
3591         }
3592
3593         /* this is needed for ASCII cp to Unicode converts */
3594         if (volume_info->iocharset == NULL) {
3595                 /* load_nls_default cannot return null */
3596                 volume_info->local_nls = load_nls_default();
3597         } else {
3598                 volume_info->local_nls = load_nls(volume_info->iocharset);
3599                 if (volume_info->local_nls == NULL) {
3600                         cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
3601                                  volume_info->iocharset);
3602                         return -ELIBACC;
3603                 }
3604         }
3605
3606         return rc;
3607 }
3608
3609 struct smb_vol *
3610 cifs_get_volume_info(char *mount_data, const char *devname)
3611 {
3612         int rc;
3613         struct smb_vol *volume_info;
3614
3615         volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
3616         if (!volume_info)
3617                 return ERR_PTR(-ENOMEM);
3618
3619         rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3620         if (rc) {
3621                 cifs_cleanup_volume_info(volume_info);
3622                 volume_info = ERR_PTR(rc);
3623         }
3624
3625         return volume_info;
3626 }
3627
3628 static int
3629 cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
3630                                         unsigned int xid,
3631                                         struct cifs_tcon *tcon,
3632                                         struct cifs_sb_info *cifs_sb,
3633                                         char *full_path)
3634 {
3635         int rc;
3636         char *s;
3637         char sep, tmp;
3638
3639         sep = CIFS_DIR_SEP(cifs_sb);
3640         s = full_path;
3641
3642         rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
3643         while (rc == 0) {
3644                 /* skip separators */
3645                 while (*s == sep)
3646                         s++;
3647                 if (!*s)
3648                         break;
3649                 /* next separator */
3650                 while (*s && *s != sep)
3651                         s++;
3652
3653                 /*
3654                  * temporarily null-terminate the path at the end of
3655                  * the current component
3656                  */
3657                 tmp = *s;
3658                 *s = 0;
3659                 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3660                                                      full_path);
3661                 *s = tmp;
3662         }
3663         return rc;
3664 }
3665
3666 int
3667 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3668 {
3669         int rc;
3670         unsigned int xid;
3671         struct cifs_ses *ses;
3672         struct cifs_tcon *tcon;
3673         struct TCP_Server_Info *server;
3674         char   *full_path;
3675         struct tcon_link *tlink;
3676 #ifdef CONFIG_CIFS_DFS_UPCALL
3677         int referral_walks_count = 0;
3678 #endif
3679
3680 #ifdef CONFIG_CIFS_DFS_UPCALL
3681 try_mount_again:
3682         /* cleanup activities if we're chasing a referral */
3683         if (referral_walks_count) {
3684                 if (tcon)
3685                         cifs_put_tcon(tcon);
3686                 else if (ses)
3687                         cifs_put_smb_ses(ses);
3688
3689                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
3690
3691                 free_xid(xid);
3692         }
3693 #endif
3694         rc = 0;
3695         tcon = NULL;
3696         ses = NULL;
3697         server = NULL;
3698         full_path = NULL;
3699         tlink = NULL;
3700
3701         xid = get_xid();
3702
3703         /* get a reference to a tcp session */
3704         server = cifs_get_tcp_session(volume_info);
3705         if (IS_ERR(server)) {
3706                 rc = PTR_ERR(server);
3707                 goto out;
3708         }
3709         if ((volume_info->max_credits < 20) ||
3710              (volume_info->max_credits > 60000))
3711                 server->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
3712         else
3713                 server->max_credits = volume_info->max_credits;
3714         /* get a reference to a SMB session */
3715         ses = cifs_get_smb_ses(server, volume_info);
3716         if (IS_ERR(ses)) {
3717                 rc = PTR_ERR(ses);
3718                 ses = NULL;
3719                 goto mount_fail_check;
3720         }
3721
3722         if ((volume_info->persistent == true) && ((ses->server->capabilities &
3723                 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES) == 0)) {
3724                 cifs_dbg(VFS, "persistent handles not supported by server\n");
3725                 rc = -EOPNOTSUPP;
3726                 goto mount_fail_check;
3727         }
3728
3729         /* search for existing tcon to this server share */
3730         tcon = cifs_get_tcon(ses, volume_info);
3731         if (IS_ERR(tcon)) {
3732                 rc = PTR_ERR(tcon);
3733                 tcon = NULL;
3734                 if (rc == -EACCES)
3735                         goto mount_fail_check;
3736
3737                 goto remote_path_check;
3738         }
3739
3740         /* tell server which Unix caps we support */
3741         if (cap_unix(tcon->ses)) {
3742                 /* reset of caps checks mount to see if unix extensions
3743                    disabled for just this mount */
3744                 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3745                 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3746                     (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3747                      CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3748                         rc = -EACCES;
3749                         goto mount_fail_check;
3750                 }
3751         } else
3752                 tcon->unix_ext = 0; /* server does not support them */
3753
3754         /* do not care if a following call succeed - informational */
3755         if (!tcon->ipc && server->ops->qfs_tcon)
3756                 server->ops->qfs_tcon(xid, tcon);
3757
3758         cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3759         cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
3760
3761 remote_path_check:
3762 #ifdef CONFIG_CIFS_DFS_UPCALL
3763         /*
3764          * Perform an unconditional check for whether there are DFS
3765          * referrals for this path without prefix, to provide support
3766          * for DFS referrals from w2k8 servers which don't seem to respond
3767          * with PATH_NOT_COVERED to requests that include the prefix.
3768          * Chase the referral if found, otherwise continue normally.
3769          */
3770         if (referral_walks_count == 0) {
3771                 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3772                                                 false);
3773                 if (!refrc) {
3774                         referral_walks_count++;
3775                         goto try_mount_again;
3776                 }
3777         }
3778 #endif
3779
3780         /* check if a whole path is not remote */
3781         if (!rc && tcon) {
3782                 if (!server->ops->is_path_accessible) {
3783                         rc = -ENOSYS;
3784                         goto mount_fail_check;
3785                 }
3786                 /*
3787                  * cifs_build_path_to_root works only when we have a valid tcon
3788                  */
3789                 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon,
3790                                         tcon->Flags & SMB_SHARE_IS_IN_DFS);
3791                 if (full_path == NULL) {
3792                         rc = -ENOMEM;
3793                         goto mount_fail_check;
3794                 }
3795                 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3796                                                      full_path);
3797                 if (rc != 0 && rc != -EREMOTE) {
3798                         kfree(full_path);
3799                         goto mount_fail_check;
3800                 }
3801
3802                 if (rc != -EREMOTE) {
3803                         rc = cifs_are_all_path_components_accessible(server,
3804                                                              xid, tcon, cifs_sb,
3805                                                              full_path);
3806                         if (rc != 0) {
3807                                 cifs_dbg(VFS, "cannot query dirs between root and final path, "
3808                                          "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
3809                                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
3810                                 rc = 0;
3811                         }
3812                 }
3813                 kfree(full_path);
3814         }
3815
3816         /* get referral if needed */
3817         if (rc == -EREMOTE) {
3818 #ifdef CONFIG_CIFS_DFS_UPCALL
3819                 if (referral_walks_count > MAX_NESTED_LINKS) {
3820                         /*
3821                          * BB: when we implement proper loop detection,
3822                          *     we will remove this check. But now we need it
3823                          *     to prevent an indefinite loop if 'DFS tree' is
3824                          *     misconfigured (i.e. has loops).
3825                          */
3826                         rc = -ELOOP;
3827                         goto mount_fail_check;
3828                 }
3829
3830                 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
3831
3832                 if (!rc) {
3833                         referral_walks_count++;
3834                         goto try_mount_again;
3835                 }
3836                 goto mount_fail_check;
3837 #else /* No DFS support, return error on mount */
3838                 rc = -EOPNOTSUPP;
3839 #endif
3840         }
3841
3842         if (rc)
3843                 goto mount_fail_check;
3844
3845         /* now, hang the tcon off of the superblock */
3846         tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3847         if (tlink == NULL) {
3848                 rc = -ENOMEM;
3849                 goto mount_fail_check;
3850         }
3851
3852         tlink->tl_uid = ses->linux_uid;
3853         tlink->tl_tcon = tcon;
3854         tlink->tl_time = jiffies;
3855         set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3856         set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3857
3858         cifs_sb->master_tlink = tlink;
3859         spin_lock(&cifs_sb->tlink_tree_lock);
3860         tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3861         spin_unlock(&cifs_sb->tlink_tree_lock);
3862
3863         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3864                                 TLINK_IDLE_EXPIRE);
3865
3866 mount_fail_check:
3867         /* on error free sesinfo and tcon struct if needed */
3868         if (rc) {
3869                 /* If find_unc succeeded then rc == 0 so we can not end */
3870                 /* up accidentally freeing someone elses tcon struct */
3871                 if (tcon)
3872                         cifs_put_tcon(tcon);
3873                 else if (ses)
3874                         cifs_put_smb_ses(ses);
3875                 else
3876                         cifs_put_tcp_session(server, 0);
3877         }
3878
3879 out:
3880         free_xid(xid);
3881         return rc;
3882 }
3883
3884 /*
3885  * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3886  * pointer may be NULL.
3887  */
3888 int
3889 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3890          const char *tree, struct cifs_tcon *tcon,
3891          const struct nls_table *nls_codepage)
3892 {
3893         struct smb_hdr *smb_buffer;
3894         struct smb_hdr *smb_buffer_response;
3895         TCONX_REQ *pSMB;
3896         TCONX_RSP *pSMBr;
3897         unsigned char *bcc_ptr;
3898         int rc = 0;
3899         int length;
3900         __u16 bytes_left, count;
3901
3902         if (ses == NULL)
3903                 return -EIO;
3904
3905         smb_buffer = cifs_buf_get();
3906         if (smb_buffer == NULL)
3907                 return -ENOMEM;
3908
3909         smb_buffer_response = smb_buffer;
3910
3911         header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3912                         NULL /*no tid */ , 4 /*wct */ );
3913
3914         smb_buffer->Mid = get_next_mid(ses->server);
3915         smb_buffer->Uid = ses->Suid;
3916         pSMB = (TCONX_REQ *) smb_buffer;
3917         pSMBr = (TCONX_RSP *) smb_buffer_response;
3918
3919         pSMB->AndXCommand = 0xFF;
3920         pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3921         bcc_ptr = &pSMB->Password[0];
3922         if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3923                 pSMB->PasswordLength = cpu_to_le16(1);  /* minimum */
3924                 *bcc_ptr = 0; /* password is null byte */
3925                 bcc_ptr++;              /* skip password */
3926                 /* already aligned so no need to do it below */
3927         } else {
3928                 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3929                 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3930                    specified as required (when that support is added to
3931                    the vfs in the future) as only NTLM or the much
3932                    weaker LANMAN (which we do not send by default) is accepted
3933                    by Samba (not sure whether other servers allow
3934                    NTLMv2 password here) */
3935 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3936                 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3937                     (ses->sectype == LANMAN))
3938                         calc_lanman_hash(tcon->password, ses->server->cryptkey,
3939                                          ses->server->sec_mode &
3940                                             SECMODE_PW_ENCRYPT ? true : false,
3941                                          bcc_ptr);
3942                 else
3943 #endif /* CIFS_WEAK_PW_HASH */
3944                 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3945                                         bcc_ptr, nls_codepage);
3946                 if (rc) {
3947                         cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
3948                                  __func__, rc);
3949                         cifs_buf_release(smb_buffer);
3950                         return rc;
3951                 }
3952
3953                 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3954                 if (ses->capabilities & CAP_UNICODE) {
3955                         /* must align unicode strings */
3956                         *bcc_ptr = 0; /* null byte password */
3957                         bcc_ptr++;
3958                 }
3959         }
3960
3961         if (ses->server->sign)
3962                 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3963
3964         if (ses->capabilities & CAP_STATUS32) {
3965                 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3966         }
3967         if (ses->capabilities & CAP_DFS) {
3968                 smb_buffer->Flags2 |= SMBFLG2_DFS;
3969         }
3970         if (ses->capabilities & CAP_UNICODE) {
3971                 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3972                 length =
3973                     cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3974                         6 /* max utf8 char length in bytes */ *
3975                         (/* server len*/ + 256 /* share len */), nls_codepage);
3976                 bcc_ptr += 2 * length;  /* convert num 16 bit words to bytes */
3977                 bcc_ptr += 2;   /* skip trailing null */
3978         } else {                /* ASCII */
3979                 strcpy(bcc_ptr, tree);
3980                 bcc_ptr += strlen(tree) + 1;
3981         }
3982         strcpy(bcc_ptr, "?????");
3983         bcc_ptr += strlen("?????");
3984         bcc_ptr += 1;
3985         count = bcc_ptr - &pSMB->Password[0];
3986         pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3987                                         pSMB->hdr.smb_buf_length) + count);
3988         pSMB->ByteCount = cpu_to_le16(count);
3989
3990         rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3991                          0);
3992
3993         /* above now done in SendReceive */
3994         if ((rc == 0) && (tcon != NULL)) {
3995                 bool is_unicode;
3996
3997                 tcon->tidStatus = CifsGood;
3998                 tcon->need_reconnect = false;
3999                 tcon->tid = smb_buffer_response->Tid;
4000                 bcc_ptr = pByteArea(smb_buffer_response);
4001                 bytes_left = get_bcc(smb_buffer_response);
4002                 length = strnlen(bcc_ptr, bytes_left - 2);
4003                 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
4004                         is_unicode = true;
4005                 else
4006                         is_unicode = false;
4007
4008
4009                 /* skip service field (NB: this field is always ASCII) */
4010                 if (length == 3) {
4011                         if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
4012                             (bcc_ptr[2] == 'C')) {
4013                                 cifs_dbg(FYI, "IPC connection\n");
4014                                 tcon->ipc = 1;
4015                         }
4016                 } else if (length == 2) {
4017                         if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
4018                                 /* the most common case */
4019                                 cifs_dbg(FYI, "disk share connection\n");
4020                         }
4021                 }
4022                 bcc_ptr += length + 1;
4023                 bytes_left -= (length + 1);
4024                 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
4025
4026                 /* mostly informational -- no need to fail on error here */
4027                 kfree(tcon->nativeFileSystem);
4028                 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
4029                                                       bytes_left, is_unicode,
4030                                                       nls_codepage);
4031
4032                 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
4033
4034                 if ((smb_buffer_response->WordCount == 3) ||
4035                          (smb_buffer_response->WordCount == 7))
4036                         /* field is in same location */
4037                         tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
4038                 else
4039                         tcon->Flags = 0;
4040                 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
4041         } else if ((rc == 0) && tcon == NULL) {
4042                 /* all we need to save for IPC$ connection */
4043                 ses->ipc_tid = smb_buffer_response->Tid;
4044         }
4045
4046         cifs_buf_release(smb_buffer);
4047         return rc;
4048 }
4049
4050 static void delayed_free(struct rcu_head *p)
4051 {
4052         struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
4053         unload_nls(sbi->local_nls);
4054         kfree(sbi);
4055 }
4056
4057 void
4058 cifs_umount(struct cifs_sb_info *cifs_sb)
4059 {
4060         struct rb_root *root = &cifs_sb->tlink_tree;
4061         struct rb_node *node;
4062         struct tcon_link *tlink;
4063
4064         cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
4065
4066         spin_lock(&cifs_sb->tlink_tree_lock);
4067         while ((node = rb_first(root))) {
4068                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4069                 cifs_get_tlink(tlink);
4070                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4071                 rb_erase(node, root);
4072
4073                 spin_unlock(&cifs_sb->tlink_tree_lock);
4074                 cifs_put_tlink(tlink);
4075                 spin_lock(&cifs_sb->tlink_tree_lock);
4076         }
4077         spin_unlock(&cifs_sb->tlink_tree_lock);
4078
4079         kfree(cifs_sb->mountdata);
4080         kfree(cifs_sb->prepath);
4081         call_rcu(&cifs_sb->rcu, delayed_free);
4082 }
4083
4084 int
4085 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
4086 {
4087         int rc = 0;
4088         struct TCP_Server_Info *server = ses->server;
4089
4090         if (!server->ops->need_neg || !server->ops->negotiate)
4091                 return -ENOSYS;
4092
4093         /* only send once per connect */
4094         if (!server->ops->need_neg(server))
4095                 return 0;
4096
4097         set_credits(server, 1);
4098
4099         rc = server->ops->negotiate(xid, ses);
4100         if (rc == 0) {
4101                 spin_lock(&GlobalMid_Lock);
4102                 if (server->tcpStatus == CifsNeedNegotiate)
4103                         server->tcpStatus = CifsGood;
4104                 else
4105                         rc = -EHOSTDOWN;
4106                 spin_unlock(&GlobalMid_Lock);
4107         }
4108
4109         return rc;
4110 }
4111
4112 int
4113 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
4114                    struct nls_table *nls_info)
4115 {
4116         int rc = -ENOSYS;
4117         struct TCP_Server_Info *server = ses->server;
4118
4119         ses->capabilities = server->capabilities;
4120         if (linuxExtEnabled == 0)
4121                 ses->capabilities &= (~server->vals->cap_unix);
4122
4123         cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
4124                  server->sec_mode, server->capabilities, server->timeAdj);
4125
4126         if (server->ops->sess_setup)
4127                 rc = server->ops->sess_setup(xid, ses, nls_info);
4128
4129         if (rc)
4130                 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
4131
4132         return rc;
4133 }
4134
4135 static int
4136 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4137 {
4138         vol->sectype = ses->sectype;
4139
4140         /* krb5 is special, since we don't need username or pw */
4141         if (vol->sectype == Kerberos)
4142                 return 0;
4143
4144         return cifs_set_cifscreds(vol, ses);
4145 }
4146
4147 static struct cifs_tcon *
4148 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
4149 {
4150         int rc;
4151         struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4152         struct cifs_ses *ses;
4153         struct cifs_tcon *tcon = NULL;
4154         struct smb_vol *vol_info;
4155
4156         vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
4157         if (vol_info == NULL)
4158                 return ERR_PTR(-ENOMEM);
4159
4160         vol_info->local_nls = cifs_sb->local_nls;
4161         vol_info->linux_uid = fsuid;
4162         vol_info->cred_uid = fsuid;
4163         vol_info->UNC = master_tcon->treeName;
4164         vol_info->retry = master_tcon->retry;
4165         vol_info->nocase = master_tcon->nocase;
4166         vol_info->local_lease = master_tcon->local_lease;
4167         vol_info->no_linux_ext = !master_tcon->unix_ext;
4168         vol_info->sectype = master_tcon->ses->sectype;
4169         vol_info->sign = master_tcon->ses->sign;
4170
4171         rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4172         if (rc) {
4173                 tcon = ERR_PTR(rc);
4174                 goto out;
4175         }
4176
4177         /* get a reference for the same TCP session */
4178         spin_lock(&cifs_tcp_ses_lock);
4179         ++master_tcon->ses->server->srv_count;
4180         spin_unlock(&cifs_tcp_ses_lock);
4181
4182         ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4183         if (IS_ERR(ses)) {
4184                 tcon = (struct cifs_tcon *)ses;
4185                 cifs_put_tcp_session(master_tcon->ses->server, 0);
4186                 goto out;
4187         }
4188
4189         tcon = cifs_get_tcon(ses, vol_info);
4190         if (IS_ERR(tcon)) {
4191                 cifs_put_smb_ses(ses);
4192                 goto out;
4193         }
4194
4195         if (cap_unix(ses))
4196                 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4197 out:
4198         kfree(vol_info->username);
4199         kfree(vol_info->password);
4200         kfree(vol_info);
4201
4202         return tcon;
4203 }
4204
4205 struct cifs_tcon *
4206 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4207 {
4208         return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4209 }
4210
4211 /* find and return a tlink with given uid */
4212 static struct tcon_link *
4213 tlink_rb_search(struct rb_root *root, kuid_t uid)
4214 {
4215         struct rb_node *node = root->rb_node;
4216         struct tcon_link *tlink;
4217
4218         while (node) {
4219                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4220
4221                 if (uid_gt(tlink->tl_uid, uid))
4222                         node = node->rb_left;
4223                 else if (uid_lt(tlink->tl_uid, uid))
4224                         node = node->rb_right;
4225                 else
4226                         return tlink;
4227         }
4228         return NULL;
4229 }
4230
4231 /* insert a tcon_link into the tree */
4232 static void
4233 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4234 {
4235         struct rb_node **new = &(root->rb_node), *parent = NULL;
4236         struct tcon_link *tlink;
4237
4238         while (*new) {
4239                 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4240                 parent = *new;
4241
4242                 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
4243                         new = &((*new)->rb_left);
4244                 else
4245                         new = &((*new)->rb_right);
4246         }
4247
4248         rb_link_node(&new_tlink->tl_rbnode, parent, new);
4249         rb_insert_color(&new_tlink->tl_rbnode, root);
4250 }
4251
4252 /*
4253  * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4254  * current task.
4255  *
4256  * If the superblock doesn't refer to a multiuser mount, then just return
4257  * the master tcon for the mount.
4258  *
4259  * First, search the rbtree for an existing tcon for this fsuid. If one
4260  * exists, then check to see if it's pending construction. If it is then wait
4261  * for construction to complete. Once it's no longer pending, check to see if
4262  * it failed and either return an error or retry construction, depending on
4263  * the timeout.
4264  *
4265  * If one doesn't exist then insert a new tcon_link struct into the tree and
4266  * try to construct a new one.
4267  */
4268 struct tcon_link *
4269 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4270 {
4271         int ret;
4272         kuid_t fsuid = current_fsuid();
4273         struct tcon_link *tlink, *newtlink;
4274
4275         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4276                 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4277
4278         spin_lock(&cifs_sb->tlink_tree_lock);
4279         tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4280         if (tlink)
4281                 cifs_get_tlink(tlink);
4282         spin_unlock(&cifs_sb->tlink_tree_lock);
4283
4284         if (tlink == NULL) {
4285                 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4286                 if (newtlink == NULL)
4287                         return ERR_PTR(-ENOMEM);
4288                 newtlink->tl_uid = fsuid;
4289                 newtlink->tl_tcon = ERR_PTR(-EACCES);
4290                 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4291                 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4292                 cifs_get_tlink(newtlink);
4293
4294                 spin_lock(&cifs_sb->tlink_tree_lock);
4295                 /* was one inserted after previous search? */
4296                 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4297                 if (tlink) {
4298                         cifs_get_tlink(tlink);
4299                         spin_unlock(&cifs_sb->tlink_tree_lock);
4300                         kfree(newtlink);
4301                         goto wait_for_construction;
4302                 }
4303                 tlink = newtlink;
4304                 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4305                 spin_unlock(&cifs_sb->tlink_tree_lock);
4306         } else {
4307 wait_for_construction:
4308                 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4309                                   TASK_INTERRUPTIBLE);
4310                 if (ret) {
4311                         cifs_put_tlink(tlink);
4312                         return ERR_PTR(-ERESTARTSYS);
4313                 }
4314
4315                 /* if it's good, return it */
4316                 if (!IS_ERR(tlink->tl_tcon))
4317                         return tlink;
4318
4319                 /* return error if we tried this already recently */
4320                 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4321                         cifs_put_tlink(tlink);
4322                         return ERR_PTR(-EACCES);
4323                 }
4324
4325                 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4326                         goto wait_for_construction;
4327         }
4328
4329         tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4330         clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4331         wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4332
4333         if (IS_ERR(tlink->tl_tcon)) {
4334                 cifs_put_tlink(tlink);
4335                 return ERR_PTR(-EACCES);
4336         }
4337
4338         return tlink;
4339 }
4340
4341 /*
4342  * periodic workqueue job that scans tcon_tree for a superblock and closes
4343  * out tcons.
4344  */
4345 static void
4346 cifs_prune_tlinks(struct work_struct *work)
4347 {
4348         struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4349                                                     prune_tlinks.work);
4350         struct rb_root *root = &cifs_sb->tlink_tree;
4351         struct rb_node *node = rb_first(root);
4352         struct rb_node *tmp;
4353         struct tcon_link *tlink;
4354
4355         /*
4356          * Because we drop the spinlock in the loop in order to put the tlink
4357          * it's not guarded against removal of links from the tree. The only
4358          * places that remove entries from the tree are this function and
4359          * umounts. Because this function is non-reentrant and is canceled
4360          * before umount can proceed, this is safe.
4361          */
4362         spin_lock(&cifs_sb->tlink_tree_lock);
4363         node = rb_first(root);
4364         while (node != NULL) {
4365                 tmp = node;
4366                 node = rb_next(tmp);
4367                 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4368
4369                 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4370                     atomic_read(&tlink->tl_count) != 0 ||
4371                     time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4372                         continue;
4373
4374                 cifs_get_tlink(tlink);
4375                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4376                 rb_erase(tmp, root);
4377
4378                 spin_unlock(&cifs_sb->tlink_tree_lock);
4379                 cifs_put_tlink(tlink);
4380                 spin_lock(&cifs_sb->tlink_tree_lock);
4381         }
4382         spin_unlock(&cifs_sb->tlink_tree_lock);
4383
4384         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4385                                 TLINK_IDLE_EXPIRE);
4386 }