fs/cifs/connect.c

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