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