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