4 * Copyright (C) International Business Machines Corp., 2002,2011
5 * Author(s): Steve French (sfrench@us.ibm.com)
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.
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.
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
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>
45 #include <linux/parser.h>
46 #include <linux/bvec.h>
49 #include "cifsproto.h"
50 #include "cifs_unicode.h"
51 #include "cifs_debug.h"
52 #include "cifs_fs_sb.h"
55 #include "rfc1002pdu.h"
57 #include "smb2proto.h"
58 #include "smbdirect.h"
59 #include "dns_resolve.h"
61 #ifdef CONFIG_CIFS_DFS_UPCALL
62 #include "dfs_cache.h"
65 extern mempool_t *cifs_req_poolp;
66 extern bool disable_legacy_dialects;
68 /* FIXME: should these be tunable? */
69 #define TLINK_ERROR_EXPIRE (1 * HZ)
70 #define TLINK_IDLE_EXPIRE (600 * HZ)
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, Opt_nolease,
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,
85 Opt_handlecache, Opt_nohandlecache,
86 Opt_forcemandatorylock, Opt_setuidfromacl, Opt_setuids,
87 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
88 Opt_nohard, Opt_nosoft,
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_ignore_signature, 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, Opt_rootfs,
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,
107 Opt_blocksize, Opt_rsize, Opt_wsize, Opt_actimeo,
108 Opt_echo_interval, Opt_max_credits, Opt_handletimeout,
111 /* Mount options which take string value */
112 Opt_user, Opt_pass, Opt_ip,
113 Opt_domain, Opt_srcaddr, Opt_iocharset,
114 Opt_netbiosname, Opt_servern,
115 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
117 /* Mount options to be ignored */
120 /* Options which could be blank */
128 static const match_table_t cifs_mount_option_tokens = {
130 { Opt_user_xattr, "user_xattr" },
131 { Opt_nouser_xattr, "nouser_xattr" },
132 { Opt_forceuid, "forceuid" },
133 { Opt_noforceuid, "noforceuid" },
134 { Opt_forcegid, "forcegid" },
135 { Opt_noforcegid, "noforcegid" },
136 { Opt_noblocksend, "noblocksend" },
137 { Opt_noautotune, "noautotune" },
138 { Opt_nolease, "nolease" },
139 { Opt_hard, "hard" },
140 { Opt_soft, "soft" },
141 { Opt_perm, "perm" },
142 { Opt_noperm, "noperm" },
143 { Opt_mapchars, "mapchars" }, /* SFU style */
144 { Opt_nomapchars, "nomapchars" },
145 { Opt_mapposix, "mapposix" }, /* SFM style */
146 { Opt_nomapposix, "nomapposix" },
148 { Opt_nosfu, "nosfu" },
149 { Opt_nodfs, "nodfs" },
150 { Opt_posixpaths, "posixpaths" },
151 { Opt_noposixpaths, "noposixpaths" },
152 { Opt_nounix, "nounix" },
153 { Opt_nounix, "nolinux" },
154 { Opt_nounix, "noposix" },
155 { Opt_unix, "unix" },
156 { Opt_unix, "linux" },
157 { Opt_unix, "posix" },
158 { Opt_nocase, "nocase" },
159 { Opt_nocase, "ignorecase" },
161 { Opt_nobrl, "nobrl" },
162 { Opt_handlecache, "handlecache" },
163 { Opt_nohandlecache, "nohandlecache" },
164 { Opt_nobrl, "nolock" },
165 { Opt_forcemandatorylock, "forcemandatorylock" },
166 { Opt_forcemandatorylock, "forcemand" },
167 { Opt_setuids, "setuids" },
168 { Opt_nosetuids, "nosetuids" },
169 { Opt_setuidfromacl, "idsfromsid" },
170 { Opt_dynperm, "dynperm" },
171 { Opt_nodynperm, "nodynperm" },
172 { Opt_nohard, "nohard" },
173 { Opt_nosoft, "nosoft" },
174 { Opt_nointr, "nointr" },
175 { Opt_intr, "intr" },
176 { Opt_nostrictsync, "nostrictsync" },
177 { Opt_strictsync, "strictsync" },
178 { Opt_serverino, "serverino" },
179 { Opt_noserverino, "noserverino" },
180 { Opt_rwpidforward, "rwpidforward" },
181 { Opt_modesid, "modefromsid" },
182 { Opt_cifsacl, "cifsacl" },
183 { Opt_nocifsacl, "nocifsacl" },
185 { Opt_noacl, "noacl" },
186 { Opt_locallease, "locallease" },
187 { Opt_sign, "sign" },
188 { Opt_ignore_signature, "signloosely" },
189 { Opt_seal, "seal" },
190 { Opt_noac, "noac" },
192 { Opt_mfsymlinks, "mfsymlinks" },
193 { Opt_multiuser, "multiuser" },
194 { Opt_sloppy, "sloppy" },
195 { Opt_nosharesock, "nosharesock" },
196 { Opt_persistent, "persistenthandles"},
197 { Opt_nopersistent, "nopersistenthandles"},
198 { Opt_resilient, "resilienthandles"},
199 { Opt_noresilient, "noresilienthandles"},
200 { Opt_domainauto, "domainauto"},
203 { Opt_backupuid, "backupuid=%s" },
204 { Opt_backupgid, "backupgid=%s" },
205 { Opt_uid, "uid=%s" },
206 { Opt_cruid, "cruid=%s" },
207 { Opt_gid, "gid=%s" },
208 { Opt_file_mode, "file_mode=%s" },
209 { Opt_dirmode, "dirmode=%s" },
210 { Opt_dirmode, "dir_mode=%s" },
211 { Opt_port, "port=%s" },
212 { Opt_min_enc_offload, "esize=%s" },
213 { Opt_blocksize, "bsize=%s" },
214 { Opt_rsize, "rsize=%s" },
215 { Opt_wsize, "wsize=%s" },
216 { Opt_actimeo, "actimeo=%s" },
217 { Opt_handletimeout, "handletimeout=%s" },
218 { Opt_echo_interval, "echo_interval=%s" },
219 { Opt_max_credits, "max_credits=%s" },
220 { Opt_snapshot, "snapshot=%s" },
221 { Opt_compress, "compress=%s" },
223 { Opt_blank_user, "user=" },
224 { Opt_blank_user, "username=" },
225 { Opt_user, "user=%s" },
226 { Opt_user, "username=%s" },
227 { Opt_blank_pass, "pass=" },
228 { Opt_blank_pass, "password=" },
229 { Opt_pass, "pass=%s" },
230 { Opt_pass, "password=%s" },
231 { Opt_blank_ip, "ip=" },
232 { Opt_blank_ip, "addr=" },
234 { Opt_ip, "addr=%s" },
235 { Opt_ignore, "unc=%s" },
236 { Opt_ignore, "target=%s" },
237 { Opt_ignore, "path=%s" },
238 { Opt_domain, "dom=%s" },
239 { Opt_domain, "domain=%s" },
240 { Opt_domain, "workgroup=%s" },
241 { Opt_srcaddr, "srcaddr=%s" },
242 { Opt_ignore, "prefixpath=%s" },
243 { Opt_iocharset, "iocharset=%s" },
244 { Opt_netbiosname, "netbiosname=%s" },
245 { Opt_servern, "servern=%s" },
246 { Opt_ver, "ver=%s" },
247 { Opt_vers, "vers=%s" },
248 { Opt_sec, "sec=%s" },
249 { Opt_cache, "cache=%s" },
251 { Opt_ignore, "cred" },
252 { Opt_ignore, "credentials" },
253 { Opt_ignore, "cred=%s" },
254 { Opt_ignore, "credentials=%s" },
255 { Opt_ignore, "guest" },
256 { Opt_ignore, "rw" },
257 { Opt_ignore, "ro" },
258 { Opt_ignore, "suid" },
259 { Opt_ignore, "nosuid" },
260 { Opt_ignore, "exec" },
261 { Opt_ignore, "noexec" },
262 { Opt_ignore, "nodev" },
263 { Opt_ignore, "noauto" },
264 { Opt_ignore, "dev" },
265 { Opt_ignore, "mand" },
266 { Opt_ignore, "nomand" },
267 { Opt_ignore, "relatime" },
268 { Opt_ignore, "_netdev" },
269 { Opt_rootfs, "rootfs" },
275 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
276 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
277 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
278 Opt_sec_ntlmv2i, Opt_sec_lanman,
284 static const match_table_t cifs_secflavor_tokens = {
285 { Opt_sec_krb5, "krb5" },
286 { Opt_sec_krb5i, "krb5i" },
287 { Opt_sec_krb5p, "krb5p" },
288 { Opt_sec_ntlmsspi, "ntlmsspi" },
289 { Opt_sec_ntlmssp, "ntlmssp" },
290 { Opt_ntlm, "ntlm" },
291 { Opt_sec_ntlmi, "ntlmi" },
292 { Opt_sec_ntlmv2, "nontlm" },
293 { Opt_sec_ntlmv2, "ntlmv2" },
294 { Opt_sec_ntlmv2i, "ntlmv2i" },
295 { Opt_sec_lanman, "lanman" },
296 { Opt_sec_none, "none" },
298 { Opt_sec_err, NULL }
311 static const match_table_t cifs_cacheflavor_tokens = {
312 { Opt_cache_loose, "loose" },
313 { Opt_cache_strict, "strict" },
314 { Opt_cache_none, "none" },
315 { Opt_cache_ro, "ro" },
316 { Opt_cache_rw, "singleclient" },
317 { Opt_cache_err, NULL }
320 static const match_table_t cifs_smb_version_tokens = {
321 { Smb_1, SMB1_VERSION_STRING },
322 { Smb_20, SMB20_VERSION_STRING},
323 { Smb_21, SMB21_VERSION_STRING },
324 { Smb_30, SMB30_VERSION_STRING },
325 { Smb_302, SMB302_VERSION_STRING },
326 { Smb_302, ALT_SMB302_VERSION_STRING },
327 { Smb_311, SMB311_VERSION_STRING },
328 { Smb_311, ALT_SMB311_VERSION_STRING },
329 { Smb_3any, SMB3ANY_VERSION_STRING },
330 { Smb_default, SMBDEFAULT_VERSION_STRING },
331 { Smb_version_err, NULL }
334 static int ip_connect(struct TCP_Server_Info *server);
335 static int generic_ip_connect(struct TCP_Server_Info *server);
336 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
337 static void cifs_prune_tlinks(struct work_struct *work);
338 static char *extract_hostname(const char *unc);
341 * Resolve hostname and set ip addr in tcp ses. Useful for hostnames that may
342 * get their ip addresses changed at some point.
344 * This should be called with server->srv_mutex held.
346 #ifdef CONFIG_CIFS_DFS_UPCALL
347 static int reconn_set_ipaddr(struct TCP_Server_Info *server)
351 char *unc, *ipaddr = NULL;
353 if (!server->hostname)
356 len = strlen(server->hostname) + 3;
358 unc = kmalloc(len, GFP_KERNEL);
360 cifs_dbg(FYI, "%s: failed to create UNC path\n", __func__);
363 scnprintf(unc, len, "\\\\%s", server->hostname);
365 rc = dns_resolve_server_name_to_ip(unc, &ipaddr);
369 cifs_dbg(FYI, "%s: failed to resolve server part of %s to IP: %d\n",
370 __func__, server->hostname, rc);
374 spin_lock(&cifs_tcp_ses_lock);
375 rc = cifs_convert_address((struct sockaddr *)&server->dstaddr, ipaddr,
377 spin_unlock(&cifs_tcp_ses_lock);
383 static inline int reconn_set_ipaddr(struct TCP_Server_Info *server)
389 #ifdef CONFIG_CIFS_DFS_UPCALL
390 struct super_cb_data {
391 struct TCP_Server_Info *server;
392 struct super_block *sb;
395 /* These functions must be called with server->srv_mutex held */
397 static void super_cb(struct super_block *sb, void *arg)
399 struct super_cb_data *d = arg;
400 struct cifs_sb_info *cifs_sb;
401 struct cifs_tcon *tcon;
406 cifs_sb = CIFS_SB(sb);
407 tcon = cifs_sb_master_tcon(cifs_sb);
408 if (tcon->ses->server == d->server)
412 static struct super_block *get_tcp_super(struct TCP_Server_Info *server)
414 struct super_cb_data d = {
419 iterate_supers_type(&cifs_fs_type, super_cb, &d);
422 return ERR_PTR(-ENOENT);
424 * Grab an active reference in order to prevent automounts (DFS links)
425 * of expiring and then freeing up our cifs superblock pointer while
426 * we're doing failover.
428 cifs_sb_active(d.sb);
432 static inline void put_tcp_super(struct super_block *sb)
434 if (!IS_ERR_OR_NULL(sb))
435 cifs_sb_deactive(sb);
438 static void reconn_inval_dfs_target(struct TCP_Server_Info *server,
439 struct cifs_sb_info *cifs_sb,
440 struct dfs_cache_tgt_list *tgt_list,
441 struct dfs_cache_tgt_iterator **tgt_it)
445 if (!cifs_sb || !cifs_sb->origin_fullpath || !tgt_list ||
450 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
452 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
454 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
457 cifs_dbg(FYI, "%s: UNC: %s\n", __func__, cifs_sb->origin_fullpath);
459 name = dfs_cache_get_tgt_name(*tgt_it);
461 kfree(server->hostname);
463 server->hostname = extract_hostname(name);
464 if (IS_ERR(server->hostname)) {
466 "%s: failed to extract hostname from target: %ld\n",
467 __func__, PTR_ERR(server->hostname));
471 static inline int reconn_setup_dfs_targets(struct cifs_sb_info *cifs_sb,
472 struct dfs_cache_tgt_list *tl)
474 if (!cifs_sb->origin_fullpath)
476 return dfs_cache_noreq_find(cifs_sb->origin_fullpath + 1, NULL, tl);
481 * cifs tcp session reconnection
483 * mark tcp session as reconnecting so temporarily locked
484 * mark all smb sessions as reconnecting for tcp session
485 * reconnect tcp session
486 * wake up waiters on reconnection? - (not needed currently)
489 cifs_reconnect(struct TCP_Server_Info *server)
492 struct list_head *tmp, *tmp2;
493 struct cifs_ses *ses;
494 struct cifs_tcon *tcon;
495 struct mid_q_entry *mid_entry;
496 struct list_head retry_list;
497 #ifdef CONFIG_CIFS_DFS_UPCALL
498 struct super_block *sb = NULL;
499 struct cifs_sb_info *cifs_sb = NULL;
500 struct dfs_cache_tgt_list tgt_list = {0};
501 struct dfs_cache_tgt_iterator *tgt_it = NULL;
504 spin_lock(&GlobalMid_Lock);
505 server->nr_targets = 1;
506 #ifdef CONFIG_CIFS_DFS_UPCALL
507 spin_unlock(&GlobalMid_Lock);
508 sb = get_tcp_super(server);
511 cifs_dbg(FYI, "%s: will not do DFS failover: rc = %d\n",
515 cifs_sb = CIFS_SB(sb);
516 rc = reconn_setup_dfs_targets(cifs_sb, &tgt_list);
519 if (rc != -EOPNOTSUPP) {
520 cifs_server_dbg(VFS, "%s: no target servers for DFS failover\n",
524 server->nr_targets = dfs_cache_get_nr_tgts(&tgt_list);
527 cifs_dbg(FYI, "%s: will retry %d target(s)\n", __func__,
529 spin_lock(&GlobalMid_Lock);
531 if (server->tcpStatus == CifsExiting) {
532 /* the demux thread will exit normally
533 next time through the loop */
534 spin_unlock(&GlobalMid_Lock);
535 #ifdef CONFIG_CIFS_DFS_UPCALL
536 dfs_cache_free_tgts(&tgt_list);
541 server->tcpStatus = CifsNeedReconnect;
542 spin_unlock(&GlobalMid_Lock);
544 server->max_read = 0;
546 cifs_dbg(FYI, "Mark tcp session as need reconnect\n");
547 trace_smb3_reconnect(server->CurrentMid, server->hostname);
549 /* before reconnecting the tcp session, mark the smb session (uid)
550 and the tid bad so they are not used until reconnected */
551 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
553 spin_lock(&cifs_tcp_ses_lock);
554 list_for_each(tmp, &server->smb_ses_list) {
555 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
556 ses->need_reconnect = true;
557 list_for_each(tmp2, &ses->tcon_list) {
558 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
559 tcon->need_reconnect = true;
562 ses->tcon_ipc->need_reconnect = true;
564 spin_unlock(&cifs_tcp_ses_lock);
566 /* do not want to be sending data on a socket we are freeing */
567 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
568 mutex_lock(&server->srv_mutex);
569 if (server->ssocket) {
570 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
571 server->ssocket->state, server->ssocket->flags);
572 kernel_sock_shutdown(server->ssocket, SHUT_WR);
573 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
574 server->ssocket->state, server->ssocket->flags);
575 sock_release(server->ssocket);
576 server->ssocket = NULL;
578 server->sequence_number = 0;
579 server->session_estab = false;
580 kfree(server->session_key.response);
581 server->session_key.response = NULL;
582 server->session_key.len = 0;
583 server->lstrp = jiffies;
585 /* mark submitted MIDs for retry and issue callback */
586 INIT_LIST_HEAD(&retry_list);
587 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
588 spin_lock(&GlobalMid_Lock);
589 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
590 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
591 kref_get(&mid_entry->refcount);
592 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
593 mid_entry->mid_state = MID_RETRY_NEEDED;
594 list_move(&mid_entry->qhead, &retry_list);
595 mid_entry->mid_flags |= MID_DELETED;
597 spin_unlock(&GlobalMid_Lock);
598 mutex_unlock(&server->srv_mutex);
600 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
601 list_for_each_safe(tmp, tmp2, &retry_list) {
602 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
603 list_del_init(&mid_entry->qhead);
604 mid_entry->callback(mid_entry);
605 cifs_mid_q_entry_release(mid_entry);
608 if (cifs_rdma_enabled(server)) {
609 mutex_lock(&server->srv_mutex);
610 smbd_destroy(server);
611 mutex_unlock(&server->srv_mutex);
617 mutex_lock(&server->srv_mutex);
618 #ifdef CONFIG_CIFS_DFS_UPCALL
620 * Set up next DFS target server (if any) for reconnect. If DFS
621 * feature is disabled, then we will retry last server we
622 * connected to before.
624 reconn_inval_dfs_target(server, cifs_sb, &tgt_list, &tgt_it);
626 rc = reconn_set_ipaddr(server);
628 cifs_dbg(FYI, "%s: failed to resolve hostname: %d\n",
632 if (cifs_rdma_enabled(server))
633 rc = smbd_reconnect(server);
635 rc = generic_ip_connect(server);
637 cifs_dbg(FYI, "reconnect error %d\n", rc);
638 mutex_unlock(&server->srv_mutex);
641 atomic_inc(&tcpSesReconnectCount);
642 set_credits(server, 1);
643 spin_lock(&GlobalMid_Lock);
644 if (server->tcpStatus != CifsExiting)
645 server->tcpStatus = CifsNeedNegotiate;
646 spin_unlock(&GlobalMid_Lock);
647 mutex_unlock(&server->srv_mutex);
649 } while (server->tcpStatus == CifsNeedReconnect);
651 #ifdef CONFIG_CIFS_DFS_UPCALL
653 rc = dfs_cache_noreq_update_tgthint(cifs_sb->origin_fullpath + 1,
656 cifs_server_dbg(VFS, "%s: failed to update DFS target hint: rc = %d\n",
659 rc = dfs_cache_update_vol(cifs_sb->origin_fullpath, server);
661 cifs_server_dbg(VFS, "%s: failed to update vol info in DFS cache: rc = %d\n",
664 dfs_cache_free_tgts(&tgt_list);
670 if (server->tcpStatus == CifsNeedNegotiate)
671 mod_delayed_work(cifsiod_wq, &server->echo, 0);
677 cifs_echo_request(struct work_struct *work)
680 struct TCP_Server_Info *server = container_of(work,
681 struct TCP_Server_Info, echo.work);
682 unsigned long echo_interval;
685 * If we need to renegotiate, set echo interval to zero to
686 * immediately call echo service where we can renegotiate.
688 if (server->tcpStatus == CifsNeedNegotiate)
691 echo_interval = server->echo_interval;
694 * We cannot send an echo if it is disabled.
695 * Also, no need to ping if we got a response recently.
698 if (server->tcpStatus == CifsNeedReconnect ||
699 server->tcpStatus == CifsExiting ||
700 server->tcpStatus == CifsNew ||
701 (server->ops->can_echo && !server->ops->can_echo(server)) ||
702 time_before(jiffies, server->lstrp + echo_interval - HZ))
705 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
707 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
711 queue_delayed_work(cifsiod_wq, &server->echo, server->echo_interval);
715 allocate_buffers(struct TCP_Server_Info *server)
717 if (!server->bigbuf) {
718 server->bigbuf = (char *)cifs_buf_get();
719 if (!server->bigbuf) {
720 cifs_server_dbg(VFS, "No memory for large SMB response\n");
722 /* retry will check if exiting */
725 } else if (server->large_buf) {
726 /* we are reusing a dirty large buf, clear its start */
727 memset(server->bigbuf, 0, HEADER_SIZE(server));
730 if (!server->smallbuf) {
731 server->smallbuf = (char *)cifs_small_buf_get();
732 if (!server->smallbuf) {
733 cifs_server_dbg(VFS, "No memory for SMB response\n");
735 /* retry will check if exiting */
738 /* beginning of smb buffer is cleared in our buf_get */
740 /* if existing small buf clear beginning */
741 memset(server->smallbuf, 0, HEADER_SIZE(server));
748 server_unresponsive(struct TCP_Server_Info *server)
751 * We need to wait 3 echo intervals to make sure we handle such
753 * 1s client sends a normal SMB request
754 * 2s client gets a response
755 * 30s echo workqueue job pops, and decides we got a response recently
756 * and don't need to send another
758 * 65s kernel_recvmsg times out, and we see that we haven't gotten
759 * a response in >60s.
761 if ((server->tcpStatus == CifsGood ||
762 server->tcpStatus == CifsNeedNegotiate) &&
763 time_after(jiffies, server->lstrp + 3 * server->echo_interval)) {
764 cifs_server_dbg(VFS, "has not responded in %lu seconds. Reconnecting...\n",
765 (3 * server->echo_interval) / HZ);
766 cifs_reconnect(server);
767 wake_up(&server->response_q);
775 zero_credits(struct TCP_Server_Info *server)
779 spin_lock(&server->req_lock);
780 val = server->credits + server->echo_credits + server->oplock_credits;
781 if (server->in_flight == 0 && val == 0) {
782 spin_unlock(&server->req_lock);
785 spin_unlock(&server->req_lock);
790 cifs_readv_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg)
795 for (total_read = 0; msg_data_left(smb_msg); total_read += length) {
798 /* reconnect if no credits and no requests in flight */
799 if (zero_credits(server)) {
800 cifs_reconnect(server);
801 return -ECONNABORTED;
804 if (server_unresponsive(server))
805 return -ECONNABORTED;
806 if (cifs_rdma_enabled(server) && server->smbd_conn)
807 length = smbd_recv(server->smbd_conn, smb_msg);
809 length = sock_recvmsg(server->ssocket, smb_msg, 0);
811 if (server->tcpStatus == CifsExiting)
814 if (server->tcpStatus == CifsNeedReconnect) {
815 cifs_reconnect(server);
816 return -ECONNABORTED;
819 if (length == -ERESTARTSYS ||
823 * Minimum sleep to prevent looping, allowing socket
824 * to clear and app threads to set tcpStatus
825 * CifsNeedReconnect if server hung.
827 usleep_range(1000, 2000);
833 cifs_dbg(FYI, "Received no data or error: %d\n", length);
834 cifs_reconnect(server);
835 return -ECONNABORTED;
842 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
843 unsigned int to_read)
845 struct msghdr smb_msg = {};
846 struct kvec iov = {.iov_base = buf, .iov_len = to_read};
847 iov_iter_kvec(&smb_msg.msg_iter, READ, &iov, 1, to_read);
849 return cifs_readv_from_socket(server, &smb_msg);
853 cifs_read_page_from_socket(struct TCP_Server_Info *server, struct page *page,
854 unsigned int page_offset, unsigned int to_read)
856 struct msghdr smb_msg = {};
857 struct bio_vec bv = {
858 .bv_page = page, .bv_len = to_read, .bv_offset = page_offset};
859 iov_iter_bvec(&smb_msg.msg_iter, READ, &bv, 1, to_read);
860 return cifs_readv_from_socket(server, &smb_msg);
864 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
867 * The first byte big endian of the length field,
868 * is actually not part of the length but the type
869 * with the most common, zero, as regular data.
872 case RFC1002_SESSION_MESSAGE:
873 /* Regular SMB response */
875 case RFC1002_SESSION_KEEP_ALIVE:
876 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
878 case RFC1002_POSITIVE_SESSION_RESPONSE:
879 cifs_dbg(FYI, "RFC 1002 positive session response\n");
881 case RFC1002_NEGATIVE_SESSION_RESPONSE:
883 * We get this from Windows 98 instead of an error on
884 * SMB negprot response.
886 cifs_dbg(FYI, "RFC 1002 negative session response\n");
887 /* give server a second to clean up */
890 * Always try 445 first on reconnect since we get NACK
891 * on some if we ever connected to port 139 (the NACK
892 * is since we do not begin with RFC1001 session
895 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
896 cifs_reconnect(server);
897 wake_up(&server->response_q);
900 cifs_server_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
901 cifs_reconnect(server);
908 dequeue_mid(struct mid_q_entry *mid, bool malformed)
910 #ifdef CONFIG_CIFS_STATS2
911 mid->when_received = jiffies;
913 spin_lock(&GlobalMid_Lock);
915 mid->mid_state = MID_RESPONSE_RECEIVED;
917 mid->mid_state = MID_RESPONSE_MALFORMED;
919 * Trying to handle/dequeue a mid after the send_recv()
920 * function has finished processing it is a bug.
922 if (mid->mid_flags & MID_DELETED)
923 printk_once(KERN_WARNING
924 "trying to dequeue a deleted mid\n");
926 list_del_init(&mid->qhead);
927 mid->mid_flags |= MID_DELETED;
929 spin_unlock(&GlobalMid_Lock);
933 smb2_get_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)
935 struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buffer;
938 * SMB1 does not use credits.
940 if (server->vals->header_preamble_size)
943 return le16_to_cpu(shdr->CreditRequest);
947 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
948 char *buf, int malformed)
950 if (server->ops->check_trans2 &&
951 server->ops->check_trans2(mid, server, buf, malformed))
953 mid->credits_received = smb2_get_credits_from_hdr(buf, server);
955 mid->large_buf = server->large_buf;
956 /* Was previous buf put in mpx struct for multi-rsp? */
957 if (!mid->multiRsp) {
958 /* smb buffer will be freed by user thread */
959 if (server->large_buf)
960 server->bigbuf = NULL;
962 server->smallbuf = NULL;
964 dequeue_mid(mid, malformed);
967 static void clean_demultiplex_info(struct TCP_Server_Info *server)
971 /* take it off the list, if it's not already */
972 spin_lock(&cifs_tcp_ses_lock);
973 list_del_init(&server->tcp_ses_list);
974 spin_unlock(&cifs_tcp_ses_lock);
976 cancel_delayed_work_sync(&server->echo);
978 spin_lock(&GlobalMid_Lock);
979 server->tcpStatus = CifsExiting;
980 spin_unlock(&GlobalMid_Lock);
981 wake_up_all(&server->response_q);
983 /* check if we have blocked requests that need to free */
984 spin_lock(&server->req_lock);
985 if (server->credits <= 0)
987 spin_unlock(&server->req_lock);
989 * Although there should not be any requests blocked on this queue it
990 * can not hurt to be paranoid and try to wake up requests that may
991 * haven been blocked when more than 50 at time were on the wire to the
992 * same server - they now will see the session is in exit state and get
993 * out of SendReceive.
995 wake_up_all(&server->request_q);
996 /* give those requests time to exit */
998 if (cifs_rdma_enabled(server))
999 smbd_destroy(server);
1000 if (server->ssocket) {
1001 sock_release(server->ssocket);
1002 server->ssocket = NULL;
1005 if (!list_empty(&server->pending_mid_q)) {
1006 struct list_head dispose_list;
1007 struct mid_q_entry *mid_entry;
1008 struct list_head *tmp, *tmp2;
1010 INIT_LIST_HEAD(&dispose_list);
1011 spin_lock(&GlobalMid_Lock);
1012 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
1013 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
1014 cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
1015 kref_get(&mid_entry->refcount);
1016 mid_entry->mid_state = MID_SHUTDOWN;
1017 list_move(&mid_entry->qhead, &dispose_list);
1018 mid_entry->mid_flags |= MID_DELETED;
1020 spin_unlock(&GlobalMid_Lock);
1022 /* now walk dispose list and issue callbacks */
1023 list_for_each_safe(tmp, tmp2, &dispose_list) {
1024 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
1025 cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
1026 list_del_init(&mid_entry->qhead);
1027 mid_entry->callback(mid_entry);
1028 cifs_mid_q_entry_release(mid_entry);
1030 /* 1/8th of sec is more than enough time for them to exit */
1034 if (!list_empty(&server->pending_mid_q)) {
1036 * mpx threads have not exited yet give them at least the smb
1037 * send timeout time for long ops.
1039 * Due to delays on oplock break requests, we need to wait at
1040 * least 45 seconds before giving up on a request getting a
1041 * response and going ahead and killing cifsd.
1043 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
1046 * If threads still have not exited they are probably never
1047 * coming home not much else we can do but free the memory.
1051 kfree(server->hostname);
1054 length = atomic_dec_return(&tcpSesAllocCount);
1056 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
1060 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1063 char *buf = server->smallbuf;
1064 unsigned int pdu_length = server->pdu_size;
1066 /* make sure this will fit in a large buffer */
1067 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) -
1068 server->vals->header_preamble_size) {
1069 cifs_server_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
1070 cifs_reconnect(server);
1071 wake_up(&server->response_q);
1072 return -ECONNABORTED;
1075 /* switch to large buffer if too big for a small one */
1076 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
1077 server->large_buf = true;
1078 memcpy(server->bigbuf, buf, server->total_read);
1079 buf = server->bigbuf;
1082 /* now read the rest */
1083 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
1084 pdu_length - HEADER_SIZE(server) + 1
1085 + server->vals->header_preamble_size);
1089 server->total_read += length;
1091 dump_smb(buf, server->total_read);
1093 return cifs_handle_standard(server, mid);
1097 cifs_handle_standard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1099 char *buf = server->large_buf ? server->bigbuf : server->smallbuf;
1103 * We know that we received enough to get to the MID as we
1104 * checked the pdu_length earlier. Now check to see
1105 * if the rest of the header is OK. We borrow the length
1106 * var for the rest of the loop to avoid a new stack var.
1108 * 48 bytes is enough to display the header and a little bit
1109 * into the payload for debugging purposes.
1111 length = server->ops->check_message(buf, server->total_read, server);
1113 cifs_dump_mem("Bad SMB: ", buf,
1114 min_t(unsigned int, server->total_read, 48));
1116 if (server->ops->is_session_expired &&
1117 server->ops->is_session_expired(buf)) {
1118 cifs_reconnect(server);
1119 wake_up(&server->response_q);
1123 if (server->ops->is_status_pending &&
1124 server->ops->is_status_pending(buf, server))
1130 handle_mid(mid, server, buf, length);
1135 smb2_add_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)
1137 struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buffer;
1140 * SMB1 does not use credits.
1142 if (server->vals->header_preamble_size)
1145 if (shdr->CreditRequest) {
1146 spin_lock(&server->req_lock);
1147 server->credits += le16_to_cpu(shdr->CreditRequest);
1148 spin_unlock(&server->req_lock);
1149 wake_up(&server->request_q);
1155 cifs_demultiplex_thread(void *p)
1157 int i, num_mids, length;
1158 struct TCP_Server_Info *server = p;
1159 unsigned int pdu_length;
1160 unsigned int next_offset;
1162 struct task_struct *task_to_wake = NULL;
1163 struct mid_q_entry *mids[MAX_COMPOUND];
1164 char *bufs[MAX_COMPOUND];
1166 current->flags |= PF_MEMALLOC;
1167 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
1169 length = atomic_inc_return(&tcpSesAllocCount);
1171 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
1174 allow_kernel_signal(SIGKILL);
1175 while (server->tcpStatus != CifsExiting) {
1176 if (try_to_freeze())
1179 if (!allocate_buffers(server))
1182 server->large_buf = false;
1183 buf = server->smallbuf;
1184 pdu_length = 4; /* enough to get RFC1001 header */
1186 length = cifs_read_from_socket(server, buf, pdu_length);
1190 if (server->vals->header_preamble_size == 0)
1191 server->total_read = 0;
1193 server->total_read = length;
1196 * The right amount was read from socket - 4 bytes,
1197 * so we can now interpret the length field.
1199 pdu_length = get_rfc1002_length(buf);
1201 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
1202 if (!is_smb_response(server, buf[0]))
1205 server->pdu_size = pdu_length;
1207 /* make sure we have enough to get to the MID */
1208 if (server->pdu_size < HEADER_SIZE(server) - 1 -
1209 server->vals->header_preamble_size) {
1210 cifs_server_dbg(VFS, "SMB response too short (%u bytes)\n",
1212 cifs_reconnect(server);
1213 wake_up(&server->response_q);
1217 /* read down to the MID */
1218 length = cifs_read_from_socket(server,
1219 buf + server->vals->header_preamble_size,
1220 HEADER_SIZE(server) - 1
1221 - server->vals->header_preamble_size);
1224 server->total_read += length;
1226 if (server->ops->next_header) {
1227 next_offset = server->ops->next_header(buf);
1229 server->pdu_size = next_offset;
1232 memset(mids, 0, sizeof(mids));
1233 memset(bufs, 0, sizeof(bufs));
1236 if (server->ops->is_transform_hdr &&
1237 server->ops->receive_transform &&
1238 server->ops->is_transform_hdr(buf)) {
1239 length = server->ops->receive_transform(server,
1244 mids[0] = server->ops->find_mid(server, buf);
1248 if (!mids[0] || !mids[0]->receive)
1249 length = standard_receive3(server, mids[0]);
1251 length = mids[0]->receive(server, mids[0]);
1255 for (i = 0; i < num_mids; i++)
1257 cifs_mid_q_entry_release(mids[i]);
1261 server->lstrp = jiffies;
1263 for (i = 0; i < num_mids; i++) {
1264 if (mids[i] != NULL) {
1265 mids[i]->resp_buf_size = server->pdu_size;
1267 if (!mids[i]->multiRsp || mids[i]->multiEnd)
1268 mids[i]->callback(mids[i]);
1270 cifs_mid_q_entry_release(mids[i]);
1271 } else if (server->ops->is_oplock_break &&
1272 server->ops->is_oplock_break(bufs[i],
1274 smb2_add_credits_from_hdr(bufs[i], server);
1275 cifs_dbg(FYI, "Received oplock break\n");
1277 cifs_server_dbg(VFS, "No task to wake, unknown frame "
1278 "received! NumMids %d\n",
1279 atomic_read(&midCount));
1280 cifs_dump_mem("Received Data is: ", bufs[i],
1281 HEADER_SIZE(server));
1282 smb2_add_credits_from_hdr(bufs[i], server);
1283 #ifdef CONFIG_CIFS_DEBUG2
1284 if (server->ops->dump_detail)
1285 server->ops->dump_detail(bufs[i],
1287 cifs_dump_mids(server);
1288 #endif /* CIFS_DEBUG2 */
1292 if (pdu_length > server->pdu_size) {
1293 if (!allocate_buffers(server))
1295 pdu_length -= server->pdu_size;
1296 server->total_read = 0;
1297 server->large_buf = false;
1298 buf = server->smallbuf;
1301 } /* end while !EXITING */
1303 /* buffer usually freed in free_mid - need to free it here on exit */
1304 cifs_buf_release(server->bigbuf);
1305 if (server->smallbuf) /* no sense logging a debug message if NULL */
1306 cifs_small_buf_release(server->smallbuf);
1308 task_to_wake = xchg(&server->tsk, NULL);
1309 clean_demultiplex_info(server);
1311 /* if server->tsk was NULL then wait for a signal before exiting */
1312 if (!task_to_wake) {
1313 set_current_state(TASK_INTERRUPTIBLE);
1314 while (!signal_pending(current)) {
1316 set_current_state(TASK_INTERRUPTIBLE);
1318 set_current_state(TASK_RUNNING);
1321 module_put_and_exit(0);
1324 /* extract the host portion of the UNC string */
1326 extract_hostname(const char *unc)
1332 /* skip double chars at beginning of string */
1333 /* BB: check validity of these bytes? */
1334 if (strlen(unc) < 3)
1335 return ERR_PTR(-EINVAL);
1336 for (src = unc; *src && *src == '\\'; src++)
1339 return ERR_PTR(-EINVAL);
1341 /* delimiter between hostname and sharename is always '\\' now */
1342 delim = strchr(src, '\\');
1344 return ERR_PTR(-EINVAL);
1347 dst = kmalloc((len + 1), GFP_KERNEL);
1349 return ERR_PTR(-ENOMEM);
1351 memcpy(dst, src, len);
1357 static int get_option_ul(substring_t args[], unsigned long *option)
1362 string = match_strdup(args);
1365 rc = kstrtoul(string, 0, option);
1371 static int get_option_uid(substring_t args[], kuid_t *result)
1373 unsigned long value;
1377 rc = get_option_ul(args, &value);
1381 uid = make_kuid(current_user_ns(), value);
1382 if (!uid_valid(uid))
1389 static int get_option_gid(substring_t args[], kgid_t *result)
1391 unsigned long value;
1395 rc = get_option_ul(args, &value);
1399 gid = make_kgid(current_user_ns(), value);
1400 if (!gid_valid(gid))
1407 static int cifs_parse_security_flavors(char *value,
1408 struct smb_vol *vol)
1411 substring_t args[MAX_OPT_ARGS];
1414 * With mount options, the last one should win. Reset any existing
1415 * settings back to default.
1417 vol->sectype = Unspecified;
1420 switch (match_token(value, cifs_secflavor_tokens, args)) {
1422 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
1428 vol->sectype = Kerberos;
1430 case Opt_sec_ntlmsspi:
1433 case Opt_sec_ntlmssp:
1434 vol->sectype = RawNTLMSSP;
1440 vol->sectype = NTLM;
1442 case Opt_sec_ntlmv2i:
1445 case Opt_sec_ntlmv2:
1446 vol->sectype = NTLMv2;
1448 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1449 case Opt_sec_lanman:
1450 vol->sectype = LANMAN;
1457 cifs_dbg(VFS, "bad security option: %s\n", value);
1465 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1467 substring_t args[MAX_OPT_ARGS];
1469 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1470 case Opt_cache_loose:
1471 vol->direct_io = false;
1472 vol->strict_io = false;
1473 vol->cache_ro = false;
1474 vol->cache_rw = false;
1476 case Opt_cache_strict:
1477 vol->direct_io = false;
1478 vol->strict_io = true;
1479 vol->cache_ro = false;
1480 vol->cache_rw = false;
1482 case Opt_cache_none:
1483 vol->direct_io = true;
1484 vol->strict_io = false;
1485 vol->cache_ro = false;
1486 vol->cache_rw = false;
1489 vol->direct_io = false;
1490 vol->strict_io = false;
1491 vol->cache_ro = true;
1492 vol->cache_rw = false;
1495 vol->direct_io = false;
1496 vol->strict_io = false;
1497 vol->cache_ro = false;
1498 vol->cache_rw = true;
1501 cifs_dbg(VFS, "bad cache= option: %s\n", value);
1508 cifs_parse_smb_version(char *value, struct smb_vol *vol, bool is_smb3)
1510 substring_t args[MAX_OPT_ARGS];
1512 switch (match_token(value, cifs_smb_version_tokens, args)) {
1513 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1515 if (disable_legacy_dialects) {
1516 cifs_dbg(VFS, "mount with legacy dialect disabled\n");
1520 cifs_dbg(VFS, "vers=1.0 (cifs) not permitted when mounting with smb3\n");
1523 vol->ops = &smb1_operations;
1524 vol->vals = &smb1_values;
1527 if (disable_legacy_dialects) {
1528 cifs_dbg(VFS, "mount with legacy dialect disabled\n");
1532 cifs_dbg(VFS, "vers=2.0 not permitted when mounting with smb3\n");
1535 vol->ops = &smb20_operations;
1536 vol->vals = &smb20_values;
1540 cifs_dbg(VFS, "vers=1.0 (cifs) mount not permitted when legacy dialects disabled\n");
1543 cifs_dbg(VFS, "vers=2.0 mount not permitted when legacy dialects disabled\n");
1545 #endif /* CIFS_ALLOW_INSECURE_LEGACY */
1547 vol->ops = &smb21_operations;
1548 vol->vals = &smb21_values;
1551 vol->ops = &smb30_operations;
1552 vol->vals = &smb30_values;
1555 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1556 vol->vals = &smb302_values;
1559 vol->ops = &smb311_operations;
1560 vol->vals = &smb311_values;
1563 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1564 vol->vals = &smb3any_values;
1567 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1568 vol->vals = &smbdefault_values;
1571 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
1578 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1579 * fields with the result. Returns 0 on success and an error otherwise.
1582 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1585 const char *delims = "/\\";
1588 if (unlikely(!devname || !*devname)) {
1589 cifs_dbg(VFS, "Device name not specified.\n");
1593 /* make sure we have a valid UNC double delimiter prefix */
1594 len = strspn(devname, delims);
1598 /* find delimiter between host and sharename */
1599 pos = strpbrk(devname + 2, delims);
1603 /* skip past delimiter */
1606 /* now go until next delimiter or end of string */
1607 len = strcspn(pos, delims);
1609 /* move "pos" up to delimiter or NULL */
1611 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1615 convert_delimiter(vol->UNC, '\\');
1617 /* skip any delimiter */
1618 if (*pos == '/' || *pos == '\\')
1621 /* If pos is NULL then no prepath */
1625 vol->prepath = kstrdup(pos, GFP_KERNEL);
1633 cifs_parse_mount_options(const char *mountdata, const char *devname,
1634 struct smb_vol *vol, bool is_smb3)
1637 char *mountdata_copy = NULL, *options;
1638 unsigned int temp_len, i, j;
1640 short int override_uid = -1;
1641 short int override_gid = -1;
1642 bool uid_specified = false;
1643 bool gid_specified = false;
1644 bool sloppy = false;
1645 char *invalid = NULL;
1646 char *nodename = utsname()->nodename;
1647 char *string = NULL;
1648 char *tmp_end, *value;
1650 bool got_ip = false;
1651 bool got_version = false;
1652 unsigned short port = 0;
1653 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1657 delim = separator[0];
1659 /* ensure we always start with zeroed-out smb_vol */
1660 memset(vol, 0, sizeof(*vol));
1663 * does not have to be perfect mapping since field is
1664 * informational, only used for servers that do not support
1665 * port 445 and it can be overridden at mount time
1667 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1668 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1669 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1671 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1672 /* null target name indicates to use *SMBSERVR default called name
1673 if we end up sending RFC1001 session initialize */
1674 vol->target_rfc1001_name[0] = 0;
1675 vol->cred_uid = current_uid();
1676 vol->linux_uid = current_uid();
1677 vol->linux_gid = current_gid();
1678 vol->bsize = 1024 * 1024; /* can improve cp performance significantly */
1680 * default to SFM style remapping of seven reserved characters
1681 * unless user overrides it or we negotiate CIFS POSIX where
1682 * it is unnecessary. Can not simultaneously use more than one mapping
1683 * since then readdir could list files that open could not open
1687 /* default to only allowing write access to owner of the mount */
1688 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1690 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1691 /* default is always to request posix paths. */
1692 vol->posix_paths = 1;
1693 /* default to using server inode numbers where available */
1694 vol->server_ino = 1;
1696 /* default is to use strict cifs caching semantics */
1697 vol->strict_io = true;
1699 vol->actimeo = CIFS_DEF_ACTIMEO;
1701 /* Most clients set timeout to 0, allows server to use its default */
1702 vol->handle_timeout = 0; /* See MS-SMB2 spec section 2.2.14.2.12 */
1704 /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1705 vol->ops = &smb30_operations;
1706 vol->vals = &smbdefault_values;
1708 vol->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1711 goto cifs_parse_mount_err;
1713 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1714 if (!mountdata_copy)
1715 goto cifs_parse_mount_err;
1717 options = mountdata_copy;
1718 end = options + strlen(options);
1720 if (strncmp(options, "sep=", 4) == 0) {
1721 if (options[4] != 0) {
1722 separator[0] = options[4];
1725 cifs_dbg(FYI, "Null separator not allowed\n");
1728 vol->backupuid_specified = false; /* no backup intent for a user */
1729 vol->backupgid_specified = false; /* no backup intent for a group */
1731 switch (cifs_parse_devname(devname, vol)) {
1735 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1736 goto cifs_parse_mount_err;
1738 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1739 goto cifs_parse_mount_err;
1741 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1742 goto cifs_parse_mount_err;
1745 while ((data = strsep(&options, separator)) != NULL) {
1746 substring_t args[MAX_OPT_ARGS];
1747 unsigned long option;
1753 token = match_token(data, cifs_mount_option_tokens, args);
1757 /* Ingnore the following */
1761 /* Boolean values */
1762 case Opt_user_xattr:
1765 case Opt_nouser_xattr:
1771 case Opt_noforceuid:
1777 case Opt_noforcegid:
1780 case Opt_noblocksend:
1781 vol->noblocksnd = 1;
1783 case Opt_noautotune:
1784 vol->noautotune = 1;
1802 vol->sfu_remap = true;
1803 vol->remap = false; /* disable SFM mapping */
1805 case Opt_nomapchars:
1806 vol->sfu_remap = false;
1810 vol->sfu_remap = false; /* disable SFU mapping */
1812 case Opt_nomapposix:
1825 #ifdef CONFIG_CIFS_ROOT
1829 case Opt_posixpaths:
1830 vol->posix_paths = 1;
1832 case Opt_noposixpaths:
1833 vol->posix_paths = 0;
1838 "conflicting unix mount options\n");
1839 vol->no_linux_ext = 1;
1842 if (vol->no_linux_ext)
1844 "conflicting unix mount options\n");
1856 * turn off mandatory locking in mode
1857 * if remote locking is turned off since the
1858 * local vfs will do advisory
1860 if (vol->file_mode ==
1861 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1862 vol->file_mode = S_IALLUGO;
1864 case Opt_nohandlecache:
1865 vol->nohandlecache = 1;
1867 case Opt_handlecache:
1868 vol->nohandlecache = 0;
1870 case Opt_forcemandatorylock:
1879 case Opt_setuidfromacl:
1880 vol->setuidfromacl = 1;
1883 vol->dynperm = true;
1886 vol->dynperm = false;
1900 case Opt_nostrictsync:
1901 vol->nostrictsync = 1;
1903 case Opt_strictsync:
1904 vol->nostrictsync = 0;
1907 vol->server_ino = 1;
1909 case Opt_noserverino:
1910 vol->server_ino = 0;
1912 case Opt_rwpidforward:
1913 vol->rwpidforward = 1;
1925 vol->no_psx_acl = 0;
1928 vol->no_psx_acl = 1;
1930 case Opt_locallease:
1931 vol->local_lease = 1;
1936 case Opt_ignore_signature:
1938 vol->ignore_signature = true;
1941 /* we do not do the following in secFlags because seal
1942 * is a per tree connection (mount) not a per socket
1943 * or per-smb connection option in the protocol
1944 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1949 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1952 #ifndef CONFIG_CIFS_FSCACHE
1953 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1954 goto cifs_parse_mount_err;
1958 case Opt_mfsymlinks:
1959 vol->mfsymlinks = true;
1962 vol->multiuser = true;
1967 case Opt_nosharesock:
1968 vol->nosharesock = true;
1970 case Opt_nopersistent:
1971 vol->nopersistent = true;
1972 if (vol->persistent) {
1974 "persistenthandles mount options conflict\n");
1975 goto cifs_parse_mount_err;
1978 case Opt_persistent:
1979 vol->persistent = true;
1980 if ((vol->nopersistent) || (vol->resilient)) {
1982 "persistenthandles mount options conflict\n");
1983 goto cifs_parse_mount_err;
1987 vol->resilient = true;
1988 if (vol->persistent) {
1990 "persistenthandles mount options conflict\n");
1991 goto cifs_parse_mount_err;
1994 case Opt_noresilient:
1995 vol->resilient = false; /* already the default */
1997 case Opt_domainauto:
1998 vol->domainauto = true;
2004 vol->compression = UNKNOWN_TYPE;
2006 "SMB3 compression support is experimental\n");
2009 /* Numeric Values */
2011 if (get_option_uid(args, &vol->backupuid)) {
2012 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
2014 goto cifs_parse_mount_err;
2016 vol->backupuid_specified = true;
2019 if (get_option_gid(args, &vol->backupgid)) {
2020 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
2022 goto cifs_parse_mount_err;
2024 vol->backupgid_specified = true;
2027 if (get_option_uid(args, &vol->linux_uid)) {
2028 cifs_dbg(VFS, "%s: Invalid uid value\n",
2030 goto cifs_parse_mount_err;
2032 uid_specified = true;
2035 if (get_option_uid(args, &vol->cred_uid)) {
2036 cifs_dbg(VFS, "%s: Invalid cruid value\n",
2038 goto cifs_parse_mount_err;
2042 if (get_option_gid(args, &vol->linux_gid)) {
2043 cifs_dbg(VFS, "%s: Invalid gid value\n",
2045 goto cifs_parse_mount_err;
2047 gid_specified = true;
2050 if (get_option_ul(args, &option)) {
2051 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
2053 goto cifs_parse_mount_err;
2055 vol->file_mode = option;
2058 if (get_option_ul(args, &option)) {
2059 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
2061 goto cifs_parse_mount_err;
2063 vol->dir_mode = option;
2066 if (get_option_ul(args, &option) ||
2067 option > USHRT_MAX) {
2068 cifs_dbg(VFS, "%s: Invalid port value\n",
2070 goto cifs_parse_mount_err;
2072 port = (unsigned short)option;
2074 case Opt_min_enc_offload:
2075 if (get_option_ul(args, &option)) {
2076 cifs_dbg(VFS, "Invalid minimum encrypted read offload size (esize)\n");
2077 goto cifs_parse_mount_err;
2079 vol->min_offload = option;
2082 if (get_option_ul(args, &option)) {
2083 cifs_dbg(VFS, "%s: Invalid blocksize value\n",
2085 goto cifs_parse_mount_err;
2088 * inode blocksize realistically should never need to be
2089 * less than 16K or greater than 16M and default is 1MB.
2090 * Note that small inode block sizes (e.g. 64K) can lead
2091 * to very poor performance of common tools like cp and scp
2093 if ((option < CIFS_MAX_MSGSIZE) ||
2094 (option > (4 * SMB3_DEFAULT_IOSIZE))) {
2095 cifs_dbg(VFS, "%s: Invalid blocksize\n",
2097 goto cifs_parse_mount_err;
2099 vol->bsize = option;
2102 if (get_option_ul(args, &option)) {
2103 cifs_dbg(VFS, "%s: Invalid rsize value\n",
2105 goto cifs_parse_mount_err;
2107 vol->rsize = option;
2110 if (get_option_ul(args, &option)) {
2111 cifs_dbg(VFS, "%s: Invalid wsize value\n",
2113 goto cifs_parse_mount_err;
2115 vol->wsize = option;
2118 if (get_option_ul(args, &option)) {
2119 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
2121 goto cifs_parse_mount_err;
2123 vol->actimeo = HZ * option;
2124 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
2125 cifs_dbg(VFS, "attribute cache timeout too large\n");
2126 goto cifs_parse_mount_err;
2129 case Opt_handletimeout:
2130 if (get_option_ul(args, &option)) {
2131 cifs_dbg(VFS, "%s: Invalid handletimeout value\n",
2133 goto cifs_parse_mount_err;
2135 vol->handle_timeout = option;
2136 if (vol->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) {
2137 cifs_dbg(VFS, "Invalid handle cache timeout, longer than 16 minutes\n");
2138 goto cifs_parse_mount_err;
2141 case Opt_echo_interval:
2142 if (get_option_ul(args, &option)) {
2143 cifs_dbg(VFS, "%s: Invalid echo interval value\n",
2145 goto cifs_parse_mount_err;
2147 vol->echo_interval = option;
2150 if (get_option_ul(args, &option)) {
2151 cifs_dbg(VFS, "%s: Invalid snapshot time\n",
2153 goto cifs_parse_mount_err;
2155 vol->snapshot_time = option;
2157 case Opt_max_credits:
2158 if (get_option_ul(args, &option) || (option < 20) ||
2160 cifs_dbg(VFS, "%s: Invalid max_credits value\n",
2162 goto cifs_parse_mount_err;
2164 vol->max_credits = option;
2167 /* String Arguments */
2169 case Opt_blank_user:
2170 /* null user, ie. anonymous authentication */
2172 vol->username = NULL;
2175 string = match_strdup(args);
2179 if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
2180 CIFS_MAX_USERNAME_LEN) {
2181 pr_warn("CIFS: username too long\n");
2182 goto cifs_parse_mount_err;
2185 kfree(vol->username);
2186 vol->username = kstrdup(string, GFP_KERNEL);
2188 goto cifs_parse_mount_err;
2190 case Opt_blank_pass:
2191 /* passwords have to be handled differently
2192 * to allow the character used for deliminator
2193 * to be passed within them
2197 * Check if this is a case where the password
2198 * starts with a delimiter
2200 tmp_end = strchr(data, '=');
2202 if (!(tmp_end < end && tmp_end[1] == delim)) {
2203 /* No it is not. Set the password to NULL */
2204 kzfree(vol->password);
2205 vol->password = NULL;
2208 /* Fallthrough - to Opt_pass below.*/
2210 /* Obtain the value string */
2211 value = strchr(data, '=');
2214 /* Set tmp_end to end of the string */
2215 tmp_end = (char *) value + strlen(value);
2217 /* Check if following character is the deliminator
2218 * If yes, we have encountered a double deliminator
2219 * reset the NULL character to the deliminator
2221 if (tmp_end < end && tmp_end[1] == delim) {
2224 /* Keep iterating until we get to a single
2225 * deliminator OR the end
2227 while ((tmp_end = strchr(tmp_end, delim))
2228 != NULL && (tmp_end[1] == delim)) {
2229 tmp_end = (char *) &tmp_end[2];
2232 /* Reset var options to point to next element */
2235 options = (char *) &tmp_end[1];
2237 /* Reached the end of the mount option
2242 kzfree(vol->password);
2243 /* Now build new password string */
2244 temp_len = strlen(value);
2245 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
2246 if (vol->password == NULL) {
2247 pr_warn("CIFS: no memory for password\n");
2248 goto cifs_parse_mount_err;
2251 for (i = 0, j = 0; i < temp_len; i++, j++) {
2252 vol->password[j] = value[i];
2253 if ((value[i] == delim) &&
2254 value[i+1] == delim)
2255 /* skip the second deliminator */
2258 vol->password[j] = '\0';
2261 /* FIXME: should this be an error instead? */
2265 string = match_strdup(args);
2269 if (!cifs_convert_address(dstaddr, string,
2271 pr_err("CIFS: bad ip= option (%s).\n", string);
2272 goto cifs_parse_mount_err;
2277 string = match_strdup(args);
2281 if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
2282 == CIFS_MAX_DOMAINNAME_LEN) {
2283 pr_warn("CIFS: domain name too long\n");
2284 goto cifs_parse_mount_err;
2287 kfree(vol->domainname);
2288 vol->domainname = kstrdup(string, GFP_KERNEL);
2289 if (!vol->domainname) {
2290 pr_warn("CIFS: no memory for domainname\n");
2291 goto cifs_parse_mount_err;
2293 cifs_dbg(FYI, "Domain name set\n");
2296 string = match_strdup(args);
2300 if (!cifs_convert_address(
2301 (struct sockaddr *)&vol->srcaddr,
2302 string, strlen(string))) {
2303 pr_warn("CIFS: Could not parse srcaddr: %s\n",
2305 goto cifs_parse_mount_err;
2309 string = match_strdup(args);
2313 if (strnlen(string, 1024) >= 65) {
2314 pr_warn("CIFS: iocharset name too long.\n");
2315 goto cifs_parse_mount_err;
2318 if (strncasecmp(string, "default", 7) != 0) {
2319 kfree(vol->iocharset);
2320 vol->iocharset = kstrdup(string,
2322 if (!vol->iocharset) {
2323 pr_warn("CIFS: no memory for charset\n");
2324 goto cifs_parse_mount_err;
2327 /* if iocharset not set then load_nls_default
2330 cifs_dbg(FYI, "iocharset set to %s\n", string);
2332 case Opt_netbiosname:
2333 string = match_strdup(args);
2337 memset(vol->source_rfc1001_name, 0x20,
2340 * FIXME: are there cases in which a comma can
2341 * be valid in workstation netbios name (and
2342 * need special handling)?
2344 for (i = 0; i < RFC1001_NAME_LEN; i++) {
2345 /* don't ucase netbiosname for user */
2348 vol->source_rfc1001_name[i] = string[i];
2350 /* The string has 16th byte zero still from
2351 * set at top of the function
2353 if (i == RFC1001_NAME_LEN && string[i] != 0)
2354 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
2357 /* servernetbiosname specified override *SMBSERVER */
2358 string = match_strdup(args);
2362 /* last byte, type, is 0x20 for servr type */
2363 memset(vol->target_rfc1001_name, 0x20,
2364 RFC1001_NAME_LEN_WITH_NULL);
2366 /* BB are there cases in which a comma can be
2367 valid in this workstation netbios name
2368 (and need special handling)? */
2370 /* user or mount helper must uppercase the
2372 for (i = 0; i < 15; i++) {
2375 vol->target_rfc1001_name[i] = string[i];
2377 /* The string has 16th byte zero still from
2378 set at top of the function */
2379 if (i == RFC1001_NAME_LEN && string[i] != 0)
2380 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
2383 /* version of mount userspace tools, not dialect */
2384 string = match_strdup(args);
2388 /* If interface changes in mount.cifs bump to new ver */
2389 if (strncasecmp(string, "1", 1) == 0) {
2390 if (strlen(string) > 1) {
2391 pr_warn("Bad mount helper ver=%s. Did "
2392 "you want SMB1 (CIFS) dialect "
2393 "and mean to type vers=1.0 "
2394 "instead?\n", string);
2395 goto cifs_parse_mount_err;
2397 /* This is the default */
2400 /* For all other value, error */
2401 pr_warn("CIFS: Invalid mount helper version specified\n");
2402 goto cifs_parse_mount_err;
2404 /* protocol version (dialect) */
2405 string = match_strdup(args);
2409 if (cifs_parse_smb_version(string, vol, is_smb3) != 0)
2410 goto cifs_parse_mount_err;
2414 string = match_strdup(args);
2418 if (cifs_parse_security_flavors(string, vol) != 0)
2419 goto cifs_parse_mount_err;
2422 string = match_strdup(args);
2426 if (cifs_parse_cache_flavor(string, vol) != 0)
2427 goto cifs_parse_mount_err;
2431 * An option we don't recognize. Save it off for later
2432 * if we haven't already found one
2438 /* Free up any allocated string */
2443 if (!sloppy && invalid) {
2444 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
2445 goto cifs_parse_mount_err;
2448 if (vol->rdma && vol->vals->protocol_id < SMB30_PROT_ID) {
2449 cifs_dbg(VFS, "SMB Direct requires Version >=3.0\n");
2450 goto cifs_parse_mount_err;
2454 /* Muliuser mounts require CONFIG_KEYS support */
2455 if (vol->multiuser) {
2456 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
2457 goto cifs_parse_mount_err;
2461 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
2462 goto cifs_parse_mount_err;
2465 /* make sure UNC has a share name */
2466 if (!strchr(vol->UNC + 3, '\\')) {
2467 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
2468 goto cifs_parse_mount_err;
2475 /* No ip= option specified? Try to get it from UNC */
2476 /* Use the address part of the UNC. */
2477 slash = strchr(&vol->UNC[2], '\\');
2478 len = slash - &vol->UNC[2];
2479 if (!cifs_convert_address(dstaddr, &vol->UNC[2], len)) {
2480 pr_err("Unable to determine destination address.\n");
2481 goto cifs_parse_mount_err;
2485 /* set the port that we got earlier */
2486 cifs_set_port(dstaddr, port);
2489 vol->override_uid = override_uid;
2490 else if (override_uid == 1)
2491 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
2494 vol->override_gid = override_gid;
2495 else if (override_gid == 1)
2496 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
2498 if (got_version == false)
2499 pr_warn("No dialect specified on mount. Default has changed to "
2500 "a more secure dialect, SMB2.1 or later (e.g. SMB3), from CIFS "
2501 "(SMB1). To use the less secure SMB1 dialect to access "
2502 "old servers which do not support SMB3 (or SMB2.1) specify vers=1.0"
2505 kfree(mountdata_copy);
2509 pr_warn("Could not allocate temporary buffer\n");
2510 cifs_parse_mount_err:
2512 kfree(mountdata_copy);
2516 /** Returns true if srcaddr isn't specified and rhs isn't
2517 * specified, or if srcaddr is specified and
2518 * matches the IP address of the rhs argument.
2521 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
2523 switch (srcaddr->sa_family) {
2525 return (rhs->sa_family == AF_UNSPEC);
2527 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
2528 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
2529 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
2532 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
2533 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
2534 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
2538 return false; /* don't expect to be here */
2543 * If no port is specified in addr structure, we try to match with 445 port
2544 * and if it fails - with 139 ports. It should be called only if address
2545 * families of server and addr are equal.
2548 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
2550 __be16 port, *sport;
2552 /* SMBDirect manages its own ports, don't match it here */
2556 switch (addr->sa_family) {
2558 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
2559 port = ((struct sockaddr_in *) addr)->sin_port;
2562 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
2563 port = ((struct sockaddr_in6 *) addr)->sin6_port;
2571 port = htons(CIFS_PORT);
2575 port = htons(RFC1001_PORT);
2578 return port == *sport;
2582 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
2583 struct sockaddr *srcaddr)
2585 switch (addr->sa_family) {
2587 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2588 struct sockaddr_in *srv_addr4 =
2589 (struct sockaddr_in *)&server->dstaddr;
2591 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2596 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2597 struct sockaddr_in6 *srv_addr6 =
2598 (struct sockaddr_in6 *)&server->dstaddr;
2600 if (!ipv6_addr_equal(&addr6->sin6_addr,
2601 &srv_addr6->sin6_addr))
2603 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2609 return false; /* don't expect to be here */
2612 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2619 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2622 * The select_sectype function should either return the vol->sectype
2623 * that was specified, or "Unspecified" if that sectype was not
2624 * compatible with the given NEGOTIATE request.
2626 if (server->ops->select_sectype(server, vol->sectype)
2631 * Now check if signing mode is acceptable. No need to check
2632 * global_secflags at this point since if MUST_SIGN is set then
2633 * the server->sign had better be too.
2635 if (vol->sign && !server->sign)
2641 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2643 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2645 if (vol->nosharesock)
2648 /* If multidialect negotiation see if existing sessions match one */
2649 if (strcmp(vol->vals->version_string, SMB3ANY_VERSION_STRING) == 0) {
2650 if (server->vals->protocol_id < SMB30_PROT_ID)
2652 } else if (strcmp(vol->vals->version_string,
2653 SMBDEFAULT_VERSION_STRING) == 0) {
2654 if (server->vals->protocol_id < SMB21_PROT_ID)
2656 } else if ((server->vals != vol->vals) || (server->ops != vol->ops))
2659 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2662 if (!match_address(server, addr,
2663 (struct sockaddr *)&vol->srcaddr))
2666 if (!match_port(server, addr))
2669 if (!match_security(server, vol))
2672 if (server->echo_interval != vol->echo_interval * HZ)
2675 if (server->rdma != vol->rdma)
2678 if (server->ignore_signature != vol->ignore_signature)
2681 if (server->min_offload != vol->min_offload)
2687 struct TCP_Server_Info *
2688 cifs_find_tcp_session(struct smb_vol *vol)
2690 struct TCP_Server_Info *server;
2692 spin_lock(&cifs_tcp_ses_lock);
2693 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2694 if (!match_server(server, vol))
2697 ++server->srv_count;
2698 spin_unlock(&cifs_tcp_ses_lock);
2699 cifs_dbg(FYI, "Existing tcp session with server found\n");
2702 spin_unlock(&cifs_tcp_ses_lock);
2707 cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
2709 struct task_struct *task;
2711 spin_lock(&cifs_tcp_ses_lock);
2712 if (--server->srv_count > 0) {
2713 spin_unlock(&cifs_tcp_ses_lock);
2717 put_net(cifs_net_ns(server));
2719 list_del_init(&server->tcp_ses_list);
2720 spin_unlock(&cifs_tcp_ses_lock);
2722 cancel_delayed_work_sync(&server->echo);
2726 * Avoid deadlock here: reconnect work calls
2727 * cifs_put_tcp_session() at its end. Need to be sure
2728 * that reconnect work does nothing with server pointer after
2731 cancel_delayed_work(&server->reconnect);
2733 cancel_delayed_work_sync(&server->reconnect);
2735 spin_lock(&GlobalMid_Lock);
2736 server->tcpStatus = CifsExiting;
2737 spin_unlock(&GlobalMid_Lock);
2739 cifs_crypto_secmech_release(server);
2740 cifs_fscache_release_client_cookie(server);
2742 kfree(server->session_key.response);
2743 server->session_key.response = NULL;
2744 server->session_key.len = 0;
2746 task = xchg(&server->tsk, NULL);
2748 send_sig(SIGKILL, task, 1);
2751 static struct TCP_Server_Info *
2752 cifs_get_tcp_session(struct smb_vol *volume_info)
2754 struct TCP_Server_Info *tcp_ses = NULL;
2757 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2759 /* see if we already have a matching tcp_ses */
2760 tcp_ses = cifs_find_tcp_session(volume_info);
2764 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2770 tcp_ses->ops = volume_info->ops;
2771 tcp_ses->vals = volume_info->vals;
2772 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2773 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2774 if (IS_ERR(tcp_ses->hostname)) {
2775 rc = PTR_ERR(tcp_ses->hostname);
2776 goto out_err_crypto_release;
2779 tcp_ses->noblockcnt = volume_info->rootfs;
2780 tcp_ses->noblocksnd = volume_info->noblocksnd || volume_info->rootfs;
2781 tcp_ses->noautotune = volume_info->noautotune;
2782 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2783 tcp_ses->rdma = volume_info->rdma;
2784 tcp_ses->in_flight = 0;
2785 tcp_ses->max_in_flight = 0;
2786 tcp_ses->credits = 1;
2787 init_waitqueue_head(&tcp_ses->response_q);
2788 init_waitqueue_head(&tcp_ses->request_q);
2789 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2790 mutex_init(&tcp_ses->srv_mutex);
2791 memcpy(tcp_ses->workstation_RFC1001_name,
2792 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2793 memcpy(tcp_ses->server_RFC1001_name,
2794 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2795 tcp_ses->session_estab = false;
2796 tcp_ses->sequence_number = 0;
2797 tcp_ses->reconnect_instance = 1;
2798 tcp_ses->lstrp = jiffies;
2799 tcp_ses->compress_algorithm = cpu_to_le16(volume_info->compression);
2800 spin_lock_init(&tcp_ses->req_lock);
2801 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2802 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2803 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2804 INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
2805 mutex_init(&tcp_ses->reconnect_mutex);
2806 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2807 sizeof(tcp_ses->srcaddr));
2808 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2809 sizeof(tcp_ses->dstaddr));
2810 generate_random_uuid(tcp_ses->client_guid);
2812 * at this point we are the only ones with the pointer
2813 * to the struct since the kernel thread not created yet
2814 * no need to spinlock this init of tcpStatus or srv_count
2816 tcp_ses->tcpStatus = CifsNew;
2817 ++tcp_ses->srv_count;
2819 if (volume_info->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
2820 volume_info->echo_interval <= SMB_ECHO_INTERVAL_MAX)
2821 tcp_ses->echo_interval = volume_info->echo_interval * HZ;
2823 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
2824 if (tcp_ses->rdma) {
2825 #ifndef CONFIG_CIFS_SMB_DIRECT
2826 cifs_dbg(VFS, "CONFIG_CIFS_SMB_DIRECT is not enabled\n");
2828 goto out_err_crypto_release;
2830 tcp_ses->smbd_conn = smbd_get_connection(
2831 tcp_ses, (struct sockaddr *)&volume_info->dstaddr);
2832 if (tcp_ses->smbd_conn) {
2833 cifs_dbg(VFS, "RDMA transport established\n");
2835 goto smbd_connected;
2838 goto out_err_crypto_release;
2841 rc = ip_connect(tcp_ses);
2843 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2844 goto out_err_crypto_release;
2848 * since we're in a cifs function already, we know that
2849 * this will succeed. No need for try_module_get().
2851 __module_get(THIS_MODULE);
2852 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2854 if (IS_ERR(tcp_ses->tsk)) {
2855 rc = PTR_ERR(tcp_ses->tsk);
2856 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2857 module_put(THIS_MODULE);
2858 goto out_err_crypto_release;
2860 tcp_ses->min_offload = volume_info->min_offload;
2861 tcp_ses->tcpStatus = CifsNeedNegotiate;
2863 tcp_ses->nr_targets = 1;
2864 tcp_ses->ignore_signature = volume_info->ignore_signature;
2865 /* thread spawned, put it on the list */
2866 spin_lock(&cifs_tcp_ses_lock);
2867 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2868 spin_unlock(&cifs_tcp_ses_lock);
2870 cifs_fscache_get_client_cookie(tcp_ses);
2872 /* queue echo request delayed work */
2873 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
2877 out_err_crypto_release:
2878 cifs_crypto_secmech_release(tcp_ses);
2880 put_net(cifs_net_ns(tcp_ses));
2884 if (!IS_ERR(tcp_ses->hostname))
2885 kfree(tcp_ses->hostname);
2886 if (tcp_ses->ssocket)
2887 sock_release(tcp_ses->ssocket);
2893 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2895 if (vol->sectype != Unspecified &&
2896 vol->sectype != ses->sectype)
2899 switch (ses->sectype) {
2901 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2905 /* NULL username means anonymous session */
2906 if (ses->user_name == NULL) {
2912 /* anything else takes username/password */
2913 if (strncmp(ses->user_name,
2914 vol->username ? vol->username : "",
2915 CIFS_MAX_USERNAME_LEN))
2917 if ((vol->username && strlen(vol->username) != 0) &&
2918 ses->password != NULL &&
2919 strncmp(ses->password,
2920 vol->password ? vol->password : "",
2921 CIFS_MAX_PASSWORD_LEN))
2928 * cifs_setup_ipc - helper to setup the IPC tcon for the session
2930 * A new IPC connection is made and stored in the session
2931 * tcon_ipc. The IPC tcon has the same lifetime as the session.
2934 cifs_setup_ipc(struct cifs_ses *ses, struct smb_vol *volume_info)
2937 struct cifs_tcon *tcon;
2938 struct nls_table *nls_codepage;
2939 char unc[SERVER_NAME_LENGTH + sizeof("//x/IPC$")] = {0};
2941 struct TCP_Server_Info *server = ses->server;
2944 * If the mount request that resulted in the creation of the
2945 * session requires encryption, force IPC to be encrypted too.
2947 if (volume_info->seal) {
2948 if (server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION)
2951 cifs_server_dbg(VFS,
2952 "IPC: server doesn't support encryption\n");
2957 tcon = tconInfoAlloc();
2961 scnprintf(unc, sizeof(unc), "\\\\%s\\IPC$", server->hostname);
2964 nls_codepage = load_nls_default();
2970 rc = server->ops->tree_connect(xid, ses, unc, tcon, nls_codepage);
2974 cifs_server_dbg(VFS, "failed to connect to IPC (rc=%d)\n", rc);
2979 cifs_dbg(FYI, "IPC tcon rc = %d ipc tid = %d\n", rc, tcon->tid);
2981 ses->tcon_ipc = tcon;
2983 unload_nls(nls_codepage);
2988 * cifs_free_ipc - helper to release the session IPC tcon
2990 * Needs to be called everytime a session is destroyed
2993 cifs_free_ipc(struct cifs_ses *ses)
2996 struct cifs_tcon *tcon = ses->tcon_ipc;
3001 if (ses->server->ops->tree_disconnect) {
3003 rc = ses->server->ops->tree_disconnect(xid, tcon);
3008 cifs_dbg(FYI, "failed to disconnect IPC tcon (rc=%d)\n", rc);
3011 ses->tcon_ipc = NULL;
3015 static struct cifs_ses *
3016 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
3018 struct cifs_ses *ses;
3020 spin_lock(&cifs_tcp_ses_lock);
3021 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
3022 if (ses->status == CifsExiting)
3024 if (!match_session(ses, vol))
3027 spin_unlock(&cifs_tcp_ses_lock);
3030 spin_unlock(&cifs_tcp_ses_lock);
3034 void cifs_put_smb_ses(struct cifs_ses *ses)
3036 unsigned int rc, xid;
3037 struct TCP_Server_Info *server = ses->server;
3039 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
3041 spin_lock(&cifs_tcp_ses_lock);
3042 if (ses->status == CifsExiting) {
3043 spin_unlock(&cifs_tcp_ses_lock);
3046 if (--ses->ses_count > 0) {
3047 spin_unlock(&cifs_tcp_ses_lock);
3050 spin_unlock(&cifs_tcp_ses_lock);
3052 spin_lock(&GlobalMid_Lock);
3053 if (ses->status == CifsGood)
3054 ses->status = CifsExiting;
3055 spin_unlock(&GlobalMid_Lock);
3059 if (ses->status == CifsExiting && server->ops->logoff) {
3061 rc = server->ops->logoff(xid, ses);
3063 cifs_server_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
3068 spin_lock(&cifs_tcp_ses_lock);
3069 list_del_init(&ses->smb_ses_list);
3070 spin_unlock(&cifs_tcp_ses_lock);
3073 cifs_put_tcp_session(server, 0);
3078 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
3079 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
3081 /* Populate username and pw fields from keyring if possible */
3083 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
3087 const char *delim, *payload;
3091 struct TCP_Server_Info *server = ses->server;
3092 struct sockaddr_in *sa;
3093 struct sockaddr_in6 *sa6;
3094 const struct user_key_payload *upayload;
3096 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
3100 /* try to find an address key first */
3101 switch (server->dstaddr.ss_family) {
3103 sa = (struct sockaddr_in *)&server->dstaddr;
3104 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
3107 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
3108 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
3111 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
3112 server->dstaddr.ss_family);
3117 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
3118 key = request_key(&key_type_logon, desc, "");
3120 if (!ses->domainName) {
3121 cifs_dbg(FYI, "domainName is NULL\n");
3126 /* didn't work, try to find a domain key */
3127 sprintf(desc, "cifs:d:%s", ses->domainName);
3128 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
3129 key = request_key(&key_type_logon, desc, "");
3137 down_read(&key->sem);
3138 upayload = user_key_payload_locked(key);
3139 if (IS_ERR_OR_NULL(upayload)) {
3140 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
3144 /* find first : in payload */
3145 payload = upayload->data;
3146 delim = strnchr(payload, upayload->datalen, ':');
3147 cifs_dbg(FYI, "payload=%s\n", payload);
3149 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
3155 len = delim - payload;
3156 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
3157 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
3163 vol->username = kstrndup(payload, len, GFP_KERNEL);
3164 if (!vol->username) {
3165 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
3170 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
3172 len = key->datalen - (len + 1);
3173 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
3174 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
3176 kfree(vol->username);
3177 vol->username = NULL;
3182 vol->password = kstrndup(delim, len, GFP_KERNEL);
3183 if (!vol->password) {
3184 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
3187 kfree(vol->username);
3188 vol->username = NULL;
3193 * If we have a domain key then we must set the domainName in the
3196 if (is_domain && ses->domainName) {
3197 vol->domainname = kstrndup(ses->domainName,
3198 strlen(ses->domainName),
3200 if (!vol->domainname) {
3201 cifs_dbg(FYI, "Unable to allocate %zd bytes for "
3204 kfree(vol->username);
3205 vol->username = NULL;
3206 kzfree(vol->password);
3207 vol->password = NULL;
3217 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
3220 #else /* ! CONFIG_KEYS */
3222 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
3223 struct cifs_ses *ses __attribute__((unused)))
3227 #endif /* CONFIG_KEYS */
3230 * cifs_get_smb_ses - get a session matching @volume_info data from @server
3232 * This function assumes it is being called from cifs_mount() where we
3233 * already got a server reference (server refcount +1). See
3234 * cifs_get_tcon() for refcount explanations.
3237 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
3241 struct cifs_ses *ses;
3242 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3243 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3247 ses = cifs_find_smb_ses(server, volume_info);
3249 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
3252 mutex_lock(&ses->session_mutex);
3253 rc = cifs_negotiate_protocol(xid, ses);
3255 mutex_unlock(&ses->session_mutex);
3256 /* problem -- put our ses reference */
3257 cifs_put_smb_ses(ses);
3261 if (ses->need_reconnect) {
3262 cifs_dbg(FYI, "Session needs reconnect\n");
3263 rc = cifs_setup_session(xid, ses,
3264 volume_info->local_nls);
3266 mutex_unlock(&ses->session_mutex);
3267 /* problem -- put our reference */
3268 cifs_put_smb_ses(ses);
3273 mutex_unlock(&ses->session_mutex);
3275 /* existing SMB ses has a server reference already */
3276 cifs_put_tcp_session(server, 0);
3283 cifs_dbg(FYI, "Existing smb sess not found\n");
3284 ses = sesInfoAlloc();
3288 /* new SMB session uses our server ref */
3289 ses->server = server;
3290 if (server->dstaddr.ss_family == AF_INET6)
3291 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
3293 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
3295 if (volume_info->username) {
3296 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
3297 if (!ses->user_name)
3301 /* volume_info->password freed at unmount */
3302 if (volume_info->password) {
3303 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
3307 if (volume_info->domainname) {
3308 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
3309 if (!ses->domainName)
3312 if (volume_info->domainauto)
3313 ses->domainAuto = volume_info->domainauto;
3314 ses->cred_uid = volume_info->cred_uid;
3315 ses->linux_uid = volume_info->linux_uid;
3317 ses->sectype = volume_info->sectype;
3318 ses->sign = volume_info->sign;
3319 mutex_lock(&ses->session_mutex);
3320 rc = cifs_negotiate_protocol(xid, ses);
3322 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
3323 mutex_unlock(&ses->session_mutex);
3327 /* success, put it on the list */
3328 spin_lock(&cifs_tcp_ses_lock);
3329 list_add(&ses->smb_ses_list, &server->smb_ses_list);
3330 spin_unlock(&cifs_tcp_ses_lock);
3334 cifs_setup_ipc(ses, volume_info);
3344 static int match_tcon(struct cifs_tcon *tcon, struct smb_vol *volume_info)
3346 if (tcon->tidStatus == CifsExiting)
3348 if (strncmp(tcon->treeName, volume_info->UNC, MAX_TREE_SIZE))
3350 if (tcon->seal != volume_info->seal)
3352 if (tcon->snapshot_time != volume_info->snapshot_time)
3354 if (tcon->handle_timeout != volume_info->handle_timeout)
3356 if (tcon->no_lease != volume_info->no_lease)
3361 static struct cifs_tcon *
3362 cifs_find_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
3364 struct list_head *tmp;
3365 struct cifs_tcon *tcon;
3367 spin_lock(&cifs_tcp_ses_lock);
3368 list_for_each(tmp, &ses->tcon_list) {
3369 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
3370 #ifdef CONFIG_CIFS_DFS_UPCALL
3374 if (!match_tcon(tcon, volume_info))
3377 spin_unlock(&cifs_tcp_ses_lock);
3380 spin_unlock(&cifs_tcp_ses_lock);
3385 cifs_put_tcon(struct cifs_tcon *tcon)
3388 struct cifs_ses *ses;
3391 * IPC tcon share the lifetime of their session and are
3392 * destroyed in the session put function
3394 if (tcon == NULL || tcon->ipc)
3398 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
3399 spin_lock(&cifs_tcp_ses_lock);
3400 if (--tcon->tc_count > 0) {
3401 spin_unlock(&cifs_tcp_ses_lock);
3405 list_del_init(&tcon->tcon_list);
3406 spin_unlock(&cifs_tcp_ses_lock);
3409 if (ses->server->ops->tree_disconnect)
3410 ses->server->ops->tree_disconnect(xid, tcon);
3413 cifs_fscache_release_super_cookie(tcon);
3415 cifs_put_smb_ses(ses);
3419 * cifs_get_tcon - get a tcon matching @volume_info data from @ses
3421 * - tcon refcount is the number of mount points using the tcon.
3422 * - ses refcount is the number of tcon using the session.
3424 * 1. This function assumes it is being called from cifs_mount() where
3425 * we already got a session reference (ses refcount +1).
3427 * 2. Since we're in the context of adding a mount point, the end
3428 * result should be either:
3430 * a) a new tcon already allocated with refcount=1 (1 mount point) and
3431 * its session refcount incremented (1 new tcon). This +1 was
3432 * already done in (1).
3434 * b) an existing tcon with refcount+1 (add a mount point to it) and
3435 * identical ses refcount (no new tcon). Because of (1) we need to
3436 * decrement the ses refcount.
3438 static struct cifs_tcon *
3439 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
3442 struct cifs_tcon *tcon;
3444 tcon = cifs_find_tcon(ses, volume_info);
3447 * tcon has refcount already incremented but we need to
3448 * decrement extra ses reference gotten by caller (case b)
3450 cifs_dbg(FYI, "Found match on UNC path\n");
3451 cifs_put_smb_ses(ses);
3455 if (!ses->server->ops->tree_connect) {
3460 tcon = tconInfoAlloc();
3466 if (volume_info->snapshot_time) {
3467 if (ses->server->vals->protocol_id == 0) {
3469 "Use SMB2 or later for snapshot mount option\n");
3473 tcon->snapshot_time = volume_info->snapshot_time;
3476 if (volume_info->handle_timeout) {
3477 if (ses->server->vals->protocol_id == 0) {
3479 "Use SMB2.1 or later for handle timeout option\n");
3483 tcon->handle_timeout = volume_info->handle_timeout;
3487 if (volume_info->password) {
3488 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
3489 if (!tcon->password) {
3495 if (volume_info->seal) {
3496 if (ses->server->vals->protocol_id == 0) {
3498 "SMB3 or later required for encryption\n");
3501 } else if (tcon->ses->server->capabilities &
3502 SMB2_GLOBAL_CAP_ENCRYPTION)
3505 cifs_dbg(VFS, "Encryption is not supported on share\n");
3511 if (volume_info->linux_ext) {
3512 if (ses->server->posix_ext_supported) {
3513 tcon->posix_extensions = true;
3514 printk_once(KERN_WARNING
3515 "SMB3.11 POSIX Extensions are experimental\n");
3517 cifs_dbg(VFS, "Server does not support mounting with posix SMB3.11 extensions.\n");
3524 * BB Do we need to wrap session_mutex around this TCon call and Unix
3525 * SetFS as we do on SessSetup and reconnect?
3528 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
3529 volume_info->local_nls);
3531 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
3535 tcon->use_persistent = false;
3536 /* check if SMB2 or later, CIFS does not support persistent handles */
3537 if (volume_info->persistent) {
3538 if (ses->server->vals->protocol_id == 0) {
3540 "SMB3 or later required for persistent handles\n");
3543 } else if (ses->server->capabilities &
3544 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3545 tcon->use_persistent = true;
3546 else /* persistent handles requested but not supported */ {
3548 "Persistent handles not supported on share\n");
3552 } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
3553 && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3554 && (volume_info->nopersistent == false)) {
3555 cifs_dbg(FYI, "enabling persistent handles\n");
3556 tcon->use_persistent = true;
3557 } else if (volume_info->resilient) {
3558 if (ses->server->vals->protocol_id == 0) {
3560 "SMB2.1 or later required for resilient handles\n");
3564 tcon->use_resilient = true;
3567 /* If the user really knows what they are doing they can override */
3568 if (tcon->share_flags & SMB2_SHAREFLAG_NO_CACHING) {
3569 if (volume_info->cache_ro)
3570 cifs_dbg(VFS, "cache=ro requested on mount but NO_CACHING flag set on share\n");
3571 else if (volume_info->cache_rw)
3572 cifs_dbg(VFS, "cache=singleclient requested on mount but NO_CACHING flag set on share\n");
3576 * We can have only one retry value for a connection to a share so for
3577 * resources mounted more than once to the same server share the last
3578 * value passed in for the retry flag is used.
3580 tcon->retry = volume_info->retry;
3581 tcon->nocase = volume_info->nocase;
3582 tcon->nohandlecache = volume_info->nohandlecache;
3583 tcon->local_lease = volume_info->local_lease;
3584 tcon->no_lease = volume_info->no_lease;
3585 INIT_LIST_HEAD(&tcon->pending_opens);
3587 spin_lock(&cifs_tcp_ses_lock);
3588 list_add(&tcon->tcon_list, &ses->tcon_list);
3589 spin_unlock(&cifs_tcp_ses_lock);
3591 cifs_fscache_get_super_cookie(tcon);
3601 cifs_put_tlink(struct tcon_link *tlink)
3603 if (!tlink || IS_ERR(tlink))
3606 if (!atomic_dec_and_test(&tlink->tl_count) ||
3607 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
3608 tlink->tl_time = jiffies;
3612 if (!IS_ERR(tlink_tcon(tlink)))
3613 cifs_put_tcon(tlink_tcon(tlink));
3619 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3621 struct cifs_sb_info *old = CIFS_SB(sb);
3622 struct cifs_sb_info *new = mnt_data->cifs_sb;
3623 unsigned int oldflags = old->mnt_cifs_flags & CIFS_MOUNT_MASK;
3624 unsigned int newflags = new->mnt_cifs_flags & CIFS_MOUNT_MASK;
3626 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
3629 if (old->mnt_cifs_serverino_autodisabled)
3630 newflags &= ~CIFS_MOUNT_SERVER_INUM;
3632 if (oldflags != newflags)
3636 * We want to share sb only if we don't specify an r/wsize or
3637 * specified r/wsize is greater than or equal to existing one.
3639 if (new->wsize && new->wsize < old->wsize)
3642 if (new->rsize && new->rsize < old->rsize)
3645 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
3648 if (old->mnt_file_mode != new->mnt_file_mode ||
3649 old->mnt_dir_mode != new->mnt_dir_mode)
3652 if (strcmp(old->local_nls->charset, new->local_nls->charset))
3655 if (old->actimeo != new->actimeo)
3662 match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3664 struct cifs_sb_info *old = CIFS_SB(sb);
3665 struct cifs_sb_info *new = mnt_data->cifs_sb;
3666 bool old_set = (old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) &&
3668 bool new_set = (new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) &&
3671 if (old_set && new_set && !strcmp(new->prepath, old->prepath))
3673 else if (!old_set && !new_set)
3680 cifs_match_super(struct super_block *sb, void *data)
3682 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
3683 struct smb_vol *volume_info;
3684 struct cifs_sb_info *cifs_sb;
3685 struct TCP_Server_Info *tcp_srv;
3686 struct cifs_ses *ses;
3687 struct cifs_tcon *tcon;
3688 struct tcon_link *tlink;
3691 spin_lock(&cifs_tcp_ses_lock);
3692 cifs_sb = CIFS_SB(sb);
3693 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3694 if (tlink == NULL) {
3695 /* can not match superblock if tlink were ever null */
3696 spin_unlock(&cifs_tcp_ses_lock);
3699 tcon = tlink_tcon(tlink);
3701 tcp_srv = ses->server;
3703 volume_info = mnt_data->vol;
3705 if (!match_server(tcp_srv, volume_info) ||
3706 !match_session(ses, volume_info) ||
3707 !match_tcon(tcon, volume_info) ||
3708 !match_prepath(sb, mnt_data)) {
3713 rc = compare_mount_options(sb, mnt_data);
3715 spin_unlock(&cifs_tcp_ses_lock);
3716 cifs_put_tlink(tlink);
3720 #ifdef CONFIG_DEBUG_LOCK_ALLOC
3721 static struct lock_class_key cifs_key[2];
3722 static struct lock_class_key cifs_slock_key[2];
3725 cifs_reclassify_socket4(struct socket *sock)
3727 struct sock *sk = sock->sk;
3728 BUG_ON(!sock_allow_reclassification(sk));
3729 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
3730 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
3734 cifs_reclassify_socket6(struct socket *sock)
3736 struct sock *sk = sock->sk;
3737 BUG_ON(!sock_allow_reclassification(sk));
3738 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
3739 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
3743 cifs_reclassify_socket4(struct socket *sock)
3748 cifs_reclassify_socket6(struct socket *sock)
3753 /* See RFC1001 section 14 on representation of Netbios names */
3754 static void rfc1002mangle(char *target, char *source, unsigned int length)
3758 for (i = 0, j = 0; i < (length); i++) {
3759 /* mask a nibble at a time and encode */
3760 target[j] = 'A' + (0x0F & (source[i] >> 4));
3761 target[j+1] = 'A' + (0x0F & source[i]);
3768 bind_socket(struct TCP_Server_Info *server)
3771 if (server->srcaddr.ss_family != AF_UNSPEC) {
3772 /* Bind to the specified local IP address */
3773 struct socket *socket = server->ssocket;
3774 rc = socket->ops->bind(socket,
3775 (struct sockaddr *) &server->srcaddr,
3776 sizeof(server->srcaddr));
3778 struct sockaddr_in *saddr4;
3779 struct sockaddr_in6 *saddr6;
3780 saddr4 = (struct sockaddr_in *)&server->srcaddr;
3781 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
3782 if (saddr6->sin6_family == AF_INET6)
3783 cifs_server_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
3784 &saddr6->sin6_addr, rc);
3786 cifs_server_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
3787 &saddr4->sin_addr.s_addr, rc);
3794 ip_rfc1001_connect(struct TCP_Server_Info *server)
3798 * some servers require RFC1001 sessinit before sending
3799 * negprot - BB check reconnection in case where second
3800 * sessinit is sent but no second negprot
3802 struct rfc1002_session_packet *ses_init_buf;
3803 struct smb_hdr *smb_buf;
3804 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
3807 ses_init_buf->trailer.session_req.called_len = 32;
3809 if (server->server_RFC1001_name[0] != 0)
3810 rfc1002mangle(ses_init_buf->trailer.
3811 session_req.called_name,
3812 server->server_RFC1001_name,
3813 RFC1001_NAME_LEN_WITH_NULL);
3815 rfc1002mangle(ses_init_buf->trailer.
3816 session_req.called_name,
3817 DEFAULT_CIFS_CALLED_NAME,
3818 RFC1001_NAME_LEN_WITH_NULL);
3820 ses_init_buf->trailer.session_req.calling_len = 32;
3823 * calling name ends in null (byte 16) from old smb
3826 if (server->workstation_RFC1001_name[0] != 0)
3827 rfc1002mangle(ses_init_buf->trailer.
3828 session_req.calling_name,
3829 server->workstation_RFC1001_name,
3830 RFC1001_NAME_LEN_WITH_NULL);
3832 rfc1002mangle(ses_init_buf->trailer.
3833 session_req.calling_name,
3835 RFC1001_NAME_LEN_WITH_NULL);
3837 ses_init_buf->trailer.session_req.scope1 = 0;
3838 ses_init_buf->trailer.session_req.scope2 = 0;
3839 smb_buf = (struct smb_hdr *)ses_init_buf;
3841 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3842 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3843 rc = smb_send(server, smb_buf, 0x44);
3844 kfree(ses_init_buf);
3846 * RFC1001 layer in at least one server
3847 * requires very short break before negprot
3848 * presumably because not expecting negprot
3849 * to follow so fast. This is a simple
3850 * solution that works without
3851 * complicating the code and causes no
3852 * significant slowing down on mount
3855 usleep_range(1000, 2000);
3858 * else the negprot may still work without this
3859 * even though malloc failed
3866 generic_ip_connect(struct TCP_Server_Info *server)
3871 struct socket *socket = server->ssocket;
3872 struct sockaddr *saddr;
3874 saddr = (struct sockaddr *) &server->dstaddr;
3876 if (server->dstaddr.ss_family == AF_INET6) {
3877 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3878 slen = sizeof(struct sockaddr_in6);
3881 sport = ((struct sockaddr_in *) saddr)->sin_port;
3882 slen = sizeof(struct sockaddr_in);
3886 if (socket == NULL) {
3887 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3888 IPPROTO_TCP, &socket, 1);
3890 cifs_server_dbg(VFS, "Error %d creating socket\n", rc);
3891 server->ssocket = NULL;
3895 /* BB other socket options to set KEEPALIVE, NODELAY? */
3896 cifs_dbg(FYI, "Socket created\n");
3897 server->ssocket = socket;
3898 socket->sk->sk_allocation = GFP_NOFS;
3899 if (sfamily == AF_INET6)
3900 cifs_reclassify_socket6(socket);
3902 cifs_reclassify_socket4(socket);
3905 rc = bind_socket(server);
3910 * Eventually check for other socket options to change from
3911 * the default. sock_setsockopt not used because it expects
3914 socket->sk->sk_rcvtimeo = 7 * HZ;
3915 socket->sk->sk_sndtimeo = 5 * HZ;
3917 /* make the bufsizes depend on wsize/rsize and max requests */
3918 if (server->noautotune) {
3919 if (socket->sk->sk_sndbuf < (200 * 1024))
3920 socket->sk->sk_sndbuf = 200 * 1024;
3921 if (socket->sk->sk_rcvbuf < (140 * 1024))
3922 socket->sk->sk_rcvbuf = 140 * 1024;
3925 if (server->tcp_nodelay) {
3927 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3928 (char *)&val, sizeof(val));
3930 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3934 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3935 socket->sk->sk_sndbuf,
3936 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3938 rc = socket->ops->connect(socket, saddr, slen,
3939 server->noblockcnt ? O_NONBLOCK : 0);
3941 * When mounting SMB root file systems, we do not want to block in
3942 * connect. Otherwise bail out and then let cifs_reconnect() perform
3943 * reconnect failover - if possible.
3945 if (server->noblockcnt && rc == -EINPROGRESS)
3948 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3949 sock_release(socket);
3950 server->ssocket = NULL;
3954 if (sport == htons(RFC1001_PORT))
3955 rc = ip_rfc1001_connect(server);
3961 ip_connect(struct TCP_Server_Info *server)
3964 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3965 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3967 if (server->dstaddr.ss_family == AF_INET6)
3968 sport = &addr6->sin6_port;
3970 sport = &addr->sin_port;
3975 /* try with 445 port at first */
3976 *sport = htons(CIFS_PORT);
3978 rc = generic_ip_connect(server);
3982 /* if it failed, try with 139 port */
3983 *sport = htons(RFC1001_PORT);
3986 return generic_ip_connect(server);
3989 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3990 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3992 /* if we are reconnecting then should we check to see if
3993 * any requested capabilities changed locally e.g. via
3994 * remount but we can not do much about it here
3995 * if they have (even if we could detect it by the following)
3996 * Perhaps we could add a backpointer to array of sb from tcon
3997 * or if we change to make all sb to same share the same
3998 * sb as NFS - then we only have one backpointer to sb.
3999 * What if we wanted to mount the server share twice once with
4000 * and once without posixacls or posix paths? */
4001 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
4003 if (vol_info && vol_info->no_linux_ext) {
4004 tcon->fsUnixInfo.Capability = 0;
4005 tcon->unix_ext = 0; /* Unix Extensions disabled */
4006 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
4008 } else if (vol_info)
4009 tcon->unix_ext = 1; /* Unix Extensions supported */
4011 if (tcon->unix_ext == 0) {
4012 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
4016 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
4017 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
4018 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
4019 /* check for reconnect case in which we do not
4020 want to change the mount behavior if we can avoid it */
4021 if (vol_info == NULL) {
4022 /* turn off POSIX ACL and PATHNAMES if not set
4023 originally at mount time */
4024 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
4025 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
4026 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
4027 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
4028 cifs_dbg(VFS, "POSIXPATH support change\n");
4029 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
4030 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
4031 cifs_dbg(VFS, "possible reconnect error\n");
4032 cifs_dbg(VFS, "server disabled POSIX path support\n");
4036 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
4037 cifs_dbg(VFS, "per-share encryption not supported yet\n");
4039 cap &= CIFS_UNIX_CAP_MASK;
4040 if (vol_info && vol_info->no_psx_acl)
4041 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
4042 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
4043 cifs_dbg(FYI, "negotiated posix acl support\n");
4045 cifs_sb->mnt_cifs_flags |=
4046 CIFS_MOUNT_POSIXACL;
4049 if (vol_info && vol_info->posix_paths == 0)
4050 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
4051 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
4052 cifs_dbg(FYI, "negotiate posix pathnames\n");
4054 cifs_sb->mnt_cifs_flags |=
4055 CIFS_MOUNT_POSIX_PATHS;
4058 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
4059 #ifdef CONFIG_CIFS_DEBUG2
4060 if (cap & CIFS_UNIX_FCNTL_CAP)
4061 cifs_dbg(FYI, "FCNTL cap\n");
4062 if (cap & CIFS_UNIX_EXTATTR_CAP)
4063 cifs_dbg(FYI, "EXTATTR cap\n");
4064 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
4065 cifs_dbg(FYI, "POSIX path cap\n");
4066 if (cap & CIFS_UNIX_XATTR_CAP)
4067 cifs_dbg(FYI, "XATTR cap\n");
4068 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
4069 cifs_dbg(FYI, "POSIX ACL cap\n");
4070 if (cap & CIFS_UNIX_LARGE_READ_CAP)
4071 cifs_dbg(FYI, "very large read cap\n");
4072 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
4073 cifs_dbg(FYI, "very large write cap\n");
4074 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
4075 cifs_dbg(FYI, "transport encryption cap\n");
4076 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
4077 cifs_dbg(FYI, "mandatory transport encryption cap\n");
4078 #endif /* CIFS_DEBUG2 */
4079 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
4080 if (vol_info == NULL) {
4081 cifs_dbg(FYI, "resetting capabilities failed\n");
4083 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");
4089 int cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
4090 struct cifs_sb_info *cifs_sb)
4092 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
4094 spin_lock_init(&cifs_sb->tlink_tree_lock);
4095 cifs_sb->tlink_tree = RB_ROOT;
4097 cifs_sb->bsize = pvolume_info->bsize;
4099 * Temporarily set r/wsize for matching superblock. If we end up using
4100 * new sb then client will later negotiate it downward if needed.
4102 cifs_sb->rsize = pvolume_info->rsize;
4103 cifs_sb->wsize = pvolume_info->wsize;
4105 cifs_sb->mnt_uid = pvolume_info->linux_uid;
4106 cifs_sb->mnt_gid = pvolume_info->linux_gid;
4107 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
4108 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
4109 cifs_dbg(FYI, "file mode: %04ho dir mode: %04ho\n",
4110 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
4112 cifs_sb->actimeo = pvolume_info->actimeo;
4113 cifs_sb->local_nls = pvolume_info->local_nls;
4115 if (pvolume_info->nodfs)
4116 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_DFS;
4117 if (pvolume_info->noperm)
4118 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
4119 if (pvolume_info->setuids)
4120 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
4121 if (pvolume_info->setuidfromacl)
4122 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
4123 if (pvolume_info->server_ino)
4124 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
4125 if (pvolume_info->remap)
4126 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
4127 if (pvolume_info->sfu_remap)
4128 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
4129 if (pvolume_info->no_xattr)
4130 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
4131 if (pvolume_info->sfu_emul)
4132 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
4133 if (pvolume_info->nobrl)
4134 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
4135 if (pvolume_info->nohandlecache)
4136 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE;
4137 if (pvolume_info->nostrictsync)
4138 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
4139 if (pvolume_info->mand_lock)
4140 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
4141 if (pvolume_info->rwpidforward)
4142 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
4143 if (pvolume_info->mode_ace)
4144 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MODE_FROM_SID;
4145 if (pvolume_info->cifs_acl)
4146 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
4147 if (pvolume_info->backupuid_specified) {
4148 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
4149 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
4151 if (pvolume_info->backupgid_specified) {
4152 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
4153 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
4155 if (pvolume_info->override_uid)
4156 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
4157 if (pvolume_info->override_gid)
4158 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
4159 if (pvolume_info->dynperm)
4160 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
4161 if (pvolume_info->fsc)
4162 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
4163 if (pvolume_info->multiuser)
4164 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
4165 CIFS_MOUNT_NO_PERM);
4166 if (pvolume_info->strict_io)
4167 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
4168 if (pvolume_info->direct_io) {
4169 cifs_dbg(FYI, "mounting share using direct i/o\n");
4170 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
4172 if (pvolume_info->cache_ro) {
4173 cifs_dbg(VFS, "mounting share with read only caching. Ensure that the share will not be modified while in use.\n");
4174 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RO_CACHE;
4175 } else if (pvolume_info->cache_rw) {
4176 cifs_dbg(VFS, "mounting share in single client RW caching mode. Ensure that no other systems will be accessing the share.\n");
4177 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_RO_CACHE |
4178 CIFS_MOUNT_RW_CACHE);
4180 if (pvolume_info->mfsymlinks) {
4181 if (pvolume_info->sfu_emul) {
4183 * Our SFU ("Services for Unix" emulation does not allow
4184 * creating symlinks but does allow reading existing SFU
4185 * symlinks (it does allow both creating and reading SFU
4186 * style mknod and FIFOs though). When "mfsymlinks" and
4187 * "sfu" are both enabled at the same time, it allows
4188 * reading both types of symlinks, but will only create
4189 * them with mfsymlinks format. This allows better
4190 * Apple compatibility (probably better for Samba too)
4191 * while still recognizing old Windows style symlinks.
4193 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
4195 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
4198 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
4199 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
4201 if (pvolume_info->prepath) {
4202 cifs_sb->prepath = kstrdup(pvolume_info->prepath, GFP_KERNEL);
4203 if (cifs_sb->prepath == NULL)
4211 cifs_cleanup_volume_info_contents(struct smb_vol *volume_info)
4213 kfree(volume_info->username);
4214 kzfree(volume_info->password);
4215 kfree(volume_info->UNC);
4216 kfree(volume_info->domainname);
4217 kfree(volume_info->iocharset);
4218 kfree(volume_info->prepath);
4222 cifs_cleanup_volume_info(struct smb_vol *volume_info)
4226 cifs_cleanup_volume_info_contents(volume_info);
4230 /* Release all succeed connections */
4231 static inline void mount_put_conns(struct cifs_sb_info *cifs_sb,
4233 struct TCP_Server_Info *server,
4234 struct cifs_ses *ses, struct cifs_tcon *tcon)
4239 cifs_put_tcon(tcon);
4241 cifs_put_smb_ses(ses);
4243 cifs_put_tcp_session(server, 0);
4244 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
4248 /* Get connections for tcp, ses and tcon */
4249 static int mount_get_conns(struct smb_vol *vol, struct cifs_sb_info *cifs_sb,
4251 struct TCP_Server_Info **nserver,
4252 struct cifs_ses **nses, struct cifs_tcon **ntcon)
4255 struct TCP_Server_Info *server;
4256 struct cifs_ses *ses;
4257 struct cifs_tcon *tcon;
4265 /* get a reference to a tcp session */
4266 server = cifs_get_tcp_session(vol);
4267 if (IS_ERR(server)) {
4268 rc = PTR_ERR(server);
4274 if ((vol->max_credits < 20) || (vol->max_credits > 60000))
4275 server->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
4277 server->max_credits = vol->max_credits;
4279 /* get a reference to a SMB session */
4280 ses = cifs_get_smb_ses(server, vol);
4288 if ((vol->persistent == true) && (!(ses->server->capabilities &
4289 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES))) {
4290 cifs_server_dbg(VFS, "persistent handles not supported by server\n");
4294 /* search for existing tcon to this server share */
4295 tcon = cifs_get_tcon(ses, vol);
4303 /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
4304 if (tcon->posix_extensions)
4305 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
4307 /* tell server which Unix caps we support */
4308 if (cap_unix(tcon->ses)) {
4310 * reset of caps checks mount to see if unix extensions disabled
4311 * for just this mount.
4313 reset_cifs_unix_caps(*xid, tcon, cifs_sb, vol);
4314 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
4315 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
4316 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP))
4319 tcon->unix_ext = 0; /* server does not support them */
4321 /* do not care if a following call succeed - informational */
4322 if (!tcon->pipe && server->ops->qfs_tcon) {
4323 server->ops->qfs_tcon(*xid, tcon, cifs_sb);
4324 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE) {
4325 if (tcon->fsDevInfo.DeviceCharacteristics &
4326 cpu_to_le32(FILE_READ_ONLY_DEVICE))
4327 cifs_dbg(VFS, "mounted to read only share\n");
4328 else if ((cifs_sb->mnt_cifs_flags &
4329 CIFS_MOUNT_RW_CACHE) == 0)
4330 cifs_dbg(VFS, "read only mount of RW share\n");
4331 /* no need to log a RW mount of a typical RW share */
4335 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, vol);
4336 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, vol);
4341 static int mount_setup_tlink(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses,
4342 struct cifs_tcon *tcon)
4344 struct tcon_link *tlink;
4346 /* hang the tcon off of the superblock */
4347 tlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4351 tlink->tl_uid = ses->linux_uid;
4352 tlink->tl_tcon = tcon;
4353 tlink->tl_time = jiffies;
4354 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
4355 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4357 cifs_sb->master_tlink = tlink;
4358 spin_lock(&cifs_sb->tlink_tree_lock);
4359 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4360 spin_unlock(&cifs_sb->tlink_tree_lock);
4362 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4367 #ifdef CONFIG_CIFS_DFS_UPCALL
4369 * cifs_build_path_to_root returns full path to root when we do not have an
4370 * exiting connection (tcon)
4373 build_unc_path_to_root(const struct smb_vol *vol,
4374 const struct cifs_sb_info *cifs_sb, bool useppath)
4376 char *full_path, *pos;
4377 unsigned int pplen = useppath && vol->prepath ?
4378 strlen(vol->prepath) + 1 : 0;
4379 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
4381 if (unc_len > MAX_TREE_SIZE)
4382 return ERR_PTR(-EINVAL);
4384 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
4385 if (full_path == NULL)
4386 return ERR_PTR(-ENOMEM);
4388 memcpy(full_path, vol->UNC, unc_len);
4389 pos = full_path + unc_len;
4392 *pos = CIFS_DIR_SEP(cifs_sb);
4393 memcpy(pos + 1, vol->prepath, pplen);
4397 *pos = '\0'; /* add trailing null */
4398 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
4399 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
4404 * expand_dfs_referral - Perform a dfs referral query and update the cifs_sb
4407 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
4408 * to a string containing updated options for the submount. Otherwise it
4409 * will be left untouched.
4411 * Returns the rc from get_dfs_path to the caller, which can be used to
4412 * determine whether there were referrals.
4415 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
4416 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
4420 struct dfs_info3_param referral = {0};
4421 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
4423 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
4426 full_path = build_unc_path_to_root(volume_info, cifs_sb, true);
4427 if (IS_ERR(full_path))
4428 return PTR_ERR(full_path);
4430 /* For DFS paths, skip the first '\' of the UNC */
4431 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
4433 rc = dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb),
4434 ref_path, &referral, NULL);
4436 char *fake_devname = NULL;
4438 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
4439 full_path + 1, &referral,
4441 free_dfs_info_param(&referral);
4443 if (IS_ERR(mdata)) {
4444 rc = PTR_ERR(mdata);
4447 cifs_cleanup_volume_info_contents(volume_info);
4448 rc = cifs_setup_volume_info(volume_info, mdata,
4449 fake_devname, false);
4451 kfree(fake_devname);
4452 kfree(cifs_sb->mountdata);
4453 cifs_sb->mountdata = mdata;
4459 static inline int get_next_dfs_tgt(const char *path,
4460 struct dfs_cache_tgt_list *tgt_list,
4461 struct dfs_cache_tgt_iterator **tgt_it)
4464 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
4466 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
4467 return !*tgt_it ? -EHOSTDOWN : 0;
4470 static int update_vol_info(const struct dfs_cache_tgt_iterator *tgt_it,
4471 struct smb_vol *fake_vol, struct smb_vol *vol)
4473 const char *tgt = dfs_cache_get_tgt_name(tgt_it);
4474 int len = strlen(tgt) + 2;
4477 new_unc = kmalloc(len, GFP_KERNEL);
4480 scnprintf(new_unc, len, "\\%s", tgt);
4485 if (fake_vol->prepath) {
4486 kfree(vol->prepath);
4487 vol->prepath = fake_vol->prepath;
4488 fake_vol->prepath = NULL;
4490 memcpy(&vol->dstaddr, &fake_vol->dstaddr, sizeof(vol->dstaddr));
4495 static int setup_dfs_tgt_conn(const char *path,
4496 const struct dfs_cache_tgt_iterator *tgt_it,
4497 struct cifs_sb_info *cifs_sb,
4498 struct smb_vol *vol,
4500 struct TCP_Server_Info **server,
4501 struct cifs_ses **ses,
4502 struct cifs_tcon **tcon)
4505 struct dfs_info3_param ref = {0};
4506 char *mdata = NULL, *fake_devname = NULL;
4507 struct smb_vol fake_vol = {NULL};
4509 cifs_dbg(FYI, "%s: dfs path: %s\n", __func__, path);
4511 rc = dfs_cache_get_tgt_referral(path, tgt_it, &ref);
4515 mdata = cifs_compose_mount_options(cifs_sb->mountdata, path, &ref,
4517 free_dfs_info_param(&ref);
4519 if (IS_ERR(mdata)) {
4520 rc = PTR_ERR(mdata);
4523 cifs_dbg(FYI, "%s: fake_devname: %s\n", __func__, fake_devname);
4524 rc = cifs_setup_volume_info(&fake_vol, mdata, fake_devname,
4528 kfree(fake_devname);
4532 * We use a 'fake_vol' here because we need pass it down to the
4533 * mount_{get,put} functions to test connection against new DFS
4536 mount_put_conns(cifs_sb, *xid, *server, *ses, *tcon);
4537 rc = mount_get_conns(&fake_vol, cifs_sb, xid, server, ses,
4541 * We were able to connect to new target server.
4542 * Update current volume info with new target server.
4544 rc = update_vol_info(tgt_it, &fake_vol, vol);
4547 cifs_cleanup_volume_info_contents(&fake_vol);
4551 static int mount_do_dfs_failover(const char *path,
4552 struct cifs_sb_info *cifs_sb,
4553 struct smb_vol *vol,
4554 struct cifs_ses *root_ses,
4556 struct TCP_Server_Info **server,
4557 struct cifs_ses **ses,
4558 struct cifs_tcon **tcon)
4561 struct dfs_cache_tgt_list tgt_list;
4562 struct dfs_cache_tgt_iterator *tgt_it = NULL;
4564 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
4567 rc = dfs_cache_noreq_find(path, NULL, &tgt_list);
4572 /* Get next DFS target server - if any */
4573 rc = get_next_dfs_tgt(path, &tgt_list, &tgt_it);
4576 /* Connect to next DFS target */
4577 rc = setup_dfs_tgt_conn(path, tgt_it, cifs_sb, vol, xid, server,
4579 if (!rc || rc == -EACCES || rc == -EOPNOTSUPP)
4584 * Update DFS target hint in DFS referral cache with the target
4585 * server we successfully reconnected to.
4587 rc = dfs_cache_update_tgthint(*xid, root_ses ? root_ses : *ses,
4589 cifs_remap(cifs_sb), path,
4592 dfs_cache_free_tgts(&tgt_list);
4598 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
4599 const char *devname, bool is_smb3)
4603 if (cifs_parse_mount_options(mount_data, devname, volume_info, is_smb3))
4606 if (volume_info->nullauth) {
4607 cifs_dbg(FYI, "Anonymous login\n");
4608 kfree(volume_info->username);
4609 volume_info->username = NULL;
4610 } else if (volume_info->username) {
4611 /* BB fixme parse for domain name here */
4612 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
4614 cifs_dbg(VFS, "No username specified\n");
4615 /* In userspace mount helper we can get user name from alternate
4616 locations such as env variables and files on disk */
4620 /* this is needed for ASCII cp to Unicode converts */
4621 if (volume_info->iocharset == NULL) {
4622 /* load_nls_default cannot return null */
4623 volume_info->local_nls = load_nls_default();
4625 volume_info->local_nls = load_nls(volume_info->iocharset);
4626 if (volume_info->local_nls == NULL) {
4627 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
4628 volume_info->iocharset);
4637 cifs_get_volume_info(char *mount_data, const char *devname, bool is_smb3)
4640 struct smb_vol *volume_info;
4642 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
4644 return ERR_PTR(-ENOMEM);
4646 rc = cifs_setup_volume_info(volume_info, mount_data, devname, is_smb3);
4648 cifs_cleanup_volume_info(volume_info);
4649 volume_info = ERR_PTR(rc);
4656 cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
4658 struct cifs_tcon *tcon,
4659 struct cifs_sb_info *cifs_sb,
4666 int skip = added_treename ? 1 : 0;
4668 sep = CIFS_DIR_SEP(cifs_sb);
4671 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
4673 /* skip separators */
4678 /* next separator */
4679 while (*s && *s != sep)
4682 * if the treename is added, we then have to skip the first
4683 * part within the separators
4690 * temporarily null-terminate the path at the end of
4691 * the current component
4695 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
4703 * Check if path is remote (e.g. a DFS share). Return -EREMOTE if it is,
4706 static int is_path_remote(struct cifs_sb_info *cifs_sb, struct smb_vol *vol,
4707 const unsigned int xid,
4708 struct TCP_Server_Info *server,
4709 struct cifs_tcon *tcon)
4714 if (!server->ops->is_path_accessible)
4718 * cifs_build_path_to_root works only when we have a valid tcon
4720 full_path = cifs_build_path_to_root(vol, cifs_sb, tcon,
4721 tcon->Flags & SMB_SHARE_IS_IN_DFS);
4722 if (full_path == NULL)
4725 cifs_dbg(FYI, "%s: full_path: %s\n", __func__, full_path);
4727 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
4729 if (rc != 0 && rc != -EREMOTE) {
4734 if (rc != -EREMOTE) {
4735 rc = cifs_are_all_path_components_accessible(server, xid, tcon,
4736 cifs_sb, full_path, tcon->Flags & SMB_SHARE_IS_IN_DFS);
4738 cifs_server_dbg(VFS, "cannot query dirs between root and final path, "
4739 "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
4740 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
4749 #ifdef CONFIG_CIFS_DFS_UPCALL
4750 static inline void set_root_tcon(struct cifs_sb_info *cifs_sb,
4751 struct cifs_tcon *tcon,
4752 struct cifs_tcon **root)
4754 spin_lock(&cifs_tcp_ses_lock);
4756 tcon->remap = cifs_remap(cifs_sb);
4757 spin_unlock(&cifs_tcp_ses_lock);
4761 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *vol)
4765 struct cifs_ses *ses;
4766 struct cifs_tcon *root_tcon = NULL;
4767 struct cifs_tcon *tcon = NULL;
4768 struct TCP_Server_Info *server;
4769 char *root_path = NULL, *full_path = NULL;
4770 char *old_mountdata, *origin_mountdata = NULL;
4773 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4775 /* If not a standalone DFS root, then check if path is remote */
4776 rc = dfs_cache_find(xid, ses, cifs_sb->local_nls,
4777 cifs_remap(cifs_sb), vol->UNC + 1, NULL,
4780 rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
4788 * If first DFS target server went offline and we failed to connect it,
4789 * server and ses pointers are NULL at this point, though we still have
4790 * chance to get a cached DFS referral in expand_dfs_referral() and
4791 * retry next target available in it.
4793 * If a NULL ses ptr is passed to dfs_cache_find(), a lookup will be
4794 * performed against DFS path and *no* requests will be sent to server
4795 * for any new DFS referrals. Hence it's safe to skip checking whether
4796 * server or ses ptr is NULL.
4798 if (rc == -EACCES || rc == -EOPNOTSUPP)
4801 root_path = build_unc_path_to_root(vol, cifs_sb, false);
4802 if (IS_ERR(root_path)) {
4803 rc = PTR_ERR(root_path);
4808 full_path = build_unc_path_to_root(vol, cifs_sb, true);
4809 if (IS_ERR(full_path)) {
4810 rc = PTR_ERR(full_path);
4815 * Perform an unconditional check for whether there are DFS
4816 * referrals for this path without prefix, to provide support
4817 * for DFS referrals from w2k8 servers which don't seem to respond
4818 * with PATH_NOT_COVERED to requests that include the prefix.
4819 * Chase the referral if found, otherwise continue normally.
4821 old_mountdata = cifs_sb->mountdata;
4822 (void)expand_dfs_referral(xid, ses, vol, cifs_sb, false);
4824 if (cifs_sb->mountdata == NULL) {
4829 /* Save DFS root volume information for DFS refresh worker */
4830 origin_mountdata = kstrndup(cifs_sb->mountdata,
4831 strlen(cifs_sb->mountdata), GFP_KERNEL);
4832 if (!origin_mountdata) {
4837 if (cifs_sb->mountdata != old_mountdata) {
4838 /* If we were redirected, reconnect to new target server */
4839 mount_put_conns(cifs_sb, xid, server, ses, tcon);
4840 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4843 if (rc == -EACCES || rc == -EOPNOTSUPP)
4845 /* Perform DFS failover to any other DFS targets */
4846 rc = mount_do_dfs_failover(root_path + 1, cifs_sb, vol, NULL,
4847 &xid, &server, &ses, &tcon);
4853 root_path = build_unc_path_to_root(vol, cifs_sb, false);
4854 if (IS_ERR(root_path)) {
4855 rc = PTR_ERR(root_path);
4859 /* Cache out resolved root server */
4860 (void)dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb),
4861 root_path + 1, NULL, NULL);
4865 set_root_tcon(cifs_sb, tcon, &root_tcon);
4867 for (count = 1; ;) {
4869 rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
4870 if (!rc || rc != -EREMOTE)
4874 * BB: when we implement proper loop detection,
4875 * we will remove this check. But now we need it
4876 * to prevent an indefinite loop if 'DFS tree' is
4877 * misconfigured (i.e. has loops).
4879 if (count++ > MAX_NESTED_LINKS) {
4885 full_path = build_unc_path_to_root(vol, cifs_sb, true);
4886 if (IS_ERR(full_path)) {
4887 rc = PTR_ERR(full_path);
4892 old_mountdata = cifs_sb->mountdata;
4893 rc = expand_dfs_referral(xid, root_tcon->ses, vol, cifs_sb,
4898 if (cifs_sb->mountdata != old_mountdata) {
4899 mount_put_conns(cifs_sb, xid, server, ses, tcon);
4900 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses,
4903 * Ensure that DFS referrals go through new root server.
4906 (tcon->share_flags & (SHI1005_FLAGS_DFS |
4907 SHI1005_FLAGS_DFS_ROOT))) {
4908 cifs_put_tcon(root_tcon);
4909 set_root_tcon(cifs_sb, tcon, &root_tcon);
4913 if (rc == -EACCES || rc == -EOPNOTSUPP)
4915 /* Perform DFS failover to any other DFS targets */
4916 rc = mount_do_dfs_failover(full_path + 1, cifs_sb, vol,
4917 root_tcon->ses, &xid,
4918 &server, &ses, &tcon);
4919 if (rc == -EACCES || rc == -EOPNOTSUPP || !server ||
4924 cifs_put_tcon(root_tcon);
4929 spin_lock(&cifs_tcp_ses_lock);
4930 if (!tcon->dfs_path) {
4931 /* Save full path in new tcon to do failover when reconnecting tcons */
4932 tcon->dfs_path = full_path;
4934 tcon->remap = cifs_remap(cifs_sb);
4936 cifs_sb->origin_fullpath = kstrndup(tcon->dfs_path,
4937 strlen(tcon->dfs_path),
4939 if (!cifs_sb->origin_fullpath) {
4940 spin_unlock(&cifs_tcp_ses_lock);
4944 spin_unlock(&cifs_tcp_ses_lock);
4946 rc = dfs_cache_add_vol(origin_mountdata, vol, cifs_sb->origin_fullpath);
4948 kfree(cifs_sb->origin_fullpath);
4952 * After reconnecting to a different server, unique ids won't
4953 * match anymore, so we disable serverino. This prevents
4954 * dentry revalidation to think the dentry are stale (ESTALE).
4956 cifs_autodisable_serverino(cifs_sb);
4959 return mount_setup_tlink(cifs_sb, ses, tcon);
4964 kfree(origin_mountdata);
4965 mount_put_conns(cifs_sb, xid, server, ses, tcon);
4969 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *vol)
4973 struct cifs_ses *ses;
4974 struct cifs_tcon *tcon;
4975 struct TCP_Server_Info *server;
4977 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4982 rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
4991 return mount_setup_tlink(cifs_sb, ses, tcon);
4994 mount_put_conns(cifs_sb, xid, server, ses, tcon);
5000 * Issue a TREE_CONNECT request.
5003 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
5004 const char *tree, struct cifs_tcon *tcon,
5005 const struct nls_table *nls_codepage)
5007 struct smb_hdr *smb_buffer;
5008 struct smb_hdr *smb_buffer_response;
5011 unsigned char *bcc_ptr;
5014 __u16 bytes_left, count;
5019 smb_buffer = cifs_buf_get();
5020 if (smb_buffer == NULL)
5023 smb_buffer_response = smb_buffer;
5025 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
5026 NULL /*no tid */ , 4 /*wct */ );
5028 smb_buffer->Mid = get_next_mid(ses->server);
5029 smb_buffer->Uid = ses->Suid;
5030 pSMB = (TCONX_REQ *) smb_buffer;
5031 pSMBr = (TCONX_RSP *) smb_buffer_response;
5033 pSMB->AndXCommand = 0xFF;
5034 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
5035 bcc_ptr = &pSMB->Password[0];
5036 if (tcon->pipe || (ses->server->sec_mode & SECMODE_USER)) {
5037 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
5038 *bcc_ptr = 0; /* password is null byte */
5039 bcc_ptr++; /* skip password */
5040 /* already aligned so no need to do it below */
5042 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
5043 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
5044 specified as required (when that support is added to
5045 the vfs in the future) as only NTLM or the much
5046 weaker LANMAN (which we do not send by default) is accepted
5047 by Samba (not sure whether other servers allow
5048 NTLMv2 password here) */
5049 #ifdef CONFIG_CIFS_WEAK_PW_HASH
5050 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
5051 (ses->sectype == LANMAN))
5052 calc_lanman_hash(tcon->password, ses->server->cryptkey,
5053 ses->server->sec_mode &
5054 SECMODE_PW_ENCRYPT ? true : false,
5057 #endif /* CIFS_WEAK_PW_HASH */
5058 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
5059 bcc_ptr, nls_codepage);
5061 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
5063 cifs_buf_release(smb_buffer);
5067 bcc_ptr += CIFS_AUTH_RESP_SIZE;
5068 if (ses->capabilities & CAP_UNICODE) {
5069 /* must align unicode strings */
5070 *bcc_ptr = 0; /* null byte password */
5075 if (ses->server->sign)
5076 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
5078 if (ses->capabilities & CAP_STATUS32) {
5079 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
5081 if (ses->capabilities & CAP_DFS) {
5082 smb_buffer->Flags2 |= SMBFLG2_DFS;
5084 if (ses->capabilities & CAP_UNICODE) {
5085 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
5087 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
5088 6 /* max utf8 char length in bytes */ *
5089 (/* server len*/ + 256 /* share len */), nls_codepage);
5090 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
5091 bcc_ptr += 2; /* skip trailing null */
5092 } else { /* ASCII */
5093 strcpy(bcc_ptr, tree);
5094 bcc_ptr += strlen(tree) + 1;
5096 strcpy(bcc_ptr, "?????");
5097 bcc_ptr += strlen("?????");
5099 count = bcc_ptr - &pSMB->Password[0];
5100 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
5101 pSMB->hdr.smb_buf_length) + count);
5102 pSMB->ByteCount = cpu_to_le16(count);
5104 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
5107 /* above now done in SendReceive */
5111 tcon->tidStatus = CifsGood;
5112 tcon->need_reconnect = false;
5113 tcon->tid = smb_buffer_response->Tid;
5114 bcc_ptr = pByteArea(smb_buffer_response);
5115 bytes_left = get_bcc(smb_buffer_response);
5116 length = strnlen(bcc_ptr, bytes_left - 2);
5117 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
5123 /* skip service field (NB: this field is always ASCII) */
5125 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
5126 (bcc_ptr[2] == 'C')) {
5127 cifs_dbg(FYI, "IPC connection\n");
5131 } else if (length == 2) {
5132 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
5133 /* the most common case */
5134 cifs_dbg(FYI, "disk share connection\n");
5137 bcc_ptr += length + 1;
5138 bytes_left -= (length + 1);
5139 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
5141 /* mostly informational -- no need to fail on error here */
5142 kfree(tcon->nativeFileSystem);
5143 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
5144 bytes_left, is_unicode,
5147 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
5149 if ((smb_buffer_response->WordCount == 3) ||
5150 (smb_buffer_response->WordCount == 7))
5151 /* field is in same location */
5152 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
5155 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
5158 cifs_buf_release(smb_buffer);
5162 static void delayed_free(struct rcu_head *p)
5164 struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
5165 unload_nls(sbi->local_nls);
5170 cifs_umount(struct cifs_sb_info *cifs_sb)
5172 struct rb_root *root = &cifs_sb->tlink_tree;
5173 struct rb_node *node;
5174 struct tcon_link *tlink;
5176 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
5178 spin_lock(&cifs_sb->tlink_tree_lock);
5179 while ((node = rb_first(root))) {
5180 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
5181 cifs_get_tlink(tlink);
5182 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
5183 rb_erase(node, root);
5185 spin_unlock(&cifs_sb->tlink_tree_lock);
5186 cifs_put_tlink(tlink);
5187 spin_lock(&cifs_sb->tlink_tree_lock);
5189 spin_unlock(&cifs_sb->tlink_tree_lock);
5191 kfree(cifs_sb->mountdata);
5192 kfree(cifs_sb->prepath);
5193 #ifdef CONFIG_CIFS_DFS_UPCALL
5194 dfs_cache_del_vol(cifs_sb->origin_fullpath);
5195 kfree(cifs_sb->origin_fullpath);
5197 call_rcu(&cifs_sb->rcu, delayed_free);
5201 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
5204 struct TCP_Server_Info *server = ses->server;
5206 if (!server->ops->need_neg || !server->ops->negotiate)
5209 /* only send once per connect */
5210 if (!server->ops->need_neg(server))
5213 rc = server->ops->negotiate(xid, ses);
5215 spin_lock(&GlobalMid_Lock);
5216 if (server->tcpStatus == CifsNeedNegotiate)
5217 server->tcpStatus = CifsGood;
5220 spin_unlock(&GlobalMid_Lock);
5227 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
5228 struct nls_table *nls_info)
5231 struct TCP_Server_Info *server = ses->server;
5233 ses->capabilities = server->capabilities;
5234 if (linuxExtEnabled == 0)
5235 ses->capabilities &= (~server->vals->cap_unix);
5237 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
5238 server->sec_mode, server->capabilities, server->timeAdj);
5240 if (ses->auth_key.response) {
5241 cifs_dbg(FYI, "Free previous auth_key.response = %p\n",
5242 ses->auth_key.response);
5243 kfree(ses->auth_key.response);
5244 ses->auth_key.response = NULL;
5245 ses->auth_key.len = 0;
5248 if (server->ops->sess_setup)
5249 rc = server->ops->sess_setup(xid, ses, nls_info);
5252 cifs_server_dbg(VFS, "Send error in SessSetup = %d\n", rc);
5258 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
5260 vol->sectype = ses->sectype;
5262 /* krb5 is special, since we don't need username or pw */
5263 if (vol->sectype == Kerberos)
5266 return cifs_set_cifscreds(vol, ses);
5269 static struct cifs_tcon *
5270 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
5273 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
5274 struct cifs_ses *ses;
5275 struct cifs_tcon *tcon = NULL;
5276 struct smb_vol *vol_info;
5278 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
5279 if (vol_info == NULL)
5280 return ERR_PTR(-ENOMEM);
5282 vol_info->local_nls = cifs_sb->local_nls;
5283 vol_info->linux_uid = fsuid;
5284 vol_info->cred_uid = fsuid;
5285 vol_info->UNC = master_tcon->treeName;
5286 vol_info->retry = master_tcon->retry;
5287 vol_info->nocase = master_tcon->nocase;
5288 vol_info->nohandlecache = master_tcon->nohandlecache;
5289 vol_info->local_lease = master_tcon->local_lease;
5290 vol_info->no_lease = master_tcon->no_lease;
5291 vol_info->resilient = master_tcon->use_resilient;
5292 vol_info->persistent = master_tcon->use_persistent;
5293 vol_info->handle_timeout = master_tcon->handle_timeout;
5294 vol_info->no_linux_ext = !master_tcon->unix_ext;
5295 vol_info->linux_ext = master_tcon->posix_extensions;
5296 vol_info->sectype = master_tcon->ses->sectype;
5297 vol_info->sign = master_tcon->ses->sign;
5298 vol_info->seal = master_tcon->seal;
5300 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
5306 /* get a reference for the same TCP session */
5307 spin_lock(&cifs_tcp_ses_lock);
5308 ++master_tcon->ses->server->srv_count;
5309 spin_unlock(&cifs_tcp_ses_lock);
5311 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
5313 tcon = (struct cifs_tcon *)ses;
5314 cifs_put_tcp_session(master_tcon->ses->server, 0);
5318 tcon = cifs_get_tcon(ses, vol_info);
5320 cifs_put_smb_ses(ses);
5325 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
5328 kfree(vol_info->username);
5329 kzfree(vol_info->password);
5336 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
5338 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
5341 /* find and return a tlink with given uid */
5342 static struct tcon_link *
5343 tlink_rb_search(struct rb_root *root, kuid_t uid)
5345 struct rb_node *node = root->rb_node;
5346 struct tcon_link *tlink;
5349 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
5351 if (uid_gt(tlink->tl_uid, uid))
5352 node = node->rb_left;
5353 else if (uid_lt(tlink->tl_uid, uid))
5354 node = node->rb_right;
5361 /* insert a tcon_link into the tree */
5363 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
5365 struct rb_node **new = &(root->rb_node), *parent = NULL;
5366 struct tcon_link *tlink;
5369 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
5372 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
5373 new = &((*new)->rb_left);
5375 new = &((*new)->rb_right);
5378 rb_link_node(&new_tlink->tl_rbnode, parent, new);
5379 rb_insert_color(&new_tlink->tl_rbnode, root);
5383 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
5386 * If the superblock doesn't refer to a multiuser mount, then just return
5387 * the master tcon for the mount.
5389 * First, search the rbtree for an existing tcon for this fsuid. If one
5390 * exists, then check to see if it's pending construction. If it is then wait
5391 * for construction to complete. Once it's no longer pending, check to see if
5392 * it failed and either return an error or retry construction, depending on
5395 * If one doesn't exist then insert a new tcon_link struct into the tree and
5396 * try to construct a new one.
5399 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
5402 kuid_t fsuid = current_fsuid();
5403 struct tcon_link *tlink, *newtlink;
5405 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
5406 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
5408 spin_lock(&cifs_sb->tlink_tree_lock);
5409 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
5411 cifs_get_tlink(tlink);
5412 spin_unlock(&cifs_sb->tlink_tree_lock);
5414 if (tlink == NULL) {
5415 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
5416 if (newtlink == NULL)
5417 return ERR_PTR(-ENOMEM);
5418 newtlink->tl_uid = fsuid;
5419 newtlink->tl_tcon = ERR_PTR(-EACCES);
5420 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
5421 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
5422 cifs_get_tlink(newtlink);
5424 spin_lock(&cifs_sb->tlink_tree_lock);
5425 /* was one inserted after previous search? */
5426 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
5428 cifs_get_tlink(tlink);
5429 spin_unlock(&cifs_sb->tlink_tree_lock);
5431 goto wait_for_construction;
5434 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
5435 spin_unlock(&cifs_sb->tlink_tree_lock);
5437 wait_for_construction:
5438 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
5439 TASK_INTERRUPTIBLE);
5441 cifs_put_tlink(tlink);
5442 return ERR_PTR(-ERESTARTSYS);
5445 /* if it's good, return it */
5446 if (!IS_ERR(tlink->tl_tcon))
5449 /* return error if we tried this already recently */
5450 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
5451 cifs_put_tlink(tlink);
5452 return ERR_PTR(-EACCES);
5455 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
5456 goto wait_for_construction;
5459 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
5460 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
5461 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
5463 if (IS_ERR(tlink->tl_tcon)) {
5464 cifs_put_tlink(tlink);
5465 return ERR_PTR(-EACCES);
5472 * periodic workqueue job that scans tcon_tree for a superblock and closes
5476 cifs_prune_tlinks(struct work_struct *work)
5478 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
5480 struct rb_root *root = &cifs_sb->tlink_tree;
5481 struct rb_node *node;
5482 struct rb_node *tmp;
5483 struct tcon_link *tlink;
5486 * Because we drop the spinlock in the loop in order to put the tlink
5487 * it's not guarded against removal of links from the tree. The only
5488 * places that remove entries from the tree are this function and
5489 * umounts. Because this function is non-reentrant and is canceled
5490 * before umount can proceed, this is safe.
5492 spin_lock(&cifs_sb->tlink_tree_lock);
5493 node = rb_first(root);
5494 while (node != NULL) {
5496 node = rb_next(tmp);
5497 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
5499 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
5500 atomic_read(&tlink->tl_count) != 0 ||
5501 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
5504 cifs_get_tlink(tlink);
5505 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
5506 rb_erase(tmp, root);
5508 spin_unlock(&cifs_sb->tlink_tree_lock);
5509 cifs_put_tlink(tlink);
5510 spin_lock(&cifs_sb->tlink_tree_lock);
5512 spin_unlock(&cifs_sb->tlink_tree_lock);
5514 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,