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