4 * Copyright (C) International Business Machines Corp., 2002,2011
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/sched/signal.h>
25 #include <linux/list.h>
26 #include <linux/wait.h>
27 #include <linux/slab.h>
28 #include <linux/pagemap.h>
29 #include <linux/ctype.h>
30 #include <linux/utsname.h>
31 #include <linux/mempool.h>
32 #include <linux/delay.h>
33 #include <linux/completion.h>
34 #include <linux/kthread.h>
35 #include <linux/pagevec.h>
36 #include <linux/freezer.h>
37 #include <linux/namei.h>
38 #include <linux/uuid.h>
39 #include <linux/uaccess.h>
40 #include <asm/processor.h>
41 #include <linux/inet.h>
42 #include <linux/module.h>
43 #include <keys/user-type.h>
45 #include <linux/parser.h>
46 #include <linux/bvec.h>
49 #include "cifsproto.h"
50 #include "cifs_unicode.h"
51 #include "cifs_debug.h"
52 #include "cifs_fs_sb.h"
55 #include "rfc1002pdu.h"
57 #include "smb2proto.h"
58 #include "smbdirect.h"
59 #include "dns_resolve.h"
61 #ifdef CONFIG_CIFS_DFS_UPCALL
62 #include "dfs_cache.h"
65 extern mempool_t *cifs_req_poolp;
66 extern bool disable_legacy_dialects;
68 /* FIXME: should these be tunable? */
69 #define TLINK_ERROR_EXPIRE (1 * HZ)
70 #define TLINK_IDLE_EXPIRE (600 * HZ)
73 /* Mount options that take no arguments */
74 Opt_user_xattr, Opt_nouser_xattr,
75 Opt_forceuid, Opt_noforceuid,
76 Opt_forcegid, Opt_noforcegid,
77 Opt_noblocksend, Opt_noautotune,
78 Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
79 Opt_mapposix, Opt_nomapposix,
80 Opt_mapchars, Opt_nomapchars, Opt_sfu,
81 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
82 Opt_noposixpaths, Opt_nounix, Opt_unix,
85 Opt_handlecache, Opt_nohandlecache,
86 Opt_forcemandatorylock, Opt_setuidfromacl, Opt_setuids,
87 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
88 Opt_nohard, Opt_nosoft,
90 Opt_nostrictsync, Opt_strictsync,
91 Opt_serverino, Opt_noserverino,
92 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
93 Opt_acl, Opt_noacl, Opt_locallease,
94 Opt_sign, Opt_seal, Opt_noac,
95 Opt_fsc, Opt_mfsymlinks,
96 Opt_multiuser, Opt_sloppy, Opt_nosharesock,
97 Opt_persistent, Opt_nopersistent,
98 Opt_resilient, Opt_noresilient,
99 Opt_domainauto, Opt_rdma,
101 /* Mount options which take numeric value */
102 Opt_backupuid, Opt_backupgid, Opt_uid,
103 Opt_cruid, Opt_gid, Opt_file_mode,
104 Opt_dirmode, Opt_port,
105 Opt_blocksize, Opt_rsize, Opt_wsize, Opt_actimeo,
106 Opt_echo_interval, Opt_max_credits, Opt_handletimeout,
109 /* Mount options which take string value */
110 Opt_user, Opt_pass, Opt_ip,
111 Opt_domain, Opt_srcaddr, Opt_iocharset,
112 Opt_netbiosname, Opt_servern,
113 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
115 /* Mount options to be ignored */
118 /* Options which could be blank */
126 static const match_table_t cifs_mount_option_tokens = {
128 { Opt_user_xattr, "user_xattr" },
129 { Opt_nouser_xattr, "nouser_xattr" },
130 { Opt_forceuid, "forceuid" },
131 { Opt_noforceuid, "noforceuid" },
132 { Opt_forcegid, "forcegid" },
133 { Opt_noforcegid, "noforcegid" },
134 { Opt_noblocksend, "noblocksend" },
135 { Opt_noautotune, "noautotune" },
136 { Opt_hard, "hard" },
137 { Opt_soft, "soft" },
138 { Opt_perm, "perm" },
139 { Opt_noperm, "noperm" },
140 { Opt_mapchars, "mapchars" }, /* SFU style */
141 { Opt_nomapchars, "nomapchars" },
142 { Opt_mapposix, "mapposix" }, /* SFM style */
143 { Opt_nomapposix, "nomapposix" },
145 { Opt_nosfu, "nosfu" },
146 { Opt_nodfs, "nodfs" },
147 { Opt_posixpaths, "posixpaths" },
148 { Opt_noposixpaths, "noposixpaths" },
149 { Opt_nounix, "nounix" },
150 { Opt_nounix, "nolinux" },
151 { Opt_nounix, "noposix" },
152 { Opt_unix, "unix" },
153 { Opt_unix, "linux" },
154 { Opt_unix, "posix" },
155 { Opt_nocase, "nocase" },
156 { Opt_nocase, "ignorecase" },
158 { Opt_nobrl, "nobrl" },
159 { Opt_handlecache, "handlecache" },
160 { Opt_nohandlecache, "nohandlecache" },
161 { Opt_nobrl, "nolock" },
162 { Opt_forcemandatorylock, "forcemandatorylock" },
163 { Opt_forcemandatorylock, "forcemand" },
164 { Opt_setuids, "setuids" },
165 { Opt_nosetuids, "nosetuids" },
166 { Opt_setuidfromacl, "idsfromsid" },
167 { Opt_dynperm, "dynperm" },
168 { Opt_nodynperm, "nodynperm" },
169 { Opt_nohard, "nohard" },
170 { Opt_nosoft, "nosoft" },
171 { Opt_nointr, "nointr" },
172 { Opt_intr, "intr" },
173 { Opt_nostrictsync, "nostrictsync" },
174 { Opt_strictsync, "strictsync" },
175 { Opt_serverino, "serverino" },
176 { Opt_noserverino, "noserverino" },
177 { Opt_rwpidforward, "rwpidforward" },
178 { Opt_cifsacl, "cifsacl" },
179 { Opt_nocifsacl, "nocifsacl" },
181 { Opt_noacl, "noacl" },
182 { Opt_locallease, "locallease" },
183 { Opt_sign, "sign" },
184 { Opt_seal, "seal" },
185 { Opt_noac, "noac" },
187 { Opt_mfsymlinks, "mfsymlinks" },
188 { Opt_multiuser, "multiuser" },
189 { Opt_sloppy, "sloppy" },
190 { Opt_nosharesock, "nosharesock" },
191 { Opt_persistent, "persistenthandles"},
192 { Opt_nopersistent, "nopersistenthandles"},
193 { Opt_resilient, "resilienthandles"},
194 { Opt_noresilient, "noresilienthandles"},
195 { Opt_domainauto, "domainauto"},
198 { Opt_backupuid, "backupuid=%s" },
199 { Opt_backupgid, "backupgid=%s" },
200 { Opt_uid, "uid=%s" },
201 { Opt_cruid, "cruid=%s" },
202 { Opt_gid, "gid=%s" },
203 { Opt_file_mode, "file_mode=%s" },
204 { Opt_dirmode, "dirmode=%s" },
205 { Opt_dirmode, "dir_mode=%s" },
206 { Opt_port, "port=%s" },
207 { Opt_blocksize, "bsize=%s" },
208 { Opt_rsize, "rsize=%s" },
209 { Opt_wsize, "wsize=%s" },
210 { Opt_actimeo, "actimeo=%s" },
211 { Opt_handletimeout, "handletimeout=%s" },
212 { Opt_echo_interval, "echo_interval=%s" },
213 { Opt_max_credits, "max_credits=%s" },
214 { Opt_snapshot, "snapshot=%s" },
216 { Opt_blank_user, "user=" },
217 { Opt_blank_user, "username=" },
218 { Opt_user, "user=%s" },
219 { Opt_user, "username=%s" },
220 { Opt_blank_pass, "pass=" },
221 { Opt_blank_pass, "password=" },
222 { Opt_pass, "pass=%s" },
223 { Opt_pass, "password=%s" },
224 { Opt_blank_ip, "ip=" },
225 { Opt_blank_ip, "addr=" },
227 { Opt_ip, "addr=%s" },
228 { Opt_ignore, "unc=%s" },
229 { Opt_ignore, "target=%s" },
230 { Opt_ignore, "path=%s" },
231 { Opt_domain, "dom=%s" },
232 { Opt_domain, "domain=%s" },
233 { Opt_domain, "workgroup=%s" },
234 { Opt_srcaddr, "srcaddr=%s" },
235 { Opt_ignore, "prefixpath=%s" },
236 { Opt_iocharset, "iocharset=%s" },
237 { Opt_netbiosname, "netbiosname=%s" },
238 { Opt_servern, "servern=%s" },
239 { Opt_ver, "ver=%s" },
240 { Opt_vers, "vers=%s" },
241 { Opt_sec, "sec=%s" },
242 { Opt_cache, "cache=%s" },
244 { Opt_ignore, "cred" },
245 { Opt_ignore, "credentials" },
246 { Opt_ignore, "cred=%s" },
247 { Opt_ignore, "credentials=%s" },
248 { Opt_ignore, "guest" },
249 { Opt_ignore, "rw" },
250 { Opt_ignore, "ro" },
251 { Opt_ignore, "suid" },
252 { Opt_ignore, "nosuid" },
253 { Opt_ignore, "exec" },
254 { Opt_ignore, "noexec" },
255 { Opt_ignore, "nodev" },
256 { Opt_ignore, "noauto" },
257 { Opt_ignore, "dev" },
258 { Opt_ignore, "mand" },
259 { Opt_ignore, "nomand" },
260 { Opt_ignore, "relatime" },
261 { Opt_ignore, "_netdev" },
267 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
268 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
269 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
270 Opt_sec_ntlmv2i, Opt_sec_lanman,
276 static const match_table_t cifs_secflavor_tokens = {
277 { Opt_sec_krb5, "krb5" },
278 { Opt_sec_krb5i, "krb5i" },
279 { Opt_sec_krb5p, "krb5p" },
280 { Opt_sec_ntlmsspi, "ntlmsspi" },
281 { Opt_sec_ntlmssp, "ntlmssp" },
282 { Opt_ntlm, "ntlm" },
283 { Opt_sec_ntlmi, "ntlmi" },
284 { Opt_sec_ntlmv2, "nontlm" },
285 { Opt_sec_ntlmv2, "ntlmv2" },
286 { Opt_sec_ntlmv2i, "ntlmv2i" },
287 { Opt_sec_lanman, "lanman" },
288 { Opt_sec_none, "none" },
290 { Opt_sec_err, NULL }
301 static const match_table_t cifs_cacheflavor_tokens = {
302 { Opt_cache_loose, "loose" },
303 { Opt_cache_strict, "strict" },
304 { Opt_cache_none, "none" },
305 { Opt_cache_err, NULL }
308 static const match_table_t cifs_smb_version_tokens = {
309 { Smb_1, SMB1_VERSION_STRING },
310 { Smb_20, SMB20_VERSION_STRING},
311 { Smb_21, SMB21_VERSION_STRING },
312 { Smb_30, SMB30_VERSION_STRING },
313 { Smb_302, SMB302_VERSION_STRING },
314 { Smb_302, ALT_SMB302_VERSION_STRING },
315 { Smb_311, SMB311_VERSION_STRING },
316 { Smb_311, ALT_SMB311_VERSION_STRING },
317 { Smb_3any, SMB3ANY_VERSION_STRING },
318 { Smb_default, SMBDEFAULT_VERSION_STRING },
319 { Smb_version_err, NULL }
322 static int ip_connect(struct TCP_Server_Info *server);
323 static int generic_ip_connect(struct TCP_Server_Info *server);
324 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
325 static void cifs_prune_tlinks(struct work_struct *work);
326 static char *extract_hostname(const char *unc);
329 * Resolve hostname and set ip addr in tcp ses. Useful for hostnames that may
330 * get their ip addresses changed at some point.
332 * This should be called with server->srv_mutex held.
334 #ifdef CONFIG_CIFS_DFS_UPCALL
335 static int reconn_set_ipaddr(struct TCP_Server_Info *server)
339 char *unc, *ipaddr = NULL;
341 if (!server->hostname)
344 len = strlen(server->hostname) + 3;
346 unc = kmalloc(len, GFP_KERNEL);
348 cifs_dbg(FYI, "%s: failed to create UNC path\n", __func__);
351 scnprintf(unc, len, "\\\\%s", server->hostname);
353 rc = dns_resolve_server_name_to_ip(unc, &ipaddr);
357 cifs_dbg(FYI, "%s: failed to resolve server part of %s to IP: %d\n",
358 __func__, server->hostname, rc);
362 rc = cifs_convert_address((struct sockaddr *)&server->dstaddr, ipaddr,
369 static inline int reconn_set_ipaddr(struct TCP_Server_Info *server)
375 #ifdef CONFIG_CIFS_DFS_UPCALL
376 struct super_cb_data {
377 struct TCP_Server_Info *server;
378 struct cifs_sb_info *cifs_sb;
381 /* These functions must be called with server->srv_mutex held */
383 static void super_cb(struct super_block *sb, void *arg)
385 struct super_cb_data *d = arg;
386 struct cifs_sb_info *cifs_sb;
387 struct cifs_tcon *tcon;
392 cifs_sb = CIFS_SB(sb);
393 tcon = cifs_sb_master_tcon(cifs_sb);
394 if (tcon->ses->server == d->server)
395 d->cifs_sb = cifs_sb;
398 static inline struct cifs_sb_info *
399 find_super_by_tcp(struct TCP_Server_Info *server)
401 struct super_cb_data d = {
406 iterate_supers_type(&cifs_fs_type, super_cb, &d);
407 return d.cifs_sb ? d.cifs_sb : ERR_PTR(-ENOENT);
410 static void reconn_inval_dfs_target(struct TCP_Server_Info *server,
411 struct cifs_sb_info *cifs_sb,
412 struct dfs_cache_tgt_list *tgt_list,
413 struct dfs_cache_tgt_iterator **tgt_it)
417 if (!cifs_sb || !cifs_sb->origin_fullpath || !tgt_list ||
422 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
424 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
426 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
429 cifs_dbg(FYI, "%s: UNC: %s\n", __func__, cifs_sb->origin_fullpath);
431 name = dfs_cache_get_tgt_name(*tgt_it);
433 kfree(server->hostname);
435 server->hostname = extract_hostname(name);
436 if (IS_ERR(server->hostname)) {
438 "%s: failed to extract hostname from target: %ld\n",
439 __func__, PTR_ERR(server->hostname));
443 static inline int reconn_setup_dfs_targets(struct cifs_sb_info *cifs_sb,
444 struct dfs_cache_tgt_list *tl,
445 struct dfs_cache_tgt_iterator **it)
447 if (!cifs_sb->origin_fullpath)
449 return dfs_cache_noreq_find(cifs_sb->origin_fullpath + 1, NULL, tl);
454 * cifs tcp session reconnection
456 * mark tcp session as reconnecting so temporarily locked
457 * mark all smb sessions as reconnecting for tcp session
458 * reconnect tcp session
459 * wake up waiters on reconnection? - (not needed currently)
462 cifs_reconnect(struct TCP_Server_Info *server)
465 struct list_head *tmp, *tmp2;
466 struct cifs_ses *ses;
467 struct cifs_tcon *tcon;
468 struct mid_q_entry *mid_entry;
469 struct list_head retry_list;
470 #ifdef CONFIG_CIFS_DFS_UPCALL
471 struct cifs_sb_info *cifs_sb = NULL;
472 struct dfs_cache_tgt_list tgt_list = {0};
473 struct dfs_cache_tgt_iterator *tgt_it = NULL;
476 spin_lock(&GlobalMid_Lock);
477 server->nr_targets = 1;
478 #ifdef CONFIG_CIFS_DFS_UPCALL
479 spin_unlock(&GlobalMid_Lock);
480 cifs_sb = find_super_by_tcp(server);
481 if (IS_ERR(cifs_sb)) {
482 rc = PTR_ERR(cifs_sb);
483 cifs_dbg(FYI, "%s: will not do DFS failover: rc = %d\n",
487 rc = reconn_setup_dfs_targets(cifs_sb, &tgt_list, &tgt_it);
488 if (rc && (rc != -EOPNOTSUPP)) {
489 cifs_dbg(VFS, "%s: no target servers for DFS failover\n",
492 server->nr_targets = dfs_cache_get_nr_tgts(&tgt_list);
495 cifs_dbg(FYI, "%s: will retry %d target(s)\n", __func__,
497 spin_lock(&GlobalMid_Lock);
499 if (server->tcpStatus == CifsExiting) {
500 /* the demux thread will exit normally
501 next time through the loop */
502 spin_unlock(&GlobalMid_Lock);
505 server->tcpStatus = CifsNeedReconnect;
506 spin_unlock(&GlobalMid_Lock);
508 server->max_read = 0;
510 cifs_dbg(FYI, "Mark tcp session as need reconnect\n");
511 trace_smb3_reconnect(server->CurrentMid, server->hostname);
513 /* before reconnecting the tcp session, mark the smb session (uid)
514 and the tid bad so they are not used until reconnected */
515 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
517 spin_lock(&cifs_tcp_ses_lock);
518 list_for_each(tmp, &server->smb_ses_list) {
519 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
520 ses->need_reconnect = true;
521 list_for_each(tmp2, &ses->tcon_list) {
522 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
523 tcon->need_reconnect = true;
526 ses->tcon_ipc->need_reconnect = true;
528 spin_unlock(&cifs_tcp_ses_lock);
530 /* do not want to be sending data on a socket we are freeing */
531 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
532 mutex_lock(&server->srv_mutex);
533 if (server->ssocket) {
534 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
535 server->ssocket->state, server->ssocket->flags);
536 kernel_sock_shutdown(server->ssocket, SHUT_WR);
537 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
538 server->ssocket->state, server->ssocket->flags);
539 sock_release(server->ssocket);
540 server->ssocket = NULL;
542 server->sequence_number = 0;
543 server->session_estab = false;
544 kfree(server->session_key.response);
545 server->session_key.response = NULL;
546 server->session_key.len = 0;
547 server->lstrp = jiffies;
549 /* mark submitted MIDs for retry and issue callback */
550 INIT_LIST_HEAD(&retry_list);
551 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
552 spin_lock(&GlobalMid_Lock);
553 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
554 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
555 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
556 mid_entry->mid_state = MID_RETRY_NEEDED;
557 list_move(&mid_entry->qhead, &retry_list);
559 spin_unlock(&GlobalMid_Lock);
560 mutex_unlock(&server->srv_mutex);
562 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
563 list_for_each_safe(tmp, tmp2, &retry_list) {
564 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
565 list_del_init(&mid_entry->qhead);
566 mid_entry->callback(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);
580 * Set up next DFS target server (if any) for reconnect. If DFS
581 * feature is disabled, then we will retry last server we
582 * connected to before.
584 if (cifs_rdma_enabled(server))
585 rc = smbd_reconnect(server);
587 rc = generic_ip_connect(server);
589 cifs_dbg(FYI, "reconnect error %d\n", rc);
590 #ifdef CONFIG_CIFS_DFS_UPCALL
591 reconn_inval_dfs_target(server, cifs_sb, &tgt_list,
594 rc = reconn_set_ipaddr(server);
596 cifs_dbg(FYI, "%s: failed to resolve hostname: %d\n",
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_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_dbg(VFS, "%s: failed to update vol info in DFS cache: rc = %d\n",
625 dfs_cache_free_tgts(&tgt_list);
628 if (server->tcpStatus == CifsNeedNegotiate)
629 mod_delayed_work(cifsiod_wq, &server->echo, 0);
635 cifs_echo_request(struct work_struct *work)
638 struct TCP_Server_Info *server = container_of(work,
639 struct TCP_Server_Info, echo.work);
640 unsigned long echo_interval;
643 * If we need to renegotiate, set echo interval to zero to
644 * immediately call echo service where we can renegotiate.
646 if (server->tcpStatus == CifsNeedNegotiate)
649 echo_interval = server->echo_interval;
652 * We cannot send an echo if it is disabled.
653 * Also, no need to ping if we got a response recently.
656 if (server->tcpStatus == CifsNeedReconnect ||
657 server->tcpStatus == CifsExiting ||
658 server->tcpStatus == CifsNew ||
659 (server->ops->can_echo && !server->ops->can_echo(server)) ||
660 time_before(jiffies, server->lstrp + echo_interval - HZ))
663 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
665 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
669 queue_delayed_work(cifsiod_wq, &server->echo, server->echo_interval);
673 allocate_buffers(struct TCP_Server_Info *server)
675 if (!server->bigbuf) {
676 server->bigbuf = (char *)cifs_buf_get();
677 if (!server->bigbuf) {
678 cifs_dbg(VFS, "No memory for large SMB response\n");
680 /* retry will check if exiting */
683 } else if (server->large_buf) {
684 /* we are reusing a dirty large buf, clear its start */
685 memset(server->bigbuf, 0, HEADER_SIZE(server));
688 if (!server->smallbuf) {
689 server->smallbuf = (char *)cifs_small_buf_get();
690 if (!server->smallbuf) {
691 cifs_dbg(VFS, "No memory for SMB response\n");
693 /* retry will check if exiting */
696 /* beginning of smb buffer is cleared in our buf_get */
698 /* if existing small buf clear beginning */
699 memset(server->smallbuf, 0, HEADER_SIZE(server));
706 server_unresponsive(struct TCP_Server_Info *server)
709 * We need to wait 2 echo intervals to make sure we handle such
711 * 1s client sends a normal SMB request
712 * 2s client gets a response
713 * 30s echo workqueue job pops, and decides we got a response recently
714 * and don't need to send another
716 * 65s kernel_recvmsg times out, and we see that we haven't gotten
717 * a response in >60s.
719 if ((server->tcpStatus == CifsGood ||
720 server->tcpStatus == CifsNeedNegotiate) &&
721 time_after(jiffies, server->lstrp + 2 * server->echo_interval)) {
722 cifs_dbg(VFS, "Server %s has not responded in %lu seconds. Reconnecting...\n",
723 server->hostname, (2 * server->echo_interval) / HZ);
724 cifs_reconnect(server);
725 wake_up(&server->response_q);
733 zero_credits(struct TCP_Server_Info *server)
737 spin_lock(&server->req_lock);
738 val = server->credits + server->echo_credits + server->oplock_credits;
739 if (server->in_flight == 0 && val == 0) {
740 spin_unlock(&server->req_lock);
743 spin_unlock(&server->req_lock);
748 cifs_readv_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg)
753 smb_msg->msg_control = NULL;
754 smb_msg->msg_controllen = 0;
756 for (total_read = 0; msg_data_left(smb_msg); total_read += length) {
759 /* reconnect if no credits and no requests in flight */
760 if (zero_credits(server)) {
761 cifs_reconnect(server);
762 return -ECONNABORTED;
765 if (server_unresponsive(server))
766 return -ECONNABORTED;
767 if (cifs_rdma_enabled(server) && server->smbd_conn)
768 length = smbd_recv(server->smbd_conn, smb_msg);
770 length = sock_recvmsg(server->ssocket, smb_msg, 0);
772 if (server->tcpStatus == CifsExiting)
775 if (server->tcpStatus == CifsNeedReconnect) {
776 cifs_reconnect(server);
777 return -ECONNABORTED;
780 if (length == -ERESTARTSYS ||
784 * Minimum sleep to prevent looping, allowing socket
785 * to clear and app threads to set tcpStatus
786 * CifsNeedReconnect if server hung.
788 usleep_range(1000, 2000);
794 cifs_dbg(FYI, "Received no data or error: %d\n", length);
795 cifs_reconnect(server);
796 return -ECONNABORTED;
803 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
804 unsigned int to_read)
806 struct msghdr smb_msg;
807 struct kvec iov = {.iov_base = buf, .iov_len = to_read};
808 iov_iter_kvec(&smb_msg.msg_iter, READ, &iov, 1, to_read);
810 return cifs_readv_from_socket(server, &smb_msg);
814 cifs_read_page_from_socket(struct TCP_Server_Info *server, struct page *page,
815 unsigned int page_offset, unsigned int to_read)
817 struct msghdr smb_msg;
818 struct bio_vec bv = {
819 .bv_page = page, .bv_len = to_read, .bv_offset = page_offset};
820 iov_iter_bvec(&smb_msg.msg_iter, READ, &bv, 1, to_read);
821 return cifs_readv_from_socket(server, &smb_msg);
825 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
828 * The first byte big endian of the length field,
829 * is actually not part of the length but the type
830 * with the most common, zero, as regular data.
833 case RFC1002_SESSION_MESSAGE:
834 /* Regular SMB response */
836 case RFC1002_SESSION_KEEP_ALIVE:
837 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
839 case RFC1002_POSITIVE_SESSION_RESPONSE:
840 cifs_dbg(FYI, "RFC 1002 positive session response\n");
842 case RFC1002_NEGATIVE_SESSION_RESPONSE:
844 * We get this from Windows 98 instead of an error on
845 * SMB negprot response.
847 cifs_dbg(FYI, "RFC 1002 negative session response\n");
848 /* give server a second to clean up */
851 * Always try 445 first on reconnect since we get NACK
852 * on some if we ever connected to port 139 (the NACK
853 * is since we do not begin with RFC1001 session
856 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
857 cifs_reconnect(server);
858 wake_up(&server->response_q);
861 cifs_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
862 cifs_reconnect(server);
869 dequeue_mid(struct mid_q_entry *mid, bool malformed)
871 #ifdef CONFIG_CIFS_STATS2
872 mid->when_received = jiffies;
874 spin_lock(&GlobalMid_Lock);
876 mid->mid_state = MID_RESPONSE_RECEIVED;
878 mid->mid_state = MID_RESPONSE_MALFORMED;
880 * Trying to handle/dequeue a mid after the send_recv()
881 * function has finished processing it is a bug.
883 if (mid->mid_flags & MID_DELETED)
884 printk_once(KERN_WARNING
885 "trying to dequeue a deleted mid\n");
887 list_del_init(&mid->qhead);
888 spin_unlock(&GlobalMid_Lock);
892 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
893 char *buf, int malformed)
895 if (server->ops->check_trans2 &&
896 server->ops->check_trans2(mid, server, buf, malformed))
899 mid->large_buf = server->large_buf;
900 /* Was previous buf put in mpx struct for multi-rsp? */
901 if (!mid->multiRsp) {
902 /* smb buffer will be freed by user thread */
903 if (server->large_buf)
904 server->bigbuf = NULL;
906 server->smallbuf = NULL;
908 dequeue_mid(mid, malformed);
911 static void clean_demultiplex_info(struct TCP_Server_Info *server)
915 /* take it off the list, if it's not already */
916 spin_lock(&cifs_tcp_ses_lock);
917 list_del_init(&server->tcp_ses_list);
918 spin_unlock(&cifs_tcp_ses_lock);
920 spin_lock(&GlobalMid_Lock);
921 server->tcpStatus = CifsExiting;
922 spin_unlock(&GlobalMid_Lock);
923 wake_up_all(&server->response_q);
925 /* check if we have blocked requests that need to free */
926 spin_lock(&server->req_lock);
927 if (server->credits <= 0)
929 spin_unlock(&server->req_lock);
931 * Although there should not be any requests blocked on this queue it
932 * can not hurt to be paranoid and try to wake up requests that may
933 * haven been blocked when more than 50 at time were on the wire to the
934 * same server - they now will see the session is in exit state and get
935 * out of SendReceive.
937 wake_up_all(&server->request_q);
938 /* give those requests time to exit */
940 if (cifs_rdma_enabled(server))
941 smbd_destroy(server);
942 if (server->ssocket) {
943 sock_release(server->ssocket);
944 server->ssocket = NULL;
947 if (!list_empty(&server->pending_mid_q)) {
948 struct list_head dispose_list;
949 struct mid_q_entry *mid_entry;
950 struct list_head *tmp, *tmp2;
952 INIT_LIST_HEAD(&dispose_list);
953 spin_lock(&GlobalMid_Lock);
954 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
955 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
956 cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
957 mid_entry->mid_state = MID_SHUTDOWN;
958 list_move(&mid_entry->qhead, &dispose_list);
960 spin_unlock(&GlobalMid_Lock);
962 /* now walk dispose list and issue callbacks */
963 list_for_each_safe(tmp, tmp2, &dispose_list) {
964 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
965 cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
966 list_del_init(&mid_entry->qhead);
967 mid_entry->callback(mid_entry);
969 /* 1/8th of sec is more than enough time for them to exit */
973 if (!list_empty(&server->pending_mid_q)) {
975 * mpx threads have not exited yet give them at least the smb
976 * send timeout time for long ops.
978 * Due to delays on oplock break requests, we need to wait at
979 * least 45 seconds before giving up on a request getting a
980 * response and going ahead and killing cifsd.
982 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
985 * If threads still have not exited they are probably never
986 * coming home not much else we can do but free the memory.
990 kfree(server->hostname);
993 length = atomic_dec_return(&tcpSesAllocCount);
995 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
999 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1002 char *buf = server->smallbuf;
1003 unsigned int pdu_length = server->pdu_size;
1005 /* make sure this will fit in a large buffer */
1006 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) -
1007 server->vals->header_preamble_size) {
1008 cifs_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
1009 cifs_reconnect(server);
1010 wake_up(&server->response_q);
1011 return -ECONNABORTED;
1014 /* switch to large buffer if too big for a small one */
1015 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
1016 server->large_buf = true;
1017 memcpy(server->bigbuf, buf, server->total_read);
1018 buf = server->bigbuf;
1021 /* now read the rest */
1022 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
1023 pdu_length - HEADER_SIZE(server) + 1
1024 + server->vals->header_preamble_size);
1028 server->total_read += length;
1030 dump_smb(buf, server->total_read);
1032 return cifs_handle_standard(server, mid);
1036 cifs_handle_standard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1038 char *buf = server->large_buf ? server->bigbuf : server->smallbuf;
1042 * We know that we received enough to get to the MID as we
1043 * checked the pdu_length earlier. Now check to see
1044 * if the rest of the header is OK. We borrow the length
1045 * var for the rest of the loop to avoid a new stack var.
1047 * 48 bytes is enough to display the header and a little bit
1048 * into the payload for debugging purposes.
1050 length = server->ops->check_message(buf, server->total_read, server);
1052 cifs_dump_mem("Bad SMB: ", buf,
1053 min_t(unsigned int, server->total_read, 48));
1055 if (server->ops->is_session_expired &&
1056 server->ops->is_session_expired(buf)) {
1057 cifs_reconnect(server);
1058 wake_up(&server->response_q);
1062 if (server->ops->is_status_pending &&
1063 server->ops->is_status_pending(buf, server))
1069 handle_mid(mid, server, buf, length);
1074 smb2_add_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)
1076 struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buffer;
1079 * SMB1 does not use credits.
1081 if (server->vals->header_preamble_size)
1084 if (shdr->CreditRequest) {
1085 spin_lock(&server->req_lock);
1086 server->credits += le16_to_cpu(shdr->CreditRequest);
1087 spin_unlock(&server->req_lock);
1088 wake_up(&server->request_q);
1094 cifs_demultiplex_thread(void *p)
1096 int i, num_mids, length;
1097 struct TCP_Server_Info *server = p;
1098 unsigned int pdu_length;
1099 unsigned int next_offset;
1101 struct task_struct *task_to_wake = NULL;
1102 struct mid_q_entry *mids[MAX_COMPOUND];
1103 char *bufs[MAX_COMPOUND];
1105 current->flags |= PF_MEMALLOC;
1106 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
1108 length = atomic_inc_return(&tcpSesAllocCount);
1110 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
1113 while (server->tcpStatus != CifsExiting) {
1114 if (try_to_freeze())
1117 if (!allocate_buffers(server))
1120 server->large_buf = false;
1121 buf = server->smallbuf;
1122 pdu_length = 4; /* enough to get RFC1001 header */
1124 length = cifs_read_from_socket(server, buf, pdu_length);
1128 if (server->vals->header_preamble_size == 0)
1129 server->total_read = 0;
1131 server->total_read = length;
1134 * The right amount was read from socket - 4 bytes,
1135 * so we can now interpret the length field.
1137 pdu_length = get_rfc1002_length(buf);
1139 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
1140 if (!is_smb_response(server, buf[0]))
1143 server->pdu_size = pdu_length;
1145 /* make sure we have enough to get to the MID */
1146 if (server->pdu_size < HEADER_SIZE(server) - 1 -
1147 server->vals->header_preamble_size) {
1148 cifs_dbg(VFS, "SMB response too short (%u bytes)\n",
1150 cifs_reconnect(server);
1151 wake_up(&server->response_q);
1155 /* read down to the MID */
1156 length = cifs_read_from_socket(server,
1157 buf + server->vals->header_preamble_size,
1158 HEADER_SIZE(server) - 1
1159 - server->vals->header_preamble_size);
1162 server->total_read += length;
1164 if (server->ops->next_header) {
1165 next_offset = server->ops->next_header(buf);
1167 server->pdu_size = next_offset;
1170 memset(mids, 0, sizeof(mids));
1171 memset(bufs, 0, sizeof(bufs));
1174 if (server->ops->is_transform_hdr &&
1175 server->ops->receive_transform &&
1176 server->ops->is_transform_hdr(buf)) {
1177 length = server->ops->receive_transform(server,
1182 mids[0] = server->ops->find_mid(server, buf);
1186 if (!mids[0] || !mids[0]->receive)
1187 length = standard_receive3(server, mids[0]);
1189 length = mids[0]->receive(server, mids[0]);
1193 for (i = 0; i < num_mids; i++)
1195 cifs_mid_q_entry_release(mids[i]);
1199 server->lstrp = jiffies;
1201 for (i = 0; i < num_mids; i++) {
1202 if (mids[i] != NULL) {
1203 mids[i]->resp_buf_size = server->pdu_size;
1204 if ((mids[i]->mid_flags & MID_WAIT_CANCELLED) &&
1205 mids[i]->mid_state == MID_RESPONSE_RECEIVED &&
1206 server->ops->handle_cancelled_mid)
1207 server->ops->handle_cancelled_mid(
1211 if (!mids[i]->multiRsp || mids[i]->multiEnd)
1212 mids[i]->callback(mids[i]);
1214 cifs_mid_q_entry_release(mids[i]);
1215 } else if (server->ops->is_oplock_break &&
1216 server->ops->is_oplock_break(bufs[i],
1218 smb2_add_credits_from_hdr(bufs[i], server);
1219 cifs_dbg(FYI, "Received oplock break\n");
1221 cifs_dbg(VFS, "No task to wake, unknown frame "
1222 "received! NumMids %d\n",
1223 atomic_read(&midCount));
1224 cifs_dump_mem("Received Data is: ", bufs[i],
1225 HEADER_SIZE(server));
1226 #ifdef CONFIG_CIFS_DEBUG2
1227 if (server->ops->dump_detail)
1228 server->ops->dump_detail(bufs[i],
1230 smb2_add_credits_from_hdr(bufs[i], server);
1231 cifs_dump_mids(server);
1232 #endif /* CIFS_DEBUG2 */
1236 if (pdu_length > server->pdu_size) {
1237 if (!allocate_buffers(server))
1239 pdu_length -= server->pdu_size;
1240 server->total_read = 0;
1241 server->large_buf = false;
1242 buf = server->smallbuf;
1245 } /* end while !EXITING */
1247 /* buffer usually freed in free_mid - need to free it here on exit */
1248 cifs_buf_release(server->bigbuf);
1249 if (server->smallbuf) /* no sense logging a debug message if NULL */
1250 cifs_small_buf_release(server->smallbuf);
1252 task_to_wake = xchg(&server->tsk, NULL);
1253 clean_demultiplex_info(server);
1255 /* if server->tsk was NULL then wait for a signal before exiting */
1256 if (!task_to_wake) {
1257 set_current_state(TASK_INTERRUPTIBLE);
1258 while (!signal_pending(current)) {
1260 set_current_state(TASK_INTERRUPTIBLE);
1262 set_current_state(TASK_RUNNING);
1265 module_put_and_exit(0);
1268 /* extract the host portion of the UNC string */
1270 extract_hostname(const char *unc)
1276 /* skip double chars at beginning of string */
1277 /* BB: check validity of these bytes? */
1278 if (strlen(unc) < 3)
1279 return ERR_PTR(-EINVAL);
1280 for (src = unc; *src && *src == '\\'; src++)
1283 return ERR_PTR(-EINVAL);
1285 /* delimiter between hostname and sharename is always '\\' now */
1286 delim = strchr(src, '\\');
1288 return ERR_PTR(-EINVAL);
1291 dst = kmalloc((len + 1), GFP_KERNEL);
1293 return ERR_PTR(-ENOMEM);
1295 memcpy(dst, src, len);
1301 static int get_option_ul(substring_t args[], unsigned long *option)
1306 string = match_strdup(args);
1309 rc = kstrtoul(string, 0, option);
1315 static int get_option_uid(substring_t args[], kuid_t *result)
1317 unsigned long value;
1321 rc = get_option_ul(args, &value);
1325 uid = make_kuid(current_user_ns(), value);
1326 if (!uid_valid(uid))
1333 static int get_option_gid(substring_t args[], kgid_t *result)
1335 unsigned long value;
1339 rc = get_option_ul(args, &value);
1343 gid = make_kgid(current_user_ns(), value);
1344 if (!gid_valid(gid))
1351 static int cifs_parse_security_flavors(char *value,
1352 struct smb_vol *vol)
1355 substring_t args[MAX_OPT_ARGS];
1358 * With mount options, the last one should win. Reset any existing
1359 * settings back to default.
1361 vol->sectype = Unspecified;
1364 switch (match_token(value, cifs_secflavor_tokens, args)) {
1366 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
1372 vol->sectype = Kerberos;
1374 case Opt_sec_ntlmsspi:
1377 case Opt_sec_ntlmssp:
1378 vol->sectype = RawNTLMSSP;
1384 vol->sectype = NTLM;
1386 case Opt_sec_ntlmv2i:
1389 case Opt_sec_ntlmv2:
1390 vol->sectype = NTLMv2;
1392 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1393 case Opt_sec_lanman:
1394 vol->sectype = LANMAN;
1401 cifs_dbg(VFS, "bad security option: %s\n", value);
1409 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1411 substring_t args[MAX_OPT_ARGS];
1413 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1414 case Opt_cache_loose:
1415 vol->direct_io = false;
1416 vol->strict_io = false;
1418 case Opt_cache_strict:
1419 vol->direct_io = false;
1420 vol->strict_io = true;
1422 case Opt_cache_none:
1423 vol->direct_io = true;
1424 vol->strict_io = false;
1427 cifs_dbg(VFS, "bad cache= option: %s\n", value);
1434 cifs_parse_smb_version(char *value, struct smb_vol *vol, bool is_smb3)
1436 substring_t args[MAX_OPT_ARGS];
1438 switch (match_token(value, cifs_smb_version_tokens, args)) {
1439 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1441 if (disable_legacy_dialects) {
1442 cifs_dbg(VFS, "mount with legacy dialect disabled\n");
1446 cifs_dbg(VFS, "vers=1.0 (cifs) not permitted when mounting with smb3\n");
1449 vol->ops = &smb1_operations;
1450 vol->vals = &smb1_values;
1453 if (disable_legacy_dialects) {
1454 cifs_dbg(VFS, "mount with legacy dialect disabled\n");
1458 cifs_dbg(VFS, "vers=2.0 not permitted when mounting with smb3\n");
1461 vol->ops = &smb20_operations;
1462 vol->vals = &smb20_values;
1466 cifs_dbg(VFS, "vers=1.0 (cifs) mount not permitted when legacy dialects disabled\n");
1469 cifs_dbg(VFS, "vers=2.0 mount not permitted when legacy dialects disabled\n");
1471 #endif /* CIFS_ALLOW_INSECURE_LEGACY */
1473 vol->ops = &smb21_operations;
1474 vol->vals = &smb21_values;
1477 vol->ops = &smb30_operations;
1478 vol->vals = &smb30_values;
1481 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1482 vol->vals = &smb302_values;
1485 vol->ops = &smb311_operations;
1486 vol->vals = &smb311_values;
1489 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1490 vol->vals = &smb3any_values;
1493 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1494 vol->vals = &smbdefault_values;
1497 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
1504 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1505 * fields with the result. Returns 0 on success and an error otherwise.
1508 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1511 const char *delims = "/\\";
1514 if (unlikely(!devname || !*devname)) {
1515 cifs_dbg(VFS, "Device name not specified.\n");
1519 /* make sure we have a valid UNC double delimiter prefix */
1520 len = strspn(devname, delims);
1524 /* find delimiter between host and sharename */
1525 pos = strpbrk(devname + 2, delims);
1529 /* skip past delimiter */
1532 /* now go until next delimiter or end of string */
1533 len = strcspn(pos, delims);
1535 /* move "pos" up to delimiter or NULL */
1537 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1541 convert_delimiter(vol->UNC, '\\');
1543 /* skip any delimiter */
1544 if (*pos == '/' || *pos == '\\')
1547 /* If pos is NULL then no prepath */
1551 vol->prepath = kstrdup(pos, GFP_KERNEL);
1559 cifs_parse_mount_options(const char *mountdata, const char *devname,
1560 struct smb_vol *vol, bool is_smb3)
1563 char *mountdata_copy = NULL, *options;
1564 unsigned int temp_len, i, j;
1566 short int override_uid = -1;
1567 short int override_gid = -1;
1568 bool uid_specified = false;
1569 bool gid_specified = false;
1570 bool sloppy = false;
1571 char *invalid = NULL;
1572 char *nodename = utsname()->nodename;
1573 char *string = NULL;
1574 char *tmp_end, *value;
1576 bool got_ip = false;
1577 bool got_version = false;
1578 unsigned short port = 0;
1579 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1583 delim = separator[0];
1585 /* ensure we always start with zeroed-out smb_vol */
1586 memset(vol, 0, sizeof(*vol));
1589 * does not have to be perfect mapping since field is
1590 * informational, only used for servers that do not support
1591 * port 445 and it can be overridden at mount time
1593 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1594 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1595 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1597 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1598 /* null target name indicates to use *SMBSERVR default called name
1599 if we end up sending RFC1001 session initialize */
1600 vol->target_rfc1001_name[0] = 0;
1601 vol->cred_uid = current_uid();
1602 vol->linux_uid = current_uid();
1603 vol->linux_gid = current_gid();
1604 vol->bsize = 1024 * 1024; /* can improve cp performance significantly */
1606 * default to SFM style remapping of seven reserved characters
1607 * unless user overrides it or we negotiate CIFS POSIX where
1608 * it is unnecessary. Can not simultaneously use more than one mapping
1609 * since then readdir could list files that open could not open
1613 /* default to only allowing write access to owner of the mount */
1614 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1616 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1617 /* default is always to request posix paths. */
1618 vol->posix_paths = 1;
1619 /* default to using server inode numbers where available */
1620 vol->server_ino = 1;
1622 /* default is to use strict cifs caching semantics */
1623 vol->strict_io = true;
1625 vol->actimeo = CIFS_DEF_ACTIMEO;
1627 /* Most clients set timeout to 0, allows server to use its default */
1628 vol->handle_timeout = 0; /* See MS-SMB2 spec section 2.2.14.2.12 */
1630 /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1631 vol->ops = &smb30_operations;
1632 vol->vals = &smbdefault_values;
1634 vol->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1637 goto cifs_parse_mount_err;
1639 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1640 if (!mountdata_copy)
1641 goto cifs_parse_mount_err;
1643 options = mountdata_copy;
1644 end = options + strlen(options);
1646 if (strncmp(options, "sep=", 4) == 0) {
1647 if (options[4] != 0) {
1648 separator[0] = options[4];
1651 cifs_dbg(FYI, "Null separator not allowed\n");
1654 vol->backupuid_specified = false; /* no backup intent for a user */
1655 vol->backupgid_specified = false; /* no backup intent for a group */
1657 switch (cifs_parse_devname(devname, vol)) {
1661 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1662 goto cifs_parse_mount_err;
1664 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1665 goto cifs_parse_mount_err;
1667 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1668 goto cifs_parse_mount_err;
1671 while ((data = strsep(&options, separator)) != NULL) {
1672 substring_t args[MAX_OPT_ARGS];
1673 unsigned long option;
1679 token = match_token(data, cifs_mount_option_tokens, args);
1683 /* Ingnore the following */
1687 /* Boolean values */
1688 case Opt_user_xattr:
1691 case Opt_nouser_xattr:
1697 case Opt_noforceuid:
1703 case Opt_noforcegid:
1706 case Opt_noblocksend:
1707 vol->noblocksnd = 1;
1709 case Opt_noautotune:
1710 vol->noautotune = 1;
1725 vol->sfu_remap = true;
1726 vol->remap = false; /* disable SFM mapping */
1728 case Opt_nomapchars:
1729 vol->sfu_remap = false;
1733 vol->sfu_remap = false; /* disable SFU mapping */
1735 case Opt_nomapposix:
1747 case Opt_posixpaths:
1748 vol->posix_paths = 1;
1750 case Opt_noposixpaths:
1751 vol->posix_paths = 0;
1756 "conflicting unix mount options\n");
1757 vol->no_linux_ext = 1;
1760 if (vol->no_linux_ext)
1762 "conflicting unix mount options\n");
1774 * turn off mandatory locking in mode
1775 * if remote locking is turned off since the
1776 * local vfs will do advisory
1778 if (vol->file_mode ==
1779 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1780 vol->file_mode = S_IALLUGO;
1782 case Opt_nohandlecache:
1783 vol->nohandlecache = 1;
1785 case Opt_handlecache:
1786 vol->nohandlecache = 0;
1788 case Opt_forcemandatorylock:
1797 case Opt_setuidfromacl:
1798 vol->setuidfromacl = 1;
1801 vol->dynperm = true;
1804 vol->dynperm = false;
1818 case Opt_nostrictsync:
1819 vol->nostrictsync = 1;
1821 case Opt_strictsync:
1822 vol->nostrictsync = 0;
1825 vol->server_ino = 1;
1827 case Opt_noserverino:
1828 vol->server_ino = 0;
1830 case Opt_rwpidforward:
1831 vol->rwpidforward = 1;
1840 vol->no_psx_acl = 0;
1843 vol->no_psx_acl = 1;
1845 case Opt_locallease:
1846 vol->local_lease = 1;
1852 /* we do not do the following in secFlags because seal
1853 * is a per tree connection (mount) not a per socket
1854 * or per-smb connection option in the protocol
1855 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1860 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1863 #ifndef CONFIG_CIFS_FSCACHE
1864 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1865 goto cifs_parse_mount_err;
1869 case Opt_mfsymlinks:
1870 vol->mfsymlinks = true;
1873 vol->multiuser = true;
1878 case Opt_nosharesock:
1879 vol->nosharesock = true;
1881 case Opt_nopersistent:
1882 vol->nopersistent = true;
1883 if (vol->persistent) {
1885 "persistenthandles mount options conflict\n");
1886 goto cifs_parse_mount_err;
1889 case Opt_persistent:
1890 vol->persistent = true;
1891 if ((vol->nopersistent) || (vol->resilient)) {
1893 "persistenthandles mount options conflict\n");
1894 goto cifs_parse_mount_err;
1898 vol->resilient = true;
1899 if (vol->persistent) {
1901 "persistenthandles mount options conflict\n");
1902 goto cifs_parse_mount_err;
1905 case Opt_noresilient:
1906 vol->resilient = false; /* already the default */
1908 case Opt_domainauto:
1909 vol->domainauto = true;
1915 /* Numeric Values */
1917 if (get_option_uid(args, &vol->backupuid)) {
1918 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1920 goto cifs_parse_mount_err;
1922 vol->backupuid_specified = true;
1925 if (get_option_gid(args, &vol->backupgid)) {
1926 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1928 goto cifs_parse_mount_err;
1930 vol->backupgid_specified = true;
1933 if (get_option_uid(args, &vol->linux_uid)) {
1934 cifs_dbg(VFS, "%s: Invalid uid value\n",
1936 goto cifs_parse_mount_err;
1938 uid_specified = true;
1941 if (get_option_uid(args, &vol->cred_uid)) {
1942 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1944 goto cifs_parse_mount_err;
1948 if (get_option_gid(args, &vol->linux_gid)) {
1949 cifs_dbg(VFS, "%s: Invalid gid value\n",
1951 goto cifs_parse_mount_err;
1953 gid_specified = true;
1956 if (get_option_ul(args, &option)) {
1957 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1959 goto cifs_parse_mount_err;
1961 vol->file_mode = option;
1964 if (get_option_ul(args, &option)) {
1965 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1967 goto cifs_parse_mount_err;
1969 vol->dir_mode = option;
1972 if (get_option_ul(args, &option) ||
1973 option > USHRT_MAX) {
1974 cifs_dbg(VFS, "%s: Invalid port value\n",
1976 goto cifs_parse_mount_err;
1978 port = (unsigned short)option;
1981 if (get_option_ul(args, &option)) {
1982 cifs_dbg(VFS, "%s: Invalid blocksize value\n",
1984 goto cifs_parse_mount_err;
1987 * inode blocksize realistically should never need to be
1988 * less than 16K or greater than 16M and default is 1MB.
1989 * Note that small inode block sizes (e.g. 64K) can lead
1990 * to very poor performance of common tools like cp and scp
1992 if ((option < CIFS_MAX_MSGSIZE) ||
1993 (option > (4 * SMB3_DEFAULT_IOSIZE))) {
1994 cifs_dbg(VFS, "%s: Invalid blocksize\n",
1996 goto cifs_parse_mount_err;
1998 vol->bsize = option;
2001 if (get_option_ul(args, &option)) {
2002 cifs_dbg(VFS, "%s: Invalid rsize value\n",
2004 goto cifs_parse_mount_err;
2006 vol->rsize = option;
2009 if (get_option_ul(args, &option)) {
2010 cifs_dbg(VFS, "%s: Invalid wsize value\n",
2012 goto cifs_parse_mount_err;
2014 vol->wsize = option;
2017 if (get_option_ul(args, &option)) {
2018 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
2020 goto cifs_parse_mount_err;
2022 vol->actimeo = HZ * option;
2023 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
2024 cifs_dbg(VFS, "attribute cache timeout too large\n");
2025 goto cifs_parse_mount_err;
2028 case Opt_handletimeout:
2029 if (get_option_ul(args, &option)) {
2030 cifs_dbg(VFS, "%s: Invalid handletimeout value\n",
2032 goto cifs_parse_mount_err;
2034 vol->handle_timeout = option;
2035 if (vol->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) {
2036 cifs_dbg(VFS, "Invalid handle cache timeout, longer than 16 minutes\n");
2037 goto cifs_parse_mount_err;
2040 case Opt_echo_interval:
2041 if (get_option_ul(args, &option)) {
2042 cifs_dbg(VFS, "%s: Invalid echo interval value\n",
2044 goto cifs_parse_mount_err;
2046 vol->echo_interval = option;
2049 if (get_option_ul(args, &option)) {
2050 cifs_dbg(VFS, "%s: Invalid snapshot time\n",
2052 goto cifs_parse_mount_err;
2054 vol->snapshot_time = option;
2056 case Opt_max_credits:
2057 if (get_option_ul(args, &option) || (option < 20) ||
2059 cifs_dbg(VFS, "%s: Invalid max_credits value\n",
2061 goto cifs_parse_mount_err;
2063 vol->max_credits = option;
2066 /* String Arguments */
2068 case Opt_blank_user:
2069 /* null user, ie. anonymous authentication */
2071 vol->username = NULL;
2074 string = match_strdup(args);
2078 if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
2079 CIFS_MAX_USERNAME_LEN) {
2080 pr_warn("CIFS: username too long\n");
2081 goto cifs_parse_mount_err;
2084 kfree(vol->username);
2085 vol->username = kstrdup(string, GFP_KERNEL);
2087 goto cifs_parse_mount_err;
2089 case Opt_blank_pass:
2090 /* passwords have to be handled differently
2091 * to allow the character used for deliminator
2092 * to be passed within them
2096 * Check if this is a case where the password
2097 * starts with a delimiter
2099 tmp_end = strchr(data, '=');
2101 if (!(tmp_end < end && tmp_end[1] == delim)) {
2102 /* No it is not. Set the password to NULL */
2103 kzfree(vol->password);
2104 vol->password = NULL;
2107 /* Fallthrough - to Opt_pass below.*/
2109 /* Obtain the value string */
2110 value = strchr(data, '=');
2113 /* Set tmp_end to end of the string */
2114 tmp_end = (char *) value + strlen(value);
2116 /* Check if following character is the deliminator
2117 * If yes, we have encountered a double deliminator
2118 * reset the NULL character to the deliminator
2120 if (tmp_end < end && tmp_end[1] == delim) {
2123 /* Keep iterating until we get to a single
2124 * deliminator OR the end
2126 while ((tmp_end = strchr(tmp_end, delim))
2127 != NULL && (tmp_end[1] == delim)) {
2128 tmp_end = (char *) &tmp_end[2];
2131 /* Reset var options to point to next element */
2134 options = (char *) &tmp_end[1];
2136 /* Reached the end of the mount option
2141 kzfree(vol->password);
2142 /* Now build new password string */
2143 temp_len = strlen(value);
2144 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
2145 if (vol->password == NULL) {
2146 pr_warn("CIFS: no memory for password\n");
2147 goto cifs_parse_mount_err;
2150 for (i = 0, j = 0; i < temp_len; i++, j++) {
2151 vol->password[j] = value[i];
2152 if ((value[i] == delim) &&
2153 value[i+1] == delim)
2154 /* skip the second deliminator */
2157 vol->password[j] = '\0';
2160 /* FIXME: should this be an error instead? */
2164 string = match_strdup(args);
2168 if (!cifs_convert_address(dstaddr, string,
2170 pr_err("CIFS: bad ip= option (%s).\n", string);
2171 goto cifs_parse_mount_err;
2176 string = match_strdup(args);
2180 if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
2181 == CIFS_MAX_DOMAINNAME_LEN) {
2182 pr_warn("CIFS: domain name too long\n");
2183 goto cifs_parse_mount_err;
2186 kfree(vol->domainname);
2187 vol->domainname = kstrdup(string, GFP_KERNEL);
2188 if (!vol->domainname) {
2189 pr_warn("CIFS: no memory for domainname\n");
2190 goto cifs_parse_mount_err;
2192 cifs_dbg(FYI, "Domain name set\n");
2195 string = match_strdup(args);
2199 if (!cifs_convert_address(
2200 (struct sockaddr *)&vol->srcaddr,
2201 string, strlen(string))) {
2202 pr_warn("CIFS: Could not parse srcaddr: %s\n",
2204 goto cifs_parse_mount_err;
2208 string = match_strdup(args);
2212 if (strnlen(string, 1024) >= 65) {
2213 pr_warn("CIFS: iocharset name too long.\n");
2214 goto cifs_parse_mount_err;
2217 if (strncasecmp(string, "default", 7) != 0) {
2218 kfree(vol->iocharset);
2219 vol->iocharset = kstrdup(string,
2221 if (!vol->iocharset) {
2222 pr_warn("CIFS: no memory for charset\n");
2223 goto cifs_parse_mount_err;
2226 /* if iocharset not set then load_nls_default
2229 cifs_dbg(FYI, "iocharset set to %s\n", string);
2231 case Opt_netbiosname:
2232 string = match_strdup(args);
2236 memset(vol->source_rfc1001_name, 0x20,
2239 * FIXME: are there cases in which a comma can
2240 * be valid in workstation netbios name (and
2241 * need special handling)?
2243 for (i = 0; i < RFC1001_NAME_LEN; i++) {
2244 /* don't ucase netbiosname for user */
2247 vol->source_rfc1001_name[i] = string[i];
2249 /* The string has 16th byte zero still from
2250 * set at top of the function
2252 if (i == RFC1001_NAME_LEN && string[i] != 0)
2253 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
2256 /* servernetbiosname specified override *SMBSERVER */
2257 string = match_strdup(args);
2261 /* last byte, type, is 0x20 for servr type */
2262 memset(vol->target_rfc1001_name, 0x20,
2263 RFC1001_NAME_LEN_WITH_NULL);
2265 /* BB are there cases in which a comma can be
2266 valid in this workstation netbios name
2267 (and need special handling)? */
2269 /* user or mount helper must uppercase the
2271 for (i = 0; i < 15; i++) {
2274 vol->target_rfc1001_name[i] = string[i];
2276 /* The string has 16th byte zero still from
2277 set at top of the function */
2278 if (i == RFC1001_NAME_LEN && string[i] != 0)
2279 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
2282 /* version of mount userspace tools, not dialect */
2283 string = match_strdup(args);
2287 /* If interface changes in mount.cifs bump to new ver */
2288 if (strncasecmp(string, "1", 1) == 0) {
2289 if (strlen(string) > 1) {
2290 pr_warn("Bad mount helper ver=%s. Did "
2291 "you want SMB1 (CIFS) dialect "
2292 "and mean to type vers=1.0 "
2293 "instead?\n", string);
2294 goto cifs_parse_mount_err;
2296 /* This is the default */
2299 /* For all other value, error */
2300 pr_warn("CIFS: Invalid mount helper version specified\n");
2301 goto cifs_parse_mount_err;
2303 /* protocol version (dialect) */
2304 string = match_strdup(args);
2308 if (cifs_parse_smb_version(string, vol, is_smb3) != 0)
2309 goto cifs_parse_mount_err;
2313 string = match_strdup(args);
2317 if (cifs_parse_security_flavors(string, vol) != 0)
2318 goto cifs_parse_mount_err;
2321 string = match_strdup(args);
2325 if (cifs_parse_cache_flavor(string, vol) != 0)
2326 goto cifs_parse_mount_err;
2330 * An option we don't recognize. Save it off for later
2331 * if we haven't already found one
2337 /* Free up any allocated string */
2342 if (!sloppy && invalid) {
2343 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
2344 goto cifs_parse_mount_err;
2347 if (vol->rdma && vol->vals->protocol_id < SMB30_PROT_ID) {
2348 cifs_dbg(VFS, "SMB Direct requires Version >=3.0\n");
2349 goto cifs_parse_mount_err;
2353 /* Muliuser mounts require CONFIG_KEYS support */
2354 if (vol->multiuser) {
2355 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
2356 goto cifs_parse_mount_err;
2360 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
2361 goto cifs_parse_mount_err;
2364 /* make sure UNC has a share name */
2365 if (!strchr(vol->UNC + 3, '\\')) {
2366 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
2367 goto cifs_parse_mount_err;
2374 /* No ip= option specified? Try to get it from UNC */
2375 /* Use the address part of the UNC. */
2376 slash = strchr(&vol->UNC[2], '\\');
2377 len = slash - &vol->UNC[2];
2378 if (!cifs_convert_address(dstaddr, &vol->UNC[2], len)) {
2379 pr_err("Unable to determine destination address.\n");
2380 goto cifs_parse_mount_err;
2384 /* set the port that we got earlier */
2385 cifs_set_port(dstaddr, port);
2388 vol->override_uid = override_uid;
2389 else if (override_uid == 1)
2390 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
2393 vol->override_gid = override_gid;
2394 else if (override_gid == 1)
2395 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
2397 if (got_version == false)
2398 pr_warn("No dialect specified on mount. Default has changed to "
2399 "a more secure dialect, SMB2.1 or later (e.g. SMB3), from CIFS "
2400 "(SMB1). To use the less secure SMB1 dialect to access "
2401 "old servers which do not support SMB3 (or SMB2.1) specify vers=1.0"
2404 kfree(mountdata_copy);
2408 pr_warn("Could not allocate temporary buffer\n");
2409 cifs_parse_mount_err:
2411 kfree(mountdata_copy);
2415 /** Returns true if srcaddr isn't specified and rhs isn't
2416 * specified, or if srcaddr is specified and
2417 * matches the IP address of the rhs argument.
2420 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
2422 switch (srcaddr->sa_family) {
2424 return (rhs->sa_family == AF_UNSPEC);
2426 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
2427 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
2428 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
2431 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
2432 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
2433 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
2437 return false; /* don't expect to be here */
2442 * If no port is specified in addr structure, we try to match with 445 port
2443 * and if it fails - with 139 ports. It should be called only if address
2444 * families of server and addr are equal.
2447 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
2449 __be16 port, *sport;
2451 /* SMBDirect manages its own ports, don't match it here */
2455 switch (addr->sa_family) {
2457 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
2458 port = ((struct sockaddr_in *) addr)->sin_port;
2461 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
2462 port = ((struct sockaddr_in6 *) addr)->sin6_port;
2470 port = htons(CIFS_PORT);
2474 port = htons(RFC1001_PORT);
2477 return port == *sport;
2481 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
2482 struct sockaddr *srcaddr)
2484 switch (addr->sa_family) {
2486 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2487 struct sockaddr_in *srv_addr4 =
2488 (struct sockaddr_in *)&server->dstaddr;
2490 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2495 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2496 struct sockaddr_in6 *srv_addr6 =
2497 (struct sockaddr_in6 *)&server->dstaddr;
2499 if (!ipv6_addr_equal(&addr6->sin6_addr,
2500 &srv_addr6->sin6_addr))
2502 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2508 return false; /* don't expect to be here */
2511 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2518 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2521 * The select_sectype function should either return the vol->sectype
2522 * that was specified, or "Unspecified" if that sectype was not
2523 * compatible with the given NEGOTIATE request.
2525 if (server->ops->select_sectype(server, vol->sectype)
2530 * Now check if signing mode is acceptable. No need to check
2531 * global_secflags at this point since if MUST_SIGN is set then
2532 * the server->sign had better be too.
2534 if (vol->sign && !server->sign)
2540 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2542 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2544 if (vol->nosharesock)
2547 /* BB update this for smb3any and default case */
2548 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2551 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2554 if (!match_address(server, addr,
2555 (struct sockaddr *)&vol->srcaddr))
2558 if (!match_port(server, addr))
2561 if (!match_security(server, vol))
2564 if (server->echo_interval != vol->echo_interval * HZ)
2567 if (server->rdma != vol->rdma)
2573 struct TCP_Server_Info *
2574 cifs_find_tcp_session(struct smb_vol *vol)
2576 struct TCP_Server_Info *server;
2578 spin_lock(&cifs_tcp_ses_lock);
2579 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2580 if (!match_server(server, vol))
2583 ++server->srv_count;
2584 spin_unlock(&cifs_tcp_ses_lock);
2585 cifs_dbg(FYI, "Existing tcp session with server found\n");
2588 spin_unlock(&cifs_tcp_ses_lock);
2593 cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
2595 struct task_struct *task;
2597 spin_lock(&cifs_tcp_ses_lock);
2598 if (--server->srv_count > 0) {
2599 spin_unlock(&cifs_tcp_ses_lock);
2603 put_net(cifs_net_ns(server));
2605 list_del_init(&server->tcp_ses_list);
2606 spin_unlock(&cifs_tcp_ses_lock);
2608 cancel_delayed_work_sync(&server->echo);
2612 * Avoid deadlock here: reconnect work calls
2613 * cifs_put_tcp_session() at its end. Need to be sure
2614 * that reconnect work does nothing with server pointer after
2617 cancel_delayed_work(&server->reconnect);
2619 cancel_delayed_work_sync(&server->reconnect);
2621 spin_lock(&GlobalMid_Lock);
2622 server->tcpStatus = CifsExiting;
2623 spin_unlock(&GlobalMid_Lock);
2625 cifs_crypto_secmech_release(server);
2626 cifs_fscache_release_client_cookie(server);
2628 kfree(server->session_key.response);
2629 server->session_key.response = NULL;
2630 server->session_key.len = 0;
2632 task = xchg(&server->tsk, NULL);
2634 force_sig(SIGKILL, task);
2637 static struct TCP_Server_Info *
2638 cifs_get_tcp_session(struct smb_vol *volume_info)
2640 struct TCP_Server_Info *tcp_ses = NULL;
2643 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2645 /* see if we already have a matching tcp_ses */
2646 tcp_ses = cifs_find_tcp_session(volume_info);
2650 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2656 tcp_ses->ops = volume_info->ops;
2657 tcp_ses->vals = volume_info->vals;
2658 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2659 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2660 if (IS_ERR(tcp_ses->hostname)) {
2661 rc = PTR_ERR(tcp_ses->hostname);
2662 goto out_err_crypto_release;
2665 tcp_ses->noblocksnd = volume_info->noblocksnd;
2666 tcp_ses->noautotune = volume_info->noautotune;
2667 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2668 tcp_ses->rdma = volume_info->rdma;
2669 tcp_ses->in_flight = 0;
2670 tcp_ses->credits = 1;
2671 init_waitqueue_head(&tcp_ses->response_q);
2672 init_waitqueue_head(&tcp_ses->request_q);
2673 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2674 mutex_init(&tcp_ses->srv_mutex);
2675 memcpy(tcp_ses->workstation_RFC1001_name,
2676 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2677 memcpy(tcp_ses->server_RFC1001_name,
2678 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2679 tcp_ses->session_estab = false;
2680 tcp_ses->sequence_number = 0;
2681 tcp_ses->reconnect_instance = 1;
2682 tcp_ses->lstrp = jiffies;
2683 spin_lock_init(&tcp_ses->req_lock);
2684 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2685 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2686 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2687 INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
2688 mutex_init(&tcp_ses->reconnect_mutex);
2689 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2690 sizeof(tcp_ses->srcaddr));
2691 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2692 sizeof(tcp_ses->dstaddr));
2693 generate_random_uuid(tcp_ses->client_guid);
2695 * at this point we are the only ones with the pointer
2696 * to the struct since the kernel thread not created yet
2697 * no need to spinlock this init of tcpStatus or srv_count
2699 tcp_ses->tcpStatus = CifsNew;
2700 ++tcp_ses->srv_count;
2702 if (volume_info->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
2703 volume_info->echo_interval <= SMB_ECHO_INTERVAL_MAX)
2704 tcp_ses->echo_interval = volume_info->echo_interval * HZ;
2706 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
2707 if (tcp_ses->rdma) {
2708 #ifndef CONFIG_CIFS_SMB_DIRECT
2709 cifs_dbg(VFS, "CONFIG_CIFS_SMB_DIRECT is not enabled\n");
2711 goto out_err_crypto_release;
2713 tcp_ses->smbd_conn = smbd_get_connection(
2714 tcp_ses, (struct sockaddr *)&volume_info->dstaddr);
2715 if (tcp_ses->smbd_conn) {
2716 cifs_dbg(VFS, "RDMA transport established\n");
2718 goto smbd_connected;
2721 goto out_err_crypto_release;
2724 rc = ip_connect(tcp_ses);
2726 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2727 goto out_err_crypto_release;
2731 * since we're in a cifs function already, we know that
2732 * this will succeed. No need for try_module_get().
2734 __module_get(THIS_MODULE);
2735 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2737 if (IS_ERR(tcp_ses->tsk)) {
2738 rc = PTR_ERR(tcp_ses->tsk);
2739 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2740 module_put(THIS_MODULE);
2741 goto out_err_crypto_release;
2743 tcp_ses->tcpStatus = CifsNeedNegotiate;
2745 tcp_ses->nr_targets = 1;
2747 /* thread spawned, put it on the list */
2748 spin_lock(&cifs_tcp_ses_lock);
2749 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2750 spin_unlock(&cifs_tcp_ses_lock);
2752 cifs_fscache_get_client_cookie(tcp_ses);
2754 /* queue echo request delayed work */
2755 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
2759 out_err_crypto_release:
2760 cifs_crypto_secmech_release(tcp_ses);
2762 put_net(cifs_net_ns(tcp_ses));
2766 if (!IS_ERR(tcp_ses->hostname))
2767 kfree(tcp_ses->hostname);
2768 if (tcp_ses->ssocket)
2769 sock_release(tcp_ses->ssocket);
2775 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2777 if (vol->sectype != Unspecified &&
2778 vol->sectype != ses->sectype)
2781 switch (ses->sectype) {
2783 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2787 /* NULL username means anonymous session */
2788 if (ses->user_name == NULL) {
2794 /* anything else takes username/password */
2795 if (strncmp(ses->user_name,
2796 vol->username ? vol->username : "",
2797 CIFS_MAX_USERNAME_LEN))
2799 if ((vol->username && strlen(vol->username) != 0) &&
2800 ses->password != NULL &&
2801 strncmp(ses->password,
2802 vol->password ? vol->password : "",
2803 CIFS_MAX_PASSWORD_LEN))
2810 * cifs_setup_ipc - helper to setup the IPC tcon for the session
2812 * A new IPC connection is made and stored in the session
2813 * tcon_ipc. The IPC tcon has the same lifetime as the session.
2816 cifs_setup_ipc(struct cifs_ses *ses, struct smb_vol *volume_info)
2819 struct cifs_tcon *tcon;
2820 struct nls_table *nls_codepage;
2821 char unc[SERVER_NAME_LENGTH + sizeof("//x/IPC$")] = {0};
2825 * If the mount request that resulted in the creation of the
2826 * session requires encryption, force IPC to be encrypted too.
2828 if (volume_info->seal) {
2829 if (ses->server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION)
2833 "IPC: server doesn't support encryption\n");
2838 tcon = tconInfoAlloc();
2842 scnprintf(unc, sizeof(unc), "\\\\%s\\IPC$", ses->server->hostname);
2845 nls_codepage = load_nls_default();
2851 rc = ses->server->ops->tree_connect(xid, ses, unc, tcon, nls_codepage);
2855 cifs_dbg(VFS, "failed to connect to IPC (rc=%d)\n", rc);
2860 cifs_dbg(FYI, "IPC tcon rc = %d ipc tid = %d\n", rc, tcon->tid);
2862 ses->tcon_ipc = tcon;
2864 unload_nls(nls_codepage);
2869 * cifs_free_ipc - helper to release the session IPC tcon
2871 * Needs to be called everytime a session is destroyed
2874 cifs_free_ipc(struct cifs_ses *ses)
2877 struct cifs_tcon *tcon = ses->tcon_ipc;
2882 if (ses->server->ops->tree_disconnect) {
2884 rc = ses->server->ops->tree_disconnect(xid, tcon);
2889 cifs_dbg(FYI, "failed to disconnect IPC tcon (rc=%d)\n", rc);
2892 ses->tcon_ipc = NULL;
2896 static struct cifs_ses *
2897 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2899 struct cifs_ses *ses;
2901 spin_lock(&cifs_tcp_ses_lock);
2902 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2903 if (ses->status == CifsExiting)
2905 if (!match_session(ses, vol))
2908 spin_unlock(&cifs_tcp_ses_lock);
2911 spin_unlock(&cifs_tcp_ses_lock);
2915 void cifs_put_smb_ses(struct cifs_ses *ses)
2917 unsigned int rc, xid;
2918 struct TCP_Server_Info *server = ses->server;
2920 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
2922 spin_lock(&cifs_tcp_ses_lock);
2923 if (ses->status == CifsExiting) {
2924 spin_unlock(&cifs_tcp_ses_lock);
2927 if (--ses->ses_count > 0) {
2928 spin_unlock(&cifs_tcp_ses_lock);
2931 if (ses->status == CifsGood)
2932 ses->status = CifsExiting;
2933 spin_unlock(&cifs_tcp_ses_lock);
2937 if (ses->status == CifsExiting && server->ops->logoff) {
2939 rc = server->ops->logoff(xid, ses);
2941 cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2946 spin_lock(&cifs_tcp_ses_lock);
2947 list_del_init(&ses->smb_ses_list);
2948 spin_unlock(&cifs_tcp_ses_lock);
2951 cifs_put_tcp_session(server, 0);
2956 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2957 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2959 /* Populate username and pw fields from keyring if possible */
2961 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2964 const char *delim, *payload;
2968 struct TCP_Server_Info *server = ses->server;
2969 struct sockaddr_in *sa;
2970 struct sockaddr_in6 *sa6;
2971 const struct user_key_payload *upayload;
2973 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2977 /* try to find an address key first */
2978 switch (server->dstaddr.ss_family) {
2980 sa = (struct sockaddr_in *)&server->dstaddr;
2981 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2984 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2985 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2988 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2989 server->dstaddr.ss_family);
2994 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2995 key = request_key(&key_type_logon, desc, "");
2997 if (!ses->domainName) {
2998 cifs_dbg(FYI, "domainName is NULL\n");
3003 /* didn't work, try to find a domain key */
3004 sprintf(desc, "cifs:d:%s", ses->domainName);
3005 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
3006 key = request_key(&key_type_logon, desc, "");
3013 down_read(&key->sem);
3014 upayload = user_key_payload_locked(key);
3015 if (IS_ERR_OR_NULL(upayload)) {
3016 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
3020 /* find first : in payload */
3021 payload = upayload->data;
3022 delim = strnchr(payload, upayload->datalen, ':');
3023 cifs_dbg(FYI, "payload=%s\n", payload);
3025 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
3031 len = delim - payload;
3032 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
3033 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
3039 vol->username = kstrndup(payload, len, GFP_KERNEL);
3040 if (!vol->username) {
3041 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
3046 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
3048 len = key->datalen - (len + 1);
3049 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
3050 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
3052 kfree(vol->username);
3053 vol->username = NULL;
3058 vol->password = kstrndup(delim, len, GFP_KERNEL);
3059 if (!vol->password) {
3060 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
3063 kfree(vol->username);
3064 vol->username = NULL;
3073 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
3076 #else /* ! CONFIG_KEYS */
3078 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
3079 struct cifs_ses *ses __attribute__((unused)))
3083 #endif /* CONFIG_KEYS */
3086 * cifs_get_smb_ses - get a session matching @volume_info data from @server
3088 * This function assumes it is being called from cifs_mount() where we
3089 * already got a server reference (server refcount +1). See
3090 * cifs_get_tcon() for refcount explanations.
3093 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
3097 struct cifs_ses *ses;
3098 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3099 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3103 ses = cifs_find_smb_ses(server, volume_info);
3105 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
3108 mutex_lock(&ses->session_mutex);
3109 rc = cifs_negotiate_protocol(xid, ses);
3111 mutex_unlock(&ses->session_mutex);
3112 /* problem -- put our ses reference */
3113 cifs_put_smb_ses(ses);
3117 if (ses->need_reconnect) {
3118 cifs_dbg(FYI, "Session needs reconnect\n");
3119 rc = cifs_setup_session(xid, ses,
3120 volume_info->local_nls);
3122 mutex_unlock(&ses->session_mutex);
3123 /* problem -- put our reference */
3124 cifs_put_smb_ses(ses);
3129 mutex_unlock(&ses->session_mutex);
3131 /* existing SMB ses has a server reference already */
3132 cifs_put_tcp_session(server, 0);
3137 cifs_dbg(FYI, "Existing smb sess not found\n");
3138 ses = sesInfoAlloc();
3142 /* new SMB session uses our server ref */
3143 ses->server = server;
3144 if (server->dstaddr.ss_family == AF_INET6)
3145 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
3147 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
3149 if (volume_info->username) {
3150 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
3151 if (!ses->user_name)
3155 /* volume_info->password freed at unmount */
3156 if (volume_info->password) {
3157 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
3161 if (volume_info->domainname) {
3162 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
3163 if (!ses->domainName)
3166 if (volume_info->domainauto)
3167 ses->domainAuto = volume_info->domainauto;
3168 ses->cred_uid = volume_info->cred_uid;
3169 ses->linux_uid = volume_info->linux_uid;
3171 ses->sectype = volume_info->sectype;
3172 ses->sign = volume_info->sign;
3174 mutex_lock(&ses->session_mutex);
3175 rc = cifs_negotiate_protocol(xid, ses);
3177 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
3178 mutex_unlock(&ses->session_mutex);
3182 /* success, put it on the list */
3183 spin_lock(&cifs_tcp_ses_lock);
3184 list_add(&ses->smb_ses_list, &server->smb_ses_list);
3185 spin_unlock(&cifs_tcp_ses_lock);
3189 cifs_setup_ipc(ses, volume_info);
3199 static int match_tcon(struct cifs_tcon *tcon, struct smb_vol *volume_info)
3201 if (tcon->tidStatus == CifsExiting)
3203 if (strncmp(tcon->treeName, volume_info->UNC, MAX_TREE_SIZE))
3205 if (tcon->seal != volume_info->seal)
3207 if (tcon->snapshot_time != volume_info->snapshot_time)
3209 if (tcon->handle_timeout != volume_info->handle_timeout)
3214 static struct cifs_tcon *
3215 cifs_find_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
3217 struct list_head *tmp;
3218 struct cifs_tcon *tcon;
3220 spin_lock(&cifs_tcp_ses_lock);
3221 list_for_each(tmp, &ses->tcon_list) {
3222 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
3223 if (!match_tcon(tcon, volume_info))
3226 spin_unlock(&cifs_tcp_ses_lock);
3229 spin_unlock(&cifs_tcp_ses_lock);
3234 cifs_put_tcon(struct cifs_tcon *tcon)
3237 struct cifs_ses *ses;
3240 * IPC tcon share the lifetime of their session and are
3241 * destroyed in the session put function
3243 if (tcon == NULL || tcon->ipc)
3247 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
3248 spin_lock(&cifs_tcp_ses_lock);
3249 if (--tcon->tc_count > 0) {
3250 spin_unlock(&cifs_tcp_ses_lock);
3254 list_del_init(&tcon->tcon_list);
3255 spin_unlock(&cifs_tcp_ses_lock);
3258 if (ses->server->ops->tree_disconnect)
3259 ses->server->ops->tree_disconnect(xid, tcon);
3262 cifs_fscache_release_super_cookie(tcon);
3264 cifs_put_smb_ses(ses);
3268 * cifs_get_tcon - get a tcon matching @volume_info data from @ses
3270 * - tcon refcount is the number of mount points using the tcon.
3271 * - ses refcount is the number of tcon using the session.
3273 * 1. This function assumes it is being called from cifs_mount() where
3274 * we already got a session reference (ses refcount +1).
3276 * 2. Since we're in the context of adding a mount point, the end
3277 * result should be either:
3279 * a) a new tcon already allocated with refcount=1 (1 mount point) and
3280 * its session refcount incremented (1 new tcon). This +1 was
3281 * already done in (1).
3283 * b) an existing tcon with refcount+1 (add a mount point to it) and
3284 * identical ses refcount (no new tcon). Because of (1) we need to
3285 * decrement the ses refcount.
3287 static struct cifs_tcon *
3288 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
3291 struct cifs_tcon *tcon;
3293 tcon = cifs_find_tcon(ses, volume_info);
3296 * tcon has refcount already incremented but we need to
3297 * decrement extra ses reference gotten by caller (case b)
3299 cifs_dbg(FYI, "Found match on UNC path\n");
3300 cifs_put_smb_ses(ses);
3304 if (!ses->server->ops->tree_connect) {
3309 tcon = tconInfoAlloc();
3315 if (volume_info->snapshot_time) {
3316 if (ses->server->vals->protocol_id == 0) {
3318 "Use SMB2 or later for snapshot mount option\n");
3322 tcon->snapshot_time = volume_info->snapshot_time;
3325 if (volume_info->handle_timeout) {
3326 if (ses->server->vals->protocol_id == 0) {
3328 "Use SMB2.1 or later for handle timeout option\n");
3332 tcon->handle_timeout = volume_info->handle_timeout;
3336 if (volume_info->password) {
3337 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
3338 if (!tcon->password) {
3344 if (volume_info->seal) {
3345 if (ses->server->vals->protocol_id == 0) {
3347 "SMB3 or later required for encryption\n");
3350 } else if (tcon->ses->server->capabilities &
3351 SMB2_GLOBAL_CAP_ENCRYPTION)
3354 cifs_dbg(VFS, "Encryption is not supported on share\n");
3360 if (volume_info->linux_ext) {
3361 if (ses->server->posix_ext_supported) {
3362 tcon->posix_extensions = true;
3363 printk_once(KERN_WARNING
3364 "SMB3.11 POSIX Extensions are experimental\n");
3366 cifs_dbg(VFS, "Server does not support mounting with posix SMB3.11 extensions.\n");
3373 * BB Do we need to wrap session_mutex around this TCon call and Unix
3374 * SetFS as we do on SessSetup and reconnect?
3377 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
3378 volume_info->local_nls);
3380 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
3384 tcon->use_persistent = false;
3385 /* check if SMB2 or later, CIFS does not support persistent handles */
3386 if (volume_info->persistent) {
3387 if (ses->server->vals->protocol_id == 0) {
3389 "SMB3 or later required for persistent handles\n");
3392 } else if (ses->server->capabilities &
3393 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3394 tcon->use_persistent = true;
3395 else /* persistent handles requested but not supported */ {
3397 "Persistent handles not supported on share\n");
3401 } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
3402 && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3403 && (volume_info->nopersistent == false)) {
3404 cifs_dbg(FYI, "enabling persistent handles\n");
3405 tcon->use_persistent = true;
3406 } else if (volume_info->resilient) {
3407 if (ses->server->vals->protocol_id == 0) {
3409 "SMB2.1 or later required for resilient handles\n");
3413 tcon->use_resilient = true;
3417 * We can have only one retry value for a connection to a share so for
3418 * resources mounted more than once to the same server share the last
3419 * value passed in for the retry flag is used.
3421 tcon->retry = volume_info->retry;
3422 tcon->nocase = volume_info->nocase;
3423 tcon->nohandlecache = volume_info->nohandlecache;
3424 tcon->local_lease = volume_info->local_lease;
3425 INIT_LIST_HEAD(&tcon->pending_opens);
3427 spin_lock(&cifs_tcp_ses_lock);
3428 list_add(&tcon->tcon_list, &ses->tcon_list);
3429 spin_unlock(&cifs_tcp_ses_lock);
3431 cifs_fscache_get_super_cookie(tcon);
3441 cifs_put_tlink(struct tcon_link *tlink)
3443 if (!tlink || IS_ERR(tlink))
3446 if (!atomic_dec_and_test(&tlink->tl_count) ||
3447 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
3448 tlink->tl_time = jiffies;
3452 if (!IS_ERR(tlink_tcon(tlink)))
3453 cifs_put_tcon(tlink_tcon(tlink));
3459 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3461 struct cifs_sb_info *old = CIFS_SB(sb);
3462 struct cifs_sb_info *new = mnt_data->cifs_sb;
3464 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
3467 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
3468 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
3472 * We want to share sb only if we don't specify an r/wsize or
3473 * specified r/wsize is greater than or equal to existing one.
3475 if (new->wsize && new->wsize < old->wsize)
3478 if (new->rsize && new->rsize < old->rsize)
3481 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
3484 if (old->mnt_file_mode != new->mnt_file_mode ||
3485 old->mnt_dir_mode != new->mnt_dir_mode)
3488 if (strcmp(old->local_nls->charset, new->local_nls->charset))
3491 if (old->actimeo != new->actimeo)
3498 match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3500 struct cifs_sb_info *old = CIFS_SB(sb);
3501 struct cifs_sb_info *new = mnt_data->cifs_sb;
3502 bool old_set = old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH;
3503 bool new_set = new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH;
3505 if (old_set && new_set && !strcmp(new->prepath, old->prepath))
3507 else if (!old_set && !new_set)
3514 cifs_match_super(struct super_block *sb, void *data)
3516 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
3517 struct smb_vol *volume_info;
3518 struct cifs_sb_info *cifs_sb;
3519 struct TCP_Server_Info *tcp_srv;
3520 struct cifs_ses *ses;
3521 struct cifs_tcon *tcon;
3522 struct tcon_link *tlink;
3525 spin_lock(&cifs_tcp_ses_lock);
3526 cifs_sb = CIFS_SB(sb);
3527 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3528 if (IS_ERR(tlink)) {
3529 spin_unlock(&cifs_tcp_ses_lock);
3532 tcon = tlink_tcon(tlink);
3534 tcp_srv = ses->server;
3536 volume_info = mnt_data->vol;
3538 if (!match_server(tcp_srv, volume_info) ||
3539 !match_session(ses, volume_info) ||
3540 !match_tcon(tcon, volume_info) ||
3541 !match_prepath(sb, mnt_data)) {
3546 rc = compare_mount_options(sb, mnt_data);
3548 spin_unlock(&cifs_tcp_ses_lock);
3549 cifs_put_tlink(tlink);
3553 #ifdef CONFIG_DEBUG_LOCK_ALLOC
3554 static struct lock_class_key cifs_key[2];
3555 static struct lock_class_key cifs_slock_key[2];
3558 cifs_reclassify_socket4(struct socket *sock)
3560 struct sock *sk = sock->sk;
3561 BUG_ON(!sock_allow_reclassification(sk));
3562 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
3563 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
3567 cifs_reclassify_socket6(struct socket *sock)
3569 struct sock *sk = sock->sk;
3570 BUG_ON(!sock_allow_reclassification(sk));
3571 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
3572 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
3576 cifs_reclassify_socket4(struct socket *sock)
3581 cifs_reclassify_socket6(struct socket *sock)
3586 /* See RFC1001 section 14 on representation of Netbios names */
3587 static void rfc1002mangle(char *target, char *source, unsigned int length)
3591 for (i = 0, j = 0; i < (length); i++) {
3592 /* mask a nibble at a time and encode */
3593 target[j] = 'A' + (0x0F & (source[i] >> 4));
3594 target[j+1] = 'A' + (0x0F & source[i]);
3601 bind_socket(struct TCP_Server_Info *server)
3604 if (server->srcaddr.ss_family != AF_UNSPEC) {
3605 /* Bind to the specified local IP address */
3606 struct socket *socket = server->ssocket;
3607 rc = socket->ops->bind(socket,
3608 (struct sockaddr *) &server->srcaddr,
3609 sizeof(server->srcaddr));
3611 struct sockaddr_in *saddr4;
3612 struct sockaddr_in6 *saddr6;
3613 saddr4 = (struct sockaddr_in *)&server->srcaddr;
3614 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
3615 if (saddr6->sin6_family == AF_INET6)
3616 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
3617 &saddr6->sin6_addr, rc);
3619 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
3620 &saddr4->sin_addr.s_addr, rc);
3627 ip_rfc1001_connect(struct TCP_Server_Info *server)
3631 * some servers require RFC1001 sessinit before sending
3632 * negprot - BB check reconnection in case where second
3633 * sessinit is sent but no second negprot
3635 struct rfc1002_session_packet *ses_init_buf;
3636 struct smb_hdr *smb_buf;
3637 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
3640 ses_init_buf->trailer.session_req.called_len = 32;
3642 if (server->server_RFC1001_name[0] != 0)
3643 rfc1002mangle(ses_init_buf->trailer.
3644 session_req.called_name,
3645 server->server_RFC1001_name,
3646 RFC1001_NAME_LEN_WITH_NULL);
3648 rfc1002mangle(ses_init_buf->trailer.
3649 session_req.called_name,
3650 DEFAULT_CIFS_CALLED_NAME,
3651 RFC1001_NAME_LEN_WITH_NULL);
3653 ses_init_buf->trailer.session_req.calling_len = 32;
3656 * calling name ends in null (byte 16) from old smb
3659 if (server->workstation_RFC1001_name[0] != 0)
3660 rfc1002mangle(ses_init_buf->trailer.
3661 session_req.calling_name,
3662 server->workstation_RFC1001_name,
3663 RFC1001_NAME_LEN_WITH_NULL);
3665 rfc1002mangle(ses_init_buf->trailer.
3666 session_req.calling_name,
3668 RFC1001_NAME_LEN_WITH_NULL);
3670 ses_init_buf->trailer.session_req.scope1 = 0;
3671 ses_init_buf->trailer.session_req.scope2 = 0;
3672 smb_buf = (struct smb_hdr *)ses_init_buf;
3674 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3675 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3676 rc = smb_send(server, smb_buf, 0x44);
3677 kfree(ses_init_buf);
3679 * RFC1001 layer in at least one server
3680 * requires very short break before negprot
3681 * presumably because not expecting negprot
3682 * to follow so fast. This is a simple
3683 * solution that works without
3684 * complicating the code and causes no
3685 * significant slowing down on mount
3688 usleep_range(1000, 2000);
3691 * else the negprot may still work without this
3692 * even though malloc failed
3699 generic_ip_connect(struct TCP_Server_Info *server)
3704 struct socket *socket = server->ssocket;
3705 struct sockaddr *saddr;
3707 saddr = (struct sockaddr *) &server->dstaddr;
3709 if (server->dstaddr.ss_family == AF_INET6) {
3710 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3711 slen = sizeof(struct sockaddr_in6);
3714 sport = ((struct sockaddr_in *) saddr)->sin_port;
3715 slen = sizeof(struct sockaddr_in);
3719 if (socket == NULL) {
3720 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3721 IPPROTO_TCP, &socket, 1);
3723 cifs_dbg(VFS, "Error %d creating socket\n", rc);
3724 server->ssocket = NULL;
3728 /* BB other socket options to set KEEPALIVE, NODELAY? */
3729 cifs_dbg(FYI, "Socket created\n");
3730 server->ssocket = socket;
3731 socket->sk->sk_allocation = GFP_NOFS;
3732 if (sfamily == AF_INET6)
3733 cifs_reclassify_socket6(socket);
3735 cifs_reclassify_socket4(socket);
3738 rc = bind_socket(server);
3743 * Eventually check for other socket options to change from
3744 * the default. sock_setsockopt not used because it expects
3747 socket->sk->sk_rcvtimeo = 7 * HZ;
3748 socket->sk->sk_sndtimeo = 5 * HZ;
3750 /* make the bufsizes depend on wsize/rsize and max requests */
3751 if (server->noautotune) {
3752 if (socket->sk->sk_sndbuf < (200 * 1024))
3753 socket->sk->sk_sndbuf = 200 * 1024;
3754 if (socket->sk->sk_rcvbuf < (140 * 1024))
3755 socket->sk->sk_rcvbuf = 140 * 1024;
3758 if (server->tcp_nodelay) {
3760 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3761 (char *)&val, sizeof(val));
3763 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3767 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3768 socket->sk->sk_sndbuf,
3769 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3771 rc = socket->ops->connect(socket, saddr, slen, 0);
3773 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3774 sock_release(socket);
3775 server->ssocket = NULL;
3779 if (sport == htons(RFC1001_PORT))
3780 rc = ip_rfc1001_connect(server);
3786 ip_connect(struct TCP_Server_Info *server)
3789 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3790 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3792 if (server->dstaddr.ss_family == AF_INET6)
3793 sport = &addr6->sin6_port;
3795 sport = &addr->sin_port;
3800 /* try with 445 port at first */
3801 *sport = htons(CIFS_PORT);
3803 rc = generic_ip_connect(server);
3807 /* if it failed, try with 139 port */
3808 *sport = htons(RFC1001_PORT);
3811 return generic_ip_connect(server);
3814 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3815 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3817 /* if we are reconnecting then should we check to see if
3818 * any requested capabilities changed locally e.g. via
3819 * remount but we can not do much about it here
3820 * if they have (even if we could detect it by the following)
3821 * Perhaps we could add a backpointer to array of sb from tcon
3822 * or if we change to make all sb to same share the same
3823 * sb as NFS - then we only have one backpointer to sb.
3824 * What if we wanted to mount the server share twice once with
3825 * and once without posixacls or posix paths? */
3826 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3828 if (vol_info && vol_info->no_linux_ext) {
3829 tcon->fsUnixInfo.Capability = 0;
3830 tcon->unix_ext = 0; /* Unix Extensions disabled */
3831 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3833 } else if (vol_info)
3834 tcon->unix_ext = 1; /* Unix Extensions supported */
3836 if (tcon->unix_ext == 0) {
3837 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3841 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3842 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3843 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3844 /* check for reconnect case in which we do not
3845 want to change the mount behavior if we can avoid it */
3846 if (vol_info == NULL) {
3847 /* turn off POSIX ACL and PATHNAMES if not set
3848 originally at mount time */
3849 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3850 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3851 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3852 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3853 cifs_dbg(VFS, "POSIXPATH support change\n");
3854 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3855 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3856 cifs_dbg(VFS, "possible reconnect error\n");
3857 cifs_dbg(VFS, "server disabled POSIX path support\n");
3861 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3862 cifs_dbg(VFS, "per-share encryption not supported yet\n");
3864 cap &= CIFS_UNIX_CAP_MASK;
3865 if (vol_info && vol_info->no_psx_acl)
3866 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3867 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3868 cifs_dbg(FYI, "negotiated posix acl support\n");
3870 cifs_sb->mnt_cifs_flags |=
3871 CIFS_MOUNT_POSIXACL;
3874 if (vol_info && vol_info->posix_paths == 0)
3875 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3876 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3877 cifs_dbg(FYI, "negotiate posix pathnames\n");
3879 cifs_sb->mnt_cifs_flags |=
3880 CIFS_MOUNT_POSIX_PATHS;
3883 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3884 #ifdef CONFIG_CIFS_DEBUG2
3885 if (cap & CIFS_UNIX_FCNTL_CAP)
3886 cifs_dbg(FYI, "FCNTL cap\n");
3887 if (cap & CIFS_UNIX_EXTATTR_CAP)
3888 cifs_dbg(FYI, "EXTATTR cap\n");
3889 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3890 cifs_dbg(FYI, "POSIX path cap\n");
3891 if (cap & CIFS_UNIX_XATTR_CAP)
3892 cifs_dbg(FYI, "XATTR cap\n");
3893 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3894 cifs_dbg(FYI, "POSIX ACL cap\n");
3895 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3896 cifs_dbg(FYI, "very large read cap\n");
3897 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3898 cifs_dbg(FYI, "very large write cap\n");
3899 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3900 cifs_dbg(FYI, "transport encryption cap\n");
3901 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3902 cifs_dbg(FYI, "mandatory transport encryption cap\n");
3903 #endif /* CIFS_DEBUG2 */
3904 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3905 if (vol_info == NULL) {
3906 cifs_dbg(FYI, "resetting capabilities failed\n");
3908 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");
3914 int cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3915 struct cifs_sb_info *cifs_sb)
3917 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3919 spin_lock_init(&cifs_sb->tlink_tree_lock);
3920 cifs_sb->tlink_tree = RB_ROOT;
3922 cifs_sb->bsize = pvolume_info->bsize;
3924 * Temporarily set r/wsize for matching superblock. If we end up using
3925 * new sb then client will later negotiate it downward if needed.
3927 cifs_sb->rsize = pvolume_info->rsize;
3928 cifs_sb->wsize = pvolume_info->wsize;
3930 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3931 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3932 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3933 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3934 cifs_dbg(FYI, "file mode: 0x%hx dir mode: 0x%hx\n",
3935 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3937 cifs_sb->actimeo = pvolume_info->actimeo;
3938 cifs_sb->local_nls = pvolume_info->local_nls;
3940 if (pvolume_info->nodfs)
3941 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_DFS;
3942 if (pvolume_info->noperm)
3943 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3944 if (pvolume_info->setuids)
3945 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3946 if (pvolume_info->setuidfromacl)
3947 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
3948 if (pvolume_info->server_ino)
3949 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3950 if (pvolume_info->remap)
3951 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3952 if (pvolume_info->sfu_remap)
3953 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3954 if (pvolume_info->no_xattr)
3955 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3956 if (pvolume_info->sfu_emul)
3957 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3958 if (pvolume_info->nobrl)
3959 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3960 if (pvolume_info->nohandlecache)
3961 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE;
3962 if (pvolume_info->nostrictsync)
3963 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3964 if (pvolume_info->mand_lock)
3965 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3966 if (pvolume_info->rwpidforward)
3967 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3968 if (pvolume_info->cifs_acl)
3969 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3970 if (pvolume_info->backupuid_specified) {
3971 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3972 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3974 if (pvolume_info->backupgid_specified) {
3975 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3976 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3978 if (pvolume_info->override_uid)
3979 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3980 if (pvolume_info->override_gid)
3981 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3982 if (pvolume_info->dynperm)
3983 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3984 if (pvolume_info->fsc)
3985 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3986 if (pvolume_info->multiuser)
3987 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3988 CIFS_MOUNT_NO_PERM);
3989 if (pvolume_info->strict_io)
3990 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3991 if (pvolume_info->direct_io) {
3992 cifs_dbg(FYI, "mounting share using direct i/o\n");
3993 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3995 if (pvolume_info->mfsymlinks) {
3996 if (pvolume_info->sfu_emul) {
3998 * Our SFU ("Services for Unix" emulation does not allow
3999 * creating symlinks but does allow reading existing SFU
4000 * symlinks (it does allow both creating and reading SFU
4001 * style mknod and FIFOs though). When "mfsymlinks" and
4002 * "sfu" are both enabled at the same time, it allows
4003 * reading both types of symlinks, but will only create
4004 * them with mfsymlinks format. This allows better
4005 * Apple compatibility (probably better for Samba too)
4006 * while still recognizing old Windows style symlinks.
4008 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
4010 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
4013 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
4014 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
4016 if (pvolume_info->prepath) {
4017 cifs_sb->prepath = kstrdup(pvolume_info->prepath, GFP_KERNEL);
4018 if (cifs_sb->prepath == NULL)
4026 cifs_cleanup_volume_info_contents(struct smb_vol *volume_info)
4028 kfree(volume_info->username);
4029 kzfree(volume_info->password);
4030 kfree(volume_info->UNC);
4031 kfree(volume_info->domainname);
4032 kfree(volume_info->iocharset);
4033 kfree(volume_info->prepath);
4037 cifs_cleanup_volume_info(struct smb_vol *volume_info)
4041 cifs_cleanup_volume_info_contents(volume_info);
4045 /* Release all succeed connections */
4046 static inline void mount_put_conns(struct cifs_sb_info *cifs_sb,
4048 struct TCP_Server_Info *server,
4049 struct cifs_ses *ses, struct cifs_tcon *tcon)
4054 cifs_put_tcon(tcon);
4056 cifs_put_smb_ses(ses);
4058 cifs_put_tcp_session(server, 0);
4059 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
4063 /* Get connections for tcp, ses and tcon */
4064 static int mount_get_conns(struct smb_vol *vol, struct cifs_sb_info *cifs_sb,
4066 struct TCP_Server_Info **nserver,
4067 struct cifs_ses **nses, struct cifs_tcon **ntcon)
4070 struct TCP_Server_Info *server;
4071 struct cifs_ses *ses;
4072 struct cifs_tcon *tcon;
4080 /* get a reference to a tcp session */
4081 server = cifs_get_tcp_session(vol);
4082 if (IS_ERR(server)) {
4083 rc = PTR_ERR(server);
4089 if ((vol->max_credits < 20) || (vol->max_credits > 60000))
4090 server->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
4092 server->max_credits = vol->max_credits;
4094 /* get a reference to a SMB session */
4095 ses = cifs_get_smb_ses(server, vol);
4103 if ((vol->persistent == true) && (!(ses->server->capabilities &
4104 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES))) {
4105 cifs_dbg(VFS, "persistent handles not supported by server\n");
4109 /* search for existing tcon to this server share */
4110 tcon = cifs_get_tcon(ses, vol);
4118 /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
4119 if (tcon->posix_extensions)
4120 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
4122 /* tell server which Unix caps we support */
4123 if (cap_unix(tcon->ses)) {
4125 * reset of caps checks mount to see if unix extensions disabled
4126 * for just this mount.
4128 reset_cifs_unix_caps(*xid, tcon, cifs_sb, vol);
4129 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
4130 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
4131 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP))
4134 tcon->unix_ext = 0; /* server does not support them */
4136 /* do not care if a following call succeed - informational */
4137 if (!tcon->pipe && server->ops->qfs_tcon)
4138 server->ops->qfs_tcon(*xid, tcon);
4140 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, vol);
4141 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, vol);
4146 static int mount_setup_tlink(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses,
4147 struct cifs_tcon *tcon)
4149 struct tcon_link *tlink;
4151 /* hang the tcon off of the superblock */
4152 tlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4156 tlink->tl_uid = ses->linux_uid;
4157 tlink->tl_tcon = tcon;
4158 tlink->tl_time = jiffies;
4159 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
4160 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4162 cifs_sb->master_tlink = tlink;
4163 spin_lock(&cifs_sb->tlink_tree_lock);
4164 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4165 spin_unlock(&cifs_sb->tlink_tree_lock);
4167 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4172 #ifdef CONFIG_CIFS_DFS_UPCALL
4174 * cifs_build_path_to_root returns full path to root when we do not have an
4175 * exiting connection (tcon)
4178 build_unc_path_to_root(const struct smb_vol *vol,
4179 const struct cifs_sb_info *cifs_sb, bool useppath)
4181 char *full_path, *pos;
4182 unsigned int pplen = useppath && vol->prepath ?
4183 strlen(vol->prepath) + 1 : 0;
4184 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
4186 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
4187 if (full_path == NULL)
4188 return ERR_PTR(-ENOMEM);
4190 strncpy(full_path, vol->UNC, unc_len);
4191 pos = full_path + unc_len;
4194 *pos = CIFS_DIR_SEP(cifs_sb);
4195 strncpy(pos + 1, vol->prepath, pplen);
4199 *pos = '\0'; /* add trailing null */
4200 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
4201 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
4206 * expand_dfs_referral - Perform a dfs referral query and update the cifs_sb
4209 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
4210 * to a string containing updated options for the submount. Otherwise it
4211 * will be left untouched.
4213 * Returns the rc from get_dfs_path to the caller, which can be used to
4214 * determine whether there were referrals.
4217 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
4218 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
4222 struct dfs_info3_param referral = {0};
4223 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
4225 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
4228 full_path = build_unc_path_to_root(volume_info, cifs_sb, true);
4229 if (IS_ERR(full_path))
4230 return PTR_ERR(full_path);
4232 /* For DFS paths, skip the first '\' of the UNC */
4233 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
4235 rc = dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb),
4236 ref_path, &referral, NULL);
4238 char *fake_devname = NULL;
4240 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
4241 full_path + 1, &referral,
4243 free_dfs_info_param(&referral);
4245 if (IS_ERR(mdata)) {
4246 rc = PTR_ERR(mdata);
4249 cifs_cleanup_volume_info_contents(volume_info);
4250 rc = cifs_setup_volume_info(volume_info, mdata,
4251 fake_devname, false);
4253 kfree(fake_devname);
4254 kfree(cifs_sb->mountdata);
4255 cifs_sb->mountdata = mdata;
4261 static inline int get_next_dfs_tgt(const char *path,
4262 struct dfs_cache_tgt_list *tgt_list,
4263 struct dfs_cache_tgt_iterator **tgt_it)
4266 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
4268 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
4269 return !*tgt_it ? -EHOSTDOWN : 0;
4272 static int update_vol_info(const struct dfs_cache_tgt_iterator *tgt_it,
4273 struct smb_vol *fake_vol, struct smb_vol *vol)
4275 const char *tgt = dfs_cache_get_tgt_name(tgt_it);
4276 int len = strlen(tgt) + 2;
4279 new_unc = kmalloc(len, GFP_KERNEL);
4282 scnprintf(new_unc, len, "\\%s", tgt);
4287 if (fake_vol->prepath) {
4288 kfree(vol->prepath);
4289 vol->prepath = fake_vol->prepath;
4290 fake_vol->prepath = NULL;
4292 memcpy(&vol->dstaddr, &fake_vol->dstaddr, sizeof(vol->dstaddr));
4297 static int setup_dfs_tgt_conn(const char *path,
4298 const struct dfs_cache_tgt_iterator *tgt_it,
4299 struct cifs_sb_info *cifs_sb,
4300 struct smb_vol *vol,
4302 struct TCP_Server_Info **server,
4303 struct cifs_ses **ses,
4304 struct cifs_tcon **tcon)
4307 struct dfs_info3_param ref = {0};
4308 char *mdata = NULL, *fake_devname = NULL;
4309 struct smb_vol fake_vol = {0};
4311 cifs_dbg(FYI, "%s: dfs path: %s\n", __func__, path);
4313 rc = dfs_cache_get_tgt_referral(path, tgt_it, &ref);
4317 mdata = cifs_compose_mount_options(cifs_sb->mountdata, path, &ref,
4319 free_dfs_info_param(&ref);
4321 if (IS_ERR(mdata)) {
4322 rc = PTR_ERR(mdata);
4325 cifs_dbg(FYI, "%s: fake_devname: %s\n", __func__, fake_devname);
4326 rc = cifs_setup_volume_info(&fake_vol, mdata, fake_devname,
4330 kfree(fake_devname);
4334 * We use a 'fake_vol' here because we need pass it down to the
4335 * mount_{get,put} functions to test connection against new DFS
4338 mount_put_conns(cifs_sb, *xid, *server, *ses, *tcon);
4339 rc = mount_get_conns(&fake_vol, cifs_sb, xid, server, ses,
4343 * We were able to connect to new target server.
4344 * Update current volume info with new target server.
4346 rc = update_vol_info(tgt_it, &fake_vol, vol);
4349 cifs_cleanup_volume_info_contents(&fake_vol);
4353 static int mount_do_dfs_failover(const char *path,
4354 struct cifs_sb_info *cifs_sb,
4355 struct smb_vol *vol,
4356 struct cifs_ses *root_ses,
4358 struct TCP_Server_Info **server,
4359 struct cifs_ses **ses,
4360 struct cifs_tcon **tcon)
4363 struct dfs_cache_tgt_list tgt_list;
4364 struct dfs_cache_tgt_iterator *tgt_it = NULL;
4366 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
4369 rc = dfs_cache_noreq_find(path, NULL, &tgt_list);
4374 /* Get next DFS target server - if any */
4375 rc = get_next_dfs_tgt(path, &tgt_list, &tgt_it);
4378 /* Connect to next DFS target */
4379 rc = setup_dfs_tgt_conn(path, tgt_it, cifs_sb, vol, xid, server,
4381 if (!rc || rc == -EACCES || rc == -EOPNOTSUPP)
4386 * Update DFS target hint in DFS referral cache with the target
4387 * server we successfully reconnected to.
4389 rc = dfs_cache_update_tgthint(*xid, root_ses ? root_ses : *ses,
4391 cifs_remap(cifs_sb), path,
4394 dfs_cache_free_tgts(&tgt_list);
4400 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
4401 const char *devname, bool is_smb3)
4405 if (cifs_parse_mount_options(mount_data, devname, volume_info, is_smb3))
4408 if (volume_info->nullauth) {
4409 cifs_dbg(FYI, "Anonymous login\n");
4410 kfree(volume_info->username);
4411 volume_info->username = NULL;
4412 } else if (volume_info->username) {
4413 /* BB fixme parse for domain name here */
4414 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
4416 cifs_dbg(VFS, "No username specified\n");
4417 /* In userspace mount helper we can get user name from alternate
4418 locations such as env variables and files on disk */
4422 /* this is needed for ASCII cp to Unicode converts */
4423 if (volume_info->iocharset == NULL) {
4424 /* load_nls_default cannot return null */
4425 volume_info->local_nls = load_nls_default();
4427 volume_info->local_nls = load_nls(volume_info->iocharset);
4428 if (volume_info->local_nls == NULL) {
4429 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
4430 volume_info->iocharset);
4439 cifs_get_volume_info(char *mount_data, const char *devname, bool is_smb3)
4442 struct smb_vol *volume_info;
4444 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
4446 return ERR_PTR(-ENOMEM);
4448 rc = cifs_setup_volume_info(volume_info, mount_data, devname, is_smb3);
4450 cifs_cleanup_volume_info(volume_info);
4451 volume_info = ERR_PTR(rc);
4458 cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
4460 struct cifs_tcon *tcon,
4461 struct cifs_sb_info *cifs_sb,
4468 sep = CIFS_DIR_SEP(cifs_sb);
4471 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
4473 /* skip separators */
4478 /* next separator */
4479 while (*s && *s != sep)
4483 * temporarily null-terminate the path at the end of
4484 * the current component
4488 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
4496 * Check if path is remote (e.g. a DFS share). Return -EREMOTE if it is,
4499 static int is_path_remote(struct cifs_sb_info *cifs_sb, struct smb_vol *vol,
4500 const unsigned int xid,
4501 struct TCP_Server_Info *server,
4502 struct cifs_tcon *tcon)
4507 if (!server->ops->is_path_accessible)
4511 * cifs_build_path_to_root works only when we have a valid tcon
4513 full_path = cifs_build_path_to_root(vol, cifs_sb, tcon,
4514 tcon->Flags & SMB_SHARE_IS_IN_DFS);
4515 if (full_path == NULL)
4518 cifs_dbg(FYI, "%s: full_path: %s\n", __func__, full_path);
4520 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
4522 if (rc != 0 && rc != -EREMOTE) {
4527 if (rc != -EREMOTE) {
4528 rc = cifs_are_all_path_components_accessible(server, xid, tcon,
4532 cifs_dbg(VFS, "cannot query dirs between root and final path, "
4533 "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
4534 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
4543 #ifdef CONFIG_CIFS_DFS_UPCALL
4544 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *vol)
4548 struct cifs_ses *ses;
4549 struct cifs_tcon *root_tcon = NULL;
4550 struct cifs_tcon *tcon = NULL;
4551 struct TCP_Server_Info *server;
4552 char *root_path = NULL, *full_path = NULL;
4553 char *old_mountdata, *origin_mountdata = NULL;
4556 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4558 /* If not a standalone DFS root, then check if path is remote */
4559 rc = dfs_cache_find(xid, ses, cifs_sb->local_nls,
4560 cifs_remap(cifs_sb), vol->UNC + 1, NULL,
4563 rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
4571 * If first DFS target server went offline and we failed to connect it,
4572 * server and ses pointers are NULL at this point, though we still have
4573 * chance to get a cached DFS referral in expand_dfs_referral() and
4574 * retry next target available in it.
4576 * If a NULL ses ptr is passed to dfs_cache_find(), a lookup will be
4577 * performed against DFS path and *no* requests will be sent to server
4578 * for any new DFS referrals. Hence it's safe to skip checking whether
4579 * server or ses ptr is NULL.
4581 if (rc == -EACCES || rc == -EOPNOTSUPP)
4584 root_path = build_unc_path_to_root(vol, cifs_sb, false);
4585 if (IS_ERR(root_path)) {
4586 rc = PTR_ERR(root_path);
4591 full_path = build_unc_path_to_root(vol, cifs_sb, true);
4592 if (IS_ERR(full_path)) {
4593 rc = PTR_ERR(full_path);
4598 * Perform an unconditional check for whether there are DFS
4599 * referrals for this path without prefix, to provide support
4600 * for DFS referrals from w2k8 servers which don't seem to respond
4601 * with PATH_NOT_COVERED to requests that include the prefix.
4602 * Chase the referral if found, otherwise continue normally.
4604 old_mountdata = cifs_sb->mountdata;
4605 (void)expand_dfs_referral(xid, ses, vol, cifs_sb, false);
4607 if (cifs_sb->mountdata == NULL) {
4612 /* Save DFS root volume information for DFS refresh worker */
4613 origin_mountdata = kstrndup(cifs_sb->mountdata,
4614 strlen(cifs_sb->mountdata), GFP_KERNEL);
4615 if (!origin_mountdata) {
4620 if (cifs_sb->mountdata != old_mountdata) {
4621 /* If we were redirected, reconnect to new target server */
4622 mount_put_conns(cifs_sb, xid, server, ses, tcon);
4623 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4626 if (rc == -EACCES || rc == -EOPNOTSUPP)
4628 /* Perform DFS failover to any other DFS targets */
4629 rc = mount_do_dfs_failover(root_path + 1, cifs_sb, vol, NULL,
4630 &xid, &server, &ses, &tcon);
4636 root_path = build_unc_path_to_root(vol, cifs_sb, false);
4637 if (IS_ERR(root_path)) {
4638 rc = PTR_ERR(root_path);
4642 /* Cache out resolved root server */
4643 (void)dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb),
4644 root_path + 1, NULL, NULL);
4646 * Save root tcon for additional DFS requests to update or create a new
4647 * DFS cache entry, or even perform DFS failover.
4649 spin_lock(&cifs_tcp_ses_lock);
4651 tcon->dfs_path = root_path;
4653 tcon->remap = cifs_remap(cifs_sb);
4654 spin_unlock(&cifs_tcp_ses_lock);
4658 for (count = 1; ;) {
4660 rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
4661 if (!rc || rc != -EREMOTE)
4665 * BB: when we implement proper loop detection,
4666 * we will remove this check. But now we need it
4667 * to prevent an indefinite loop if 'DFS tree' is
4668 * misconfigured (i.e. has loops).
4670 if (count++ > MAX_NESTED_LINKS) {
4676 full_path = build_unc_path_to_root(vol, cifs_sb, true);
4677 if (IS_ERR(full_path)) {
4678 rc = PTR_ERR(full_path);
4683 old_mountdata = cifs_sb->mountdata;
4684 rc = expand_dfs_referral(xid, root_tcon->ses, vol, cifs_sb,
4689 if (cifs_sb->mountdata != old_mountdata) {
4690 mount_put_conns(cifs_sb, xid, server, ses, tcon);
4691 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses,
4695 if (rc == -EACCES || rc == -EOPNOTSUPP)
4697 /* Perform DFS failover to any other DFS targets */
4698 rc = mount_do_dfs_failover(full_path + 1, cifs_sb, vol,
4699 root_tcon->ses, &xid,
4700 &server, &ses, &tcon);
4701 if (rc == -EACCES || rc == -EOPNOTSUPP || !server ||
4706 cifs_put_tcon(root_tcon);
4711 spin_lock(&cifs_tcp_ses_lock);
4712 if (!tcon->dfs_path) {
4713 /* Save full path in new tcon to do failover when reconnecting tcons */
4714 tcon->dfs_path = full_path;
4716 tcon->remap = cifs_remap(cifs_sb);
4718 cifs_sb->origin_fullpath = kstrndup(tcon->dfs_path,
4719 strlen(tcon->dfs_path),
4721 if (!cifs_sb->origin_fullpath) {
4722 spin_unlock(&cifs_tcp_ses_lock);
4726 spin_unlock(&cifs_tcp_ses_lock);
4728 rc = dfs_cache_add_vol(origin_mountdata, vol, cifs_sb->origin_fullpath);
4730 kfree(cifs_sb->origin_fullpath);
4734 * After reconnecting to a different server, unique ids won't
4735 * match anymore, so we disable serverino. This prevents
4736 * dentry revalidation to think the dentry are stale (ESTALE).
4738 cifs_autodisable_serverino(cifs_sb);
4741 return mount_setup_tlink(cifs_sb, ses, tcon);
4746 kfree(origin_mountdata);
4747 mount_put_conns(cifs_sb, xid, server, ses, tcon);
4751 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *vol)
4755 struct cifs_ses *ses;
4756 struct cifs_tcon *tcon;
4757 struct TCP_Server_Info *server;
4759 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4764 rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
4773 return mount_setup_tlink(cifs_sb, ses, tcon);
4776 mount_put_conns(cifs_sb, xid, server, ses, tcon);
4782 * Issue a TREE_CONNECT request.
4785 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
4786 const char *tree, struct cifs_tcon *tcon,
4787 const struct nls_table *nls_codepage)
4789 struct smb_hdr *smb_buffer;
4790 struct smb_hdr *smb_buffer_response;
4793 unsigned char *bcc_ptr;
4796 __u16 bytes_left, count;
4801 smb_buffer = cifs_buf_get();
4802 if (smb_buffer == NULL)
4805 smb_buffer_response = smb_buffer;
4807 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
4808 NULL /*no tid */ , 4 /*wct */ );
4810 smb_buffer->Mid = get_next_mid(ses->server);
4811 smb_buffer->Uid = ses->Suid;
4812 pSMB = (TCONX_REQ *) smb_buffer;
4813 pSMBr = (TCONX_RSP *) smb_buffer_response;
4815 pSMB->AndXCommand = 0xFF;
4816 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
4817 bcc_ptr = &pSMB->Password[0];
4818 if (tcon->pipe || (ses->server->sec_mode & SECMODE_USER)) {
4819 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
4820 *bcc_ptr = 0; /* password is null byte */
4821 bcc_ptr++; /* skip password */
4822 /* already aligned so no need to do it below */
4824 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
4825 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
4826 specified as required (when that support is added to
4827 the vfs in the future) as only NTLM or the much
4828 weaker LANMAN (which we do not send by default) is accepted
4829 by Samba (not sure whether other servers allow
4830 NTLMv2 password here) */
4831 #ifdef CONFIG_CIFS_WEAK_PW_HASH
4832 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
4833 (ses->sectype == LANMAN))
4834 calc_lanman_hash(tcon->password, ses->server->cryptkey,
4835 ses->server->sec_mode &
4836 SECMODE_PW_ENCRYPT ? true : false,
4839 #endif /* CIFS_WEAK_PW_HASH */
4840 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
4841 bcc_ptr, nls_codepage);
4843 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
4845 cifs_buf_release(smb_buffer);
4849 bcc_ptr += CIFS_AUTH_RESP_SIZE;
4850 if (ses->capabilities & CAP_UNICODE) {
4851 /* must align unicode strings */
4852 *bcc_ptr = 0; /* null byte password */
4857 if (ses->server->sign)
4858 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
4860 if (ses->capabilities & CAP_STATUS32) {
4861 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
4863 if (ses->capabilities & CAP_DFS) {
4864 smb_buffer->Flags2 |= SMBFLG2_DFS;
4866 if (ses->capabilities & CAP_UNICODE) {
4867 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
4869 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
4870 6 /* max utf8 char length in bytes */ *
4871 (/* server len*/ + 256 /* share len */), nls_codepage);
4872 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
4873 bcc_ptr += 2; /* skip trailing null */
4874 } else { /* ASCII */
4875 strcpy(bcc_ptr, tree);
4876 bcc_ptr += strlen(tree) + 1;
4878 strcpy(bcc_ptr, "?????");
4879 bcc_ptr += strlen("?????");
4881 count = bcc_ptr - &pSMB->Password[0];
4882 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
4883 pSMB->hdr.smb_buf_length) + count);
4884 pSMB->ByteCount = cpu_to_le16(count);
4886 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
4889 /* above now done in SendReceive */
4893 tcon->tidStatus = CifsGood;
4894 tcon->need_reconnect = false;
4895 tcon->tid = smb_buffer_response->Tid;
4896 bcc_ptr = pByteArea(smb_buffer_response);
4897 bytes_left = get_bcc(smb_buffer_response);
4898 length = strnlen(bcc_ptr, bytes_left - 2);
4899 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
4905 /* skip service field (NB: this field is always ASCII) */
4907 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
4908 (bcc_ptr[2] == 'C')) {
4909 cifs_dbg(FYI, "IPC connection\n");
4913 } else if (length == 2) {
4914 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
4915 /* the most common case */
4916 cifs_dbg(FYI, "disk share connection\n");
4919 bcc_ptr += length + 1;
4920 bytes_left -= (length + 1);
4921 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
4923 /* mostly informational -- no need to fail on error here */
4924 kfree(tcon->nativeFileSystem);
4925 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
4926 bytes_left, is_unicode,
4929 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
4931 if ((smb_buffer_response->WordCount == 3) ||
4932 (smb_buffer_response->WordCount == 7))
4933 /* field is in same location */
4934 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
4937 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
4940 cifs_buf_release(smb_buffer);
4944 static void delayed_free(struct rcu_head *p)
4946 struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
4947 unload_nls(sbi->local_nls);
4952 cifs_umount(struct cifs_sb_info *cifs_sb)
4954 struct rb_root *root = &cifs_sb->tlink_tree;
4955 struct rb_node *node;
4956 struct tcon_link *tlink;
4958 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
4960 spin_lock(&cifs_sb->tlink_tree_lock);
4961 while ((node = rb_first(root))) {
4962 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4963 cifs_get_tlink(tlink);
4964 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4965 rb_erase(node, root);
4967 spin_unlock(&cifs_sb->tlink_tree_lock);
4968 cifs_put_tlink(tlink);
4969 spin_lock(&cifs_sb->tlink_tree_lock);
4971 spin_unlock(&cifs_sb->tlink_tree_lock);
4973 kfree(cifs_sb->mountdata);
4974 kfree(cifs_sb->prepath);
4975 #ifdef CONFIG_CIFS_DFS_UPCALL
4976 dfs_cache_del_vol(cifs_sb->origin_fullpath);
4977 kfree(cifs_sb->origin_fullpath);
4979 call_rcu(&cifs_sb->rcu, delayed_free);
4983 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
4986 struct TCP_Server_Info *server = ses->server;
4988 if (!server->ops->need_neg || !server->ops->negotiate)
4991 /* only send once per connect */
4992 if (!server->ops->need_neg(server))
4995 rc = server->ops->negotiate(xid, ses);
4997 spin_lock(&GlobalMid_Lock);
4998 if (server->tcpStatus == CifsNeedNegotiate)
4999 server->tcpStatus = CifsGood;
5002 spin_unlock(&GlobalMid_Lock);
5009 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
5010 struct nls_table *nls_info)
5013 struct TCP_Server_Info *server = ses->server;
5015 ses->capabilities = server->capabilities;
5016 if (linuxExtEnabled == 0)
5017 ses->capabilities &= (~server->vals->cap_unix);
5019 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
5020 server->sec_mode, server->capabilities, server->timeAdj);
5022 if (ses->auth_key.response) {
5023 cifs_dbg(FYI, "Free previous auth_key.response = %p\n",
5024 ses->auth_key.response);
5025 kfree(ses->auth_key.response);
5026 ses->auth_key.response = NULL;
5027 ses->auth_key.len = 0;
5030 if (server->ops->sess_setup)
5031 rc = server->ops->sess_setup(xid, ses, nls_info);
5034 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
5040 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
5042 vol->sectype = ses->sectype;
5044 /* krb5 is special, since we don't need username or pw */
5045 if (vol->sectype == Kerberos)
5048 return cifs_set_cifscreds(vol, ses);
5051 static struct cifs_tcon *
5052 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
5055 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
5056 struct cifs_ses *ses;
5057 struct cifs_tcon *tcon = NULL;
5058 struct smb_vol *vol_info;
5060 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
5061 if (vol_info == NULL)
5062 return ERR_PTR(-ENOMEM);
5064 vol_info->local_nls = cifs_sb->local_nls;
5065 vol_info->linux_uid = fsuid;
5066 vol_info->cred_uid = fsuid;
5067 vol_info->UNC = master_tcon->treeName;
5068 vol_info->retry = master_tcon->retry;
5069 vol_info->nocase = master_tcon->nocase;
5070 vol_info->nohandlecache = master_tcon->nohandlecache;
5071 vol_info->local_lease = master_tcon->local_lease;
5072 vol_info->no_linux_ext = !master_tcon->unix_ext;
5073 vol_info->sectype = master_tcon->ses->sectype;
5074 vol_info->sign = master_tcon->ses->sign;
5076 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
5082 /* get a reference for the same TCP session */
5083 spin_lock(&cifs_tcp_ses_lock);
5084 ++master_tcon->ses->server->srv_count;
5085 spin_unlock(&cifs_tcp_ses_lock);
5087 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
5089 tcon = (struct cifs_tcon *)ses;
5090 cifs_put_tcp_session(master_tcon->ses->server, 0);
5094 tcon = cifs_get_tcon(ses, vol_info);
5096 cifs_put_smb_ses(ses);
5100 /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
5101 if (tcon->posix_extensions)
5102 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
5105 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
5108 kfree(vol_info->username);
5109 kzfree(vol_info->password);
5116 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
5118 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
5121 /* find and return a tlink with given uid */
5122 static struct tcon_link *
5123 tlink_rb_search(struct rb_root *root, kuid_t uid)
5125 struct rb_node *node = root->rb_node;
5126 struct tcon_link *tlink;
5129 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
5131 if (uid_gt(tlink->tl_uid, uid))
5132 node = node->rb_left;
5133 else if (uid_lt(tlink->tl_uid, uid))
5134 node = node->rb_right;
5141 /* insert a tcon_link into the tree */
5143 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
5145 struct rb_node **new = &(root->rb_node), *parent = NULL;
5146 struct tcon_link *tlink;
5149 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
5152 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
5153 new = &((*new)->rb_left);
5155 new = &((*new)->rb_right);
5158 rb_link_node(&new_tlink->tl_rbnode, parent, new);
5159 rb_insert_color(&new_tlink->tl_rbnode, root);
5163 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
5166 * If the superblock doesn't refer to a multiuser mount, then just return
5167 * the master tcon for the mount.
5169 * First, search the rbtree for an existing tcon for this fsuid. If one
5170 * exists, then check to see if it's pending construction. If it is then wait
5171 * for construction to complete. Once it's no longer pending, check to see if
5172 * it failed and either return an error or retry construction, depending on
5175 * If one doesn't exist then insert a new tcon_link struct into the tree and
5176 * try to construct a new one.
5179 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
5182 kuid_t fsuid = current_fsuid();
5183 struct tcon_link *tlink, *newtlink;
5185 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
5186 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
5188 spin_lock(&cifs_sb->tlink_tree_lock);
5189 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
5191 cifs_get_tlink(tlink);
5192 spin_unlock(&cifs_sb->tlink_tree_lock);
5194 if (tlink == NULL) {
5195 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
5196 if (newtlink == NULL)
5197 return ERR_PTR(-ENOMEM);
5198 newtlink->tl_uid = fsuid;
5199 newtlink->tl_tcon = ERR_PTR(-EACCES);
5200 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
5201 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
5202 cifs_get_tlink(newtlink);
5204 spin_lock(&cifs_sb->tlink_tree_lock);
5205 /* was one inserted after previous search? */
5206 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
5208 cifs_get_tlink(tlink);
5209 spin_unlock(&cifs_sb->tlink_tree_lock);
5211 goto wait_for_construction;
5214 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
5215 spin_unlock(&cifs_sb->tlink_tree_lock);
5217 wait_for_construction:
5218 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
5219 TASK_INTERRUPTIBLE);
5221 cifs_put_tlink(tlink);
5222 return ERR_PTR(-ERESTARTSYS);
5225 /* if it's good, return it */
5226 if (!IS_ERR(tlink->tl_tcon))
5229 /* return error if we tried this already recently */
5230 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
5231 cifs_put_tlink(tlink);
5232 return ERR_PTR(-EACCES);
5235 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
5236 goto wait_for_construction;
5239 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
5240 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
5241 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
5243 if (IS_ERR(tlink->tl_tcon)) {
5244 cifs_put_tlink(tlink);
5245 return ERR_PTR(-EACCES);
5252 * periodic workqueue job that scans tcon_tree for a superblock and closes
5256 cifs_prune_tlinks(struct work_struct *work)
5258 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
5260 struct rb_root *root = &cifs_sb->tlink_tree;
5261 struct rb_node *node;
5262 struct rb_node *tmp;
5263 struct tcon_link *tlink;
5266 * Because we drop the spinlock in the loop in order to put the tlink
5267 * it's not guarded against removal of links from the tree. The only
5268 * places that remove entries from the tree are this function and
5269 * umounts. Because this function is non-reentrant and is canceled
5270 * before umount can proceed, this is safe.
5272 spin_lock(&cifs_sb->tlink_tree_lock);
5273 node = rb_first(root);
5274 while (node != NULL) {
5276 node = rb_next(tmp);
5277 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
5279 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
5280 atomic_read(&tlink->tl_count) != 0 ||
5281 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
5284 cifs_get_tlink(tlink);
5285 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
5286 rb_erase(tmp, root);
5288 spin_unlock(&cifs_sb->tlink_tree_lock);
5289 cifs_put_tlink(tlink);
5290 spin_lock(&cifs_sb->tlink_tree_lock);
5292 spin_unlock(&cifs_sb->tlink_tree_lock);
5294 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,