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