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