]> git.ipfire.org Git - thirdparty/kernel/stable.git/blob - fs/cifs/connect.c
projects / thirdparty / kernel / stable.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'drm/tegra/for-5.1-rc5' of git://anongit.freedesktop.org/tegra/linux into...
[thirdparty/kernel/stable.git] / fs / cifs / connect.c
1 /*
2 * fs/cifs/connect.c
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2011
5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21 #include <linux/fs.h>
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/sched/signal.h>
25 #include <linux/list.h>
26 #include <linux/wait.h>
27 #include <linux/slab.h>
28 #include <linux/pagemap.h>
29 #include <linux/ctype.h>
30 #include <linux/utsname.h>
31 #include <linux/mempool.h>
32 #include <linux/delay.h>
33 #include <linux/completion.h>
34 #include <linux/kthread.h>
35 #include <linux/pagevec.h>
36 #include <linux/freezer.h>
37 #include <linux/namei.h>
38 #include <linux/uuid.h>
39 #include <linux/uaccess.h>
40 #include <asm/processor.h>
41 #include <linux/inet.h>
42 #include <linux/module.h>
43 #include <keys/user-type.h>
44 #include <net/ipv6.h>
45 #include <linux/parser.h>
46 #include <linux/bvec.h>
47 #include "cifspdu.h"
48 #include "cifsglob.h"
49 #include "cifsproto.h"
50 #include "cifs_unicode.h"
51 #include "cifs_debug.h"
52 #include "cifs_fs_sb.h"
53 #include "ntlmssp.h"
54 #include "nterr.h"
55 #include "rfc1002pdu.h"
56 #include "fscache.h"
57 #include "smb2proto.h"
58 #include "smbdirect.h"
59 #include "dns_resolve.h"
60 #include "cifsfs.h"
61 #ifdef CONFIG_CIFS_DFS_UPCALL
62 #include "dfs_cache.h"
63 #endif
64
65 extern mempool_t *cifs_req_poolp;
66 extern bool disable_legacy_dialects;
67
68 /* FIXME: should these be tunable? */
69 #define TLINK_ERROR_EXPIRE (1 * HZ)
70 #define TLINK_IDLE_EXPIRE (600 * HZ)
71
72 enum {
73 /* Mount options that take no arguments */
74 Opt_user_xattr, Opt_nouser_xattr,
75 Opt_forceuid, Opt_noforceuid,
76 Opt_forcegid, Opt_noforcegid,
77 Opt_noblocksend, Opt_noautotune,
78 Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
79 Opt_mapposix, Opt_nomapposix,
80 Opt_mapchars, Opt_nomapchars, Opt_sfu,
81 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
82 Opt_noposixpaths, Opt_nounix, Opt_unix,
83 Opt_nocase,
84 Opt_brl, Opt_nobrl,
85 Opt_handlecache, Opt_nohandlecache,
86 Opt_forcemandatorylock, Opt_setuidfromacl, Opt_setuids,
87 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
88 Opt_nohard, Opt_nosoft,
89 Opt_nointr, Opt_intr,
90 Opt_nostrictsync, Opt_strictsync,
91 Opt_serverino, Opt_noserverino,
92 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
93 Opt_acl, Opt_noacl, Opt_locallease,
94 Opt_sign, Opt_seal, Opt_noac,
95 Opt_fsc, Opt_mfsymlinks,
96 Opt_multiuser, Opt_sloppy, Opt_nosharesock,
97 Opt_persistent, Opt_nopersistent,
98 Opt_resilient, Opt_noresilient,
99 Opt_domainauto, Opt_rdma,
100
101 /* Mount options which take numeric value */
102 Opt_backupuid, Opt_backupgid, Opt_uid,
103 Opt_cruid, Opt_gid, Opt_file_mode,
104 Opt_dirmode, Opt_port,
105 Opt_blocksize, Opt_rsize, Opt_wsize, Opt_actimeo,
106 Opt_echo_interval, Opt_max_credits, Opt_handletimeout,
107 Opt_snapshot,
108
109 /* Mount options which take string value */
110 Opt_user, Opt_pass, Opt_ip,
111 Opt_domain, Opt_srcaddr, Opt_iocharset,
112 Opt_netbiosname, Opt_servern,
113 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
114
115 /* Mount options to be ignored */
116 Opt_ignore,
117
118 /* Options which could be blank */
119 Opt_blank_pass,
120 Opt_blank_user,
121 Opt_blank_ip,
122
123 Opt_err
124 };
125
126 static const match_table_t cifs_mount_option_tokens = {
127
128 { Opt_user_xattr, "user_xattr" },
129 { Opt_nouser_xattr, "nouser_xattr" },
130 { Opt_forceuid, "forceuid" },
131 { Opt_noforceuid, "noforceuid" },
132 { Opt_forcegid, "forcegid" },
133 { Opt_noforcegid, "noforcegid" },
134 { Opt_noblocksend, "noblocksend" },
135 { Opt_noautotune, "noautotune" },
136 { Opt_hard, "hard" },
137 { Opt_soft, "soft" },
138 { Opt_perm, "perm" },
139 { Opt_noperm, "noperm" },
140 { Opt_mapchars, "mapchars" }, /* SFU style */
141 { Opt_nomapchars, "nomapchars" },
142 { Opt_mapposix, "mapposix" }, /* SFM style */
143 { Opt_nomapposix, "nomapposix" },
144 { Opt_sfu, "sfu" },
145 { Opt_nosfu, "nosfu" },
146 { Opt_nodfs, "nodfs" },
147 { Opt_posixpaths, "posixpaths" },
148 { Opt_noposixpaths, "noposixpaths" },
149 { Opt_nounix, "nounix" },
150 { Opt_nounix, "nolinux" },
151 { Opt_nounix, "noposix" },
152 { Opt_unix, "unix" },
153 { Opt_unix, "linux" },
154 { Opt_unix, "posix" },
155 { Opt_nocase, "nocase" },
156 { Opt_nocase, "ignorecase" },
157 { Opt_brl, "brl" },
158 { Opt_nobrl, "nobrl" },
159 { Opt_handlecache, "handlecache" },
160 { Opt_nohandlecache, "nohandlecache" },
161 { Opt_nobrl, "nolock" },
162 { Opt_forcemandatorylock, "forcemandatorylock" },
163 { Opt_forcemandatorylock, "forcemand" },
164 { Opt_setuids, "setuids" },
165 { Opt_nosetuids, "nosetuids" },
166 { Opt_setuidfromacl, "idsfromsid" },
167 { Opt_dynperm, "dynperm" },
168 { Opt_nodynperm, "nodynperm" },
169 { Opt_nohard, "nohard" },
170 { Opt_nosoft, "nosoft" },
171 { Opt_nointr, "nointr" },
172 { Opt_intr, "intr" },
173 { Opt_nostrictsync, "nostrictsync" },
174 { Opt_strictsync, "strictsync" },
175 { Opt_serverino, "serverino" },
176 { Opt_noserverino, "noserverino" },
177 { Opt_rwpidforward, "rwpidforward" },
178 { Opt_cifsacl, "cifsacl" },
179 { Opt_nocifsacl, "nocifsacl" },
180 { Opt_acl, "acl" },
181 { Opt_noacl, "noacl" },
182 { Opt_locallease, "locallease" },
183 { Opt_sign, "sign" },
184 { Opt_seal, "seal" },
185 { Opt_noac, "noac" },
186 { Opt_fsc, "fsc" },
187 { Opt_mfsymlinks, "mfsymlinks" },
188 { Opt_multiuser, "multiuser" },
189 { Opt_sloppy, "sloppy" },
190 { Opt_nosharesock, "nosharesock" },
191 { Opt_persistent, "persistenthandles"},
192 { Opt_nopersistent, "nopersistenthandles"},
193 { Opt_resilient, "resilienthandles"},
194 { Opt_noresilient, "noresilienthandles"},
195 { Opt_domainauto, "domainauto"},
196 { Opt_rdma, "rdma"},
197
198 { Opt_backupuid, "backupuid=%s" },
199 { Opt_backupgid, "backupgid=%s" },
200 { Opt_uid, "uid=%s" },
201 { Opt_cruid, "cruid=%s" },
202 { Opt_gid, "gid=%s" },
203 { Opt_file_mode, "file_mode=%s" },
204 { Opt_dirmode, "dirmode=%s" },
205 { Opt_dirmode, "dir_mode=%s" },
206 { Opt_port, "port=%s" },
207 { Opt_blocksize, "bsize=%s" },
208 { Opt_rsize, "rsize=%s" },
209 { Opt_wsize, "wsize=%s" },
210 { Opt_actimeo, "actimeo=%s" },
211 { Opt_handletimeout, "handletimeout=%s" },
212 { Opt_echo_interval, "echo_interval=%s" },
213 { Opt_max_credits, "max_credits=%s" },
214 { Opt_snapshot, "snapshot=%s" },
215
216 { Opt_blank_user, "user=" },
217 { Opt_blank_user, "username=" },
218 { Opt_user, "user=%s" },
219 { Opt_user, "username=%s" },
220 { Opt_blank_pass, "pass=" },
221 { Opt_blank_pass, "password=" },
222 { Opt_pass, "pass=%s" },
223 { Opt_pass, "password=%s" },
224 { Opt_blank_ip, "ip=" },
225 { Opt_blank_ip, "addr=" },
226 { Opt_ip, "ip=%s" },
227 { Opt_ip, "addr=%s" },
228 { Opt_ignore, "unc=%s" },
229 { Opt_ignore, "target=%s" },
230 { Opt_ignore, "path=%s" },
231 { Opt_domain, "dom=%s" },
232 { Opt_domain, "domain=%s" },
233 { Opt_domain, "workgroup=%s" },
234 { Opt_srcaddr, "srcaddr=%s" },
235 { Opt_ignore, "prefixpath=%s" },
236 { Opt_iocharset, "iocharset=%s" },
237 { Opt_netbiosname, "netbiosname=%s" },
238 { Opt_servern, "servern=%s" },
239 { Opt_ver, "ver=%s" },
240 { Opt_vers, "vers=%s" },
241 { Opt_sec, "sec=%s" },
242 { Opt_cache, "cache=%s" },
243
244 { Opt_ignore, "cred" },
245 { Opt_ignore, "credentials" },
246 { Opt_ignore, "cred=%s" },
247 { Opt_ignore, "credentials=%s" },
248 { Opt_ignore, "guest" },
249 { Opt_ignore, "rw" },
250 { Opt_ignore, "ro" },
251 { Opt_ignore, "suid" },
252 { Opt_ignore, "nosuid" },
253 { Opt_ignore, "exec" },
254 { Opt_ignore, "noexec" },
255 { Opt_ignore, "nodev" },
256 { Opt_ignore, "noauto" },
257 { Opt_ignore, "dev" },
258 { Opt_ignore, "mand" },
259 { Opt_ignore, "nomand" },
260 { Opt_ignore, "relatime" },
261 { Opt_ignore, "_netdev" },
262
263 { Opt_err, NULL }
264 };
265
266 enum {
267 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
268 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
269 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
270 Opt_sec_ntlmv2i, Opt_sec_lanman,
271 Opt_sec_none,
272
273 Opt_sec_err
274 };
275
276 static const match_table_t cifs_secflavor_tokens = {
277 { Opt_sec_krb5, "krb5" },
278 { Opt_sec_krb5i, "krb5i" },
279 { Opt_sec_krb5p, "krb5p" },
280 { Opt_sec_ntlmsspi, "ntlmsspi" },
281 { Opt_sec_ntlmssp, "ntlmssp" },
282 { Opt_ntlm, "ntlm" },
283 { Opt_sec_ntlmi, "ntlmi" },
284 { Opt_sec_ntlmv2, "nontlm" },
285 { Opt_sec_ntlmv2, "ntlmv2" },
286 { Opt_sec_ntlmv2i, "ntlmv2i" },
287 { Opt_sec_lanman, "lanman" },
288 { Opt_sec_none, "none" },
289
290 { Opt_sec_err, NULL }
291 };
292
293 /* cache flavors */
294 enum {
295 Opt_cache_loose,
296 Opt_cache_strict,
297 Opt_cache_none,
298 Opt_cache_err
299 };
300
301 static const match_table_t cifs_cacheflavor_tokens = {
302 { Opt_cache_loose, "loose" },
303 { Opt_cache_strict, "strict" },
304 { Opt_cache_none, "none" },
305 { Opt_cache_err, NULL }
306 };
307
308 static const match_table_t cifs_smb_version_tokens = {
309 { Smb_1, SMB1_VERSION_STRING },
310 { Smb_20, SMB20_VERSION_STRING},
311 { Smb_21, SMB21_VERSION_STRING },
312 { Smb_30, SMB30_VERSION_STRING },
313 { Smb_302, SMB302_VERSION_STRING },
314 { Smb_302, ALT_SMB302_VERSION_STRING },
315 { Smb_311, SMB311_VERSION_STRING },
316 { Smb_311, ALT_SMB311_VERSION_STRING },
317 { Smb_3any, SMB3ANY_VERSION_STRING },
318 { Smb_default, SMBDEFAULT_VERSION_STRING },
319 { Smb_version_err, NULL }
320 };
321
322 static int ip_connect(struct TCP_Server_Info *server);
323 static int generic_ip_connect(struct TCP_Server_Info *server);
324 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
325 static void cifs_prune_tlinks(struct work_struct *work);
326 static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
327 const char *devname, bool is_smb3);
328 static char *extract_hostname(const char *unc);
329
330 /*
331 * Resolve hostname and set ip addr in tcp ses. Useful for hostnames that may
332 * get their ip addresses changed at some point.
333 *
334 * This should be called with server->srv_mutex held.
335 */
336 #ifdef CONFIG_CIFS_DFS_UPCALL
337 static int reconn_set_ipaddr(struct TCP_Server_Info *server)
338 {
339 int rc;
340 int len;
341 char *unc, *ipaddr = NULL;
342
343 if (!server->hostname)
344 return -EINVAL;
345
346 len = strlen(server->hostname) + 3;
347
348 unc = kmalloc(len, GFP_KERNEL);
349 if (!unc) {
350 cifs_dbg(FYI, "%s: failed to create UNC path\n", __func__);
351 return -ENOMEM;
352 }
353 scnprintf(unc, len, "\\\\%s", server->hostname);
354
355 rc = dns_resolve_server_name_to_ip(unc, &ipaddr);
356 kfree(unc);
357
358 if (rc < 0) {
359 cifs_dbg(FYI, "%s: failed to resolve server part of %s to IP: %d\n",
360 __func__, server->hostname, rc);
361 return rc;
362 }
363
364 rc = cifs_convert_address((struct sockaddr *)&server->dstaddr, ipaddr,
365 strlen(ipaddr));
366 kfree(ipaddr);
367
368 return !rc ? -1 : 0;
369 }
370 #else
371 static inline int reconn_set_ipaddr(struct TCP_Server_Info *server)
372 {
373 return 0;
374 }
375 #endif
376
377 #ifdef CONFIG_CIFS_DFS_UPCALL
378 struct super_cb_data {
379 struct TCP_Server_Info *server;
380 struct cifs_sb_info *cifs_sb;
381 };
382
383 /* These functions must be called with server->srv_mutex held */
384
385 static void super_cb(struct super_block *sb, void *arg)
386 {
387 struct super_cb_data *d = arg;
388 struct cifs_sb_info *cifs_sb;
389 struct cifs_tcon *tcon;
390
391 if (d->cifs_sb)
392 return;
393
394 cifs_sb = CIFS_SB(sb);
395 tcon = cifs_sb_master_tcon(cifs_sb);
396 if (tcon->ses->server == d->server)
397 d->cifs_sb = cifs_sb;
398 }
399
400 static inline struct cifs_sb_info *
401 find_super_by_tcp(struct TCP_Server_Info *server)
402 {
403 struct super_cb_data d = {
404 .server = server,
405 .cifs_sb = NULL,
406 };
407
408 iterate_supers_type(&cifs_fs_type, super_cb, &d);
409 return d.cifs_sb ? d.cifs_sb : ERR_PTR(-ENOENT);
410 }
411
412 static void reconn_inval_dfs_target(struct TCP_Server_Info *server,
413 struct cifs_sb_info *cifs_sb,
414 struct dfs_cache_tgt_list *tgt_list,
415 struct dfs_cache_tgt_iterator **tgt_it)
416 {
417 const char *name;
418
419 if (!cifs_sb || !cifs_sb->origin_fullpath || !tgt_list ||
420 !server->nr_targets)
421 return;
422
423 if (!*tgt_it) {
424 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
425 } else {
426 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
427 if (!*tgt_it)
428 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
429 }
430
431 cifs_dbg(FYI, "%s: UNC: %s\n", __func__, cifs_sb->origin_fullpath);
432
433 name = dfs_cache_get_tgt_name(*tgt_it);
434
435 kfree(server->hostname);
436
437 server->hostname = extract_hostname(name);
438 if (IS_ERR(server->hostname)) {
439 cifs_dbg(FYI,
440 "%s: failed to extract hostname from target: %ld\n",
441 __func__, PTR_ERR(server->hostname));
442 }
443 }
444
445 static inline int reconn_setup_dfs_targets(struct cifs_sb_info *cifs_sb,
446 struct dfs_cache_tgt_list *tl,
447 struct dfs_cache_tgt_iterator **it)
448 {
449 if (!cifs_sb->origin_fullpath)
450 return -EOPNOTSUPP;
451 return dfs_cache_noreq_find(cifs_sb->origin_fullpath + 1, NULL, tl);
452 }
453 #endif
454
455 /*
456 * cifs tcp session reconnection
457 *
458 * mark tcp session as reconnecting so temporarily locked
459 * mark all smb sessions as reconnecting for tcp session
460 * reconnect tcp session
461 * wake up waiters on reconnection? - (not needed currently)
462 */
463 int
464 cifs_reconnect(struct TCP_Server_Info *server)
465 {
466 int rc = 0;
467 struct list_head *tmp, *tmp2;
468 struct cifs_ses *ses;
469 struct cifs_tcon *tcon;
470 struct mid_q_entry *mid_entry;
471 struct list_head retry_list;
472 #ifdef CONFIG_CIFS_DFS_UPCALL
473 struct cifs_sb_info *cifs_sb = NULL;
474 struct dfs_cache_tgt_list tgt_list = {0};
475 struct dfs_cache_tgt_iterator *tgt_it = NULL;
476 #endif
477
478 spin_lock(&GlobalMid_Lock);
479 server->nr_targets = 1;
480 #ifdef CONFIG_CIFS_DFS_UPCALL
481 cifs_sb = find_super_by_tcp(server);
482 if (IS_ERR(cifs_sb)) {
483 rc = PTR_ERR(cifs_sb);
484 cifs_dbg(FYI, "%s: will not do DFS failover: rc = %d\n",
485 __func__, rc);
486 cifs_sb = NULL;
487 } else {
488 rc = reconn_setup_dfs_targets(cifs_sb, &tgt_list, &tgt_it);
489 if (rc && (rc != -EOPNOTSUPP)) {
490 cifs_dbg(VFS, "%s: no target servers for DFS failover\n",
491 __func__);
492 } else {
493 server->nr_targets = dfs_cache_get_nr_tgts(&tgt_list);
494 }
495 }
496 cifs_dbg(FYI, "%s: will retry %d target(s)\n", __func__,
497 server->nr_targets);
498 #endif
499 if (server->tcpStatus == CifsExiting) {
500 /* the demux thread will exit normally
501 next time through the loop */
502 spin_unlock(&GlobalMid_Lock);
503 return rc;
504 } else
505 server->tcpStatus = CifsNeedReconnect;
506 spin_unlock(&GlobalMid_Lock);
507 server->maxBuf = 0;
508 server->max_read = 0;
509
510 cifs_dbg(FYI, "Mark tcp session as need reconnect\n");
511 trace_smb3_reconnect(server->CurrentMid, server->hostname);
512
513 /* before reconnecting the tcp session, mark the smb session (uid)
514 and the tid bad so they are not used until reconnected */
515 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
516 __func__);
517 spin_lock(&cifs_tcp_ses_lock);
518 list_for_each(tmp, &server->smb_ses_list) {
519 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
520 ses->need_reconnect = true;
521 list_for_each(tmp2, &ses->tcon_list) {
522 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
523 tcon->need_reconnect = true;
524 }
525 if (ses->tcon_ipc)
526 ses->tcon_ipc->need_reconnect = true;
527 }
528 spin_unlock(&cifs_tcp_ses_lock);
529
530 /* do not want to be sending data on a socket we are freeing */
531 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
532 mutex_lock(&server->srv_mutex);
533 if (server->ssocket) {
534 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
535 server->ssocket->state, server->ssocket->flags);
536 kernel_sock_shutdown(server->ssocket, SHUT_WR);
537 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
538 server->ssocket->state, server->ssocket->flags);
539 sock_release(server->ssocket);
540 server->ssocket = NULL;
541 }
542 server->sequence_number = 0;
543 server->session_estab = false;
544 kfree(server->session_key.response);
545 server->session_key.response = NULL;
546 server->session_key.len = 0;
547 server->lstrp = jiffies;
548
549 /* mark submitted MIDs for retry and issue callback */
550 INIT_LIST_HEAD(&retry_list);
551 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
552 spin_lock(&GlobalMid_Lock);
553 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
554 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
555 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
556 mid_entry->mid_state = MID_RETRY_NEEDED;
557 list_move(&mid_entry->qhead, &retry_list);
558 }
559 spin_unlock(&GlobalMid_Lock);
560 mutex_unlock(&server->srv_mutex);
561
562 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
563 list_for_each_safe(tmp, tmp2, &retry_list) {
564 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
565 list_del_init(&mid_entry->qhead);
566 mid_entry->callback(mid_entry);
567 }
568
569 do {
570 try_to_freeze();
571
572 mutex_lock(&server->srv_mutex);
573 /*
574 * Set up next DFS target server (if any) for reconnect. If DFS
575 * feature is disabled, then we will retry last server we
576 * connected to before.
577 */
578 if (cifs_rdma_enabled(server))
579 rc = smbd_reconnect(server);
580 else
581 rc = generic_ip_connect(server);
582 if (rc) {
583 cifs_dbg(FYI, "reconnect error %d\n", rc);
584 #ifdef CONFIG_CIFS_DFS_UPCALL
585 reconn_inval_dfs_target(server, cifs_sb, &tgt_list,
586 &tgt_it);
587 #endif
588 rc = reconn_set_ipaddr(server);
589 if (rc) {
590 cifs_dbg(FYI, "%s: failed to resolve hostname: %d\n",
591 __func__, rc);
592 }
593 mutex_unlock(&server->srv_mutex);
594 msleep(3000);
595 } else {
596 atomic_inc(&tcpSesReconnectCount);
597 set_credits(server, 1);
598 spin_lock(&GlobalMid_Lock);
599 if (server->tcpStatus != CifsExiting)
600 server->tcpStatus = CifsNeedNegotiate;
601 spin_unlock(&GlobalMid_Lock);
602 mutex_unlock(&server->srv_mutex);
603 }
604 } while (server->tcpStatus == CifsNeedReconnect);
605
606 #ifdef CONFIG_CIFS_DFS_UPCALL
607 if (tgt_it) {
608 rc = dfs_cache_noreq_update_tgthint(cifs_sb->origin_fullpath + 1,
609 tgt_it);
610 if (rc) {
611 cifs_dbg(VFS, "%s: failed to update DFS target hint: rc = %d\n",
612 __func__, rc);
613 }
614 rc = dfs_cache_update_vol(cifs_sb->origin_fullpath, server);
615 if (rc) {
616 cifs_dbg(VFS, "%s: failed to update vol info in DFS cache: rc = %d\n",
617 __func__, rc);
618 }
619 dfs_cache_free_tgts(&tgt_list);
620 }
621 #endif
622 if (server->tcpStatus == CifsNeedNegotiate)
623 mod_delayed_work(cifsiod_wq, &server->echo, 0);
624
625 return rc;
626 }
627
628 static void
629 cifs_echo_request(struct work_struct *work)
630 {
631 int rc;
632 struct TCP_Server_Info *server = container_of(work,
633 struct TCP_Server_Info, echo.work);
634 unsigned long echo_interval;
635
636 /*
637 * If we need to renegotiate, set echo interval to zero to
638 * immediately call echo service where we can renegotiate.
639 */
640 if (server->tcpStatus == CifsNeedNegotiate)
641 echo_interval = 0;
642 else
643 echo_interval = server->echo_interval;
644
645 /*
646 * We cannot send an echo if it is disabled.
647 * Also, no need to ping if we got a response recently.
648 */
649
650 if (server->tcpStatus == CifsNeedReconnect ||
651 server->tcpStatus == CifsExiting ||
652 server->tcpStatus == CifsNew ||
653 (server->ops->can_echo && !server->ops->can_echo(server)) ||
654 time_before(jiffies, server->lstrp + echo_interval - HZ))
655 goto requeue_echo;
656
657 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
658 if (rc)
659 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
660 server->hostname);
661
662 requeue_echo:
663 queue_delayed_work(cifsiod_wq, &server->echo, server->echo_interval);
664 }
665
666 static bool
667 allocate_buffers(struct TCP_Server_Info *server)
668 {
669 if (!server->bigbuf) {
670 server->bigbuf = (char *)cifs_buf_get();
671 if (!server->bigbuf) {
672 cifs_dbg(VFS, "No memory for large SMB response\n");
673 msleep(3000);
674 /* retry will check if exiting */
675 return false;
676 }
677 } else if (server->large_buf) {
678 /* we are reusing a dirty large buf, clear its start */
679 memset(server->bigbuf, 0, HEADER_SIZE(server));
680 }
681
682 if (!server->smallbuf) {
683 server->smallbuf = (char *)cifs_small_buf_get();
684 if (!server->smallbuf) {
685 cifs_dbg(VFS, "No memory for SMB response\n");
686 msleep(1000);
687 /* retry will check if exiting */
688 return false;
689 }
690 /* beginning of smb buffer is cleared in our buf_get */
691 } else {
692 /* if existing small buf clear beginning */
693 memset(server->smallbuf, 0, HEADER_SIZE(server));
694 }
695
696 return true;
697 }
698
699 static bool
700 server_unresponsive(struct TCP_Server_Info *server)
701 {
702 /*
703 * We need to wait 2 echo intervals to make sure we handle such
704 * situations right:
705 * 1s client sends a normal SMB request
706 * 2s client gets a response
707 * 30s echo workqueue job pops, and decides we got a response recently
708 * and don't need to send another
709 * ...
710 * 65s kernel_recvmsg times out, and we see that we haven't gotten
711 * a response in >60s.
712 */
713 if ((server->tcpStatus == CifsGood ||
714 server->tcpStatus == CifsNeedNegotiate) &&
715 time_after(jiffies, server->lstrp + 2 * server->echo_interval)) {
716 cifs_dbg(VFS, "Server %s has not responded in %lu seconds. Reconnecting...\n",
717 server->hostname, (2 * server->echo_interval) / HZ);
718 cifs_reconnect(server);
719 wake_up(&server->response_q);
720 return true;
721 }
722
723 return false;
724 }
725
726 static inline bool
727 zero_credits(struct TCP_Server_Info *server)
728 {
729 int val;
730
731 spin_lock(&server->req_lock);
732 val = server->credits + server->echo_credits + server->oplock_credits;
733 if (server->in_flight == 0 && val == 0) {
734 spin_unlock(&server->req_lock);
735 return true;
736 }
737 spin_unlock(&server->req_lock);
738 return false;
739 }
740
741 static int
742 cifs_readv_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg)
743 {
744 int length = 0;
745 int total_read;
746
747 smb_msg->msg_control = NULL;
748 smb_msg->msg_controllen = 0;
749
750 for (total_read = 0; msg_data_left(smb_msg); total_read += length) {
751 try_to_freeze();
752
753 /* reconnect if no credits and no requests in flight */
754 if (zero_credits(server)) {
755 cifs_reconnect(server);
756 return -ECONNABORTED;
757 }
758
759 if (server_unresponsive(server))
760 return -ECONNABORTED;
761 if (cifs_rdma_enabled(server) && server->smbd_conn)
762 length = smbd_recv(server->smbd_conn, smb_msg);
763 else
764 length = sock_recvmsg(server->ssocket, smb_msg, 0);
765
766 if (server->tcpStatus == CifsExiting)
767 return -ESHUTDOWN;
768
769 if (server->tcpStatus == CifsNeedReconnect) {
770 cifs_reconnect(server);
771 return -ECONNABORTED;
772 }
773
774 if (length == -ERESTARTSYS ||
775 length == -EAGAIN ||
776 length == -EINTR) {
777 /*
778 * Minimum sleep to prevent looping, allowing socket
779 * to clear and app threads to set tcpStatus
780 * CifsNeedReconnect if server hung.
781 */
782 usleep_range(1000, 2000);
783 length = 0;
784 continue;
785 }
786
787 if (length <= 0) {
788 cifs_dbg(FYI, "Received no data or error: %d\n", length);
789 cifs_reconnect(server);
790 return -ECONNABORTED;
791 }
792 }
793 return total_read;
794 }
795
796 int
797 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
798 unsigned int to_read)
799 {
800 struct msghdr smb_msg;
801 struct kvec iov = {.iov_base = buf, .iov_len = to_read};
802 iov_iter_kvec(&smb_msg.msg_iter, READ, &iov, 1, to_read);
803
804 return cifs_readv_from_socket(server, &smb_msg);
805 }
806
807 int
808 cifs_read_page_from_socket(struct TCP_Server_Info *server, struct page *page,
809 unsigned int page_offset, unsigned int to_read)
810 {
811 struct msghdr smb_msg;
812 struct bio_vec bv = {
813 .bv_page = page, .bv_len = to_read, .bv_offset = page_offset};
814 iov_iter_bvec(&smb_msg.msg_iter, READ, &bv, 1, to_read);
815 return cifs_readv_from_socket(server, &smb_msg);
816 }
817
818 static bool
819 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
820 {
821 /*
822 * The first byte big endian of the length field,
823 * is actually not part of the length but the type
824 * with the most common, zero, as regular data.
825 */
826 switch (type) {
827 case RFC1002_SESSION_MESSAGE:
828 /* Regular SMB response */
829 return true;
830 case RFC1002_SESSION_KEEP_ALIVE:
831 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
832 break;
833 case RFC1002_POSITIVE_SESSION_RESPONSE:
834 cifs_dbg(FYI, "RFC 1002 positive session response\n");
835 break;
836 case RFC1002_NEGATIVE_SESSION_RESPONSE:
837 /*
838 * We get this from Windows 98 instead of an error on
839 * SMB negprot response.
840 */
841 cifs_dbg(FYI, "RFC 1002 negative session response\n");
842 /* give server a second to clean up */
843 msleep(1000);
844 /*
845 * Always try 445 first on reconnect since we get NACK
846 * on some if we ever connected to port 139 (the NACK
847 * is since we do not begin with RFC1001 session
848 * initialize frame).
849 */
850 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
851 cifs_reconnect(server);
852 wake_up(&server->response_q);
853 break;
854 default:
855 cifs_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
856 cifs_reconnect(server);
857 }
858
859 return false;
860 }
861
862 void
863 dequeue_mid(struct mid_q_entry *mid, bool malformed)
864 {
865 #ifdef CONFIG_CIFS_STATS2
866 mid->when_received = jiffies;
867 #endif
868 spin_lock(&GlobalMid_Lock);
869 if (!malformed)
870 mid->mid_state = MID_RESPONSE_RECEIVED;
871 else
872 mid->mid_state = MID_RESPONSE_MALFORMED;
873 /*
874 * Trying to handle/dequeue a mid after the send_recv()
875 * function has finished processing it is a bug.
876 */
877 if (mid->mid_flags & MID_DELETED)
878 printk_once(KERN_WARNING
879 "trying to dequeue a deleted mid\n");
880 else
881 list_del_init(&mid->qhead);
882 spin_unlock(&GlobalMid_Lock);
883 }
884
885 static void
886 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
887 char *buf, int malformed)
888 {
889 if (server->ops->check_trans2 &&
890 server->ops->check_trans2(mid, server, buf, malformed))
891 return;
892 mid->resp_buf = buf;
893 mid->large_buf = server->large_buf;
894 /* Was previous buf put in mpx struct for multi-rsp? */
895 if (!mid->multiRsp) {
896 /* smb buffer will be freed by user thread */
897 if (server->large_buf)
898 server->bigbuf = NULL;
899 else
900 server->smallbuf = NULL;
901 }
902 dequeue_mid(mid, malformed);
903 }
904
905 static void clean_demultiplex_info(struct TCP_Server_Info *server)
906 {
907 int length;
908
909 /* take it off the list, if it's not already */
910 spin_lock(&cifs_tcp_ses_lock);
911 list_del_init(&server->tcp_ses_list);
912 spin_unlock(&cifs_tcp_ses_lock);
913
914 spin_lock(&GlobalMid_Lock);
915 server->tcpStatus = CifsExiting;
916 spin_unlock(&GlobalMid_Lock);
917 wake_up_all(&server->response_q);
918
919 /* check if we have blocked requests that need to free */
920 spin_lock(&server->req_lock);
921 if (server->credits <= 0)
922 server->credits = 1;
923 spin_unlock(&server->req_lock);
924 /*
925 * Although there should not be any requests blocked on this queue it
926 * can not hurt to be paranoid and try to wake up requests that may
927 * haven been blocked when more than 50 at time were on the wire to the
928 * same server - they now will see the session is in exit state and get
929 * out of SendReceive.
930 */
931 wake_up_all(&server->request_q);
932 /* give those requests time to exit */
933 msleep(125);
934 if (cifs_rdma_enabled(server) && server->smbd_conn) {
935 smbd_destroy(server->smbd_conn);
936 server->smbd_conn = NULL;
937 }
938 if (server->ssocket) {
939 sock_release(server->ssocket);
940 server->ssocket = NULL;
941 }
942
943 if (!list_empty(&server->pending_mid_q)) {
944 struct list_head dispose_list;
945 struct mid_q_entry *mid_entry;
946 struct list_head *tmp, *tmp2;
947
948 INIT_LIST_HEAD(&dispose_list);
949 spin_lock(&GlobalMid_Lock);
950 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
951 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
952 cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
953 mid_entry->mid_state = MID_SHUTDOWN;
954 list_move(&mid_entry->qhead, &dispose_list);
955 }
956 spin_unlock(&GlobalMid_Lock);
957
958 /* now walk dispose list and issue callbacks */
959 list_for_each_safe(tmp, tmp2, &dispose_list) {
960 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
961 cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
962 list_del_init(&mid_entry->qhead);
963 mid_entry->callback(mid_entry);
964 }
965 /* 1/8th of sec is more than enough time for them to exit */
966 msleep(125);
967 }
968
969 if (!list_empty(&server->pending_mid_q)) {
970 /*
971 * mpx threads have not exited yet give them at least the smb
972 * send timeout time for long ops.
973 *
974 * Due to delays on oplock break requests, we need to wait at
975 * least 45 seconds before giving up on a request getting a
976 * response and going ahead and killing cifsd.
977 */
978 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
979 msleep(46000);
980 /*
981 * If threads still have not exited they are probably never
982 * coming home not much else we can do but free the memory.
983 */
984 }
985
986 kfree(server->hostname);
987 kfree(server);
988
989 length = atomic_dec_return(&tcpSesAllocCount);
990 if (length > 0)
991 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
992 }
993
994 static int
995 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
996 {
997 int length;
998 char *buf = server->smallbuf;
999 unsigned int pdu_length = server->pdu_size;
1000
1001 /* make sure this will fit in a large buffer */
1002 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) -
1003 server->vals->header_preamble_size) {
1004 cifs_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
1005 cifs_reconnect(server);
1006 wake_up(&server->response_q);
1007 return -ECONNABORTED;
1008 }
1009
1010 /* switch to large buffer if too big for a small one */
1011 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
1012 server->large_buf = true;
1013 memcpy(server->bigbuf, buf, server->total_read);
1014 buf = server->bigbuf;
1015 }
1016
1017 /* now read the rest */
1018 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
1019 pdu_length - HEADER_SIZE(server) + 1
1020 + server->vals->header_preamble_size);
1021
1022 if (length < 0)
1023 return length;
1024 server->total_read += length;
1025
1026 dump_smb(buf, server->total_read);
1027
1028 return cifs_handle_standard(server, mid);
1029 }
1030
1031 int
1032 cifs_handle_standard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1033 {
1034 char *buf = server->large_buf ? server->bigbuf : server->smallbuf;
1035 int length;
1036
1037 /*
1038 * We know that we received enough to get to the MID as we
1039 * checked the pdu_length earlier. Now check to see
1040 * if the rest of the header is OK. We borrow the length
1041 * var for the rest of the loop to avoid a new stack var.
1042 *
1043 * 48 bytes is enough to display the header and a little bit
1044 * into the payload for debugging purposes.
1045 */
1046 length = server->ops->check_message(buf, server->total_read, server);
1047 if (length != 0)
1048 cifs_dump_mem("Bad SMB: ", buf,
1049 min_t(unsigned int, server->total_read, 48));
1050
1051 if (server->ops->is_session_expired &&
1052 server->ops->is_session_expired(buf)) {
1053 cifs_reconnect(server);
1054 wake_up(&server->response_q);
1055 return -1;
1056 }
1057
1058 if (server->ops->is_status_pending &&
1059 server->ops->is_status_pending(buf, server))
1060 return -1;
1061
1062 if (!mid)
1063 return length;
1064
1065 handle_mid(mid, server, buf, length);
1066 return 0;
1067 }
1068
1069 static void
1070 smb2_add_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)
1071 {
1072 struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buffer;
1073
1074 /*
1075 * SMB1 does not use credits.
1076 */
1077 if (server->vals->header_preamble_size)
1078 return;
1079
1080 if (shdr->CreditRequest) {
1081 spin_lock(&server->req_lock);
1082 server->credits += le16_to_cpu(shdr->CreditRequest);
1083 spin_unlock(&server->req_lock);
1084 wake_up(&server->request_q);
1085 }
1086 }
1087
1088
1089 static int
1090 cifs_demultiplex_thread(void *p)
1091 {
1092 int i, num_mids, length;
1093 struct TCP_Server_Info *server = p;
1094 unsigned int pdu_length;
1095 unsigned int next_offset;
1096 char *buf = NULL;
1097 struct task_struct *task_to_wake = NULL;
1098 struct mid_q_entry *mids[MAX_COMPOUND];
1099 char *bufs[MAX_COMPOUND];
1100
1101 current->flags |= PF_MEMALLOC;
1102 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
1103
1104 length = atomic_inc_return(&tcpSesAllocCount);
1105 if (length > 1)
1106 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
1107
1108 set_freezable();
1109 while (server->tcpStatus != CifsExiting) {
1110 if (try_to_freeze())
1111 continue;
1112
1113 if (!allocate_buffers(server))
1114 continue;
1115
1116 server->large_buf = false;
1117 buf = server->smallbuf;
1118 pdu_length = 4; /* enough to get RFC1001 header */
1119
1120 length = cifs_read_from_socket(server, buf, pdu_length);
1121 if (length < 0)
1122 continue;
1123
1124 if (server->vals->header_preamble_size == 0)
1125 server->total_read = 0;
1126 else
1127 server->total_read = length;
1128
1129 /*
1130 * The right amount was read from socket - 4 bytes,
1131 * so we can now interpret the length field.
1132 */
1133 pdu_length = get_rfc1002_length(buf);
1134
1135 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
1136 if (!is_smb_response(server, buf[0]))
1137 continue;
1138 next_pdu:
1139 server->pdu_size = pdu_length;
1140
1141 /* make sure we have enough to get to the MID */
1142 if (server->pdu_size < HEADER_SIZE(server) - 1 -
1143 server->vals->header_preamble_size) {
1144 cifs_dbg(VFS, "SMB response too short (%u bytes)\n",
1145 server->pdu_size);
1146 cifs_reconnect(server);
1147 wake_up(&server->response_q);
1148 continue;
1149 }
1150
1151 /* read down to the MID */
1152 length = cifs_read_from_socket(server,
1153 buf + server->vals->header_preamble_size,
1154 HEADER_SIZE(server) - 1
1155 - server->vals->header_preamble_size);
1156 if (length < 0)
1157 continue;
1158 server->total_read += length;
1159
1160 if (server->ops->next_header) {
1161 next_offset = server->ops->next_header(buf);
1162 if (next_offset)
1163 server->pdu_size = next_offset;
1164 }
1165
1166 memset(mids, 0, sizeof(mids));
1167 memset(bufs, 0, sizeof(bufs));
1168 num_mids = 0;
1169
1170 if (server->ops->is_transform_hdr &&
1171 server->ops->receive_transform &&
1172 server->ops->is_transform_hdr(buf)) {
1173 length = server->ops->receive_transform(server,
1174 mids,
1175 bufs,
1176 &num_mids);
1177 } else {
1178 mids[0] = server->ops->find_mid(server, buf);
1179 bufs[0] = buf;
1180 num_mids = 1;
1181
1182 if (!mids[0] || !mids[0]->receive)
1183 length = standard_receive3(server, mids[0]);
1184 else
1185 length = mids[0]->receive(server, mids[0]);
1186 }
1187
1188 if (length < 0) {
1189 for (i = 0; i < num_mids; i++)
1190 if (mids[i])
1191 cifs_mid_q_entry_release(mids[i]);
1192 continue;
1193 }
1194
1195 server->lstrp = jiffies;
1196
1197 for (i = 0; i < num_mids; i++) {
1198 if (mids[i] != NULL) {
1199 mids[i]->resp_buf_size = server->pdu_size;
1200 if ((mids[i]->mid_flags & MID_WAIT_CANCELLED) &&
1201 mids[i]->mid_state == MID_RESPONSE_RECEIVED &&
1202 server->ops->handle_cancelled_mid)
1203 server->ops->handle_cancelled_mid(
1204 mids[i]->resp_buf,
1205 server);
1206
1207 if (!mids[i]->multiRsp || mids[i]->multiEnd)
1208 mids[i]->callback(mids[i]);
1209
1210 cifs_mid_q_entry_release(mids[i]);
1211 } else if (server->ops->is_oplock_break &&
1212 server->ops->is_oplock_break(bufs[i],
1213 server)) {
1214 smb2_add_credits_from_hdr(bufs[i], server);
1215 cifs_dbg(FYI, "Received oplock break\n");
1216 } else {
1217 cifs_dbg(VFS, "No task to wake, unknown frame "
1218 "received! NumMids %d\n",
1219 atomic_read(&midCount));
1220 cifs_dump_mem("Received Data is: ", bufs[i],
1221 HEADER_SIZE(server));
1222 #ifdef CONFIG_CIFS_DEBUG2
1223 if (server->ops->dump_detail)
1224 server->ops->dump_detail(bufs[i],
1225 server);
1226 smb2_add_credits_from_hdr(bufs[i], server);
1227 cifs_dump_mids(server);
1228 #endif /* CIFS_DEBUG2 */
1229 }
1230 }
1231
1232 if (pdu_length > server->pdu_size) {
1233 if (!allocate_buffers(server))
1234 continue;
1235 pdu_length -= server->pdu_size;
1236 server->total_read = 0;
1237 server->large_buf = false;
1238 buf = server->smallbuf;
1239 goto next_pdu;
1240 }
1241 } /* end while !EXITING */
1242
1243 /* buffer usually freed in free_mid - need to free it here on exit */
1244 cifs_buf_release(server->bigbuf);
1245 if (server->smallbuf) /* no sense logging a debug message if NULL */
1246 cifs_small_buf_release(server->smallbuf);
1247
1248 task_to_wake = xchg(&server->tsk, NULL);
1249 clean_demultiplex_info(server);
1250
1251 /* if server->tsk was NULL then wait for a signal before exiting */
1252 if (!task_to_wake) {
1253 set_current_state(TASK_INTERRUPTIBLE);
1254 while (!signal_pending(current)) {
1255 schedule();
1256 set_current_state(TASK_INTERRUPTIBLE);
1257 }
1258 set_current_state(TASK_RUNNING);
1259 }
1260
1261 module_put_and_exit(0);
1262 }
1263
1264 /* extract the host portion of the UNC string */
1265 static char *
1266 extract_hostname(const char *unc)
1267 {
1268 const char *src;
1269 char *dst, *delim;
1270 unsigned int len;
1271
1272 /* skip double chars at beginning of string */
1273 /* BB: check validity of these bytes? */
1274 if (strlen(unc) < 3)
1275 return ERR_PTR(-EINVAL);
1276 for (src = unc; *src && *src == '\\'; src++)
1277 ;
1278 if (!*src)
1279 return ERR_PTR(-EINVAL);
1280
1281 /* delimiter between hostname and sharename is always '\\' now */
1282 delim = strchr(src, '\\');
1283 if (!delim)
1284 return ERR_PTR(-EINVAL);
1285
1286 len = delim - src;
1287 dst = kmalloc((len + 1), GFP_KERNEL);
1288 if (dst == NULL)
1289 return ERR_PTR(-ENOMEM);
1290
1291 memcpy(dst, src, len);
1292 dst[len] = '\0';
1293
1294 return dst;
1295 }
1296
1297 static int get_option_ul(substring_t args[], unsigned long *option)
1298 {
1299 int rc;
1300 char *string;
1301
1302 string = match_strdup(args);
1303 if (string == NULL)
1304 return -ENOMEM;
1305 rc = kstrtoul(string, 0, option);
1306 kfree(string);
1307
1308 return rc;
1309 }
1310
1311 static int get_option_uid(substring_t args[], kuid_t *result)
1312 {
1313 unsigned long value;
1314 kuid_t uid;
1315 int rc;
1316
1317 rc = get_option_ul(args, &value);
1318 if (rc)
1319 return rc;
1320
1321 uid = make_kuid(current_user_ns(), value);
1322 if (!uid_valid(uid))
1323 return -EINVAL;
1324
1325 *result = uid;
1326 return 0;
1327 }
1328
1329 static int get_option_gid(substring_t args[], kgid_t *result)
1330 {
1331 unsigned long value;
1332 kgid_t gid;
1333 int rc;
1334
1335 rc = get_option_ul(args, &value);
1336 if (rc)
1337 return rc;
1338
1339 gid = make_kgid(current_user_ns(), value);
1340 if (!gid_valid(gid))
1341 return -EINVAL;
1342
1343 *result = gid;
1344 return 0;
1345 }
1346
1347 static int cifs_parse_security_flavors(char *value,
1348 struct smb_vol *vol)
1349 {
1350
1351 substring_t args[MAX_OPT_ARGS];
1352
1353 /*
1354 * With mount options, the last one should win. Reset any existing
1355 * settings back to default.
1356 */
1357 vol->sectype = Unspecified;
1358 vol->sign = false;
1359
1360 switch (match_token(value, cifs_secflavor_tokens, args)) {
1361 case Opt_sec_krb5p:
1362 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
1363 return 1;
1364 case Opt_sec_krb5i:
1365 vol->sign = true;
1366 /* Fallthrough */
1367 case Opt_sec_krb5:
1368 vol->sectype = Kerberos;
1369 break;
1370 case Opt_sec_ntlmsspi:
1371 vol->sign = true;
1372 /* Fallthrough */
1373 case Opt_sec_ntlmssp:
1374 vol->sectype = RawNTLMSSP;
1375 break;
1376 case Opt_sec_ntlmi:
1377 vol->sign = true;
1378 /* Fallthrough */
1379 case Opt_ntlm:
1380 vol->sectype = NTLM;
1381 break;
1382 case Opt_sec_ntlmv2i:
1383 vol->sign = true;
1384 /* Fallthrough */
1385 case Opt_sec_ntlmv2:
1386 vol->sectype = NTLMv2;
1387 break;
1388 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1389 case Opt_sec_lanman:
1390 vol->sectype = LANMAN;
1391 break;
1392 #endif
1393 case Opt_sec_none:
1394 vol->nullauth = 1;
1395 break;
1396 default:
1397 cifs_dbg(VFS, "bad security option: %s\n", value);
1398 return 1;
1399 }
1400
1401 return 0;
1402 }
1403
1404 static int
1405 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1406 {
1407 substring_t args[MAX_OPT_ARGS];
1408
1409 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1410 case Opt_cache_loose:
1411 vol->direct_io = false;
1412 vol->strict_io = false;
1413 break;
1414 case Opt_cache_strict:
1415 vol->direct_io = false;
1416 vol->strict_io = true;
1417 break;
1418 case Opt_cache_none:
1419 vol->direct_io = true;
1420 vol->strict_io = false;
1421 break;
1422 default:
1423 cifs_dbg(VFS, "bad cache= option: %s\n", value);
1424 return 1;
1425 }
1426 return 0;
1427 }
1428
1429 static int
1430 cifs_parse_smb_version(char *value, struct smb_vol *vol, bool is_smb3)
1431 {
1432 substring_t args[MAX_OPT_ARGS];
1433
1434 switch (match_token(value, cifs_smb_version_tokens, args)) {
1435 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1436 case Smb_1:
1437 if (disable_legacy_dialects) {
1438 cifs_dbg(VFS, "mount with legacy dialect disabled\n");
1439 return 1;
1440 }
1441 if (is_smb3) {
1442 cifs_dbg(VFS, "vers=1.0 (cifs) not permitted when mounting with smb3\n");
1443 return 1;
1444 }
1445 vol->ops = &smb1_operations;
1446 vol->vals = &smb1_values;
1447 break;
1448 case Smb_20:
1449 if (disable_legacy_dialects) {
1450 cifs_dbg(VFS, "mount with legacy dialect disabled\n");
1451 return 1;
1452 }
1453 if (is_smb3) {
1454 cifs_dbg(VFS, "vers=2.0 not permitted when mounting with smb3\n");
1455 return 1;
1456 }
1457 vol->ops = &smb20_operations;
1458 vol->vals = &smb20_values;
1459 break;
1460 #else
1461 case Smb_1:
1462 cifs_dbg(VFS, "vers=1.0 (cifs) mount not permitted when legacy dialects disabled\n");
1463 return 1;
1464 case Smb_20:
1465 cifs_dbg(VFS, "vers=2.0 mount not permitted when legacy dialects disabled\n");
1466 return 1;
1467 #endif /* CIFS_ALLOW_INSECURE_LEGACY */
1468 case Smb_21:
1469 vol->ops = &smb21_operations;
1470 vol->vals = &smb21_values;
1471 break;
1472 case Smb_30:
1473 vol->ops = &smb30_operations;
1474 vol->vals = &smb30_values;
1475 break;
1476 case Smb_302:
1477 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1478 vol->vals = &smb302_values;
1479 break;
1480 case Smb_311:
1481 vol->ops = &smb311_operations;
1482 vol->vals = &smb311_values;
1483 break;
1484 case Smb_3any:
1485 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1486 vol->vals = &smb3any_values;
1487 break;
1488 case Smb_default:
1489 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1490 vol->vals = &smbdefault_values;
1491 break;
1492 default:
1493 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
1494 return 1;
1495 }
1496 return 0;
1497 }
1498
1499 /*
1500 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1501 * fields with the result. Returns 0 on success and an error otherwise.
1502 */
1503 static int
1504 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1505 {
1506 char *pos;
1507 const char *delims = "/\\";
1508 size_t len;
1509
1510 if (unlikely(!devname || !*devname)) {
1511 cifs_dbg(VFS, "Device name not specified.\n");
1512 return -EINVAL;
1513 }
1514
1515 /* make sure we have a valid UNC double delimiter prefix */
1516 len = strspn(devname, delims);
1517 if (len != 2)
1518 return -EINVAL;
1519
1520 /* find delimiter between host and sharename */
1521 pos = strpbrk(devname + 2, delims);
1522 if (!pos)
1523 return -EINVAL;
1524
1525 /* skip past delimiter */
1526 ++pos;
1527
1528 /* now go until next delimiter or end of string */
1529 len = strcspn(pos, delims);
1530
1531 /* move "pos" up to delimiter or NULL */
1532 pos += len;
1533 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1534 if (!vol->UNC)
1535 return -ENOMEM;
1536
1537 convert_delimiter(vol->UNC, '\\');
1538
1539 /* skip any delimiter */
1540 if (*pos == '/' || *pos == '\\')
1541 pos++;
1542
1543 /* If pos is NULL then no prepath */
1544 if (!*pos)
1545 return 0;
1546
1547 vol->prepath = kstrdup(pos, GFP_KERNEL);
1548 if (!vol->prepath)
1549 return -ENOMEM;
1550
1551 return 0;
1552 }
1553
1554 static int
1555 cifs_parse_mount_options(const char *mountdata, const char *devname,
1556 struct smb_vol *vol, bool is_smb3)
1557 {
1558 char *data, *end;
1559 char *mountdata_copy = NULL, *options;
1560 unsigned int temp_len, i, j;
1561 char separator[2];
1562 short int override_uid = -1;
1563 short int override_gid = -1;
1564 bool uid_specified = false;
1565 bool gid_specified = false;
1566 bool sloppy = false;
1567 char *invalid = NULL;
1568 char *nodename = utsname()->nodename;
1569 char *string = NULL;
1570 char *tmp_end, *value;
1571 char delim;
1572 bool got_ip = false;
1573 bool got_version = false;
1574 unsigned short port = 0;
1575 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1576
1577 separator[0] = ',';
1578 separator[1] = 0;
1579 delim = separator[0];
1580
1581 /* ensure we always start with zeroed-out smb_vol */
1582 memset(vol, 0, sizeof(*vol));
1583
1584 /*
1585 * does not have to be perfect mapping since field is
1586 * informational, only used for servers that do not support
1587 * port 445 and it can be overridden at mount time
1588 */
1589 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1590 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1591 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1592
1593 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1594 /* null target name indicates to use *SMBSERVR default called name
1595 if we end up sending RFC1001 session initialize */
1596 vol->target_rfc1001_name[0] = 0;
1597 vol->cred_uid = current_uid();
1598 vol->linux_uid = current_uid();
1599 vol->linux_gid = current_gid();
1600 vol->bsize = 1024 * 1024; /* can improve cp performance significantly */
1601 /*
1602 * default to SFM style remapping of seven reserved characters
1603 * unless user overrides it or we negotiate CIFS POSIX where
1604 * it is unnecessary. Can not simultaneously use more than one mapping
1605 * since then readdir could list files that open could not open
1606 */
1607 vol->remap = true;
1608
1609 /* default to only allowing write access to owner of the mount */
1610 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1611
1612 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1613 /* default is always to request posix paths. */
1614 vol->posix_paths = 1;
1615 /* default to using server inode numbers where available */
1616 vol->server_ino = 1;
1617
1618 /* default is to use strict cifs caching semantics */
1619 vol->strict_io = true;
1620
1621 vol->actimeo = CIFS_DEF_ACTIMEO;
1622
1623 /* Most clients set timeout to 0, allows server to use its default */
1624 vol->handle_timeout = 0; /* See MS-SMB2 spec section 2.2.14.2.12 */
1625
1626 /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1627 vol->ops = &smb30_operations;
1628 vol->vals = &smbdefault_values;
1629
1630 vol->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1631
1632 if (!mountdata)
1633 goto cifs_parse_mount_err;
1634
1635 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1636 if (!mountdata_copy)
1637 goto cifs_parse_mount_err;
1638
1639 options = mountdata_copy;
1640 end = options + strlen(options);
1641
1642 if (strncmp(options, "sep=", 4) == 0) {
1643 if (options[4] != 0) {
1644 separator[0] = options[4];
1645 options += 5;
1646 } else {
1647 cifs_dbg(FYI, "Null separator not allowed\n");
1648 }
1649 }
1650 vol->backupuid_specified = false; /* no backup intent for a user */
1651 vol->backupgid_specified = false; /* no backup intent for a group */
1652
1653 switch (cifs_parse_devname(devname, vol)) {
1654 case 0:
1655 break;
1656 case -ENOMEM:
1657 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1658 goto cifs_parse_mount_err;
1659 case -EINVAL:
1660 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1661 goto cifs_parse_mount_err;
1662 default:
1663 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1664 goto cifs_parse_mount_err;
1665 }
1666
1667 while ((data = strsep(&options, separator)) != NULL) {
1668 substring_t args[MAX_OPT_ARGS];
1669 unsigned long option;
1670 int token;
1671
1672 if (!*data)
1673 continue;
1674
1675 token = match_token(data, cifs_mount_option_tokens, args);
1676
1677 switch (token) {
1678
1679 /* Ingnore the following */
1680 case Opt_ignore:
1681 break;
1682
1683 /* Boolean values */
1684 case Opt_user_xattr:
1685 vol->no_xattr = 0;
1686 break;
1687 case Opt_nouser_xattr:
1688 vol->no_xattr = 1;
1689 break;
1690 case Opt_forceuid:
1691 override_uid = 1;
1692 break;
1693 case Opt_noforceuid:
1694 override_uid = 0;
1695 break;
1696 case Opt_forcegid:
1697 override_gid = 1;
1698 break;
1699 case Opt_noforcegid:
1700 override_gid = 0;
1701 break;
1702 case Opt_noblocksend:
1703 vol->noblocksnd = 1;
1704 break;
1705 case Opt_noautotune:
1706 vol->noautotune = 1;
1707 break;
1708 case Opt_hard:
1709 vol->retry = 1;
1710 break;
1711 case Opt_soft:
1712 vol->retry = 0;
1713 break;
1714 case Opt_perm:
1715 vol->noperm = 0;
1716 break;
1717 case Opt_noperm:
1718 vol->noperm = 1;
1719 break;
1720 case Opt_mapchars:
1721 vol->sfu_remap = true;
1722 vol->remap = false; /* disable SFM mapping */
1723 break;
1724 case Opt_nomapchars:
1725 vol->sfu_remap = false;
1726 break;
1727 case Opt_mapposix:
1728 vol->remap = true;
1729 vol->sfu_remap = false; /* disable SFU mapping */
1730 break;
1731 case Opt_nomapposix:
1732 vol->remap = false;
1733 break;
1734 case Opt_sfu:
1735 vol->sfu_emul = 1;
1736 break;
1737 case Opt_nosfu:
1738 vol->sfu_emul = 0;
1739 break;
1740 case Opt_nodfs:
1741 vol->nodfs = 1;
1742 break;
1743 case Opt_posixpaths:
1744 vol->posix_paths = 1;
1745 break;
1746 case Opt_noposixpaths:
1747 vol->posix_paths = 0;
1748 break;
1749 case Opt_nounix:
1750 if (vol->linux_ext)
1751 cifs_dbg(VFS,
1752 "conflicting unix mount options\n");
1753 vol->no_linux_ext = 1;
1754 break;
1755 case Opt_unix:
1756 if (vol->no_linux_ext)
1757 cifs_dbg(VFS,
1758 "conflicting unix mount options\n");
1759 vol->linux_ext = 1;
1760 break;
1761 case Opt_nocase:
1762 vol->nocase = 1;
1763 break;
1764 case Opt_brl:
1765 vol->nobrl = 0;
1766 break;
1767 case Opt_nobrl:
1768 vol->nobrl = 1;
1769 /*
1770 * turn off mandatory locking in mode
1771 * if remote locking is turned off since the
1772 * local vfs will do advisory
1773 */
1774 if (vol->file_mode ==
1775 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1776 vol->file_mode = S_IALLUGO;
1777 break;
1778 case Opt_nohandlecache:
1779 vol->nohandlecache = 1;
1780 break;
1781 case Opt_handlecache:
1782 vol->nohandlecache = 0;
1783 break;
1784 case Opt_forcemandatorylock:
1785 vol->mand_lock = 1;
1786 break;
1787 case Opt_setuids:
1788 vol->setuids = 1;
1789 break;
1790 case Opt_nosetuids:
1791 vol->setuids = 0;
1792 break;
1793 case Opt_setuidfromacl:
1794 vol->setuidfromacl = 1;
1795 break;
1796 case Opt_dynperm:
1797 vol->dynperm = true;
1798 break;
1799 case Opt_nodynperm:
1800 vol->dynperm = false;
1801 break;
1802 case Opt_nohard:
1803 vol->retry = 0;
1804 break;
1805 case Opt_nosoft:
1806 vol->retry = 1;
1807 break;
1808 case Opt_nointr:
1809 vol->intr = 0;
1810 break;
1811 case Opt_intr:
1812 vol->intr = 1;
1813 break;
1814 case Opt_nostrictsync:
1815 vol->nostrictsync = 1;
1816 break;
1817 case Opt_strictsync:
1818 vol->nostrictsync = 0;
1819 break;
1820 case Opt_serverino:
1821 vol->server_ino = 1;
1822 break;
1823 case Opt_noserverino:
1824 vol->server_ino = 0;
1825 break;
1826 case Opt_rwpidforward:
1827 vol->rwpidforward = 1;
1828 break;
1829 case Opt_cifsacl:
1830 vol->cifs_acl = 1;
1831 break;
1832 case Opt_nocifsacl:
1833 vol->cifs_acl = 0;
1834 break;
1835 case Opt_acl:
1836 vol->no_psx_acl = 0;
1837 break;
1838 case Opt_noacl:
1839 vol->no_psx_acl = 1;
1840 break;
1841 case Opt_locallease:
1842 vol->local_lease = 1;
1843 break;
1844 case Opt_sign:
1845 vol->sign = true;
1846 break;
1847 case Opt_seal:
1848 /* we do not do the following in secFlags because seal
1849 * is a per tree connection (mount) not a per socket
1850 * or per-smb connection option in the protocol
1851 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1852 */
1853 vol->seal = 1;
1854 break;
1855 case Opt_noac:
1856 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1857 break;
1858 case Opt_fsc:
1859 #ifndef CONFIG_CIFS_FSCACHE
1860 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1861 goto cifs_parse_mount_err;
1862 #endif
1863 vol->fsc = true;
1864 break;
1865 case Opt_mfsymlinks:
1866 vol->mfsymlinks = true;
1867 break;
1868 case Opt_multiuser:
1869 vol->multiuser = true;
1870 break;
1871 case Opt_sloppy:
1872 sloppy = true;
1873 break;
1874 case Opt_nosharesock:
1875 vol->nosharesock = true;
1876 break;
1877 case Opt_nopersistent:
1878 vol->nopersistent = true;
1879 if (vol->persistent) {
1880 cifs_dbg(VFS,
1881 "persistenthandles mount options conflict\n");
1882 goto cifs_parse_mount_err;
1883 }
1884 break;
1885 case Opt_persistent:
1886 vol->persistent = true;
1887 if ((vol->nopersistent) || (vol->resilient)) {
1888 cifs_dbg(VFS,
1889 "persistenthandles mount options conflict\n");
1890 goto cifs_parse_mount_err;
1891 }
1892 break;
1893 case Opt_resilient:
1894 vol->resilient = true;
1895 if (vol->persistent) {
1896 cifs_dbg(VFS,
1897 "persistenthandles mount options conflict\n");
1898 goto cifs_parse_mount_err;
1899 }
1900 break;
1901 case Opt_noresilient:
1902 vol->resilient = false; /* already the default */
1903 break;
1904 case Opt_domainauto:
1905 vol->domainauto = true;
1906 break;
1907 case Opt_rdma:
1908 vol->rdma = true;
1909 break;
1910
1911 /* Numeric Values */
1912 case Opt_backupuid:
1913 if (get_option_uid(args, &vol->backupuid)) {
1914 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1915 __func__);
1916 goto cifs_parse_mount_err;
1917 }
1918 vol->backupuid_specified = true;
1919 break;
1920 case Opt_backupgid:
1921 if (get_option_gid(args, &vol->backupgid)) {
1922 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1923 __func__);
1924 goto cifs_parse_mount_err;
1925 }
1926 vol->backupgid_specified = true;
1927 break;
1928 case Opt_uid:
1929 if (get_option_uid(args, &vol->linux_uid)) {
1930 cifs_dbg(VFS, "%s: Invalid uid value\n",
1931 __func__);
1932 goto cifs_parse_mount_err;
1933 }
1934 uid_specified = true;
1935 break;
1936 case Opt_cruid:
1937 if (get_option_uid(args, &vol->cred_uid)) {
1938 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1939 __func__);
1940 goto cifs_parse_mount_err;
1941 }
1942 break;
1943 case Opt_gid:
1944 if (get_option_gid(args, &vol->linux_gid)) {
1945 cifs_dbg(VFS, "%s: Invalid gid value\n",
1946 __func__);
1947 goto cifs_parse_mount_err;
1948 }
1949 gid_specified = true;
1950 break;
1951 case Opt_file_mode:
1952 if (get_option_ul(args, &option)) {
1953 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1954 __func__);
1955 goto cifs_parse_mount_err;
1956 }
1957 vol->file_mode = option;
1958 break;
1959 case Opt_dirmode:
1960 if (get_option_ul(args, &option)) {
1961 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1962 __func__);
1963 goto cifs_parse_mount_err;
1964 }
1965 vol->dir_mode = option;
1966 break;
1967 case Opt_port:
1968 if (get_option_ul(args, &option) ||
1969 option > USHRT_MAX) {
1970 cifs_dbg(VFS, "%s: Invalid port value\n",
1971 __func__);
1972 goto cifs_parse_mount_err;
1973 }
1974 port = (unsigned short)option;
1975 break;
1976 case Opt_blocksize:
1977 if (get_option_ul(args, &option)) {
1978 cifs_dbg(VFS, "%s: Invalid blocksize value\n",
1979 __func__);
1980 goto cifs_parse_mount_err;
1981 }
1982 /*
1983 * inode blocksize realistically should never need to be
1984 * less than 16K or greater than 16M and default is 1MB.
1985 * Note that small inode block sizes (e.g. 64K) can lead
1986 * to very poor performance of common tools like cp and scp
1987 */
1988 if ((option < CIFS_MAX_MSGSIZE) ||
1989 (option > (4 * SMB3_DEFAULT_IOSIZE))) {
1990 cifs_dbg(VFS, "%s: Invalid blocksize\n",
1991 __func__);
1992 goto cifs_parse_mount_err;
1993 }
1994 vol->bsize = option;
1995 break;
1996 case Opt_rsize:
1997 if (get_option_ul(args, &option)) {
1998 cifs_dbg(VFS, "%s: Invalid rsize value\n",
1999 __func__);
2000 goto cifs_parse_mount_err;
2001 }
2002 vol->rsize = option;
2003 break;
2004 case Opt_wsize:
2005 if (get_option_ul(args, &option)) {
2006 cifs_dbg(VFS, "%s: Invalid wsize value\n",
2007 __func__);
2008 goto cifs_parse_mount_err;
2009 }
2010 vol->wsize = option;
2011 break;
2012 case Opt_actimeo:
2013 if (get_option_ul(args, &option)) {
2014 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
2015 __func__);
2016 goto cifs_parse_mount_err;
2017 }
2018 vol->actimeo = HZ * option;
2019 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
2020 cifs_dbg(VFS, "attribute cache timeout too large\n");
2021 goto cifs_parse_mount_err;
2022 }
2023 break;
2024 case Opt_handletimeout:
2025 if (get_option_ul(args, &option)) {
2026 cifs_dbg(VFS, "%s: Invalid handletimeout value\n",
2027 __func__);
2028 goto cifs_parse_mount_err;
2029 }
2030 vol->handle_timeout = option;
2031 if (vol->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) {
2032 cifs_dbg(VFS, "Invalid handle cache timeout, longer than 16 minutes\n");
2033 goto cifs_parse_mount_err;
2034 }
2035 break;
2036 case Opt_echo_interval:
2037 if (get_option_ul(args, &option)) {
2038 cifs_dbg(VFS, "%s: Invalid echo interval value\n",
2039 __func__);
2040 goto cifs_parse_mount_err;
2041 }
2042 vol->echo_interval = option;
2043 break;
2044 case Opt_snapshot:
2045 if (get_option_ul(args, &option)) {
2046 cifs_dbg(VFS, "%s: Invalid snapshot time\n",
2047 __func__);
2048 goto cifs_parse_mount_err;
2049 }
2050 vol->snapshot_time = option;
2051 break;
2052 case Opt_max_credits:
2053 if (get_option_ul(args, &option) || (option < 20) ||
2054 (option > 60000)) {
2055 cifs_dbg(VFS, "%s: Invalid max_credits value\n",
2056 __func__);
2057 goto cifs_parse_mount_err;
2058 }
2059 vol->max_credits = option;
2060 break;
2061
2062 /* String Arguments */
2063
2064 case Opt_blank_user:
2065 /* null user, ie. anonymous authentication */
2066 vol->nullauth = 1;
2067 vol->username = NULL;
2068 break;
2069 case Opt_user:
2070 string = match_strdup(args);
2071 if (string == NULL)
2072 goto out_nomem;
2073
2074 if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
2075 CIFS_MAX_USERNAME_LEN) {
2076 pr_warn("CIFS: username too long\n");
2077 goto cifs_parse_mount_err;
2078 }
2079
2080 kfree(vol->username);
2081 vol->username = kstrdup(string, GFP_KERNEL);
2082 if (!vol->username)
2083 goto cifs_parse_mount_err;
2084 break;
2085 case Opt_blank_pass:
2086 /* passwords have to be handled differently
2087 * to allow the character used for deliminator
2088 * to be passed within them
2089 */
2090
2091 /*
2092 * Check if this is a case where the password
2093 * starts with a delimiter
2094 */
2095 tmp_end = strchr(data, '=');
2096 tmp_end++;
2097 if (!(tmp_end < end && tmp_end[1] == delim)) {
2098 /* No it is not. Set the password to NULL */
2099 kzfree(vol->password);
2100 vol->password = NULL;
2101 break;
2102 }
2103 /* Fallthrough - to Opt_pass below.*/
2104 case Opt_pass:
2105 /* Obtain the value string */
2106 value = strchr(data, '=');
2107 value++;
2108
2109 /* Set tmp_end to end of the string */
2110 tmp_end = (char *) value + strlen(value);
2111
2112 /* Check if following character is the deliminator
2113 * If yes, we have encountered a double deliminator
2114 * reset the NULL character to the deliminator
2115 */
2116 if (tmp_end < end && tmp_end[1] == delim) {
2117 tmp_end[0] = delim;
2118
2119 /* Keep iterating until we get to a single
2120 * deliminator OR the end
2121 */
2122 while ((tmp_end = strchr(tmp_end, delim))
2123 != NULL && (tmp_end[1] == delim)) {
2124 tmp_end = (char *) &tmp_end[2];
2125 }
2126
2127 /* Reset var options to point to next element */
2128 if (tmp_end) {
2129 tmp_end[0] = '\0';
2130 options = (char *) &tmp_end[1];
2131 } else
2132 /* Reached the end of the mount option
2133 * string */
2134 options = end;
2135 }
2136
2137 kzfree(vol->password);
2138 /* Now build new password string */
2139 temp_len = strlen(value);
2140 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
2141 if (vol->password == NULL) {
2142 pr_warn("CIFS: no memory for password\n");
2143 goto cifs_parse_mount_err;
2144 }
2145
2146 for (i = 0, j = 0; i < temp_len; i++, j++) {
2147 vol->password[j] = value[i];
2148 if ((value[i] == delim) &&
2149 value[i+1] == delim)
2150 /* skip the second deliminator */
2151 i++;
2152 }
2153 vol->password[j] = '\0';
2154 break;
2155 case Opt_blank_ip:
2156 /* FIXME: should this be an error instead? */
2157 got_ip = false;
2158 break;
2159 case Opt_ip:
2160 string = match_strdup(args);
2161 if (string == NULL)
2162 goto out_nomem;
2163
2164 if (!cifs_convert_address(dstaddr, string,
2165 strlen(string))) {
2166 pr_err("CIFS: bad ip= option (%s).\n", string);
2167 goto cifs_parse_mount_err;
2168 }
2169 got_ip = true;
2170 break;
2171 case Opt_domain:
2172 string = match_strdup(args);
2173 if (string == NULL)
2174 goto out_nomem;
2175
2176 if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
2177 == CIFS_MAX_DOMAINNAME_LEN) {
2178 pr_warn("CIFS: domain name too long\n");
2179 goto cifs_parse_mount_err;
2180 }
2181
2182 kfree(vol->domainname);
2183 vol->domainname = kstrdup(string, GFP_KERNEL);
2184 if (!vol->domainname) {
2185 pr_warn("CIFS: no memory for domainname\n");
2186 goto cifs_parse_mount_err;
2187 }
2188 cifs_dbg(FYI, "Domain name set\n");
2189 break;
2190 case Opt_srcaddr:
2191 string = match_strdup(args);
2192 if (string == NULL)
2193 goto out_nomem;
2194
2195 if (!cifs_convert_address(
2196 (struct sockaddr *)&vol->srcaddr,
2197 string, strlen(string))) {
2198 pr_warn("CIFS: Could not parse srcaddr: %s\n",
2199 string);
2200 goto cifs_parse_mount_err;
2201 }
2202 break;
2203 case Opt_iocharset:
2204 string = match_strdup(args);
2205 if (string == NULL)
2206 goto out_nomem;
2207
2208 if (strnlen(string, 1024) >= 65) {
2209 pr_warn("CIFS: iocharset name too long.\n");
2210 goto cifs_parse_mount_err;
2211 }
2212
2213 if (strncasecmp(string, "default", 7) != 0) {
2214 kfree(vol->iocharset);
2215 vol->iocharset = kstrdup(string,
2216 GFP_KERNEL);
2217 if (!vol->iocharset) {
2218 pr_warn("CIFS: no memory for charset\n");
2219 goto cifs_parse_mount_err;
2220 }
2221 }
2222 /* if iocharset not set then load_nls_default
2223 * is used by caller
2224 */
2225 cifs_dbg(FYI, "iocharset set to %s\n", string);
2226 break;
2227 case Opt_netbiosname:
2228 string = match_strdup(args);
2229 if (string == NULL)
2230 goto out_nomem;
2231
2232 memset(vol->source_rfc1001_name, 0x20,
2233 RFC1001_NAME_LEN);
2234 /*
2235 * FIXME: are there cases in which a comma can
2236 * be valid in workstation netbios name (and
2237 * need special handling)?
2238 */
2239 for (i = 0; i < RFC1001_NAME_LEN; i++) {
2240 /* don't ucase netbiosname for user */
2241 if (string[i] == 0)
2242 break;
2243 vol->source_rfc1001_name[i] = string[i];
2244 }
2245 /* The string has 16th byte zero still from
2246 * set at top of the function
2247 */
2248 if (i == RFC1001_NAME_LEN && string[i] != 0)
2249 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
2250 break;
2251 case Opt_servern:
2252 /* servernetbiosname specified override *SMBSERVER */
2253 string = match_strdup(args);
2254 if (string == NULL)
2255 goto out_nomem;
2256
2257 /* last byte, type, is 0x20 for servr type */
2258 memset(vol->target_rfc1001_name, 0x20,
2259 RFC1001_NAME_LEN_WITH_NULL);
2260
2261 /* BB are there cases in which a comma can be
2262 valid in this workstation netbios name
2263 (and need special handling)? */
2264
2265 /* user or mount helper must uppercase the
2266 netbios name */
2267 for (i = 0; i < 15; i++) {
2268 if (string[i] == 0)
2269 break;
2270 vol->target_rfc1001_name[i] = string[i];
2271 }
2272 /* The string has 16th byte zero still from
2273 set at top of the function */
2274 if (i == RFC1001_NAME_LEN && string[i] != 0)
2275 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
2276 break;
2277 case Opt_ver:
2278 /* version of mount userspace tools, not dialect */
2279 string = match_strdup(args);
2280 if (string == NULL)
2281 goto out_nomem;
2282
2283 /* If interface changes in mount.cifs bump to new ver */
2284 if (strncasecmp(string, "1", 1) == 0) {
2285 if (strlen(string) > 1) {
2286 pr_warn("Bad mount helper ver=%s. Did "
2287 "you want SMB1 (CIFS) dialect "
2288 "and mean to type vers=1.0 "
2289 "instead?\n", string);
2290 goto cifs_parse_mount_err;
2291 }
2292 /* This is the default */
2293 break;
2294 }
2295 /* For all other value, error */
2296 pr_warn("CIFS: Invalid mount helper version specified\n");
2297 goto cifs_parse_mount_err;
2298 case Opt_vers:
2299 /* protocol version (dialect) */
2300 string = match_strdup(args);
2301 if (string == NULL)
2302 goto out_nomem;
2303
2304 if (cifs_parse_smb_version(string, vol, is_smb3) != 0)
2305 goto cifs_parse_mount_err;
2306 got_version = true;
2307 break;
2308 case Opt_sec:
2309 string = match_strdup(args);
2310 if (string == NULL)
2311 goto out_nomem;
2312
2313 if (cifs_parse_security_flavors(string, vol) != 0)
2314 goto cifs_parse_mount_err;
2315 break;
2316 case Opt_cache:
2317 string = match_strdup(args);
2318 if (string == NULL)
2319 goto out_nomem;
2320
2321 if (cifs_parse_cache_flavor(string, vol) != 0)
2322 goto cifs_parse_mount_err;
2323 break;
2324 default:
2325 /*
2326 * An option we don't recognize. Save it off for later
2327 * if we haven't already found one
2328 */
2329 if (!invalid)
2330 invalid = data;
2331 break;
2332 }
2333 /* Free up any allocated string */
2334 kfree(string);
2335 string = NULL;
2336 }
2337
2338 if (!sloppy && invalid) {
2339 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
2340 goto cifs_parse_mount_err;
2341 }
2342
2343 if (vol->rdma && vol->vals->protocol_id < SMB30_PROT_ID) {
2344 cifs_dbg(VFS, "SMB Direct requires Version >=3.0\n");
2345 goto cifs_parse_mount_err;
2346 }
2347
2348 #ifndef CONFIG_KEYS
2349 /* Muliuser mounts require CONFIG_KEYS support */
2350 if (vol->multiuser) {
2351 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
2352 goto cifs_parse_mount_err;
2353 }
2354 #endif
2355 if (!vol->UNC) {
2356 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
2357 goto cifs_parse_mount_err;
2358 }
2359
2360 /* make sure UNC has a share name */
2361 if (!strchr(vol->UNC + 3, '\\')) {
2362 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
2363 goto cifs_parse_mount_err;
2364 }
2365
2366 if (!got_ip) {
2367 int len;
2368 const char *slash;
2369
2370 /* No ip= option specified? Try to get it from UNC */
2371 /* Use the address part of the UNC. */
2372 slash = strchr(&vol->UNC[2], '\\');
2373 len = slash - &vol->UNC[2];
2374 if (!cifs_convert_address(dstaddr, &vol->UNC[2], len)) {
2375 pr_err("Unable to determine destination address.\n");
2376 goto cifs_parse_mount_err;
2377 }
2378 }
2379
2380 /* set the port that we got earlier */
2381 cifs_set_port(dstaddr, port);
2382
2383 if (uid_specified)
2384 vol->override_uid = override_uid;
2385 else if (override_uid == 1)
2386 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
2387
2388 if (gid_specified)
2389 vol->override_gid = override_gid;
2390 else if (override_gid == 1)
2391 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
2392
2393 if (got_version == false)
2394 pr_warn("No dialect specified on mount. Default has changed to "
2395 "a more secure dialect, SMB2.1 or later (e.g. SMB3), from CIFS "
2396 "(SMB1). To use the less secure SMB1 dialect to access "
2397 "old servers which do not support SMB3 (or SMB2.1) specify vers=1.0"
2398 " on mount.\n");
2399
2400 kfree(mountdata_copy);
2401 return 0;
2402
2403 out_nomem:
2404 pr_warn("Could not allocate temporary buffer\n");
2405 cifs_parse_mount_err:
2406 kfree(string);
2407 kfree(mountdata_copy);
2408 return 1;
2409 }
2410
2411 /** Returns true if srcaddr isn't specified and rhs isn't
2412 * specified, or if srcaddr is specified and
2413 * matches the IP address of the rhs argument.
2414 */
2415 static bool
2416 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
2417 {
2418 switch (srcaddr->sa_family) {
2419 case AF_UNSPEC:
2420 return (rhs->sa_family == AF_UNSPEC);
2421 case AF_INET: {
2422 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
2423 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
2424 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
2425 }
2426 case AF_INET6: {
2427 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
2428 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
2429 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
2430 }
2431 default:
2432 WARN_ON(1);
2433 return false; /* don't expect to be here */
2434 }
2435 }
2436
2437 /*
2438 * If no port is specified in addr structure, we try to match with 445 port
2439 * and if it fails - with 139 ports. It should be called only if address
2440 * families of server and addr are equal.
2441 */
2442 static bool
2443 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
2444 {
2445 __be16 port, *sport;
2446
2447 switch (addr->sa_family) {
2448 case AF_INET:
2449 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
2450 port = ((struct sockaddr_in *) addr)->sin_port;
2451 break;
2452 case AF_INET6:
2453 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
2454 port = ((struct sockaddr_in6 *) addr)->sin6_port;
2455 break;
2456 default:
2457 WARN_ON(1);
2458 return false;
2459 }
2460
2461 if (!port) {
2462 port = htons(CIFS_PORT);
2463 if (port == *sport)
2464 return true;
2465
2466 port = htons(RFC1001_PORT);
2467 }
2468
2469 return port == *sport;
2470 }
2471
2472 static bool
2473 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
2474 struct sockaddr *srcaddr)
2475 {
2476 switch (addr->sa_family) {
2477 case AF_INET: {
2478 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2479 struct sockaddr_in *srv_addr4 =
2480 (struct sockaddr_in *)&server->dstaddr;
2481
2482 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2483 return false;
2484 break;
2485 }
2486 case AF_INET6: {
2487 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2488 struct sockaddr_in6 *srv_addr6 =
2489 (struct sockaddr_in6 *)&server->dstaddr;
2490
2491 if (!ipv6_addr_equal(&addr6->sin6_addr,
2492 &srv_addr6->sin6_addr))
2493 return false;
2494 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2495 return false;
2496 break;
2497 }
2498 default:
2499 WARN_ON(1);
2500 return false; /* don't expect to be here */
2501 }
2502
2503 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2504 return false;
2505
2506 return true;
2507 }
2508
2509 static bool
2510 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2511 {
2512 /*
2513 * The select_sectype function should either return the vol->sectype
2514 * that was specified, or "Unspecified" if that sectype was not
2515 * compatible with the given NEGOTIATE request.
2516 */
2517 if (server->ops->select_sectype(server, vol->sectype)
2518 == Unspecified)
2519 return false;
2520
2521 /*
2522 * Now check if signing mode is acceptable. No need to check
2523 * global_secflags at this point since if MUST_SIGN is set then
2524 * the server->sign had better be too.
2525 */
2526 if (vol->sign && !server->sign)
2527 return false;
2528
2529 return true;
2530 }
2531
2532 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2533 {
2534 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2535
2536 if (vol->nosharesock)
2537 return 0;
2538
2539 /* BB update this for smb3any and default case */
2540 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2541 return 0;
2542
2543 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2544 return 0;
2545
2546 if (!match_address(server, addr,
2547 (struct sockaddr *)&vol->srcaddr))
2548 return 0;
2549
2550 if (!match_port(server, addr))
2551 return 0;
2552
2553 if (!match_security(server, vol))
2554 return 0;
2555
2556 if (server->echo_interval != vol->echo_interval * HZ)
2557 return 0;
2558
2559 if (server->rdma != vol->rdma)
2560 return 0;
2561
2562 return 1;
2563 }
2564
2565 struct TCP_Server_Info *
2566 cifs_find_tcp_session(struct smb_vol *vol)
2567 {
2568 struct TCP_Server_Info *server;
2569
2570 spin_lock(&cifs_tcp_ses_lock);
2571 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2572 if (!match_server(server, vol))
2573 continue;
2574
2575 ++server->srv_count;
2576 spin_unlock(&cifs_tcp_ses_lock);
2577 cifs_dbg(FYI, "Existing tcp session with server found\n");
2578 return server;
2579 }
2580 spin_unlock(&cifs_tcp_ses_lock);
2581 return NULL;
2582 }
2583
2584 void
2585 cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
2586 {
2587 struct task_struct *task;
2588
2589 spin_lock(&cifs_tcp_ses_lock);
2590 if (--server->srv_count > 0) {
2591 spin_unlock(&cifs_tcp_ses_lock);
2592 return;
2593 }
2594
2595 put_net(cifs_net_ns(server));
2596
2597 list_del_init(&server->tcp_ses_list);
2598 spin_unlock(&cifs_tcp_ses_lock);
2599
2600 cancel_delayed_work_sync(&server->echo);
2601
2602 if (from_reconnect)
2603 /*
2604 * Avoid deadlock here: reconnect work calls
2605 * cifs_put_tcp_session() at its end. Need to be sure
2606 * that reconnect work does nothing with server pointer after
2607 * that step.
2608 */
2609 cancel_delayed_work(&server->reconnect);
2610 else
2611 cancel_delayed_work_sync(&server->reconnect);
2612
2613 spin_lock(&GlobalMid_Lock);
2614 server->tcpStatus = CifsExiting;
2615 spin_unlock(&GlobalMid_Lock);
2616
2617 cifs_crypto_secmech_release(server);
2618 cifs_fscache_release_client_cookie(server);
2619
2620 kfree(server->session_key.response);
2621 server->session_key.response = NULL;
2622 server->session_key.len = 0;
2623
2624 task = xchg(&server->tsk, NULL);
2625 if (task)
2626 force_sig(SIGKILL, task);
2627 }
2628
2629 static struct TCP_Server_Info *
2630 cifs_get_tcp_session(struct smb_vol *volume_info)
2631 {
2632 struct TCP_Server_Info *tcp_ses = NULL;
2633 int rc;
2634
2635 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2636
2637 /* see if we already have a matching tcp_ses */
2638 tcp_ses = cifs_find_tcp_session(volume_info);
2639 if (tcp_ses)
2640 return tcp_ses;
2641
2642 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2643 if (!tcp_ses) {
2644 rc = -ENOMEM;
2645 goto out_err;
2646 }
2647
2648 tcp_ses->ops = volume_info->ops;
2649 tcp_ses->vals = volume_info->vals;
2650 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2651 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2652 if (IS_ERR(tcp_ses->hostname)) {
2653 rc = PTR_ERR(tcp_ses->hostname);
2654 goto out_err_crypto_release;
2655 }
2656
2657 tcp_ses->noblocksnd = volume_info->noblocksnd;
2658 tcp_ses->noautotune = volume_info->noautotune;
2659 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2660 tcp_ses->rdma = volume_info->rdma;
2661 tcp_ses->in_flight = 0;
2662 tcp_ses->credits = 1;
2663 init_waitqueue_head(&tcp_ses->response_q);
2664 init_waitqueue_head(&tcp_ses->request_q);
2665 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2666 mutex_init(&tcp_ses->srv_mutex);
2667 memcpy(tcp_ses->workstation_RFC1001_name,
2668 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2669 memcpy(tcp_ses->server_RFC1001_name,
2670 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2671 tcp_ses->session_estab = false;
2672 tcp_ses->sequence_number = 0;
2673 tcp_ses->reconnect_instance = 1;
2674 tcp_ses->lstrp = jiffies;
2675 spin_lock_init(&tcp_ses->req_lock);
2676 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2677 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2678 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2679 INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
2680 mutex_init(&tcp_ses->reconnect_mutex);
2681 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2682 sizeof(tcp_ses->srcaddr));
2683 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2684 sizeof(tcp_ses->dstaddr));
2685 generate_random_uuid(tcp_ses->client_guid);
2686 /*
2687 * at this point we are the only ones with the pointer
2688 * to the struct since the kernel thread not created yet
2689 * no need to spinlock this init of tcpStatus or srv_count
2690 */
2691 tcp_ses->tcpStatus = CifsNew;
2692 ++tcp_ses->srv_count;
2693
2694 if (volume_info->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
2695 volume_info->echo_interval <= SMB_ECHO_INTERVAL_MAX)
2696 tcp_ses->echo_interval = volume_info->echo_interval * HZ;
2697 else
2698 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
2699 if (tcp_ses->rdma) {
2700 #ifndef CONFIG_CIFS_SMB_DIRECT
2701 cifs_dbg(VFS, "CONFIG_CIFS_SMB_DIRECT is not enabled\n");
2702 rc = -ENOENT;
2703 goto out_err_crypto_release;
2704 #endif
2705 tcp_ses->smbd_conn = smbd_get_connection(
2706 tcp_ses, (struct sockaddr *)&volume_info->dstaddr);
2707 if (tcp_ses->smbd_conn) {
2708 cifs_dbg(VFS, "RDMA transport established\n");
2709 rc = 0;
2710 goto smbd_connected;
2711 } else {
2712 rc = -ENOENT;
2713 goto out_err_crypto_release;
2714 }
2715 }
2716 rc = ip_connect(tcp_ses);
2717 if (rc < 0) {
2718 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2719 goto out_err_crypto_release;
2720 }
2721 smbd_connected:
2722 /*
2723 * since we're in a cifs function already, we know that
2724 * this will succeed. No need for try_module_get().
2725 */
2726 __module_get(THIS_MODULE);
2727 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2728 tcp_ses, "cifsd");
2729 if (IS_ERR(tcp_ses->tsk)) {
2730 rc = PTR_ERR(tcp_ses->tsk);
2731 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2732 module_put(THIS_MODULE);
2733 goto out_err_crypto_release;
2734 }
2735 tcp_ses->tcpStatus = CifsNeedNegotiate;
2736
2737 tcp_ses->nr_targets = 1;
2738
2739 /* thread spawned, put it on the list */
2740 spin_lock(&cifs_tcp_ses_lock);
2741 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2742 spin_unlock(&cifs_tcp_ses_lock);
2743
2744 cifs_fscache_get_client_cookie(tcp_ses);
2745
2746 /* queue echo request delayed work */
2747 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
2748
2749 return tcp_ses;
2750
2751 out_err_crypto_release:
2752 cifs_crypto_secmech_release(tcp_ses);
2753
2754 put_net(cifs_net_ns(tcp_ses));
2755
2756 out_err:
2757 if (tcp_ses) {
2758 if (!IS_ERR(tcp_ses->hostname))
2759 kfree(tcp_ses->hostname);
2760 if (tcp_ses->ssocket)
2761 sock_release(tcp_ses->ssocket);
2762 kfree(tcp_ses);
2763 }
2764 return ERR_PTR(rc);
2765 }
2766
2767 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2768 {
2769 if (vol->sectype != Unspecified &&
2770 vol->sectype != ses->sectype)
2771 return 0;
2772
2773 switch (ses->sectype) {
2774 case Kerberos:
2775 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2776 return 0;
2777 break;
2778 default:
2779 /* NULL username means anonymous session */
2780 if (ses->user_name == NULL) {
2781 if (!vol->nullauth)
2782 return 0;
2783 break;
2784 }
2785
2786 /* anything else takes username/password */
2787 if (strncmp(ses->user_name,
2788 vol->username ? vol->username : "",
2789 CIFS_MAX_USERNAME_LEN))
2790 return 0;
2791 if ((vol->username && strlen(vol->username) != 0) &&
2792 ses->password != NULL &&
2793 strncmp(ses->password,
2794 vol->password ? vol->password : "",
2795 CIFS_MAX_PASSWORD_LEN))
2796 return 0;
2797 }
2798 return 1;
2799 }
2800
2801 /**
2802 * cifs_setup_ipc - helper to setup the IPC tcon for the session
2803 *
2804 * A new IPC connection is made and stored in the session
2805 * tcon_ipc. The IPC tcon has the same lifetime as the session.
2806 */
2807 static int
2808 cifs_setup_ipc(struct cifs_ses *ses, struct smb_vol *volume_info)
2809 {
2810 int rc = 0, xid;
2811 struct cifs_tcon *tcon;
2812 struct nls_table *nls_codepage;
2813 char unc[SERVER_NAME_LENGTH + sizeof("//x/IPC$")] = {0};
2814 bool seal = false;
2815
2816 /*
2817 * If the mount request that resulted in the creation of the
2818 * session requires encryption, force IPC to be encrypted too.
2819 */
2820 if (volume_info->seal) {
2821 if (ses->server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION)
2822 seal = true;
2823 else {
2824 cifs_dbg(VFS,
2825 "IPC: server doesn't support encryption\n");
2826 return -EOPNOTSUPP;
2827 }
2828 }
2829
2830 tcon = tconInfoAlloc();
2831 if (tcon == NULL)
2832 return -ENOMEM;
2833
2834 scnprintf(unc, sizeof(unc), "\\\\%s\\IPC$", ses->server->hostname);
2835
2836 /* cannot fail */
2837 nls_codepage = load_nls_default();
2838
2839 xid = get_xid();
2840 tcon->ses = ses;
2841 tcon->ipc = true;
2842 tcon->seal = seal;
2843 rc = ses->server->ops->tree_connect(xid, ses, unc, tcon, nls_codepage);
2844 free_xid(xid);
2845
2846 if (rc) {
2847 cifs_dbg(VFS, "failed to connect to IPC (rc=%d)\n", rc);
2848 tconInfoFree(tcon);
2849 goto out;
2850 }
2851
2852 cifs_dbg(FYI, "IPC tcon rc = %d ipc tid = %d\n", rc, tcon->tid);
2853
2854 ses->tcon_ipc = tcon;
2855 out:
2856 unload_nls(nls_codepage);
2857 return rc;
2858 }
2859
2860 /**
2861 * cifs_free_ipc - helper to release the session IPC tcon
2862 *
2863 * Needs to be called everytime a session is destroyed
2864 */
2865 static int
2866 cifs_free_ipc(struct cifs_ses *ses)
2867 {
2868 int rc = 0, xid;
2869 struct cifs_tcon *tcon = ses->tcon_ipc;
2870
2871 if (tcon == NULL)
2872 return 0;
2873
2874 if (ses->server->ops->tree_disconnect) {
2875 xid = get_xid();
2876 rc = ses->server->ops->tree_disconnect(xid, tcon);
2877 free_xid(xid);
2878 }
2879
2880 if (rc)
2881 cifs_dbg(FYI, "failed to disconnect IPC tcon (rc=%d)\n", rc);
2882
2883 tconInfoFree(tcon);
2884 ses->tcon_ipc = NULL;
2885 return rc;
2886 }
2887
2888 static struct cifs_ses *
2889 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2890 {
2891 struct cifs_ses *ses;
2892
2893 spin_lock(&cifs_tcp_ses_lock);
2894 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2895 if (ses->status == CifsExiting)
2896 continue;
2897 if (!match_session(ses, vol))
2898 continue;
2899 ++ses->ses_count;
2900 spin_unlock(&cifs_tcp_ses_lock);
2901 return ses;
2902 }
2903 spin_unlock(&cifs_tcp_ses_lock);
2904 return NULL;
2905 }
2906
2907 static void
2908 cifs_put_smb_ses(struct cifs_ses *ses)
2909 {
2910 unsigned int rc, xid;
2911 struct TCP_Server_Info *server = ses->server;
2912
2913 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
2914
2915 spin_lock(&cifs_tcp_ses_lock);
2916 if (ses->status == CifsExiting) {
2917 spin_unlock(&cifs_tcp_ses_lock);
2918 return;
2919 }
2920 if (--ses->ses_count > 0) {
2921 spin_unlock(&cifs_tcp_ses_lock);
2922 return;
2923 }
2924 if (ses->status == CifsGood)
2925 ses->status = CifsExiting;
2926 spin_unlock(&cifs_tcp_ses_lock);
2927
2928 cifs_free_ipc(ses);
2929
2930 if (ses->status == CifsExiting && server->ops->logoff) {
2931 xid = get_xid();
2932 rc = server->ops->logoff(xid, ses);
2933 if (rc)
2934 cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2935 __func__, rc);
2936 _free_xid(xid);
2937 }
2938
2939 spin_lock(&cifs_tcp_ses_lock);
2940 list_del_init(&ses->smb_ses_list);
2941 spin_unlock(&cifs_tcp_ses_lock);
2942
2943 sesInfoFree(ses);
2944 cifs_put_tcp_session(server, 0);
2945 }
2946
2947 #ifdef CONFIG_KEYS
2948
2949 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2950 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2951
2952 /* Populate username and pw fields from keyring if possible */
2953 static int
2954 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2955 {
2956 int rc = 0;
2957 const char *delim, *payload;
2958 char *desc;
2959 ssize_t len;
2960 struct key *key;
2961 struct TCP_Server_Info *server = ses->server;
2962 struct sockaddr_in *sa;
2963 struct sockaddr_in6 *sa6;
2964 const struct user_key_payload *upayload;
2965
2966 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2967 if (!desc)
2968 return -ENOMEM;
2969
2970 /* try to find an address key first */
2971 switch (server->dstaddr.ss_family) {
2972 case AF_INET:
2973 sa = (struct sockaddr_in *)&server->dstaddr;
2974 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2975 break;
2976 case AF_INET6:
2977 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2978 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2979 break;
2980 default:
2981 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2982 server->dstaddr.ss_family);
2983 rc = -EINVAL;
2984 goto out_err;
2985 }
2986
2987 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2988 key = request_key(&key_type_logon, desc, "");
2989 if (IS_ERR(key)) {
2990 if (!ses->domainName) {
2991 cifs_dbg(FYI, "domainName is NULL\n");
2992 rc = PTR_ERR(key);
2993 goto out_err;
2994 }
2995
2996 /* didn't work, try to find a domain key */
2997 sprintf(desc, "cifs:d:%s", ses->domainName);
2998 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2999 key = request_key(&key_type_logon, desc, "");
3000 if (IS_ERR(key)) {
3001 rc = PTR_ERR(key);
3002 goto out_err;
3003 }
3004 }
3005
3006 down_read(&key->sem);
3007 upayload = user_key_payload_locked(key);
3008 if (IS_ERR_OR_NULL(upayload)) {
3009 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
3010 goto out_key_put;
3011 }
3012
3013 /* find first : in payload */
3014 payload = upayload->data;
3015 delim = strnchr(payload, upayload->datalen, ':');
3016 cifs_dbg(FYI, "payload=%s\n", payload);
3017 if (!delim) {
3018 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
3019 upayload->datalen);
3020 rc = -EINVAL;
3021 goto out_key_put;
3022 }
3023
3024 len = delim - payload;
3025 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
3026 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
3027 len);
3028 rc = -EINVAL;
3029 goto out_key_put;
3030 }
3031
3032 vol->username = kstrndup(payload, len, GFP_KERNEL);
3033 if (!vol->username) {
3034 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
3035 len);
3036 rc = -ENOMEM;
3037 goto out_key_put;
3038 }
3039 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
3040
3041 len = key->datalen - (len + 1);
3042 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
3043 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
3044 rc = -EINVAL;
3045 kfree(vol->username);
3046 vol->username = NULL;
3047 goto out_key_put;
3048 }
3049
3050 ++delim;
3051 vol->password = kstrndup(delim, len, GFP_KERNEL);
3052 if (!vol->password) {
3053 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
3054 len);
3055 rc = -ENOMEM;
3056 kfree(vol->username);
3057 vol->username = NULL;
3058 goto out_key_put;
3059 }
3060
3061 out_key_put:
3062 up_read(&key->sem);
3063 key_put(key);
3064 out_err:
3065 kfree(desc);
3066 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
3067 return rc;
3068 }
3069 #else /* ! CONFIG_KEYS */
3070 static inline int
3071 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
3072 struct cifs_ses *ses __attribute__((unused)))
3073 {
3074 return -ENOSYS;
3075 }
3076 #endif /* CONFIG_KEYS */
3077
3078 /**
3079 * cifs_get_smb_ses - get a session matching @volume_info data from @server
3080 *
3081 * This function assumes it is being called from cifs_mount() where we
3082 * already got a server reference (server refcount +1). See
3083 * cifs_get_tcon() for refcount explanations.
3084 */
3085 static struct cifs_ses *
3086 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
3087 {
3088 int rc = -ENOMEM;
3089 unsigned int xid;
3090 struct cifs_ses *ses;
3091 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3092 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3093
3094 xid = get_xid();
3095
3096 ses = cifs_find_smb_ses(server, volume_info);
3097 if (ses) {
3098 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
3099 ses->status);
3100
3101 mutex_lock(&ses->session_mutex);
3102 rc = cifs_negotiate_protocol(xid, ses);
3103 if (rc) {
3104 mutex_unlock(&ses->session_mutex);
3105 /* problem -- put our ses reference */
3106 cifs_put_smb_ses(ses);
3107 free_xid(xid);
3108 return ERR_PTR(rc);
3109 }
3110 if (ses->need_reconnect) {
3111 cifs_dbg(FYI, "Session needs reconnect\n");
3112 rc = cifs_setup_session(xid, ses,
3113 volume_info->local_nls);
3114 if (rc) {
3115 mutex_unlock(&ses->session_mutex);
3116 /* problem -- put our reference */
3117 cifs_put_smb_ses(ses);
3118 free_xid(xid);
3119 return ERR_PTR(rc);
3120 }
3121 }
3122 mutex_unlock(&ses->session_mutex);
3123
3124 /* existing SMB ses has a server reference already */
3125 cifs_put_tcp_session(server, 0);
3126 free_xid(xid);
3127 return ses;
3128 }
3129
3130 cifs_dbg(FYI, "Existing smb sess not found\n");
3131 ses = sesInfoAlloc();
3132 if (ses == NULL)
3133 goto get_ses_fail;
3134
3135 /* new SMB session uses our server ref */
3136 ses->server = server;
3137 if (server->dstaddr.ss_family == AF_INET6)
3138 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
3139 else
3140 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
3141
3142 if (volume_info->username) {
3143 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
3144 if (!ses->user_name)
3145 goto get_ses_fail;
3146 }
3147
3148 /* volume_info->password freed at unmount */
3149 if (volume_info->password) {
3150 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
3151 if (!ses->password)
3152 goto get_ses_fail;
3153 }
3154 if (volume_info->domainname) {
3155 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
3156 if (!ses->domainName)
3157 goto get_ses_fail;
3158 }
3159 if (volume_info->domainauto)
3160 ses->domainAuto = volume_info->domainauto;
3161 ses->cred_uid = volume_info->cred_uid;
3162 ses->linux_uid = volume_info->linux_uid;
3163
3164 ses->sectype = volume_info->sectype;
3165 ses->sign = volume_info->sign;
3166
3167 mutex_lock(&ses->session_mutex);
3168 rc = cifs_negotiate_protocol(xid, ses);
3169 if (!rc)
3170 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
3171 mutex_unlock(&ses->session_mutex);
3172 if (rc)
3173 goto get_ses_fail;
3174
3175 /* success, put it on the list */
3176 spin_lock(&cifs_tcp_ses_lock);
3177 list_add(&ses->smb_ses_list, &server->smb_ses_list);
3178 spin_unlock(&cifs_tcp_ses_lock);
3179
3180 free_xid(xid);
3181
3182 cifs_setup_ipc(ses, volume_info);
3183
3184 return ses;
3185
3186 get_ses_fail:
3187 sesInfoFree(ses);
3188 free_xid(xid);
3189 return ERR_PTR(rc);
3190 }
3191
3192 static int match_tcon(struct cifs_tcon *tcon, struct smb_vol *volume_info)
3193 {
3194 if (tcon->tidStatus == CifsExiting)
3195 return 0;
3196 if (strncmp(tcon->treeName, volume_info->UNC, MAX_TREE_SIZE))
3197 return 0;
3198 if (tcon->seal != volume_info->seal)
3199 return 0;
3200 if (tcon->snapshot_time != volume_info->snapshot_time)
3201 return 0;
3202 if (tcon->handle_timeout != volume_info->handle_timeout)
3203 return 0;
3204 return 1;
3205 }
3206
3207 static struct cifs_tcon *
3208 cifs_find_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
3209 {
3210 struct list_head *tmp;
3211 struct cifs_tcon *tcon;
3212
3213 spin_lock(&cifs_tcp_ses_lock);
3214 list_for_each(tmp, &ses->tcon_list) {
3215 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
3216 if (!match_tcon(tcon, volume_info))
3217 continue;
3218 ++tcon->tc_count;
3219 spin_unlock(&cifs_tcp_ses_lock);
3220 return tcon;
3221 }
3222 spin_unlock(&cifs_tcp_ses_lock);
3223 return NULL;
3224 }
3225
3226 void
3227 cifs_put_tcon(struct cifs_tcon *tcon)
3228 {
3229 unsigned int xid;
3230 struct cifs_ses *ses;
3231
3232 /*
3233 * IPC tcon share the lifetime of their session and are
3234 * destroyed in the session put function
3235 */
3236 if (tcon == NULL || tcon->ipc)
3237 return;
3238
3239 ses = tcon->ses;
3240 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
3241 spin_lock(&cifs_tcp_ses_lock);
3242 if (--tcon->tc_count > 0) {
3243 spin_unlock(&cifs_tcp_ses_lock);
3244 return;
3245 }
3246
3247 list_del_init(&tcon->tcon_list);
3248 spin_unlock(&cifs_tcp_ses_lock);
3249
3250 xid = get_xid();
3251 if (ses->server->ops->tree_disconnect)
3252 ses->server->ops->tree_disconnect(xid, tcon);
3253 _free_xid(xid);
3254
3255 cifs_fscache_release_super_cookie(tcon);
3256 tconInfoFree(tcon);
3257 cifs_put_smb_ses(ses);
3258 }
3259
3260 /**
3261 * cifs_get_tcon - get a tcon matching @volume_info data from @ses
3262 *
3263 * - tcon refcount is the number of mount points using the tcon.
3264 * - ses refcount is the number of tcon using the session.
3265 *
3266 * 1. This function assumes it is being called from cifs_mount() where
3267 * we already got a session reference (ses refcount +1).
3268 *
3269 * 2. Since we're in the context of adding a mount point, the end
3270 * result should be either:
3271 *
3272 * a) a new tcon already allocated with refcount=1 (1 mount point) and
3273 * its session refcount incremented (1 new tcon). This +1 was
3274 * already done in (1).
3275 *
3276 * b) an existing tcon with refcount+1 (add a mount point to it) and
3277 * identical ses refcount (no new tcon). Because of (1) we need to
3278 * decrement the ses refcount.
3279 */
3280 static struct cifs_tcon *
3281 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
3282 {
3283 int rc, xid;
3284 struct cifs_tcon *tcon;
3285
3286 tcon = cifs_find_tcon(ses, volume_info);
3287 if (tcon) {
3288 /*
3289 * tcon has refcount already incremented but we need to
3290 * decrement extra ses reference gotten by caller (case b)
3291 */
3292 cifs_dbg(FYI, "Found match on UNC path\n");
3293 cifs_put_smb_ses(ses);
3294 return tcon;
3295 }
3296
3297 if (!ses->server->ops->tree_connect) {
3298 rc = -ENOSYS;
3299 goto out_fail;
3300 }
3301
3302 tcon = tconInfoAlloc();
3303 if (tcon == NULL) {
3304 rc = -ENOMEM;
3305 goto out_fail;
3306 }
3307
3308 if (volume_info->snapshot_time) {
3309 if (ses->server->vals->protocol_id == 0) {
3310 cifs_dbg(VFS,
3311 "Use SMB2 or later for snapshot mount option\n");
3312 rc = -EOPNOTSUPP;
3313 goto out_fail;
3314 } else
3315 tcon->snapshot_time = volume_info->snapshot_time;
3316 }
3317
3318 if (volume_info->handle_timeout) {
3319 if (ses->server->vals->protocol_id == 0) {
3320 cifs_dbg(VFS,
3321 "Use SMB2.1 or later for handle timeout option\n");
3322 rc = -EOPNOTSUPP;
3323 goto out_fail;
3324 } else
3325 tcon->handle_timeout = volume_info->handle_timeout;
3326 }
3327
3328 tcon->ses = ses;
3329 if (volume_info->password) {
3330 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
3331 if (!tcon->password) {
3332 rc = -ENOMEM;
3333 goto out_fail;
3334 }
3335 }
3336
3337 if (volume_info->seal) {
3338 if (ses->server->vals->protocol_id == 0) {
3339 cifs_dbg(VFS,
3340 "SMB3 or later required for encryption\n");
3341 rc = -EOPNOTSUPP;
3342 goto out_fail;
3343 } else if (tcon->ses->server->capabilities &
3344 SMB2_GLOBAL_CAP_ENCRYPTION)
3345 tcon->seal = true;
3346 else {
3347 cifs_dbg(VFS, "Encryption is not supported on share\n");
3348 rc = -EOPNOTSUPP;
3349 goto out_fail;
3350 }
3351 }
3352
3353 if (volume_info->linux_ext) {
3354 if (ses->server->posix_ext_supported) {
3355 tcon->posix_extensions = true;
3356 printk_once(KERN_WARNING
3357 "SMB3.11 POSIX Extensions are experimental\n");
3358 } else {
3359 cifs_dbg(VFS, "Server does not support mounting with posix SMB3.11 extensions.\n");
3360 rc = -EOPNOTSUPP;
3361 goto out_fail;
3362 }
3363 }
3364
3365 /*
3366 * BB Do we need to wrap session_mutex around this TCon call and Unix
3367 * SetFS as we do on SessSetup and reconnect?
3368 */
3369 xid = get_xid();
3370 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
3371 volume_info->local_nls);
3372 free_xid(xid);
3373 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
3374 if (rc)
3375 goto out_fail;
3376
3377 tcon->use_persistent = false;
3378 /* check if SMB2 or later, CIFS does not support persistent handles */
3379 if (volume_info->persistent) {
3380 if (ses->server->vals->protocol_id == 0) {
3381 cifs_dbg(VFS,
3382 "SMB3 or later required for persistent handles\n");
3383 rc = -EOPNOTSUPP;
3384 goto out_fail;
3385 } else if (ses->server->capabilities &
3386 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3387 tcon->use_persistent = true;
3388 else /* persistent handles requested but not supported */ {
3389 cifs_dbg(VFS,
3390 "Persistent handles not supported on share\n");
3391 rc = -EOPNOTSUPP;
3392 goto out_fail;
3393 }
3394 } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
3395 && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3396 && (volume_info->nopersistent == false)) {
3397 cifs_dbg(FYI, "enabling persistent handles\n");
3398 tcon->use_persistent = true;
3399 } else if (volume_info->resilient) {
3400 if (ses->server->vals->protocol_id == 0) {
3401 cifs_dbg(VFS,
3402 "SMB2.1 or later required for resilient handles\n");
3403 rc = -EOPNOTSUPP;
3404 goto out_fail;
3405 }
3406 tcon->use_resilient = true;
3407 }
3408
3409 /*
3410 * We can have only one retry value for a connection to a share so for
3411 * resources mounted more than once to the same server share the last
3412 * value passed in for the retry flag is used.
3413 */
3414 tcon->retry = volume_info->retry;
3415 tcon->nocase = volume_info->nocase;
3416 tcon->nohandlecache = volume_info->nohandlecache;
3417 tcon->local_lease = volume_info->local_lease;
3418 INIT_LIST_HEAD(&tcon->pending_opens);
3419
3420 spin_lock(&cifs_tcp_ses_lock);
3421 list_add(&tcon->tcon_list, &ses->tcon_list);
3422 spin_unlock(&cifs_tcp_ses_lock);
3423
3424 cifs_fscache_get_super_cookie(tcon);
3425
3426 return tcon;
3427
3428 out_fail:
3429 tconInfoFree(tcon);
3430 return ERR_PTR(rc);
3431 }
3432
3433 void
3434 cifs_put_tlink(struct tcon_link *tlink)
3435 {
3436 if (!tlink || IS_ERR(tlink))
3437 return;
3438
3439 if (!atomic_dec_and_test(&tlink->tl_count) ||
3440 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
3441 tlink->tl_time = jiffies;
3442 return;
3443 }
3444
3445 if (!IS_ERR(tlink_tcon(tlink)))
3446 cifs_put_tcon(tlink_tcon(tlink));
3447 kfree(tlink);
3448 return;
3449 }
3450
3451 static int
3452 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3453 {
3454 struct cifs_sb_info *old = CIFS_SB(sb);
3455 struct cifs_sb_info *new = mnt_data->cifs_sb;
3456
3457 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
3458 return 0;
3459
3460 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
3461 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
3462 return 0;
3463
3464 /*
3465 * We want to share sb only if we don't specify an r/wsize or
3466 * specified r/wsize is greater than or equal to existing one.
3467 */
3468 if (new->wsize && new->wsize < old->wsize)
3469 return 0;
3470
3471 if (new->rsize && new->rsize < old->rsize)
3472 return 0;
3473
3474 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
3475 return 0;
3476
3477 if (old->mnt_file_mode != new->mnt_file_mode ||
3478 old->mnt_dir_mode != new->mnt_dir_mode)
3479 return 0;
3480
3481 if (strcmp(old->local_nls->charset, new->local_nls->charset))
3482 return 0;
3483
3484 if (old->actimeo != new->actimeo)
3485 return 0;
3486
3487 return 1;
3488 }
3489
3490 static int
3491 match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3492 {
3493 struct cifs_sb_info *old = CIFS_SB(sb);
3494 struct cifs_sb_info *new = mnt_data->cifs_sb;
3495 bool old_set = old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH;
3496 bool new_set = new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH;
3497
3498 if (old_set && new_set && !strcmp(new->prepath, old->prepath))
3499 return 1;
3500 else if (!old_set && !new_set)
3501 return 1;
3502
3503 return 0;
3504 }
3505
3506 int
3507 cifs_match_super(struct super_block *sb, void *data)
3508 {
3509 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
3510 struct smb_vol *volume_info;
3511 struct cifs_sb_info *cifs_sb;
3512 struct TCP_Server_Info *tcp_srv;
3513 struct cifs_ses *ses;
3514 struct cifs_tcon *tcon;
3515 struct tcon_link *tlink;
3516 int rc = 0;
3517
3518 spin_lock(&cifs_tcp_ses_lock);
3519 cifs_sb = CIFS_SB(sb);
3520 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3521 if (IS_ERR(tlink)) {
3522 spin_unlock(&cifs_tcp_ses_lock);
3523 return rc;
3524 }
3525 tcon = tlink_tcon(tlink);
3526 ses = tcon->ses;
3527 tcp_srv = ses->server;
3528
3529 volume_info = mnt_data->vol;
3530
3531 if (!match_server(tcp_srv, volume_info) ||
3532 !match_session(ses, volume_info) ||
3533 !match_tcon(tcon, volume_info) ||
3534 !match_prepath(sb, mnt_data)) {
3535 rc = 0;
3536 goto out;
3537 }
3538
3539 rc = compare_mount_options(sb, mnt_data);
3540 out:
3541 spin_unlock(&cifs_tcp_ses_lock);
3542 cifs_put_tlink(tlink);
3543 return rc;
3544 }
3545
3546 #ifdef CONFIG_DEBUG_LOCK_ALLOC
3547 static struct lock_class_key cifs_key[2];
3548 static struct lock_class_key cifs_slock_key[2];
3549
3550 static inline void
3551 cifs_reclassify_socket4(struct socket *sock)
3552 {
3553 struct sock *sk = sock->sk;
3554 BUG_ON(!sock_allow_reclassification(sk));
3555 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
3556 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
3557 }
3558
3559 static inline void
3560 cifs_reclassify_socket6(struct socket *sock)
3561 {
3562 struct sock *sk = sock->sk;
3563 BUG_ON(!sock_allow_reclassification(sk));
3564 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
3565 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
3566 }
3567 #else
3568 static inline void
3569 cifs_reclassify_socket4(struct socket *sock)
3570 {
3571 }
3572
3573 static inline void
3574 cifs_reclassify_socket6(struct socket *sock)
3575 {
3576 }
3577 #endif
3578
3579 /* See RFC1001 section 14 on representation of Netbios names */
3580 static void rfc1002mangle(char *target, char *source, unsigned int length)
3581 {
3582 unsigned int i, j;
3583
3584 for (i = 0, j = 0; i < (length); i++) {
3585 /* mask a nibble at a time and encode */
3586 target[j] = 'A' + (0x0F & (source[i] >> 4));
3587 target[j+1] = 'A' + (0x0F & source[i]);
3588 j += 2;
3589 }
3590
3591 }
3592
3593 static int
3594 bind_socket(struct TCP_Server_Info *server)
3595 {
3596 int rc = 0;
3597 if (server->srcaddr.ss_family != AF_UNSPEC) {
3598 /* Bind to the specified local IP address */
3599 struct socket *socket = server->ssocket;
3600 rc = socket->ops->bind(socket,
3601 (struct sockaddr *) &server->srcaddr,
3602 sizeof(server->srcaddr));
3603 if (rc < 0) {
3604 struct sockaddr_in *saddr4;
3605 struct sockaddr_in6 *saddr6;
3606 saddr4 = (struct sockaddr_in *)&server->srcaddr;
3607 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
3608 if (saddr6->sin6_family == AF_INET6)
3609 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
3610 &saddr6->sin6_addr, rc);
3611 else
3612 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
3613 &saddr4->sin_addr.s_addr, rc);
3614 }
3615 }
3616 return rc;
3617 }
3618
3619 static int
3620 ip_rfc1001_connect(struct TCP_Server_Info *server)
3621 {
3622 int rc = 0;
3623 /*
3624 * some servers require RFC1001 sessinit before sending
3625 * negprot - BB check reconnection in case where second
3626 * sessinit is sent but no second negprot
3627 */
3628 struct rfc1002_session_packet *ses_init_buf;
3629 struct smb_hdr *smb_buf;
3630 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
3631 GFP_KERNEL);
3632 if (ses_init_buf) {
3633 ses_init_buf->trailer.session_req.called_len = 32;
3634
3635 if (server->server_RFC1001_name[0] != 0)
3636 rfc1002mangle(ses_init_buf->trailer.
3637 session_req.called_name,
3638 server->server_RFC1001_name,
3639 RFC1001_NAME_LEN_WITH_NULL);
3640 else
3641 rfc1002mangle(ses_init_buf->trailer.
3642 session_req.called_name,
3643 DEFAULT_CIFS_CALLED_NAME,
3644 RFC1001_NAME_LEN_WITH_NULL);
3645
3646 ses_init_buf->trailer.session_req.calling_len = 32;
3647
3648 /*
3649 * calling name ends in null (byte 16) from old smb
3650 * convention.
3651 */
3652 if (server->workstation_RFC1001_name[0] != 0)
3653 rfc1002mangle(ses_init_buf->trailer.
3654 session_req.calling_name,
3655 server->workstation_RFC1001_name,
3656 RFC1001_NAME_LEN_WITH_NULL);
3657 else
3658 rfc1002mangle(ses_init_buf->trailer.
3659 session_req.calling_name,
3660 "LINUX_CIFS_CLNT",
3661 RFC1001_NAME_LEN_WITH_NULL);
3662
3663 ses_init_buf->trailer.session_req.scope1 = 0;
3664 ses_init_buf->trailer.session_req.scope2 = 0;
3665 smb_buf = (struct smb_hdr *)ses_init_buf;
3666
3667 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3668 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3669 rc = smb_send(server, smb_buf, 0x44);
3670 kfree(ses_init_buf);
3671 /*
3672 * RFC1001 layer in at least one server
3673 * requires very short break before negprot
3674 * presumably because not expecting negprot
3675 * to follow so fast. This is a simple
3676 * solution that works without
3677 * complicating the code and causes no
3678 * significant slowing down on mount
3679 * for everyone else
3680 */
3681 usleep_range(1000, 2000);
3682 }
3683 /*
3684 * else the negprot may still work without this
3685 * even though malloc failed
3686 */
3687
3688 return rc;
3689 }
3690
3691 static int
3692 generic_ip_connect(struct TCP_Server_Info *server)
3693 {
3694 int rc = 0;
3695 __be16 sport;
3696 int slen, sfamily;
3697 struct socket *socket = server->ssocket;
3698 struct sockaddr *saddr;
3699
3700 saddr = (struct sockaddr *) &server->dstaddr;
3701
3702 if (server->dstaddr.ss_family == AF_INET6) {
3703 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3704 slen = sizeof(struct sockaddr_in6);
3705 sfamily = AF_INET6;
3706 } else {
3707 sport = ((struct sockaddr_in *) saddr)->sin_port;
3708 slen = sizeof(struct sockaddr_in);
3709 sfamily = AF_INET;
3710 }
3711
3712 if (socket == NULL) {
3713 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3714 IPPROTO_TCP, &socket, 1);
3715 if (rc < 0) {
3716 cifs_dbg(VFS, "Error %d creating socket\n", rc);
3717 server->ssocket = NULL;
3718 return rc;
3719 }
3720
3721 /* BB other socket options to set KEEPALIVE, NODELAY? */
3722 cifs_dbg(FYI, "Socket created\n");
3723 server->ssocket = socket;
3724 socket->sk->sk_allocation = GFP_NOFS;
3725 if (sfamily == AF_INET6)
3726 cifs_reclassify_socket6(socket);
3727 else
3728 cifs_reclassify_socket4(socket);
3729 }
3730
3731 rc = bind_socket(server);
3732 if (rc < 0)
3733 return rc;
3734
3735 /*
3736 * Eventually check for other socket options to change from
3737 * the default. sock_setsockopt not used because it expects
3738 * user space buffer
3739 */
3740 socket->sk->sk_rcvtimeo = 7 * HZ;
3741 socket->sk->sk_sndtimeo = 5 * HZ;
3742
3743 /* make the bufsizes depend on wsize/rsize and max requests */
3744 if (server->noautotune) {
3745 if (socket->sk->sk_sndbuf < (200 * 1024))
3746 socket->sk->sk_sndbuf = 200 * 1024;
3747 if (socket->sk->sk_rcvbuf < (140 * 1024))
3748 socket->sk->sk_rcvbuf = 140 * 1024;
3749 }
3750
3751 if (server->tcp_nodelay) {
3752 int val = 1;
3753 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3754 (char *)&val, sizeof(val));
3755 if (rc)
3756 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3757 rc);
3758 }
3759
3760 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3761 socket->sk->sk_sndbuf,
3762 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3763
3764 rc = socket->ops->connect(socket, saddr, slen, 0);
3765 if (rc < 0) {
3766 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3767 sock_release(socket);
3768 server->ssocket = NULL;
3769 return rc;
3770 }
3771
3772 if (sport == htons(RFC1001_PORT))
3773 rc = ip_rfc1001_connect(server);
3774
3775 return rc;
3776 }
3777
3778 static int
3779 ip_connect(struct TCP_Server_Info *server)
3780 {
3781 __be16 *sport;
3782 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3783 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3784
3785 if (server->dstaddr.ss_family == AF_INET6)
3786 sport = &addr6->sin6_port;
3787 else
3788 sport = &addr->sin_port;
3789
3790 if (*sport == 0) {
3791 int rc;
3792
3793 /* try with 445 port at first */
3794 *sport = htons(CIFS_PORT);
3795
3796 rc = generic_ip_connect(server);
3797 if (rc >= 0)
3798 return rc;
3799
3800 /* if it failed, try with 139 port */
3801 *sport = htons(RFC1001_PORT);
3802 }
3803
3804 return generic_ip_connect(server);
3805 }
3806
3807 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3808 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3809 {
3810 /* if we are reconnecting then should we check to see if
3811 * any requested capabilities changed locally e.g. via
3812 * remount but we can not do much about it here
3813 * if they have (even if we could detect it by the following)
3814 * Perhaps we could add a backpointer to array of sb from tcon
3815 * or if we change to make all sb to same share the same
3816 * sb as NFS - then we only have one backpointer to sb.
3817 * What if we wanted to mount the server share twice once with
3818 * and once without posixacls or posix paths? */
3819 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3820
3821 if (vol_info && vol_info->no_linux_ext) {
3822 tcon->fsUnixInfo.Capability = 0;
3823 tcon->unix_ext = 0; /* Unix Extensions disabled */
3824 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3825 return;
3826 } else if (vol_info)
3827 tcon->unix_ext = 1; /* Unix Extensions supported */
3828
3829 if (tcon->unix_ext == 0) {
3830 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3831 return;
3832 }
3833
3834 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3835 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3836 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3837 /* check for reconnect case in which we do not
3838 want to change the mount behavior if we can avoid it */
3839 if (vol_info == NULL) {
3840 /* turn off POSIX ACL and PATHNAMES if not set
3841 originally at mount time */
3842 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3843 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3844 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3845 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3846 cifs_dbg(VFS, "POSIXPATH support change\n");
3847 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3848 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3849 cifs_dbg(VFS, "possible reconnect error\n");
3850 cifs_dbg(VFS, "server disabled POSIX path support\n");
3851 }
3852 }
3853
3854 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3855 cifs_dbg(VFS, "per-share encryption not supported yet\n");
3856
3857 cap &= CIFS_UNIX_CAP_MASK;
3858 if (vol_info && vol_info->no_psx_acl)
3859 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3860 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3861 cifs_dbg(FYI, "negotiated posix acl support\n");
3862 if (cifs_sb)
3863 cifs_sb->mnt_cifs_flags |=
3864 CIFS_MOUNT_POSIXACL;
3865 }
3866
3867 if (vol_info && vol_info->posix_paths == 0)
3868 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3869 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3870 cifs_dbg(FYI, "negotiate posix pathnames\n");
3871 if (cifs_sb)
3872 cifs_sb->mnt_cifs_flags |=
3873 CIFS_MOUNT_POSIX_PATHS;
3874 }
3875
3876 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3877 #ifdef CONFIG_CIFS_DEBUG2
3878 if (cap & CIFS_UNIX_FCNTL_CAP)
3879 cifs_dbg(FYI, "FCNTL cap\n");
3880 if (cap & CIFS_UNIX_EXTATTR_CAP)
3881 cifs_dbg(FYI, "EXTATTR cap\n");
3882 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3883 cifs_dbg(FYI, "POSIX path cap\n");
3884 if (cap & CIFS_UNIX_XATTR_CAP)
3885 cifs_dbg(FYI, "XATTR cap\n");
3886 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3887 cifs_dbg(FYI, "POSIX ACL cap\n");
3888 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3889 cifs_dbg(FYI, "very large read cap\n");
3890 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3891 cifs_dbg(FYI, "very large write cap\n");
3892 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3893 cifs_dbg(FYI, "transport encryption cap\n");
3894 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3895 cifs_dbg(FYI, "mandatory transport encryption cap\n");
3896 #endif /* CIFS_DEBUG2 */
3897 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3898 if (vol_info == NULL) {
3899 cifs_dbg(FYI, "resetting capabilities failed\n");
3900 } else
3901 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");
3902
3903 }
3904 }
3905 }
3906
3907 int cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3908 struct cifs_sb_info *cifs_sb)
3909 {
3910 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3911
3912 spin_lock_init(&cifs_sb->tlink_tree_lock);
3913 cifs_sb->tlink_tree = RB_ROOT;
3914
3915 cifs_sb->bsize = pvolume_info->bsize;
3916 /*
3917 * Temporarily set r/wsize for matching superblock. If we end up using
3918 * new sb then client will later negotiate it downward if needed.
3919 */
3920 cifs_sb->rsize = pvolume_info->rsize;
3921 cifs_sb->wsize = pvolume_info->wsize;
3922
3923 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3924 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3925 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3926 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3927 cifs_dbg(FYI, "file mode: 0x%hx dir mode: 0x%hx\n",
3928 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3929
3930 cifs_sb->actimeo = pvolume_info->actimeo;
3931 cifs_sb->local_nls = pvolume_info->local_nls;
3932
3933 if (pvolume_info->nodfs)
3934 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_DFS;
3935 if (pvolume_info->noperm)
3936 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3937 if (pvolume_info->setuids)
3938 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3939 if (pvolume_info->setuidfromacl)
3940 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
3941 if (pvolume_info->server_ino)
3942 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3943 if (pvolume_info->remap)
3944 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3945 if (pvolume_info->sfu_remap)
3946 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3947 if (pvolume_info->no_xattr)
3948 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3949 if (pvolume_info->sfu_emul)
3950 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3951 if (pvolume_info->nobrl)
3952 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3953 if (pvolume_info->nohandlecache)
3954 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE;
3955 if (pvolume_info->nostrictsync)
3956 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3957 if (pvolume_info->mand_lock)
3958 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3959 if (pvolume_info->rwpidforward)
3960 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3961 if (pvolume_info->cifs_acl)
3962 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3963 if (pvolume_info->backupuid_specified) {
3964 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3965 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3966 }
3967 if (pvolume_info->backupgid_specified) {
3968 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3969 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3970 }
3971 if (pvolume_info->override_uid)
3972 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3973 if (pvolume_info->override_gid)
3974 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3975 if (pvolume_info->dynperm)
3976 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3977 if (pvolume_info->fsc)
3978 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3979 if (pvolume_info->multiuser)
3980 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3981 CIFS_MOUNT_NO_PERM);
3982 if (pvolume_info->strict_io)
3983 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3984 if (pvolume_info->direct_io) {
3985 cifs_dbg(FYI, "mounting share using direct i/o\n");
3986 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3987 }
3988 if (pvolume_info->mfsymlinks) {
3989 if (pvolume_info->sfu_emul) {
3990 /*
3991 * Our SFU ("Services for Unix" emulation does not allow
3992 * creating symlinks but does allow reading existing SFU
3993 * symlinks (it does allow both creating and reading SFU
3994 * style mknod and FIFOs though). When "mfsymlinks" and
3995 * "sfu" are both enabled at the same time, it allows
3996 * reading both types of symlinks, but will only create
3997 * them with mfsymlinks format. This allows better
3998 * Apple compatibility (probably better for Samba too)
3999 * while still recognizing old Windows style symlinks.
4000 */
4001 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
4002 }
4003 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
4004 }
4005
4006 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
4007 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
4008
4009 if (pvolume_info->prepath) {
4010 cifs_sb->prepath = kstrdup(pvolume_info->prepath, GFP_KERNEL);
4011 if (cifs_sb->prepath == NULL)
4012 return -ENOMEM;
4013 }
4014
4015 return 0;
4016 }
4017
4018 void
4019 cifs_cleanup_volume_info_contents(struct smb_vol *volume_info)
4020 {
4021 kfree(volume_info->username);
4022 kzfree(volume_info->password);
4023 kfree(volume_info->UNC);
4024 kfree(volume_info->domainname);
4025 kfree(volume_info->iocharset);
4026 kfree(volume_info->prepath);
4027 }
4028
4029 void
4030 cifs_cleanup_volume_info(struct smb_vol *volume_info)
4031 {
4032 if (!volume_info)
4033 return;
4034 cifs_cleanup_volume_info_contents(volume_info);
4035 kfree(volume_info);
4036 }
4037
4038 /* Release all succeed connections */
4039 static inline void mount_put_conns(struct cifs_sb_info *cifs_sb,
4040 unsigned int xid,
4041 struct TCP_Server_Info *server,
4042 struct cifs_ses *ses, struct cifs_tcon *tcon)
4043 {
4044 int rc = 0;
4045
4046 if (tcon)
4047 cifs_put_tcon(tcon);
4048 else if (ses)
4049 cifs_put_smb_ses(ses);
4050 else if (server)
4051 cifs_put_tcp_session(server, 0);
4052 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
4053 free_xid(xid);
4054 }
4055
4056 /* Get connections for tcp, ses and tcon */
4057 static int mount_get_conns(struct smb_vol *vol, struct cifs_sb_info *cifs_sb,
4058 unsigned int *xid,
4059 struct TCP_Server_Info **nserver,
4060 struct cifs_ses **nses, struct cifs_tcon **ntcon)
4061 {
4062 int rc = 0;
4063 struct TCP_Server_Info *server;
4064 struct cifs_ses *ses;
4065 struct cifs_tcon *tcon;
4066
4067 *nserver = NULL;
4068 *nses = NULL;
4069 *ntcon = NULL;
4070
4071 *xid = get_xid();
4072
4073 /* get a reference to a tcp session */
4074 server = cifs_get_tcp_session(vol);
4075 if (IS_ERR(server)) {
4076 rc = PTR_ERR(server);
4077 return rc;
4078 }
4079
4080 *nserver = server;
4081
4082 if ((vol->max_credits < 20) || (vol->max_credits > 60000))
4083 server->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
4084 else
4085 server->max_credits = vol->max_credits;
4086
4087 /* get a reference to a SMB session */
4088 ses = cifs_get_smb_ses(server, vol);
4089 if (IS_ERR(ses)) {
4090 rc = PTR_ERR(ses);
4091 return rc;
4092 }
4093
4094 *nses = ses;
4095
4096 if ((vol->persistent == true) && (!(ses->server->capabilities &
4097 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES))) {
4098 cifs_dbg(VFS, "persistent handles not supported by server\n");
4099 return -EOPNOTSUPP;
4100 }
4101
4102 /* search for existing tcon to this server share */
4103 tcon = cifs_get_tcon(ses, vol);
4104 if (IS_ERR(tcon)) {
4105 rc = PTR_ERR(tcon);
4106 return rc;
4107 }
4108
4109 *ntcon = tcon;
4110
4111 /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
4112 if (tcon->posix_extensions)
4113 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
4114
4115 /* tell server which Unix caps we support */
4116 if (cap_unix(tcon->ses)) {
4117 /*
4118 * reset of caps checks mount to see if unix extensions disabled
4119 * for just this mount.
4120 */
4121 reset_cifs_unix_caps(*xid, tcon, cifs_sb, vol);
4122 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
4123 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
4124 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP))
4125 return -EACCES;
4126 } else
4127 tcon->unix_ext = 0; /* server does not support them */
4128
4129 /* do not care if a following call succeed - informational */
4130 if (!tcon->pipe && server->ops->qfs_tcon)
4131 server->ops->qfs_tcon(*xid, tcon);
4132
4133 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, vol);
4134 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, vol);
4135
4136 return 0;
4137 }
4138
4139 static int mount_setup_tlink(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses,
4140 struct cifs_tcon *tcon)
4141 {
4142 struct tcon_link *tlink;
4143
4144 /* hang the tcon off of the superblock */
4145 tlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4146 if (tlink == NULL)
4147 return -ENOMEM;
4148
4149 tlink->tl_uid = ses->linux_uid;
4150 tlink->tl_tcon = tcon;
4151 tlink->tl_time = jiffies;
4152 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
4153 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4154
4155 cifs_sb->master_tlink = tlink;
4156 spin_lock(&cifs_sb->tlink_tree_lock);
4157 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4158 spin_unlock(&cifs_sb->tlink_tree_lock);
4159
4160 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4161 TLINK_IDLE_EXPIRE);
4162 return 0;
4163 }
4164
4165 #ifdef CONFIG_CIFS_DFS_UPCALL
4166 /*
4167 * cifs_build_path_to_root returns full path to root when we do not have an
4168 * exiting connection (tcon)
4169 */
4170 static char *
4171 build_unc_path_to_root(const struct smb_vol *vol,
4172 const struct cifs_sb_info *cifs_sb, bool useppath)
4173 {
4174 char *full_path, *pos;
4175 unsigned int pplen = useppath && vol->prepath ?
4176 strlen(vol->prepath) + 1 : 0;
4177 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
4178
4179 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
4180 if (full_path == NULL)
4181 return ERR_PTR(-ENOMEM);
4182
4183 strncpy(full_path, vol->UNC, unc_len);
4184 pos = full_path + unc_len;
4185
4186 if (pplen) {
4187 *pos = CIFS_DIR_SEP(cifs_sb);
4188 strncpy(pos + 1, vol->prepath, pplen);
4189 pos += pplen;
4190 }
4191
4192 *pos = '\0'; /* add trailing null */
4193 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
4194 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
4195 return full_path;
4196 }
4197
4198 /**
4199 * expand_dfs_referral - Perform a dfs referral query and update the cifs_sb
4200 *
4201 *
4202 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
4203 * to a string containing updated options for the submount. Otherwise it
4204 * will be left untouched.
4205 *
4206 * Returns the rc from get_dfs_path to the caller, which can be used to
4207 * determine whether there were referrals.
4208 */
4209 static int
4210 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
4211 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
4212 int check_prefix)
4213 {
4214 int rc;
4215 struct dfs_info3_param referral = {0};
4216 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
4217
4218 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
4219 return -EREMOTE;
4220
4221 full_path = build_unc_path_to_root(volume_info, cifs_sb, true);
4222 if (IS_ERR(full_path))
4223 return PTR_ERR(full_path);
4224
4225 /* For DFS paths, skip the first '\' of the UNC */
4226 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
4227
4228 rc = dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb),
4229 ref_path, &referral, NULL);
4230 if (!rc) {
4231 char *fake_devname = NULL;
4232
4233 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
4234 full_path + 1, &referral,
4235 &fake_devname);
4236 free_dfs_info_param(&referral);
4237
4238 if (IS_ERR(mdata)) {
4239 rc = PTR_ERR(mdata);
4240 mdata = NULL;
4241 } else {
4242 cifs_cleanup_volume_info_contents(volume_info);
4243 rc = cifs_setup_volume_info(volume_info, mdata,
4244 fake_devname, false);
4245 }
4246 kfree(fake_devname);
4247 kfree(cifs_sb->mountdata);
4248 cifs_sb->mountdata = mdata;
4249 }
4250 kfree(full_path);
4251 return rc;
4252 }
4253
4254 static inline int get_next_dfs_tgt(const char *path,
4255 struct dfs_cache_tgt_list *tgt_list,
4256 struct dfs_cache_tgt_iterator **tgt_it)
4257 {
4258 if (!*tgt_it)
4259 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
4260 else
4261 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
4262 return !*tgt_it ? -EHOSTDOWN : 0;
4263 }
4264
4265 static int update_vol_info(const struct dfs_cache_tgt_iterator *tgt_it,
4266 struct smb_vol *fake_vol, struct smb_vol *vol)
4267 {
4268 const char *tgt = dfs_cache_get_tgt_name(tgt_it);
4269 int len = strlen(tgt) + 2;
4270 char *new_unc;
4271
4272 new_unc = kmalloc(len, GFP_KERNEL);
4273 if (!new_unc)
4274 return -ENOMEM;
4275 scnprintf(new_unc, len, "\\%s", tgt);
4276
4277 kfree(vol->UNC);
4278 vol->UNC = new_unc;
4279
4280 if (fake_vol->prepath) {
4281 kfree(vol->prepath);
4282 vol->prepath = fake_vol->prepath;
4283 fake_vol->prepath = NULL;
4284 }
4285 memcpy(&vol->dstaddr, &fake_vol->dstaddr, sizeof(vol->dstaddr));
4286
4287 return 0;
4288 }
4289
4290 static int setup_dfs_tgt_conn(const char *path,
4291 const struct dfs_cache_tgt_iterator *tgt_it,
4292 struct cifs_sb_info *cifs_sb,
4293 struct smb_vol *vol,
4294 unsigned int *xid,
4295 struct TCP_Server_Info **server,
4296 struct cifs_ses **ses,
4297 struct cifs_tcon **tcon)
4298 {
4299 int rc;
4300 struct dfs_info3_param ref = {0};
4301 char *mdata = NULL, *fake_devname = NULL;
4302 struct smb_vol fake_vol = {0};
4303
4304 cifs_dbg(FYI, "%s: dfs path: %s\n", __func__, path);
4305
4306 rc = dfs_cache_get_tgt_referral(path, tgt_it, &ref);
4307 if (rc)
4308 return rc;
4309
4310 mdata = cifs_compose_mount_options(cifs_sb->mountdata, path, &ref,
4311 &fake_devname);
4312 free_dfs_info_param(&ref);
4313
4314 if (IS_ERR(mdata)) {
4315 rc = PTR_ERR(mdata);
4316 mdata = NULL;
4317 } else {
4318 cifs_dbg(FYI, "%s: fake_devname: %s\n", __func__, fake_devname);
4319 rc = cifs_setup_volume_info(&fake_vol, mdata, fake_devname,
4320 false);
4321 }
4322 kfree(mdata);
4323 kfree(fake_devname);
4324
4325 if (!rc) {
4326 /*
4327 * We use a 'fake_vol' here because we need pass it down to the
4328 * mount_{get,put} functions to test connection against new DFS
4329 * targets.
4330 */
4331 mount_put_conns(cifs_sb, *xid, *server, *ses, *tcon);
4332 rc = mount_get_conns(&fake_vol, cifs_sb, xid, server, ses,
4333 tcon);
4334 if (!rc) {
4335 /*
4336 * We were able to connect to new target server.
4337 * Update current volume info with new target server.
4338 */
4339 rc = update_vol_info(tgt_it, &fake_vol, vol);
4340 }
4341 }
4342 cifs_cleanup_volume_info_contents(&fake_vol);
4343 return rc;
4344 }
4345
4346 static int mount_do_dfs_failover(const char *path,
4347 struct cifs_sb_info *cifs_sb,
4348 struct smb_vol *vol,
4349 struct cifs_ses *root_ses,
4350 unsigned int *xid,
4351 struct TCP_Server_Info **server,
4352 struct cifs_ses **ses,
4353 struct cifs_tcon **tcon)
4354 {
4355 int rc;
4356 struct dfs_cache_tgt_list tgt_list;
4357 struct dfs_cache_tgt_iterator *tgt_it = NULL;
4358
4359 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
4360 return -EOPNOTSUPP;
4361
4362 rc = dfs_cache_noreq_find(path, NULL, &tgt_list);
4363 if (rc)
4364 return rc;
4365
4366 for (;;) {
4367 /* Get next DFS target server - if any */
4368 rc = get_next_dfs_tgt(path, &tgt_list, &tgt_it);
4369 if (rc)
4370 break;
4371 /* Connect to next DFS target */
4372 rc = setup_dfs_tgt_conn(path, tgt_it, cifs_sb, vol, xid, server,
4373 ses, tcon);
4374 if (!rc || rc == -EACCES || rc == -EOPNOTSUPP)
4375 break;
4376 }
4377 if (!rc) {
4378 /*
4379 * Update DFS target hint in DFS referral cache with the target
4380 * server we successfully reconnected to.
4381 */
4382 rc = dfs_cache_update_tgthint(*xid, root_ses ? root_ses : *ses,
4383 cifs_sb->local_nls,
4384 cifs_remap(cifs_sb), path,
4385 tgt_it);
4386 }
4387 dfs_cache_free_tgts(&tgt_list);
4388 return rc;
4389 }
4390 #endif
4391
4392 static int
4393 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
4394 const char *devname, bool is_smb3)
4395 {
4396 int rc = 0;
4397
4398 if (cifs_parse_mount_options(mount_data, devname, volume_info, is_smb3))
4399 return -EINVAL;
4400
4401 if (volume_info->nullauth) {
4402 cifs_dbg(FYI, "Anonymous login\n");
4403 kfree(volume_info->username);
4404 volume_info->username = NULL;
4405 } else if (volume_info->username) {
4406 /* BB fixme parse for domain name here */
4407 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
4408 } else {
4409 cifs_dbg(VFS, "No username specified\n");
4410 /* In userspace mount helper we can get user name from alternate
4411 locations such as env variables and files on disk */
4412 return -EINVAL;
4413 }
4414
4415 /* this is needed for ASCII cp to Unicode converts */
4416 if (volume_info->iocharset == NULL) {
4417 /* load_nls_default cannot return null */
4418 volume_info->local_nls = load_nls_default();
4419 } else {
4420 volume_info->local_nls = load_nls(volume_info->iocharset);
4421 if (volume_info->local_nls == NULL) {
4422 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
4423 volume_info->iocharset);
4424 return -ELIBACC;
4425 }
4426 }
4427
4428 return rc;
4429 }
4430
4431 struct smb_vol *
4432 cifs_get_volume_info(char *mount_data, const char *devname, bool is_smb3)
4433 {
4434 int rc;
4435 struct smb_vol *volume_info;
4436
4437 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
4438 if (!volume_info)
4439 return ERR_PTR(-ENOMEM);
4440
4441 rc = cifs_setup_volume_info(volume_info, mount_data, devname, is_smb3);
4442 if (rc) {
4443 cifs_cleanup_volume_info(volume_info);
4444 volume_info = ERR_PTR(rc);
4445 }
4446
4447 return volume_info;
4448 }
4449
4450 static int
4451 cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
4452 unsigned int xid,
4453 struct cifs_tcon *tcon,
4454 struct cifs_sb_info *cifs_sb,
4455 char *full_path)
4456 {
4457 int rc;
4458 char *s;
4459 char sep, tmp;
4460
4461 sep = CIFS_DIR_SEP(cifs_sb);
4462 s = full_path;
4463
4464 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
4465 while (rc == 0) {
4466 /* skip separators */
4467 while (*s == sep)
4468 s++;
4469 if (!*s)
4470 break;
4471 /* next separator */
4472 while (*s && *s != sep)
4473 s++;
4474
4475 /*
4476 * temporarily null-terminate the path at the end of
4477 * the current component
4478 */
4479 tmp = *s;
4480 *s = 0;
4481 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
4482 full_path);
4483 *s = tmp;
4484 }
4485 return rc;
4486 }
4487
4488 /*
4489 * Check if path is remote (e.g. a DFS share). Return -EREMOTE if it is,
4490 * otherwise 0.
4491 */
4492 static int is_path_remote(struct cifs_sb_info *cifs_sb, struct smb_vol *vol,
4493 const unsigned int xid,
4494 struct TCP_Server_Info *server,
4495 struct cifs_tcon *tcon)
4496 {
4497 int rc;
4498 char *full_path;
4499
4500 if (!server->ops->is_path_accessible)
4501 return -EOPNOTSUPP;
4502
4503 /*
4504 * cifs_build_path_to_root works only when we have a valid tcon
4505 */
4506 full_path = cifs_build_path_to_root(vol, cifs_sb, tcon,
4507 tcon->Flags & SMB_SHARE_IS_IN_DFS);
4508 if (full_path == NULL)
4509 return -ENOMEM;
4510
4511 cifs_dbg(FYI, "%s: full_path: %s\n", __func__, full_path);
4512
4513 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
4514 full_path);
4515 if (rc != 0 && rc != -EREMOTE) {
4516 kfree(full_path);
4517 return rc;
4518 }
4519
4520 if (rc != -EREMOTE) {
4521 rc = cifs_are_all_path_components_accessible(server, xid, tcon,
4522 cifs_sb,
4523 full_path);
4524 if (rc != 0) {
4525 cifs_dbg(VFS, "cannot query dirs between root and final path, "
4526 "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
4527 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
4528 rc = 0;
4529 }
4530 }
4531
4532 kfree(full_path);
4533 return rc;
4534 }
4535
4536 #ifdef CONFIG_CIFS_DFS_UPCALL
4537 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *vol)
4538 {
4539 int rc = 0;
4540 unsigned int xid;
4541 struct cifs_ses *ses;
4542 struct cifs_tcon *root_tcon = NULL;
4543 struct cifs_tcon *tcon = NULL;
4544 struct TCP_Server_Info *server;
4545 char *root_path = NULL, *full_path = NULL;
4546 char *old_mountdata;
4547 int count;
4548
4549 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4550 if (!rc && tcon) {
4551 /* If not a standalone DFS root, then check if path is remote */
4552 rc = dfs_cache_find(xid, ses, cifs_sb->local_nls,
4553 cifs_remap(cifs_sb), vol->UNC + 1, NULL,
4554 NULL);
4555 if (rc) {
4556 rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
4557 if (!rc)
4558 goto out;
4559 if (rc != -EREMOTE)
4560 goto error;
4561 }
4562 }
4563 /*
4564 * If first DFS target server went offline and we failed to connect it,
4565 * server and ses pointers are NULL at this point, though we still have
4566 * chance to get a cached DFS referral in expand_dfs_referral() and
4567 * retry next target available in it.
4568 *
4569 * If a NULL ses ptr is passed to dfs_cache_find(), a lookup will be
4570 * performed against DFS path and *no* requests will be sent to server
4571 * for any new DFS referrals. Hence it's safe to skip checking whether
4572 * server or ses ptr is NULL.
4573 */
4574 if (rc == -EACCES || rc == -EOPNOTSUPP)
4575 goto error;
4576
4577 root_path = build_unc_path_to_root(vol, cifs_sb, false);
4578 if (IS_ERR(root_path)) {
4579 rc = PTR_ERR(root_path);
4580 root_path = NULL;
4581 goto error;
4582 }
4583
4584 full_path = build_unc_path_to_root(vol, cifs_sb, true);
4585 if (IS_ERR(full_path)) {
4586 rc = PTR_ERR(full_path);
4587 full_path = NULL;
4588 goto error;
4589 }
4590 /*
4591 * Perform an unconditional check for whether there are DFS
4592 * referrals for this path without prefix, to provide support
4593 * for DFS referrals from w2k8 servers which don't seem to respond
4594 * with PATH_NOT_COVERED to requests that include the prefix.
4595 * Chase the referral if found, otherwise continue normally.
4596 */
4597 old_mountdata = cifs_sb->mountdata;
4598 (void)expand_dfs_referral(xid, ses, vol, cifs_sb, false);
4599
4600 if (cifs_sb->mountdata == NULL) {
4601 rc = -ENOENT;
4602 goto error;
4603 }
4604
4605 if (cifs_sb->mountdata != old_mountdata) {
4606 /* If we were redirected, reconnect to new target server */
4607 mount_put_conns(cifs_sb, xid, server, ses, tcon);
4608 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4609 }
4610 if (rc) {
4611 if (rc == -EACCES || rc == -EOPNOTSUPP)
4612 goto error;
4613 /* Perform DFS failover to any other DFS targets */
4614 rc = mount_do_dfs_failover(root_path + 1, cifs_sb, vol, NULL,
4615 &xid, &server, &ses, &tcon);
4616 if (rc)
4617 goto error;
4618 }
4619
4620 kfree(root_path);
4621 root_path = build_unc_path_to_root(vol, cifs_sb, false);
4622 if (IS_ERR(root_path)) {
4623 rc = PTR_ERR(root_path);
4624 root_path = NULL;
4625 goto error;
4626 }
4627 /* Cache out resolved root server */
4628 (void)dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb),
4629 root_path + 1, NULL, NULL);
4630 /*
4631 * Save root tcon for additional DFS requests to update or create a new
4632 * DFS cache entry, or even perform DFS failover.
4633 */
4634 spin_lock(&cifs_tcp_ses_lock);
4635 tcon->tc_count++;
4636 tcon->dfs_path = root_path;
4637 root_path = NULL;
4638 tcon->remap = cifs_remap(cifs_sb);
4639 spin_unlock(&cifs_tcp_ses_lock);
4640
4641 root_tcon = tcon;
4642
4643 for (count = 1; ;) {
4644 if (!rc && tcon) {
4645 rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
4646 if (!rc || rc != -EREMOTE)
4647 break;
4648 }
4649 /*
4650 * BB: when we implement proper loop detection,
4651 * we will remove this check. But now we need it
4652 * to prevent an indefinite loop if 'DFS tree' is
4653 * misconfigured (i.e. has loops).
4654 */
4655 if (count++ > MAX_NESTED_LINKS) {
4656 rc = -ELOOP;
4657 break;
4658 }
4659
4660 kfree(full_path);
4661 full_path = build_unc_path_to_root(vol, cifs_sb, true);
4662 if (IS_ERR(full_path)) {
4663 rc = PTR_ERR(full_path);
4664 full_path = NULL;
4665 break;
4666 }
4667
4668 old_mountdata = cifs_sb->mountdata;
4669 rc = expand_dfs_referral(xid, root_tcon->ses, vol, cifs_sb,
4670 true);
4671 if (rc)
4672 break;
4673
4674 if (cifs_sb->mountdata != old_mountdata) {
4675 mount_put_conns(cifs_sb, xid, server, ses, tcon);
4676 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses,
4677 &tcon);
4678 }
4679 if (rc) {
4680 if (rc == -EACCES || rc == -EOPNOTSUPP)
4681 break;
4682 /* Perform DFS failover to any other DFS targets */
4683 rc = mount_do_dfs_failover(full_path + 1, cifs_sb, vol,
4684 root_tcon->ses, &xid,
4685 &server, &ses, &tcon);
4686 if (rc == -EACCES || rc == -EOPNOTSUPP || !server ||
4687 !ses)
4688 goto error;
4689 }
4690 }
4691 cifs_put_tcon(root_tcon);
4692
4693 if (rc)
4694 goto error;
4695
4696 spin_lock(&cifs_tcp_ses_lock);
4697 if (!tcon->dfs_path) {
4698 /* Save full path in new tcon to do failover when reconnecting tcons */
4699 tcon->dfs_path = full_path;
4700 full_path = NULL;
4701 tcon->remap = cifs_remap(cifs_sb);
4702 }
4703 cifs_sb->origin_fullpath = kstrndup(tcon->dfs_path,
4704 strlen(tcon->dfs_path),
4705 GFP_ATOMIC);
4706 if (!cifs_sb->origin_fullpath) {
4707 spin_unlock(&cifs_tcp_ses_lock);
4708 rc = -ENOMEM;
4709 goto error;
4710 }
4711 spin_unlock(&cifs_tcp_ses_lock);
4712
4713 rc = dfs_cache_add_vol(vol, cifs_sb->origin_fullpath);
4714 if (rc) {
4715 kfree(cifs_sb->origin_fullpath);
4716 goto error;
4717 }
4718 /*
4719 * After reconnecting to a different server, unique ids won't
4720 * match anymore, so we disable serverino. This prevents
4721 * dentry revalidation to think the dentry are stale (ESTALE).
4722 */
4723 cifs_autodisable_serverino(cifs_sb);
4724 out:
4725 free_xid(xid);
4726 return mount_setup_tlink(cifs_sb, ses, tcon);
4727
4728 error:
4729 kfree(full_path);
4730 kfree(root_path);
4731 mount_put_conns(cifs_sb, xid, server, ses, tcon);
4732 return rc;
4733 }
4734 #else
4735 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *vol)
4736 {
4737 int rc = 0;
4738 unsigned int xid;
4739 struct cifs_ses *ses;
4740 struct cifs_tcon *tcon;
4741 struct TCP_Server_Info *server;
4742
4743 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4744 if (rc)
4745 goto error;
4746
4747 if (tcon) {
4748 rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
4749 if (rc == -EREMOTE)
4750 rc = -EOPNOTSUPP;
4751 if (rc)
4752 goto error;
4753 }
4754
4755 free_xid(xid);
4756
4757 return mount_setup_tlink(cifs_sb, ses, tcon);
4758
4759 error:
4760 mount_put_conns(cifs_sb, xid, server, ses, tcon);
4761 return rc;
4762 }
4763 #endif
4764
4765 /*
4766 * Issue a TREE_CONNECT request.
4767 */
4768 int
4769 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
4770 const char *tree, struct cifs_tcon *tcon,
4771 const struct nls_table *nls_codepage)
4772 {
4773 struct smb_hdr *smb_buffer;
4774 struct smb_hdr *smb_buffer_response;
4775 TCONX_REQ *pSMB;
4776 TCONX_RSP *pSMBr;
4777 unsigned char *bcc_ptr;
4778 int rc = 0;
4779 int length;
4780 __u16 bytes_left, count;
4781
4782 if (ses == NULL)
4783 return -EIO;
4784
4785 smb_buffer = cifs_buf_get();
4786 if (smb_buffer == NULL)
4787 return -ENOMEM;
4788
4789 smb_buffer_response = smb_buffer;
4790
4791 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
4792 NULL /*no tid */ , 4 /*wct */ );
4793
4794 smb_buffer->Mid = get_next_mid(ses->server);
4795 smb_buffer->Uid = ses->Suid;
4796 pSMB = (TCONX_REQ *) smb_buffer;
4797 pSMBr = (TCONX_RSP *) smb_buffer_response;
4798
4799 pSMB->AndXCommand = 0xFF;
4800 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
4801 bcc_ptr = &pSMB->Password[0];
4802 if (tcon->pipe || (ses->server->sec_mode & SECMODE_USER)) {
4803 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
4804 *bcc_ptr = 0; /* password is null byte */
4805 bcc_ptr++; /* skip password */
4806 /* already aligned so no need to do it below */
4807 } else {
4808 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
4809 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
4810 specified as required (when that support is added to
4811 the vfs in the future) as only NTLM or the much
4812 weaker LANMAN (which we do not send by default) is accepted
4813 by Samba (not sure whether other servers allow
4814 NTLMv2 password here) */
4815 #ifdef CONFIG_CIFS_WEAK_PW_HASH
4816 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
4817 (ses->sectype == LANMAN))
4818 calc_lanman_hash(tcon->password, ses->server->cryptkey,
4819 ses->server->sec_mode &
4820 SECMODE_PW_ENCRYPT ? true : false,
4821 bcc_ptr);
4822 else
4823 #endif /* CIFS_WEAK_PW_HASH */
4824 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
4825 bcc_ptr, nls_codepage);
4826 if (rc) {
4827 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
4828 __func__, rc);
4829 cifs_buf_release(smb_buffer);
4830 return rc;
4831 }
4832
4833 bcc_ptr += CIFS_AUTH_RESP_SIZE;
4834 if (ses->capabilities & CAP_UNICODE) {
4835 /* must align unicode strings */
4836 *bcc_ptr = 0; /* null byte password */
4837 bcc_ptr++;
4838 }
4839 }
4840
4841 if (ses->server->sign)
4842 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
4843
4844 if (ses->capabilities & CAP_STATUS32) {
4845 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
4846 }
4847 if (ses->capabilities & CAP_DFS) {
4848 smb_buffer->Flags2 |= SMBFLG2_DFS;
4849 }
4850 if (ses->capabilities & CAP_UNICODE) {
4851 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
4852 length =
4853 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
4854 6 /* max utf8 char length in bytes */ *
4855 (/* server len*/ + 256 /* share len */), nls_codepage);
4856 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
4857 bcc_ptr += 2; /* skip trailing null */
4858 } else { /* ASCII */
4859 strcpy(bcc_ptr, tree);
4860 bcc_ptr += strlen(tree) + 1;
4861 }
4862 strcpy(bcc_ptr, "?????");
4863 bcc_ptr += strlen("?????");
4864 bcc_ptr += 1;
4865 count = bcc_ptr - &pSMB->Password[0];
4866 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
4867 pSMB->hdr.smb_buf_length) + count);
4868 pSMB->ByteCount = cpu_to_le16(count);
4869
4870 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
4871 0);
4872
4873 /* above now done in SendReceive */
4874 if (rc == 0) {
4875 bool is_unicode;
4876
4877 tcon->tidStatus = CifsGood;
4878 tcon->need_reconnect = false;
4879 tcon->tid = smb_buffer_response->Tid;
4880 bcc_ptr = pByteArea(smb_buffer_response);
4881 bytes_left = get_bcc(smb_buffer_response);
4882 length = strnlen(bcc_ptr, bytes_left - 2);
4883 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
4884 is_unicode = true;
4885 else
4886 is_unicode = false;
4887
4888
4889 /* skip service field (NB: this field is always ASCII) */
4890 if (length == 3) {
4891 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
4892 (bcc_ptr[2] == 'C')) {
4893 cifs_dbg(FYI, "IPC connection\n");
4894 tcon->ipc = true;
4895 tcon->pipe = true;
4896 }
4897 } else if (length == 2) {
4898 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
4899 /* the most common case */
4900 cifs_dbg(FYI, "disk share connection\n");
4901 }
4902 }
4903 bcc_ptr += length + 1;
4904 bytes_left -= (length + 1);
4905 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
4906
4907 /* mostly informational -- no need to fail on error here */
4908 kfree(tcon->nativeFileSystem);
4909 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
4910 bytes_left, is_unicode,
4911 nls_codepage);
4912
4913 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
4914
4915 if ((smb_buffer_response->WordCount == 3) ||
4916 (smb_buffer_response->WordCount == 7))
4917 /* field is in same location */
4918 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
4919 else
4920 tcon->Flags = 0;
4921 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
4922 }
4923
4924 cifs_buf_release(smb_buffer);
4925 return rc;
4926 }
4927
4928 static void delayed_free(struct rcu_head *p)
4929 {
4930 struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
4931 unload_nls(sbi->local_nls);
4932 kfree(sbi);
4933 }
4934
4935 void
4936 cifs_umount(struct cifs_sb_info *cifs_sb)
4937 {
4938 struct rb_root *root = &cifs_sb->tlink_tree;
4939 struct rb_node *node;
4940 struct tcon_link *tlink;
4941
4942 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
4943
4944 spin_lock(&cifs_sb->tlink_tree_lock);
4945 while ((node = rb_first(root))) {
4946 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4947 cifs_get_tlink(tlink);
4948 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4949 rb_erase(node, root);
4950
4951 spin_unlock(&cifs_sb->tlink_tree_lock);
4952 cifs_put_tlink(tlink);
4953 spin_lock(&cifs_sb->tlink_tree_lock);
4954 }
4955 spin_unlock(&cifs_sb->tlink_tree_lock);
4956
4957 kfree(cifs_sb->mountdata);
4958 kfree(cifs_sb->prepath);
4959 #ifdef CONFIG_CIFS_DFS_UPCALL
4960 dfs_cache_del_vol(cifs_sb->origin_fullpath);
4961 kfree(cifs_sb->origin_fullpath);
4962 #endif
4963 call_rcu(&cifs_sb->rcu, delayed_free);
4964 }
4965
4966 int
4967 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
4968 {
4969 int rc = 0;
4970 struct TCP_Server_Info *server = ses->server;
4971
4972 if (!server->ops->need_neg || !server->ops->negotiate)
4973 return -ENOSYS;
4974
4975 /* only send once per connect */
4976 if (!server->ops->need_neg(server))
4977 return 0;
4978
4979 rc = server->ops->negotiate(xid, ses);
4980 if (rc == 0) {
4981 spin_lock(&GlobalMid_Lock);
4982 if (server->tcpStatus == CifsNeedNegotiate)
4983 server->tcpStatus = CifsGood;
4984 else
4985 rc = -EHOSTDOWN;
4986 spin_unlock(&GlobalMid_Lock);
4987 }
4988
4989 return rc;
4990 }
4991
4992 int
4993 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
4994 struct nls_table *nls_info)
4995 {
4996 int rc = -ENOSYS;
4997 struct TCP_Server_Info *server = ses->server;
4998
4999 ses->capabilities = server->capabilities;
5000 if (linuxExtEnabled == 0)
5001 ses->capabilities &= (~server->vals->cap_unix);
5002
5003 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
5004 server->sec_mode, server->capabilities, server->timeAdj);
5005
5006 if (ses->auth_key.response) {
5007 cifs_dbg(FYI, "Free previous auth_key.response = %p\n",
5008 ses->auth_key.response);
5009 kfree(ses->auth_key.response);
5010 ses->auth_key.response = NULL;
5011 ses->auth_key.len = 0;
5012 }
5013
5014 if (server->ops->sess_setup)
5015 rc = server->ops->sess_setup(xid, ses, nls_info);
5016
5017 if (rc)
5018 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
5019
5020 return rc;
5021 }
5022
5023 static int
5024 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
5025 {
5026 vol->sectype = ses->sectype;
5027
5028 /* krb5 is special, since we don't need username or pw */
5029 if (vol->sectype == Kerberos)
5030 return 0;
5031
5032 return cifs_set_cifscreds(vol, ses);
5033 }
5034
5035 static struct cifs_tcon *
5036 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
5037 {
5038 int rc;
5039 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
5040 struct cifs_ses *ses;
5041 struct cifs_tcon *tcon = NULL;
5042 struct smb_vol *vol_info;
5043
5044 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
5045 if (vol_info == NULL)
5046 return ERR_PTR(-ENOMEM);
5047
5048 vol_info->local_nls = cifs_sb->local_nls;
5049 vol_info->linux_uid = fsuid;
5050 vol_info->cred_uid = fsuid;
5051 vol_info->UNC = master_tcon->treeName;
5052 vol_info->retry = master_tcon->retry;
5053 vol_info->nocase = master_tcon->nocase;
5054 vol_info->nohandlecache = master_tcon->nohandlecache;
5055 vol_info->local_lease = master_tcon->local_lease;
5056 vol_info->no_linux_ext = !master_tcon->unix_ext;
5057 vol_info->sectype = master_tcon->ses->sectype;
5058 vol_info->sign = master_tcon->ses->sign;
5059
5060 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
5061 if (rc) {
5062 tcon = ERR_PTR(rc);
5063 goto out;
5064 }
5065
5066 /* get a reference for the same TCP session */
5067 spin_lock(&cifs_tcp_ses_lock);
5068 ++master_tcon->ses->server->srv_count;
5069 spin_unlock(&cifs_tcp_ses_lock);
5070
5071 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
5072 if (IS_ERR(ses)) {
5073 tcon = (struct cifs_tcon *)ses;
5074 cifs_put_tcp_session(master_tcon->ses->server, 0);
5075 goto out;
5076 }
5077
5078 tcon = cifs_get_tcon(ses, vol_info);
5079 if (IS_ERR(tcon)) {
5080 cifs_put_smb_ses(ses);
5081 goto out;
5082 }
5083
5084 /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
5085 if (tcon->posix_extensions)
5086 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
5087
5088 if (cap_unix(ses))
5089 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
5090
5091 out:
5092 kfree(vol_info->username);
5093 kzfree(vol_info->password);
5094 kfree(vol_info);
5095
5096 return tcon;
5097 }
5098
5099 struct cifs_tcon *
5100 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
5101 {
5102 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
5103 }
5104
5105 /* find and return a tlink with given uid */
5106 static struct tcon_link *
5107 tlink_rb_search(struct rb_root *root, kuid_t uid)
5108 {
5109 struct rb_node *node = root->rb_node;
5110 struct tcon_link *tlink;
5111
5112 while (node) {
5113 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
5114
5115 if (uid_gt(tlink->tl_uid, uid))
5116 node = node->rb_left;
5117 else if (uid_lt(tlink->tl_uid, uid))
5118 node = node->rb_right;
5119 else
5120 return tlink;
5121 }
5122 return NULL;
5123 }
5124
5125 /* insert a tcon_link into the tree */
5126 static void
5127 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
5128 {
5129 struct rb_node **new = &(root->rb_node), *parent = NULL;
5130 struct tcon_link *tlink;
5131
5132 while (*new) {
5133 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
5134 parent = *new;
5135
5136 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
5137 new = &((*new)->rb_left);
5138 else
5139 new = &((*new)->rb_right);
5140 }
5141
5142 rb_link_node(&new_tlink->tl_rbnode, parent, new);
5143 rb_insert_color(&new_tlink->tl_rbnode, root);
5144 }
5145
5146 /*
5147 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
5148 * current task.
5149 *
5150 * If the superblock doesn't refer to a multiuser mount, then just return
5151 * the master tcon for the mount.
5152 *
5153 * First, search the rbtree for an existing tcon for this fsuid. If one
5154 * exists, then check to see if it's pending construction. If it is then wait
5155 * for construction to complete. Once it's no longer pending, check to see if
5156 * it failed and either return an error or retry construction, depending on
5157 * the timeout.
5158 *
5159 * If one doesn't exist then insert a new tcon_link struct into the tree and
5160 * try to construct a new one.
5161 */
5162 struct tcon_link *
5163 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
5164 {
5165 int ret;
5166 kuid_t fsuid = current_fsuid();
5167 struct tcon_link *tlink, *newtlink;
5168
5169 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
5170 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
5171
5172 spin_lock(&cifs_sb->tlink_tree_lock);
5173 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
5174 if (tlink)
5175 cifs_get_tlink(tlink);
5176 spin_unlock(&cifs_sb->tlink_tree_lock);
5177
5178 if (tlink == NULL) {
5179 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
5180 if (newtlink == NULL)
5181 return ERR_PTR(-ENOMEM);
5182 newtlink->tl_uid = fsuid;
5183 newtlink->tl_tcon = ERR_PTR(-EACCES);
5184 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
5185 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
5186 cifs_get_tlink(newtlink);
5187
5188 spin_lock(&cifs_sb->tlink_tree_lock);
5189 /* was one inserted after previous search? */
5190 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
5191 if (tlink) {
5192 cifs_get_tlink(tlink);
5193 spin_unlock(&cifs_sb->tlink_tree_lock);
5194 kfree(newtlink);
5195 goto wait_for_construction;
5196 }
5197 tlink = newtlink;
5198 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
5199 spin_unlock(&cifs_sb->tlink_tree_lock);
5200 } else {
5201 wait_for_construction:
5202 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
5203 TASK_INTERRUPTIBLE);
5204 if (ret) {
5205 cifs_put_tlink(tlink);
5206 return ERR_PTR(-ERESTARTSYS);
5207 }
5208
5209 /* if it's good, return it */
5210 if (!IS_ERR(tlink->tl_tcon))
5211 return tlink;
5212
5213 /* return error if we tried this already recently */
5214 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
5215 cifs_put_tlink(tlink);
5216 return ERR_PTR(-EACCES);
5217 }
5218
5219 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
5220 goto wait_for_construction;
5221 }
5222
5223 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
5224 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
5225 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
5226
5227 if (IS_ERR(tlink->tl_tcon)) {
5228 cifs_put_tlink(tlink);
5229 return ERR_PTR(-EACCES);
5230 }
5231
5232 return tlink;
5233 }
5234
5235 /*
5236 * periodic workqueue job that scans tcon_tree for a superblock and closes
5237 * out tcons.
5238 */
5239 static void
5240 cifs_prune_tlinks(struct work_struct *work)
5241 {
5242 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
5243 prune_tlinks.work);
5244 struct rb_root *root = &cifs_sb->tlink_tree;
5245 struct rb_node *node;
5246 struct rb_node *tmp;
5247 struct tcon_link *tlink;
5248
5249 /*
5250 * Because we drop the spinlock in the loop in order to put the tlink
5251 * it's not guarded against removal of links from the tree. The only
5252 * places that remove entries from the tree are this function and
5253 * umounts. Because this function is non-reentrant and is canceled
5254 * before umount can proceed, this is safe.
5255 */
5256 spin_lock(&cifs_sb->tlink_tree_lock);
5257 node = rb_first(root);
5258 while (node != NULL) {
5259 tmp = node;
5260 node = rb_next(tmp);
5261 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
5262
5263 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
5264 atomic_read(&tlink->tl_count) != 0 ||
5265 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
5266 continue;
5267
5268 cifs_get_tlink(tlink);
5269 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
5270 rb_erase(tmp, root);
5271
5272 spin_unlock(&cifs_sb->tlink_tree_lock);
5273 cifs_put_tlink(tlink);
5274 spin_lock(&cifs_sb->tlink_tree_lock);
5275 }
5276 spin_unlock(&cifs_sb->tlink_tree_lock);
5277
5278 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
5279 TLINK_IDLE_EXPIRE);
5280 }
Mirror https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git