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