fs/cifs/connect.c

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