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