fs/cifs/connect.c

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