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 /*
3449  * On hosts with high memory, we can't currently support wsize/rsize that are
3450  * larger than we can kmap at once. Cap the rsize/wsize at
3451  * LAST_PKMAP * PAGE_SIZE. We'll never be able to fill a read or write request
3452  * larger than that anyway.
3453  */
3454 #ifdef CONFIG_HIGHMEM
3455 #define CIFS_KMAP_SIZE_LIMIT    (LAST_PKMAP * PAGE_CACHE_SIZE)
3456 #else /* CONFIG_HIGHMEM */
3457 #define CIFS_KMAP_SIZE_LIMIT    (1<<24)
3458 #endif /* CONFIG_HIGHMEM */
3459
3460 static unsigned int
3461 cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
3462 {
3463         __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3464         struct TCP_Server_Info *server = tcon->ses->server;
3465         unsigned int wsize;
3466
3467         /* start with specified wsize, or default */
3468         if (pvolume_info->wsize)
3469                 wsize = pvolume_info->wsize;
3470         else if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
3471                 wsize = CIFS_DEFAULT_IOSIZE;
3472         else
3473                 wsize = CIFS_DEFAULT_NON_POSIX_WSIZE;
3474
3475         /* can server support 24-bit write sizes? (via UNIX extensions) */
3476         if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
3477                 wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE);
3478
3479         /*
3480          * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
3481          * Limit it to max buffer offered by the server, minus the size of the
3482          * WRITEX header, not including the 4 byte RFC1001 length.
3483          */
3484         if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
3485             (!(server->capabilities & CAP_UNIX) &&
3486              (server->sec_mode & (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED))))
3487                 wsize = min_t(unsigned int, wsize,
3488                                 server->maxBuf - sizeof(WRITE_REQ) + 4);
3489
3490         /* limit to the amount that we can kmap at once */
3491         wsize = min_t(unsigned int, wsize, CIFS_KMAP_SIZE_LIMIT);
3492
3493         /* hard limit of CIFS_MAX_WSIZE */
3494         wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
3495
3496         return wsize;
3497 }
3498
3499 static unsigned int
3500 cifs_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
3501 {
3502         __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3503         struct TCP_Server_Info *server = tcon->ses->server;
3504         unsigned int rsize, defsize;
3505
3506         /*
3507          * Set default value...
3508          *
3509          * HACK alert! Ancient servers have very small buffers. Even though
3510          * MS-CIFS indicates that servers are only limited by the client's
3511          * bufsize for reads, testing against win98se shows that it throws
3512          * INVALID_PARAMETER errors if you try to request too large a read.
3513          * OS/2 just sends back short reads.
3514          *
3515          * If the server doesn't advertise CAP_LARGE_READ_X, then assume that
3516          * it can't handle a read request larger than its MaxBufferSize either.
3517          */
3518         if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_READ_CAP))
3519                 defsize = CIFS_DEFAULT_IOSIZE;
3520         else if (server->capabilities & CAP_LARGE_READ_X)
3521                 defsize = CIFS_DEFAULT_NON_POSIX_RSIZE;
3522         else
3523                 defsize = server->maxBuf - sizeof(READ_RSP);
3524
3525         rsize = pvolume_info->rsize ? pvolume_info->rsize : defsize;
3526
3527         /*
3528          * no CAP_LARGE_READ_X? Then MS-CIFS states that we must limit this to
3529          * the client's MaxBufferSize.
3530          */
3531         if (!(server->capabilities & CAP_LARGE_READ_X))
3532                 rsize = min_t(unsigned int, CIFSMaxBufSize, rsize);
3533
3534         /* limit to the amount that we can kmap at once */
3535         rsize = min_t(unsigned int, rsize, CIFS_KMAP_SIZE_LIMIT);
3536
3537         /* hard limit of CIFS_MAX_RSIZE */
3538         rsize = min_t(unsigned int, rsize, CIFS_MAX_RSIZE);
3539
3540         return rsize;
3541 }
3542
3543 static int
3544 is_path_accessible(int xid, struct cifs_tcon *tcon,
3545                    struct cifs_sb_info *cifs_sb, const char *full_path)
3546 {
3547         int rc;
3548         FILE_ALL_INFO *pfile_info;
3549
3550         pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
3551         if (pfile_info == NULL)
3552                 return -ENOMEM;
3553
3554         rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
3555                               0 /* not legacy */, cifs_sb->local_nls,
3556                               cifs_sb->mnt_cifs_flags &
3557                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
3558
3559         if (rc == -EOPNOTSUPP || rc == -EINVAL)
3560                 rc = SMBQueryInformation(xid, tcon, full_path, pfile_info,
3561                                 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
3562                                   CIFS_MOUNT_MAP_SPECIAL_CHR);
3563         kfree(pfile_info);
3564         return rc;
3565 }
3566
3567 static void
3568 cleanup_volume_info_contents(struct smb_vol *volume_info)
3569 {
3570         kfree(volume_info->username);
3571         kzfree(volume_info->password);
3572         if (volume_info->UNCip != volume_info->UNC + 2)
3573                 kfree(volume_info->UNCip);
3574         kfree(volume_info->UNC);
3575         kfree(volume_info->domainname);
3576         kfree(volume_info->iocharset);
3577         kfree(volume_info->prepath);
3578 }
3579
3580 void
3581 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3582 {
3583         if (!volume_info)
3584                 return;
3585         cleanup_volume_info_contents(volume_info);
3586         kfree(volume_info);
3587 }
3588
3589
3590 #ifdef CONFIG_CIFS_DFS_UPCALL
3591 /* build_path_to_root returns full path to root when
3592  * we do not have an exiting connection (tcon) */
3593 static char *
3594 build_unc_path_to_root(const struct smb_vol *vol,
3595                 const struct cifs_sb_info *cifs_sb)
3596 {
3597         char *full_path, *pos;
3598         unsigned int pplen = vol->prepath ? strlen(vol->prepath) : 0;
3599         unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3600
3601         full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3602         if (full_path == NULL)
3603                 return ERR_PTR(-ENOMEM);
3604
3605         strncpy(full_path, vol->UNC, unc_len);
3606         pos = full_path + unc_len;
3607
3608         if (pplen) {
3609                 strncpy(pos, vol->prepath, pplen);
3610                 pos += pplen;
3611         }
3612
3613         *pos = '\0'; /* add trailing null */
3614         convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3615         cFYI(1, "%s: full_path=%s", __func__, full_path);
3616         return full_path;
3617 }
3618
3619 /*
3620  * Perform a dfs referral query for a share and (optionally) prefix
3621  *
3622  * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3623  * to a string containing updated options for the submount.  Otherwise it
3624  * will be left untouched.
3625  *
3626  * Returns the rc from get_dfs_path to the caller, which can be used to
3627  * determine whether there were referrals.
3628  */
3629 static int
3630 expand_dfs_referral(int xid, struct cifs_ses *pSesInfo,
3631                     struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3632                     int check_prefix)
3633 {
3634         int rc;
3635         unsigned int num_referrals = 0;
3636         struct dfs_info3_param *referrals = NULL;
3637         char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3638
3639         full_path = build_unc_path_to_root(volume_info, cifs_sb);
3640         if (IS_ERR(full_path))
3641                 return PTR_ERR(full_path);
3642
3643         /* For DFS paths, skip the first '\' of the UNC */
3644         ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3645
3646         rc = get_dfs_path(xid, pSesInfo , ref_path, cifs_sb->local_nls,
3647                           &num_referrals, &referrals,
3648                           cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3649
3650         if (!rc && num_referrals > 0) {
3651                 char *fake_devname = NULL;
3652
3653                 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3654                                                    full_path + 1, referrals,
3655                                                    &fake_devname);
3656
3657                 free_dfs_info_array(referrals, num_referrals);
3658
3659                 if (IS_ERR(mdata)) {
3660                         rc = PTR_ERR(mdata);
3661                         mdata = NULL;
3662                 } else {
3663                         cleanup_volume_info_contents(volume_info);
3664                         memset(volume_info, '\0', sizeof(*volume_info));
3665                         rc = cifs_setup_volume_info(volume_info, mdata,
3666                                                         fake_devname);
3667                 }
3668                 kfree(fake_devname);
3669                 kfree(cifs_sb->mountdata);
3670                 cifs_sb->mountdata = mdata;
3671         }
3672         kfree(full_path);
3673         return rc;
3674 }
3675 #endif
3676
3677 static int
3678 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3679                         const char *devname)
3680 {
3681         int rc = 0;
3682
3683         if (cifs_parse_mount_options(mount_data, devname, volume_info))
3684                 return -EINVAL;
3685
3686
3687         if (volume_info->nullauth) {
3688                 cFYI(1, "Anonymous login");
3689                 kfree(volume_info->username);
3690                 volume_info->username = NULL;
3691         } else if (volume_info->username) {
3692                 /* BB fixme parse for domain name here */
3693                 cFYI(1, "Username: %s", volume_info->username);
3694         } else {
3695                 cifserror("No username specified");
3696         /* In userspace mount helper we can get user name from alternate
3697            locations such as env variables and files on disk */
3698                 return -EINVAL;
3699         }
3700
3701         /* this is needed for ASCII cp to Unicode converts */
3702         if (volume_info->iocharset == NULL) {
3703                 /* load_nls_default cannot return null */
3704                 volume_info->local_nls = load_nls_default();
3705         } else {
3706                 volume_info->local_nls = load_nls(volume_info->iocharset);
3707                 if (volume_info->local_nls == NULL) {
3708                         cERROR(1, "CIFS mount error: iocharset %s not found",
3709                                  volume_info->iocharset);
3710                         return -ELIBACC;
3711                 }
3712         }
3713
3714         return rc;
3715 }
3716
3717 struct smb_vol *
3718 cifs_get_volume_info(char *mount_data, const char *devname)
3719 {
3720         int rc;
3721         struct smb_vol *volume_info;
3722
3723         volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
3724         if (!volume_info)
3725                 return ERR_PTR(-ENOMEM);
3726
3727         rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3728         if (rc) {
3729                 cifs_cleanup_volume_info(volume_info);
3730                 volume_info = ERR_PTR(rc);
3731         }
3732
3733         return volume_info;
3734 }
3735
3736 int
3737 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3738 {
3739         int rc;
3740         int xid;
3741         struct cifs_ses *pSesInfo;
3742         struct cifs_tcon *tcon;
3743         struct TCP_Server_Info *srvTcp;
3744         char   *full_path;
3745         struct tcon_link *tlink;
3746 #ifdef CONFIG_CIFS_DFS_UPCALL
3747         int referral_walks_count = 0;
3748 #endif
3749
3750         rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3751         if (rc)
3752                 return rc;
3753
3754 #ifdef CONFIG_CIFS_DFS_UPCALL
3755 try_mount_again:
3756         /* cleanup activities if we're chasing a referral */
3757         if (referral_walks_count) {
3758                 if (tcon)
3759                         cifs_put_tcon(tcon);
3760                 else if (pSesInfo)
3761                         cifs_put_smb_ses(pSesInfo);
3762
3763                 FreeXid(xid);
3764         }
3765 #endif
3766         rc = 0;
3767         tcon = NULL;
3768         pSesInfo = NULL;
3769         srvTcp = NULL;
3770         full_path = NULL;
3771         tlink = NULL;
3772
3773         xid = GetXid();
3774
3775         /* get a reference to a tcp session */
3776         srvTcp = cifs_get_tcp_session(volume_info);
3777         if (IS_ERR(srvTcp)) {
3778                 rc = PTR_ERR(srvTcp);
3779                 bdi_destroy(&cifs_sb->bdi);
3780                 goto out;
3781         }
3782
3783         /* get a reference to a SMB session */
3784         pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
3785         if (IS_ERR(pSesInfo)) {
3786                 rc = PTR_ERR(pSesInfo);
3787                 pSesInfo = NULL;
3788                 goto mount_fail_check;
3789         }
3790
3791         /* search for existing tcon to this server share */
3792         tcon = cifs_get_tcon(pSesInfo, volume_info);
3793         if (IS_ERR(tcon)) {
3794                 rc = PTR_ERR(tcon);
3795                 tcon = NULL;
3796                 goto remote_path_check;
3797         }
3798
3799         /* tell server which Unix caps we support */
3800         if (tcon->ses->capabilities & CAP_UNIX) {
3801                 /* reset of caps checks mount to see if unix extensions
3802                    disabled for just this mount */
3803                 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3804                 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3805                     (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3806                      CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3807                         rc = -EACCES;
3808                         goto mount_fail_check;
3809                 }
3810         } else
3811                 tcon->unix_ext = 0; /* server does not support them */
3812
3813         /* do not care if following two calls succeed - informational */
3814         if (!tcon->ipc) {
3815                 CIFSSMBQFSDeviceInfo(xid, tcon);
3816                 CIFSSMBQFSAttributeInfo(xid, tcon);
3817         }
3818
3819         cifs_sb->wsize = cifs_negotiate_wsize(tcon, volume_info);
3820         cifs_sb->rsize = cifs_negotiate_rsize(tcon, volume_info);
3821
3822         /* tune readahead according to rsize */
3823         cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3824
3825 remote_path_check:
3826 #ifdef CONFIG_CIFS_DFS_UPCALL
3827         /*
3828          * Perform an unconditional check for whether there are DFS
3829          * referrals for this path without prefix, to provide support
3830          * for DFS referrals from w2k8 servers which don't seem to respond
3831          * with PATH_NOT_COVERED to requests that include the prefix.
3832          * Chase the referral if found, otherwise continue normally.
3833          */
3834         if (referral_walks_count == 0) {
3835                 int refrc = expand_dfs_referral(xid, pSesInfo, volume_info,
3836                                                 cifs_sb, false);
3837                 if (!refrc) {
3838                         referral_walks_count++;
3839                         goto try_mount_again;
3840                 }
3841         }
3842 #endif
3843
3844         /* check if a whole path is not remote */
3845         if (!rc && tcon) {
3846                 /* build_path_to_root works only when we have a valid tcon */
3847                 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3848                 if (full_path == NULL) {
3849                         rc = -ENOMEM;
3850                         goto mount_fail_check;
3851                 }
3852                 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
3853                 if (rc != 0 && rc != -EREMOTE) {
3854                         kfree(full_path);
3855                         goto mount_fail_check;
3856                 }
3857                 kfree(full_path);
3858         }
3859
3860         /* get referral if needed */
3861         if (rc == -EREMOTE) {
3862 #ifdef CONFIG_CIFS_DFS_UPCALL
3863                 if (referral_walks_count > MAX_NESTED_LINKS) {
3864                         /*
3865                          * BB: when we implement proper loop detection,
3866                          *     we will remove this check. But now we need it
3867                          *     to prevent an indefinite loop if 'DFS tree' is
3868                          *     misconfigured (i.e. has loops).
3869                          */
3870                         rc = -ELOOP;
3871                         goto mount_fail_check;
3872                 }
3873
3874                 rc = expand_dfs_referral(xid, pSesInfo, volume_info, cifs_sb,
3875                                          true);
3876
3877                 if (!rc) {
3878                         referral_walks_count++;
3879                         goto try_mount_again;
3880                 }
3881                 goto mount_fail_check;
3882 #else /* No DFS support, return error on mount */
3883                 rc = -EOPNOTSUPP;
3884 #endif
3885         }
3886
3887         if (rc)
3888                 goto mount_fail_check;
3889
3890         /* now, hang the tcon off of the superblock */
3891         tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3892         if (tlink == NULL) {
3893                 rc = -ENOMEM;
3894                 goto mount_fail_check;
3895         }
3896
3897         tlink->tl_uid = pSesInfo->linux_uid;
3898         tlink->tl_tcon = tcon;
3899         tlink->tl_time = jiffies;
3900         set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3901         set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3902
3903         cifs_sb->master_tlink = tlink;
3904         spin_lock(&cifs_sb->tlink_tree_lock);
3905         tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3906         spin_unlock(&cifs_sb->tlink_tree_lock);
3907
3908         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3909                                 TLINK_IDLE_EXPIRE);
3910
3911 mount_fail_check:
3912         /* on error free sesinfo and tcon struct if needed */
3913         if (rc) {
3914                 /* If find_unc succeeded then rc == 0 so we can not end */
3915                 /* up accidentally freeing someone elses tcon struct */
3916                 if (tcon)
3917                         cifs_put_tcon(tcon);
3918                 else if (pSesInfo)
3919                         cifs_put_smb_ses(pSesInfo);
3920                 else
3921                         cifs_put_tcp_session(srvTcp);
3922                 bdi_destroy(&cifs_sb->bdi);
3923         }
3924
3925 out:
3926         FreeXid(xid);
3927         return rc;
3928 }
3929
3930 /*
3931  * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3932  * pointer may be NULL.
3933  */
3934 int
3935 CIFSTCon(unsigned int xid, struct cifs_ses *ses,
3936          const char *tree, struct cifs_tcon *tcon,
3937          const struct nls_table *nls_codepage)
3938 {
3939         struct smb_hdr *smb_buffer;
3940         struct smb_hdr *smb_buffer_response;
3941         TCONX_REQ *pSMB;
3942         TCONX_RSP *pSMBr;
3943         unsigned char *bcc_ptr;
3944         int rc = 0;
3945         int length;
3946         __u16 bytes_left, count;
3947
3948         if (ses == NULL)
3949                 return -EIO;
3950
3951         smb_buffer = cifs_buf_get();
3952         if (smb_buffer == NULL)
3953                 return -ENOMEM;
3954
3955         smb_buffer_response = smb_buffer;
3956
3957         header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3958                         NULL /*no tid */ , 4 /*wct */ );
3959
3960         smb_buffer->Mid = get_next_mid(ses->server);
3961         smb_buffer->Uid = ses->Suid;
3962         pSMB = (TCONX_REQ *) smb_buffer;
3963         pSMBr = (TCONX_RSP *) smb_buffer_response;
3964
3965         pSMB->AndXCommand = 0xFF;
3966         pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3967         bcc_ptr = &pSMB->Password[0];
3968         if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3969                 pSMB->PasswordLength = cpu_to_le16(1);  /* minimum */
3970                 *bcc_ptr = 0; /* password is null byte */
3971                 bcc_ptr++;              /* skip password */
3972                 /* already aligned so no need to do it below */
3973         } else {
3974                 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3975                 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3976                    specified as required (when that support is added to
3977                    the vfs in the future) as only NTLM or the much
3978                    weaker LANMAN (which we do not send by default) is accepted
3979                    by Samba (not sure whether other servers allow
3980                    NTLMv2 password here) */
3981 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3982                 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3983                     (ses->server->secType == LANMAN))
3984                         calc_lanman_hash(tcon->password, ses->server->cryptkey,
3985                                          ses->server->sec_mode &
3986                                             SECMODE_PW_ENCRYPT ? true : false,
3987                                          bcc_ptr);
3988                 else
3989 #endif /* CIFS_WEAK_PW_HASH */
3990                 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3991                                         bcc_ptr, nls_codepage);
3992
3993                 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3994                 if (ses->capabilities & CAP_UNICODE) {
3995                         /* must align unicode strings */
3996                         *bcc_ptr = 0; /* null byte password */
3997                         bcc_ptr++;
3998                 }
3999         }
4000
4001         if (ses->server->sec_mode &
4002                         (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
4003                 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
4004
4005         if (ses->capabilities & CAP_STATUS32) {
4006                 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
4007         }
4008         if (ses->capabilities & CAP_DFS) {
4009                 smb_buffer->Flags2 |= SMBFLG2_DFS;
4010         }
4011         if (ses->capabilities & CAP_UNICODE) {
4012                 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
4013                 length =
4014                     cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
4015                         6 /* max utf8 char length in bytes */ *
4016                         (/* server len*/ + 256 /* share len */), nls_codepage);
4017                 bcc_ptr += 2 * length;  /* convert num 16 bit words to bytes */
4018                 bcc_ptr += 2;   /* skip trailing null */
4019         } else {                /* ASCII */
4020                 strcpy(bcc_ptr, tree);
4021                 bcc_ptr += strlen(tree) + 1;
4022         }
4023         strcpy(bcc_ptr, "?????");
4024         bcc_ptr += strlen("?????");
4025         bcc_ptr += 1;
4026         count = bcc_ptr - &pSMB->Password[0];
4027         pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
4028                                         pSMB->hdr.smb_buf_length) + count);
4029         pSMB->ByteCount = cpu_to_le16(count);
4030
4031         rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
4032                          0);
4033
4034         /* above now done in SendReceive */
4035         if ((rc == 0) && (tcon != NULL)) {
4036                 bool is_unicode;
4037
4038                 tcon->tidStatus = CifsGood;
4039                 tcon->need_reconnect = false;
4040                 tcon->tid = smb_buffer_response->Tid;
4041                 bcc_ptr = pByteArea(smb_buffer_response);
4042                 bytes_left = get_bcc(smb_buffer_response);
4043                 length = strnlen(bcc_ptr, bytes_left - 2);
4044                 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
4045                         is_unicode = true;
4046                 else
4047                         is_unicode = false;
4048
4049
4050                 /* skip service field (NB: this field is always ASCII) */
4051                 if (length == 3) {
4052                         if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
4053                             (bcc_ptr[2] == 'C')) {
4054                                 cFYI(1, "IPC connection");
4055                                 tcon->ipc = 1;
4056                         }
4057                 } else if (length == 2) {
4058                         if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
4059                                 /* the most common case */
4060                                 cFYI(1, "disk share connection");
4061                         }
4062                 }
4063                 bcc_ptr += length + 1;
4064                 bytes_left -= (length + 1);
4065                 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
4066
4067                 /* mostly informational -- no need to fail on error here */
4068                 kfree(tcon->nativeFileSystem);
4069                 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
4070                                                       bytes_left, is_unicode,
4071                                                       nls_codepage);
4072
4073                 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
4074
4075                 if ((smb_buffer_response->WordCount == 3) ||
4076                          (smb_buffer_response->WordCount == 7))
4077                         /* field is in same location */
4078                         tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
4079                 else
4080                         tcon->Flags = 0;
4081                 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
4082         } else if ((rc == 0) && tcon == NULL) {
4083                 /* all we need to save for IPC$ connection */
4084                 ses->ipc_tid = smb_buffer_response->Tid;
4085         }
4086
4087         cifs_buf_release(smb_buffer);
4088         return rc;
4089 }
4090
4091 void
4092 cifs_umount(struct cifs_sb_info *cifs_sb)
4093 {
4094         struct rb_root *root = &cifs_sb->tlink_tree;
4095         struct rb_node *node;
4096         struct tcon_link *tlink;
4097
4098         cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
4099
4100         spin_lock(&cifs_sb->tlink_tree_lock);
4101         while ((node = rb_first(root))) {
4102                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4103                 cifs_get_tlink(tlink);
4104                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4105                 rb_erase(node, root);
4106
4107                 spin_unlock(&cifs_sb->tlink_tree_lock);
4108                 cifs_put_tlink(tlink);
4109                 spin_lock(&cifs_sb->tlink_tree_lock);
4110         }
4111         spin_unlock(&cifs_sb->tlink_tree_lock);
4112
4113         bdi_destroy(&cifs_sb->bdi);
4114         kfree(cifs_sb->mountdata);
4115         unload_nls(cifs_sb->local_nls);
4116         kfree(cifs_sb);
4117 }
4118
4119 int cifs_negotiate_protocol(unsigned int xid, struct cifs_ses *ses)
4120 {
4121         int rc = 0;
4122         struct TCP_Server_Info *server = ses->server;
4123
4124         /* only send once per connect */
4125         if (server->maxBuf != 0)
4126                 return 0;
4127
4128         set_credits(server, 1);
4129         rc = CIFSSMBNegotiate(xid, ses);
4130         if (rc == -EAGAIN) {
4131                 /* retry only once on 1st time connection */
4132                 set_credits(server, 1);
4133                 rc = CIFSSMBNegotiate(xid, ses);
4134                 if (rc == -EAGAIN)
4135                         rc = -EHOSTDOWN;
4136         }
4137         if (rc == 0) {
4138                 spin_lock(&GlobalMid_Lock);
4139                 if (server->tcpStatus == CifsNeedNegotiate)
4140                         server->tcpStatus = CifsGood;
4141                 else
4142                         rc = -EHOSTDOWN;
4143                 spin_unlock(&GlobalMid_Lock);
4144
4145         }
4146
4147         return rc;
4148 }
4149
4150
4151 int cifs_setup_session(unsigned int xid, struct cifs_ses *ses,
4152                         struct nls_table *nls_info)
4153 {
4154         int rc = 0;
4155         struct TCP_Server_Info *server = ses->server;
4156
4157         ses->flags = 0;
4158         ses->capabilities = server->capabilities;
4159         if (linuxExtEnabled == 0)
4160                 ses->capabilities &= (~CAP_UNIX);
4161
4162         cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
4163                  server->sec_mode, server->capabilities, server->timeAdj);
4164
4165         rc = CIFS_SessSetup(xid, ses, nls_info);
4166         if (rc) {
4167                 cERROR(1, "Send error in SessSetup = %d", rc);
4168         } else {
4169                 mutex_lock(&ses->server->srv_mutex);
4170                 if (!server->session_estab) {
4171                         server->session_key.response = ses->auth_key.response;
4172                         server->session_key.len = ses->auth_key.len;
4173                         server->sequence_number = 0x2;
4174                         server->session_estab = true;
4175                         ses->auth_key.response = NULL;
4176                 }
4177                 mutex_unlock(&server->srv_mutex);
4178
4179                 cFYI(1, "CIFS Session Established successfully");
4180                 spin_lock(&GlobalMid_Lock);
4181                 ses->status = CifsGood;
4182                 ses->need_reconnect = false;
4183                 spin_unlock(&GlobalMid_Lock);
4184         }
4185
4186         kfree(ses->auth_key.response);
4187         ses->auth_key.response = NULL;
4188         ses->auth_key.len = 0;
4189         kfree(ses->ntlmssp);
4190         ses->ntlmssp = NULL;
4191
4192         return rc;
4193 }
4194
4195 static int
4196 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4197 {
4198         switch (ses->server->secType) {
4199         case Kerberos:
4200                 vol->secFlg = CIFSSEC_MUST_KRB5;
4201                 return 0;
4202         case NTLMv2:
4203                 vol->secFlg = CIFSSEC_MUST_NTLMV2;
4204                 break;
4205         case NTLM:
4206                 vol->secFlg = CIFSSEC_MUST_NTLM;
4207                 break;
4208         case RawNTLMSSP:
4209                 vol->secFlg = CIFSSEC_MUST_NTLMSSP;
4210                 break;
4211         case LANMAN:
4212                 vol->secFlg = CIFSSEC_MUST_LANMAN;
4213                 break;
4214         }
4215
4216         return cifs_set_cifscreds(vol, ses);
4217 }
4218
4219 static struct cifs_tcon *
4220 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
4221 {
4222         int rc;
4223         struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4224         struct cifs_ses *ses;
4225         struct cifs_tcon *tcon = NULL;
4226         struct smb_vol *vol_info;
4227
4228         vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
4229         if (vol_info == NULL)
4230                 return ERR_PTR(-ENOMEM);
4231
4232         vol_info->local_nls = cifs_sb->local_nls;
4233         vol_info->linux_uid = fsuid;
4234         vol_info->cred_uid = fsuid;
4235         vol_info->UNC = master_tcon->treeName;
4236         vol_info->retry = master_tcon->retry;
4237         vol_info->nocase = master_tcon->nocase;
4238         vol_info->local_lease = master_tcon->local_lease;
4239         vol_info->no_linux_ext = !master_tcon->unix_ext;
4240
4241         rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4242         if (rc) {
4243                 tcon = ERR_PTR(rc);
4244                 goto out;
4245         }
4246
4247         /* get a reference for the same TCP session */
4248         spin_lock(&cifs_tcp_ses_lock);
4249         ++master_tcon->ses->server->srv_count;
4250         spin_unlock(&cifs_tcp_ses_lock);
4251
4252         ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4253         if (IS_ERR(ses)) {
4254                 tcon = (struct cifs_tcon *)ses;
4255                 cifs_put_tcp_session(master_tcon->ses->server);
4256                 goto out;
4257         }
4258
4259         tcon = cifs_get_tcon(ses, vol_info);
4260         if (IS_ERR(tcon)) {
4261                 cifs_put_smb_ses(ses);
4262                 goto out;
4263         }
4264
4265         if (ses->capabilities & CAP_UNIX)
4266                 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4267 out:
4268         kfree(vol_info->username);
4269         kfree(vol_info->password);
4270         kfree(vol_info);
4271
4272         return tcon;
4273 }
4274
4275 struct cifs_tcon *
4276 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4277 {
4278         return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4279 }
4280
4281 static int
4282 cifs_sb_tcon_pending_wait(void *unused)
4283 {
4284         schedule();
4285         return signal_pending(current) ? -ERESTARTSYS : 0;
4286 }
4287
4288 /* find and return a tlink with given uid */
4289 static struct tcon_link *
4290 tlink_rb_search(struct rb_root *root, uid_t uid)
4291 {
4292         struct rb_node *node = root->rb_node;
4293         struct tcon_link *tlink;
4294
4295         while (node) {
4296                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4297
4298                 if (tlink->tl_uid > uid)
4299                         node = node->rb_left;
4300                 else if (tlink->tl_uid < uid)
4301                         node = node->rb_right;
4302                 else
4303                         return tlink;
4304         }
4305         return NULL;
4306 }
4307
4308 /* insert a tcon_link into the tree */
4309 static void
4310 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4311 {
4312         struct rb_node **new = &(root->rb_node), *parent = NULL;
4313         struct tcon_link *tlink;
4314
4315         while (*new) {
4316                 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4317                 parent = *new;
4318
4319                 if (tlink->tl_uid > new_tlink->tl_uid)
4320                         new = &((*new)->rb_left);
4321                 else
4322                         new = &((*new)->rb_right);
4323         }
4324
4325         rb_link_node(&new_tlink->tl_rbnode, parent, new);
4326         rb_insert_color(&new_tlink->tl_rbnode, root);
4327 }
4328
4329 /*
4330  * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4331  * current task.
4332  *
4333  * If the superblock doesn't refer to a multiuser mount, then just return
4334  * the master tcon for the mount.
4335  *
4336  * First, search the rbtree for an existing tcon for this fsuid. If one
4337  * exists, then check to see if it's pending construction. If it is then wait
4338  * for construction to complete. Once it's no longer pending, check to see if
4339  * it failed and either return an error or retry construction, depending on
4340  * the timeout.
4341  *
4342  * If one doesn't exist then insert a new tcon_link struct into the tree and
4343  * try to construct a new one.
4344  */
4345 struct tcon_link *
4346 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4347 {
4348         int ret;
4349         uid_t fsuid = current_fsuid();
4350         struct tcon_link *tlink, *newtlink;
4351
4352         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4353                 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4354
4355         spin_lock(&cifs_sb->tlink_tree_lock);
4356         tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4357         if (tlink)
4358                 cifs_get_tlink(tlink);
4359         spin_unlock(&cifs_sb->tlink_tree_lock);
4360
4361         if (tlink == NULL) {
4362                 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4363                 if (newtlink == NULL)
4364                         return ERR_PTR(-ENOMEM);
4365                 newtlink->tl_uid = fsuid;
4366                 newtlink->tl_tcon = ERR_PTR(-EACCES);
4367                 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4368                 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4369                 cifs_get_tlink(newtlink);
4370
4371                 spin_lock(&cifs_sb->tlink_tree_lock);
4372                 /* was one inserted after previous search? */
4373                 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4374                 if (tlink) {
4375                         cifs_get_tlink(tlink);
4376                         spin_unlock(&cifs_sb->tlink_tree_lock);
4377                         kfree(newtlink);
4378                         goto wait_for_construction;
4379                 }
4380                 tlink = newtlink;
4381                 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4382                 spin_unlock(&cifs_sb->tlink_tree_lock);
4383         } else {
4384 wait_for_construction:
4385                 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4386                                   cifs_sb_tcon_pending_wait,
4387                                   TASK_INTERRUPTIBLE);
4388                 if (ret) {
4389                         cifs_put_tlink(tlink);
4390                         return ERR_PTR(ret);
4391                 }
4392
4393                 /* if it's good, return it */
4394                 if (!IS_ERR(tlink->tl_tcon))
4395                         return tlink;
4396
4397                 /* return error if we tried this already recently */
4398                 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4399                         cifs_put_tlink(tlink);
4400                         return ERR_PTR(-EACCES);
4401                 }
4402
4403                 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4404                         goto wait_for_construction;
4405         }
4406
4407         tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4408         clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4409         wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4410
4411         if (IS_ERR(tlink->tl_tcon)) {
4412                 cifs_put_tlink(tlink);
4413                 return ERR_PTR(-EACCES);
4414         }
4415
4416         return tlink;
4417 }
4418
4419 /*
4420  * periodic workqueue job that scans tcon_tree for a superblock and closes
4421  * out tcons.
4422  */
4423 static void
4424 cifs_prune_tlinks(struct work_struct *work)
4425 {
4426         struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4427                                                     prune_tlinks.work);
4428         struct rb_root *root = &cifs_sb->tlink_tree;
4429         struct rb_node *node = rb_first(root);
4430         struct rb_node *tmp;
4431         struct tcon_link *tlink;
4432
4433         /*
4434          * Because we drop the spinlock in the loop in order to put the tlink
4435          * it's not guarded against removal of links from the tree. The only
4436          * places that remove entries from the tree are this function and
4437          * umounts. Because this function is non-reentrant and is canceled
4438          * before umount can proceed, this is safe.
4439          */
4440         spin_lock(&cifs_sb->tlink_tree_lock);
4441         node = rb_first(root);
4442         while (node != NULL) {
4443                 tmp = node;
4444                 node = rb_next(tmp);
4445                 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4446
4447                 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4448                     atomic_read(&tlink->tl_count) != 0 ||
4449                     time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4450                         continue;
4451
4452                 cifs_get_tlink(tlink);
4453                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4454                 rb_erase(tmp, root);
4455
4456                 spin_unlock(&cifs_sb->tlink_tree_lock);
4457                 cifs_put_tlink(tlink);
4458                 spin_lock(&cifs_sb->tlink_tree_lock);
4459         }
4460         spin_unlock(&cifs_sb->tlink_tree_lock);
4461
4462         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4463                                 TLINK_IDLE_EXPIRE);
4464 }