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, Opt_modesid,
102 /* Mount options which take numeric value */
103 Opt_backupuid, Opt_backupgid, Opt_uid,
104 Opt_cruid, Opt_gid, Opt_file_mode,
105 Opt_dirmode, Opt_port,
106 Opt_blocksize, Opt_rsize, Opt_wsize, Opt_actimeo,
107 Opt_echo_interval, Opt_max_credits, Opt_handletimeout,
110 /* Mount options which take string value */
111 Opt_user, Opt_pass, Opt_ip,
112 Opt_domain, Opt_srcaddr, Opt_iocharset,
113 Opt_netbiosname, Opt_servern,
114 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
116 /* Mount options to be ignored */
119 /* Options which could be blank */
127 static const match_table_t cifs_mount_option_tokens = {
129 { Opt_user_xattr, "user_xattr" },
130 { Opt_nouser_xattr, "nouser_xattr" },
131 { Opt_forceuid, "forceuid" },
132 { Opt_noforceuid, "noforceuid" },
133 { Opt_forcegid, "forcegid" },
134 { Opt_noforcegid, "noforcegid" },
135 { Opt_noblocksend, "noblocksend" },
136 { Opt_noautotune, "noautotune" },
137 { Opt_hard, "hard" },
138 { Opt_soft, "soft" },
139 { Opt_perm, "perm" },
140 { Opt_noperm, "noperm" },
141 { Opt_mapchars, "mapchars" }, /* SFU style */
142 { Opt_nomapchars, "nomapchars" },
143 { Opt_mapposix, "mapposix" }, /* SFM style */
144 { Opt_nomapposix, "nomapposix" },
146 { Opt_nosfu, "nosfu" },
147 { Opt_nodfs, "nodfs" },
148 { Opt_posixpaths, "posixpaths" },
149 { Opt_noposixpaths, "noposixpaths" },
150 { Opt_nounix, "nounix" },
151 { Opt_nounix, "nolinux" },
152 { Opt_nounix, "noposix" },
153 { Opt_unix, "unix" },
154 { Opt_unix, "linux" },
155 { Opt_unix, "posix" },
156 { Opt_nocase, "nocase" },
157 { Opt_nocase, "ignorecase" },
159 { Opt_nobrl, "nobrl" },
160 { Opt_handlecache, "handlecache" },
161 { Opt_nohandlecache, "nohandlecache" },
162 { Opt_nobrl, "nolock" },
163 { Opt_forcemandatorylock, "forcemandatorylock" },
164 { Opt_forcemandatorylock, "forcemand" },
165 { Opt_setuids, "setuids" },
166 { Opt_nosetuids, "nosetuids" },
167 { Opt_setuidfromacl, "idsfromsid" },
168 { Opt_dynperm, "dynperm" },
169 { Opt_nodynperm, "nodynperm" },
170 { Opt_nohard, "nohard" },
171 { Opt_nosoft, "nosoft" },
172 { Opt_nointr, "nointr" },
173 { Opt_intr, "intr" },
174 { Opt_nostrictsync, "nostrictsync" },
175 { Opt_strictsync, "strictsync" },
176 { Opt_serverino, "serverino" },
177 { Opt_noserverino, "noserverino" },
178 { Opt_rwpidforward, "rwpidforward" },
179 { Opt_modesid, "modefromsid" },
180 { Opt_cifsacl, "cifsacl" },
181 { Opt_nocifsacl, "nocifsacl" },
183 { Opt_noacl, "noacl" },
184 { Opt_locallease, "locallease" },
185 { Opt_sign, "sign" },
186 { Opt_seal, "seal" },
187 { Opt_noac, "noac" },
189 { Opt_mfsymlinks, "mfsymlinks" },
190 { Opt_multiuser, "multiuser" },
191 { Opt_sloppy, "sloppy" },
192 { Opt_nosharesock, "nosharesock" },
193 { Opt_persistent, "persistenthandles"},
194 { Opt_nopersistent, "nopersistenthandles"},
195 { Opt_resilient, "resilienthandles"},
196 { Opt_noresilient, "noresilienthandles"},
197 { Opt_domainauto, "domainauto"},
200 { Opt_backupuid, "backupuid=%s" },
201 { Opt_backupgid, "backupgid=%s" },
202 { Opt_uid, "uid=%s" },
203 { Opt_cruid, "cruid=%s" },
204 { Opt_gid, "gid=%s" },
205 { Opt_file_mode, "file_mode=%s" },
206 { Opt_dirmode, "dirmode=%s" },
207 { Opt_dirmode, "dir_mode=%s" },
208 { Opt_port, "port=%s" },
209 { Opt_blocksize, "bsize=%s" },
210 { Opt_rsize, "rsize=%s" },
211 { Opt_wsize, "wsize=%s" },
212 { Opt_actimeo, "actimeo=%s" },
213 { Opt_handletimeout, "handletimeout=%s" },
214 { Opt_echo_interval, "echo_interval=%s" },
215 { Opt_max_credits, "max_credits=%s" },
216 { Opt_snapshot, "snapshot=%s" },
217 { Opt_compress, "compress=%s" },
219 { Opt_blank_user, "user=" },
220 { Opt_blank_user, "username=" },
221 { Opt_user, "user=%s" },
222 { Opt_user, "username=%s" },
223 { Opt_blank_pass, "pass=" },
224 { Opt_blank_pass, "password=" },
225 { Opt_pass, "pass=%s" },
226 { Opt_pass, "password=%s" },
227 { Opt_blank_ip, "ip=" },
228 { Opt_blank_ip, "addr=" },
230 { Opt_ip, "addr=%s" },
231 { Opt_ignore, "unc=%s" },
232 { Opt_ignore, "target=%s" },
233 { Opt_ignore, "path=%s" },
234 { Opt_domain, "dom=%s" },
235 { Opt_domain, "domain=%s" },
236 { Opt_domain, "workgroup=%s" },
237 { Opt_srcaddr, "srcaddr=%s" },
238 { Opt_ignore, "prefixpath=%s" },
239 { Opt_iocharset, "iocharset=%s" },
240 { Opt_netbiosname, "netbiosname=%s" },
241 { Opt_servern, "servern=%s" },
242 { Opt_ver, "ver=%s" },
243 { Opt_vers, "vers=%s" },
244 { Opt_sec, "sec=%s" },
245 { Opt_cache, "cache=%s" },
247 { Opt_ignore, "cred" },
248 { Opt_ignore, "credentials" },
249 { Opt_ignore, "cred=%s" },
250 { Opt_ignore, "credentials=%s" },
251 { Opt_ignore, "guest" },
252 { Opt_ignore, "rw" },
253 { Opt_ignore, "ro" },
254 { Opt_ignore, "suid" },
255 { Opt_ignore, "nosuid" },
256 { Opt_ignore, "exec" },
257 { Opt_ignore, "noexec" },
258 { Opt_ignore, "nodev" },
259 { Opt_ignore, "noauto" },
260 { Opt_ignore, "dev" },
261 { Opt_ignore, "mand" },
262 { Opt_ignore, "nomand" },
263 { Opt_ignore, "relatime" },
264 { Opt_ignore, "_netdev" },
270 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
271 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
272 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
273 Opt_sec_ntlmv2i, Opt_sec_lanman,
279 static const match_table_t cifs_secflavor_tokens = {
280 { Opt_sec_krb5, "krb5" },
281 { Opt_sec_krb5i, "krb5i" },
282 { Opt_sec_krb5p, "krb5p" },
283 { Opt_sec_ntlmsspi, "ntlmsspi" },
284 { Opt_sec_ntlmssp, "ntlmssp" },
285 { Opt_ntlm, "ntlm" },
286 { Opt_sec_ntlmi, "ntlmi" },
287 { Opt_sec_ntlmv2, "nontlm" },
288 { Opt_sec_ntlmv2, "ntlmv2" },
289 { Opt_sec_ntlmv2i, "ntlmv2i" },
290 { Opt_sec_lanman, "lanman" },
291 { Opt_sec_none, "none" },
293 { Opt_sec_err, NULL }
304 static const match_table_t cifs_cacheflavor_tokens = {
305 { Opt_cache_loose, "loose" },
306 { Opt_cache_strict, "strict" },
307 { Opt_cache_none, "none" },
308 { Opt_cache_err, NULL }
311 static const match_table_t cifs_smb_version_tokens = {
312 { Smb_1, SMB1_VERSION_STRING },
313 { Smb_20, SMB20_VERSION_STRING},
314 { Smb_21, SMB21_VERSION_STRING },
315 { Smb_30, SMB30_VERSION_STRING },
316 { Smb_302, SMB302_VERSION_STRING },
317 { Smb_302, ALT_SMB302_VERSION_STRING },
318 { Smb_311, SMB311_VERSION_STRING },
319 { Smb_311, ALT_SMB311_VERSION_STRING },
320 { Smb_3any, SMB3ANY_VERSION_STRING },
321 { Smb_default, SMBDEFAULT_VERSION_STRING },
322 { Smb_version_err, NULL }
325 static int ip_connect(struct TCP_Server_Info *server);
326 static int generic_ip_connect(struct TCP_Server_Info *server);
327 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
328 static void cifs_prune_tlinks(struct work_struct *work);
329 static char *extract_hostname(const char *unc);
332 * Resolve hostname and set ip addr in tcp ses. Useful for hostnames that may
333 * get their ip addresses changed at some point.
335 * This should be called with server->srv_mutex held.
337 #ifdef CONFIG_CIFS_DFS_UPCALL
338 static int reconn_set_ipaddr(struct TCP_Server_Info *server)
342 char *unc, *ipaddr = NULL;
344 if (!server->hostname)
347 len = strlen(server->hostname) + 3;
349 unc = kmalloc(len, GFP_KERNEL);
351 cifs_dbg(FYI, "%s: failed to create UNC path\n", __func__);
354 scnprintf(unc, len, "\\\\%s", server->hostname);
356 rc = dns_resolve_server_name_to_ip(unc, &ipaddr);
360 cifs_dbg(FYI, "%s: failed to resolve server part of %s to IP: %d\n",
361 __func__, server->hostname, rc);
365 rc = cifs_convert_address((struct sockaddr *)&server->dstaddr, ipaddr,
372 static inline int reconn_set_ipaddr(struct TCP_Server_Info *server)
378 #ifdef CONFIG_CIFS_DFS_UPCALL
379 struct super_cb_data {
380 struct TCP_Server_Info *server;
381 struct cifs_sb_info *cifs_sb;
384 /* These functions must be called with server->srv_mutex held */
386 static void super_cb(struct super_block *sb, void *arg)
388 struct super_cb_data *d = arg;
389 struct cifs_sb_info *cifs_sb;
390 struct cifs_tcon *tcon;
395 cifs_sb = CIFS_SB(sb);
396 tcon = cifs_sb_master_tcon(cifs_sb);
397 if (tcon->ses->server == d->server)
398 d->cifs_sb = cifs_sb;
401 static inline struct cifs_sb_info *
402 find_super_by_tcp(struct TCP_Server_Info *server)
404 struct super_cb_data d = {
409 iterate_supers_type(&cifs_fs_type, super_cb, &d);
410 return d.cifs_sb ? d.cifs_sb : ERR_PTR(-ENOENT);
413 static void reconn_inval_dfs_target(struct TCP_Server_Info *server,
414 struct cifs_sb_info *cifs_sb,
415 struct dfs_cache_tgt_list *tgt_list,
416 struct dfs_cache_tgt_iterator **tgt_it)
420 if (!cifs_sb || !cifs_sb->origin_fullpath || !tgt_list ||
425 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
427 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
429 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
432 cifs_dbg(FYI, "%s: UNC: %s\n", __func__, cifs_sb->origin_fullpath);
434 name = dfs_cache_get_tgt_name(*tgt_it);
436 kfree(server->hostname);
438 server->hostname = extract_hostname(name);
439 if (IS_ERR(server->hostname)) {
441 "%s: failed to extract hostname from target: %ld\n",
442 __func__, PTR_ERR(server->hostname));
446 static inline int reconn_setup_dfs_targets(struct cifs_sb_info *cifs_sb,
447 struct dfs_cache_tgt_list *tl,
448 struct dfs_cache_tgt_iterator **it)
450 if (!cifs_sb->origin_fullpath)
452 return dfs_cache_noreq_find(cifs_sb->origin_fullpath + 1, NULL, tl);
457 * cifs tcp session reconnection
459 * mark tcp session as reconnecting so temporarily locked
460 * mark all smb sessions as reconnecting for tcp session
461 * reconnect tcp session
462 * wake up waiters on reconnection? - (not needed currently)
465 cifs_reconnect(struct TCP_Server_Info *server)
468 struct list_head *tmp, *tmp2;
469 struct cifs_ses *ses;
470 struct cifs_tcon *tcon;
471 struct mid_q_entry *mid_entry;
472 struct list_head retry_list;
473 #ifdef CONFIG_CIFS_DFS_UPCALL
474 struct cifs_sb_info *cifs_sb = NULL;
475 struct dfs_cache_tgt_list tgt_list = {0};
476 struct dfs_cache_tgt_iterator *tgt_it = NULL;
479 spin_lock(&GlobalMid_Lock);
480 server->nr_targets = 1;
481 #ifdef CONFIG_CIFS_DFS_UPCALL
482 spin_unlock(&GlobalMid_Lock);
483 cifs_sb = find_super_by_tcp(server);
484 if (IS_ERR(cifs_sb)) {
485 rc = PTR_ERR(cifs_sb);
486 cifs_dbg(FYI, "%s: will not do DFS failover: rc = %d\n",
490 rc = reconn_setup_dfs_targets(cifs_sb, &tgt_list, &tgt_it);
491 if (rc && (rc != -EOPNOTSUPP)) {
492 cifs_dbg(VFS, "%s: no target servers for DFS failover\n",
495 server->nr_targets = dfs_cache_get_nr_tgts(&tgt_list);
498 cifs_dbg(FYI, "%s: will retry %d target(s)\n", __func__,
500 spin_lock(&GlobalMid_Lock);
502 if (server->tcpStatus == CifsExiting) {
503 /* the demux thread will exit normally
504 next time through the loop */
505 spin_unlock(&GlobalMid_Lock);
508 server->tcpStatus = CifsNeedReconnect;
509 spin_unlock(&GlobalMid_Lock);
511 server->max_read = 0;
513 cifs_dbg(FYI, "Mark tcp session as need reconnect\n");
514 trace_smb3_reconnect(server->CurrentMid, server->hostname);
516 /* before reconnecting the tcp session, mark the smb session (uid)
517 and the tid bad so they are not used until reconnected */
518 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
520 spin_lock(&cifs_tcp_ses_lock);
521 list_for_each(tmp, &server->smb_ses_list) {
522 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
523 ses->need_reconnect = true;
524 list_for_each(tmp2, &ses->tcon_list) {
525 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
526 tcon->need_reconnect = true;
529 ses->tcon_ipc->need_reconnect = true;
531 spin_unlock(&cifs_tcp_ses_lock);
533 /* do not want to be sending data on a socket we are freeing */
534 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
535 mutex_lock(&server->srv_mutex);
536 if (server->ssocket) {
537 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
538 server->ssocket->state, server->ssocket->flags);
539 kernel_sock_shutdown(server->ssocket, SHUT_WR);
540 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
541 server->ssocket->state, server->ssocket->flags);
542 sock_release(server->ssocket);
543 server->ssocket = NULL;
545 server->sequence_number = 0;
546 server->session_estab = false;
547 kfree(server->session_key.response);
548 server->session_key.response = NULL;
549 server->session_key.len = 0;
550 server->lstrp = jiffies;
552 /* mark submitted MIDs for retry and issue callback */
553 INIT_LIST_HEAD(&retry_list);
554 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
555 spin_lock(&GlobalMid_Lock);
556 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
557 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
558 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
559 mid_entry->mid_state = MID_RETRY_NEEDED;
560 list_move(&mid_entry->qhead, &retry_list);
562 spin_unlock(&GlobalMid_Lock);
563 mutex_unlock(&server->srv_mutex);
565 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
566 list_for_each_safe(tmp, tmp2, &retry_list) {
567 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
568 list_del_init(&mid_entry->qhead);
569 mid_entry->callback(mid_entry);
572 if (cifs_rdma_enabled(server)) {
573 mutex_lock(&server->srv_mutex);
574 smbd_destroy(server);
575 mutex_unlock(&server->srv_mutex);
581 mutex_lock(&server->srv_mutex);
583 * Set up next DFS target server (if any) for reconnect. If DFS
584 * feature is disabled, then we will retry last server we
585 * connected to before.
587 if (cifs_rdma_enabled(server))
588 rc = smbd_reconnect(server);
590 rc = generic_ip_connect(server);
592 cifs_dbg(FYI, "reconnect error %d\n", rc);
593 #ifdef CONFIG_CIFS_DFS_UPCALL
594 reconn_inval_dfs_target(server, cifs_sb, &tgt_list,
597 rc = reconn_set_ipaddr(server);
599 cifs_dbg(FYI, "%s: failed to resolve hostname: %d\n",
602 mutex_unlock(&server->srv_mutex);
605 atomic_inc(&tcpSesReconnectCount);
606 set_credits(server, 1);
607 spin_lock(&GlobalMid_Lock);
608 if (server->tcpStatus != CifsExiting)
609 server->tcpStatus = CifsNeedNegotiate;
610 spin_unlock(&GlobalMid_Lock);
611 mutex_unlock(&server->srv_mutex);
613 } while (server->tcpStatus == CifsNeedReconnect);
615 #ifdef CONFIG_CIFS_DFS_UPCALL
617 rc = dfs_cache_noreq_update_tgthint(cifs_sb->origin_fullpath + 1,
620 cifs_dbg(VFS, "%s: failed to update DFS target hint: rc = %d\n",
623 rc = dfs_cache_update_vol(cifs_sb->origin_fullpath, server);
625 cifs_dbg(VFS, "%s: failed to update vol info in DFS cache: rc = %d\n",
628 dfs_cache_free_tgts(&tgt_list);
631 if (server->tcpStatus == CifsNeedNegotiate)
632 mod_delayed_work(cifsiod_wq, &server->echo, 0);
638 cifs_echo_request(struct work_struct *work)
641 struct TCP_Server_Info *server = container_of(work,
642 struct TCP_Server_Info, echo.work);
643 unsigned long echo_interval;
646 * If we need to renegotiate, set echo interval to zero to
647 * immediately call echo service where we can renegotiate.
649 if (server->tcpStatus == CifsNeedNegotiate)
652 echo_interval = server->echo_interval;
655 * We cannot send an echo if it is disabled.
656 * Also, no need to ping if we got a response recently.
659 if (server->tcpStatus == CifsNeedReconnect ||
660 server->tcpStatus == CifsExiting ||
661 server->tcpStatus == CifsNew ||
662 (server->ops->can_echo && !server->ops->can_echo(server)) ||
663 time_before(jiffies, server->lstrp + echo_interval - HZ))
666 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
668 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
672 queue_delayed_work(cifsiod_wq, &server->echo, server->echo_interval);
676 allocate_buffers(struct TCP_Server_Info *server)
678 if (!server->bigbuf) {
679 server->bigbuf = (char *)cifs_buf_get();
680 if (!server->bigbuf) {
681 cifs_dbg(VFS, "No memory for large SMB response\n");
683 /* retry will check if exiting */
686 } else if (server->large_buf) {
687 /* we are reusing a dirty large buf, clear its start */
688 memset(server->bigbuf, 0, HEADER_SIZE(server));
691 if (!server->smallbuf) {
692 server->smallbuf = (char *)cifs_small_buf_get();
693 if (!server->smallbuf) {
694 cifs_dbg(VFS, "No memory for SMB response\n");
696 /* retry will check if exiting */
699 /* beginning of smb buffer is cleared in our buf_get */
701 /* if existing small buf clear beginning */
702 memset(server->smallbuf, 0, HEADER_SIZE(server));
709 server_unresponsive(struct TCP_Server_Info *server)
712 * We need to wait 3 echo intervals to make sure we handle such
714 * 1s client sends a normal SMB request
715 * 3s client gets a response
716 * 30s echo workqueue job pops, and decides we got a response recently
717 * and don't need to send another
719 * 65s kernel_recvmsg times out, and we see that we haven't gotten
720 * a response in >60s.
722 if ((server->tcpStatus == CifsGood ||
723 server->tcpStatus == CifsNeedNegotiate) &&
724 time_after(jiffies, server->lstrp + 3 * server->echo_interval)) {
725 cifs_dbg(VFS, "Server %s has not responded in %lu seconds. Reconnecting...\n",
726 server->hostname, (3 * server->echo_interval) / HZ);
727 cifs_reconnect(server);
728 wake_up(&server->response_q);
736 zero_credits(struct TCP_Server_Info *server)
740 spin_lock(&server->req_lock);
741 val = server->credits + server->echo_credits + server->oplock_credits;
742 if (server->in_flight == 0 && val == 0) {
743 spin_unlock(&server->req_lock);
746 spin_unlock(&server->req_lock);
751 cifs_readv_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg)
756 smb_msg->msg_control = NULL;
757 smb_msg->msg_controllen = 0;
759 for (total_read = 0; msg_data_left(smb_msg); total_read += length) {
762 /* reconnect if no credits and no requests in flight */
763 if (zero_credits(server)) {
764 cifs_reconnect(server);
765 return -ECONNABORTED;
768 if (server_unresponsive(server))
769 return -ECONNABORTED;
770 if (cifs_rdma_enabled(server) && server->smbd_conn)
771 length = smbd_recv(server->smbd_conn, smb_msg);
773 length = sock_recvmsg(server->ssocket, smb_msg, 0);
775 if (server->tcpStatus == CifsExiting)
778 if (server->tcpStatus == CifsNeedReconnect) {
779 cifs_reconnect(server);
780 return -ECONNABORTED;
783 if (length == -ERESTARTSYS ||
787 * Minimum sleep to prevent looping, allowing socket
788 * to clear and app threads to set tcpStatus
789 * CifsNeedReconnect if server hung.
791 usleep_range(1000, 2000);
797 cifs_dbg(FYI, "Received no data or error: %d\n", length);
798 cifs_reconnect(server);
799 return -ECONNABORTED;
806 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
807 unsigned int to_read)
809 struct msghdr smb_msg;
810 struct kvec iov = {.iov_base = buf, .iov_len = to_read};
811 iov_iter_kvec(&smb_msg.msg_iter, READ, &iov, 1, to_read);
813 return cifs_readv_from_socket(server, &smb_msg);
817 cifs_read_page_from_socket(struct TCP_Server_Info *server, struct page *page,
818 unsigned int page_offset, unsigned int to_read)
820 struct msghdr smb_msg;
821 struct bio_vec bv = {
822 .bv_page = page, .bv_len = to_read, .bv_offset = page_offset};
823 iov_iter_bvec(&smb_msg.msg_iter, READ, &bv, 1, to_read);
824 return cifs_readv_from_socket(server, &smb_msg);
828 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
831 * The first byte big endian of the length field,
832 * is actually not part of the length but the type
833 * with the most common, zero, as regular data.
836 case RFC1002_SESSION_MESSAGE:
837 /* Regular SMB response */
839 case RFC1002_SESSION_KEEP_ALIVE:
840 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
842 case RFC1002_POSITIVE_SESSION_RESPONSE:
843 cifs_dbg(FYI, "RFC 1002 positive session response\n");
845 case RFC1002_NEGATIVE_SESSION_RESPONSE:
847 * We get this from Windows 98 instead of an error on
848 * SMB negprot response.
850 cifs_dbg(FYI, "RFC 1002 negative session response\n");
851 /* give server a second to clean up */
854 * Always try 445 first on reconnect since we get NACK
855 * on some if we ever connected to port 139 (the NACK
856 * is since we do not begin with RFC1001 session
859 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
860 cifs_reconnect(server);
861 wake_up(&server->response_q);
864 cifs_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
865 cifs_reconnect(server);
872 dequeue_mid(struct mid_q_entry *mid, bool malformed)
874 #ifdef CONFIG_CIFS_STATS2
875 mid->when_received = jiffies;
877 spin_lock(&GlobalMid_Lock);
879 mid->mid_state = MID_RESPONSE_RECEIVED;
881 mid->mid_state = MID_RESPONSE_MALFORMED;
883 * Trying to handle/dequeue a mid after the send_recv()
884 * function has finished processing it is a bug.
886 if (mid->mid_flags & MID_DELETED)
887 printk_once(KERN_WARNING
888 "trying to dequeue a deleted mid\n");
890 list_del_init(&mid->qhead);
891 spin_unlock(&GlobalMid_Lock);
895 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
896 char *buf, int malformed)
898 if (server->ops->check_trans2 &&
899 server->ops->check_trans2(mid, server, buf, malformed))
902 mid->large_buf = server->large_buf;
903 /* Was previous buf put in mpx struct for multi-rsp? */
904 if (!mid->multiRsp) {
905 /* smb buffer will be freed by user thread */
906 if (server->large_buf)
907 server->bigbuf = NULL;
909 server->smallbuf = NULL;
911 dequeue_mid(mid, malformed);
914 static void clean_demultiplex_info(struct TCP_Server_Info *server)
918 /* take it off the list, if it's not already */
919 spin_lock(&cifs_tcp_ses_lock);
920 list_del_init(&server->tcp_ses_list);
921 spin_unlock(&cifs_tcp_ses_lock);
923 spin_lock(&GlobalMid_Lock);
924 server->tcpStatus = CifsExiting;
925 spin_unlock(&GlobalMid_Lock);
926 wake_up_all(&server->response_q);
928 /* check if we have blocked requests that need to free */
929 spin_lock(&server->req_lock);
930 if (server->credits <= 0)
932 spin_unlock(&server->req_lock);
934 * Although there should not be any requests blocked on this queue it
935 * can not hurt to be paranoid and try to wake up requests that may
936 * haven been blocked when more than 50 at time were on the wire to the
937 * same server - they now will see the session is in exit state and get
938 * out of SendReceive.
940 wake_up_all(&server->request_q);
941 /* give those requests time to exit */
943 if (cifs_rdma_enabled(server))
944 smbd_destroy(server);
945 if (server->ssocket) {
946 sock_release(server->ssocket);
947 server->ssocket = NULL;
950 if (!list_empty(&server->pending_mid_q)) {
951 struct list_head dispose_list;
952 struct mid_q_entry *mid_entry;
953 struct list_head *tmp, *tmp2;
955 INIT_LIST_HEAD(&dispose_list);
956 spin_lock(&GlobalMid_Lock);
957 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
958 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
959 cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
960 mid_entry->mid_state = MID_SHUTDOWN;
961 list_move(&mid_entry->qhead, &dispose_list);
963 spin_unlock(&GlobalMid_Lock);
965 /* now walk dispose list and issue callbacks */
966 list_for_each_safe(tmp, tmp2, &dispose_list) {
967 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
968 cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
969 list_del_init(&mid_entry->qhead);
970 mid_entry->callback(mid_entry);
972 /* 1/8th of sec is more than enough time for them to exit */
976 if (!list_empty(&server->pending_mid_q)) {
978 * mpx threads have not exited yet give them at least the smb
979 * send timeout time for long ops.
981 * Due to delays on oplock break requests, we need to wait at
982 * least 45 seconds before giving up on a request getting a
983 * response and going ahead and killing cifsd.
985 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
988 * If threads still have not exited they are probably never
989 * coming home not much else we can do but free the memory.
993 kfree(server->hostname);
996 length = atomic_dec_return(&tcpSesAllocCount);
998 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
1002 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1005 char *buf = server->smallbuf;
1006 unsigned int pdu_length = server->pdu_size;
1008 /* make sure this will fit in a large buffer */
1009 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) -
1010 server->vals->header_preamble_size) {
1011 cifs_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
1012 cifs_reconnect(server);
1013 wake_up(&server->response_q);
1014 return -ECONNABORTED;
1017 /* switch to large buffer if too big for a small one */
1018 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
1019 server->large_buf = true;
1020 memcpy(server->bigbuf, buf, server->total_read);
1021 buf = server->bigbuf;
1024 /* now read the rest */
1025 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
1026 pdu_length - HEADER_SIZE(server) + 1
1027 + server->vals->header_preamble_size);
1031 server->total_read += length;
1033 dump_smb(buf, server->total_read);
1035 return cifs_handle_standard(server, mid);
1039 cifs_handle_standard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1041 char *buf = server->large_buf ? server->bigbuf : server->smallbuf;
1045 * We know that we received enough to get to the MID as we
1046 * checked the pdu_length earlier. Now check to see
1047 * if the rest of the header is OK. We borrow the length
1048 * var for the rest of the loop to avoid a new stack var.
1050 * 48 bytes is enough to display the header and a little bit
1051 * into the payload for debugging purposes.
1053 length = server->ops->check_message(buf, server->total_read, server);
1055 cifs_dump_mem("Bad SMB: ", buf,
1056 min_t(unsigned int, server->total_read, 48));
1058 if (server->ops->is_session_expired &&
1059 server->ops->is_session_expired(buf)) {
1060 cifs_reconnect(server);
1061 wake_up(&server->response_q);
1065 if (server->ops->is_status_pending &&
1066 server->ops->is_status_pending(buf, server))
1072 handle_mid(mid, server, buf, length);
1077 smb2_add_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)
1079 struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buffer;
1082 * SMB1 does not use credits.
1084 if (server->vals->header_preamble_size)
1087 if (shdr->CreditRequest) {
1088 spin_lock(&server->req_lock);
1089 server->credits += le16_to_cpu(shdr->CreditRequest);
1090 spin_unlock(&server->req_lock);
1091 wake_up(&server->request_q);
1097 cifs_demultiplex_thread(void *p)
1099 int i, num_mids, length;
1100 struct TCP_Server_Info *server = p;
1101 unsigned int pdu_length;
1102 unsigned int next_offset;
1104 struct task_struct *task_to_wake = NULL;
1105 struct mid_q_entry *mids[MAX_COMPOUND];
1106 char *bufs[MAX_COMPOUND];
1108 current->flags |= PF_MEMALLOC;
1109 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
1111 length = atomic_inc_return(&tcpSesAllocCount);
1113 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
1116 allow_kernel_signal(SIGKILL);
1117 while (server->tcpStatus != CifsExiting) {
1118 if (try_to_freeze())
1121 if (!allocate_buffers(server))
1124 server->large_buf = false;
1125 buf = server->smallbuf;
1126 pdu_length = 4; /* enough to get RFC1001 header */
1128 length = cifs_read_from_socket(server, buf, pdu_length);
1132 if (server->vals->header_preamble_size == 0)
1133 server->total_read = 0;
1135 server->total_read = length;
1138 * The right amount was read from socket - 4 bytes,
1139 * so we can now interpret the length field.
1141 pdu_length = get_rfc1002_length(buf);
1143 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
1144 if (!is_smb_response(server, buf[0]))
1147 server->pdu_size = pdu_length;
1149 /* make sure we have enough to get to the MID */
1150 if (server->pdu_size < HEADER_SIZE(server) - 1 -
1151 server->vals->header_preamble_size) {
1152 cifs_dbg(VFS, "SMB response too short (%u bytes)\n",
1154 cifs_reconnect(server);
1155 wake_up(&server->response_q);
1159 /* read down to the MID */
1160 length = cifs_read_from_socket(server,
1161 buf + server->vals->header_preamble_size,
1162 HEADER_SIZE(server) - 1
1163 - server->vals->header_preamble_size);
1166 server->total_read += length;
1168 if (server->ops->next_header) {
1169 next_offset = server->ops->next_header(buf);
1171 server->pdu_size = next_offset;
1174 memset(mids, 0, sizeof(mids));
1175 memset(bufs, 0, sizeof(bufs));
1178 if (server->ops->is_transform_hdr &&
1179 server->ops->receive_transform &&
1180 server->ops->is_transform_hdr(buf)) {
1181 length = server->ops->receive_transform(server,
1186 mids[0] = server->ops->find_mid(server, buf);
1190 if (!mids[0] || !mids[0]->receive)
1191 length = standard_receive3(server, mids[0]);
1193 length = mids[0]->receive(server, mids[0]);
1197 for (i = 0; i < num_mids; i++)
1199 cifs_mid_q_entry_release(mids[i]);
1203 server->lstrp = jiffies;
1205 for (i = 0; i < num_mids; i++) {
1206 if (mids[i] != NULL) {
1207 mids[i]->resp_buf_size = server->pdu_size;
1208 if ((mids[i]->mid_flags & MID_WAIT_CANCELLED) &&
1209 mids[i]->mid_state == MID_RESPONSE_RECEIVED &&
1210 server->ops->handle_cancelled_mid)
1211 server->ops->handle_cancelled_mid(
1215 if (!mids[i]->multiRsp || mids[i]->multiEnd)
1216 mids[i]->callback(mids[i]);
1218 cifs_mid_q_entry_release(mids[i]);
1219 } else if (server->ops->is_oplock_break &&
1220 server->ops->is_oplock_break(bufs[i],
1222 smb2_add_credits_from_hdr(bufs[i], server);
1223 cifs_dbg(FYI, "Received oplock break\n");
1225 cifs_dbg(VFS, "No task to wake, unknown frame "
1226 "received! NumMids %d\n",
1227 atomic_read(&midCount));
1228 cifs_dump_mem("Received Data is: ", bufs[i],
1229 HEADER_SIZE(server));
1230 smb2_add_credits_from_hdr(bufs[i], server);
1231 #ifdef CONFIG_CIFS_DEBUG2
1232 if (server->ops->dump_detail)
1233 server->ops->dump_detail(bufs[i],
1235 cifs_dump_mids(server);
1236 #endif /* CIFS_DEBUG2 */
1240 if (pdu_length > server->pdu_size) {
1241 if (!allocate_buffers(server))
1243 pdu_length -= server->pdu_size;
1244 server->total_read = 0;
1245 server->large_buf = false;
1246 buf = server->smallbuf;
1249 } /* end while !EXITING */
1251 /* buffer usually freed in free_mid - need to free it here on exit */
1252 cifs_buf_release(server->bigbuf);
1253 if (server->smallbuf) /* no sense logging a debug message if NULL */
1254 cifs_small_buf_release(server->smallbuf);
1256 task_to_wake = xchg(&server->tsk, NULL);
1257 clean_demultiplex_info(server);
1259 /* if server->tsk was NULL then wait for a signal before exiting */
1260 if (!task_to_wake) {
1261 set_current_state(TASK_INTERRUPTIBLE);
1262 while (!signal_pending(current)) {
1264 set_current_state(TASK_INTERRUPTIBLE);
1266 set_current_state(TASK_RUNNING);
1269 module_put_and_exit(0);
1272 /* extract the host portion of the UNC string */
1274 extract_hostname(const char *unc)
1280 /* skip double chars at beginning of string */
1281 /* BB: check validity of these bytes? */
1282 if (strlen(unc) < 3)
1283 return ERR_PTR(-EINVAL);
1284 for (src = unc; *src && *src == '\\'; src++)
1287 return ERR_PTR(-EINVAL);
1289 /* delimiter between hostname and sharename is always '\\' now */
1290 delim = strchr(src, '\\');
1292 return ERR_PTR(-EINVAL);
1295 dst = kmalloc((len + 1), GFP_KERNEL);
1297 return ERR_PTR(-ENOMEM);
1299 memcpy(dst, src, len);
1305 static int get_option_ul(substring_t args[], unsigned long *option)
1310 string = match_strdup(args);
1313 rc = kstrtoul(string, 0, option);
1319 static int get_option_uid(substring_t args[], kuid_t *result)
1321 unsigned long value;
1325 rc = get_option_ul(args, &value);
1329 uid = make_kuid(current_user_ns(), value);
1330 if (!uid_valid(uid))
1337 static int get_option_gid(substring_t args[], kgid_t *result)
1339 unsigned long value;
1343 rc = get_option_ul(args, &value);
1347 gid = make_kgid(current_user_ns(), value);
1348 if (!gid_valid(gid))
1355 static int cifs_parse_security_flavors(char *value,
1356 struct smb_vol *vol)
1359 substring_t args[MAX_OPT_ARGS];
1362 * With mount options, the last one should win. Reset any existing
1363 * settings back to default.
1365 vol->sectype = Unspecified;
1368 switch (match_token(value, cifs_secflavor_tokens, args)) {
1370 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
1376 vol->sectype = Kerberos;
1378 case Opt_sec_ntlmsspi:
1381 case Opt_sec_ntlmssp:
1382 vol->sectype = RawNTLMSSP;
1388 vol->sectype = NTLM;
1390 case Opt_sec_ntlmv2i:
1393 case Opt_sec_ntlmv2:
1394 vol->sectype = NTLMv2;
1396 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1397 case Opt_sec_lanman:
1398 vol->sectype = LANMAN;
1405 cifs_dbg(VFS, "bad security option: %s\n", value);
1413 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1415 substring_t args[MAX_OPT_ARGS];
1417 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1418 case Opt_cache_loose:
1419 vol->direct_io = false;
1420 vol->strict_io = false;
1422 case Opt_cache_strict:
1423 vol->direct_io = false;
1424 vol->strict_io = true;
1426 case Opt_cache_none:
1427 vol->direct_io = true;
1428 vol->strict_io = false;
1431 cifs_dbg(VFS, "bad cache= option: %s\n", value);
1438 cifs_parse_smb_version(char *value, struct smb_vol *vol, bool is_smb3)
1440 substring_t args[MAX_OPT_ARGS];
1442 switch (match_token(value, cifs_smb_version_tokens, args)) {
1443 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1445 if (disable_legacy_dialects) {
1446 cifs_dbg(VFS, "mount with legacy dialect disabled\n");
1450 cifs_dbg(VFS, "vers=1.0 (cifs) not permitted when mounting with smb3\n");
1453 vol->ops = &smb1_operations;
1454 vol->vals = &smb1_values;
1457 if (disable_legacy_dialects) {
1458 cifs_dbg(VFS, "mount with legacy dialect disabled\n");
1462 cifs_dbg(VFS, "vers=2.0 not permitted when mounting with smb3\n");
1465 vol->ops = &smb20_operations;
1466 vol->vals = &smb20_values;
1470 cifs_dbg(VFS, "vers=1.0 (cifs) mount not permitted when legacy dialects disabled\n");
1473 cifs_dbg(VFS, "vers=2.0 mount not permitted when legacy dialects disabled\n");
1475 #endif /* CIFS_ALLOW_INSECURE_LEGACY */
1477 vol->ops = &smb21_operations;
1478 vol->vals = &smb21_values;
1481 vol->ops = &smb30_operations;
1482 vol->vals = &smb30_values;
1485 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1486 vol->vals = &smb302_values;
1489 vol->ops = &smb311_operations;
1490 vol->vals = &smb311_values;
1493 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1494 vol->vals = &smb3any_values;
1497 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1498 vol->vals = &smbdefault_values;
1501 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
1508 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1509 * fields with the result. Returns 0 on success and an error otherwise.
1512 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1515 const char *delims = "/\\";
1518 if (unlikely(!devname || !*devname)) {
1519 cifs_dbg(VFS, "Device name not specified.\n");
1523 /* make sure we have a valid UNC double delimiter prefix */
1524 len = strspn(devname, delims);
1528 /* find delimiter between host and sharename */
1529 pos = strpbrk(devname + 2, delims);
1533 /* skip past delimiter */
1536 /* now go until next delimiter or end of string */
1537 len = strcspn(pos, delims);
1539 /* move "pos" up to delimiter or NULL */
1541 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1545 convert_delimiter(vol->UNC, '\\');
1547 /* skip any delimiter */
1548 if (*pos == '/' || *pos == '\\')
1551 /* If pos is NULL then no prepath */
1555 vol->prepath = kstrdup(pos, GFP_KERNEL);
1563 cifs_parse_mount_options(const char *mountdata, const char *devname,
1564 struct smb_vol *vol, bool is_smb3)
1567 char *mountdata_copy = NULL, *options;
1568 unsigned int temp_len, i, j;
1570 short int override_uid = -1;
1571 short int override_gid = -1;
1572 bool uid_specified = false;
1573 bool gid_specified = false;
1574 bool sloppy = false;
1575 char *invalid = NULL;
1576 char *nodename = utsname()->nodename;
1577 char *string = NULL;
1578 char *tmp_end, *value;
1580 bool got_ip = false;
1581 bool got_version = false;
1582 unsigned short port = 0;
1583 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1587 delim = separator[0];
1589 /* ensure we always start with zeroed-out smb_vol */
1590 memset(vol, 0, sizeof(*vol));
1593 * does not have to be perfect mapping since field is
1594 * informational, only used for servers that do not support
1595 * port 445 and it can be overridden at mount time
1597 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1598 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1599 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1601 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1602 /* null target name indicates to use *SMBSERVR default called name
1603 if we end up sending RFC1001 session initialize */
1604 vol->target_rfc1001_name[0] = 0;
1605 vol->cred_uid = current_uid();
1606 vol->linux_uid = current_uid();
1607 vol->linux_gid = current_gid();
1608 vol->bsize = 1024 * 1024; /* can improve cp performance significantly */
1610 * default to SFM style remapping of seven reserved characters
1611 * unless user overrides it or we negotiate CIFS POSIX where
1612 * it is unnecessary. Can not simultaneously use more than one mapping
1613 * since then readdir could list files that open could not open
1617 /* default to only allowing write access to owner of the mount */
1618 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1620 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1621 /* default is always to request posix paths. */
1622 vol->posix_paths = 1;
1623 /* default to using server inode numbers where available */
1624 vol->server_ino = 1;
1626 /* default is to use strict cifs caching semantics */
1627 vol->strict_io = true;
1629 vol->actimeo = CIFS_DEF_ACTIMEO;
1631 /* Most clients set timeout to 0, allows server to use its default */
1632 vol->handle_timeout = 0; /* See MS-SMB2 spec section 2.2.14.2.12 */
1634 /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1635 vol->ops = &smb30_operations;
1636 vol->vals = &smbdefault_values;
1638 vol->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1641 goto cifs_parse_mount_err;
1643 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1644 if (!mountdata_copy)
1645 goto cifs_parse_mount_err;
1647 options = mountdata_copy;
1648 end = options + strlen(options);
1650 if (strncmp(options, "sep=", 4) == 0) {
1651 if (options[4] != 0) {
1652 separator[0] = options[4];
1655 cifs_dbg(FYI, "Null separator not allowed\n");
1658 vol->backupuid_specified = false; /* no backup intent for a user */
1659 vol->backupgid_specified = false; /* no backup intent for a group */
1661 switch (cifs_parse_devname(devname, vol)) {
1665 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1666 goto cifs_parse_mount_err;
1668 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1669 goto cifs_parse_mount_err;
1671 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1672 goto cifs_parse_mount_err;
1675 while ((data = strsep(&options, separator)) != NULL) {
1676 substring_t args[MAX_OPT_ARGS];
1677 unsigned long option;
1683 token = match_token(data, cifs_mount_option_tokens, args);
1687 /* Ingnore the following */
1691 /* Boolean values */
1692 case Opt_user_xattr:
1695 case Opt_nouser_xattr:
1701 case Opt_noforceuid:
1707 case Opt_noforcegid:
1710 case Opt_noblocksend:
1711 vol->noblocksnd = 1;
1713 case Opt_noautotune:
1714 vol->noautotune = 1;
1729 vol->sfu_remap = true;
1730 vol->remap = false; /* disable SFM mapping */
1732 case Opt_nomapchars:
1733 vol->sfu_remap = false;
1737 vol->sfu_remap = false; /* disable SFU mapping */
1739 case Opt_nomapposix:
1751 case Opt_posixpaths:
1752 vol->posix_paths = 1;
1754 case Opt_noposixpaths:
1755 vol->posix_paths = 0;
1760 "conflicting unix mount options\n");
1761 vol->no_linux_ext = 1;
1764 if (vol->no_linux_ext)
1766 "conflicting unix mount options\n");
1778 * turn off mandatory locking in mode
1779 * if remote locking is turned off since the
1780 * local vfs will do advisory
1782 if (vol->file_mode ==
1783 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1784 vol->file_mode = S_IALLUGO;
1786 case Opt_nohandlecache:
1787 vol->nohandlecache = 1;
1789 case Opt_handlecache:
1790 vol->nohandlecache = 0;
1792 case Opt_forcemandatorylock:
1801 case Opt_setuidfromacl:
1802 vol->setuidfromacl = 1;
1805 vol->dynperm = true;
1808 vol->dynperm = false;
1822 case Opt_nostrictsync:
1823 vol->nostrictsync = 1;
1825 case Opt_strictsync:
1826 vol->nostrictsync = 0;
1829 vol->server_ino = 1;
1831 case Opt_noserverino:
1832 vol->server_ino = 0;
1834 case Opt_rwpidforward:
1835 vol->rwpidforward = 1;
1847 vol->no_psx_acl = 0;
1850 vol->no_psx_acl = 1;
1852 case Opt_locallease:
1853 vol->local_lease = 1;
1859 /* we do not do the following in secFlags because seal
1860 * is a per tree connection (mount) not a per socket
1861 * or per-smb connection option in the protocol
1862 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1867 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1870 #ifndef CONFIG_CIFS_FSCACHE
1871 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1872 goto cifs_parse_mount_err;
1876 case Opt_mfsymlinks:
1877 vol->mfsymlinks = true;
1880 vol->multiuser = true;
1885 case Opt_nosharesock:
1886 vol->nosharesock = true;
1888 case Opt_nopersistent:
1889 vol->nopersistent = true;
1890 if (vol->persistent) {
1892 "persistenthandles mount options conflict\n");
1893 goto cifs_parse_mount_err;
1896 case Opt_persistent:
1897 vol->persistent = true;
1898 if ((vol->nopersistent) || (vol->resilient)) {
1900 "persistenthandles mount options conflict\n");
1901 goto cifs_parse_mount_err;
1905 vol->resilient = true;
1906 if (vol->persistent) {
1908 "persistenthandles mount options conflict\n");
1909 goto cifs_parse_mount_err;
1912 case Opt_noresilient:
1913 vol->resilient = false; /* already the default */
1915 case Opt_domainauto:
1916 vol->domainauto = true;
1922 vol->compression = UNKNOWN_TYPE;
1924 "SMB3 compression support is experimental\n");
1927 /* Numeric Values */
1929 if (get_option_uid(args, &vol->backupuid)) {
1930 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1932 goto cifs_parse_mount_err;
1934 vol->backupuid_specified = true;
1937 if (get_option_gid(args, &vol->backupgid)) {
1938 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1940 goto cifs_parse_mount_err;
1942 vol->backupgid_specified = true;
1945 if (get_option_uid(args, &vol->linux_uid)) {
1946 cifs_dbg(VFS, "%s: Invalid uid value\n",
1948 goto cifs_parse_mount_err;
1950 uid_specified = true;
1953 if (get_option_uid(args, &vol->cred_uid)) {
1954 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1956 goto cifs_parse_mount_err;
1960 if (get_option_gid(args, &vol->linux_gid)) {
1961 cifs_dbg(VFS, "%s: Invalid gid value\n",
1963 goto cifs_parse_mount_err;
1965 gid_specified = true;
1968 if (get_option_ul(args, &option)) {
1969 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1971 goto cifs_parse_mount_err;
1973 vol->file_mode = option;
1976 if (get_option_ul(args, &option)) {
1977 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1979 goto cifs_parse_mount_err;
1981 vol->dir_mode = option;
1984 if (get_option_ul(args, &option) ||
1985 option > USHRT_MAX) {
1986 cifs_dbg(VFS, "%s: Invalid port value\n",
1988 goto cifs_parse_mount_err;
1990 port = (unsigned short)option;
1993 if (get_option_ul(args, &option)) {
1994 cifs_dbg(VFS, "%s: Invalid blocksize value\n",
1996 goto cifs_parse_mount_err;
1999 * inode blocksize realistically should never need to be
2000 * less than 16K or greater than 16M and default is 1MB.
2001 * Note that small inode block sizes (e.g. 64K) can lead
2002 * to very poor performance of common tools like cp and scp
2004 if ((option < CIFS_MAX_MSGSIZE) ||
2005 (option > (4 * SMB3_DEFAULT_IOSIZE))) {
2006 cifs_dbg(VFS, "%s: Invalid blocksize\n",
2008 goto cifs_parse_mount_err;
2010 vol->bsize = option;
2013 if (get_option_ul(args, &option)) {
2014 cifs_dbg(VFS, "%s: Invalid rsize value\n",
2016 goto cifs_parse_mount_err;
2018 vol->rsize = option;
2021 if (get_option_ul(args, &option)) {
2022 cifs_dbg(VFS, "%s: Invalid wsize value\n",
2024 goto cifs_parse_mount_err;
2026 vol->wsize = option;
2029 if (get_option_ul(args, &option)) {
2030 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
2032 goto cifs_parse_mount_err;
2034 vol->actimeo = HZ * option;
2035 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
2036 cifs_dbg(VFS, "attribute cache timeout too large\n");
2037 goto cifs_parse_mount_err;
2040 case Opt_handletimeout:
2041 if (get_option_ul(args, &option)) {
2042 cifs_dbg(VFS, "%s: Invalid handletimeout value\n",
2044 goto cifs_parse_mount_err;
2046 vol->handle_timeout = option;
2047 if (vol->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) {
2048 cifs_dbg(VFS, "Invalid handle cache timeout, longer than 16 minutes\n");
2049 goto cifs_parse_mount_err;
2052 case Opt_echo_interval:
2053 if (get_option_ul(args, &option)) {
2054 cifs_dbg(VFS, "%s: Invalid echo interval value\n",
2056 goto cifs_parse_mount_err;
2058 vol->echo_interval = option;
2061 if (get_option_ul(args, &option)) {
2062 cifs_dbg(VFS, "%s: Invalid snapshot time\n",
2064 goto cifs_parse_mount_err;
2066 vol->snapshot_time = option;
2068 case Opt_max_credits:
2069 if (get_option_ul(args, &option) || (option < 20) ||
2071 cifs_dbg(VFS, "%s: Invalid max_credits value\n",
2073 goto cifs_parse_mount_err;
2075 vol->max_credits = option;
2078 /* String Arguments */
2080 case Opt_blank_user:
2081 /* null user, ie. anonymous authentication */
2083 vol->username = NULL;
2086 string = match_strdup(args);
2090 if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
2091 CIFS_MAX_USERNAME_LEN) {
2092 pr_warn("CIFS: username too long\n");
2093 goto cifs_parse_mount_err;
2096 kfree(vol->username);
2097 vol->username = kstrdup(string, GFP_KERNEL);
2099 goto cifs_parse_mount_err;
2101 case Opt_blank_pass:
2102 /* passwords have to be handled differently
2103 * to allow the character used for deliminator
2104 * to be passed within them
2108 * Check if this is a case where the password
2109 * starts with a delimiter
2111 tmp_end = strchr(data, '=');
2113 if (!(tmp_end < end && tmp_end[1] == delim)) {
2114 /* No it is not. Set the password to NULL */
2115 kzfree(vol->password);
2116 vol->password = NULL;
2119 /* Fallthrough - to Opt_pass below.*/
2121 /* Obtain the value string */
2122 value = strchr(data, '=');
2125 /* Set tmp_end to end of the string */
2126 tmp_end = (char *) value + strlen(value);
2128 /* Check if following character is the deliminator
2129 * If yes, we have encountered a double deliminator
2130 * reset the NULL character to the deliminator
2132 if (tmp_end < end && tmp_end[1] == delim) {
2135 /* Keep iterating until we get to a single
2136 * deliminator OR the end
2138 while ((tmp_end = strchr(tmp_end, delim))
2139 != NULL && (tmp_end[1] == delim)) {
2140 tmp_end = (char *) &tmp_end[2];
2143 /* Reset var options to point to next element */
2146 options = (char *) &tmp_end[1];
2148 /* Reached the end of the mount option
2153 kzfree(vol->password);
2154 /* Now build new password string */
2155 temp_len = strlen(value);
2156 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
2157 if (vol->password == NULL) {
2158 pr_warn("CIFS: no memory for password\n");
2159 goto cifs_parse_mount_err;
2162 for (i = 0, j = 0; i < temp_len; i++, j++) {
2163 vol->password[j] = value[i];
2164 if ((value[i] == delim) &&
2165 value[i+1] == delim)
2166 /* skip the second deliminator */
2169 vol->password[j] = '\0';
2172 /* FIXME: should this be an error instead? */
2176 string = match_strdup(args);
2180 if (!cifs_convert_address(dstaddr, string,
2182 pr_err("CIFS: bad ip= option (%s).\n", string);
2183 goto cifs_parse_mount_err;
2188 string = match_strdup(args);
2192 if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
2193 == CIFS_MAX_DOMAINNAME_LEN) {
2194 pr_warn("CIFS: domain name too long\n");
2195 goto cifs_parse_mount_err;
2198 kfree(vol->domainname);
2199 vol->domainname = kstrdup(string, GFP_KERNEL);
2200 if (!vol->domainname) {
2201 pr_warn("CIFS: no memory for domainname\n");
2202 goto cifs_parse_mount_err;
2204 cifs_dbg(FYI, "Domain name set\n");
2207 string = match_strdup(args);
2211 if (!cifs_convert_address(
2212 (struct sockaddr *)&vol->srcaddr,
2213 string, strlen(string))) {
2214 pr_warn("CIFS: Could not parse srcaddr: %s\n",
2216 goto cifs_parse_mount_err;
2220 string = match_strdup(args);
2224 if (strnlen(string, 1024) >= 65) {
2225 pr_warn("CIFS: iocharset name too long.\n");
2226 goto cifs_parse_mount_err;
2229 if (strncasecmp(string, "default", 7) != 0) {
2230 kfree(vol->iocharset);
2231 vol->iocharset = kstrdup(string,
2233 if (!vol->iocharset) {
2234 pr_warn("CIFS: no memory for charset\n");
2235 goto cifs_parse_mount_err;
2238 /* if iocharset not set then load_nls_default
2241 cifs_dbg(FYI, "iocharset set to %s\n", string);
2243 case Opt_netbiosname:
2244 string = match_strdup(args);
2248 memset(vol->source_rfc1001_name, 0x20,
2251 * FIXME: are there cases in which a comma can
2252 * be valid in workstation netbios name (and
2253 * need special handling)?
2255 for (i = 0; i < RFC1001_NAME_LEN; i++) {
2256 /* don't ucase netbiosname for user */
2259 vol->source_rfc1001_name[i] = string[i];
2261 /* The string has 16th byte zero still from
2262 * set at top of the function
2264 if (i == RFC1001_NAME_LEN && string[i] != 0)
2265 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
2268 /* servernetbiosname specified override *SMBSERVER */
2269 string = match_strdup(args);
2273 /* last byte, type, is 0x20 for servr type */
2274 memset(vol->target_rfc1001_name, 0x20,
2275 RFC1001_NAME_LEN_WITH_NULL);
2277 /* BB are there cases in which a comma can be
2278 valid in this workstation netbios name
2279 (and need special handling)? */
2281 /* user or mount helper must uppercase the
2283 for (i = 0; i < 15; i++) {
2286 vol->target_rfc1001_name[i] = string[i];
2288 /* The string has 16th byte zero still from
2289 set at top of the function */
2290 if (i == RFC1001_NAME_LEN && string[i] != 0)
2291 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
2294 /* version of mount userspace tools, not dialect */
2295 string = match_strdup(args);
2299 /* If interface changes in mount.cifs bump to new ver */
2300 if (strncasecmp(string, "1", 1) == 0) {
2301 if (strlen(string) > 1) {
2302 pr_warn("Bad mount helper ver=%s. Did "
2303 "you want SMB1 (CIFS) dialect "
2304 "and mean to type vers=1.0 "
2305 "instead?\n", string);
2306 goto cifs_parse_mount_err;
2308 /* This is the default */
2311 /* For all other value, error */
2312 pr_warn("CIFS: Invalid mount helper version specified\n");
2313 goto cifs_parse_mount_err;
2315 /* protocol version (dialect) */
2316 string = match_strdup(args);
2320 if (cifs_parse_smb_version(string, vol, is_smb3) != 0)
2321 goto cifs_parse_mount_err;
2325 string = match_strdup(args);
2329 if (cifs_parse_security_flavors(string, vol) != 0)
2330 goto cifs_parse_mount_err;
2333 string = match_strdup(args);
2337 if (cifs_parse_cache_flavor(string, vol) != 0)
2338 goto cifs_parse_mount_err;
2342 * An option we don't recognize. Save it off for later
2343 * if we haven't already found one
2349 /* Free up any allocated string */
2354 if (!sloppy && invalid) {
2355 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
2356 goto cifs_parse_mount_err;
2359 if (vol->rdma && vol->vals->protocol_id < SMB30_PROT_ID) {
2360 cifs_dbg(VFS, "SMB Direct requires Version >=3.0\n");
2361 goto cifs_parse_mount_err;
2365 /* Muliuser mounts require CONFIG_KEYS support */
2366 if (vol->multiuser) {
2367 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
2368 goto cifs_parse_mount_err;
2372 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
2373 goto cifs_parse_mount_err;
2376 /* make sure UNC has a share name */
2377 if (!strchr(vol->UNC + 3, '\\')) {
2378 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
2379 goto cifs_parse_mount_err;
2386 /* No ip= option specified? Try to get it from UNC */
2387 /* Use the address part of the UNC. */
2388 slash = strchr(&vol->UNC[2], '\\');
2389 len = slash - &vol->UNC[2];
2390 if (!cifs_convert_address(dstaddr, &vol->UNC[2], len)) {
2391 pr_err("Unable to determine destination address.\n");
2392 goto cifs_parse_mount_err;
2396 /* set the port that we got earlier */
2397 cifs_set_port(dstaddr, port);
2400 vol->override_uid = override_uid;
2401 else if (override_uid == 1)
2402 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
2405 vol->override_gid = override_gid;
2406 else if (override_gid == 1)
2407 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
2409 if (got_version == false)
2410 pr_warn("No dialect specified on mount. Default has changed to "
2411 "a more secure dialect, SMB2.1 or later (e.g. SMB3), from CIFS "
2412 "(SMB1). To use the less secure SMB1 dialect to access "
2413 "old servers which do not support SMB3 (or SMB2.1) specify vers=1.0"
2416 kfree(mountdata_copy);
2420 pr_warn("Could not allocate temporary buffer\n");
2421 cifs_parse_mount_err:
2423 kfree(mountdata_copy);
2427 /** Returns true if srcaddr isn't specified and rhs isn't
2428 * specified, or if srcaddr is specified and
2429 * matches the IP address of the rhs argument.
2432 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
2434 switch (srcaddr->sa_family) {
2436 return (rhs->sa_family == AF_UNSPEC);
2438 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
2439 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
2440 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
2443 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
2444 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
2445 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
2449 return false; /* don't expect to be here */
2454 * If no port is specified in addr structure, we try to match with 445 port
2455 * and if it fails - with 139 ports. It should be called only if address
2456 * families of server and addr are equal.
2459 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
2461 __be16 port, *sport;
2463 /* SMBDirect manages its own ports, don't match it here */
2467 switch (addr->sa_family) {
2469 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
2470 port = ((struct sockaddr_in *) addr)->sin_port;
2473 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
2474 port = ((struct sockaddr_in6 *) addr)->sin6_port;
2482 port = htons(CIFS_PORT);
2486 port = htons(RFC1001_PORT);
2489 return port == *sport;
2493 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
2494 struct sockaddr *srcaddr)
2496 switch (addr->sa_family) {
2498 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2499 struct sockaddr_in *srv_addr4 =
2500 (struct sockaddr_in *)&server->dstaddr;
2502 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2507 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2508 struct sockaddr_in6 *srv_addr6 =
2509 (struct sockaddr_in6 *)&server->dstaddr;
2511 if (!ipv6_addr_equal(&addr6->sin6_addr,
2512 &srv_addr6->sin6_addr))
2514 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2520 return false; /* don't expect to be here */
2523 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2530 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2533 * The select_sectype function should either return the vol->sectype
2534 * that was specified, or "Unspecified" if that sectype was not
2535 * compatible with the given NEGOTIATE request.
2537 if (server->ops->select_sectype(server, vol->sectype)
2542 * Now check if signing mode is acceptable. No need to check
2543 * global_secflags at this point since if MUST_SIGN is set then
2544 * the server->sign had better be too.
2546 if (vol->sign && !server->sign)
2552 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2554 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2556 if (vol->nosharesock)
2559 /* If multidialect negotiation see if existing sessions match one */
2560 if (strcmp(vol->vals->version_string, SMB3ANY_VERSION_STRING) == 0) {
2561 if (server->vals->protocol_id < SMB30_PROT_ID)
2563 } else if (strcmp(vol->vals->version_string,
2564 SMBDEFAULT_VERSION_STRING) == 0) {
2565 if (server->vals->protocol_id < SMB21_PROT_ID)
2567 } else if ((server->vals != vol->vals) || (server->ops != vol->ops))
2570 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2573 if (!match_address(server, addr,
2574 (struct sockaddr *)&vol->srcaddr))
2577 if (!match_port(server, addr))
2580 if (!match_security(server, vol))
2583 if (server->echo_interval != vol->echo_interval * HZ)
2586 if (server->rdma != vol->rdma)
2592 struct TCP_Server_Info *
2593 cifs_find_tcp_session(struct smb_vol *vol)
2595 struct TCP_Server_Info *server;
2597 spin_lock(&cifs_tcp_ses_lock);
2598 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2599 if (!match_server(server, vol))
2602 ++server->srv_count;
2603 spin_unlock(&cifs_tcp_ses_lock);
2604 cifs_dbg(FYI, "Existing tcp session with server found\n");
2607 spin_unlock(&cifs_tcp_ses_lock);
2612 cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
2614 struct task_struct *task;
2616 spin_lock(&cifs_tcp_ses_lock);
2617 if (--server->srv_count > 0) {
2618 spin_unlock(&cifs_tcp_ses_lock);
2622 put_net(cifs_net_ns(server));
2624 list_del_init(&server->tcp_ses_list);
2625 spin_unlock(&cifs_tcp_ses_lock);
2627 cancel_delayed_work_sync(&server->echo);
2631 * Avoid deadlock here: reconnect work calls
2632 * cifs_put_tcp_session() at its end. Need to be sure
2633 * that reconnect work does nothing with server pointer after
2636 cancel_delayed_work(&server->reconnect);
2638 cancel_delayed_work_sync(&server->reconnect);
2640 spin_lock(&GlobalMid_Lock);
2641 server->tcpStatus = CifsExiting;
2642 spin_unlock(&GlobalMid_Lock);
2644 cifs_crypto_secmech_release(server);
2645 cifs_fscache_release_client_cookie(server);
2647 kfree(server->session_key.response);
2648 server->session_key.response = NULL;
2649 server->session_key.len = 0;
2651 task = xchg(&server->tsk, NULL);
2653 send_sig(SIGKILL, task, 1);
2656 static struct TCP_Server_Info *
2657 cifs_get_tcp_session(struct smb_vol *volume_info)
2659 struct TCP_Server_Info *tcp_ses = NULL;
2662 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2664 /* see if we already have a matching tcp_ses */
2665 tcp_ses = cifs_find_tcp_session(volume_info);
2669 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2675 tcp_ses->ops = volume_info->ops;
2676 tcp_ses->vals = volume_info->vals;
2677 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2678 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2679 if (IS_ERR(tcp_ses->hostname)) {
2680 rc = PTR_ERR(tcp_ses->hostname);
2681 goto out_err_crypto_release;
2684 tcp_ses->noblocksnd = volume_info->noblocksnd;
2685 tcp_ses->noautotune = volume_info->noautotune;
2686 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2687 tcp_ses->rdma = volume_info->rdma;
2688 tcp_ses->in_flight = 0;
2689 tcp_ses->credits = 1;
2690 init_waitqueue_head(&tcp_ses->response_q);
2691 init_waitqueue_head(&tcp_ses->request_q);
2692 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2693 mutex_init(&tcp_ses->srv_mutex);
2694 memcpy(tcp_ses->workstation_RFC1001_name,
2695 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2696 memcpy(tcp_ses->server_RFC1001_name,
2697 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2698 tcp_ses->session_estab = false;
2699 tcp_ses->sequence_number = 0;
2700 tcp_ses->reconnect_instance = 1;
2701 tcp_ses->lstrp = jiffies;
2702 tcp_ses->compress_algorithm = cpu_to_le16(volume_info->compression);
2703 spin_lock_init(&tcp_ses->req_lock);
2704 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2705 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2706 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2707 INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
2708 mutex_init(&tcp_ses->reconnect_mutex);
2709 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2710 sizeof(tcp_ses->srcaddr));
2711 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2712 sizeof(tcp_ses->dstaddr));
2713 generate_random_uuid(tcp_ses->client_guid);
2715 * at this point we are the only ones with the pointer
2716 * to the struct since the kernel thread not created yet
2717 * no need to spinlock this init of tcpStatus or srv_count
2719 tcp_ses->tcpStatus = CifsNew;
2720 ++tcp_ses->srv_count;
2722 if (volume_info->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
2723 volume_info->echo_interval <= SMB_ECHO_INTERVAL_MAX)
2724 tcp_ses->echo_interval = volume_info->echo_interval * HZ;
2726 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
2727 if (tcp_ses->rdma) {
2728 #ifndef CONFIG_CIFS_SMB_DIRECT
2729 cifs_dbg(VFS, "CONFIG_CIFS_SMB_DIRECT is not enabled\n");
2731 goto out_err_crypto_release;
2733 tcp_ses->smbd_conn = smbd_get_connection(
2734 tcp_ses, (struct sockaddr *)&volume_info->dstaddr);
2735 if (tcp_ses->smbd_conn) {
2736 cifs_dbg(VFS, "RDMA transport established\n");
2738 goto smbd_connected;
2741 goto out_err_crypto_release;
2744 rc = ip_connect(tcp_ses);
2746 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2747 goto out_err_crypto_release;
2751 * since we're in a cifs function already, we know that
2752 * this will succeed. No need for try_module_get().
2754 __module_get(THIS_MODULE);
2755 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2757 if (IS_ERR(tcp_ses->tsk)) {
2758 rc = PTR_ERR(tcp_ses->tsk);
2759 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2760 module_put(THIS_MODULE);
2761 goto out_err_crypto_release;
2763 tcp_ses->tcpStatus = CifsNeedNegotiate;
2765 tcp_ses->nr_targets = 1;
2767 /* thread spawned, put it on the list */
2768 spin_lock(&cifs_tcp_ses_lock);
2769 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2770 spin_unlock(&cifs_tcp_ses_lock);
2772 cifs_fscache_get_client_cookie(tcp_ses);
2774 /* queue echo request delayed work */
2775 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
2779 out_err_crypto_release:
2780 cifs_crypto_secmech_release(tcp_ses);
2782 put_net(cifs_net_ns(tcp_ses));
2786 if (!IS_ERR(tcp_ses->hostname))
2787 kfree(tcp_ses->hostname);
2788 if (tcp_ses->ssocket)
2789 sock_release(tcp_ses->ssocket);
2795 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2797 if (vol->sectype != Unspecified &&
2798 vol->sectype != ses->sectype)
2801 switch (ses->sectype) {
2803 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2807 /* NULL username means anonymous session */
2808 if (ses->user_name == NULL) {
2814 /* anything else takes username/password */
2815 if (strncmp(ses->user_name,
2816 vol->username ? vol->username : "",
2817 CIFS_MAX_USERNAME_LEN))
2819 if ((vol->username && strlen(vol->username) != 0) &&
2820 ses->password != NULL &&
2821 strncmp(ses->password,
2822 vol->password ? vol->password : "",
2823 CIFS_MAX_PASSWORD_LEN))
2830 * cifs_setup_ipc - helper to setup the IPC tcon for the session
2832 * A new IPC connection is made and stored in the session
2833 * tcon_ipc. The IPC tcon has the same lifetime as the session.
2836 cifs_setup_ipc(struct cifs_ses *ses, struct smb_vol *volume_info)
2839 struct cifs_tcon *tcon;
2840 struct nls_table *nls_codepage;
2841 char unc[SERVER_NAME_LENGTH + sizeof("//x/IPC$")] = {0};
2845 * If the mount request that resulted in the creation of the
2846 * session requires encryption, force IPC to be encrypted too.
2848 if (volume_info->seal) {
2849 if (ses->server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION)
2853 "IPC: server doesn't support encryption\n");
2858 tcon = tconInfoAlloc();
2862 scnprintf(unc, sizeof(unc), "\\\\%s\\IPC$", ses->server->hostname);
2865 nls_codepage = load_nls_default();
2871 rc = ses->server->ops->tree_connect(xid, ses, unc, tcon, nls_codepage);
2875 cifs_dbg(VFS, "failed to connect to IPC (rc=%d)\n", rc);
2880 cifs_dbg(FYI, "IPC tcon rc = %d ipc tid = %d\n", rc, tcon->tid);
2882 ses->tcon_ipc = tcon;
2884 unload_nls(nls_codepage);
2889 * cifs_free_ipc - helper to release the session IPC tcon
2891 * Needs to be called everytime a session is destroyed
2894 cifs_free_ipc(struct cifs_ses *ses)
2897 struct cifs_tcon *tcon = ses->tcon_ipc;
2902 if (ses->server->ops->tree_disconnect) {
2904 rc = ses->server->ops->tree_disconnect(xid, tcon);
2909 cifs_dbg(FYI, "failed to disconnect IPC tcon (rc=%d)\n", rc);
2912 ses->tcon_ipc = NULL;
2916 static struct cifs_ses *
2917 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2919 struct cifs_ses *ses;
2921 spin_lock(&cifs_tcp_ses_lock);
2922 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2923 if (ses->status == CifsExiting)
2925 if (!match_session(ses, vol))
2928 spin_unlock(&cifs_tcp_ses_lock);
2931 spin_unlock(&cifs_tcp_ses_lock);
2935 void cifs_put_smb_ses(struct cifs_ses *ses)
2937 unsigned int rc, xid;
2938 struct TCP_Server_Info *server = ses->server;
2940 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
2942 spin_lock(&cifs_tcp_ses_lock);
2943 if (ses->status == CifsExiting) {
2944 spin_unlock(&cifs_tcp_ses_lock);
2947 if (--ses->ses_count > 0) {
2948 spin_unlock(&cifs_tcp_ses_lock);
2951 if (ses->status == CifsGood)
2952 ses->status = CifsExiting;
2953 spin_unlock(&cifs_tcp_ses_lock);
2957 if (ses->status == CifsExiting && server->ops->logoff) {
2959 rc = server->ops->logoff(xid, ses);
2961 cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2966 spin_lock(&cifs_tcp_ses_lock);
2967 list_del_init(&ses->smb_ses_list);
2968 spin_unlock(&cifs_tcp_ses_lock);
2971 cifs_put_tcp_session(server, 0);
2976 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2977 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2979 /* Populate username and pw fields from keyring if possible */
2981 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2984 const char *delim, *payload;
2988 struct TCP_Server_Info *server = ses->server;
2989 struct sockaddr_in *sa;
2990 struct sockaddr_in6 *sa6;
2991 const struct user_key_payload *upayload;
2993 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2997 /* try to find an address key first */
2998 switch (server->dstaddr.ss_family) {
3000 sa = (struct sockaddr_in *)&server->dstaddr;
3001 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
3004 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
3005 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
3008 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
3009 server->dstaddr.ss_family);
3014 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
3015 key = request_key(&key_type_logon, desc, "");
3017 if (!ses->domainName) {
3018 cifs_dbg(FYI, "domainName is NULL\n");
3023 /* didn't work, try to find a domain key */
3024 sprintf(desc, "cifs:d:%s", ses->domainName);
3025 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
3026 key = request_key(&key_type_logon, desc, "");
3033 down_read(&key->sem);
3034 upayload = user_key_payload_locked(key);
3035 if (IS_ERR_OR_NULL(upayload)) {
3036 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
3040 /* find first : in payload */
3041 payload = upayload->data;
3042 delim = strnchr(payload, upayload->datalen, ':');
3043 cifs_dbg(FYI, "payload=%s\n", payload);
3045 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
3051 len = delim - payload;
3052 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
3053 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
3059 vol->username = kstrndup(payload, len, GFP_KERNEL);
3060 if (!vol->username) {
3061 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
3066 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
3068 len = key->datalen - (len + 1);
3069 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
3070 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
3072 kfree(vol->username);
3073 vol->username = NULL;
3078 vol->password = kstrndup(delim, len, GFP_KERNEL);
3079 if (!vol->password) {
3080 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
3083 kfree(vol->username);
3084 vol->username = NULL;
3093 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
3096 #else /* ! CONFIG_KEYS */
3098 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
3099 struct cifs_ses *ses __attribute__((unused)))
3103 #endif /* CONFIG_KEYS */
3106 * cifs_get_smb_ses - get a session matching @volume_info data from @server
3108 * This function assumes it is being called from cifs_mount() where we
3109 * already got a server reference (server refcount +1). See
3110 * cifs_get_tcon() for refcount explanations.
3113 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
3117 struct cifs_ses *ses;
3118 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3119 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3123 ses = cifs_find_smb_ses(server, volume_info);
3125 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
3128 mutex_lock(&ses->session_mutex);
3129 rc = cifs_negotiate_protocol(xid, ses);
3131 mutex_unlock(&ses->session_mutex);
3132 /* problem -- put our ses reference */
3133 cifs_put_smb_ses(ses);
3137 if (ses->need_reconnect) {
3138 cifs_dbg(FYI, "Session needs reconnect\n");
3139 rc = cifs_setup_session(xid, ses,
3140 volume_info->local_nls);
3142 mutex_unlock(&ses->session_mutex);
3143 /* problem -- put our reference */
3144 cifs_put_smb_ses(ses);
3149 mutex_unlock(&ses->session_mutex);
3151 /* existing SMB ses has a server reference already */
3152 cifs_put_tcp_session(server, 0);
3157 cifs_dbg(FYI, "Existing smb sess not found\n");
3158 ses = sesInfoAlloc();
3162 /* new SMB session uses our server ref */
3163 ses->server = server;
3164 if (server->dstaddr.ss_family == AF_INET6)
3165 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
3167 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
3169 if (volume_info->username) {
3170 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
3171 if (!ses->user_name)
3175 /* volume_info->password freed at unmount */
3176 if (volume_info->password) {
3177 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
3181 if (volume_info->domainname) {
3182 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
3183 if (!ses->domainName)
3186 if (volume_info->domainauto)
3187 ses->domainAuto = volume_info->domainauto;
3188 ses->cred_uid = volume_info->cred_uid;
3189 ses->linux_uid = volume_info->linux_uid;
3191 ses->sectype = volume_info->sectype;
3192 ses->sign = volume_info->sign;
3194 mutex_lock(&ses->session_mutex);
3195 rc = cifs_negotiate_protocol(xid, ses);
3197 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
3198 mutex_unlock(&ses->session_mutex);
3202 /* success, put it on the list */
3203 spin_lock(&cifs_tcp_ses_lock);
3204 list_add(&ses->smb_ses_list, &server->smb_ses_list);
3205 spin_unlock(&cifs_tcp_ses_lock);
3209 cifs_setup_ipc(ses, volume_info);
3219 static int match_tcon(struct cifs_tcon *tcon, struct smb_vol *volume_info)
3221 if (tcon->tidStatus == CifsExiting)
3223 if (strncmp(tcon->treeName, volume_info->UNC, MAX_TREE_SIZE))
3225 if (tcon->seal != volume_info->seal)
3227 if (tcon->snapshot_time != volume_info->snapshot_time)
3229 if (tcon->handle_timeout != volume_info->handle_timeout)
3234 static struct cifs_tcon *
3235 cifs_find_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
3237 struct list_head *tmp;
3238 struct cifs_tcon *tcon;
3240 spin_lock(&cifs_tcp_ses_lock);
3241 list_for_each(tmp, &ses->tcon_list) {
3242 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
3243 if (!match_tcon(tcon, volume_info))
3246 spin_unlock(&cifs_tcp_ses_lock);
3249 spin_unlock(&cifs_tcp_ses_lock);
3254 cifs_put_tcon(struct cifs_tcon *tcon)
3257 struct cifs_ses *ses;
3260 * IPC tcon share the lifetime of their session and are
3261 * destroyed in the session put function
3263 if (tcon == NULL || tcon->ipc)
3267 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
3268 spin_lock(&cifs_tcp_ses_lock);
3269 if (--tcon->tc_count > 0) {
3270 spin_unlock(&cifs_tcp_ses_lock);
3274 list_del_init(&tcon->tcon_list);
3275 spin_unlock(&cifs_tcp_ses_lock);
3278 if (ses->server->ops->tree_disconnect)
3279 ses->server->ops->tree_disconnect(xid, tcon);
3282 cifs_fscache_release_super_cookie(tcon);
3284 cifs_put_smb_ses(ses);
3288 * cifs_get_tcon - get a tcon matching @volume_info data from @ses
3290 * - tcon refcount is the number of mount points using the tcon.
3291 * - ses refcount is the number of tcon using the session.
3293 * 1. This function assumes it is being called from cifs_mount() where
3294 * we already got a session reference (ses refcount +1).
3296 * 2. Since we're in the context of adding a mount point, the end
3297 * result should be either:
3299 * a) a new tcon already allocated with refcount=1 (1 mount point) and
3300 * its session refcount incremented (1 new tcon). This +1 was
3301 * already done in (1).
3303 * b) an existing tcon with refcount+1 (add a mount point to it) and
3304 * identical ses refcount (no new tcon). Because of (1) we need to
3305 * decrement the ses refcount.
3307 static struct cifs_tcon *
3308 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
3311 struct cifs_tcon *tcon;
3313 tcon = cifs_find_tcon(ses, volume_info);
3316 * tcon has refcount already incremented but we need to
3317 * decrement extra ses reference gotten by caller (case b)
3319 cifs_dbg(FYI, "Found match on UNC path\n");
3320 cifs_put_smb_ses(ses);
3324 if (!ses->server->ops->tree_connect) {
3329 tcon = tconInfoAlloc();
3335 if (volume_info->snapshot_time) {
3336 if (ses->server->vals->protocol_id == 0) {
3338 "Use SMB2 or later for snapshot mount option\n");
3342 tcon->snapshot_time = volume_info->snapshot_time;
3345 if (volume_info->handle_timeout) {
3346 if (ses->server->vals->protocol_id == 0) {
3348 "Use SMB2.1 or later for handle timeout option\n");
3352 tcon->handle_timeout = volume_info->handle_timeout;
3356 if (volume_info->password) {
3357 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
3358 if (!tcon->password) {
3364 if (volume_info->seal) {
3365 if (ses->server->vals->protocol_id == 0) {
3367 "SMB3 or later required for encryption\n");
3370 } else if (tcon->ses->server->capabilities &
3371 SMB2_GLOBAL_CAP_ENCRYPTION)
3374 cifs_dbg(VFS, "Encryption is not supported on share\n");
3380 if (volume_info->linux_ext) {
3381 if (ses->server->posix_ext_supported) {
3382 tcon->posix_extensions = true;
3383 printk_once(KERN_WARNING
3384 "SMB3.11 POSIX Extensions are experimental\n");
3386 cifs_dbg(VFS, "Server does not support mounting with posix SMB3.11 extensions.\n");
3393 * BB Do we need to wrap session_mutex around this TCon call and Unix
3394 * SetFS as we do on SessSetup and reconnect?
3397 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
3398 volume_info->local_nls);
3400 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
3404 tcon->use_persistent = false;
3405 /* check if SMB2 or later, CIFS does not support persistent handles */
3406 if (volume_info->persistent) {
3407 if (ses->server->vals->protocol_id == 0) {
3409 "SMB3 or later required for persistent handles\n");
3412 } else if (ses->server->capabilities &
3413 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3414 tcon->use_persistent = true;
3415 else /* persistent handles requested but not supported */ {
3417 "Persistent handles not supported on share\n");
3421 } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
3422 && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3423 && (volume_info->nopersistent == false)) {
3424 cifs_dbg(FYI, "enabling persistent handles\n");
3425 tcon->use_persistent = true;
3426 } else if (volume_info->resilient) {
3427 if (ses->server->vals->protocol_id == 0) {
3429 "SMB2.1 or later required for resilient handles\n");
3433 tcon->use_resilient = true;
3437 * We can have only one retry value for a connection to a share so for
3438 * resources mounted more than once to the same server share the last
3439 * value passed in for the retry flag is used.
3441 tcon->retry = volume_info->retry;
3442 tcon->nocase = volume_info->nocase;
3443 tcon->nohandlecache = volume_info->nohandlecache;
3444 tcon->local_lease = volume_info->local_lease;
3445 INIT_LIST_HEAD(&tcon->pending_opens);
3447 spin_lock(&cifs_tcp_ses_lock);
3448 list_add(&tcon->tcon_list, &ses->tcon_list);
3449 spin_unlock(&cifs_tcp_ses_lock);
3451 cifs_fscache_get_super_cookie(tcon);
3461 cifs_put_tlink(struct tcon_link *tlink)
3463 if (!tlink || IS_ERR(tlink))
3466 if (!atomic_dec_and_test(&tlink->tl_count) ||
3467 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
3468 tlink->tl_time = jiffies;
3472 if (!IS_ERR(tlink_tcon(tlink)))
3473 cifs_put_tcon(tlink_tcon(tlink));
3479 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3481 struct cifs_sb_info *old = CIFS_SB(sb);
3482 struct cifs_sb_info *new = mnt_data->cifs_sb;
3483 unsigned int oldflags = old->mnt_cifs_flags & CIFS_MOUNT_MASK;
3484 unsigned int newflags = new->mnt_cifs_flags & CIFS_MOUNT_MASK;
3486 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
3489 if (old->mnt_cifs_serverino_autodisabled)
3490 newflags &= ~CIFS_MOUNT_SERVER_INUM;
3492 if (oldflags != newflags)
3496 * We want to share sb only if we don't specify an r/wsize or
3497 * specified r/wsize is greater than or equal to existing one.
3499 if (new->wsize && new->wsize < old->wsize)
3502 if (new->rsize && new->rsize < old->rsize)
3505 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
3508 if (old->mnt_file_mode != new->mnt_file_mode ||
3509 old->mnt_dir_mode != new->mnt_dir_mode)
3512 if (strcmp(old->local_nls->charset, new->local_nls->charset))
3515 if (old->actimeo != new->actimeo)
3522 match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3524 struct cifs_sb_info *old = CIFS_SB(sb);
3525 struct cifs_sb_info *new = mnt_data->cifs_sb;
3526 bool old_set = old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH;
3527 bool new_set = new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH;
3529 if (old_set && new_set && !strcmp(new->prepath, old->prepath))
3531 else if (!old_set && !new_set)
3538 cifs_match_super(struct super_block *sb, void *data)
3540 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
3541 struct smb_vol *volume_info;
3542 struct cifs_sb_info *cifs_sb;
3543 struct TCP_Server_Info *tcp_srv;
3544 struct cifs_ses *ses;
3545 struct cifs_tcon *tcon;
3546 struct tcon_link *tlink;
3549 spin_lock(&cifs_tcp_ses_lock);
3550 cifs_sb = CIFS_SB(sb);
3551 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3552 if (IS_ERR(tlink)) {
3553 spin_unlock(&cifs_tcp_ses_lock);
3556 tcon = tlink_tcon(tlink);
3558 tcp_srv = ses->server;
3560 volume_info = mnt_data->vol;
3562 if (!match_server(tcp_srv, volume_info) ||
3563 !match_session(ses, volume_info) ||
3564 !match_tcon(tcon, volume_info) ||
3565 !match_prepath(sb, mnt_data)) {
3570 rc = compare_mount_options(sb, mnt_data);
3572 spin_unlock(&cifs_tcp_ses_lock);
3573 cifs_put_tlink(tlink);
3577 #ifdef CONFIG_DEBUG_LOCK_ALLOC
3578 static struct lock_class_key cifs_key[2];
3579 static struct lock_class_key cifs_slock_key[2];
3582 cifs_reclassify_socket4(struct socket *sock)
3584 struct sock *sk = sock->sk;
3585 BUG_ON(!sock_allow_reclassification(sk));
3586 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
3587 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
3591 cifs_reclassify_socket6(struct socket *sock)
3593 struct sock *sk = sock->sk;
3594 BUG_ON(!sock_allow_reclassification(sk));
3595 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
3596 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
3600 cifs_reclassify_socket4(struct socket *sock)
3605 cifs_reclassify_socket6(struct socket *sock)
3610 /* See RFC1001 section 14 on representation of Netbios names */
3611 static void rfc1002mangle(char *target, char *source, unsigned int length)
3615 for (i = 0, j = 0; i < (length); i++) {
3616 /* mask a nibble at a time and encode */
3617 target[j] = 'A' + (0x0F & (source[i] >> 4));
3618 target[j+1] = 'A' + (0x0F & source[i]);
3625 bind_socket(struct TCP_Server_Info *server)
3628 if (server->srcaddr.ss_family != AF_UNSPEC) {
3629 /* Bind to the specified local IP address */
3630 struct socket *socket = server->ssocket;
3631 rc = socket->ops->bind(socket,
3632 (struct sockaddr *) &server->srcaddr,
3633 sizeof(server->srcaddr));
3635 struct sockaddr_in *saddr4;
3636 struct sockaddr_in6 *saddr6;
3637 saddr4 = (struct sockaddr_in *)&server->srcaddr;
3638 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
3639 if (saddr6->sin6_family == AF_INET6)
3640 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
3641 &saddr6->sin6_addr, rc);
3643 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
3644 &saddr4->sin_addr.s_addr, rc);
3651 ip_rfc1001_connect(struct TCP_Server_Info *server)
3655 * some servers require RFC1001 sessinit before sending
3656 * negprot - BB check reconnection in case where second
3657 * sessinit is sent but no second negprot
3659 struct rfc1002_session_packet *ses_init_buf;
3660 struct smb_hdr *smb_buf;
3661 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
3664 ses_init_buf->trailer.session_req.called_len = 32;
3666 if (server->server_RFC1001_name[0] != 0)
3667 rfc1002mangle(ses_init_buf->trailer.
3668 session_req.called_name,
3669 server->server_RFC1001_name,
3670 RFC1001_NAME_LEN_WITH_NULL);
3672 rfc1002mangle(ses_init_buf->trailer.
3673 session_req.called_name,
3674 DEFAULT_CIFS_CALLED_NAME,
3675 RFC1001_NAME_LEN_WITH_NULL);
3677 ses_init_buf->trailer.session_req.calling_len = 32;
3680 * calling name ends in null (byte 16) from old smb
3683 if (server->workstation_RFC1001_name[0] != 0)
3684 rfc1002mangle(ses_init_buf->trailer.
3685 session_req.calling_name,
3686 server->workstation_RFC1001_name,
3687 RFC1001_NAME_LEN_WITH_NULL);
3689 rfc1002mangle(ses_init_buf->trailer.
3690 session_req.calling_name,
3692 RFC1001_NAME_LEN_WITH_NULL);
3694 ses_init_buf->trailer.session_req.scope1 = 0;
3695 ses_init_buf->trailer.session_req.scope2 = 0;
3696 smb_buf = (struct smb_hdr *)ses_init_buf;
3698 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3699 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3700 rc = smb_send(server, smb_buf, 0x44);
3701 kfree(ses_init_buf);
3703 * RFC1001 layer in at least one server
3704 * requires very short break before negprot
3705 * presumably because not expecting negprot
3706 * to follow so fast. This is a simple
3707 * solution that works without
3708 * complicating the code and causes no
3709 * significant slowing down on mount
3712 usleep_range(1000, 2000);
3715 * else the negprot may still work without this
3716 * even though malloc failed
3723 generic_ip_connect(struct TCP_Server_Info *server)
3728 struct socket *socket = server->ssocket;
3729 struct sockaddr *saddr;
3731 saddr = (struct sockaddr *) &server->dstaddr;
3733 if (server->dstaddr.ss_family == AF_INET6) {
3734 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3735 slen = sizeof(struct sockaddr_in6);
3738 sport = ((struct sockaddr_in *) saddr)->sin_port;
3739 slen = sizeof(struct sockaddr_in);
3743 if (socket == NULL) {
3744 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3745 IPPROTO_TCP, &socket, 1);
3747 cifs_dbg(VFS, "Error %d creating socket\n", rc);
3748 server->ssocket = NULL;
3752 /* BB other socket options to set KEEPALIVE, NODELAY? */
3753 cifs_dbg(FYI, "Socket created\n");
3754 server->ssocket = socket;
3755 socket->sk->sk_allocation = GFP_NOFS;
3756 if (sfamily == AF_INET6)
3757 cifs_reclassify_socket6(socket);
3759 cifs_reclassify_socket4(socket);
3762 rc = bind_socket(server);
3767 * Eventually check for other socket options to change from
3768 * the default. sock_setsockopt not used because it expects
3771 socket->sk->sk_rcvtimeo = 7 * HZ;
3772 socket->sk->sk_sndtimeo = 5 * HZ;
3774 /* make the bufsizes depend on wsize/rsize and max requests */
3775 if (server->noautotune) {
3776 if (socket->sk->sk_sndbuf < (200 * 1024))
3777 socket->sk->sk_sndbuf = 200 * 1024;
3778 if (socket->sk->sk_rcvbuf < (140 * 1024))
3779 socket->sk->sk_rcvbuf = 140 * 1024;
3782 if (server->tcp_nodelay) {
3784 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3785 (char *)&val, sizeof(val));
3787 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3791 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3792 socket->sk->sk_sndbuf,
3793 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3795 rc = socket->ops->connect(socket, saddr, slen, 0);
3797 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3798 sock_release(socket);
3799 server->ssocket = NULL;
3803 if (sport == htons(RFC1001_PORT))
3804 rc = ip_rfc1001_connect(server);
3810 ip_connect(struct TCP_Server_Info *server)
3813 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3814 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3816 if (server->dstaddr.ss_family == AF_INET6)
3817 sport = &addr6->sin6_port;
3819 sport = &addr->sin_port;
3824 /* try with 445 port at first */
3825 *sport = htons(CIFS_PORT);
3827 rc = generic_ip_connect(server);
3831 /* if it failed, try with 139 port */
3832 *sport = htons(RFC1001_PORT);
3835 return generic_ip_connect(server);
3838 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3839 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3841 /* if we are reconnecting then should we check to see if
3842 * any requested capabilities changed locally e.g. via
3843 * remount but we can not do much about it here
3844 * if they have (even if we could detect it by the following)
3845 * Perhaps we could add a backpointer to array of sb from tcon
3846 * or if we change to make all sb to same share the same
3847 * sb as NFS - then we only have one backpointer to sb.
3848 * What if we wanted to mount the server share twice once with
3849 * and once without posixacls or posix paths? */
3850 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3852 if (vol_info && vol_info->no_linux_ext) {
3853 tcon->fsUnixInfo.Capability = 0;
3854 tcon->unix_ext = 0; /* Unix Extensions disabled */
3855 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3857 } else if (vol_info)
3858 tcon->unix_ext = 1; /* Unix Extensions supported */
3860 if (tcon->unix_ext == 0) {
3861 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3865 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3866 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3867 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3868 /* check for reconnect case in which we do not
3869 want to change the mount behavior if we can avoid it */
3870 if (vol_info == NULL) {
3871 /* turn off POSIX ACL and PATHNAMES if not set
3872 originally at mount time */
3873 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3874 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3875 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3876 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3877 cifs_dbg(VFS, "POSIXPATH support change\n");
3878 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3879 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3880 cifs_dbg(VFS, "possible reconnect error\n");
3881 cifs_dbg(VFS, "server disabled POSIX path support\n");
3885 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3886 cifs_dbg(VFS, "per-share encryption not supported yet\n");
3888 cap &= CIFS_UNIX_CAP_MASK;
3889 if (vol_info && vol_info->no_psx_acl)
3890 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3891 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3892 cifs_dbg(FYI, "negotiated posix acl support\n");
3894 cifs_sb->mnt_cifs_flags |=
3895 CIFS_MOUNT_POSIXACL;
3898 if (vol_info && vol_info->posix_paths == 0)
3899 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3900 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3901 cifs_dbg(FYI, "negotiate posix pathnames\n");
3903 cifs_sb->mnt_cifs_flags |=
3904 CIFS_MOUNT_POSIX_PATHS;
3907 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3908 #ifdef CONFIG_CIFS_DEBUG2
3909 if (cap & CIFS_UNIX_FCNTL_CAP)
3910 cifs_dbg(FYI, "FCNTL cap\n");
3911 if (cap & CIFS_UNIX_EXTATTR_CAP)
3912 cifs_dbg(FYI, "EXTATTR cap\n");
3913 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3914 cifs_dbg(FYI, "POSIX path cap\n");
3915 if (cap & CIFS_UNIX_XATTR_CAP)
3916 cifs_dbg(FYI, "XATTR cap\n");
3917 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3918 cifs_dbg(FYI, "POSIX ACL cap\n");
3919 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3920 cifs_dbg(FYI, "very large read cap\n");
3921 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3922 cifs_dbg(FYI, "very large write cap\n");
3923 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3924 cifs_dbg(FYI, "transport encryption cap\n");
3925 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3926 cifs_dbg(FYI, "mandatory transport encryption cap\n");
3927 #endif /* CIFS_DEBUG2 */
3928 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3929 if (vol_info == NULL) {
3930 cifs_dbg(FYI, "resetting capabilities failed\n");
3932 cifs_dbg(VFS, "Negotiating Unix capabilities with the server failed. Consider mounting with the Unix Extensions disabled if problems are found by specifying the nounix mount option.\n");
3938 int cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3939 struct cifs_sb_info *cifs_sb)
3941 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3943 spin_lock_init(&cifs_sb->tlink_tree_lock);
3944 cifs_sb->tlink_tree = RB_ROOT;
3946 cifs_sb->bsize = pvolume_info->bsize;
3948 * Temporarily set r/wsize for matching superblock. If we end up using
3949 * new sb then client will later negotiate it downward if needed.
3951 cifs_sb->rsize = pvolume_info->rsize;
3952 cifs_sb->wsize = pvolume_info->wsize;
3954 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3955 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3956 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3957 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3958 cifs_dbg(FYI, "file mode: 0x%hx dir mode: 0x%hx\n",
3959 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3961 cifs_sb->actimeo = pvolume_info->actimeo;
3962 cifs_sb->local_nls = pvolume_info->local_nls;
3964 if (pvolume_info->nodfs)
3965 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_DFS;
3966 if (pvolume_info->noperm)
3967 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3968 if (pvolume_info->setuids)
3969 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3970 if (pvolume_info->setuidfromacl)
3971 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
3972 if (pvolume_info->server_ino)
3973 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3974 if (pvolume_info->remap)
3975 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3976 if (pvolume_info->sfu_remap)
3977 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3978 if (pvolume_info->no_xattr)
3979 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3980 if (pvolume_info->sfu_emul)
3981 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3982 if (pvolume_info->nobrl)
3983 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3984 if (pvolume_info->nohandlecache)
3985 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE;
3986 if (pvolume_info->nostrictsync)
3987 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3988 if (pvolume_info->mand_lock)
3989 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3990 if (pvolume_info->rwpidforward)
3991 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3992 if (pvolume_info->mode_ace)
3993 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MODE_FROM_SID;
3994 if (pvolume_info->cifs_acl)
3995 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3996 if (pvolume_info->backupuid_specified) {
3997 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3998 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
4000 if (pvolume_info->backupgid_specified) {
4001 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
4002 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
4004 if (pvolume_info->override_uid)
4005 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
4006 if (pvolume_info->override_gid)
4007 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
4008 if (pvolume_info->dynperm)
4009 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
4010 if (pvolume_info->fsc)
4011 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
4012 if (pvolume_info->multiuser)
4013 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
4014 CIFS_MOUNT_NO_PERM);
4015 if (pvolume_info->strict_io)
4016 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
4017 if (pvolume_info->direct_io) {
4018 cifs_dbg(FYI, "mounting share using direct i/o\n");
4019 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
4021 if (pvolume_info->mfsymlinks) {
4022 if (pvolume_info->sfu_emul) {
4024 * Our SFU ("Services for Unix" emulation does not allow
4025 * creating symlinks but does allow reading existing SFU
4026 * symlinks (it does allow both creating and reading SFU
4027 * style mknod and FIFOs though). When "mfsymlinks" and
4028 * "sfu" are both enabled at the same time, it allows
4029 * reading both types of symlinks, but will only create
4030 * them with mfsymlinks format. This allows better
4031 * Apple compatibility (probably better for Samba too)
4032 * while still recognizing old Windows style symlinks.
4034 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
4036 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
4039 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
4040 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
4042 if (pvolume_info->prepath) {
4043 cifs_sb->prepath = kstrdup(pvolume_info->prepath, GFP_KERNEL);
4044 if (cifs_sb->prepath == NULL)
4052 cifs_cleanup_volume_info_contents(struct smb_vol *volume_info)
4054 kfree(volume_info->username);
4055 kzfree(volume_info->password);
4056 kfree(volume_info->UNC);
4057 kfree(volume_info->domainname);
4058 kfree(volume_info->iocharset);
4059 kfree(volume_info->prepath);
4063 cifs_cleanup_volume_info(struct smb_vol *volume_info)
4067 cifs_cleanup_volume_info_contents(volume_info);
4071 /* Release all succeed connections */
4072 static inline void mount_put_conns(struct cifs_sb_info *cifs_sb,
4074 struct TCP_Server_Info *server,
4075 struct cifs_ses *ses, struct cifs_tcon *tcon)
4080 cifs_put_tcon(tcon);
4082 cifs_put_smb_ses(ses);
4084 cifs_put_tcp_session(server, 0);
4085 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
4089 /* Get connections for tcp, ses and tcon */
4090 static int mount_get_conns(struct smb_vol *vol, struct cifs_sb_info *cifs_sb,
4092 struct TCP_Server_Info **nserver,
4093 struct cifs_ses **nses, struct cifs_tcon **ntcon)
4096 struct TCP_Server_Info *server;
4097 struct cifs_ses *ses;
4098 struct cifs_tcon *tcon;
4106 /* get a reference to a tcp session */
4107 server = cifs_get_tcp_session(vol);
4108 if (IS_ERR(server)) {
4109 rc = PTR_ERR(server);
4115 if ((vol->max_credits < 20) || (vol->max_credits > 60000))
4116 server->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
4118 server->max_credits = vol->max_credits;
4120 /* get a reference to a SMB session */
4121 ses = cifs_get_smb_ses(server, vol);
4129 if ((vol->persistent == true) && (!(ses->server->capabilities &
4130 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES))) {
4131 cifs_dbg(VFS, "persistent handles not supported by server\n");
4135 /* search for existing tcon to this server share */
4136 tcon = cifs_get_tcon(ses, vol);
4144 /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
4145 if (tcon->posix_extensions)
4146 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
4148 /* tell server which Unix caps we support */
4149 if (cap_unix(tcon->ses)) {
4151 * reset of caps checks mount to see if unix extensions disabled
4152 * for just this mount.
4154 reset_cifs_unix_caps(*xid, tcon, cifs_sb, vol);
4155 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
4156 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
4157 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP))
4160 tcon->unix_ext = 0; /* server does not support them */
4162 /* do not care if a following call succeed - informational */
4163 if (!tcon->pipe && server->ops->qfs_tcon)
4164 server->ops->qfs_tcon(*xid, tcon);
4166 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, vol);
4167 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, vol);
4172 static int mount_setup_tlink(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses,
4173 struct cifs_tcon *tcon)
4175 struct tcon_link *tlink;
4177 /* hang the tcon off of the superblock */
4178 tlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4182 tlink->tl_uid = ses->linux_uid;
4183 tlink->tl_tcon = tcon;
4184 tlink->tl_time = jiffies;
4185 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
4186 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4188 cifs_sb->master_tlink = tlink;
4189 spin_lock(&cifs_sb->tlink_tree_lock);
4190 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4191 spin_unlock(&cifs_sb->tlink_tree_lock);
4193 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4198 #ifdef CONFIG_CIFS_DFS_UPCALL
4200 * cifs_build_path_to_root returns full path to root when we do not have an
4201 * exiting connection (tcon)
4204 build_unc_path_to_root(const struct smb_vol *vol,
4205 const struct cifs_sb_info *cifs_sb, bool useppath)
4207 char *full_path, *pos;
4208 unsigned int pplen = useppath && vol->prepath ?
4209 strlen(vol->prepath) + 1 : 0;
4210 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
4212 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
4213 if (full_path == NULL)
4214 return ERR_PTR(-ENOMEM);
4216 strncpy(full_path, vol->UNC, unc_len);
4217 pos = full_path + unc_len;
4220 *pos = CIFS_DIR_SEP(cifs_sb);
4221 strncpy(pos + 1, vol->prepath, pplen);
4225 *pos = '\0'; /* add trailing null */
4226 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
4227 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
4232 * expand_dfs_referral - Perform a dfs referral query and update the cifs_sb
4235 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
4236 * to a string containing updated options for the submount. Otherwise it
4237 * will be left untouched.
4239 * Returns the rc from get_dfs_path to the caller, which can be used to
4240 * determine whether there were referrals.
4243 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
4244 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
4248 struct dfs_info3_param referral = {0};
4249 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
4251 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
4254 full_path = build_unc_path_to_root(volume_info, cifs_sb, true);
4255 if (IS_ERR(full_path))
4256 return PTR_ERR(full_path);
4258 /* For DFS paths, skip the first '\' of the UNC */
4259 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
4261 rc = dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb),
4262 ref_path, &referral, NULL);
4264 char *fake_devname = NULL;
4266 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
4267 full_path + 1, &referral,
4269 free_dfs_info_param(&referral);
4271 if (IS_ERR(mdata)) {
4272 rc = PTR_ERR(mdata);
4275 cifs_cleanup_volume_info_contents(volume_info);
4276 rc = cifs_setup_volume_info(volume_info, mdata,
4277 fake_devname, false);
4279 kfree(fake_devname);
4280 kfree(cifs_sb->mountdata);
4281 cifs_sb->mountdata = mdata;
4287 static inline int get_next_dfs_tgt(const char *path,
4288 struct dfs_cache_tgt_list *tgt_list,
4289 struct dfs_cache_tgt_iterator **tgt_it)
4292 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
4294 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
4295 return !*tgt_it ? -EHOSTDOWN : 0;
4298 static int update_vol_info(const struct dfs_cache_tgt_iterator *tgt_it,
4299 struct smb_vol *fake_vol, struct smb_vol *vol)
4301 const char *tgt = dfs_cache_get_tgt_name(tgt_it);
4302 int len = strlen(tgt) + 2;
4305 new_unc = kmalloc(len, GFP_KERNEL);
4308 scnprintf(new_unc, len, "\\%s", tgt);
4313 if (fake_vol->prepath) {
4314 kfree(vol->prepath);
4315 vol->prepath = fake_vol->prepath;
4316 fake_vol->prepath = NULL;
4318 memcpy(&vol->dstaddr, &fake_vol->dstaddr, sizeof(vol->dstaddr));
4323 static int setup_dfs_tgt_conn(const char *path,
4324 const struct dfs_cache_tgt_iterator *tgt_it,
4325 struct cifs_sb_info *cifs_sb,
4326 struct smb_vol *vol,
4328 struct TCP_Server_Info **server,
4329 struct cifs_ses **ses,
4330 struct cifs_tcon **tcon)
4333 struct dfs_info3_param ref = {0};
4334 char *mdata = NULL, *fake_devname = NULL;
4335 struct smb_vol fake_vol = {0};
4337 cifs_dbg(FYI, "%s: dfs path: %s\n", __func__, path);
4339 rc = dfs_cache_get_tgt_referral(path, tgt_it, &ref);
4343 mdata = cifs_compose_mount_options(cifs_sb->mountdata, path, &ref,
4345 free_dfs_info_param(&ref);
4347 if (IS_ERR(mdata)) {
4348 rc = PTR_ERR(mdata);
4351 cifs_dbg(FYI, "%s: fake_devname: %s\n", __func__, fake_devname);
4352 rc = cifs_setup_volume_info(&fake_vol, mdata, fake_devname,
4356 kfree(fake_devname);
4360 * We use a 'fake_vol' here because we need pass it down to the
4361 * mount_{get,put} functions to test connection against new DFS
4364 mount_put_conns(cifs_sb, *xid, *server, *ses, *tcon);
4365 rc = mount_get_conns(&fake_vol, cifs_sb, xid, server, ses,
4369 * We were able to connect to new target server.
4370 * Update current volume info with new target server.
4372 rc = update_vol_info(tgt_it, &fake_vol, vol);
4375 cifs_cleanup_volume_info_contents(&fake_vol);
4379 static int mount_do_dfs_failover(const char *path,
4380 struct cifs_sb_info *cifs_sb,
4381 struct smb_vol *vol,
4382 struct cifs_ses *root_ses,
4384 struct TCP_Server_Info **server,
4385 struct cifs_ses **ses,
4386 struct cifs_tcon **tcon)
4389 struct dfs_cache_tgt_list tgt_list;
4390 struct dfs_cache_tgt_iterator *tgt_it = NULL;
4392 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
4395 rc = dfs_cache_noreq_find(path, NULL, &tgt_list);
4400 /* Get next DFS target server - if any */
4401 rc = get_next_dfs_tgt(path, &tgt_list, &tgt_it);
4404 /* Connect to next DFS target */
4405 rc = setup_dfs_tgt_conn(path, tgt_it, cifs_sb, vol, xid, server,
4407 if (!rc || rc == -EACCES || rc == -EOPNOTSUPP)
4412 * Update DFS target hint in DFS referral cache with the target
4413 * server we successfully reconnected to.
4415 rc = dfs_cache_update_tgthint(*xid, root_ses ? root_ses : *ses,
4417 cifs_remap(cifs_sb), path,
4420 dfs_cache_free_tgts(&tgt_list);
4426 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
4427 const char *devname, bool is_smb3)
4431 if (cifs_parse_mount_options(mount_data, devname, volume_info, is_smb3))
4434 if (volume_info->nullauth) {
4435 cifs_dbg(FYI, "Anonymous login\n");
4436 kfree(volume_info->username);
4437 volume_info->username = NULL;
4438 } else if (volume_info->username) {
4439 /* BB fixme parse for domain name here */
4440 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
4442 cifs_dbg(VFS, "No username specified\n");
4443 /* In userspace mount helper we can get user name from alternate
4444 locations such as env variables and files on disk */
4448 /* this is needed for ASCII cp to Unicode converts */
4449 if (volume_info->iocharset == NULL) {
4450 /* load_nls_default cannot return null */
4451 volume_info->local_nls = load_nls_default();
4453 volume_info->local_nls = load_nls(volume_info->iocharset);
4454 if (volume_info->local_nls == NULL) {
4455 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
4456 volume_info->iocharset);
4465 cifs_get_volume_info(char *mount_data, const char *devname, bool is_smb3)
4468 struct smb_vol *volume_info;
4470 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
4472 return ERR_PTR(-ENOMEM);
4474 rc = cifs_setup_volume_info(volume_info, mount_data, devname, is_smb3);
4476 cifs_cleanup_volume_info(volume_info);
4477 volume_info = ERR_PTR(rc);
4484 cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
4486 struct cifs_tcon *tcon,
4487 struct cifs_sb_info *cifs_sb,
4494 int skip = added_treename ? 1 : 0;
4496 sep = CIFS_DIR_SEP(cifs_sb);
4499 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
4501 /* skip separators */
4506 /* next separator */
4507 while (*s && *s != sep)
4510 * if the treename is added, we then have to skip the first
4511 * part within the separators
4518 * temporarily null-terminate the path at the end of
4519 * the current component
4523 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
4531 * Check if path is remote (e.g. a DFS share). Return -EREMOTE if it is,
4534 static int is_path_remote(struct cifs_sb_info *cifs_sb, struct smb_vol *vol,
4535 const unsigned int xid,
4536 struct TCP_Server_Info *server,
4537 struct cifs_tcon *tcon)
4542 if (!server->ops->is_path_accessible)
4546 * cifs_build_path_to_root works only when we have a valid tcon
4548 full_path = cifs_build_path_to_root(vol, cifs_sb, tcon,
4549 tcon->Flags & SMB_SHARE_IS_IN_DFS);
4550 if (full_path == NULL)
4553 cifs_dbg(FYI, "%s: full_path: %s\n", __func__, full_path);
4555 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
4557 if (rc != 0 && rc != -EREMOTE) {
4562 if (rc != -EREMOTE) {
4563 rc = cifs_are_all_path_components_accessible(server, xid, tcon,
4564 cifs_sb, full_path, tcon->Flags & SMB_SHARE_IS_IN_DFS);
4566 cifs_dbg(VFS, "cannot query dirs between root and final path, "
4567 "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
4568 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
4577 #ifdef CONFIG_CIFS_DFS_UPCALL
4578 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *vol)
4582 struct cifs_ses *ses;
4583 struct cifs_tcon *root_tcon = NULL;
4584 struct cifs_tcon *tcon = NULL;
4585 struct TCP_Server_Info *server;
4586 char *root_path = NULL, *full_path = NULL;
4587 char *old_mountdata, *origin_mountdata = NULL;
4590 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4592 /* If not a standalone DFS root, then check if path is remote */
4593 rc = dfs_cache_find(xid, ses, cifs_sb->local_nls,
4594 cifs_remap(cifs_sb), vol->UNC + 1, NULL,
4597 rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
4605 * If first DFS target server went offline and we failed to connect it,
4606 * server and ses pointers are NULL at this point, though we still have
4607 * chance to get a cached DFS referral in expand_dfs_referral() and
4608 * retry next target available in it.
4610 * If a NULL ses ptr is passed to dfs_cache_find(), a lookup will be
4611 * performed against DFS path and *no* requests will be sent to server
4612 * for any new DFS referrals. Hence it's safe to skip checking whether
4613 * server or ses ptr is NULL.
4615 if (rc == -EACCES || rc == -EOPNOTSUPP)
4618 root_path = build_unc_path_to_root(vol, cifs_sb, false);
4619 if (IS_ERR(root_path)) {
4620 rc = PTR_ERR(root_path);
4625 full_path = build_unc_path_to_root(vol, cifs_sb, true);
4626 if (IS_ERR(full_path)) {
4627 rc = PTR_ERR(full_path);
4632 * Perform an unconditional check for whether there are DFS
4633 * referrals for this path without prefix, to provide support
4634 * for DFS referrals from w2k8 servers which don't seem to respond
4635 * with PATH_NOT_COVERED to requests that include the prefix.
4636 * Chase the referral if found, otherwise continue normally.
4638 old_mountdata = cifs_sb->mountdata;
4639 (void)expand_dfs_referral(xid, ses, vol, cifs_sb, false);
4641 if (cifs_sb->mountdata == NULL) {
4646 /* Save DFS root volume information for DFS refresh worker */
4647 origin_mountdata = kstrndup(cifs_sb->mountdata,
4648 strlen(cifs_sb->mountdata), GFP_KERNEL);
4649 if (!origin_mountdata) {
4654 if (cifs_sb->mountdata != old_mountdata) {
4655 /* If we were redirected, reconnect to new target server */
4656 mount_put_conns(cifs_sb, xid, server, ses, tcon);
4657 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4660 if (rc == -EACCES || rc == -EOPNOTSUPP)
4662 /* Perform DFS failover to any other DFS targets */
4663 rc = mount_do_dfs_failover(root_path + 1, cifs_sb, vol, NULL,
4664 &xid, &server, &ses, &tcon);
4670 root_path = build_unc_path_to_root(vol, cifs_sb, false);
4671 if (IS_ERR(root_path)) {
4672 rc = PTR_ERR(root_path);
4676 /* Cache out resolved root server */
4677 (void)dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb),
4678 root_path + 1, NULL, NULL);
4680 * Save root tcon for additional DFS requests to update or create a new
4681 * DFS cache entry, or even perform DFS failover.
4683 spin_lock(&cifs_tcp_ses_lock);
4685 tcon->dfs_path = root_path;
4687 tcon->remap = cifs_remap(cifs_sb);
4688 spin_unlock(&cifs_tcp_ses_lock);
4692 for (count = 1; ;) {
4694 rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
4695 if (!rc || rc != -EREMOTE)
4699 * BB: when we implement proper loop detection,
4700 * we will remove this check. But now we need it
4701 * to prevent an indefinite loop if 'DFS tree' is
4702 * misconfigured (i.e. has loops).
4704 if (count++ > MAX_NESTED_LINKS) {
4710 full_path = build_unc_path_to_root(vol, cifs_sb, true);
4711 if (IS_ERR(full_path)) {
4712 rc = PTR_ERR(full_path);
4717 old_mountdata = cifs_sb->mountdata;
4718 rc = expand_dfs_referral(xid, root_tcon->ses, vol, cifs_sb,
4723 if (cifs_sb->mountdata != old_mountdata) {
4724 mount_put_conns(cifs_sb, xid, server, ses, tcon);
4725 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses,
4729 if (rc == -EACCES || rc == -EOPNOTSUPP)
4731 /* Perform DFS failover to any other DFS targets */
4732 rc = mount_do_dfs_failover(full_path + 1, cifs_sb, vol,
4733 root_tcon->ses, &xid,
4734 &server, &ses, &tcon);
4735 if (rc == -EACCES || rc == -EOPNOTSUPP || !server ||
4740 cifs_put_tcon(root_tcon);
4745 spin_lock(&cifs_tcp_ses_lock);
4746 if (!tcon->dfs_path) {
4747 /* Save full path in new tcon to do failover when reconnecting tcons */
4748 tcon->dfs_path = full_path;
4750 tcon->remap = cifs_remap(cifs_sb);
4752 cifs_sb->origin_fullpath = kstrndup(tcon->dfs_path,
4753 strlen(tcon->dfs_path),
4755 if (!cifs_sb->origin_fullpath) {
4756 spin_unlock(&cifs_tcp_ses_lock);
4760 spin_unlock(&cifs_tcp_ses_lock);
4762 rc = dfs_cache_add_vol(origin_mountdata, vol, cifs_sb->origin_fullpath);
4764 kfree(cifs_sb->origin_fullpath);
4768 * After reconnecting to a different server, unique ids won't
4769 * match anymore, so we disable serverino. This prevents
4770 * dentry revalidation to think the dentry are stale (ESTALE).
4772 cifs_autodisable_serverino(cifs_sb);
4775 return mount_setup_tlink(cifs_sb, ses, tcon);
4780 kfree(origin_mountdata);
4781 mount_put_conns(cifs_sb, xid, server, ses, tcon);
4785 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *vol)
4789 struct cifs_ses *ses;
4790 struct cifs_tcon *tcon;
4791 struct TCP_Server_Info *server;
4793 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4798 rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
4807 return mount_setup_tlink(cifs_sb, ses, tcon);
4810 mount_put_conns(cifs_sb, xid, server, ses, tcon);
4816 * Issue a TREE_CONNECT request.
4819 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
4820 const char *tree, struct cifs_tcon *tcon,
4821 const struct nls_table *nls_codepage)
4823 struct smb_hdr *smb_buffer;
4824 struct smb_hdr *smb_buffer_response;
4827 unsigned char *bcc_ptr;
4830 __u16 bytes_left, count;
4835 smb_buffer = cifs_buf_get();
4836 if (smb_buffer == NULL)
4839 smb_buffer_response = smb_buffer;
4841 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
4842 NULL /*no tid */ , 4 /*wct */ );
4844 smb_buffer->Mid = get_next_mid(ses->server);
4845 smb_buffer->Uid = ses->Suid;
4846 pSMB = (TCONX_REQ *) smb_buffer;
4847 pSMBr = (TCONX_RSP *) smb_buffer_response;
4849 pSMB->AndXCommand = 0xFF;
4850 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
4851 bcc_ptr = &pSMB->Password[0];
4852 if (tcon->pipe || (ses->server->sec_mode & SECMODE_USER)) {
4853 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
4854 *bcc_ptr = 0; /* password is null byte */
4855 bcc_ptr++; /* skip password */
4856 /* already aligned so no need to do it below */
4858 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
4859 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
4860 specified as required (when that support is added to
4861 the vfs in the future) as only NTLM or the much
4862 weaker LANMAN (which we do not send by default) is accepted
4863 by Samba (not sure whether other servers allow
4864 NTLMv2 password here) */
4865 #ifdef CONFIG_CIFS_WEAK_PW_HASH
4866 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
4867 (ses->sectype == LANMAN))
4868 calc_lanman_hash(tcon->password, ses->server->cryptkey,
4869 ses->server->sec_mode &
4870 SECMODE_PW_ENCRYPT ? true : false,
4873 #endif /* CIFS_WEAK_PW_HASH */
4874 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
4875 bcc_ptr, nls_codepage);
4877 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
4879 cifs_buf_release(smb_buffer);
4883 bcc_ptr += CIFS_AUTH_RESP_SIZE;
4884 if (ses->capabilities & CAP_UNICODE) {
4885 /* must align unicode strings */
4886 *bcc_ptr = 0; /* null byte password */
4891 if (ses->server->sign)
4892 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
4894 if (ses->capabilities & CAP_STATUS32) {
4895 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
4897 if (ses->capabilities & CAP_DFS) {
4898 smb_buffer->Flags2 |= SMBFLG2_DFS;
4900 if (ses->capabilities & CAP_UNICODE) {
4901 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
4903 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
4904 6 /* max utf8 char length in bytes */ *
4905 (/* server len*/ + 256 /* share len */), nls_codepage);
4906 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
4907 bcc_ptr += 2; /* skip trailing null */
4908 } else { /* ASCII */
4909 strcpy(bcc_ptr, tree);
4910 bcc_ptr += strlen(tree) + 1;
4912 strcpy(bcc_ptr, "?????");
4913 bcc_ptr += strlen("?????");
4915 count = bcc_ptr - &pSMB->Password[0];
4916 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
4917 pSMB->hdr.smb_buf_length) + count);
4918 pSMB->ByteCount = cpu_to_le16(count);
4920 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
4923 /* above now done in SendReceive */
4927 tcon->tidStatus = CifsGood;
4928 tcon->need_reconnect = false;
4929 tcon->tid = smb_buffer_response->Tid;
4930 bcc_ptr = pByteArea(smb_buffer_response);
4931 bytes_left = get_bcc(smb_buffer_response);
4932 length = strnlen(bcc_ptr, bytes_left - 2);
4933 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
4939 /* skip service field (NB: this field is always ASCII) */
4941 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
4942 (bcc_ptr[2] == 'C')) {
4943 cifs_dbg(FYI, "IPC connection\n");
4947 } else if (length == 2) {
4948 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
4949 /* the most common case */
4950 cifs_dbg(FYI, "disk share connection\n");
4953 bcc_ptr += length + 1;
4954 bytes_left -= (length + 1);
4955 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
4957 /* mostly informational -- no need to fail on error here */
4958 kfree(tcon->nativeFileSystem);
4959 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
4960 bytes_left, is_unicode,
4963 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
4965 if ((smb_buffer_response->WordCount == 3) ||
4966 (smb_buffer_response->WordCount == 7))
4967 /* field is in same location */
4968 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
4971 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
4974 cifs_buf_release(smb_buffer);
4978 static void delayed_free(struct rcu_head *p)
4980 struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
4981 unload_nls(sbi->local_nls);
4986 cifs_umount(struct cifs_sb_info *cifs_sb)
4988 struct rb_root *root = &cifs_sb->tlink_tree;
4989 struct rb_node *node;
4990 struct tcon_link *tlink;
4992 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
4994 spin_lock(&cifs_sb->tlink_tree_lock);
4995 while ((node = rb_first(root))) {
4996 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4997 cifs_get_tlink(tlink);
4998 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4999 rb_erase(node, root);
5001 spin_unlock(&cifs_sb->tlink_tree_lock);
5002 cifs_put_tlink(tlink);
5003 spin_lock(&cifs_sb->tlink_tree_lock);
5005 spin_unlock(&cifs_sb->tlink_tree_lock);
5007 kfree(cifs_sb->mountdata);
5008 kfree(cifs_sb->prepath);
5009 #ifdef CONFIG_CIFS_DFS_UPCALL
5010 dfs_cache_del_vol(cifs_sb->origin_fullpath);
5011 kfree(cifs_sb->origin_fullpath);
5013 call_rcu(&cifs_sb->rcu, delayed_free);
5017 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
5020 struct TCP_Server_Info *server = ses->server;
5022 if (!server->ops->need_neg || !server->ops->negotiate)
5025 /* only send once per connect */
5026 if (!server->ops->need_neg(server))
5029 rc = server->ops->negotiate(xid, ses);
5031 spin_lock(&GlobalMid_Lock);
5032 if (server->tcpStatus == CifsNeedNegotiate)
5033 server->tcpStatus = CifsGood;
5036 spin_unlock(&GlobalMid_Lock);
5043 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
5044 struct nls_table *nls_info)
5047 struct TCP_Server_Info *server = ses->server;
5049 ses->capabilities = server->capabilities;
5050 if (linuxExtEnabled == 0)
5051 ses->capabilities &= (~server->vals->cap_unix);
5053 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
5054 server->sec_mode, server->capabilities, server->timeAdj);
5056 if (ses->auth_key.response) {
5057 cifs_dbg(FYI, "Free previous auth_key.response = %p\n",
5058 ses->auth_key.response);
5059 kfree(ses->auth_key.response);
5060 ses->auth_key.response = NULL;
5061 ses->auth_key.len = 0;
5064 if (server->ops->sess_setup)
5065 rc = server->ops->sess_setup(xid, ses, nls_info);
5068 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
5074 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
5076 vol->sectype = ses->sectype;
5078 /* krb5 is special, since we don't need username or pw */
5079 if (vol->sectype == Kerberos)
5082 return cifs_set_cifscreds(vol, ses);
5085 static struct cifs_tcon *
5086 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
5089 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
5090 struct cifs_ses *ses;
5091 struct cifs_tcon *tcon = NULL;
5092 struct smb_vol *vol_info;
5094 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
5095 if (vol_info == NULL)
5096 return ERR_PTR(-ENOMEM);
5098 vol_info->local_nls = cifs_sb->local_nls;
5099 vol_info->linux_uid = fsuid;
5100 vol_info->cred_uid = fsuid;
5101 vol_info->UNC = master_tcon->treeName;
5102 vol_info->retry = master_tcon->retry;
5103 vol_info->nocase = master_tcon->nocase;
5104 vol_info->nohandlecache = master_tcon->nohandlecache;
5105 vol_info->local_lease = master_tcon->local_lease;
5106 vol_info->no_linux_ext = !master_tcon->unix_ext;
5107 vol_info->sectype = master_tcon->ses->sectype;
5108 vol_info->sign = master_tcon->ses->sign;
5110 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
5116 /* get a reference for the same TCP session */
5117 spin_lock(&cifs_tcp_ses_lock);
5118 ++master_tcon->ses->server->srv_count;
5119 spin_unlock(&cifs_tcp_ses_lock);
5121 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
5123 tcon = (struct cifs_tcon *)ses;
5124 cifs_put_tcp_session(master_tcon->ses->server, 0);
5128 tcon = cifs_get_tcon(ses, vol_info);
5130 cifs_put_smb_ses(ses);
5134 /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
5135 if (tcon->posix_extensions)
5136 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
5139 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
5142 kfree(vol_info->username);
5143 kzfree(vol_info->password);
5150 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
5152 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
5155 /* find and return a tlink with given uid */
5156 static struct tcon_link *
5157 tlink_rb_search(struct rb_root *root, kuid_t uid)
5159 struct rb_node *node = root->rb_node;
5160 struct tcon_link *tlink;
5163 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
5165 if (uid_gt(tlink->tl_uid, uid))
5166 node = node->rb_left;
5167 else if (uid_lt(tlink->tl_uid, uid))
5168 node = node->rb_right;
5175 /* insert a tcon_link into the tree */
5177 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
5179 struct rb_node **new = &(root->rb_node), *parent = NULL;
5180 struct tcon_link *tlink;
5183 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
5186 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
5187 new = &((*new)->rb_left);
5189 new = &((*new)->rb_right);
5192 rb_link_node(&new_tlink->tl_rbnode, parent, new);
5193 rb_insert_color(&new_tlink->tl_rbnode, root);
5197 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
5200 * If the superblock doesn't refer to a multiuser mount, then just return
5201 * the master tcon for the mount.
5203 * First, search the rbtree for an existing tcon for this fsuid. If one
5204 * exists, then check to see if it's pending construction. If it is then wait
5205 * for construction to complete. Once it's no longer pending, check to see if
5206 * it failed and either return an error or retry construction, depending on
5209 * If one doesn't exist then insert a new tcon_link struct into the tree and
5210 * try to construct a new one.
5213 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
5216 kuid_t fsuid = current_fsuid();
5217 struct tcon_link *tlink, *newtlink;
5219 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
5220 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
5222 spin_lock(&cifs_sb->tlink_tree_lock);
5223 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
5225 cifs_get_tlink(tlink);
5226 spin_unlock(&cifs_sb->tlink_tree_lock);
5228 if (tlink == NULL) {
5229 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
5230 if (newtlink == NULL)
5231 return ERR_PTR(-ENOMEM);
5232 newtlink->tl_uid = fsuid;
5233 newtlink->tl_tcon = ERR_PTR(-EACCES);
5234 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
5235 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
5236 cifs_get_tlink(newtlink);
5238 spin_lock(&cifs_sb->tlink_tree_lock);
5239 /* was one inserted after previous search? */
5240 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
5242 cifs_get_tlink(tlink);
5243 spin_unlock(&cifs_sb->tlink_tree_lock);
5245 goto wait_for_construction;
5248 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
5249 spin_unlock(&cifs_sb->tlink_tree_lock);
5251 wait_for_construction:
5252 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
5253 TASK_INTERRUPTIBLE);
5255 cifs_put_tlink(tlink);
5256 return ERR_PTR(-ERESTARTSYS);
5259 /* if it's good, return it */
5260 if (!IS_ERR(tlink->tl_tcon))
5263 /* return error if we tried this already recently */
5264 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
5265 cifs_put_tlink(tlink);
5266 return ERR_PTR(-EACCES);
5269 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
5270 goto wait_for_construction;
5273 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
5274 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
5275 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
5277 if (IS_ERR(tlink->tl_tcon)) {
5278 cifs_put_tlink(tlink);
5279 return ERR_PTR(-EACCES);
5286 * periodic workqueue job that scans tcon_tree for a superblock and closes
5290 cifs_prune_tlinks(struct work_struct *work)
5292 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
5294 struct rb_root *root = &cifs_sb->tlink_tree;
5295 struct rb_node *node;
5296 struct rb_node *tmp;
5297 struct tcon_link *tlink;
5300 * Because we drop the spinlock in the loop in order to put the tlink
5301 * it's not guarded against removal of links from the tree. The only
5302 * places that remove entries from the tree are this function and
5303 * umounts. Because this function is non-reentrant and is canceled
5304 * before umount can proceed, this is safe.
5306 spin_lock(&cifs_sb->tlink_tree_lock);
5307 node = rb_first(root);
5308 while (node != NULL) {
5310 node = rb_next(tmp);
5311 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
5313 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
5314 atomic_read(&tlink->tl_count) != 0 ||
5315 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
5318 cifs_get_tlink(tlink);
5319 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
5320 rb_erase(tmp, root);
5322 spin_unlock(&cifs_sb->tlink_tree_lock);
5323 cifs_put_tlink(tlink);
5324 spin_lock(&cifs_sb->tlink_tree_lock);
5326 spin_unlock(&cifs_sb->tlink_tree_lock);
5328 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,