fs/cifs/connect.c

   1 /*
   2  *   fs/cifs/connect.c
   3  *
   4  *   Copyright (C) International Business Machines  Corp., 2002,2011
   5  *   Author(s): Steve French (sfrench@us.ibm.com)
   6  *
   7  *   This library is free software; you can redistribute it and/or modify
   8  *   it under the terms of the GNU Lesser General Public License as published
   9  *   by the Free Software Foundation; either version 2.1 of the License, or
  10  *   (at your option) any later version.
  11  *
  12  *   This library is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  15  *   the GNU Lesser General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU Lesser General Public License
  18  *   along with this library; if not, write to the Free Software
  19  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20  */
  21 #include <linux/fs.h>
  22 #include <linux/net.h>
  23 #include <linux/string.h>
  24 #include <linux/list.h>
  25 #include <linux/wait.h>
  26 #include <linux/slab.h>
  27 #include <linux/pagemap.h>
  28 #include <linux/ctype.h>
  29 #include <linux/utsname.h>
  30 #include <linux/mempool.h>
  31 #include <linux/delay.h>
  32 #include <linux/completion.h>
  33 #include <linux/kthread.h>
  34 #include <linux/pagevec.h>
  35 #include <linux/freezer.h>
  36 #include <linux/namei.h>
  37 #include <asm/uaccess.h>
  38 #include <asm/processor.h>
  39 #include <linux/inet.h>
  40 #include <linux/module.h>
  41 #include <keys/user-type.h>
  42 #include <net/ipv6.h>
  43 #include <linux/parser.h>
  44
  45 #include "cifspdu.h"
  46 #include "cifsglob.h"
  47 #include "cifsproto.h"
  48 #include "cifs_unicode.h"
  49 #include "cifs_debug.h"
  50 #include "cifs_fs_sb.h"
  51 #include "ntlmssp.h"
  52 #include "nterr.h"
  53 #include "rfc1002pdu.h"
  54 #include "fscache.h"
  55
  56 #define CIFS_PORT 445
  57 #define RFC1001_PORT 139
  58
  59 extern mempool_t *cifs_req_poolp;
  60
  61 /* FIXME: should these be tunable? */
  62 #define TLINK_ERROR_EXPIRE      (1 * HZ)
  63 #define TLINK_IDLE_EXPIRE       (600 * HZ)
  64
  65 enum {
  66
  67         /* Mount options that take no arguments */
  68         Opt_user_xattr, Opt_nouser_xattr,
  69         Opt_forceuid, Opt_noforceuid,
  70         Opt_forcegid, Opt_noforcegid,
  71         Opt_noblocksend, Opt_noautotune,
  72         Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
  73         Opt_mapchars, Opt_nomapchars, Opt_sfu,
  74         Opt_nosfu, Opt_nodfs, Opt_posixpaths,
  75         Opt_noposixpaths, Opt_nounix,
  76         Opt_nocase,
  77         Opt_brl, Opt_nobrl,
  78         Opt_forcemandatorylock, Opt_setuids,
  79         Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
  80         Opt_nohard, Opt_nosoft,
  81         Opt_nointr, Opt_intr,
  82         Opt_nostrictsync, Opt_strictsync,
  83         Opt_serverino, Opt_noserverino,
  84         Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
  85         Opt_acl, Opt_noacl, Opt_locallease,
  86         Opt_sign, Opt_seal, Opt_noac,
  87         Opt_fsc, Opt_mfsymlinks,
  88         Opt_multiuser, Opt_sloppy,
  89
  90         /* Mount options which take numeric value */
  91         Opt_backupuid, Opt_backupgid, Opt_uid,
  92         Opt_cruid, Opt_gid, Opt_file_mode,
  93         Opt_dirmode, Opt_port,
  94         Opt_rsize, Opt_wsize, Opt_actimeo,
  95
  96         /* Mount options which take string value */
  97         Opt_user, Opt_pass, Opt_ip,
  98         Opt_unc, Opt_domain,
  99         Opt_srcaddr, Opt_prefixpath,
 100         Opt_iocharset, Opt_sockopt,
 101         Opt_netbiosname, Opt_servern,
 102         Opt_ver, Opt_vers, Opt_sec, Opt_cache,
 103
 104         /* Mount options to be ignored */
 105         Opt_ignore,
 106
 107         /* Options which could be blank */
 108         Opt_blank_pass,
 109         Opt_blank_user,
 110         Opt_blank_ip,
 111
 112         Opt_err
 113 };
 114
 115 static const match_table_t cifs_mount_option_tokens = {
 116
 117         { Opt_user_xattr, "user_xattr" },
 118         { Opt_nouser_xattr, "nouser_xattr" },
 119         { Opt_forceuid, "forceuid" },
 120         { Opt_noforceuid, "noforceuid" },
 121         { Opt_forcegid, "forcegid" },
 122         { Opt_noforcegid, "noforcegid" },
 123         { Opt_noblocksend, "noblocksend" },
 124         { Opt_noautotune, "noautotune" },
 125         { Opt_hard, "hard" },
 126         { Opt_soft, "soft" },
 127         { Opt_perm, "perm" },
 128         { Opt_noperm, "noperm" },
 129         { Opt_mapchars, "mapchars" },
 130         { Opt_nomapchars, "nomapchars" },
 131         { Opt_sfu, "sfu" },
 132         { Opt_nosfu, "nosfu" },
 133         { Opt_nodfs, "nodfs" },
 134         { Opt_posixpaths, "posixpaths" },
 135         { Opt_noposixpaths, "noposixpaths" },
 136         { Opt_nounix, "nounix" },
 137         { Opt_nounix, "nolinux" },
 138         { Opt_nocase, "nocase" },
 139         { Opt_nocase, "ignorecase" },
 140         { Opt_brl, "brl" },
 141         { Opt_nobrl, "nobrl" },
 142         { Opt_nobrl, "nolock" },
 143         { Opt_forcemandatorylock, "forcemandatorylock" },
 144         { Opt_forcemandatorylock, "forcemand" },
 145         { Opt_setuids, "setuids" },
 146         { Opt_nosetuids, "nosetuids" },
 147         { Opt_dynperm, "dynperm" },
 148         { Opt_nodynperm, "nodynperm" },
 149         { Opt_nohard, "nohard" },
 150         { Opt_nosoft, "nosoft" },
 151         { Opt_nointr, "nointr" },
 152         { Opt_intr, "intr" },
 153         { Opt_nostrictsync, "nostrictsync" },
 154         { Opt_strictsync, "strictsync" },
 155         { Opt_serverino, "serverino" },
 156         { Opt_noserverino, "noserverino" },
 157         { Opt_rwpidforward, "rwpidforward" },
 158         { Opt_cifsacl, "cifsacl" },
 159         { Opt_nocifsacl, "nocifsacl" },
 160         { Opt_acl, "acl" },
 161         { Opt_noacl, "noacl" },
 162         { Opt_locallease, "locallease" },
 163         { Opt_sign, "sign" },
 164         { Opt_seal, "seal" },
 165         { Opt_noac, "noac" },
 166         { Opt_fsc, "fsc" },
 167         { Opt_mfsymlinks, "mfsymlinks" },
 168         { Opt_multiuser, "multiuser" },
 169         { Opt_sloppy, "sloppy" },
 170
 171         { Opt_backupuid, "backupuid=%s" },
 172         { Opt_backupgid, "backupgid=%s" },
 173         { Opt_uid, "uid=%s" },
 174         { Opt_cruid, "cruid=%s" },
 175         { Opt_gid, "gid=%s" },
 176         { Opt_file_mode, "file_mode=%s" },
 177         { Opt_dirmode, "dirmode=%s" },
 178         { Opt_dirmode, "dir_mode=%s" },
 179         { Opt_port, "port=%s" },
 180         { Opt_rsize, "rsize=%s" },
 181         { Opt_wsize, "wsize=%s" },
 182         { Opt_actimeo, "actimeo=%s" },
 183
 184         { Opt_blank_user, "user=" },
 185         { Opt_blank_user, "username=" },
 186         { Opt_user, "user=%s" },
 187         { Opt_user, "username=%s" },
 188         { Opt_blank_pass, "pass=" },
 189         { Opt_blank_pass, "password=" },
 190         { Opt_pass, "pass=%s" },
 191         { Opt_pass, "password=%s" },
 192         { Opt_blank_ip, "ip=" },
 193         { Opt_blank_ip, "addr=" },
 194         { Opt_ip, "ip=%s" },
 195         { Opt_ip, "addr=%s" },
 196         { Opt_unc, "unc=%s" },
 197         { Opt_unc, "target=%s" },
 198         { Opt_unc, "path=%s" },
 199         { Opt_domain, "dom=%s" },
 200         { Opt_domain, "domain=%s" },
 201         { Opt_domain, "workgroup=%s" },
 202         { Opt_srcaddr, "srcaddr=%s" },
 203         { Opt_prefixpath, "prefixpath=%s" },
 204         { Opt_iocharset, "iocharset=%s" },
 205         { Opt_sockopt, "sockopt=%s" },
 206         { Opt_netbiosname, "netbiosname=%s" },
 207         { Opt_servern, "servern=%s" },
 208         { Opt_ver, "ver=%s" },
 209         { Opt_vers, "vers=%s" },
 210         { Opt_sec, "sec=%s" },
 211         { Opt_cache, "cache=%s" },
 212
 213         { Opt_ignore, "cred" },
 214         { Opt_ignore, "credentials" },
 215         { Opt_ignore, "cred=%s" },
 216         { Opt_ignore, "credentials=%s" },
 217         { Opt_ignore, "guest" },
 218         { Opt_ignore, "rw" },
 219         { Opt_ignore, "ro" },
 220         { Opt_ignore, "suid" },
 221         { Opt_ignore, "nosuid" },
 222         { Opt_ignore, "exec" },
 223         { Opt_ignore, "noexec" },
 224         { Opt_ignore, "nodev" },
 225         { Opt_ignore, "noauto" },
 226         { Opt_ignore, "dev" },
 227         { Opt_ignore, "mand" },
 228         { Opt_ignore, "nomand" },
 229         { Opt_ignore, "_netdev" },
 230
 231         { Opt_err, NULL }
 232 };
 233
 234 enum {
 235         Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
 236         Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
 237         Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
 238         Opt_sec_ntlmv2i, Opt_sec_lanman,
 239         Opt_sec_none,
 240
 241         Opt_sec_err
 242 };
 243
 244 static const match_table_t cifs_secflavor_tokens = {
 245         { Opt_sec_krb5, "krb5" },
 246         { Opt_sec_krb5i, "krb5i" },
 247         { Opt_sec_krb5p, "krb5p" },
 248         { Opt_sec_ntlmsspi, "ntlmsspi" },
 249         { Opt_sec_ntlmssp, "ntlmssp" },
 250         { Opt_ntlm, "ntlm" },
 251         { Opt_sec_ntlmi, "ntlmi" },
 252         { Opt_sec_ntlmv2, "nontlm" },
 253         { Opt_sec_ntlmv2, "ntlmv2" },
 254         { Opt_sec_ntlmv2i, "ntlmv2i" },
 255         { Opt_sec_lanman, "lanman" },
 256         { Opt_sec_none, "none" },
 257
 258         { Opt_sec_err, NULL }
 259 };
 260
 261 /* cache flavors */
 262 enum {
 263         Opt_cache_loose,
 264         Opt_cache_strict,
 265         Opt_cache_none,
 266         Opt_cache_err
 267 };
 268
 269 static const match_table_t cifs_cacheflavor_tokens = {
 270         { Opt_cache_loose, "loose" },
 271         { Opt_cache_strict, "strict" },
 272         { Opt_cache_none, "none" },
 273         { Opt_cache_err, NULL }
 274 };
 275
 276 static const match_table_t cifs_smb_version_tokens = {
 277         { Smb_1, SMB1_VERSION_STRING },
 278         { Smb_20, SMB20_VERSION_STRING},
 279         { Smb_21, SMB21_VERSION_STRING },
 280         { Smb_30, SMB30_VERSION_STRING },
 281 };
 282
 283 static int ip_connect(struct TCP_Server_Info *server);
 284 static int generic_ip_connect(struct TCP_Server_Info *server);
 285 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
 286 static void cifs_prune_tlinks(struct work_struct *work);
 287 static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
 288                                         const char *devname);
 289
 290 /*
 291  * cifs tcp session reconnection
 292  *
 293  * mark tcp session as reconnecting so temporarily locked
 294  * mark all smb sessions as reconnecting for tcp session
 295  * reconnect tcp session
 296  * wake up waiters on reconnection? - (not needed currently)
 297  */
 298 int
 299 cifs_reconnect(struct TCP_Server_Info *server)
 300 {
 301         int rc = 0;
 302         struct list_head *tmp, *tmp2;
 303         struct cifs_ses *ses;
 304         struct cifs_tcon *tcon;
 305         struct mid_q_entry *mid_entry;
 306         struct list_head retry_list;
 307
 308         spin_lock(&GlobalMid_Lock);
 309         if (server->tcpStatus == CifsExiting) {
 310                 /* the demux thread will exit normally
 311                 next time through the loop */
 312                 spin_unlock(&GlobalMid_Lock);
 313                 return rc;
 314         } else
 315                 server->tcpStatus = CifsNeedReconnect;
 316         spin_unlock(&GlobalMid_Lock);
 317         server->maxBuf = 0;
 318 #ifdef CONFIG_CIFS_SMB2
 319         server->max_read = 0;
 320 #endif
 321
 322         cFYI(1, "Reconnecting tcp session");
 323
 324         /* before reconnecting the tcp session, mark the smb session (uid)
 325                 and the tid bad so they are not used until reconnected */
 326         cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
 327         spin_lock(&cifs_tcp_ses_lock);
 328         list_for_each(tmp, &server->smb_ses_list) {
 329                 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
 330                 ses->need_reconnect = true;
 331                 ses->ipc_tid = 0;
 332                 list_for_each(tmp2, &ses->tcon_list) {
 333                         tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
 334                         tcon->need_reconnect = true;
 335                 }
 336         }
 337         spin_unlock(&cifs_tcp_ses_lock);
 338
 339         /* do not want to be sending data on a socket we are freeing */
 340         cFYI(1, "%s: tearing down socket", __func__);
 341         mutex_lock(&server->srv_mutex);
 342         if (server->ssocket) {
 343                 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
 344                         server->ssocket->flags);
 345                 kernel_sock_shutdown(server->ssocket, SHUT_WR);
 346                 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
 347                         server->ssocket->state,
 348                         server->ssocket->flags);
 349                 sock_release(server->ssocket);
 350                 server->ssocket = NULL;
 351         }
 352         server->sequence_number = 0;
 353         server->session_estab = false;
 354         kfree(server->session_key.response);
 355         server->session_key.response = NULL;
 356         server->session_key.len = 0;
 357         server->lstrp = jiffies;
 358         mutex_unlock(&server->srv_mutex);
 359
 360         /* mark submitted MIDs for retry and issue callback */
 361         INIT_LIST_HEAD(&retry_list);
 362         cFYI(1, "%s: moving mids to private list", __func__);
 363         spin_lock(&GlobalMid_Lock);
 364         list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 365                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 366                 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
 367                         mid_entry->mid_state = MID_RETRY_NEEDED;
 368                 list_move(&mid_entry->qhead, &retry_list);
 369         }
 370         spin_unlock(&GlobalMid_Lock);
 371
 372         cFYI(1, "%s: issuing mid callbacks", __func__);
 373         list_for_each_safe(tmp, tmp2, &retry_list) {
 374                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 375                 list_del_init(&mid_entry->qhead);
 376                 mid_entry->callback(mid_entry);
 377         }
 378
 379         do {
 380                 try_to_freeze();
 381
 382                 /* we should try only the port we connected to before */
 383                 rc = generic_ip_connect(server);
 384                 if (rc) {
 385                         cFYI(1, "reconnect error %d", rc);
 386                         msleep(3000);
 387                 } else {
 388                         atomic_inc(&tcpSesReconnectCount);
 389                         spin_lock(&GlobalMid_Lock);
 390                         if (server->tcpStatus != CifsExiting)
 391                                 server->tcpStatus = CifsNeedNegotiate;
 392                         spin_unlock(&GlobalMid_Lock);
 393                 }
 394         } while (server->tcpStatus == CifsNeedReconnect);
 395
 396         return rc;
 397 }
 398
 399 static void
 400 cifs_echo_request(struct work_struct *work)
 401 {
 402         int rc;
 403         struct TCP_Server_Info *server = container_of(work,
 404                                         struct TCP_Server_Info, echo.work);
 405
 406         /*
 407          * We cannot send an echo if it is disabled or until the
 408          * NEGOTIATE_PROTOCOL request is done, which is indicated by
 409          * server->ops->need_neg() == true. Also, no need to ping if
 410          * we got a response recently.
 411          */
 412         if (!server->ops->need_neg || server->ops->need_neg(server) ||
 413             (server->ops->can_echo && !server->ops->can_echo(server)) ||
 414             time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
 415                 goto requeue_echo;
 416
 417         rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
 418         if (rc)
 419                 cFYI(1, "Unable to send echo request to server: %s",
 420                         server->hostname);
 421
 422 requeue_echo:
 423         queue_delayed_work(cifsiod_wq, &server->echo, SMB_ECHO_INTERVAL);
 424 }
 425
 426 static bool
 427 allocate_buffers(struct TCP_Server_Info *server)
 428 {
 429         if (!server->bigbuf) {
 430                 server->bigbuf = (char *)cifs_buf_get();
 431                 if (!server->bigbuf) {
 432                         cERROR(1, "No memory for large SMB response");
 433                         msleep(3000);
 434                         /* retry will check if exiting */
 435                         return false;
 436                 }
 437         } else if (server->large_buf) {
 438                 /* we are reusing a dirty large buf, clear its start */
 439                 memset(server->bigbuf, 0, HEADER_SIZE(server));
 440         }
 441
 442         if (!server->smallbuf) {
 443                 server->smallbuf = (char *)cifs_small_buf_get();
 444                 if (!server->smallbuf) {
 445                         cERROR(1, "No memory for SMB response");
 446                         msleep(1000);
 447                         /* retry will check if exiting */
 448                         return false;
 449                 }
 450                 /* beginning of smb buffer is cleared in our buf_get */
 451         } else {
 452                 /* if existing small buf clear beginning */
 453                 memset(server->smallbuf, 0, HEADER_SIZE(server));
 454         }
 455
 456         return true;
 457 }
 458
 459 static bool
 460 server_unresponsive(struct TCP_Server_Info *server)
 461 {
 462         /*
 463          * We need to wait 2 echo intervals to make sure we handle such
 464          * situations right:
 465          * 1s  client sends a normal SMB request
 466          * 2s  client gets a response
 467          * 30s echo workqueue job pops, and decides we got a response recently
 468          *     and don't need to send another
 469          * ...
 470          * 65s kernel_recvmsg times out, and we see that we haven't gotten
 471          *     a response in >60s.
 472          */
 473         if (server->tcpStatus == CifsGood &&
 474             time_after(jiffies, server->lstrp + 2 * SMB_ECHO_INTERVAL)) {
 475                 cERROR(1, "Server %s has not responded in %d seconds. "
 476                           "Reconnecting...", server->hostname,
 477                           (2 * SMB_ECHO_INTERVAL) / HZ);
 478                 cifs_reconnect(server);
 479                 wake_up(&server->response_q);
 480                 return true;
 481         }
 482
 483         return false;
 484 }
 485
 486 /*
 487  * kvec_array_init - clone a kvec array, and advance into it
 488  * @new:        pointer to memory for cloned array
 489  * @iov:        pointer to original array
 490  * @nr_segs:    number of members in original array
 491  * @bytes:      number of bytes to advance into the cloned array
 492  *
 493  * This function will copy the array provided in iov to a section of memory
 494  * and advance the specified number of bytes into the new array. It returns
 495  * the number of segments in the new array. "new" must be at least as big as
 496  * the original iov array.
 497  */
 498 static unsigned int
 499 kvec_array_init(struct kvec *new, struct kvec *iov, unsigned int nr_segs,
 500                 size_t bytes)
 501 {
 502         size_t base = 0;
 503
 504         while (bytes || !iov->iov_len) {
 505                 int copy = min(bytes, iov->iov_len);
 506
 507                 bytes -= copy;
 508                 base += copy;
 509                 if (iov->iov_len == base) {
 510                         iov++;
 511                         nr_segs--;
 512                         base = 0;
 513                 }
 514         }
 515         memcpy(new, iov, sizeof(*iov) * nr_segs);
 516         new->iov_base += base;
 517         new->iov_len -= base;
 518         return nr_segs;
 519 }
 520
 521 static struct kvec *
 522 get_server_iovec(struct TCP_Server_Info *server, unsigned int nr_segs)
 523 {
 524         struct kvec *new_iov;
 525
 526         if (server->iov && nr_segs <= server->nr_iov)
 527                 return server->iov;
 528
 529         /* not big enough -- allocate a new one and release the old */
 530         new_iov = kmalloc(sizeof(*new_iov) * nr_segs, GFP_NOFS);
 531         if (new_iov) {
 532                 kfree(server->iov);
 533                 server->iov = new_iov;
 534                 server->nr_iov = nr_segs;
 535         }
 536         return new_iov;
 537 }
 538
 539 int
 540 cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
 541                        unsigned int nr_segs, unsigned int to_read)
 542 {
 543         int length = 0;
 544         int total_read;
 545         unsigned int segs;
 546         struct msghdr smb_msg;
 547         struct kvec *iov;
 548
 549         iov = get_server_iovec(server, nr_segs);
 550         if (!iov)
 551                 return -ENOMEM;
 552
 553         smb_msg.msg_control = NULL;
 554         smb_msg.msg_controllen = 0;
 555
 556         for (total_read = 0; to_read; total_read += length, to_read -= length) {
 557                 try_to_freeze();
 558
 559                 if (server_unresponsive(server)) {
 560                         total_read = -EAGAIN;
 561                         break;
 562                 }
 563
 564                 segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
 565
 566                 length = kernel_recvmsg(server->ssocket, &smb_msg,
 567                                         iov, segs, to_read, 0);
 568
 569                 if (server->tcpStatus == CifsExiting) {
 570                         total_read = -ESHUTDOWN;
 571                         break;
 572                 } else if (server->tcpStatus == CifsNeedReconnect) {
 573                         cifs_reconnect(server);
 574                         total_read = -EAGAIN;
 575                         break;
 576                 } else if (length == -ERESTARTSYS ||
 577                            length == -EAGAIN ||
 578                            length == -EINTR) {
 579                         /*
 580                          * Minimum sleep to prevent looping, allowing socket
 581                          * to clear and app threads to set tcpStatus
 582                          * CifsNeedReconnect if server hung.
 583                          */
 584                         usleep_range(1000, 2000);
 585                         length = 0;
 586                         continue;
 587                 } else if (length <= 0) {
 588                         cFYI(1, "Received no data or error: expecting %d "
 589                                 "got %d", to_read, length);
 590                         cifs_reconnect(server);
 591                         total_read = -EAGAIN;
 592                         break;
 593                 }
 594         }
 595         return total_read;
 596 }
 597
 598 int
 599 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
 600                       unsigned int to_read)
 601 {
 602         struct kvec iov;
 603
 604         iov.iov_base = buf;
 605         iov.iov_len = to_read;
 606
 607         return cifs_readv_from_socket(server, &iov, 1, to_read);
 608 }
 609
 610 static bool
 611 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
 612 {
 613         /*
 614          * The first byte big endian of the length field,
 615          * is actually not part of the length but the type
 616          * with the most common, zero, as regular data.
 617          */
 618         switch (type) {
 619         case RFC1002_SESSION_MESSAGE:
 620                 /* Regular SMB response */
 621                 return true;
 622         case RFC1002_SESSION_KEEP_ALIVE:
 623                 cFYI(1, "RFC 1002 session keep alive");
 624                 break;
 625         case RFC1002_POSITIVE_SESSION_RESPONSE:
 626                 cFYI(1, "RFC 1002 positive session response");
 627                 break;
 628         case RFC1002_NEGATIVE_SESSION_RESPONSE:
 629                 /*
 630                  * We get this from Windows 98 instead of an error on
 631                  * SMB negprot response.
 632                  */
 633                 cFYI(1, "RFC 1002 negative session response");
 634                 /* give server a second to clean up */
 635                 msleep(1000);
 636                 /*
 637                  * Always try 445 first on reconnect since we get NACK
 638                  * on some if we ever connected to port 139 (the NACK
 639                  * is since we do not begin with RFC1001 session
 640                  * initialize frame).
 641                  */
 642                 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
 643                 cifs_reconnect(server);
 644                 wake_up(&server->response_q);
 645                 break;
 646         default:
 647                 cERROR(1, "RFC 1002 unknown response type 0x%x", type);
 648                 cifs_reconnect(server);
 649         }
 650
 651         return false;
 652 }
 653
 654 void
 655 dequeue_mid(struct mid_q_entry *mid, bool malformed)
 656 {
 657 #ifdef CONFIG_CIFS_STATS2
 658         mid->when_received = jiffies;
 659 #endif
 660         spin_lock(&GlobalMid_Lock);
 661         if (!malformed)
 662                 mid->mid_state = MID_RESPONSE_RECEIVED;
 663         else
 664                 mid->mid_state = MID_RESPONSE_MALFORMED;
 665         list_del_init(&mid->qhead);
 666         spin_unlock(&GlobalMid_Lock);
 667 }
 668
 669 static void
 670 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
 671            char *buf, int malformed)
 672 {
 673         if (server->ops->check_trans2 &&
 674             server->ops->check_trans2(mid, server, buf, malformed))
 675                 return;
 676         mid->resp_buf = buf;
 677         mid->large_buf = server->large_buf;
 678         /* Was previous buf put in mpx struct for multi-rsp? */
 679         if (!mid->multiRsp) {
 680                 /* smb buffer will be freed by user thread */
 681                 if (server->large_buf)
 682                         server->bigbuf = NULL;
 683                 else
 684                         server->smallbuf = NULL;
 685         }
 686         dequeue_mid(mid, malformed);
 687 }
 688
 689 static void clean_demultiplex_info(struct TCP_Server_Info *server)
 690 {
 691         int length;
 692
 693         /* take it off the list, if it's not already */
 694         spin_lock(&cifs_tcp_ses_lock);
 695         list_del_init(&server->tcp_ses_list);
 696         spin_unlock(&cifs_tcp_ses_lock);
 697
 698         spin_lock(&GlobalMid_Lock);
 699         server->tcpStatus = CifsExiting;
 700         spin_unlock(&GlobalMid_Lock);
 701         wake_up_all(&server->response_q);
 702
 703         /* check if we have blocked requests that need to free */
 704         spin_lock(&server->req_lock);
 705         if (server->credits <= 0)
 706                 server->credits = 1;
 707         spin_unlock(&server->req_lock);
 708         /*
 709          * Although there should not be any requests blocked on this queue it
 710          * can not hurt to be paranoid and try to wake up requests that may
 711          * haven been blocked when more than 50 at time were on the wire to the
 712          * same server - they now will see the session is in exit state and get
 713          * out of SendReceive.
 714          */
 715         wake_up_all(&server->request_q);
 716         /* give those requests time to exit */
 717         msleep(125);
 718
 719         if (server->ssocket) {
 720                 sock_release(server->ssocket);
 721                 server->ssocket = NULL;
 722         }
 723
 724         if (!list_empty(&server->pending_mid_q)) {
 725                 struct list_head dispose_list;
 726                 struct mid_q_entry *mid_entry;
 727                 struct list_head *tmp, *tmp2;
 728
 729                 INIT_LIST_HEAD(&dispose_list);
 730                 spin_lock(&GlobalMid_Lock);
 731                 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 732                         mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 733                         cFYI(1, "Clearing mid 0x%llx", mid_entry->mid);
 734                         mid_entry->mid_state = MID_SHUTDOWN;
 735                         list_move(&mid_entry->qhead, &dispose_list);
 736                 }
 737                 spin_unlock(&GlobalMid_Lock);
 738
 739                 /* now walk dispose list and issue callbacks */
 740                 list_for_each_safe(tmp, tmp2, &dispose_list) {
 741                         mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 742                         cFYI(1, "Callback mid 0x%llx", mid_entry->mid);
 743                         list_del_init(&mid_entry->qhead);
 744                         mid_entry->callback(mid_entry);
 745                 }
 746                 /* 1/8th of sec is more than enough time for them to exit */
 747                 msleep(125);
 748         }
 749
 750         if (!list_empty(&server->pending_mid_q)) {
 751                 /*
 752                  * mpx threads have not exited yet give them at least the smb
 753                  * send timeout time for long ops.
 754                  *
 755                  * Due to delays on oplock break requests, we need to wait at
 756                  * least 45 seconds before giving up on a request getting a
 757                  * response and going ahead and killing cifsd.
 758                  */
 759                 cFYI(1, "Wait for exit from demultiplex thread");
 760                 msleep(46000);
 761                 /*
 762                  * If threads still have not exited they are probably never
 763                  * coming home not much else we can do but free the memory.
 764                  */
 765         }
 766
 767         kfree(server->hostname);
 768         kfree(server->iov);
 769         kfree(server);
 770
 771         length = atomic_dec_return(&tcpSesAllocCount);
 772         if (length > 0)
 773                 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
 774                                 GFP_KERNEL);
 775 }
 776
 777 static int
 778 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
 779 {
 780         int length;
 781         char *buf = server->smallbuf;
 782         unsigned int pdu_length = get_rfc1002_length(buf);
 783
 784         /* make sure this will fit in a large buffer */
 785         if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
 786                 cERROR(1, "SMB response too long (%u bytes)",
 787                         pdu_length);
 788                 cifs_reconnect(server);
 789                 wake_up(&server->response_q);
 790                 return -EAGAIN;
 791         }
 792
 793         /* switch to large buffer if too big for a small one */
 794         if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
 795                 server->large_buf = true;
 796                 memcpy(server->bigbuf, buf, server->total_read);
 797                 buf = server->bigbuf;
 798         }
 799
 800         /* now read the rest */
 801         length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
 802                                 pdu_length - HEADER_SIZE(server) + 1 + 4);
 803         if (length < 0)
 804                 return length;
 805         server->total_read += length;
 806
 807         dump_smb(buf, server->total_read);
 808
 809         /*
 810          * We know that we received enough to get to the MID as we
 811          * checked the pdu_length earlier. Now check to see
 812          * if the rest of the header is OK. We borrow the length
 813          * var for the rest of the loop to avoid a new stack var.
 814          *
 815          * 48 bytes is enough to display the header and a little bit
 816          * into the payload for debugging purposes.
 817          */
 818         length = server->ops->check_message(buf, server->total_read);
 819         if (length != 0)
 820                 cifs_dump_mem("Bad SMB: ", buf,
 821                         min_t(unsigned int, server->total_read, 48));
 822
 823         if (server->ops->is_status_pending &&
 824             server->ops->is_status_pending(buf, server, length))
 825                 return -1;
 826
 827         if (!mid)
 828                 return length;
 829
 830         handle_mid(mid, server, buf, length);
 831         return 0;
 832 }
 833
 834 static int
 835 cifs_demultiplex_thread(void *p)
 836 {
 837         int length;
 838         struct TCP_Server_Info *server = p;
 839         unsigned int pdu_length;
 840         char *buf = NULL;
 841         struct task_struct *task_to_wake = NULL;
 842         struct mid_q_entry *mid_entry;
 843
 844         current->flags |= PF_MEMALLOC;
 845         cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
 846
 847         length = atomic_inc_return(&tcpSesAllocCount);
 848         if (length > 1)
 849                 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
 850                                 GFP_KERNEL);
 851
 852         set_freezable();
 853         while (server->tcpStatus != CifsExiting) {
 854                 if (try_to_freeze())
 855                         continue;
 856
 857                 if (!allocate_buffers(server))
 858                         continue;
 859
 860                 server->large_buf = false;
 861                 buf = server->smallbuf;
 862                 pdu_length = 4; /* enough to get RFC1001 header */
 863
 864                 length = cifs_read_from_socket(server, buf, pdu_length);
 865                 if (length < 0)
 866                         continue;
 867                 server->total_read = length;
 868
 869                 /*
 870                  * The right amount was read from socket - 4 bytes,
 871                  * so we can now interpret the length field.
 872                  */
 873                 pdu_length = get_rfc1002_length(buf);
 874
 875                 cFYI(1, "RFC1002 header 0x%x", pdu_length);
 876                 if (!is_smb_response(server, buf[0]))
 877                         continue;
 878
 879                 /* make sure we have enough to get to the MID */
 880                 if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
 881                         cERROR(1, "SMB response too short (%u bytes)",
 882                                 pdu_length);
 883                         cifs_reconnect(server);
 884                         wake_up(&server->response_q);
 885                         continue;
 886                 }
 887
 888                 /* read down to the MID */
 889                 length = cifs_read_from_socket(server, buf + 4,
 890                                                HEADER_SIZE(server) - 1 - 4);
 891                 if (length < 0)
 892                         continue;
 893                 server->total_read += length;
 894
 895                 mid_entry = server->ops->find_mid(server, buf);
 896
 897                 if (!mid_entry || !mid_entry->receive)
 898                         length = standard_receive3(server, mid_entry);
 899                 else
 900                         length = mid_entry->receive(server, mid_entry);
 901
 902                 if (length < 0)
 903                         continue;
 904
 905                 if (server->large_buf)
 906                         buf = server->bigbuf;
 907
 908                 server->lstrp = jiffies;
 909                 if (mid_entry != NULL) {
 910                         if (!mid_entry->multiRsp || mid_entry->multiEnd)
 911                                 mid_entry->callback(mid_entry);
 912                 } else if (!server->ops->is_oplock_break ||
 913                            !server->ops->is_oplock_break(buf, server)) {
 914                         cERROR(1, "No task to wake, unknown frame received! "
 915                                    "NumMids %d", atomic_read(&midCount));
 916                         cifs_dump_mem("Received Data is: ", buf,
 917                                       HEADER_SIZE(server));
 918 #ifdef CONFIG_CIFS_DEBUG2
 919                         if (server->ops->dump_detail)
 920                                 server->ops->dump_detail(buf);
 921                         cifs_dump_mids(server);
 922 #endif /* CIFS_DEBUG2 */
 923
 924                 }
 925         } /* end while !EXITING */
 926
 927         /* buffer usually freed in free_mid - need to free it here on exit */
 928         cifs_buf_release(server->bigbuf);
 929         if (server->smallbuf) /* no sense logging a debug message if NULL */
 930                 cifs_small_buf_release(server->smallbuf);
 931
 932         task_to_wake = xchg(&server->tsk, NULL);
 933         clean_demultiplex_info(server);
 934
 935         /* if server->tsk was NULL then wait for a signal before exiting */
 936         if (!task_to_wake) {
 937                 set_current_state(TASK_INTERRUPTIBLE);
 938                 while (!signal_pending(current)) {
 939                         schedule();
 940                         set_current_state(TASK_INTERRUPTIBLE);
 941                 }
 942                 set_current_state(TASK_RUNNING);
 943         }
 944
 945         module_put_and_exit(0);
 946 }
 947
 948 /* extract the host portion of the UNC string */
 949 static char *
 950 extract_hostname(const char *unc)
 951 {
 952         const char *src;
 953         char *dst, *delim;
 954         unsigned int len;
 955
 956         /* skip double chars at beginning of string */
 957         /* BB: check validity of these bytes? */
 958         src = unc + 2;
 959
 960         /* delimiter between hostname and sharename is always '\\' now */
 961         delim = strchr(src, '\\');
 962         if (!delim)
 963                 return ERR_PTR(-EINVAL);
 964
 965         len = delim - src;
 966         dst = kmalloc((len + 1), GFP_KERNEL);
 967         if (dst == NULL)
 968                 return ERR_PTR(-ENOMEM);
 969
 970         memcpy(dst, src, len);
 971         dst[len] = '\0';
 972
 973         return dst;
 974 }
 975
 976 static int get_option_ul(substring_t args[], unsigned long *option)
 977 {
 978         int rc;
 979         char *string;
 980
 981         string = match_strdup(args);
 982         if (string == NULL)
 983                 return -ENOMEM;
 984         rc = kstrtoul(string, 0, option);
 985         kfree(string);
 986
 987         return rc;
 988 }
 989
 990 static int get_option_uid(substring_t args[], kuid_t *result)
 991 {
 992         unsigned long value;
 993         kuid_t uid;
 994         int rc;
 995
 996         rc = get_option_ul(args, &value);
 997         if (rc)
 998                 return rc;
 999
1000         uid = make_kuid(current_user_ns(), value);
1001         if (!uid_valid(uid))
1002                 return -EINVAL;
1003
1004         *result = uid;
1005         return 0;
1006 }
1007
1008 static int get_option_gid(substring_t args[], kgid_t *result)
1009 {
1010         unsigned long value;
1011         kgid_t gid;
1012         int rc;
1013
1014         rc = get_option_ul(args, &value);
1015         if (rc)
1016                 return rc;
1017
1018         gid = make_kgid(current_user_ns(), value);
1019         if (!gid_valid(gid))
1020                 return -EINVAL;
1021
1022         *result = gid;
1023         return 0;
1024 }
1025
1026 static int cifs_parse_security_flavors(char *value,
1027                                        struct smb_vol *vol)
1028 {
1029
1030         substring_t args[MAX_OPT_ARGS];
1031
1032         switch (match_token(value, cifs_secflavor_tokens, args)) {
1033         case Opt_sec_krb5:
1034                 vol->secFlg |= CIFSSEC_MAY_KRB5;
1035                 break;
1036         case Opt_sec_krb5i:
1037                 vol->secFlg |= CIFSSEC_MAY_KRB5 | CIFSSEC_MUST_SIGN;
1038                 break;
1039         case Opt_sec_krb5p:
1040                 /* vol->secFlg |= CIFSSEC_MUST_SEAL | CIFSSEC_MAY_KRB5; */
1041                 cERROR(1, "Krb5 cifs privacy not supported");
1042                 break;
1043         case Opt_sec_ntlmssp:
1044                 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1045                 break;
1046         case Opt_sec_ntlmsspi:
1047                 vol->secFlg |= CIFSSEC_MAY_NTLMSSP | CIFSSEC_MUST_SIGN;
1048                 break;
1049         case Opt_ntlm:
1050                 /* ntlm is default so can be turned off too */
1051                 vol->secFlg |= CIFSSEC_MAY_NTLM;
1052                 break;
1053         case Opt_sec_ntlmi:
1054                 vol->secFlg |= CIFSSEC_MAY_NTLM | CIFSSEC_MUST_SIGN;
1055                 break;
1056         case Opt_sec_ntlmv2:
1057                 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1058                 break;
1059         case Opt_sec_ntlmv2i:
1060                 vol->secFlg |= CIFSSEC_MAY_NTLMV2 | CIFSSEC_MUST_SIGN;
1061                 break;
1062 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1063         case Opt_sec_lanman:
1064                 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1065                 break;
1066 #endif
1067         case Opt_sec_none:
1068                 vol->nullauth = 1;
1069                 break;
1070         default:
1071                 cERROR(1, "bad security option: %s", value);
1072                 return 1;
1073         }
1074
1075         return 0;
1076 }
1077
1078 static int
1079 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1080 {
1081         substring_t args[MAX_OPT_ARGS];
1082
1083         switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1084         case Opt_cache_loose:
1085                 vol->direct_io = false;
1086                 vol->strict_io = false;
1087                 break;
1088         case Opt_cache_strict:
1089                 vol->direct_io = false;
1090                 vol->strict_io = true;
1091                 break;
1092         case Opt_cache_none:
1093                 vol->direct_io = true;
1094                 vol->strict_io = false;
1095                 break;
1096         default:
1097                 cERROR(1, "bad cache= option: %s", value);
1098                 return 1;
1099         }
1100         return 0;
1101 }
1102
1103 static int
1104 cifs_parse_smb_version(char *value, struct smb_vol *vol)
1105 {
1106         substring_t args[MAX_OPT_ARGS];
1107
1108         switch (match_token(value, cifs_smb_version_tokens, args)) {
1109         case Smb_1:
1110                 vol->ops = &smb1_operations;
1111                 vol->vals = &smb1_values;
1112                 break;
1113 #ifdef CONFIG_CIFS_SMB2
1114         case Smb_20:
1115                 vol->ops = &smb21_operations; /* currently identical with 2.1 */
1116                 vol->vals = &smb20_values;
1117                 break;
1118         case Smb_21:
1119                 vol->ops = &smb21_operations;
1120                 vol->vals = &smb21_values;
1121                 break;
1122         case Smb_30:
1123                 vol->ops = &smb30_operations;
1124                 vol->vals = &smb30_values;
1125                 break;
1126 #endif
1127         default:
1128                 cERROR(1, "Unknown vers= option specified: %s", value);
1129                 return 1;
1130         }
1131         return 0;
1132 }
1133
1134 /*
1135  * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1136  * fields with the result. Returns 0 on success and an error otherwise.
1137  */
1138 static int
1139 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1140 {
1141         char *pos;
1142         const char *delims = "/\\";
1143         size_t len;
1144
1145         /* make sure we have a valid UNC double delimiter prefix */
1146         len = strspn(devname, delims);
1147         if (len != 2)
1148                 return -EINVAL;
1149
1150         /* find delimiter between host and sharename */
1151         pos = strpbrk(devname + 2, delims);
1152         if (!pos)
1153                 return -EINVAL;
1154
1155         /* skip past delimiter */
1156         ++pos;
1157
1158         /* now go until next delimiter or end of string */
1159         len = strcspn(pos, delims);
1160
1161         /* move "pos" up to delimiter or NULL */
1162         pos += len;
1163         vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1164         if (!vol->UNC)
1165                 return -ENOMEM;
1166
1167         convert_delimiter(vol->UNC, '\\');
1168
1169         /* If pos is NULL, or is a bogus trailing delimiter then no prepath */
1170         if (!*pos++ || !*pos)
1171                 return 0;
1172
1173         vol->prepath = kstrdup(pos, GFP_KERNEL);
1174         if (!vol->prepath)
1175                 return -ENOMEM;
1176
1177         return 0;
1178 }
1179
1180 static int
1181 cifs_parse_mount_options(const char *mountdata, const char *devname,
1182                          struct smb_vol *vol)
1183 {
1184         char *data, *end;
1185         char *mountdata_copy = NULL, *options;
1186         unsigned int  temp_len, i, j;
1187         char separator[2];
1188         short int override_uid = -1;
1189         short int override_gid = -1;
1190         bool uid_specified = false;
1191         bool gid_specified = false;
1192         bool sloppy = false;
1193         char *invalid = NULL;
1194         char *nodename = utsname()->nodename;
1195         char *string = NULL;
1196         char *tmp_end, *value;
1197         char delim;
1198         bool got_ip = false;
1199         unsigned short port = 0;
1200         struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1201
1202         separator[0] = ',';
1203         separator[1] = 0;
1204         delim = separator[0];
1205
1206         /* ensure we always start with zeroed-out smb_vol */
1207         memset(vol, 0, sizeof(*vol));
1208
1209         /*
1210          * does not have to be perfect mapping since field is
1211          * informational, only used for servers that do not support
1212          * port 445 and it can be overridden at mount time
1213          */
1214         memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1215         for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1216                 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1217
1218         vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1219         /* null target name indicates to use *SMBSERVR default called name
1220            if we end up sending RFC1001 session initialize */
1221         vol->target_rfc1001_name[0] = 0;
1222         vol->cred_uid = current_uid();
1223         vol->linux_uid = current_uid();
1224         vol->linux_gid = current_gid();
1225
1226         /* default to only allowing write access to owner of the mount */
1227         vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1228
1229         /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1230         /* default is always to request posix paths. */
1231         vol->posix_paths = 1;
1232         /* default to using server inode numbers where available */
1233         vol->server_ino = 1;
1234
1235         /* default is to use strict cifs caching semantics */
1236         vol->strict_io = true;
1237
1238         vol->actimeo = CIFS_DEF_ACTIMEO;
1239
1240         /* FIXME: add autonegotiation -- for now, SMB1 is default */
1241         vol->ops = &smb1_operations;
1242         vol->vals = &smb1_values;
1243
1244         if (!mountdata)
1245                 goto cifs_parse_mount_err;
1246
1247         mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1248         if (!mountdata_copy)
1249                 goto cifs_parse_mount_err;
1250
1251         options = mountdata_copy;
1252         end = options + strlen(options);
1253
1254         if (strncmp(options, "sep=", 4) == 0) {
1255                 if (options[4] != 0) {
1256                         separator[0] = options[4];
1257                         options += 5;
1258                 } else {
1259                         cFYI(1, "Null separator not allowed");
1260                 }
1261         }
1262         vol->backupuid_specified = false; /* no backup intent for a user */
1263         vol->backupgid_specified = false; /* no backup intent for a group */
1264
1265         /*
1266          * For now, we ignore -EINVAL errors under the assumption that the
1267          * unc= and prefixpath= options will be usable.
1268          */
1269         if (cifs_parse_devname(devname, vol) == -ENOMEM) {
1270                 printk(KERN_ERR "CIFS: Unable to allocate memory to parse "
1271                                 "device string.\n");
1272                 goto out_nomem;
1273         }
1274
1275         while ((data = strsep(&options, separator)) != NULL) {
1276                 substring_t args[MAX_OPT_ARGS];
1277                 unsigned long option;
1278                 int token;
1279
1280                 if (!*data)
1281                         continue;
1282
1283                 token = match_token(data, cifs_mount_option_tokens, args);
1284
1285                 switch (token) {
1286
1287                 /* Ingnore the following */
1288                 case Opt_ignore:
1289                         break;
1290
1291                 /* Boolean values */
1292                 case Opt_user_xattr:
1293                         vol->no_xattr = 0;
1294                         break;
1295                 case Opt_nouser_xattr:
1296                         vol->no_xattr = 1;
1297                         break;
1298                 case Opt_forceuid:
1299                         override_uid = 1;
1300                         break;
1301                 case Opt_noforceuid:
1302                         override_uid = 0;
1303                         break;
1304                 case Opt_forcegid:
1305                         override_gid = 1;
1306                         break;
1307                 case Opt_noforcegid:
1308                         override_gid = 0;
1309                         break;
1310                 case Opt_noblocksend:
1311                         vol->noblocksnd = 1;
1312                         break;
1313                 case Opt_noautotune:
1314                         vol->noautotune = 1;
1315                         break;
1316                 case Opt_hard:
1317                         vol->retry = 1;
1318                         break;
1319                 case Opt_soft:
1320                         vol->retry = 0;
1321                         break;
1322                 case Opt_perm:
1323                         vol->noperm = 0;
1324                         break;
1325                 case Opt_noperm:
1326                         vol->noperm = 1;
1327                         break;
1328                 case Opt_mapchars:
1329                         vol->remap = 1;
1330                         break;
1331                 case Opt_nomapchars:
1332                         vol->remap = 0;
1333                         break;
1334                 case Opt_sfu:
1335                         vol->sfu_emul = 1;
1336                         break;
1337                 case Opt_nosfu:
1338                         vol->sfu_emul = 0;
1339                         break;
1340                 case Opt_nodfs:
1341                         vol->nodfs = 1;
1342                         break;
1343                 case Opt_posixpaths:
1344                         vol->posix_paths = 1;
1345                         break;
1346                 case Opt_noposixpaths:
1347                         vol->posix_paths = 0;
1348                         break;
1349                 case Opt_nounix:
1350                         vol->no_linux_ext = 1;
1351                         break;
1352                 case Opt_nocase:
1353                         vol->nocase = 1;
1354                         break;
1355                 case Opt_brl:
1356                         vol->nobrl =  0;
1357                         break;
1358                 case Opt_nobrl:
1359                         vol->nobrl =  1;
1360                         /*
1361                          * turn off mandatory locking in mode
1362                          * if remote locking is turned off since the
1363                          * local vfs will do advisory
1364                          */
1365                         if (vol->file_mode ==
1366                                 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1367                                 vol->file_mode = S_IALLUGO;
1368                         break;
1369                 case Opt_forcemandatorylock:
1370                         vol->mand_lock = 1;
1371                         break;
1372                 case Opt_setuids:
1373                         vol->setuids = 1;
1374                         break;
1375                 case Opt_nosetuids:
1376                         vol->setuids = 0;
1377                         break;
1378                 case Opt_dynperm:
1379                         vol->dynperm = true;
1380                         break;
1381                 case Opt_nodynperm:
1382                         vol->dynperm = false;
1383                         break;
1384                 case Opt_nohard:
1385                         vol->retry = 0;
1386                         break;
1387                 case Opt_nosoft:
1388                         vol->retry = 1;
1389                         break;
1390                 case Opt_nointr:
1391                         vol->intr = 0;
1392                         break;
1393                 case Opt_intr:
1394                         vol->intr = 1;
1395                         break;
1396                 case Opt_nostrictsync:
1397                         vol->nostrictsync = 1;
1398                         break;
1399                 case Opt_strictsync:
1400                         vol->nostrictsync = 0;
1401                         break;
1402                 case Opt_serverino:
1403                         vol->server_ino = 1;
1404                         break;
1405                 case Opt_noserverino:
1406                         vol->server_ino = 0;
1407                         break;
1408                 case Opt_rwpidforward:
1409                         vol->rwpidforward = 1;
1410                         break;
1411                 case Opt_cifsacl:
1412                         vol->cifs_acl = 1;
1413                         break;
1414                 case Opt_nocifsacl:
1415                         vol->cifs_acl = 0;
1416                         break;
1417                 case Opt_acl:
1418                         vol->no_psx_acl = 0;
1419                         break;
1420                 case Opt_noacl:
1421                         vol->no_psx_acl = 1;
1422                         break;
1423                 case Opt_locallease:
1424                         vol->local_lease = 1;
1425                         break;
1426                 case Opt_sign:
1427                         vol->secFlg |= CIFSSEC_MUST_SIGN;
1428                         break;
1429                 case Opt_seal:
1430                         /* we do not do the following in secFlags because seal
1431                          * is a per tree connection (mount) not a per socket
1432                          * or per-smb connection option in the protocol
1433                          * vol->secFlg |= CIFSSEC_MUST_SEAL;
1434                          */
1435                         vol->seal = 1;
1436                         break;
1437                 case Opt_noac:
1438                         printk(KERN_WARNING "CIFS: Mount option noac not "
1439                                 "supported. Instead set "
1440                                 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1441                         break;
1442                 case Opt_fsc:
1443 #ifndef CONFIG_CIFS_FSCACHE
1444                         cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
1445                                   "kernel config option set");
1446                         goto cifs_parse_mount_err;
1447 #endif
1448                         vol->fsc = true;
1449                         break;
1450                 case Opt_mfsymlinks:
1451                         vol->mfsymlinks = true;
1452                         break;
1453                 case Opt_multiuser:
1454                         vol->multiuser = true;
1455                         break;
1456                 case Opt_sloppy:
1457                         sloppy = true;
1458                         break;
1459
1460                 /* Numeric Values */
1461                 case Opt_backupuid:
1462                         if (get_option_uid(args, &vol->backupuid)) {
1463                                 cERROR(1, "%s: Invalid backupuid value",
1464                                         __func__);
1465                                 goto cifs_parse_mount_err;
1466                         }
1467                         vol->backupuid_specified = true;
1468                         break;
1469                 case Opt_backupgid:
1470                         if (get_option_gid(args, &vol->backupgid)) {
1471                                 cERROR(1, "%s: Invalid backupgid value",
1472                                         __func__);
1473                                 goto cifs_parse_mount_err;
1474                         }
1475                         vol->backupgid_specified = true;
1476                         break;
1477                 case Opt_uid:
1478                         if (get_option_uid(args, &vol->linux_uid)) {
1479                                 cERROR(1, "%s: Invalid uid value",
1480                                         __func__);
1481                                 goto cifs_parse_mount_err;
1482                         }
1483                         uid_specified = true;
1484                         break;
1485                 case Opt_cruid:
1486                         if (get_option_uid(args, &vol->cred_uid)) {
1487                                 cERROR(1, "%s: Invalid cruid value",
1488                                         __func__);
1489                                 goto cifs_parse_mount_err;
1490                         }
1491                         break;
1492                 case Opt_gid:
1493                         if (get_option_gid(args, &vol->linux_gid)) {
1494                                 cERROR(1, "%s: Invalid gid value",
1495                                                 __func__);
1496                                 goto cifs_parse_mount_err;
1497                         }
1498                         gid_specified = true;
1499                         break;
1500                 case Opt_file_mode:
1501                         if (get_option_ul(args, &option)) {
1502                                 cERROR(1, "%s: Invalid file_mode value",
1503                                         __func__);
1504                                 goto cifs_parse_mount_err;
1505                         }
1506                         vol->file_mode = option;
1507                         break;
1508                 case Opt_dirmode:
1509                         if (get_option_ul(args, &option)) {
1510                                 cERROR(1, "%s: Invalid dir_mode value",
1511                                         __func__);
1512                                 goto cifs_parse_mount_err;
1513                         }
1514                         vol->dir_mode = option;
1515                         break;
1516                 case Opt_port:
1517                         if (get_option_ul(args, &option) ||
1518                             option > USHRT_MAX) {
1519                                 cERROR(1, "%s: Invalid port value", __func__);
1520                                 goto cifs_parse_mount_err;
1521                         }
1522                         port = (unsigned short)option;
1523                         break;
1524                 case Opt_rsize:
1525                         if (get_option_ul(args, &option)) {
1526                                 cERROR(1, "%s: Invalid rsize value",
1527                                         __func__);
1528                                 goto cifs_parse_mount_err;
1529                         }
1530                         vol->rsize = option;
1531                         break;
1532                 case Opt_wsize:
1533                         if (get_option_ul(args, &option)) {
1534                                 cERROR(1, "%s: Invalid wsize value",
1535                                         __func__);
1536                                 goto cifs_parse_mount_err;
1537                         }
1538                         vol->wsize = option;
1539                         break;
1540                 case Opt_actimeo:
1541                         if (get_option_ul(args, &option)) {
1542                                 cERROR(1, "%s: Invalid actimeo value",
1543                                         __func__);
1544                                 goto cifs_parse_mount_err;
1545                         }
1546                         vol->actimeo = HZ * option;
1547                         if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1548                                 cERROR(1, "CIFS: attribute cache"
1549                                           "timeout too large");
1550                                 goto cifs_parse_mount_err;
1551                         }
1552                         break;
1553
1554                 /* String Arguments */
1555
1556                 case Opt_blank_user:
1557                         /* null user, ie. anonymous authentication */
1558                         vol->nullauth = 1;
1559                         vol->username = NULL;
1560                         break;
1561                 case Opt_user:
1562                         string = match_strdup(args);
1563                         if (string == NULL)
1564                                 goto out_nomem;
1565
1566                         if (strnlen(string, MAX_USERNAME_SIZE) >
1567                                                         MAX_USERNAME_SIZE) {
1568                                 printk(KERN_WARNING "CIFS: username too long\n");
1569                                 goto cifs_parse_mount_err;
1570                         }
1571                         vol->username = kstrdup(string, GFP_KERNEL);
1572                         if (!vol->username) {
1573                                 printk(KERN_WARNING "CIFS: no memory "
1574                                                     "for username\n");
1575                                 goto cifs_parse_mount_err;
1576                         }
1577                         break;
1578                 case Opt_blank_pass:
1579                         vol->password = NULL;
1580                         break;
1581                 case Opt_pass:
1582                         /* passwords have to be handled differently
1583                          * to allow the character used for deliminator
1584                          * to be passed within them
1585                          */
1586
1587                         /* Obtain the value string */
1588                         value = strchr(data, '=');
1589                         value++;
1590
1591                         /* Set tmp_end to end of the string */
1592                         tmp_end = (char *) value + strlen(value);
1593
1594                         /* Check if following character is the deliminator
1595                          * If yes, we have encountered a double deliminator
1596                          * reset the NULL character to the deliminator
1597                          */
1598                         if (tmp_end < end && tmp_end[1] == delim) {
1599                                 tmp_end[0] = delim;
1600
1601                                 /* Keep iterating until we get to a single
1602                                  * deliminator OR the end
1603                                  */
1604                                 while ((tmp_end = strchr(tmp_end, delim))
1605                                         != NULL && (tmp_end[1] == delim)) {
1606                                                 tmp_end = (char *) &tmp_end[2];
1607                                 }
1608
1609                                 /* Reset var options to point to next element */
1610                                 if (tmp_end) {
1611                                         tmp_end[0] = '\0';
1612                                         options = (char *) &tmp_end[1];
1613                                 } else
1614                                         /* Reached the end of the mount option
1615                                          * string */
1616                                         options = end;
1617                         }
1618
1619                         /* Now build new password string */
1620                         temp_len = strlen(value);
1621                         vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1622                         if (vol->password == NULL) {
1623                                 printk(KERN_WARNING "CIFS: no memory "
1624                                                     "for password\n");
1625                                 goto cifs_parse_mount_err;
1626                         }
1627
1628                         for (i = 0, j = 0; i < temp_len; i++, j++) {
1629                                 vol->password[j] = value[i];
1630                                 if ((value[i] == delim) &&
1631                                      value[i+1] == delim)
1632                                         /* skip the second deliminator */
1633                                         i++;
1634                         }
1635                         vol->password[j] = '\0';
1636                         break;
1637                 case Opt_blank_ip:
1638                         /* FIXME: should this be an error instead? */
1639                         got_ip = false;
1640                         break;
1641                 case Opt_ip:
1642                         string = match_strdup(args);
1643                         if (string == NULL)
1644                                 goto out_nomem;
1645
1646                         if (!cifs_convert_address(dstaddr, string,
1647                                         strlen(string))) {
1648                                 printk(KERN_ERR "CIFS: bad ip= option (%s).\n",
1649                                         string);
1650                                 goto cifs_parse_mount_err;
1651                         }
1652                         got_ip = true;
1653                         break;
1654                 case Opt_unc:
1655                         string = vol->UNC;
1656                         vol->UNC = match_strdup(args);
1657                         if (vol->UNC == NULL)
1658                                 goto out_nomem;
1659
1660                         convert_delimiter(vol->UNC, '\\');
1661                         if (vol->UNC[0] != '\\' || vol->UNC[1] != '\\') {
1662                                 printk(KERN_ERR "CIFS: UNC Path does not "
1663                                                 "begin with // or \\\\\n");
1664                                 goto cifs_parse_mount_err;
1665                         }
1666
1667                         /* Compare old unc= option to new one */
1668                         if (!string || strcmp(string, vol->UNC))
1669                                 printk(KERN_WARNING "CIFS: the value of the "
1670                                         "unc= mount option does not match the "
1671                                         "device string. Using the unc= option "
1672                                         "for now. In 3.10, that option will "
1673                                         "be ignored and the contents of the "
1674                                         "device string will be used "
1675                                         "instead. (%s != %s)\n", string,
1676                                         vol->UNC);
1677                         break;
1678                 case Opt_domain:
1679                         string = match_strdup(args);
1680                         if (string == NULL)
1681                                 goto out_nomem;
1682
1683                         if (strnlen(string, 256) == 256) {
1684                                 printk(KERN_WARNING "CIFS: domain name too"
1685                                                     " long\n");
1686                                 goto cifs_parse_mount_err;
1687                         }
1688
1689                         vol->domainname = kstrdup(string, GFP_KERNEL);
1690                         if (!vol->domainname) {
1691                                 printk(KERN_WARNING "CIFS: no memory "
1692                                                     "for domainname\n");
1693                                 goto cifs_parse_mount_err;
1694                         }
1695                         cFYI(1, "Domain name set");
1696                         break;
1697                 case Opt_srcaddr:
1698                         string = match_strdup(args);
1699                         if (string == NULL)
1700                                 goto out_nomem;
1701
1702                         if (!cifs_convert_address(
1703                                         (struct sockaddr *)&vol->srcaddr,
1704                                         string, strlen(string))) {
1705                                 printk(KERN_WARNING "CIFS:  Could not parse"
1706                                                     " srcaddr: %s\n", string);
1707                                 goto cifs_parse_mount_err;
1708                         }
1709                         break;
1710                 case Opt_prefixpath:
1711                         /* skip over any leading delimiter */
1712                         if (*args[0].from == '/' || *args[0].from == '\\')
1713                                 args[0].from++;
1714
1715                         string = vol->prepath;
1716                         vol->prepath = match_strdup(args);
1717                         if (vol->prepath == NULL)
1718                                 goto out_nomem;
1719                         /* Compare old prefixpath= option to new one */
1720                         if (!string || strcmp(string, vol->prepath))
1721                                 printk(KERN_WARNING "CIFS: the value of the "
1722                                         "prefixpath= mount option does not "
1723                                         "match the device string. Using the "
1724                                         "prefixpath= option for now. In 3.10, "
1725                                         "that option will be ignored and the "
1726                                         "contents of the device string will be "
1727                                         "used instead.(%s != %s)\n", string,
1728                                         vol->prepath);
1729                         break;
1730                 case Opt_iocharset:
1731                         string = match_strdup(args);
1732                         if (string == NULL)
1733                                 goto out_nomem;
1734
1735                         if (strnlen(string, 1024) >= 65) {
1736                                 printk(KERN_WARNING "CIFS: iocharset name "
1737                                                     "too long.\n");
1738                                 goto cifs_parse_mount_err;
1739                         }
1740
1741                          if (strnicmp(string, "default", 7) != 0) {
1742                                 vol->iocharset = kstrdup(string,
1743                                                          GFP_KERNEL);
1744                                 if (!vol->iocharset) {
1745                                         printk(KERN_WARNING "CIFS: no memory"
1746                                                             "for charset\n");
1747                                         goto cifs_parse_mount_err;
1748                                 }
1749                         }
1750                         /* if iocharset not set then load_nls_default
1751                          * is used by caller
1752                          */
1753                         cFYI(1, "iocharset set to %s", string);
1754                         break;
1755                 case Opt_sockopt:
1756                         string = match_strdup(args);
1757                         if (string == NULL)
1758                                 goto out_nomem;
1759
1760                         if (strnicmp(string, "TCP_NODELAY", 11) == 0) {
1761                                 printk(KERN_WARNING "CIFS: the "
1762                                         "sockopt=TCP_NODELAY option has been "
1763                                         "deprecated and will be removed "
1764                                         "in 3.9\n");
1765                                 vol->sockopt_tcp_nodelay = 1;
1766                         }
1767                         break;
1768                 case Opt_netbiosname:
1769                         string = match_strdup(args);
1770                         if (string == NULL)
1771                                 goto out_nomem;
1772
1773                         memset(vol->source_rfc1001_name, 0x20,
1774                                 RFC1001_NAME_LEN);
1775                         /*
1776                          * FIXME: are there cases in which a comma can
1777                          * be valid in workstation netbios name (and
1778                          * need special handling)?
1779                          */
1780                         for (i = 0; i < RFC1001_NAME_LEN; i++) {
1781                                 /* don't ucase netbiosname for user */
1782                                 if (string[i] == 0)
1783                                         break;
1784                                 vol->source_rfc1001_name[i] = string[i];
1785                         }
1786                         /* The string has 16th byte zero still from
1787                          * set at top of the function
1788                          */
1789                         if (i == RFC1001_NAME_LEN && string[i] != 0)
1790                                 printk(KERN_WARNING "CIFS: netbiosname"
1791                                        " longer than 15 truncated.\n");
1792
1793                         break;
1794                 case Opt_servern:
1795                         /* servernetbiosname specified override *SMBSERVER */
1796                         string = match_strdup(args);
1797                         if (string == NULL)
1798                                 goto out_nomem;
1799
1800                         /* last byte, type, is 0x20 for servr type */
1801                         memset(vol->target_rfc1001_name, 0x20,
1802                                 RFC1001_NAME_LEN_WITH_NULL);
1803
1804                         /* BB are there cases in which a comma can be
1805                            valid in this workstation netbios name
1806                            (and need special handling)? */
1807
1808                         /* user or mount helper must uppercase the
1809                            netbios name */
1810                         for (i = 0; i < 15; i++) {
1811                                 if (string[i] == 0)
1812                                         break;
1813                                 vol->target_rfc1001_name[i] = string[i];
1814                         }
1815                         /* The string has 16th byte zero still from
1816                            set at top of the function  */
1817                         if (i == RFC1001_NAME_LEN && string[i] != 0)
1818                                 printk(KERN_WARNING "CIFS: server net"
1819                                        "biosname longer than 15 truncated.\n");
1820                         break;
1821                 case Opt_ver:
1822                         string = match_strdup(args);
1823                         if (string == NULL)
1824                                 goto out_nomem;
1825
1826                         if (strnicmp(string, "1", 1) == 0) {
1827                                 /* This is the default */
1828                                 break;
1829                         }
1830                         /* For all other value, error */
1831                         printk(KERN_WARNING "CIFS: Invalid version"
1832                                             " specified\n");
1833                         goto cifs_parse_mount_err;
1834                 case Opt_vers:
1835                         string = match_strdup(args);
1836                         if (string == NULL)
1837                                 goto out_nomem;
1838
1839                         if (cifs_parse_smb_version(string, vol) != 0)
1840                                 goto cifs_parse_mount_err;
1841                         break;
1842                 case Opt_sec:
1843                         string = match_strdup(args);
1844                         if (string == NULL)
1845                                 goto out_nomem;
1846
1847                         if (cifs_parse_security_flavors(string, vol) != 0)
1848                                 goto cifs_parse_mount_err;
1849                         break;
1850                 case Opt_cache:
1851                         string = match_strdup(args);
1852                         if (string == NULL)
1853                                 goto out_nomem;
1854
1855                         if (cifs_parse_cache_flavor(string, vol) != 0)
1856                                 goto cifs_parse_mount_err;
1857                         break;
1858                 default:
1859                         /*
1860                          * An option we don't recognize. Save it off for later
1861                          * if we haven't already found one
1862                          */
1863                         if (!invalid)
1864                                 invalid = data;
1865                         break;
1866                 }
1867                 /* Free up any allocated string */
1868                 kfree(string);
1869                 string = NULL;
1870         }
1871
1872         if (!sloppy && invalid) {
1873                 printk(KERN_ERR "CIFS: Unknown mount option \"%s\"\n", invalid);
1874                 goto cifs_parse_mount_err;
1875         }
1876
1877 #ifndef CONFIG_KEYS
1878         /* Muliuser mounts require CONFIG_KEYS support */
1879         if (vol->multiuser) {
1880                 cERROR(1, "Multiuser mounts require kernels with "
1881                           "CONFIG_KEYS enabled.");
1882                 goto cifs_parse_mount_err;
1883         }
1884 #endif
1885         if (!vol->UNC) {
1886                 cERROR(1, "CIFS mount error: No usable UNC path provided in "
1887                           "device string or in unc= option!");
1888                 goto cifs_parse_mount_err;
1889         }
1890
1891         /* make sure UNC has a share name */
1892         if (!strchr(vol->UNC + 3, '\\')) {
1893                 cERROR(1, "Malformed UNC. Unable to find share name.");
1894                 goto cifs_parse_mount_err;
1895         }
1896
1897         if (!got_ip) {
1898                 /* No ip= option specified? Try to get it from UNC */
1899                 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
1900                                                 strlen(&vol->UNC[2]))) {
1901                         printk(KERN_ERR "Unable to determine destination "
1902                                         "address.\n");
1903                         goto cifs_parse_mount_err;
1904                 }
1905         }
1906
1907         /* set the port that we got earlier */
1908         cifs_set_port(dstaddr, port);
1909
1910         if (uid_specified)
1911                 vol->override_uid = override_uid;
1912         else if (override_uid == 1)
1913                 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1914                                    "specified with no uid= option.\n");
1915
1916         if (gid_specified)
1917                 vol->override_gid = override_gid;
1918         else if (override_gid == 1)
1919                 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1920                                    "specified with no gid= option.\n");
1921
1922         kfree(mountdata_copy);
1923         return 0;
1924
1925 out_nomem:
1926         printk(KERN_WARNING "Could not allocate temporary buffer\n");
1927 cifs_parse_mount_err:
1928         kfree(string);
1929         kfree(mountdata_copy);
1930         return 1;
1931 }
1932
1933 /** Returns true if srcaddr isn't specified and rhs isn't
1934  * specified, or if srcaddr is specified and
1935  * matches the IP address of the rhs argument.
1936  */
1937 static bool
1938 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1939 {
1940         switch (srcaddr->sa_family) {
1941         case AF_UNSPEC:
1942                 return (rhs->sa_family == AF_UNSPEC);
1943         case AF_INET: {
1944                 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1945                 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1946                 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1947         }
1948         case AF_INET6: {
1949                 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1950                 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
1951                 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1952         }
1953         default:
1954                 WARN_ON(1);
1955                 return false; /* don't expect to be here */
1956         }
1957 }
1958
1959 /*
1960  * If no port is specified in addr structure, we try to match with 445 port
1961  * and if it fails - with 139 ports. It should be called only if address
1962  * families of server and addr are equal.
1963  */
1964 static bool
1965 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1966 {
1967         __be16 port, *sport;
1968
1969         switch (addr->sa_family) {
1970         case AF_INET:
1971                 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1972                 port = ((struct sockaddr_in *) addr)->sin_port;
1973                 break;
1974         case AF_INET6:
1975                 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1976                 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1977                 break;
1978         default:
1979                 WARN_ON(1);
1980                 return false;
1981         }
1982
1983         if (!port) {
1984                 port = htons(CIFS_PORT);
1985                 if (port == *sport)
1986                         return true;
1987
1988                 port = htons(RFC1001_PORT);
1989         }
1990
1991         return port == *sport;
1992 }
1993
1994 static bool
1995 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1996               struct sockaddr *srcaddr)
1997 {
1998         switch (addr->sa_family) {
1999         case AF_INET: {
2000                 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2001                 struct sockaddr_in *srv_addr4 =
2002                                         (struct sockaddr_in *)&server->dstaddr;
2003
2004                 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2005                         return false;
2006                 break;
2007         }
2008         case AF_INET6: {
2009                 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2010                 struct sockaddr_in6 *srv_addr6 =
2011                                         (struct sockaddr_in6 *)&server->dstaddr;
2012
2013                 if (!ipv6_addr_equal(&addr6->sin6_addr,
2014                                      &srv_addr6->sin6_addr))
2015                         return false;
2016                 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2017                         return false;
2018                 break;
2019         }
2020         default:
2021                 WARN_ON(1);
2022                 return false; /* don't expect to be here */
2023         }
2024
2025         if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2026                 return false;
2027
2028         return true;
2029 }
2030
2031 static bool
2032 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2033 {
2034         unsigned int secFlags;
2035
2036         if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
2037                 secFlags = vol->secFlg;
2038         else
2039                 secFlags = global_secflags | vol->secFlg;
2040
2041         switch (server->secType) {
2042         case LANMAN:
2043                 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
2044                         return false;
2045                 break;
2046         case NTLMv2:
2047                 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
2048                         return false;
2049                 break;
2050         case NTLM:
2051                 if (!(secFlags & CIFSSEC_MAY_NTLM))
2052                         return false;
2053                 break;
2054         case Kerberos:
2055                 if (!(secFlags & CIFSSEC_MAY_KRB5))
2056                         return false;
2057                 break;
2058         case RawNTLMSSP:
2059                 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
2060                         return false;
2061                 break;
2062         default:
2063                 /* shouldn't happen */
2064                 return false;
2065         }
2066
2067         /* now check if signing mode is acceptable */
2068         if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
2069             (server->sec_mode & SECMODE_SIGN_REQUIRED))
2070                         return false;
2071         else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
2072                  (server->sec_mode &
2073                   (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
2074                         return false;
2075
2076         return true;
2077 }
2078
2079 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2080 {
2081         struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2082
2083         if ((server->vals != vol->vals) || (server->ops != vol->ops))
2084                 return 0;
2085
2086         if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2087                 return 0;
2088
2089         if (!match_address(server, addr,
2090                            (struct sockaddr *)&vol->srcaddr))
2091                 return 0;
2092
2093         if (!match_port(server, addr))
2094                 return 0;
2095
2096         if (!match_security(server, vol))
2097                 return 0;
2098
2099         return 1;
2100 }
2101
2102 static struct TCP_Server_Info *
2103 cifs_find_tcp_session(struct smb_vol *vol)
2104 {
2105         struct TCP_Server_Info *server;
2106
2107         spin_lock(&cifs_tcp_ses_lock);
2108         list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2109                 if (!match_server(server, vol))
2110                         continue;
2111
2112                 ++server->srv_count;
2113                 spin_unlock(&cifs_tcp_ses_lock);
2114                 cFYI(1, "Existing tcp session with server found");
2115                 return server;
2116         }
2117         spin_unlock(&cifs_tcp_ses_lock);
2118         return NULL;
2119 }
2120
2121 static void
2122 cifs_put_tcp_session(struct TCP_Server_Info *server)
2123 {
2124         struct task_struct *task;
2125
2126         spin_lock(&cifs_tcp_ses_lock);
2127         if (--server->srv_count > 0) {
2128                 spin_unlock(&cifs_tcp_ses_lock);
2129                 return;
2130         }
2131
2132         put_net(cifs_net_ns(server));
2133
2134         list_del_init(&server->tcp_ses_list);
2135         spin_unlock(&cifs_tcp_ses_lock);
2136
2137         cancel_delayed_work_sync(&server->echo);
2138
2139         spin_lock(&GlobalMid_Lock);
2140         server->tcpStatus = CifsExiting;
2141         spin_unlock(&GlobalMid_Lock);
2142
2143         cifs_crypto_shash_release(server);
2144         cifs_fscache_release_client_cookie(server);
2145
2146         kfree(server->session_key.response);
2147         server->session_key.response = NULL;
2148         server->session_key.len = 0;
2149
2150         task = xchg(&server->tsk, NULL);
2151         if (task)
2152                 force_sig(SIGKILL, task);
2153 }
2154
2155 static struct TCP_Server_Info *
2156 cifs_get_tcp_session(struct smb_vol *volume_info)
2157 {
2158         struct TCP_Server_Info *tcp_ses = NULL;
2159         int rc;
2160
2161         cFYI(1, "UNC: %s", volume_info->UNC);
2162
2163         /* see if we already have a matching tcp_ses */
2164         tcp_ses = cifs_find_tcp_session(volume_info);
2165         if (tcp_ses)
2166                 return tcp_ses;
2167
2168         tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2169         if (!tcp_ses) {
2170                 rc = -ENOMEM;
2171                 goto out_err;
2172         }
2173
2174         rc = cifs_crypto_shash_allocate(tcp_ses);
2175         if (rc) {
2176                 cERROR(1, "could not setup hash structures rc %d", rc);
2177                 goto out_err;
2178         }
2179
2180         tcp_ses->ops = volume_info->ops;
2181         tcp_ses->vals = volume_info->vals;
2182         cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2183         tcp_ses->hostname = extract_hostname(volume_info->UNC);
2184         if (IS_ERR(tcp_ses->hostname)) {
2185                 rc = PTR_ERR(tcp_ses->hostname);
2186                 goto out_err_crypto_release;
2187         }
2188
2189         tcp_ses->noblocksnd = volume_info->noblocksnd;
2190         tcp_ses->noautotune = volume_info->noautotune;
2191         tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2192         tcp_ses->in_flight = 0;
2193         tcp_ses->credits = 1;
2194         init_waitqueue_head(&tcp_ses->response_q);
2195         init_waitqueue_head(&tcp_ses->request_q);
2196         INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2197         mutex_init(&tcp_ses->srv_mutex);
2198         memcpy(tcp_ses->workstation_RFC1001_name,
2199                 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2200         memcpy(tcp_ses->server_RFC1001_name,
2201                 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2202         tcp_ses->session_estab = false;
2203         tcp_ses->sequence_number = 0;
2204         tcp_ses->lstrp = jiffies;
2205         spin_lock_init(&tcp_ses->req_lock);
2206         INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2207         INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2208         INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2209         memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2210                sizeof(tcp_ses->srcaddr));
2211         memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2212                 sizeof(tcp_ses->dstaddr));
2213         /*
2214          * at this point we are the only ones with the pointer
2215          * to the struct since the kernel thread not created yet
2216          * no need to spinlock this init of tcpStatus or srv_count
2217          */
2218         tcp_ses->tcpStatus = CifsNew;
2219         ++tcp_ses->srv_count;
2220
2221         rc = ip_connect(tcp_ses);
2222         if (rc < 0) {
2223                 cERROR(1, "Error connecting to socket. Aborting operation");
2224                 goto out_err_crypto_release;
2225         }
2226
2227         /*
2228          * since we're in a cifs function already, we know that
2229          * this will succeed. No need for try_module_get().
2230          */
2231         __module_get(THIS_MODULE);
2232         tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2233                                   tcp_ses, "cifsd");
2234         if (IS_ERR(tcp_ses->tsk)) {
2235                 rc = PTR_ERR(tcp_ses->tsk);
2236                 cERROR(1, "error %d create cifsd thread", rc);
2237                 module_put(THIS_MODULE);
2238                 goto out_err_crypto_release;
2239         }
2240         tcp_ses->tcpStatus = CifsNeedNegotiate;
2241
2242         /* thread spawned, put it on the list */
2243         spin_lock(&cifs_tcp_ses_lock);
2244         list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2245         spin_unlock(&cifs_tcp_ses_lock);
2246
2247         cifs_fscache_get_client_cookie(tcp_ses);
2248
2249         /* queue echo request delayed work */
2250         queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
2251
2252         return tcp_ses;
2253
2254 out_err_crypto_release:
2255         cifs_crypto_shash_release(tcp_ses);
2256
2257         put_net(cifs_net_ns(tcp_ses));
2258
2259 out_err:
2260         if (tcp_ses) {
2261                 if (!IS_ERR(tcp_ses->hostname))
2262                         kfree(tcp_ses->hostname);
2263                 if (tcp_ses->ssocket)
2264                         sock_release(tcp_ses->ssocket);
2265                 kfree(tcp_ses);
2266         }
2267         return ERR_PTR(rc);
2268 }
2269
2270 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2271 {
2272         switch (ses->server->secType) {
2273         case Kerberos:
2274                 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2275                         return 0;
2276                 break;
2277         default:
2278                 /* NULL username means anonymous session */
2279                 if (ses->user_name == NULL) {
2280                         if (!vol->nullauth)
2281                                 return 0;
2282                         break;
2283                 }
2284
2285                 /* anything else takes username/password */
2286                 if (strncmp(ses->user_name,
2287                             vol->username ? vol->username : "",
2288                             MAX_USERNAME_SIZE))
2289                         return 0;
2290                 if (strlen(vol->username) != 0 &&
2291                     ses->password != NULL &&
2292                     strncmp(ses->password,
2293                             vol->password ? vol->password : "",
2294                             MAX_PASSWORD_SIZE))
2295                         return 0;
2296         }
2297         return 1;
2298 }
2299
2300 static struct cifs_ses *
2301 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2302 {
2303         struct cifs_ses *ses;
2304
2305         spin_lock(&cifs_tcp_ses_lock);
2306         list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2307                 if (!match_session(ses, vol))
2308                         continue;
2309                 ++ses->ses_count;
2310                 spin_unlock(&cifs_tcp_ses_lock);
2311                 return ses;
2312         }
2313         spin_unlock(&cifs_tcp_ses_lock);
2314         return NULL;
2315 }
2316
2317 static void
2318 cifs_put_smb_ses(struct cifs_ses *ses)
2319 {
2320         unsigned int xid;
2321         struct TCP_Server_Info *server = ses->server;
2322
2323         cFYI(1, "%s: ses_count=%d", __func__, ses->ses_count);
2324         spin_lock(&cifs_tcp_ses_lock);
2325         if (--ses->ses_count > 0) {
2326                 spin_unlock(&cifs_tcp_ses_lock);
2327                 return;
2328         }
2329
2330         list_del_init(&ses->smb_ses_list);
2331         spin_unlock(&cifs_tcp_ses_lock);
2332
2333         if (ses->status == CifsGood && server->ops->logoff) {
2334                 xid = get_xid();
2335                 server->ops->logoff(xid, ses);
2336                 _free_xid(xid);
2337         }
2338         sesInfoFree(ses);
2339         cifs_put_tcp_session(server);
2340 }
2341
2342 #ifdef CONFIG_KEYS
2343
2344 /* strlen("cifs:a:") + INET6_ADDRSTRLEN + 1 */
2345 #define CIFSCREDS_DESC_SIZE (7 + INET6_ADDRSTRLEN + 1)
2346
2347 /* Populate username and pw fields from keyring if possible */
2348 static int
2349 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2350 {
2351         int rc = 0;
2352         char *desc, *delim, *payload;
2353         ssize_t len;
2354         struct key *key;
2355         struct TCP_Server_Info *server = ses->server;
2356         struct sockaddr_in *sa;
2357         struct sockaddr_in6 *sa6;
2358         struct user_key_payload *upayload;
2359
2360         desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2361         if (!desc)
2362                 return -ENOMEM;
2363
2364         /* try to find an address key first */
2365         switch (server->dstaddr.ss_family) {
2366         case AF_INET:
2367                 sa = (struct sockaddr_in *)&server->dstaddr;
2368                 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2369                 break;
2370         case AF_INET6:
2371                 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2372                 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2373                 break;
2374         default:
2375                 cFYI(1, "Bad ss_family (%hu)", server->dstaddr.ss_family);
2376                 rc = -EINVAL;
2377                 goto out_err;
2378         }
2379
2380         cFYI(1, "%s: desc=%s", __func__, desc);
2381         key = request_key(&key_type_logon, desc, "");
2382         if (IS_ERR(key)) {
2383                 if (!ses->domainName) {
2384                         cFYI(1, "domainName is NULL");
2385                         rc = PTR_ERR(key);
2386                         goto out_err;
2387                 }
2388
2389                 /* didn't work, try to find a domain key */
2390                 sprintf(desc, "cifs:d:%s", ses->domainName);
2391                 cFYI(1, "%s: desc=%s", __func__, desc);
2392                 key = request_key(&key_type_logon, desc, "");
2393                 if (IS_ERR(key)) {
2394                         rc = PTR_ERR(key);
2395                         goto out_err;
2396                 }
2397         }
2398
2399         down_read(&key->sem);
2400         upayload = key->payload.data;
2401         if (IS_ERR_OR_NULL(upayload)) {
2402                 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2403                 goto out_key_put;
2404         }
2405
2406         /* find first : in payload */
2407         payload = (char *)upayload->data;
2408         delim = strnchr(payload, upayload->datalen, ':');
2409         cFYI(1, "payload=%s", payload);
2410         if (!delim) {
2411                 cFYI(1, "Unable to find ':' in payload (datalen=%d)",
2412                                 upayload->datalen);
2413                 rc = -EINVAL;
2414                 goto out_key_put;
2415         }
2416
2417         len = delim - payload;
2418         if (len > MAX_USERNAME_SIZE || len <= 0) {
2419                 cFYI(1, "Bad value from username search (len=%zd)", len);
2420                 rc = -EINVAL;
2421                 goto out_key_put;
2422         }
2423
2424         vol->username = kstrndup(payload, len, GFP_KERNEL);
2425         if (!vol->username) {
2426                 cFYI(1, "Unable to allocate %zd bytes for username", len);
2427                 rc = -ENOMEM;
2428                 goto out_key_put;
2429         }
2430         cFYI(1, "%s: username=%s", __func__, vol->username);
2431
2432         len = key->datalen - (len + 1);
2433         if (len > MAX_PASSWORD_SIZE || len <= 0) {
2434                 cFYI(1, "Bad len for password search (len=%zd)", len);
2435                 rc = -EINVAL;
2436                 kfree(vol->username);
2437                 vol->username = NULL;
2438                 goto out_key_put;
2439         }
2440
2441         ++delim;
2442         vol->password = kstrndup(delim, len, GFP_KERNEL);
2443         if (!vol->password) {
2444                 cFYI(1, "Unable to allocate %zd bytes for password", len);
2445                 rc = -ENOMEM;
2446                 kfree(vol->username);
2447                 vol->username = NULL;
2448                 goto out_key_put;
2449         }
2450
2451 out_key_put:
2452         up_read(&key->sem);
2453         key_put(key);
2454 out_err:
2455         kfree(desc);
2456         cFYI(1, "%s: returning %d", __func__, rc);
2457         return rc;
2458 }
2459 #else /* ! CONFIG_KEYS */
2460 static inline int
2461 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2462                    struct cifs_ses *ses __attribute__((unused)))
2463 {
2464         return -ENOSYS;
2465 }
2466 #endif /* CONFIG_KEYS */
2467
2468 static struct cifs_ses *
2469 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2470 {
2471         int rc = -ENOMEM;
2472         unsigned int xid;
2473         struct cifs_ses *ses;
2474         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2475         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2476
2477         xid = get_xid();
2478
2479         ses = cifs_find_smb_ses(server, volume_info);
2480         if (ses) {
2481                 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
2482
2483                 mutex_lock(&ses->session_mutex);
2484                 rc = cifs_negotiate_protocol(xid, ses);
2485                 if (rc) {
2486                         mutex_unlock(&ses->session_mutex);
2487                         /* problem -- put our ses reference */
2488                         cifs_put_smb_ses(ses);
2489                         free_xid(xid);
2490                         return ERR_PTR(rc);
2491                 }
2492                 if (ses->need_reconnect) {
2493                         cFYI(1, "Session needs reconnect");
2494                         rc = cifs_setup_session(xid, ses,
2495                                                 volume_info->local_nls);
2496                         if (rc) {
2497                                 mutex_unlock(&ses->session_mutex);
2498                                 /* problem -- put our reference */
2499                                 cifs_put_smb_ses(ses);
2500                                 free_xid(xid);
2501                                 return ERR_PTR(rc);
2502                         }
2503                 }
2504                 mutex_unlock(&ses->session_mutex);
2505
2506                 /* existing SMB ses has a server reference already */
2507                 cifs_put_tcp_session(server);
2508                 free_xid(xid);
2509                 return ses;
2510         }
2511
2512         cFYI(1, "Existing smb sess not found");
2513         ses = sesInfoAlloc();
2514         if (ses == NULL)
2515                 goto get_ses_fail;
2516
2517         /* new SMB session uses our server ref */
2518         ses->server = server;
2519         if (server->dstaddr.ss_family == AF_INET6)
2520                 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2521         else
2522                 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2523
2524         if (volume_info->username) {
2525                 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2526                 if (!ses->user_name)
2527                         goto get_ses_fail;
2528         }
2529
2530         /* volume_info->password freed at unmount */
2531         if (volume_info->password) {
2532                 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2533                 if (!ses->password)
2534                         goto get_ses_fail;
2535         }
2536         if (volume_info->domainname) {
2537                 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2538                 if (!ses->domainName)
2539                         goto get_ses_fail;
2540         }
2541         ses->cred_uid = volume_info->cred_uid;
2542         ses->linux_uid = volume_info->linux_uid;
2543
2544         ses->overrideSecFlg = volume_info->secFlg;
2545
2546         mutex_lock(&ses->session_mutex);
2547         rc = cifs_negotiate_protocol(xid, ses);
2548         if (!rc)
2549                 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2550         mutex_unlock(&ses->session_mutex);
2551         if (rc)
2552                 goto get_ses_fail;
2553
2554         /* success, put it on the list */
2555         spin_lock(&cifs_tcp_ses_lock);
2556         list_add(&ses->smb_ses_list, &server->smb_ses_list);
2557         spin_unlock(&cifs_tcp_ses_lock);
2558
2559         free_xid(xid);
2560         return ses;
2561
2562 get_ses_fail:
2563         sesInfoFree(ses);
2564         free_xid(xid);
2565         return ERR_PTR(rc);
2566 }
2567
2568 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2569 {
2570         if (tcon->tidStatus == CifsExiting)
2571                 return 0;
2572         if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2573                 return 0;
2574         return 1;
2575 }
2576
2577 static struct cifs_tcon *
2578 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2579 {
2580         struct list_head *tmp;
2581         struct cifs_tcon *tcon;
2582
2583         spin_lock(&cifs_tcp_ses_lock);
2584         list_for_each(tmp, &ses->tcon_list) {
2585                 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2586                 if (!match_tcon(tcon, unc))
2587                         continue;
2588                 ++tcon->tc_count;
2589                 spin_unlock(&cifs_tcp_ses_lock);
2590                 return tcon;
2591         }
2592         spin_unlock(&cifs_tcp_ses_lock);
2593         return NULL;
2594 }
2595
2596 static void
2597 cifs_put_tcon(struct cifs_tcon *tcon)
2598 {
2599         unsigned int xid;
2600         struct cifs_ses *ses = tcon->ses;
2601
2602         cFYI(1, "%s: tc_count=%d", __func__, tcon->tc_count);
2603         spin_lock(&cifs_tcp_ses_lock);
2604         if (--tcon->tc_count > 0) {
2605                 spin_unlock(&cifs_tcp_ses_lock);
2606                 return;
2607         }
2608
2609         list_del_init(&tcon->tcon_list);
2610         spin_unlock(&cifs_tcp_ses_lock);
2611
2612         xid = get_xid();
2613         if (ses->server->ops->tree_disconnect)
2614                 ses->server->ops->tree_disconnect(xid, tcon);
2615         _free_xid(xid);
2616
2617         cifs_fscache_release_super_cookie(tcon);
2618         tconInfoFree(tcon);
2619         cifs_put_smb_ses(ses);
2620 }
2621
2622 static struct cifs_tcon *
2623 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2624 {
2625         int rc, xid;
2626         struct cifs_tcon *tcon;
2627
2628         tcon = cifs_find_tcon(ses, volume_info->UNC);
2629         if (tcon) {
2630                 cFYI(1, "Found match on UNC path");
2631                 /* existing tcon already has a reference */
2632                 cifs_put_smb_ses(ses);
2633                 if (tcon->seal != volume_info->seal)
2634                         cERROR(1, "transport encryption setting "
2635                                    "conflicts with existing tid");
2636                 return tcon;
2637         }
2638
2639         if (!ses->server->ops->tree_connect) {
2640                 rc = -ENOSYS;
2641                 goto out_fail;
2642         }
2643
2644         tcon = tconInfoAlloc();
2645         if (tcon == NULL) {
2646                 rc = -ENOMEM;
2647                 goto out_fail;
2648         }
2649
2650         tcon->ses = ses;
2651         if (volume_info->password) {
2652                 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2653                 if (!tcon->password) {
2654                         rc = -ENOMEM;
2655                         goto out_fail;
2656                 }
2657         }
2658
2659         /*
2660          * BB Do we need to wrap session_mutex around this TCon call and Unix
2661          * SetFS as we do on SessSetup and reconnect?
2662          */
2663         xid = get_xid();
2664         rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2665                                             volume_info->local_nls);
2666         free_xid(xid);
2667         cFYI(1, "Tcon rc = %d", rc);
2668         if (rc)
2669                 goto out_fail;
2670
2671         if (volume_info->nodfs) {
2672                 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2673                 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2674         }
2675         tcon->seal = volume_info->seal;
2676         /*
2677          * We can have only one retry value for a connection to a share so for
2678          * resources mounted more than once to the same server share the last
2679          * value passed in for the retry flag is used.
2680          */
2681         tcon->retry = volume_info->retry;
2682         tcon->nocase = volume_info->nocase;
2683         tcon->local_lease = volume_info->local_lease;
2684         INIT_LIST_HEAD(&tcon->pending_opens);
2685
2686         spin_lock(&cifs_tcp_ses_lock);
2687         list_add(&tcon->tcon_list, &ses->tcon_list);
2688         spin_unlock(&cifs_tcp_ses_lock);
2689
2690         cifs_fscache_get_super_cookie(tcon);
2691
2692         return tcon;
2693
2694 out_fail:
2695         tconInfoFree(tcon);
2696         return ERR_PTR(rc);
2697 }
2698
2699 void
2700 cifs_put_tlink(struct tcon_link *tlink)
2701 {
2702         if (!tlink || IS_ERR(tlink))
2703                 return;
2704
2705         if (!atomic_dec_and_test(&tlink->tl_count) ||
2706             test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2707                 tlink->tl_time = jiffies;
2708                 return;
2709         }
2710
2711         if (!IS_ERR(tlink_tcon(tlink)))
2712                 cifs_put_tcon(tlink_tcon(tlink));
2713         kfree(tlink);
2714         return;
2715 }
2716
2717 static inline struct tcon_link *
2718 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2719 {
2720         return cifs_sb->master_tlink;
2721 }
2722
2723 static int
2724 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2725 {
2726         struct cifs_sb_info *old = CIFS_SB(sb);
2727         struct cifs_sb_info *new = mnt_data->cifs_sb;
2728
2729         if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2730                 return 0;
2731
2732         if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2733             (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2734                 return 0;
2735
2736         /*
2737          * We want to share sb only if we don't specify an r/wsize or
2738          * specified r/wsize is greater than or equal to existing one.
2739          */
2740         if (new->wsize && new->wsize < old->wsize)
2741                 return 0;
2742
2743         if (new->rsize && new->rsize < old->rsize)
2744                 return 0;
2745
2746         if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
2747                 return 0;
2748
2749         if (old->mnt_file_mode != new->mnt_file_mode ||
2750             old->mnt_dir_mode != new->mnt_dir_mode)
2751                 return 0;
2752
2753         if (strcmp(old->local_nls->charset, new->local_nls->charset))
2754                 return 0;
2755
2756         if (old->actimeo != new->actimeo)
2757                 return 0;
2758
2759         return 1;
2760 }
2761
2762 int
2763 cifs_match_super(struct super_block *sb, void *data)
2764 {
2765         struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2766         struct smb_vol *volume_info;
2767         struct cifs_sb_info *cifs_sb;
2768         struct TCP_Server_Info *tcp_srv;
2769         struct cifs_ses *ses;
2770         struct cifs_tcon *tcon;
2771         struct tcon_link *tlink;
2772         int rc = 0;
2773
2774         spin_lock(&cifs_tcp_ses_lock);
2775         cifs_sb = CIFS_SB(sb);
2776         tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2777         if (IS_ERR(tlink)) {
2778                 spin_unlock(&cifs_tcp_ses_lock);
2779                 return rc;
2780         }
2781         tcon = tlink_tcon(tlink);
2782         ses = tcon->ses;
2783         tcp_srv = ses->server;
2784
2785         volume_info = mnt_data->vol;
2786
2787         if (!match_server(tcp_srv, volume_info) ||
2788             !match_session(ses, volume_info) ||
2789             !match_tcon(tcon, volume_info->UNC)) {
2790                 rc = 0;
2791                 goto out;
2792         }
2793
2794         rc = compare_mount_options(sb, mnt_data);
2795 out:
2796         spin_unlock(&cifs_tcp_ses_lock);
2797         cifs_put_tlink(tlink);
2798         return rc;
2799 }
2800
2801 int
2802 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2803              const struct nls_table *nls_codepage, unsigned int *num_referrals,
2804              struct dfs_info3_param **referrals, int remap)
2805 {
2806         char *temp_unc;
2807         int rc = 0;
2808
2809         if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2810                 return -ENOSYS;
2811
2812         *num_referrals = 0;
2813         *referrals = NULL;
2814
2815         if (ses->ipc_tid == 0) {
2816                 temp_unc = kmalloc(2 /* for slashes */ +
2817                         strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2818                                 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
2819                 if (temp_unc == NULL)
2820                         return -ENOMEM;
2821                 temp_unc[0] = '\\';
2822                 temp_unc[1] = '\\';
2823                 strcpy(temp_unc + 2, ses->serverName);
2824                 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2825                 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2826                                                     nls_codepage);
2827                 cFYI(1, "Tcon rc = %d ipc_tid = %d", rc, ses->ipc_tid);
2828                 kfree(temp_unc);
2829         }
2830         if (rc == 0)
2831                 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2832                                                      referrals, num_referrals,
2833                                                      nls_codepage, remap);
2834         /*
2835          * BB - map targetUNCs to dfs_info3 structures, here or in
2836          * ses->server->ops->get_dfs_refer.
2837          */
2838
2839         return rc;
2840 }
2841
2842 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2843 static struct lock_class_key cifs_key[2];
2844 static struct lock_class_key cifs_slock_key[2];
2845
2846 static inline void
2847 cifs_reclassify_socket4(struct socket *sock)
2848 {
2849         struct sock *sk = sock->sk;
2850         BUG_ON(sock_owned_by_user(sk));
2851         sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2852                 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2853 }
2854
2855 static inline void
2856 cifs_reclassify_socket6(struct socket *sock)
2857 {
2858         struct sock *sk = sock->sk;
2859         BUG_ON(sock_owned_by_user(sk));
2860         sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2861                 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2862 }
2863 #else
2864 static inline void
2865 cifs_reclassify_socket4(struct socket *sock)
2866 {
2867 }
2868
2869 static inline void
2870 cifs_reclassify_socket6(struct socket *sock)
2871 {
2872 }
2873 #endif
2874
2875 /* See RFC1001 section 14 on representation of Netbios names */
2876 static void rfc1002mangle(char *target, char *source, unsigned int length)
2877 {
2878         unsigned int i, j;
2879
2880         for (i = 0, j = 0; i < (length); i++) {
2881                 /* mask a nibble at a time and encode */
2882                 target[j] = 'A' + (0x0F & (source[i] >> 4));
2883                 target[j+1] = 'A' + (0x0F & source[i]);
2884                 j += 2;
2885         }
2886
2887 }
2888
2889 static int
2890 bind_socket(struct TCP_Server_Info *server)
2891 {
2892         int rc = 0;
2893         if (server->srcaddr.ss_family != AF_UNSPEC) {
2894                 /* Bind to the specified local IP address */
2895                 struct socket *socket = server->ssocket;
2896                 rc = socket->ops->bind(socket,
2897                                        (struct sockaddr *) &server->srcaddr,
2898                                        sizeof(server->srcaddr));
2899                 if (rc < 0) {
2900                         struct sockaddr_in *saddr4;
2901                         struct sockaddr_in6 *saddr6;
2902                         saddr4 = (struct sockaddr_in *)&server->srcaddr;
2903                         saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2904                         if (saddr6->sin6_family == AF_INET6)
2905                                 cERROR(1, "cifs: "
2906                                        "Failed to bind to: %pI6c, error: %d",
2907                                        &saddr6->sin6_addr, rc);
2908                         else
2909                                 cERROR(1, "cifs: "
2910                                        "Failed to bind to: %pI4, error: %d",
2911                                        &saddr4->sin_addr.s_addr, rc);
2912                 }
2913         }
2914         return rc;
2915 }
2916
2917 static int
2918 ip_rfc1001_connect(struct TCP_Server_Info *server)
2919 {
2920         int rc = 0;
2921         /*
2922          * some servers require RFC1001 sessinit before sending
2923          * negprot - BB check reconnection in case where second
2924          * sessinit is sent but no second negprot
2925          */
2926         struct rfc1002_session_packet *ses_init_buf;
2927         struct smb_hdr *smb_buf;
2928         ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2929                                GFP_KERNEL);
2930         if (ses_init_buf) {
2931                 ses_init_buf->trailer.session_req.called_len = 32;
2932
2933                 if (server->server_RFC1001_name &&
2934                     server->server_RFC1001_name[0] != 0)
2935                         rfc1002mangle(ses_init_buf->trailer.
2936                                       session_req.called_name,
2937                                       server->server_RFC1001_name,
2938                                       RFC1001_NAME_LEN_WITH_NULL);
2939                 else
2940                         rfc1002mangle(ses_init_buf->trailer.
2941                                       session_req.called_name,
2942                                       DEFAULT_CIFS_CALLED_NAME,
2943                                       RFC1001_NAME_LEN_WITH_NULL);
2944
2945                 ses_init_buf->trailer.session_req.calling_len = 32;
2946
2947                 /*
2948                  * calling name ends in null (byte 16) from old smb
2949                  * convention.
2950                  */
2951                 if (server->workstation_RFC1001_name &&
2952                     server->workstation_RFC1001_name[0] != 0)
2953                         rfc1002mangle(ses_init_buf->trailer.
2954                                       session_req.calling_name,
2955                                       server->workstation_RFC1001_name,
2956                                       RFC1001_NAME_LEN_WITH_NULL);
2957                 else
2958                         rfc1002mangle(ses_init_buf->trailer.
2959                                       session_req.calling_name,
2960                                       "LINUX_CIFS_CLNT",
2961                                       RFC1001_NAME_LEN_WITH_NULL);
2962
2963                 ses_init_buf->trailer.session_req.scope1 = 0;
2964                 ses_init_buf->trailer.session_req.scope2 = 0;
2965                 smb_buf = (struct smb_hdr *)ses_init_buf;
2966
2967                 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2968                 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
2969                 rc = smb_send(server, smb_buf, 0x44);
2970                 kfree(ses_init_buf);
2971                 /*
2972                  * RFC1001 layer in at least one server
2973                  * requires very short break before negprot
2974                  * presumably because not expecting negprot
2975                  * to follow so fast.  This is a simple
2976                  * solution that works without
2977                  * complicating the code and causes no
2978                  * significant slowing down on mount
2979                  * for everyone else
2980                  */
2981                 usleep_range(1000, 2000);
2982         }
2983         /*
2984          * else the negprot may still work without this
2985          * even though malloc failed
2986          */
2987
2988         return rc;
2989 }
2990
2991 static int
2992 generic_ip_connect(struct TCP_Server_Info *server)
2993 {
2994         int rc = 0;
2995         __be16 sport;
2996         int slen, sfamily;
2997         struct socket *socket = server->ssocket;
2998         struct sockaddr *saddr;
2999
3000         saddr = (struct sockaddr *) &server->dstaddr;
3001
3002         if (server->dstaddr.ss_family == AF_INET6) {
3003                 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3004                 slen = sizeof(struct sockaddr_in6);
3005                 sfamily = AF_INET6;
3006         } else {
3007                 sport = ((struct sockaddr_in *) saddr)->sin_port;
3008                 slen = sizeof(struct sockaddr_in);
3009                 sfamily = AF_INET;
3010         }
3011
3012         if (socket == NULL) {
3013                 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3014                                    IPPROTO_TCP, &socket, 1);
3015                 if (rc < 0) {
3016                         cERROR(1, "Error %d creating socket", rc);
3017                         server->ssocket = NULL;
3018                         return rc;
3019                 }
3020
3021                 /* BB other socket options to set KEEPALIVE, NODELAY? */
3022                 cFYI(1, "Socket created");
3023                 server->ssocket = socket;
3024                 socket->sk->sk_allocation = GFP_NOFS;
3025                 if (sfamily == AF_INET6)
3026                         cifs_reclassify_socket6(socket);
3027                 else
3028                         cifs_reclassify_socket4(socket);
3029         }
3030
3031         rc = bind_socket(server);
3032         if (rc < 0)
3033                 return rc;
3034
3035         /*
3036          * Eventually check for other socket options to change from
3037          * the default. sock_setsockopt not used because it expects
3038          * user space buffer
3039          */
3040         socket->sk->sk_rcvtimeo = 7 * HZ;
3041         socket->sk->sk_sndtimeo = 5 * HZ;
3042
3043         /* make the bufsizes depend on wsize/rsize and max requests */
3044         if (server->noautotune) {
3045                 if (socket->sk->sk_sndbuf < (200 * 1024))
3046                         socket->sk->sk_sndbuf = 200 * 1024;
3047                 if (socket->sk->sk_rcvbuf < (140 * 1024))
3048                         socket->sk->sk_rcvbuf = 140 * 1024;
3049         }
3050
3051         if (server->tcp_nodelay) {
3052                 int val = 1;
3053                 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3054                                 (char *)&val, sizeof(val));
3055                 if (rc)
3056                         cFYI(1, "set TCP_NODELAY socket option error %d", rc);
3057         }
3058
3059          cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
3060                  socket->sk->sk_sndbuf,
3061                  socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3062
3063         rc = socket->ops->connect(socket, saddr, slen, 0);
3064         if (rc < 0) {
3065                 cFYI(1, "Error %d connecting to server", rc);
3066                 sock_release(socket);
3067                 server->ssocket = NULL;
3068                 return rc;
3069         }
3070
3071         if (sport == htons(RFC1001_PORT))
3072                 rc = ip_rfc1001_connect(server);
3073
3074         return rc;
3075 }
3076
3077 static int
3078 ip_connect(struct TCP_Server_Info *server)
3079 {
3080         __be16 *sport;
3081         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3082         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3083
3084         if (server->dstaddr.ss_family == AF_INET6)
3085                 sport = &addr6->sin6_port;
3086         else
3087                 sport = &addr->sin_port;
3088
3089         if (*sport == 0) {
3090                 int rc;
3091
3092                 /* try with 445 port at first */
3093                 *sport = htons(CIFS_PORT);
3094
3095                 rc = generic_ip_connect(server);
3096                 if (rc >= 0)
3097                         return rc;
3098
3099                 /* if it failed, try with 139 port */
3100                 *sport = htons(RFC1001_PORT);
3101         }
3102
3103         return generic_ip_connect(server);
3104 }
3105
3106 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3107                           struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3108 {
3109         /* if we are reconnecting then should we check to see if
3110          * any requested capabilities changed locally e.g. via
3111          * remount but we can not do much about it here
3112          * if they have (even if we could detect it by the following)
3113          * Perhaps we could add a backpointer to array of sb from tcon
3114          * or if we change to make all sb to same share the same
3115          * sb as NFS - then we only have one backpointer to sb.
3116          * What if we wanted to mount the server share twice once with
3117          * and once without posixacls or posix paths? */
3118         __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3119
3120         if (vol_info && vol_info->no_linux_ext) {
3121                 tcon->fsUnixInfo.Capability = 0;
3122                 tcon->unix_ext = 0; /* Unix Extensions disabled */
3123                 cFYI(1, "Linux protocol extensions disabled");
3124                 return;
3125         } else if (vol_info)
3126                 tcon->unix_ext = 1; /* Unix Extensions supported */
3127
3128         if (tcon->unix_ext == 0) {
3129                 cFYI(1, "Unix extensions disabled so not set on reconnect");
3130                 return;
3131         }
3132
3133         if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3134                 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3135                 cFYI(1, "unix caps which server supports %lld", cap);
3136                 /* check for reconnect case in which we do not
3137                    want to change the mount behavior if we can avoid it */
3138                 if (vol_info == NULL) {
3139                         /* turn off POSIX ACL and PATHNAMES if not set
3140                            originally at mount time */
3141                         if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3142                                 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3143                         if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3144                                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3145                                         cERROR(1, "POSIXPATH support change");
3146                                 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3147                         } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3148                                 cERROR(1, "possible reconnect error");
3149                                 cERROR(1, "server disabled POSIX path support");
3150                         }
3151                 }
3152
3153                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3154                         cERROR(1, "per-share encryption not supported yet");
3155
3156                 cap &= CIFS_UNIX_CAP_MASK;
3157                 if (vol_info && vol_info->no_psx_acl)
3158                         cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3159                 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3160                         cFYI(1, "negotiated posix acl support");
3161                         if (cifs_sb)
3162                                 cifs_sb->mnt_cifs_flags |=
3163                                         CIFS_MOUNT_POSIXACL;
3164                 }
3165
3166                 if (vol_info && vol_info->posix_paths == 0)
3167                         cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3168                 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3169                         cFYI(1, "negotiate posix pathnames");
3170                         if (cifs_sb)
3171                                 cifs_sb->mnt_cifs_flags |=
3172                                         CIFS_MOUNT_POSIX_PATHS;
3173                 }
3174
3175                 cFYI(1, "Negotiate caps 0x%x", (int)cap);
3176 #ifdef CONFIG_CIFS_DEBUG2
3177                 if (cap & CIFS_UNIX_FCNTL_CAP)
3178                         cFYI(1, "FCNTL cap");
3179                 if (cap & CIFS_UNIX_EXTATTR_CAP)
3180                         cFYI(1, "EXTATTR cap");
3181                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3182                         cFYI(1, "POSIX path cap");
3183                 if (cap & CIFS_UNIX_XATTR_CAP)
3184                         cFYI(1, "XATTR cap");
3185                 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3186                         cFYI(1, "POSIX ACL cap");
3187                 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3188                         cFYI(1, "very large read cap");
3189                 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3190                         cFYI(1, "very large write cap");
3191                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3192                         cFYI(1, "transport encryption cap");
3193                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3194                         cFYI(1, "mandatory transport encryption cap");
3195 #endif /* CIFS_DEBUG2 */
3196                 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3197                         if (vol_info == NULL) {
3198                                 cFYI(1, "resetting capabilities failed");
3199                         } else
3200                                 cERROR(1, "Negotiating Unix capabilities "
3201                                            "with the server failed. Consider "
3202                                            "mounting with the Unix Extensions "
3203                                            "disabled if problems are found "
3204                                            "by specifying the nounix mount "
3205                                            "option.");
3206
3207                 }
3208         }
3209 }
3210
3211 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3212                         struct cifs_sb_info *cifs_sb)
3213 {
3214         INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3215
3216         spin_lock_init(&cifs_sb->tlink_tree_lock);
3217         cifs_sb->tlink_tree = RB_ROOT;
3218
3219         /*
3220          * Temporarily set r/wsize for matching superblock. If we end up using
3221          * new sb then client will later negotiate it downward if needed.
3222          */
3223         cifs_sb->rsize = pvolume_info->rsize;
3224      &nbs