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/mm.h>
25 #include <linux/sched/signal.h>
26 #include <linux/list.h>
27 #include <linux/wait.h>
28 #include <linux/slab.h>
29 #include <linux/pagemap.h>
30 #include <linux/ctype.h>
31 #include <linux/utsname.h>
32 #include <linux/mempool.h>
33 #include <linux/delay.h>
34 #include <linux/completion.h>
35 #include <linux/kthread.h>
36 #include <linux/pagevec.h>
37 #include <linux/freezer.h>
38 #include <linux/namei.h>
39 #include <linux/uuid.h>
40 #include <linux/uaccess.h>
41 #include <asm/processor.h>
42 #include <linux/inet.h>
43 #include <linux/module.h>
44 #include <keys/user-type.h>
46 #include <linux/parser.h>
47 #include <linux/bvec.h>
50 #include "cifsproto.h"
51 #include "cifs_unicode.h"
52 #include "cifs_debug.h"
53 #include "cifs_fs_sb.h"
56 #include "rfc1002pdu.h"
58 #include "smb2proto.h"
59 #include "smbdirect.h"
60 #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)
72 /* Drop the connection to not overload the server */
73 #define NUM_STATUS_IO_TIMEOUT 5
76 /* Mount options that take no arguments */
77 Opt_user_xattr
, Opt_nouser_xattr
,
78 Opt_forceuid
, Opt_noforceuid
,
79 Opt_forcegid
, Opt_noforcegid
,
80 Opt_noblocksend
, Opt_noautotune
, Opt_nolease
,
81 Opt_hard
, Opt_soft
, Opt_perm
, Opt_noperm
, Opt_nodelete
,
82 Opt_mapposix
, Opt_nomapposix
,
83 Opt_mapchars
, Opt_nomapchars
, Opt_sfu
,
84 Opt_nosfu
, Opt_nodfs
, Opt_posixpaths
,
85 Opt_noposixpaths
, Opt_nounix
, Opt_unix
,
88 Opt_handlecache
, Opt_nohandlecache
,
89 Opt_forcemandatorylock
, Opt_setuidfromacl
, Opt_setuids
,
90 Opt_nosetuids
, Opt_dynperm
, Opt_nodynperm
,
91 Opt_nohard
, Opt_nosoft
,
93 Opt_nostrictsync
, Opt_strictsync
,
94 Opt_serverino
, Opt_noserverino
,
95 Opt_rwpidforward
, Opt_cifsacl
, Opt_nocifsacl
,
96 Opt_acl
, Opt_noacl
, Opt_locallease
,
97 Opt_sign
, Opt_ignore_signature
, Opt_seal
, Opt_noac
,
98 Opt_fsc
, Opt_mfsymlinks
,
99 Opt_multiuser
, Opt_sloppy
, Opt_nosharesock
,
100 Opt_persistent
, Opt_nopersistent
,
101 Opt_resilient
, Opt_noresilient
,
102 Opt_domainauto
, Opt_rdma
, Opt_modesid
, Opt_rootfs
,
103 Opt_multichannel
, Opt_nomultichannel
,
106 /* Mount options which take numeric value */
107 Opt_backupuid
, Opt_backupgid
, Opt_uid
,
108 Opt_cruid
, Opt_gid
, Opt_file_mode
,
109 Opt_dirmode
, Opt_port
,
111 Opt_blocksize
, Opt_rsize
, Opt_wsize
, Opt_actimeo
,
112 Opt_echo_interval
, Opt_max_credits
, Opt_handletimeout
,
113 Opt_snapshot
, Opt_max_channels
,
115 /* Mount options which take string value */
116 Opt_user
, Opt_pass
, Opt_ip
,
117 Opt_domain
, Opt_srcaddr
, Opt_iocharset
,
118 Opt_netbiosname
, Opt_servern
,
119 Opt_ver
, Opt_vers
, Opt_sec
, Opt_cache
,
121 /* Mount options to be ignored */
124 /* Options which could be blank */
132 static const match_table_t cifs_mount_option_tokens
= {
134 { Opt_user_xattr
, "user_xattr" },
135 { Opt_nouser_xattr
, "nouser_xattr" },
136 { Opt_forceuid
, "forceuid" },
137 { Opt_noforceuid
, "noforceuid" },
138 { Opt_forcegid
, "forcegid" },
139 { Opt_noforcegid
, "noforcegid" },
140 { Opt_noblocksend
, "noblocksend" },
141 { Opt_noautotune
, "noautotune" },
142 { Opt_nolease
, "nolease" },
143 { Opt_hard
, "hard" },
144 { Opt_soft
, "soft" },
145 { Opt_perm
, "perm" },
146 { Opt_noperm
, "noperm" },
147 { Opt_nodelete
, "nodelete" },
148 { Opt_mapchars
, "mapchars" }, /* SFU style */
149 { Opt_nomapchars
, "nomapchars" },
150 { Opt_mapposix
, "mapposix" }, /* SFM style */
151 { Opt_nomapposix
, "nomapposix" },
153 { Opt_nosfu
, "nosfu" },
154 { Opt_nodfs
, "nodfs" },
155 { Opt_posixpaths
, "posixpaths" },
156 { Opt_noposixpaths
, "noposixpaths" },
157 { Opt_nounix
, "nounix" },
158 { Opt_nounix
, "nolinux" },
159 { Opt_nounix
, "noposix" },
160 { Opt_unix
, "unix" },
161 { Opt_unix
, "linux" },
162 { Opt_unix
, "posix" },
163 { Opt_nocase
, "nocase" },
164 { Opt_nocase
, "ignorecase" },
166 { Opt_nobrl
, "nobrl" },
167 { Opt_handlecache
, "handlecache" },
168 { Opt_nohandlecache
, "nohandlecache" },
169 { Opt_nobrl
, "nolock" },
170 { Opt_forcemandatorylock
, "forcemandatorylock" },
171 { Opt_forcemandatorylock
, "forcemand" },
172 { Opt_setuids
, "setuids" },
173 { Opt_nosetuids
, "nosetuids" },
174 { Opt_setuidfromacl
, "idsfromsid" },
175 { Opt_dynperm
, "dynperm" },
176 { Opt_nodynperm
, "nodynperm" },
177 { Opt_nohard
, "nohard" },
178 { Opt_nosoft
, "nosoft" },
179 { Opt_nointr
, "nointr" },
180 { Opt_intr
, "intr" },
181 { Opt_nostrictsync
, "nostrictsync" },
182 { Opt_strictsync
, "strictsync" },
183 { Opt_serverino
, "serverino" },
184 { Opt_noserverino
, "noserverino" },
185 { Opt_rwpidforward
, "rwpidforward" },
186 { Opt_modesid
, "modefromsid" },
187 { Opt_cifsacl
, "cifsacl" },
188 { Opt_nocifsacl
, "nocifsacl" },
190 { Opt_noacl
, "noacl" },
191 { Opt_locallease
, "locallease" },
192 { Opt_sign
, "sign" },
193 { Opt_ignore_signature
, "signloosely" },
194 { Opt_seal
, "seal" },
195 { Opt_noac
, "noac" },
197 { Opt_mfsymlinks
, "mfsymlinks" },
198 { Opt_multiuser
, "multiuser" },
199 { Opt_sloppy
, "sloppy" },
200 { Opt_nosharesock
, "nosharesock" },
201 { Opt_persistent
, "persistenthandles"},
202 { Opt_nopersistent
, "nopersistenthandles"},
203 { Opt_resilient
, "resilienthandles"},
204 { Opt_noresilient
, "noresilienthandles"},
205 { Opt_domainauto
, "domainauto"},
207 { Opt_multichannel
, "multichannel" },
208 { Opt_nomultichannel
, "nomultichannel" },
210 { Opt_backupuid
, "backupuid=%s" },
211 { Opt_backupgid
, "backupgid=%s" },
212 { Opt_uid
, "uid=%s" },
213 { Opt_cruid
, "cruid=%s" },
214 { Opt_gid
, "gid=%s" },
215 { Opt_file_mode
, "file_mode=%s" },
216 { Opt_dirmode
, "dirmode=%s" },
217 { Opt_dirmode
, "dir_mode=%s" },
218 { Opt_port
, "port=%s" },
219 { Opt_min_enc_offload
, "esize=%s" },
220 { Opt_blocksize
, "bsize=%s" },
221 { Opt_rsize
, "rsize=%s" },
222 { Opt_wsize
, "wsize=%s" },
223 { Opt_actimeo
, "actimeo=%s" },
224 { Opt_handletimeout
, "handletimeout=%s" },
225 { Opt_echo_interval
, "echo_interval=%s" },
226 { Opt_max_credits
, "max_credits=%s" },
227 { Opt_snapshot
, "snapshot=%s" },
228 { Opt_max_channels
, "max_channels=%s" },
229 { Opt_compress
, "compress=%s" },
231 { Opt_blank_user
, "user=" },
232 { Opt_blank_user
, "username=" },
233 { Opt_user
, "user=%s" },
234 { Opt_user
, "username=%s" },
235 { Opt_blank_pass
, "pass=" },
236 { Opt_blank_pass
, "password=" },
237 { Opt_pass
, "pass=%s" },
238 { Opt_pass
, "password=%s" },
239 { Opt_blank_ip
, "ip=" },
240 { Opt_blank_ip
, "addr=" },
242 { Opt_ip
, "addr=%s" },
243 { Opt_ignore
, "unc=%s" },
244 { Opt_ignore
, "target=%s" },
245 { Opt_ignore
, "path=%s" },
246 { Opt_domain
, "dom=%s" },
247 { Opt_domain
, "domain=%s" },
248 { Opt_domain
, "workgroup=%s" },
249 { Opt_srcaddr
, "srcaddr=%s" },
250 { Opt_ignore
, "prefixpath=%s" },
251 { Opt_iocharset
, "iocharset=%s" },
252 { Opt_netbiosname
, "netbiosname=%s" },
253 { Opt_servern
, "servern=%s" },
254 { Opt_ver
, "ver=%s" },
255 { Opt_vers
, "vers=%s" },
256 { Opt_sec
, "sec=%s" },
257 { Opt_cache
, "cache=%s" },
259 { Opt_ignore
, "cred" },
260 { Opt_ignore
, "credentials" },
261 { Opt_ignore
, "cred=%s" },
262 { Opt_ignore
, "credentials=%s" },
263 { Opt_ignore
, "guest" },
264 { Opt_ignore
, "rw" },
265 { Opt_ignore
, "ro" },
266 { Opt_ignore
, "suid" },
267 { Opt_ignore
, "nosuid" },
268 { Opt_ignore
, "exec" },
269 { Opt_ignore
, "noexec" },
270 { Opt_ignore
, "nodev" },
271 { Opt_ignore
, "noauto" },
272 { Opt_ignore
, "dev" },
273 { Opt_ignore
, "mand" },
274 { Opt_ignore
, "nomand" },
275 { Opt_ignore
, "relatime" },
276 { Opt_ignore
, "_netdev" },
277 { Opt_rootfs
, "rootfs" },
283 Opt_sec_krb5
, Opt_sec_krb5i
, Opt_sec_krb5p
,
284 Opt_sec_ntlmsspi
, Opt_sec_ntlmssp
,
285 Opt_ntlm
, Opt_sec_ntlmi
, Opt_sec_ntlmv2
,
286 Opt_sec_ntlmv2i
, Opt_sec_lanman
,
292 static const match_table_t cifs_secflavor_tokens
= {
293 { Opt_sec_krb5
, "krb5" },
294 { Opt_sec_krb5i
, "krb5i" },
295 { Opt_sec_krb5p
, "krb5p" },
296 { Opt_sec_ntlmsspi
, "ntlmsspi" },
297 { Opt_sec_ntlmssp
, "ntlmssp" },
298 { Opt_ntlm
, "ntlm" },
299 { Opt_sec_ntlmi
, "ntlmi" },
300 { Opt_sec_ntlmv2
, "nontlm" },
301 { Opt_sec_ntlmv2
, "ntlmv2" },
302 { Opt_sec_ntlmv2i
, "ntlmv2i" },
303 { Opt_sec_lanman
, "lanman" },
304 { Opt_sec_none
, "none" },
306 { Opt_sec_err
, NULL
}
319 static const match_table_t cifs_cacheflavor_tokens
= {
320 { Opt_cache_loose
, "loose" },
321 { Opt_cache_strict
, "strict" },
322 { Opt_cache_none
, "none" },
323 { Opt_cache_ro
, "ro" },
324 { Opt_cache_rw
, "singleclient" },
325 { Opt_cache_err
, NULL
}
328 static const match_table_t cifs_smb_version_tokens
= {
329 { Smb_1
, SMB1_VERSION_STRING
},
330 { Smb_20
, SMB20_VERSION_STRING
},
331 { Smb_21
, SMB21_VERSION_STRING
},
332 { Smb_30
, SMB30_VERSION_STRING
},
333 { Smb_302
, SMB302_VERSION_STRING
},
334 { Smb_302
, ALT_SMB302_VERSION_STRING
},
335 { Smb_311
, SMB311_VERSION_STRING
},
336 { Smb_311
, ALT_SMB311_VERSION_STRING
},
337 { Smb_3any
, SMB3ANY_VERSION_STRING
},
338 { Smb_default
, SMBDEFAULT_VERSION_STRING
},
339 { Smb_version_err
, NULL
}
342 static int ip_connect(struct TCP_Server_Info
*server
);
343 static int generic_ip_connect(struct TCP_Server_Info
*server
);
344 static void tlink_rb_insert(struct rb_root
*root
, struct tcon_link
*new_tlink
);
345 static void cifs_prune_tlinks(struct work_struct
*work
);
346 static char *extract_hostname(const char *unc
);
349 * Resolve hostname and set ip addr in tcp ses. Useful for hostnames that may
350 * get their ip addresses changed at some point.
352 * This should be called with server->srv_mutex held.
354 #ifdef CONFIG_CIFS_DFS_UPCALL
355 static int reconn_set_ipaddr(struct TCP_Server_Info
*server
)
359 char *unc
, *ipaddr
= NULL
;
361 if (!server
->hostname
)
364 len
= strlen(server
->hostname
) + 3;
366 unc
= kmalloc(len
, GFP_KERNEL
);
368 cifs_dbg(FYI
, "%s: failed to create UNC path\n", __func__
);
371 scnprintf(unc
, len
, "\\\\%s", server
->hostname
);
373 rc
= dns_resolve_server_name_to_ip(unc
, &ipaddr
);
377 cifs_dbg(FYI
, "%s: failed to resolve server part of %s to IP: %d\n",
378 __func__
, server
->hostname
, rc
);
382 spin_lock(&cifs_tcp_ses_lock
);
383 rc
= cifs_convert_address((struct sockaddr
*)&server
->dstaddr
, ipaddr
,
385 spin_unlock(&cifs_tcp_ses_lock
);
391 static inline int reconn_set_ipaddr(struct TCP_Server_Info
*server
)
397 #ifdef CONFIG_CIFS_DFS_UPCALL
398 /* These functions must be called with server->srv_mutex held */
399 static void reconn_set_next_dfs_target(struct TCP_Server_Info
*server
,
400 struct cifs_sb_info
*cifs_sb
,
401 struct dfs_cache_tgt_list
*tgt_list
,
402 struct dfs_cache_tgt_iterator
**tgt_it
)
406 if (!cifs_sb
|| !cifs_sb
->origin_fullpath
)
410 *tgt_it
= dfs_cache_get_tgt_iterator(tgt_list
);
412 *tgt_it
= dfs_cache_get_next_tgt(tgt_list
, *tgt_it
);
414 *tgt_it
= dfs_cache_get_tgt_iterator(tgt_list
);
417 cifs_dbg(FYI
, "%s: UNC: %s\n", __func__
, cifs_sb
->origin_fullpath
);
419 name
= dfs_cache_get_tgt_name(*tgt_it
);
421 kfree(server
->hostname
);
423 server
->hostname
= extract_hostname(name
);
424 if (IS_ERR(server
->hostname
)) {
426 "%s: failed to extract hostname from target: %ld\n",
427 __func__
, PTR_ERR(server
->hostname
));
431 static inline int reconn_setup_dfs_targets(struct cifs_sb_info
*cifs_sb
,
432 struct dfs_cache_tgt_list
*tl
)
434 if (!cifs_sb
->origin_fullpath
)
436 return dfs_cache_noreq_find(cifs_sb
->origin_fullpath
+ 1, NULL
, tl
);
441 * cifs tcp session reconnection
443 * mark tcp session as reconnecting so temporarily locked
444 * mark all smb sessions as reconnecting for tcp session
445 * reconnect tcp session
446 * wake up waiters on reconnection? - (not needed currently)
449 cifs_reconnect(struct TCP_Server_Info
*server
)
452 struct list_head
*tmp
, *tmp2
;
453 struct cifs_ses
*ses
;
454 struct cifs_tcon
*tcon
;
455 struct mid_q_entry
*mid_entry
;
456 struct list_head retry_list
;
457 #ifdef CONFIG_CIFS_DFS_UPCALL
458 struct super_block
*sb
= NULL
;
459 struct cifs_sb_info
*cifs_sb
= NULL
;
460 struct dfs_cache_tgt_list tgt_list
= {0};
461 struct dfs_cache_tgt_iterator
*tgt_it
= NULL
;
464 spin_lock(&GlobalMid_Lock
);
465 server
->nr_targets
= 1;
466 #ifdef CONFIG_CIFS_DFS_UPCALL
467 spin_unlock(&GlobalMid_Lock
);
468 sb
= cifs_get_tcp_super(server
);
471 cifs_dbg(FYI
, "%s: will not do DFS failover: rc = %d\n",
475 cifs_sb
= CIFS_SB(sb
);
476 rc
= reconn_setup_dfs_targets(cifs_sb
, &tgt_list
);
479 if (rc
!= -EOPNOTSUPP
) {
480 cifs_server_dbg(VFS
, "%s: no target servers for DFS failover\n",
484 server
->nr_targets
= dfs_cache_get_nr_tgts(&tgt_list
);
487 cifs_dbg(FYI
, "%s: will retry %d target(s)\n", __func__
,
489 spin_lock(&GlobalMid_Lock
);
491 if (server
->tcpStatus
== CifsExiting
) {
492 /* the demux thread will exit normally
493 next time through the loop */
494 spin_unlock(&GlobalMid_Lock
);
495 #ifdef CONFIG_CIFS_DFS_UPCALL
496 dfs_cache_free_tgts(&tgt_list
);
497 cifs_put_tcp_super(sb
);
499 wake_up(&server
->response_q
);
502 server
->tcpStatus
= CifsNeedReconnect
;
503 spin_unlock(&GlobalMid_Lock
);
505 server
->max_read
= 0;
507 cifs_dbg(FYI
, "Mark tcp session as need reconnect\n");
508 trace_smb3_reconnect(server
->CurrentMid
, server
->hostname
);
510 /* before reconnecting the tcp session, mark the smb session (uid)
511 and the tid bad so they are not used until reconnected */
512 cifs_dbg(FYI
, "%s: marking sessions and tcons for reconnect\n",
514 spin_lock(&cifs_tcp_ses_lock
);
515 list_for_each(tmp
, &server
->smb_ses_list
) {
516 ses
= list_entry(tmp
, struct cifs_ses
, smb_ses_list
);
517 ses
->need_reconnect
= true;
518 list_for_each(tmp2
, &ses
->tcon_list
) {
519 tcon
= list_entry(tmp2
, struct cifs_tcon
, tcon_list
);
520 tcon
->need_reconnect
= true;
523 ses
->tcon_ipc
->need_reconnect
= true;
525 spin_unlock(&cifs_tcp_ses_lock
);
527 /* do not want to be sending data on a socket we are freeing */
528 cifs_dbg(FYI
, "%s: tearing down socket\n", __func__
);
529 mutex_lock(&server
->srv_mutex
);
530 if (server
->ssocket
) {
531 cifs_dbg(FYI
, "State: 0x%x Flags: 0x%lx\n",
532 server
->ssocket
->state
, server
->ssocket
->flags
);
533 kernel_sock_shutdown(server
->ssocket
, SHUT_WR
);
534 cifs_dbg(FYI
, "Post shutdown state: 0x%x Flags: 0x%lx\n",
535 server
->ssocket
->state
, server
->ssocket
->flags
);
536 sock_release(server
->ssocket
);
537 server
->ssocket
= NULL
;
539 server
->sequence_number
= 0;
540 server
->session_estab
= false;
541 kfree(server
->session_key
.response
);
542 server
->session_key
.response
= NULL
;
543 server
->session_key
.len
= 0;
544 server
->lstrp
= jiffies
;
546 /* mark submitted MIDs for retry and issue callback */
547 INIT_LIST_HEAD(&retry_list
);
548 cifs_dbg(FYI
, "%s: moving mids to private list\n", __func__
);
549 spin_lock(&GlobalMid_Lock
);
550 list_for_each_safe(tmp
, tmp2
, &server
->pending_mid_q
) {
551 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
552 kref_get(&mid_entry
->refcount
);
553 if (mid_entry
->mid_state
== MID_REQUEST_SUBMITTED
)
554 mid_entry
->mid_state
= MID_RETRY_NEEDED
;
555 list_move(&mid_entry
->qhead
, &retry_list
);
556 mid_entry
->mid_flags
|= MID_DELETED
;
558 spin_unlock(&GlobalMid_Lock
);
559 mutex_unlock(&server
->srv_mutex
);
561 cifs_dbg(FYI
, "%s: issuing mid callbacks\n", __func__
);
562 list_for_each_safe(tmp
, tmp2
, &retry_list
) {
563 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
564 list_del_init(&mid_entry
->qhead
);
565 mid_entry
->callback(mid_entry
);
566 cifs_mid_q_entry_release(mid_entry
);
569 if (cifs_rdma_enabled(server
)) {
570 mutex_lock(&server
->srv_mutex
);
571 smbd_destroy(server
);
572 mutex_unlock(&server
->srv_mutex
);
578 mutex_lock(&server
->srv_mutex
);
579 #ifdef CONFIG_CIFS_DFS_UPCALL
581 * Set up next DFS target server (if any) for reconnect. If DFS
582 * feature is disabled, then we will retry last server we
583 * connected to before.
585 reconn_set_next_dfs_target(server
, cifs_sb
, &tgt_list
, &tgt_it
);
587 rc
= reconn_set_ipaddr(server
);
589 cifs_dbg(FYI
, "%s: failed to resolve hostname: %d\n",
593 if (cifs_rdma_enabled(server
))
594 rc
= smbd_reconnect(server
);
596 rc
= generic_ip_connect(server
);
598 cifs_dbg(FYI
, "reconnect error %d\n", rc
);
599 mutex_unlock(&server
->srv_mutex
);
602 atomic_inc(&tcpSesReconnectCount
);
603 set_credits(server
, 1);
604 spin_lock(&GlobalMid_Lock
);
605 if (server
->tcpStatus
!= CifsExiting
)
606 server
->tcpStatus
= CifsNeedNegotiate
;
607 spin_unlock(&GlobalMid_Lock
);
608 mutex_unlock(&server
->srv_mutex
);
610 } while (server
->tcpStatus
== CifsNeedReconnect
);
612 #ifdef CONFIG_CIFS_DFS_UPCALL
614 rc
= dfs_cache_noreq_update_tgthint(cifs_sb
->origin_fullpath
+ 1,
617 cifs_server_dbg(VFS
, "%s: failed to update DFS target hint: rc = %d\n",
620 rc
= dfs_cache_update_vol(cifs_sb
->origin_fullpath
, server
);
622 cifs_server_dbg(VFS
, "%s: failed to update vol info in DFS cache: rc = %d\n",
625 dfs_cache_free_tgts(&tgt_list
);
629 cifs_put_tcp_super(sb
);
631 if (server
->tcpStatus
== CifsNeedNegotiate
)
632 mod_delayed_work(cifsiod_wq
, &server
->echo
, 0);
634 wake_up(&server
->response_q
);
639 cifs_echo_request(struct work_struct
*work
)
642 struct TCP_Server_Info
*server
= container_of(work
,
643 struct TCP_Server_Info
, echo
.work
);
644 unsigned long echo_interval
;
647 * If we need to renegotiate, set echo interval to zero to
648 * immediately call echo service where we can renegotiate.
650 if (server
->tcpStatus
== CifsNeedNegotiate
)
653 echo_interval
= server
->echo_interval
;
656 * We cannot send an echo if it is disabled.
657 * Also, no need to ping if we got a response recently.
660 if (server
->tcpStatus
== CifsNeedReconnect
||
661 server
->tcpStatus
== CifsExiting
||
662 server
->tcpStatus
== CifsNew
||
663 (server
->ops
->can_echo
&& !server
->ops
->can_echo(server
)) ||
664 time_before(jiffies
, server
->lstrp
+ echo_interval
- HZ
))
667 rc
= server
->ops
->echo
? server
->ops
->echo(server
) : -ENOSYS
;
669 cifs_dbg(FYI
, "Unable to send echo request to server: %s\n",
673 queue_delayed_work(cifsiod_wq
, &server
->echo
, server
->echo_interval
);
677 allocate_buffers(struct TCP_Server_Info
*server
)
679 if (!server
->bigbuf
) {
680 server
->bigbuf
= (char *)cifs_buf_get();
681 if (!server
->bigbuf
) {
682 cifs_server_dbg(VFS
, "No memory for large SMB response\n");
684 /* retry will check if exiting */
687 } else if (server
->large_buf
) {
688 /* we are reusing a dirty large buf, clear its start */
689 memset(server
->bigbuf
, 0, HEADER_SIZE(server
));
692 if (!server
->smallbuf
) {
693 server
->smallbuf
= (char *)cifs_small_buf_get();
694 if (!server
->smallbuf
) {
695 cifs_server_dbg(VFS
, "No memory for SMB response\n");
697 /* retry will check if exiting */
700 /* beginning of smb buffer is cleared in our buf_get */
702 /* if existing small buf clear beginning */
703 memset(server
->smallbuf
, 0, HEADER_SIZE(server
));
710 server_unresponsive(struct TCP_Server_Info
*server
)
713 * We need to wait 3 echo intervals to make sure we handle such
715 * 1s client sends a normal SMB request
716 * 2s client gets a response
717 * 30s echo workqueue job pops, and decides we got a response recently
718 * and don't need to send another
720 * 65s kernel_recvmsg times out, and we see that we haven't gotten
721 * a response in >60s.
723 if ((server
->tcpStatus
== CifsGood
||
724 server
->tcpStatus
== CifsNeedNegotiate
) &&
725 time_after(jiffies
, server
->lstrp
+ 3 * server
->echo_interval
)) {
726 cifs_server_dbg(VFS
, "has not responded in %lu seconds. Reconnecting...\n",
727 (3 * server
->echo_interval
) / HZ
);
728 cifs_reconnect(server
);
736 zero_credits(struct TCP_Server_Info
*server
)
740 spin_lock(&server
->req_lock
);
741 val
= server
->credits
+ server
->echo_credits
+ server
->oplock_credits
;
742 if (server
->in_flight
== 0 && val
== 0) {
743 spin_unlock(&server
->req_lock
);
746 spin_unlock(&server
->req_lock
);
751 cifs_readv_from_socket(struct TCP_Server_Info
*server
, struct msghdr
*smb_msg
)
756 smb_msg
->msg_control
= NULL
;
757 smb_msg
->msg_controllen
= 0;
759 for (total_read
= 0; msg_data_left(smb_msg
); total_read
+= length
) {
762 /* reconnect if no credits and no requests in flight */
763 if (zero_credits(server
)) {
764 cifs_reconnect(server
);
765 return -ECONNABORTED
;
768 if (server_unresponsive(server
))
769 return -ECONNABORTED
;
770 if (cifs_rdma_enabled(server
) && server
->smbd_conn
)
771 length
= smbd_recv(server
->smbd_conn
, smb_msg
);
773 length
= sock_recvmsg(server
->ssocket
, smb_msg
, 0);
775 if (server
->tcpStatus
== CifsExiting
)
778 if (server
->tcpStatus
== CifsNeedReconnect
) {
779 cifs_reconnect(server
);
780 return -ECONNABORTED
;
783 if (length
== -ERESTARTSYS
||
787 * Minimum sleep to prevent looping, allowing socket
788 * to clear and app threads to set tcpStatus
789 * CifsNeedReconnect if server hung.
791 usleep_range(1000, 2000);
797 cifs_dbg(FYI
, "Received no data or error: %d\n", length
);
798 cifs_reconnect(server
);
799 return -ECONNABORTED
;
806 cifs_read_from_socket(struct TCP_Server_Info
*server
, char *buf
,
807 unsigned int to_read
)
809 struct msghdr smb_msg
;
810 struct kvec iov
= {.iov_base
= buf
, .iov_len
= to_read
};
811 iov_iter_kvec(&smb_msg
.msg_iter
, READ
, &iov
, 1, to_read
);
813 return cifs_readv_from_socket(server
, &smb_msg
);
817 cifs_read_page_from_socket(struct TCP_Server_Info
*server
, struct page
*page
,
818 unsigned int page_offset
, unsigned int to_read
)
820 struct msghdr smb_msg
;
821 struct bio_vec bv
= {
822 .bv_page
= page
, .bv_len
= to_read
, .bv_offset
= page_offset
};
823 iov_iter_bvec(&smb_msg
.msg_iter
, READ
, &bv
, 1, to_read
);
824 return cifs_readv_from_socket(server
, &smb_msg
);
828 is_smb_response(struct TCP_Server_Info
*server
, unsigned char type
)
831 * The first byte big endian of the length field,
832 * is actually not part of the length but the type
833 * with the most common, zero, as regular data.
836 case RFC1002_SESSION_MESSAGE
:
837 /* Regular SMB response */
839 case RFC1002_SESSION_KEEP_ALIVE
:
840 cifs_dbg(FYI
, "RFC 1002 session keep alive\n");
842 case RFC1002_POSITIVE_SESSION_RESPONSE
:
843 cifs_dbg(FYI
, "RFC 1002 positive session response\n");
845 case RFC1002_NEGATIVE_SESSION_RESPONSE
:
847 * We get this from Windows 98 instead of an error on
848 * SMB negprot response.
850 cifs_dbg(FYI
, "RFC 1002 negative session response\n");
851 /* give server a second to clean up */
854 * Always try 445 first on reconnect since we get NACK
855 * on some if we ever connected to port 139 (the NACK
856 * is since we do not begin with RFC1001 session
859 cifs_set_port((struct sockaddr
*)&server
->dstaddr
, CIFS_PORT
);
860 cifs_reconnect(server
);
863 cifs_server_dbg(VFS
, "RFC 1002 unknown response type 0x%x\n", type
);
864 cifs_reconnect(server
);
871 dequeue_mid(struct mid_q_entry
*mid
, bool malformed
)
873 #ifdef CONFIG_CIFS_STATS2
874 mid
->when_received
= jiffies
;
876 spin_lock(&GlobalMid_Lock
);
878 mid
->mid_state
= MID_RESPONSE_RECEIVED
;
880 mid
->mid_state
= MID_RESPONSE_MALFORMED
;
882 * Trying to handle/dequeue a mid after the send_recv()
883 * function has finished processing it is a bug.
885 if (mid
->mid_flags
& MID_DELETED
)
886 pr_warn_once("trying to dequeue a deleted mid\n");
888 list_del_init(&mid
->qhead
);
889 mid
->mid_flags
|= MID_DELETED
;
891 spin_unlock(&GlobalMid_Lock
);
895 smb2_get_credits_from_hdr(char *buffer
, struct TCP_Server_Info
*server
)
897 struct smb2_sync_hdr
*shdr
= (struct smb2_sync_hdr
*)buffer
;
900 * SMB1 does not use credits.
902 if (server
->vals
->header_preamble_size
)
905 return le16_to_cpu(shdr
->CreditRequest
);
909 handle_mid(struct mid_q_entry
*mid
, struct TCP_Server_Info
*server
,
910 char *buf
, int malformed
)
912 if (server
->ops
->check_trans2
&&
913 server
->ops
->check_trans2(mid
, server
, buf
, malformed
))
915 mid
->credits_received
= smb2_get_credits_from_hdr(buf
, server
);
917 mid
->large_buf
= server
->large_buf
;
918 /* Was previous buf put in mpx struct for multi-rsp? */
919 if (!mid
->multiRsp
) {
920 /* smb buffer will be freed by user thread */
921 if (server
->large_buf
)
922 server
->bigbuf
= NULL
;
924 server
->smallbuf
= NULL
;
926 dequeue_mid(mid
, malformed
);
929 static void clean_demultiplex_info(struct TCP_Server_Info
*server
)
933 /* take it off the list, if it's not already */
934 spin_lock(&cifs_tcp_ses_lock
);
935 list_del_init(&server
->tcp_ses_list
);
936 spin_unlock(&cifs_tcp_ses_lock
);
938 spin_lock(&GlobalMid_Lock
);
939 server
->tcpStatus
= CifsExiting
;
940 spin_unlock(&GlobalMid_Lock
);
941 wake_up_all(&server
->response_q
);
943 /* check if we have blocked requests that need to free */
944 spin_lock(&server
->req_lock
);
945 if (server
->credits
<= 0)
947 spin_unlock(&server
->req_lock
);
949 * Although there should not be any requests blocked on this queue it
950 * can not hurt to be paranoid and try to wake up requests that may
951 * haven been blocked when more than 50 at time were on the wire to the
952 * same server - they now will see the session is in exit state and get
953 * out of SendReceive.
955 wake_up_all(&server
->request_q
);
956 /* give those requests time to exit */
958 if (cifs_rdma_enabled(server
))
959 smbd_destroy(server
);
960 if (server
->ssocket
) {
961 sock_release(server
->ssocket
);
962 server
->ssocket
= NULL
;
965 if (!list_empty(&server
->pending_mid_q
)) {
966 struct list_head dispose_list
;
967 struct mid_q_entry
*mid_entry
;
968 struct list_head
*tmp
, *tmp2
;
970 INIT_LIST_HEAD(&dispose_list
);
971 spin_lock(&GlobalMid_Lock
);
972 list_for_each_safe(tmp
, tmp2
, &server
->pending_mid_q
) {
973 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
974 cifs_dbg(FYI
, "Clearing mid 0x%llx\n", mid_entry
->mid
);
975 kref_get(&mid_entry
->refcount
);
976 mid_entry
->mid_state
= MID_SHUTDOWN
;
977 list_move(&mid_entry
->qhead
, &dispose_list
);
978 mid_entry
->mid_flags
|= MID_DELETED
;
980 spin_unlock(&GlobalMid_Lock
);
982 /* now walk dispose list and issue callbacks */
983 list_for_each_safe(tmp
, tmp2
, &dispose_list
) {
984 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
985 cifs_dbg(FYI
, "Callback mid 0x%llx\n", mid_entry
->mid
);
986 list_del_init(&mid_entry
->qhead
);
987 mid_entry
->callback(mid_entry
);
988 cifs_mid_q_entry_release(mid_entry
);
990 /* 1/8th of sec is more than enough time for them to exit */
994 if (!list_empty(&server
->pending_mid_q
)) {
996 * mpx threads have not exited yet give them at least the smb
997 * send timeout time for long ops.
999 * Due to delays on oplock break requests, we need to wait at
1000 * least 45 seconds before giving up on a request getting a
1001 * response and going ahead and killing cifsd.
1003 cifs_dbg(FYI
, "Wait for exit from demultiplex thread\n");
1006 * If threads still have not exited they are probably never
1007 * coming home not much else we can do but free the memory.
1011 kfree(server
->hostname
);
1014 length
= atomic_dec_return(&tcpSesAllocCount
);
1016 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
);
1020 standard_receive3(struct TCP_Server_Info
*server
, struct mid_q_entry
*mid
)
1023 char *buf
= server
->smallbuf
;
1024 unsigned int pdu_length
= server
->pdu_size
;
1026 /* make sure this will fit in a large buffer */
1027 if (pdu_length
> CIFSMaxBufSize
+ MAX_HEADER_SIZE(server
) -
1028 server
->vals
->header_preamble_size
) {
1029 cifs_server_dbg(VFS
, "SMB response too long (%u bytes)\n", pdu_length
);
1030 cifs_reconnect(server
);
1031 return -ECONNABORTED
;
1034 /* switch to large buffer if too big for a small one */
1035 if (pdu_length
> MAX_CIFS_SMALL_BUFFER_SIZE
- 4) {
1036 server
->large_buf
= true;
1037 memcpy(server
->bigbuf
, buf
, server
->total_read
);
1038 buf
= server
->bigbuf
;
1041 /* now read the rest */
1042 length
= cifs_read_from_socket(server
, buf
+ HEADER_SIZE(server
) - 1,
1043 pdu_length
- HEADER_SIZE(server
) + 1
1044 + server
->vals
->header_preamble_size
);
1048 server
->total_read
+= length
;
1050 dump_smb(buf
, server
->total_read
);
1052 return cifs_handle_standard(server
, mid
);
1056 cifs_handle_standard(struct TCP_Server_Info
*server
, struct mid_q_entry
*mid
)
1058 char *buf
= server
->large_buf
? server
->bigbuf
: server
->smallbuf
;
1062 * We know that we received enough to get to the MID as we
1063 * checked the pdu_length earlier. Now check to see
1064 * if the rest of the header is OK. We borrow the length
1065 * var for the rest of the loop to avoid a new stack var.
1067 * 48 bytes is enough to display the header and a little bit
1068 * into the payload for debugging purposes.
1070 length
= server
->ops
->check_message(buf
, server
->total_read
, server
);
1072 cifs_dump_mem("Bad SMB: ", buf
,
1073 min_t(unsigned int, server
->total_read
, 48));
1075 if (server
->ops
->is_session_expired
&&
1076 server
->ops
->is_session_expired(buf
)) {
1077 cifs_reconnect(server
);
1081 if (server
->ops
->is_status_pending
&&
1082 server
->ops
->is_status_pending(buf
, server
))
1088 handle_mid(mid
, server
, buf
, length
);
1093 smb2_add_credits_from_hdr(char *buffer
, struct TCP_Server_Info
*server
)
1095 struct smb2_sync_hdr
*shdr
= (struct smb2_sync_hdr
*)buffer
;
1098 * SMB1 does not use credits.
1100 if (server
->vals
->header_preamble_size
)
1103 if (shdr
->CreditRequest
) {
1104 spin_lock(&server
->req_lock
);
1105 server
->credits
+= le16_to_cpu(shdr
->CreditRequest
);
1106 spin_unlock(&server
->req_lock
);
1107 wake_up(&server
->request_q
);
1113 cifs_demultiplex_thread(void *p
)
1115 int i
, num_mids
, length
;
1116 struct TCP_Server_Info
*server
= p
;
1117 unsigned int pdu_length
;
1118 unsigned int next_offset
;
1120 struct task_struct
*task_to_wake
= NULL
;
1121 struct mid_q_entry
*mids
[MAX_COMPOUND
];
1122 char *bufs
[MAX_COMPOUND
];
1123 unsigned int noreclaim_flag
, num_io_timeout
= 0;
1125 noreclaim_flag
= memalloc_noreclaim_save();
1126 cifs_dbg(FYI
, "Demultiplex PID: %d\n", task_pid_nr(current
));
1128 length
= atomic_inc_return(&tcpSesAllocCount
);
1130 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
);
1133 allow_kernel_signal(SIGKILL
);
1134 while (server
->tcpStatus
!= CifsExiting
) {
1135 if (try_to_freeze())
1138 if (!allocate_buffers(server
))
1141 server
->large_buf
= false;
1142 buf
= server
->smallbuf
;
1143 pdu_length
= 4; /* enough to get RFC1001 header */
1145 length
= cifs_read_from_socket(server
, buf
, pdu_length
);
1149 if (server
->vals
->header_preamble_size
== 0)
1150 server
->total_read
= 0;
1152 server
->total_read
= length
;
1155 * The right amount was read from socket - 4 bytes,
1156 * so we can now interpret the length field.
1158 pdu_length
= get_rfc1002_length(buf
);
1160 cifs_dbg(FYI
, "RFC1002 header 0x%x\n", pdu_length
);
1161 if (!is_smb_response(server
, buf
[0]))
1164 server
->pdu_size
= pdu_length
;
1166 /* make sure we have enough to get to the MID */
1167 if (server
->pdu_size
< HEADER_SIZE(server
) - 1 -
1168 server
->vals
->header_preamble_size
) {
1169 cifs_server_dbg(VFS
, "SMB response too short (%u bytes)\n",
1171 cifs_reconnect(server
);
1175 /* read down to the MID */
1176 length
= cifs_read_from_socket(server
,
1177 buf
+ server
->vals
->header_preamble_size
,
1178 HEADER_SIZE(server
) - 1
1179 - server
->vals
->header_preamble_size
);
1182 server
->total_read
+= length
;
1184 if (server
->ops
->next_header
) {
1185 next_offset
= server
->ops
->next_header(buf
);
1187 server
->pdu_size
= next_offset
;
1190 memset(mids
, 0, sizeof(mids
));
1191 memset(bufs
, 0, sizeof(bufs
));
1194 if (server
->ops
->is_transform_hdr
&&
1195 server
->ops
->receive_transform
&&
1196 server
->ops
->is_transform_hdr(buf
)) {
1197 length
= server
->ops
->receive_transform(server
,
1202 mids
[0] = server
->ops
->find_mid(server
, buf
);
1206 if (!mids
[0] || !mids
[0]->receive
)
1207 length
= standard_receive3(server
, mids
[0]);
1209 length
= mids
[0]->receive(server
, mids
[0]);
1213 for (i
= 0; i
< num_mids
; i
++)
1215 cifs_mid_q_entry_release(mids
[i
]);
1219 if (server
->ops
->is_status_io_timeout
&&
1220 server
->ops
->is_status_io_timeout(buf
)) {
1222 if (num_io_timeout
> NUM_STATUS_IO_TIMEOUT
) {
1223 cifs_reconnect(server
);
1229 server
->lstrp
= jiffies
;
1231 for (i
= 0; i
< num_mids
; i
++) {
1232 if (mids
[i
] != NULL
) {
1233 mids
[i
]->resp_buf_size
= server
->pdu_size
;
1235 if (!mids
[i
]->multiRsp
|| mids
[i
]->multiEnd
)
1236 mids
[i
]->callback(mids
[i
]);
1238 cifs_mid_q_entry_release(mids
[i
]);
1239 } else if (server
->ops
->is_oplock_break
&&
1240 server
->ops
->is_oplock_break(bufs
[i
],
1242 smb2_add_credits_from_hdr(bufs
[i
], server
);
1243 cifs_dbg(FYI
, "Received oplock break\n");
1245 cifs_server_dbg(VFS
, "No task to wake, unknown frame received! NumMids %d\n",
1246 atomic_read(&midCount
));
1247 cifs_dump_mem("Received Data is: ", bufs
[i
],
1248 HEADER_SIZE(server
));
1249 smb2_add_credits_from_hdr(bufs
[i
], server
);
1250 #ifdef CONFIG_CIFS_DEBUG2
1251 if (server
->ops
->dump_detail
)
1252 server
->ops
->dump_detail(bufs
[i
],
1254 cifs_dump_mids(server
);
1255 #endif /* CIFS_DEBUG2 */
1259 if (pdu_length
> server
->pdu_size
) {
1260 if (!allocate_buffers(server
))
1262 pdu_length
-= server
->pdu_size
;
1263 server
->total_read
= 0;
1264 server
->large_buf
= false;
1265 buf
= server
->smallbuf
;
1268 } /* end while !EXITING */
1270 /* buffer usually freed in free_mid - need to free it here on exit */
1271 cifs_buf_release(server
->bigbuf
);
1272 if (server
->smallbuf
) /* no sense logging a debug message if NULL */
1273 cifs_small_buf_release(server
->smallbuf
);
1275 task_to_wake
= xchg(&server
->tsk
, NULL
);
1276 clean_demultiplex_info(server
);
1278 /* if server->tsk was NULL then wait for a signal before exiting */
1279 if (!task_to_wake
) {
1280 set_current_state(TASK_INTERRUPTIBLE
);
1281 while (!signal_pending(current
)) {
1283 set_current_state(TASK_INTERRUPTIBLE
);
1285 set_current_state(TASK_RUNNING
);
1288 memalloc_noreclaim_restore(noreclaim_flag
);
1289 module_put_and_exit(0);
1292 /* extract the host portion of the UNC string */
1294 extract_hostname(const char *unc
)
1300 /* skip double chars at beginning of string */
1301 /* BB: check validity of these bytes? */
1302 if (strlen(unc
) < 3)
1303 return ERR_PTR(-EINVAL
);
1304 for (src
= unc
; *src
&& *src
== '\\'; src
++)
1307 return ERR_PTR(-EINVAL
);
1309 /* delimiter between hostname and sharename is always '\\' now */
1310 delim
= strchr(src
, '\\');
1312 return ERR_PTR(-EINVAL
);
1315 dst
= kmalloc((len
+ 1), GFP_KERNEL
);
1317 return ERR_PTR(-ENOMEM
);
1319 memcpy(dst
, src
, len
);
1325 static int get_option_ul(substring_t args
[], unsigned long *option
)
1330 string
= match_strdup(args
);
1333 rc
= kstrtoul(string
, 0, option
);
1339 static int get_option_uid(substring_t args
[], kuid_t
*result
)
1341 unsigned long value
;
1345 rc
= get_option_ul(args
, &value
);
1349 uid
= make_kuid(current_user_ns(), value
);
1350 if (!uid_valid(uid
))
1357 static int get_option_gid(substring_t args
[], kgid_t
*result
)
1359 unsigned long value
;
1363 rc
= get_option_ul(args
, &value
);
1367 gid
= make_kgid(current_user_ns(), value
);
1368 if (!gid_valid(gid
))
1375 static int cifs_parse_security_flavors(char *value
,
1376 struct smb_vol
*vol
)
1379 substring_t args
[MAX_OPT_ARGS
];
1382 * With mount options, the last one should win. Reset any existing
1383 * settings back to default.
1385 vol
->sectype
= Unspecified
;
1388 switch (match_token(value
, cifs_secflavor_tokens
, args
)) {
1390 cifs_dbg(VFS
, "sec=krb5p is not supported!\n");
1396 vol
->sectype
= Kerberos
;
1398 case Opt_sec_ntlmsspi
:
1401 case Opt_sec_ntlmssp
:
1402 vol
->sectype
= RawNTLMSSP
;
1408 vol
->sectype
= NTLM
;
1410 case Opt_sec_ntlmv2i
:
1413 case Opt_sec_ntlmv2
:
1414 vol
->sectype
= NTLMv2
;
1416 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1417 case Opt_sec_lanman
:
1418 vol
->sectype
= LANMAN
;
1425 cifs_dbg(VFS
, "bad security option: %s\n", value
);
1433 cifs_parse_cache_flavor(char *value
, struct smb_vol
*vol
)
1435 substring_t args
[MAX_OPT_ARGS
];
1437 switch (match_token(value
, cifs_cacheflavor_tokens
, args
)) {
1438 case Opt_cache_loose
:
1439 vol
->direct_io
= false;
1440 vol
->strict_io
= false;
1441 vol
->cache_ro
= false;
1442 vol
->cache_rw
= false;
1444 case Opt_cache_strict
:
1445 vol
->direct_io
= false;
1446 vol
->strict_io
= true;
1447 vol
->cache_ro
= false;
1448 vol
->cache_rw
= false;
1450 case Opt_cache_none
:
1451 vol
->direct_io
= true;
1452 vol
->strict_io
= false;
1453 vol
->cache_ro
= false;
1454 vol
->cache_rw
= false;
1457 vol
->direct_io
= false;
1458 vol
->strict_io
= false;
1459 vol
->cache_ro
= true;
1460 vol
->cache_rw
= false;
1463 vol
->direct_io
= false;
1464 vol
->strict_io
= false;
1465 vol
->cache_ro
= false;
1466 vol
->cache_rw
= true;
1469 cifs_dbg(VFS
, "bad cache= option: %s\n", value
);
1476 cifs_parse_smb_version(char *value
, struct smb_vol
*vol
, bool is_smb3
)
1478 substring_t args
[MAX_OPT_ARGS
];
1480 switch (match_token(value
, cifs_smb_version_tokens
, args
)) {
1481 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1483 if (disable_legacy_dialects
) {
1484 cifs_dbg(VFS
, "mount with legacy dialect disabled\n");
1488 cifs_dbg(VFS
, "vers=1.0 (cifs) not permitted when mounting with smb3\n");
1491 cifs_dbg(VFS
, "Use of the less secure dialect vers=1.0 is not recommended unless required for access to very old servers\n");
1492 vol
->ops
= &smb1_operations
;
1493 vol
->vals
= &smb1_values
;
1496 if (disable_legacy_dialects
) {
1497 cifs_dbg(VFS
, "mount with legacy dialect disabled\n");
1501 cifs_dbg(VFS
, "vers=2.0 not permitted when mounting with smb3\n");
1504 vol
->ops
= &smb20_operations
;
1505 vol
->vals
= &smb20_values
;
1509 cifs_dbg(VFS
, "vers=1.0 (cifs) mount not permitted when legacy dialects disabled\n");
1512 cifs_dbg(VFS
, "vers=2.0 mount not permitted when legacy dialects disabled\n");
1514 #endif /* CIFS_ALLOW_INSECURE_LEGACY */
1516 vol
->ops
= &smb21_operations
;
1517 vol
->vals
= &smb21_values
;
1520 vol
->ops
= &smb30_operations
;
1521 vol
->vals
= &smb30_values
;
1524 vol
->ops
= &smb30_operations
; /* currently identical with 3.0 */
1525 vol
->vals
= &smb302_values
;
1528 vol
->ops
= &smb311_operations
;
1529 vol
->vals
= &smb311_values
;
1532 vol
->ops
= &smb30_operations
; /* currently identical with 3.0 */
1533 vol
->vals
= &smb3any_values
;
1536 vol
->ops
= &smb30_operations
; /* currently identical with 3.0 */
1537 vol
->vals
= &smbdefault_values
;
1540 cifs_dbg(VFS
, "Unknown vers= option specified: %s\n", value
);
1547 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1548 * fields with the result. Returns 0 on success and an error otherwise.
1551 cifs_parse_devname(const char *devname
, struct smb_vol
*vol
)
1554 const char *delims
= "/\\";
1557 if (unlikely(!devname
|| !*devname
)) {
1558 cifs_dbg(VFS
, "Device name not specified\n");
1562 /* make sure we have a valid UNC double delimiter prefix */
1563 len
= strspn(devname
, delims
);
1567 /* find delimiter between host and sharename */
1568 pos
= strpbrk(devname
+ 2, delims
);
1572 /* skip past delimiter */
1575 /* now go until next delimiter or end of string */
1576 len
= strcspn(pos
, delims
);
1578 /* move "pos" up to delimiter or NULL */
1580 vol
->UNC
= kstrndup(devname
, pos
- devname
, GFP_KERNEL
);
1584 convert_delimiter(vol
->UNC
, '\\');
1586 /* skip any delimiter */
1587 if (*pos
== '/' || *pos
== '\\')
1590 /* If pos is NULL then no prepath */
1594 vol
->prepath
= kstrdup(pos
, GFP_KERNEL
);
1602 cifs_parse_mount_options(const char *mountdata
, const char *devname
,
1603 struct smb_vol
*vol
, bool is_smb3
)
1606 char *mountdata_copy
= NULL
, *options
;
1607 unsigned int temp_len
, i
, j
;
1609 short int override_uid
= -1;
1610 short int override_gid
= -1;
1611 bool uid_specified
= false;
1612 bool gid_specified
= false;
1613 bool sloppy
= false;
1614 char *invalid
= NULL
;
1615 char *nodename
= utsname()->nodename
;
1616 char *string
= NULL
;
1617 char *tmp_end
, *value
;
1619 bool got_ip
= false;
1620 bool got_version
= false;
1621 unsigned short port
= 0;
1622 struct sockaddr
*dstaddr
= (struct sockaddr
*)&vol
->dstaddr
;
1626 delim
= separator
[0];
1628 /* ensure we always start with zeroed-out smb_vol */
1629 memset(vol
, 0, sizeof(*vol
));
1632 * does not have to be perfect mapping since field is
1633 * informational, only used for servers that do not support
1634 * port 445 and it can be overridden at mount time
1636 memset(vol
->source_rfc1001_name
, 0x20, RFC1001_NAME_LEN
);
1637 for (i
= 0; i
< strnlen(nodename
, RFC1001_NAME_LEN
); i
++)
1638 vol
->source_rfc1001_name
[i
] = toupper(nodename
[i
]);
1640 vol
->source_rfc1001_name
[RFC1001_NAME_LEN
] = 0;
1641 /* null target name indicates to use *SMBSERVR default called name
1642 if we end up sending RFC1001 session initialize */
1643 vol
->target_rfc1001_name
[0] = 0;
1644 vol
->cred_uid
= current_uid();
1645 vol
->linux_uid
= current_uid();
1646 vol
->linux_gid
= current_gid();
1647 vol
->bsize
= 1024 * 1024; /* can improve cp performance significantly */
1649 * default to SFM style remapping of seven reserved characters
1650 * unless user overrides it or we negotiate CIFS POSIX where
1651 * it is unnecessary. Can not simultaneously use more than one mapping
1652 * since then readdir could list files that open could not open
1656 /* default to only allowing write access to owner of the mount */
1657 vol
->dir_mode
= vol
->file_mode
= S_IRUGO
| S_IXUGO
| S_IWUSR
;
1659 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1660 /* default is always to request posix paths. */
1661 vol
->posix_paths
= 1;
1662 /* default to using server inode numbers where available */
1663 vol
->server_ino
= 1;
1665 /* default is to use strict cifs caching semantics */
1666 vol
->strict_io
= true;
1668 vol
->actimeo
= CIFS_DEF_ACTIMEO
;
1670 /* Most clients set timeout to 0, allows server to use its default */
1671 vol
->handle_timeout
= 0; /* See MS-SMB2 spec section 2.2.14.2.12 */
1673 /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1674 vol
->ops
= &smb30_operations
;
1675 vol
->vals
= &smbdefault_values
;
1677 vol
->echo_interval
= SMB_ECHO_INTERVAL_DEFAULT
;
1679 /* default to no multichannel (single server connection) */
1680 vol
->multichannel
= false;
1681 vol
->max_channels
= 1;
1684 goto cifs_parse_mount_err
;
1686 mountdata_copy
= kstrndup(mountdata
, PAGE_SIZE
, GFP_KERNEL
);
1687 if (!mountdata_copy
)
1688 goto cifs_parse_mount_err
;
1690 options
= mountdata_copy
;
1691 end
= options
+ strlen(options
);
1693 if (strncmp(options
, "sep=", 4) == 0) {
1694 if (options
[4] != 0) {
1695 separator
[0] = options
[4];
1698 cifs_dbg(FYI
, "Null separator not allowed\n");
1701 vol
->backupuid_specified
= false; /* no backup intent for a user */
1702 vol
->backupgid_specified
= false; /* no backup intent for a group */
1704 switch (cifs_parse_devname(devname
, vol
)) {
1708 cifs_dbg(VFS
, "Unable to allocate memory for devname\n");
1709 goto cifs_parse_mount_err
;
1711 cifs_dbg(VFS
, "Malformed UNC in devname\n");
1712 goto cifs_parse_mount_err
;
1714 cifs_dbg(VFS
, "Unknown error parsing devname\n");
1715 goto cifs_parse_mount_err
;
1718 while ((data
= strsep(&options
, separator
)) != NULL
) {
1719 substring_t args
[MAX_OPT_ARGS
];
1720 unsigned long option
;
1726 token
= match_token(data
, cifs_mount_option_tokens
, args
);
1730 /* Ingnore the following */
1734 /* Boolean values */
1735 case Opt_user_xattr
:
1738 case Opt_nouser_xattr
:
1744 case Opt_noforceuid
:
1750 case Opt_noforcegid
:
1753 case Opt_noblocksend
:
1754 vol
->noblocksnd
= 1;
1756 case Opt_noautotune
:
1757 vol
->noautotune
= 1;
1778 vol
->sfu_remap
= true;
1779 vol
->remap
= false; /* disable SFM mapping */
1781 case Opt_nomapchars
:
1782 vol
->sfu_remap
= false;
1786 vol
->sfu_remap
= false; /* disable SFU mapping */
1788 case Opt_nomapposix
:
1801 #ifdef CONFIG_CIFS_ROOT
1805 case Opt_posixpaths
:
1806 vol
->posix_paths
= 1;
1808 case Opt_noposixpaths
:
1809 vol
->posix_paths
= 0;
1814 "conflicting unix mount options\n");
1815 vol
->no_linux_ext
= 1;
1818 if (vol
->no_linux_ext
)
1820 "conflicting unix mount options\n");
1832 * turn off mandatory locking in mode
1833 * if remote locking is turned off since the
1834 * local vfs will do advisory
1836 if (vol
->file_mode
==
1837 (S_IALLUGO
& ~(S_ISUID
| S_IXGRP
)))
1838 vol
->file_mode
= S_IALLUGO
;
1840 case Opt_nohandlecache
:
1841 vol
->nohandlecache
= 1;
1843 case Opt_handlecache
:
1844 vol
->nohandlecache
= 0;
1846 case Opt_forcemandatorylock
:
1855 case Opt_setuidfromacl
:
1856 vol
->setuidfromacl
= 1;
1859 vol
->dynperm
= true;
1862 vol
->dynperm
= false;
1876 case Opt_nostrictsync
:
1877 vol
->nostrictsync
= 1;
1879 case Opt_strictsync
:
1880 vol
->nostrictsync
= 0;
1883 vol
->server_ino
= 1;
1885 case Opt_noserverino
:
1886 vol
->server_ino
= 0;
1888 case Opt_rwpidforward
:
1889 vol
->rwpidforward
= 1;
1901 vol
->no_psx_acl
= 0;
1904 vol
->no_psx_acl
= 1;
1906 case Opt_locallease
:
1907 vol
->local_lease
= 1;
1912 case Opt_ignore_signature
:
1914 vol
->ignore_signature
= true;
1917 /* we do not do the following in secFlags because seal
1918 * is a per tree connection (mount) not a per socket
1919 * or per-smb connection option in the protocol
1920 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1925 pr_warn("Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1928 #ifndef CONFIG_CIFS_FSCACHE
1929 cifs_dbg(VFS
, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1930 goto cifs_parse_mount_err
;
1934 case Opt_mfsymlinks
:
1935 vol
->mfsymlinks
= true;
1938 vol
->multiuser
= true;
1943 case Opt_nosharesock
:
1944 vol
->nosharesock
= true;
1946 case Opt_nopersistent
:
1947 vol
->nopersistent
= true;
1948 if (vol
->persistent
) {
1950 "persistenthandles mount options conflict\n");
1951 goto cifs_parse_mount_err
;
1954 case Opt_persistent
:
1955 vol
->persistent
= true;
1956 if ((vol
->nopersistent
) || (vol
->resilient
)) {
1958 "persistenthandles mount options conflict\n");
1959 goto cifs_parse_mount_err
;
1963 vol
->resilient
= true;
1964 if (vol
->persistent
) {
1966 "persistenthandles mount options conflict\n");
1967 goto cifs_parse_mount_err
;
1970 case Opt_noresilient
:
1971 vol
->resilient
= false; /* already the default */
1973 case Opt_domainauto
:
1974 vol
->domainauto
= true;
1979 case Opt_multichannel
:
1980 vol
->multichannel
= true;
1981 /* if number of channels not specified, default to 2 */
1982 if (vol
->max_channels
< 2)
1983 vol
->max_channels
= 2;
1985 case Opt_nomultichannel
:
1986 vol
->multichannel
= false;
1987 vol
->max_channels
= 1;
1990 vol
->compression
= UNKNOWN_TYPE
;
1992 "SMB3 compression support is experimental\n");
1995 /* Numeric Values */
1997 if (get_option_uid(args
, &vol
->backupuid
)) {
1998 cifs_dbg(VFS
, "%s: Invalid backupuid value\n",
2000 goto cifs_parse_mount_err
;
2002 vol
->backupuid_specified
= true;
2005 if (get_option_gid(args
, &vol
->backupgid
)) {
2006 cifs_dbg(VFS
, "%s: Invalid backupgid value\n",
2008 goto cifs_parse_mount_err
;
2010 vol
->backupgid_specified
= true;
2013 if (get_option_uid(args
, &vol
->linux_uid
)) {
2014 cifs_dbg(VFS
, "%s: Invalid uid value\n",
2016 goto cifs_parse_mount_err
;
2018 uid_specified
= true;
2021 if (get_option_uid(args
, &vol
->cred_uid
)) {
2022 cifs_dbg(VFS
, "%s: Invalid cruid value\n",
2024 goto cifs_parse_mount_err
;
2028 if (get_option_gid(args
, &vol
->linux_gid
)) {
2029 cifs_dbg(VFS
, "%s: Invalid gid value\n",
2031 goto cifs_parse_mount_err
;
2033 gid_specified
= true;
2036 if (get_option_ul(args
, &option
)) {
2037 cifs_dbg(VFS
, "%s: Invalid file_mode value\n",
2039 goto cifs_parse_mount_err
;
2041 vol
->file_mode
= option
;
2044 if (get_option_ul(args
, &option
)) {
2045 cifs_dbg(VFS
, "%s: Invalid dir_mode value\n",
2047 goto cifs_parse_mount_err
;
2049 vol
->dir_mode
= option
;
2052 if (get_option_ul(args
, &option
) ||
2053 option
> USHRT_MAX
) {
2054 cifs_dbg(VFS
, "%s: Invalid port value\n",
2056 goto cifs_parse_mount_err
;
2058 port
= (unsigned short)option
;
2060 case Opt_min_enc_offload
:
2061 if (get_option_ul(args
, &option
)) {
2062 cifs_dbg(VFS
, "Invalid minimum encrypted read offload size (esize)\n");
2063 goto cifs_parse_mount_err
;
2065 vol
->min_offload
= option
;
2068 if (get_option_ul(args
, &option
)) {
2069 cifs_dbg(VFS
, "%s: Invalid blocksize value\n",
2071 goto cifs_parse_mount_err
;
2074 * inode blocksize realistically should never need to be
2075 * less than 16K or greater than 16M and default is 1MB.
2076 * Note that small inode block sizes (e.g. 64K) can lead
2077 * to very poor performance of common tools like cp and scp
2079 if ((option
< CIFS_MAX_MSGSIZE
) ||
2080 (option
> (4 * SMB3_DEFAULT_IOSIZE
))) {
2081 cifs_dbg(VFS
, "%s: Invalid blocksize\n",
2083 goto cifs_parse_mount_err
;
2085 vol
->bsize
= option
;
2088 if (get_option_ul(args
, &option
)) {
2089 cifs_dbg(VFS
, "%s: Invalid rsize value\n",
2091 goto cifs_parse_mount_err
;
2093 vol
->rsize
= option
;
2096 if (get_option_ul(args
, &option
)) {
2097 cifs_dbg(VFS
, "%s: Invalid wsize value\n",
2099 goto cifs_parse_mount_err
;
2101 vol
->wsize
= option
;
2104 if (get_option_ul(args
, &option
)) {
2105 cifs_dbg(VFS
, "%s: Invalid actimeo value\n",
2107 goto cifs_parse_mount_err
;
2109 vol
->actimeo
= HZ
* option
;
2110 if (vol
->actimeo
> CIFS_MAX_ACTIMEO
) {
2111 cifs_dbg(VFS
, "attribute cache timeout too large\n");
2112 goto cifs_parse_mount_err
;
2115 case Opt_handletimeout
:
2116 if (get_option_ul(args
, &option
)) {
2117 cifs_dbg(VFS
, "%s: Invalid handletimeout value\n",
2119 goto cifs_parse_mount_err
;
2121 vol
->handle_timeout
= option
;
2122 if (vol
->handle_timeout
> SMB3_MAX_HANDLE_TIMEOUT
) {
2123 cifs_dbg(VFS
, "Invalid handle cache timeout, longer than 16 minutes\n");
2124 goto cifs_parse_mount_err
;
2127 case Opt_echo_interval
:
2128 if (get_option_ul(args
, &option
)) {
2129 cifs_dbg(VFS
, "%s: Invalid echo interval value\n",
2131 goto cifs_parse_mount_err
;
2133 vol
->echo_interval
= option
;
2136 if (get_option_ul(args
, &option
)) {
2137 cifs_dbg(VFS
, "%s: Invalid snapshot time\n",
2139 goto cifs_parse_mount_err
;
2141 vol
->snapshot_time
= option
;
2143 case Opt_max_credits
:
2144 if (get_option_ul(args
, &option
) || (option
< 20) ||
2146 cifs_dbg(VFS
, "%s: Invalid max_credits value\n",
2148 goto cifs_parse_mount_err
;
2150 vol
->max_credits
= option
;
2152 case Opt_max_channels
:
2153 if (get_option_ul(args
, &option
) || option
< 1 ||
2154 option
> CIFS_MAX_CHANNELS
) {
2155 cifs_dbg(VFS
, "%s: Invalid max_channels value, needs to be 1-%d\n",
2156 __func__
, CIFS_MAX_CHANNELS
);
2157 goto cifs_parse_mount_err
;
2159 vol
->max_channels
= option
;
2162 /* String Arguments */
2164 case Opt_blank_user
:
2165 /* null user, ie. anonymous authentication */
2167 vol
->username
= NULL
;
2170 string
= match_strdup(args
);
2174 if (strnlen(string
, CIFS_MAX_USERNAME_LEN
) >
2175 CIFS_MAX_USERNAME_LEN
) {
2176 pr_warn("username too long\n");
2177 goto cifs_parse_mount_err
;
2180 kfree(vol
->username
);
2181 vol
->username
= kstrdup(string
, GFP_KERNEL
);
2183 goto cifs_parse_mount_err
;
2185 case Opt_blank_pass
:
2186 /* passwords have to be handled differently
2187 * to allow the character used for deliminator
2188 * to be passed within them
2192 * Check if this is a case where the password
2193 * starts with a delimiter
2195 tmp_end
= strchr(data
, '=');
2197 if (!(tmp_end
< end
&& tmp_end
[1] == delim
)) {
2198 /* No it is not. Set the password to NULL */
2199 kfree_sensitive(vol
->password
);
2200 vol
->password
= NULL
;
2203 fallthrough
; /* to Opt_pass below */
2205 /* Obtain the value string */
2206 value
= strchr(data
, '=');
2209 /* Set tmp_end to end of the string */
2210 tmp_end
= (char *) value
+ strlen(value
);
2212 /* Check if following character is the deliminator
2213 * If yes, we have encountered a double deliminator
2214 * reset the NULL character to the deliminator
2216 if (tmp_end
< end
&& tmp_end
[1] == delim
) {
2219 /* Keep iterating until we get to a single
2220 * deliminator OR the end
2222 while ((tmp_end
= strchr(tmp_end
, delim
))
2223 != NULL
&& (tmp_end
[1] == delim
)) {
2224 tmp_end
= (char *) &tmp_end
[2];
2227 /* Reset var options to point to next element */
2230 options
= (char *) &tmp_end
[1];
2232 /* Reached the end of the mount option
2237 kfree_sensitive(vol
->password
);
2238 /* Now build new password string */
2239 temp_len
= strlen(value
);
2240 vol
->password
= kzalloc(temp_len
+1, GFP_KERNEL
);
2241 if (vol
->password
== NULL
) {
2242 pr_warn("no memory for password\n");
2243 goto cifs_parse_mount_err
;
2246 for (i
= 0, j
= 0; i
< temp_len
; i
++, j
++) {
2247 vol
->password
[j
] = value
[i
];
2248 if ((value
[i
] == delim
) &&
2249 value
[i
+1] == delim
)
2250 /* skip the second deliminator */
2253 vol
->password
[j
] = '\0';
2256 /* FIXME: should this be an error instead? */
2260 string
= match_strdup(args
);
2264 if (!cifs_convert_address(dstaddr
, string
,
2266 pr_err("bad ip= option (%s)\n", string
);
2267 goto cifs_parse_mount_err
;
2272 string
= match_strdup(args
);
2276 if (strnlen(string
, CIFS_MAX_DOMAINNAME_LEN
)
2277 == CIFS_MAX_DOMAINNAME_LEN
) {
2278 pr_warn("domain name too long\n");
2279 goto cifs_parse_mount_err
;
2282 kfree(vol
->domainname
);
2283 vol
->domainname
= kstrdup(string
, GFP_KERNEL
);
2284 if (!vol
->domainname
) {
2285 pr_warn("no memory for domainname\n");
2286 goto cifs_parse_mount_err
;
2288 cifs_dbg(FYI
, "Domain name set\n");
2291 string
= match_strdup(args
);
2295 if (!cifs_convert_address(
2296 (struct sockaddr
*)&vol
->srcaddr
,
2297 string
, strlen(string
))) {
2298 pr_warn("Could not parse srcaddr: %s\n",
2300 goto cifs_parse_mount_err
;
2304 string
= match_strdup(args
);
2308 if (strnlen(string
, 1024) >= 65) {
2309 pr_warn("iocharset name too long\n");
2310 goto cifs_parse_mount_err
;
2313 if (strncasecmp(string
, "default", 7) != 0) {
2314 kfree(vol
->iocharset
);
2315 vol
->iocharset
= kstrdup(string
,
2317 if (!vol
->iocharset
) {
2318 pr_warn("no memory for charset\n");
2319 goto cifs_parse_mount_err
;
2322 /* if iocharset not set then load_nls_default
2325 cifs_dbg(FYI
, "iocharset set to %s\n", string
);
2327 case Opt_netbiosname
:
2328 string
= match_strdup(args
);
2332 memset(vol
->source_rfc1001_name
, 0x20,
2335 * FIXME: are there cases in which a comma can
2336 * be valid in workstation netbios name (and
2337 * need special handling)?
2339 for (i
= 0; i
< RFC1001_NAME_LEN
; i
++) {
2340 /* don't ucase netbiosname for user */
2343 vol
->source_rfc1001_name
[i
] = string
[i
];
2345 /* The string has 16th byte zero still from
2346 * set at top of the function
2348 if (i
== RFC1001_NAME_LEN
&& string
[i
] != 0)
2349 pr_warn("netbiosname longer than 15 truncated\n");
2352 /* servernetbiosname specified override *SMBSERVER */
2353 string
= match_strdup(args
);
2357 /* last byte, type, is 0x20 for servr type */
2358 memset(vol
->target_rfc1001_name
, 0x20,
2359 RFC1001_NAME_LEN_WITH_NULL
);
2361 /* BB are there cases in which a comma can be
2362 valid in this workstation netbios name
2363 (and need special handling)? */
2365 /* user or mount helper must uppercase the
2367 for (i
= 0; i
< 15; i
++) {
2370 vol
->target_rfc1001_name
[i
] = string
[i
];
2372 /* The string has 16th byte zero still from
2373 set at top of the function */
2374 if (i
== RFC1001_NAME_LEN
&& string
[i
] != 0)
2375 pr_warn("server netbiosname longer than 15 truncated\n");
2378 /* version of mount userspace tools, not dialect */
2379 string
= match_strdup(args
);
2383 /* If interface changes in mount.cifs bump to new ver */
2384 if (strncasecmp(string
, "1", 1) == 0) {
2385 if (strlen(string
) > 1) {
2386 pr_warn("Bad mount helper ver=%s. Did you want SMB1 (CIFS) dialect and mean to type vers=1.0 instead?\n",
2388 goto cifs_parse_mount_err
;
2390 /* This is the default */
2393 /* For all other value, error */
2394 pr_warn("Invalid mount helper version specified\n");
2395 goto cifs_parse_mount_err
;
2397 /* protocol version (dialect) */
2398 string
= match_strdup(args
);
2402 if (cifs_parse_smb_version(string
, vol
, is_smb3
) != 0)
2403 goto cifs_parse_mount_err
;
2407 string
= match_strdup(args
);
2411 if (cifs_parse_security_flavors(string
, vol
) != 0)
2412 goto cifs_parse_mount_err
;
2415 string
= match_strdup(args
);
2419 if (cifs_parse_cache_flavor(string
, vol
) != 0)
2420 goto cifs_parse_mount_err
;
2424 * An option we don't recognize. Save it off for later
2425 * if we haven't already found one
2431 /* Free up any allocated string */
2436 if (!sloppy
&& invalid
) {
2437 pr_err("Unknown mount option \"%s\"\n", invalid
);
2438 goto cifs_parse_mount_err
;
2441 if (vol
->rdma
&& vol
->vals
->protocol_id
< SMB30_PROT_ID
) {
2442 cifs_dbg(VFS
, "SMB Direct requires Version >=3.0\n");
2443 goto cifs_parse_mount_err
;
2447 /* Muliuser mounts require CONFIG_KEYS support */
2448 if (vol
->multiuser
) {
2449 cifs_dbg(VFS
, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
2450 goto cifs_parse_mount_err
;
2454 cifs_dbg(VFS
, "CIFS mount error: No usable UNC path provided in device string!\n");
2455 goto cifs_parse_mount_err
;
2458 /* make sure UNC has a share name */
2459 if (!strchr(vol
->UNC
+ 3, '\\')) {
2460 cifs_dbg(VFS
, "Malformed UNC. Unable to find share name.\n");
2461 goto cifs_parse_mount_err
;
2468 /* No ip= option specified? Try to get it from UNC */
2469 /* Use the address part of the UNC. */
2470 slash
= strchr(&vol
->UNC
[2], '\\');
2471 len
= slash
- &vol
->UNC
[2];
2472 if (!cifs_convert_address(dstaddr
, &vol
->UNC
[2], len
)) {
2473 pr_err("Unable to determine destination address\n");
2474 goto cifs_parse_mount_err
;
2478 /* set the port that we got earlier */
2479 cifs_set_port(dstaddr
, port
);
2482 vol
->override_uid
= override_uid
;
2483 else if (override_uid
== 1)
2484 pr_notice("ignoring forceuid mount option specified with no uid= option\n");
2487 vol
->override_gid
= override_gid
;
2488 else if (override_gid
== 1)
2489 pr_notice("ignoring forcegid mount option specified with no gid= option\n");
2491 if (got_version
== false)
2492 pr_warn_once("No dialect specified on mount. Default has changed to a more secure dialect, SMB2.1 or later (e.g. SMB3.1.1), from CIFS (SMB1). To use the less secure SMB1 dialect to access old servers which do not support SMB3.1.1 (or even SMB3 or SMB2.1) specify vers=1.0 on mount.\n");
2494 kfree(mountdata_copy
);
2498 pr_warn("Could not allocate temporary buffer\n");
2499 cifs_parse_mount_err
:
2501 kfree(mountdata_copy
);
2505 /** Returns true if srcaddr isn't specified and rhs isn't
2506 * specified, or if srcaddr is specified and
2507 * matches the IP address of the rhs argument.
2510 cifs_match_ipaddr(struct sockaddr
*srcaddr
, struct sockaddr
*rhs
)
2512 switch (srcaddr
->sa_family
) {
2514 return (rhs
->sa_family
== AF_UNSPEC
);
2516 struct sockaddr_in
*saddr4
= (struct sockaddr_in
*)srcaddr
;
2517 struct sockaddr_in
*vaddr4
= (struct sockaddr_in
*)rhs
;
2518 return (saddr4
->sin_addr
.s_addr
== vaddr4
->sin_addr
.s_addr
);
2521 struct sockaddr_in6
*saddr6
= (struct sockaddr_in6
*)srcaddr
;
2522 struct sockaddr_in6
*vaddr6
= (struct sockaddr_in6
*)rhs
;
2523 return ipv6_addr_equal(&saddr6
->sin6_addr
, &vaddr6
->sin6_addr
);
2527 return false; /* don't expect to be here */
2532 * If no port is specified in addr structure, we try to match with 445 port
2533 * and if it fails - with 139 ports. It should be called only if address
2534 * families of server and addr are equal.
2537 match_port(struct TCP_Server_Info
*server
, struct sockaddr
*addr
)
2539 __be16 port
, *sport
;
2541 /* SMBDirect manages its own ports, don't match it here */
2545 switch (addr
->sa_family
) {
2547 sport
= &((struct sockaddr_in
*) &server
->dstaddr
)->sin_port
;
2548 port
= ((struct sockaddr_in
*) addr
)->sin_port
;
2551 sport
= &((struct sockaddr_in6
*) &server
->dstaddr
)->sin6_port
;
2552 port
= ((struct sockaddr_in6
*) addr
)->sin6_port
;
2560 port
= htons(CIFS_PORT
);
2564 port
= htons(RFC1001_PORT
);
2567 return port
== *sport
;
2571 match_address(struct TCP_Server_Info
*server
, struct sockaddr
*addr
,
2572 struct sockaddr
*srcaddr
)
2574 switch (addr
->sa_family
) {
2576 struct sockaddr_in
*addr4
= (struct sockaddr_in
*)addr
;
2577 struct sockaddr_in
*srv_addr4
=
2578 (struct sockaddr_in
*)&server
->dstaddr
;
2580 if (addr4
->sin_addr
.s_addr
!= srv_addr4
->sin_addr
.s_addr
)
2585 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)addr
;
2586 struct sockaddr_in6
*srv_addr6
=
2587 (struct sockaddr_in6
*)&server
->dstaddr
;
2589 if (!ipv6_addr_equal(&addr6
->sin6_addr
,
2590 &srv_addr6
->sin6_addr
))
2592 if (addr6
->sin6_scope_id
!= srv_addr6
->sin6_scope_id
)
2598 return false; /* don't expect to be here */
2601 if (!cifs_match_ipaddr(srcaddr
, (struct sockaddr
*)&server
->srcaddr
))
2608 match_security(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
2611 * The select_sectype function should either return the vol->sectype
2612 * that was specified, or "Unspecified" if that sectype was not
2613 * compatible with the given NEGOTIATE request.
2615 if (server
->ops
->select_sectype(server
, vol
->sectype
)
2620 * Now check if signing mode is acceptable. No need to check
2621 * global_secflags at this point since if MUST_SIGN is set then
2622 * the server->sign had better be too.
2624 if (vol
->sign
&& !server
->sign
)
2630 static int match_server(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
2632 struct sockaddr
*addr
= (struct sockaddr
*)&vol
->dstaddr
;
2634 if (vol
->nosharesock
)
2637 /* If multidialect negotiation see if existing sessions match one */
2638 if (strcmp(vol
->vals
->version_string
, SMB3ANY_VERSION_STRING
) == 0) {
2639 if (server
->vals
->protocol_id
< SMB30_PROT_ID
)
2641 } else if (strcmp(vol
->vals
->version_string
,
2642 SMBDEFAULT_VERSION_STRING
) == 0) {
2643 if (server
->vals
->protocol_id
< SMB21_PROT_ID
)
2645 } else if ((server
->vals
!= vol
->vals
) || (server
->ops
!= vol
->ops
))
2648 if (!net_eq(cifs_net_ns(server
), current
->nsproxy
->net_ns
))
2651 if (!match_address(server
, addr
,
2652 (struct sockaddr
*)&vol
->srcaddr
))
2655 if (!match_port(server
, addr
))
2658 if (!match_security(server
, vol
))
2661 if (server
->echo_interval
!= vol
->echo_interval
* HZ
)
2664 if (server
->rdma
!= vol
->rdma
)
2667 if (server
->ignore_signature
!= vol
->ignore_signature
)
2670 if (server
->min_offload
!= vol
->min_offload
)
2676 struct TCP_Server_Info
*
2677 cifs_find_tcp_session(struct smb_vol
*vol
)
2679 struct TCP_Server_Info
*server
;
2681 spin_lock(&cifs_tcp_ses_lock
);
2682 list_for_each_entry(server
, &cifs_tcp_ses_list
, tcp_ses_list
) {
2684 * Skip ses channels since they're only handled in lower layers
2685 * (e.g. cifs_send_recv).
2687 if (server
->is_channel
|| !match_server(server
, vol
))
2690 ++server
->srv_count
;
2691 spin_unlock(&cifs_tcp_ses_lock
);
2692 cifs_dbg(FYI
, "Existing tcp session with server found\n");
2695 spin_unlock(&cifs_tcp_ses_lock
);
2700 cifs_put_tcp_session(struct TCP_Server_Info
*server
, int from_reconnect
)
2702 struct task_struct
*task
;
2704 spin_lock(&cifs_tcp_ses_lock
);
2705 if (--server
->srv_count
> 0) {
2706 spin_unlock(&cifs_tcp_ses_lock
);
2710 put_net(cifs_net_ns(server
));
2712 list_del_init(&server
->tcp_ses_list
);
2713 spin_unlock(&cifs_tcp_ses_lock
);
2715 cancel_delayed_work_sync(&server
->echo
);
2719 * Avoid deadlock here: reconnect work calls
2720 * cifs_put_tcp_session() at its end. Need to be sure
2721 * that reconnect work does nothing with server pointer after
2724 cancel_delayed_work(&server
->reconnect
);
2726 cancel_delayed_work_sync(&server
->reconnect
);
2728 spin_lock(&GlobalMid_Lock
);
2729 server
->tcpStatus
= CifsExiting
;
2730 spin_unlock(&GlobalMid_Lock
);
2732 cifs_crypto_secmech_release(server
);
2733 cifs_fscache_release_client_cookie(server
);
2735 kfree(server
->session_key
.response
);
2736 server
->session_key
.response
= NULL
;
2737 server
->session_key
.len
= 0;
2739 task
= xchg(&server
->tsk
, NULL
);
2741 send_sig(SIGKILL
, task
, 1);
2744 struct TCP_Server_Info
*
2745 cifs_get_tcp_session(struct smb_vol
*volume_info
)
2747 struct TCP_Server_Info
*tcp_ses
= NULL
;
2750 cifs_dbg(FYI
, "UNC: %s\n", volume_info
->UNC
);
2752 /* see if we already have a matching tcp_ses */
2753 tcp_ses
= cifs_find_tcp_session(volume_info
);
2757 tcp_ses
= kzalloc(sizeof(struct TCP_Server_Info
), GFP_KERNEL
);
2763 tcp_ses
->ops
= volume_info
->ops
;
2764 tcp_ses
->vals
= volume_info
->vals
;
2765 cifs_set_net_ns(tcp_ses
, get_net(current
->nsproxy
->net_ns
));
2766 tcp_ses
->hostname
= extract_hostname(volume_info
->UNC
);
2767 if (IS_ERR(tcp_ses
->hostname
)) {
2768 rc
= PTR_ERR(tcp_ses
->hostname
);
2769 goto out_err_crypto_release
;
2772 tcp_ses
->noblockcnt
= volume_info
->rootfs
;
2773 tcp_ses
->noblocksnd
= volume_info
->noblocksnd
|| volume_info
->rootfs
;
2774 tcp_ses
->noautotune
= volume_info
->noautotune
;
2775 tcp_ses
->tcp_nodelay
= volume_info
->sockopt_tcp_nodelay
;
2776 tcp_ses
->rdma
= volume_info
->rdma
;
2777 tcp_ses
->in_flight
= 0;
2778 tcp_ses
->max_in_flight
= 0;
2779 tcp_ses
->credits
= 1;
2780 init_waitqueue_head(&tcp_ses
->response_q
);
2781 init_waitqueue_head(&tcp_ses
->request_q
);
2782 INIT_LIST_HEAD(&tcp_ses
->pending_mid_q
);
2783 mutex_init(&tcp_ses
->srv_mutex
);
2784 memcpy(tcp_ses
->workstation_RFC1001_name
,
2785 volume_info
->source_rfc1001_name
, RFC1001_NAME_LEN_WITH_NULL
);
2786 memcpy(tcp_ses
->server_RFC1001_name
,
2787 volume_info
->target_rfc1001_name
, RFC1001_NAME_LEN_WITH_NULL
);
2788 tcp_ses
->session_estab
= false;
2789 tcp_ses
->sequence_number
= 0;
2790 tcp_ses
->reconnect_instance
= 1;
2791 tcp_ses
->lstrp
= jiffies
;
2792 tcp_ses
->compress_algorithm
= cpu_to_le16(volume_info
->compression
);
2793 spin_lock_init(&tcp_ses
->req_lock
);
2794 INIT_LIST_HEAD(&tcp_ses
->tcp_ses_list
);
2795 INIT_LIST_HEAD(&tcp_ses
->smb_ses_list
);
2796 INIT_DELAYED_WORK(&tcp_ses
->echo
, cifs_echo_request
);
2797 INIT_DELAYED_WORK(&tcp_ses
->reconnect
, smb2_reconnect_server
);
2798 mutex_init(&tcp_ses
->reconnect_mutex
);
2799 memcpy(&tcp_ses
->srcaddr
, &volume_info
->srcaddr
,
2800 sizeof(tcp_ses
->srcaddr
));
2801 memcpy(&tcp_ses
->dstaddr
, &volume_info
->dstaddr
,
2802 sizeof(tcp_ses
->dstaddr
));
2803 if (volume_info
->use_client_guid
)
2804 memcpy(tcp_ses
->client_guid
, volume_info
->client_guid
,
2805 SMB2_CLIENT_GUID_SIZE
);
2807 generate_random_uuid(tcp_ses
->client_guid
);
2809 * at this point we are the only ones with the pointer
2810 * to the struct since the kernel thread not created yet
2811 * no need to spinlock this init of tcpStatus or srv_count
2813 tcp_ses
->tcpStatus
= CifsNew
;
2814 ++tcp_ses
->srv_count
;
2816 if (volume_info
->echo_interval
>= SMB_ECHO_INTERVAL_MIN
&&
2817 volume_info
->echo_interval
<= SMB_ECHO_INTERVAL_MAX
)
2818 tcp_ses
->echo_interval
= volume_info
->echo_interval
* HZ
;
2820 tcp_ses
->echo_interval
= SMB_ECHO_INTERVAL_DEFAULT
* HZ
;
2821 if (tcp_ses
->rdma
) {
2822 #ifndef CONFIG_CIFS_SMB_DIRECT
2823 cifs_dbg(VFS
, "CONFIG_CIFS_SMB_DIRECT is not enabled\n");
2825 goto out_err_crypto_release
;
2827 tcp_ses
->smbd_conn
= smbd_get_connection(
2828 tcp_ses
, (struct sockaddr
*)&volume_info
->dstaddr
);
2829 if (tcp_ses
->smbd_conn
) {
2830 cifs_dbg(VFS
, "RDMA transport established\n");
2832 goto smbd_connected
;
2835 goto out_err_crypto_release
;
2838 rc
= ip_connect(tcp_ses
);
2840 cifs_dbg(VFS
, "Error connecting to socket. Aborting operation.\n");
2841 goto out_err_crypto_release
;
2845 * since we're in a cifs function already, we know that
2846 * this will succeed. No need for try_module_get().
2848 __module_get(THIS_MODULE
);
2849 tcp_ses
->tsk
= kthread_run(cifs_demultiplex_thread
,
2851 if (IS_ERR(tcp_ses
->tsk
)) {
2852 rc
= PTR_ERR(tcp_ses
->tsk
);
2853 cifs_dbg(VFS
, "error %d create cifsd thread\n", rc
);
2854 module_put(THIS_MODULE
);
2855 goto out_err_crypto_release
;
2857 tcp_ses
->min_offload
= volume_info
->min_offload
;
2858 tcp_ses
->tcpStatus
= CifsNeedNegotiate
;
2860 tcp_ses
->nr_targets
= 1;
2861 tcp_ses
->ignore_signature
= volume_info
->ignore_signature
;
2862 /* thread spawned, put it on the list */
2863 spin_lock(&cifs_tcp_ses_lock
);
2864 list_add(&tcp_ses
->tcp_ses_list
, &cifs_tcp_ses_list
);
2865 spin_unlock(&cifs_tcp_ses_lock
);
2867 cifs_fscache_get_client_cookie(tcp_ses
);
2869 /* queue echo request delayed work */
2870 queue_delayed_work(cifsiod_wq
, &tcp_ses
->echo
, tcp_ses
->echo_interval
);
2874 out_err_crypto_release
:
2875 cifs_crypto_secmech_release(tcp_ses
);
2877 put_net(cifs_net_ns(tcp_ses
));
2881 if (!IS_ERR(tcp_ses
->hostname
))
2882 kfree(tcp_ses
->hostname
);
2883 if (tcp_ses
->ssocket
)
2884 sock_release(tcp_ses
->ssocket
);
2890 static int match_session(struct cifs_ses
*ses
, struct smb_vol
*vol
)
2892 if (vol
->sectype
!= Unspecified
&&
2893 vol
->sectype
!= ses
->sectype
)
2897 * If an existing session is limited to less channels than
2898 * requested, it should not be reused
2900 if (ses
->chan_max
< vol
->max_channels
)
2903 switch (ses
->sectype
) {
2905 if (!uid_eq(vol
->cred_uid
, ses
->cred_uid
))
2909 /* NULL username means anonymous session */
2910 if (ses
->user_name
== NULL
) {
2916 /* anything else takes username/password */
2917 if (strncmp(ses
->user_name
,
2918 vol
->username
? vol
->username
: "",
2919 CIFS_MAX_USERNAME_LEN
))
2921 if ((vol
->username
&& strlen(vol
->username
) != 0) &&
2922 ses
->password
!= NULL
&&
2923 strncmp(ses
->password
,
2924 vol
->password
? vol
->password
: "",
2925 CIFS_MAX_PASSWORD_LEN
))
2932 * cifs_setup_ipc - helper to setup the IPC tcon for the session
2934 * A new IPC connection is made and stored in the session
2935 * tcon_ipc. The IPC tcon has the same lifetime as the session.
2938 cifs_setup_ipc(struct cifs_ses
*ses
, struct smb_vol
*volume_info
)
2941 struct cifs_tcon
*tcon
;
2942 struct nls_table
*nls_codepage
;
2943 char unc
[SERVER_NAME_LENGTH
+ sizeof("//x/IPC$")] = {0};
2945 struct TCP_Server_Info
*server
= ses
->server
;
2948 * If the mount request that resulted in the creation of the
2949 * session requires encryption, force IPC to be encrypted too.
2951 if (volume_info
->seal
) {
2952 if (server
->capabilities
& SMB2_GLOBAL_CAP_ENCRYPTION
)
2955 cifs_server_dbg(VFS
,
2956 "IPC: server doesn't support encryption\n");
2961 tcon
= tconInfoAlloc();
2965 scnprintf(unc
, sizeof(unc
), "\\\\%s\\IPC$", server
->hostname
);
2968 nls_codepage
= load_nls_default();
2974 rc
= server
->ops
->tree_connect(xid
, ses
, unc
, tcon
, nls_codepage
);
2978 cifs_server_dbg(VFS
, "failed to connect to IPC (rc=%d)\n", rc
);
2983 cifs_dbg(FYI
, "IPC tcon rc = %d ipc tid = %d\n", rc
, tcon
->tid
);
2985 ses
->tcon_ipc
= tcon
;
2987 unload_nls(nls_codepage
);
2992 * cifs_free_ipc - helper to release the session IPC tcon
2994 * Needs to be called everytime a session is destroyed
2997 cifs_free_ipc(struct cifs_ses
*ses
)
3000 struct cifs_tcon
*tcon
= ses
->tcon_ipc
;
3005 if (ses
->server
->ops
->tree_disconnect
) {
3007 rc
= ses
->server
->ops
->tree_disconnect(xid
, tcon
);
3012 cifs_dbg(FYI
, "failed to disconnect IPC tcon (rc=%d)\n", rc
);
3015 ses
->tcon_ipc
= NULL
;
3019 static struct cifs_ses
*
3020 cifs_find_smb_ses(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
3022 struct cifs_ses
*ses
;
3024 spin_lock(&cifs_tcp_ses_lock
);
3025 list_for_each_entry(ses
, &server
->smb_ses_list
, smb_ses_list
) {
3026 if (ses
->status
== CifsExiting
)
3028 if (!match_session(ses
, vol
))
3031 spin_unlock(&cifs_tcp_ses_lock
);
3034 spin_unlock(&cifs_tcp_ses_lock
);
3038 void cifs_put_smb_ses(struct cifs_ses
*ses
)
3040 unsigned int rc
, xid
;
3041 struct TCP_Server_Info
*server
= ses
->server
;
3043 cifs_dbg(FYI
, "%s: ses_count=%d\n", __func__
, ses
->ses_count
);
3045 spin_lock(&cifs_tcp_ses_lock
);
3046 if (ses
->status
== CifsExiting
) {
3047 spin_unlock(&cifs_tcp_ses_lock
);
3050 if (--ses
->ses_count
> 0) {
3051 spin_unlock(&cifs_tcp_ses_lock
);
3054 if (ses
->status
== CifsGood
)
3055 ses
->status
= CifsExiting
;
3056 spin_unlock(&cifs_tcp_ses_lock
);
3060 if (ses
->status
== CifsExiting
&& server
->ops
->logoff
) {
3062 rc
= server
->ops
->logoff(xid
, ses
);
3064 cifs_server_dbg(VFS
, "%s: Session Logoff failure rc=%d\n",
3069 spin_lock(&cifs_tcp_ses_lock
);
3070 list_del_init(&ses
->smb_ses_list
);
3071 spin_unlock(&cifs_tcp_ses_lock
);
3073 /* close any extra channels */
3074 if (ses
->chan_count
> 1) {
3077 for (i
= 1; i
< ses
->chan_count
; i
++)
3078 cifs_put_tcp_session(ses
->chans
[i
].server
, 0);
3082 cifs_put_tcp_session(server
, 0);
3087 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
3088 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
3090 /* Populate username and pw fields from keyring if possible */
3092 cifs_set_cifscreds(struct smb_vol
*vol
, struct cifs_ses
*ses
)
3096 const char *delim
, *payload
;
3100 struct TCP_Server_Info
*server
= ses
->server
;
3101 struct sockaddr_in
*sa
;
3102 struct sockaddr_in6
*sa6
;
3103 const struct user_key_payload
*upayload
;
3105 desc
= kmalloc(CIFSCREDS_DESC_SIZE
, GFP_KERNEL
);
3109 /* try to find an address key first */
3110 switch (server
->dstaddr
.ss_family
) {
3112 sa
= (struct sockaddr_in
*)&server
->dstaddr
;
3113 sprintf(desc
, "cifs:a:%pI4", &sa
->sin_addr
.s_addr
);
3116 sa6
= (struct sockaddr_in6
*)&server
->dstaddr
;
3117 sprintf(desc
, "cifs:a:%pI6c", &sa6
->sin6_addr
.s6_addr
);
3120 cifs_dbg(FYI
, "Bad ss_family (%hu)\n",
3121 server
->dstaddr
.ss_family
);
3126 cifs_dbg(FYI
, "%s: desc=%s\n", __func__
, desc
);
3127 key
= request_key(&key_type_logon
, desc
, "");
3129 if (!ses
->domainName
) {
3130 cifs_dbg(FYI
, "domainName is NULL\n");
3135 /* didn't work, try to find a domain key */
3136 sprintf(desc
, "cifs:d:%s", ses
->domainName
);
3137 cifs_dbg(FYI
, "%s: desc=%s\n", __func__
, desc
);
3138 key
= request_key(&key_type_logon
, desc
, "");
3146 down_read(&key
->sem
);
3147 upayload
= user_key_payload_locked(key
);
3148 if (IS_ERR_OR_NULL(upayload
)) {
3149 rc
= upayload
? PTR_ERR(upayload
) : -EINVAL
;
3153 /* find first : in payload */
3154 payload
= upayload
->data
;
3155 delim
= strnchr(payload
, upayload
->datalen
, ':');
3156 cifs_dbg(FYI
, "payload=%s\n", payload
);
3158 cifs_dbg(FYI
, "Unable to find ':' in payload (datalen=%d)\n",
3164 len
= delim
- payload
;
3165 if (len
> CIFS_MAX_USERNAME_LEN
|| len
<= 0) {
3166 cifs_dbg(FYI
, "Bad value from username search (len=%zd)\n",
3172 vol
->username
= kstrndup(payload
, len
, GFP_KERNEL
);
3173 if (!vol
->username
) {
3174 cifs_dbg(FYI
, "Unable to allocate %zd bytes for username\n",
3179 cifs_dbg(FYI
, "%s: username=%s\n", __func__
, vol
->username
);
3181 len
= key
->datalen
- (len
+ 1);
3182 if (len
> CIFS_MAX_PASSWORD_LEN
|| len
<= 0) {
3183 cifs_dbg(FYI
, "Bad len for password search (len=%zd)\n", len
);
3185 kfree(vol
->username
);
3186 vol
->username
= NULL
;
3191 vol
->password
= kstrndup(delim
, len
, GFP_KERNEL
);
3192 if (!vol
->password
) {
3193 cifs_dbg(FYI
, "Unable to allocate %zd bytes for password\n",
3196 kfree(vol
->username
);
3197 vol
->username
= NULL
;
3202 * If we have a domain key then we must set the domainName in the
3205 if (is_domain
&& ses
->domainName
) {
3206 vol
->domainname
= kstrndup(ses
->domainName
,
3207 strlen(ses
->domainName
),
3209 if (!vol
->domainname
) {
3210 cifs_dbg(FYI
, "Unable to allocate %zd bytes for domain\n",
3213 kfree(vol
->username
);
3214 vol
->username
= NULL
;
3215 kfree_sensitive(vol
->password
);
3216 vol
->password
= NULL
;
3226 cifs_dbg(FYI
, "%s: returning %d\n", __func__
, rc
);
3229 #else /* ! CONFIG_KEYS */
3231 cifs_set_cifscreds(struct smb_vol
*vol
__attribute__((unused
)),
3232 struct cifs_ses
*ses
__attribute__((unused
)))
3236 #endif /* CONFIG_KEYS */
3239 * cifs_get_smb_ses - get a session matching @volume_info data from @server
3241 * This function assumes it is being called from cifs_mount() where we
3242 * already got a server reference (server refcount +1). See
3243 * cifs_get_tcon() for refcount explanations.
3246 cifs_get_smb_ses(struct TCP_Server_Info
*server
, struct smb_vol
*volume_info
)
3250 struct cifs_ses
*ses
;
3251 struct sockaddr_in
*addr
= (struct sockaddr_in
*)&server
->dstaddr
;
3252 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)&server
->dstaddr
;
3256 ses
= cifs_find_smb_ses(server
, volume_info
);
3258 cifs_dbg(FYI
, "Existing smb sess found (status=%d)\n",
3261 mutex_lock(&ses
->session_mutex
);
3262 rc
= cifs_negotiate_protocol(xid
, ses
);
3264 mutex_unlock(&ses
->session_mutex
);
3265 /* problem -- put our ses reference */
3266 cifs_put_smb_ses(ses
);
3270 if (ses
->need_reconnect
) {
3271 cifs_dbg(FYI
, "Session needs reconnect\n");
3272 rc
= cifs_setup_session(xid
, ses
,
3273 volume_info
->local_nls
);
3275 mutex_unlock(&ses
->session_mutex
);
3276 /* problem -- put our reference */
3277 cifs_put_smb_ses(ses
);
3282 mutex_unlock(&ses
->session_mutex
);
3284 /* existing SMB ses has a server reference already */
3285 cifs_put_tcp_session(server
, 0);
3290 cifs_dbg(FYI
, "Existing smb sess not found\n");
3291 ses
= sesInfoAlloc();
3295 /* new SMB session uses our server ref */
3296 ses
->server
= server
;
3297 if (server
->dstaddr
.ss_family
== AF_INET6
)
3298 sprintf(ses
->serverName
, "%pI6", &addr6
->sin6_addr
);
3300 sprintf(ses
->serverName
, "%pI4", &addr
->sin_addr
);
3302 if (volume_info
->username
) {
3303 ses
->user_name
= kstrdup(volume_info
->username
, GFP_KERNEL
);
3304 if (!ses
->user_name
)
3308 /* volume_info->password freed at unmount */
3309 if (volume_info
->password
) {
3310 ses
->password
= kstrdup(volume_info
->password
, GFP_KERNEL
);
3314 if (volume_info
->domainname
) {
3315 ses
->domainName
= kstrdup(volume_info
->domainname
, GFP_KERNEL
);
3316 if (!ses
->domainName
)
3319 if (volume_info
->domainauto
)
3320 ses
->domainAuto
= volume_info
->domainauto
;
3321 ses
->cred_uid
= volume_info
->cred_uid
;
3322 ses
->linux_uid
= volume_info
->linux_uid
;
3324 ses
->sectype
= volume_info
->sectype
;
3325 ses
->sign
= volume_info
->sign
;
3326 mutex_lock(&ses
->session_mutex
);
3328 /* add server as first channel */
3329 ses
->chans
[0].server
= server
;
3330 ses
->chan_count
= 1;
3331 ses
->chan_max
= volume_info
->multichannel
? volume_info
->max_channels
:1;
3333 rc
= cifs_negotiate_protocol(xid
, ses
);
3335 rc
= cifs_setup_session(xid
, ses
, volume_info
->local_nls
);
3337 /* each channel uses a different signing key */
3338 memcpy(ses
->chans
[0].signkey
, ses
->smb3signingkey
,
3339 sizeof(ses
->smb3signingkey
));
3341 mutex_unlock(&ses
->session_mutex
);
3345 /* success, put it on the list and add it as first channel */
3346 spin_lock(&cifs_tcp_ses_lock
);
3347 list_add(&ses
->smb_ses_list
, &server
->smb_ses_list
);
3348 spin_unlock(&cifs_tcp_ses_lock
);
3352 cifs_setup_ipc(ses
, volume_info
);
3362 static int match_tcon(struct cifs_tcon
*tcon
, struct smb_vol
*volume_info
)
3364 if (tcon
->tidStatus
== CifsExiting
)
3366 if (strncmp(tcon
->treeName
, volume_info
->UNC
, MAX_TREE_SIZE
))
3368 if (tcon
->seal
!= volume_info
->seal
)
3370 if (tcon
->snapshot_time
!= volume_info
->snapshot_time
)
3372 if (tcon
->handle_timeout
!= volume_info
->handle_timeout
)
3374 if (tcon
->no_lease
!= volume_info
->no_lease
)
3376 if (tcon
->nodelete
!= volume_info
->nodelete
)
3381 static struct cifs_tcon
*
3382 cifs_find_tcon(struct cifs_ses
*ses
, struct smb_vol
*volume_info
)
3384 struct list_head
*tmp
;
3385 struct cifs_tcon
*tcon
;
3387 spin_lock(&cifs_tcp_ses_lock
);
3388 list_for_each(tmp
, &ses
->tcon_list
) {
3389 tcon
= list_entry(tmp
, struct cifs_tcon
, tcon_list
);
3390 #ifdef CONFIG_CIFS_DFS_UPCALL
3394 if (!match_tcon(tcon
, volume_info
))
3397 spin_unlock(&cifs_tcp_ses_lock
);
3400 spin_unlock(&cifs_tcp_ses_lock
);
3405 cifs_put_tcon(struct cifs_tcon
*tcon
)
3408 struct cifs_ses
*ses
;
3411 * IPC tcon share the lifetime of their session and are
3412 * destroyed in the session put function
3414 if (tcon
== NULL
|| tcon
->ipc
)
3418 cifs_dbg(FYI
, "%s: tc_count=%d\n", __func__
, tcon
->tc_count
);
3419 spin_lock(&cifs_tcp_ses_lock
);
3420 if (--tcon
->tc_count
> 0) {
3421 spin_unlock(&cifs_tcp_ses_lock
);
3425 list_del_init(&tcon
->tcon_list
);
3426 spin_unlock(&cifs_tcp_ses_lock
);
3429 if (ses
->server
->ops
->tree_disconnect
)
3430 ses
->server
->ops
->tree_disconnect(xid
, tcon
);
3433 cifs_fscache_release_super_cookie(tcon
);
3435 cifs_put_smb_ses(ses
);
3439 * cifs_get_tcon - get a tcon matching @volume_info data from @ses
3441 * - tcon refcount is the number of mount points using the tcon.
3442 * - ses refcount is the number of tcon using the session.
3444 * 1. This function assumes it is being called from cifs_mount() where
3445 * we already got a session reference (ses refcount +1).
3447 * 2. Since we're in the context of adding a mount point, the end
3448 * result should be either:
3450 * a) a new tcon already allocated with refcount=1 (1 mount point) and
3451 * its session refcount incremented (1 new tcon). This +1 was
3452 * already done in (1).
3454 * b) an existing tcon with refcount+1 (add a mount point to it) and
3455 * identical ses refcount (no new tcon). Because of (1) we need to
3456 * decrement the ses refcount.
3458 static struct cifs_tcon
*
3459 cifs_get_tcon(struct cifs_ses
*ses
, struct smb_vol
*volume_info
)
3462 struct cifs_tcon
*tcon
;
3464 tcon
= cifs_find_tcon(ses
, volume_info
);
3467 * tcon has refcount already incremented but we need to
3468 * decrement extra ses reference gotten by caller (case b)
3470 cifs_dbg(FYI
, "Found match on UNC path\n");
3471 cifs_put_smb_ses(ses
);
3475 if (!ses
->server
->ops
->tree_connect
) {
3480 tcon
= tconInfoAlloc();
3486 if (volume_info
->snapshot_time
) {
3487 if (ses
->server
->vals
->protocol_id
== 0) {
3489 "Use SMB2 or later for snapshot mount option\n");
3493 tcon
->snapshot_time
= volume_info
->snapshot_time
;
3496 if (volume_info
->handle_timeout
) {
3497 if (ses
->server
->vals
->protocol_id
== 0) {
3499 "Use SMB2.1 or later for handle timeout option\n");
3503 tcon
->handle_timeout
= volume_info
->handle_timeout
;
3507 if (volume_info
->password
) {
3508 tcon
->password
= kstrdup(volume_info
->password
, GFP_KERNEL
);
3509 if (!tcon
->password
) {
3515 if (volume_info
->seal
) {
3516 if (ses
->server
->vals
->protocol_id
== 0) {
3518 "SMB3 or later required for encryption\n");
3521 } else if (tcon
->ses
->server
->capabilities
&
3522 SMB2_GLOBAL_CAP_ENCRYPTION
)
3525 cifs_dbg(VFS
, "Encryption is not supported on share\n");
3531 if (volume_info
->linux_ext
) {
3532 if (ses
->server
->posix_ext_supported
) {
3533 tcon
->posix_extensions
= true;
3534 pr_warn_once("SMB3.11 POSIX Extensions are experimental\n");
3536 cifs_dbg(VFS
, "Server does not support mounting with posix SMB3.11 extensions\n");
3543 * BB Do we need to wrap session_mutex around this TCon call and Unix
3544 * SetFS as we do on SessSetup and reconnect?
3547 rc
= ses
->server
->ops
->tree_connect(xid
, ses
, volume_info
->UNC
, tcon
,
3548 volume_info
->local_nls
);
3550 cifs_dbg(FYI
, "Tcon rc = %d\n", rc
);
3554 tcon
->use_persistent
= false;
3555 /* check if SMB2 or later, CIFS does not support persistent handles */
3556 if (volume_info
->persistent
) {
3557 if (ses
->server
->vals
->protocol_id
== 0) {
3559 "SMB3 or later required for persistent handles\n");
3562 } else if (ses
->server
->capabilities
&
3563 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES
)
3564 tcon
->use_persistent
= true;
3565 else /* persistent handles requested but not supported */ {
3567 "Persistent handles not supported on share\n");
3571 } else if ((tcon
->capabilities
& SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY
)
3572 && (ses
->server
->capabilities
& SMB2_GLOBAL_CAP_PERSISTENT_HANDLES
)
3573 && (volume_info
->nopersistent
== false)) {
3574 cifs_dbg(FYI
, "enabling persistent handles\n");
3575 tcon
->use_persistent
= true;
3576 } else if (volume_info
->resilient
) {
3577 if (ses
->server
->vals
->protocol_id
== 0) {
3579 "SMB2.1 or later required for resilient handles\n");
3583 tcon
->use_resilient
= true;
3586 /* If the user really knows what they are doing they can override */
3587 if (tcon
->share_flags
& SMB2_SHAREFLAG_NO_CACHING
) {
3588 if (volume_info
->cache_ro
)
3589 cifs_dbg(VFS
, "cache=ro requested on mount but NO_CACHING flag set on share\n");
3590 else if (volume_info
->cache_rw
)
3591 cifs_dbg(VFS
, "cache=singleclient requested on mount but NO_CACHING flag set on share\n");
3594 if (volume_info
->no_lease
) {
3595 if (ses
->server
->vals
->protocol_id
== 0) {
3597 "SMB2 or later required for nolease option\n");
3601 tcon
->no_lease
= volume_info
->no_lease
;
3605 * We can have only one retry value for a connection to a share so for
3606 * resources mounted more than once to the same server share the last
3607 * value passed in for the retry flag is used.
3609 tcon
->retry
= volume_info
->retry
;
3610 tcon
->nocase
= volume_info
->nocase
;
3611 tcon
->nohandlecache
= volume_info
->nohandlecache
;
3612 tcon
->nodelete
= volume_info
->nodelete
;
3613 tcon
->local_lease
= volume_info
->local_lease
;
3614 INIT_LIST_HEAD(&tcon
->pending_opens
);
3616 spin_lock(&cifs_tcp_ses_lock
);
3617 list_add(&tcon
->tcon_list
, &ses
->tcon_list
);
3618 spin_unlock(&cifs_tcp_ses_lock
);
3620 cifs_fscache_get_super_cookie(tcon
);
3630 cifs_put_tlink(struct tcon_link
*tlink
)
3632 if (!tlink
|| IS_ERR(tlink
))
3635 if (!atomic_dec_and_test(&tlink
->tl_count
) ||
3636 test_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
)) {
3637 tlink
->tl_time
= jiffies
;
3641 if (!IS_ERR(tlink_tcon(tlink
)))
3642 cifs_put_tcon(tlink_tcon(tlink
));
3648 compare_mount_options(struct super_block
*sb
, struct cifs_mnt_data
*mnt_data
)
3650 struct cifs_sb_info
*old
= CIFS_SB(sb
);
3651 struct cifs_sb_info
*new = mnt_data
->cifs_sb
;
3652 unsigned int oldflags
= old
->mnt_cifs_flags
& CIFS_MOUNT_MASK
;
3653 unsigned int newflags
= new->mnt_cifs_flags
& CIFS_MOUNT_MASK
;
3655 if ((sb
->s_flags
& CIFS_MS_MASK
) != (mnt_data
->flags
& CIFS_MS_MASK
))
3658 if (old
->mnt_cifs_serverino_autodisabled
)
3659 newflags
&= ~CIFS_MOUNT_SERVER_INUM
;
3661 if (oldflags
!= newflags
)
3665 * We want to share sb only if we don't specify an r/wsize or
3666 * specified r/wsize is greater than or equal to existing one.
3668 if (new->wsize
&& new->wsize
< old
->wsize
)
3671 if (new->rsize
&& new->rsize
< old
->rsize
)
3674 if (!uid_eq(old
->mnt_uid
, new->mnt_uid
) || !gid_eq(old
->mnt_gid
, new->mnt_gid
))
3677 if (old
->mnt_file_mode
!= new->mnt_file_mode
||
3678 old
->mnt_dir_mode
!= new->mnt_dir_mode
)
3681 if (strcmp(old
->local_nls
->charset
, new->local_nls
->charset
))
3684 if (old
->actimeo
!= new->actimeo
)
3691 match_prepath(struct super_block
*sb
, struct cifs_mnt_data
*mnt_data
)
3693 struct cifs_sb_info
*old
= CIFS_SB(sb
);
3694 struct cifs_sb_info
*new = mnt_data
->cifs_sb
;
3695 bool old_set
= (old
->mnt_cifs_flags
& CIFS_MOUNT_USE_PREFIX_PATH
) &&
3697 bool new_set
= (new->mnt_cifs_flags
& CIFS_MOUNT_USE_PREFIX_PATH
) &&
3700 if (old_set
&& new_set
&& !strcmp(new->prepath
, old
->prepath
))
3702 else if (!old_set
&& !new_set
)
3709 cifs_match_super(struct super_block
*sb
, void *data
)
3711 struct cifs_mnt_data
*mnt_data
= (struct cifs_mnt_data
*)data
;
3712 struct smb_vol
*volume_info
;
3713 struct cifs_sb_info
*cifs_sb
;
3714 struct TCP_Server_Info
*tcp_srv
;
3715 struct cifs_ses
*ses
;
3716 struct cifs_tcon
*tcon
;
3717 struct tcon_link
*tlink
;
3720 spin_lock(&cifs_tcp_ses_lock
);
3721 cifs_sb
= CIFS_SB(sb
);
3722 tlink
= cifs_get_tlink(cifs_sb_master_tlink(cifs_sb
));
3723 if (IS_ERR(tlink
)) {
3724 spin_unlock(&cifs_tcp_ses_lock
);
3727 tcon
= tlink_tcon(tlink
);
3729 tcp_srv
= ses
->server
;
3731 volume_info
= mnt_data
->vol
;
3733 if (!match_server(tcp_srv
, volume_info
) ||
3734 !match_session(ses
, volume_info
) ||
3735 !match_tcon(tcon
, volume_info
) ||
3736 !match_prepath(sb
, mnt_data
)) {
3741 rc
= compare_mount_options(sb
, mnt_data
);
3743 spin_unlock(&cifs_tcp_ses_lock
);
3744 cifs_put_tlink(tlink
);
3748 #ifdef CONFIG_DEBUG_LOCK_ALLOC
3749 static struct lock_class_key cifs_key
[2];
3750 static struct lock_class_key cifs_slock_key
[2];
3753 cifs_reclassify_socket4(struct socket
*sock
)
3755 struct sock
*sk
= sock
->sk
;
3756 BUG_ON(!sock_allow_reclassification(sk
));
3757 sock_lock_init_class_and_name(sk
, "slock-AF_INET-CIFS",
3758 &cifs_slock_key
[0], "sk_lock-AF_INET-CIFS", &cifs_key
[0]);
3762 cifs_reclassify_socket6(struct socket
*sock
)
3764 struct sock
*sk
= sock
->sk
;
3765 BUG_ON(!sock_allow_reclassification(sk
));
3766 sock_lock_init_class_and_name(sk
, "slock-AF_INET6-CIFS",
3767 &cifs_slock_key
[1], "sk_lock-AF_INET6-CIFS", &cifs_key
[1]);
3771 cifs_reclassify_socket4(struct socket
*sock
)
3776 cifs_reclassify_socket6(struct socket
*sock
)
3781 /* See RFC1001 section 14 on representation of Netbios names */
3782 static void rfc1002mangle(char *target
, char *source
, unsigned int length
)
3786 for (i
= 0, j
= 0; i
< (length
); i
++) {
3787 /* mask a nibble at a time and encode */
3788 target
[j
] = 'A' + (0x0F & (source
[i
] >> 4));
3789 target
[j
+1] = 'A' + (0x0F & source
[i
]);
3796 bind_socket(struct TCP_Server_Info
*server
)
3799 if (server
->srcaddr
.ss_family
!= AF_UNSPEC
) {
3800 /* Bind to the specified local IP address */
3801 struct socket
*socket
= server
->ssocket
;
3802 rc
= socket
->ops
->bind(socket
,
3803 (struct sockaddr
*) &server
->srcaddr
,
3804 sizeof(server
->srcaddr
));
3806 struct sockaddr_in
*saddr4
;
3807 struct sockaddr_in6
*saddr6
;
3808 saddr4
= (struct sockaddr_in
*)&server
->srcaddr
;
3809 saddr6
= (struct sockaddr_in6
*)&server
->srcaddr
;
3810 if (saddr6
->sin6_family
== AF_INET6
)
3811 cifs_server_dbg(VFS
, "Failed to bind to: %pI6c, error: %d\n",
3812 &saddr6
->sin6_addr
, rc
);
3814 cifs_server_dbg(VFS
, "Failed to bind to: %pI4, error: %d\n",
3815 &saddr4
->sin_addr
.s_addr
, rc
);
3822 ip_rfc1001_connect(struct TCP_Server_Info
*server
)
3826 * some servers require RFC1001 sessinit before sending
3827 * negprot - BB check reconnection in case where second
3828 * sessinit is sent but no second negprot
3830 struct rfc1002_session_packet
*ses_init_buf
;
3831 struct smb_hdr
*smb_buf
;
3832 ses_init_buf
= kzalloc(sizeof(struct rfc1002_session_packet
),
3835 ses_init_buf
->trailer
.session_req
.called_len
= 32;
3837 if (server
->server_RFC1001_name
[0] != 0)
3838 rfc1002mangle(ses_init_buf
->trailer
.
3839 session_req
.called_name
,
3840 server
->server_RFC1001_name
,
3841 RFC1001_NAME_LEN_WITH_NULL
);
3843 rfc1002mangle(ses_init_buf
->trailer
.
3844 session_req
.called_name
,
3845 DEFAULT_CIFS_CALLED_NAME
,
3846 RFC1001_NAME_LEN_WITH_NULL
);
3848 ses_init_buf
->trailer
.session_req
.calling_len
= 32;
3851 * calling name ends in null (byte 16) from old smb
3854 if (server
->workstation_RFC1001_name
[0] != 0)
3855 rfc1002mangle(ses_init_buf
->trailer
.
3856 session_req
.calling_name
,
3857 server
->workstation_RFC1001_name
,
3858 RFC1001_NAME_LEN_WITH_NULL
);
3860 rfc1002mangle(ses_init_buf
->trailer
.
3861 session_req
.calling_name
,
3863 RFC1001_NAME_LEN_WITH_NULL
);
3865 ses_init_buf
->trailer
.session_req
.scope1
= 0;
3866 ses_init_buf
->trailer
.session_req
.scope2
= 0;
3867 smb_buf
= (struct smb_hdr
*)ses_init_buf
;
3869 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3870 smb_buf
->smb_buf_length
= cpu_to_be32(0x81000044);
3871 rc
= smb_send(server
, smb_buf
, 0x44);
3872 kfree(ses_init_buf
);
3874 * RFC1001 layer in at least one server
3875 * requires very short break before negprot
3876 * presumably because not expecting negprot
3877 * to follow so fast. This is a simple
3878 * solution that works without
3879 * complicating the code and causes no
3880 * significant slowing down on mount
3883 usleep_range(1000, 2000);
3886 * else the negprot may still work without this
3887 * even though malloc failed
3894 generic_ip_connect(struct TCP_Server_Info
*server
)
3899 struct socket
*socket
= server
->ssocket
;
3900 struct sockaddr
*saddr
;
3902 saddr
= (struct sockaddr
*) &server
->dstaddr
;
3904 if (server
->dstaddr
.ss_family
== AF_INET6
) {
3905 struct sockaddr_in6
*ipv6
= (struct sockaddr_in6
*)&server
->dstaddr
;
3907 sport
= ipv6
->sin6_port
;
3908 slen
= sizeof(struct sockaddr_in6
);
3910 cifs_dbg(FYI
, "%s: connecting to [%pI6]:%d\n", __func__
, &ipv6
->sin6_addr
,
3913 struct sockaddr_in
*ipv4
= (struct sockaddr_in
*)&server
->dstaddr
;
3915 sport
= ipv4
->sin_port
;
3916 slen
= sizeof(struct sockaddr_in
);
3918 cifs_dbg(FYI
, "%s: connecting to %pI4:%d\n", __func__
, &ipv4
->sin_addr
,
3922 if (socket
== NULL
) {
3923 rc
= __sock_create(cifs_net_ns(server
), sfamily
, SOCK_STREAM
,
3924 IPPROTO_TCP
, &socket
, 1);
3926 cifs_server_dbg(VFS
, "Error %d creating socket\n", rc
);
3927 server
->ssocket
= NULL
;
3931 /* BB other socket options to set KEEPALIVE, NODELAY? */
3932 cifs_dbg(FYI
, "Socket created\n");
3933 server
->ssocket
= socket
;
3934 socket
->sk
->sk_allocation
= GFP_NOFS
;
3935 if (sfamily
== AF_INET6
)
3936 cifs_reclassify_socket6(socket
);
3938 cifs_reclassify_socket4(socket
);
3941 rc
= bind_socket(server
);
3946 * Eventually check for other socket options to change from
3947 * the default. sock_setsockopt not used because it expects
3950 socket
->sk
->sk_rcvtimeo
= 7 * HZ
;
3951 socket
->sk
->sk_sndtimeo
= 5 * HZ
;
3953 /* make the bufsizes depend on wsize/rsize and max requests */
3954 if (server
->noautotune
) {
3955 if (socket
->sk
->sk_sndbuf
< (200 * 1024))
3956 socket
->sk
->sk_sndbuf
= 200 * 1024;
3957 if (socket
->sk
->sk_rcvbuf
< (140 * 1024))
3958 socket
->sk
->sk_rcvbuf
= 140 * 1024;
3961 if (server
->tcp_nodelay
)
3962 tcp_sock_set_nodelay(socket
->sk
);
3964 cifs_dbg(FYI
, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3965 socket
->sk
->sk_sndbuf
,
3966 socket
->sk
->sk_rcvbuf
, socket
->sk
->sk_rcvtimeo
);
3968 rc
= socket
->ops
->connect(socket
, saddr
, slen
,
3969 server
->noblockcnt
? O_NONBLOCK
: 0);
3971 * When mounting SMB root file systems, we do not want to block in
3972 * connect. Otherwise bail out and then let cifs_reconnect() perform
3973 * reconnect failover - if possible.
3975 if (server
->noblockcnt
&& rc
== -EINPROGRESS
)
3978 cifs_dbg(FYI
, "Error %d connecting to server\n", rc
);
3979 sock_release(socket
);
3980 server
->ssocket
= NULL
;
3984 if (sport
== htons(RFC1001_PORT
))
3985 rc
= ip_rfc1001_connect(server
);
3991 ip_connect(struct TCP_Server_Info
*server
)
3994 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)&server
->dstaddr
;
3995 struct sockaddr_in
*addr
= (struct sockaddr_in
*)&server
->dstaddr
;
3997 if (server
->dstaddr
.ss_family
== AF_INET6
)
3998 sport
= &addr6
->sin6_port
;
4000 sport
= &addr
->sin_port
;
4005 /* try with 445 port at first */
4006 *sport
= htons(CIFS_PORT
);
4008 rc
= generic_ip_connect(server
);
4012 /* if it failed, try with 139 port */
4013 *sport
= htons(RFC1001_PORT
);
4016 return generic_ip_connect(server
);
4019 void reset_cifs_unix_caps(unsigned int xid
, struct cifs_tcon
*tcon
,
4020 struct cifs_sb_info
*cifs_sb
, struct smb_vol
*vol_info
)
4022 /* if we are reconnecting then should we check to see if
4023 * any requested capabilities changed locally e.g. via
4024 * remount but we can not do much about it here
4025 * if they have (even if we could detect it by the following)
4026 * Perhaps we could add a backpointer to array of sb from tcon
4027 * or if we change to make all sb to same share the same
4028 * sb as NFS - then we only have one backpointer to sb.
4029 * What if we wanted to mount the server share twice once with
4030 * and once without posixacls or posix paths? */
4031 __u64 saved_cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
4033 if (vol_info
&& vol_info
->no_linux_ext
) {
4034 tcon
->fsUnixInfo
.Capability
= 0;
4035 tcon
->unix_ext
= 0; /* Unix Extensions disabled */
4036 cifs_dbg(FYI
, "Linux protocol extensions disabled\n");
4038 } else if (vol_info
)
4039 tcon
->unix_ext
= 1; /* Unix Extensions supported */
4041 if (tcon
->unix_ext
== 0) {
4042 cifs_dbg(FYI
, "Unix extensions disabled so not set on reconnect\n");
4046 if (!CIFSSMBQFSUnixInfo(xid
, tcon
)) {
4047 __u64 cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
4048 cifs_dbg(FYI
, "unix caps which server supports %lld\n", cap
);
4049 /* check for reconnect case in which we do not
4050 want to change the mount behavior if we can avoid it */
4051 if (vol_info
== NULL
) {
4052 /* turn off POSIX ACL and PATHNAMES if not set
4053 originally at mount time */
4054 if ((saved_cap
& CIFS_UNIX_POSIX_ACL_CAP
) == 0)
4055 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
4056 if ((saved_cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
4057 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
4058 cifs_dbg(VFS
, "POSIXPATH support change\n");
4059 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
4060 } else if ((cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
4061 cifs_dbg(VFS
, "possible reconnect error\n");
4062 cifs_dbg(VFS
, "server disabled POSIX path support\n");
4066 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)
4067 cifs_dbg(VFS
, "per-share encryption not supported yet\n");
4069 cap
&= CIFS_UNIX_CAP_MASK
;
4070 if (vol_info
&& vol_info
->no_psx_acl
)
4071 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
4072 else if (CIFS_UNIX_POSIX_ACL_CAP
& cap
) {
4073 cifs_dbg(FYI
, "negotiated posix acl support\n");
4075 cifs_sb
->mnt_cifs_flags
|=
4076 CIFS_MOUNT_POSIXACL
;
4079 if (vol_info
&& vol_info
->posix_paths
== 0)
4080 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
4081 else if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) {
4082 cifs_dbg(FYI
, "negotiate posix pathnames\n");
4084 cifs_sb
->mnt_cifs_flags
|=
4085 CIFS_MOUNT_POSIX_PATHS
;
4088 cifs_dbg(FYI
, "Negotiate caps 0x%x\n", (int)cap
);
4089 #ifdef CONFIG_CIFS_DEBUG2
4090 if (cap
& CIFS_UNIX_FCNTL_CAP
)
4091 cifs_dbg(FYI
, "FCNTL cap\n");
4092 if (cap
& CIFS_UNIX_EXTATTR_CAP
)
4093 cifs_dbg(FYI
, "EXTATTR cap\n");
4094 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
4095 cifs_dbg(FYI
, "POSIX path cap\n");
4096 if (cap
& CIFS_UNIX_XATTR_CAP
)
4097 cifs_dbg(FYI
, "XATTR cap\n");
4098 if (cap
& CIFS_UNIX_POSIX_ACL_CAP
)
4099 cifs_dbg(FYI
, "POSIX ACL cap\n");
4100 if (cap
& CIFS_UNIX_LARGE_READ_CAP
)
4101 cifs_dbg(FYI
, "very large read cap\n");
4102 if (cap
& CIFS_UNIX_LARGE_WRITE_CAP
)
4103 cifs_dbg(FYI
, "very large write cap\n");
4104 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP
)
4105 cifs_dbg(FYI
, "transport encryption cap\n");
4106 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)
4107 cifs_dbg(FYI
, "mandatory transport encryption cap\n");
4108 #endif /* CIFS_DEBUG2 */
4109 if (CIFSSMBSetFSUnixInfo(xid
, tcon
, cap
)) {
4110 if (vol_info
== NULL
) {
4111 cifs_dbg(FYI
, "resetting capabilities failed\n");
4113 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");
4119 int cifs_setup_cifs_sb(struct smb_vol
*pvolume_info
,
4120 struct cifs_sb_info
*cifs_sb
)
4122 INIT_DELAYED_WORK(&cifs_sb
->prune_tlinks
, cifs_prune_tlinks
);
4124 spin_lock_init(&cifs_sb
->tlink_tree_lock
);
4125 cifs_sb
->tlink_tree
= RB_ROOT
;
4127 cifs_sb
->bsize
= pvolume_info
->bsize
;
4129 * Temporarily set r/wsize for matching superblock. If we end up using
4130 * new sb then client will later negotiate it downward if needed.
4132 cifs_sb
->rsize
= pvolume_info
->rsize
;
4133 cifs_sb
->wsize
= pvolume_info
->wsize
;
4135 cifs_sb
->mnt_uid
= pvolume_info
->linux_uid
;
4136 cifs_sb
->mnt_gid
= pvolume_info
->linux_gid
;
4137 cifs_sb
->mnt_file_mode
= pvolume_info
->file_mode
;
4138 cifs_sb
->mnt_dir_mode
= pvolume_info
->dir_mode
;
4139 cifs_dbg(FYI
, "file mode: %04ho dir mode: %04ho\n",
4140 cifs_sb
->mnt_file_mode
, cifs_sb
->mnt_dir_mode
);
4142 cifs_sb
->actimeo
= pvolume_info
->actimeo
;
4143 cifs_sb
->local_nls
= pvolume_info
->local_nls
;
4145 if (pvolume_info
->nodfs
)
4146 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_DFS
;
4147 if (pvolume_info
->noperm
)
4148 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_PERM
;
4149 if (pvolume_info
->setuids
)
4150 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SET_UID
;
4151 if (pvolume_info
->setuidfromacl
)
4152 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_UID_FROM_ACL
;
4153 if (pvolume_info
->server_ino
)
4154 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SERVER_INUM
;
4155 if (pvolume_info
->remap
)
4156 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MAP_SFM_CHR
;
4157 if (pvolume_info
->sfu_remap
)
4158 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MAP_SPECIAL_CHR
;
4159 if (pvolume_info
->no_xattr
)
4160 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_XATTR
;
4161 if (pvolume_info
->sfu_emul
)
4162 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_UNX_EMUL
;
4163 if (pvolume_info
->nobrl
)
4164 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_BRL
;
4165 if (pvolume_info
->nohandlecache
)
4166 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_HANDLE_CACHE
;
4167 if (pvolume_info
->nostrictsync
)
4168 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NOSSYNC
;
4169 if (pvolume_info
->mand_lock
)
4170 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NOPOSIXBRL
;
4171 if (pvolume_info
->rwpidforward
)
4172 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_RWPIDFORWARD
;
4173 if (pvolume_info
->mode_ace
)
4174 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MODE_FROM_SID
;
4175 if (pvolume_info
->cifs_acl
)
4176 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_ACL
;
4177 if (pvolume_info
->backupuid_specified
) {
4178 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_BACKUPUID
;
4179 cifs_sb
->mnt_backupuid
= pvolume_info
->backupuid
;
4181 if (pvolume_info
->backupgid_specified
) {
4182 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_BACKUPGID
;
4183 cifs_sb
->mnt_backupgid
= pvolume_info
->backupgid
;
4185 if (pvolume_info
->override_uid
)
4186 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_UID
;
4187 if (pvolume_info
->override_gid
)
4188 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_GID
;
4189 if (pvolume_info
->dynperm
)
4190 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DYNPERM
;
4191 if (pvolume_info
->fsc
)
4192 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_FSCACHE
;
4193 if (pvolume_info
->multiuser
)
4194 cifs_sb
->mnt_cifs_flags
|= (CIFS_MOUNT_MULTIUSER
|
4195 CIFS_MOUNT_NO_PERM
);
4196 if (pvolume_info
->strict_io
)
4197 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_STRICT_IO
;
4198 if (pvolume_info
->direct_io
) {
4199 cifs_dbg(FYI
, "mounting share using direct i/o\n");
4200 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DIRECT_IO
;
4202 if (pvolume_info
->cache_ro
) {
4203 cifs_dbg(VFS
, "mounting share with read only caching. Ensure that the share will not be modified while in use.\n");
4204 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_RO_CACHE
;
4205 } else if (pvolume_info
->cache_rw
) {
4206 cifs_dbg(VFS
, "mounting share in single client RW caching mode. Ensure that no other systems will be accessing the share.\n");
4207 cifs_sb
->mnt_cifs_flags
|= (CIFS_MOUNT_RO_CACHE
|
4208 CIFS_MOUNT_RW_CACHE
);
4210 if (pvolume_info
->mfsymlinks
) {
4211 if (pvolume_info
->sfu_emul
) {
4213 * Our SFU ("Services for Unix" emulation does not allow
4214 * creating symlinks but does allow reading existing SFU
4215 * symlinks (it does allow both creating and reading SFU
4216 * style mknod and FIFOs though). When "mfsymlinks" and
4217 * "sfu" are both enabled at the same time, it allows
4218 * reading both types of symlinks, but will only create
4219 * them with mfsymlinks format. This allows better
4220 * Apple compatibility (probably better for Samba too)
4221 * while still recognizing old Windows style symlinks.
4223 cifs_dbg(VFS
, "mount options mfsymlinks and sfu both enabled\n");
4225 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MF_SYMLINKS
;
4228 if ((pvolume_info
->cifs_acl
) && (pvolume_info
->dynperm
))
4229 cifs_dbg(VFS
, "mount option dynperm ignored if cifsacl mount option supported\n");
4231 if (pvolume_info
->prepath
) {
4232 cifs_sb
->prepath
= kstrdup(pvolume_info
->prepath
, GFP_KERNEL
);
4233 if (cifs_sb
->prepath
== NULL
)
4241 cifs_cleanup_volume_info_contents(struct smb_vol
*volume_info
)
4243 kfree(volume_info
->username
);
4244 kfree_sensitive(volume_info
->password
);
4245 kfree(volume_info
->UNC
);
4246 kfree(volume_info
->domainname
);
4247 kfree(volume_info
->iocharset
);
4248 kfree(volume_info
->prepath
);
4252 cifs_cleanup_volume_info(struct smb_vol
*volume_info
)
4256 cifs_cleanup_volume_info_contents(volume_info
);
4260 /* Release all succeed connections */
4261 static inline void mount_put_conns(struct cifs_sb_info
*cifs_sb
,
4263 struct TCP_Server_Info
*server
,
4264 struct cifs_ses
*ses
, struct cifs_tcon
*tcon
)
4269 cifs_put_tcon(tcon
);
4271 cifs_put_smb_ses(ses
);
4273 cifs_put_tcp_session(server
, 0);
4274 cifs_sb
->mnt_cifs_flags
&= ~CIFS_MOUNT_POSIX_PATHS
;
4278 /* Get connections for tcp, ses and tcon */
4279 static int mount_get_conns(struct smb_vol
*vol
, struct cifs_sb_info
*cifs_sb
,
4281 struct TCP_Server_Info
**nserver
,
4282 struct cifs_ses
**nses
, struct cifs_tcon
**ntcon
)
4285 struct TCP_Server_Info
*server
;
4286 struct cifs_ses
*ses
;
4287 struct cifs_tcon
*tcon
;
4295 /* get a reference to a tcp session */
4296 server
= cifs_get_tcp_session(vol
);
4297 if (IS_ERR(server
)) {
4298 rc
= PTR_ERR(server
);
4304 if ((vol
->max_credits
< 20) || (vol
->max_credits
> 60000))
4305 server
->max_credits
= SMB2_MAX_CREDITS_AVAILABLE
;
4307 server
->max_credits
= vol
->max_credits
;
4309 /* get a reference to a SMB session */
4310 ses
= cifs_get_smb_ses(server
, vol
);
4318 if ((vol
->persistent
== true) && (!(ses
->server
->capabilities
&
4319 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES
))) {
4320 cifs_server_dbg(VFS
, "persistent handles not supported by server\n");
4324 /* search for existing tcon to this server share */
4325 tcon
= cifs_get_tcon(ses
, vol
);
4333 /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
4334 if (tcon
->posix_extensions
)
4335 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_POSIX_PATHS
;
4337 /* tell server which Unix caps we support */
4338 if (cap_unix(tcon
->ses
)) {
4340 * reset of caps checks mount to see if unix extensions disabled
4341 * for just this mount.
4343 reset_cifs_unix_caps(*xid
, tcon
, cifs_sb
, vol
);
4344 if ((tcon
->ses
->server
->tcpStatus
== CifsNeedReconnect
) &&
4345 (le64_to_cpu(tcon
->fsUnixInfo
.Capability
) &
4346 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
))
4349 tcon
->unix_ext
= 0; /* server does not support them */
4351 /* do not care if a following call succeed - informational */
4352 if (!tcon
->pipe
&& server
->ops
->qfs_tcon
) {
4353 server
->ops
->qfs_tcon(*xid
, tcon
, cifs_sb
);
4354 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RO_CACHE
) {
4355 if (tcon
->fsDevInfo
.DeviceCharacteristics
&
4356 cpu_to_le32(FILE_READ_ONLY_DEVICE
))
4357 cifs_dbg(VFS
, "mounted to read only share\n");
4358 else if ((cifs_sb
->mnt_cifs_flags
&
4359 CIFS_MOUNT_RW_CACHE
) == 0)
4360 cifs_dbg(VFS
, "read only mount of RW share\n");
4361 /* no need to log a RW mount of a typical RW share */
4365 cifs_sb
->wsize
= server
->ops
->negotiate_wsize(tcon
, vol
);
4366 cifs_sb
->rsize
= server
->ops
->negotiate_rsize(tcon
, vol
);
4371 static int mount_setup_tlink(struct cifs_sb_info
*cifs_sb
, struct cifs_ses
*ses
,
4372 struct cifs_tcon
*tcon
)
4374 struct tcon_link
*tlink
;
4376 /* hang the tcon off of the superblock */
4377 tlink
= kzalloc(sizeof(*tlink
), GFP_KERNEL
);
4381 tlink
->tl_uid
= ses
->linux_uid
;
4382 tlink
->tl_tcon
= tcon
;
4383 tlink
->tl_time
= jiffies
;
4384 set_bit(TCON_LINK_MASTER
, &tlink
->tl_flags
);
4385 set_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
4387 cifs_sb
->master_tlink
= tlink
;
4388 spin_lock(&cifs_sb
->tlink_tree_lock
);
4389 tlink_rb_insert(&cifs_sb
->tlink_tree
, tlink
);
4390 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4392 queue_delayed_work(cifsiod_wq
, &cifs_sb
->prune_tlinks
,
4397 #ifdef CONFIG_CIFS_DFS_UPCALL
4399 * cifs_build_path_to_root returns full path to root when we do not have an
4400 * exiting connection (tcon)
4403 build_unc_path_to_root(const struct smb_vol
*vol
,
4404 const struct cifs_sb_info
*cifs_sb
, bool useppath
)
4406 char *full_path
, *pos
;
4407 unsigned int pplen
= useppath
&& vol
->prepath
?
4408 strlen(vol
->prepath
) + 1 : 0;
4409 unsigned int unc_len
= strnlen(vol
->UNC
, MAX_TREE_SIZE
+ 1);
4411 if (unc_len
> MAX_TREE_SIZE
)
4412 return ERR_PTR(-EINVAL
);
4414 full_path
= kmalloc(unc_len
+ pplen
+ 1, GFP_KERNEL
);
4415 if (full_path
== NULL
)
4416 return ERR_PTR(-ENOMEM
);
4418 memcpy(full_path
, vol
->UNC
, unc_len
);
4419 pos
= full_path
+ unc_len
;
4422 *pos
= CIFS_DIR_SEP(cifs_sb
);
4423 memcpy(pos
+ 1, vol
->prepath
, pplen
);
4427 *pos
= '\0'; /* add trailing null */
4428 convert_delimiter(full_path
, CIFS_DIR_SEP(cifs_sb
));
4429 cifs_dbg(FYI
, "%s: full_path=%s\n", __func__
, full_path
);
4434 * expand_dfs_referral - Perform a dfs referral query and update the cifs_sb
4437 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
4438 * to a string containing updated options for the submount. Otherwise it
4439 * will be left untouched.
4441 * Returns the rc from get_dfs_path to the caller, which can be used to
4442 * determine whether there were referrals.
4445 expand_dfs_referral(const unsigned int xid
, struct cifs_ses
*ses
,
4446 struct smb_vol
*volume_info
, struct cifs_sb_info
*cifs_sb
,
4450 struct dfs_info3_param referral
= {0};
4451 char *full_path
= NULL
, *mdata
= NULL
;
4453 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_DFS
)
4456 full_path
= build_unc_path_to_root(volume_info
, cifs_sb
, true);
4457 if (IS_ERR(full_path
))
4458 return PTR_ERR(full_path
);
4460 rc
= dfs_cache_find(xid
, ses
, cifs_sb
->local_nls
, cifs_remap(cifs_sb
),
4461 ref_path
, &referral
, NULL
);
4463 char *fake_devname
= NULL
;
4465 mdata
= cifs_compose_mount_options(cifs_sb
->mountdata
,
4466 full_path
+ 1, &referral
,
4468 free_dfs_info_param(&referral
);
4470 if (IS_ERR(mdata
)) {
4471 rc
= PTR_ERR(mdata
);
4474 cifs_cleanup_volume_info_contents(volume_info
);
4475 rc
= cifs_setup_volume_info(volume_info
, mdata
,
4476 fake_devname
, false);
4478 kfree(fake_devname
);
4479 kfree(cifs_sb
->mountdata
);
4480 cifs_sb
->mountdata
= mdata
;
4486 static inline int get_next_dfs_tgt(const char *path
,
4487 struct dfs_cache_tgt_list
*tgt_list
,
4488 struct dfs_cache_tgt_iterator
**tgt_it
)
4491 *tgt_it
= dfs_cache_get_tgt_iterator(tgt_list
);
4493 *tgt_it
= dfs_cache_get_next_tgt(tgt_list
, *tgt_it
);
4494 return !*tgt_it
? -EHOSTDOWN
: 0;
4497 static int update_vol_info(const struct dfs_cache_tgt_iterator
*tgt_it
,
4498 struct smb_vol
*fake_vol
, struct smb_vol
*vol
)
4500 const char *tgt
= dfs_cache_get_tgt_name(tgt_it
);
4501 int len
= strlen(tgt
) + 2;
4504 new_unc
= kmalloc(len
, GFP_KERNEL
);
4507 scnprintf(new_unc
, len
, "\\%s", tgt
);
4512 if (fake_vol
->prepath
) {
4513 kfree(vol
->prepath
);
4514 vol
->prepath
= fake_vol
->prepath
;
4515 fake_vol
->prepath
= NULL
;
4517 memcpy(&vol
->dstaddr
, &fake_vol
->dstaddr
, sizeof(vol
->dstaddr
));
4522 static int setup_dfs_tgt_conn(const char *path
, const char *full_path
,
4523 const struct dfs_cache_tgt_iterator
*tgt_it
,
4524 struct cifs_sb_info
*cifs_sb
, struct smb_vol
*vol
, unsigned int *xid
,
4525 struct TCP_Server_Info
**server
, struct cifs_ses
**ses
,
4526 struct cifs_tcon
**tcon
)
4529 struct dfs_info3_param ref
= {0};
4530 char *mdata
= NULL
, *fake_devname
= NULL
;
4531 struct smb_vol fake_vol
= {NULL
};
4533 cifs_dbg(FYI
, "%s: dfs path: %s\n", __func__
, path
);
4535 rc
= dfs_cache_get_tgt_referral(path
, tgt_it
, &ref
);
4539 mdata
= cifs_compose_mount_options(cifs_sb
->mountdata
, full_path
+ 1, &ref
, &fake_devname
);
4540 free_dfs_info_param(&ref
);
4542 if (IS_ERR(mdata
)) {
4543 rc
= PTR_ERR(mdata
);
4546 cifs_dbg(FYI
, "%s: fake_devname: %s\n", __func__
, fake_devname
);
4547 rc
= cifs_setup_volume_info(&fake_vol
, mdata
, fake_devname
,
4551 kfree(fake_devname
);
4555 * We use a 'fake_vol' here because we need pass it down to the
4556 * mount_{get,put} functions to test connection against new DFS
4559 mount_put_conns(cifs_sb
, *xid
, *server
, *ses
, *tcon
);
4560 rc
= mount_get_conns(&fake_vol
, cifs_sb
, xid
, server
, ses
,
4562 if (!rc
|| (*server
&& *ses
)) {
4564 * We were able to connect to new target server.
4565 * Update current volume info with new target server.
4567 rc
= update_vol_info(tgt_it
, &fake_vol
, vol
);
4570 cifs_cleanup_volume_info_contents(&fake_vol
);
4574 static int do_dfs_failover(const char *path
, const char *full_path
, struct cifs_sb_info
*cifs_sb
,
4575 struct smb_vol
*vol
, struct cifs_ses
*root_ses
, unsigned int *xid
,
4576 struct TCP_Server_Info
**server
, struct cifs_ses
**ses
,
4577 struct cifs_tcon
**tcon
)
4580 struct dfs_cache_tgt_list tgt_list
;
4581 struct dfs_cache_tgt_iterator
*tgt_it
= NULL
;
4583 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_DFS
)
4586 rc
= dfs_cache_noreq_find(path
, NULL
, &tgt_list
);
4591 /* Get next DFS target server - if any */
4592 rc
= get_next_dfs_tgt(path
, &tgt_list
, &tgt_it
);
4595 /* Connect to next DFS target */
4596 rc
= setup_dfs_tgt_conn(path
, full_path
, tgt_it
, cifs_sb
, vol
, xid
, server
, ses
,
4598 if (!rc
|| (*server
&& *ses
))
4603 * Update DFS target hint in DFS referral cache with the target
4604 * server we successfully reconnected to.
4606 rc
= dfs_cache_update_tgthint(*xid
, root_ses
? root_ses
: *ses
,
4608 cifs_remap(cifs_sb
), path
,
4611 dfs_cache_free_tgts(&tgt_list
);
4617 cifs_setup_volume_info(struct smb_vol
*volume_info
, char *mount_data
,
4618 const char *devname
, bool is_smb3
)
4622 if (cifs_parse_mount_options(mount_data
, devname
, volume_info
, is_smb3
))
4625 if (volume_info
->nullauth
) {
4626 cifs_dbg(FYI
, "Anonymous login\n");
4627 kfree(volume_info
->username
);
4628 volume_info
->username
= NULL
;
4629 } else if (volume_info
->username
) {
4630 /* BB fixme parse for domain name here */
4631 cifs_dbg(FYI
, "Username: %s\n", volume_info
->username
);
4633 cifs_dbg(VFS
, "No username specified\n");
4634 /* In userspace mount helper we can get user name from alternate
4635 locations such as env variables and files on disk */
4639 /* this is needed for ASCII cp to Unicode converts */
4640 if (volume_info
->iocharset
== NULL
) {
4641 /* load_nls_default cannot return null */
4642 volume_info
->local_nls
= load_nls_default();
4644 volume_info
->local_nls
= load_nls(volume_info
->iocharset
);
4645 if (volume_info
->local_nls
== NULL
) {
4646 cifs_dbg(VFS
, "CIFS mount error: iocharset %s not found\n",
4647 volume_info
->iocharset
);
4656 cifs_get_volume_info(char *mount_data
, const char *devname
, bool is_smb3
)
4659 struct smb_vol
*volume_info
;
4661 volume_info
= kmalloc(sizeof(struct smb_vol
), GFP_KERNEL
);
4663 return ERR_PTR(-ENOMEM
);
4665 rc
= cifs_setup_volume_info(volume_info
, mount_data
, devname
, is_smb3
);
4667 cifs_cleanup_volume_info(volume_info
);
4668 volume_info
= ERR_PTR(rc
);
4675 cifs_are_all_path_components_accessible(struct TCP_Server_Info
*server
,
4677 struct cifs_tcon
*tcon
,
4678 struct cifs_sb_info
*cifs_sb
,
4685 int skip
= added_treename
? 1 : 0;
4687 sep
= CIFS_DIR_SEP(cifs_sb
);
4690 rc
= server
->ops
->is_path_accessible(xid
, tcon
, cifs_sb
, "");
4692 /* skip separators */
4697 /* next separator */
4698 while (*s
&& *s
!= sep
)
4701 * if the treename is added, we then have to skip the first
4702 * part within the separators
4709 * temporarily null-terminate the path at the end of
4710 * the current component
4714 rc
= server
->ops
->is_path_accessible(xid
, tcon
, cifs_sb
,
4722 * Check if path is remote (e.g. a DFS share). Return -EREMOTE if it is,
4725 static int is_path_remote(struct cifs_sb_info
*cifs_sb
, struct smb_vol
*vol
,
4726 const unsigned int xid
,
4727 struct TCP_Server_Info
*server
,
4728 struct cifs_tcon
*tcon
)
4733 if (!server
->ops
->is_path_accessible
)
4737 * cifs_build_path_to_root works only when we have a valid tcon
4739 full_path
= cifs_build_path_to_root(vol
, cifs_sb
, tcon
,
4740 tcon
->Flags
& SMB_SHARE_IS_IN_DFS
);
4741 if (full_path
== NULL
)
4744 cifs_dbg(FYI
, "%s: full_path: %s\n", __func__
, full_path
);
4746 rc
= server
->ops
->is_path_accessible(xid
, tcon
, cifs_sb
,
4748 if (rc
!= 0 && rc
!= -EREMOTE
) {
4753 if (rc
!= -EREMOTE
) {
4754 rc
= cifs_are_all_path_components_accessible(server
, xid
, tcon
,
4755 cifs_sb
, full_path
, tcon
->Flags
& SMB_SHARE_IS_IN_DFS
);
4757 cifs_server_dbg(VFS
, "cannot query dirs between root and final path, enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
4758 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_USE_PREFIX_PATH
;
4767 #ifdef CONFIG_CIFS_DFS_UPCALL
4768 static void set_root_ses(struct cifs_sb_info
*cifs_sb
, struct cifs_ses
*ses
,
4769 struct cifs_ses
**root_ses
)
4772 spin_lock(&cifs_tcp_ses_lock
);
4774 ses
->tcon_ipc
->remap
= cifs_remap(cifs_sb
);
4775 spin_unlock(&cifs_tcp_ses_lock
);
4780 static void put_root_ses(struct cifs_ses
*ses
)
4783 cifs_put_smb_ses(ses
);
4786 /* Check if a path component is remote and then update @dfs_path accordingly */
4787 static int check_dfs_prepath(struct cifs_sb_info
*cifs_sb
, struct smb_vol
*vol
,
4788 const unsigned int xid
, struct TCP_Server_Info
*server
,
4789 struct cifs_tcon
*tcon
, char **dfs_path
)
4792 char sep
= CIFS_DIR_SEP(cifs_sb
), tmp
;
4795 int added_treename
= tcon
->Flags
& SMB_SHARE_IS_IN_DFS
;
4796 int skip
= added_treename
;
4798 path
= cifs_build_path_to_root(vol
, cifs_sb
, tcon
, added_treename
);
4803 * Walk through the path components in @path and check if they're accessible. In case any of
4804 * the components is -EREMOTE, then update @dfs_path with the next DFS referral request path
4805 * (NOT including the remaining components).
4809 /* skip separators */
4810 while (*s
&& *s
== sep
)
4814 /* next separator */
4815 while (*s
&& *s
!= sep
)
4818 * if the treename is added, we then have to skip the first
4819 * part within the separators
4827 rc
= server
->ops
->is_path_accessible(xid
, tcon
, cifs_sb
, path
);
4828 if (rc
&& rc
== -EREMOTE
) {
4829 struct smb_vol v
= {NULL
};
4830 /* if @path contains a tree name, skip it in the prefix path */
4831 if (added_treename
) {
4832 rc
= cifs_parse_devname(path
, &v
);
4836 npath
= build_unc_path_to_root(&v
, cifs_sb
, true);
4837 cifs_cleanup_volume_info_contents(&v
);
4840 v
.prepath
= path
+ 1;
4841 npath
= build_unc_path_to_root(&v
, cifs_sb
, true);
4843 if (IS_ERR(npath
)) {
4844 rc
= PTR_ERR(npath
);
4857 int cifs_mount(struct cifs_sb_info
*cifs_sb
, struct smb_vol
*vol
)
4861 struct TCP_Server_Info
*server
= NULL
;
4862 struct cifs_ses
*ses
= NULL
, *root_ses
= NULL
;
4863 struct cifs_tcon
*tcon
= NULL
;
4865 char *ref_path
= NULL
, *full_path
= NULL
;
4866 char *oldmnt
= NULL
;
4867 char *mntdata
= NULL
;
4869 rc
= mount_get_conns(vol
, cifs_sb
, &xid
, &server
, &ses
, &tcon
);
4871 * Unconditionally try to get an DFS referral (even cached) to determine whether it is an
4874 * Skip prefix path to provide support for DFS referrals from w2k8 servers which don't seem
4875 * to respond with PATH_NOT_COVERED to requests that include the prefix.
4877 if (dfs_cache_find(xid
, ses
, cifs_sb
->local_nls
, cifs_remap(cifs_sb
), vol
->UNC
+ 1, NULL
,
4879 /* No DFS referral was returned. Looks like a regular share. */
4882 /* Check if it is fully accessible and then mount it */
4883 rc
= is_path_remote(cifs_sb
, vol
, xid
, server
, tcon
);
4889 /* Save mount options */
4890 mntdata
= kstrndup(cifs_sb
->mountdata
, strlen(cifs_sb
->mountdata
), GFP_KERNEL
);
4895 /* Get path of DFS root */
4896 ref_path
= build_unc_path_to_root(vol
, cifs_sb
, false);
4897 if (IS_ERR(ref_path
)) {
4898 rc
= PTR_ERR(ref_path
);
4903 set_root_ses(cifs_sb
, ses
, &root_ses
);
4905 /* Save full path of last DFS path we used to resolve final target server */
4907 full_path
= build_unc_path_to_root(vol
, cifs_sb
, !!count
);
4908 if (IS_ERR(full_path
)) {
4909 rc
= PTR_ERR(full_path
);
4913 /* Chase referral */
4914 oldmnt
= cifs_sb
->mountdata
;
4915 rc
= expand_dfs_referral(xid
, root_ses
, vol
, cifs_sb
, ref_path
+ 1);
4918 /* Connect to new DFS target only if we were redirected */
4919 if (oldmnt
!= cifs_sb
->mountdata
) {
4920 mount_put_conns(cifs_sb
, xid
, server
, ses
, tcon
);
4921 rc
= mount_get_conns(vol
, cifs_sb
, &xid
, &server
, &ses
, &tcon
);
4923 if (rc
&& !server
&& !ses
) {
4924 /* Failed to connect. Try to connect to other targets in the referral. */
4925 rc
= do_dfs_failover(ref_path
+ 1, full_path
, cifs_sb
, vol
, root_ses
, &xid
,
4926 &server
, &ses
, &tcon
);
4928 if (rc
== -EACCES
|| rc
== -EOPNOTSUPP
|| !server
|| !ses
)
4932 /* Make sure that requests go through new root servers */
4933 if (is_tcon_dfs(tcon
)) {
4934 put_root_ses(root_ses
);
4935 set_root_ses(cifs_sb
, ses
, &root_ses
);
4937 /* Check for remaining path components and then continue chasing them (-EREMOTE) */
4938 rc
= check_dfs_prepath(cifs_sb
, vol
, xid
, server
, tcon
, &ref_path
);
4939 /* Prevent recursion on broken link referrals */
4940 if (rc
== -EREMOTE
&& ++count
> MAX_NESTED_LINKS
)
4942 } while (rc
== -EREMOTE
);
4946 put_root_ses(root_ses
);
4951 * Store DFS full path in both superblock and tree connect structures.
4953 * For DFS root mounts, the prefix path (cifs_sb->prepath) is preserved during reconnect so
4954 * only the root path is set in cifs_sb->origin_fullpath and tcon->dfs_path. And for DFS
4955 * links, the prefix path is included in both and may be changed during reconnect. See
4956 * cifs_tree_connect().
4958 cifs_sb
->origin_fullpath
= kstrndup(full_path
, strlen(full_path
), GFP_KERNEL
);
4959 if (!cifs_sb
->origin_fullpath
) {
4963 spin_lock(&cifs_tcp_ses_lock
);
4964 tcon
->dfs_path
= full_path
;
4966 tcon
->remap
= cifs_remap(cifs_sb
);
4967 spin_unlock(&cifs_tcp_ses_lock
);
4969 /* Add original volume information for DFS cache to be used when refreshing referrals */
4970 rc
= dfs_cache_add_vol(mntdata
, vol
, cifs_sb
->origin_fullpath
);
4974 * After reconnecting to a different server, unique ids won't
4975 * match anymore, so we disable serverino. This prevents
4976 * dentry revalidation to think the dentry are stale (ESTALE).
4978 cifs_autodisable_serverino(cifs_sb
);
4980 * Force the use of prefix path to support failover on DFS paths that
4981 * resolve to targets that have different prefix paths.
4983 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_USE_PREFIX_PATH
;
4984 kfree(cifs_sb
->prepath
);
4985 cifs_sb
->prepath
= vol
->prepath
;
4986 vol
->prepath
= NULL
;
4990 cifs_try_adding_channels(ses
);
4991 return mount_setup_tlink(cifs_sb
, ses
, tcon
);
4997 kfree(cifs_sb
->origin_fullpath
);
4998 put_root_ses(root_ses
);
4999 mount_put_conns(cifs_sb
, xid
, server
, ses
, tcon
);
5003 int cifs_mount(struct cifs_sb_info
*cifs_sb
, struct smb_vol
*vol
)
5007 struct cifs_ses
*ses
;
5008 struct cifs_tcon
*tcon
;
5009 struct TCP_Server_Info
*server
;
5011 rc
= mount_get_conns(vol
, cifs_sb
, &xid
, &server
, &ses
, &tcon
);
5016 rc
= is_path_remote(cifs_sb
, vol
, xid
, server
, tcon
);
5025 return mount_setup_tlink(cifs_sb
, ses
, tcon
);
5028 mount_put_conns(cifs_sb
, xid
, server
, ses
, tcon
);
5034 * Issue a TREE_CONNECT request.
5037 CIFSTCon(const unsigned int xid
, struct cifs_ses
*ses
,
5038 const char *tree
, struct cifs_tcon
*tcon
,
5039 const struct nls_table
*nls_codepage
)
5041 struct smb_hdr
*smb_buffer
;
5042 struct smb_hdr
*smb_buffer_response
;
5045 unsigned char *bcc_ptr
;
5048 __u16 bytes_left
, count
;
5053 smb_buffer
= cifs_buf_get();
5054 if (smb_buffer
== NULL
)
5057 smb_buffer_response
= smb_buffer
;
5059 header_assemble(smb_buffer
, SMB_COM_TREE_CONNECT_ANDX
,
5060 NULL
/*no tid */ , 4 /*wct */ );
5062 smb_buffer
->Mid
= get_next_mid(ses
->server
);
5063 smb_buffer
->Uid
= ses
->Suid
;
5064 pSMB
= (TCONX_REQ
*) smb_buffer
;
5065 pSMBr
= (TCONX_RSP
*) smb_buffer_response
;
5067 pSMB
->AndXCommand
= 0xFF;
5068 pSMB
->Flags
= cpu_to_le16(TCON_EXTENDED_SECINFO
);
5069 bcc_ptr
= &pSMB
->Password
[0];
5070 if (tcon
->pipe
|| (ses
->server
->sec_mode
& SECMODE_USER
)) {
5071 pSMB
->PasswordLength
= cpu_to_le16(1); /* minimum */
5072 *bcc_ptr
= 0; /* password is null byte */
5073 bcc_ptr
++; /* skip password */
5074 /* already aligned so no need to do it below */
5076 pSMB
->PasswordLength
= cpu_to_le16(CIFS_AUTH_RESP_SIZE
);
5077 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
5078 specified as required (when that support is added to
5079 the vfs in the future) as only NTLM or the much
5080 weaker LANMAN (which we do not send by default) is accepted
5081 by Samba (not sure whether other servers allow
5082 NTLMv2 password here) */
5083 #ifdef CONFIG_CIFS_WEAK_PW_HASH
5084 if ((global_secflags
& CIFSSEC_MAY_LANMAN
) &&
5085 (ses
->sectype
== LANMAN
))
5086 calc_lanman_hash(tcon
->password
, ses
->server
->cryptkey
,
5087 ses
->server
->sec_mode
&
5088 SECMODE_PW_ENCRYPT
? true : false,
5091 #endif /* CIFS_WEAK_PW_HASH */
5092 rc
= SMBNTencrypt(tcon
->password
, ses
->server
->cryptkey
,
5093 bcc_ptr
, nls_codepage
);
5095 cifs_dbg(FYI
, "%s Can't generate NTLM rsp. Error: %d\n",
5097 cifs_buf_release(smb_buffer
);
5101 bcc_ptr
+= CIFS_AUTH_RESP_SIZE
;
5102 if (ses
->capabilities
& CAP_UNICODE
) {
5103 /* must align unicode strings */
5104 *bcc_ptr
= 0; /* null byte password */
5109 if (ses
->server
->sign
)
5110 smb_buffer
->Flags2
|= SMBFLG2_SECURITY_SIGNATURE
;
5112 if (ses
->capabilities
& CAP_STATUS32
) {
5113 smb_buffer
->Flags2
|= SMBFLG2_ERR_STATUS
;
5115 if (ses
->capabilities
& CAP_DFS
) {
5116 smb_buffer
->Flags2
|= SMBFLG2_DFS
;
5118 if (ses
->capabilities
& CAP_UNICODE
) {
5119 smb_buffer
->Flags2
|= SMBFLG2_UNICODE
;
5121 cifs_strtoUTF16((__le16
*) bcc_ptr
, tree
,
5122 6 /* max utf8 char length in bytes */ *
5123 (/* server len*/ + 256 /* share len */), nls_codepage
);
5124 bcc_ptr
+= 2 * length
; /* convert num 16 bit words to bytes */
5125 bcc_ptr
+= 2; /* skip trailing null */
5126 } else { /* ASCII */
5127 strcpy(bcc_ptr
, tree
);
5128 bcc_ptr
+= strlen(tree
) + 1;
5130 strcpy(bcc_ptr
, "?????");
5131 bcc_ptr
+= strlen("?????");
5133 count
= bcc_ptr
- &pSMB
->Password
[0];
5134 be32_add_cpu(&pSMB
->hdr
.smb_buf_length
, count
);
5135 pSMB
->ByteCount
= cpu_to_le16(count
);
5137 rc
= SendReceive(xid
, ses
, smb_buffer
, smb_buffer_response
, &length
,
5140 /* above now done in SendReceive */
5144 tcon
->tidStatus
= CifsGood
;
5145 tcon
->need_reconnect
= false;
5146 tcon
->tid
= smb_buffer_response
->Tid
;
5147 bcc_ptr
= pByteArea(smb_buffer_response
);
5148 bytes_left
= get_bcc(smb_buffer_response
);
5149 length
= strnlen(bcc_ptr
, bytes_left
- 2);
5150 if (smb_buffer
->Flags2
& SMBFLG2_UNICODE
)
5156 /* skip service field (NB: this field is always ASCII) */
5158 if ((bcc_ptr
[0] == 'I') && (bcc_ptr
[1] == 'P') &&
5159 (bcc_ptr
[2] == 'C')) {
5160 cifs_dbg(FYI
, "IPC connection\n");
5164 } else if (length
== 2) {
5165 if ((bcc_ptr
[0] == 'A') && (bcc_ptr
[1] == ':')) {
5166 /* the most common case */
5167 cifs_dbg(FYI
, "disk share connection\n");
5170 bcc_ptr
+= length
+ 1;
5171 bytes_left
-= (length
+ 1);
5172 strlcpy(tcon
->treeName
, tree
, sizeof(tcon
->treeName
));
5174 /* mostly informational -- no need to fail on error here */
5175 kfree(tcon
->nativeFileSystem
);
5176 tcon
->nativeFileSystem
= cifs_strndup_from_utf16(bcc_ptr
,
5177 bytes_left
, is_unicode
,
5180 cifs_dbg(FYI
, "nativeFileSystem=%s\n", tcon
->nativeFileSystem
);
5182 if ((smb_buffer_response
->WordCount
== 3) ||
5183 (smb_buffer_response
->WordCount
== 7))
5184 /* field is in same location */
5185 tcon
->Flags
= le16_to_cpu(pSMBr
->OptionalSupport
);
5188 cifs_dbg(FYI
, "Tcon flags: 0x%x\n", tcon
->Flags
);
5191 cifs_buf_release(smb_buffer
);
5195 static void delayed_free(struct rcu_head
*p
)
5197 struct cifs_sb_info
*sbi
= container_of(p
, struct cifs_sb_info
, rcu
);
5198 unload_nls(sbi
->local_nls
);
5203 cifs_umount(struct cifs_sb_info
*cifs_sb
)
5205 struct rb_root
*root
= &cifs_sb
->tlink_tree
;
5206 struct rb_node
*node
;
5207 struct tcon_link
*tlink
;
5209 cancel_delayed_work_sync(&cifs_sb
->prune_tlinks
);
5211 spin_lock(&cifs_sb
->tlink_tree_lock
);
5212 while ((node
= rb_first(root
))) {
5213 tlink
= rb_entry(node
, struct tcon_link
, tl_rbnode
);
5214 cifs_get_tlink(tlink
);
5215 clear_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
5216 rb_erase(node
, root
);
5218 spin_unlock(&cifs_sb
->tlink_tree_lock
);
5219 cifs_put_tlink(tlink
);
5220 spin_lock(&cifs_sb
->tlink_tree_lock
);
5222 spin_unlock(&cifs_sb
->tlink_tree_lock
);
5224 kfree(cifs_sb
->mountdata
);
5225 kfree(cifs_sb
->prepath
);
5226 #ifdef CONFIG_CIFS_DFS_UPCALL
5227 dfs_cache_del_vol(cifs_sb
->origin_fullpath
);
5228 kfree(cifs_sb
->origin_fullpath
);
5230 call_rcu(&cifs_sb
->rcu
, delayed_free
);
5234 cifs_negotiate_protocol(const unsigned int xid
, struct cifs_ses
*ses
)
5237 struct TCP_Server_Info
*server
= cifs_ses_server(ses
);
5239 if (!server
->ops
->need_neg
|| !server
->ops
->negotiate
)
5242 /* only send once per connect */
5243 if (!server
->ops
->need_neg(server
))
5246 rc
= server
->ops
->negotiate(xid
, ses
);
5248 spin_lock(&GlobalMid_Lock
);
5249 if (server
->tcpStatus
== CifsNeedNegotiate
)
5250 server
->tcpStatus
= CifsGood
;
5253 spin_unlock(&GlobalMid_Lock
);
5260 cifs_setup_session(const unsigned int xid
, struct cifs_ses
*ses
,
5261 struct nls_table
*nls_info
)
5264 struct TCP_Server_Info
*server
= cifs_ses_server(ses
);
5266 if (!ses
->binding
) {
5267 ses
->capabilities
= server
->capabilities
;
5268 if (linuxExtEnabled
== 0)
5269 ses
->capabilities
&= (~server
->vals
->cap_unix
);
5271 if (ses
->auth_key
.response
) {
5272 cifs_dbg(FYI
, "Free previous auth_key.response = %p\n",
5273 ses
->auth_key
.response
);
5274 kfree(ses
->auth_key
.response
);
5275 ses
->auth_key
.response
= NULL
;
5276 ses
->auth_key
.len
= 0;
5280 cifs_dbg(FYI
, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
5281 server
->sec_mode
, server
->capabilities
, server
->timeAdj
);
5283 if (server
->ops
->sess_setup
)
5284 rc
= server
->ops
->sess_setup(xid
, ses
, nls_info
);
5287 cifs_server_dbg(VFS
, "Send error in SessSetup = %d\n", rc
);
5293 cifs_set_vol_auth(struct smb_vol
*vol
, struct cifs_ses
*ses
)
5295 vol
->sectype
= ses
->sectype
;
5297 /* krb5 is special, since we don't need username or pw */
5298 if (vol
->sectype
== Kerberos
)
5301 return cifs_set_cifscreds(vol
, ses
);
5304 static struct cifs_tcon
*
5305 cifs_construct_tcon(struct cifs_sb_info
*cifs_sb
, kuid_t fsuid
)
5308 struct cifs_tcon
*master_tcon
= cifs_sb_master_tcon(cifs_sb
);
5309 struct cifs_ses
*ses
;
5310 struct cifs_tcon
*tcon
= NULL
;
5311 struct smb_vol
*vol_info
;
5313 vol_info
= kzalloc(sizeof(*vol_info
), GFP_KERNEL
);
5314 if (vol_info
== NULL
)
5315 return ERR_PTR(-ENOMEM
);
5317 vol_info
->local_nls
= cifs_sb
->local_nls
;
5318 vol_info
->linux_uid
= fsuid
;
5319 vol_info
->cred_uid
= fsuid
;
5320 vol_info
->UNC
= master_tcon
->treeName
;
5321 vol_info
->retry
= master_tcon
->retry
;
5322 vol_info
->nocase
= master_tcon
->nocase
;
5323 vol_info
->nohandlecache
= master_tcon
->nohandlecache
;
5324 vol_info
->local_lease
= master_tcon
->local_lease
;
5325 vol_info
->no_lease
= master_tcon
->no_lease
;
5326 vol_info
->resilient
= master_tcon
->use_resilient
;
5327 vol_info
->persistent
= master_tcon
->use_persistent
;
5328 vol_info
->handle_timeout
= master_tcon
->handle_timeout
;
5329 vol_info
->no_linux_ext
= !master_tcon
->unix_ext
;
5330 vol_info
->linux_ext
= master_tcon
->posix_extensions
;
5331 vol_info
->sectype
= master_tcon
->ses
->sectype
;
5332 vol_info
->sign
= master_tcon
->ses
->sign
;
5333 vol_info
->seal
= master_tcon
->seal
;
5335 rc
= cifs_set_vol_auth(vol_info
, master_tcon
->ses
);
5341 /* get a reference for the same TCP session */
5342 spin_lock(&cifs_tcp_ses_lock
);
5343 ++master_tcon
->ses
->server
->srv_count
;
5344 spin_unlock(&cifs_tcp_ses_lock
);
5346 ses
= cifs_get_smb_ses(master_tcon
->ses
->server
, vol_info
);
5348 tcon
= (struct cifs_tcon
*)ses
;
5349 cifs_put_tcp_session(master_tcon
->ses
->server
, 0);
5353 tcon
= cifs_get_tcon(ses
, vol_info
);
5355 cifs_put_smb_ses(ses
);
5360 reset_cifs_unix_caps(0, tcon
, NULL
, vol_info
);
5363 kfree(vol_info
->username
);
5364 kfree_sensitive(vol_info
->password
);
5371 cifs_sb_master_tcon(struct cifs_sb_info
*cifs_sb
)
5373 return tlink_tcon(cifs_sb_master_tlink(cifs_sb
));
5376 /* find and return a tlink with given uid */
5377 static struct tcon_link
*
5378 tlink_rb_search(struct rb_root
*root
, kuid_t uid
)
5380 struct rb_node
*node
= root
->rb_node
;
5381 struct tcon_link
*tlink
;
5384 tlink
= rb_entry(node
, struct tcon_link
, tl_rbnode
);
5386 if (uid_gt(tlink
->tl_uid
, uid
))
5387 node
= node
->rb_left
;
5388 else if (uid_lt(tlink
->tl_uid
, uid
))
5389 node
= node
->rb_right
;
5396 /* insert a tcon_link into the tree */
5398 tlink_rb_insert(struct rb_root
*root
, struct tcon_link
*new_tlink
)
5400 struct rb_node
**new = &(root
->rb_node
), *parent
= NULL
;
5401 struct tcon_link
*tlink
;
5404 tlink
= rb_entry(*new, struct tcon_link
, tl_rbnode
);
5407 if (uid_gt(tlink
->tl_uid
, new_tlink
->tl_uid
))
5408 new = &((*new)->rb_left
);
5410 new = &((*new)->rb_right
);
5413 rb_link_node(&new_tlink
->tl_rbnode
, parent
, new);
5414 rb_insert_color(&new_tlink
->tl_rbnode
, root
);
5418 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
5421 * If the superblock doesn't refer to a multiuser mount, then just return
5422 * the master tcon for the mount.
5424 * First, search the rbtree for an existing tcon for this fsuid. If one
5425 * exists, then check to see if it's pending construction. If it is then wait
5426 * for construction to complete. Once it's no longer pending, check to see if
5427 * it failed and either return an error or retry construction, depending on
5430 * If one doesn't exist then insert a new tcon_link struct into the tree and
5431 * try to construct a new one.
5434 cifs_sb_tlink(struct cifs_sb_info
*cifs_sb
)
5437 kuid_t fsuid
= current_fsuid();
5438 struct tcon_link
*tlink
, *newtlink
;
5440 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
5441 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb
));
5443 spin_lock(&cifs_sb
->tlink_tree_lock
);
5444 tlink
= tlink_rb_search(&cifs_sb
->tlink_tree
, fsuid
);
5446 cifs_get_tlink(tlink
);
5447 spin_unlock(&cifs_sb
->tlink_tree_lock
);
5449 if (tlink
== NULL
) {
5450 newtlink
= kzalloc(sizeof(*tlink
), GFP_KERNEL
);
5451 if (newtlink
== NULL
)
5452 return ERR_PTR(-ENOMEM
);
5453 newtlink
->tl_uid
= fsuid
;
5454 newtlink
->tl_tcon
= ERR_PTR(-EACCES
);
5455 set_bit(TCON_LINK_PENDING
, &newtlink
->tl_flags
);
5456 set_bit(TCON_LINK_IN_TREE
, &newtlink
->tl_flags
);
5457 cifs_get_tlink(newtlink
);
5459 spin_lock(&cifs_sb
->tlink_tree_lock
);
5460 /* was one inserted after previous search? */
5461 tlink
= tlink_rb_search(&cifs_sb
->tlink_tree
, fsuid
);
5463 cifs_get_tlink(tlink
);
5464 spin_unlock(&cifs_sb
->tlink_tree_lock
);
5466 goto wait_for_construction
;
5469 tlink_rb_insert(&cifs_sb
->tlink_tree
, tlink
);
5470 spin_unlock(&cifs_sb
->tlink_tree_lock
);
5472 wait_for_construction
:
5473 ret
= wait_on_bit(&tlink
->tl_flags
, TCON_LINK_PENDING
,
5474 TASK_INTERRUPTIBLE
);
5476 cifs_put_tlink(tlink
);
5477 return ERR_PTR(-ERESTARTSYS
);
5480 /* if it's good, return it */
5481 if (!IS_ERR(tlink
->tl_tcon
))
5484 /* return error if we tried this already recently */
5485 if (time_before(jiffies
, tlink
->tl_time
+ TLINK_ERROR_EXPIRE
)) {
5486 cifs_put_tlink(tlink
);
5487 return ERR_PTR(-EACCES
);
5490 if (test_and_set_bit(TCON_LINK_PENDING
, &tlink
->tl_flags
))
5491 goto wait_for_construction
;
5494 tlink
->tl_tcon
= cifs_construct_tcon(cifs_sb
, fsuid
);
5495 clear_bit(TCON_LINK_PENDING
, &tlink
->tl_flags
);
5496 wake_up_bit(&tlink
->tl_flags
, TCON_LINK_PENDING
);
5498 if (IS_ERR(tlink
->tl_tcon
)) {
5499 cifs_put_tlink(tlink
);
5500 return ERR_PTR(-EACCES
);
5507 * periodic workqueue job that scans tcon_tree for a superblock and closes
5511 cifs_prune_tlinks(struct work_struct
*work
)
5513 struct cifs_sb_info
*cifs_sb
= container_of(work
, struct cifs_sb_info
,
5515 struct rb_root
*root
= &cifs_sb
->tlink_tree
;
5516 struct rb_node
*node
;
5517 struct rb_node
*tmp
;
5518 struct tcon_link
*tlink
;
5521 * Because we drop the spinlock in the loop in order to put the tlink
5522 * it's not guarded against removal of links from the tree. The only
5523 * places that remove entries from the tree are this function and
5524 * umounts. Because this function is non-reentrant and is canceled
5525 * before umount can proceed, this is safe.
5527 spin_lock(&cifs_sb
->tlink_tree_lock
);
5528 node
= rb_first(root
);
5529 while (node
!= NULL
) {
5531 node
= rb_next(tmp
);
5532 tlink
= rb_entry(tmp
, struct tcon_link
, tl_rbnode
);
5534 if (test_bit(TCON_LINK_MASTER
, &tlink
->tl_flags
) ||
5535 atomic_read(&tlink
->tl_count
) != 0 ||
5536 time_after(tlink
->tl_time
+ TLINK_IDLE_EXPIRE
, jiffies
))
5539 cifs_get_tlink(tlink
);
5540 clear_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
5541 rb_erase(tmp
, root
);
5543 spin_unlock(&cifs_sb
->tlink_tree_lock
);
5544 cifs_put_tlink(tlink
);
5545 spin_lock(&cifs_sb
->tlink_tree_lock
);
5547 spin_unlock(&cifs_sb
->tlink_tree_lock
);
5549 queue_delayed_work(cifsiod_wq
, &cifs_sb
->prune_tlinks
,
5553 #ifdef CONFIG_CIFS_DFS_UPCALL
5554 int cifs_tree_connect(const unsigned int xid
, struct cifs_tcon
*tcon
, const struct nls_table
*nlsc
)
5557 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
5558 const struct smb_version_operations
*ops
= server
->ops
;
5559 struct dfs_cache_tgt_list tl
;
5560 struct dfs_cache_tgt_iterator
*it
= NULL
;
5562 const char *tcp_host
;
5563 size_t tcp_host_len
;
5564 const char *dfs_host
;
5565 size_t dfs_host_len
;
5566 char *share
= NULL
, *prefix
= NULL
;
5567 struct dfs_info3_param ref
= {0};
5570 tree
= kzalloc(MAX_TREE_SIZE
, GFP_KERNEL
);
5574 if (!tcon
->dfs_path
) {
5576 scnprintf(tree
, MAX_TREE_SIZE
, "\\\\%s\\IPC$", server
->hostname
);
5577 rc
= ops
->tree_connect(xid
, tcon
->ses
, tree
, tcon
, nlsc
);
5579 rc
= ops
->tree_connect(xid
, tcon
->ses
, tcon
->treeName
, tcon
, nlsc
);
5584 rc
= dfs_cache_noreq_find(tcon
->dfs_path
+ 1, &ref
, &tl
);
5587 isroot
= ref
.server_type
== DFS_TYPE_ROOT
;
5588 free_dfs_info_param(&ref
);
5590 extract_unc_hostname(server
->hostname
, &tcp_host
, &tcp_host_len
);
5592 for (it
= dfs_cache_get_tgt_iterator(&tl
); it
; it
= dfs_cache_get_next_tgt(&tl
, it
)) {
5600 rc
= dfs_cache_get_tgt_share(tcon
->dfs_path
+ 1, it
, &share
, &prefix
);
5602 cifs_dbg(VFS
, "%s: failed to parse target share %d\n",
5607 extract_unc_hostname(share
, &dfs_host
, &dfs_host_len
);
5609 if (dfs_host_len
!= tcp_host_len
5610 || strncasecmp(dfs_host
, tcp_host
, dfs_host_len
) != 0) {
5611 cifs_dbg(FYI
, "%s: %.*s doesn't match %.*s\n", __func__
, (int)dfs_host_len
,
5612 dfs_host
, (int)tcp_host_len
, tcp_host
);
5614 rc
= match_target_ip(server
, dfs_host
, dfs_host_len
, &target_match
);
5616 cifs_dbg(VFS
, "%s: failed to match target ip: %d\n", __func__
, rc
);
5620 if (!target_match
) {
5621 cifs_dbg(FYI
, "%s: skipping target\n", __func__
);
5627 scnprintf(tree
, MAX_TREE_SIZE
, "\\\\%s\\IPC$", share
);
5628 rc
= ops
->tree_connect(xid
, tcon
->ses
, tree
, tcon
, nlsc
);
5630 scnprintf(tree
, MAX_TREE_SIZE
, "\\%s", share
);
5631 rc
= ops
->tree_connect(xid
, tcon
->ses
, tree
, tcon
, nlsc
);
5632 /* Only handle prefix paths of DFS link targets */
5633 if (!rc
&& !isroot
) {
5634 rc
= update_super_prepath(tcon
, prefix
);
5647 rc
= dfs_cache_noreq_update_tgthint(tcon
->dfs_path
+ 1, it
);
5651 dfs_cache_free_tgts(&tl
);
5657 int cifs_tree_connect(const unsigned int xid
, struct cifs_tcon
*tcon
, const struct nls_table
*nlsc
)
5659 const struct smb_version_operations
*ops
= tcon
->ses
->server
->ops
;
5661 return ops
->tree_connect(xid
, tcon
->ses
, tcon
->treeName
, tcon
, nlsc
);