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
,
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_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
,
101 /* Mount options which take numeric value */
102 Opt_backupuid
, Opt_backupgid
, Opt_uid
,
103 Opt_cruid
, Opt_gid
, Opt_file_mode
,
104 Opt_dirmode
, Opt_port
,
105 Opt_blocksize
, Opt_rsize
, Opt_wsize
, Opt_actimeo
,
106 Opt_echo_interval
, Opt_max_credits
, Opt_handletimeout
,
109 /* Mount options which take string value */
110 Opt_user
, Opt_pass
, Opt_ip
,
111 Opt_domain
, Opt_srcaddr
, Opt_iocharset
,
112 Opt_netbiosname
, Opt_servern
,
113 Opt_ver
, Opt_vers
, Opt_sec
, Opt_cache
,
115 /* Mount options to be ignored */
118 /* Options which could be blank */
126 static const match_table_t cifs_mount_option_tokens
= {
128 { Opt_user_xattr
, "user_xattr" },
129 { Opt_nouser_xattr
, "nouser_xattr" },
130 { Opt_forceuid
, "forceuid" },
131 { Opt_noforceuid
, "noforceuid" },
132 { Opt_forcegid
, "forcegid" },
133 { Opt_noforcegid
, "noforcegid" },
134 { Opt_noblocksend
, "noblocksend" },
135 { Opt_noautotune
, "noautotune" },
136 { Opt_hard
, "hard" },
137 { Opt_soft
, "soft" },
138 { Opt_perm
, "perm" },
139 { Opt_noperm
, "noperm" },
140 { Opt_mapchars
, "mapchars" }, /* SFU style */
141 { Opt_nomapchars
, "nomapchars" },
142 { Opt_mapposix
, "mapposix" }, /* SFM style */
143 { Opt_nomapposix
, "nomapposix" },
145 { Opt_nosfu
, "nosfu" },
146 { Opt_nodfs
, "nodfs" },
147 { Opt_posixpaths
, "posixpaths" },
148 { Opt_noposixpaths
, "noposixpaths" },
149 { Opt_nounix
, "nounix" },
150 { Opt_nounix
, "nolinux" },
151 { Opt_nounix
, "noposix" },
152 { Opt_unix
, "unix" },
153 { Opt_unix
, "linux" },
154 { Opt_unix
, "posix" },
155 { Opt_nocase
, "nocase" },
156 { Opt_nocase
, "ignorecase" },
158 { Opt_nobrl
, "nobrl" },
159 { Opt_handlecache
, "handlecache" },
160 { Opt_nohandlecache
, "nohandlecache" },
161 { Opt_nobrl
, "nolock" },
162 { Opt_forcemandatorylock
, "forcemandatorylock" },
163 { Opt_forcemandatorylock
, "forcemand" },
164 { Opt_setuids
, "setuids" },
165 { Opt_nosetuids
, "nosetuids" },
166 { Opt_setuidfromacl
, "idsfromsid" },
167 { Opt_dynperm
, "dynperm" },
168 { Opt_nodynperm
, "nodynperm" },
169 { Opt_nohard
, "nohard" },
170 { Opt_nosoft
, "nosoft" },
171 { Opt_nointr
, "nointr" },
172 { Opt_intr
, "intr" },
173 { Opt_nostrictsync
, "nostrictsync" },
174 { Opt_strictsync
, "strictsync" },
175 { Opt_serverino
, "serverino" },
176 { Opt_noserverino
, "noserverino" },
177 { Opt_rwpidforward
, "rwpidforward" },
178 { Opt_cifsacl
, "cifsacl" },
179 { Opt_nocifsacl
, "nocifsacl" },
181 { Opt_noacl
, "noacl" },
182 { Opt_locallease
, "locallease" },
183 { Opt_sign
, "sign" },
184 { Opt_seal
, "seal" },
185 { Opt_noac
, "noac" },
187 { Opt_mfsymlinks
, "mfsymlinks" },
188 { Opt_multiuser
, "multiuser" },
189 { Opt_sloppy
, "sloppy" },
190 { Opt_nosharesock
, "nosharesock" },
191 { Opt_persistent
, "persistenthandles"},
192 { Opt_nopersistent
, "nopersistenthandles"},
193 { Opt_resilient
, "resilienthandles"},
194 { Opt_noresilient
, "noresilienthandles"},
195 { Opt_domainauto
, "domainauto"},
198 { Opt_backupuid
, "backupuid=%s" },
199 { Opt_backupgid
, "backupgid=%s" },
200 { Opt_uid
, "uid=%s" },
201 { Opt_cruid
, "cruid=%s" },
202 { Opt_gid
, "gid=%s" },
203 { Opt_file_mode
, "file_mode=%s" },
204 { Opt_dirmode
, "dirmode=%s" },
205 { Opt_dirmode
, "dir_mode=%s" },
206 { Opt_port
, "port=%s" },
207 { Opt_blocksize
, "bsize=%s" },
208 { Opt_rsize
, "rsize=%s" },
209 { Opt_wsize
, "wsize=%s" },
210 { Opt_actimeo
, "actimeo=%s" },
211 { Opt_handletimeout
, "handletimeout=%s" },
212 { Opt_echo_interval
, "echo_interval=%s" },
213 { Opt_max_credits
, "max_credits=%s" },
214 { Opt_snapshot
, "snapshot=%s" },
216 { Opt_blank_user
, "user=" },
217 { Opt_blank_user
, "username=" },
218 { Opt_user
, "user=%s" },
219 { Opt_user
, "username=%s" },
220 { Opt_blank_pass
, "pass=" },
221 { Opt_blank_pass
, "password=" },
222 { Opt_pass
, "pass=%s" },
223 { Opt_pass
, "password=%s" },
224 { Opt_blank_ip
, "ip=" },
225 { Opt_blank_ip
, "addr=" },
227 { Opt_ip
, "addr=%s" },
228 { Opt_ignore
, "unc=%s" },
229 { Opt_ignore
, "target=%s" },
230 { Opt_ignore
, "path=%s" },
231 { Opt_domain
, "dom=%s" },
232 { Opt_domain
, "domain=%s" },
233 { Opt_domain
, "workgroup=%s" },
234 { Opt_srcaddr
, "srcaddr=%s" },
235 { Opt_ignore
, "prefixpath=%s" },
236 { Opt_iocharset
, "iocharset=%s" },
237 { Opt_netbiosname
, "netbiosname=%s" },
238 { Opt_servern
, "servern=%s" },
239 { Opt_ver
, "ver=%s" },
240 { Opt_vers
, "vers=%s" },
241 { Opt_sec
, "sec=%s" },
242 { Opt_cache
, "cache=%s" },
244 { Opt_ignore
, "cred" },
245 { Opt_ignore
, "credentials" },
246 { Opt_ignore
, "cred=%s" },
247 { Opt_ignore
, "credentials=%s" },
248 { Opt_ignore
, "guest" },
249 { Opt_ignore
, "rw" },
250 { Opt_ignore
, "ro" },
251 { Opt_ignore
, "suid" },
252 { Opt_ignore
, "nosuid" },
253 { Opt_ignore
, "exec" },
254 { Opt_ignore
, "noexec" },
255 { Opt_ignore
, "nodev" },
256 { Opt_ignore
, "noauto" },
257 { Opt_ignore
, "dev" },
258 { Opt_ignore
, "mand" },
259 { Opt_ignore
, "nomand" },
260 { Opt_ignore
, "relatime" },
261 { Opt_ignore
, "_netdev" },
267 Opt_sec_krb5
, Opt_sec_krb5i
, Opt_sec_krb5p
,
268 Opt_sec_ntlmsspi
, Opt_sec_ntlmssp
,
269 Opt_ntlm
, Opt_sec_ntlmi
, Opt_sec_ntlmv2
,
270 Opt_sec_ntlmv2i
, Opt_sec_lanman
,
276 static const match_table_t cifs_secflavor_tokens
= {
277 { Opt_sec_krb5
, "krb5" },
278 { Opt_sec_krb5i
, "krb5i" },
279 { Opt_sec_krb5p
, "krb5p" },
280 { Opt_sec_ntlmsspi
, "ntlmsspi" },
281 { Opt_sec_ntlmssp
, "ntlmssp" },
282 { Opt_ntlm
, "ntlm" },
283 { Opt_sec_ntlmi
, "ntlmi" },
284 { Opt_sec_ntlmv2
, "nontlm" },
285 { Opt_sec_ntlmv2
, "ntlmv2" },
286 { Opt_sec_ntlmv2i
, "ntlmv2i" },
287 { Opt_sec_lanman
, "lanman" },
288 { Opt_sec_none
, "none" },
290 { Opt_sec_err
, NULL
}
301 static const match_table_t cifs_cacheflavor_tokens
= {
302 { Opt_cache_loose
, "loose" },
303 { Opt_cache_strict
, "strict" },
304 { Opt_cache_none
, "none" },
305 { Opt_cache_err
, NULL
}
308 static const match_table_t cifs_smb_version_tokens
= {
309 { Smb_1
, SMB1_VERSION_STRING
},
310 { Smb_20
, SMB20_VERSION_STRING
},
311 { Smb_21
, SMB21_VERSION_STRING
},
312 { Smb_30
, SMB30_VERSION_STRING
},
313 { Smb_302
, SMB302_VERSION_STRING
},
314 { Smb_302
, ALT_SMB302_VERSION_STRING
},
315 { Smb_311
, SMB311_VERSION_STRING
},
316 { Smb_311
, ALT_SMB311_VERSION_STRING
},
317 { Smb_3any
, SMB3ANY_VERSION_STRING
},
318 { Smb_default
, SMBDEFAULT_VERSION_STRING
},
319 { Smb_version_err
, NULL
}
322 static int ip_connect(struct TCP_Server_Info
*server
);
323 static int generic_ip_connect(struct TCP_Server_Info
*server
);
324 static void tlink_rb_insert(struct rb_root
*root
, struct tcon_link
*new_tlink
);
325 static void cifs_prune_tlinks(struct work_struct
*work
);
326 static char *extract_hostname(const char *unc
);
329 * Resolve hostname and set ip addr in tcp ses. Useful for hostnames that may
330 * get their ip addresses changed at some point.
332 * This should be called with server->srv_mutex held.
334 #ifdef CONFIG_CIFS_DFS_UPCALL
335 static int reconn_set_ipaddr(struct TCP_Server_Info
*server
)
339 char *unc
, *ipaddr
= NULL
;
341 if (!server
->hostname
)
344 len
= strlen(server
->hostname
) + 3;
346 unc
= kmalloc(len
, GFP_KERNEL
);
348 cifs_dbg(FYI
, "%s: failed to create UNC path\n", __func__
);
351 scnprintf(unc
, len
, "\\\\%s", server
->hostname
);
353 rc
= dns_resolve_server_name_to_ip(unc
, &ipaddr
);
357 cifs_dbg(FYI
, "%s: failed to resolve server part of %s to IP: %d\n",
358 __func__
, server
->hostname
, rc
);
362 rc
= cifs_convert_address((struct sockaddr
*)&server
->dstaddr
, ipaddr
,
369 static inline int reconn_set_ipaddr(struct TCP_Server_Info
*server
)
375 #ifdef CONFIG_CIFS_DFS_UPCALL
376 struct super_cb_data
{
377 struct TCP_Server_Info
*server
;
378 struct cifs_sb_info
*cifs_sb
;
381 /* These functions must be called with server->srv_mutex held */
383 static void super_cb(struct super_block
*sb
, void *arg
)
385 struct super_cb_data
*d
= arg
;
386 struct cifs_sb_info
*cifs_sb
;
387 struct cifs_tcon
*tcon
;
392 cifs_sb
= CIFS_SB(sb
);
393 tcon
= cifs_sb_master_tcon(cifs_sb
);
394 if (tcon
->ses
->server
== d
->server
)
395 d
->cifs_sb
= cifs_sb
;
398 static inline struct cifs_sb_info
*
399 find_super_by_tcp(struct TCP_Server_Info
*server
)
401 struct super_cb_data d
= {
406 iterate_supers_type(&cifs_fs_type
, super_cb
, &d
);
407 return d
.cifs_sb
? d
.cifs_sb
: ERR_PTR(-ENOENT
);
410 static void reconn_inval_dfs_target(struct TCP_Server_Info
*server
,
411 struct cifs_sb_info
*cifs_sb
,
412 struct dfs_cache_tgt_list
*tgt_list
,
413 struct dfs_cache_tgt_iterator
**tgt_it
)
417 if (!cifs_sb
|| !cifs_sb
->origin_fullpath
|| !tgt_list
||
422 *tgt_it
= dfs_cache_get_tgt_iterator(tgt_list
);
424 *tgt_it
= dfs_cache_get_next_tgt(tgt_list
, *tgt_it
);
426 *tgt_it
= dfs_cache_get_tgt_iterator(tgt_list
);
429 cifs_dbg(FYI
, "%s: UNC: %s\n", __func__
, cifs_sb
->origin_fullpath
);
431 name
= dfs_cache_get_tgt_name(*tgt_it
);
433 kfree(server
->hostname
);
435 server
->hostname
= extract_hostname(name
);
436 if (IS_ERR(server
->hostname
)) {
438 "%s: failed to extract hostname from target: %ld\n",
439 __func__
, PTR_ERR(server
->hostname
));
443 static inline int reconn_setup_dfs_targets(struct cifs_sb_info
*cifs_sb
,
444 struct dfs_cache_tgt_list
*tl
,
445 struct dfs_cache_tgt_iterator
**it
)
447 if (!cifs_sb
->origin_fullpath
)
449 return dfs_cache_noreq_find(cifs_sb
->origin_fullpath
+ 1, NULL
, tl
);
454 * cifs tcp session reconnection
456 * mark tcp session as reconnecting so temporarily locked
457 * mark all smb sessions as reconnecting for tcp session
458 * reconnect tcp session
459 * wake up waiters on reconnection? - (not needed currently)
462 cifs_reconnect(struct TCP_Server_Info
*server
)
465 struct list_head
*tmp
, *tmp2
;
466 struct cifs_ses
*ses
;
467 struct cifs_tcon
*tcon
;
468 struct mid_q_entry
*mid_entry
;
469 struct list_head retry_list
;
470 #ifdef CONFIG_CIFS_DFS_UPCALL
471 struct cifs_sb_info
*cifs_sb
= NULL
;
472 struct dfs_cache_tgt_list tgt_list
= {0};
473 struct dfs_cache_tgt_iterator
*tgt_it
= NULL
;
476 spin_lock(&GlobalMid_Lock
);
477 server
->nr_targets
= 1;
478 #ifdef CONFIG_CIFS_DFS_UPCALL
479 cifs_sb
= find_super_by_tcp(server
);
480 if (IS_ERR(cifs_sb
)) {
481 rc
= PTR_ERR(cifs_sb
);
482 cifs_dbg(FYI
, "%s: will not do DFS failover: rc = %d\n",
486 rc
= reconn_setup_dfs_targets(cifs_sb
, &tgt_list
, &tgt_it
);
487 if (rc
&& (rc
!= -EOPNOTSUPP
)) {
488 cifs_dbg(VFS
, "%s: no target servers for DFS failover\n",
491 server
->nr_targets
= dfs_cache_get_nr_tgts(&tgt_list
);
494 cifs_dbg(FYI
, "%s: will retry %d target(s)\n", __func__
,
497 if (server
->tcpStatus
== CifsExiting
) {
498 /* the demux thread will exit normally
499 next time through the loop */
500 spin_unlock(&GlobalMid_Lock
);
503 server
->tcpStatus
= CifsNeedReconnect
;
504 spin_unlock(&GlobalMid_Lock
);
506 server
->max_read
= 0;
508 cifs_dbg(FYI
, "Mark tcp session as need reconnect\n");
509 trace_smb3_reconnect(server
->CurrentMid
, server
->hostname
);
511 /* before reconnecting the tcp session, mark the smb session (uid)
512 and the tid bad so they are not used until reconnected */
513 cifs_dbg(FYI
, "%s: marking sessions and tcons for reconnect\n",
515 spin_lock(&cifs_tcp_ses_lock
);
516 list_for_each(tmp
, &server
->smb_ses_list
) {
517 ses
= list_entry(tmp
, struct cifs_ses
, smb_ses_list
);
518 ses
->need_reconnect
= true;
519 list_for_each(tmp2
, &ses
->tcon_list
) {
520 tcon
= list_entry(tmp2
, struct cifs_tcon
, tcon_list
);
521 tcon
->need_reconnect
= true;
524 ses
->tcon_ipc
->need_reconnect
= true;
526 spin_unlock(&cifs_tcp_ses_lock
);
528 /* do not want to be sending data on a socket we are freeing */
529 cifs_dbg(FYI
, "%s: tearing down socket\n", __func__
);
530 mutex_lock(&server
->srv_mutex
);
532 /* mark submitted MIDs for retry and issue callback */
533 INIT_LIST_HEAD(&retry_list
);
534 cifs_dbg(FYI
, "%s: moving mids to private list\n", __func__
);
535 spin_lock(&GlobalMid_Lock
);
536 list_for_each_safe(tmp
, tmp2
, &server
->pending_mid_q
) {
537 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
538 if (mid_entry
->mid_state
== MID_REQUEST_SUBMITTED
)
539 mid_entry
->mid_state
= MID_RETRY_NEEDED
;
540 list_move(&mid_entry
->qhead
, &retry_list
);
542 spin_unlock(&GlobalMid_Lock
);
544 cifs_dbg(FYI
, "%s: issuing mid callbacks\n", __func__
);
545 list_for_each_safe(tmp
, tmp2
, &retry_list
) {
546 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
547 list_del_init(&mid_entry
->qhead
);
548 mid_entry
->callback(mid_entry
);
551 if (server
->ssocket
) {
552 cifs_dbg(FYI
, "State: 0x%x Flags: 0x%lx\n",
553 server
->ssocket
->state
, server
->ssocket
->flags
);
554 kernel_sock_shutdown(server
->ssocket
, SHUT_WR
);
555 cifs_dbg(FYI
, "Post shutdown state: 0x%x Flags: 0x%lx\n",
556 server
->ssocket
->state
, server
->ssocket
->flags
);
557 sock_release(server
->ssocket
);
558 server
->ssocket
= NULL
;
559 } else if (cifs_rdma_enabled(server
))
560 smbd_destroy(server
);
561 server
->sequence_number
= 0;
562 server
->session_estab
= false;
563 kfree(server
->session_key
.response
);
564 server
->session_key
.response
= NULL
;
565 server
->session_key
.len
= 0;
566 server
->lstrp
= jiffies
;
568 mutex_unlock(&server
->srv_mutex
);
573 mutex_lock(&server
->srv_mutex
);
575 * Set up next DFS target server (if any) for reconnect. If DFS
576 * feature is disabled, then we will retry last server we
577 * connected to before.
579 if (cifs_rdma_enabled(server
))
580 rc
= smbd_reconnect(server
);
582 rc
= generic_ip_connect(server
);
584 cifs_dbg(FYI
, "reconnect error %d\n", rc
);
585 #ifdef CONFIG_CIFS_DFS_UPCALL
586 reconn_inval_dfs_target(server
, cifs_sb
, &tgt_list
,
589 rc
= reconn_set_ipaddr(server
);
591 cifs_dbg(FYI
, "%s: failed to resolve hostname: %d\n",
594 mutex_unlock(&server
->srv_mutex
);
597 atomic_inc(&tcpSesReconnectCount
);
598 set_credits(server
, 1);
599 spin_lock(&GlobalMid_Lock
);
600 if (server
->tcpStatus
!= CifsExiting
)
601 server
->tcpStatus
= CifsNeedNegotiate
;
602 spin_unlock(&GlobalMid_Lock
);
603 mutex_unlock(&server
->srv_mutex
);
605 } while (server
->tcpStatus
== CifsNeedReconnect
);
607 #ifdef CONFIG_CIFS_DFS_UPCALL
609 rc
= dfs_cache_noreq_update_tgthint(cifs_sb
->origin_fullpath
+ 1,
612 cifs_dbg(VFS
, "%s: failed to update DFS target hint: rc = %d\n",
615 rc
= dfs_cache_update_vol(cifs_sb
->origin_fullpath
, server
);
617 cifs_dbg(VFS
, "%s: failed to update vol info in DFS cache: rc = %d\n",
620 dfs_cache_free_tgts(&tgt_list
);
623 if (server
->tcpStatus
== CifsNeedNegotiate
)
624 mod_delayed_work(cifsiod_wq
, &server
->echo
, 0);
630 cifs_echo_request(struct work_struct
*work
)
633 struct TCP_Server_Info
*server
= container_of(work
,
634 struct TCP_Server_Info
, echo
.work
);
635 unsigned long echo_interval
;
638 * If we need to renegotiate, set echo interval to zero to
639 * immediately call echo service where we can renegotiate.
641 if (server
->tcpStatus
== CifsNeedNegotiate
)
644 echo_interval
= server
->echo_interval
;
647 * We cannot send an echo if it is disabled.
648 * Also, no need to ping if we got a response recently.
651 if (server
->tcpStatus
== CifsNeedReconnect
||
652 server
->tcpStatus
== CifsExiting
||
653 server
->tcpStatus
== CifsNew
||
654 (server
->ops
->can_echo
&& !server
->ops
->can_echo(server
)) ||
655 time_before(jiffies
, server
->lstrp
+ echo_interval
- HZ
))
658 rc
= server
->ops
->echo
? server
->ops
->echo(server
) : -ENOSYS
;
660 cifs_dbg(FYI
, "Unable to send echo request to server: %s\n",
664 queue_delayed_work(cifsiod_wq
, &server
->echo
, server
->echo_interval
);
668 allocate_buffers(struct TCP_Server_Info
*server
)
670 if (!server
->bigbuf
) {
671 server
->bigbuf
= (char *)cifs_buf_get();
672 if (!server
->bigbuf
) {
673 cifs_dbg(VFS
, "No memory for large SMB response\n");
675 /* retry will check if exiting */
678 } else if (server
->large_buf
) {
679 /* we are reusing a dirty large buf, clear its start */
680 memset(server
->bigbuf
, 0, HEADER_SIZE(server
));
683 if (!server
->smallbuf
) {
684 server
->smallbuf
= (char *)cifs_small_buf_get();
685 if (!server
->smallbuf
) {
686 cifs_dbg(VFS
, "No memory for SMB response\n");
688 /* retry will check if exiting */
691 /* beginning of smb buffer is cleared in our buf_get */
693 /* if existing small buf clear beginning */
694 memset(server
->smallbuf
, 0, HEADER_SIZE(server
));
701 server_unresponsive(struct TCP_Server_Info
*server
)
704 * We need to wait 2 echo intervals to make sure we handle such
706 * 1s client sends a normal SMB request
707 * 2s client gets a response
708 * 30s echo workqueue job pops, and decides we got a response recently
709 * and don't need to send another
711 * 65s kernel_recvmsg times out, and we see that we haven't gotten
712 * a response in >60s.
714 if ((server
->tcpStatus
== CifsGood
||
715 server
->tcpStatus
== CifsNeedNegotiate
) &&
716 time_after(jiffies
, server
->lstrp
+ 2 * server
->echo_interval
)) {
717 cifs_dbg(VFS
, "Server %s has not responded in %lu seconds. Reconnecting...\n",
718 server
->hostname
, (2 * server
->echo_interval
) / HZ
);
719 cifs_reconnect(server
);
720 wake_up(&server
->response_q
);
728 zero_credits(struct TCP_Server_Info
*server
)
732 spin_lock(&server
->req_lock
);
733 val
= server
->credits
+ server
->echo_credits
+ server
->oplock_credits
;
734 if (server
->in_flight
== 0 && val
== 0) {
735 spin_unlock(&server
->req_lock
);
738 spin_unlock(&server
->req_lock
);
743 cifs_readv_from_socket(struct TCP_Server_Info
*server
, struct msghdr
*smb_msg
)
748 smb_msg
->msg_control
= NULL
;
749 smb_msg
->msg_controllen
= 0;
751 for (total_read
= 0; msg_data_left(smb_msg
); total_read
+= length
) {
754 /* reconnect if no credits and no requests in flight */
755 if (zero_credits(server
)) {
756 cifs_reconnect(server
);
757 return -ECONNABORTED
;
760 if (server_unresponsive(server
))
761 return -ECONNABORTED
;
762 if (cifs_rdma_enabled(server
) && server
->smbd_conn
)
763 length
= smbd_recv(server
->smbd_conn
, smb_msg
);
765 length
= sock_recvmsg(server
->ssocket
, smb_msg
, 0);
767 if (server
->tcpStatus
== CifsExiting
)
770 if (server
->tcpStatus
== CifsNeedReconnect
) {
771 cifs_reconnect(server
);
772 return -ECONNABORTED
;
775 if (length
== -ERESTARTSYS
||
779 * Minimum sleep to prevent looping, allowing socket
780 * to clear and app threads to set tcpStatus
781 * CifsNeedReconnect if server hung.
783 usleep_range(1000, 2000);
789 cifs_dbg(FYI
, "Received no data or error: %d\n", length
);
790 cifs_reconnect(server
);
791 return -ECONNABORTED
;
798 cifs_read_from_socket(struct TCP_Server_Info
*server
, char *buf
,
799 unsigned int to_read
)
801 struct msghdr smb_msg
;
802 struct kvec iov
= {.iov_base
= buf
, .iov_len
= to_read
};
803 iov_iter_kvec(&smb_msg
.msg_iter
, READ
, &iov
, 1, to_read
);
805 return cifs_readv_from_socket(server
, &smb_msg
);
809 cifs_read_page_from_socket(struct TCP_Server_Info
*server
, struct page
*page
,
810 unsigned int page_offset
, unsigned int to_read
)
812 struct msghdr smb_msg
;
813 struct bio_vec bv
= {
814 .bv_page
= page
, .bv_len
= to_read
, .bv_offset
= page_offset
};
815 iov_iter_bvec(&smb_msg
.msg_iter
, READ
, &bv
, 1, to_read
);
816 return cifs_readv_from_socket(server
, &smb_msg
);
820 is_smb_response(struct TCP_Server_Info
*server
, unsigned char type
)
823 * The first byte big endian of the length field,
824 * is actually not part of the length but the type
825 * with the most common, zero, as regular data.
828 case RFC1002_SESSION_MESSAGE
:
829 /* Regular SMB response */
831 case RFC1002_SESSION_KEEP_ALIVE
:
832 cifs_dbg(FYI
, "RFC 1002 session keep alive\n");
834 case RFC1002_POSITIVE_SESSION_RESPONSE
:
835 cifs_dbg(FYI
, "RFC 1002 positive session response\n");
837 case RFC1002_NEGATIVE_SESSION_RESPONSE
:
839 * We get this from Windows 98 instead of an error on
840 * SMB negprot response.
842 cifs_dbg(FYI
, "RFC 1002 negative session response\n");
843 /* give server a second to clean up */
846 * Always try 445 first on reconnect since we get NACK
847 * on some if we ever connected to port 139 (the NACK
848 * is since we do not begin with RFC1001 session
851 cifs_set_port((struct sockaddr
*)&server
->dstaddr
, CIFS_PORT
);
852 cifs_reconnect(server
);
853 wake_up(&server
->response_q
);
856 cifs_dbg(VFS
, "RFC 1002 unknown response type 0x%x\n", type
);
857 cifs_reconnect(server
);
864 dequeue_mid(struct mid_q_entry
*mid
, bool malformed
)
866 #ifdef CONFIG_CIFS_STATS2
867 mid
->when_received
= jiffies
;
869 spin_lock(&GlobalMid_Lock
);
871 mid
->mid_state
= MID_RESPONSE_RECEIVED
;
873 mid
->mid_state
= MID_RESPONSE_MALFORMED
;
875 * Trying to handle/dequeue a mid after the send_recv()
876 * function has finished processing it is a bug.
878 if (mid
->mid_flags
& MID_DELETED
)
879 printk_once(KERN_WARNING
880 "trying to dequeue a deleted mid\n");
882 list_del_init(&mid
->qhead
);
883 spin_unlock(&GlobalMid_Lock
);
887 handle_mid(struct mid_q_entry
*mid
, struct TCP_Server_Info
*server
,
888 char *buf
, int malformed
)
890 if (server
->ops
->check_trans2
&&
891 server
->ops
->check_trans2(mid
, server
, buf
, malformed
))
894 mid
->large_buf
= server
->large_buf
;
895 /* Was previous buf put in mpx struct for multi-rsp? */
896 if (!mid
->multiRsp
) {
897 /* smb buffer will be freed by user thread */
898 if (server
->large_buf
)
899 server
->bigbuf
= NULL
;
901 server
->smallbuf
= NULL
;
903 dequeue_mid(mid
, malformed
);
906 static void clean_demultiplex_info(struct TCP_Server_Info
*server
)
910 /* take it off the list, if it's not already */
911 spin_lock(&cifs_tcp_ses_lock
);
912 list_del_init(&server
->tcp_ses_list
);
913 spin_unlock(&cifs_tcp_ses_lock
);
915 spin_lock(&GlobalMid_Lock
);
916 server
->tcpStatus
= CifsExiting
;
917 spin_unlock(&GlobalMid_Lock
);
918 wake_up_all(&server
->response_q
);
920 /* check if we have blocked requests that need to free */
921 spin_lock(&server
->req_lock
);
922 if (server
->credits
<= 0)
924 spin_unlock(&server
->req_lock
);
926 * Although there should not be any requests blocked on this queue it
927 * can not hurt to be paranoid and try to wake up requests that may
928 * haven been blocked when more than 50 at time were on the wire to the
929 * same server - they now will see the session is in exit state and get
930 * out of SendReceive.
932 wake_up_all(&server
->request_q
);
933 /* give those requests time to exit */
935 if (cifs_rdma_enabled(server
))
936 smbd_destroy(server
);
937 if (server
->ssocket
) {
938 sock_release(server
->ssocket
);
939 server
->ssocket
= NULL
;
942 if (!list_empty(&server
->pending_mid_q
)) {
943 struct list_head dispose_list
;
944 struct mid_q_entry
*mid_entry
;
945 struct list_head
*tmp
, *tmp2
;
947 INIT_LIST_HEAD(&dispose_list
);
948 spin_lock(&GlobalMid_Lock
);
949 list_for_each_safe(tmp
, tmp2
, &server
->pending_mid_q
) {
950 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
951 cifs_dbg(FYI
, "Clearing mid 0x%llx\n", mid_entry
->mid
);
952 mid_entry
->mid_state
= MID_SHUTDOWN
;
953 list_move(&mid_entry
->qhead
, &dispose_list
);
955 spin_unlock(&GlobalMid_Lock
);
957 /* now walk dispose list and issue callbacks */
958 list_for_each_safe(tmp
, tmp2
, &dispose_list
) {
959 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
960 cifs_dbg(FYI
, "Callback mid 0x%llx\n", mid_entry
->mid
);
961 list_del_init(&mid_entry
->qhead
);
962 mid_entry
->callback(mid_entry
);
964 /* 1/8th of sec is more than enough time for them to exit */
968 if (!list_empty(&server
->pending_mid_q
)) {
970 * mpx threads have not exited yet give them at least the smb
971 * send timeout time for long ops.
973 * Due to delays on oplock break requests, we need to wait at
974 * least 45 seconds before giving up on a request getting a
975 * response and going ahead and killing cifsd.
977 cifs_dbg(FYI
, "Wait for exit from demultiplex thread\n");
980 * If threads still have not exited they are probably never
981 * coming home not much else we can do but free the memory.
985 kfree(server
->hostname
);
988 length
= atomic_dec_return(&tcpSesAllocCount
);
990 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
);
994 standard_receive3(struct TCP_Server_Info
*server
, struct mid_q_entry
*mid
)
997 char *buf
= server
->smallbuf
;
998 unsigned int pdu_length
= server
->pdu_size
;
1000 /* make sure this will fit in a large buffer */
1001 if (pdu_length
> CIFSMaxBufSize
+ MAX_HEADER_SIZE(server
) -
1002 server
->vals
->header_preamble_size
) {
1003 cifs_dbg(VFS
, "SMB response too long (%u bytes)\n", pdu_length
);
1004 cifs_reconnect(server
);
1005 wake_up(&server
->response_q
);
1006 return -ECONNABORTED
;
1009 /* switch to large buffer if too big for a small one */
1010 if (pdu_length
> MAX_CIFS_SMALL_BUFFER_SIZE
- 4) {
1011 server
->large_buf
= true;
1012 memcpy(server
->bigbuf
, buf
, server
->total_read
);
1013 buf
= server
->bigbuf
;
1016 /* now read the rest */
1017 length
= cifs_read_from_socket(server
, buf
+ HEADER_SIZE(server
) - 1,
1018 pdu_length
- HEADER_SIZE(server
) + 1
1019 + server
->vals
->header_preamble_size
);
1023 server
->total_read
+= length
;
1025 dump_smb(buf
, server
->total_read
);
1027 return cifs_handle_standard(server
, mid
);
1031 cifs_handle_standard(struct TCP_Server_Info
*server
, struct mid_q_entry
*mid
)
1033 char *buf
= server
->large_buf
? server
->bigbuf
: server
->smallbuf
;
1037 * We know that we received enough to get to the MID as we
1038 * checked the pdu_length earlier. Now check to see
1039 * if the rest of the header is OK. We borrow the length
1040 * var for the rest of the loop to avoid a new stack var.
1042 * 48 bytes is enough to display the header and a little bit
1043 * into the payload for debugging purposes.
1045 length
= server
->ops
->check_message(buf
, server
->total_read
, server
);
1047 cifs_dump_mem("Bad SMB: ", buf
,
1048 min_t(unsigned int, server
->total_read
, 48));
1050 if (server
->ops
->is_session_expired
&&
1051 server
->ops
->is_session_expired(buf
)) {
1052 cifs_reconnect(server
);
1053 wake_up(&server
->response_q
);
1057 if (server
->ops
->is_status_pending
&&
1058 server
->ops
->is_status_pending(buf
, server
))
1064 handle_mid(mid
, server
, buf
, length
);
1069 smb2_add_credits_from_hdr(char *buffer
, struct TCP_Server_Info
*server
)
1071 struct smb2_sync_hdr
*shdr
= (struct smb2_sync_hdr
*)buffer
;
1074 * SMB1 does not use credits.
1076 if (server
->vals
->header_preamble_size
)
1079 if (shdr
->CreditRequest
) {
1080 spin_lock(&server
->req_lock
);
1081 server
->credits
+= le16_to_cpu(shdr
->CreditRequest
);
1082 spin_unlock(&server
->req_lock
);
1083 wake_up(&server
->request_q
);
1089 cifs_demultiplex_thread(void *p
)
1091 int i
, num_mids
, length
;
1092 struct TCP_Server_Info
*server
= p
;
1093 unsigned int pdu_length
;
1094 unsigned int next_offset
;
1096 struct task_struct
*task_to_wake
= NULL
;
1097 struct mid_q_entry
*mids
[MAX_COMPOUND
];
1098 char *bufs
[MAX_COMPOUND
];
1100 current
->flags
|= PF_MEMALLOC
;
1101 cifs_dbg(FYI
, "Demultiplex PID: %d\n", task_pid_nr(current
));
1103 length
= atomic_inc_return(&tcpSesAllocCount
);
1105 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
);
1108 while (server
->tcpStatus
!= CifsExiting
) {
1109 if (try_to_freeze())
1112 if (!allocate_buffers(server
))
1115 server
->large_buf
= false;
1116 buf
= server
->smallbuf
;
1117 pdu_length
= 4; /* enough to get RFC1001 header */
1119 length
= cifs_read_from_socket(server
, buf
, pdu_length
);
1123 if (server
->vals
->header_preamble_size
== 0)
1124 server
->total_read
= 0;
1126 server
->total_read
= length
;
1129 * The right amount was read from socket - 4 bytes,
1130 * so we can now interpret the length field.
1132 pdu_length
= get_rfc1002_length(buf
);
1134 cifs_dbg(FYI
, "RFC1002 header 0x%x\n", pdu_length
);
1135 if (!is_smb_response(server
, buf
[0]))
1138 server
->pdu_size
= pdu_length
;
1140 /* make sure we have enough to get to the MID */
1141 if (server
->pdu_size
< HEADER_SIZE(server
) - 1 -
1142 server
->vals
->header_preamble_size
) {
1143 cifs_dbg(VFS
, "SMB response too short (%u bytes)\n",
1145 cifs_reconnect(server
);
1146 wake_up(&server
->response_q
);
1150 /* read down to the MID */
1151 length
= cifs_read_from_socket(server
,
1152 buf
+ server
->vals
->header_preamble_size
,
1153 HEADER_SIZE(server
) - 1
1154 - server
->vals
->header_preamble_size
);
1157 server
->total_read
+= length
;
1159 if (server
->ops
->next_header
) {
1160 next_offset
= server
->ops
->next_header(buf
);
1162 server
->pdu_size
= next_offset
;
1165 memset(mids
, 0, sizeof(mids
));
1166 memset(bufs
, 0, sizeof(bufs
));
1169 if (server
->ops
->is_transform_hdr
&&
1170 server
->ops
->receive_transform
&&
1171 server
->ops
->is_transform_hdr(buf
)) {
1172 length
= server
->ops
->receive_transform(server
,
1177 mids
[0] = server
->ops
->find_mid(server
, buf
);
1181 if (!mids
[0] || !mids
[0]->receive
)
1182 length
= standard_receive3(server
, mids
[0]);
1184 length
= mids
[0]->receive(server
, mids
[0]);
1188 for (i
= 0; i
< num_mids
; i
++)
1190 cifs_mid_q_entry_release(mids
[i
]);
1194 server
->lstrp
= jiffies
;
1196 for (i
= 0; i
< num_mids
; i
++) {
1197 if (mids
[i
] != NULL
) {
1198 mids
[i
]->resp_buf_size
= server
->pdu_size
;
1199 if ((mids
[i
]->mid_flags
& MID_WAIT_CANCELLED
) &&
1200 mids
[i
]->mid_state
== MID_RESPONSE_RECEIVED
&&
1201 server
->ops
->handle_cancelled_mid
)
1202 server
->ops
->handle_cancelled_mid(
1206 if (!mids
[i
]->multiRsp
|| mids
[i
]->multiEnd
)
1207 mids
[i
]->callback(mids
[i
]);
1209 cifs_mid_q_entry_release(mids
[i
]);
1210 } else if (server
->ops
->is_oplock_break
&&
1211 server
->ops
->is_oplock_break(bufs
[i
],
1213 smb2_add_credits_from_hdr(bufs
[i
], server
);
1214 cifs_dbg(FYI
, "Received oplock break\n");
1216 cifs_dbg(VFS
, "No task to wake, unknown frame "
1217 "received! NumMids %d\n",
1218 atomic_read(&midCount
));
1219 cifs_dump_mem("Received Data is: ", bufs
[i
],
1220 HEADER_SIZE(server
));
1221 #ifdef CONFIG_CIFS_DEBUG2
1222 if (server
->ops
->dump_detail
)
1223 server
->ops
->dump_detail(bufs
[i
],
1225 smb2_add_credits_from_hdr(bufs
[i
], server
);
1226 cifs_dump_mids(server
);
1227 #endif /* CIFS_DEBUG2 */
1231 if (pdu_length
> server
->pdu_size
) {
1232 if (!allocate_buffers(server
))
1234 pdu_length
-= server
->pdu_size
;
1235 server
->total_read
= 0;
1236 server
->large_buf
= false;
1237 buf
= server
->smallbuf
;
1240 } /* end while !EXITING */
1242 /* buffer usually freed in free_mid - need to free it here on exit */
1243 cifs_buf_release(server
->bigbuf
);
1244 if (server
->smallbuf
) /* no sense logging a debug message if NULL */
1245 cifs_small_buf_release(server
->smallbuf
);
1247 task_to_wake
= xchg(&server
->tsk
, NULL
);
1248 clean_demultiplex_info(server
);
1250 /* if server->tsk was NULL then wait for a signal before exiting */
1251 if (!task_to_wake
) {
1252 set_current_state(TASK_INTERRUPTIBLE
);
1253 while (!signal_pending(current
)) {
1255 set_current_state(TASK_INTERRUPTIBLE
);
1257 set_current_state(TASK_RUNNING
);
1260 module_put_and_exit(0);
1263 /* extract the host portion of the UNC string */
1265 extract_hostname(const char *unc
)
1271 /* skip double chars at beginning of string */
1272 /* BB: check validity of these bytes? */
1273 if (strlen(unc
) < 3)
1274 return ERR_PTR(-EINVAL
);
1275 for (src
= unc
; *src
&& *src
== '\\'; src
++)
1278 return ERR_PTR(-EINVAL
);
1280 /* delimiter between hostname and sharename is always '\\' now */
1281 delim
= strchr(src
, '\\');
1283 return ERR_PTR(-EINVAL
);
1286 dst
= kmalloc((len
+ 1), GFP_KERNEL
);
1288 return ERR_PTR(-ENOMEM
);
1290 memcpy(dst
, src
, len
);
1296 static int get_option_ul(substring_t args
[], unsigned long *option
)
1301 string
= match_strdup(args
);
1304 rc
= kstrtoul(string
, 0, option
);
1310 static int get_option_uid(substring_t args
[], kuid_t
*result
)
1312 unsigned long value
;
1316 rc
= get_option_ul(args
, &value
);
1320 uid
= make_kuid(current_user_ns(), value
);
1321 if (!uid_valid(uid
))
1328 static int get_option_gid(substring_t args
[], kgid_t
*result
)
1330 unsigned long value
;
1334 rc
= get_option_ul(args
, &value
);
1338 gid
= make_kgid(current_user_ns(), value
);
1339 if (!gid_valid(gid
))
1346 static int cifs_parse_security_flavors(char *value
,
1347 struct smb_vol
*vol
)
1350 substring_t args
[MAX_OPT_ARGS
];
1353 * With mount options, the last one should win. Reset any existing
1354 * settings back to default.
1356 vol
->sectype
= Unspecified
;
1359 switch (match_token(value
, cifs_secflavor_tokens
, args
)) {
1361 cifs_dbg(VFS
, "sec=krb5p is not supported!\n");
1367 vol
->sectype
= Kerberos
;
1369 case Opt_sec_ntlmsspi
:
1372 case Opt_sec_ntlmssp
:
1373 vol
->sectype
= RawNTLMSSP
;
1379 vol
->sectype
= NTLM
;
1381 case Opt_sec_ntlmv2i
:
1384 case Opt_sec_ntlmv2
:
1385 vol
->sectype
= NTLMv2
;
1387 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1388 case Opt_sec_lanman
:
1389 vol
->sectype
= LANMAN
;
1396 cifs_dbg(VFS
, "bad security option: %s\n", value
);
1404 cifs_parse_cache_flavor(char *value
, struct smb_vol
*vol
)
1406 substring_t args
[MAX_OPT_ARGS
];
1408 switch (match_token(value
, cifs_cacheflavor_tokens
, args
)) {
1409 case Opt_cache_loose
:
1410 vol
->direct_io
= false;
1411 vol
->strict_io
= false;
1413 case Opt_cache_strict
:
1414 vol
->direct_io
= false;
1415 vol
->strict_io
= true;
1417 case Opt_cache_none
:
1418 vol
->direct_io
= true;
1419 vol
->strict_io
= false;
1422 cifs_dbg(VFS
, "bad cache= option: %s\n", value
);
1429 cifs_parse_smb_version(char *value
, struct smb_vol
*vol
, bool is_smb3
)
1431 substring_t args
[MAX_OPT_ARGS
];
1433 switch (match_token(value
, cifs_smb_version_tokens
, args
)) {
1434 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1436 if (disable_legacy_dialects
) {
1437 cifs_dbg(VFS
, "mount with legacy dialect disabled\n");
1441 cifs_dbg(VFS
, "vers=1.0 (cifs) not permitted when mounting with smb3\n");
1444 vol
->ops
= &smb1_operations
;
1445 vol
->vals
= &smb1_values
;
1448 if (disable_legacy_dialects
) {
1449 cifs_dbg(VFS
, "mount with legacy dialect disabled\n");
1453 cifs_dbg(VFS
, "vers=2.0 not permitted when mounting with smb3\n");
1456 vol
->ops
= &smb20_operations
;
1457 vol
->vals
= &smb20_values
;
1461 cifs_dbg(VFS
, "vers=1.0 (cifs) mount not permitted when legacy dialects disabled\n");
1464 cifs_dbg(VFS
, "vers=2.0 mount not permitted when legacy dialects disabled\n");
1466 #endif /* CIFS_ALLOW_INSECURE_LEGACY */
1468 vol
->ops
= &smb21_operations
;
1469 vol
->vals
= &smb21_values
;
1472 vol
->ops
= &smb30_operations
;
1473 vol
->vals
= &smb30_values
;
1476 vol
->ops
= &smb30_operations
; /* currently identical with 3.0 */
1477 vol
->vals
= &smb302_values
;
1480 vol
->ops
= &smb311_operations
;
1481 vol
->vals
= &smb311_values
;
1484 vol
->ops
= &smb30_operations
; /* currently identical with 3.0 */
1485 vol
->vals
= &smb3any_values
;
1488 vol
->ops
= &smb30_operations
; /* currently identical with 3.0 */
1489 vol
->vals
= &smbdefault_values
;
1492 cifs_dbg(VFS
, "Unknown vers= option specified: %s\n", value
);
1499 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1500 * fields with the result. Returns 0 on success and an error otherwise.
1503 cifs_parse_devname(const char *devname
, struct smb_vol
*vol
)
1506 const char *delims
= "/\\";
1509 if (unlikely(!devname
|| !*devname
)) {
1510 cifs_dbg(VFS
, "Device name not specified.\n");
1514 /* make sure we have a valid UNC double delimiter prefix */
1515 len
= strspn(devname
, delims
);
1519 /* find delimiter between host and sharename */
1520 pos
= strpbrk(devname
+ 2, delims
);
1524 /* skip past delimiter */
1527 /* now go until next delimiter or end of string */
1528 len
= strcspn(pos
, delims
);
1530 /* move "pos" up to delimiter or NULL */
1532 vol
->UNC
= kstrndup(devname
, pos
- devname
, GFP_KERNEL
);
1536 convert_delimiter(vol
->UNC
, '\\');
1538 /* skip any delimiter */
1539 if (*pos
== '/' || *pos
== '\\')
1542 /* If pos is NULL then no prepath */
1546 vol
->prepath
= kstrdup(pos
, GFP_KERNEL
);
1554 cifs_parse_mount_options(const char *mountdata
, const char *devname
,
1555 struct smb_vol
*vol
, bool is_smb3
)
1558 char *mountdata_copy
= NULL
, *options
;
1559 unsigned int temp_len
, i
, j
;
1561 short int override_uid
= -1;
1562 short int override_gid
= -1;
1563 bool uid_specified
= false;
1564 bool gid_specified
= false;
1565 bool sloppy
= false;
1566 char *invalid
= NULL
;
1567 char *nodename
= utsname()->nodename
;
1568 char *string
= NULL
;
1569 char *tmp_end
, *value
;
1571 bool got_ip
= false;
1572 bool got_version
= false;
1573 unsigned short port
= 0;
1574 struct sockaddr
*dstaddr
= (struct sockaddr
*)&vol
->dstaddr
;
1578 delim
= separator
[0];
1580 /* ensure we always start with zeroed-out smb_vol */
1581 memset(vol
, 0, sizeof(*vol
));
1584 * does not have to be perfect mapping since field is
1585 * informational, only used for servers that do not support
1586 * port 445 and it can be overridden at mount time
1588 memset(vol
->source_rfc1001_name
, 0x20, RFC1001_NAME_LEN
);
1589 for (i
= 0; i
< strnlen(nodename
, RFC1001_NAME_LEN
); i
++)
1590 vol
->source_rfc1001_name
[i
] = toupper(nodename
[i
]);
1592 vol
->source_rfc1001_name
[RFC1001_NAME_LEN
] = 0;
1593 /* null target name indicates to use *SMBSERVR default called name
1594 if we end up sending RFC1001 session initialize */
1595 vol
->target_rfc1001_name
[0] = 0;
1596 vol
->cred_uid
= current_uid();
1597 vol
->linux_uid
= current_uid();
1598 vol
->linux_gid
= current_gid();
1599 vol
->bsize
= 1024 * 1024; /* can improve cp performance significantly */
1601 * default to SFM style remapping of seven reserved characters
1602 * unless user overrides it or we negotiate CIFS POSIX where
1603 * it is unnecessary. Can not simultaneously use more than one mapping
1604 * since then readdir could list files that open could not open
1608 /* default to only allowing write access to owner of the mount */
1609 vol
->dir_mode
= vol
->file_mode
= S_IRUGO
| S_IXUGO
| S_IWUSR
;
1611 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1612 /* default is always to request posix paths. */
1613 vol
->posix_paths
= 1;
1614 /* default to using server inode numbers where available */
1615 vol
->server_ino
= 1;
1617 /* default is to use strict cifs caching semantics */
1618 vol
->strict_io
= true;
1620 vol
->actimeo
= CIFS_DEF_ACTIMEO
;
1622 /* Most clients set timeout to 0, allows server to use its default */
1623 vol
->handle_timeout
= 0; /* See MS-SMB2 spec section 2.2.14.2.12 */
1625 /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1626 vol
->ops
= &smb30_operations
;
1627 vol
->vals
= &smbdefault_values
;
1629 vol
->echo_interval
= SMB_ECHO_INTERVAL_DEFAULT
;
1632 goto cifs_parse_mount_err
;
1634 mountdata_copy
= kstrndup(mountdata
, PAGE_SIZE
, GFP_KERNEL
);
1635 if (!mountdata_copy
)
1636 goto cifs_parse_mount_err
;
1638 options
= mountdata_copy
;
1639 end
= options
+ strlen(options
);
1641 if (strncmp(options
, "sep=", 4) == 0) {
1642 if (options
[4] != 0) {
1643 separator
[0] = options
[4];
1646 cifs_dbg(FYI
, "Null separator not allowed\n");
1649 vol
->backupuid_specified
= false; /* no backup intent for a user */
1650 vol
->backupgid_specified
= false; /* no backup intent for a group */
1652 switch (cifs_parse_devname(devname
, vol
)) {
1656 cifs_dbg(VFS
, "Unable to allocate memory for devname.\n");
1657 goto cifs_parse_mount_err
;
1659 cifs_dbg(VFS
, "Malformed UNC in devname.\n");
1660 goto cifs_parse_mount_err
;
1662 cifs_dbg(VFS
, "Unknown error parsing devname.\n");
1663 goto cifs_parse_mount_err
;
1666 while ((data
= strsep(&options
, separator
)) != NULL
) {
1667 substring_t args
[MAX_OPT_ARGS
];
1668 unsigned long option
;
1674 token
= match_token(data
, cifs_mount_option_tokens
, args
);
1678 /* Ingnore the following */
1682 /* Boolean values */
1683 case Opt_user_xattr
:
1686 case Opt_nouser_xattr
:
1692 case Opt_noforceuid
:
1698 case Opt_noforcegid
:
1701 case Opt_noblocksend
:
1702 vol
->noblocksnd
= 1;
1704 case Opt_noautotune
:
1705 vol
->noautotune
= 1;
1720 vol
->sfu_remap
= true;
1721 vol
->remap
= false; /* disable SFM mapping */
1723 case Opt_nomapchars
:
1724 vol
->sfu_remap
= false;
1728 vol
->sfu_remap
= false; /* disable SFU mapping */
1730 case Opt_nomapposix
:
1742 case Opt_posixpaths
:
1743 vol
->posix_paths
= 1;
1745 case Opt_noposixpaths
:
1746 vol
->posix_paths
= 0;
1751 "conflicting unix mount options\n");
1752 vol
->no_linux_ext
= 1;
1755 if (vol
->no_linux_ext
)
1757 "conflicting unix mount options\n");
1769 * turn off mandatory locking in mode
1770 * if remote locking is turned off since the
1771 * local vfs will do advisory
1773 if (vol
->file_mode
==
1774 (S_IALLUGO
& ~(S_ISUID
| S_IXGRP
)))
1775 vol
->file_mode
= S_IALLUGO
;
1777 case Opt_nohandlecache
:
1778 vol
->nohandlecache
= 1;
1780 case Opt_handlecache
:
1781 vol
->nohandlecache
= 0;
1783 case Opt_forcemandatorylock
:
1792 case Opt_setuidfromacl
:
1793 vol
->setuidfromacl
= 1;
1796 vol
->dynperm
= true;
1799 vol
->dynperm
= false;
1813 case Opt_nostrictsync
:
1814 vol
->nostrictsync
= 1;
1816 case Opt_strictsync
:
1817 vol
->nostrictsync
= 0;
1820 vol
->server_ino
= 1;
1822 case Opt_noserverino
:
1823 vol
->server_ino
= 0;
1825 case Opt_rwpidforward
:
1826 vol
->rwpidforward
= 1;
1835 vol
->no_psx_acl
= 0;
1838 vol
->no_psx_acl
= 1;
1840 case Opt_locallease
:
1841 vol
->local_lease
= 1;
1847 /* we do not do the following in secFlags because seal
1848 * is a per tree connection (mount) not a per socket
1849 * or per-smb connection option in the protocol
1850 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1855 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1858 #ifndef CONFIG_CIFS_FSCACHE
1859 cifs_dbg(VFS
, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1860 goto cifs_parse_mount_err
;
1864 case Opt_mfsymlinks
:
1865 vol
->mfsymlinks
= true;
1868 vol
->multiuser
= true;
1873 case Opt_nosharesock
:
1874 vol
->nosharesock
= true;
1876 case Opt_nopersistent
:
1877 vol
->nopersistent
= true;
1878 if (vol
->persistent
) {
1880 "persistenthandles mount options conflict\n");
1881 goto cifs_parse_mount_err
;
1884 case Opt_persistent
:
1885 vol
->persistent
= true;
1886 if ((vol
->nopersistent
) || (vol
->resilient
)) {
1888 "persistenthandles mount options conflict\n");
1889 goto cifs_parse_mount_err
;
1893 vol
->resilient
= true;
1894 if (vol
->persistent
) {
1896 "persistenthandles mount options conflict\n");
1897 goto cifs_parse_mount_err
;
1900 case Opt_noresilient
:
1901 vol
->resilient
= false; /* already the default */
1903 case Opt_domainauto
:
1904 vol
->domainauto
= true;
1910 /* Numeric Values */
1912 if (get_option_uid(args
, &vol
->backupuid
)) {
1913 cifs_dbg(VFS
, "%s: Invalid backupuid value\n",
1915 goto cifs_parse_mount_err
;
1917 vol
->backupuid_specified
= true;
1920 if (get_option_gid(args
, &vol
->backupgid
)) {
1921 cifs_dbg(VFS
, "%s: Invalid backupgid value\n",
1923 goto cifs_parse_mount_err
;
1925 vol
->backupgid_specified
= true;
1928 if (get_option_uid(args
, &vol
->linux_uid
)) {
1929 cifs_dbg(VFS
, "%s: Invalid uid value\n",
1931 goto cifs_parse_mount_err
;
1933 uid_specified
= true;
1936 if (get_option_uid(args
, &vol
->cred_uid
)) {
1937 cifs_dbg(VFS
, "%s: Invalid cruid value\n",
1939 goto cifs_parse_mount_err
;
1943 if (get_option_gid(args
, &vol
->linux_gid
)) {
1944 cifs_dbg(VFS
, "%s: Invalid gid value\n",
1946 goto cifs_parse_mount_err
;
1948 gid_specified
= true;
1951 if (get_option_ul(args
, &option
)) {
1952 cifs_dbg(VFS
, "%s: Invalid file_mode value\n",
1954 goto cifs_parse_mount_err
;
1956 vol
->file_mode
= option
;
1959 if (get_option_ul(args
, &option
)) {
1960 cifs_dbg(VFS
, "%s: Invalid dir_mode value\n",
1962 goto cifs_parse_mount_err
;
1964 vol
->dir_mode
= option
;
1967 if (get_option_ul(args
, &option
) ||
1968 option
> USHRT_MAX
) {
1969 cifs_dbg(VFS
, "%s: Invalid port value\n",
1971 goto cifs_parse_mount_err
;
1973 port
= (unsigned short)option
;
1976 if (get_option_ul(args
, &option
)) {
1977 cifs_dbg(VFS
, "%s: Invalid blocksize value\n",
1979 goto cifs_parse_mount_err
;
1982 * inode blocksize realistically should never need to be
1983 * less than 16K or greater than 16M and default is 1MB.
1984 * Note that small inode block sizes (e.g. 64K) can lead
1985 * to very poor performance of common tools like cp and scp
1987 if ((option
< CIFS_MAX_MSGSIZE
) ||
1988 (option
> (4 * SMB3_DEFAULT_IOSIZE
))) {
1989 cifs_dbg(VFS
, "%s: Invalid blocksize\n",
1991 goto cifs_parse_mount_err
;
1993 vol
->bsize
= option
;
1996 if (get_option_ul(args
, &option
)) {
1997 cifs_dbg(VFS
, "%s: Invalid rsize value\n",
1999 goto cifs_parse_mount_err
;
2001 vol
->rsize
= option
;
2004 if (get_option_ul(args
, &option
)) {
2005 cifs_dbg(VFS
, "%s: Invalid wsize value\n",
2007 goto cifs_parse_mount_err
;
2009 vol
->wsize
= option
;
2012 if (get_option_ul(args
, &option
)) {
2013 cifs_dbg(VFS
, "%s: Invalid actimeo value\n",
2015 goto cifs_parse_mount_err
;
2017 vol
->actimeo
= HZ
* option
;
2018 if (vol
->actimeo
> CIFS_MAX_ACTIMEO
) {
2019 cifs_dbg(VFS
, "attribute cache timeout too large\n");
2020 goto cifs_parse_mount_err
;
2023 case Opt_handletimeout
:
2024 if (get_option_ul(args
, &option
)) {
2025 cifs_dbg(VFS
, "%s: Invalid handletimeout value\n",
2027 goto cifs_parse_mount_err
;
2029 vol
->handle_timeout
= option
;
2030 if (vol
->handle_timeout
> SMB3_MAX_HANDLE_TIMEOUT
) {
2031 cifs_dbg(VFS
, "Invalid handle cache timeout, longer than 16 minutes\n");
2032 goto cifs_parse_mount_err
;
2035 case Opt_echo_interval
:
2036 if (get_option_ul(args
, &option
)) {
2037 cifs_dbg(VFS
, "%s: Invalid echo interval value\n",
2039 goto cifs_parse_mount_err
;
2041 vol
->echo_interval
= option
;
2044 if (get_option_ul(args
, &option
)) {
2045 cifs_dbg(VFS
, "%s: Invalid snapshot time\n",
2047 goto cifs_parse_mount_err
;
2049 vol
->snapshot_time
= option
;
2051 case Opt_max_credits
:
2052 if (get_option_ul(args
, &option
) || (option
< 20) ||
2054 cifs_dbg(VFS
, "%s: Invalid max_credits value\n",
2056 goto cifs_parse_mount_err
;
2058 vol
->max_credits
= option
;
2061 /* String Arguments */
2063 case Opt_blank_user
:
2064 /* null user, ie. anonymous authentication */
2066 vol
->username
= NULL
;
2069 string
= match_strdup(args
);
2073 if (strnlen(string
, CIFS_MAX_USERNAME_LEN
) >
2074 CIFS_MAX_USERNAME_LEN
) {
2075 pr_warn("CIFS: username too long\n");
2076 goto cifs_parse_mount_err
;
2079 kfree(vol
->username
);
2080 vol
->username
= kstrdup(string
, GFP_KERNEL
);
2082 goto cifs_parse_mount_err
;
2084 case Opt_blank_pass
:
2085 /* passwords have to be handled differently
2086 * to allow the character used for deliminator
2087 * to be passed within them
2091 * Check if this is a case where the password
2092 * starts with a delimiter
2094 tmp_end
= strchr(data
, '=');
2096 if (!(tmp_end
< end
&& tmp_end
[1] == delim
)) {
2097 /* No it is not. Set the password to NULL */
2098 kzfree(vol
->password
);
2099 vol
->password
= NULL
;
2102 /* Fallthrough - to Opt_pass below.*/
2104 /* Obtain the value string */
2105 value
= strchr(data
, '=');
2108 /* Set tmp_end to end of the string */
2109 tmp_end
= (char *) value
+ strlen(value
);
2111 /* Check if following character is the deliminator
2112 * If yes, we have encountered a double deliminator
2113 * reset the NULL character to the deliminator
2115 if (tmp_end
< end
&& tmp_end
[1] == delim
) {
2118 /* Keep iterating until we get to a single
2119 * deliminator OR the end
2121 while ((tmp_end
= strchr(tmp_end
, delim
))
2122 != NULL
&& (tmp_end
[1] == delim
)) {
2123 tmp_end
= (char *) &tmp_end
[2];
2126 /* Reset var options to point to next element */
2129 options
= (char *) &tmp_end
[1];
2131 /* Reached the end of the mount option
2136 kzfree(vol
->password
);
2137 /* Now build new password string */
2138 temp_len
= strlen(value
);
2139 vol
->password
= kzalloc(temp_len
+1, GFP_KERNEL
);
2140 if (vol
->password
== NULL
) {
2141 pr_warn("CIFS: no memory for password\n");
2142 goto cifs_parse_mount_err
;
2145 for (i
= 0, j
= 0; i
< temp_len
; i
++, j
++) {
2146 vol
->password
[j
] = value
[i
];
2147 if ((value
[i
] == delim
) &&
2148 value
[i
+1] == delim
)
2149 /* skip the second deliminator */
2152 vol
->password
[j
] = '\0';
2155 /* FIXME: should this be an error instead? */
2159 string
= match_strdup(args
);
2163 if (!cifs_convert_address(dstaddr
, string
,
2165 pr_err("CIFS: bad ip= option (%s).\n", string
);
2166 goto cifs_parse_mount_err
;
2171 string
= match_strdup(args
);
2175 if (strnlen(string
, CIFS_MAX_DOMAINNAME_LEN
)
2176 == CIFS_MAX_DOMAINNAME_LEN
) {
2177 pr_warn("CIFS: domain name too long\n");
2178 goto cifs_parse_mount_err
;
2181 kfree(vol
->domainname
);
2182 vol
->domainname
= kstrdup(string
, GFP_KERNEL
);
2183 if (!vol
->domainname
) {
2184 pr_warn("CIFS: no memory for domainname\n");
2185 goto cifs_parse_mount_err
;
2187 cifs_dbg(FYI
, "Domain name set\n");
2190 string
= match_strdup(args
);
2194 if (!cifs_convert_address(
2195 (struct sockaddr
*)&vol
->srcaddr
,
2196 string
, strlen(string
))) {
2197 pr_warn("CIFS: Could not parse srcaddr: %s\n",
2199 goto cifs_parse_mount_err
;
2203 string
= match_strdup(args
);
2207 if (strnlen(string
, 1024) >= 65) {
2208 pr_warn("CIFS: iocharset name too long.\n");
2209 goto cifs_parse_mount_err
;
2212 if (strncasecmp(string
, "default", 7) != 0) {
2213 kfree(vol
->iocharset
);
2214 vol
->iocharset
= kstrdup(string
,
2216 if (!vol
->iocharset
) {
2217 pr_warn("CIFS: no memory for charset\n");
2218 goto cifs_parse_mount_err
;
2221 /* if iocharset not set then load_nls_default
2224 cifs_dbg(FYI
, "iocharset set to %s\n", string
);
2226 case Opt_netbiosname
:
2227 string
= match_strdup(args
);
2231 memset(vol
->source_rfc1001_name
, 0x20,
2234 * FIXME: are there cases in which a comma can
2235 * be valid in workstation netbios name (and
2236 * need special handling)?
2238 for (i
= 0; i
< RFC1001_NAME_LEN
; i
++) {
2239 /* don't ucase netbiosname for user */
2242 vol
->source_rfc1001_name
[i
] = string
[i
];
2244 /* The string has 16th byte zero still from
2245 * set at top of the function
2247 if (i
== RFC1001_NAME_LEN
&& string
[i
] != 0)
2248 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
2251 /* servernetbiosname specified override *SMBSERVER */
2252 string
= match_strdup(args
);
2256 /* last byte, type, is 0x20 for servr type */
2257 memset(vol
->target_rfc1001_name
, 0x20,
2258 RFC1001_NAME_LEN_WITH_NULL
);
2260 /* BB are there cases in which a comma can be
2261 valid in this workstation netbios name
2262 (and need special handling)? */
2264 /* user or mount helper must uppercase the
2266 for (i
= 0; i
< 15; i
++) {
2269 vol
->target_rfc1001_name
[i
] = string
[i
];
2271 /* The string has 16th byte zero still from
2272 set at top of the function */
2273 if (i
== RFC1001_NAME_LEN
&& string
[i
] != 0)
2274 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
2277 /* version of mount userspace tools, not dialect */
2278 string
= match_strdup(args
);
2282 /* If interface changes in mount.cifs bump to new ver */
2283 if (strncasecmp(string
, "1", 1) == 0) {
2284 if (strlen(string
) > 1) {
2285 pr_warn("Bad mount helper ver=%s. Did "
2286 "you want SMB1 (CIFS) dialect "
2287 "and mean to type vers=1.0 "
2288 "instead?\n", string
);
2289 goto cifs_parse_mount_err
;
2291 /* This is the default */
2294 /* For all other value, error */
2295 pr_warn("CIFS: Invalid mount helper version specified\n");
2296 goto cifs_parse_mount_err
;
2298 /* protocol version (dialect) */
2299 string
= match_strdup(args
);
2303 if (cifs_parse_smb_version(string
, vol
, is_smb3
) != 0)
2304 goto cifs_parse_mount_err
;
2308 string
= match_strdup(args
);
2312 if (cifs_parse_security_flavors(string
, vol
) != 0)
2313 goto cifs_parse_mount_err
;
2316 string
= match_strdup(args
);
2320 if (cifs_parse_cache_flavor(string
, vol
) != 0)
2321 goto cifs_parse_mount_err
;
2325 * An option we don't recognize. Save it off for later
2326 * if we haven't already found one
2332 /* Free up any allocated string */
2337 if (!sloppy
&& invalid
) {
2338 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid
);
2339 goto cifs_parse_mount_err
;
2342 if (vol
->rdma
&& vol
->vals
->protocol_id
< SMB30_PROT_ID
) {
2343 cifs_dbg(VFS
, "SMB Direct requires Version >=3.0\n");
2344 goto cifs_parse_mount_err
;
2348 /* Muliuser mounts require CONFIG_KEYS support */
2349 if (vol
->multiuser
) {
2350 cifs_dbg(VFS
, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
2351 goto cifs_parse_mount_err
;
2355 cifs_dbg(VFS
, "CIFS mount error: No usable UNC path provided in device string!\n");
2356 goto cifs_parse_mount_err
;
2359 /* make sure UNC has a share name */
2360 if (!strchr(vol
->UNC
+ 3, '\\')) {
2361 cifs_dbg(VFS
, "Malformed UNC. Unable to find share name.\n");
2362 goto cifs_parse_mount_err
;
2369 /* No ip= option specified? Try to get it from UNC */
2370 /* Use the address part of the UNC. */
2371 slash
= strchr(&vol
->UNC
[2], '\\');
2372 len
= slash
- &vol
->UNC
[2];
2373 if (!cifs_convert_address(dstaddr
, &vol
->UNC
[2], len
)) {
2374 pr_err("Unable to determine destination address.\n");
2375 goto cifs_parse_mount_err
;
2379 /* set the port that we got earlier */
2380 cifs_set_port(dstaddr
, port
);
2383 vol
->override_uid
= override_uid
;
2384 else if (override_uid
== 1)
2385 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
2388 vol
->override_gid
= override_gid
;
2389 else if (override_gid
== 1)
2390 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
2392 if (got_version
== false)
2393 pr_warn("No dialect specified on mount. Default has changed to "
2394 "a more secure dialect, SMB2.1 or later (e.g. SMB3), from CIFS "
2395 "(SMB1). To use the less secure SMB1 dialect to access "
2396 "old servers which do not support SMB3 (or SMB2.1) specify vers=1.0"
2399 kfree(mountdata_copy
);
2403 pr_warn("Could not allocate temporary buffer\n");
2404 cifs_parse_mount_err
:
2406 kfree(mountdata_copy
);
2410 /** Returns true if srcaddr isn't specified and rhs isn't
2411 * specified, or if srcaddr is specified and
2412 * matches the IP address of the rhs argument.
2415 srcip_matches(struct sockaddr
*srcaddr
, struct sockaddr
*rhs
)
2417 switch (srcaddr
->sa_family
) {
2419 return (rhs
->sa_family
== AF_UNSPEC
);
2421 struct sockaddr_in
*saddr4
= (struct sockaddr_in
*)srcaddr
;
2422 struct sockaddr_in
*vaddr4
= (struct sockaddr_in
*)rhs
;
2423 return (saddr4
->sin_addr
.s_addr
== vaddr4
->sin_addr
.s_addr
);
2426 struct sockaddr_in6
*saddr6
= (struct sockaddr_in6
*)srcaddr
;
2427 struct sockaddr_in6
*vaddr6
= (struct sockaddr_in6
*)rhs
;
2428 return ipv6_addr_equal(&saddr6
->sin6_addr
, &vaddr6
->sin6_addr
);
2432 return false; /* don't expect to be here */
2437 * If no port is specified in addr structure, we try to match with 445 port
2438 * and if it fails - with 139 ports. It should be called only if address
2439 * families of server and addr are equal.
2442 match_port(struct TCP_Server_Info
*server
, struct sockaddr
*addr
)
2444 __be16 port
, *sport
;
2446 switch (addr
->sa_family
) {
2448 sport
= &((struct sockaddr_in
*) &server
->dstaddr
)->sin_port
;
2449 port
= ((struct sockaddr_in
*) addr
)->sin_port
;
2452 sport
= &((struct sockaddr_in6
*) &server
->dstaddr
)->sin6_port
;
2453 port
= ((struct sockaddr_in6
*) addr
)->sin6_port
;
2461 port
= htons(CIFS_PORT
);
2465 port
= htons(RFC1001_PORT
);
2468 return port
== *sport
;
2472 match_address(struct TCP_Server_Info
*server
, struct sockaddr
*addr
,
2473 struct sockaddr
*srcaddr
)
2475 switch (addr
->sa_family
) {
2477 struct sockaddr_in
*addr4
= (struct sockaddr_in
*)addr
;
2478 struct sockaddr_in
*srv_addr4
=
2479 (struct sockaddr_in
*)&server
->dstaddr
;
2481 if (addr4
->sin_addr
.s_addr
!= srv_addr4
->sin_addr
.s_addr
)
2486 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)addr
;
2487 struct sockaddr_in6
*srv_addr6
=
2488 (struct sockaddr_in6
*)&server
->dstaddr
;
2490 if (!ipv6_addr_equal(&addr6
->sin6_addr
,
2491 &srv_addr6
->sin6_addr
))
2493 if (addr6
->sin6_scope_id
!= srv_addr6
->sin6_scope_id
)
2499 return false; /* don't expect to be here */
2502 if (!srcip_matches(srcaddr
, (struct sockaddr
*)&server
->srcaddr
))
2509 match_security(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
2512 * The select_sectype function should either return the vol->sectype
2513 * that was specified, or "Unspecified" if that sectype was not
2514 * compatible with the given NEGOTIATE request.
2516 if (server
->ops
->select_sectype(server
, vol
->sectype
)
2521 * Now check if signing mode is acceptable. No need to check
2522 * global_secflags at this point since if MUST_SIGN is set then
2523 * the server->sign had better be too.
2525 if (vol
->sign
&& !server
->sign
)
2531 static int match_server(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
2533 struct sockaddr
*addr
= (struct sockaddr
*)&vol
->dstaddr
;
2535 if (vol
->nosharesock
)
2538 /* BB update this for smb3any and default case */
2539 if ((server
->vals
!= vol
->vals
) || (server
->ops
!= vol
->ops
))
2542 if (!net_eq(cifs_net_ns(server
), current
->nsproxy
->net_ns
))
2545 if (!match_address(server
, addr
,
2546 (struct sockaddr
*)&vol
->srcaddr
))
2549 if (!match_port(server
, addr
))
2552 if (!match_security(server
, vol
))
2555 if (server
->echo_interval
!= vol
->echo_interval
* HZ
)
2558 if (server
->rdma
!= vol
->rdma
)
2564 struct TCP_Server_Info
*
2565 cifs_find_tcp_session(struct smb_vol
*vol
)
2567 struct TCP_Server_Info
*server
;
2569 spin_lock(&cifs_tcp_ses_lock
);
2570 list_for_each_entry(server
, &cifs_tcp_ses_list
, tcp_ses_list
) {
2571 if (!match_server(server
, vol
))
2574 ++server
->srv_count
;
2575 spin_unlock(&cifs_tcp_ses_lock
);
2576 cifs_dbg(FYI
, "Existing tcp session with server found\n");
2579 spin_unlock(&cifs_tcp_ses_lock
);
2584 cifs_put_tcp_session(struct TCP_Server_Info
*server
, int from_reconnect
)
2586 struct task_struct
*task
;
2588 spin_lock(&cifs_tcp_ses_lock
);
2589 if (--server
->srv_count
> 0) {
2590 spin_unlock(&cifs_tcp_ses_lock
);
2594 put_net(cifs_net_ns(server
));
2596 list_del_init(&server
->tcp_ses_list
);
2597 spin_unlock(&cifs_tcp_ses_lock
);
2599 cancel_delayed_work_sync(&server
->echo
);
2603 * Avoid deadlock here: reconnect work calls
2604 * cifs_put_tcp_session() at its end. Need to be sure
2605 * that reconnect work does nothing with server pointer after
2608 cancel_delayed_work(&server
->reconnect
);
2610 cancel_delayed_work_sync(&server
->reconnect
);
2612 spin_lock(&GlobalMid_Lock
);
2613 server
->tcpStatus
= CifsExiting
;
2614 spin_unlock(&GlobalMid_Lock
);
2616 cifs_crypto_secmech_release(server
);
2617 cifs_fscache_release_client_cookie(server
);
2619 kfree(server
->session_key
.response
);
2620 server
->session_key
.response
= NULL
;
2621 server
->session_key
.len
= 0;
2623 task
= xchg(&server
->tsk
, NULL
);
2625 force_sig(SIGKILL
, task
);
2628 static struct TCP_Server_Info
*
2629 cifs_get_tcp_session(struct smb_vol
*volume_info
)
2631 struct TCP_Server_Info
*tcp_ses
= NULL
;
2634 cifs_dbg(FYI
, "UNC: %s\n", volume_info
->UNC
);
2636 /* see if we already have a matching tcp_ses */
2637 tcp_ses
= cifs_find_tcp_session(volume_info
);
2641 tcp_ses
= kzalloc(sizeof(struct TCP_Server_Info
), GFP_KERNEL
);
2647 tcp_ses
->ops
= volume_info
->ops
;
2648 tcp_ses
->vals
= volume_info
->vals
;
2649 cifs_set_net_ns(tcp_ses
, get_net(current
->nsproxy
->net_ns
));
2650 tcp_ses
->hostname
= extract_hostname(volume_info
->UNC
);
2651 if (IS_ERR(tcp_ses
->hostname
)) {
2652 rc
= PTR_ERR(tcp_ses
->hostname
);
2653 goto out_err_crypto_release
;
2656 tcp_ses
->noblocksnd
= volume_info
->noblocksnd
;
2657 tcp_ses
->noautotune
= volume_info
->noautotune
;
2658 tcp_ses
->tcp_nodelay
= volume_info
->sockopt_tcp_nodelay
;
2659 tcp_ses
->rdma
= volume_info
->rdma
;
2660 tcp_ses
->in_flight
= 0;
2661 tcp_ses
->credits
= 1;
2662 init_waitqueue_head(&tcp_ses
->response_q
);
2663 init_waitqueue_head(&tcp_ses
->request_q
);
2664 INIT_LIST_HEAD(&tcp_ses
->pending_mid_q
);
2665 mutex_init(&tcp_ses
->srv_mutex
);
2666 memcpy(tcp_ses
->workstation_RFC1001_name
,
2667 volume_info
->source_rfc1001_name
, RFC1001_NAME_LEN_WITH_NULL
);
2668 memcpy(tcp_ses
->server_RFC1001_name
,
2669 volume_info
->target_rfc1001_name
, RFC1001_NAME_LEN_WITH_NULL
);
2670 tcp_ses
->session_estab
= false;
2671 tcp_ses
->sequence_number
= 0;
2672 tcp_ses
->reconnect_instance
= 1;
2673 tcp_ses
->lstrp
= jiffies
;
2674 spin_lock_init(&tcp_ses
->req_lock
);
2675 INIT_LIST_HEAD(&tcp_ses
->tcp_ses_list
);
2676 INIT_LIST_HEAD(&tcp_ses
->smb_ses_list
);
2677 INIT_DELAYED_WORK(&tcp_ses
->echo
, cifs_echo_request
);
2678 INIT_DELAYED_WORK(&tcp_ses
->reconnect
, smb2_reconnect_server
);
2679 mutex_init(&tcp_ses
->reconnect_mutex
);
2680 memcpy(&tcp_ses
->srcaddr
, &volume_info
->srcaddr
,
2681 sizeof(tcp_ses
->srcaddr
));
2682 memcpy(&tcp_ses
->dstaddr
, &volume_info
->dstaddr
,
2683 sizeof(tcp_ses
->dstaddr
));
2684 generate_random_uuid(tcp_ses
->client_guid
);
2686 * at this point we are the only ones with the pointer
2687 * to the struct since the kernel thread not created yet
2688 * no need to spinlock this init of tcpStatus or srv_count
2690 tcp_ses
->tcpStatus
= CifsNew
;
2691 ++tcp_ses
->srv_count
;
2693 if (volume_info
->echo_interval
>= SMB_ECHO_INTERVAL_MIN
&&
2694 volume_info
->echo_interval
<= SMB_ECHO_INTERVAL_MAX
)
2695 tcp_ses
->echo_interval
= volume_info
->echo_interval
* HZ
;
2697 tcp_ses
->echo_interval
= SMB_ECHO_INTERVAL_DEFAULT
* HZ
;
2698 if (tcp_ses
->rdma
) {
2699 #ifndef CONFIG_CIFS_SMB_DIRECT
2700 cifs_dbg(VFS
, "CONFIG_CIFS_SMB_DIRECT is not enabled\n");
2702 goto out_err_crypto_release
;
2704 tcp_ses
->smbd_conn
= smbd_get_connection(
2705 tcp_ses
, (struct sockaddr
*)&volume_info
->dstaddr
);
2706 if (tcp_ses
->smbd_conn
) {
2707 cifs_dbg(VFS
, "RDMA transport established\n");
2709 goto smbd_connected
;
2712 goto out_err_crypto_release
;
2715 rc
= ip_connect(tcp_ses
);
2717 cifs_dbg(VFS
, "Error connecting to socket. Aborting operation.\n");
2718 goto out_err_crypto_release
;
2722 * since we're in a cifs function already, we know that
2723 * this will succeed. No need for try_module_get().
2725 __module_get(THIS_MODULE
);
2726 tcp_ses
->tsk
= kthread_run(cifs_demultiplex_thread
,
2728 if (IS_ERR(tcp_ses
->tsk
)) {
2729 rc
= PTR_ERR(tcp_ses
->tsk
);
2730 cifs_dbg(VFS
, "error %d create cifsd thread\n", rc
);
2731 module_put(THIS_MODULE
);
2732 goto out_err_crypto_release
;
2734 tcp_ses
->tcpStatus
= CifsNeedNegotiate
;
2736 tcp_ses
->nr_targets
= 1;
2738 /* thread spawned, put it on the list */
2739 spin_lock(&cifs_tcp_ses_lock
);
2740 list_add(&tcp_ses
->tcp_ses_list
, &cifs_tcp_ses_list
);
2741 spin_unlock(&cifs_tcp_ses_lock
);
2743 cifs_fscache_get_client_cookie(tcp_ses
);
2745 /* queue echo request delayed work */
2746 queue_delayed_work(cifsiod_wq
, &tcp_ses
->echo
, tcp_ses
->echo_interval
);
2750 out_err_crypto_release
:
2751 cifs_crypto_secmech_release(tcp_ses
);
2753 put_net(cifs_net_ns(tcp_ses
));
2757 if (!IS_ERR(tcp_ses
->hostname
))
2758 kfree(tcp_ses
->hostname
);
2759 if (tcp_ses
->ssocket
)
2760 sock_release(tcp_ses
->ssocket
);
2766 static int match_session(struct cifs_ses
*ses
, struct smb_vol
*vol
)
2768 if (vol
->sectype
!= Unspecified
&&
2769 vol
->sectype
!= ses
->sectype
)
2772 switch (ses
->sectype
) {
2774 if (!uid_eq(vol
->cred_uid
, ses
->cred_uid
))
2778 /* NULL username means anonymous session */
2779 if (ses
->user_name
== NULL
) {
2785 /* anything else takes username/password */
2786 if (strncmp(ses
->user_name
,
2787 vol
->username
? vol
->username
: "",
2788 CIFS_MAX_USERNAME_LEN
))
2790 if ((vol
->username
&& strlen(vol
->username
) != 0) &&
2791 ses
->password
!= NULL
&&
2792 strncmp(ses
->password
,
2793 vol
->password
? vol
->password
: "",
2794 CIFS_MAX_PASSWORD_LEN
))
2801 * cifs_setup_ipc - helper to setup the IPC tcon for the session
2803 * A new IPC connection is made and stored in the session
2804 * tcon_ipc. The IPC tcon has the same lifetime as the session.
2807 cifs_setup_ipc(struct cifs_ses
*ses
, struct smb_vol
*volume_info
)
2810 struct cifs_tcon
*tcon
;
2811 struct nls_table
*nls_codepage
;
2812 char unc
[SERVER_NAME_LENGTH
+ sizeof("//x/IPC$")] = {0};
2816 * If the mount request that resulted in the creation of the
2817 * session requires encryption, force IPC to be encrypted too.
2819 if (volume_info
->seal
) {
2820 if (ses
->server
->capabilities
& SMB2_GLOBAL_CAP_ENCRYPTION
)
2824 "IPC: server doesn't support encryption\n");
2829 tcon
= tconInfoAlloc();
2833 scnprintf(unc
, sizeof(unc
), "\\\\%s\\IPC$", ses
->server
->hostname
);
2836 nls_codepage
= load_nls_default();
2842 rc
= ses
->server
->ops
->tree_connect(xid
, ses
, unc
, tcon
, nls_codepage
);
2846 cifs_dbg(VFS
, "failed to connect to IPC (rc=%d)\n", rc
);
2851 cifs_dbg(FYI
, "IPC tcon rc = %d ipc tid = %d\n", rc
, tcon
->tid
);
2853 ses
->tcon_ipc
= tcon
;
2855 unload_nls(nls_codepage
);
2860 * cifs_free_ipc - helper to release the session IPC tcon
2862 * Needs to be called everytime a session is destroyed
2865 cifs_free_ipc(struct cifs_ses
*ses
)
2868 struct cifs_tcon
*tcon
= ses
->tcon_ipc
;
2873 if (ses
->server
->ops
->tree_disconnect
) {
2875 rc
= ses
->server
->ops
->tree_disconnect(xid
, tcon
);
2880 cifs_dbg(FYI
, "failed to disconnect IPC tcon (rc=%d)\n", rc
);
2883 ses
->tcon_ipc
= NULL
;
2887 static struct cifs_ses
*
2888 cifs_find_smb_ses(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
2890 struct cifs_ses
*ses
;
2892 spin_lock(&cifs_tcp_ses_lock
);
2893 list_for_each_entry(ses
, &server
->smb_ses_list
, smb_ses_list
) {
2894 if (ses
->status
== CifsExiting
)
2896 if (!match_session(ses
, vol
))
2899 spin_unlock(&cifs_tcp_ses_lock
);
2902 spin_unlock(&cifs_tcp_ses_lock
);
2906 void cifs_put_smb_ses(struct cifs_ses
*ses
)
2908 unsigned int rc
, xid
;
2909 struct TCP_Server_Info
*server
= ses
->server
;
2911 cifs_dbg(FYI
, "%s: ses_count=%d\n", __func__
, ses
->ses_count
);
2913 spin_lock(&cifs_tcp_ses_lock
);
2914 if (ses
->status
== CifsExiting
) {
2915 spin_unlock(&cifs_tcp_ses_lock
);
2918 if (--ses
->ses_count
> 0) {
2919 spin_unlock(&cifs_tcp_ses_lock
);
2922 if (ses
->status
== CifsGood
)
2923 ses
->status
= CifsExiting
;
2924 spin_unlock(&cifs_tcp_ses_lock
);
2928 if (ses
->status
== CifsExiting
&& server
->ops
->logoff
) {
2930 rc
= server
->ops
->logoff(xid
, ses
);
2932 cifs_dbg(VFS
, "%s: Session Logoff failure rc=%d\n",
2937 spin_lock(&cifs_tcp_ses_lock
);
2938 list_del_init(&ses
->smb_ses_list
);
2939 spin_unlock(&cifs_tcp_ses_lock
);
2942 cifs_put_tcp_session(server
, 0);
2947 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2948 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2950 /* Populate username and pw fields from keyring if possible */
2952 cifs_set_cifscreds(struct smb_vol
*vol
, struct cifs_ses
*ses
)
2955 const char *delim
, *payload
;
2959 struct TCP_Server_Info
*server
= ses
->server
;
2960 struct sockaddr_in
*sa
;
2961 struct sockaddr_in6
*sa6
;
2962 const struct user_key_payload
*upayload
;
2964 desc
= kmalloc(CIFSCREDS_DESC_SIZE
, GFP_KERNEL
);
2968 /* try to find an address key first */
2969 switch (server
->dstaddr
.ss_family
) {
2971 sa
= (struct sockaddr_in
*)&server
->dstaddr
;
2972 sprintf(desc
, "cifs:a:%pI4", &sa
->sin_addr
.s_addr
);
2975 sa6
= (struct sockaddr_in6
*)&server
->dstaddr
;
2976 sprintf(desc
, "cifs:a:%pI6c", &sa6
->sin6_addr
.s6_addr
);
2979 cifs_dbg(FYI
, "Bad ss_family (%hu)\n",
2980 server
->dstaddr
.ss_family
);
2985 cifs_dbg(FYI
, "%s: desc=%s\n", __func__
, desc
);
2986 key
= request_key(&key_type_logon
, desc
, "");
2988 if (!ses
->domainName
) {
2989 cifs_dbg(FYI
, "domainName is NULL\n");
2994 /* didn't work, try to find a domain key */
2995 sprintf(desc
, "cifs:d:%s", ses
->domainName
);
2996 cifs_dbg(FYI
, "%s: desc=%s\n", __func__
, desc
);
2997 key
= request_key(&key_type_logon
, desc
, "");
3004 down_read(&key
->sem
);
3005 upayload
= user_key_payload_locked(key
);
3006 if (IS_ERR_OR_NULL(upayload
)) {
3007 rc
= upayload
? PTR_ERR(upayload
) : -EINVAL
;
3011 /* find first : in payload */
3012 payload
= upayload
->data
;
3013 delim
= strnchr(payload
, upayload
->datalen
, ':');
3014 cifs_dbg(FYI
, "payload=%s\n", payload
);
3016 cifs_dbg(FYI
, "Unable to find ':' in payload (datalen=%d)\n",
3022 len
= delim
- payload
;
3023 if (len
> CIFS_MAX_USERNAME_LEN
|| len
<= 0) {
3024 cifs_dbg(FYI
, "Bad value from username search (len=%zd)\n",
3030 vol
->username
= kstrndup(payload
, len
, GFP_KERNEL
);
3031 if (!vol
->username
) {
3032 cifs_dbg(FYI
, "Unable to allocate %zd bytes for username\n",
3037 cifs_dbg(FYI
, "%s: username=%s\n", __func__
, vol
->username
);
3039 len
= key
->datalen
- (len
+ 1);
3040 if (len
> CIFS_MAX_PASSWORD_LEN
|| len
<= 0) {
3041 cifs_dbg(FYI
, "Bad len for password search (len=%zd)\n", len
);
3043 kfree(vol
->username
);
3044 vol
->username
= NULL
;
3049 vol
->password
= kstrndup(delim
, len
, GFP_KERNEL
);
3050 if (!vol
->password
) {
3051 cifs_dbg(FYI
, "Unable to allocate %zd bytes for password\n",
3054 kfree(vol
->username
);
3055 vol
->username
= NULL
;
3064 cifs_dbg(FYI
, "%s: returning %d\n", __func__
, rc
);
3067 #else /* ! CONFIG_KEYS */
3069 cifs_set_cifscreds(struct smb_vol
*vol
__attribute__((unused
)),
3070 struct cifs_ses
*ses
__attribute__((unused
)))
3074 #endif /* CONFIG_KEYS */
3077 * cifs_get_smb_ses - get a session matching @volume_info data from @server
3079 * This function assumes it is being called from cifs_mount() where we
3080 * already got a server reference (server refcount +1). See
3081 * cifs_get_tcon() for refcount explanations.
3084 cifs_get_smb_ses(struct TCP_Server_Info
*server
, struct smb_vol
*volume_info
)
3088 struct cifs_ses
*ses
;
3089 struct sockaddr_in
*addr
= (struct sockaddr_in
*)&server
->dstaddr
;
3090 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)&server
->dstaddr
;
3094 ses
= cifs_find_smb_ses(server
, volume_info
);
3096 cifs_dbg(FYI
, "Existing smb sess found (status=%d)\n",
3099 mutex_lock(&ses
->session_mutex
);
3100 rc
= cifs_negotiate_protocol(xid
, ses
);
3102 mutex_unlock(&ses
->session_mutex
);
3103 /* problem -- put our ses reference */
3104 cifs_put_smb_ses(ses
);
3108 if (ses
->need_reconnect
) {
3109 cifs_dbg(FYI
, "Session needs reconnect\n");
3110 rc
= cifs_setup_session(xid
, ses
,
3111 volume_info
->local_nls
);
3113 mutex_unlock(&ses
->session_mutex
);
3114 /* problem -- put our reference */
3115 cifs_put_smb_ses(ses
);
3120 mutex_unlock(&ses
->session_mutex
);
3122 /* existing SMB ses has a server reference already */
3123 cifs_put_tcp_session(server
, 0);
3128 cifs_dbg(FYI
, "Existing smb sess not found\n");
3129 ses
= sesInfoAlloc();
3133 /* new SMB session uses our server ref */
3134 ses
->server
= server
;
3135 if (server
->dstaddr
.ss_family
== AF_INET6
)
3136 sprintf(ses
->serverName
, "%pI6", &addr6
->sin6_addr
);
3138 sprintf(ses
->serverName
, "%pI4", &addr
->sin_addr
);
3140 if (volume_info
->username
) {
3141 ses
->user_name
= kstrdup(volume_info
->username
, GFP_KERNEL
);
3142 if (!ses
->user_name
)
3146 /* volume_info->password freed at unmount */
3147 if (volume_info
->password
) {
3148 ses
->password
= kstrdup(volume_info
->password
, GFP_KERNEL
);
3152 if (volume_info
->domainname
) {
3153 ses
->domainName
= kstrdup(volume_info
->domainname
, GFP_KERNEL
);
3154 if (!ses
->domainName
)
3157 if (volume_info
->domainauto
)
3158 ses
->domainAuto
= volume_info
->domainauto
;
3159 ses
->cred_uid
= volume_info
->cred_uid
;
3160 ses
->linux_uid
= volume_info
->linux_uid
;
3162 ses
->sectype
= volume_info
->sectype
;
3163 ses
->sign
= volume_info
->sign
;
3165 mutex_lock(&ses
->session_mutex
);
3166 rc
= cifs_negotiate_protocol(xid
, ses
);
3168 rc
= cifs_setup_session(xid
, ses
, volume_info
->local_nls
);
3169 mutex_unlock(&ses
->session_mutex
);
3173 /* success, put it on the list */
3174 spin_lock(&cifs_tcp_ses_lock
);
3175 list_add(&ses
->smb_ses_list
, &server
->smb_ses_list
);
3176 spin_unlock(&cifs_tcp_ses_lock
);
3180 cifs_setup_ipc(ses
, volume_info
);
3190 static int match_tcon(struct cifs_tcon
*tcon
, struct smb_vol
*volume_info
)
3192 if (tcon
->tidStatus
== CifsExiting
)
3194 if (strncmp(tcon
->treeName
, volume_info
->UNC
, MAX_TREE_SIZE
))
3196 if (tcon
->seal
!= volume_info
->seal
)
3198 if (tcon
->snapshot_time
!= volume_info
->snapshot_time
)
3200 if (tcon
->handle_timeout
!= volume_info
->handle_timeout
)
3205 static struct cifs_tcon
*
3206 cifs_find_tcon(struct cifs_ses
*ses
, struct smb_vol
*volume_info
)
3208 struct list_head
*tmp
;
3209 struct cifs_tcon
*tcon
;
3211 spin_lock(&cifs_tcp_ses_lock
);
3212 list_for_each(tmp
, &ses
->tcon_list
) {
3213 tcon
= list_entry(tmp
, struct cifs_tcon
, tcon_list
);
3214 if (!match_tcon(tcon
, volume_info
))
3217 spin_unlock(&cifs_tcp_ses_lock
);
3220 spin_unlock(&cifs_tcp_ses_lock
);
3225 cifs_put_tcon(struct cifs_tcon
*tcon
)
3228 struct cifs_ses
*ses
;
3231 * IPC tcon share the lifetime of their session and are
3232 * destroyed in the session put function
3234 if (tcon
== NULL
|| tcon
->ipc
)
3238 cifs_dbg(FYI
, "%s: tc_count=%d\n", __func__
, tcon
->tc_count
);
3239 spin_lock(&cifs_tcp_ses_lock
);
3240 if (--tcon
->tc_count
> 0) {
3241 spin_unlock(&cifs_tcp_ses_lock
);
3245 list_del_init(&tcon
->tcon_list
);
3246 spin_unlock(&cifs_tcp_ses_lock
);
3249 if (ses
->server
->ops
->tree_disconnect
)
3250 ses
->server
->ops
->tree_disconnect(xid
, tcon
);
3253 cifs_fscache_release_super_cookie(tcon
);
3255 cifs_put_smb_ses(ses
);
3259 * cifs_get_tcon - get a tcon matching @volume_info data from @ses
3261 * - tcon refcount is the number of mount points using the tcon.
3262 * - ses refcount is the number of tcon using the session.
3264 * 1. This function assumes it is being called from cifs_mount() where
3265 * we already got a session reference (ses refcount +1).
3267 * 2. Since we're in the context of adding a mount point, the end
3268 * result should be either:
3270 * a) a new tcon already allocated with refcount=1 (1 mount point) and
3271 * its session refcount incremented (1 new tcon). This +1 was
3272 * already done in (1).
3274 * b) an existing tcon with refcount+1 (add a mount point to it) and
3275 * identical ses refcount (no new tcon). Because of (1) we need to
3276 * decrement the ses refcount.
3278 static struct cifs_tcon
*
3279 cifs_get_tcon(struct cifs_ses
*ses
, struct smb_vol
*volume_info
)
3282 struct cifs_tcon
*tcon
;
3284 tcon
= cifs_find_tcon(ses
, volume_info
);
3287 * tcon has refcount already incremented but we need to
3288 * decrement extra ses reference gotten by caller (case b)
3290 cifs_dbg(FYI
, "Found match on UNC path\n");
3291 cifs_put_smb_ses(ses
);
3295 if (!ses
->server
->ops
->tree_connect
) {
3300 tcon
= tconInfoAlloc();
3306 if (volume_info
->snapshot_time
) {
3307 if (ses
->server
->vals
->protocol_id
== 0) {
3309 "Use SMB2 or later for snapshot mount option\n");
3313 tcon
->snapshot_time
= volume_info
->snapshot_time
;
3316 if (volume_info
->handle_timeout
) {
3317 if (ses
->server
->vals
->protocol_id
== 0) {
3319 "Use SMB2.1 or later for handle timeout option\n");
3323 tcon
->handle_timeout
= volume_info
->handle_timeout
;
3327 if (volume_info
->password
) {
3328 tcon
->password
= kstrdup(volume_info
->password
, GFP_KERNEL
);
3329 if (!tcon
->password
) {
3335 if (volume_info
->seal
) {
3336 if (ses
->server
->vals
->protocol_id
== 0) {
3338 "SMB3 or later required for encryption\n");
3341 } else if (tcon
->ses
->server
->capabilities
&
3342 SMB2_GLOBAL_CAP_ENCRYPTION
)
3345 cifs_dbg(VFS
, "Encryption is not supported on share\n");
3351 if (volume_info
->linux_ext
) {
3352 if (ses
->server
->posix_ext_supported
) {
3353 tcon
->posix_extensions
= true;
3354 printk_once(KERN_WARNING
3355 "SMB3.11 POSIX Extensions are experimental\n");
3357 cifs_dbg(VFS
, "Server does not support mounting with posix SMB3.11 extensions.\n");
3364 * BB Do we need to wrap session_mutex around this TCon call and Unix
3365 * SetFS as we do on SessSetup and reconnect?
3368 rc
= ses
->server
->ops
->tree_connect(xid
, ses
, volume_info
->UNC
, tcon
,
3369 volume_info
->local_nls
);
3371 cifs_dbg(FYI
, "Tcon rc = %d\n", rc
);
3375 tcon
->use_persistent
= false;
3376 /* check if SMB2 or later, CIFS does not support persistent handles */
3377 if (volume_info
->persistent
) {
3378 if (ses
->server
->vals
->protocol_id
== 0) {
3380 "SMB3 or later required for persistent handles\n");
3383 } else if (ses
->server
->capabilities
&
3384 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES
)
3385 tcon
->use_persistent
= true;
3386 else /* persistent handles requested but not supported */ {
3388 "Persistent handles not supported on share\n");
3392 } else if ((tcon
->capabilities
& SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY
)
3393 && (ses
->server
->capabilities
& SMB2_GLOBAL_CAP_PERSISTENT_HANDLES
)
3394 && (volume_info
->nopersistent
== false)) {
3395 cifs_dbg(FYI
, "enabling persistent handles\n");
3396 tcon
->use_persistent
= true;
3397 } else if (volume_info
->resilient
) {
3398 if (ses
->server
->vals
->protocol_id
== 0) {
3400 "SMB2.1 or later required for resilient handles\n");
3404 tcon
->use_resilient
= true;
3408 * We can have only one retry value for a connection to a share so for
3409 * resources mounted more than once to the same server share the last
3410 * value passed in for the retry flag is used.
3412 tcon
->retry
= volume_info
->retry
;
3413 tcon
->nocase
= volume_info
->nocase
;
3414 tcon
->nohandlecache
= volume_info
->nohandlecache
;
3415 tcon
->local_lease
= volume_info
->local_lease
;
3416 INIT_LIST_HEAD(&tcon
->pending_opens
);
3418 spin_lock(&cifs_tcp_ses_lock
);
3419 list_add(&tcon
->tcon_list
, &ses
->tcon_list
);
3420 spin_unlock(&cifs_tcp_ses_lock
);
3422 cifs_fscache_get_super_cookie(tcon
);
3432 cifs_put_tlink(struct tcon_link
*tlink
)
3434 if (!tlink
|| IS_ERR(tlink
))
3437 if (!atomic_dec_and_test(&tlink
->tl_count
) ||
3438 test_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
)) {
3439 tlink
->tl_time
= jiffies
;
3443 if (!IS_ERR(tlink_tcon(tlink
)))
3444 cifs_put_tcon(tlink_tcon(tlink
));
3450 compare_mount_options(struct super_block
*sb
, struct cifs_mnt_data
*mnt_data
)
3452 struct cifs_sb_info
*old
= CIFS_SB(sb
);
3453 struct cifs_sb_info
*new = mnt_data
->cifs_sb
;
3455 if ((sb
->s_flags
& CIFS_MS_MASK
) != (mnt_data
->flags
& CIFS_MS_MASK
))
3458 if ((old
->mnt_cifs_flags
& CIFS_MOUNT_MASK
) !=
3459 (new->mnt_cifs_flags
& CIFS_MOUNT_MASK
))
3463 * We want to share sb only if we don't specify an r/wsize or
3464 * specified r/wsize is greater than or equal to existing one.
3466 if (new->wsize
&& new->wsize
< old
->wsize
)
3469 if (new->rsize
&& new->rsize
< old
->rsize
)
3472 if (!uid_eq(old
->mnt_uid
, new->mnt_uid
) || !gid_eq(old
->mnt_gid
, new->mnt_gid
))
3475 if (old
->mnt_file_mode
!= new->mnt_file_mode
||
3476 old
->mnt_dir_mode
!= new->mnt_dir_mode
)
3479 if (strcmp(old
->local_nls
->charset
, new->local_nls
->charset
))
3482 if (old
->actimeo
!= new->actimeo
)
3489 match_prepath(struct super_block
*sb
, struct cifs_mnt_data
*mnt_data
)
3491 struct cifs_sb_info
*old
= CIFS_SB(sb
);
3492 struct cifs_sb_info
*new = mnt_data
->cifs_sb
;
3493 bool old_set
= old
->mnt_cifs_flags
& CIFS_MOUNT_USE_PREFIX_PATH
;
3494 bool new_set
= new->mnt_cifs_flags
& CIFS_MOUNT_USE_PREFIX_PATH
;
3496 if (old_set
&& new_set
&& !strcmp(new->prepath
, old
->prepath
))
3498 else if (!old_set
&& !new_set
)
3505 cifs_match_super(struct super_block
*sb
, void *data
)
3507 struct cifs_mnt_data
*mnt_data
= (struct cifs_mnt_data
*)data
;
3508 struct smb_vol
*volume_info
;
3509 struct cifs_sb_info
*cifs_sb
;
3510 struct TCP_Server_Info
*tcp_srv
;
3511 struct cifs_ses
*ses
;
3512 struct cifs_tcon
*tcon
;
3513 struct tcon_link
*tlink
;
3516 spin_lock(&cifs_tcp_ses_lock
);
3517 cifs_sb
= CIFS_SB(sb
);
3518 tlink
= cifs_get_tlink(cifs_sb_master_tlink(cifs_sb
));
3519 if (IS_ERR(tlink
)) {
3520 spin_unlock(&cifs_tcp_ses_lock
);
3523 tcon
= tlink_tcon(tlink
);
3525 tcp_srv
= ses
->server
;
3527 volume_info
= mnt_data
->vol
;
3529 if (!match_server(tcp_srv
, volume_info
) ||
3530 !match_session(ses
, volume_info
) ||
3531 !match_tcon(tcon
, volume_info
) ||
3532 !match_prepath(sb
, mnt_data
)) {
3537 rc
= compare_mount_options(sb
, mnt_data
);
3539 spin_unlock(&cifs_tcp_ses_lock
);
3540 cifs_put_tlink(tlink
);
3544 #ifdef CONFIG_DEBUG_LOCK_ALLOC
3545 static struct lock_class_key cifs_key
[2];
3546 static struct lock_class_key cifs_slock_key
[2];
3549 cifs_reclassify_socket4(struct socket
*sock
)
3551 struct sock
*sk
= sock
->sk
;
3552 BUG_ON(!sock_allow_reclassification(sk
));
3553 sock_lock_init_class_and_name(sk
, "slock-AF_INET-CIFS",
3554 &cifs_slock_key
[0], "sk_lock-AF_INET-CIFS", &cifs_key
[0]);
3558 cifs_reclassify_socket6(struct socket
*sock
)
3560 struct sock
*sk
= sock
->sk
;
3561 BUG_ON(!sock_allow_reclassification(sk
));
3562 sock_lock_init_class_and_name(sk
, "slock-AF_INET6-CIFS",
3563 &cifs_slock_key
[1], "sk_lock-AF_INET6-CIFS", &cifs_key
[1]);
3567 cifs_reclassify_socket4(struct socket
*sock
)
3572 cifs_reclassify_socket6(struct socket
*sock
)
3577 /* See RFC1001 section 14 on representation of Netbios names */
3578 static void rfc1002mangle(char *target
, char *source
, unsigned int length
)
3582 for (i
= 0, j
= 0; i
< (length
); i
++) {
3583 /* mask a nibble at a time and encode */
3584 target
[j
] = 'A' + (0x0F & (source
[i
] >> 4));
3585 target
[j
+1] = 'A' + (0x0F & source
[i
]);
3592 bind_socket(struct TCP_Server_Info
*server
)
3595 if (server
->srcaddr
.ss_family
!= AF_UNSPEC
) {
3596 /* Bind to the specified local IP address */
3597 struct socket
*socket
= server
->ssocket
;
3598 rc
= socket
->ops
->bind(socket
,
3599 (struct sockaddr
*) &server
->srcaddr
,
3600 sizeof(server
->srcaddr
));
3602 struct sockaddr_in
*saddr4
;
3603 struct sockaddr_in6
*saddr6
;
3604 saddr4
= (struct sockaddr_in
*)&server
->srcaddr
;
3605 saddr6
= (struct sockaddr_in6
*)&server
->srcaddr
;
3606 if (saddr6
->sin6_family
== AF_INET6
)
3607 cifs_dbg(VFS
, "Failed to bind to: %pI6c, error: %d\n",
3608 &saddr6
->sin6_addr
, rc
);
3610 cifs_dbg(VFS
, "Failed to bind to: %pI4, error: %d\n",
3611 &saddr4
->sin_addr
.s_addr
, rc
);
3618 ip_rfc1001_connect(struct TCP_Server_Info
*server
)
3622 * some servers require RFC1001 sessinit before sending
3623 * negprot - BB check reconnection in case where second
3624 * sessinit is sent but no second negprot
3626 struct rfc1002_session_packet
*ses_init_buf
;
3627 struct smb_hdr
*smb_buf
;
3628 ses_init_buf
= kzalloc(sizeof(struct rfc1002_session_packet
),
3631 ses_init_buf
->trailer
.session_req
.called_len
= 32;
3633 if (server
->server_RFC1001_name
[0] != 0)
3634 rfc1002mangle(ses_init_buf
->trailer
.
3635 session_req
.called_name
,
3636 server
->server_RFC1001_name
,
3637 RFC1001_NAME_LEN_WITH_NULL
);
3639 rfc1002mangle(ses_init_buf
->trailer
.
3640 session_req
.called_name
,
3641 DEFAULT_CIFS_CALLED_NAME
,
3642 RFC1001_NAME_LEN_WITH_NULL
);
3644 ses_init_buf
->trailer
.session_req
.calling_len
= 32;
3647 * calling name ends in null (byte 16) from old smb
3650 if (server
->workstation_RFC1001_name
[0] != 0)
3651 rfc1002mangle(ses_init_buf
->trailer
.
3652 session_req
.calling_name
,
3653 server
->workstation_RFC1001_name
,
3654 RFC1001_NAME_LEN_WITH_NULL
);
3656 rfc1002mangle(ses_init_buf
->trailer
.
3657 session_req
.calling_name
,
3659 RFC1001_NAME_LEN_WITH_NULL
);
3661 ses_init_buf
->trailer
.session_req
.scope1
= 0;
3662 ses_init_buf
->trailer
.session_req
.scope2
= 0;
3663 smb_buf
= (struct smb_hdr
*)ses_init_buf
;
3665 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3666 smb_buf
->smb_buf_length
= cpu_to_be32(0x81000044);
3667 rc
= smb_send(server
, smb_buf
, 0x44);
3668 kfree(ses_init_buf
);
3670 * RFC1001 layer in at least one server
3671 * requires very short break before negprot
3672 * presumably because not expecting negprot
3673 * to follow so fast. This is a simple
3674 * solution that works without
3675 * complicating the code and causes no
3676 * significant slowing down on mount
3679 usleep_range(1000, 2000);
3682 * else the negprot may still work without this
3683 * even though malloc failed
3690 generic_ip_connect(struct TCP_Server_Info
*server
)
3695 struct socket
*socket
= server
->ssocket
;
3696 struct sockaddr
*saddr
;
3698 saddr
= (struct sockaddr
*) &server
->dstaddr
;
3700 if (server
->dstaddr
.ss_family
== AF_INET6
) {
3701 sport
= ((struct sockaddr_in6
*) saddr
)->sin6_port
;
3702 slen
= sizeof(struct sockaddr_in6
);
3705 sport
= ((struct sockaddr_in
*) saddr
)->sin_port
;
3706 slen
= sizeof(struct sockaddr_in
);
3710 if (socket
== NULL
) {
3711 rc
= __sock_create(cifs_net_ns(server
), sfamily
, SOCK_STREAM
,
3712 IPPROTO_TCP
, &socket
, 1);
3714 cifs_dbg(VFS
, "Error %d creating socket\n", rc
);
3715 server
->ssocket
= NULL
;
3719 /* BB other socket options to set KEEPALIVE, NODELAY? */
3720 cifs_dbg(FYI
, "Socket created\n");
3721 server
->ssocket
= socket
;
3722 socket
->sk
->sk_allocation
= GFP_NOFS
;
3723 if (sfamily
== AF_INET6
)
3724 cifs_reclassify_socket6(socket
);
3726 cifs_reclassify_socket4(socket
);
3729 rc
= bind_socket(server
);
3734 * Eventually check for other socket options to change from
3735 * the default. sock_setsockopt not used because it expects
3738 socket
->sk
->sk_rcvtimeo
= 7 * HZ
;
3739 socket
->sk
->sk_sndtimeo
= 5 * HZ
;
3741 /* make the bufsizes depend on wsize/rsize and max requests */
3742 if (server
->noautotune
) {
3743 if (socket
->sk
->sk_sndbuf
< (200 * 1024))
3744 socket
->sk
->sk_sndbuf
= 200 * 1024;
3745 if (socket
->sk
->sk_rcvbuf
< (140 * 1024))
3746 socket
->sk
->sk_rcvbuf
= 140 * 1024;
3749 if (server
->tcp_nodelay
) {
3751 rc
= kernel_setsockopt(socket
, SOL_TCP
, TCP_NODELAY
,
3752 (char *)&val
, sizeof(val
));
3754 cifs_dbg(FYI
, "set TCP_NODELAY socket option error %d\n",
3758 cifs_dbg(FYI
, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3759 socket
->sk
->sk_sndbuf
,
3760 socket
->sk
->sk_rcvbuf
, socket
->sk
->sk_rcvtimeo
);
3762 rc
= socket
->ops
->connect(socket
, saddr
, slen
, 0);
3764 cifs_dbg(FYI
, "Error %d connecting to server\n", rc
);
3765 sock_release(socket
);
3766 server
->ssocket
= NULL
;
3770 if (sport
== htons(RFC1001_PORT
))
3771 rc
= ip_rfc1001_connect(server
);
3777 ip_connect(struct TCP_Server_Info
*server
)
3780 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)&server
->dstaddr
;
3781 struct sockaddr_in
*addr
= (struct sockaddr_in
*)&server
->dstaddr
;
3783 if (server
->dstaddr
.ss_family
== AF_INET6
)
3784 sport
= &addr6
->sin6_port
;
3786 sport
= &addr
->sin_port
;
3791 /* try with 445 port at first */
3792 *sport
= htons(CIFS_PORT
);
3794 rc
= generic_ip_connect(server
);
3798 /* if it failed, try with 139 port */
3799 *sport
= htons(RFC1001_PORT
);
3802 return generic_ip_connect(server
);
3805 void reset_cifs_unix_caps(unsigned int xid
, struct cifs_tcon
*tcon
,
3806 struct cifs_sb_info
*cifs_sb
, struct smb_vol
*vol_info
)
3808 /* if we are reconnecting then should we check to see if
3809 * any requested capabilities changed locally e.g. via
3810 * remount but we can not do much about it here
3811 * if they have (even if we could detect it by the following)
3812 * Perhaps we could add a backpointer to array of sb from tcon
3813 * or if we change to make all sb to same share the same
3814 * sb as NFS - then we only have one backpointer to sb.
3815 * What if we wanted to mount the server share twice once with
3816 * and once without posixacls or posix paths? */
3817 __u64 saved_cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
3819 if (vol_info
&& vol_info
->no_linux_ext
) {
3820 tcon
->fsUnixInfo
.Capability
= 0;
3821 tcon
->unix_ext
= 0; /* Unix Extensions disabled */
3822 cifs_dbg(FYI
, "Linux protocol extensions disabled\n");
3824 } else if (vol_info
)
3825 tcon
->unix_ext
= 1; /* Unix Extensions supported */
3827 if (tcon
->unix_ext
== 0) {
3828 cifs_dbg(FYI
, "Unix extensions disabled so not set on reconnect\n");
3832 if (!CIFSSMBQFSUnixInfo(xid
, tcon
)) {
3833 __u64 cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
3834 cifs_dbg(FYI
, "unix caps which server supports %lld\n", cap
);
3835 /* check for reconnect case in which we do not
3836 want to change the mount behavior if we can avoid it */
3837 if (vol_info
== NULL
) {
3838 /* turn off POSIX ACL and PATHNAMES if not set
3839 originally at mount time */
3840 if ((saved_cap
& CIFS_UNIX_POSIX_ACL_CAP
) == 0)
3841 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
3842 if ((saved_cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
3843 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
3844 cifs_dbg(VFS
, "POSIXPATH support change\n");
3845 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
3846 } else if ((cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
3847 cifs_dbg(VFS
, "possible reconnect error\n");
3848 cifs_dbg(VFS
, "server disabled POSIX path support\n");
3852 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)
3853 cifs_dbg(VFS
, "per-share encryption not supported yet\n");
3855 cap
&= CIFS_UNIX_CAP_MASK
;
3856 if (vol_info
&& vol_info
->no_psx_acl
)
3857 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
3858 else if (CIFS_UNIX_POSIX_ACL_CAP
& cap
) {
3859 cifs_dbg(FYI
, "negotiated posix acl support\n");
3861 cifs_sb
->mnt_cifs_flags
|=
3862 CIFS_MOUNT_POSIXACL
;
3865 if (vol_info
&& vol_info
->posix_paths
== 0)
3866 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
3867 else if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) {
3868 cifs_dbg(FYI
, "negotiate posix pathnames\n");
3870 cifs_sb
->mnt_cifs_flags
|=
3871 CIFS_MOUNT_POSIX_PATHS
;
3874 cifs_dbg(FYI
, "Negotiate caps 0x%x\n", (int)cap
);
3875 #ifdef CONFIG_CIFS_DEBUG2
3876 if (cap
& CIFS_UNIX_FCNTL_CAP
)
3877 cifs_dbg(FYI
, "FCNTL cap\n");
3878 if (cap
& CIFS_UNIX_EXTATTR_CAP
)
3879 cifs_dbg(FYI
, "EXTATTR cap\n");
3880 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
3881 cifs_dbg(FYI
, "POSIX path cap\n");
3882 if (cap
& CIFS_UNIX_XATTR_CAP
)
3883 cifs_dbg(FYI
, "XATTR cap\n");
3884 if (cap
& CIFS_UNIX_POSIX_ACL_CAP
)
3885 cifs_dbg(FYI
, "POSIX ACL cap\n");
3886 if (cap
& CIFS_UNIX_LARGE_READ_CAP
)
3887 cifs_dbg(FYI
, "very large read cap\n");
3888 if (cap
& CIFS_UNIX_LARGE_WRITE_CAP
)
3889 cifs_dbg(FYI
, "very large write cap\n");
3890 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP
)
3891 cifs_dbg(FYI
, "transport encryption cap\n");
3892 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)
3893 cifs_dbg(FYI
, "mandatory transport encryption cap\n");
3894 #endif /* CIFS_DEBUG2 */
3895 if (CIFSSMBSetFSUnixInfo(xid
, tcon
, cap
)) {
3896 if (vol_info
== NULL
) {
3897 cifs_dbg(FYI
, "resetting capabilities failed\n");
3899 cifs_dbg(VFS
, "Negotiating Unix capabilities with the server failed. Consider mounting with the Unix Extensions disabled if problems are found by specifying the nounix mount option.\n");
3905 int cifs_setup_cifs_sb(struct smb_vol
*pvolume_info
,
3906 struct cifs_sb_info
*cifs_sb
)
3908 INIT_DELAYED_WORK(&cifs_sb
->prune_tlinks
, cifs_prune_tlinks
);
3910 spin_lock_init(&cifs_sb
->tlink_tree_lock
);
3911 cifs_sb
->tlink_tree
= RB_ROOT
;
3913 cifs_sb
->bsize
= pvolume_info
->bsize
;
3915 * Temporarily set r/wsize for matching superblock. If we end up using
3916 * new sb then client will later negotiate it downward if needed.
3918 cifs_sb
->rsize
= pvolume_info
->rsize
;
3919 cifs_sb
->wsize
= pvolume_info
->wsize
;
3921 cifs_sb
->mnt_uid
= pvolume_info
->linux_uid
;
3922 cifs_sb
->mnt_gid
= pvolume_info
->linux_gid
;
3923 cifs_sb
->mnt_file_mode
= pvolume_info
->file_mode
;
3924 cifs_sb
->mnt_dir_mode
= pvolume_info
->dir_mode
;
3925 cifs_dbg(FYI
, "file mode: 0x%hx dir mode: 0x%hx\n",
3926 cifs_sb
->mnt_file_mode
, cifs_sb
->mnt_dir_mode
);
3928 cifs_sb
->actimeo
= pvolume_info
->actimeo
;
3929 cifs_sb
->local_nls
= pvolume_info
->local_nls
;
3931 if (pvolume_info
->nodfs
)
3932 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_DFS
;
3933 if (pvolume_info
->noperm
)
3934 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_PERM
;
3935 if (pvolume_info
->setuids
)
3936 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SET_UID
;
3937 if (pvolume_info
->setuidfromacl
)
3938 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_UID_FROM_ACL
;
3939 if (pvolume_info
->server_ino
)
3940 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SERVER_INUM
;
3941 if (pvolume_info
->remap
)
3942 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MAP_SFM_CHR
;
3943 if (pvolume_info
->sfu_remap
)
3944 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MAP_SPECIAL_CHR
;
3945 if (pvolume_info
->no_xattr
)
3946 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_XATTR
;
3947 if (pvolume_info
->sfu_emul
)
3948 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_UNX_EMUL
;
3949 if (pvolume_info
->nobrl
)
3950 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_BRL
;
3951 if (pvolume_info
->nohandlecache
)
3952 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_HANDLE_CACHE
;
3953 if (pvolume_info
->nostrictsync
)
3954 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NOSSYNC
;
3955 if (pvolume_info
->mand_lock
)
3956 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NOPOSIXBRL
;
3957 if (pvolume_info
->rwpidforward
)
3958 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_RWPIDFORWARD
;
3959 if (pvolume_info
->cifs_acl
)
3960 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_ACL
;
3961 if (pvolume_info
->backupuid_specified
) {
3962 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_BACKUPUID
;
3963 cifs_sb
->mnt_backupuid
= pvolume_info
->backupuid
;
3965 if (pvolume_info
->backupgid_specified
) {
3966 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_BACKUPGID
;
3967 cifs_sb
->mnt_backupgid
= pvolume_info
->backupgid
;
3969 if (pvolume_info
->override_uid
)
3970 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_UID
;
3971 if (pvolume_info
->override_gid
)
3972 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_GID
;
3973 if (pvolume_info
->dynperm
)
3974 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DYNPERM
;
3975 if (pvolume_info
->fsc
)
3976 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_FSCACHE
;
3977 if (pvolume_info
->multiuser
)
3978 cifs_sb
->mnt_cifs_flags
|= (CIFS_MOUNT_MULTIUSER
|
3979 CIFS_MOUNT_NO_PERM
);
3980 if (pvolume_info
->strict_io
)
3981 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_STRICT_IO
;
3982 if (pvolume_info
->direct_io
) {
3983 cifs_dbg(FYI
, "mounting share using direct i/o\n");
3984 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DIRECT_IO
;
3986 if (pvolume_info
->mfsymlinks
) {
3987 if (pvolume_info
->sfu_emul
) {
3989 * Our SFU ("Services for Unix" emulation does not allow
3990 * creating symlinks but does allow reading existing SFU
3991 * symlinks (it does allow both creating and reading SFU
3992 * style mknod and FIFOs though). When "mfsymlinks" and
3993 * "sfu" are both enabled at the same time, it allows
3994 * reading both types of symlinks, but will only create
3995 * them with mfsymlinks format. This allows better
3996 * Apple compatibility (probably better for Samba too)
3997 * while still recognizing old Windows style symlinks.
3999 cifs_dbg(VFS
, "mount options mfsymlinks and sfu both enabled\n");
4001 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MF_SYMLINKS
;
4004 if ((pvolume_info
->cifs_acl
) && (pvolume_info
->dynperm
))
4005 cifs_dbg(VFS
, "mount option dynperm ignored if cifsacl mount option supported\n");
4007 if (pvolume_info
->prepath
) {
4008 cifs_sb
->prepath
= kstrdup(pvolume_info
->prepath
, GFP_KERNEL
);
4009 if (cifs_sb
->prepath
== NULL
)
4017 cifs_cleanup_volume_info_contents(struct smb_vol
*volume_info
)
4019 kfree(volume_info
->username
);
4020 kzfree(volume_info
->password
);
4021 kfree(volume_info
->UNC
);
4022 kfree(volume_info
->domainname
);
4023 kfree(volume_info
->iocharset
);
4024 kfree(volume_info
->prepath
);
4028 cifs_cleanup_volume_info(struct smb_vol
*volume_info
)
4032 cifs_cleanup_volume_info_contents(volume_info
);
4036 /* Release all succeed connections */
4037 static inline void mount_put_conns(struct cifs_sb_info
*cifs_sb
,
4039 struct TCP_Server_Info
*server
,
4040 struct cifs_ses
*ses
, struct cifs_tcon
*tcon
)
4045 cifs_put_tcon(tcon
);
4047 cifs_put_smb_ses(ses
);
4049 cifs_put_tcp_session(server
, 0);
4050 cifs_sb
->mnt_cifs_flags
&= ~CIFS_MOUNT_POSIX_PATHS
;
4054 /* Get connections for tcp, ses and tcon */
4055 static int mount_get_conns(struct smb_vol
*vol
, struct cifs_sb_info
*cifs_sb
,
4057 struct TCP_Server_Info
**nserver
,
4058 struct cifs_ses
**nses
, struct cifs_tcon
**ntcon
)
4061 struct TCP_Server_Info
*server
;
4062 struct cifs_ses
*ses
;
4063 struct cifs_tcon
*tcon
;
4071 /* get a reference to a tcp session */
4072 server
= cifs_get_tcp_session(vol
);
4073 if (IS_ERR(server
)) {
4074 rc
= PTR_ERR(server
);
4080 if ((vol
->max_credits
< 20) || (vol
->max_credits
> 60000))
4081 server
->max_credits
= SMB2_MAX_CREDITS_AVAILABLE
;
4083 server
->max_credits
= vol
->max_credits
;
4085 /* get a reference to a SMB session */
4086 ses
= cifs_get_smb_ses(server
, vol
);
4094 if ((vol
->persistent
== true) && (!(ses
->server
->capabilities
&
4095 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES
))) {
4096 cifs_dbg(VFS
, "persistent handles not supported by server\n");
4100 /* search for existing tcon to this server share */
4101 tcon
= cifs_get_tcon(ses
, vol
);
4109 /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
4110 if (tcon
->posix_extensions
)
4111 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_POSIX_PATHS
;
4113 /* tell server which Unix caps we support */
4114 if (cap_unix(tcon
->ses
)) {
4116 * reset of caps checks mount to see if unix extensions disabled
4117 * for just this mount.
4119 reset_cifs_unix_caps(*xid
, tcon
, cifs_sb
, vol
);
4120 if ((tcon
->ses
->server
->tcpStatus
== CifsNeedReconnect
) &&
4121 (le64_to_cpu(tcon
->fsUnixInfo
.Capability
) &
4122 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
))
4125 tcon
->unix_ext
= 0; /* server does not support them */
4127 /* do not care if a following call succeed - informational */
4128 if (!tcon
->pipe
&& server
->ops
->qfs_tcon
)
4129 server
->ops
->qfs_tcon(*xid
, tcon
);
4131 cifs_sb
->wsize
= server
->ops
->negotiate_wsize(tcon
, vol
);
4132 cifs_sb
->rsize
= server
->ops
->negotiate_rsize(tcon
, vol
);
4137 static int mount_setup_tlink(struct cifs_sb_info
*cifs_sb
, struct cifs_ses
*ses
,
4138 struct cifs_tcon
*tcon
)
4140 struct tcon_link
*tlink
;
4142 /* hang the tcon off of the superblock */
4143 tlink
= kzalloc(sizeof(*tlink
), GFP_KERNEL
);
4147 tlink
->tl_uid
= ses
->linux_uid
;
4148 tlink
->tl_tcon
= tcon
;
4149 tlink
->tl_time
= jiffies
;
4150 set_bit(TCON_LINK_MASTER
, &tlink
->tl_flags
);
4151 set_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
4153 cifs_sb
->master_tlink
= tlink
;
4154 spin_lock(&cifs_sb
->tlink_tree_lock
);
4155 tlink_rb_insert(&cifs_sb
->tlink_tree
, tlink
);
4156 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4158 queue_delayed_work(cifsiod_wq
, &cifs_sb
->prune_tlinks
,
4163 #ifdef CONFIG_CIFS_DFS_UPCALL
4165 * cifs_build_path_to_root returns full path to root when we do not have an
4166 * exiting connection (tcon)
4169 build_unc_path_to_root(const struct smb_vol
*vol
,
4170 const struct cifs_sb_info
*cifs_sb
, bool useppath
)
4172 char *full_path
, *pos
;
4173 unsigned int pplen
= useppath
&& vol
->prepath
?
4174 strlen(vol
->prepath
) + 1 : 0;
4175 unsigned int unc_len
= strnlen(vol
->UNC
, MAX_TREE_SIZE
+ 1);
4177 full_path
= kmalloc(unc_len
+ pplen
+ 1, GFP_KERNEL
);
4178 if (full_path
== NULL
)
4179 return ERR_PTR(-ENOMEM
);
4181 strncpy(full_path
, vol
->UNC
, unc_len
);
4182 pos
= full_path
+ unc_len
;
4185 *pos
= CIFS_DIR_SEP(cifs_sb
);
4186 strncpy(pos
+ 1, vol
->prepath
, pplen
);
4190 *pos
= '\0'; /* add trailing null */
4191 convert_delimiter(full_path
, CIFS_DIR_SEP(cifs_sb
));
4192 cifs_dbg(FYI
, "%s: full_path=%s\n", __func__
, full_path
);
4197 * expand_dfs_referral - Perform a dfs referral query and update the cifs_sb
4200 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
4201 * to a string containing updated options for the submount. Otherwise it
4202 * will be left untouched.
4204 * Returns the rc from get_dfs_path to the caller, which can be used to
4205 * determine whether there were referrals.
4208 expand_dfs_referral(const unsigned int xid
, struct cifs_ses
*ses
,
4209 struct smb_vol
*volume_info
, struct cifs_sb_info
*cifs_sb
,
4213 struct dfs_info3_param referral
= {0};
4214 char *full_path
= NULL
, *ref_path
= NULL
, *mdata
= NULL
;
4216 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_DFS
)
4219 full_path
= build_unc_path_to_root(volume_info
, cifs_sb
, true);
4220 if (IS_ERR(full_path
))
4221 return PTR_ERR(full_path
);
4223 /* For DFS paths, skip the first '\' of the UNC */
4224 ref_path
= check_prefix
? full_path
+ 1 : volume_info
->UNC
+ 1;
4226 rc
= dfs_cache_find(xid
, ses
, cifs_sb
->local_nls
, cifs_remap(cifs_sb
),
4227 ref_path
, &referral
, NULL
);
4229 char *fake_devname
= NULL
;
4231 mdata
= cifs_compose_mount_options(cifs_sb
->mountdata
,
4232 full_path
+ 1, &referral
,
4234 free_dfs_info_param(&referral
);
4236 if (IS_ERR(mdata
)) {
4237 rc
= PTR_ERR(mdata
);
4240 cifs_cleanup_volume_info_contents(volume_info
);
4241 rc
= cifs_setup_volume_info(volume_info
, mdata
,
4242 fake_devname
, false);
4244 kfree(fake_devname
);
4245 kfree(cifs_sb
->mountdata
);
4246 cifs_sb
->mountdata
= mdata
;
4252 static inline int get_next_dfs_tgt(const char *path
,
4253 struct dfs_cache_tgt_list
*tgt_list
,
4254 struct dfs_cache_tgt_iterator
**tgt_it
)
4257 *tgt_it
= dfs_cache_get_tgt_iterator(tgt_list
);
4259 *tgt_it
= dfs_cache_get_next_tgt(tgt_list
, *tgt_it
);
4260 return !*tgt_it
? -EHOSTDOWN
: 0;
4263 static int update_vol_info(const struct dfs_cache_tgt_iterator
*tgt_it
,
4264 struct smb_vol
*fake_vol
, struct smb_vol
*vol
)
4266 const char *tgt
= dfs_cache_get_tgt_name(tgt_it
);
4267 int len
= strlen(tgt
) + 2;
4270 new_unc
= kmalloc(len
, GFP_KERNEL
);
4273 scnprintf(new_unc
, len
, "\\%s", tgt
);
4278 if (fake_vol
->prepath
) {
4279 kfree(vol
->prepath
);
4280 vol
->prepath
= fake_vol
->prepath
;
4281 fake_vol
->prepath
= NULL
;
4283 memcpy(&vol
->dstaddr
, &fake_vol
->dstaddr
, sizeof(vol
->dstaddr
));
4288 static int setup_dfs_tgt_conn(const char *path
,
4289 const struct dfs_cache_tgt_iterator
*tgt_it
,
4290 struct cifs_sb_info
*cifs_sb
,
4291 struct smb_vol
*vol
,
4293 struct TCP_Server_Info
**server
,
4294 struct cifs_ses
**ses
,
4295 struct cifs_tcon
**tcon
)
4298 struct dfs_info3_param ref
= {0};
4299 char *mdata
= NULL
, *fake_devname
= NULL
;
4300 struct smb_vol fake_vol
= {0};
4302 cifs_dbg(FYI
, "%s: dfs path: %s\n", __func__
, path
);
4304 rc
= dfs_cache_get_tgt_referral(path
, tgt_it
, &ref
);
4308 mdata
= cifs_compose_mount_options(cifs_sb
->mountdata
, path
, &ref
,
4310 free_dfs_info_param(&ref
);
4312 if (IS_ERR(mdata
)) {
4313 rc
= PTR_ERR(mdata
);
4316 cifs_dbg(FYI
, "%s: fake_devname: %s\n", __func__
, fake_devname
);
4317 rc
= cifs_setup_volume_info(&fake_vol
, mdata
, fake_devname
,
4321 kfree(fake_devname
);
4325 * We use a 'fake_vol' here because we need pass it down to the
4326 * mount_{get,put} functions to test connection against new DFS
4329 mount_put_conns(cifs_sb
, *xid
, *server
, *ses
, *tcon
);
4330 rc
= mount_get_conns(&fake_vol
, cifs_sb
, xid
, server
, ses
,
4334 * We were able to connect to new target server.
4335 * Update current volume info with new target server.
4337 rc
= update_vol_info(tgt_it
, &fake_vol
, vol
);
4340 cifs_cleanup_volume_info_contents(&fake_vol
);
4344 static int mount_do_dfs_failover(const char *path
,
4345 struct cifs_sb_info
*cifs_sb
,
4346 struct smb_vol
*vol
,
4347 struct cifs_ses
*root_ses
,
4349 struct TCP_Server_Info
**server
,
4350 struct cifs_ses
**ses
,
4351 struct cifs_tcon
**tcon
)
4354 struct dfs_cache_tgt_list tgt_list
;
4355 struct dfs_cache_tgt_iterator
*tgt_it
= NULL
;
4357 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_DFS
)
4360 rc
= dfs_cache_noreq_find(path
, NULL
, &tgt_list
);
4365 /* Get next DFS target server - if any */
4366 rc
= get_next_dfs_tgt(path
, &tgt_list
, &tgt_it
);
4369 /* Connect to next DFS target */
4370 rc
= setup_dfs_tgt_conn(path
, tgt_it
, cifs_sb
, vol
, xid
, server
,
4372 if (!rc
|| rc
== -EACCES
|| rc
== -EOPNOTSUPP
)
4377 * Update DFS target hint in DFS referral cache with the target
4378 * server we successfully reconnected to.
4380 rc
= dfs_cache_update_tgthint(*xid
, root_ses
? root_ses
: *ses
,
4382 cifs_remap(cifs_sb
), path
,
4385 dfs_cache_free_tgts(&tgt_list
);
4391 cifs_setup_volume_info(struct smb_vol
*volume_info
, char *mount_data
,
4392 const char *devname
, bool is_smb3
)
4396 if (cifs_parse_mount_options(mount_data
, devname
, volume_info
, is_smb3
))
4399 if (volume_info
->nullauth
) {
4400 cifs_dbg(FYI
, "Anonymous login\n");
4401 kfree(volume_info
->username
);
4402 volume_info
->username
= NULL
;
4403 } else if (volume_info
->username
) {
4404 /* BB fixme parse for domain name here */
4405 cifs_dbg(FYI
, "Username: %s\n", volume_info
->username
);
4407 cifs_dbg(VFS
, "No username specified\n");
4408 /* In userspace mount helper we can get user name from alternate
4409 locations such as env variables and files on disk */
4413 /* this is needed for ASCII cp to Unicode converts */
4414 if (volume_info
->iocharset
== NULL
) {
4415 /* load_nls_default cannot return null */
4416 volume_info
->local_nls
= load_nls_default();
4418 volume_info
->local_nls
= load_nls(volume_info
->iocharset
);
4419 if (volume_info
->local_nls
== NULL
) {
4420 cifs_dbg(VFS
, "CIFS mount error: iocharset %s not found\n",
4421 volume_info
->iocharset
);
4430 cifs_get_volume_info(char *mount_data
, const char *devname
, bool is_smb3
)
4433 struct smb_vol
*volume_info
;
4435 volume_info
= kmalloc(sizeof(struct smb_vol
), GFP_KERNEL
);
4437 return ERR_PTR(-ENOMEM
);
4439 rc
= cifs_setup_volume_info(volume_info
, mount_data
, devname
, is_smb3
);
4441 cifs_cleanup_volume_info(volume_info
);
4442 volume_info
= ERR_PTR(rc
);
4449 cifs_are_all_path_components_accessible(struct TCP_Server_Info
*server
,
4451 struct cifs_tcon
*tcon
,
4452 struct cifs_sb_info
*cifs_sb
,
4459 sep
= CIFS_DIR_SEP(cifs_sb
);
4462 rc
= server
->ops
->is_path_accessible(xid
, tcon
, cifs_sb
, "");
4464 /* skip separators */
4469 /* next separator */
4470 while (*s
&& *s
!= sep
)
4474 * temporarily null-terminate the path at the end of
4475 * the current component
4479 rc
= server
->ops
->is_path_accessible(xid
, tcon
, cifs_sb
,
4487 * Check if path is remote (e.g. a DFS share). Return -EREMOTE if it is,
4490 static int is_path_remote(struct cifs_sb_info
*cifs_sb
, struct smb_vol
*vol
,
4491 const unsigned int xid
,
4492 struct TCP_Server_Info
*server
,
4493 struct cifs_tcon
*tcon
)
4498 if (!server
->ops
->is_path_accessible
)
4502 * cifs_build_path_to_root works only when we have a valid tcon
4504 full_path
= cifs_build_path_to_root(vol
, cifs_sb
, tcon
,
4505 tcon
->Flags
& SMB_SHARE_IS_IN_DFS
);
4506 if (full_path
== NULL
)
4509 cifs_dbg(FYI
, "%s: full_path: %s\n", __func__
, full_path
);
4511 rc
= server
->ops
->is_path_accessible(xid
, tcon
, cifs_sb
,
4513 if (rc
!= 0 && rc
!= -EREMOTE
) {
4518 if (rc
!= -EREMOTE
) {
4519 rc
= cifs_are_all_path_components_accessible(server
, xid
, tcon
,
4523 cifs_dbg(VFS
, "cannot query dirs between root and final path, "
4524 "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
4525 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_USE_PREFIX_PATH
;
4534 #ifdef CONFIG_CIFS_DFS_UPCALL
4535 int cifs_mount(struct cifs_sb_info
*cifs_sb
, struct smb_vol
*vol
)
4539 struct cifs_ses
*ses
;
4540 struct cifs_tcon
*root_tcon
= NULL
;
4541 struct cifs_tcon
*tcon
= NULL
;
4542 struct TCP_Server_Info
*server
;
4543 char *root_path
= NULL
, *full_path
= NULL
;
4544 char *old_mountdata
, *origin_mountdata
= NULL
;
4547 rc
= mount_get_conns(vol
, cifs_sb
, &xid
, &server
, &ses
, &tcon
);
4549 /* If not a standalone DFS root, then check if path is remote */
4550 rc
= dfs_cache_find(xid
, ses
, cifs_sb
->local_nls
,
4551 cifs_remap(cifs_sb
), vol
->UNC
+ 1, NULL
,
4554 rc
= is_path_remote(cifs_sb
, vol
, xid
, server
, tcon
);
4562 * If first DFS target server went offline and we failed to connect it,
4563 * server and ses pointers are NULL at this point, though we still have
4564 * chance to get a cached DFS referral in expand_dfs_referral() and
4565 * retry next target available in it.
4567 * If a NULL ses ptr is passed to dfs_cache_find(), a lookup will be
4568 * performed against DFS path and *no* requests will be sent to server
4569 * for any new DFS referrals. Hence it's safe to skip checking whether
4570 * server or ses ptr is NULL.
4572 if (rc
== -EACCES
|| rc
== -EOPNOTSUPP
)
4575 root_path
= build_unc_path_to_root(vol
, cifs_sb
, false);
4576 if (IS_ERR(root_path
)) {
4577 rc
= PTR_ERR(root_path
);
4582 full_path
= build_unc_path_to_root(vol
, cifs_sb
, true);
4583 if (IS_ERR(full_path
)) {
4584 rc
= PTR_ERR(full_path
);
4589 * Perform an unconditional check for whether there are DFS
4590 * referrals for this path without prefix, to provide support
4591 * for DFS referrals from w2k8 servers which don't seem to respond
4592 * with PATH_NOT_COVERED to requests that include the prefix.
4593 * Chase the referral if found, otherwise continue normally.
4595 old_mountdata
= cifs_sb
->mountdata
;
4596 (void)expand_dfs_referral(xid
, ses
, vol
, cifs_sb
, false);
4598 if (cifs_sb
->mountdata
== NULL
) {
4603 /* Save DFS root volume information for DFS refresh worker */
4604 origin_mountdata
= kstrndup(cifs_sb
->mountdata
,
4605 strlen(cifs_sb
->mountdata
), GFP_KERNEL
);
4606 if (!origin_mountdata
) {
4611 if (cifs_sb
->mountdata
!= old_mountdata
) {
4612 /* If we were redirected, reconnect to new target server */
4613 mount_put_conns(cifs_sb
, xid
, server
, ses
, tcon
);
4614 rc
= mount_get_conns(vol
, cifs_sb
, &xid
, &server
, &ses
, &tcon
);
4617 if (rc
== -EACCES
|| rc
== -EOPNOTSUPP
)
4619 /* Perform DFS failover to any other DFS targets */
4620 rc
= mount_do_dfs_failover(root_path
+ 1, cifs_sb
, vol
, NULL
,
4621 &xid
, &server
, &ses
, &tcon
);
4627 root_path
= build_unc_path_to_root(vol
, cifs_sb
, false);
4628 if (IS_ERR(root_path
)) {
4629 rc
= PTR_ERR(root_path
);
4633 /* Cache out resolved root server */
4634 (void)dfs_cache_find(xid
, ses
, cifs_sb
->local_nls
, cifs_remap(cifs_sb
),
4635 root_path
+ 1, NULL
, NULL
);
4637 * Save root tcon for additional DFS requests to update or create a new
4638 * DFS cache entry, or even perform DFS failover.
4640 spin_lock(&cifs_tcp_ses_lock
);
4642 tcon
->dfs_path
= root_path
;
4644 tcon
->remap
= cifs_remap(cifs_sb
);
4645 spin_unlock(&cifs_tcp_ses_lock
);
4649 for (count
= 1; ;) {
4651 rc
= is_path_remote(cifs_sb
, vol
, xid
, server
, tcon
);
4652 if (!rc
|| rc
!= -EREMOTE
)
4656 * BB: when we implement proper loop detection,
4657 * we will remove this check. But now we need it
4658 * to prevent an indefinite loop if 'DFS tree' is
4659 * misconfigured (i.e. has loops).
4661 if (count
++ > MAX_NESTED_LINKS
) {
4667 full_path
= build_unc_path_to_root(vol
, cifs_sb
, true);
4668 if (IS_ERR(full_path
)) {
4669 rc
= PTR_ERR(full_path
);
4674 old_mountdata
= cifs_sb
->mountdata
;
4675 rc
= expand_dfs_referral(xid
, root_tcon
->ses
, vol
, cifs_sb
,
4680 if (cifs_sb
->mountdata
!= old_mountdata
) {
4681 mount_put_conns(cifs_sb
, xid
, server
, ses
, tcon
);
4682 rc
= mount_get_conns(vol
, cifs_sb
, &xid
, &server
, &ses
,
4686 if (rc
== -EACCES
|| rc
== -EOPNOTSUPP
)
4688 /* Perform DFS failover to any other DFS targets */
4689 rc
= mount_do_dfs_failover(full_path
+ 1, cifs_sb
, vol
,
4690 root_tcon
->ses
, &xid
,
4691 &server
, &ses
, &tcon
);
4692 if (rc
== -EACCES
|| rc
== -EOPNOTSUPP
|| !server
||
4697 cifs_put_tcon(root_tcon
);
4702 spin_lock(&cifs_tcp_ses_lock
);
4703 if (!tcon
->dfs_path
) {
4704 /* Save full path in new tcon to do failover when reconnecting tcons */
4705 tcon
->dfs_path
= full_path
;
4707 tcon
->remap
= cifs_remap(cifs_sb
);
4709 cifs_sb
->origin_fullpath
= kstrndup(tcon
->dfs_path
,
4710 strlen(tcon
->dfs_path
),
4712 if (!cifs_sb
->origin_fullpath
) {
4713 spin_unlock(&cifs_tcp_ses_lock
);
4717 spin_unlock(&cifs_tcp_ses_lock
);
4719 rc
= dfs_cache_add_vol(origin_mountdata
, vol
, cifs_sb
->origin_fullpath
);
4721 kfree(cifs_sb
->origin_fullpath
);
4725 * After reconnecting to a different server, unique ids won't
4726 * match anymore, so we disable serverino. This prevents
4727 * dentry revalidation to think the dentry are stale (ESTALE).
4729 cifs_autodisable_serverino(cifs_sb
);
4732 return mount_setup_tlink(cifs_sb
, ses
, tcon
);
4737 kfree(origin_mountdata
);
4738 mount_put_conns(cifs_sb
, xid
, server
, ses
, tcon
);
4742 int cifs_mount(struct cifs_sb_info
*cifs_sb
, struct smb_vol
*vol
)
4746 struct cifs_ses
*ses
;
4747 struct cifs_tcon
*tcon
;
4748 struct TCP_Server_Info
*server
;
4750 rc
= mount_get_conns(vol
, cifs_sb
, &xid
, &server
, &ses
, &tcon
);
4755 rc
= is_path_remote(cifs_sb
, vol
, xid
, server
, tcon
);
4764 return mount_setup_tlink(cifs_sb
, ses
, tcon
);
4767 mount_put_conns(cifs_sb
, xid
, server
, ses
, tcon
);
4773 * Issue a TREE_CONNECT request.
4776 CIFSTCon(const unsigned int xid
, struct cifs_ses
*ses
,
4777 const char *tree
, struct cifs_tcon
*tcon
,
4778 const struct nls_table
*nls_codepage
)
4780 struct smb_hdr
*smb_buffer
;
4781 struct smb_hdr
*smb_buffer_response
;
4784 unsigned char *bcc_ptr
;
4787 __u16 bytes_left
, count
;
4792 smb_buffer
= cifs_buf_get();
4793 if (smb_buffer
== NULL
)
4796 smb_buffer_response
= smb_buffer
;
4798 header_assemble(smb_buffer
, SMB_COM_TREE_CONNECT_ANDX
,
4799 NULL
/*no tid */ , 4 /*wct */ );
4801 smb_buffer
->Mid
= get_next_mid(ses
->server
);
4802 smb_buffer
->Uid
= ses
->Suid
;
4803 pSMB
= (TCONX_REQ
*) smb_buffer
;
4804 pSMBr
= (TCONX_RSP
*) smb_buffer_response
;
4806 pSMB
->AndXCommand
= 0xFF;
4807 pSMB
->Flags
= cpu_to_le16(TCON_EXTENDED_SECINFO
);
4808 bcc_ptr
= &pSMB
->Password
[0];
4809 if (tcon
->pipe
|| (ses
->server
->sec_mode
& SECMODE_USER
)) {
4810 pSMB
->PasswordLength
= cpu_to_le16(1); /* minimum */
4811 *bcc_ptr
= 0; /* password is null byte */
4812 bcc_ptr
++; /* skip password */
4813 /* already aligned so no need to do it below */
4815 pSMB
->PasswordLength
= cpu_to_le16(CIFS_AUTH_RESP_SIZE
);
4816 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
4817 specified as required (when that support is added to
4818 the vfs in the future) as only NTLM or the much
4819 weaker LANMAN (which we do not send by default) is accepted
4820 by Samba (not sure whether other servers allow
4821 NTLMv2 password here) */
4822 #ifdef CONFIG_CIFS_WEAK_PW_HASH
4823 if ((global_secflags
& CIFSSEC_MAY_LANMAN
) &&
4824 (ses
->sectype
== LANMAN
))
4825 calc_lanman_hash(tcon
->password
, ses
->server
->cryptkey
,
4826 ses
->server
->sec_mode
&
4827 SECMODE_PW_ENCRYPT
? true : false,
4830 #endif /* CIFS_WEAK_PW_HASH */
4831 rc
= SMBNTencrypt(tcon
->password
, ses
->server
->cryptkey
,
4832 bcc_ptr
, nls_codepage
);
4834 cifs_dbg(FYI
, "%s Can't generate NTLM rsp. Error: %d\n",
4836 cifs_buf_release(smb_buffer
);
4840 bcc_ptr
+= CIFS_AUTH_RESP_SIZE
;
4841 if (ses
->capabilities
& CAP_UNICODE
) {
4842 /* must align unicode strings */
4843 *bcc_ptr
= 0; /* null byte password */
4848 if (ses
->server
->sign
)
4849 smb_buffer
->Flags2
|= SMBFLG2_SECURITY_SIGNATURE
;
4851 if (ses
->capabilities
& CAP_STATUS32
) {
4852 smb_buffer
->Flags2
|= SMBFLG2_ERR_STATUS
;
4854 if (ses
->capabilities
& CAP_DFS
) {
4855 smb_buffer
->Flags2
|= SMBFLG2_DFS
;
4857 if (ses
->capabilities
& CAP_UNICODE
) {
4858 smb_buffer
->Flags2
|= SMBFLG2_UNICODE
;
4860 cifs_strtoUTF16((__le16
*) bcc_ptr
, tree
,
4861 6 /* max utf8 char length in bytes */ *
4862 (/* server len*/ + 256 /* share len */), nls_codepage
);
4863 bcc_ptr
+= 2 * length
; /* convert num 16 bit words to bytes */
4864 bcc_ptr
+= 2; /* skip trailing null */
4865 } else { /* ASCII */
4866 strcpy(bcc_ptr
, tree
);
4867 bcc_ptr
+= strlen(tree
) + 1;
4869 strcpy(bcc_ptr
, "?????");
4870 bcc_ptr
+= strlen("?????");
4872 count
= bcc_ptr
- &pSMB
->Password
[0];
4873 pSMB
->hdr
.smb_buf_length
= cpu_to_be32(be32_to_cpu(
4874 pSMB
->hdr
.smb_buf_length
) + count
);
4875 pSMB
->ByteCount
= cpu_to_le16(count
);
4877 rc
= SendReceive(xid
, ses
, smb_buffer
, smb_buffer_response
, &length
,
4880 /* above now done in SendReceive */
4884 tcon
->tidStatus
= CifsGood
;
4885 tcon
->need_reconnect
= false;
4886 tcon
->tid
= smb_buffer_response
->Tid
;
4887 bcc_ptr
= pByteArea(smb_buffer_response
);
4888 bytes_left
= get_bcc(smb_buffer_response
);
4889 length
= strnlen(bcc_ptr
, bytes_left
- 2);
4890 if (smb_buffer
->Flags2
& SMBFLG2_UNICODE
)
4896 /* skip service field (NB: this field is always ASCII) */
4898 if ((bcc_ptr
[0] == 'I') && (bcc_ptr
[1] == 'P') &&
4899 (bcc_ptr
[2] == 'C')) {
4900 cifs_dbg(FYI
, "IPC connection\n");
4904 } else if (length
== 2) {
4905 if ((bcc_ptr
[0] == 'A') && (bcc_ptr
[1] == ':')) {
4906 /* the most common case */
4907 cifs_dbg(FYI
, "disk share connection\n");
4910 bcc_ptr
+= length
+ 1;
4911 bytes_left
-= (length
+ 1);
4912 strlcpy(tcon
->treeName
, tree
, sizeof(tcon
->treeName
));
4914 /* mostly informational -- no need to fail on error here */
4915 kfree(tcon
->nativeFileSystem
);
4916 tcon
->nativeFileSystem
= cifs_strndup_from_utf16(bcc_ptr
,
4917 bytes_left
, is_unicode
,
4920 cifs_dbg(FYI
, "nativeFileSystem=%s\n", tcon
->nativeFileSystem
);
4922 if ((smb_buffer_response
->WordCount
== 3) ||
4923 (smb_buffer_response
->WordCount
== 7))
4924 /* field is in same location */
4925 tcon
->Flags
= le16_to_cpu(pSMBr
->OptionalSupport
);
4928 cifs_dbg(FYI
, "Tcon flags: 0x%x\n", tcon
->Flags
);
4931 cifs_buf_release(smb_buffer
);
4935 static void delayed_free(struct rcu_head
*p
)
4937 struct cifs_sb_info
*sbi
= container_of(p
, struct cifs_sb_info
, rcu
);
4938 unload_nls(sbi
->local_nls
);
4943 cifs_umount(struct cifs_sb_info
*cifs_sb
)
4945 struct rb_root
*root
= &cifs_sb
->tlink_tree
;
4946 struct rb_node
*node
;
4947 struct tcon_link
*tlink
;
4949 cancel_delayed_work_sync(&cifs_sb
->prune_tlinks
);
4951 spin_lock(&cifs_sb
->tlink_tree_lock
);
4952 while ((node
= rb_first(root
))) {
4953 tlink
= rb_entry(node
, struct tcon_link
, tl_rbnode
);
4954 cifs_get_tlink(tlink
);
4955 clear_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
4956 rb_erase(node
, root
);
4958 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4959 cifs_put_tlink(tlink
);
4960 spin_lock(&cifs_sb
->tlink_tree_lock
);
4962 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4964 kfree(cifs_sb
->mountdata
);
4965 kfree(cifs_sb
->prepath
);
4966 #ifdef CONFIG_CIFS_DFS_UPCALL
4967 dfs_cache_del_vol(cifs_sb
->origin_fullpath
);
4968 kfree(cifs_sb
->origin_fullpath
);
4970 call_rcu(&cifs_sb
->rcu
, delayed_free
);
4974 cifs_negotiate_protocol(const unsigned int xid
, struct cifs_ses
*ses
)
4977 struct TCP_Server_Info
*server
= ses
->server
;
4979 if (!server
->ops
->need_neg
|| !server
->ops
->negotiate
)
4982 /* only send once per connect */
4983 if (!server
->ops
->need_neg(server
))
4986 rc
= server
->ops
->negotiate(xid
, ses
);
4988 spin_lock(&GlobalMid_Lock
);
4989 if (server
->tcpStatus
== CifsNeedNegotiate
)
4990 server
->tcpStatus
= CifsGood
;
4993 spin_unlock(&GlobalMid_Lock
);
5000 cifs_setup_session(const unsigned int xid
, struct cifs_ses
*ses
,
5001 struct nls_table
*nls_info
)
5004 struct TCP_Server_Info
*server
= ses
->server
;
5006 ses
->capabilities
= server
->capabilities
;
5007 if (linuxExtEnabled
== 0)
5008 ses
->capabilities
&= (~server
->vals
->cap_unix
);
5010 cifs_dbg(FYI
, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
5011 server
->sec_mode
, server
->capabilities
, server
->timeAdj
);
5013 if (ses
->auth_key
.response
) {
5014 cifs_dbg(FYI
, "Free previous auth_key.response = %p\n",
5015 ses
->auth_key
.response
);
5016 kfree(ses
->auth_key
.response
);
5017 ses
->auth_key
.response
= NULL
;
5018 ses
->auth_key
.len
= 0;
5021 if (server
->ops
->sess_setup
)
5022 rc
= server
->ops
->sess_setup(xid
, ses
, nls_info
);
5025 cifs_dbg(VFS
, "Send error in SessSetup = %d\n", rc
);
5031 cifs_set_vol_auth(struct smb_vol
*vol
, struct cifs_ses
*ses
)
5033 vol
->sectype
= ses
->sectype
;
5035 /* krb5 is special, since we don't need username or pw */
5036 if (vol
->sectype
== Kerberos
)
5039 return cifs_set_cifscreds(vol
, ses
);
5042 static struct cifs_tcon
*
5043 cifs_construct_tcon(struct cifs_sb_info
*cifs_sb
, kuid_t fsuid
)
5046 struct cifs_tcon
*master_tcon
= cifs_sb_master_tcon(cifs_sb
);
5047 struct cifs_ses
*ses
;
5048 struct cifs_tcon
*tcon
= NULL
;
5049 struct smb_vol
*vol_info
;
5051 vol_info
= kzalloc(sizeof(*vol_info
), GFP_KERNEL
);
5052 if (vol_info
== NULL
)
5053 return ERR_PTR(-ENOMEM
);
5055 vol_info
->local_nls
= cifs_sb
->local_nls
;
5056 vol_info
->linux_uid
= fsuid
;
5057 vol_info
->cred_uid
= fsuid
;
5058 vol_info
->UNC
= master_tcon
->treeName
;
5059 vol_info
->retry
= master_tcon
->retry
;
5060 vol_info
->nocase
= master_tcon
->nocase
;
5061 vol_info
->nohandlecache
= master_tcon
->nohandlecache
;
5062 vol_info
->local_lease
= master_tcon
->local_lease
;
5063 vol_info
->no_linux_ext
= !master_tcon
->unix_ext
;
5064 vol_info
->sectype
= master_tcon
->ses
->sectype
;
5065 vol_info
->sign
= master_tcon
->ses
->sign
;
5067 rc
= cifs_set_vol_auth(vol_info
, master_tcon
->ses
);
5073 /* get a reference for the same TCP session */
5074 spin_lock(&cifs_tcp_ses_lock
);
5075 ++master_tcon
->ses
->server
->srv_count
;
5076 spin_unlock(&cifs_tcp_ses_lock
);
5078 ses
= cifs_get_smb_ses(master_tcon
->ses
->server
, vol_info
);
5080 tcon
= (struct cifs_tcon
*)ses
;
5081 cifs_put_tcp_session(master_tcon
->ses
->server
, 0);
5085 tcon
= cifs_get_tcon(ses
, vol_info
);
5087 cifs_put_smb_ses(ses
);
5091 /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
5092 if (tcon
->posix_extensions
)
5093 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_POSIX_PATHS
;
5096 reset_cifs_unix_caps(0, tcon
, NULL
, vol_info
);
5099 kfree(vol_info
->username
);
5100 kzfree(vol_info
->password
);
5107 cifs_sb_master_tcon(struct cifs_sb_info
*cifs_sb
)
5109 return tlink_tcon(cifs_sb_master_tlink(cifs_sb
));
5112 /* find and return a tlink with given uid */
5113 static struct tcon_link
*
5114 tlink_rb_search(struct rb_root
*root
, kuid_t uid
)
5116 struct rb_node
*node
= root
->rb_node
;
5117 struct tcon_link
*tlink
;
5120 tlink
= rb_entry(node
, struct tcon_link
, tl_rbnode
);
5122 if (uid_gt(tlink
->tl_uid
, uid
))
5123 node
= node
->rb_left
;
5124 else if (uid_lt(tlink
->tl_uid
, uid
))
5125 node
= node
->rb_right
;
5132 /* insert a tcon_link into the tree */
5134 tlink_rb_insert(struct rb_root
*root
, struct tcon_link
*new_tlink
)
5136 struct rb_node
**new = &(root
->rb_node
), *parent
= NULL
;
5137 struct tcon_link
*tlink
;
5140 tlink
= rb_entry(*new, struct tcon_link
, tl_rbnode
);
5143 if (uid_gt(tlink
->tl_uid
, new_tlink
->tl_uid
))
5144 new = &((*new)->rb_left
);
5146 new = &((*new)->rb_right
);
5149 rb_link_node(&new_tlink
->tl_rbnode
, parent
, new);
5150 rb_insert_color(&new_tlink
->tl_rbnode
, root
);
5154 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
5157 * If the superblock doesn't refer to a multiuser mount, then just return
5158 * the master tcon for the mount.
5160 * First, search the rbtree for an existing tcon for this fsuid. If one
5161 * exists, then check to see if it's pending construction. If it is then wait
5162 * for construction to complete. Once it's no longer pending, check to see if
5163 * it failed and either return an error or retry construction, depending on
5166 * If one doesn't exist then insert a new tcon_link struct into the tree and
5167 * try to construct a new one.
5170 cifs_sb_tlink(struct cifs_sb_info
*cifs_sb
)
5173 kuid_t fsuid
= current_fsuid();
5174 struct tcon_link
*tlink
, *newtlink
;
5176 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
5177 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb
));
5179 spin_lock(&cifs_sb
->tlink_tree_lock
);
5180 tlink
= tlink_rb_search(&cifs_sb
->tlink_tree
, fsuid
);
5182 cifs_get_tlink(tlink
);
5183 spin_unlock(&cifs_sb
->tlink_tree_lock
);
5185 if (tlink
== NULL
) {
5186 newtlink
= kzalloc(sizeof(*tlink
), GFP_KERNEL
);
5187 if (newtlink
== NULL
)
5188 return ERR_PTR(-ENOMEM
);
5189 newtlink
->tl_uid
= fsuid
;
5190 newtlink
->tl_tcon
= ERR_PTR(-EACCES
);
5191 set_bit(TCON_LINK_PENDING
, &newtlink
->tl_flags
);
5192 set_bit(TCON_LINK_IN_TREE
, &newtlink
->tl_flags
);
5193 cifs_get_tlink(newtlink
);
5195 spin_lock(&cifs_sb
->tlink_tree_lock
);
5196 /* was one inserted after previous search? */
5197 tlink
= tlink_rb_search(&cifs_sb
->tlink_tree
, fsuid
);
5199 cifs_get_tlink(tlink
);
5200 spin_unlock(&cifs_sb
->tlink_tree_lock
);
5202 goto wait_for_construction
;
5205 tlink_rb_insert(&cifs_sb
->tlink_tree
, tlink
);
5206 spin_unlock(&cifs_sb
->tlink_tree_lock
);
5208 wait_for_construction
:
5209 ret
= wait_on_bit(&tlink
->tl_flags
, TCON_LINK_PENDING
,
5210 TASK_INTERRUPTIBLE
);
5212 cifs_put_tlink(tlink
);
5213 return ERR_PTR(-ERESTARTSYS
);
5216 /* if it's good, return it */
5217 if (!IS_ERR(tlink
->tl_tcon
))
5220 /* return error if we tried this already recently */
5221 if (time_before(jiffies
, tlink
->tl_time
+ TLINK_ERROR_EXPIRE
)) {
5222 cifs_put_tlink(tlink
);
5223 return ERR_PTR(-EACCES
);
5226 if (test_and_set_bit(TCON_LINK_PENDING
, &tlink
->tl_flags
))
5227 goto wait_for_construction
;
5230 tlink
->tl_tcon
= cifs_construct_tcon(cifs_sb
, fsuid
);
5231 clear_bit(TCON_LINK_PENDING
, &tlink
->tl_flags
);
5232 wake_up_bit(&tlink
->tl_flags
, TCON_LINK_PENDING
);
5234 if (IS_ERR(tlink
->tl_tcon
)) {
5235 cifs_put_tlink(tlink
);
5236 return ERR_PTR(-EACCES
);
5243 * periodic workqueue job that scans tcon_tree for a superblock and closes
5247 cifs_prune_tlinks(struct work_struct
*work
)
5249 struct cifs_sb_info
*cifs_sb
= container_of(work
, struct cifs_sb_info
,
5251 struct rb_root
*root
= &cifs_sb
->tlink_tree
;
5252 struct rb_node
*node
;
5253 struct rb_node
*tmp
;
5254 struct tcon_link
*tlink
;
5257 * Because we drop the spinlock in the loop in order to put the tlink
5258 * it's not guarded against removal of links from the tree. The only
5259 * places that remove entries from the tree are this function and
5260 * umounts. Because this function is non-reentrant and is canceled
5261 * before umount can proceed, this is safe.
5263 spin_lock(&cifs_sb
->tlink_tree_lock
);
5264 node
= rb_first(root
);
5265 while (node
!= NULL
) {
5267 node
= rb_next(tmp
);
5268 tlink
= rb_entry(tmp
, struct tcon_link
, tl_rbnode
);
5270 if (test_bit(TCON_LINK_MASTER
, &tlink
->tl_flags
) ||
5271 atomic_read(&tlink
->tl_count
) != 0 ||
5272 time_after(tlink
->tl_time
+ TLINK_IDLE_EXPIRE
, jiffies
))
5275 cifs_get_tlink(tlink
);
5276 clear_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
5277 rb_erase(tmp
, root
);
5279 spin_unlock(&cifs_sb
->tlink_tree_lock
);
5280 cifs_put_tlink(tlink
);
5281 spin_lock(&cifs_sb
->tlink_tree_lock
);
5283 spin_unlock(&cifs_sb
->tlink_tree_lock
);
5285 queue_delayed_work(cifsiod_wq
, &cifs_sb
->prune_tlinks
,